From 9ce262848f90e4affaa3d86ee65e18d41d74a9ab Mon Sep 17 00:00:00 2001 From: Emux Date: Mon, 20 May 2024 12:44:18 +0300 Subject: [PATCH] Native libraries (#1126) --- .gitmodules | 3 - jni/build.gradle | 4 +- jni/jni/Android.mk | 18 +- jni/jni/Application.mk | 4 +- jni/jni/build-android32.xml | 1 + jni/jni/build.xml | 13 - jni/jni/jni-headers/classfile_constants.h | 79 +- jni/jni/jni-headers/jawt.h | 116 +- jni/jni/jni-headers/jdwpTransport.h | 119 +- jni/jni/jni-headers/jni.h | 695 +++++---- jni/jni/jni-headers/linux/jawt_md.h | 25 +- jni/jni/jni-headers/linux/jni_md.h | 44 +- jni/jni/jni-headers/mac/jni_md.h | 49 +- jni/jni/jni-headers/win32/jawt_md.h | 24 +- jni/jni/jni-headers/win32/jni_md.h | 25 +- jni/jni/libtess2 | 1 - jni/jni/libtess2/.gitignore | 28 + jni/jni/libtess2/Bin/bg.svg | 70 + jni/jni/libtess2/Bin/fg.svg | 7 + jni/jni/libtess2/Contrib/nanosvg.c | 1335 +++++++++++++++++ jni/jni/libtess2/Contrib/nanosvg.h | 66 + jni/jni/libtess2/Example/example.c | 408 +++++ jni/jni/libtess2/Include/tesselator.h | 242 +++ jni/jni/libtess2/LICENSE.txt | 25 + jni/jni/libtess2/README.md | 22 + jni/jni/libtess2/Source/bucketalloc.c | 191 +++ jni/jni/libtess2/Source/bucketalloc.h | 51 + jni/jni/libtess2/Source/dict.c | 109 ++ jni/jni/libtess2/Source/dict.h | 74 + jni/jni/libtess2/Source/geom.c | 293 ++++ jni/jni/libtess2/Source/geom.h | 78 + jni/jni/libtess2/Source/mesh.c | 917 +++++++++++ jni/jni/libtess2/Source/mesh.h | 269 ++++ jni/jni/libtess2/Source/priorityq.c | 514 +++++++ jni/jni/libtess2/Source/priorityq.h | 104 ++ jni/jni/libtess2/Source/sweep.c | 1324 ++++++++++++++++ jni/jni/libtess2/Source/sweep.h | 74 + jni/jni/libtess2/Source/tess.c | 1114 ++++++++++++++ jni/jni/libtess2/Source/tess.h | 93 ++ jni/jni/libtess2/alg_outline.md | 233 +++ jni/jni/libtess2/premake4.lua | 45 + ...essJNI.cpp => org_oscim_utils_TessJNI.cpp} | 208 +-- ...ls.TessJNI.h => org_oscim_utils_TessJNI.h} | 38 - jni/src/JniBuilder.java | 60 +- settings.gradle | 1 + 45 files changed, 8581 insertions(+), 632 deletions(-) delete mode 100644 .gitmodules delete mode 160000 jni/jni/libtess2 create mode 100644 jni/jni/libtess2/.gitignore create mode 100644 jni/jni/libtess2/Bin/bg.svg create mode 100644 jni/jni/libtess2/Bin/fg.svg create mode 100644 jni/jni/libtess2/Contrib/nanosvg.c create mode 100644 jni/jni/libtess2/Contrib/nanosvg.h create mode 100644 jni/jni/libtess2/Example/example.c create mode 100755 jni/jni/libtess2/Include/tesselator.h create mode 100644 jni/jni/libtess2/LICENSE.txt create mode 100644 jni/jni/libtess2/README.md create mode 100755 jni/jni/libtess2/Source/bucketalloc.c create mode 100755 jni/jni/libtess2/Source/bucketalloc.h create mode 100755 jni/jni/libtess2/Source/dict.c create mode 100755 jni/jni/libtess2/Source/dict.h create mode 100755 jni/jni/libtess2/Source/geom.c create mode 100755 jni/jni/libtess2/Source/geom.h create mode 100755 jni/jni/libtess2/Source/mesh.c create mode 100755 jni/jni/libtess2/Source/mesh.h create mode 100755 jni/jni/libtess2/Source/priorityq.c create mode 100755 jni/jni/libtess2/Source/priorityq.h create mode 100755 jni/jni/libtess2/Source/sweep.c create mode 100755 jni/jni/libtess2/Source/sweep.h create mode 100755 jni/jni/libtess2/Source/tess.c create mode 100755 jni/jni/libtess2/Source/tess.h create mode 100644 jni/jni/libtess2/alg_outline.md create mode 100644 jni/jni/libtess2/premake4.lua rename jni/jni/{org.oscim.utils.TessJNI.cpp => org_oscim_utils_TessJNI.cpp} (52%) rename jni/jni/{org.oscim.utils.TessJNI.h => org_oscim_utils_TessJNI.h} (68%) diff --git a/.gitmodules b/.gitmodules deleted file mode 100644 index 8756c045b..000000000 --- a/.gitmodules +++ /dev/null @@ -1,3 +0,0 @@ -[submodule "libtess2"] - path = jni/jni/libtess2 - url = https://github.com/memononen/libtess2.git diff --git a/jni/build.gradle b/jni/build.gradle index 676d4cb89..8737954ec 100644 --- a/jni/build.gradle +++ b/jni/build.gradle @@ -1,7 +1,7 @@ -apply plugin: 'java' +apply plugin: 'application' dependencies { - implementation "com.badlogicgames.gdx:gdx-jnigen:$gdxVersion" + implementation 'com.badlogicgames.gdx:gdx-jnigen:2.5.1' } sourceSets { diff --git a/jni/jni/Android.mk b/jni/jni/Android.mk index 32d51c05a..f472b302d 100644 --- a/jni/jni/Android.mk +++ b/jni/jni/Android.mk @@ -4,19 +4,19 @@ include $(CLEAR_VARS) LOCAL_MODULE := vtm-jni LOCAL_C_INCLUDES := . libtess2/Include -LOCAL_CFLAGS := $(LOCAL_C_INCLUDES:%=-I%) -O2 -Wall -D__ANDROID__ -Wall -std=c99 -O2 -ffast-math -DNDEBUG -LOCAL_CPPFLAGS := $(LOCAL_C_INCLUDES:%=-I%) -O2 -Wall -D__ANDROID__ -Wall -std=c99 -O2 -ffast-math -DNDEBUG +LOCAL_CFLAGS := $(LOCAL_C_INCLUDES:%=-I%) -O2 -Wall -D__ANDROID__ -Wall -O2 -ffast-math -DNDEBUG +LOCAL_CPPFLAGS := $(LOCAL_C_INCLUDES:%=-I%) -O2 -Wall -D__ANDROID__ -Wall -O2 -ffast-math -DNDEBUG LOCAL_LDLIBS := -lm -llog LOCAL_ARM_MODE := arm -LOCAL_SRC_FILES := org.oscim.utils.TessJNI.cpp\ - libtess2/Source/sweep.c\ - libtess2/Source/priorityq.c\ - libtess2/Source/bucketalloc.c\ - libtess2/Source/geom.c\ +LOCAL_SRC_FILES := libtess2/Source/dict.c\ libtess2/Source/tess.c\ - libtess2/Source/dict.c\ + libtess2/Source/geom.c\ + libtess2/Source/bucketalloc.c\ libtess2/Source/mesh.c\ - gl/utils.c + libtess2/Source/sweep.c\ + libtess2/Source/priorityq.c\ + gl/utils.c\ + org_oscim_utils_TessJNI.cpp include $(BUILD_SHARED_LIBRARY) diff --git a/jni/jni/Application.mk b/jni/jni/Application.mk index c3421418d..b448d58b3 100644 --- a/jni/jni/Application.mk +++ b/jni/jni/Application.mk @@ -1,2 +1,2 @@ -APP_ABI := armeabi armeabi-v7a x86 -APP_PLATFORM := android-8 \ No newline at end of file +APP_ABI := all +APP_PLATFORM := android-9 diff --git a/jni/jni/build-android32.xml b/jni/jni/build-android32.xml index f216d27bb..2edeb7adf 100644 --- a/jni/jni/build-android32.xml +++ b/jni/jni/build-android32.xml @@ -29,5 +29,6 @@ + diff --git a/jni/jni/build.xml b/jni/jni/build.xml index bda2da00b..2f4c57c45 100644 --- a/jni/jni/build.xml +++ b/jni/jni/build.xml @@ -1,29 +1,16 @@ - - - - - - - - - - - - - diff --git a/jni/jni/jni-headers/classfile_constants.h b/jni/jni/jni-headers/classfile_constants.h index 30e839ee9..68628b102 100644 --- a/jni/jni/jni-headers/classfile_constants.h +++ b/jni/jni/jni-headers/classfile_constants.h @@ -1,9 +1,26 @@ /* - * %W% %E% - * - * Copyright (c) 2006, Oracle and/or its affiliates. All rights reserved. - * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. - * + * Copyright (c) 2004, 2017, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. */ #ifndef CLASSFILE_CONSTANTS_H @@ -13,6 +30,10 @@ extern "C" { #endif +/* Classfile version number for this information */ +#define JVM_CLASSFILE_MAJOR_VERSION 55 +#define JVM_CLASSFILE_MINOR_VERSION 0 + /* Flags */ enum { @@ -33,9 +54,29 @@ enum { JVM_ACC_STRICT = 0x0800, JVM_ACC_SYNTHETIC = 0x1000, JVM_ACC_ANNOTATION = 0x2000, - JVM_ACC_ENUM = 0x4000 + JVM_ACC_ENUM = 0x4000, + JVM_ACC_MODULE = 0x8000 }; +#define JVM_ACC_PUBLIC_BIT 0 +#define JVM_ACC_PRIVATE_BIT 1 +#define JVM_ACC_PROTECTED_BIT 2 +#define JVM_ACC_STATIC_BIT 3 +#define JVM_ACC_FINAL_BIT 4 +#define JVM_ACC_SYNCHRONIZED_BIT 5 +#define JVM_ACC_SUPER_BIT 5 +#define JVM_ACC_VOLATILE_BIT 6 +#define JVM_ACC_BRIDGE_BIT 6 +#define JVM_ACC_TRANSIENT_BIT 7 +#define JVM_ACC_VARARGS_BIT 7 +#define JVM_ACC_NATIVE_BIT 8 +#define JVM_ACC_INTERFACE_BIT 9 +#define JVM_ACC_ABSTRACT_BIT 10 +#define JVM_ACC_STRICT_BIT 11 +#define JVM_ACC_SYNTHETIC_BIT 12 +#define JVM_ACC_ANNOTATION_BIT 13 +#define JVM_ACC_ENUM_BIT 14 + /* Used in newarray instruction. */ enum { @@ -56,14 +97,32 @@ enum { JVM_CONSTANT_Unicode = 2, /* unused */ JVM_CONSTANT_Integer = 3, JVM_CONSTANT_Float = 4, - JVM_CONSTANT_Long = 5, + JVM_CONSTANT_Long = 5, JVM_CONSTANT_Double = 6, JVM_CONSTANT_Class = 7, JVM_CONSTANT_String = 8, JVM_CONSTANT_Fieldref = 9, JVM_CONSTANT_Methodref = 10, JVM_CONSTANT_InterfaceMethodref = 11, - JVM_CONSTANT_NameAndType = 12 + JVM_CONSTANT_NameAndType = 12, + JVM_CONSTANT_MethodHandle = 15, // JSR 292 + JVM_CONSTANT_MethodType = 16, // JSR 292 + JVM_CONSTANT_Dynamic = 17, + JVM_CONSTANT_InvokeDynamic = 18, + JVM_CONSTANT_ExternalMax = 18 +}; + +/* JVM_CONSTANT_MethodHandle subtypes */ +enum { + JVM_REF_getField = 1, + JVM_REF_getStatic = 2, + JVM_REF_putField = 3, + JVM_REF_putStatic = 4, + JVM_REF_invokeVirtual = 5, + JVM_REF_invokeStatic = 6, + JVM_REF_invokeSpecial = 7, + JVM_REF_newInvokeSpecial = 8, + JVM_REF_invokeInterface = 9 }; /* StackMapTable type item numbers */ @@ -289,7 +348,7 @@ enum { JVM_OPC_invokespecial = 183, JVM_OPC_invokestatic = 184, JVM_OPC_invokeinterface = 185, - JVM_OPC_xxxunusedxxx = 186, + JVM_OPC_invokedynamic = 186, JVM_OPC_new = 187, JVM_OPC_newarray = 188, JVM_OPC_anewarray = 189, @@ -498,7 +557,7 @@ enum { 3, /* invokespecial */ \ 3, /* invokestatic */ \ 5, /* invokeinterface */ \ - 0, /* xxxunusedxxx */ \ + 5, /* invokedynamic */ \ 3, /* new */ \ 2, /* newarray */ \ 3, /* anewarray */ \ diff --git a/jni/jni/jni-headers/jawt.h b/jni/jni/jni-headers/jawt.h index 87e0b182e..2079b0bc1 100644 --- a/jni/jni/jni-headers/jawt.h +++ b/jni/jni/jni-headers/jawt.h @@ -1,8 +1,26 @@ /* - * %W% %E% + * Copyright (c) 1999, 2017, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * - * Copyright (c) 2006, Oracle and/or its affiliates. All rights reserved. - * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. */ #ifndef _JAVASOFT_JAWT_H_ @@ -15,23 +33,27 @@ extern "C" { #endif /* - * AWT native interface (new in JDK 1.3) + * AWT native interface. * * The AWT native interface allows a native C or C++ application a means * by which to access native structures in AWT. This is to facilitate moving * legacy C and C++ applications to Java and to target the needs of the - * community who, at present, wish to do their own native rendering to canvases - * for performance reasons. Standard extensions such as Java3D also require a - * means to access the underlying native data structures of AWT. + * developers who need to do their own native rendering to canvases + * for performance or other reasons. + * + * Conversely it also provides mechanisms for an application which already + * has a native window to provide that to AWT for AWT rendering. * - * There may be future extensions to this API depending on demand. + * Since every platform may be different in its native data structures + * and APIs for windowing systems the application must necessarily + * provided per-platform source and compile and deliver per-platform + * native code to use this API. * - * A VM does not have to implement this API in order to pass the JCK. - * It is recommended, however, that this API is implemented on VMs that support - * standard extensions, such as Java3D. + * These interfaces are not part of the Java SE specification and + * a VM is not required to implement this API. However it is strongly + * recommended that all implementations which support headful AWT + * also support these interfaces. * - * Since this is a native API, any program which uses it cannot be considered - * 100% pure java. */ /* @@ -40,7 +62,7 @@ extern "C" { * For each platform, there is a native drawing surface structure. This * platform-specific structure can be found in jawt_md.h. It is recommended * that additional platforms follow the same model. It is also recommended - * that VMs on Win32 and Solaris support the existing structures in jawt_md.h. + * that VMs on all platforms support the existing structures in jawt_md.h. * ******************* * EXAMPLE OF USAGE: @@ -80,8 +102,8 @@ extern "C" { * jboolean result; * jint lock; * - * // Get the AWT - * awt.version = JAWT_VERSION_1_3; + * // Get the AWT. Request version 9 to access features in that release. + * awt.version = JAWT_VERSION_9; * result = JAWT_GetAWT(env, &awt); * assert(result != JNI_FALSE); * @@ -136,7 +158,9 @@ typedef struct jawt_DrawingSurfaceInfo { /* * Pointer to the platform-specific information. This can be safely * cast to a JAWT_Win32DrawingSurfaceInfo on Windows or a - * JAWT_X11DrawingSurfaceInfo on Solaris. See jawt_md.h for details. + * JAWT_X11DrawingSurfaceInfo on Linux and Solaris. On Mac OS X this is a + * pointer to a NSObject that conforms to the JAWT_SurfaceLayers + * protocol. See jawt_md.h for details. */ void* platformInfo; /* Cached pointer to the underlying drawing surface */ @@ -203,7 +227,7 @@ typedef struct jawt_DrawingSurface { */ void (JNICALL *FreeDrawingSurfaceInfo) (JAWT_DrawingSurfaceInfo* dsi); - /* + /* * Unlock the drawing surface of the target component for native rendering. */ void (JNICALL *Unlock) @@ -217,7 +241,8 @@ typedef struct jawt_DrawingSurface { typedef struct jawt { /* * Version of this structure. This must always be set before - * calling JAWT_GetAWT() + * calling JAWT_GetAWT(). It affects the functions returned. + * Must be one of the known pre-defined versions. */ jint version; /* @@ -259,6 +284,50 @@ typedef struct jawt { */ jobject (JNICALL *GetComponent)(JNIEnv* env, void* platformInfo); + /** + * Since 9 + * Creates a java.awt.Frame placed in a native container. Container is + * referenced by the native platform handle. For example on Windows this + * corresponds to an HWND. For other platforms, see the appropriate + * machine-dependent header file for a description. The reference returned + * by this function is a local reference that is only valid in this + * environment. This function returns a NULL reference if no frame could be + * created with matching platform information. + */ + jobject (JNICALL *CreateEmbeddedFrame) (JNIEnv *env, void* platformInfo); + + /** + * Since 9 + * Moves and resizes the embedded frame. The new location of the top-left + * corner is specified by x and y parameters relative to the native parent + * component. The new size is specified by width and height. + * + * The embedded frame should be created by CreateEmbeddedFrame() method, or + * this function will not have any effect. + * + * java.awt.Component.setLocation() and java.awt.Component.setBounds() for + * EmbeddedFrame really don't move it within the native parent. These + * methods always locate the embedded frame at (0, 0) for backward + * compatibility. To allow moving embedded frames this method was + * introduced, and it works just the same way as setLocation() and + * setBounds() for usual, non-embedded components. + * + * Using usual get/setLocation() and get/setBounds() together with this new + * method is not recommended. + */ + void (JNICALL *SetBounds) (JNIEnv *env, jobject embeddedFrame, + jint x, jint y, jint w, jint h); + /** + * Since 9 + * Synthesize a native message to activate or deactivate an EmbeddedFrame + * window depending on the value of parameter doActivate, if "true" + * activates the window; otherwise, deactivates the window. + * + * The embedded frame should be created by CreateEmbeddedFrame() method, or + * this function will not have any effect. + */ + void (JNICALL *SynthesizeWindowActivation) (JNIEnv *env, + jobject embeddedFrame, jboolean doActivate); } JAWT; /* @@ -268,8 +337,17 @@ typedef struct jawt { _JNI_IMPORT_OR_EXPORT_ jboolean JNICALL JAWT_GetAWT(JNIEnv* env, JAWT* awt); +/* + * Specify one of these constants as the JAWT.version + * Specifying an earlier version will limit the available functions to + * those provided in that earlier version of JAWT. + * See the "Since" note on each API. Methods with no "Since" + * may be presumed to be present in JAWT_VERSION_1_3. + */ #define JAWT_VERSION_1_3 0x00010003 #define JAWT_VERSION_1_4 0x00010004 +#define JAWT_VERSION_1_7 0x00010007 +#define JAWT_VERSION_9 0x00090000 #ifdef __cplusplus } /* extern "C" */ diff --git a/jni/jni/jni-headers/jdwpTransport.h b/jni/jni/jni-headers/jdwpTransport.h index eae435aa2..5b4a70723 100644 --- a/jni/jni/jni-headers/jdwpTransport.h +++ b/jni/jni/jni-headers/jdwpTransport.h @@ -1,8 +1,26 @@ /* - * %W% %E% + * Copyright (c) 2003, 2017, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * - * Copyright (c) 2006, Oracle and/or its affiliates. All rights reserved. - * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. */ /* @@ -15,7 +33,8 @@ #include "jni.h" enum { - JDWPTRANSPORT_VERSION_1_0 = 0x00010000 + JDWPTRANSPORT_VERSION_1_0 = 0x00010000, + JDWPTRANSPORT_VERSION_1_1 = 0x00010001 }; #ifdef __cplusplus @@ -46,7 +65,7 @@ typedef enum { JDWPTRANSPORT_ERROR_TIMEOUT = 203, JDWPTRANSPORT_ERROR_MSG_NOT_AVAILABLE = 204 } jdwpTransportError; - + /* * Structure to define capabilities @@ -66,24 +85,31 @@ typedef struct { unsigned int reserved11 :1; unsigned int reserved12 :1; unsigned int reserved13 :1; - unsigned int reserved14 :1; - unsigned int reserved15 :1; + unsigned int reserved14 :1; + unsigned int reserved15 :1; } JDWPTransportCapabilities; /* * Structures to define packet layout. - * + * * See: http://java.sun.com/j2se/1.5/docs/guide/jpda/jdwp-spec.html */ +#define JDWP_HEADER_SIZE 11 + enum { - JDWPTRANSPORT_FLAGS_NONE = 0x0, - JDWPTRANSPORT_FLAGS_REPLY = 0x80 + /* + * If additional flags are added that apply to jdwpCmdPacket, + * then debugLoop.c: reader() will need to be updated to + * accept more than JDWPTRANSPORT_FLAGS_NONE. + */ + JDWPTRANSPORT_FLAGS_NONE = 0x0, + JDWPTRANSPORT_FLAGS_REPLY = 0x80 }; typedef struct { - jint len; + jint len; jint id; jbyte flags; jbyte cmdSet; @@ -114,11 +140,18 @@ typedef struct jdwpTransportCallback { void (*free)(void *buffer); /* Call this for all deallocations */ } jdwpTransportCallback; -typedef jint (JNICALL *jdwpTransport_OnLoad_t)(JavaVM *jvm, - jdwpTransportCallback *callback, - jint version, - jdwpTransportEnv** env); +typedef jint (*jdwpTransport_OnLoad_t)(JavaVM *jvm, + jdwpTransportCallback *callback, + jint version, + jdwpTransportEnv** env); +/* + * JDWP transport configuration from the agent. + */ +typedef struct jdwpTransportConfiguration { + /* Field added in JDWPTRANSPORT_VERSION_1_1: */ + const char* allowed_peers; /* Peers allowed for connection */ +} jdwpTransportConfiguration; /* Function Interface */ @@ -127,28 +160,28 @@ struct jdwpTransportNativeInterface_ { /* 1 : RESERVED */ void *reserved1; - /* 2 : Get Capabilities */ + /* 2 : Get Capabilities */ jdwpTransportError (JNICALL *GetCapabilities)(jdwpTransportEnv* env, - JDWPTransportCapabilities *capabilities_ptr); + JDWPTransportCapabilities *capabilities_ptr); /* 3 : Attach */ jdwpTransportError (JNICALL *Attach)(jdwpTransportEnv* env, - const char* address, - jlong attach_timeout, - jlong handshake_timeout); + const char* address, + jlong attach_timeout, + jlong handshake_timeout); /* 4: StartListening */ jdwpTransportError (JNICALL *StartListening)(jdwpTransportEnv* env, - const char* address, - char** actual_address); + const char* address, + char** actual_address); /* 5: StopListening */ jdwpTransportError (JNICALL *StopListening)(jdwpTransportEnv* env); /* 6: Accept */ jdwpTransportError (JNICALL *Accept)(jdwpTransportEnv* env, - jlong accept_timeout, - jlong handshake_timeout); + jlong accept_timeout, + jlong handshake_timeout); /* 7: IsOpen */ jboolean (JNICALL *IsOpen)(jdwpTransportEnv* env); @@ -158,51 +191,54 @@ struct jdwpTransportNativeInterface_ { /* 9: ReadPacket */ jdwpTransportError (JNICALL *ReadPacket)(jdwpTransportEnv* env, - jdwpPacket *pkt); + jdwpPacket *pkt); /* 10: Write Packet */ jdwpTransportError (JNICALL *WritePacket)(jdwpTransportEnv* env, - const jdwpPacket* pkt); + const jdwpPacket* pkt); /* 11: GetLastError */ jdwpTransportError (JNICALL *GetLastError)(jdwpTransportEnv* env, - char** error); + char** error); + /* 12: SetTransportConfiguration added in JDWPTRANSPORT_VERSION_1_1 */ + jdwpTransportError (JNICALL *SetTransportConfiguration)(jdwpTransportEnv* env, + jdwpTransportConfiguration *config); }; /* * Use inlined functions so that C++ code can use syntax such as - * env->Attach("mymachine:5000", 10*1000, 0); + * env->Attach("mymachine:5000", 10*1000, 0); * * rather than using C's :- * - * (*env)->Attach(env, "mymachine:5000", 10*1000, 0); + * (*env)->Attach(env, "mymachine:5000", 10*1000, 0); */ struct _jdwpTransportEnv { const struct jdwpTransportNativeInterface_ *functions; #ifdef __cplusplus jdwpTransportError GetCapabilities(JDWPTransportCapabilities *capabilities_ptr) { - return functions->GetCapabilities(this, capabilities_ptr); + return functions->GetCapabilities(this, capabilities_ptr); } jdwpTransportError Attach(const char* address, jlong attach_timeout, - jlong handshake_timeout) { - return functions->Attach(this, address, attach_timeout, handshake_timeout); + jlong handshake_timeout) { + return functions->Attach(this, address, attach_timeout, handshake_timeout); } jdwpTransportError StartListening(const char* address, - char** actual_address) { - return functions->StartListening(this, address, actual_address); + char** actual_address) { + return functions->StartListening(this, address, actual_address); } jdwpTransportError StopListening(void) { - return functions->StopListening(this); + return functions->StopListening(this); } jdwpTransportError Accept(jlong accept_timeout, jlong handshake_timeout) { - return functions->Accept(this, accept_timeout, handshake_timeout); + return functions->Accept(this, accept_timeout, handshake_timeout); } jboolean IsOpen(void) { @@ -214,17 +250,21 @@ struct _jdwpTransportEnv { } jdwpTransportError ReadPacket(jdwpPacket *pkt) { - return functions->ReadPacket(this, pkt); + return functions->ReadPacket(this, pkt); } jdwpTransportError WritePacket(const jdwpPacket* pkt) { - return functions->WritePacket(this, pkt); + return functions->WritePacket(this, pkt); } jdwpTransportError GetLastError(char** error) { - return functions->GetLastError(this, error); + return functions->GetLastError(this, error); } + /* SetTransportConfiguration added in JDWPTRANSPORT_VERSION_1_1 */ + jdwpTransportError SetTransportConfiguration(jdwpTransportEnv* env, + return functions->SetTransportConfiguration(this, config); + } #endif /* __cplusplus */ }; @@ -234,4 +274,3 @@ struct _jdwpTransportEnv { #endif /* __cplusplus */ #endif /* JDWPTRANSPORT_H */ - diff --git a/jni/jni/jni-headers/jni.h b/jni/jni/jni-headers/jni.h index 8160a9eb6..e15503f4d 100644 --- a/jni/jni/jni-headers/jni.h +++ b/jni/jni/jni-headers/jni.h @@ -1,8 +1,26 @@ /* - * @(#)jni.h 1.63 10/03/23 + * Copyright (c) 1996, 2016, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * - * Copyright (c) 2006, Oracle and/or its affiliates. All rights reserved. - * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. */ /* @@ -36,11 +54,11 @@ extern "C" { #ifndef JNI_TYPES_ALREADY_DEFINED_IN_JNI_MD_H -typedef unsigned char jboolean; -typedef unsigned short jchar; -typedef short jshort; -typedef float jfloat; -typedef double jdouble; +typedef unsigned char jboolean; +typedef unsigned short jchar; +typedef short jshort; +typedef float jfloat; +typedef double jdouble; typedef jint jsize; @@ -122,7 +140,7 @@ typedef enum _jobjectType { JNIInvalidRefType = 0, JNILocalRefType = 1, JNIGlobalRefType = 2, - JNIWeakGlobalRefType = 3 + JNIWeakGlobalRefType = 3 } jobjectRefType; @@ -747,6 +765,11 @@ struct JNINativeInterface_ { jobjectRefType (JNICALL *GetObjectRefType) (JNIEnv* env, jobject obj); + + /* Module Features */ + + jobject (JNICALL *GetModule) + (JNIEnv* env, jclass clazz); }; /* @@ -769,7 +792,7 @@ struct JNIEnv_ { return functions->GetVersion(this); } jclass DefineClass(const char *name, jobject loader, const jbyte *buf, - jsize len) { + jsize len) { return functions->DefineClass(this, name, loader, buf, len); } jclass FindClass(const char *name) { @@ -849,18 +872,18 @@ struct JNIEnv_ { } jobject NewObject(jclass clazz, jmethodID methodID, ...) { va_list args; - jobject result; - va_start(args, methodID); + jobject result; + va_start(args, methodID); result = functions->NewObjectV(this,clazz,methodID,args); - va_end(args); - return result; + va_end(args); + return result; } jobject NewObjectV(jclass clazz, jmethodID methodID, - va_list args) { + va_list args) { return functions->NewObjectV(this,clazz,methodID,args); } jobject NewObjectA(jclass clazz, jmethodID methodID, - const jvalue *args) { + const jvalue *args) { return functions->NewObjectA(this,clazz,methodID,args); } @@ -872,392 +895,392 @@ struct JNIEnv_ { } jmethodID GetMethodID(jclass clazz, const char *name, - const char *sig) { + const char *sig) { return functions->GetMethodID(this,clazz,name,sig); } jobject CallObjectMethod(jobject obj, jmethodID methodID, ...) { va_list args; - jobject result; - va_start(args,methodID); - result = functions->CallObjectMethodV(this,obj,methodID,args); - va_end(args); - return result; + jobject result; + va_start(args,methodID); + result = functions->CallObjectMethodV(this,obj,methodID,args); + va_end(args); + return result; } jobject CallObjectMethodV(jobject obj, jmethodID methodID, - va_list args) { + va_list args) { return functions->CallObjectMethodV(this,obj,methodID,args); } jobject CallObjectMethodA(jobject obj, jmethodID methodID, - const jvalue * args) { + const jvalue * args) { return functions->CallObjectMethodA(this,obj,methodID,args); } jboolean CallBooleanMethod(jobject obj, - jmethodID methodID, ...) { + jmethodID methodID, ...) { va_list args; - jboolean result; - va_start(args,methodID); - result = functions->CallBooleanMethodV(this,obj,methodID,args); - va_end(args); - return result; + jboolean result; + va_start(args,methodID); + result = functions->CallBooleanMethodV(this,obj,methodID,args); + va_end(args); + return result; } jboolean CallBooleanMethodV(jobject obj, jmethodID methodID, - va_list args) { + va_list args) { return functions->CallBooleanMethodV(this,obj,methodID,args); } jboolean CallBooleanMethodA(jobject obj, jmethodID methodID, - const jvalue * args) { + const jvalue * args) { return functions->CallBooleanMethodA(this,obj,methodID, args); } jbyte CallByteMethod(jobject obj, jmethodID methodID, ...) { va_list args; - jbyte result; - va_start(args,methodID); - result = functions->CallByteMethodV(this,obj,methodID,args); - va_end(args); - return result; + jbyte result; + va_start(args,methodID); + result = functions->CallByteMethodV(this,obj,methodID,args); + va_end(args); + return result; } jbyte CallByteMethodV(jobject obj, jmethodID methodID, - va_list args) { + va_list args) { return functions->CallByteMethodV(this,obj,methodID,args); } jbyte CallByteMethodA(jobject obj, jmethodID methodID, - const jvalue * args) { + const jvalue * args) { return functions->CallByteMethodA(this,obj,methodID,args); } jchar CallCharMethod(jobject obj, jmethodID methodID, ...) { va_list args; - jchar result; - va_start(args,methodID); - result = functions->CallCharMethodV(this,obj,methodID,args); - va_end(args); - return result; + jchar result; + va_start(args,methodID); + result = functions->CallCharMethodV(this,obj,methodID,args); + va_end(args); + return result; } jchar CallCharMethodV(jobject obj, jmethodID methodID, - va_list args) { + va_list args) { return functions->CallCharMethodV(this,obj,methodID,args); } jchar CallCharMethodA(jobject obj, jmethodID methodID, - const jvalue * args) { + const jvalue * args) { return functions->CallCharMethodA(this,obj,methodID,args); } jshort CallShortMethod(jobject obj, jmethodID methodID, ...) { va_list args; - jshort result; - va_start(args,methodID); - result = functions->CallShortMethodV(this,obj,methodID,args); - va_end(args); - return result; + jshort result; + va_start(args,methodID); + result = functions->CallShortMethodV(this,obj,methodID,args); + va_end(args); + return result; } jshort CallShortMethodV(jobject obj, jmethodID methodID, - va_list args) { + va_list args) { return functions->CallShortMethodV(this,obj,methodID,args); } jshort CallShortMethodA(jobject obj, jmethodID methodID, - const jvalue * args) { + const jvalue * args) { return functions->CallShortMethodA(this,obj,methodID,args); } jint CallIntMethod(jobject obj, jmethodID methodID, ...) { va_list args; - jint result; - va_start(args,methodID); - result = functions->CallIntMethodV(this,obj,methodID,args); - va_end(args); - return result; + jint result; + va_start(args,methodID); + result = functions->CallIntMethodV(this,obj,methodID,args); + va_end(args); + return result; } jint CallIntMethodV(jobject obj, jmethodID methodID, - va_list args) { + va_list args) { return functions->CallIntMethodV(this,obj,methodID,args); } jint CallIntMethodA(jobject obj, jmethodID methodID, - const jvalue * args) { + const jvalue * args) { return functions->CallIntMethodA(this,obj,methodID,args); } jlong CallLongMethod(jobject obj, jmethodID methodID, ...) { va_list args; - jlong result; - va_start(args,methodID); - result = functions->CallLongMethodV(this,obj,methodID,args); - va_end(args); - return result; + jlong result; + va_start(args,methodID); + result = functions->CallLongMethodV(this,obj,methodID,args); + va_end(args); + return result; } jlong CallLongMethodV(jobject obj, jmethodID methodID, - va_list args) { + va_list args) { return functions->CallLongMethodV(this,obj,methodID,args); } jlong CallLongMethodA(jobject obj, jmethodID methodID, - const jvalue * args) { + const jvalue * args) { return functions->CallLongMethodA(this,obj,methodID,args); } jfloat CallFloatMethod(jobject obj, jmethodID methodID, ...) { va_list args; - jfloat result; - va_start(args,methodID); - result = functions->CallFloatMethodV(this,obj,methodID,args); - va_end(args); - return result; + jfloat result; + va_start(args,methodID); + result = functions->CallFloatMethodV(this,obj,methodID,args); + va_end(args); + return result; } jfloat CallFloatMethodV(jobject obj, jmethodID methodID, - va_list args) { + va_list args) { return functions->CallFloatMethodV(this,obj,methodID,args); } jfloat CallFloatMethodA(jobject obj, jmethodID methodID, - const jvalue * args) { + const jvalue * args) { return functions->CallFloatMethodA(this,obj,methodID,args); } jdouble CallDoubleMethod(jobject obj, jmethodID methodID, ...) { va_list args; - jdouble result; - va_start(args,methodID); - result = functions->CallDoubleMethodV(this,obj,methodID,args); - va_end(args); - return result; + jdouble result; + va_start(args,methodID); + result = functions->CallDoubleMethodV(this,obj,methodID,args); + va_end(args); + return result; } jdouble CallDoubleMethodV(jobject obj, jmethodID methodID, - va_list args) { + va_list args) { return functions->CallDoubleMethodV(this,obj,methodID,args); } jdouble CallDoubleMethodA(jobject obj, jmethodID methodID, - const jvalue * args) { + const jvalue * args) { return functions->CallDoubleMethodA(this,obj,methodID,args); } void CallVoidMethod(jobject obj, jmethodID methodID, ...) { va_list args; - va_start(args,methodID); - functions->CallVoidMethodV(this,obj,methodID,args); - va_end(args); + va_start(args,methodID); + functions->CallVoidMethodV(this,obj,methodID,args); + va_end(args); } void CallVoidMethodV(jobject obj, jmethodID methodID, - va_list args) { + va_list args) { functions->CallVoidMethodV(this,obj,methodID,args); } void CallVoidMethodA(jobject obj, jmethodID methodID, - const jvalue * args) { + const jvalue * args) { functions->CallVoidMethodA(this,obj,methodID,args); } jobject CallNonvirtualObjectMethod(jobject obj, jclass clazz, - jmethodID methodID, ...) { + jmethodID methodID, ...) { va_list args; - jobject result; - va_start(args,methodID); - result = functions->CallNonvirtualObjectMethodV(this,obj,clazz, - methodID,args); - va_end(args); - return result; + jobject result; + va_start(args,methodID); + result = functions->CallNonvirtualObjectMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; } jobject CallNonvirtualObjectMethodV(jobject obj, jclass clazz, - jmethodID methodID, va_list args) { + jmethodID methodID, va_list args) { return functions->CallNonvirtualObjectMethodV(this,obj,clazz, - methodID,args); + methodID,args); } jobject CallNonvirtualObjectMethodA(jobject obj, jclass clazz, - jmethodID methodID, const jvalue * args) { + jmethodID methodID, const jvalue * args) { return functions->CallNonvirtualObjectMethodA(this,obj,clazz, - methodID,args); + methodID,args); } jboolean CallNonvirtualBooleanMethod(jobject obj, jclass clazz, - jmethodID methodID, ...) { + jmethodID methodID, ...) { va_list args; - jboolean result; - va_start(args,methodID); - result = functions->CallNonvirtualBooleanMethodV(this,obj,clazz, - methodID,args); - va_end(args); - return result; + jboolean result; + va_start(args,methodID); + result = functions->CallNonvirtualBooleanMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; } jboolean CallNonvirtualBooleanMethodV(jobject obj, jclass clazz, - jmethodID methodID, va_list args) { + jmethodID methodID, va_list args) { return functions->CallNonvirtualBooleanMethodV(this,obj,clazz, - methodID,args); + methodID,args); } jboolean CallNonvirtualBooleanMethodA(jobject obj, jclass clazz, - jmethodID methodID, const jvalue * args) { + jmethodID methodID, const jvalue * args) { return functions->CallNonvirtualBooleanMethodA(this,obj,clazz, - methodID, args); + methodID, args); } jbyte CallNonvirtualByteMethod(jobject obj, jclass clazz, - jmethodID methodID, ...) { + jmethodID methodID, ...) { va_list args; - jbyte result; - va_start(args,methodID); - result = functions->CallNonvirtualByteMethodV(this,obj,clazz, - methodID,args); - va_end(args); - return result; + jbyte result; + va_start(args,methodID); + result = functions->CallNonvirtualByteMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; } jbyte CallNonvirtualByteMethodV(jobject obj, jclass clazz, - jmethodID methodID, va_list args) { + jmethodID methodID, va_list args) { return functions->CallNonvirtualByteMethodV(this,obj,clazz, - methodID,args); + methodID,args); } jbyte CallNonvirtualByteMethodA(jobject obj, jclass clazz, - jmethodID methodID, const jvalue * args) { + jmethodID methodID, const jvalue * args) { return functions->CallNonvirtualByteMethodA(this,obj,clazz, - methodID,args); + methodID,args); } jchar CallNonvirtualCharMethod(jobject obj, jclass clazz, - jmethodID methodID, ...) { + jmethodID methodID, ...) { va_list args; - jchar result; - va_start(args,methodID); - result = functions->CallNonvirtualCharMethodV(this,obj,clazz, - methodID,args); - va_end(args); - return result; + jchar result; + va_start(args,methodID); + result = functions->CallNonvirtualCharMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; } jchar CallNonvirtualCharMethodV(jobject obj, jclass clazz, - jmethodID methodID, va_list args) { + jmethodID methodID, va_list args) { return functions->CallNonvirtualCharMethodV(this,obj,clazz, - methodID,args); + methodID,args); } jchar CallNonvirtualCharMethodA(jobject obj, jclass clazz, - jmethodID methodID, const jvalue * args) { + jmethodID methodID, const jvalue * args) { return functions->CallNonvirtualCharMethodA(this,obj,clazz, - methodID,args); + methodID,args); } jshort CallNonvirtualShortMethod(jobject obj, jclass clazz, - jmethodID methodID, ...) { + jmethodID methodID, ...) { va_list args; - jshort result; - va_start(args,methodID); - result = functions->CallNonvirtualShortMethodV(this,obj,clazz, - methodID,args); - va_end(args); - return result; + jshort result; + va_start(args,methodID); + result = functions->CallNonvirtualShortMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; } jshort CallNonvirtualShortMethodV(jobject obj, jclass clazz, - jmethodID methodID, va_list args) { + jmethodID methodID, va_list args) { return functions->CallNonvirtualShortMethodV(this,obj,clazz, - methodID,args); + methodID,args); } jshort CallNonvirtualShortMethodA(jobject obj, jclass clazz, - jmethodID methodID, const jvalue * args) { + jmethodID methodID, const jvalue * args) { return functions->CallNonvirtualShortMethodA(this,obj,clazz, - methodID,args); + methodID,args); } jint CallNonvirtualIntMethod(jobject obj, jclass clazz, - jmethodID methodID, ...) { + jmethodID methodID, ...) { va_list args; - jint result; - va_start(args,methodID); - result = functions->CallNonvirtualIntMethodV(this,obj,clazz, - methodID,args); - va_end(args); - return result; + jint result; + va_start(args,methodID); + result = functions->CallNonvirtualIntMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; } jint CallNonvirtualIntMethodV(jobject obj, jclass clazz, - jmethodID methodID, va_list args) { + jmethodID methodID, va_list args) { return functions->CallNonvirtualIntMethodV(this,obj,clazz, - methodID,args); + methodID,args); } jint CallNonvirtualIntMethodA(jobject obj, jclass clazz, - jmethodID methodID, const jvalue * args) { + jmethodID methodID, const jvalue * args) { return functions->CallNonvirtualIntMethodA(this,obj,clazz, - methodID,args); + methodID,args); } jlong CallNonvirtualLongMethod(jobject obj, jclass clazz, - jmethodID methodID, ...) { + jmethodID methodID, ...) { va_list args; - jlong result; - va_start(args,methodID); - result = functions->CallNonvirtualLongMethodV(this,obj,clazz, - methodID,args); - va_end(args); - return result; + jlong result; + va_start(args,methodID); + result = functions->CallNonvirtualLongMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; } jlong CallNonvirtualLongMethodV(jobject obj, jclass clazz, - jmethodID methodID, va_list args) { + jmethodID methodID, va_list args) { return functions->CallNonvirtualLongMethodV(this,obj,clazz, - methodID,args); + methodID,args); } jlong CallNonvirtualLongMethodA(jobject obj, jclass clazz, - jmethodID methodID, const jvalue * args) { + jmethodID methodID, const jvalue * args) { return functions->CallNonvirtualLongMethodA(this,obj,clazz, - methodID,args); + methodID,args); } jfloat CallNonvirtualFloatMethod(jobject obj, jclass clazz, - jmethodID methodID, ...) { + jmethodID methodID, ...) { va_list args; - jfloat result; - va_start(args,methodID); - result = functions->CallNonvirtualFloatMethodV(this,obj,clazz, - methodID,args); - va_end(args); - return result; + jfloat result; + va_start(args,methodID); + result = functions->CallNonvirtualFloatMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; } jfloat CallNonvirtualFloatMethodV(jobject obj, jclass clazz, - jmethodID methodID, - va_list args) { + jmethodID methodID, + va_list args) { return functions->CallNonvirtualFloatMethodV(this,obj,clazz, - methodID,args); + methodID,args); } jfloat CallNonvirtualFloatMethodA(jobject obj, jclass clazz, - jmethodID methodID, - const jvalue * args) { + jmethodID methodID, + const jvalue * args) { return functions->CallNonvirtualFloatMethodA(this,obj,clazz, - methodID,args); + methodID,args); } jdouble CallNonvirtualDoubleMethod(jobject obj, jclass clazz, - jmethodID methodID, ...) { + jmethodID methodID, ...) { va_list args; - jdouble result; - va_start(args,methodID); - result = functions->CallNonvirtualDoubleMethodV(this,obj,clazz, - methodID,args); - va_end(args); - return result; + jdouble result; + va_start(args,methodID); + result = functions->CallNonvirtualDoubleMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; } jdouble CallNonvirtualDoubleMethodV(jobject obj, jclass clazz, - jmethodID methodID, - va_list args) { + jmethodID methodID, + va_list args) { return functions->CallNonvirtualDoubleMethodV(this,obj,clazz, - methodID,args); + methodID,args); } jdouble CallNonvirtualDoubleMethodA(jobject obj, jclass clazz, - jmethodID methodID, - const jvalue * args) { + jmethodID methodID, + const jvalue * args) { return functions->CallNonvirtualDoubleMethodA(this,obj,clazz, - methodID,args); + methodID,args); } void CallNonvirtualVoidMethod(jobject obj, jclass clazz, - jmethodID methodID, ...) { + jmethodID methodID, ...) { va_list args; - va_start(args,methodID); - functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args); - va_end(args); + va_start(args,methodID); + functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args); + va_end(args); } void CallNonvirtualVoidMethodV(jobject obj, jclass clazz, - jmethodID methodID, - va_list args) { + jmethodID methodID, + va_list args) { functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args); } void CallNonvirtualVoidMethodA(jobject obj, jclass clazz, - jmethodID methodID, - const jvalue * args) { + jmethodID methodID, + const jvalue * args) { functions->CallNonvirtualVoidMethodA(this,obj,clazz,methodID,args); } jfieldID GetFieldID(jclass clazz, const char *name, - const char *sig) { + const char *sig) { return functions->GetFieldID(this,clazz,name,sig); } @@ -1293,222 +1316,222 @@ struct JNIEnv_ { functions->SetObjectField(this,obj,fieldID,val); } void SetBooleanField(jobject obj, jfieldID fieldID, - jboolean val) { + jboolean val) { functions->SetBooleanField(this,obj,fieldID,val); } void SetByteField(jobject obj, jfieldID fieldID, - jbyte val) { + jbyte val) { functions->SetByteField(this,obj,fieldID,val); } void SetCharField(jobject obj, jfieldID fieldID, - jchar val) { + jchar val) { functions->SetCharField(this,obj,fieldID,val); } void SetShortField(jobject obj, jfieldID fieldID, - jshort val) { + jshort val) { functions->SetShortField(this,obj,fieldID,val); } void SetIntField(jobject obj, jfieldID fieldID, - jint val) { + jint val) { functions->SetIntField(this,obj,fieldID,val); } void SetLongField(jobject obj, jfieldID fieldID, - jlong val) { + jlong val) { functions->SetLongField(this,obj,fieldID,val); } void SetFloatField(jobject obj, jfieldID fieldID, - jfloat val) { + jfloat val) { functions->SetFloatField(this,obj,fieldID,val); } void SetDoubleField(jobject obj, jfieldID fieldID, - jdouble val) { + jdouble val) { functions->SetDoubleField(this,obj,fieldID,val); } jmethodID GetStaticMethodID(jclass clazz, const char *name, - const char *sig) { + const char *sig) { return functions->GetStaticMethodID(this,clazz,name,sig); } jobject CallStaticObjectMethod(jclass clazz, jmethodID methodID, - ...) { + ...) { va_list args; - jobject result; - va_start(args,methodID); - result = functions->CallStaticObjectMethodV(this,clazz,methodID,args); - va_end(args); - return result; + jobject result; + va_start(args,methodID); + result = functions->CallStaticObjectMethodV(this,clazz,methodID,args); + va_end(args); + return result; } jobject CallStaticObjectMethodV(jclass clazz, jmethodID methodID, - va_list args) { + va_list args) { return functions->CallStaticObjectMethodV(this,clazz,methodID,args); } jobject CallStaticObjectMethodA(jclass clazz, jmethodID methodID, - const jvalue *args) { + const jvalue *args) { return functions->CallStaticObjectMethodA(this,clazz,methodID,args); } jboolean CallStaticBooleanMethod(jclass clazz, - jmethodID methodID, ...) { + jmethodID methodID, ...) { va_list args; - jboolean result; - va_start(args,methodID); - result = functions->CallStaticBooleanMethodV(this,clazz,methodID,args); - va_end(args); - return result; + jboolean result; + va_start(args,methodID); + result = functions->CallStaticBooleanMethodV(this,clazz,methodID,args); + va_end(args); + return result; } jboolean CallStaticBooleanMethodV(jclass clazz, - jmethodID methodID, va_list args) { + jmethodID methodID, va_list args) { return functions->CallStaticBooleanMethodV(this,clazz,methodID,args); } jboolean CallStaticBooleanMethodA(jclass clazz, - jmethodID methodID, const jvalue *args) { + jmethodID methodID, const jvalue *args) { return functions->CallStaticBooleanMethodA(this,clazz,methodID,args); } jbyte CallStaticByteMethod(jclass clazz, - jmethodID methodID, ...) { + jmethodID methodID, ...) { va_list args; - jbyte result; - va_start(args,methodID); - result = functions->CallStaticByteMethodV(this,clazz,methodID,args); - va_end(args); - return result; + jbyte result; + va_start(args,methodID); + result = functions->CallStaticByteMethodV(this,clazz,methodID,args); + va_end(args); + return result; } jbyte CallStaticByteMethodV(jclass clazz, - jmethodID methodID, va_list args) { + jmethodID methodID, va_list args) { return functions->CallStaticByteMethodV(this,clazz,methodID,args); } jbyte CallStaticByteMethodA(jclass clazz, - jmethodID methodID, const jvalue *args) { + jmethodID methodID, const jvalue *args) { return functions->CallStaticByteMethodA(this,clazz,methodID,args); } jchar CallStaticCharMethod(jclass clazz, - jmethodID methodID, ...) { + jmethodID methodID, ...) { va_list args; - jchar result; - va_start(args,methodID); - result = functions->CallStaticCharMethodV(this,clazz,methodID,args); - va_end(args); - return result; + jchar result; + va_start(args,methodID); + result = functions->CallStaticCharMethodV(this,clazz,methodID,args); + va_end(args); + return result; } jchar CallStaticCharMethodV(jclass clazz, - jmethodID methodID, va_list args) { + jmethodID methodID, va_list args) { return functions->CallStaticCharMethodV(this,clazz,methodID,args); } jchar CallStaticCharMethodA(jclass clazz, - jmethodID methodID, const jvalue *args) { + jmethodID methodID, const jvalue *args) { return functions->CallStaticCharMethodA(this,clazz,methodID,args); } jshort CallStaticShortMethod(jclass clazz, - jmethodID methodID, ...) { + jmethodID methodID, ...) { va_list args; - jshort result; - va_start(args,methodID); - result = functions->CallStaticShortMethodV(this,clazz,methodID,args); - va_end(args); - return result; + jshort result; + va_start(args,methodID); + result = functions->CallStaticShortMethodV(this,clazz,methodID,args); + va_end(args); + return result; } jshort CallStaticShortMethodV(jclass clazz, - jmethodID methodID, va_list args) { + jmethodID methodID, va_list args) { return functions->CallStaticShortMethodV(this,clazz,methodID,args); } jshort CallStaticShortMethodA(jclass clazz, - jmethodID methodID, const jvalue *args) { + jmethodID methodID, const jvalue *args) { return functions->CallStaticShortMethodA(this,clazz,methodID,args); } jint CallStaticIntMethod(jclass clazz, - jmethodID methodID, ...) { + jmethodID methodID, ...) { va_list args; - jint result; - va_start(args,methodID); - result = functions->CallStaticIntMethodV(this,clazz,methodID,args); - va_end(args); - return result; + jint result; + va_start(args,methodID); + result = functions->CallStaticIntMethodV(this,clazz,methodID,args); + va_end(args); + return result; } jint CallStaticIntMethodV(jclass clazz, - jmethodID methodID, va_list args) { + jmethodID methodID, va_list args) { return functions->CallStaticIntMethodV(this,clazz,methodID,args); } jint CallStaticIntMethodA(jclass clazz, - jmethodID methodID, const jvalue *args) { + jmethodID methodID, const jvalue *args) { return functions->CallStaticIntMethodA(this,clazz,methodID,args); } jlong CallStaticLongMethod(jclass clazz, - jmethodID methodID, ...) { + jmethodID methodID, ...) { va_list args; - jlong result; - va_start(args,methodID); - result = functions->CallStaticLongMethodV(this,clazz,methodID,args); - va_end(args); - return result; + jlong result; + va_start(args,methodID); + result = functions->CallStaticLongMethodV(this,clazz,methodID,args); + va_end(args); + return result; } jlong CallStaticLongMethodV(jclass clazz, - jmethodID methodID, va_list args) { + jmethodID methodID, va_list args) { return functions->CallStaticLongMethodV(this,clazz,methodID,args); } jlong CallStaticLongMethodA(jclass clazz, - jmethodID methodID, const jvalue *args) { + jmethodID methodID, const jvalue *args) { return functions->CallStaticLongMethodA(this,clazz,methodID,args); } jfloat CallStaticFloatMethod(jclass clazz, - jmethodID methodID, ...) { + jmethodID methodID, ...) { va_list args; - jfloat result; - va_start(args,methodID); - result = functions->CallStaticFloatMethodV(this,clazz,methodID,args); - va_end(args); - return result; + jfloat result; + va_start(args,methodID); + result = functions->CallStaticFloatMethodV(this,clazz,methodID,args); + va_end(args); + return result; } jfloat CallStaticFloatMethodV(jclass clazz, - jmethodID methodID, va_list args) { + jmethodID methodID, va_list args) { return functions->CallStaticFloatMethodV(this,clazz,methodID,args); } jfloat CallStaticFloatMethodA(jclass clazz, - jmethodID methodID, const jvalue *args) { + jmethodID methodID, const jvalue *args) { return functions->CallStaticFloatMethodA(this,clazz,methodID,args); } jdouble CallStaticDoubleMethod(jclass clazz, - jmethodID methodID, ...) { + jmethodID methodID, ...) { va_list args; - jdouble result; - va_start(args,methodID); - result = functions->CallStaticDoubleMethodV(this,clazz,methodID,args); - va_end(args); - return result; + jdouble result; + va_start(args,methodID); + result = functions->CallStaticDoubleMethodV(this,clazz,methodID,args); + va_end(args); + return result; } jdouble CallStaticDoubleMethodV(jclass clazz, - jmethodID methodID, va_list args) { + jmethodID methodID, va_list args) { return functions->CallStaticDoubleMethodV(this,clazz,methodID,args); } jdouble CallStaticDoubleMethodA(jclass clazz, - jmethodID methodID, const jvalue *args) { + jmethodID methodID, const jvalue *args) { return functions->CallStaticDoubleMethodA(this,clazz,methodID,args); } void CallStaticVoidMethod(jclass cls, jmethodID methodID, ...) { va_list args; - va_start(args,methodID); - functions->CallStaticVoidMethodV(this,cls,methodID,args); - va_end(args); + va_start(args,methodID); + functions->CallStaticVoidMethodV(this,cls,methodID,args); + va_end(args); } void CallStaticVoidMethodV(jclass cls, jmethodID methodID, - va_list args) { + va_list args) { functions->CallStaticVoidMethodV(this,cls,methodID,args); } void CallStaticVoidMethodA(jclass cls, jmethodID methodID, - const jvalue * args) { + const jvalue * args) { functions->CallStaticVoidMethodA(this,cls,methodID,args); } jfieldID GetStaticFieldID(jclass clazz, const char *name, - const char *sig) { + const char *sig) { return functions->GetStaticFieldID(this,clazz,name,sig); } jobject GetStaticObjectField(jclass clazz, jfieldID fieldID) { @@ -1540,39 +1563,39 @@ struct JNIEnv_ { } void SetStaticObjectField(jclass clazz, jfieldID fieldID, - jobject value) { + jobject value) { functions->SetStaticObjectField(this,clazz,fieldID,value); } void SetStaticBooleanField(jclass clazz, jfieldID fieldID, - jboolean value) { + jboolean value) { functions->SetStaticBooleanField(this,clazz,fieldID,value); } void SetStaticByteField(jclass clazz, jfieldID fieldID, - jbyte value) { + jbyte value) { functions->SetStaticByteField(this,clazz,fieldID,value); } void SetStaticCharField(jclass clazz, jfieldID fieldID, - jchar value) { + jchar value) { functions->SetStaticCharField(this,clazz,fieldID,value); } void SetStaticShortField(jclass clazz, jfieldID fieldID, - jshort value) { + jshort value) { functions->SetStaticShortField(this,clazz,fieldID,value); } void SetStaticIntField(jclass clazz, jfieldID fieldID, - jint value) { + jint value) { functions->SetStaticIntField(this,clazz,fieldID,value); } void SetStaticLongField(jclass clazz, jfieldID fieldID, - jlong value) { + jlong value) { functions->SetStaticLongField(this,clazz,fieldID,value); } void SetStaticFloatField(jclass clazz, jfieldID fieldID, - jfloat value) { + jfloat value) { functions->SetStaticFloatField(this,clazz,fieldID,value); } void SetStaticDoubleField(jclass clazz, jfieldID fieldID, - jdouble value) { + jdouble value) { functions->SetStaticDoubleField(this,clazz,fieldID,value); } @@ -1607,14 +1630,14 @@ struct JNIEnv_ { } jobjectArray NewObjectArray(jsize len, jclass clazz, - jobject init) { + jobject init) { return functions->NewObjectArray(this,len,clazz,init); } jobject GetObjectArrayElement(jobjectArray array, jsize index) { return functions->GetObjectArrayElement(this,array,index); } void SetObjectArrayElement(jobjectArray array, jsize index, - jobject val) { + jobject val) { functions->SetObjectArrayElement(this,array,index,val); } @@ -1669,114 +1692,114 @@ struct JNIEnv_ { } void ReleaseBooleanArrayElements(jbooleanArray array, - jboolean *elems, - jint mode) { + jboolean *elems, + jint mode) { functions->ReleaseBooleanArrayElements(this,array,elems,mode); } void ReleaseByteArrayElements(jbyteArray array, - jbyte *elems, - jint mode) { + jbyte *elems, + jint mode) { functions->ReleaseByteArrayElements(this,array,elems,mode); } void ReleaseCharArrayElements(jcharArray array, - jchar *elems, - jint mode) { + jchar *elems, + jint mode) { functions->ReleaseCharArrayElements(this,array,elems,mode); } void ReleaseShortArrayElements(jshortArray array, - jshort *elems, - jint mode) { + jshort *elems, + jint mode) { functions->ReleaseShortArrayElements(this,array,elems,mode); } void ReleaseIntArrayElements(jintArray array, - jint *elems, - jint mode) { + jint *elems, + jint mode) { functions->ReleaseIntArrayElements(this,array,elems,mode); } void ReleaseLongArrayElements(jlongArray array, - jlong *elems, - jint mode) { + jlong *elems, + jint mode) { functions->ReleaseLongArrayElements(this,array,elems,mode); } void ReleaseFloatArrayElements(jfloatArray array, - jfloat *elems, - jint mode) { + jfloat *elems, + jint mode) { functions->ReleaseFloatArrayElements(this,array,elems,mode); } void ReleaseDoubleArrayElements(jdoubleArray array, - jdouble *elems, - jint mode) { + jdouble *elems, + jint mode) { functions->ReleaseDoubleArrayElements(this,array,elems,mode); } void GetBooleanArrayRegion(jbooleanArray array, - jsize start, jsize len, jboolean *buf) { + jsize start, jsize len, jboolean *buf) { functions->GetBooleanArrayRegion(this,array,start,len,buf); } void GetByteArrayRegion(jbyteArray array, - jsize start, jsize len, jbyte *buf) { + jsize start, jsize len, jbyte *buf) { functions->GetByteArrayRegion(this,array,start,len,buf); } void GetCharArrayRegion(jcharArray array, - jsize start, jsize len, jchar *buf) { + jsize start, jsize len, jchar *buf) { functions->GetCharArrayRegion(this,array,start,len,buf); } void GetShortArrayRegion(jshortArray array, - jsize start, jsize len, jshort *buf) { + jsize start, jsize len, jshort *buf) { functions->GetShortArrayRegion(this,array,start,len,buf); } void GetIntArrayRegion(jintArray array, - jsize start, jsize len, jint *buf) { + jsize start, jsize len, jint *buf) { functions->GetIntArrayRegion(this,array,start,len,buf); } void GetLongArrayRegion(jlongArray array, - jsize start, jsize len, jlong *buf) { + jsize start, jsize len, jlong *buf) { functions->GetLongArrayRegion(this,array,start,len,buf); } void GetFloatArrayRegion(jfloatArray array, - jsize start, jsize len, jfloat *buf) { + jsize start, jsize len, jfloat *buf) { functions->GetFloatArrayRegion(this,array,start,len,buf); } void GetDoubleArrayRegion(jdoubleArray array, - jsize start, jsize len, jdouble *buf) { + jsize start, jsize len, jdouble *buf) { functions->GetDoubleArrayRegion(this,array,start,len,buf); } void SetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len, - const jboolean *buf) { + const jboolean *buf) { functions->SetBooleanArrayRegion(this,array,start,len,buf); } void SetByteArrayRegion(jbyteArray array, jsize start, jsize len, - const jbyte *buf) { + const jbyte *buf) { functions->SetByteArrayRegion(this,array,start,len,buf); } void SetCharArrayRegion(jcharArray array, jsize start, jsize len, - const jchar *buf) { + const jchar *buf) { functions->SetCharArrayRegion(this,array,start,len,buf); } void SetShortArrayRegion(jshortArray array, jsize start, jsize len, - const jshort *buf) { + const jshort *buf) { functions->SetShortArrayRegion(this,array,start,len,buf); } void SetIntArrayRegion(jintArray array, jsize start, jsize len, - const jint *buf) { + const jint *buf) { functions->SetIntArrayRegion(this,array,start,len,buf); } void SetLongArrayRegion(jlongArray array, jsize start, jsize len, - const jlong *buf) { + const jlong *buf) { functions->SetLongArrayRegion(this,array,start,len,buf); } void SetFloatArrayRegion(jfloatArray array, jsize start, jsize len, - const jfloat *buf) { + const jfloat *buf) { functions->SetFloatArrayRegion(this,array,start,len,buf); } void SetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len, - const jdouble *buf) { + const jdouble *buf) { functions->SetDoubleArrayRegion(this,array,start,len,buf); } jint RegisterNatives(jclass clazz, const JNINativeMethod *methods, - jint nMethods) { + jint nMethods) { return functions->RegisterNatives(this,clazz,methods,nMethods); } jint UnregisterNatives(jclass clazz) { @@ -1823,7 +1846,7 @@ struct JNIEnv_ { } jboolean ExceptionCheck() { - return functions->ExceptionCheck(this); + return functions->ExceptionCheck(this); } jobject NewDirectByteBuffer(void* address, jlong capacity) { @@ -1839,6 +1862,12 @@ struct JNIEnv_ { return functions->GetObjectRefType(this, obj); } + /* Module Features */ + + jobject GetModule(jclass clazz) { + return functions->GetModule(this, clazz); + } + #endif /* __cplusplus */ }; @@ -1933,12 +1962,12 @@ JNI_OnUnload(JavaVM *vm, void *reserved); #define JNI_VERSION_1_2 0x00010002 #define JNI_VERSION_1_4 0x00010004 #define JNI_VERSION_1_6 0x00010006 +#define JNI_VERSION_1_8 0x00010008 +#define JNI_VERSION_9 0x00090000 +#define JNI_VERSION_10 0x000a0000 #ifdef __cplusplus } /* extern "C" */ #endif /* __cplusplus */ #endif /* !_JAVASOFT_JNI_H_ */ - - - diff --git a/jni/jni/jni-headers/linux/jawt_md.h b/jni/jni/jni-headers/linux/jawt_md.h index fa66d2197..2ba3a8e83 100644 --- a/jni/jni/jni-headers/linux/jawt_md.h +++ b/jni/jni/jni-headers/linux/jawt_md.h @@ -1,8 +1,26 @@ /* - * @(#)jawt_md.h 1.13 10/03/23 + * Copyright (c) 1999, 2001, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * - * Copyright (c) 2006, Oracle and/or its affiliates. All rights reserved. - * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. */ #ifndef _JAVASOFT_JAWT_MD_H_ @@ -10,7 +28,6 @@ #include #include -#include #include "jawt.h" #ifdef __cplusplus diff --git a/jni/jni/jni-headers/linux/jni_md.h b/jni/jni/jni-headers/linux/jni_md.h index 8d4ccdfe6..6e352038f 100644 --- a/jni/jni/jni-headers/linux/jni_md.h +++ b/jni/jni/jni-headers/linux/jni_md.h @@ -1,19 +1,51 @@ /* - * @(#)jni_md.h 1.20 10/03/23 + * Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * - * Copyright (c) 2006, Oracle and/or its affiliates. All rights reserved. - * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. */ #ifndef _JAVASOFT_JNI_MD_H_ #define _JAVASOFT_JNI_MD_H_ -#define JNIEXPORT -#define JNIIMPORT +#ifndef __has_attribute + #define __has_attribute(x) 0 +#endif +#if (defined(__GNUC__) && ((__GNUC__ > 4) || (__GNUC__ == 4) && (__GNUC_MINOR__ > 2))) || __has_attribute(visibility) + #ifdef ARM + #define JNIEXPORT __attribute__((externally_visible,visibility("default"))) + #define JNIIMPORT __attribute__((externally_visible,visibility("default"))) + #else + #define JNIEXPORT __attribute__((visibility("default"))) + #define JNIIMPORT __attribute__((visibility("default"))) + #endif +#else + #define JNIEXPORT + #define JNIIMPORT +#endif + #define JNICALL typedef int jint; -#ifdef _LP64 /* 64-bit Solaris */ +#ifdef _LP64 typedef long jlong; #else typedef long long jlong; diff --git a/jni/jni/jni-headers/mac/jni_md.h b/jni/jni/jni-headers/mac/jni_md.h index 7a2116f89..6e352038f 100644 --- a/jni/jni/jni-headers/mac/jni_md.h +++ b/jni/jni/jni-headers/mac/jni_md.h @@ -1,23 +1,56 @@ /* - * @(#)jni_md.h 1.19 05/11/17 + * Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * - * Copyright 2006 Sun Microsystems, Inc. All rights reserved. - * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. */ #ifndef _JAVASOFT_JNI_MD_H_ #define _JAVASOFT_JNI_MD_H_ -#define JNIEXPORT __attribute__((visibility("default"))) -#define JNIIMPORT +#ifndef __has_attribute + #define __has_attribute(x) 0 +#endif +#if (defined(__GNUC__) && ((__GNUC__ > 4) || (__GNUC__ == 4) && (__GNUC_MINOR__ > 2))) || __has_attribute(visibility) + #ifdef ARM + #define JNIEXPORT __attribute__((externally_visible,visibility("default"))) + #define JNIIMPORT __attribute__((externally_visible,visibility("default"))) + #else + #define JNIEXPORT __attribute__((visibility("default"))) + #define JNIIMPORT __attribute__((visibility("default"))) + #endif +#else + #define JNIEXPORT + #define JNIIMPORT +#endif + #define JNICALL -#if __LP64__ typedef int jint; +#ifdef _LP64 +typedef long jlong; #else -typedef long jint; -#endif typedef long long jlong; +#endif + typedef signed char jbyte; #endif /* !_JAVASOFT_JNI_MD_H_ */ diff --git a/jni/jni/jni-headers/win32/jawt_md.h b/jni/jni/jni-headers/win32/jawt_md.h index 82ba0347d..7d43ff827 100644 --- a/jni/jni/jni-headers/win32/jawt_md.h +++ b/jni/jni/jni-headers/win32/jawt_md.h @@ -1,8 +1,26 @@ /* - * %W% %E% + * Copyright (c) 1999, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * - * Copyright (c) 2006, Oracle and/or its affiliates. All rights reserved. - * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. */ #ifndef _JAVASOFT_JAWT_MD_H_ diff --git a/jni/jni/jni-headers/win32/jni_md.h b/jni/jni/jni-headers/win32/jni_md.h index 9ac4718e9..6c8d6b9e7 100644 --- a/jni/jni/jni-headers/win32/jni_md.h +++ b/jni/jni/jni-headers/win32/jni_md.h @@ -1,8 +1,26 @@ /* - * %W% %E% + * Copyright (c) 1996, 1998, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * - * Copyright (c) 2006, Oracle and/or its affiliates. All rights reserved. - * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. */ #ifndef _JAVASOFT_JNI_MD_H_ @@ -12,6 +30,7 @@ #define JNIIMPORT __declspec(dllimport) #define JNICALL __stdcall +// 'long' is always 32 bit on windows so this matches what jdk expects typedef long jint; typedef __int64 jlong; typedef signed char jbyte; diff --git a/jni/jni/libtess2 b/jni/jni/libtess2 deleted file mode 160000 index a43504d78..000000000 --- a/jni/jni/libtess2 +++ /dev/null @@ -1 +0,0 @@ -Subproject commit a43504d78a5695ca07cf3706e34abfdfd5b4343b diff --git a/jni/jni/libtess2/.gitignore b/jni/jni/libtess2/.gitignore new file mode 100644 index 000000000..a6db6870b --- /dev/null +++ b/jni/jni/libtess2/.gitignore @@ -0,0 +1,28 @@ +## Compiled source # +*.com +*.class +*.dll +*.exe +*.o +*.so +test + +## Logs and databases # +*.log +*.sql +*.sqlite + +## OS generated files # +.DS_Store +.DS_Store? +._* +.Spotlight-V100 +.Trashes +ehthumbs.db +Thumbs.db + +## Build dir +Build/* + +## xcode specific +*xcuserdata* diff --git a/jni/jni/libtess2/Bin/bg.svg b/jni/jni/libtess2/Bin/bg.svg new file mode 100644 index 000000000..ade8549aa --- /dev/null +++ b/jni/jni/libtess2/Bin/bg.svg @@ -0,0 +1,70 @@ + + + + + + + + + + + + + diff --git a/jni/jni/libtess2/Bin/fg.svg b/jni/jni/libtess2/Bin/fg.svg new file mode 100644 index 000000000..7bed88b75 --- /dev/null +++ b/jni/jni/libtess2/Bin/fg.svg @@ -0,0 +1,7 @@ + + + + + + diff --git a/jni/jni/libtess2/Contrib/nanosvg.c b/jni/jni/libtess2/Contrib/nanosvg.c new file mode 100644 index 000000000..d3abba6c4 --- /dev/null +++ b/jni/jni/libtess2/Contrib/nanosvg.c @@ -0,0 +1,1335 @@ +// +// Copyright (c) 2009 Mikko Mononen memon@inside.org +// +// This software is provided 'as-is', without any express or implied +// warranty. In no event will the authors be held liable for any damages +// arising from the use of this software. +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it +// freely, subject to the following restrictions: +// 1. The origin of this software must not be misrepresented; you must not +// claim that you wrote the original software. If you use this software +// in a product, an acknowledgment in the product documentation would be +// appreciated but is not required. +// 2. Altered source versions must be plainly marked as such, and must not be +// misrepresented as being the original software. +// 3. This notice may not be removed or altered from any source distribution. +// + +// The SVG parser is based on Anti-Graim Geometry SVG example +// Copyright (C) 2002-2004 Maxim Shemanarev (McSeem) + +#include "nanosvg.h" +#include +#include +#include +#include +#include + +#ifndef M_PI + #define M_PI 3.14159265358979323846264338327 +#endif + +#ifdef _MSC_VER + #pragma warning (disable: 4996) // Switch off security warnings +#endif + +// Simple XML parser + +#define TAG 1 +#define CONTENT 2 +#define MAX_ATTRIBS 256 + +static void parseContent(char* s, + void (*contentCb)(void* ud, const char* s), + void* ud) +{ + // Trim start white spaces + while (*s && isspace(*s)) s++; + if (!*s) return; + + if (contentCb) + (*contentCb)(ud, s); +} + +static void parseElement(char* s, + void (*startelCb)(void* ud, const char* el, const char** attr), + void (*endelCb)(void* ud, const char* el), + void* ud) +{ + const char* attr[MAX_ATTRIBS]; + int nattr = 0; + char* name; + int start = 0; + int end = 0; + + // Skip white space after the '<' + while (*s && isspace(*s)) s++; + + // Check if the tag is end tag + if (*s == '/') + { + s++; + end = 1; + } + else + { + start = 1; + } + + // Skip comments, data and preprocessor stuff. + if (!*s || *s == '?' || *s == '!') + return; + + // Get tag name + name = s; + while (*s && !isspace(*s)) s++; + if (*s) { *s++ = '\0'; } + + // Get attribs + while (!end && *s && nattr < MAX_ATTRIBS-1) + { + // Skip white space before the attrib name + while (*s && isspace(*s)) s++; + if (!*s) break; + if (*s == '/') + { + end = 1; + break; + } + attr[nattr++] = s; + // Find end of the attrib name. + while (*s && !isspace(*s) && *s != '=') s++; + if (*s) { *s++ = '\0'; } + // Skip until the beginning of the value. + while (*s && *s != '\"') s++; + if (!*s) break; + s++; + // Store value and find the end of it. + attr[nattr++] = s; + while (*s && *s != '\"') s++; + if (*s) { *s++ = '\0'; } + } + + // List terminator + attr[nattr++] = 0; + attr[nattr++] = 0; + + // Call callbacks. + if (start && startelCb) + (*startelCb)(ud, name, attr); + if (end && endelCb) + (*endelCb)(ud, name); +} + +int parsexml(char* input, + void (*startelCb)(void* ud, const char* el, const char** attr), + void (*endelCb)(void* ud, const char* el), + void (*contentCb)(void* ud, const char* s), + void* ud) +{ + char* s = input; + char* mark = s; + int state = CONTENT; + while (*s) + { + if (*s == '<' && state == CONTENT) + { + // Start of a tag + *s++ = '\0'; + parseContent(mark, contentCb, ud); + mark = s; + state = TAG; + } + else if (*s == '>' && state == TAG) + { + // Start of a content or new tag. + *s++ = '\0'; + parseElement(mark, startelCb, endelCb, ud); + mark = s; + state = CONTENT; + } + else + s++; + } + + return 1; +} + + +/* Simple SVG parser. */ + +#define SVG_MAX_ATTR 128 + +struct SVGAttrib +{ + float xform[6]; + unsigned int fillColor; + unsigned int strokeColor; + float fillOpacity; + float strokeOpacity; + float strokeWidth; + char hasFill; + char hasStroke; + char visible; +}; + +struct SVGParser +{ + struct SVGAttrib attr[SVG_MAX_ATTR]; + int attrHead; + float* buf; + int nbuf; + int cbuf; + struct SVGPath* plist; + char pathFlag; + char defsFlag; + float tol; +}; + +static void xformSetIdentity(float* t) +{ + t[0] = 1.0f; t[1] = 0.0f; + t[2] = 0.0f; t[3] = 1.0f; + t[4] = 0.0f; t[5] = 0.0f; +} + +static void xformSetTranslation(float* t, float tx, float ty) +{ + t[0] = 1.0f; t[1] = 0.0f; + t[2] = 0.0f; t[3] = 1.0f; + t[4] = tx; t[5] = ty; +} + +static void xformSetScale(float* t, float sx, float sy) +{ + t[0] = sx; t[1] = 0.0f; + t[2] = 0.0f; t[3] = sy; + t[4] = 0.0f; t[5] = 0.0f; +} + +static void xformMultiply(float* t, float* s) +{ + float t0 = t[0] * s[0] + t[1] * s[2]; + float t2 = t[2] * s[0] + t[3] * s[2]; + float t4 = t[4] * s[0] + t[5] * s[2] + s[4]; + t[1] = t[0] * s[1] + t[1] * s[3]; + t[3] = t[2] * s[1] + t[3] * s[3]; + t[5] = t[4] * s[1] + t[5] * s[3] + s[5]; + t[0] = t0; + t[2] = t2; + t[4] = t4; +} + +static void xformPremultiply(float* t, float* s) +{ + float s2[6]; + memcpy(s2, s, sizeof(float)*6); + xformMultiply(s2, t); + memcpy(t, s2, sizeof(float)*6); +} + +static struct SVGParser* svgCreateParser() +{ + struct SVGParser* p; + p = (struct SVGParser*)malloc(sizeof(struct SVGParser)); + if (!p) + return NULL; + memset(p, 0, sizeof(struct SVGParser)); + + // Init style + xformSetIdentity(p->attr[0].xform); + p->attr[0].fillColor = 0; + p->attr[0].strokeColor = 0; + p->attr[0].fillOpacity = 1; + p->attr[0].strokeOpacity = 1; + p->attr[0].strokeWidth = 1; + p->attr[0].hasFill = 0; + p->attr[0].hasStroke = 0; + p->attr[0].visible = 1; + + return p; +} + +static void svgDeleteParser(struct SVGParser* p) +{ + struct SVGPath* path; + struct SVGPath* next; + path = p->plist; + while (path) + { + next = path->next; + if (path->pts) + free(path->pts); + free(path); + path = next; + } + if (p->buf) + free(p->buf); + free(p); +} + +static void svgResetPath(struct SVGParser* p) +{ + p->nbuf = 0; +} + +static void svgPathPoint(struct SVGParser* p, float x, float y) +{ + int cap; + float* buf; + if (p->nbuf+1 > p->cbuf) + { + cap = p->cbuf ? p->cbuf*2 : 8; + buf = (float*)malloc(cap*2*sizeof(float)); + if (!buf) return; + if (p->nbuf) + memcpy(buf, p->buf, p->nbuf*2*sizeof(float)); + if (p->buf) + free(p->buf); + p->buf = buf; + p->cbuf = cap; + } + p->buf[p->nbuf*2+0] = x; + p->buf[p->nbuf*2+1] = y; + p->nbuf++; +} + +static struct SVGAttrib* svgGetAttr(struct SVGParser* p) +{ + return &p->attr[p->attrHead]; +} + +static void svgPushAttr(struct SVGParser* p) +{ + if (p->attrHead < SVG_MAX_ATTR-1) + { + p->attrHead++; + memcpy(&p->attr[p->attrHead], &p->attr[p->attrHead-1], sizeof(struct SVGAttrib)); + } +} + +static void svgPopAttr(struct SVGParser* p) +{ + if (p->attrHead > 0) + p->attrHead--; +} + +static void svgCreatePath(struct SVGParser* p, char closed) +{ + float* t; + float* pt; + struct SVGAttrib* attr; + struct SVGPath* path; + int i; + + if (!p) + return; + + if (!p->nbuf) + { + return; + } + + attr = svgGetAttr(p); + + path = (struct SVGPath*)malloc(sizeof(struct SVGPath)); + if (!path) + return; + memset(path, 0, sizeof(struct SVGPath)); + path->pts = (float*)malloc(p->nbuf*2*sizeof(float)); + if (!path->pts) + { + free(path); + return; + } + path->closed = closed; + path->npts = p->nbuf; + + path->next = p->plist; + p->plist = path; + + // Transform path. + t = attr->xform; + for (i = 0; i < p->nbuf; ++i) + { + pt = &p->buf[i*2]; + path->pts[i*2+0] = pt[0]*t[0] + pt[1]*t[2] + t[4]; + path->pts[i*2+1] = pt[0]*t[1] + pt[1]*t[3] + t[5]; + } + + path->hasFill = attr->hasFill; + path->hasStroke = attr->hasStroke; + path->strokeWidth = attr->strokeWidth * t[0]; + + path->fillColor = attr->fillColor; + if (path->hasFill) + path->fillColor |= (unsigned int)(attr->fillOpacity*255) << 24; + + path->strokeColor = attr->strokeColor; + if (path->hasStroke) + path->strokeColor |= (unsigned int)(attr->strokeOpacity*255) << 24; +} + +static int isnum(char c) +{ + return strchr("0123456789+-.eE", c) != 0; +} + +/*static const char* parsePathFloats(const char* s, float* arg, int n) +{ + char num[64]; + const char* start; + int nnum; + int i = 0; + while (*s && i < n) + { + // Skip white spaces and commas + while (*s && (isspace(*s) || *s == ',')) s++; + if (!*s) break; + start = s; + nnum = 0; + while (*s && isnum(*s)) + { + if (nnum < 63) num[nnum++] = *s; + s++; + } + num[nnum] = '\0'; + arg[i++] = (float)atof(num); + } + return s; +}*/ + + +static const char* getNextPathItem(const char* s, char* it) +{ + int i = 0; + it[0] = '\0'; + // Skip white spaces and commas + while (*s && (isspace(*s) || *s == ',')) s++; + if (!*s) return s; + if (*s == '-' || *s == '+' || isnum(*s)) + { + while (*s == '-' || *s == '+') + { + if (i < 63) it[i++] = *s; + s++; + } + while (*s && *s != '-' && *s != '+' && isnum(*s)) + { + if (i < 63) it[i++] = *s; + s++; + } + it[i] = '\0'; + } + else + { + it[0] = *s++; + it[1] = '\0'; + return s; + } + return s; +} + + +static unsigned int parseColor(const char* str) +{ + unsigned c = 0; + while(*str == ' ') ++str; + if (*str == '#') + sscanf(str + 1, "%x", &c); + return c; +} + +static float parseFloat(const char* str) +{ + while (*str == ' ') ++str; + return (float)atof(str); +} + +static int parseTransformArgs(const char* str, float* args, int maxNa, int* na) +{ + const char* end; + const char* ptr; + + *na = 0; + ptr = str; + while (*ptr && *ptr != '(') ++ptr; + if (*ptr == 0) + return 1; + end = ptr; + while (*end && *end != ')') ++end; + if (*end == 0) + return 1; + + while (ptr < end) + { + if (isnum(*ptr)) + { + if (*na >= maxNa) return 0; + args[(*na)++] = (float)atof(ptr); + while (ptr < end && isnum(*ptr)) ++ptr; + } + else + { + ++ptr; + } + } + return (int)(end - str); +} + +static int svgParseMatrix(struct SVGParser* p, const char* str) +{ + float t[6]; + int na = 0; + int len = parseTransformArgs(str, t, 6, &na); + if (na != 6) return len; + xformPremultiply(svgGetAttr(p)->xform, t); + return len; +} + +static int svgParseTranslate(struct SVGParser* p, const char* str) +{ + float args[2]; + float t[6]; + int na = 0; + int len = parseTransformArgs(str, args, 2, &na); + if (na == 1) args[1] = 0.0; + xformSetTranslation(t, args[0], args[1]); + xformPremultiply(svgGetAttr(p)->xform, t); + return len; +} + +static int svgParseScale(struct SVGParser* p, const char* str) +{ + float args[2]; + int na = 0; + float t[6]; + int len = parseTransformArgs(str, args, 2, &na); + if (na == 1) args[1] = args[0]; + xformSetScale(t, args[0], args[1]); + xformPremultiply(svgGetAttr(p)->xform, t); + return len; +} + +static void svgParseTransform(struct SVGParser* p, const char* str) +{ + while (*str) + { + if (strncmp(str, "matrix", 6) == 0) + str += svgParseMatrix(p, str); + else if (strncmp(str, "translate", 9) == 0) + str += svgParseTranslate(p, str); + else if (strncmp(str, "scale", 5) == 0) + str += svgParseScale(p, str); + else + ++str; + } +} + +static void svgParseStyle(struct SVGParser* p, const char* str); + +static int svgParseAttr(struct SVGParser* p, const char* name, const char* value) +{ + struct SVGAttrib* attr = svgGetAttr(p); + if (!attr) return 0; + + if (strcmp(name, "style") == 0) + { + svgParseStyle(p, value); + } + else if (strcmp(name, "display") == 0) + { + if (strcmp(value, "none") == 0) + attr->visible = 0; + else + attr->visible = 1; + } + else if (strcmp(name, "fill") == 0) + { + if (strcmp(value, "none") == 0) + { + attr->hasFill = 0; + } + else + { + attr->hasFill = 1; + attr->fillColor = parseColor(value); + } + } + else if (strcmp(name, "fill-opacity") == 0) + { + attr->fillOpacity = parseFloat(value); + } + else if (strcmp(name, "stroke") == 0) + { + if (strcmp(value, "none") == 0) + { + attr->hasStroke = 0; + } + else + { + attr->hasStroke = 1; + attr->strokeColor = parseColor(value); + } + } + else if (strcmp(name, "stroke-width") == 0) + { + attr->strokeWidth = parseFloat(value); + } + else if (strcmp(name, "stroke-opacity") == 0) + { + attr->strokeOpacity = parseFloat(value); + } + else if (strcmp(name, "transform") == 0) + { + svgParseTransform(p, value); + } + else + { + return 0; + } + return 1; +} + +static int svgParseNameValue(struct SVGParser* p, const char* start, const char* end) +{ + const char* str; + const char* val; + char name[512]; + char value[512]; + int n; + + str = start; + while (str < end && *str != ':') ++str; + + val = str; + + // Right Trim + while (str > start && (*str == ':' || isspace(*str))) --str; + ++str; + + n = (int)(str - start); + if (n > 511) n = 511; + if (n) memcpy(name, start, n); + name[n] = 0; + + while (val < end && (*val == ':' || isspace(*val))) ++val; + + n = (int)(end - val); + if (n > 511) n = 511; + if (n) memcpy(value, val, n); + value[n] = 0; + + return svgParseAttr(p, name, value); +} + +static void svgParseStyle(struct SVGParser* p, const char* str) +{ + const char* start; + const char* end; + + while (*str) + { + // Left Trim + while(*str && isspace(*str)) ++str; + start = str; + while(*str && *str != ';') ++str; + end = str; + + // Right Trim + while (end > start && (*end == ';' || isspace(*end))) --end; + ++end; + + svgParseNameValue(p, start, end); + if (*str) ++str; + } +} + +static void svgParseAttribs(struct SVGParser* p, const char** attr) +{ + int i; + for (i = 0; attr[i]; i += 2) + { + if (strcmp(attr[i], "style") == 0) + svgParseStyle(p, attr[i + 1]); + else + svgParseAttr(p, attr[i], attr[i + 1]); + } +} + +static int getArgsPerElement(char cmd) +{ + switch (tolower(cmd)) + { + case 'v': + case 'h': + return 1; + case 'm': + case 'l': + case 't': + return 2; + case 'q': + case 's': + return 4; + case 'c': + return 6; + case 'a': + return 7; + } + return 0; +} + +static float distPtSeg(float x, float y, float px, float py, float qx, float qy) +{ + float pqx, pqy, dx, dy, d, t; + pqx = qx-px; + pqy = qy-py; + dx = x-px; + dy = y-py; + d = pqx*pqx + pqy*pqy; + t = pqx*dx + pqy*dy; + if (d > 0) t /= d; + if (t < 0) t = 0; + else if (t > 1) t = 1; + dx = px + t*pqx - x; + dy = py + t*pqy - y; + return dx*dx + dy*dy; +} + +static void cubicBezRec(struct SVGParser* p, + float x1, float y1, float x2, float y2, + float x3, float y3, float x4, float y4, + int level) +{ + float x12,y12,x23,y23,x34,y34,x123,y123,x234,y234,x1234,y1234; + float d; + + if (level > 12) return; + + x12 = (x1+x2)*0.5f; + y12 = (y1+y2)*0.5f; + x23 = (x2+x3)*0.5f; + y23 = (y2+y3)*0.5f; + x34 = (x3+x4)*0.5f; + y34 = (y3+y4)*0.5f; + x123 = (x12+x23)*0.5f; + y123 = (y12+y23)*0.5f; + x234 = (x23+x34)*0.5f; + y234 = (y23+y34)*0.5f; + x1234 = (x123+x234)*0.5f; + y1234 = (y123+y234)*0.5f; + + d = distPtSeg(x1234, y1234, x1,y1, x4,y4); + if (level > 0 && d < p->tol*p->tol) + { + svgPathPoint(p, x1234, y1234); + return; + } + + cubicBezRec(p, x1,y1, x12,y12, x123,y123, x1234,y1234, level+1); + cubicBezRec(p, x1234,y1234, x234,y234, x34,y34, x4,y4, level+1); +} + +static void cubicBez(struct SVGParser* p, + float x1, float y1, float cx1, float cy1, + float cx2, float cy2, float x2, float y2) +{ + cubicBezRec(p, x1,y1, cx1,cy1, cx2,cy2, x2,y2, 0); + svgPathPoint(p, x2, y2); +} + +static void quadBezRec(struct SVGParser* p, + float x1, float y1, float x2, float y2, float x3, float y3, + int level) +{ + float x12,y12,x23,y23,x123,y123,d; + + if (level > 12) return; + + x12 = (x1+x2)*0.5f; + y12 = (y1+y2)*0.5f; + x23 = (x2+x3)*0.5f; + y23 = (y2+y3)*0.5f; + x123 = (x12+x23)*0.5f; + y123 = (y12+y23)*0.5f; + + d = distPtSeg(x123, y123, x1,y1, x3,y3); + if (level > 0 && d < p->tol*p->tol) + { + svgPathPoint(p, x123, y123); + return; + } + + quadBezRec(p, x1,y1, x12,y12, x123,y123, level+1); + quadBezRec(p, x123,y123, x23,y23, x3,y3, level+1); +} + +static void quadBez(struct SVGParser* p, + float x1, float y1, float cx, float cy, float x2, float y2) +{ + quadBezRec(p, x1,y1, cx,cy, x2,y2, 0); + svgPathPoint(p, x2, y2); +} + +static void pathLineTo(struct SVGParser* p, float* cpx, float* cpy, float* args, int rel) +{ + if (rel) + { + *cpx += args[0]; + *cpy += args[1]; + } + else + { + *cpx = args[0]; + *cpy = args[1]; + } + svgPathPoint(p, *cpx, *cpy); +} + +static void pathHLineTo(struct SVGParser* p, float* cpx, float* cpy, float* args, int rel) +{ + if (rel) + *cpx += args[0]; + else + *cpx = args[0]; + svgPathPoint(p, *cpx, *cpy); +} + +static void pathVLineTo(struct SVGParser* p, float* cpx, float* cpy, float* args, int rel) +{ + if (rel) + *cpy += args[0]; + else + *cpy = args[0]; + svgPathPoint(p, *cpx, *cpy); +} + +static void pathCubicBezTo(struct SVGParser* p, float* cpx, float* cpy, + float* cpx2, float* cpy2, float* args, int rel) +{ + float x1, y1, x2, y2, cx1, cy1, cx2, cy2; + + x1 = *cpx; + y1 = *cpy; + if (rel) + { + cx1 = *cpx + args[0]; + cy1 = *cpy + args[1]; + cx2 = *cpx + args[2]; + cy2 = *cpy + args[3]; + x2 = *cpx + args[4]; + y2 = *cpy + args[5]; + } + else + { + cx1 = args[0]; + cy1 = args[1]; + cx2 = args[2]; + cy2 = args[3]; + x2 = args[4]; + y2 = args[5]; + } + + cubicBez(p, x1,y1, cx1,cy1, cx2,cy2, x2,y2); + + *cpx2 = cx2; + *cpy2 = cy2; + *cpx = x2; + *cpy = y2; +} + +static void pathCubicBezShortTo(struct SVGParser* p, float* cpx, float* cpy, + float* cpx2, float* cpy2, float* args, int rel) +{ + float x1, y1, x2, y2, cx1, cy1, cx2, cy2; + + x1 = *cpx; + y1 = *cpy; + if (rel) + { + cx2 = *cpx + args[0]; + cy2 = *cpy + args[1]; + x2 = *cpx + args[2]; + y2 = *cpy + args[3]; + } + else + { + cx2 = args[0]; + cy2 = args[1]; + x2 = args[2]; + y2 = args[3]; + } + + cx1 = 2*x1 - *cpx2; + cy1 = 2*y1 - *cpy2; + + cubicBez(p, x1,y1, cx1,cy1, cx2,cy2, x2,y2); + + *cpx2 = cx2; + *cpy2 = cy2; + *cpx = x2; + *cpy = y2; +} + +static void pathQuadBezTo(struct SVGParser* p, float* cpx, float* cpy, + float* cpx2, float* cpy2, float* args, int rel) +{ + float x1, y1, x2, y2, cx, cy; + + x1 = *cpx; + y1 = *cpy; + if (rel) + { + cx = *cpx + args[0]; + cy = *cpy + args[1]; + x2 = *cpx + args[2]; + y2 = *cpy + args[3]; + } + else + { + cx = args[0]; + cy = args[1]; + x2 = args[2]; + y2 = args[3]; + } + + quadBez(p, x1,y1, cx,cy, x2,y2); + + *cpx2 = cx; + *cpy2 = cy; + *cpx = x2; + *cpy = y2; +} + +static void pathQuadBezShortTo(struct SVGParser* p, float* cpx, float* cpy, + float* cpx2, float* cpy2, float* args, int rel) +{ + float x1, y1, x2, y2, cx, cy; + + x1 = *cpx; + y1 = *cpy; + if (rel) + { + x2 = *cpx + args[0]; + y2 = *cpy + args[1]; + } + else + { + x2 = args[0]; + y2 = args[1]; + } + + cx = 2*x1 - *cpx2; + cy = 2*y1 - *cpy2; + + quadBez(p, x1,y1, cx,cy, x2,y2); + + *cpx2 = cx; + *cpy2 = cy; + *cpx = x2; + *cpy = y2; +} + +static void svgParsePath(struct SVGParser* p, const char** attr) +{ + const char* s; + char cmd; + float args[10]; + int nargs; + int rargs; + float cpx, cpy, cpx2, cpy2; + const char* tmp[4]; + char closedFlag; + int i; + char item[64]; + + for (i = 0; attr[i]; i += 2) + { + if (strcmp(attr[i], "d") == 0) + { + s = attr[i + 1]; + + svgResetPath(p); + closedFlag = 0; + nargs = 0; + + while (*s) + { + s = getNextPathItem(s, item); + if (!*item) break; + + if (isnum(item[0])) + { + if (nargs < 10) + args[nargs++] = (float)atof(item); + if (nargs >= rargs) + { + switch (cmd) + { + case 'm': + case 'M': + case 'l': + case 'L': + pathLineTo(p, &cpx, &cpy, args, (cmd == 'm' || cmd == 'l') ? 1 : 0); + break; + case 'H': + case 'h': + pathHLineTo(p, &cpx, &cpy, args, cmd == 'h' ? 1 : 0); + break; + case 'V': + case 'v': + pathVLineTo(p, &cpx, &cpy, args, cmd == 'v' ? 1 : 0); + break; + case 'C': + case 'c': + pathCubicBezTo(p, &cpx, &cpy, &cpx2, &cpy2, args, cmd == 'c' ? 1 : 0); + break; + case 'S': + case 's': + pathCubicBezShortTo(p, &cpx, &cpy, &cpx2, &cpy2, args, cmd == 's' ? 1 : 0); + break; + case 'Q': + case 'q': + pathQuadBezTo(p, &cpx, &cpy, &cpx2, &cpy2, args, cmd == 'q' ? 1 : 0); + break; + case 'T': + case 't': + pathQuadBezShortTo(p, &cpx, &cpy, &cpx2, &cpy2, args, cmd == 's' ? 1 : 0); + break; + default: + if (nargs >= 2) + { + cpx = args[nargs-2]; + cpy = args[nargs-1]; + } + break; + } + nargs = 0; + } + } + else + { + cmd = item[0]; + rargs = getArgsPerElement(cmd); + if (cmd == 'M' || cmd == 'm') + { + // Commit path. + if (p->nbuf) + svgCreatePath(p, closedFlag); + // Start new subpath. + svgResetPath(p); + closedFlag = 0; + nargs = 0; + cpx = 0; cpy = 0; + } + else if (cmd == 'Z' || cmd == 'z') + { + closedFlag = 1; + // Commit path. + if (p->nbuf) + svgCreatePath(p, closedFlag); + // Start new subpath. + svgResetPath(p); + closedFlag = 0; + nargs = 0; + } + } + } + + // Commit path. + if (p->nbuf) + svgCreatePath(p, closedFlag); + + } + else + { + tmp[0] = attr[i]; + tmp[1] = attr[i + 1]; + tmp[2] = 0; + tmp[3] = 0; + svgParseAttribs(p, tmp); + } + } +} + +static void svgParseRect(struct SVGParser* p, const char** attr) +{ + float x = 0.0f; + float y = 0.0f; + float w = 0.0f; + float h = 0.0f; + int i; + + for (i = 0; attr[i]; i += 2) + { + if (!svgParseAttr(p, attr[i], attr[i + 1])) + { + if (strcmp(attr[i], "x") == 0) x = parseFloat(attr[i+1]); + if (strcmp(attr[i], "y") == 0) y = parseFloat(attr[i+1]); + if (strcmp(attr[i], "width") == 0) w = parseFloat(attr[i+1]); + if (strcmp(attr[i], "height") == 0) h = parseFloat(attr[i+1]); + } + } + + if (w != 0.0f && h != 0.0f) + { + svgResetPath(p); + + svgPathPoint(p, x, y); + svgPathPoint(p, x+w, y); + svgPathPoint(p, x+w, y+h); + svgPathPoint(p, x, y+h); + + svgCreatePath(p, 1); + } +} + +static void svgParseCircle(struct SVGParser* p, const char** attr) +{ + float cx = 0.0f; + float cy = 0.0f; + float r = 0.0f; + float da; + int i,n; + float x,y,u; + + for (i = 0; attr[i]; i += 2) + { + if (!svgParseAttr(p, attr[i], attr[i + 1])) + { + if (strcmp(attr[i], "cx") == 0) cx = parseFloat(attr[i+1]); + if (strcmp(attr[i], "cy") == 0) cy = parseFloat(attr[i+1]); + if (strcmp(attr[i], "r") == 0) r = fabsf(parseFloat(attr[i+1])); + } + } + + if (r != 0.0f) + { + svgResetPath(p); + + da = acosf(r/(r+p->tol))*2; + n = (int)ceilf(M_PI*2/da); + + da = (float)(M_PI*2)/n; + for (i = 0; i < n; ++i) + { + u = i*da; + x = cx + cosf(u)*r; + y = cy + sinf(u)*r; + svgPathPoint(p, x, y); + } + + svgCreatePath(p, 1); + } +} + +static void svgParseLine(struct SVGParser* p, const char** attr) +{ + float x1 = 0.0; + float y1 = 0.0; + float x2 = 0.0; + float y2 = 0.0; + int i; + + for (i = 0; attr[i]; i += 2) + { + if (!svgParseAttr(p, attr[i], attr[i + 1])) + { + if (strcmp(attr[i], "x1") == 0) x1 = parseFloat(attr[i + 1]); + if (strcmp(attr[i], "y1") == 0) y1 = parseFloat(attr[i + 1]); + if (strcmp(attr[i], "x2") == 0) x2 = parseFloat(attr[i + 1]); + if (strcmp(attr[i], "y2") == 0) y2 = parseFloat(attr[i + 1]); + } + } + + svgResetPath(p); + + svgPathPoint(p, x1, y1); + svgPathPoint(p, x2, y2); + + svgCreatePath(p, 0); +} + +static void svgParsePoly(struct SVGParser* p, const char** attr, int closeFlag) +{ + int i; + const char* s; + float args[2]; + int nargs; + char item[64]; + + svgResetPath(p); + + for (i = 0; attr[i]; i += 2) + { + if (!svgParseAttr(p, attr[i], attr[i + 1])) + { + if (strcmp(attr[i], "points") == 0) + { + s = attr[i + 1]; + nargs = 0; + while (*s) + { + s = getNextPathItem(s, item); + args[nargs++] = (float)atof(item); + if (nargs >= 2) + { + svgPathPoint(p, args[0], args[1]); + nargs = 0; + } + } + } + } + } + + svgCreatePath(p, closeFlag); +} + +static void svgStartElement(void* ud, const char* el, const char** attr) +{ + struct SVGParser* p = (struct SVGParser*)ud; + + // Skip everything in defs + if (p->defsFlag) + return; + + if (strcmp(el, "g") == 0) + { + svgPushAttr(p); + svgParseAttribs(p, attr); + } + else if (strcmp(el, "path") == 0) + { + if (p->pathFlag) // Do not allow nested paths. + return; + svgPushAttr(p); + svgParsePath(p, attr); + p->pathFlag = 1; + svgPopAttr(p); + } + else if (strcmp(el, "rect") == 0) + { + svgPushAttr(p); + svgParseRect(p, attr); + svgPopAttr(p); + } + else if (strcmp(el, "circle") == 0) + { + svgPushAttr(p); + svgParseCircle(p, attr); + svgPopAttr(p); + } + else if (strcmp(el, "line") == 0) + { + svgPushAttr(p); + svgParseLine(p, attr); + svgPopAttr(p); + } + else if (strcmp(el, "polyline") == 0) + { + svgPushAttr(p); + svgParsePoly(p, attr, 0); + svgPopAttr(p); + } + else if (strcmp(el, "polygon") == 0) + { + svgPushAttr(p); + svgParsePoly(p, attr, 1); + svgPopAttr(p); + } + else if (strcmp(el, "defs") == 0) + { + p->defsFlag = 1; + } +} + +static void svgEndElement(void* ud, const char* el) +{ + struct SVGParser* p = (struct SVGParser*)ud; + + if (strcmp(el, "g") == 0) + { + svgPopAttr(p); + } + else if (strcmp(el, "path") == 0) + { + p->pathFlag = 0; + } + else if (strcmp(el, "defs") == 0) + { + p->defsFlag = 0; + } +} + +static void svgContent(void* ud, const char* s) +{ + // empty +} + +struct SVGPath* svgParse(char* input) +{ + struct SVGParser* p; + struct SVGPath* ret = 0; + + p = svgCreateParser(); + if (!p) + return 0; + + p->tol = 1.0f; + + parsexml(input, svgStartElement, svgEndElement, svgContent, p); + + if (p->buf) + { + free(p->buf); + p->buf = NULL; + p->nbuf = 0; + p->cbuf = 0; + } + + ret = p->plist; + p->plist = 0; + + svgDeleteParser(p); + + return ret; +} + +struct SVGPath* svgParseFromFile(const char* filename) +{ + FILE* fp; + int size; + char* data; + struct SVGPath* plist; + + fp = fopen(filename, "rb"); + if (!fp) return 0; + fseek(fp, 0, SEEK_END); + size = ftell(fp); + fseek(fp, 0, SEEK_SET); + data = (char*)malloc(size+1); + fread(data, size, 1, fp); + data[size] = '\0'; // Must be null terminated. + fclose(fp); + plist = svgParse(data); + free(data); + return plist; +} + +void svgDelete(struct SVGPath* plist) +{ + struct SVGPath* path; + struct SVGPath* next; + if (!plist) + return; + path = plist; + while (path) + { + next = path->next; + if (path->pts) + free(path->pts); + free(path); + path = next; + } +} diff --git a/jni/jni/libtess2/Contrib/nanosvg.h b/jni/jni/libtess2/Contrib/nanosvg.h new file mode 100644 index 000000000..a6bc8578c --- /dev/null +++ b/jni/jni/libtess2/Contrib/nanosvg.h @@ -0,0 +1,66 @@ +// +// Copyright (c) 2009 Mikko Mononen memon@inside.org +// +// This software is provided 'as-is', without any express or implied +// warranty. In no event will the authors be held liable for any damages +// arising from the use of this software. +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it +// freely, subject to the following restrictions: +// 1. The origin of this software must not be misrepresented; you must not +// claim that you wrote the original software. If you use this software +// in a product, an acknowledgment in the product documentation would be +// appreciated but is not required. +// 2. Altered source versions must be plainly marked as such, and must not be +// misrepresented as being the original software. +// 3. This notice may not be removed or altered from any source distribution. +// + +// Version 1.0 - Initial version +// Version 1.1 - Fixed path parsing, implemented curves, implemented circle. + +#ifndef NANOSVG_H +#define NANOSVG_H + +#ifdef __cplusplus +extern "C" { +#endif + +/* Example Usage: + // Load + struct SVGPath* plist; + plist = svgParseFromFile("test.svg."); + // Use... + for (SVGPath* it = plist; it; it = it->next) + ... + // Delete + svgDelete(plist); +*/ + +struct SVGPath +{ + float* pts; + int npts; + unsigned int fillColor; + unsigned int strokeColor; + float strokeWidth; + char hasFill; + char hasStroke; + char closed; + struct SVGPath* next; +}; + +// Parses SVG file from a file, returns linked list of paths. +struct SVGPath* svgParseFromFile(const char* filename); + +// Parses SVG file from a null terminated string, returns linked list of paths. +struct SVGPath* svgParse(char* input); + +// Deletes list of paths. +void svgDelete(struct SVGPath* plist); + +#ifdef __cplusplus +}; +#endif + +#endif // NANOSVG_H diff --git a/jni/jni/libtess2/Example/example.c b/jni/jni/libtess2/Example/example.c new file mode 100644 index 000000000..2d4e23bf1 --- /dev/null +++ b/jni/jni/libtess2/Example/example.c @@ -0,0 +1,408 @@ + +#include +#include +#include +#include +#include +#include "nanosvg.h" +#include "tesselator.h" + + +void* stdAlloc(void* userData, unsigned int size) +{ + int* allocated = ( int*)userData; + TESS_NOTUSED(userData); + *allocated += (int)size; + return malloc(size); +} + +void stdFree(void* userData, void* ptr) +{ + TESS_NOTUSED(userData); + free(ptr); +} + +struct MemPool +{ + unsigned char* buf; + unsigned int cap; + unsigned int size; +}; + +void* poolAlloc( void* userData, unsigned int size ) +{ + struct MemPool* pool = (struct MemPool*)userData; + size = (size+0x7) & ~0x7; + if (pool->size + size < pool->cap) + { + unsigned char* ptr = pool->buf + pool->size; + pool->size += size; + return ptr; + } + printf("out of mem: %d < %d!\n", pool->size + size, pool->cap); + return 0; +} + +void poolFree( void* userData, void* ptr ) +{ + // empty + TESS_NOTUSED(userData); + TESS_NOTUSED(ptr); +} + + +// Undefine this to see non-interactive heap allocator version. +#define USE_POOL 1 + + +int run = 1; +int cdt = 0; + +static void key(GLFWwindow* window, int key, int scancode, int action, int mods) +{ + TESS_NOTUSED(scancode); + TESS_NOTUSED(mods); + if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS) + glfwSetWindowShouldClose(window, GL_TRUE); + if (key == GLFW_KEY_SPACE && action == GLFW_PRESS) + run = !run; + if (key == GLFW_KEY_C && action == GLFW_PRESS) + cdt = !cdt; +} + +int main(int argc, char *argv[]) +{ + GLFWwindow* window; + const GLFWvidmode* mode; + int width,height,i,j; + struct SVGPath* bg; + struct SVGPath* fg; + struct SVGPath* it; + float bounds[4],view[4],cx,cy,w,offx,offy; + float t = 0.0f, pt = 0.0f; + TESSalloc ma; + TESStesselator* tess = 0; + const int nvp = 3; + unsigned char* vflags = 0; +#ifdef USE_POOL + struct MemPool pool; + unsigned char mem[1024*1024]; + int nvflags = 0; +#else + int allocated = 0; + double t0 = 0, t1 = 0; +#endif + TESS_NOTUSED(argc); + TESS_NOTUSED(argv); + + if (!glfwInit()) { + printf("Failed to init GLFW."); + return -1; + } + + printf("loading...\n"); + // Load assets + bg = svgParseFromFile("../Bin/bg.svg"); + if (!bg) return -1; + fg = svgParseFromFile("../Bin/fg.svg"); + if (!fg) return -1; + + printf("go...\n"); + + // Flip y + for (it = bg; it != NULL; it = it->next) + for (i = 0; i < it->npts; ++i) + it->pts[i*2+1] = -it->pts[i*2+1]; + for (it = fg; it != NULL; it = it->next) + for (i = 0; i < it->npts; ++i) + it->pts[i*2+1] = -it->pts[i*2+1]; + + // Find FG bounds and center. + bounds[0] = bounds[2] = fg->pts[0]; + bounds[1] = bounds[3] = fg->pts[1]; + for (it = fg; it != NULL; it = it->next) + { + for (i = 0; i < it->npts; ++i) + { + const float x = it->pts[i*2]; + const float y = it->pts[i*2+1]; + if (x < bounds[0]) bounds[0] = x; + if (y < bounds[1]) bounds[1] = y; + if (x > bounds[2]) bounds[2] = x; + if (y > bounds[3]) bounds[3] = y; + } + } + cx = (bounds[0]+bounds[2])/2; + cy = (bounds[1]+bounds[3])/2; + for (it = fg; it != NULL; it = it->next) + { + for (i = 0; i < it->npts; ++i) + { + it->pts[i*2] -= cx; + it->pts[i*2+1] -= cy; + } + } + + // Find BG bounds. + bounds[0] = bounds[2] = bg->pts[0]; + bounds[1] = bounds[3] = bg->pts[1]; + for (it = bg; it != NULL; it = it->next) + { + for (i = 0; i < it->npts; ++i) + { + const float x = it->pts[i*2]; + const float y = it->pts[i*2+1]; + if (x < bounds[0]) bounds[0] = x; + if (y < bounds[1]) bounds[1] = y; + if (x > bounds[2]) bounds[2] = x; + if (y > bounds[3]) bounds[3] = y; + } + } + +#ifdef USE_POOL + + pool.size = 0; + pool.cap = sizeof(mem); + pool.buf = mem; + memset(&ma, 0, sizeof(ma)); + ma.memalloc = poolAlloc; + ma.memfree = poolFree; + ma.userData = (void*)&pool; + ma.extraVertices = 256; // realloc not provided, allow 256 extra vertices. + +#else + + t0 = glfwGetTime(); + + memset(&ma, 0, sizeof(ma)); + ma.memalloc = stdAlloc; + ma.memfree = stdFree; + ma.userData = (void*)&allocated; + ma.extraVertices = 256; // realloc not provided, allow 256 extra vertices. + + tess = tessNewTess(&ma); + if (!tess) + return -1; + + tessSetOption(tess, TESS_CONSTRAINED_DELAUNAY_TRIANGULATION, 1); + + // Offset the foreground shape to center of the bg. + offx = (bounds[2]+bounds[0])/2; + offy = (bounds[3]+bounds[1])/2; + for (it = fg; it != NULL; it = it->next) + { + for (i = 0; i < it->npts; ++i) + { + it->pts[i*2] += offx; + it->pts[i*2+1] += offy; + } + } + + // Add contours. + for (it = bg; it != NULL; it = it->next) + tessAddContour(tess, 2, it->pts, sizeof(float)*2, it->npts); + for (it = fg; it != NULL; it = it->next) + tessAddContour(tess, 2, it->pts, sizeof(float)*2, it->npts); + if (!tessTesselate(tess, TESS_WINDING_POSITIVE, TESS_POLYGONS, nvp, 2, 0)) + return -1; + + t1 = glfwGetTime(); + + printf("Time: %.3f ms\n", (t1 - t0) * 1000.0f); + printf("Memory used: %.1f kB\n", allocated/1024.0f); + +#endif + + mode = glfwGetVideoMode(glfwGetPrimaryMonitor()); + width = mode->width - 40; + height = mode->height - 80; + window = glfwCreateWindow(width, height, "Libtess2 Demo", NULL, NULL); + if (!window) { + glfwTerminate(); + return -1; + } + + glfwSetKeyCallback(window, key); + glfwMakeContextCurrent(window); + + // Adjust bounds so that we get nice view of the bg. + cx = (bounds[0]+bounds[2])/2; + cy = (bounds[3]+bounds[1])/2; + w = (bounds[2]-bounds[0])/2; + view[0] = cx - w*1.2f; + view[2] = cx + w*1.2f; + view[1] = cy - w*1.2f*(float)height/(float)width; + view[3] = cy + w*1.2f*(float)height/(float)width; + + glfwSetTime(0); + + while (!glfwWindowShouldClose(window)) + { + int winWidth, winHeight; + int fbWidth, fbHeight; + float pxr, ct; + + glfwGetWindowSize(window, &winWidth, &winHeight); + glfwGetFramebufferSize(window, &fbWidth, &fbHeight); + + // Calculate pixel ration for hi-dpi devices. + pxr = (float)fbWidth / (float)winWidth; + + ct = (float)glfwGetTime(); + if (run) t += ct - pt; + pt = ct; + + // Update and render + glViewport(0, 0, fbWidth, fbHeight); + glClearColor(0.3f, 0.3f, 0.32f, 1.0f); + glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); + glEnable(GL_BLEND); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + glDisable(GL_TEXTURE_2D); + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + glOrtho(view[0],view[2],view[1],view[3],-1,1); + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + glDisable(GL_DEPTH_TEST); + glEnable(GL_BLEND); + glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA); + +#ifdef USE_POOL + pool.size = 0; // reset pool + tess = tessNewTess(&ma); + if (tess) + { + tessSetOption(tess, TESS_CONSTRAINED_DELAUNAY_TRIANGULATION, cdt); + + offx = (view[2]+view[0])/2 + sinf(t) * (view[2]-view[0])/2; + offy = (view[3]+view[1])/2 + cosf(t*3.13f) * (view[3]-view[1])/6; + + for (it = fg; it != NULL; it = it->next) + { + for (i = 0; i < it->npts; ++i) + { + it->pts[i*2] += offx; + it->pts[i*2+1] += offy; + } + } + + for (it = bg; it != NULL; it = it->next) + tessAddContour(tess, 2, it->pts, sizeof(float)*2, it->npts); + for (it = fg; it != NULL; it = it->next) + tessAddContour(tess, 2, it->pts, sizeof(float)*2, it->npts); + + for (it = fg; it != NULL; it = it->next) + { + for (i = 0; i < it->npts; ++i) + { + it->pts[i*2] -= offx; + it->pts[i*2+1] -= offy; + } + } + + // First combine contours and then triangulate, this removes unnecessary inner vertices. + if (tessTesselate(tess, TESS_WINDING_POSITIVE, TESS_BOUNDARY_CONTOURS, 0, 0, 0)) + { + const float* verts = tessGetVertices(tess); + const int* vinds = tessGetVertexIndices(tess); + const int nverts = tessGetVertexCount(tess); + const int* elems = tessGetElements(tess); + const int nelems = tessGetElementCount(tess); + + if (nverts > nvflags) + { + if (vflags) + free(vflags); + nvflags = nverts; + vflags = (unsigned char*)malloc(sizeof(unsigned char)*nvflags); + } + + if (vflags) + { + // Vertex indices describe the order the indices were added and can be used + // to map the tesselator output to input. Vertices marked as TESS_UNDEF + // are the ones that were created at the intersection of segments. + // That is, if vflags is set it means that the vertex comes from intersegment. + for (i = 0; i < nverts; ++i) + vflags[i] = vinds[i] == TESS_UNDEF ? 1 : 0; + } + + for (i = 0; i < nelems; ++i) + { + int b = elems[i*2]; + int n = elems[i*2+1]; + tessAddContour(tess, 2, &verts[b*2], sizeof(float)*2, n); + } + if (!tessTesselate(tess, TESS_WINDING_POSITIVE, TESS_POLYGONS, nvp, 2, 0)) + tess = 0; + } + else + tess = 0; + } +#endif + + // Draw tesselated pieces. + if (tess) + { + const float* verts = tessGetVertices(tess); + const int* vinds = tessGetVertexIndices(tess); + const int* elems = tessGetElements(tess); + const int nverts = tessGetVertexCount(tess); + const int nelems = tessGetElementCount(tess); + + // Draw polygons. + glColor4ub(255,255,255,128); + for (i = 0; i < nelems; ++i) + { + const int* p = &elems[i*nvp]; + glBegin(GL_TRIANGLE_FAN); + for (j = 0; j < nvp && p[j] != TESS_UNDEF; ++j) + glVertex2f(verts[p[j]*2], verts[p[j]*2+1]); + glEnd(); + } + + glLineWidth(1.0f * pxr); + glPointSize(3.0f * pxr); + + glColor4ub(0,0,0,16); + for (i = 0; i < nelems; ++i) + { + const int* p = &elems[i*nvp]; + glBegin(GL_LINE_LOOP); + for (j = 0; j < nvp && p[j] != TESS_UNDEF; ++j) + glVertex2f(verts[p[j]*2], verts[p[j]*2+1]); + glEnd(); + } + + glColor4ub(0,0,0,128); + glBegin(GL_POINTS); + for (i = 0; i < nverts; ++i) + { + if (vflags && vflags[vinds[i]]) + glColor4ub(255,0,0,192); + else + glColor4ub(0,0,0,128); + glVertex2f(verts[i*2], verts[i*2+1]); + } + glEnd(); + + glPointSize(1.0f); + } + + glEnable(GL_DEPTH_TEST); + glfwSwapBuffers(window); + glfwPollEvents(); + } + + if (tess) tessDeleteTess(tess); + + if (vflags) + free(vflags); + + svgDelete(bg); + svgDelete(fg); + + glfwTerminate(); + return 0; +} diff --git a/jni/jni/libtess2/Include/tesselator.h b/jni/jni/libtess2/Include/tesselator.h new file mode 100755 index 000000000..3d431559a --- /dev/null +++ b/jni/jni/libtess2/Include/tesselator.h @@ -0,0 +1,242 @@ +/* +** SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008) +** Copyright (C) [dates of first publication] Silicon Graphics, Inc. +** All Rights Reserved. +** +** Permission is hereby granted, free of charge, to any person obtaining a copy +** of this software and associated documentation files (the "Software"), to deal +** in the Software without restriction, including without limitation the rights +** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +** of the Software, and to permit persons to whom the Software is furnished to do so, +** subject to the following conditions: +** +** The above copyright notice including the dates of first publication and either this +** permission notice or a reference to http://oss.sgi.com/projects/FreeB/ shall be +** included in all copies or substantial portions of the Software. +** +** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +** INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A +** PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL SILICON GRAPHICS, INC. +** BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE +** OR OTHER DEALINGS IN THE SOFTWARE. +** +** Except as contained in this notice, the name of Silicon Graphics, Inc. shall not +** be used in advertising or otherwise to promote the sale, use or other dealings in +** this Software without prior written authorization from Silicon Graphics, Inc. +*/ +/* +** Author: Mikko Mononen, July 2009. +*/ + +#ifndef TESSELATOR_H +#define TESSELATOR_H + +#ifdef __cplusplus +extern "C" { +#endif + +// See OpenGL Red Book for description of the winding rules +// http://www.glprogramming.com/red/chapter11.html +enum TessWindingRule +{ + TESS_WINDING_ODD, + TESS_WINDING_NONZERO, + TESS_WINDING_POSITIVE, + TESS_WINDING_NEGATIVE, + TESS_WINDING_ABS_GEQ_TWO, +}; + +// The contents of the tessGetElements() depends on element type being passed to tessTesselate(). +// Tesselation result element types: +// TESS_POLYGONS +// Each element in the element array is polygon defined as 'polySize' number of vertex indices. +// If a polygon has than 'polySize' vertices, the remaining indices are stored as TESS_UNDEF. +// Example, drawing a polygon: +// const int nelems = tessGetElementCount(tess); +// const TESSindex* elems = tessGetElements(tess); +// for (int i = 0; i < nelems; i++) { +// const TESSindex* poly = &elems[i * polySize]; +// glBegin(GL_POLYGON); +// for (int j = 0; j < polySize; j++) { +// if (poly[j] == TESS_UNDEF) break; +// glVertex2fv(&verts[poly[j]*vertexSize]); +// } +// glEnd(); +// } +// +// TESS_CONNECTED_POLYGONS +// Each element in the element array is polygon defined as 'polySize' number of vertex indices, +// followed by 'polySize' indices to neighour polygons, that is each element is 'polySize' * 2 indices. +// If a polygon has than 'polySize' vertices, the remaining indices are stored as TESS_UNDEF. +// If a polygon edge is a boundary, that is, not connected to another polygon, the neighbour index is TESS_UNDEF. +// Example, flood fill based on seed polygon: +// const int nelems = tessGetElementCount(tess); +// const TESSindex* elems = tessGetElements(tess); +// unsigned char* visited = (unsigned char*)calloc(nelems); +// TESSindex stack[50]; +// int nstack = 0; +// stack[nstack++] = seedPoly; +// visited[startPoly] = 1; +// while (nstack > 0) { +// TESSindex idx = stack[--nstack]; +// const TESSindex* poly = &elems[idx * polySize * 2]; +// const TESSindex* nei = &poly[polySize]; +// for (int i = 0; i < polySize; i++) { +// if (poly[i] == TESS_UNDEF) break; +// if (nei[i] != TESS_UNDEF && !visited[nei[i]]) +// stack[nstack++] = nei[i]; +// visited[nei[i]] = 1; +// } +// } +// } +// +// TESS_BOUNDARY_CONTOURS +// Each element in the element array is [base index, count] pair defining a range of vertices for a contour. +// The first value is index to first vertex in contour and the second value is number of vertices in the contour. +// Example, drawing contours: +// const int nelems = tessGetElementCount(tess); +// const TESSindex* elems = tessGetElements(tess); +// for (int i = 0; i < nelems; i++) { +// const TESSindex base = elems[i * 2]; +// const TESSindex count = elems[i * 2 + 1]; +// glBegin(GL_LINE_LOOP); +// for (int j = 0; j < count; j++) { +// glVertex2fv(&verts[(base+j) * vertexSize]); +// } +// glEnd(); +// } + +enum TessElementType +{ + TESS_POLYGONS, + TESS_CONNECTED_POLYGONS, + TESS_BOUNDARY_CONTOURS, +}; + + +// TESS_CONSTRAINED_DELAUNAY_TRIANGULATION +// If enabled, the initial triagulation is improved with non-robust Constrained Delayney triangulation. +// Disable by default. +// +// TESS_REVERSE_CONTOURS +// If enabled, tessAddContour() will treat CW contours as CCW and vice versa +// Disabled by default. + +enum TessOption +{ + TESS_CONSTRAINED_DELAUNAY_TRIANGULATION, + TESS_REVERSE_CONTOURS +}; + +typedef float TESSreal; +typedef int TESSindex; +typedef struct TESStesselator TESStesselator; +typedef struct TESSalloc TESSalloc; + +#define TESS_UNDEF (~(TESSindex)0) + +#define TESS_NOTUSED(v) do { (void)(1 ? (void)0 : ( (void)(v) ) ); } while(0) + +// Custom memory allocator interface. +// The internal memory allocator allocates mesh edges, vertices and faces +// as well as dictionary nodes and active regions in buckets and uses simple +// freelist to speed up the allocation. The bucket size should roughly match your +// expected input data. For example if you process only hundreds of vertices, +// a bucket size of 128 might be ok, where as when processing thousands of vertices +// bucket size of 1024 might be approproate. The bucket size is a compromise between +// how often to allocate memory from the system versus how much extra space the system +// should allocate. Reasonable defaults are show in commects below, they will be used if +// the bucket sizes are zero. +// +// The use may left the memrealloc to be null. In that case, the tesselator will not try to +// dynamically grow int's internal arrays. The tesselator only needs the reallocation when it +// has found intersecting segments and needs to add new vertex. This defency can be cured by +// allocating some extra vertices beforehand. The 'extraVertices' variable allows to specify +// number of expected extra vertices. +struct TESSalloc +{ + void *(*memalloc)( void *userData, unsigned int size ); + void *(*memrealloc)( void *userData, void* ptr, unsigned int size ); + void (*memfree)( void *userData, void *ptr ); + void* userData; // User data passed to the allocator functions. + int meshEdgeBucketSize; // 512 + int meshVertexBucketSize; // 512 + int meshFaceBucketSize; // 256 + int dictNodeBucketSize; // 512 + int regionBucketSize; // 256 + int extraVertices; // Number of extra vertices allocated for the priority queue. +}; + + +// +// Example use: +// +// +// +// + +// tessNewTess() - Creates a new tesselator. +// Use tessDeleteTess() to delete the tesselator. +// Parameters: +// alloc - pointer to a filled TESSalloc struct or NULL to use default malloc based allocator. +// Returns: +// new tesselator object. +TESStesselator* tessNewTess( TESSalloc* alloc ); + +// tessDeleteTess() - Deletes a tesselator. +// Parameters: +// tess - pointer to tesselator object to be deleted. +void tessDeleteTess( TESStesselator *tess ); + +// tessAddContour() - Adds a contour to be tesselated. +// The type of the vertex coordinates is assumed to be TESSreal. +// Parameters: +// tess - pointer to tesselator object. +// size - number of coordinates per vertex. Must be 2 or 3. +// pointer - pointer to the first coordinate of the first vertex in the array. +// stride - defines offset in bytes between consecutive vertices. +// count - number of vertices in contour. +void tessAddContour( TESStesselator *tess, int size, const void* pointer, int stride, int count ); + +// tessSetOption() - Toggles optional tessellation parameters +// Parameters: +// option - one of TessOption +// value - 1 if enabled, 0 if disabled. +void tessSetOption( TESStesselator *tess, int option, int value ); + +// tessTesselate() - tesselate contours. +// Parameters: +// tess - pointer to tesselator object. +// windingRule - winding rules used for tesselation, must be one of TessWindingRule. +// elementType - defines the tesselation result element type, must be one of TessElementType. +// polySize - defines maximum vertices per polygons if output is polygons. +// vertexSize - defines the number of coordinates in tesselation result vertex, must be 2 or 3. +// normal - defines the normal of the input contours, of null the normal is calculated automatically. +// Returns: +// 1 if succeed, 0 if failed. +int tessTesselate( TESStesselator *tess, int windingRule, int elementType, int polySize, int vertexSize, const TESSreal* normal ); + +// tessGetVertexCount() - Returns number of vertices in the tesselated output. +int tessGetVertexCount( TESStesselator *tess ); + +// tessGetVertices() - Returns pointer to first coordinate of first vertex. +const TESSreal* tessGetVertices( TESStesselator *tess ); + +// tessGetVertexIndices() - Returns pointer to first vertex index. +// Vertex indices can be used to map the generated vertices to the original vertices. +// Every point added using tessAddContour() will get a new index starting at 0. +// New vertices generated at the intersections of segments are assigned value TESS_UNDEF. +const TESSindex* tessGetVertexIndices( TESStesselator *tess ); + +// tessGetElementCount() - Returns number of elements in the the tesselated output. +int tessGetElementCount( TESStesselator *tess ); + +// tessGetElements() - Returns pointer to the first element. +const TESSindex* tessGetElements( TESStesselator *tess ); + +#ifdef __cplusplus +}; +#endif + +#endif // TESSELATOR_H diff --git a/jni/jni/libtess2/LICENSE.txt b/jni/jni/libtess2/LICENSE.txt new file mode 100644 index 000000000..619c7a229 --- /dev/null +++ b/jni/jni/libtess2/LICENSE.txt @@ -0,0 +1,25 @@ +** SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008) +** Copyright (C) [dates of first publication] Silicon Graphics, Inc. +** All Rights Reserved. +** +** Permission is hereby granted, free of charge, to any person obtaining a copy +** of this software and associated documentation files (the "Software"), to deal +** in the Software without restriction, including without limitation the rights +** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +** of the Software, and to permit persons to whom the Software is furnished to do so, +** subject to the following conditions: +** +** The above copyright notice including the dates of first publication and either this +** permission notice or a reference to http://oss.sgi.com/projects/FreeB/ shall be +** included in all copies or substantial portions of the Software. +** +** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +** INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A +** PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL SILICON GRAPHICS, INC. +** BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE +** OR OTHER DEALINGS IN THE SOFTWARE. +** +** Except as contained in this notice, the name of Silicon Graphics, Inc. shall not +** be used in advertising or otherwise to promote the sale, use or other dealings in +** this Software without prior written authorization from Silicon Graphics, Inc. diff --git a/jni/jni/libtess2/README.md b/jni/jni/libtess2/README.md new file mode 100644 index 000000000..3f22301ed --- /dev/null +++ b/jni/jni/libtess2/README.md @@ -0,0 +1,22 @@ +*This project is not actively maintained.* + + +Libtess2 +======== +Version 1.0.2 + + +This is refactored version of the original libtess which comes with the GLU reference implementation. The code is good quality polygon tesselator and triangulator. The original code comes with rather horrible interface and its' performance suffers from lots of small memory allocations. The main point of the refactoring has been the interface and memory allocation scheme. + +A lot of the GLU tesselator documentation applies to Libtess2 too (apart from the API), check out http://www.glprogramming.com/red/chapter11.html + +Simple bucketed memory allocator (see Graphics Gems III for reference) was added which speeds up the code by order of magnitude (tests showed 15 to 50 times improvement depending on data). The API allows the user to pass his own allocator to the library. It is possible to configure the library so that the library runs on predefined chunk of memory. + +The API was changed to loosely resemble the OpenGL vertex array API. The processed data can be accessed via getter functions. The code is able to output contours, polygons and connected polygons. The output of the tesselator can be also used as input for new run. I.e. the user may first want to calculate an union all the input contours and the triangulate them. + +The code is released under SGI FREE SOFTWARE LICENSE B Version 2.0. +https://directory.fsf.org/wiki/License:SGIFreeBv2 + + +Mikko Mononen +memon@inside.org diff --git a/jni/jni/libtess2/Source/bucketalloc.c b/jni/jni/libtess2/Source/bucketalloc.c new file mode 100755 index 000000000..420ebab5e --- /dev/null +++ b/jni/jni/libtess2/Source/bucketalloc.c @@ -0,0 +1,191 @@ +/* +** SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008) +** Copyright (C) [dates of first publication] Silicon Graphics, Inc. +** All Rights Reserved. +** +** Permission is hereby granted, free of charge, to any person obtaining a copy +** of this software and associated documentation files (the "Software"), to deal +** in the Software without restriction, including without limitation the rights +** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +** of the Software, and to permit persons to whom the Software is furnished to do so, +** subject to the following conditions: +** +** The above copyright notice including the dates of first publication and either this +** permission notice or a reference to http://oss.sgi.com/projects/FreeB/ shall be +** included in all copies or substantial portions of the Software. +** +** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +** INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A +** PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL SILICON GRAPHICS, INC. +** BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE +** OR OTHER DEALINGS IN THE SOFTWARE. +** +** Except as contained in this notice, the name of Silicon Graphics, Inc. shall not +** be used in advertising or otherwise to promote the sale, use or other dealings in +** this Software without prior written authorization from Silicon Graphics, Inc. +*/ +/* +** Author: Mikko Mononen, July 2009. +*/ + +#include +#include +#include "../Include/tesselator.h" + +//#define CHECK_BOUNDS + +typedef struct BucketAlloc BucketAlloc; +typedef struct Bucket Bucket; + +struct Bucket +{ + Bucket *next; +}; + +struct BucketAlloc +{ + void *freelist; + Bucket *buckets; + unsigned int itemSize; + unsigned int bucketSize; + const char *name; + TESSalloc* alloc; +}; + +static int CreateBucket( struct BucketAlloc* ba ) +{ + size_t size; + Bucket* bucket; + void* freelist; + unsigned char* head; + unsigned char* it; + + // Allocate memory for the bucket + size = sizeof(Bucket) + ba->itemSize * ba->bucketSize; + bucket = (Bucket*)ba->alloc->memalloc( ba->alloc->userData, size ); + if ( !bucket ) + return 0; + bucket->next = 0; + + // Add the bucket into the list of buckets. + bucket->next = ba->buckets; + ba->buckets = bucket; + + // Add new items to the free list. + freelist = ba->freelist; + head = (unsigned char*)bucket + sizeof(Bucket); + it = head + ba->itemSize * ba->bucketSize; + do + { + it -= ba->itemSize; + // Store pointer to next free item. + *((void**)it) = freelist; + // Pointer to next location containing a free item. + freelist = (void*)it; + } + while ( it != head ); + // Update pointer to next location containing a free item. + ba->freelist = (void*)it; + + return 1; +} + +static void *NextFreeItem( struct BucketAlloc *ba ) +{ + return *(void**)ba->freelist; +} + +struct BucketAlloc* createBucketAlloc( TESSalloc* alloc, const char* name, + unsigned int itemSize, unsigned int bucketSize ) +{ + BucketAlloc* ba = (BucketAlloc*)alloc->memalloc( alloc->userData, sizeof(BucketAlloc) ); + + ba->alloc = alloc; + ba->name = name; + ba->itemSize = itemSize; + if ( ba->itemSize < sizeof(void*) ) + ba->itemSize = sizeof(void*); + ba->bucketSize = bucketSize; + ba->freelist = 0; + ba->buckets = 0; + + if ( !CreateBucket( ba ) ) + { + alloc->memfree( alloc->userData, ba ); + return 0; + } + + return ba; +} + +void* bucketAlloc( struct BucketAlloc *ba ) +{ + void *it; + + // If running out of memory, allocate new bucket and update the freelist. + if ( !ba->freelist || !NextFreeItem( ba ) ) + { + if ( !CreateBucket( ba ) ) + return 0; + } + + // Pop item from in front of the free list. + it = ba->freelist; + ba->freelist = NextFreeItem( ba ); + + return it; +} + +void bucketFree( struct BucketAlloc *ba, void *ptr ) +{ +#ifdef CHECK_BOUNDS + int inBounds = 0; + Bucket *bucket; + + // Check that the pointer is allocated with this allocator. + bucket = ba->buckets; + while ( bucket ) + { + void *bucketMin = (void*)((unsigned char*)bucket + sizeof(Bucket)); + void *bucketMax = (void*)((unsigned char*)bucket + sizeof(Bucket) + ba->itemSize * ba->bucketSize); + if ( ptr >= bucketMin && ptr < bucketMax ) + { + inBounds = 1; + break; + } + bucket = bucket->next; + } + + if ( inBounds ) + { + // Add the node in front of the free list. + *(void**)ptr = ba->freelist; + ba->freelist = ptr; + } + else + { + printf("ERROR! pointer 0x%p does not belong to allocator '%s'\n", ba->name); + } +#else + // Add the node in front of the free list. + *(void**)ptr = ba->freelist; + ba->freelist = ptr; +#endif +} + +void deleteBucketAlloc( struct BucketAlloc *ba ) +{ + TESSalloc* alloc = ba->alloc; + Bucket *bucket = ba->buckets; + Bucket *next; + while ( bucket ) + { + next = bucket->next; + alloc->memfree( alloc->userData, bucket ); + bucket = next; + } + ba->freelist = 0; + ba->buckets = 0; + alloc->memfree( alloc->userData, ba ); +} diff --git a/jni/jni/libtess2/Source/bucketalloc.h b/jni/jni/libtess2/Source/bucketalloc.h new file mode 100755 index 000000000..c540951ea --- /dev/null +++ b/jni/jni/libtess2/Source/bucketalloc.h @@ -0,0 +1,51 @@ +/* +** SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008) +** Copyright (C) [dates of first publication] Silicon Graphics, Inc. +** All Rights Reserved. +** +** Permission is hereby granted, free of charge, to any person obtaining a copy +** of this software and associated documentation files (the "Software"), to deal +** in the Software without restriction, including without limitation the rights +** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +** of the Software, and to permit persons to whom the Software is furnished to do so, +** subject to the following conditions: +** +** The above copyright notice including the dates of first publication and either this +** permission notice or a reference to http://oss.sgi.com/projects/FreeB/ shall be +** included in all copies or substantial portions of the Software. +** +** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +** INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A +** PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL SILICON GRAPHICS, INC. +** BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE +** OR OTHER DEALINGS IN THE SOFTWARE. +** +** Except as contained in this notice, the name of Silicon Graphics, Inc. shall not +** be used in advertising or otherwise to promote the sale, use or other dealings in +** this Software without prior written authorization from Silicon Graphics, Inc. +*/ +/* +** Author: Mikko Mononen, July 2009. +*/ + +#ifndef MEMALLOC_H +#define MEMALLOC_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "tesselator.h" + +struct BucketAlloc *createBucketAlloc( TESSalloc* alloc, const char *name, + unsigned int itemSize, unsigned int bucketSize ); +void *bucketAlloc( struct BucketAlloc *ba); +void bucketFree( struct BucketAlloc *ba, void *ptr ); +void deleteBucketAlloc( struct BucketAlloc *ba ); + +#ifdef __cplusplus +}; +#endif + +#endif diff --git a/jni/jni/libtess2/Source/dict.c b/jni/jni/libtess2/Source/dict.c new file mode 100755 index 000000000..650adda21 --- /dev/null +++ b/jni/jni/libtess2/Source/dict.c @@ -0,0 +1,109 @@ +/* +** SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008) +** Copyright (C) [dates of first publication] Silicon Graphics, Inc. +** All Rights Reserved. +** +** Permission is hereby granted, free of charge, to any person obtaining a copy +** of this software and associated documentation files (the "Software"), to deal +** in the Software without restriction, including without limitation the rights +** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +** of the Software, and to permit persons to whom the Software is furnished to do so, +** subject to the following conditions: +** +** The above copyright notice including the dates of first publication and either this +** permission notice or a reference to http://oss.sgi.com/projects/FreeB/ shall be +** included in all copies or substantial portions of the Software. +** +** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +** INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A +** PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL SILICON GRAPHICS, INC. +** BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE +** OR OTHER DEALINGS IN THE SOFTWARE. +** +** Except as contained in this notice, the name of Silicon Graphics, Inc. shall not +** be used in advertising or otherwise to promote the sale, use or other dealings in +** this Software without prior written authorization from Silicon Graphics, Inc. +*/ +/* +** Author: Eric Veach, July 1994. +*/ + +#include +#include "../Include/tesselator.h" +#include "bucketalloc.h" +#include "dict.h" + +/* really tessDictListNewDict */ +Dict *dictNewDict( TESSalloc* alloc, void *frame, int (*leq)(void *frame, DictKey key1, DictKey key2) ) +{ + Dict *dict = (Dict *)alloc->memalloc( alloc->userData, sizeof( Dict )); + DictNode *head; + + if (dict == NULL) return NULL; + + head = &dict->head; + + head->key = NULL; + head->next = head; + head->prev = head; + + dict->frame = frame; + dict->leq = leq; + + if (alloc->dictNodeBucketSize < 16) + alloc->dictNodeBucketSize = 16; + if (alloc->dictNodeBucketSize > 4096) + alloc->dictNodeBucketSize = 4096; + dict->nodePool = createBucketAlloc( alloc, "Dict", sizeof(DictNode), alloc->dictNodeBucketSize ); + + return dict; +} + +/* really tessDictListDeleteDict */ +void dictDeleteDict( TESSalloc* alloc, Dict *dict ) +{ + deleteBucketAlloc( dict->nodePool ); + alloc->memfree( alloc->userData, dict ); +} + +/* really tessDictListInsertBefore */ +DictNode *dictInsertBefore( Dict *dict, DictNode *node, DictKey key ) +{ + DictNode *newNode; + + do { + node = node->prev; + } while( node->key != NULL && ! (*dict->leq)(dict->frame, node->key, key)); + + newNode = (DictNode *)bucketAlloc( dict->nodePool ); + if (newNode == NULL) return NULL; + + newNode->key = key; + newNode->next = node->next; + node->next->prev = newNode; + newNode->prev = node; + node->next = newNode; + + return newNode; +} + +/* really tessDictListDelete */ +void dictDelete( Dict *dict, DictNode *node ) /*ARGSUSED*/ +{ + node->next->prev = node->prev; + node->prev->next = node->next; + bucketFree( dict->nodePool, node ); +} + +/* really tessDictListSearch */ +DictNode *dictSearch( Dict *dict, DictKey key ) +{ + DictNode *node = &dict->head; + + do { + node = node->next; + } while( node->key != NULL && ! (*dict->leq)(dict->frame, key, node->key)); + + return node; +} diff --git a/jni/jni/libtess2/Source/dict.h b/jni/jni/libtess2/Source/dict.h new file mode 100755 index 000000000..4cf322657 --- /dev/null +++ b/jni/jni/libtess2/Source/dict.h @@ -0,0 +1,74 @@ +/* +** SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008) +** Copyright (C) [dates of first publication] Silicon Graphics, Inc. +** All Rights Reserved. +** +** Permission is hereby granted, free of charge, to any person obtaining a copy +** of this software and associated documentation files (the "Software"), to deal +** in the Software without restriction, including without limitation the rights +** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +** of the Software, and to permit persons to whom the Software is furnished to do so, +** subject to the following conditions: +** +** The above copyright notice including the dates of first publication and either this +** permission notice or a reference to http://oss.sgi.com/projects/FreeB/ shall be +** included in all copies or substantial portions of the Software. +** +** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +** INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A +** PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL SILICON GRAPHICS, INC. +** BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE +** OR OTHER DEALINGS IN THE SOFTWARE. +** +** Except as contained in this notice, the name of Silicon Graphics, Inc. shall not +** be used in advertising or otherwise to promote the sale, use or other dealings in +** this Software without prior written authorization from Silicon Graphics, Inc. +*/ +/* +** Author: Eric Veach, July 1994. +*/ + +#ifndef DICT_LIST_H +#define DICT_LIST_H + +typedef void *DictKey; +typedef struct Dict Dict; +typedef struct DictNode DictNode; + +Dict *dictNewDict( TESSalloc* alloc, void *frame, int (*leq)(void *frame, DictKey key1, DictKey key2) ); + +void dictDeleteDict( TESSalloc* alloc, Dict *dict ); + +/* Search returns the node with the smallest key greater than or equal +* to the given key. If there is no such key, returns a node whose +* key is NULL. Similarly, Succ(Max(d)) has a NULL key, etc. +*/ +DictNode *dictSearch( Dict *dict, DictKey key ); +DictNode *dictInsertBefore( Dict *dict, DictNode *node, DictKey key ); +void dictDelete( Dict *dict, DictNode *node ); + +#define dictKey(n) ((n)->key) +#define dictSucc(n) ((n)->next) +#define dictPred(n) ((n)->prev) +#define dictMin(d) ((d)->head.next) +#define dictMax(d) ((d)->head.prev) +#define dictInsert(d,k) (dictInsertBefore((d),&(d)->head,(k))) + + +/*** Private data structures ***/ + +struct DictNode { + DictKey key; + DictNode *next; + DictNode *prev; +}; + +struct Dict { + DictNode head; + void *frame; + struct BucketAlloc *nodePool; + int (*leq)(void *frame, DictKey key1, DictKey key2); +}; + +#endif diff --git a/jni/jni/libtess2/Source/geom.c b/jni/jni/libtess2/Source/geom.c new file mode 100755 index 000000000..ce232cfcb --- /dev/null +++ b/jni/jni/libtess2/Source/geom.c @@ -0,0 +1,293 @@ +/* +** SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008) +** Copyright (C) [dates of first publication] Silicon Graphics, Inc. +** All Rights Reserved. +** +** Permission is hereby granted, free of charge, to any person obtaining a copy +** of this software and associated documentation files (the "Software"), to deal +** in the Software without restriction, including without limitation the rights +** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +** of the Software, and to permit persons to whom the Software is furnished to do so, +** subject to the following conditions: +** +** The above copyright notice including the dates of first publication and either this +** permission notice or a reference to http://oss.sgi.com/projects/FreeB/ shall be +** included in all copies or substantial portions of the Software. +** +** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +** INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A +** PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL SILICON GRAPHICS, INC. +** BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE +** OR OTHER DEALINGS IN THE SOFTWARE. +** +** Except as contained in this notice, the name of Silicon Graphics, Inc. shall not +** be used in advertising or otherwise to promote the sale, use or other dealings in +** this Software without prior written authorization from Silicon Graphics, Inc. +*/ +/* +** Author: Eric Veach, July 1994. +*/ + +//#include "tesos.h" +#include +#include "mesh.h" +#include "geom.h" +#include + +int tesvertLeq( TESSvertex *u, TESSvertex *v ) +{ + /* Returns TRUE if u is lexicographically <= v. */ + + return VertLeq( u, v ); +} + +TESSreal tesedgeEval( TESSvertex *u, TESSvertex *v, TESSvertex *w ) +{ + /* Given three vertices u,v,w such that VertLeq(u,v) && VertLeq(v,w), + * evaluates the t-coord of the edge uw at the s-coord of the vertex v. + * Returns v->t - (uw)(v->s), ie. the signed distance from uw to v. + * If uw is vertical (and thus passes thru v), the result is zero. + * + * The calculation is extremely accurate and stable, even when v + * is very close to u or w. In particular if we set v->t = 0 and + * let r be the negated result (this evaluates (uw)(v->s)), then + * r is guaranteed to satisfy MIN(u->t,w->t) <= r <= MAX(u->t,w->t). + */ + TESSreal gapL, gapR; + + assert( VertLeq( u, v ) && VertLeq( v, w )); + + gapL = v->s - u->s; + gapR = w->s - v->s; + + if( gapL + gapR > 0 ) { + if( gapL < gapR ) { + return (v->t - u->t) + (u->t - w->t) * (gapL / (gapL + gapR)); + } else { + return (v->t - w->t) + (w->t - u->t) * (gapR / (gapL + gapR)); + } + } + /* vertical line */ + return 0; +} + +TESSreal tesedgeSign( TESSvertex *u, TESSvertex *v, TESSvertex *w ) +{ + /* Returns a number whose sign matches EdgeEval(u,v,w) but which + * is cheaper to evaluate. Returns > 0, == 0 , or < 0 + * as v is above, on, or below the edge uw. + */ + TESSreal gapL, gapR; + + assert( VertLeq( u, v ) && VertLeq( v, w )); + + gapL = v->s - u->s; + gapR = w->s - v->s; + + if( gapL + gapR > 0 ) { + return (v->t - w->t) * gapL + (v->t - u->t) * gapR; + } + /* vertical line */ + return 0; +} + + +/*********************************************************************** +* Define versions of EdgeSign, EdgeEval with s and t transposed. +*/ + +TESSreal testransEval( TESSvertex *u, TESSvertex *v, TESSvertex *w ) +{ + /* Given three vertices u,v,w such that TransLeq(u,v) && TransLeq(v,w), + * evaluates the t-coord of the edge uw at the s-coord of the vertex v. + * Returns v->s - (uw)(v->t), ie. the signed distance from uw to v. + * If uw is vertical (and thus passes thru v), the result is zero. + * + * The calculation is extremely accurate and stable, even when v + * is very close to u or w. In particular if we set v->s = 0 and + * let r be the negated result (this evaluates (uw)(v->t)), then + * r is guaranteed to satisfy MIN(u->s,w->s) <= r <= MAX(u->s,w->s). + */ + TESSreal gapL, gapR; + + assert( TransLeq( u, v ) && TransLeq( v, w )); + + gapL = v->t - u->t; + gapR = w->t - v->t; + + if( gapL + gapR > 0 ) { + if( gapL < gapR ) { + return (v->s - u->s) + (u->s - w->s) * (gapL / (gapL + gapR)); + } else { + return (v->s - w->s) + (w->s - u->s) * (gapR / (gapL + gapR)); + } + } + /* vertical line */ + return 0; +} + +TESSreal testransSign( TESSvertex *u, TESSvertex *v, TESSvertex *w ) +{ + /* Returns a number whose sign matches TransEval(u,v,w) but which + * is cheaper to evaluate. Returns > 0, == 0 , or < 0 + * as v is above, on, or below the edge uw. + */ + TESSreal gapL, gapR; + + assert( TransLeq( u, v ) && TransLeq( v, w )); + + gapL = v->t - u->t; + gapR = w->t - v->t; + + if( gapL + gapR > 0 ) { + return (v->s - w->s) * gapL + (v->s - u->s) * gapR; + } + /* vertical line */ + return 0; +} + + +int tesvertCCW( TESSvertex *u, TESSvertex *v, TESSvertex *w ) +{ + /* For almost-degenerate situations, the results are not reliable. + * Unless the floating-point arithmetic can be performed without + * rounding errors, *any* implementation will give incorrect results + * on some degenerate inputs, so the client must have some way to + * handle this situation. + */ + return (u->s*(v->t - w->t) + v->s*(w->t - u->t) + w->s*(u->t - v->t)) >= 0; +} + +/* Given parameters a,x,b,y returns the value (b*x+a*y)/(a+b), +* or (x+y)/2 if a==b==0. It requires that a,b >= 0, and enforces +* this in the rare case that one argument is slightly negative. +* The implementation is extremely stable numerically. +* In particular it guarantees that the result r satisfies +* MIN(x,y) <= r <= MAX(x,y), and the results are very accurate +* even when a and b differ greatly in magnitude. +*/ +#define RealInterpolate(a,x,b,y) \ + (a = (a < 0) ? 0 : a, b = (b < 0) ? 0 : b, \ + ((a <= b) ? ((b == 0) ? ((x+y) / 2) \ + : (x + (y-x) * (a/(a+b)))) \ + : (y + (x-y) * (b/(a+b))))) + +#ifndef FOR_TRITE_TEST_PROGRAM +#define Interpolate(a,x,b,y) RealInterpolate(a,x,b,y) +#else + +/* Claim: the ONLY property the sweep algorithm relies on is that +* MIN(x,y) <= r <= MAX(x,y). This is a nasty way to test that. +*/ +#include +extern int RandomInterpolate; + +double Interpolate( double a, double x, double b, double y) +{ + printf("*********************%d\n",RandomInterpolate); + if( RandomInterpolate ) { + a = 1.2 * drand48() - 0.1; + a = (a < 0) ? 0 : ((a > 1) ? 1 : a); + b = 1.0 - a; + } + return RealInterpolate(a,x,b,y); +} + +#endif + +#define Swap(a,b) if (1) { TESSvertex *t = a; a = b; b = t; } else + +void tesedgeIntersect( TESSvertex *o1, TESSvertex *d1, + TESSvertex *o2, TESSvertex *d2, + TESSvertex *v ) + /* Given edges (o1,d1) and (o2,d2), compute their point of intersection. + * The computed point is guaranteed to lie in the intersection of the + * bounding rectangles defined by each edge. + */ +{ + TESSreal z1, z2; + + /* This is certainly not the most efficient way to find the intersection + * of two line segments, but it is very numerically stable. + * + * Strategy: find the two middle vertices in the VertLeq ordering, + * and interpolate the intersection s-value from these. Then repeat + * using the TransLeq ordering to find the intersection t-value. + */ + + if( ! VertLeq( o1, d1 )) { Swap( o1, d1 ); } + if( ! VertLeq( o2, d2 )) { Swap( o2, d2 ); } + if( ! VertLeq( o1, o2 )) { Swap( o1, o2 ); Swap( d1, d2 ); } + + if( ! VertLeq( o2, d1 )) { + /* Technically, no intersection -- do our best */ + v->s = (o2->s + d1->s) / 2; + } else if( VertLeq( d1, d2 )) { + /* Interpolate between o2 and d1 */ + z1 = EdgeEval( o1, o2, d1 ); + z2 = EdgeEval( o2, d1, d2 ); + if( z1+z2 < 0 ) { z1 = -z1; z2 = -z2; } + v->s = Interpolate( z1, o2->s, z2, d1->s ); + } else { + /* Interpolate between o2 and d2 */ + z1 = EdgeSign( o1, o2, d1 ); + z2 = -EdgeSign( o1, d2, d1 ); + if( z1+z2 < 0 ) { z1 = -z1; z2 = -z2; } + v->s = Interpolate( z1, o2->s, z2, d2->s ); + } + + /* Now repeat the process for t */ + + if( ! TransLeq( o1, d1 )) { Swap( o1, d1 ); } + if( ! TransLeq( o2, d2 )) { Swap( o2, d2 ); } + if( ! TransLeq( o1, o2 )) { Swap( o1, o2 ); Swap( d1, d2 ); } + + if( ! TransLeq( o2, d1 )) { + /* Technically, no intersection -- do our best */ + v->t = (o2->t + d1->t) / 2; + } else if( TransLeq( d1, d2 )) { + /* Interpolate between o2 and d1 */ + z1 = TransEval( o1, o2, d1 ); + z2 = TransEval( o2, d1, d2 ); + if( z1+z2 < 0 ) { z1 = -z1; z2 = -z2; } + v->t = Interpolate( z1, o2->t, z2, d1->t ); + } else { + /* Interpolate between o2 and d2 */ + z1 = TransSign( o1, o2, d1 ); + z2 = -TransSign( o1, d2, d1 ); + if( z1+z2 < 0 ) { z1 = -z1; z2 = -z2; } + v->t = Interpolate( z1, o2->t, z2, d2->t ); + } +} + +TESSreal inCircle( TESSvertex *v, TESSvertex *v0, TESSvertex *v1, TESSvertex *v2 ) { + TESSreal adx, ady, bdx, bdy, cdx, cdy; + TESSreal abdet, bcdet, cadet; + TESSreal alift, blift, clift; + + adx = v0->s - v->s; + ady = v0->t - v->t; + bdx = v1->s - v->s; + bdy = v1->t - v->t; + cdx = v2->s - v->s; + cdy = v2->t - v->t; + + abdet = adx * bdy - bdx * ady; + bcdet = bdx * cdy - cdx * bdy; + cadet = cdx * ady - adx * cdy; + + alift = adx * adx + ady * ady; + blift = bdx * bdx + bdy * bdy; + clift = cdx * cdx + cdy * cdy; + + return alift * bcdet + blift * cadet + clift * abdet; +} + +/* + Returns 1 is edge is locally delaunay + */ +int tesedgeIsLocallyDelaunay( TESShalfEdge *e ) +{ + return inCircle(e->Sym->Lnext->Lnext->Org, e->Lnext->Org, e->Lnext->Lnext->Org, e->Org) < 0; +} diff --git a/jni/jni/libtess2/Source/geom.h b/jni/jni/libtess2/Source/geom.h new file mode 100755 index 000000000..1b93fd643 --- /dev/null +++ b/jni/jni/libtess2/Source/geom.h @@ -0,0 +1,78 @@ +/* +** SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008) +** Copyright (C) [dates of first publication] Silicon Graphics, Inc. +** All Rights Reserved. +** +** Permission is hereby granted, free of charge, to any person obtaining a copy +** of this software and associated documentation files (the "Software"), to deal +** in the Software without restriction, including without limitation the rights +** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +** of the Software, and to permit persons to whom the Software is furnished to do so, +** subject to the following conditions: +** +** The above copyright notice including the dates of first publication and either this +** permission notice or a reference to http://oss.sgi.com/projects/FreeB/ shall be +** included in all copies or substantial portions of the Software. +** +** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +** INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A +** PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL SILICON GRAPHICS, INC. +** BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE +** OR OTHER DEALINGS IN THE SOFTWARE. +** +** Except as contained in this notice, the name of Silicon Graphics, Inc. shall not +** be used in advertising or otherwise to promote the sale, use or other dealings in +** this Software without prior written authorization from Silicon Graphics, Inc. +*/ +/* +** Author: Eric Veach, July 1994. +*/ + +#ifndef GEOM_H +#define GEOM_H + +#include "mesh.h" + +#ifdef NO_BRANCH_CONDITIONS +/* MIPS architecture has special instructions to evaluate boolean +* conditions -- more efficient than branching, IF you can get the +* compiler to generate the right instructions (SGI compiler doesn't) +*/ +#define VertEq(u,v) (((u)->s == (v)->s) & ((u)->t == (v)->t)) +#define VertLeq(u,v) (((u)->s < (v)->s) | \ + ((u)->s == (v)->s & (u)->t <= (v)->t)) +#else +#define VertEq(u,v) ((u)->s == (v)->s && (u)->t == (v)->t) +#define VertLeq(u,v) (((u)->s < (v)->s) || ((u)->s == (v)->s && (u)->t <= (v)->t)) +#endif + +#define EdgeEval(u,v,w) tesedgeEval(u,v,w) +#define EdgeSign(u,v,w) tesedgeSign(u,v,w) + +/* Versions of VertLeq, EdgeSign, EdgeEval with s and t transposed. */ + +#define TransLeq(u,v) (((u)->t < (v)->t) || ((u)->t == (v)->t && (u)->s <= (v)->s)) +#define TransEval(u,v,w) testransEval(u,v,w) +#define TransSign(u,v,w) testransSign(u,v,w) + + +#define EdgeGoesLeft(e) VertLeq( (e)->Dst, (e)->Org ) +#define EdgeGoesRight(e) VertLeq( (e)->Org, (e)->Dst ) +#define EdgeIsInternal(e) e->Rface && e->Rface->inside + +#define ABS(x) ((x) < 0 ? -(x) : (x)) +#define VertL1dist(u,v) (ABS(u->s - v->s) + ABS(u->t - v->t)) + +#define VertCCW(u,v,w) tesvertCCW(u,v,w) + +int tesvertLeq( TESSvertex *u, TESSvertex *v ); +TESSreal tesedgeEval( TESSvertex *u, TESSvertex *v, TESSvertex *w ); +TESSreal tesedgeSign( TESSvertex *u, TESSvertex *v, TESSvertex *w ); +TESSreal testransEval( TESSvertex *u, TESSvertex *v, TESSvertex *w ); +TESSreal testransSign( TESSvertex *u, TESSvertex *v, TESSvertex *w ); +int tesvertCCW( TESSvertex *u, TESSvertex *v, TESSvertex *w ); +void tesedgeIntersect( TESSvertex *o1, TESSvertex *d1, TESSvertex *o2, TESSvertex *d2, TESSvertex *v ); +int tesedgeIsLocallyDelaunay( TESShalfEdge *e ); + +#endif diff --git a/jni/jni/libtess2/Source/mesh.c b/jni/jni/libtess2/Source/mesh.c new file mode 100755 index 000000000..a0fa08e57 --- /dev/null +++ b/jni/jni/libtess2/Source/mesh.c @@ -0,0 +1,917 @@ +/* +** SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008) +** Copyright (C) [dates of first publication] Silicon Graphics, Inc. +** All Rights Reserved. +** +** Permission is hereby granted, free of charge, to any person obtaining a copy +** of this software and associated documentation files (the "Software"), to deal +** in the Software without restriction, including without limitation the rights +** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +** of the Software, and to permit persons to whom the Software is furnished to do so, +** subject to the following conditions: +** +** The above copyright notice including the dates of first publication and either this +** permission notice or a reference to http://oss.sgi.com/projects/FreeB/ shall be +** included in all copies or substantial portions of the Software. +** +** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +** INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A +** PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL SILICON GRAPHICS, INC. +** BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE +** OR OTHER DEALINGS IN THE SOFTWARE. +** +** Except as contained in this notice, the name of Silicon Graphics, Inc. shall not +** be used in advertising or otherwise to promote the sale, use or other dealings in +** this Software without prior written authorization from Silicon Graphics, Inc. +*/ +/* +** Author: Eric Veach, July 1994. +*/ + +//#include "tesos.h" +#include +#include +#include "mesh.h" +#include "geom.h" +#include "bucketalloc.h" + +#define TRUE 1 +#define FALSE 0 + +/************************ Utility Routines ************************/ + +/* Allocate and free half-edges in pairs for efficiency. +* The *only* place that should use this fact is allocation/free. +*/ +typedef struct { TESShalfEdge e, eSym; } EdgePair; + +/* MakeEdge creates a new pair of half-edges which form their own loop. +* No vertex or face structures are allocated, but these must be assigned +* before the current edge operation is completed. +*/ +static TESShalfEdge *MakeEdge( TESSmesh* mesh, TESShalfEdge *eNext ) +{ + TESShalfEdge *e; + TESShalfEdge *eSym; + TESShalfEdge *ePrev; + EdgePair *pair = (EdgePair *)bucketAlloc( mesh->edgeBucket ); + if (pair == NULL) return NULL; + + e = &pair->e; + eSym = &pair->eSym; + + /* Make sure eNext points to the first edge of the edge pair */ + if( eNext->Sym < eNext ) { eNext = eNext->Sym; } + + /* Insert in circular doubly-linked list before eNext. + * Note that the prev pointer is stored in Sym->next. + */ + ePrev = eNext->Sym->next; + eSym->next = ePrev; + ePrev->Sym->next = e; + e->next = eNext; + eNext->Sym->next = eSym; + + e->Sym = eSym; + e->Onext = e; + e->Lnext = eSym; + e->Org = NULL; + e->Lface = NULL; + e->winding = 0; + e->activeRegion = NULL; + e->mark = 0; + + eSym->Sym = e; + eSym->Onext = eSym; + eSym->Lnext = e; + eSym->Org = NULL; + eSym->Lface = NULL; + eSym->winding = 0; + eSym->activeRegion = NULL; + eSym->mark = 0; + + return e; +} + +/* Splice( a, b ) is best described by the Guibas/Stolfi paper or the +* CS348a notes (see mesh.h). Basically it modifies the mesh so that +* a->Onext and b->Onext are exchanged. This can have various effects +* depending on whether a and b belong to different face or vertex rings. +* For more explanation see tessMeshSplice() below. +*/ +static void Splice( TESShalfEdge *a, TESShalfEdge *b ) +{ + TESShalfEdge *aOnext = a->Onext; + TESShalfEdge *bOnext = b->Onext; + + aOnext->Sym->Lnext = b; + bOnext->Sym->Lnext = a; + a->Onext = bOnext; + b->Onext = aOnext; +} + +/* MakeVertex( newVertex, eOrig, vNext ) attaches a new vertex and makes it the +* origin of all edges in the vertex loop to which eOrig belongs. "vNext" gives +* a place to insert the new vertex in the global vertex list. We insert +* the new vertex *before* vNext so that algorithms which walk the vertex +* list will not see the newly created vertices. +*/ +static void MakeVertex( TESSvertex *newVertex, + TESShalfEdge *eOrig, TESSvertex *vNext ) +{ + TESShalfEdge *e; + TESSvertex *vPrev; + TESSvertex *vNew = newVertex; + + assert(vNew != NULL); + + /* insert in circular doubly-linked list before vNext */ + vPrev = vNext->prev; + vNew->prev = vPrev; + vPrev->next = vNew; + vNew->next = vNext; + vNext->prev = vNew; + + vNew->anEdge = eOrig; + /* leave coords, s, t undefined */ + + /* fix other edges on this vertex loop */ + e = eOrig; + do { + e->Org = vNew; + e = e->Onext; + } while( e != eOrig ); +} + +/* MakeFace( newFace, eOrig, fNext ) attaches a new face and makes it the left +* face of all edges in the face loop to which eOrig belongs. "fNext" gives +* a place to insert the new face in the global face list. We insert +* the new face *before* fNext so that algorithms which walk the face +* list will not see the newly created faces. +*/ +static void MakeFace( TESSface *newFace, TESShalfEdge *eOrig, TESSface *fNext ) +{ + TESShalfEdge *e; + TESSface *fPrev; + TESSface *fNew = newFace; + + assert(fNew != NULL); + + /* insert in circular doubly-linked list before fNext */ + fPrev = fNext->prev; + fNew->prev = fPrev; + fPrev->next = fNew; + fNew->next = fNext; + fNext->prev = fNew; + + fNew->anEdge = eOrig; + fNew->trail = NULL; + fNew->marked = FALSE; + + /* The new face is marked "inside" if the old one was. This is a + * convenience for the common case where a face has been split in two. + */ + fNew->inside = fNext->inside; + + /* fix other edges on this face loop */ + e = eOrig; + do { + e->Lface = fNew; + e = e->Lnext; + } while( e != eOrig ); +} + +/* KillEdge( eDel ) destroys an edge (the half-edges eDel and eDel->Sym), +* and removes from the global edge list. +*/ +static void KillEdge( TESSmesh *mesh, TESShalfEdge *eDel ) +{ + TESShalfEdge *ePrev, *eNext; + + /* Half-edges are allocated in pairs, see EdgePair above */ + if( eDel->Sym < eDel ) { eDel = eDel->Sym; } + + /* delete from circular doubly-linked list */ + eNext = eDel->next; + ePrev = eDel->Sym->next; + eNext->Sym->next = ePrev; + ePrev->Sym->next = eNext; + + bucketFree( mesh->edgeBucket, eDel ); +} + + +/* KillVertex( vDel ) destroys a vertex and removes it from the global +* vertex list. It updates the vertex loop to point to a given new vertex. +*/ +static void KillVertex( TESSmesh *mesh, TESSvertex *vDel, TESSvertex *newOrg ) +{ + TESShalfEdge *e, *eStart = vDel->anEdge; + TESSvertex *vPrev, *vNext; + + /* change the origin of all affected edges */ + e = eStart; + do { + e->Org = newOrg; + e = e->Onext; + } while( e != eStart ); + + /* delete from circular doubly-linked list */ + vPrev = vDel->prev; + vNext = vDel->next; + vNext->prev = vPrev; + vPrev->next = vNext; + + bucketFree( mesh->vertexBucket, vDel ); +} + +/* KillFace( fDel ) destroys a face and removes it from the global face +* list. It updates the face loop to point to a given new face. +*/ +static void KillFace( TESSmesh *mesh, TESSface *fDel, TESSface *newLface ) +{ + TESShalfEdge *e, *eStart = fDel->anEdge; + TESSface *fPrev, *fNext; + + /* change the left face of all affected edges */ + e = eStart; + do { + e->Lface = newLface; + e = e->Lnext; + } while( e != eStart ); + + /* delete from circular doubly-linked list */ + fPrev = fDel->prev; + fNext = fDel->next; + fNext->prev = fPrev; + fPrev->next = fNext; + + bucketFree( mesh->faceBucket, fDel ); +} + + +/****************** Basic Edge Operations **********************/ + +/* tessMeshMakeEdge creates one edge, two vertices, and a loop (face). +* The loop consists of the two new half-edges. +*/ +TESShalfEdge *tessMeshMakeEdge( TESSmesh *mesh ) +{ + TESSvertex *newVertex1 = (TESSvertex*)bucketAlloc(mesh->vertexBucket); + TESSvertex *newVertex2 = (TESSvertex*)bucketAlloc(mesh->vertexBucket); + TESSface *newFace = (TESSface*)bucketAlloc(mesh->faceBucket); + TESShalfEdge *e; + + /* if any one is null then all get freed */ + if (newVertex1 == NULL || newVertex2 == NULL || newFace == NULL) { + if (newVertex1 != NULL) bucketFree( mesh->vertexBucket, newVertex1 ); + if (newVertex2 != NULL) bucketFree( mesh->vertexBucket, newVertex2 ); + if (newFace != NULL) bucketFree( mesh->faceBucket, newFace ); + return NULL; + } + + e = MakeEdge( mesh, &mesh->eHead ); + if (e == NULL) return NULL; + + MakeVertex( newVertex1, e, &mesh->vHead ); + MakeVertex( newVertex2, e->Sym, &mesh->vHead ); + MakeFace( newFace, e, &mesh->fHead ); + return e; +} + + +/* tessMeshSplice( eOrg, eDst ) is the basic operation for changing the +* mesh connectivity and topology. It changes the mesh so that +* eOrg->Onext <- OLD( eDst->Onext ) +* eDst->Onext <- OLD( eOrg->Onext ) +* where OLD(...) means the value before the meshSplice operation. +* +* This can have two effects on the vertex structure: +* - if eOrg->Org != eDst->Org, the two vertices are merged together +* - if eOrg->Org == eDst->Org, the origin is split into two vertices +* In both cases, eDst->Org is changed and eOrg->Org is untouched. +* +* Similarly (and independently) for the face structure, +* - if eOrg->Lface == eDst->Lface, one loop is split into two +* - if eOrg->Lface != eDst->Lface, two distinct loops are joined into one +* In both cases, eDst->Lface is changed and eOrg->Lface is unaffected. +* +* Some special cases: +* If eDst == eOrg, the operation has no effect. +* If eDst == eOrg->Lnext, the new face will have a single edge. +* If eDst == eOrg->Lprev, the old face will have a single edge. +* If eDst == eOrg->Onext, the new vertex will have a single edge. +* If eDst == eOrg->Oprev, the old vertex will have a single edge. +*/ +int tessMeshSplice( TESSmesh* mesh, TESShalfEdge *eOrg, TESShalfEdge *eDst ) +{ + int joiningLoops = FALSE; + int joiningVertices = FALSE; + + if( eOrg == eDst ) return 1; + + if( eDst->Org != eOrg->Org ) { + /* We are merging two disjoint vertices -- destroy eDst->Org */ + joiningVertices = TRUE; + KillVertex( mesh, eDst->Org, eOrg->Org ); + } + if( eDst->Lface != eOrg->Lface ) { + /* We are connecting two disjoint loops -- destroy eDst->Lface */ + joiningLoops = TRUE; + KillFace( mesh, eDst->Lface, eOrg->Lface ); + } + + /* Change the edge structure */ + Splice( eDst, eOrg ); + + if( ! joiningVertices ) { + TESSvertex *newVertex = (TESSvertex*)bucketAlloc( mesh->vertexBucket ); + if (newVertex == NULL) return 0; + + /* We split one vertex into two -- the new vertex is eDst->Org. + * Make sure the old vertex points to a valid half-edge. + */ + MakeVertex( newVertex, eDst, eOrg->Org ); + eOrg->Org->anEdge = eOrg; + } + if( ! joiningLoops ) { + TESSface *newFace = (TESSface*)bucketAlloc( mesh->faceBucket ); + if (newFace == NULL) return 0; + + /* We split one loop into two -- the new loop is eDst->Lface. + * Make sure the old face points to a valid half-edge. + */ + MakeFace( newFace, eDst, eOrg->Lface ); + eOrg->Lface->anEdge = eOrg; + } + + return 1; +} + + +/* tessMeshDelete( eDel ) removes the edge eDel. There are several cases: +* if (eDel->Lface != eDel->Rface), we join two loops into one; the loop +* eDel->Lface is deleted. Otherwise, we are splitting one loop into two; +* the newly created loop will contain eDel->Dst. If the deletion of eDel +* would create isolated vertices, those are deleted as well. +* +* This function could be implemented as two calls to tessMeshSplice +* plus a few calls to memFree, but this would allocate and delete +* unnecessary vertices and faces. +*/ +int tessMeshDelete( TESSmesh *mesh, TESShalfEdge *eDel ) +{ + TESShalfEdge *eDelSym = eDel->Sym; + int joiningLoops = FALSE; + + /* First step: disconnect the origin vertex eDel->Org. We make all + * changes to get a consistent mesh in this "intermediate" state. + */ + if( eDel->Lface != eDel->Rface ) { + /* We are joining two loops into one -- remove the left face */ + joiningLoops = TRUE; + KillFace( mesh, eDel->Lface, eDel->Rface ); + } + + if( eDel->Onext == eDel ) { + KillVertex( mesh, eDel->Org, NULL ); + } else { + /* Make sure that eDel->Org and eDel->Rface point to valid half-edges */ + eDel->Rface->anEdge = eDel->Oprev; + eDel->Org->anEdge = eDel->Onext; + + Splice( eDel, eDel->Oprev ); + if( ! joiningLoops ) { + TESSface *newFace= (TESSface*)bucketAlloc( mesh->faceBucket ); + if (newFace == NULL) return 0; + + /* We are splitting one loop into two -- create a new loop for eDel. */ + MakeFace( newFace, eDel, eDel->Lface ); + } + } + + /* Claim: the mesh is now in a consistent state, except that eDel->Org + * may have been deleted. Now we disconnect eDel->Dst. + */ + if( eDelSym->Onext == eDelSym ) { + KillVertex( mesh, eDelSym->Org, NULL ); + KillFace( mesh, eDelSym->Lface, NULL ); + } else { + /* Make sure that eDel->Dst and eDel->Lface point to valid half-edges */ + eDel->Lface->anEdge = eDelSym->Oprev; + eDelSym->Org->anEdge = eDelSym->Onext; + Splice( eDelSym, eDelSym->Oprev ); + } + + /* Any isolated vertices or faces have already been freed. */ + KillEdge( mesh, eDel ); + + return 1; +} + + +/******************** Other Edge Operations **********************/ + +/* All these routines can be implemented with the basic edge +* operations above. They are provided for convenience and efficiency. +*/ + + +/* tessMeshAddEdgeVertex( eOrg ) creates a new edge eNew such that +* eNew == eOrg->Lnext, and eNew->Dst is a newly created vertex. +* eOrg and eNew will have the same left face. +*/ +TESShalfEdge *tessMeshAddEdgeVertex( TESSmesh *mesh, TESShalfEdge *eOrg ) +{ + TESShalfEdge *eNewSym; + TESShalfEdge *eNew = MakeEdge( mesh, eOrg ); + if (eNew == NULL) return NULL; + + eNewSym = eNew->Sym; + + /* Connect the new edge appropriately */ + Splice( eNew, eOrg->Lnext ); + + /* Set the vertex and face information */ + eNew->Org = eOrg->Dst; + { + TESSvertex *newVertex= (TESSvertex*)bucketAlloc( mesh->vertexBucket ); + if (newVertex == NULL) return NULL; + + MakeVertex( newVertex, eNewSym, eNew->Org ); + } + eNew->Lface = eNewSym->Lface = eOrg->Lface; + + return eNew; +} + + +/* tessMeshSplitEdge( eOrg ) splits eOrg into two edges eOrg and eNew, +* such that eNew == eOrg->Lnext. The new vertex is eOrg->Dst == eNew->Org. +* eOrg and eNew will have the same left face. +*/ +TESShalfEdge *tessMeshSplitEdge( TESSmesh *mesh, TESShalfEdge *eOrg ) +{ + TESShalfEdge *eNew; + TESShalfEdge *tempHalfEdge= tessMeshAddEdgeVertex( mesh, eOrg ); + if (tempHalfEdge == NULL) return NULL; + + eNew = tempHalfEdge->Sym; + + /* Disconnect eOrg from eOrg->Dst and connect it to eNew->Org */ + Splice( eOrg->Sym, eOrg->Sym->Oprev ); + Splice( eOrg->Sym, eNew ); + + /* Set the vertex and face information */ + eOrg->Dst = eNew->Org; + eNew->Dst->anEdge = eNew->Sym; /* may have pointed to eOrg->Sym */ + eNew->Rface = eOrg->Rface; + eNew->winding = eOrg->winding; /* copy old winding information */ + eNew->Sym->winding = eOrg->Sym->winding; + + return eNew; +} + + +/* tessMeshConnect( eOrg, eDst ) creates a new edge from eOrg->Dst +* to eDst->Org, and returns the corresponding half-edge eNew. +* If eOrg->Lface == eDst->Lface, this splits one loop into two, +* and the newly created loop is eNew->Lface. Otherwise, two disjoint +* loops are merged into one, and the loop eDst->Lface is destroyed. +* +* If (eOrg == eDst), the new face will have only two edges. +* If (eOrg->Lnext == eDst), the old face is reduced to a single edge. +* If (eOrg->Lnext->Lnext == eDst), the old face is reduced to two edges. +*/ +TESShalfEdge *tessMeshConnect( TESSmesh *mesh, TESShalfEdge *eOrg, TESShalfEdge *eDst ) +{ + TESShalfEdge *eNewSym; + int joiningLoops = FALSE; + TESShalfEdge *eNew = MakeEdge( mesh, eOrg ); + if (eNew == NULL) return NULL; + + eNewSym = eNew->Sym; + + if( eDst->Lface != eOrg->Lface ) { + /* We are connecting two disjoint loops -- destroy eDst->Lface */ + joiningLoops = TRUE; + KillFace( mesh, eDst->Lface, eOrg->Lface ); + } + + /* Connect the new edge appropriately */ + Splice( eNew, eOrg->Lnext ); + Splice( eNewSym, eDst ); + + /* Set the vertex and face information */ + eNew->Org = eOrg->Dst; + eNewSym->Org = eDst->Org; + eNew->Lface = eNewSym->Lface = eOrg->Lface; + + /* Make sure the old face points to a valid half-edge */ + eOrg->Lface->anEdge = eNewSym; + + if( ! joiningLoops ) { + TESSface *newFace= (TESSface*)bucketAlloc( mesh->faceBucket ); + if (newFace == NULL) return NULL; + + /* We split one loop into two -- the new loop is eNew->Lface */ + MakeFace( newFace, eNew, eOrg->Lface ); + } + return eNew; +} + + +/******************** Other Operations **********************/ + +/* tessMeshZapFace( fZap ) destroys a face and removes it from the +* global face list. All edges of fZap will have a NULL pointer as their +* left face. Any edges which also have a NULL pointer as their right face +* are deleted entirely (along with any isolated vertices this produces). +* An entire mesh can be deleted by zapping its faces, one at a time, +* in any order. Zapped faces cannot be used in further mesh operations! +*/ +void tessMeshZapFace( TESSmesh *mesh, TESSface *fZap ) +{ + TESShalfEdge *eStart = fZap->anEdge; + TESShalfEdge *e, *eNext, *eSym; + TESSface *fPrev, *fNext; + + /* walk around face, deleting edges whose right face is also NULL */ + eNext = eStart->Lnext; + do { + e = eNext; + eNext = e->Lnext; + + e->Lface = NULL; + if( e->Rface == NULL ) { + /* delete the edge -- see TESSmeshDelete above */ + + if( e->Onext == e ) { + KillVertex( mesh, e->Org, NULL ); + } else { + /* Make sure that e->Org points to a valid half-edge */ + e->Org->anEdge = e->Onext; + Splice( e, e->Oprev ); + } + eSym = e->Sym; + if( eSym->Onext == eSym ) { + KillVertex( mesh, eSym->Org, NULL ); + } else { + /* Make sure that eSym->Org points to a valid half-edge */ + eSym->Org->anEdge = eSym->Onext; + Splice( eSym, eSym->Oprev ); + } + KillEdge( mesh, e ); + } + } while( e != eStart ); + + /* delete from circular doubly-linked list */ + fPrev = fZap->prev; + fNext = fZap->next; + fNext->prev = fPrev; + fPrev->next = fNext; + + bucketFree( mesh->faceBucket, fZap ); +} + + +/* tessMeshNewMesh() creates a new mesh with no edges, no vertices, +* and no loops (what we usually call a "face"). +*/ +TESSmesh *tessMeshNewMesh( TESSalloc* alloc ) +{ + TESSvertex *v; + TESSface *f; + TESShalfEdge *e; + TESShalfEdge *eSym; + TESSmesh *mesh = (TESSmesh *)alloc->memalloc( alloc->userData, sizeof( TESSmesh )); + if (mesh == NULL) { + return NULL; + } + + if (alloc->meshEdgeBucketSize < 16) + alloc->meshEdgeBucketSize = 16; + if (alloc->meshEdgeBucketSize > 4096) + alloc->meshEdgeBucketSize = 4096; + + if (alloc->meshVertexBucketSize < 16) + alloc->meshVertexBucketSize = 16; + if (alloc->meshVertexBucketSize > 4096) + alloc->meshVertexBucketSize = 4096; + + if (alloc->meshFaceBucketSize < 16) + alloc->meshFaceBucketSize = 16; + if (alloc->meshFaceBucketSize > 4096) + alloc->meshFaceBucketSize = 4096; + + mesh->edgeBucket = createBucketAlloc( alloc, "Mesh Edges", sizeof(EdgePair), alloc->meshEdgeBucketSize ); + mesh->vertexBucket = createBucketAlloc( alloc, "Mesh Vertices", sizeof(TESSvertex), alloc->meshVertexBucketSize ); + mesh->faceBucket = createBucketAlloc( alloc, "Mesh Faces", sizeof(TESSface), alloc->meshFaceBucketSize ); + + v = &mesh->vHead; + f = &mesh->fHead; + e = &mesh->eHead; + eSym = &mesh->eHeadSym; + + v->next = v->prev = v; + v->anEdge = NULL; + + f->next = f->prev = f; + f->anEdge = NULL; + f->trail = NULL; + f->marked = FALSE; + f->inside = FALSE; + + e->next = e; + e->Sym = eSym; + e->Onext = NULL; + e->Lnext = NULL; + e->Org = NULL; + e->Lface = NULL; + e->winding = 0; + e->activeRegion = NULL; + + eSym->next = eSym; + eSym->Sym = e; + eSym->Onext = NULL; + eSym->Lnext = NULL; + eSym->Org = NULL; + eSym->Lface = NULL; + eSym->winding = 0; + eSym->activeRegion = NULL; + + return mesh; +} + + +/* tessMeshUnion( mesh1, mesh2 ) forms the union of all structures in +* both meshes, and returns the new mesh (the old meshes are destroyed). +*/ +TESSmesh *tessMeshUnion( TESSalloc* alloc, TESSmesh *mesh1, TESSmesh *mesh2 ) +{ + TESSface *f1 = &mesh1->fHead; + TESSvertex *v1 = &mesh1->vHead; + TESShalfEdge *e1 = &mesh1->eHead; + TESSface *f2 = &mesh2->fHead; + TESSvertex *v2 = &mesh2->vHead; + TESShalfEdge *e2 = &mesh2->eHead; + + /* Add the faces, vertices, and edges of mesh2 to those of mesh1 */ + if( f2->next != f2 ) { + f1->prev->next = f2->next; + f2->next->prev = f1->prev; + f2->prev->next = f1; + f1->prev = f2->prev; + } + + if( v2->next != v2 ) { + v1->prev->next = v2->next; + v2->next->prev = v1->prev; + v2->prev->next = v1; + v1->prev = v2->prev; + } + + if( e2->next != e2 ) { + e1->Sym->next->Sym->next = e2->next; + e2->next->Sym->next = e1->Sym->next; + e2->Sym->next->Sym->next = e1; + e1->Sym->next = e2->Sym->next; + } + + alloc->memfree( alloc->userData, mesh2 ); + return mesh1; +} + + +static int CountFaceVerts( TESSface *f ) +{ + TESShalfEdge *eCur = f->anEdge; + int n = 0; + do + { + n++; + eCur = eCur->Lnext; + } + while (eCur != f->anEdge); + return n; +} + +int tessMeshMergeConvexFaces( TESSmesh *mesh, int maxVertsPerFace ) +{ + TESShalfEdge *e, *eNext, *eSym; + TESShalfEdge *eHead = &mesh->eHead; + TESSvertex *va, *vb, *vc, *vd, *ve, *vf; + int leftNv, rightNv; + + for( e = eHead->next; e != eHead; e = eNext ) + { + eNext = e->next; + eSym = e->Sym; + if( !eSym ) + continue; + + // Both faces must be inside + if( !e->Lface || !e->Lface->inside ) + continue; + if( !eSym->Lface || !eSym->Lface->inside ) + continue; + + leftNv = CountFaceVerts( e->Lface ); + rightNv = CountFaceVerts( eSym->Lface ); + if( (leftNv+rightNv-2) > maxVertsPerFace ) + continue; + + // Merge if the resulting poly is convex. + // + // vf--ve--vd + // ^| + // left e || right + // |v + // va--vb--vc + + va = e->Lprev->Org; + vb = e->Org; + vc = e->Sym->Lnext->Dst; + + vd = e->Sym->Lprev->Org; + ve = e->Sym->Org; + vf = e->Lnext->Dst; + + if( VertCCW( va, vb, vc ) && VertCCW( vd, ve, vf ) ) { + if( e == eNext || e == eNext->Sym ) { eNext = eNext->next; } + if( !tessMeshDelete( mesh, e ) ) + return 0; + } + } + + return 1; +} + +void tessMeshFlipEdge( TESSmesh *mesh, TESShalfEdge *edge ) +{ + TESShalfEdge *a0 = edge; + TESShalfEdge *a1 = a0->Lnext; + TESShalfEdge *a2 = a1->Lnext; + TESShalfEdge *b0 = edge->Sym; + TESShalfEdge *b1 = b0->Lnext; + TESShalfEdge *b2 = b1->Lnext; + + TESSvertex *aOrg = a0->Org; + TESSvertex *aOpp = a2->Org; + TESSvertex *bOrg = b0->Org; + TESSvertex *bOpp = b2->Org; + + TESSface *fa = a0->Lface; + TESSface *fb = b0->Lface; + + assert(EdgeIsInternal(edge)); + assert(a2->Lnext == a0); + assert(b2->Lnext == b0); + + a0->Org = bOpp; + a0->Onext = b1->Sym; + b0->Org = aOpp; + b0->Onext = a1->Sym; + a2->Onext = b0; + b2->Onext = a0; + b1->Onext = a2->Sym; + a1->Onext = b2->Sym; + + a0->Lnext = a2; + a2->Lnext = b1; + b1->Lnext = a0; + + b0->Lnext = b2; + b2->Lnext = a1; + a1->Lnext = b0; + + a1->Lface = fb; + b1->Lface = fa; + + fa->anEdge = a0; + fb->anEdge = b0; + + if (aOrg->anEdge == a0) aOrg->anEdge = b1; + if (bOrg->anEdge == b0) bOrg->anEdge = a1; + + assert( a0->Lnext->Onext->Sym == a0 ); + assert( a0->Onext->Sym->Lnext == a0 ); + assert( a0->Org->anEdge->Org == a0->Org ); + + + assert( a1->Lnext->Onext->Sym == a1 ); + assert( a1->Onext->Sym->Lnext == a1 ); + assert( a1->Org->anEdge->Org == a1->Org ); + + assert( a2->Lnext->Onext->Sym == a2 ); + assert( a2->Onext->Sym->Lnext == a2 ); + assert( a2->Org->anEdge->Org == a2->Org ); + + assert( b0->Lnext->Onext->Sym == b0 ); + assert( b0->Onext->Sym->Lnext == b0 ); + assert( b0->Org->anEdge->Org == b0->Org ); + + assert( b1->Lnext->Onext->Sym == b1 ); + assert( b1->Onext->Sym->Lnext == b1 ); + assert( b1->Org->anEdge->Org == b1->Org ); + + assert( b2->Lnext->Onext->Sym == b2 ); + assert( b2->Onext->Sym->Lnext == b2 ); + assert( b2->Org->anEdge->Org == b2->Org ); + + assert(aOrg->anEdge->Org == aOrg); + assert(bOrg->anEdge->Org == bOrg); + + assert(a0->Oprev->Onext->Org == a0->Org); +} + +#ifdef DELETE_BY_ZAPPING + +/* tessMeshDeleteMesh( mesh ) will free all storage for any valid mesh. +*/ +void tessMeshDeleteMesh( TESSalloc* alloc, TESSmesh *mesh ) +{ + TESSface *fHead = &mesh->fHead; + + while( fHead->next != fHead ) { + tessMeshZapFace( fHead->next ); + } + assert( mesh->vHead.next == &mesh->vHead ); + + alloc->memfree( alloc->userData, mesh ); +} + +#else + +/* tessMeshDeleteMesh( mesh ) will free all storage for any valid mesh. +*/ +void tessMeshDeleteMesh( TESSalloc* alloc, TESSmesh *mesh ) +{ + deleteBucketAlloc(mesh->edgeBucket); + deleteBucketAlloc(mesh->vertexBucket); + deleteBucketAlloc(mesh->faceBucket); + + alloc->memfree( alloc->userData, mesh ); +} + +#endif + +#ifndef NDEBUG + +/* tessMeshCheckMesh( mesh ) checks a mesh for self-consistency. +*/ +void tessMeshCheckMesh( TESSmesh *mesh ) +{ + TESSface *fHead = &mesh->fHead; + TESSvertex *vHead = &mesh->vHead; + TESShalfEdge *eHead = &mesh->eHead; + TESSface *f, *fPrev; + TESSvertex *v, *vPrev; + TESShalfEdge *e, *ePrev; + + for( fPrev = fHead ; (f = fPrev->next) != fHead; fPrev = f) { + assert( f->prev == fPrev ); + e = f->anEdge; + do { + assert( e->Sym != e ); + assert( e->Sym->Sym == e ); + assert( e->Lnext->Onext->Sym == e ); + assert( e->Onext->Sym->Lnext == e ); + assert( e->Lface == f ); + e = e->Lnext; + } while( e != f->anEdge ); + } + assert( f->prev == fPrev && f->anEdge == NULL ); + + for( vPrev = vHead ; (v = vPrev->next) != vHead; vPrev = v) { + assert( v->prev == vPrev ); + e = v->anEdge; + do { + assert( e->Sym != e ); + assert( e->Sym->Sym == e ); + assert( e->Lnext->Onext->Sym == e ); + assert( e->Onext->Sym->Lnext == e ); + assert( e->Org == v ); + e = e->Onext; + } while( e != v->anEdge ); + } + assert( v->prev == vPrev && v->anEdge == NULL ); + + for( ePrev = eHead ; (e = ePrev->next) != eHead; ePrev = e) { + assert( e->Sym->next == ePrev->Sym ); + assert( e->Sym != e ); + assert( e->Sym->Sym == e ); + assert( e->Org != NULL ); + assert( e->Dst != NULL ); + assert( e->Lnext->Onext->Sym == e ); + assert( e->Onext->Sym->Lnext == e ); + } + assert( e->Sym->next == ePrev->Sym + && e->Sym == &mesh->eHeadSym + && e->Sym->Sym == e + && e->Org == NULL && e->Dst == NULL + && e->Lface == NULL && e->Rface == NULL ); +} + +#endif diff --git a/jni/jni/libtess2/Source/mesh.h b/jni/jni/libtess2/Source/mesh.h new file mode 100755 index 000000000..479c66f36 --- /dev/null +++ b/jni/jni/libtess2/Source/mesh.h @@ -0,0 +1,269 @@ +/* +** SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008) +** Copyright (C) [dates of first publication] Silicon Graphics, Inc. +** All Rights Reserved. +** +** Permission is hereby granted, free of charge, to any person obtaining a copy +** of this software and associated documentation files (the "Software"), to deal +** in the Software without restriction, including without limitation the rights +** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +** of the Software, and to permit persons to whom the Software is furnished to do so, +** subject to the following conditions: +** +** The above copyright notice including the dates of first publication and either this +** permission notice or a reference to http://oss.sgi.com/projects/FreeB/ shall be +** included in all copies or substantial portions of the Software. +** +** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +** INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A +** PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL SILICON GRAPHICS, INC. +** BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE +** OR OTHER DEALINGS IN THE SOFTWARE. +** +** Except as contained in this notice, the name of Silicon Graphics, Inc. shall not +** be used in advertising or otherwise to promote the sale, use or other dealings in +** this Software without prior written authorization from Silicon Graphics, Inc. +*/ +/* +** Author: Eric Veach, July 1994. +*/ + +#ifndef MESH_H +#define MESH_H + +#include "../Include/tesselator.h" + +typedef struct TESSmesh TESSmesh; +typedef struct TESSvertex TESSvertex; +typedef struct TESSface TESSface; +typedef struct TESShalfEdge TESShalfEdge; +typedef struct ActiveRegion ActiveRegion; + +/* The mesh structure is similar in spirit, notation, and operations +* to the "quad-edge" structure (see L. Guibas and J. Stolfi, Primitives +* for the manipulation of general subdivisions and the computation of +* Voronoi diagrams, ACM Transactions on Graphics, 4(2):74-123, April 1985). +* For a simplified description, see the course notes for CS348a, +* "Mathematical Foundations of Computer Graphics", available at the +* Stanford bookstore (and taught during the fall quarter). +* The implementation also borrows a tiny subset of the graph-based approach +* use in Mantyla's Geometric Work Bench (see M. Mantyla, An Introduction +* to Sold Modeling, Computer Science Press, Rockville, Maryland, 1988). +* +* The fundamental data structure is the "half-edge". Two half-edges +* go together to make an edge, but they point in opposite directions. +* Each half-edge has a pointer to its mate (the "symmetric" half-edge Sym), +* its origin vertex (Org), the face on its left side (Lface), and the +* adjacent half-edges in the CCW direction around the origin vertex +* (Onext) and around the left face (Lnext). There is also a "next" +* pointer for the global edge list (see below). +* +* The notation used for mesh navigation: +* Sym = the mate of a half-edge (same edge, but opposite direction) +* Onext = edge CCW around origin vertex (keep same origin) +* Dnext = edge CCW around destination vertex (keep same dest) +* Lnext = edge CCW around left face (dest becomes new origin) +* Rnext = edge CCW around right face (origin becomes new dest) +* +* "prev" means to substitute CW for CCW in the definitions above. +* +* The mesh keeps global lists of all vertices, faces, and edges, +* stored as doubly-linked circular lists with a dummy header node. +* The mesh stores pointers to these dummy headers (vHead, fHead, eHead). +* +* The circular edge list is special; since half-edges always occur +* in pairs (e and e->Sym), each half-edge stores a pointer in only +* one direction. Starting at eHead and following the e->next pointers +* will visit each *edge* once (ie. e or e->Sym, but not both). +* e->Sym stores a pointer in the opposite direction, thus it is +* always true that e->Sym->next->Sym->next == e. +* +* Each vertex has a pointer to next and previous vertices in the +* circular list, and a pointer to a half-edge with this vertex as +* the origin (NULL if this is the dummy header). There is also a +* field "data" for client data. +* +* Each face has a pointer to the next and previous faces in the +* circular list, and a pointer to a half-edge with this face as +* the left face (NULL if this is the dummy header). There is also +* a field "data" for client data. +* +* Note that what we call a "face" is really a loop; faces may consist +* of more than one loop (ie. not simply connected), but there is no +* record of this in the data structure. The mesh may consist of +* several disconnected regions, so it may not be possible to visit +* the entire mesh by starting at a half-edge and traversing the edge +* structure. +* +* The mesh does NOT support isolated vertices; a vertex is deleted along +* with its last edge. Similarly when two faces are merged, one of the +* faces is deleted (see tessMeshDelete below). For mesh operations, +* all face (loop) and vertex pointers must not be NULL. However, once +* mesh manipulation is finished, TESSmeshZapFace can be used to delete +* faces of the mesh, one at a time. All external faces can be "zapped" +* before the mesh is returned to the client; then a NULL face indicates +* a region which is not part of the output polygon. +*/ + +struct TESSvertex { + TESSvertex *next; /* next vertex (never NULL) */ + TESSvertex *prev; /* previous vertex (never NULL) */ + TESShalfEdge *anEdge; /* a half-edge with this origin */ + + /* Internal data (keep hidden) */ + TESSreal coords[3]; /* vertex location in 3D */ + TESSreal s, t; /* projection onto the sweep plane */ + int pqHandle; /* to allow deletion from priority queue */ + TESSindex n; /* to allow identify unique vertices */ + TESSindex idx; /* to allow map result to original verts */ +}; + +struct TESSface { + TESSface *next; /* next face (never NULL) */ + TESSface *prev; /* previous face (never NULL) */ + TESShalfEdge *anEdge; /* a half edge with this left face */ + + /* Internal data (keep hidden) */ + TESSface *trail; /* "stack" for conversion to strips */ + TESSindex n; /* to allow identiy unique faces */ + char marked; /* flag for conversion to strips */ + char inside; /* this face is in the polygon interior */ +}; + +struct TESShalfEdge { + TESShalfEdge *next; /* doubly-linked list (prev==Sym->next) */ + TESShalfEdge *Sym; /* same edge, opposite direction */ + TESShalfEdge *Onext; /* next edge CCW around origin */ + TESShalfEdge *Lnext; /* next edge CCW around left face */ + TESSvertex *Org; /* origin vertex (Overtex too long) */ + TESSface *Lface; /* left face */ + + /* Internal data (keep hidden) */ + ActiveRegion *activeRegion; /* a region with this upper edge (sweep.c) */ + int winding; /* change in winding number when crossing + from the right face to the left face */ + int mark; /* Used by the Edge Flip algorithm */ +}; + +#define Rface Sym->Lface +#define Dst Sym->Org + +#define Oprev Sym->Lnext +#define Lprev Onext->Sym +#define Dprev Lnext->Sym +#define Rprev Sym->Onext +#define Dnext Rprev->Sym /* 3 pointers */ +#define Rnext Oprev->Sym /* 3 pointers */ + +struct TESSmesh { + TESSvertex vHead; /* dummy header for vertex list */ + TESSface fHead; /* dummy header for face list */ + TESShalfEdge eHead; /* dummy header for edge list */ + TESShalfEdge eHeadSym; /* and its symmetric counterpart */ + + struct BucketAlloc* edgeBucket; + struct BucketAlloc* vertexBucket; + struct BucketAlloc* faceBucket; +}; + +/* The mesh operations below have three motivations: completeness, +* convenience, and efficiency. The basic mesh operations are MakeEdge, +* Splice, and Delete. All the other edge operations can be implemented +* in terms of these. The other operations are provided for convenience +* and/or efficiency. +* +* When a face is split or a vertex is added, they are inserted into the +* global list *before* the existing vertex or face (ie. e->Org or e->Lface). +* This makes it easier to process all vertices or faces in the global lists +* without worrying about processing the same data twice. As a convenience, +* when a face is split, the "inside" flag is copied from the old face. +* Other internal data (v->data, v->activeRegion, f->data, f->marked, +* f->trail, e->winding) is set to zero. +* +* ********************** Basic Edge Operations ************************** +* +* tessMeshMakeEdge( mesh ) creates one edge, two vertices, and a loop. +* The loop (face) consists of the two new half-edges. +* +* tessMeshSplice( eOrg, eDst ) is the basic operation for changing the +* mesh connectivity and topology. It changes the mesh so that +* eOrg->Onext <- OLD( eDst->Onext ) +* eDst->Onext <- OLD( eOrg->Onext ) +* where OLD(...) means the value before the meshSplice operation. +* +* This can have two effects on the vertex structure: +* - if eOrg->Org != eDst->Org, the two vertices are merged together +* - if eOrg->Org == eDst->Org, the origin is split into two vertices +* In both cases, eDst->Org is changed and eOrg->Org is untouched. +* +* Similarly (and independently) for the face structure, +* - if eOrg->Lface == eDst->Lface, one loop is split into two +* - if eOrg->Lface != eDst->Lface, two distinct loops are joined into one +* In both cases, eDst->Lface is changed and eOrg->Lface is unaffected. +* +* tessMeshDelete( eDel ) removes the edge eDel. There are several cases: +* if (eDel->Lface != eDel->Rface), we join two loops into one; the loop +* eDel->Lface is deleted. Otherwise, we are splitting one loop into two; +* the newly created loop will contain eDel->Dst. If the deletion of eDel +* would create isolated vertices, those are deleted as well. +* +* ********************** Other Edge Operations ************************** +* +* tessMeshAddEdgeVertex( eOrg ) creates a new edge eNew such that +* eNew == eOrg->Lnext, and eNew->Dst is a newly created vertex. +* eOrg and eNew will have the same left face. +* +* tessMeshSplitEdge( eOrg ) splits eOrg into two edges eOrg and eNew, +* such that eNew == eOrg->Lnext. The new vertex is eOrg->Dst == eNew->Org. +* eOrg and eNew will have the same left face. +* +* tessMeshConnect( eOrg, eDst ) creates a new edge from eOrg->Dst +* to eDst->Org, and returns the corresponding half-edge eNew. +* If eOrg->Lface == eDst->Lface, this splits one loop into two, +* and the newly created loop is eNew->Lface. Otherwise, two disjoint +* loops are merged into one, and the loop eDst->Lface is destroyed. +* +* ************************ Other Operations ***************************** +* +* tessMeshNewMesh() creates a new mesh with no edges, no vertices, +* and no loops (what we usually call a "face"). +* +* tessMeshUnion( mesh1, mesh2 ) forms the union of all structures in +* both meshes, and returns the new mesh (the old meshes are destroyed). +* +* tessMeshDeleteMesh( mesh ) will free all storage for any valid mesh. +* +* tessMeshZapFace( fZap ) destroys a face and removes it from the +* global face list. All edges of fZap will have a NULL pointer as their +* left face. Any edges which also have a NULL pointer as their right face +* are deleted entirely (along with any isolated vertices this produces). +* An entire mesh can be deleted by zapping its faces, one at a time, +* in any order. Zapped faces cannot be used in further mesh operations! +* +* tessMeshCheckMesh( mesh ) checks a mesh for self-consistency. +*/ + +TESShalfEdge *tessMeshMakeEdge( TESSmesh *mesh ); +int tessMeshSplice( TESSmesh *mesh, TESShalfEdge *eOrg, TESShalfEdge *eDst ); +int tessMeshDelete( TESSmesh *mesh, TESShalfEdge *eDel ); + +TESShalfEdge *tessMeshAddEdgeVertex( TESSmesh *mesh, TESShalfEdge *eOrg ); +TESShalfEdge *tessMeshSplitEdge( TESSmesh *mesh, TESShalfEdge *eOrg ); +TESShalfEdge *tessMeshConnect( TESSmesh *mesh, TESShalfEdge *eOrg, TESShalfEdge *eDst ); + +TESSmesh *tessMeshNewMesh( TESSalloc* alloc ); +TESSmesh *tessMeshUnion( TESSalloc* alloc, TESSmesh *mesh1, TESSmesh *mesh2 ); +int tessMeshMergeConvexFaces( TESSmesh *mesh, int maxVertsPerFace ); +void tessMeshDeleteMesh( TESSalloc* alloc, TESSmesh *mesh ); +void tessMeshZapFace( TESSmesh *mesh, TESSface *fZap ); + +void tessMeshFlipEdge( TESSmesh *mesh, TESShalfEdge *edge ); + +#ifdef NDEBUG +#define tessMeshCheckMesh( mesh ) +#else +void tessMeshCheckMesh( TESSmesh *mesh ); +#endif + +#endif diff --git a/jni/jni/libtess2/Source/priorityq.c b/jni/jni/libtess2/Source/priorityq.c new file mode 100755 index 000000000..62a665453 --- /dev/null +++ b/jni/jni/libtess2/Source/priorityq.c @@ -0,0 +1,514 @@ +/* +** SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008) +** Copyright (C) [dates of first publication] Silicon Graphics, Inc. +** All Rights Reserved. +** +** Permission is hereby granted, free of charge, to any person obtaining a copy +** of this software and associated documentation files (the "Software"), to deal +** in the Software without restriction, including without limitation the rights +** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +** of the Software, and to permit persons to whom the Software is furnished to do so, +** subject to the following conditions: +** +** The above copyright notice including the dates of first publication and either this +** permission notice or a reference to http://oss.sgi.com/projects/FreeB/ shall be +** included in all copies or substantial portions of the Software. +** +** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +** INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A +** PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL SILICON GRAPHICS, INC. +** BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE +** OR OTHER DEALINGS IN THE SOFTWARE. +** +** Except as contained in this notice, the name of Silicon Graphics, Inc. shall not +** be used in advertising or otherwise to promote the sale, use or other dealings in +** this Software without prior written authorization from Silicon Graphics, Inc. +*/ +/* +** Author: Eric Veach, July 1994. +*/ + +//#include "tesos.h" +#include +#include +#include "../Include/tesselator.h" +#include "priorityq.h" + + +#define INIT_SIZE 32 + +#define TRUE 1 +#define FALSE 0 + +#ifdef FOR_TRITE_TEST_PROGRAM +#define LEQ(x,y) (*pq->leq)(x,y) +#else +/* Violates modularity, but a little faster */ +#include "geom.h" +#define LEQ(x,y) VertLeq((TESSvertex *)x, (TESSvertex *)y) +#endif + + +/* Include all the code for the regular heap-based queue here. */ + +/* The basic operations are insertion of a new key (pqInsert), +* and examination/extraction of a key whose value is minimum +* (pqMinimum/pqExtractMin). Deletion is also allowed (pqDelete); +* for this purpose pqInsert returns a "handle" which is supplied +* as the argument. +* +* An initial heap may be created efficiently by calling pqInsert +* repeatedly, then calling pqInit. In any case pqInit must be called +* before any operations other than pqInsert are used. +* +* If the heap is empty, pqMinimum/pqExtractMin will return a NULL key. +* This may also be tested with pqIsEmpty. +*/ + + +/* Since we support deletion the data structure is a little more +* complicated than an ordinary heap. "nodes" is the heap itself; +* active nodes are stored in the range 1..pq->size. When the +* heap exceeds its allocated size (pq->max), its size doubles. +* The children of node i are nodes 2i and 2i+1. +* +* Each node stores an index into an array "handles". Each handle +* stores a key, plus a pointer back to the node which currently +* represents that key (ie. nodes[handles[i].node].handle == i). +*/ + + +#define pqHeapMinimum(pq) ((pq)->handles[(pq)->nodes[1].handle].key) +#define pqHeapIsEmpty(pq) ((pq)->size == 0) + + + +/* really pqHeapNewPriorityQHeap */ +PriorityQHeap *pqHeapNewPriorityQ( TESSalloc* alloc, int size, int (*leq)(PQkey key1, PQkey key2) ) +{ + PriorityQHeap *pq = (PriorityQHeap *)alloc->memalloc( alloc->userData, sizeof( PriorityQHeap )); + if (pq == NULL) return NULL; + + pq->size = 0; + pq->max = size; + pq->nodes = (PQnode *)alloc->memalloc( alloc->userData, (size + 1) * sizeof(pq->nodes[0]) ); + if (pq->nodes == NULL) { + alloc->memfree( alloc->userData, pq ); + return NULL; + } + + pq->handles = (PQhandleElem *)alloc->memalloc( alloc->userData, (size + 1) * sizeof(pq->handles[0]) ); + if (pq->handles == NULL) { + alloc->memfree( alloc->userData, pq->nodes ); + alloc->memfree( alloc->userData, pq ); + return NULL; + } + + pq->initialized = FALSE; + pq->freeList = 0; + pq->leq = leq; + + pq->nodes[1].handle = 1; /* so that Minimum() returns NULL */ + pq->handles[1].key = NULL; + return pq; +} + +/* really pqHeapDeletePriorityQHeap */ +void pqHeapDeletePriorityQ( TESSalloc* alloc, PriorityQHeap *pq ) +{ + alloc->memfree( alloc->userData, pq->handles ); + alloc->memfree( alloc->userData, pq->nodes ); + alloc->memfree( alloc->userData, pq ); +} + + +static void FloatDown( PriorityQHeap *pq, int curr ) +{ + PQnode *n = pq->nodes; + PQhandleElem *h = pq->handles; + PQhandle hCurr, hChild; + int child; + + hCurr = n[curr].handle; + for( ;; ) { + child = curr << 1; + if( child < pq->size && LEQ( h[n[child+1].handle].key, + h[n[child].handle].key )) { + ++child; + } + + assert(child <= pq->max); + + hChild = n[child].handle; + if( child > pq->size || LEQ( h[hCurr].key, h[hChild].key )) { + n[curr].handle = hCurr; + h[hCurr].node = curr; + break; + } + n[curr].handle = hChild; + h[hChild].node = curr; + curr = child; + } +} + + +static void FloatUp( PriorityQHeap *pq, int curr ) +{ + PQnode *n = pq->nodes; + PQhandleElem *h = pq->handles; + PQhandle hCurr, hParent; + int parent; + + hCurr = n[curr].handle; + for( ;; ) { + parent = curr >> 1; + hParent = n[parent].handle; + if( parent == 0 || LEQ( h[hParent].key, h[hCurr].key )) { + n[curr].handle = hCurr; + h[hCurr].node = curr; + break; + } + n[curr].handle = hParent; + h[hParent].node = curr; + curr = parent; + } +} + +/* really pqHeapInit */ +void pqHeapInit( PriorityQHeap *pq ) +{ + int i; + + /* This method of building a heap is O(n), rather than O(n lg n). */ + + for( i = pq->size; i >= 1; --i ) { + FloatDown( pq, i ); + } + pq->initialized = TRUE; +} + +/* really pqHeapInsert */ +/* returns INV_HANDLE iff out of memory */ +PQhandle pqHeapInsert( TESSalloc* alloc, PriorityQHeap *pq, PQkey keyNew ) +{ + int curr; + PQhandle free; + + curr = ++ pq->size; + if( (curr*2) > pq->max ) { + if (!alloc->memrealloc) + { + return INV_HANDLE; + } + else + { + PQnode *saveNodes= pq->nodes; + PQhandleElem *saveHandles= pq->handles; + + // If the heap overflows, double its size. + pq->max <<= 1; + pq->nodes = (PQnode *)alloc->memrealloc( alloc->userData, pq->nodes, + (size_t)((pq->max + 1) * sizeof( pq->nodes[0] ))); + if (pq->nodes == NULL) { + pq->nodes = saveNodes; // restore ptr to free upon return + return INV_HANDLE; + } + pq->handles = (PQhandleElem *)alloc->memrealloc( alloc->userData, pq->handles, + (size_t) ((pq->max + 1) * sizeof( pq->handles[0] ))); + if (pq->handles == NULL) { + pq->handles = saveHandles; // restore ptr to free upon return + return INV_HANDLE; + } + } + } + + if( pq->freeList == 0 ) { + free = curr; + } else { + free = pq->freeList; + pq->freeList = pq->handles[free].node; + } + + pq->nodes[curr].handle = free; + pq->handles[free].node = curr; + pq->handles[free].key = keyNew; + + if( pq->initialized ) { + FloatUp( pq, curr ); + } + assert(free != INV_HANDLE); + return free; +} + +/* really pqHeapExtractMin */ +PQkey pqHeapExtractMin( PriorityQHeap *pq ) +{ + PQnode *n = pq->nodes; + PQhandleElem *h = pq->handles; + PQhandle hMin = n[1].handle; + PQkey min = h[hMin].key; + + if( pq->size > 0 ) { + n[1].handle = n[pq->size].handle; + h[n[1].handle].node = 1; + + h[hMin].key = NULL; + h[hMin].node = pq->freeList; + pq->freeList = hMin; + + if( -- pq->size > 0 ) { + FloatDown( pq, 1 ); + } + } + return min; +} + +/* really pqHeapDelete */ +void pqHeapDelete( PriorityQHeap *pq, PQhandle hCurr ) +{ + PQnode *n = pq->nodes; + PQhandleElem *h = pq->handles; + int curr; + + assert( hCurr >= 1 && hCurr <= pq->max && h[hCurr].key != NULL ); + + curr = h[hCurr].node; + n[curr].handle = n[pq->size].handle; + h[n[curr].handle].node = curr; + + if( curr <= -- pq->size ) { + if( curr <= 1 || LEQ( h[n[curr>>1].handle].key, h[n[curr].handle].key )) { + FloatDown( pq, curr ); + } else { + FloatUp( pq, curr ); + } + } + h[hCurr].key = NULL; + h[hCurr].node = pq->freeList; + pq->freeList = hCurr; +} + + + +/* Now redefine all the function names to map to their "Sort" versions. */ + +/* really tessPqSortNewPriorityQ */ +PriorityQ *pqNewPriorityQ( TESSalloc* alloc, int size, int (*leq)(PQkey key1, PQkey key2) ) +{ + PriorityQ *pq = (PriorityQ *)alloc->memalloc( alloc->userData, sizeof( PriorityQ )); + if (pq == NULL) return NULL; + + pq->heap = pqHeapNewPriorityQ( alloc, size, leq ); + if (pq->heap == NULL) { + alloc->memfree( alloc->userData, pq ); + return NULL; + } + +// pq->keys = (PQkey *)memAlloc( INIT_SIZE * sizeof(pq->keys[0]) ); + pq->keys = (PQkey *)alloc->memalloc( alloc->userData, size * sizeof(pq->keys[0]) ); + if (pq->keys == NULL) { + pqHeapDeletePriorityQ( alloc, pq->heap ); + alloc->memfree( alloc->userData, pq ); + return NULL; + } + + pq->size = 0; + pq->max = size; //INIT_SIZE; + pq->initialized = FALSE; + pq->leq = leq; + + return pq; +} + +/* really tessPqSortDeletePriorityQ */ +void pqDeletePriorityQ( TESSalloc* alloc, PriorityQ *pq ) +{ + assert(pq != NULL); + if (pq->heap != NULL) pqHeapDeletePriorityQ( alloc, pq->heap ); + if (pq->order != NULL) alloc->memfree( alloc->userData, pq->order ); + if (pq->keys != NULL) alloc->memfree( alloc->userData, pq->keys ); + alloc->memfree( alloc->userData, pq ); +} + + +#define LT(x,y) (! LEQ(y,x)) +#define GT(x,y) (! LEQ(x,y)) +#define Swap(a,b) if(1){PQkey *tmp = *a; *a = *b; *b = tmp;}else + +/* really tessPqSortInit */ +int pqInit( TESSalloc* alloc, PriorityQ *pq ) +{ + PQkey **p, **r, **i, **j, *piv; + struct { PQkey **p, **r; } Stack[50], *top = Stack; + unsigned int seed = 2016473283; + + /* Create an array of indirect pointers to the keys, so that we + * the handles we have returned are still valid. + */ + /* + pq->order = (PQkey **)memAlloc( (size_t) + (pq->size * sizeof(pq->order[0])) ); + */ + pq->order = (PQkey **)alloc->memalloc( alloc->userData, + (size_t)((pq->size+1) * sizeof(pq->order[0])) ); + /* the previous line is a patch to compensate for the fact that IBM */ + /* machines return a null on a malloc of zero bytes (unlike SGI), */ + /* so we have to put in this defense to guard against a memory */ + /* fault four lines down. from fossum@austin.ibm.com. */ + if (pq->order == NULL) return 0; + + p = pq->order; + r = p + pq->size - 1; + for( piv = pq->keys, i = p; i <= r; ++piv, ++i ) { + *i = piv; + } + + /* Sort the indirect pointers in descending order, + * using randomized Quicksort + */ + top->p = p; top->r = r; ++top; + while( --top >= Stack ) { + p = top->p; + r = top->r; + while( r > p + 10 ) { + seed = seed * 1539415821 + 1; + i = p + seed % (r - p + 1); + piv = *i; + *i = *p; + *p = piv; + i = p - 1; + j = r + 1; + do { + do { ++i; } while( GT( **i, *piv )); + do { --j; } while( LT( **j, *piv )); + Swap( i, j ); + } while( i < j ); + Swap( i, j ); /* Undo last swap */ + if( i - p < r - j ) { + top->p = j+1; top->r = r; ++top; + r = i-1; + } else { + top->p = p; top->r = i-1; ++top; + p = j+1; + } + } + /* Insertion sort small lists */ + for( i = p+1; i <= r; ++i ) { + piv = *i; + for( j = i; j > p && LT( **(j-1), *piv ); --j ) { + *j = *(j-1); + } + *j = piv; + } + } + pq->max = pq->size; + pq->initialized = TRUE; + pqHeapInit( pq->heap ); /* always succeeds */ + +#ifndef NDEBUG + p = pq->order; + r = p + pq->size - 1; + for( i = p; i < r; ++i ) { + assert( LEQ( **(i+1), **i )); + } +#endif + + return 1; +} + +/* really tessPqSortInsert */ +/* returns INV_HANDLE iff out of memory */ +PQhandle pqInsert( TESSalloc* alloc, PriorityQ *pq, PQkey keyNew ) +{ + int curr; + + if( pq->initialized ) { + return pqHeapInsert( alloc, pq->heap, keyNew ); + } + curr = pq->size; + if( ++ pq->size >= pq->max ) { + if (!alloc->memrealloc) + { + return INV_HANDLE; + } + else + { + PQkey *saveKey= pq->keys; + // If the heap overflows, double its size. + pq->max <<= 1; + pq->keys = (PQkey *)alloc->memrealloc( alloc->userData, pq->keys, + (size_t)(pq->max * sizeof( pq->keys[0] ))); + if (pq->keys == NULL) { + pq->keys = saveKey; // restore ptr to free upon return + return INV_HANDLE; + } + } + } + assert(curr != INV_HANDLE); + pq->keys[curr] = keyNew; + + /* Negative handles index the sorted array. */ + return -(curr+1); +} + +/* really tessPqSortExtractMin */ +PQkey pqExtractMin( PriorityQ *pq ) +{ + PQkey sortMin, heapMin; + + if( pq->size == 0 ) { + return pqHeapExtractMin( pq->heap ); + } + sortMin = *(pq->order[pq->size-1]); + if( ! pqHeapIsEmpty( pq->heap )) { + heapMin = pqHeapMinimum( pq->heap ); + if( LEQ( heapMin, sortMin )) { + return pqHeapExtractMin( pq->heap ); + } + } + do { + -- pq->size; + } while( pq->size > 0 && *(pq->order[pq->size-1]) == NULL ); + return sortMin; +} + +/* really tessPqSortMinimum */ +PQkey pqMinimum( PriorityQ *pq ) +{ + PQkey sortMin, heapMin; + + if( pq->size == 0 ) { + return pqHeapMinimum( pq->heap ); + } + sortMin = *(pq->order[pq->size-1]); + if( ! pqHeapIsEmpty( pq->heap )) { + heapMin = pqHeapMinimum( pq->heap ); + if( LEQ( heapMin, sortMin )) { + return heapMin; + } + } + return sortMin; +} + +/* really tessPqSortIsEmpty */ +int pqIsEmpty( PriorityQ *pq ) +{ + return (pq->size == 0) && pqHeapIsEmpty( pq->heap ); +} + +/* really tessPqSortDelete */ +void pqDelete( PriorityQ *pq, PQhandle curr ) +{ + if( curr >= 0 ) { + pqHeapDelete( pq->heap, curr ); + return; + } + curr = -(curr+1); + assert( curr < pq->max && pq->keys[curr] != NULL ); + + pq->keys[curr] = NULL; + while( pq->size > 0 && *(pq->order[pq->size-1]) == NULL ) { + -- pq->size; + } +} diff --git a/jni/jni/libtess2/Source/priorityq.h b/jni/jni/libtess2/Source/priorityq.h new file mode 100755 index 000000000..6ef1c05f5 --- /dev/null +++ b/jni/jni/libtess2/Source/priorityq.h @@ -0,0 +1,104 @@ +/* +** SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008) +** Copyright (C) [dates of first publication] Silicon Graphics, Inc. +** All Rights Reserved. +** +** Permission is hereby granted, free of charge, to any person obtaining a copy +** of this software and associated documentation files (the "Software"), to deal +** in the Software without restriction, including without limitation the rights +** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +** of the Software, and to permit persons to whom the Software is furnished to do so, +** subject to the following conditions: +** +** The above copyright notice including the dates of first publication and either this +** permission notice or a reference to http://oss.sgi.com/projects/FreeB/ shall be +** included in all copies or substantial portions of the Software. +** +** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +** INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A +** PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL SILICON GRAPHICS, INC. +** BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE +** OR OTHER DEALINGS IN THE SOFTWARE. +** +** Except as contained in this notice, the name of Silicon Graphics, Inc. shall not +** be used in advertising or otherwise to promote the sale, use or other dealings in +** this Software without prior written authorization from Silicon Graphics, Inc. +*/ +/* +** Author: Eric Veach, July 1994. +*/ + +#ifndef PRIORITYQ_H +#define PRIORITYQ_H + +/* The basic operations are insertion of a new key (pqInsert), +* and examination/extraction of a key whose value is minimum +* (pqMinimum/pqExtractMin). Deletion is also allowed (pqDelete); +* for this purpose pqInsert returns a "handle" which is supplied +* as the argument. +* +* An initial heap may be created efficiently by calling pqInsert +* repeatedly, then calling pqInit. In any case pqInit must be called +* before any operations other than pqInsert are used. +* +* If the heap is empty, pqMinimum/pqExtractMin will return a NULL key. +* This may also be tested with pqIsEmpty. +*/ + +/* Since we support deletion the data structure is a little more +* complicated than an ordinary heap. "nodes" is the heap itself; +* active nodes are stored in the range 1..pq->size. When the +* heap exceeds its allocated size (pq->max), its size doubles. +* The children of node i are nodes 2i and 2i+1. +* +* Each node stores an index into an array "handles". Each handle +* stores a key, plus a pointer back to the node which currently +* represents that key (ie. nodes[handles[i].node].handle == i). +*/ + +typedef void *PQkey; +typedef int PQhandle; +typedef struct PriorityQHeap PriorityQHeap; + +#define INV_HANDLE 0x0fffffff + +typedef struct { PQhandle handle; } PQnode; +typedef struct { PQkey key; PQhandle node; } PQhandleElem; + +struct PriorityQHeap { + + PQnode *nodes; + PQhandleElem *handles; + int size, max; + PQhandle freeList; + int initialized; + + int (*leq)(PQkey key1, PQkey key2); +}; + +typedef struct PriorityQ PriorityQ; + +struct PriorityQ { + PriorityQHeap *heap; + + PQkey *keys; + PQkey **order; + PQhandle size, max; + int initialized; + + int (*leq)(PQkey key1, PQkey key2); +}; + +PriorityQ *pqNewPriorityQ( TESSalloc* alloc, int size, int (*leq)(PQkey key1, PQkey key2) ); +void pqDeletePriorityQ( TESSalloc* alloc, PriorityQ *pq ); + +int pqInit( TESSalloc* alloc, PriorityQ *pq ); +PQhandle pqInsert( TESSalloc* alloc, PriorityQ *pq, PQkey key ); +PQkey pqExtractMin( PriorityQ *pq ); +void pqDelete( PriorityQ *pq, PQhandle handle ); + +PQkey pqMinimum( PriorityQ *pq ); +int pqIsEmpty( PriorityQ *pq ); + +#endif diff --git a/jni/jni/libtess2/Source/sweep.c b/jni/jni/libtess2/Source/sweep.c new file mode 100755 index 000000000..32a56bf40 --- /dev/null +++ b/jni/jni/libtess2/Source/sweep.c @@ -0,0 +1,1324 @@ +/* +** SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008) +** Copyright (C) [dates of first publication] Silicon Graphics, Inc. +** All Rights Reserved. +** +** Permission is hereby granted, free of charge, to any person obtaining a copy +** of this software and associated documentation files (the "Software"), to deal +** in the Software without restriction, including without limitation the rights +** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +** of the Software, and to permit persons to whom the Software is furnished to do so, +** subject to the following conditions: +** +** The above copyright notice including the dates of first publication and either this +** permission notice or a reference to http://oss.sgi.com/projects/FreeB/ shall be +** included in all copies or substantial portions of the Software. +** +** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +** INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A +** PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL SILICON GRAPHICS, INC. +** BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE +** OR OTHER DEALINGS IN THE SOFTWARE. +** +** Except as contained in this notice, the name of Silicon Graphics, Inc. shall not +** be used in advertising or otherwise to promote the sale, use or other dealings in +** this Software without prior written authorization from Silicon Graphics, Inc. +*/ +/* +** Author: Eric Veach, July 1994. +*/ + +#include +#include +#include /* longjmp */ + +#include "mesh.h" +#include "geom.h" +#include "tess.h" +#include "dict.h" +#include "priorityq.h" +#include "bucketalloc.h" +#include "sweep.h" + +#define TRUE 1 +#define FALSE 0 + +#ifdef FOR_TRITE_TEST_PROGRAM +extern void DebugEvent( TESStesselator *tess ); +#else +#define DebugEvent( tess ) +#endif + +/* +* Invariants for the Edge Dictionary. +* - each pair of adjacent edges e2=Succ(e1) satisfies EdgeLeq(e1,e2) +* at any valid location of the sweep event +* - if EdgeLeq(e2,e1) as well (at any valid sweep event), then e1 and e2 +* share a common endpoint +* - for each e, e->Dst has been processed, but not e->Org +* - each edge e satisfies VertLeq(e->Dst,event) && VertLeq(event,e->Org) +* where "event" is the current sweep line event. +* - no edge e has zero length +* +* Invariants for the Mesh (the processed portion). +* - the portion of the mesh left of the sweep line is a planar graph, +* ie. there is *some* way to embed it in the plane +* - no processed edge has zero length +* - no two processed vertices have identical coordinates +* - each "inside" region is monotone, ie. can be broken into two chains +* of monotonically increasing vertices according to VertLeq(v1,v2) +* - a non-invariant: these chains may intersect (very slightly) +* +* Invariants for the Sweep. +* - if none of the edges incident to the event vertex have an activeRegion +* (ie. none of these edges are in the edge dictionary), then the vertex +* has only right-going edges. +* - if an edge is marked "fixUpperEdge" (it is a temporary edge introduced +* by ConnectRightVertex), then it is the only right-going edge from +* its associated vertex. (This says that these edges exist only +* when it is necessary.) +*/ + +#define MAX(x,y) ((x) >= (y) ? (x) : (y)) +#define MIN(x,y) ((x) <= (y) ? (x) : (y)) + +/* When we merge two edges into one, we need to compute the combined +* winding of the new edge. +*/ +#define AddWinding(eDst,eSrc) (eDst->winding += eSrc->winding, \ + eDst->Sym->winding += eSrc->Sym->winding) + +static void SweepEvent( TESStesselator *tess, TESSvertex *vEvent ); +static void WalkDirtyRegions( TESStesselator *tess, ActiveRegion *regUp ); +static int CheckForRightSplice( TESStesselator *tess, ActiveRegion *regUp ); + +static int EdgeLeq( TESStesselator *tess, ActiveRegion *reg1, ActiveRegion *reg2 ) +/* +* Both edges must be directed from right to left (this is the canonical +* direction for the upper edge of each region). +* +* The strategy is to evaluate a "t" value for each edge at the +* current sweep line position, given by tess->event. The calculations +* are designed to be very stable, but of course they are not perfect. +* +* Special case: if both edge destinations are at the sweep event, +* we sort the edges by slope (they would otherwise compare equally). +*/ +{ + TESSvertex *event = tess->event; + TESShalfEdge *e1, *e2; + TESSreal t1, t2; + + e1 = reg1->eUp; + e2 = reg2->eUp; + + if( e1->Dst == event ) { + if( e2->Dst == event ) { + /* Two edges right of the sweep line which meet at the sweep event. + * Sort them by slope. + */ + if( VertLeq( e1->Org, e2->Org )) { + return EdgeSign( e2->Dst, e1->Org, e2->Org ) <= 0; + } + return EdgeSign( e1->Dst, e2->Org, e1->Org ) >= 0; + } + return EdgeSign( e2->Dst, event, e2->Org ) <= 0; + } + if( e2->Dst == event ) { + return EdgeSign( e1->Dst, event, e1->Org ) >= 0; + } + + /* General case - compute signed distance *from* e1, e2 to event */ + t1 = EdgeEval( e1->Dst, event, e1->Org ); + t2 = EdgeEval( e2->Dst, event, e2->Org ); + return (t1 >= t2); +} + + +static void DeleteRegion( TESStesselator *tess, ActiveRegion *reg ) +{ + if( reg->fixUpperEdge ) { + /* It was created with zero winding number, so it better be + * deleted with zero winding number (ie. it better not get merged + * with a real edge). + */ + assert( reg->eUp->winding == 0 ); + } + reg->eUp->activeRegion = NULL; + dictDelete( tess->dict, reg->nodeUp ); + bucketFree( tess->regionPool, reg ); +} + + +static int FixUpperEdge( TESStesselator *tess, ActiveRegion *reg, TESShalfEdge *newEdge ) +/* +* Replace an upper edge which needs fixing (see ConnectRightVertex). +*/ +{ + assert( reg->fixUpperEdge ); + if ( !tessMeshDelete( tess->mesh, reg->eUp ) ) return 0; + reg->fixUpperEdge = FALSE; + reg->eUp = newEdge; + newEdge->activeRegion = reg; + + return 1; +} + +static ActiveRegion *TopLeftRegion( TESStesselator *tess, ActiveRegion *reg ) +{ + TESSvertex *org = reg->eUp->Org; + TESShalfEdge *e; + + /* Find the region above the uppermost edge with the same origin */ + do { + reg = RegionAbove( reg ); + } while( reg->eUp->Org == org ); + + /* If the edge above was a temporary edge introduced by ConnectRightVertex, + * now is the time to fix it. + */ + if( reg->fixUpperEdge ) { + e = tessMeshConnect( tess->mesh, RegionBelow(reg)->eUp->Sym, reg->eUp->Lnext ); + if (e == NULL) return NULL; + if ( !FixUpperEdge( tess, reg, e ) ) return NULL; + reg = RegionAbove( reg ); + } + return reg; +} + +static ActiveRegion *TopRightRegion( ActiveRegion *reg ) +{ + TESSvertex *dst = reg->eUp->Dst; + + /* Find the region above the uppermost edge with the same destination */ + do { + reg = RegionAbove( reg ); + } while( reg->eUp->Dst == dst ); + return reg; +} + +static ActiveRegion *AddRegionBelow( TESStesselator *tess, + ActiveRegion *regAbove, + TESShalfEdge *eNewUp ) +/* +* Add a new active region to the sweep line, *somewhere* below "regAbove" +* (according to where the new edge belongs in the sweep-line dictionary). +* The upper edge of the new region will be "eNewUp". +* Winding number and "inside" flag are not updated. +*/ +{ + ActiveRegion *regNew = (ActiveRegion *)bucketAlloc( tess->regionPool ); + if (regNew == NULL) longjmp(tess->env,1); + + regNew->eUp = eNewUp; + regNew->nodeUp = dictInsertBefore( tess->dict, regAbove->nodeUp, regNew ); + if (regNew->nodeUp == NULL) longjmp(tess->env,1); + regNew->fixUpperEdge = FALSE; + regNew->sentinel = FALSE; + regNew->dirty = FALSE; + + eNewUp->activeRegion = regNew; + return regNew; +} + +static int IsWindingInside( TESStesselator *tess, int n ) +{ + switch( tess->windingRule ) { + case TESS_WINDING_ODD: + return (n & 1); + case TESS_WINDING_NONZERO: + return (n != 0); + case TESS_WINDING_POSITIVE: + return (n > 0); + case TESS_WINDING_NEGATIVE: + return (n < 0); + case TESS_WINDING_ABS_GEQ_TWO: + return (n >= 2) || (n <= -2); + } + /*LINTED*/ + assert( FALSE ); + /*NOTREACHED*/ + + return( FALSE ); +} + + +static void ComputeWinding( TESStesselator *tess, ActiveRegion *reg ) +{ + reg->windingNumber = RegionAbove(reg)->windingNumber + reg->eUp->winding; + reg->inside = IsWindingInside( tess, reg->windingNumber ); +} + + +static void FinishRegion( TESStesselator *tess, ActiveRegion *reg ) +/* +* Delete a region from the sweep line. This happens when the upper +* and lower chains of a region meet (at a vertex on the sweep line). +* The "inside" flag is copied to the appropriate mesh face (we could +* not do this before -- since the structure of the mesh is always +* changing, this face may not have even existed until now). +*/ +{ + TESShalfEdge *e = reg->eUp; + TESSface *f = e->Lface; + + f->inside = reg->inside; + f->anEdge = e; /* optimization for tessMeshTessellateMonoRegion() */ + DeleteRegion( tess, reg ); +} + + +static TESShalfEdge *FinishLeftRegions( TESStesselator *tess, + ActiveRegion *regFirst, ActiveRegion *regLast ) +/* +* We are given a vertex with one or more left-going edges. All affected +* edges should be in the edge dictionary. Starting at regFirst->eUp, +* we walk down deleting all regions where both edges have the same +* origin vOrg. At the same time we copy the "inside" flag from the +* active region to the face, since at this point each face will belong +* to at most one region (this was not necessarily true until this point +* in the sweep). The walk stops at the region above regLast; if regLast +* is NULL we walk as far as possible. At the same time we relink the +* mesh if necessary, so that the ordering of edges around vOrg is the +* same as in the dictionary. +*/ +{ + ActiveRegion *reg, *regPrev; + TESShalfEdge *e, *ePrev; + + regPrev = regFirst; + ePrev = regFirst->eUp; + while( regPrev != regLast ) { + regPrev->fixUpperEdge = FALSE; /* placement was OK */ + reg = RegionBelow( regPrev ); + e = reg->eUp; + if( e->Org != ePrev->Org ) { + if( ! reg->fixUpperEdge ) { + /* Remove the last left-going edge. Even though there are no further + * edges in the dictionary with this origin, there may be further + * such edges in the mesh (if we are adding left edges to a vertex + * that has already been processed). Thus it is important to call + * FinishRegion rather than just DeleteRegion. + */ + FinishRegion( tess, regPrev ); + break; + } + /* If the edge below was a temporary edge introduced by + * ConnectRightVertex, now is the time to fix it. + */ + e = tessMeshConnect( tess->mesh, ePrev->Lprev, e->Sym ); + if (e == NULL) longjmp(tess->env,1); + if ( !FixUpperEdge( tess, reg, e ) ) longjmp(tess->env,1); + } + + /* Relink edges so that ePrev->Onext == e */ + if( ePrev->Onext != e ) { + if ( !tessMeshSplice( tess->mesh, e->Oprev, e ) ) longjmp(tess->env,1); + if ( !tessMeshSplice( tess->mesh, ePrev, e ) ) longjmp(tess->env,1); + } + FinishRegion( tess, regPrev ); /* may change reg->eUp */ + ePrev = reg->eUp; + regPrev = reg; + } + return ePrev; +} + + +static void AddRightEdges( TESStesselator *tess, ActiveRegion *regUp, + TESShalfEdge *eFirst, TESShalfEdge *eLast, TESShalfEdge *eTopLeft, + int cleanUp ) +/* +* Purpose: insert right-going edges into the edge dictionary, and update +* winding numbers and mesh connectivity appropriately. All right-going +* edges share a common origin vOrg. Edges are inserted CCW starting at +* eFirst; the last edge inserted is eLast->Oprev. If vOrg has any +* left-going edges already processed, then eTopLeft must be the edge +* such that an imaginary upward vertical segment from vOrg would be +* contained between eTopLeft->Oprev and eTopLeft; otherwise eTopLeft +* should be NULL. +*/ +{ + ActiveRegion *reg, *regPrev; + TESShalfEdge *e, *ePrev; + int firstTime = TRUE; + + /* Insert the new right-going edges in the dictionary */ + e = eFirst; + do { + assert( VertLeq( e->Org, e->Dst )); + AddRegionBelow( tess, regUp, e->Sym ); + e = e->Onext; + } while ( e != eLast ); + + /* Walk *all* right-going edges from e->Org, in the dictionary order, + * updating the winding numbers of each region, and re-linking the mesh + * edges to match the dictionary ordering (if necessary). + */ + if( eTopLeft == NULL ) { + eTopLeft = RegionBelow( regUp )->eUp->Rprev; + } + regPrev = regUp; + ePrev = eTopLeft; + for( ;; ) { + reg = RegionBelow( regPrev ); + e = reg->eUp->Sym; + if( e->Org != ePrev->Org ) break; + + if( e->Onext != ePrev ) { + /* Unlink e from its current position, and relink below ePrev */ + if ( !tessMeshSplice( tess->mesh, e->Oprev, e ) ) longjmp(tess->env,1); + if ( !tessMeshSplice( tess->mesh, ePrev->Oprev, e ) ) longjmp(tess->env,1); + } + /* Compute the winding number and "inside" flag for the new regions */ + reg->windingNumber = regPrev->windingNumber - e->winding; + reg->inside = IsWindingInside( tess, reg->windingNumber ); + + /* Check for two outgoing edges with same slope -- process these + * before any intersection tests (see example in tessComputeInterior). + */ + regPrev->dirty = TRUE; + if( ! firstTime && CheckForRightSplice( tess, regPrev )) { + AddWinding( e, ePrev ); + DeleteRegion( tess, regPrev ); + if ( !tessMeshDelete( tess->mesh, ePrev ) ) longjmp(tess->env,1); + } + firstTime = FALSE; + regPrev = reg; + ePrev = e; + } + regPrev->dirty = TRUE; + assert( regPrev->windingNumber - e->winding == reg->windingNumber ); + + if( cleanUp ) { + /* Check for intersections between newly adjacent edges. */ + WalkDirtyRegions( tess, regPrev ); + } +} + + +static void SpliceMergeVertices( TESStesselator *tess, TESShalfEdge *e1, + TESShalfEdge *e2 ) +/* +* Two vertices with idential coordinates are combined into one. +* e1->Org is kept, while e2->Org is discarded. +*/ +{ + if ( !tessMeshSplice( tess->mesh, e1, e2 ) ) longjmp(tess->env,1); +} + +static void VertexWeights( TESSvertex *isect, TESSvertex *org, TESSvertex *dst, + TESSreal *weights ) +/* +* Find some weights which describe how the intersection vertex is +* a linear combination of "org" and "dest". Each of the two edges +* which generated "isect" is allocated 50% of the weight; each edge +* splits the weight between its org and dst according to the +* relative distance to "isect". +*/ +{ + TESSreal t1 = VertL1dist( org, isect ); + TESSreal t2 = VertL1dist( dst, isect ); + + weights[0] = (TESSreal)0.5 * t2 / (t1 + t2); + weights[1] = (TESSreal)0.5 * t1 / (t1 + t2); + isect->coords[0] += weights[0]*org->coords[0] + weights[1]*dst->coords[0]; + isect->coords[1] += weights[0]*org->coords[1] + weights[1]*dst->coords[1]; + isect->coords[2] += weights[0]*org->coords[2] + weights[1]*dst->coords[2]; +} + + +static void GetIntersectData( TESStesselator *tess, TESSvertex *isect, + TESSvertex *orgUp, TESSvertex *dstUp, + TESSvertex *orgLo, TESSvertex *dstLo ) + /* + * We've computed a new intersection point, now we need a "data" pointer + * from the user so that we can refer to this new vertex in the + * rendering callbacks. + */ +{ + TESSreal weights[4]; + TESS_NOTUSED( tess ); + + isect->coords[0] = isect->coords[1] = isect->coords[2] = 0; + isect->idx = TESS_UNDEF; + VertexWeights( isect, orgUp, dstUp, &weights[0] ); + VertexWeights( isect, orgLo, dstLo, &weights[2] ); +} + +static int CheckForRightSplice( TESStesselator *tess, ActiveRegion *regUp ) +/* +* Check the upper and lower edge of "regUp", to make sure that the +* eUp->Org is above eLo, or eLo->Org is below eUp (depending on which +* origin is leftmost). +* +* The main purpose is to splice right-going edges with the same +* dest vertex and nearly identical slopes (ie. we can't distinguish +* the slopes numerically). However the splicing can also help us +* to recover from numerical errors. For example, suppose at one +* point we checked eUp and eLo, and decided that eUp->Org is barely +* above eLo. Then later, we split eLo into two edges (eg. from +* a splice operation like this one). This can change the result of +* our test so that now eUp->Org is incident to eLo, or barely below it. +* We must correct this condition to maintain the dictionary invariants. +* +* One possibility is to check these edges for intersection again +* (ie. CheckForIntersect). This is what we do if possible. However +* CheckForIntersect requires that tess->event lies between eUp and eLo, +* so that it has something to fall back on when the intersection +* calculation gives us an unusable answer. So, for those cases where +* we can't check for intersection, this routine fixes the problem +* by just splicing the offending vertex into the other edge. +* This is a guaranteed solution, no matter how degenerate things get. +* Basically this is a combinatorial solution to a numerical problem. +*/ +{ + ActiveRegion *regLo = RegionBelow(regUp); + TESShalfEdge *eUp = regUp->eUp; + TESShalfEdge *eLo = regLo->eUp; + + if( VertLeq( eUp->Org, eLo->Org )) { + if( EdgeSign( eLo->Dst, eUp->Org, eLo->Org ) > 0 ) return FALSE; + + /* eUp->Org appears to be below eLo */ + if( ! VertEq( eUp->Org, eLo->Org )) { + /* Splice eUp->Org into eLo */ + if ( tessMeshSplitEdge( tess->mesh, eLo->Sym ) == NULL) longjmp(tess->env,1); + if ( !tessMeshSplice( tess->mesh, eUp, eLo->Oprev ) ) longjmp(tess->env,1); + regUp->dirty = regLo->dirty = TRUE; + + } else if( eUp->Org != eLo->Org ) { + /* merge the two vertices, discarding eUp->Org */ + pqDelete( tess->pq, eUp->Org->pqHandle ); + SpliceMergeVertices( tess, eLo->Oprev, eUp ); + } + } else { + if( EdgeSign( eUp->Dst, eLo->Org, eUp->Org ) <= 0 ) return FALSE; + + /* eLo->Org appears to be above eUp, so splice eLo->Org into eUp */ + RegionAbove(regUp)->dirty = regUp->dirty = TRUE; + if (tessMeshSplitEdge( tess->mesh, eUp->Sym ) == NULL) longjmp(tess->env,1); + if ( !tessMeshSplice( tess->mesh, eLo->Oprev, eUp ) ) longjmp(tess->env,1); + } + return TRUE; +} + +static int CheckForLeftSplice( TESStesselator *tess, ActiveRegion *regUp ) +/* +* Check the upper and lower edge of "regUp", to make sure that the +* eUp->Dst is above eLo, or eLo->Dst is below eUp (depending on which +* destination is rightmost). +* +* Theoretically, this should always be true. However, splitting an edge +* into two pieces can change the results of previous tests. For example, +* suppose at one point we checked eUp and eLo, and decided that eUp->Dst +* is barely above eLo. Then later, we split eLo into two edges (eg. from +* a splice operation like this one). This can change the result of +* the test so that now eUp->Dst is incident to eLo, or barely below it. +* We must correct this condition to maintain the dictionary invariants +* (otherwise new edges might get inserted in the wrong place in the +* dictionary, and bad stuff will happen). +* +* We fix the problem by just splicing the offending vertex into the +* other edge. +*/ +{ + ActiveRegion *regLo = RegionBelow(regUp); + TESShalfEdge *eUp = regUp->eUp; + TESShalfEdge *eLo = regLo->eUp; + TESShalfEdge *e; + + assert( ! VertEq( eUp->Dst, eLo->Dst )); + + if( VertLeq( eUp->Dst, eLo->Dst )) { + if( EdgeSign( eUp->Dst, eLo->Dst, eUp->Org ) < 0 ) return FALSE; + + /* eLo->Dst is above eUp, so splice eLo->Dst into eUp */ + RegionAbove(regUp)->dirty = regUp->dirty = TRUE; + e = tessMeshSplitEdge( tess->mesh, eUp ); + if (e == NULL) longjmp(tess->env,1); + if ( !tessMeshSplice( tess->mesh, eLo->Sym, e ) ) longjmp(tess->env,1); + e->Lface->inside = regUp->inside; + } else { + if( EdgeSign( eLo->Dst, eUp->Dst, eLo->Org ) > 0 ) return FALSE; + + /* eUp->Dst is below eLo, so splice eUp->Dst into eLo */ + regUp->dirty = regLo->dirty = TRUE; + e = tessMeshSplitEdge( tess->mesh, eLo ); + if (e == NULL) longjmp(tess->env,1); + if ( !tessMeshSplice( tess->mesh, eUp->Lnext, eLo->Sym ) ) longjmp(tess->env,1); + e->Rface->inside = regUp->inside; + } + return TRUE; +} + + +static int CheckForIntersect( TESStesselator *tess, ActiveRegion *regUp ) +/* +* Check the upper and lower edges of the given region to see if +* they intersect. If so, create the intersection and add it +* to the data structures. +* +* Returns TRUE if adding the new intersection resulted in a recursive +* call to AddRightEdges(); in this case all "dirty" regions have been +* checked for intersections, and possibly regUp has been deleted. +*/ +{ + ActiveRegion *regLo = RegionBelow(regUp); + TESShalfEdge *eUp = regUp->eUp; + TESShalfEdge *eLo = regLo->eUp; + TESSvertex *orgUp = eUp->Org; + TESSvertex *orgLo = eLo->Org; + TESSvertex *dstUp = eUp->Dst; + TESSvertex *dstLo = eLo->Dst; + TESSreal tMinUp, tMaxLo; + TESSvertex isect, *orgMin; + TESShalfEdge *e; + + assert( ! VertEq( dstLo, dstUp )); + assert( EdgeSign( dstUp, tess->event, orgUp ) <= 0 ); + assert( EdgeSign( dstLo, tess->event, orgLo ) >= 0 ); + assert( orgUp != tess->event && orgLo != tess->event ); + assert( ! regUp->fixUpperEdge && ! regLo->fixUpperEdge ); + + if( orgUp == orgLo ) return FALSE; /* right endpoints are the same */ + + tMinUp = MIN( orgUp->t, dstUp->t ); + tMaxLo = MAX( orgLo->t, dstLo->t ); + if( tMinUp > tMaxLo ) return FALSE; /* t ranges do not overlap */ + + if( VertLeq( orgUp, orgLo )) { + if( EdgeSign( dstLo, orgUp, orgLo ) > 0 ) return FALSE; + } else { + if( EdgeSign( dstUp, orgLo, orgUp ) < 0 ) return FALSE; + } + + /* At this point the edges intersect, at least marginally */ + DebugEvent( tess ); + + tesedgeIntersect( dstUp, orgUp, dstLo, orgLo, &isect ); + /* The following properties are guaranteed: */ + assert( MIN( orgUp->t, dstUp->t ) <= isect.t ); + assert( isect.t <= MAX( orgLo->t, dstLo->t )); + assert( MIN( dstLo->s, dstUp->s ) <= isect.s ); + assert( isect.s <= MAX( orgLo->s, orgUp->s )); + + if( VertLeq( &isect, tess->event )) { + /* The intersection point lies slightly to the left of the sweep line, + * so move it until it''s slightly to the right of the sweep line. + * (If we had perfect numerical precision, this would never happen + * in the first place). The easiest and safest thing to do is + * replace the intersection by tess->event. + */ + isect.s = tess->event->s; + isect.t = tess->event->t; + } + /* Similarly, if the computed intersection lies to the right of the + * rightmost origin (which should rarely happen), it can cause + * unbelievable inefficiency on sufficiently degenerate inputs. + * (If you have the test program, try running test54.d with the + * "X zoom" option turned on). + */ + orgMin = VertLeq( orgUp, orgLo ) ? orgUp : orgLo; + if( VertLeq( orgMin, &isect )) { + isect.s = orgMin->s; + isect.t = orgMin->t; + } + + if( VertEq( &isect, orgUp ) || VertEq( &isect, orgLo )) { + /* Easy case -- intersection at one of the right endpoints */ + (void) CheckForRightSplice( tess, regUp ); + return FALSE; + } + + if( (! VertEq( dstUp, tess->event ) + && EdgeSign( dstUp, tess->event, &isect ) >= 0) + || (! VertEq( dstLo, tess->event ) + && EdgeSign( dstLo, tess->event, &isect ) <= 0 )) + { + /* Very unusual -- the new upper or lower edge would pass on the + * wrong side of the sweep event, or through it. This can happen + * due to very small numerical errors in the intersection calculation. + */ + if( dstLo == tess->event ) { + /* Splice dstLo into eUp, and process the new region(s) */ + if (tessMeshSplitEdge( tess->mesh, eUp->Sym ) == NULL) longjmp(tess->env,1); + if ( !tessMeshSplice( tess->mesh, eLo->Sym, eUp ) ) longjmp(tess->env,1); + regUp = TopLeftRegion( tess, regUp ); + if (regUp == NULL) longjmp(tess->env,1); + eUp = RegionBelow(regUp)->eUp; + FinishLeftRegions( tess, RegionBelow(regUp), regLo ); + AddRightEdges( tess, regUp, eUp->Oprev, eUp, eUp, TRUE ); + return TRUE; + } + if( dstUp == tess->event ) { + /* Splice dstUp into eLo, and process the new region(s) */ + if (tessMeshSplitEdge( tess->mesh, eLo->Sym ) == NULL) longjmp(tess->env,1); + if ( !tessMeshSplice( tess->mesh, eUp->Lnext, eLo->Oprev ) ) longjmp(tess->env,1); + regLo = regUp; + regUp = TopRightRegion( regUp ); + e = RegionBelow(regUp)->eUp->Rprev; + regLo->eUp = eLo->Oprev; + eLo = FinishLeftRegions( tess, regLo, NULL ); + AddRightEdges( tess, regUp, eLo->Onext, eUp->Rprev, e, TRUE ); + return TRUE; + } + /* Special case: called from ConnectRightVertex. If either + * edge passes on the wrong side of tess->event, split it + * (and wait for ConnectRightVertex to splice it appropriately). + */ + if( EdgeSign( dstUp, tess->event, &isect ) >= 0 ) { + RegionAbove(regUp)->dirty = regUp->dirty = TRUE; + if (tessMeshSplitEdge( tess->mesh, eUp->Sym ) == NULL) longjmp(tess->env,1); + eUp->Org->s = tess->event->s; + eUp->Org->t = tess->event->t; + } + if( EdgeSign( dstLo, tess->event, &isect ) <= 0 ) { + regUp->dirty = regLo->dirty = TRUE; + if (tessMeshSplitEdge( tess->mesh, eLo->Sym ) == NULL) longjmp(tess->env,1); + eLo->Org->s = tess->event->s; + eLo->Org->t = tess->event->t; + } + /* leave the rest for ConnectRightVertex */ + return FALSE; + } + + /* General case -- split both edges, splice into new vertex. + * When we do the splice operation, the order of the arguments is + * arbitrary as far as correctness goes. However, when the operation + * creates a new face, the work done is proportional to the size of + * the new face. We expect the faces in the processed part of + * the mesh (ie. eUp->Lface) to be smaller than the faces in the + * unprocessed original contours (which will be eLo->Oprev->Lface). + */ + if (tessMeshSplitEdge( tess->mesh, eUp->Sym ) == NULL) longjmp(tess->env,1); + if (tessMeshSplitEdge( tess->mesh, eLo->Sym ) == NULL) longjmp(tess->env,1); + if ( !tessMeshSplice( tess->mesh, eLo->Oprev, eUp ) ) longjmp(tess->env,1); + eUp->Org->s = isect.s; + eUp->Org->t = isect.t; + eUp->Org->pqHandle = pqInsert( &tess->alloc, tess->pq, eUp->Org ); + if (eUp->Org->pqHandle == INV_HANDLE) { + pqDeletePriorityQ( &tess->alloc, tess->pq ); + tess->pq = NULL; + longjmp(tess->env,1); + } + GetIntersectData( tess, eUp->Org, orgUp, dstUp, orgLo, dstLo ); + RegionAbove(regUp)->dirty = regUp->dirty = regLo->dirty = TRUE; + return FALSE; +} + +static void WalkDirtyRegions( TESStesselator *tess, ActiveRegion *regUp ) +/* +* When the upper or lower edge of any region changes, the region is +* marked "dirty". This routine walks through all the dirty regions +* and makes sure that the dictionary invariants are satisfied +* (see the comments at the beginning of this file). Of course +* new dirty regions can be created as we make changes to restore +* the invariants. +*/ +{ + ActiveRegion *regLo = RegionBelow(regUp); + TESShalfEdge *eUp, *eLo; + + for( ;; ) { + /* Find the lowest dirty region (we walk from the bottom up). */ + while( regLo->dirty ) { + regUp = regLo; + regLo = RegionBelow(regLo); + } + if( ! regUp->dirty ) { + regLo = regUp; + regUp = RegionAbove( regUp ); + if( regUp == NULL || ! regUp->dirty ) { + /* We've walked all the dirty regions */ + return; + } + } + regUp->dirty = FALSE; + eUp = regUp->eUp; + eLo = regLo->eUp; + + if( eUp->Dst != eLo->Dst ) { + /* Check that the edge ordering is obeyed at the Dst vertices. */ + if( CheckForLeftSplice( tess, regUp )) { + + /* If the upper or lower edge was marked fixUpperEdge, then + * we no longer need it (since these edges are needed only for + * vertices which otherwise have no right-going edges). + */ + if( regLo->fixUpperEdge ) { + DeleteRegion( tess, regLo ); + if ( !tessMeshDelete( tess->mesh, eLo ) ) longjmp(tess->env,1); + regLo = RegionBelow( regUp ); + eLo = regLo->eUp; + } else if( regUp->fixUpperEdge ) { + DeleteRegion( tess, regUp ); + if ( !tessMeshDelete( tess->mesh, eUp ) ) longjmp(tess->env,1); + regUp = RegionAbove( regLo ); + eUp = regUp->eUp; + } + } + } + if( eUp->Org != eLo->Org ) { + if( eUp->Dst != eLo->Dst + && ! regUp->fixUpperEdge && ! regLo->fixUpperEdge + && (eUp->Dst == tess->event || eLo->Dst == tess->event) ) + { + /* When all else fails in CheckForIntersect(), it uses tess->event + * as the intersection location. To make this possible, it requires + * that tess->event lie between the upper and lower edges, and also + * that neither of these is marked fixUpperEdge (since in the worst + * case it might splice one of these edges into tess->event, and + * violate the invariant that fixable edges are the only right-going + * edge from their associated vertex). + */ + if( CheckForIntersect( tess, regUp )) { + /* WalkDirtyRegions() was called recursively; we're done */ + return; + } + } else { + /* Even though we can't use CheckForIntersect(), the Org vertices + * may violate the dictionary edge ordering. Check and correct this. + */ + (void) CheckForRightSplice( tess, regUp ); + } + } + if( eUp->Org == eLo->Org && eUp->Dst == eLo->Dst ) { + /* A degenerate loop consisting of only two edges -- delete it. */ + AddWinding( eLo, eUp ); + DeleteRegion( tess, regUp ); + if ( !tessMeshDelete( tess->mesh, eUp ) ) longjmp(tess->env,1); + regUp = RegionAbove( regLo ); + } + } +} + + +static void ConnectRightVertex( TESStesselator *tess, ActiveRegion *regUp, + TESShalfEdge *eBottomLeft ) +/* +* Purpose: connect a "right" vertex vEvent (one where all edges go left) +* to the unprocessed portion of the mesh. Since there are no right-going +* edges, two regions (one above vEvent and one below) are being merged +* into one. "regUp" is the upper of these two regions. +* +* There are two reasons for doing this (adding a right-going edge): +* - if the two regions being merged are "inside", we must add an edge +* to keep them separated (the combined region would not be monotone). +* - in any case, we must leave some record of vEvent in the dictionary, +* so that we can merge vEvent with features that we have not seen yet. +* For example, maybe there is a vertical edge which passes just to +* the right of vEvent; we would like to splice vEvent into this edge. +* +* However, we don't want to connect vEvent to just any vertex. We don''t +* want the new edge to cross any other edges; otherwise we will create +* intersection vertices even when the input data had no self-intersections. +* (This is a bad thing; if the user's input data has no intersections, +* we don't want to generate any false intersections ourselves.) +* +* Our eventual goal is to connect vEvent to the leftmost unprocessed +* vertex of the combined region (the union of regUp and regLo). +* But because of unseen vertices with all right-going edges, and also +* new vertices which may be created by edge intersections, we don''t +* know where that leftmost unprocessed vertex is. In the meantime, we +* connect vEvent to the closest vertex of either chain, and mark the region +* as "fixUpperEdge". This flag says to delete and reconnect this edge +* to the next processed vertex on the boundary of the combined region. +* Quite possibly the vertex we connected to will turn out to be the +* closest one, in which case we won''t need to make any changes. +*/ +{ + TESShalfEdge *eNew; + TESShalfEdge *eTopLeft = eBottomLeft->Onext; + ActiveRegion *regLo = RegionBelow(regUp); + TESShalfEdge *eUp = regUp->eUp; + TESShalfEdge *eLo = regLo->eUp; + int degenerate = FALSE; + + if( eUp->Dst != eLo->Dst ) { + (void) CheckForIntersect( tess, regUp ); + } + + /* Possible new degeneracies: upper or lower edge of regUp may pass + * through vEvent, or may coincide with new intersection vertex + */ + if( VertEq( eUp->Org, tess->event )) { + if ( !tessMeshSplice( tess->mesh, eTopLeft->Oprev, eUp ) ) longjmp(tess->env,1); + regUp = TopLeftRegion( tess, regUp ); + if (regUp == NULL) longjmp(tess->env,1); + eTopLeft = RegionBelow( regUp )->eUp; + FinishLeftRegions( tess, RegionBelow(regUp), regLo ); + degenerate = TRUE; + } + if( VertEq( eLo->Org, tess->event )) { + if ( !tessMeshSplice( tess->mesh, eBottomLeft, eLo->Oprev ) ) longjmp(tess->env,1); + eBottomLeft = FinishLeftRegions( tess, regLo, NULL ); + degenerate = TRUE; + } + if( degenerate ) { + AddRightEdges( tess, regUp, eBottomLeft->Onext, eTopLeft, eTopLeft, TRUE ); + return; + } + + /* Non-degenerate situation -- need to add a temporary, fixable edge. + * Connect to the closer of eLo->Org, eUp->Org. + */ + if( VertLeq( eLo->Org, eUp->Org )) { + eNew = eLo->Oprev; + } else { + eNew = eUp; + } + eNew = tessMeshConnect( tess->mesh, eBottomLeft->Lprev, eNew ); + if (eNew == NULL) longjmp(tess->env,1); + + /* Prevent cleanup, otherwise eNew might disappear before we've even + * had a chance to mark it as a temporary edge. + */ + AddRightEdges( tess, regUp, eNew, eNew->Onext, eNew->Onext, FALSE ); + eNew->Sym->activeRegion->fixUpperEdge = TRUE; + WalkDirtyRegions( tess, regUp ); +} + +/* Because vertices at exactly the same location are merged together +* before we process the sweep event, some degenerate cases can't occur. +* However if someone eventually makes the modifications required to +* merge features which are close together, the cases below marked +* TOLERANCE_NONZERO will be useful. They were debugged before the +* code to merge identical vertices in the main loop was added. +*/ +#define TOLERANCE_NONZERO FALSE + +static void ConnectLeftDegenerate( TESStesselator *tess, + ActiveRegion *regUp, TESSvertex *vEvent ) +/* +* The event vertex lies exacty on an already-processed edge or vertex. +* Adding the new vertex involves splicing it into the already-processed +* part of the mesh. +*/ +{ + TESShalfEdge *e, *eTopLeft, *eTopRight, *eLast; + ActiveRegion *reg; + + e = regUp->eUp; + if( VertEq( e->Org, vEvent )) { + /* e->Org is an unprocessed vertex - just combine them, and wait + * for e->Org to be pulled from the queue + */ + assert( TOLERANCE_NONZERO ); + SpliceMergeVertices( tess, e, vEvent->anEdge ); + return; + } + + if( ! VertEq( e->Dst, vEvent )) { + /* General case -- splice vEvent into edge e which passes through it */ + if (tessMeshSplitEdge( tess->mesh, e->Sym ) == NULL) longjmp(tess->env,1); + if( regUp->fixUpperEdge ) { + /* This edge was fixable -- delete unused portion of original edge */ + if ( !tessMeshDelete( tess->mesh, e->Onext ) ) longjmp(tess->env,1); + regUp->fixUpperEdge = FALSE; + } + if ( !tessMeshSplice( tess->mesh, vEvent->anEdge, e ) ) longjmp(tess->env,1); + SweepEvent( tess, vEvent ); /* recurse */ + return; + } + + /* vEvent coincides with e->Dst, which has already been processed. + * Splice in the additional right-going edges. + */ + assert( TOLERANCE_NONZERO ); + regUp = TopRightRegion( regUp ); + reg = RegionBelow( regUp ); + eTopRight = reg->eUp->Sym; + eTopLeft = eLast = eTopRight->Onext; + if( reg->fixUpperEdge ) { + /* Here e->Dst has only a single fixable edge going right. + * We can delete it since now we have some real right-going edges. + */ + assert( eTopLeft != eTopRight ); /* there are some left edges too */ + DeleteRegion( tess, reg ); + if ( !tessMeshDelete( tess->mesh, eTopRight ) ) longjmp(tess->env,1); + eTopRight = eTopLeft->Oprev; + } + if ( !tessMeshSplice( tess->mesh, vEvent->anEdge, eTopRight ) ) longjmp(tess->env,1); + if( ! EdgeGoesLeft( eTopLeft )) { + /* e->Dst had no left-going edges -- indicate this to AddRightEdges() */ + eTopLeft = NULL; + } + AddRightEdges( tess, regUp, eTopRight->Onext, eLast, eTopLeft, TRUE ); +} + + +static void ConnectLeftVertex( TESStesselator *tess, TESSvertex *vEvent ) +/* +* Purpose: connect a "left" vertex (one where both edges go right) +* to the processed portion of the mesh. Let R be the active region +* containing vEvent, and let U and L be the upper and lower edge +* chains of R. There are two possibilities: +* +* - the normal case: split R into two regions, by connecting vEvent to +* the rightmost vertex of U or L lying to the left of the sweep line +* +* - the degenerate case: if vEvent is close enough to U or L, we +* merge vEvent into that edge chain. The subcases are: +* - merging with the rightmost vertex of U or L +* - merging with the active edge of U or L +* - merging with an already-processed portion of U or L +*/ +{ + ActiveRegion *regUp, *regLo, *reg; + TESShalfEdge *eUp, *eLo, *eNew; + ActiveRegion tmp; + + /* assert( vEvent->anEdge->Onext->Onext == vEvent->anEdge ); */ + + /* Get a pointer to the active region containing vEvent */ + tmp.eUp = vEvent->anEdge->Sym; + /* __GL_DICTLISTKEY */ /* tessDictListSearch */ + regUp = (ActiveRegion *)dictKey( dictSearch( tess->dict, &tmp )); + regLo = RegionBelow( regUp ); + if( !regLo ) { + // This may happen if the input polygon is coplanar. + return; + } + eUp = regUp->eUp; + eLo = regLo->eUp; + + /* Try merging with U or L first */ + if( EdgeSign( eUp->Dst, vEvent, eUp->Org ) == 0 ) { + ConnectLeftDegenerate( tess, regUp, vEvent ); + return; + } + + /* Connect vEvent to rightmost processed vertex of either chain. + * e->Dst is the vertex that we will connect to vEvent. + */ + reg = VertLeq( eLo->Dst, eUp->Dst ) ? regUp : regLo; + + if( regUp->inside || reg->fixUpperEdge) { + if( reg == regUp ) { + eNew = tessMeshConnect( tess->mesh, vEvent->anEdge->Sym, eUp->Lnext ); + if (eNew == NULL) longjmp(tess->env,1); + } else { + TESShalfEdge *tempHalfEdge= tessMeshConnect( tess->mesh, eLo->Dnext, vEvent->anEdge); + if (tempHalfEdge == NULL) longjmp(tess->env,1); + + eNew = tempHalfEdge->Sym; + } + if( reg->fixUpperEdge ) { + if ( !FixUpperEdge( tess, reg, eNew ) ) longjmp(tess->env,1); + } else { + ComputeWinding( tess, AddRegionBelow( tess, regUp, eNew )); + } + SweepEvent( tess, vEvent ); + } else { + /* The new vertex is in a region which does not belong to the polygon. + * We don''t need to connect this vertex to the rest of the mesh. + */ + AddRightEdges( tess, regUp, vEvent->anEdge, vEvent->anEdge, NULL, TRUE ); + } +} + + +static void SweepEvent( TESStesselator *tess, TESSvertex *vEvent ) +/* +* Does everything necessary when the sweep line crosses a vertex. +* Updates the mesh and the edge dictionary. +*/ +{ + ActiveRegion *regUp, *reg; + TESShalfEdge *e, *eTopLeft, *eBottomLeft; + + tess->event = vEvent; /* for access in EdgeLeq() */ + DebugEvent( tess ); + + /* Check if this vertex is the right endpoint of an edge that is + * already in the dictionary. In this case we don't need to waste + * time searching for the location to insert new edges. + */ + e = vEvent->anEdge; + while( e->activeRegion == NULL ) { + e = e->Onext; + if( e == vEvent->anEdge ) { + /* All edges go right -- not incident to any processed edges */ + ConnectLeftVertex( tess, vEvent ); + return; + } + } + + /* Processing consists of two phases: first we "finish" all the + * active regions where both the upper and lower edges terminate + * at vEvent (ie. vEvent is closing off these regions). + * We mark these faces "inside" or "outside" the polygon according + * to their winding number, and delete the edges from the dictionary. + * This takes care of all the left-going edges from vEvent. + */ + regUp = TopLeftRegion( tess, e->activeRegion ); + if (regUp == NULL) longjmp(tess->env,1); + reg = RegionBelow( regUp ); + eTopLeft = reg->eUp; + eBottomLeft = FinishLeftRegions( tess, reg, NULL ); + + /* Next we process all the right-going edges from vEvent. This + * involves adding the edges to the dictionary, and creating the + * associated "active regions" which record information about the + * regions between adjacent dictionary edges. + */ + if( eBottomLeft->Onext == eTopLeft ) { + /* No right-going edges -- add a temporary "fixable" edge */ + ConnectRightVertex( tess, regUp, eBottomLeft ); + } else { + AddRightEdges( tess, regUp, eBottomLeft->Onext, eTopLeft, eTopLeft, TRUE ); + } +} + + +/* Make the sentinel coordinates big enough that they will never be +* merged with real input features. +*/ + +static void AddSentinel( TESStesselator *tess, TESSreal smin, TESSreal smax, TESSreal t ) +/* +* We add two sentinel edges above and below all other edges, +* to avoid special cases at the top and bottom. +*/ +{ + TESShalfEdge *e; + ActiveRegion *reg = (ActiveRegion *)bucketAlloc( tess->regionPool ); + if (reg == NULL) longjmp(tess->env,1); + + e = tessMeshMakeEdge( tess->mesh ); + if (e == NULL) longjmp(tess->env,1); + + e->Org->s = smax; + e->Org->t = t; + e->Dst->s = smin; + e->Dst->t = t; + tess->event = e->Dst; /* initialize it */ + + reg->eUp = e; + reg->windingNumber = 0; + reg->inside = FALSE; + reg->fixUpperEdge = FALSE; + reg->sentinel = TRUE; + reg->dirty = FALSE; + reg->nodeUp = dictInsert( tess->dict, reg ); + if (reg->nodeUp == NULL) longjmp(tess->env,1); +} + + +static void InitEdgeDict( TESStesselator *tess ) +/* +* We maintain an ordering of edge intersections with the sweep line. +* This order is maintained in a dynamic dictionary. +*/ +{ + TESSreal w, h; + TESSreal smin, smax, tmin, tmax; + + tess->dict = dictNewDict( &tess->alloc, tess, (int (*)(void *, DictKey, DictKey)) EdgeLeq ); + if (tess->dict == NULL) longjmp(tess->env,1); + + /* If the bbox is empty, ensure that sentinels are not coincident by slightly enlarging it. */ + w = (tess->bmax[0] - tess->bmin[0]) + (TESSreal)0.01; + h = (tess->bmax[1] - tess->bmin[1]) + (TESSreal)0.01; + + smin = tess->bmin[0] - w; + smax = tess->bmax[0] + w; + tmin = tess->bmin[1] - h; + tmax = tess->bmax[1] + h; + + AddSentinel( tess, smin, smax, tmin ); + AddSentinel( tess, smin, smax, tmax ); +} + + +static void DoneEdgeDict( TESStesselator *tess ) +{ + ActiveRegion *reg; + int fixedEdges = 0; + + while( (reg = (ActiveRegion *)dictKey( dictMin( tess->dict ))) != NULL ) { + /* + * At the end of all processing, the dictionary should contain + * only the two sentinel edges, plus at most one "fixable" edge + * created by ConnectRightVertex(). + */ + if( ! reg->sentinel ) { + assert( reg->fixUpperEdge ); + assert( ++fixedEdges == 1 ); + } + assert( reg->windingNumber == 0 ); + DeleteRegion( tess, reg ); + /* tessMeshDelete( reg->eUp );*/ + } + dictDeleteDict( &tess->alloc, tess->dict ); +} + + +static void RemoveDegenerateEdges( TESStesselator *tess ) +/* +* Remove zero-length edges, and contours with fewer than 3 vertices. +*/ +{ + TESShalfEdge *e, *eNext, *eLnext; + TESShalfEdge *eHead = &tess->mesh->eHead; + + /*LINTED*/ + for( e = eHead->next; e != eHead; e = eNext ) { + eNext = e->next; + eLnext = e->Lnext; + + if( VertEq( e->Org, e->Dst ) && e->Lnext->Lnext != e ) { + /* Zero-length edge, contour has at least 3 edges */ + + SpliceMergeVertices( tess, eLnext, e ); /* deletes e->Org */ + if ( !tessMeshDelete( tess->mesh, e ) ) longjmp(tess->env,1); /* e is a self-loop */ + e = eLnext; + eLnext = e->Lnext; + } + if( eLnext->Lnext == e ) { + /* Degenerate contour (one or two edges) */ + + if( eLnext != e ) { + if( eLnext == eNext || eLnext == eNext->Sym ) { eNext = eNext->next; } + if ( !tessMeshDelete( tess->mesh, eLnext ) ) longjmp(tess->env,1); + } + if( e == eNext || e == eNext->Sym ) { eNext = eNext->next; } + if ( !tessMeshDelete( tess->mesh, e ) ) longjmp(tess->env,1); + } + } +} + +static int InitPriorityQ( TESStesselator *tess ) +/* +* Insert all vertices into the priority queue which determines the +* order in which vertices cross the sweep line. +*/ +{ + PriorityQ *pq; + TESSvertex *v, *vHead; + int vertexCount = 0; + + vHead = &tess->mesh->vHead; + for( v = vHead->next; v != vHead; v = v->next ) { + vertexCount++; + } + /* Make sure there is enough space for sentinels. */ + vertexCount += MAX( 8, tess->alloc.extraVertices ); + + pq = tess->pq = pqNewPriorityQ( &tess->alloc, vertexCount, (int (*)(PQkey, PQkey)) tesvertLeq ); + if (pq == NULL) return 0; + + vHead = &tess->mesh->vHead; + for( v = vHead->next; v != vHead; v = v->next ) { + v->pqHandle = pqInsert( &tess->alloc, pq, v ); + if (v->pqHandle == INV_HANDLE) + break; + } + if (v != vHead || !pqInit( &tess->alloc, pq ) ) { + pqDeletePriorityQ( &tess->alloc, tess->pq ); + tess->pq = NULL; + return 0; + } + + return 1; +} + + +static void DonePriorityQ( TESStesselator *tess ) +{ + pqDeletePriorityQ( &tess->alloc, tess->pq ); +} + + +static int RemoveDegenerateFaces( TESStesselator *tess, TESSmesh *mesh ) +/* +* Delete any degenerate faces with only two edges. WalkDirtyRegions() +* will catch almost all of these, but it won't catch degenerate faces +* produced by splice operations on already-processed edges. +* The two places this can happen are in FinishLeftRegions(), when +* we splice in a "temporary" edge produced by ConnectRightVertex(), +* and in CheckForLeftSplice(), where we splice already-processed +* edges to ensure that our dictionary invariants are not violated +* by numerical errors. +* +* In both these cases it is *very* dangerous to delete the offending +* edge at the time, since one of the routines further up the stack +* will sometimes be keeping a pointer to that edge. +*/ +{ + TESSface *f, *fNext; + TESShalfEdge *e; + + /*LINTED*/ + for( f = mesh->fHead.next; f != &mesh->fHead; f = fNext ) { + fNext = f->next; + e = f->anEdge; + assert( e->Lnext != e ); + + if( e->Lnext->Lnext == e ) { + /* A face with only two edges */ + AddWinding( e->Onext, e ); + if ( !tessMeshDelete( tess->mesh, e ) ) return 0; + } + } + return 1; +} + +int tessComputeInterior( TESStesselator *tess ) +/* +* tessComputeInterior( tess ) computes the planar arrangement specified +* by the given contours, and further subdivides this arrangement +* into regions. Each region is marked "inside" if it belongs +* to the polygon, according to the rule given by tess->windingRule. +* Each interior region is guaranteed be monotone. +*/ +{ + TESSvertex *v, *vNext; + + /* Each vertex defines an event for our sweep line. Start by inserting + * all the vertices in a priority queue. Events are processed in + * lexicographic order, ie. + * + * e1 < e2 iff e1.x < e2.x || (e1.x == e2.x && e1.y < e2.y) + */ + RemoveDegenerateEdges( tess ); + if ( !InitPriorityQ( tess ) ) return 0; /* if error */ + InitEdgeDict( tess ); + + while( (v = (TESSvertex *)pqExtractMin( tess->pq )) != NULL ) { + for( ;; ) { + vNext = (TESSvertex *)pqMinimum( tess->pq ); + if( vNext == NULL || ! VertEq( vNext, v )) break; + + /* Merge together all vertices at exactly the same location. + * This is more efficient than processing them one at a time, + * simplifies the code (see ConnectLeftDegenerate), and is also + * important for correct handling of certain degenerate cases. + * For example, suppose there are two identical edges A and B + * that belong to different contours (so without this code they would + * be processed by separate sweep events). Suppose another edge C + * crosses A and B from above. When A is processed, we split it + * at its intersection point with C. However this also splits C, + * so when we insert B we may compute a slightly different + * intersection point. This might leave two edges with a small + * gap between them. This kind of error is especially obvious + * when using boundary extraction (TESS_BOUNDARY_ONLY). + */ + vNext = (TESSvertex *)pqExtractMin( tess->pq ); + SpliceMergeVertices( tess, v->anEdge, vNext->anEdge ); + } + SweepEvent( tess, v ); + } + + /* Set tess->event for debugging purposes */ + tess->event = ((ActiveRegion *) dictKey( dictMin( tess->dict )))->eUp->Org; + DebugEvent( tess ); + DoneEdgeDict( tess ); + DonePriorityQ( tess ); + + if ( !RemoveDegenerateFaces( tess, tess->mesh ) ) return 0; + tessMeshCheckMesh( tess->mesh ); + + return 1; +} diff --git a/jni/jni/libtess2/Source/sweep.h b/jni/jni/libtess2/Source/sweep.h new file mode 100755 index 000000000..32f0f86dc --- /dev/null +++ b/jni/jni/libtess2/Source/sweep.h @@ -0,0 +1,74 @@ +/* +** SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008) +** Copyright (C) [dates of first publication] Silicon Graphics, Inc. +** All Rights Reserved. +** +** Permission is hereby granted, free of charge, to any person obtaining a copy +** of this software and associated documentation files (the "Software"), to deal +** in the Software without restriction, including without limitation the rights +** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +** of the Software, and to permit persons to whom the Software is furnished to do so, +** subject to the following conditions: +** +** The above copyright notice including the dates of first publication and either this +** permission notice or a reference to http://oss.sgi.com/projects/FreeB/ shall be +** included in all copies or substantial portions of the Software. +** +** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +** INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A +** PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL SILICON GRAPHICS, INC. +** BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE +** OR OTHER DEALINGS IN THE SOFTWARE. +** +** Except as contained in this notice, the name of Silicon Graphics, Inc. shall not +** be used in advertising or otherwise to promote the sale, use or other dealings in +** this Software without prior written authorization from Silicon Graphics, Inc. +*/ +/* +** Author: Eric Veach, July 1994. +*/ + +#ifndef SWEEP_H +#define SWEEP_H + +#include "mesh.h" + +/* tessComputeInterior( tess ) computes the planar arrangement specified +* by the given contours, and further subdivides this arrangement +* into regions. Each region is marked "inside" if it belongs +* to the polygon, according to the rule given by tess->windingRule. +* Each interior region is guaranteed be monotone. +*/ +int tessComputeInterior( TESStesselator *tess ); + + +/* The following is here *only* for access by debugging routines */ + +#include "dict.h" + +/* For each pair of adjacent edges crossing the sweep line, there is +* an ActiveRegion to represent the region between them. The active +* regions are kept in sorted order in a dynamic dictionary. As the +* sweep line crosses each vertex, we update the affected regions. +*/ + +struct ActiveRegion { + TESShalfEdge *eUp; /* upper edge, directed right to left */ + DictNode *nodeUp; /* dictionary node corresponding to eUp */ + int windingNumber; /* used to determine which regions are + * inside the polygon */ + int inside; /* is this region inside the polygon? */ + int sentinel; /* marks fake edges at t = +/-infinity */ + int dirty; /* marks regions where the upper or lower + * edge has changed, but we haven't checked + * whether they intersect yet */ + int fixUpperEdge; /* marks temporary edges introduced when + * we process a "right vertex" (one without + * any edges leaving to the right) */ +}; + +#define RegionBelow(r) ((ActiveRegion *) dictKey(dictPred((r)->nodeUp))) +#define RegionAbove(r) ((ActiveRegion *) dictKey(dictSucc((r)->nodeUp))) + +#endif diff --git a/jni/jni/libtess2/Source/tess.c b/jni/jni/libtess2/Source/tess.c new file mode 100755 index 000000000..5f47f8de0 --- /dev/null +++ b/jni/jni/libtess2/Source/tess.c @@ -0,0 +1,1114 @@ +/* +** SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008) +** Copyright (C) [dates of first publication] Silicon Graphics, Inc. +** All Rights Reserved. +** +** Permission is hereby granted, free of charge, to any person obtaining a copy +** of this software and associated documentation files (the "Software"), to deal +** in the Software without restriction, including without limitation the rights +** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +** of the Software, and to permit persons to whom the Software is furnished to do so, +** subject to the following conditions: +** +** The above copyright notice including the dates of first publication and either this +** permission notice or a reference to http://oss.sgi.com/projects/FreeB/ shall be +** included in all copies or substantial portions of the Software. +** +** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +** INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A +** PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL SILICON GRAPHICS, INC. +** BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE +** OR OTHER DEALINGS IN THE SOFTWARE. +** +** Except as contained in this notice, the name of Silicon Graphics, Inc. shall not +** be used in advertising or otherwise to promote the sale, use or other dealings in +** this Software without prior written authorization from Silicon Graphics, Inc. +*/ +/* +** Author: Eric Veach, July 1994. +*/ + +#include +#include +#include +#include "bucketalloc.h" +#include "tess.h" +#include "mesh.h" +#include "sweep.h" +#include "geom.h" +#include +#include +#include + +#define TRUE 1 +#define FALSE 0 + +#define Dot(u,v) (u[0]*v[0] + u[1]*v[1] + u[2]*v[2]) + +#if defined(FOR_TRITE_TEST_PROGRAM) || defined(TRUE_PROJECT) +static void Normalize( TESSreal v[3] ) +{ + TESSreal len = v[0]*v[0] + v[1]*v[1] + v[2]*v[2]; + + assert( len > 0 ); + len = sqrtf( len ); + v[0] /= len; + v[1] /= len; + v[2] /= len; +} +#endif + +#define ABS(x) ((x) < 0 ? -(x) : (x)) + +static int LongAxis( TESSreal v[3] ) +{ + int i = 0; + + if( ABS(v[1]) > ABS(v[0]) ) { i = 1; } + if( ABS(v[2]) > ABS(v[i]) ) { i = 2; } + return i; +} + +static int ShortAxis( TESSreal v[3] ) +{ + int i = 0; + + if( ABS(v[1]) < ABS(v[0]) ) { i = 1; } + if( ABS(v[2]) < ABS(v[i]) ) { i = 2; } + return i; +} + +static void ComputeNormal( TESStesselator *tess, TESSreal norm[3] ) +{ + TESSvertex *v, *v1, *v2; + TESSreal c, tLen2, maxLen2; + TESSreal maxVal[3], minVal[3], d1[3], d2[3], tNorm[3]; + TESSvertex *maxVert[3], *minVert[3]; + TESSvertex *vHead = &tess->mesh->vHead; + int i; + + v = vHead->next; + for( i = 0; i < 3; ++i ) { + c = v->coords[i]; + minVal[i] = c; + minVert[i] = v; + maxVal[i] = c; + maxVert[i] = v; + } + + for( v = vHead->next; v != vHead; v = v->next ) { + for( i = 0; i < 3; ++i ) { + c = v->coords[i]; + if( c < minVal[i] ) { minVal[i] = c; minVert[i] = v; } + if( c > maxVal[i] ) { maxVal[i] = c; maxVert[i] = v; } + } + } + + /* Find two vertices separated by at least 1/sqrt(3) of the maximum + * distance between any two vertices + */ + i = 0; + if( maxVal[1] - minVal[1] > maxVal[0] - minVal[0] ) { i = 1; } + if( maxVal[2] - minVal[2] > maxVal[i] - minVal[i] ) { i = 2; } + if( minVal[i] >= maxVal[i] ) { + /* All vertices are the same -- normal doesn't matter */ + norm[0] = 0; norm[1] = 0; norm[2] = 1; + return; + } + + /* Look for a third vertex which forms the triangle with maximum area + * (Length of normal == twice the triangle area) + */ + maxLen2 = 0; + v1 = minVert[i]; + v2 = maxVert[i]; + d1[0] = v1->coords[0] - v2->coords[0]; + d1[1] = v1->coords[1] - v2->coords[1]; + d1[2] = v1->coords[2] - v2->coords[2]; + for( v = vHead->next; v != vHead; v = v->next ) { + d2[0] = v->coords[0] - v2->coords[0]; + d2[1] = v->coords[1] - v2->coords[1]; + d2[2] = v->coords[2] - v2->coords[2]; + tNorm[0] = d1[1]*d2[2] - d1[2]*d2[1]; + tNorm[1] = d1[2]*d2[0] - d1[0]*d2[2]; + tNorm[2] = d1[0]*d2[1] - d1[1]*d2[0]; + tLen2 = tNorm[0]*tNorm[0] + tNorm[1]*tNorm[1] + tNorm[2]*tNorm[2]; + if( tLen2 > maxLen2 ) { + maxLen2 = tLen2; + norm[0] = tNorm[0]; + norm[1] = tNorm[1]; + norm[2] = tNorm[2]; + } + } + + if( maxLen2 <= 0 ) { + /* All points lie on a single line -- any decent normal will do */ + norm[0] = norm[1] = norm[2] = 0; + norm[ShortAxis(d1)] = 1; + } +} + + +static void CheckOrientation( TESStesselator *tess ) +{ + TESSreal area; + TESSface *f, *fHead = &tess->mesh->fHead; + TESSvertex *v, *vHead = &tess->mesh->vHead; + TESShalfEdge *e; + + /* When we compute the normal automatically, we choose the orientation + * so that the the sum of the signed areas of all contours is non-negative. + */ + area = 0; + for( f = fHead->next; f != fHead; f = f->next ) { + e = f->anEdge; + if( e->winding <= 0 ) continue; + do { + area += (e->Org->s - e->Dst->s) * (e->Org->t + e->Dst->t); + e = e->Lnext; + } while( e != f->anEdge ); + } + if( area < 0 ) { + /* Reverse the orientation by flipping all the t-coordinates */ + for( v = vHead->next; v != vHead; v = v->next ) { + v->t = - v->t; + } + tess->tUnit[0] = - tess->tUnit[0]; + tess->tUnit[1] = - tess->tUnit[1]; + tess->tUnit[2] = - tess->tUnit[2]; + } +} + +#ifdef FOR_TRITE_TEST_PROGRAM +#include +extern int RandomSweep; +#define S_UNIT_X (RandomSweep ? (2*drand48()-1) : 1.0) +#define S_UNIT_Y (RandomSweep ? (2*drand48()-1) : 0.0) +#else +#if defined(SLANTED_SWEEP) +/* The "feature merging" is not intended to be complete. There are +* special cases where edges are nearly parallel to the sweep line +* which are not implemented. The algorithm should still behave +* robustly (ie. produce a reasonable tesselation) in the presence +* of such edges, however it may miss features which could have been +* merged. We could minimize this effect by choosing the sweep line +* direction to be something unusual (ie. not parallel to one of the +* coordinate axes). +*/ +#define S_UNIT_X (TESSreal)0.50941539564955385 /* Pre-normalized */ +#define S_UNIT_Y (TESSreal)0.86052074622010633 +#else +#define S_UNIT_X (TESSreal)1.0 +#define S_UNIT_Y (TESSreal)0.0 +#endif +#endif + +/* Determine the polygon normal and project vertices onto the plane +* of the polygon. +*/ +void tessProjectPolygon( TESStesselator *tess ) +{ + TESSvertex *v, *vHead = &tess->mesh->vHead; + TESSreal norm[3]; + TESSreal *sUnit, *tUnit; + int i, first, computedNormal = FALSE; + + norm[0] = tess->normal[0]; + norm[1] = tess->normal[1]; + norm[2] = tess->normal[2]; + if( norm[0] == 0 && norm[1] == 0 && norm[2] == 0 ) { + ComputeNormal( tess, norm ); + computedNormal = TRUE; + } + sUnit = tess->sUnit; + tUnit = tess->tUnit; + i = LongAxis( norm ); + +#if defined(FOR_TRITE_TEST_PROGRAM) || defined(TRUE_PROJECT) + /* Choose the initial sUnit vector to be approximately perpendicular + * to the normal. + */ + Normalize( norm ); + + sUnit[i] = 0; + sUnit[(i+1)%3] = S_UNIT_X; + sUnit[(i+2)%3] = S_UNIT_Y; + + /* Now make it exactly perpendicular */ + w = Dot( sUnit, norm ); + sUnit[0] -= w * norm[0]; + sUnit[1] -= w * norm[1]; + sUnit[2] -= w * norm[2]; + Normalize( sUnit ); + + /* Choose tUnit so that (sUnit,tUnit,norm) form a right-handed frame */ + tUnit[0] = norm[1]*sUnit[2] - norm[2]*sUnit[1]; + tUnit[1] = norm[2]*sUnit[0] - norm[0]*sUnit[2]; + tUnit[2] = norm[0]*sUnit[1] - norm[1]*sUnit[0]; + Normalize( tUnit ); +#else + /* Project perpendicular to a coordinate axis -- better numerically */ + sUnit[i] = 0; + sUnit[(i+1)%3] = S_UNIT_X; + sUnit[(i+2)%3] = S_UNIT_Y; + + tUnit[i] = 0; + tUnit[(i+1)%3] = (norm[i] > 0) ? -S_UNIT_Y : S_UNIT_Y; + tUnit[(i+2)%3] = (norm[i] > 0) ? S_UNIT_X : -S_UNIT_X; +#endif + + /* Project the vertices onto the sweep plane */ + for( v = vHead->next; v != vHead; v = v->next ) + { + v->s = Dot( v->coords, sUnit ); + v->t = Dot( v->coords, tUnit ); + } + if( computedNormal ) { + CheckOrientation( tess ); + } + + /* Compute ST bounds. */ + first = 1; + for( v = vHead->next; v != vHead; v = v->next ) + { + if (first) + { + tess->bmin[0] = tess->bmax[0] = v->s; + tess->bmin[1] = tess->bmax[1] = v->t; + first = 0; + } + else + { + if (v->s < tess->bmin[0]) tess->bmin[0] = v->s; + if (v->s > tess->bmax[0]) tess->bmax[0] = v->s; + if (v->t < tess->bmin[1]) tess->bmin[1] = v->t; + if (v->t > tess->bmax[1]) tess->bmax[1] = v->t; + } + } +} + +#define AddWinding(eDst,eSrc) (eDst->winding += eSrc->winding, \ + eDst->Sym->winding += eSrc->Sym->winding) + +/* tessMeshTessellateMonoRegion( face ) tessellates a monotone region +* (what else would it do??) The region must consist of a single +* loop of half-edges (see mesh.h) oriented CCW. "Monotone" in this +* case means that any vertical line intersects the interior of the +* region in a single interval. +* +* Tessellation consists of adding interior edges (actually pairs of +* half-edges), to split the region into non-overlapping triangles. +* +* The basic idea is explained in Preparata and Shamos (which I don''t +* have handy right now), although their implementation is more +* complicated than this one. The are two edge chains, an upper chain +* and a lower chain. We process all vertices from both chains in order, +* from right to left. +* +* The algorithm ensures that the following invariant holds after each +* vertex is processed: the untessellated region consists of two +* chains, where one chain (say the upper) is a single edge, and +* the other chain is concave. The left vertex of the single edge +* is always to the left of all vertices in the concave chain. +* +* Each step consists of adding the rightmost unprocessed vertex to one +* of the two chains, and forming a fan of triangles from the rightmost +* of two chain endpoints. Determining whether we can add each triangle +* to the fan is a simple orientation test. By making the fan as large +* as possible, we restore the invariant (check it yourself). +*/ +int tessMeshTessellateMonoRegion( TESSmesh *mesh, TESSface *face ) +{ + TESShalfEdge *up, *lo; + + /* All edges are oriented CCW around the boundary of the region. + * First, find the half-edge whose origin vertex is rightmost. + * Since the sweep goes from left to right, face->anEdge should + * be close to the edge we want. + */ + up = face->anEdge; + assert( up->Lnext != up && up->Lnext->Lnext != up ); + + for( ; VertLeq( up->Dst, up->Org ); up = up->Lprev ) + ; + for( ; VertLeq( up->Org, up->Dst ); up = up->Lnext ) + ; + lo = up->Lprev; + + while( up->Lnext != lo ) { + if( VertLeq( up->Dst, lo->Org )) { + /* up->Dst is on the left. It is safe to form triangles from lo->Org. + * The EdgeGoesLeft test guarantees progress even when some triangles + * are CW, given that the upper and lower chains are truly monotone. + */ + while( lo->Lnext != up && (EdgeGoesLeft( lo->Lnext ) + || EdgeSign( lo->Org, lo->Dst, lo->Lnext->Dst ) <= 0 )) { + TESShalfEdge *tempHalfEdge= tessMeshConnect( mesh, lo->Lnext, lo ); + if (tempHalfEdge == NULL) return 0; + lo = tempHalfEdge->Sym; + } + lo = lo->Lprev; + } else { + /* lo->Org is on the left. We can make CCW triangles from up->Dst. */ + while( lo->Lnext != up && (EdgeGoesRight( up->Lprev ) + || EdgeSign( up->Dst, up->Org, up->Lprev->Org ) >= 0 )) { + TESShalfEdge *tempHalfEdge= tessMeshConnect( mesh, up, up->Lprev ); + if (tempHalfEdge == NULL) return 0; + up = tempHalfEdge->Sym; + } + up = up->Lnext; + } + } + + /* Now lo->Org == up->Dst == the leftmost vertex. The remaining region + * can be tessellated in a fan from this leftmost vertex. + */ + assert( lo->Lnext != up ); + while( lo->Lnext->Lnext != up ) { + TESShalfEdge *tempHalfEdge= tessMeshConnect( mesh, lo->Lnext, lo ); + if (tempHalfEdge == NULL) return 0; + lo = tempHalfEdge->Sym; + } + + return 1; +} + +/* tessMeshTessellateInterior( mesh ) tessellates each region of +* the mesh which is marked "inside" the polygon. Each such region +* must be monotone. +*/ +int tessMeshTessellateInterior( TESSmesh *mesh ) +{ + TESSface *f, *next; + + /*LINTED*/ + for( f = mesh->fHead.next; f != &mesh->fHead; f = next ) { + /* Make sure we don''t try to tessellate the new triangles. */ + next = f->next; + if( f->inside ) { + if ( !tessMeshTessellateMonoRegion( mesh, f ) ) return 0; + } + } + return 1; +} + + +typedef struct EdgeStackNode EdgeStackNode; +typedef struct EdgeStack EdgeStack; + +struct EdgeStackNode { + TESShalfEdge *edge; + EdgeStackNode *next; +}; + +struct EdgeStack { + EdgeStackNode *top; + struct BucketAlloc *nodeBucket; +}; + +int stackInit( EdgeStack *stack, TESSalloc *alloc ) +{ + stack->top = NULL; + stack->nodeBucket = createBucketAlloc( alloc, "CDT nodes", sizeof(EdgeStackNode), 512 ); + return stack->nodeBucket != NULL; +} + +void stackDelete( EdgeStack *stack ) +{ + deleteBucketAlloc( stack->nodeBucket ); +} + +int stackEmpty( EdgeStack *stack ) +{ + return stack->top == NULL; +} + +void stackPush( EdgeStack *stack, TESShalfEdge *e ) +{ + EdgeStackNode *node = (EdgeStackNode *)bucketAlloc( stack->nodeBucket ); + if ( ! node ) return; + node->edge = e; + node->next = stack->top; + stack->top = node; +} + +TESShalfEdge *stackPop( EdgeStack *stack ) +{ + TESShalfEdge *e = NULL; + EdgeStackNode *node = stack->top; + if (node) { + stack->top = node->next; + e = node->edge; + bucketFree( stack->nodeBucket, node ); + } + return e; +} + + +// Starting with a valid triangulation, uses the Edge Flip algorithm to +// refine the triangulation into a Constrained Delaunay Triangulation. +void tessMeshRefineDelaunay( TESSmesh *mesh, TESSalloc *alloc ) +{ + // At this point, we have a valid, but not optimal, triangulation. + // We refine the triangulation using the Edge Flip algorithm + // + // 1) Find all internal edges + // 2) Mark all dual edges + // 3) insert all dual edges into a queue + + TESSface *f; + EdgeStack stack; + TESShalfEdge *e; + int maxFaces = 0, maxIter = 0, iter = 0; + + stackInit(&stack, alloc); + + for( f = mesh->fHead.next; f != &mesh->fHead; f = f->next ) { + if ( f->inside) { + e = f->anEdge; + do { + e->mark = EdgeIsInternal(e); // Mark internal edges + if (e->mark && !e->Sym->mark) stackPush(&stack, e); // Insert into queue + e = e->Lnext; + } while (e != f->anEdge); + maxFaces++; + } + } + + // The algorithm should converge on O(n^2), since the predicate is not robust, + // we'll save guard against infinite loop. + maxIter = maxFaces * maxFaces; + + // Pop stack until we find a reversed edge + // Flip the reversed edge, and insert any of the four opposite edges + // which are internal and not already in the stack (!marked) + while (!stackEmpty(&stack) && iter < maxIter) { + e = stackPop(&stack); + e->mark = e->Sym->mark = 0; + if (!tesedgeIsLocallyDelaunay(e)) { + TESShalfEdge *edges[4]; + int i; + tessMeshFlipEdge(mesh, e); + // for each opposite edge + edges[0] = e->Lnext; + edges[1] = e->Lprev; + edges[2] = e->Sym->Lnext; + edges[3] = e->Sym->Lprev; + for (i = 0; i < 4; i++) { + if (!edges[i]->mark && EdgeIsInternal(edges[i])) { + edges[i]->mark = edges[i]->Sym->mark = 1; + stackPush(&stack, edges[i]); + } + } + } + iter++; + } + + stackDelete(&stack); +} + + +/* tessMeshDiscardExterior( mesh ) zaps (ie. sets to NULL) all faces +* which are not marked "inside" the polygon. Since further mesh operations +* on NULL faces are not allowed, the main purpose is to clean up the +* mesh so that exterior loops are not represented in the data structure. +*/ +void tessMeshDiscardExterior( TESSmesh *mesh ) +{ + TESSface *f, *next; + + /*LINTED*/ + for( f = mesh->fHead.next; f != &mesh->fHead; f = next ) { + /* Since f will be destroyed, save its next pointer. */ + next = f->next; + if( ! f->inside ) { + tessMeshZapFace( mesh, f ); + } + } +} + +/* tessMeshSetWindingNumber( mesh, value, keepOnlyBoundary ) resets the +* winding numbers on all edges so that regions marked "inside" the +* polygon have a winding number of "value", and regions outside +* have a winding number of 0. +* +* If keepOnlyBoundary is TRUE, it also deletes all edges which do not +* separate an interior region from an exterior one. +*/ +int tessMeshSetWindingNumber( TESSmesh *mesh, int value, + int keepOnlyBoundary ) +{ + TESShalfEdge *e, *eNext; + + for( e = mesh->eHead.next; e != &mesh->eHead; e = eNext ) { + eNext = e->next; + if( e->Rface->inside != e->Lface->inside ) { + + /* This is a boundary edge (one side is interior, one is exterior). */ + e->winding = (e->Lface->inside) ? value : -value; + } else { + + /* Both regions are interior, or both are exterior. */ + if( ! keepOnlyBoundary ) { + e->winding = 0; + } else { + if ( !tessMeshDelete( mesh, e ) ) return 0; + } + } + } + return 1; +} + +void* heapAlloc( void* userData, unsigned int size ) +{ + TESS_NOTUSED( userData ); + return malloc( size ); +} + +void* heapRealloc( void *userData, void* ptr, unsigned int size ) +{ + TESS_NOTUSED( userData ); + return realloc( ptr, size ); +} + +void heapFree( void* userData, void* ptr ) +{ + TESS_NOTUSED( userData ); + free( ptr ); +} + +static TESSalloc defaulAlloc = +{ + heapAlloc, + heapRealloc, + heapFree, + 0, + 0, + 0, + 0, + 0, + 0, + 0, +}; + +TESStesselator* tessNewTess( TESSalloc* alloc ) +{ + TESStesselator* tess; + + if (alloc == NULL) + alloc = &defaulAlloc; + + /* Only initialize fields which can be changed by the api. Other fields + * are initialized where they are used. + */ + + tess = (TESStesselator *)alloc->memalloc( alloc->userData, sizeof( TESStesselator )); + if ( tess == NULL ) { + return 0; /* out of memory */ + } + tess->alloc = *alloc; + /* Check and set defaults. */ + if (tess->alloc.meshEdgeBucketSize == 0) + tess->alloc.meshEdgeBucketSize = 512; + if (tess->alloc.meshVertexBucketSize == 0) + tess->alloc.meshVertexBucketSize = 512; + if (tess->alloc.meshFaceBucketSize == 0) + tess->alloc.meshFaceBucketSize = 256; + if (tess->alloc.dictNodeBucketSize == 0) + tess->alloc.dictNodeBucketSize = 512; + if (tess->alloc.regionBucketSize == 0) + tess->alloc.regionBucketSize = 256; + + tess->normal[0] = 0; + tess->normal[1] = 0; + tess->normal[2] = 0; + + tess->bmin[0] = 0; + tess->bmin[1] = 0; + tess->bmax[0] = 0; + tess->bmax[1] = 0; + + tess->reverseContours = 0; + + tess->windingRule = TESS_WINDING_ODD; + tess->processCDT = 0; + + if (tess->alloc.regionBucketSize < 16) + tess->alloc.regionBucketSize = 16; + if (tess->alloc.regionBucketSize > 4096) + tess->alloc.regionBucketSize = 4096; + tess->regionPool = createBucketAlloc( &tess->alloc, "Regions", + sizeof(ActiveRegion), tess->alloc.regionBucketSize ); + + // Initialize to begin polygon. + tess->mesh = NULL; + + tess->outOfMemory = 0; + tess->vertexIndexCounter = 0; + + tess->vertices = 0; + tess->vertexIndices = 0; + tess->vertexCount = 0; + tess->elements = 0; + tess->elementCount = 0; + + return tess; +} + +void tessDeleteTess( TESStesselator *tess ) +{ + + struct TESSalloc alloc = tess->alloc; + + deleteBucketAlloc( tess->regionPool ); + + if( tess->mesh != NULL ) { + tessMeshDeleteMesh( &alloc, tess->mesh ); + tess->mesh = NULL; + } + if (tess->vertices != NULL) { + alloc.memfree( alloc.userData, tess->vertices ); + tess->vertices = 0; + } + if (tess->vertexIndices != NULL) { + alloc.memfree( alloc.userData, tess->vertexIndices ); + tess->vertexIndices = 0; + } + if (tess->elements != NULL) { + alloc.memfree( alloc.userData, tess->elements ); + tess->elements = 0; + } + + alloc.memfree( alloc.userData, tess ); +} + + +static TESSindex GetNeighbourFace(TESShalfEdge* edge) +{ + if (!edge->Rface) + return TESS_UNDEF; + if (!edge->Rface->inside) + return TESS_UNDEF; + return edge->Rface->n; +} + +void OutputPolymesh( TESStesselator *tess, TESSmesh *mesh, int elementType, int polySize, int vertexSize ) +{ + TESSvertex* v = 0; + TESSface* f = 0; + TESShalfEdge* edge = 0; + int maxFaceCount = 0; + int maxVertexCount = 0; + int faceVerts, i; + TESSindex *elements = 0; + TESSreal *vert; + + // Assume that the input data is triangles now. + // Try to merge as many polygons as possible + if (polySize > 3) + { + if (!tessMeshMergeConvexFaces( mesh, polySize )) + { + tess->outOfMemory = 1; + return; + } + } + + // Mark unused + for ( v = mesh->vHead.next; v != &mesh->vHead; v = v->next ) + v->n = TESS_UNDEF; + + // Create unique IDs for all vertices and faces. + for ( f = mesh->fHead.next; f != &mesh->fHead; f = f->next ) + { + f->n = TESS_UNDEF; + if( !f->inside ) continue; + + edge = f->anEdge; + faceVerts = 0; + do + { + v = edge->Org; + if ( v->n == TESS_UNDEF ) + { + v->n = maxVertexCount; + maxVertexCount++; + } + faceVerts++; + edge = edge->Lnext; + } + while (edge != f->anEdge); + + assert( faceVerts <= polySize ); + + f->n = maxFaceCount; + ++maxFaceCount; + } + + tess->elementCount = maxFaceCount; + if (elementType == TESS_CONNECTED_POLYGONS) + maxFaceCount *= 2; + tess->elements = (TESSindex*)tess->alloc.memalloc( tess->alloc.userData, + sizeof(TESSindex) * maxFaceCount * polySize ); + if (!tess->elements) + { + tess->outOfMemory = 1; + return; + } + + tess->vertexCount = maxVertexCount; + tess->vertices = (TESSreal*)tess->alloc.memalloc( tess->alloc.userData, + sizeof(TESSreal) * tess->vertexCount * vertexSize ); + if (!tess->vertices) + { + tess->outOfMemory = 1; + return; + } + + tess->vertexIndices = (TESSindex*)tess->alloc.memalloc( tess->alloc.userData, + sizeof(TESSindex) * tess->vertexCount ); + if (!tess->vertexIndices) + { + tess->outOfMemory = 1; + return; + } + + // Output vertices. + for ( v = mesh->vHead.next; v != &mesh->vHead; v = v->next ) + { + if ( v->n != TESS_UNDEF ) + { + // Store coordinate + vert = &tess->vertices[v->n*vertexSize]; + vert[0] = v->coords[0]; + vert[1] = v->coords[1]; + if ( vertexSize > 2 ) + vert[2] = v->coords[2]; + // Store vertex index. + tess->vertexIndices[v->n] = v->idx; + } + } + + // Output indices. + elements = tess->elements; + for ( f = mesh->fHead.next; f != &mesh->fHead; f = f->next ) + { + if ( !f->inside ) continue; + + // Store polygon + edge = f->anEdge; + faceVerts = 0; + do + { + v = edge->Org; + *elements++ = v->n; + faceVerts++; + edge = edge->Lnext; + } + while (edge != f->anEdge); + // Fill unused. + for (i = faceVerts; i < polySize; ++i) + *elements++ = TESS_UNDEF; + + // Store polygon connectivity + if ( elementType == TESS_CONNECTED_POLYGONS ) + { + edge = f->anEdge; + do + { + *elements++ = GetNeighbourFace( edge ); + edge = edge->Lnext; + } + while (edge != f->anEdge); + // Fill unused. + for (i = faceVerts; i < polySize; ++i) + *elements++ = TESS_UNDEF; + } + } +} + +void OutputContours( TESStesselator *tess, TESSmesh *mesh, int vertexSize ) +{ + TESSface *f = 0; + TESShalfEdge *edge = 0; + TESShalfEdge *start = 0; + TESSreal *verts = 0; + TESSindex *elements = 0; + TESSindex *vertInds = 0; + int startVert = 0; + int vertCount = 0; + + tess->vertexCount = 0; + tess->elementCount = 0; + + for ( f = mesh->fHead.next; f != &mesh->fHead; f = f->next ) + { + if ( !f->inside ) continue; + + start = edge = f->anEdge; + do + { + ++tess->vertexCount; + edge = edge->Lnext; + } + while ( edge != start ); + + ++tess->elementCount; + } + + tess->elements = (TESSindex*)tess->alloc.memalloc( tess->alloc.userData, + sizeof(TESSindex) * tess->elementCount * 2 ); + if (!tess->elements) + { + tess->outOfMemory = 1; + return; + } + + tess->vertices = (TESSreal*)tess->alloc.memalloc( tess->alloc.userData, + sizeof(TESSreal) * tess->vertexCount * vertexSize ); + if (!tess->vertices) + { + tess->outOfMemory = 1; + return; + } + + tess->vertexIndices = (TESSindex*)tess->alloc.memalloc( tess->alloc.userData, + sizeof(TESSindex) * tess->vertexCount ); + if (!tess->vertexIndices) + { + tess->outOfMemory = 1; + return; + } + + verts = tess->vertices; + elements = tess->elements; + vertInds = tess->vertexIndices; + + startVert = 0; + + for ( f = mesh->fHead.next; f != &mesh->fHead; f = f->next ) + { + if ( !f->inside ) continue; + + vertCount = 0; + start = edge = f->anEdge; + do + { + *verts++ = edge->Org->coords[0]; + *verts++ = edge->Org->coords[1]; + if ( vertexSize > 2 ) + *verts++ = edge->Org->coords[2]; + *vertInds++ = edge->Org->idx; + ++vertCount; + edge = edge->Lnext; + } + while ( edge != start ); + + elements[0] = startVert; + elements[1] = vertCount; + elements += 2; + + startVert += vertCount; + } +} + +void tessAddContour( TESStesselator *tess, int size, const void* vertices, + int stride, int numVertices ) +{ + const unsigned char *src = (const unsigned char*)vertices; + TESShalfEdge *e; + int i; + + if ( tess->mesh == NULL ) + tess->mesh = tessMeshNewMesh( &tess->alloc ); + if ( tess->mesh == NULL ) { + tess->outOfMemory = 1; + return; + } + + if ( size < 2 ) + size = 2; + if ( size > 3 ) + size = 3; + + e = NULL; + + for( i = 0; i < numVertices; ++i ) + { + const TESSreal* coords = (const TESSreal*)src; + src += stride; + + if( e == NULL ) { + /* Make a self-loop (one vertex, one edge). */ + e = tessMeshMakeEdge( tess->mesh ); + if ( e == NULL ) { + tess->outOfMemory = 1; + return; + } + if ( !tessMeshSplice( tess->mesh, e, e->Sym ) ) { + tess->outOfMemory = 1; + return; + } + } else { + /* Create a new vertex and edge which immediately follow e + * in the ordering around the left face. + */ + if ( tessMeshSplitEdge( tess->mesh, e ) == NULL ) { + tess->outOfMemory = 1; + return; + } + e = e->Lnext; + } + + /* The new vertex is now e->Org. */ + e->Org->coords[0] = coords[0]; + e->Org->coords[1] = coords[1]; + if ( size > 2 ) + e->Org->coords[2] = coords[2]; + else + e->Org->coords[2] = 0; + /* Store the insertion number so that the vertex can be later recognized. */ + e->Org->idx = tess->vertexIndexCounter++; + + /* The winding of an edge says how the winding number changes as we + * cross from the edge''s right face to its left face. We add the + * vertices in such an order that a CCW contour will add +1 to + * the winding number of the region inside the contour. + */ + e->winding = tess->reverseContours ? -1 : 1; + e->Sym->winding = tess->reverseContours ? 1 : -1; + } +} + +void tessSetOption( TESStesselator *tess, int option, int value ) +{ + switch(option) + { + case TESS_CONSTRAINED_DELAUNAY_TRIANGULATION: + tess->processCDT = value > 0 ? 1 : 0; + break; + case TESS_REVERSE_CONTOURS: + tess->reverseContours = value > 0 ? 1 : 0; + break; + } +} + + +int tessTesselate( TESStesselator *tess, int windingRule, int elementType, + int polySize, int vertexSize, const TESSreal* normal ) +{ + TESSmesh *mesh; + int rc = 1; + + if (tess->vertices != NULL) { + tess->alloc.memfree( tess->alloc.userData, tess->vertices ); + tess->vertices = 0; + } + if (tess->elements != NULL) { + tess->alloc.memfree( tess->alloc.userData, tess->elements ); + tess->elements = 0; + } + if (tess->vertexIndices != NULL) { + tess->alloc.memfree( tess->alloc.userData, tess->vertexIndices ); + tess->vertexIndices = 0; + } + + tess->vertexIndexCounter = 0; + + if (normal) + { + tess->normal[0] = normal[0]; + tess->normal[1] = normal[1]; + tess->normal[2] = normal[2]; + } + + tess->windingRule = windingRule; + + if (vertexSize < 2) + vertexSize = 2; + if (vertexSize > 3) + vertexSize = 3; + + if (setjmp(tess->env) != 0) { + /* come back here if out of memory */ + return 0; + } + + if (!tess->mesh) + { + return 0; + } + + /* Determine the polygon normal and project vertices onto the plane + * of the polygon. + */ + tessProjectPolygon( tess ); + + /* tessComputeInterior( tess ) computes the planar arrangement specified + * by the given contours, and further subdivides this arrangement + * into regions. Each region is marked "inside" if it belongs + * to the polygon, according to the rule given by tess->windingRule. + * Each interior region is guaranteed be monotone. + */ + if ( !tessComputeInterior( tess ) ) { + longjmp(tess->env,1); /* could've used a label */ + } + + mesh = tess->mesh; + + /* If the user wants only the boundary contours, we throw away all edges + * except those which separate the interior from the exterior. + * Otherwise we tessellate all the regions marked "inside". + */ + if (elementType == TESS_BOUNDARY_CONTOURS) { + rc = tessMeshSetWindingNumber( mesh, 1, TRUE ); + } else { + rc = tessMeshTessellateInterior( mesh ); + if (rc != 0 && tess->processCDT != 0) + tessMeshRefineDelaunay( mesh, &tess->alloc ); + } + if (rc == 0) longjmp(tess->env,1); /* could've used a label */ + + tessMeshCheckMesh( mesh ); + + if (elementType == TESS_BOUNDARY_CONTOURS) { + OutputContours( tess, mesh, vertexSize ); /* output contours */ + } + else + { + OutputPolymesh( tess, mesh, elementType, polySize, vertexSize ); /* output polygons */ + } + + tessMeshDeleteMesh( &tess->alloc, mesh ); + tess->mesh = NULL; + + if (tess->outOfMemory) + return 0; + return 1; +} + +int tessGetVertexCount( TESStesselator *tess ) +{ + return tess->vertexCount; +} + +const TESSreal* tessGetVertices( TESStesselator *tess ) +{ + return tess->vertices; +} + +const TESSindex* tessGetVertexIndices( TESStesselator *tess ) +{ + return tess->vertexIndices; +} + +int tessGetElementCount( TESStesselator *tess ) +{ + return tess->elementCount; +} + +const int* tessGetElements( TESStesselator *tess ) +{ + return tess->elements; +} diff --git a/jni/jni/libtess2/Source/tess.h b/jni/jni/libtess2/Source/tess.h new file mode 100755 index 000000000..30fda27bc --- /dev/null +++ b/jni/jni/libtess2/Source/tess.h @@ -0,0 +1,93 @@ +/* +** SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008) +** Copyright (C) [dates of first publication] Silicon Graphics, Inc. +** All Rights Reserved. +** +** Permission is hereby granted, free of charge, to any person obtaining a copy +** of this software and associated documentation files (the "Software"), to deal +** in the Software without restriction, including without limitation the rights +** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +** of the Software, and to permit persons to whom the Software is furnished to do so, +** subject to the following conditions: +** +** The above copyright notice including the dates of first publication and either this +** permission notice or a reference to http://oss.sgi.com/projects/FreeB/ shall be +** included in all copies or substantial portions of the Software. +** +** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +** INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A +** PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL SILICON GRAPHICS, INC. +** BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE +** OR OTHER DEALINGS IN THE SOFTWARE. +** +** Except as contained in this notice, the name of Silicon Graphics, Inc. shall not +** be used in advertising or otherwise to promote the sale, use or other dealings in +** this Software without prior written authorization from Silicon Graphics, Inc. +*/ +/* +** Author: Eric Veach, July 1994. +*/ + +#ifndef TESS_H +#define TESS_H + +#include +#include "bucketalloc.h" +#include "mesh.h" +#include "dict.h" +#include "priorityq.h" +#include "../Include/tesselator.h" + +#ifdef __cplusplus +extern "C" { +#endif + +//typedef struct TESStesselator TESStesselator; + +struct TESStesselator { + + /*** state needed for collecting the input data ***/ + TESSmesh *mesh; /* stores the input contours, and eventually + the tessellation itself */ + int outOfMemory; + + /*** state needed for projecting onto the sweep plane ***/ + + TESSreal normal[3]; /* user-specified normal (if provided) */ + TESSreal sUnit[3]; /* unit vector in s-direction (debugging) */ + TESSreal tUnit[3]; /* unit vector in t-direction (debugging) */ + + TESSreal bmin[2]; + TESSreal bmax[2]; + + int processCDT; /* option to run Constrained Delayney pass. */ + int reverseContours; /* tessAddContour() will treat CCW contours as CW and vice versa */ + + /*** state needed for the line sweep ***/ + int windingRule; /* rule for determining polygon interior */ + + Dict *dict; /* edge dictionary for sweep line */ + PriorityQ *pq; /* priority queue of vertex events */ + TESSvertex *event; /* current sweep event being processed */ + + struct BucketAlloc* regionPool; + + TESSindex vertexIndexCounter; + + TESSreal *vertices; + TESSindex *vertexIndices; + int vertexCount; + TESSindex *elements; + int elementCount; + + TESSalloc alloc; + + jmp_buf env; /* place to jump to when memAllocs fail */ +}; + +#ifdef __cplusplus +}; +#endif + +#endif diff --git a/jni/jni/libtess2/alg_outline.md b/jni/jni/libtess2/alg_outline.md new file mode 100644 index 000000000..9a4a2bd76 --- /dev/null +++ b/jni/jni/libtess2/alg_outline.md @@ -0,0 +1,233 @@ +This is only a very brief overview. There is quite a bit of +additional documentation in the source code itself. + + +Goals of robust tesselation +--------------------------- + +The tesselation algorithm is fundamentally a 2D algorithm. We +initially project all data into a plane; our goal is to robustly +tesselate the projected data. The same topological tesselation is +then applied to the input data. + +Topologically, the output should always be a tesselation. If the +input is even slightly non-planar, then some triangles will +necessarily be back-facing when viewed from some angles, but the goal +is to minimize this effect. + +The algorithm needs some capability of cleaning up the input data as +well as the numerical errors in its own calculations. One way to do +this is to specify a tolerance as defined above, and clean up the +input and output during the line sweep process. At the very least, +the algorithm must handle coincident vertices, vertices incident to an +edge, and coincident edges. + + +Phases of the algorithm +----------------------- + +1. Find the polygon normal N. +2. Project the vertex data onto a plane. It does not need to be + perpendicular to the normal, eg. we can project onto the plane + perpendicular to the coordinate axis whose dot product with N + is largest. +3. Using a line-sweep algorithm, partition the plane into x-monotone + regions. Any vertical line intersects an x-monotone region in + at most one interval. +4. Triangulate the x-monotone regions. +5. Group the triangles into strips and fans. + + +Finding the normal vector +------------------------- + +A common way to find a polygon normal is to compute the signed area +when the polygon is projected along the three coordinate axes. We +can't do this, since contours can have zero area without being +degenerate (eg. a bowtie). + +We fit a plane to the vertex data, ignoring how they are connected +into contours. Ideally this would be a least-squares fit; however for +our purpose the accuracy of the normal is not important. Instead we +find three vertices which are widely separated, and compute the normal +to the triangle they form. The vertices are chosen so that the +triangle has an area at least 1/sqrt(3) times the largest area of any +triangle formed using the input vertices. + +The contours do affect the orientation of the normal; after computing +the normal, we check that the sum of the signed contour areas is +non-negative, and reverse the normal if necessary. + + +Projecting the vertices +----------------------- + +We project the vertices onto a plane perpendicular to one of the three +coordinate axes. This helps numerical accuracy by removing a +transformation step between the original input data and the data +processed by the algorithm. The projection also compresses the input +data; the 2D distance between vertices after projection may be smaller +than the original 2D distance. However by choosing the coordinate +axis whose dot product with the normal is greatest, the compression +factor is at most 1/sqrt(3). + +Even though the *accuracy* of the normal is not that important (since +we are projecting perpendicular to a coordinate axis anyway), the +*robustness* of the computation is important. For example, if there +are many vertices which lie almost along a line, and one vertex V +which is well-separated from the line, then our normal computation +should involve V otherwise the results will be garbage. + +The advantage of projecting perpendicular to the polygon normal is +that computed intersection points will be as close as possible to +their ideal locations. To get this behavior, define TRUE_PROJECT. + + +The Line Sweep +-------------- + +There are three data structures: the mesh, the event queue, and the +edge dictionary. + +The mesh is a "quad-edge" data structure which records the topology of +the current decomposition; for details see the include file "mesh.h". + +The event queue simply holds all vertices (both original and computed +ones), organized so that we can quickly extract the vertex with the +minimum x-coord (and among those, the one with the minimum y-coord). + +The edge dictionary describes the current intersection of the sweep +line with the regions of the polygon. This is just an ordering of the +edges which intersect the sweep line, sorted by their current order of +intersection. For each pair of edges, we store some information about +the monotone region between them -- these are call "active regions" +(since they are crossed by the current sweep line). + +The basic algorithm is to sweep from left to right, processing each +vertex. The processed portion of the mesh (left of the sweep line) is +a planar decomposition. As we cross each vertex, we update the mesh +and the edge dictionary, then we check any newly adjacent pairs of +edges to see if they intersect. + +A vertex can have any number of edges. Vertices with many edges can +be created as vertices are merged and intersection points are +computed. For unprocessed vertices (right of the sweep line), these +edges are in no particular order around the vertex; for processed +vertices, the topological ordering should match the geometric ordering. + +The vertex processing happens in two phases: first we process are the +left-going edges (all these edges are currently in the edge +dictionary). This involves: + + - deleting the left-going edges from the dictionary; + - relinking the mesh if necessary, so that the order of these edges around + the event vertex matches the order in the dictionary; + - marking any terminated regions (regions which lie between two left-going + edges) as either "inside" or "outside" according to their winding number. + +When there are no left-going edges, and the event vertex is in an +"interior" region, we need to add an edge (to split the region into +monotone pieces). To do this we simply join the event vertex to the +rightmost left endpoint of the upper or lower edge of the containing +region. + +Then we process the right-going edges. This involves: + + - inserting the edges in the edge dictionary; + - computing the winding number of any newly created active regions. + We can compute this incrementally using the winding of each edge + that we cross as we walk through the dictionary. + - relinking the mesh if necessary, so that the order of these edges around + the event vertex matches the order in the dictionary; + - checking any newly adjacent edges for intersection and/or merging. + +If there are no right-going edges, again we need to add one to split +the containing region into monotone pieces. In our case it is most +convenient to add an edge to the leftmost right endpoint of either +containing edge; however we may need to change this later (see the +code for details). + + +Invariants +---------- + +These are the most important invariants maintained during the sweep. +We define a function VertLeq(v1,v2) which defines the order in which +vertices cross the sweep line, and a function EdgeLeq(e1,e2; loc) +which says whether e1 is below e2 at the sweep event location "loc". +This function is defined only at sweep event locations which lie +between the rightmost left endpoint of {e1,e2}, and the leftmost right +endpoint of {e1,e2}. + +Invariants for the Edge Dictionary. + + - Each pair of adjacent edges e2=Succ(e1) satisfies EdgeLeq(e1,e2) + at any valid location of the sweep event. + - If EdgeLeq(e2,e1) as well (at any valid sweep event), then e1 and e2 + share a common endpoint. + - For each e in the dictionary, e->Dst has been processed but not e->Org. + - Each edge e satisfies VertLeq(e->Dst,event) && VertLeq(event,e->Org) + where "event" is the current sweep line event. + - No edge e has zero length. + - No two edges have identical left and right endpoints. + +Invariants for the Mesh (the processed portion). + + - The portion of the mesh left of the sweep line is a planar graph, + ie. there is *some* way to embed it in the plane. + - No processed edge has zero length. + - No two processed vertices have identical coordinates. + - Each "inside" region is monotone, ie. can be broken into two chains + of monotonically increasing vertices according to VertLeq(v1,v2) + - a non-invariant: these chains may intersect (slightly) due to + numerical errors, but this does not affect the algorithm's operation. + +Invariants for the Sweep. + + - If a vertex has any left-going edges, then these must be in the edge + dictionary at the time the vertex is processed. + - If an edge is marked "fixUpperEdge" (it is a temporary edge introduced + by ConnectRightVertex), then it is the only right-going edge from + its associated vertex. (This says that these edges exist only + when it is necessary.) + + +Robustness +---------- + +The key to the robustness of the algorithm is maintaining the +invariants above, especially the correct ordering of the edge +dictionary. We achieve this by: + + 1. Writing the numerical computations for maximum precision rather + than maximum speed. + + 2. Making no assumptions at all about the results of the edge + intersection calculations -- for sufficiently degenerate inputs, + the computed location is not much better than a random number. + + 3. When numerical errors violate the invariants, restore them + by making *topological* changes when necessary (ie. relinking + the mesh structure). + + +Triangulation and Grouping +-------------------------- + +We finish the line sweep before doing any triangulation. This is +because even after a monotone region is complete, there can be further +changes to its vertex data because of further vertex merging. + +After triangulating all monotone regions, we want to group the +triangles into fans and strips. We do this using a greedy approach. +The triangulation itself is not optimized to reduce the number of +primitives; we just try to get a reasonable decomposition of the +computed triangulation. + +Optionally, it's possible to output a Constrained Delaunay Triangulation. +This is done by doing a delaunay refinement with the normal triangulation as +a basis. The Edge Flip algorithm is used, which is guaranteed to terminate in O(n^2). + +Note: We don't use robust predicates to check if edges are locally +delaunay, but currently us a naive epsilon of 0.01 radians to ensure +termination. diff --git a/jni/jni/libtess2/premake4.lua b/jni/jni/libtess2/premake4.lua new file mode 100644 index 000000000..69533c9ce --- /dev/null +++ b/jni/jni/libtess2/premake4.lua @@ -0,0 +1,45 @@ + +local action = _ACTION or "" + +solution "libtess2" + location ( "Build" ) + configurations { "Debug", "Release" } + platforms {"native", "x64", "x32"} + + configuration "Debug" + defines { "DEBUG" } + flags { "Symbols", "ExtraWarnings"} + + configuration "Release" + defines { "NDEBUG" } + flags { "Optimize", "ExtraWarnings"} + + + project "tess2" + language "C" + kind "StaticLib" + includedirs { "Include", "Source" } + files { "Source/*.c" } + targetdir("Build") + + -- more dynamic example + project "example" + kind "ConsoleApp" + language "C" + links { "tess2" } + files { "Example/example.c", "Contrib/*.c" } + includedirs { "Include", "Contrib" } + targetdir("Build") + + configuration { "linux" } + linkoptions { "`pkg-config --libs glfw3`" } + links { "GL", "GLU", "m", "GLEW" } + defines { "NANOVG_GLEW" } + + configuration { "windows" } + links { "glfw3", "gdi32", "winmm", "user32", "GLEW", "glu32","opengl32" } + defines { "NANOVG_GLEW" } + + configuration { "macosx" } + links { "glfw3" } + linkoptions { "-framework OpenGL", "-framework Cocoa", "-framework IOKit", "-framework CoreVideo" } diff --git a/jni/jni/org.oscim.utils.TessJNI.cpp b/jni/jni/org_oscim_utils_TessJNI.cpp similarity index 52% rename from jni/jni/org.oscim.utils.TessJNI.cpp rename to jni/jni/org_oscim_utils_TessJNI.cpp index 98c1fcf28..f544220e4 100644 --- a/jni/jni/org.oscim.utils.TessJNI.cpp +++ b/jni/jni/org_oscim_utils_TessJNI.cpp @@ -1,56 +1,56 @@ -#include +#include //@line:114 - #include - #include - #include - void* heapAlloc( void* userData, unsigned int size ){ - TESS_NOTUSED( userData ); - return malloc( size ); - } - void* heapRealloc( void *userData, void* ptr, unsigned int size ){ - TESS_NOTUSED( userData ); - return realloc( ptr, size ); - } - void heapFree( void* userData, void* ptr ){ - TESS_NOTUSED( userData ); - free( ptr ); - } - JNIEXPORT jlong JNICALL Java_org_oscim_utils_TessJNI_newTess(JNIEnv* env, jclass clazz, jint size) { + #include + #include + #include + void* heapAlloc( void* userData, unsigned int size ){ + TESS_NOTUSED( userData ); + return malloc( size ); + } + void* heapRealloc( void *userData, void* ptr, unsigned int size ){ + TESS_NOTUSED( userData ); + return realloc( ptr, size ); + } + void heapFree( void* userData, void* ptr ){ + TESS_NOTUSED( userData ); + free( ptr ); + } + JNIEXPORT jlong JNICALL Java_org_oscim_utils_TessJNI_newTess(JNIEnv* env, jclass clazz, jint size) { //@line:131 { - if (size <= 0) - return (jlong)tessNewTess(0); - if (size > 10) - size = 10; - TESSalloc ma; - memset(&ma, 0, sizeof(ma)); - ma.memalloc = heapAlloc; - ma.memfree = heapFree; - ma.memrealloc = heapRealloc; - //ma.userData = (void*)&allocated; - ma.meshEdgeBucketSize = 2 << size; // 512 - ma.meshVertexBucketSize = 2 << size; // 512 - ma.meshFaceBucketSize = 1 << size; // 256 - ma.dictNodeBucketSize = 2 << size; // 512 - ma.regionBucketSize = 1 << size; // 256 - ma.extraVertices = 8; - //ma.extraVertices = 256; - return (jlong)tessNewTess(&ma); - } + if (size <= 0) + return (long)tessNewTess(0); + if (size > 10) + size = 10; + TESSalloc ma; + memset(&ma, 0, sizeof(ma)); + ma.memalloc = heapAlloc; + ma.memfree = heapFree; + ma.memrealloc = heapRealloc; + //ma.userData = (void*)&allocated; + ma.meshEdgeBucketSize = 2 << size; // 512 + ma.meshVertexBucketSize = 2 << size; // 512 + ma.meshFaceBucketSize = 1 << size; // 256 + ma.dictNodeBucketSize = 2 << size; // 512 + ma.regionBucketSize = 1 << size; // 256 + ma.extraVertices = 8; + //ma.extraVertices = 256; + return (long)tessNewTess(&ma); + } } JNIEXPORT void JNICALL Java_org_oscim_utils_TessJNI_freeTess(JNIEnv* env, jclass clazz, jlong inst) { -//@line:151 +//@line:152 { - tessDeleteTess((TESStesselator*) inst); - } + tessDeleteTess((TESStesselator*) inst); + } } @@ -58,10 +58,10 @@ JNIEXPORT void JNICALL Java_org_oscim_utils_TessJNI_addContour(JNIEnv* env, jcla float* contour = (float*)env->GetPrimitiveArrayCritical(obj_contour, 0); -//@line:164 +//@line:166 { - tessAddContour((TESStesselator*) inst, size, contour + (offset * stride), stride, count); - } + tessAddContour((TESStesselator*) inst, size, contour + (offset * stride), stride, count); + } env->ReleasePrimitiveArrayCritical(obj_contour, contour, 0); } @@ -71,23 +71,23 @@ JNIEXPORT void JNICALL Java_org_oscim_utils_TessJNI_addMultiContour2D(JNIEnv* en float* contour = (float*)env->GetPrimitiveArrayCritical(obj_contour, 0); -//@line:167 +//@line:170 { - TESStesselator* tess = (TESStesselator*) inst; - int offset = 0; - // start at 0 to get the correct offset in contour.. - for (int i = 0; i < idxStart + idxCount; i++){ - int len = index[i]; - if ((len % 2 != 0) || (len < 0)) - break; - if (len < 6 || i < idxStart) { - offset += len; - continue; - } - tessAddContour(tess, 2, contour + offset, 8, len >> 1); - offset += len; - } - } + TESStesselator* tess = (TESStesselator*) inst; + int offset = 0; + // start at 0 to get the correct offset in contour.. + for (int i = 0; i < idxStart + idxCount; i++){ + int len = index[i]; + if ((len % 2 != 0) || (len < 0)) + break; + if (len < 6 || i < idxStart) { + offset += len; + continue; + } + tessAddContour(tess, 2, contour + offset, 8, len >> 1); + offset += len; + } + } env->ReleasePrimitiveArrayCritical(obj_index, index, 0); env->ReleasePrimitiveArrayCritical(obj_contour, contour, 0); @@ -96,34 +96,34 @@ JNIEXPORT void JNICALL Java_org_oscim_utils_TessJNI_addMultiContour2D(JNIEnv* en JNIEXPORT jint JNICALL Java_org_oscim_utils_TessJNI_tessContour2D(JNIEnv* env, jclass clazz, jlong inst, jint windingRule, jint elementType, jint polySize, jint vertexSize) { -//@line:194 +//@line:198 { - return tessTesselate((TESStesselator*) inst, windingRule, elementType, polySize, vertexSize, 0); - } + return tessTesselate((TESStesselator*) inst, windingRule, elementType, polySize, vertexSize, 0); + } } JNIEXPORT jint JNICALL Java_org_oscim_utils_TessJNI_getVertexCount(JNIEnv* env, jclass clazz, jlong inst) { -//@line:197 +//@line:202 { - return tessGetVertexCount((TESStesselator*) inst); - } + return tessGetVertexCount((TESStesselator*) inst); + } } static inline jboolean wrapped_Java_org_oscim_utils_TessJNI_getVertices (JNIEnv* env, jclass clazz, jlong inst, jfloatArray obj_out, jint offset, jint length, float* out) { -//@line:203 +//@line:209 { - const TESSreal* vertices = tessGetVertices((TESStesselator*) inst); - if (!vertices) - return 0; - memcpy(out, vertices + offset, length * sizeof(TESSreal)); - return 1; - } + const TESSreal* vertices = tessGetVertices((TESStesselator*) inst); + if (!vertices) + return 0; + memcpy(out, vertices + offset, length * sizeof(TESSreal)); + return 1; + } } JNIEXPORT jboolean JNICALL Java_org_oscim_utils_TessJNI_getVertices(JNIEnv* env, jclass clazz, jlong inst, jfloatArray obj_out, jint offset, jint length) { @@ -140,12 +140,12 @@ JNIEXPORT void JNICALL Java_org_oscim_utils_TessJNI_getVerticesS(JNIEnv* env, jc short* out = (short*)env->GetPrimitiveArrayCritical(obj_out, 0); -//@line:213 +//@line:220 { - const TESSreal* vertices = tessGetVertices((TESStesselator*) inst); - for(int i = 0; i < length; i++) - out[i] = (short)(vertices[offset++] * scale + 0.5f); - } + const TESSreal* vertices = tessGetVertices((TESStesselator*) inst); + for(int i = 0; i < length; i++) + out[i] = (short)(vertices[offset++] * scale + 0.5f); + } env->ReleasePrimitiveArrayCritical(obj_out, out, 0); } @@ -153,14 +153,14 @@ JNIEXPORT void JNICALL Java_org_oscim_utils_TessJNI_getVerticesS(JNIEnv* env, jc static inline jboolean wrapped_Java_org_oscim_utils_TessJNI_getVertexIndices (JNIEnv* env, jclass clazz, jlong inst, jintArray obj_out, jint offset, jint length, int* out) { -//@line:225 +//@line:233 { - const TESSindex* indices = tessGetVertexIndices((TESStesselator*) inst); - if (!indices) - return 0; - memcpy(out, indices + offset, length * sizeof(TESSindex)); - return 1; - } + const TESSindex* indices = tessGetVertexIndices((TESStesselator*) inst); + if (!indices) + return 0; + memcpy(out, indices + offset, length * sizeof(TESSindex)); + return 1; + } } JNIEXPORT jboolean JNICALL Java_org_oscim_utils_TessJNI_getVertexIndices(JNIEnv* env, jclass clazz, jlong inst, jintArray obj_out, jint offset, jint length) { @@ -176,24 +176,24 @@ JNIEXPORT jboolean JNICALL Java_org_oscim_utils_TessJNI_getVertexIndices(JNIEnv* JNIEXPORT jint JNICALL Java_org_oscim_utils_TessJNI_getElementCount(JNIEnv* env, jclass clazz, jlong inst) { -//@line:235 +//@line:244 { - return tessGetElementCount((TESStesselator*) inst); - } + return tessGetElementCount((TESStesselator*) inst); + } } static inline jboolean wrapped_Java_org_oscim_utils_TessJNI_getElements (JNIEnv* env, jclass clazz, jlong inst, jintArray obj_out, jint offset, jint length, int* out) { -//@line:241 +//@line:251 { - const TESSindex* elements = tessGetElements((TESStesselator*) inst); - if (!elements) - return 0; - memcpy(out, elements + offset, length * sizeof(TESSindex)); - return 1; - } + const TESSindex* elements = tessGetElements((TESStesselator*) inst); + if (!elements) + return 0; + memcpy(out, elements + offset, length * sizeof(TESSindex)); + return 1; + } } JNIEXPORT jboolean JNICALL Java_org_oscim_utils_TessJNI_getElements(JNIEnv* env, jclass clazz, jlong inst, jintArray obj_out, jint offset, jint length) { @@ -210,12 +210,12 @@ JNIEXPORT void JNICALL Java_org_oscim_utils_TessJNI_getElementsS(JNIEnv* env, jc short* out = (short*)env->GetPrimitiveArrayCritical(obj_out, 0); -//@line:251 +//@line:262 { - const TESSindex* elements = tessGetElements((TESStesselator*) inst); - for(int i = 0; i < length; i++) - out[i] = (short)elements[offset++]; - } + const TESSindex* elements = tessGetElements((TESStesselator*) inst); + for(int i = 0; i < length; i++) + out[i] = (short)elements[offset++]; + } env->ReleasePrimitiveArrayCritical(obj_out, out, 0); } @@ -224,13 +224,13 @@ JNIEXPORT void JNICALL Java_org_oscim_utils_TessJNI_getElementsWithInputVertexId short* out = (short*)env->GetPrimitiveArrayCritical(obj_out, 0); -//@line:259 +//@line:271 { - const TESSindex* elements = tessGetElements((TESStesselator*) inst); - const TESSindex* indices = tessGetVertexIndices((TESStesselator*) inst); - for(int i = 0; i < length; i++) - out[dstOffset++] = (short)(indices[elements[offset++]]); - } + const TESSindex* elements = tessGetElements((TESStesselator*) inst); + const TESSindex* indices = tessGetVertexIndices((TESStesselator*) inst); + for(int i = 0; i < length; i++) + out[dstOffset++] = (short)(indices[elements[offset++]]); + } env->ReleasePrimitiveArrayCritical(obj_out, out, 0); } diff --git a/jni/jni/org.oscim.utils.TessJNI.h b/jni/jni/org_oscim_utils_TessJNI.h similarity index 68% rename from jni/jni/org.oscim.utils.TessJNI.h rename to jni/jni/org_oscim_utils_TessJNI.h index b19d953d2..884432022 100644 --- a/jni/jni/org.oscim.utils.TessJNI.h +++ b/jni/jni/org_oscim_utils_TessJNI.h @@ -115,41 +115,3 @@ JNIEXPORT void JNICALL Java_org_oscim_utils_TessJNI_getElementsWithInputVertexId } #endif #endif -/* Header for class org_oscim_utils_TessJNI_ElementType */ - -#ifndef _Included_org_oscim_utils_TessJNI_ElementType -#define _Included_org_oscim_utils_TessJNI_ElementType -#ifdef __cplusplus -extern "C" { -#endif -#undef org_oscim_utils_TessJNI_ElementType_POLYGONS -#define org_oscim_utils_TessJNI_ElementType_POLYGONS 0L -#undef org_oscim_utils_TessJNI_ElementType_CONNECTED_POLYGONS -#define org_oscim_utils_TessJNI_ElementType_CONNECTED_POLYGONS 1L -#undef org_oscim_utils_TessJNI_ElementType_BOUNDARY_CONTOURS -#define org_oscim_utils_TessJNI_ElementType_BOUNDARY_CONTOURS 2L -#ifdef __cplusplus -} -#endif -#endif -/* Header for class org_oscim_utils_TessJNI_WindingRule */ - -#ifndef _Included_org_oscim_utils_TessJNI_WindingRule -#define _Included_org_oscim_utils_TessJNI_WindingRule -#ifdef __cplusplus -extern "C" { -#endif -#undef org_oscim_utils_TessJNI_WindingRule_ODD -#define org_oscim_utils_TessJNI_WindingRule_ODD 0L -#undef org_oscim_utils_TessJNI_WindingRule_NONZERO -#define org_oscim_utils_TessJNI_WindingRule_NONZERO 1L -#undef org_oscim_utils_TessJNI_WindingRule_POSITIVE -#define org_oscim_utils_TessJNI_WindingRule_POSITIVE 2L -#undef org_oscim_utils_TessJNI_WindingRule_NEGATIVE -#define org_oscim_utils_TessJNI_WindingRule_NEGATIVE 3L -#undef org_oscim_utils_TessJNI_WindingRule_ABS_GEQ_TWO -#define org_oscim_utils_TessJNI_WindingRule_ABS_GEQ_TWO 4L -#ifdef __cplusplus -} -#endif -#endif diff --git a/jni/src/JniBuilder.java b/jni/src/JniBuilder.java index 30beba9db..8138225a0 100644 --- a/jni/src/JniBuilder.java +++ b/jni/src/JniBuilder.java @@ -1,8 +1,6 @@ -import com.badlogic.gdx.jnigen.AntScriptGenerator; -import com.badlogic.gdx.jnigen.BuildConfig; -import com.badlogic.gdx.jnigen.BuildTarget; -import com.badlogic.gdx.jnigen.BuildTarget.TargetOs; -import com.badlogic.gdx.jnigen.NativeCodeGenerator; +import com.badlogic.gdx.jnigen.*; +import com.badlogic.gdx.utils.Architecture; +import com.badlogic.gdx.utils.Os; public class JniBuilder { public static void main(String[] args) throws Exception { @@ -18,11 +16,10 @@ public static void main(String[] args) throws Exception { "libtess2/Source/tess.c", }; - String cflags = " -Wall -std=c99 -O2 -ffast-math"; + String cflags = " -Wall -O2 -ffast-math"; cflags += " -DNDEBUG"; /* disable debug in libtess2 */ - //BuildTarget win32home = BuildTarget - // .newDefaultTarget(TargetOs.Windows, false); + //BuildTarget win32home = BuildTarget.newDefaultTarget(Os.Windows, Architecture.Bitness._32); //win32home.compilerPrefix = ""; //win32home.buildFileName = "build-windows32home.xml"; //win32home.excludeFromMasterBuildFile = true; @@ -31,70 +28,65 @@ public static void main(String[] args) throws Exception { //win32home.cFlags += cflags; //win32home.cppFlags += cflags; - BuildTarget win32 = BuildTarget - .newDefaultTarget(TargetOs.Windows, false); + /*BuildTarget win32 = BuildTarget.newDefaultTarget(Os.Windows, Architecture.Bitness._32); win32.headerDirs = headers; win32.cIncludes = sources; win32.cFlags += cflags; - win32.cppFlags += cflags; + win32.cppFlags += cflags;*/ - BuildTarget win64 = BuildTarget - .newDefaultTarget(TargetOs.Windows, true); + /*BuildTarget win64 = BuildTarget.newDefaultTarget(Os.Windows, Architecture.Bitness._64); win64.headerDirs = headers; win64.cIncludes = sources; win64.cFlags += cflags; - win64.cppFlags += cflags; + win64.cppFlags += cflags;*/ - BuildTarget lin32 = BuildTarget - .newDefaultTarget(TargetOs.Linux, false); + /*BuildTarget lin32 = BuildTarget.newDefaultTarget(Os.Linux, Architecture.Bitness._32); lin32.headerDirs = headers; lin32.cIncludes = sources; lin32.cFlags += cflags; - lin32.cppFlags += cflags; + lin32.cppFlags += cflags;*/ - BuildTarget lin64 = BuildTarget - .newDefaultTarget(TargetOs.Linux, true); + /*BuildTarget lin64 = BuildTarget.newDefaultTarget(Os.Linux, Architecture.Bitness._64); lin64.headerDirs = headers; lin64.cIncludes = sources; lin64.cFlags += cflags; - lin64.cppFlags += cflags; + lin64.cppFlags += cflags;*/ - BuildTarget mac = BuildTarget - .newDefaultTarget(TargetOs.MacOsX, false); + /*BuildTarget mac = BuildTarget.newDefaultTarget(Os.MacOsX, Architecture.Bitness._32); mac.headerDirs = headers; mac.cIncludes = sources; mac.cFlags += cflags; mac.cppFlags += cflags; - mac.linkerFlags += " -framework CoreServices -framework Carbon"; + mac.linkerFlags += " -framework CoreServices -framework Carbon";*/ - BuildTarget android = BuildTarget - .newDefaultTarget(TargetOs.Android, false); + BuildTarget android = BuildTarget.newDefaultTarget(Os.Android, Architecture.Bitness._32); android.headerDirs = headers; android.cIncludes = sources; android.cFlags += cflags; android.cppFlags += cflags; android.linkerFlags += " -llog"; - BuildTarget ios = BuildTarget.newDefaultTarget(TargetOs.IOS, false); + /*BuildTarget ios = BuildTarget.newDefaultTarget(Os.IOS, Architecture.Bitness._32); ios.headerDirs = headers; ios.cIncludes = sources; ios.cFlags += cflags; - ios.cppFlags += cflags; + ios.cppFlags += cflags;*/ new NativeCodeGenerator().generate(); new AntScriptGenerator() .generate(new BuildConfig("vtm-jni"), - android, - lin64, - lin32, - mac, - ios, + android + //lin64, + //lin32, + //mac, + //ios, //win32home, - win32, - win64 + //win32, + //win64 ); + BuildExecutor.executeAnt("jni/build-android32.xml", "compile-natives"); // BuildExecutor.executeAnt("jni/build-windows32home.xml", "-v clean"); // BuildExecutor.executeAnt("jni/build-linux64.xml", "-v"); // BuildExecutor.executeAnt("jni/build.xml", "pack-natives -v"); diff --git a/settings.gradle b/settings.gradle index 9645bd1ec..cc9cdde5d 100644 --- a/settings.gradle +++ b/settings.gradle @@ -14,6 +14,7 @@ dependencyResolutionManagement { maven { url 'https://jitpack.io' } } } +include ':jni' include ':vtm' include ':vtm-android' include ':vtm-android-example'