+ * + * If the animation key go from n to m and the current time is t, use the + * value at (t-n) % (|m-n|). + */ + REPEAT(0x3); + + + /** + * Utility method for converting from c/c++ based integer enums to java + * enums.
+ * + * This method is intended to be used from JNI and my change based on + * implementation needs. + * + * @param rawValue an integer based enum value (as defined by assimp) + * @return the enum value corresponding to rawValue + */ + static AiAnimBehavior fromRawValue(int rawValue) { + for (AiAnimBehavior type : AiAnimBehavior.values()) { + if (type.m_rawValue == rawValue) { + return type; + } + } + + throw new IllegalArgumentException("unexptected raw value: " + + rawValue); + } + + + /** + * Constructor. + * + * @param rawValue maps java enum to c/c++ integer enum values + */ + private AiAnimBehavior(int rawValue) { + m_rawValue = rawValue; + } + + + /** + * The mapped c/c++ integer enum value. + */ + private final int m_rawValue; +} diff --git a/port/jassimp/jassimp/src/jassimp/AiAnimation.java b/port/jassimp/jassimp/src/jassimp/AiAnimation.java new file mode 100644 index 000000000..fca3bc53d --- /dev/null +++ b/port/jassimp/jassimp/src/jassimp/AiAnimation.java @@ -0,0 +1,179 @@ +/* +--------------------------------------------------------------------------- +Open Asset Import Library - Java Binding (jassimp) +--------------------------------------------------------------------------- + +Copyright (c) 2006-2012, assimp team + +All rights reserved. + +Redistribution and use of this software in source and binary forms, +with or without modification, are permitted provided that the following +conditions are met: + +* Redistributions of source code must retain the above + copyright notice, this list of conditions and the + following disclaimer. + +* Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the + following disclaimer in the documentation and/or other + materials provided with the distribution. + +* Neither the name of the assimp team, nor the names of its + contributors may be used to endorse or promote products + derived from this software without specific prior + written permission of the assimp team. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +--------------------------------------------------------------------------- +*/ +package jassimp; + +import java.util.ArrayList; +import java.util.List; + +/** + * An animation.
+ * + * An animation consists of keyframe data for a number of nodes. For + * each node affected by the animation a separate series of data is given.
+ * + * Like {@link AiMesh}, the animation related classes offer a Buffer API, a + * Direct API and a wrapped API. Please consult the documentation of + * {@link AiMesh} for a description and comparison of these APIs. + */ +public final class AiAnimation { + /** + * Constructor. + * + * @param name name + * @param duration duration + * @param ticksPerSecond ticks per second + */ + AiAnimation(String name, double duration, double ticksPerSecond) { + m_name = name; + m_duration = duration; + m_ticksPerSecond = ticksPerSecond; + } + + + /** + * Returns the name of the animation.
+ * + * If the modeling package this data was exported from does support only + * a single animation channel, this name is usually empty (length is zero). + * + * @return the name + */ + public String getName() { + return m_name; + } + + + /** + * Returns the duration of the animation in ticks. + * + * @return the duration + */ + public double getDuration() { + return m_duration; + } + + + /** + * Returns the ticks per second.
+ * + * 0 if not specified in the imported file + * + * @return the number of ticks per second + */ + public double getTicksPerSecond() { + return m_ticksPerSecond; + } + + + /** + * Returns the number of bone animation channels.
+ *
+ * Each channel affects a single node. This method will return the same
+ * value as getChannels().size()
+ *
+ * @return the number of bone animation channels
+ */
+ public int getNumChannels() {
+ return m_nodeAnims.size();
+ }
+
+
+ /**
+ * Returns the list of bone animation channels.
+ *
+ * Each channel affects a single node. The array is mNumChannels in size.
+ *
+ * @return the list of bone animation channels
+ */
+ public List
+ *
+ * Each channel affects a single mesh and defines vertex-based animation.
+ * This method will return the same value as
+ *
+ *
+ * Each channel affects a single mesh.
+ *
+ * @return the list of mesh animation channels
+ */
+ public List
+ *
+ * If you're familiar with OpenGL or D3D, these flags aren't new to you.
+ * They define *how* the final color value of a pixel is computed, basing
+ * on the previous color at that pixel and the new color value from the
+ * material. The blend formula is:
+ *
+ *
+ * Formula:
+ *
+ *
+ * Formula:
+ *
+ *
+ * This method is intended to be used from JNI and my change based on
+ * implementation needs.
+ *
+ * @param rawValue an integer based enum value (as defined by assimp)
+ * @return the enum value corresponding to rawValue
+ */
+ static AiBlendMode fromRawValue(int rawValue) {
+ for (AiBlendMode type : AiBlendMode.values()) {
+ if (type.m_rawValue == rawValue) {
+ return type;
+ }
+ }
+
+ throw new IllegalArgumentException("unexptected raw value: " +
+ rawValue);
+ }
+
+
+ /**
+ * Constructor.
+ *
+ * @param rawValue maps java enum to c/c++ integer enum values
+ */
+ private AiBlendMode(int rawValue) {
+ m_rawValue = rawValue;
+ }
+
+
+ /**
+ * The mapped c/c++ integer enum value.
+ */
+ private final int m_rawValue;
+}
\ No newline at end of file
diff --git a/port/jassimp/jassimp/src/jassimp/AiBone.java b/port/jassimp/jassimp/src/jassimp/AiBone.java
new file mode 100644
index 000000000..87c4b8199
--- /dev/null
+++ b/port/jassimp/jassimp/src/jassimp/AiBone.java
@@ -0,0 +1,137 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library - Java Binding (jassimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2012, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+ copyright notice, this list of conditions and the
+ following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the
+ following disclaimer in the documentation and/or other
+ materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+ contributors may be used to endorse or promote products
+ derived from this software without specific prior
+ written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+package jassimp;
+
+import java.util.ArrayList;
+import java.util.List;
+
+
+/**
+ * A single bone of a mesh.
+ *
+ * A bone has a name by which it can be found in the frame hierarchy and by
+ * which it can be addressed by animations. In addition it has a number of
+ * influences on vertices.
+ *
+ * This class is designed to be mutable, i.e., the returned collections are
+ * writable and may be modified.
+ */
+public final class AiBone {
+ /**
+ * Constructor.
+ */
+ AiBone() {
+ /* nothing to do */
+ }
+
+
+ /**
+ * Returns the name of the bone.
+ *
+ * @return the name
+ */
+ public String getName() {
+ return m_name;
+ }
+
+
+ /**
+ * Returns the number of bone weights.
+ *
+ * This method exists for compatibility with the native assimp API.
+ * The returned value is identical to
+ *
+ * The offset matrix is a 4x4 matrix that transforms from mesh space to
+ * bone space in bind pose.
+ *
+ * This method is part of the wrapped API (see {@link AiWrapperProvider}
+ * for details on wrappers).
+ *
+ * @param wrapperProvider the wrapper provider (used for type inference)
+ *
+ * @return the offset matrix
+ */
+ @SuppressWarnings("unchecked")
+ public
+ *
+ * The influence from all bones at one vertex amounts to 1
+ *
+ * @return the influence
+ */
+ public float getWeight() {
+ return m_weight;
+ }
+
+
+ /**
+ * Vertex index.
+ */
+ private int m_vertexId;
+
+
+ /**
+ * Influence of bone on vertex.
+ */
+ private float m_weight;
+}
diff --git a/port/jassimp/jassimp/src/jassimp/AiBuiltInWrapperProvider.java b/port/jassimp/jassimp/src/jassimp/AiBuiltInWrapperProvider.java
new file mode 100644
index 000000000..64fad515a
--- /dev/null
+++ b/port/jassimp/jassimp/src/jassimp/AiBuiltInWrapperProvider.java
@@ -0,0 +1,84 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library - Java Binding (jassimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2012, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+ copyright notice, this list of conditions and the
+ following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the
+ following disclaimer in the documentation and/or other
+ materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+ contributors may be used to endorse or promote products
+ derived from this software without specific prior
+ written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+package jassimp;
+
+import java.nio.ByteBuffer;
+
+
+/**
+ * Wrapper provider using jassimp built in types.
+ */
+public final class AiBuiltInWrapperProvider implements AiWrapperProvider<
+ AiVector, AiMatrix4f, AiColor, AiNode, AiQuaternion> {
+
+ @Override
+ public AiVector wrapVector3f(ByteBuffer buffer, int offset,
+ int numComponents) {
+
+ return new AiVector(buffer, offset, numComponents);
+ }
+
+
+ @Override
+ public AiMatrix4f wrapMatrix4f(float[] data) {
+ return new AiMatrix4f(data);
+ }
+
+
+ @Override
+ public AiColor wrapColor(ByteBuffer buffer, int offset) {
+ return new AiColor(buffer, offset);
+ }
+
+
+ @Override
+ public AiNode wrapSceneNode(Object parent, Object matrix,
+ int[] meshReferences, String name) {
+
+ return new AiNode((AiNode) parent, matrix, meshReferences, name);
+ }
+
+
+ @Override
+ public AiQuaternion wrapQuaternion(ByteBuffer buffer, int offset) {
+ return new AiQuaternion(buffer, offset);
+ }
+}
diff --git a/port/jassimp/jassimp/src/jassimp/AiCamera.java b/port/jassimp/jassimp/src/jassimp/AiCamera.java
new file mode 100644
index 000000000..6378210f7
--- /dev/null
+++ b/port/jassimp/jassimp/src/jassimp/AiCamera.java
@@ -0,0 +1,303 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library - Java Binding (jassimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2012, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+ copyright notice, this list of conditions and the
+ following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the
+ following disclaimer in the documentation and/or other
+ materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+ contributors may be used to endorse or promote products
+ derived from this software without specific prior
+ written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+package jassimp;
+
+
+/**
+ * Helper structure to describe a virtual camera.
+ *
+ * Cameras have a representation in the node graph and can be animated.
+ * An important aspect is that the camera itself is also part of the
+ * scenegraph. This means, any values such as the look-at vector are not
+ * *absolute*, they're relative to the coordinate system defined
+ * by the node which corresponds to the camera. This allows for camera
+ * animations. For static cameras parameters like the 'look-at' or 'up' vectors
+ * are usually specified directly in aiCamera, but beware, they could also
+ * be encoded in the node transformation. The following (pseudo)code sample
+ * shows how to do it:
+ *
+ *
+ * There must be a node in the scenegraph with the same name.
+ * This node specifies the position of the camera in the scene
+ * hierarchy and can be animated.
+ */
+ public String getName() {
+ return m_name;
+ }
+
+
+ /**
+ * Returns the position of the camera.
+ *
+ * The returned position is relative to the coordinate space defined by the
+ * corresponding node.
+ *
+ * The default value is 0|0|0.
+ *
+ * This method is part of the wrapped API (see {@link AiWrapperProvider}
+ * for details on wrappers).
+ *
+ * The built-in behavior is to return a {@link AiVector}.
+ *
+ * @param wrapperProvider the wrapper provider (used for type inference)
+ * @return the position vector
+ */
+ @SuppressWarnings("unchecked")
+ public
+ *
+ * The 'right' vector of the camera coordinate system is the cross product
+ * of the up and lookAt vectors. The default value is 0|1|0. The vector
+ * may be normalized, but it needn't.
+ *
+ * This method is part of the wrapped API (see {@link AiWrapperProvider}
+ * for details on wrappers).
+ *
+ * The built-in behavior is to return a {@link AiVector}.
+ *
+ * @param wrapperProvider the wrapper provider (used for type inference)
+ * @return the 'Up' vector
+ */
+ @SuppressWarnings("unchecked")
+ public
+ *
+ * The returned vector is relative to the coordinate space defined by the
+ * corresponding node.
+ *
+ * This is the viewing direction of the user. The default value is 0|0|1.
+ * The vector may be normalized, but it needn't.
+ *
+ * This method is part of the wrapped API (see {@link AiWrapperProvider}
+ * for details on wrappers).
+ *
+ * The built-in behavior is to return a {@link AiVector}.
+ *
+ * @param wrapperProvider the wrapper provider (used for type inference)
+ * @return the 'LookAt' vector
+ */
+ @SuppressWarnings("unchecked")
+ public
+ *
+ * The field of view angle is the angle between the center line of the
+ * screen and the left or right border. The default value is 1/4PI.
+ *
+ * @return the half horizontal field of view angle
+ */
+ public float getHorizontalFOV() {
+ return m_horizontalFOV;
+ }
+
+
+ /**
+ * Returns the distance of the near clipping plane from the camera.
+ *
+ * The value may not be 0.f (for arithmetic reasons to prevent a division
+ * through zero). The default value is 0.1f.
+ *
+ * @return the distance of the near clipping plane
+ */
+ public float getClipPlaneNear() {
+ return m_clipNear;
+ }
+
+
+ /**
+ * Returns the distance of the far clipping plane from the camera.
+ *
+ * The far clipping plane must, of course, be further away than the
+ * near clipping plane. The default value is 1000.0f. The ratio
+ * between the near and the far plane should not be too
+ * large (between 1000-10000 should be ok) to avoid floating-point
+ * inaccuracies which could lead to z-fighting.
+ *
+ * @return the distance of the far clipping plane
+ */
+ public float getClipPlaneFar() {
+ return m_clipFar;
+ }
+
+
+ /**
+ * Returns the screen aspect ratio.
+ *
+ * This is the ration between the width and the height of the
+ * screen. Typical values are 4/3, 1/2 or 1/1. This value is
+ * 0 if the aspect ratio is not defined in the source file.
+ * 0 is also the default value.
+ *
+ * @return the screen aspect ratio
+ */
+ public float getAspect() {
+ return m_aspect;
+ }
+
+
+ /**
+ * Name.
+ */
+ private final String m_name;
+
+
+ /**
+ * Position.
+ */
+ private final Object m_position;
+
+
+ /**
+ * Up vector.
+ */
+ private final Object m_up;
+
+
+ /**
+ * Look-At vector.
+ */
+ private final Object m_lookAt;
+
+
+ /**
+ * FOV.
+ */
+ private final float m_horizontalFOV;
+
+
+ /**
+ * Near clipping plane.
+ */
+ private final float m_clipNear;
+
+
+ /**
+ * Far clipping plane.
+ */
+ private final float m_clipFar;
+
+
+ /**
+ * Aspect ratio.
+ */
+ private final float m_aspect;
+}
\ No newline at end of file
diff --git a/port/jassimp/jassimp/src/jassimp/AiColor.java b/port/jassimp/jassimp/src/jassimp/AiColor.java
new file mode 100644
index 000000000..25eb251d6
--- /dev/null
+++ b/port/jassimp/jassimp/src/jassimp/AiColor.java
@@ -0,0 +1,162 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library - Java Binding (jassimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2012, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+ copyright notice, this list of conditions and the
+ following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the
+ following disclaimer in the documentation and/or other
+ materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+ contributors may be used to endorse or promote products
+ derived from this software without specific prior
+ written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+package jassimp;
+
+import java.nio.ByteBuffer;
+
+
+/**
+ * Wrapper for colors.
+ *
+ * The wrapper is writable, i.e., changes performed via the set-methods will
+ * modify the underlying mesh.
+ */
+public final class AiColor {
+ /**
+ * Constructor.
+ *
+ * @param buffer the buffer to wrap
+ * @param offset offset into buffer
+ */
+ public AiColor(ByteBuffer buffer, int offset) {
+ m_buffer = buffer;
+ m_offset = offset;
+ }
+
+
+ /**
+ * Returns the red color component.
+ *
+ * @return the red component
+ */
+ public float getRed() {
+ return m_buffer.getFloat(m_offset);
+ }
+
+
+ /**
+ * Returns the green color component.
+ *
+ * @return the green component
+ */
+ public float getGreen() {
+ return m_buffer.getFloat(m_offset + 4);
+ }
+
+
+ /**
+ * Returns the blue color component.
+ *
+ * @return the blue component
+ */
+ public float getBlue() {
+ return m_buffer.getFloat(m_offset + 8);
+ }
+
+
+ /**
+ * Returns the alpha color component.
+ *
+ * @return the alpha component
+ */
+ public float getAlpha() {
+ return m_buffer.getFloat(m_offset + 12);
+ }
+
+
+ /**
+ * Sets the red color component.
+ *
+ * @param red the new value
+ */
+ public void setRed(float red) {
+ m_buffer.putFloat(m_offset, red);
+ }
+
+
+ /**
+ * Sets the green color component.
+ *
+ * @param green the new value
+ */
+ public void setGreen(float green) {
+ m_buffer.putFloat(m_offset + 4, green);
+ }
+
+
+ /**
+ * Sets the blue color component.
+ *
+ * @param blue the new value
+ */
+ public void setBlue(float blue) {
+ m_buffer.putFloat(m_offset + 8, blue);
+ }
+
+
+ /**
+ * Sets the alpha color component.
+ *
+ * @param alpha the new value
+ */
+ public void setAlpha(float alpha) {
+ m_buffer.putFloat(m_offset + 12, alpha);
+ }
+
+
+ @Override
+ public String toString() {
+ return "[" + getRed() + ", " + getGreen() + ", " + getBlue() + ", " +
+ getAlpha() + "]";
+ }
+
+
+ /**
+ * Wrapped buffer.
+ */
+ private final ByteBuffer m_buffer;
+
+
+ /**
+ * Offset into m_buffer.
+ */
+ private final int m_offset;
+}
diff --git a/port/jassimp/jassimp/src/jassimp/AiConfig.java b/port/jassimp/jassimp/src/jassimp/AiConfig.java
new file mode 100644
index 000000000..f49ce8625
--- /dev/null
+++ b/port/jassimp/jassimp/src/jassimp/AiConfig.java
@@ -0,0 +1,15 @@
+/*
+ * $Revision$
+ * $Date$
+ */
+package jassimp;
+
+
+/**
+ * Configuration interface for assimp importer.
+ *
+ * This class is work-in-progress
+ */
+public class AiConfig {
+
+}
diff --git a/port/jassimp/jassimp/src/jassimp/AiConfigOptions.java b/port/jassimp/jassimp/src/jassimp/AiConfigOptions.java
new file mode 100644
index 000000000..6196598cd
--- /dev/null
+++ b/port/jassimp/jassimp/src/jassimp/AiConfigOptions.java
@@ -0,0 +1,663 @@
+/*
+ * $Revision$
+ * $Date$
+ */
+package jassimp;
+
+
+/**
+ * Lists all possible configuration options.
+ *
+ * This class is work-in-progress
+ */
+public enum AiConfigOptions {
+ /**
+ * Maximum bone count per mesh for the SplitbyBoneCount step.
+ *
+ * Meshes are split until the maximum number of bones is reached. The
+ * default value is AI_SBBC_DEFAULT_MAX_BONES, which may be altered at
+ * compile-time. This limit is imposed by the native jassimp library
+ * and typically is 60.
+ *
+ * Property data type: integer.
+ */
+ PP_SBBC_MAX_BONES("PP_SBBC_MAX_BONES"),
+
+
+ /**
+ * Specifies the maximum angle that may be between two vertex tangents
+ * that their tangents and bi-tangents are smoothed.
+ *
+ * This applies to the CalcTangentSpace-Step. The angle is specified
+ * in degrees. The maximum value is 175.
+ *
+ * Property type: float. Default value: 45 degrees
+ */
+ PP_CT_MAX_SMOOTHING_ANGLE("PP_CT_MAX_SMOOTHING_ANGLE"),
+
+
+ /**
+ * Source UV channel for tangent space computation.
+ *
+ * The specified channel must exist or an error will be raised.
+ *
+ * Property type: integer. Default value: 0
+ */
+ PP_CT_TEXTURE_CHANNEL_INDEX("PP_CT_TEXTURE_CHANNEL_INDEX"),
+
+
+ /**
+ * Specifies the maximum angle that may be between two face normals
+ * at the same vertex position that their are smoothed together.
+ *
+ * Sometimes referred to as 'crease angle'. This applies to the
+ * GenSmoothNormals-Step. The angle is specified in degrees, so 180 is PI.
+ * The default value is 175 degrees (all vertex normals are smoothed). The
+ * maximum value is 175, too.
+ *
+ * Property type: float.
+ *
+ * Warning: setting this option may cause a severe loss of performance. The
+ * performance is unaffected if the {@link #CONFIG_FAVOUR_SPEED} flag is
+ * set but the output quality may be reduced.
+ */
+ PP_GSN_MAX_SMOOTHING_ANGLE("PP_GSN_MAX_SMOOTHING_ANGLE"),
+
+
+ /**
+ * Sets the colormap (= palette) to be used to decode embedded textures in
+ * MDL (Quake or 3DGS) files.
+ *
+ * This must be a valid path to a file. The file is 768 (256*3) bytes
+ * large and contains RGB triplets for each of the 256 palette entries.
+ * The default value is colormap.lmp. If the file is not found,
+ * a default palette (from Quake 1) is used.
+ *
+ * Property type: string.
+ */
+ IMPORT_MDL_COLORMAP("IMPORT_MDL_COLORMAP"),
+
+
+ /**
+ * Configures the #aiProcess_RemoveRedundantMaterials step to keep
+ * materials matching a name in a given list.
+ *
+ * This is a list of 1 to n strings, ' ' serves as delimiter character.
+ * Identifiers containing whitespaces must be enclosed in *single*
+ * quotation marks. For example:
+ * "keep-me and_me_to anotherMaterialToBeKept \'name with whitespace\'".
+ * If a material matches on of these names, it will not be modified or
+ * removed by the postprocessing step nor will other materials be replaced
+ * by a reference to it.
+ *
+ * This option might be useful if you are using some magic material names
+ * to pass additional semantics through the content pipeline. This ensures
+ * they won't be optimized away, but a general optimization is still
+ * performed for materials not contained in the list.
+ *
+ * Property type: String. Default value: n/a
+ *
+ * Note:Linefeeds, tabs or carriage returns are treated as
+ * whitespace. Material names are case sensitive.
+ */
+ PP_RRM_EXCLUDE_LIST("PP_RRM_EXCLUDE_LIST"),
+
+
+ /**
+ * Configures the {@link AiPostProcessSteps#PRE_TRANSFORM_VERTICES} step
+ * to keep the scene hierarchy. Meshes are moved to worldspace, but no
+ * optimization is performed (read: meshes with equal materials are not
+ * joined. The total number of meshes won't change).
+ *
+ * This option could be of use for you if the scene hierarchy contains
+ * important additional information which you intend to parse.
+ * For rendering, you can still render all meshes in the scene without
+ * any transformations.
+ *
+ * Property type: bool. Default value: false.
+ */
+ PP_PTV_KEEP_HIERARCHY("PP_PTV_KEEP_HIERARCHY"),
+
+
+ /**
+ * Configures the {@link AiPostProcessSteps#PRE_TRANSFORM_VERTICES} step
+ * to normalize all vertex components into the [-1,1] range.
+ *
+ * That is, a bounding box for the whole scene is computed, the maximum
+ * component is taken and all meshes are scaled appropriately (uniformly
+ * of course!). This might be useful if you don't know the spatial
+ * dimension of the input data.
+ *
+ * Property type: bool. Default value: false.
+ */
+ PP_PTV_NORMALIZE("PP_PTV_NORMALIZE"),
+
+
+ /**
+ * Configures the {@link AiPostProcessSteps#FIND_DEGENERATES} step to
+ * remove degenerated primitives from the import - immediately.
+ *
+ * The default behaviour converts degenerated triangles to lines and
+ * degenerated lines to points. See the documentation to the
+ * {@link AiPostProcessSteps#FIND_DEGENERATES} step for a detailed example
+ * of the various ways to get rid of these lines and points if you don't
+ * want them.
+ *
+ * Property type: bool. Default value: false.
+ */
+ PP_FD_REMOVE("PP_FD_REMOVE")
+
+
+// // ---------------------------------------------------------------------------
+// /** @brief Configures the #aiProcess_OptimizeGraph step to preserve nodes
+// * matching a name in a given list.
+// *
+// * This is a list of 1 to n strings, ' ' serves as delimiter character.
+// * Identifiers containing whitespaces must be enclosed in *single*
+// * quotation marks. For example:
+// * "keep-me and_me_to anotherNodeToBeKept \'name with whitespace\'".
+// * If a node matches on of these names, it will not be modified or
+// * removed by the postprocessing step.
+ *
+ * Assimp supports multiple sorts of light sources, including
+ * directional, point and spot lights. All of them are defined with just
+ * a single structure and distinguished by their parameters.
+ * Note - some file formats (such as 3DS, ASE) export a "target point" -
+ * the point a spot light is looking at (it can even be animated). Assimp
+ * writes the target point as a subnode of a spotlights's main node,
+ * called "<spotName>.Target". However, this is just additional
+ * information then, the transformation tracks of the main node make the
+ * spot light already point in the right direction.
+ */
+public final class AiLight {
+ /**
+ * Constructor.
+ *
+ * @param name
+ * @param type
+ * @param position
+ * @param direction
+ * @param attenuationConstant
+ * @param attenuationLinear
+ * @param attenuationQuadratic
+ * @param diffuse
+ * @param specular
+ * @param ambient
+ * @param innerCone
+ * @param outerCone
+ */
+ AiLight(String name, int type, Object position, Object direction,
+ float attenuationConstant, float attenuationLinear,
+ float attenuationQuadratic, Object diffuse, Object specular,
+ Object ambient, float innerCone, float outerCone) {
+
+ m_name = name;
+ m_type = AiLightType.fromRawValue(type);
+ m_position = position;
+ m_direction = direction;
+ m_attenuationConstant = attenuationConstant;
+ m_attenuationLinear = attenuationLinear;
+ m_attenuationQuadratic = attenuationQuadratic;
+ m_diffuse = diffuse;
+ m_specular = specular;
+ m_ambient = ambient;
+ m_innerCone = innerCone;
+ m_outerCone = outerCone;
+ }
+
+
+ /**
+ * Returns the name of the light source.
+ *
+ * There must be a node in the scenegraph with the same name.
+ * This node specifies the position of the light in the scene
+ * hierarchy and can be animated.
+ *
+ * @return the name
+ */
+ public String getName() {
+ return m_name;
+ }
+
+
+ /**
+ * Returns The type of the light source.
+ *
+ * @return the type
+ */
+ public AiLightType getType() {
+ return m_type;
+ }
+
+
+ /**
+ * Returns the position of the light.
+ *
+ * The position is relative to the transformation of the scene graph node
+ * corresponding to the light. The position is undefined for directional
+ * lights.
+ *
+ * This method is part of the wrapped API (see {@link AiWrapperProvider}
+ * for details on wrappers).
+ *
+ * The built in behavior is to return an {@link AiVector}.
+ *
+ *
+ * @param wrapperProvider the wrapper provider (used for type inference)
+ *
+ * @return the position
+ */
+ @SuppressWarnings("unchecked")
+ public
+ *
+ * The direction is relative to the transformation of the scene graph node
+ * corresponding to the light. The direction is undefined for point lights.
+ * The vector may be normalized, but it needn't..
+ *
+ * This method is part of the wrapped API (see {@link AiWrapperProvider}
+ * for details on wrappers).
+ *
+ * The built in behavior is to return an {@link AiVector}.
+ *
+ * @param wrapperProvider the wrapper provider (used for type inference)
+ * @return the position
+ */
+ @SuppressWarnings("unchecked")
+ public
+ *
+ * The intensity of the light source at a given distance 'd' from
+ * the light's position is
+ *
+ *
+ * The intensity of the light source at a given distance 'd' from
+ * the light's position is
+ *
+ *
+ * The intensity of the light source at a given distance 'd' from
+ * the light's position is
+ *
+ *
+ * The diffuse light color is multiplied with the diffuse
+ * material color to obtain the final color that contributes
+ * to the diffuse shading term.
+ *
+ * This method is part of the wrapped API (see {@link AiWrapperProvider}
+ * for details on wrappers).
+ *
+ * The built in behavior is to return an {@link AiColor}.
+ *
+ * @param wrapperProvider the wrapper provider (used for type inference)
+ * @return the diffuse color (alpha will be 1)
+ */
+ @SuppressWarnings("unchecked")
+ public
+ *
+ * The specular light color is multiplied with the specular
+ * material color to obtain the final color that contributes
+ * to the specular shading term.
+ *
+ * This method is part of the wrapped API (see {@link AiWrapperProvider}
+ * for details on wrappers).
+ *
+ * The built in behavior is to return an {@link AiColor}.
+ *
+ * @param wrapperProvider the wrapper provider (used for type inference)
+ * @return the specular color (alpha will be 1)
+ */
+ @SuppressWarnings("unchecked")
+ public
+ *
+ * The ambient light color is multiplied with the ambient
+ * material color to obtain the final color that contributes
+ * to the ambient shading term. Most renderers will ignore
+ * this value it, is just a remaining of the fixed-function pipeline
+ * that is still supported by quite many file formats.
+ *
+ * This method is part of the wrapped API (see {@link AiWrapperProvider}
+ * for details on wrappers).
+ *
+ * The built in behavior is to return an {@link AiColor}.
+ *
+ * @param wrapperProvider the wrapper provider (used for type inference)
+ * @return the ambient color (alpha will be 1)
+ */
+ @SuppressWarnings("unchecked")
+ public
+ *
+ * The spot light has maximum influence on objects inside this
+ * angle. The angle is given in radians. It is 2PI for point
+ * lights and undefined for directional lights.
+ *
+ * @return the inner angle
+ */
+ public float getAngleInnerCone() {
+ return m_innerCone;
+ }
+
+
+ /**
+ * Outer angle of a spot light's light cone.
+ *
+ * The spot light does not affect objects outside this angle.
+ * The angle is given in radians. It is 2PI for point lights and
+ * undefined for directional lights. The outer angle must be
+ * greater than or equal to the inner angle.
+ * It is assumed that the application uses a smooth
+ * interpolation between the inner and the outer cone of the
+ * spot light.
+ *
+ * @return the outer angle
+ */
+ public float getAngleOuterCone() {
+ return m_outerCone;
+ }
+
+
+ /**
+ * Name.
+ */
+ private final String m_name;
+
+
+ /**
+ * Type.
+ */
+ private final AiLightType m_type;
+
+
+ /**
+ * Position.
+ */
+ private final Object m_position;
+
+
+ /**
+ * Direction.
+ */
+ private final Object m_direction;
+
+
+ /**
+ * Constant attenuation.
+ */
+ private final float m_attenuationConstant;
+
+
+ /**
+ * Linear attenuation.
+ */
+ private final float m_attenuationLinear;
+
+
+ /**
+ * Quadratic attenuation.
+ */
+ private final float m_attenuationQuadratic;
+
+
+ /**
+ * Diffuse color.
+ */
+ private final Object m_diffuse;
+
+
+ /**
+ * Specular color.
+ */
+ private final Object m_specular;
+
+
+ /**
+ * Ambient color.
+ */
+ private final Object m_ambient;
+
+
+ /**
+ * Inner cone of spotlight.
+ */
+ private final float m_innerCone;
+
+
+ /**
+ * Outer cone of spotlight.
+ */
+ private final float m_outerCone;
+}
diff --git a/port/jassimp/jassimp/src/jassimp/AiLightType.java b/port/jassimp/jassimp/src/jassimp/AiLightType.java
new file mode 100644
index 000000000..5df38763c
--- /dev/null
+++ b/port/jassimp/jassimp/src/jassimp/AiLightType.java
@@ -0,0 +1,112 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library - Java Binding (jassimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2012, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+ copyright notice, this list of conditions and the
+ following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the
+ following disclaimer in the documentation and/or other
+ materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+ contributors may be used to endorse or promote products
+ derived from this software without specific prior
+ written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+package jassimp;
+
+
+/**
+ * List of light types supported by {@link AiLight}.
+ */
+public enum AiLightType {
+ /**
+ * A directional light source.
+ *
+ * A directional light has a well-defined direction but is infinitely far
+ * away. That's quite a good approximation for sun light.
+ */
+ DIRECTIONAL(0x1),
+
+
+ /**
+ * A point light source.
+ *
+ * A point light has a well-defined position in space but no direction -
+ * it emits light in all directions. A normal bulb is a point light.
+ */
+ POINT(0x2),
+
+
+ /**
+ * A spot light source.
+ *
+ * A spot light emits light in a specific angle. It has a position and a
+ * direction it is pointing to. A good example for a spot light is a light
+ * spot in sport arenas.
+ */
+ SPOT(0x3);
+
+
+ /**
+ * Utility method for converting from c/c++ based integer enums to java
+ * enums.
+ *
+ * This method is intended to be used from JNI and my change based on
+ * implementation needs.
+ *
+ * @param rawValue an integer based enum value (as defined by assimp)
+ * @return the enum value corresponding to rawValue
+ */
+ static AiLightType fromRawValue(int rawValue) {
+ for (AiLightType type : AiLightType.values()) {
+ if (type.m_rawValue == rawValue) {
+ return type;
+ }
+ }
+
+ throw new IllegalArgumentException("unexptected raw value: " +
+ rawValue);
+ }
+
+
+ /**
+ * Constructor.
+ *
+ * @param rawValue maps java enum to c/c++ integer enum values
+ */
+ private AiLightType(int rawValue) {
+ m_rawValue = rawValue;
+ }
+
+
+ /**
+ * The mapped c/c++ integer enum value.
+ */
+ private final int m_rawValue;
+}
diff --git a/port/jassimp/jassimp/src/jassimp/AiMaterial.java b/port/jassimp/jassimp/src/jassimp/AiMaterial.java
new file mode 100644
index 000000000..7a9abc0d3
--- /dev/null
+++ b/port/jassimp/jassimp/src/jassimp/AiMaterial.java
@@ -0,0 +1,1202 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library - Java Binding (jassimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2012, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+ copyright notice, this list of conditions and the
+ following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the
+ following disclaimer in the documentation and/or other
+ materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+ contributors may be used to endorse or promote products
+ derived from this software without specific prior
+ written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+package jassimp;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.ArrayList;
+import java.util.EnumMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+
+/**
+ * Data structure for a material.
+ *
+ * Depending on the imported scene and scene format, individual properties
+ * might be present or not. A list of all imported properties can be retrieved
+ * via {@link #getProperties()}.
+ *
+ * This class offers
+ *
+ * If your application expects a certain set of properties to be available,
+ * the {@link #hasProperties(Set)} method can be used to check whether all
+ * these properties are actually set. If this check fails, you can still
+ * use this material via the
+ *
+ * This method is intended to be used from JNI and my change based on
+ * implementation needs.
+ *
+ * @param rawValue an integer based enum value (as defined by assimp)
+ * @return the enum value corresponding to rawValue
+ */
+ static PropertyType fromRawValue(int rawValue) {
+ for (PropertyType type : PropertyType.values()) {
+ if (type.m_rawValue == rawValue) {
+ return type;
+ }
+ }
+
+ throw new IllegalArgumentException("unexptected raw value: " +
+ rawValue);
+ }
+
+
+ /**
+ * Constructor.
+ *
+ * @param rawValue maps java enum to c/c++ integer enum values
+ */
+ private PropertyType(int rawValue) {
+ m_rawValue = rawValue;
+ }
+
+
+ /**
+ * The mapped c/c++ integer enum value.
+ */
+ private final int m_rawValue;
+ }
+
+
+ /**
+ * Data structure for a single material property.
+ *
+ * As an user, you'll probably never need to deal with this data structure.
+ * Just use the provided get() family of functions to query material
+ * properties easily.
+ */
+ public static final class Property {
+ /**
+ * Constructor.
+ *
+ * @param key
+ * @param semantic
+ * @param index
+ * @param type
+ * @param data
+ */
+ Property(String key, int semantic, int index, int type,
+ Object data) {
+
+ m_key = key;
+ m_semantic = semantic;
+ m_index = index;
+ m_type = PropertyType.fromRawValue(type);
+ m_data = data;
+ }
+
+
+ /**
+ * Constructor.
+ *
+ * @param key
+ * @param semantic
+ * @param index
+ * @param type
+ * @param dataLen
+ */
+ Property(String key, int semantic, int index, int type,
+ int dataLen) {
+
+ m_key = key;
+ m_semantic = semantic;
+ m_index = index;
+ m_type = PropertyType.fromRawValue(type);
+
+ ByteBuffer b = ByteBuffer.allocateDirect(dataLen);
+ b.order(ByteOrder.nativeOrder());
+
+ m_data = b;
+ }
+
+
+ /**
+ * Returns the key of the property.
+ *
+ * Keys are generally case insensitive.
+ *
+ * @return the key
+ */
+ public String getKey() {
+ return m_key;
+ }
+
+
+ /**
+ * Textures: Specifies their exact usage semantic.
+ * For non-texture properties, this member is always 0
+ * (or, better-said, #aiTextureType_NONE).
+ *
+ * @return the semantic
+ */
+ public int getSemantic() {
+ return m_semantic;
+ }
+
+
+ /**
+ * Textures: Specifies the index of the texture.
+ * For non-texture properties, this member is always 0.
+ *
+ * @return the index
+ */
+ public int getIndex() {
+ return m_index;
+ }
+
+
+ /**
+ * Type information for the property.
+ *
+ * Defines the data layout inside the data buffer. This is used
+ * by the library internally to perform debug checks and to
+ * utilize proper type conversions.
+ * (It's probably a hacky solution, but it works.)
+ *
+ * @return the type
+ */
+ public PropertyType getType() {
+ return m_type;
+ }
+
+
+ /**
+ * Binary buffer to hold the property's value.
+ * The size of the buffer is always mDataLength.
+ *
+ * @return the data
+ */
+ Object getData() {
+ return m_data;
+ }
+
+
+ /**
+ * Key.
+ */
+ private final String m_key;
+
+
+ /**
+ * Semantic.
+ */
+ private final int m_semantic;
+
+
+ /**
+ * Index.
+ */
+ private final int m_index;
+
+
+ /**
+ * Type.
+ */
+ private final PropertyType m_type;
+
+
+ /**
+ * Data.
+ */
+ private final Object m_data;
+ }
+
+
+ /**
+ * Constructor.
+ */
+ AiMaterial() {
+ /* nothing to do */
+ }
+
+
+ /**
+ * Checks whether the given set of properties is available.
+ *
+ * @param keys the keys to check
+ * @return true if all properties are available, false otherwise
+ */
+ public boolean hasProperties(Set
+ *
+ * The passed in Object must match the type of the key as returned by
+ * the corresponding
+ *
+ * If missing, defaults to empty string
+ *
+ * @return the name
+ */
+ public String getName() {
+ return getTyped(PropertyKey.NAME, String.class);
+ }
+
+
+ /**
+ * Returns the two-sided flag.
+ *
+ * If missing, defaults to 0
+ *
+ * @return the two-sided flag
+ */
+ public int getTwoSided() {
+ return getTyped(PropertyKey.TWO_SIDED, Integer.class);
+ }
+
+
+ /**
+ * Returns the shading mode.
+ *
+ * If missing, defaults to {@link AiShadingMode#FLAT}
+ *
+ * @return the shading mode
+ */
+ public AiShadingMode getShadingMode() {
+ Property p = getProperty(PropertyKey.SHADING_MODE.m_key);
+
+ if (null == p || null == p.getData()) {
+ return (AiShadingMode) m_defaults.get(PropertyKey.SHADING_MODE);
+ }
+
+ return AiShadingMode.fromRawValue((Integer) p.getData());
+ }
+
+
+ /**
+ * Returns the wireframe flag.
+ *
+ * If missing, defaults to 0
+ *
+ * @return the wireframe flag
+ */
+ public int getWireframe() {
+ return getTyped(PropertyKey.WIREFRAME, Integer.class);
+ }
+
+
+ /**
+ * Returns the blend mode.
+ *
+ * If missing, defaults to {@link AiBlendMode#DEFAULT}
+ *
+ * @return the blend mode
+ */
+ public AiBlendMode getBlendMode() {
+ Property p = getProperty(PropertyKey.BLEND_MODE.m_key);
+
+ if (null == p || null == p.getData()) {
+ return (AiBlendMode) m_defaults.get(PropertyKey.BLEND_MODE);
+ }
+
+ return AiBlendMode.fromRawValue((Integer) p.getData());
+ }
+
+
+ /**
+ * Returns the opacity.
+ *
+ * If missing, defaults to 1.0
+ *
+ * @return the opacity
+ */
+ public float getOpacity() {
+ return getTyped(PropertyKey.OPACITY, Float.class);
+ }
+
+
+ /**
+ * Returns the bump scaling factor.
+ *
+ * If missing, defaults to 1.0
+ *
+ * @return the bump scaling factor
+ */
+ public float getBumpScaling() {
+ return getTyped(PropertyKey.BUMP_SCALING, Float.class);
+ }
+
+
+ /**
+ * Returns the shininess.
+ *
+ * If missing, defaults to 1.0
+ *
+ * @return the shininess
+ */
+ public float getShininess() {
+ return getTyped(PropertyKey.SHININESS, Float.class);
+ }
+
+
+ /**
+ * Returns the reflectivity.
+ *
+ * If missing, defaults to 0.0
+ *
+ * @return the reflectivity
+ */
+ public float getReflectivity() {
+ return getTyped(PropertyKey.REFLECTIVITY, Float.class);
+ }
+
+
+ /**
+ * Returns the shininess strength.
+ *
+ * If missing, defaults to 0.0
+ *
+ * @return the shininess strength
+ */
+ public float getShininessStrength() {
+ return getTyped(PropertyKey.SHININESS_STRENGTH, Float.class);
+ }
+
+
+ /**
+ * Returns the refract index.
+ *
+ * If missing, defaults to 0.0
+ *
+ * @return the refract index
+ */
+ public float getRefractIndex() {
+ return getTyped(PropertyKey.REFRACTI, Float.class);
+ }
+
+
+ /**
+ * Returns the diffuse color.
+ *
+ * If missing, defaults to opaque white (1.0, 1.0, 1.0, 1.0)
+ *
+ * This method is part of the wrapped API (see {@link AiWrapperProvider}
+ * for details on wrappers).
+ *
+ * The built-in behavior is to return a {@link AiVector}.
+ *
+ * @param wrapperProvider the wrapper provider (used for type inference)
+ * @return the diffuse color
+ */
+ @SuppressWarnings("unchecked")
+ public
+ *
+ * If missing, defaults to opaque white (1.0, 1.0, 1.0, 1.0)
+ *
+ * This method is part of the wrapped API (see {@link AiWrapperProvider}
+ * for details on wrappers).
+ *
+ * The built-in behavior is to return a {@link AiVector}.
+ *
+ * @param wrapperProvider the wrapper provider (used for type inference)
+ * @return the ambient color
+ */
+ @SuppressWarnings("unchecked")
+ public
+ *
+ * If missing, defaults to opaque white (1.0, 1.0, 1.0, 1.0)
+ *
+ * This method is part of the wrapped API (see {@link AiWrapperProvider}
+ * for details on wrappers).
+ *
+ * The built-in behavior is to return a {@link AiVector}.
+ *
+ * @param wrapperProvider the wrapper provider (used for type inference)
+ * @return the specular color
+ */
+ @SuppressWarnings("unchecked")
+ public
+ *
+ * If missing, defaults to opaque white (1.0, 1.0, 1.0, 1.0)
+ *
+ * This method is part of the wrapped API (see {@link AiWrapperProvider}
+ * for details on wrappers).
+ *
+ * The built-in behavior is to return a {@link AiVector}.
+ *
+ * @param wrapperProvider the wrapper provider (used for type inference)
+ * @return the emissive color
+ */
+ @SuppressWarnings("unchecked")
+ public
+ *
+ * If missing, defaults to opaque white (1.0, 1.0, 1.0, 1.0)
+ *
+ * This method is part of the wrapped API (see {@link AiWrapperProvider}
+ * for details on wrappers).
+ *
+ * The built-in behavior is to return a {@link AiVector}.
+ *
+ * @param wrapperProvider the wrapper provider (used for type inference)
+ * @return the transparent color
+ */
+ @SuppressWarnings("unchecked")
+ public
+ *
+ * If missing, defaults to opaque white (1.0, 1.0, 1.0, 1.0)
+ *
+ * This method is part of the wrapped API (see {@link AiWrapperProvider}
+ * for details on wrappers).
+ *
+ * The built-in behavior is to return a {@link AiVector}.
+ *
+ * @param wrapperProvider the wrapper provider (used for type inference)
+ * @return the reflective color
+ */
+ @SuppressWarnings("unchecked")
+ public
+ *
+ * If missing, defaults to empty string
+ *
+ * @return the global background image
+ */
+ public String getGlobalBackgroundImage() {
+ return getTyped(PropertyKey.GLOBAL_BACKGROUND_IMAGE, String.class);
+ }
+
+
+ /**
+ * Returns the number of textures of the given type.
+ *
+ * @param type the type
+ * @return the number of textures
+ */
+ public int getNumTextures(AiTextureType type) {
+ return m_numTextures.get(type);
+ }
+
+
+ /**
+ * Returns the texture file.
+ *
+ * If missing, defaults to empty string
+ *
+ * @param type the texture type
+ * @param index the index in the texture stack
+ * @return the file
+ * @throws IndexOutOfBoundsException if index is invalid
+ */
+ public String getTextureFile(AiTextureType type, int index) {
+ checkTexRange(type, index);
+
+ return getTyped(PropertyKey.TEX_FILE, type, index, String.class);
+ }
+
+
+ /**
+ * Returns the index of the UV coordinate set used by the texture.
+ *
+ * If missing, defaults to 0
+ *
+ * @param type the texture type
+ * @param index the index in the texture stack
+ * @return the UV index
+ * @throws IndexOutOfBoundsException if index is invalid
+ */
+ public int getTextureUVIndex(AiTextureType type, int index) {
+ checkTexRange(type, index);
+
+ return getTyped(PropertyKey.TEX_UV_INDEX, type, index, Integer.class);
+ }
+
+
+ /**
+ * Returns the blend factor of the texture.
+ *
+ * If missing, defaults to 1.0
+ *
+ * @param type the texture type
+ * @param index the index in the texture stack
+ * @return the blend factor
+ */
+ public float getBlendFactor(AiTextureType type, int index) {
+ checkTexRange(type, index);
+
+ return getTyped(PropertyKey.TEX_BLEND, type, index, Float.class);
+ }
+
+
+ /**
+ * Returns the texture operation.
+ *
+ * If missing, defaults to {@link AiTextureOp#ADD}
+ *
+ * @param type the texture type
+ * @param index the index in the texture stack
+ * @return the texture operation
+ */
+ public AiTextureOp getTextureOp(AiTextureType type, int index) {
+ checkTexRange(type, index);
+
+ Property p = getProperty(PropertyKey.TEX_OP.m_key);
+
+ if (null == p || null == p.getData()) {
+ return (AiTextureOp) m_defaults.get(PropertyKey.TEX_OP);
+ }
+
+ return AiTextureOp.fromRawValue((Integer) p.getData());
+ }
+
+
+ /**
+ * Returns the texture mapping mode for the u axis.
+ *
+ * If missing, defaults to {@link AiTextureMapMode#CLAMP}
+ *
+ * @param type the texture type
+ * @param index the index in the texture stack
+ * @return the texture mapping mode
+ */
+ public AiTextureMapMode getTextureMapModeU(AiTextureType type, int index) {
+ checkTexRange(type, index);
+
+ Property p = getProperty(PropertyKey.TEX_MAP_MODE_U.m_key);
+
+ if (null == p || null == p.getData()) {
+ return (AiTextureMapMode) m_defaults.get(
+ PropertyKey.TEX_MAP_MODE_U);
+ }
+
+ return AiTextureMapMode.fromRawValue((Integer) p.getData());
+ }
+
+
+ /**
+ * Returns the texture mapping mode for the v axis.
+ *
+ * If missing, defaults to {@link AiTextureMapMode#CLAMP}
+ *
+ * @param type the texture type
+ * @param index the index in the texture stack
+ * @return the texture mapping mode
+ */
+ public AiTextureMapMode getTextureMapModeV(AiTextureType type, int index) {
+ checkTexRange(type, index);
+
+ Property p = getProperty(PropertyKey.TEX_MAP_MODE_V.m_key);
+
+ if (null == p || null == p.getData()) {
+ return (AiTextureMapMode) m_defaults.get(
+ PropertyKey.TEX_MAP_MODE_V);
+ }
+
+ return AiTextureMapMode.fromRawValue((Integer) p.getData());
+ }
+
+
+ /**
+ * Returns the texture mapping mode for the w axis.
+ *
+ * If missing, defaults to {@link AiTextureMapMode#CLAMP}
+ *
+ * @param type the texture type
+ * @param index the index in the texture stack
+ * @return the texture mapping mode
+ */
+ public AiTextureMapMode getTextureMapModeW(AiTextureType type, int index) {
+ checkTexRange(type, index);
+
+ Property p = getProperty(PropertyKey.TEX_MAP_MODE_W.m_key);
+
+ if (null == p || null == p.getData()) {
+ return (AiTextureMapMode) m_defaults.get(
+ PropertyKey.TEX_MAP_MODE_W);
+ }
+
+ return AiTextureMapMode.fromRawValue((Integer) p.getData());
+ }
+
+
+ /**
+ * Returns all information related to a single texture.
+ *
+ * @param type the texture type
+ * @param index the index in the texture stack
+ * @return the texture information
+ */
+ public AiTextureInfo getTextureInfo(AiTextureType type, int index) {
+ return new AiTextureInfo(type, index, getTextureFile(type, index),
+ getTextureUVIndex(type, index), getBlendFactor(type, index),
+ getTextureOp(type, index), getTextureMapModeW(type, index),
+ getTextureMapModeW(type, index),
+ getTextureMapModeW(type, index));
+ }
+ // }}
+
+ // {{ Generic Getters
+ /**
+ * Returns a single property based on its key.
+ *
+ * @param key the key
+ * @return the property or null if the property is not set
+ */
+ public Property getProperty(String key) {
+ for (Property property : m_properties) {
+ if (property.getKey().equals(key)) {
+ return property;
+ }
+ }
+
+ return null;
+ }
+
+
+ /**
+ * Returns a single property based on its key.
+ *
+ * @param key the key
+ * @param semantic the semantic type (texture type)
+ * @param index the index
+ * @return the property or null if the property is not set
+ */
+ public Property getProperty(String key, int semantic, int index) {
+ for (Property property : m_properties) {
+ if (property.getKey().equals(key) &&
+ property.m_semantic == semantic &&
+ property.m_index == index) {
+
+ return property;
+ }
+ }
+
+ return null;
+ }
+
+
+ /**
+ * Returns all properties of the material.
+ *
+ * @return the list of properties
+ */
+ public List
+ *
+ * The array must have exactly 16 entries. The data in the array must be in
+ * row-major order.
+ *
+ * @param data
+ * the array to wrap, may not be null
+ */
+ public AiMatrix4f(float[] data) {
+ if (data == null) {
+ throw new IllegalArgumentException("data may not be null");
+ }
+ if (data.length != 16) {
+ throw new IllegalArgumentException("array length is not 16");
+ }
+
+ m_data = data;
+ }
+
+ /**
+ * Gets an element of the matrix.
+ *
+ * @param row
+ * the row
+ * @param col
+ * the column
+ * @return the element at the given position
+ */
+ public float get(int row, int col) {
+ if (row < 0 || row > 3) {
+ throw new IndexOutOfBoundsException("Index: " + row + ", Size: 4");
+ }
+ if (col < 0 || col > 3) {
+ throw new IndexOutOfBoundsException("Index: " + col + ", Size: 4");
+ }
+
+ return m_data[row * 4 + col];
+ }
+
+ /**
+ * Stores the matrix in a new direct ByteBuffer with native byte order.
+ *
+ *
+ * The returned buffer can be passed to rendering APIs such as LWJGL, e.g.,
+ * as parameter for
+ *
+ *
+ *
+ * Faces consist of one or more references to vertices, called vertex indices.
+ * The {@link #getPrimitiveTypes()} method can be used to check what
+ * face types are present in the mesh. Note that a single mesh can possess
+ * faces of different types. The number of indices used by a specific face can
+ * be retrieved with the {@link #getFaceNumIndices(int)} method.
+ *
+ *
+ *
+ *
+ * The jassimp interface uses flat byte buffers to store vertex and face data.
+ * This data can be accessed through three APIs:
+ *
+ *
+ * The Direct API provides an easy to use interface for reading and writing
+ * individual data values. Its performance is comparable to the Buffer API's
+ * performance for these operations. The main difference to the Buffer API is
+ * the missing support for bulk operations. If you intend to retrieve or modify
+ * large subsets of the raw data consider using the Buffer API, especially
+ * if the subsets are contiguous.
+ *
+ *
+ * The Wrapped API offers an object oriented interface for accessing
+ * and modifying mesh data. As the name implies, this interface is realized
+ * through wrapper objects that provide a view on the raw data. For each
+ * invocation of a
+ * Modification of face data is theoretically possible by modifying the face
+ * buffer and the faceOffset buffer however it is strongly disadvised to do so
+ * because it might break all algorithms that depend on the internal consistency
+ * of these two data structures.
+ */
+public final class AiMesh {
+ /**
+ * Number of bytes per float value.
+ */
+ private static final int SIZEOF_FLOAT = 4;
+
+
+ /**
+ * Number of bytes per int value.
+ */
+ private static final int SIZEOF_INT = 4;
+
+
+ /**
+ * This class is instantiated via JNI, no accessible constructor.
+ */
+ private AiMesh() {
+ /* nothing to do */
+ }
+
+
+ /**
+ * Returns the primitive types used by this mesh.
+ *
+ * @return a set of primitive types used by this mesh
+ */
+ public Set
+ *
+ * To automatically triangulate meshes the
+ * {@link AiPostProcessSteps#TRIANGULATE} post processing option can be
+ * used when loading the scene
+ *
+ * @return true if the mesh is a pure triangle mesh, false otherwise
+ */
+ public boolean isPureTriangle() {
+ return m_primitiveTypes.contains(AiPrimitiveType.TRIANGLE) &&
+ m_primitiveTypes.size() == 1;
+ }
+
+
+ /**
+ * Tells whether the mesh has vertex positions.
+ *
+ * Meshes almost always contain position data
+ *
+ * @return true if positions are available
+ */
+ public boolean hasPositions() {
+ return m_vertices != null;
+ }
+
+
+ /**
+ * Tells whether the mesh has faces.
+ *
+ * Meshes almost always contain faces
+ *
+ * @return true if faces are available
+ */
+ public boolean hasFaces() {
+ return m_faces != null;
+ }
+
+
+ /**
+ * Tells whether the mesh has normals.
+ *
+ * @return true if normals are available
+ */
+ public boolean hasNormals() {
+ return m_normals != null;
+ }
+
+
+ /**
+ * Tells whether the mesh has tangents and bitangents.
+ *
+ * It is not possible that it contains tangents and no bitangents (or the
+ * other way round). The existence of one of them implies that the second
+ * is there, too.
+ *
+ * @return true if tangents and bitangents are available
+ */
+ public boolean hasTangentsAndBitangents() {
+ return m_tangents != null && m_tangents != null;
+ }
+
+
+ /**
+ * Tells whether the mesh has a vertex color set.
+ *
+ * @param colorset index of the color set
+ * @return true if colors are available
+ */
+ public boolean hasColors(int colorset) {
+ return m_colorsets[colorset] != null;
+ }
+
+
+ /**
+ * Tells whether the mesh has any vertex colors.
+ *
+ * Use {@link #hasColors(int)} to check which color sets are
+ * available.
+ *
+ * @return true if any colors are available
+ */
+ public boolean hasVertexColors() {
+ for (ByteBuffer buf : m_colorsets) {
+ if (buf != null) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+
+ /**
+ * Tells whether the mesh has a texture coordinate set.
+ *
+ * @param coords index of the texture coordinate set
+ * @return true if texture coordinates are available
+ */
+ public boolean hasTexCoords(int coords) {
+ return m_texcoords[coords] != null;
+ }
+
+
+ /**
+ * Tells whether the mesh has any texture coordinate sets.
+ *
+ * Use {@link #hasTexCoords(int)} to check which texture coordinate
+ * sets are available
+ *
+ * @return true if any texture coordinates are available
+ */
+ public boolean hasTexCoords() {
+ for (ByteBuffer buf : m_texcoords) {
+ if (buf != null) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+
+ /**
+ * Tells whether the mesh has bones.
+ *
+ * @return true if bones are available
+ */
+ public boolean hasBones() {
+ return !m_bones.isEmpty();
+ }
+
+
+ /**
+ * Returns the bones of this mesh.
+ *
+ * @return a list of bones
+ */
+ public List
+ *
+ * Possible values range from 1 to 3 (1D to 3D texture coordinates)
+ *
+ * @param coords the coordinate set
+ * @return the number of components
+ */
+ public int getNumUVComponents(int coords) {
+ return m_numUVComponents[coords];
+ }
+
+
+ /**
+ * Returns the material used by this mesh.
+ *
+ * A mesh does use only a single material. If an imported model uses
+ * multiple materials, the import splits up the mesh. Use this value
+ * as index into the scene's material list.
+ *
+ * @return the material index
+ */
+ public int getMaterialIndex() {
+ return m_materialIndex;
+ }
+
+
+ /**
+ * Returns the name of the mesh.
+ *
+ * Not all meshes have a name, if no name is set an empty string is
+ * returned.
+ *
+ * @return the name or an empty string if no name is set
+ */
+ public String getName() {
+ return m_name;
+ }
+
+
+ // CHECKSTYLE:OFF
+ @Override
+ public String toString() {
+ StringBuilder buf = new StringBuilder();
+ buf.append("Mesh(").append(m_numVertices).append(" vertices, ").
+ append(m_numFaces).append(" faces");
+
+ if (hasNormals()) {
+ buf.append(", normals");
+ }
+ if (hasTangentsAndBitangents()) {
+ buf.append(", (bi-)tangents");
+ }
+ if (hasVertexColors()) {
+ buf.append(", colors");
+ }
+ if (hasTexCoords()) {
+ buf.append(", texCoords");
+ }
+
+ buf.append(")");
+ return buf.toString();
+ }
+ // CHECKSTYLE:ON
+
+
+ // {{ Buffer API
+ /**
+ * Returns a buffer containing vertex positions.
+ *
+ * A vertex position consists of a triple of floats, the buffer will
+ * therefore contain
+ *
+ * You should use the {@link #getIndexBuffer()} method if you are
+ * interested in getting an index buffer used by graphics APIs such as
+ * LWJGL.
+ *
+ * The buffer contains all vertex indices from all faces as a flat list. If
+ * the mesh is a pure triangle mesh, the buffer returned by this method is
+ * identical to the buffer returned by {@link #getIndexBuffer()}. For other
+ * meshes, the {@link #getFaceOffsets()} method can be used to retrieve
+ * an index structure that allows addressing individual faces in the list.
+ *
+ * @return a native-order direct buffer, or null if no data is available
+ */
+ public IntBuffer getFaceBuffer() {
+ if (m_faces == null) {
+ return null;
+ }
+
+ return m_faces.asIntBuffer();
+ }
+
+
+ /**
+ * Returns an index structure for the buffer returned by
+ * {@link #getFaceBuffer()}.
+ *
+ * You should use the {@link #getIndexBuffer()} method if you are
+ * interested in getting an index buffer used by graphics APIs such as
+ * LWJGL.
+ *
+ * The returned buffer contains one integer entry for each face. This entry
+ * specifies the offset at which the face's data is located inside the
+ * face buffer. The difference between two subsequent entries can be used
+ * to determine how many vertices belong to a given face (the last face
+ * contains all entries between the offset and the end of the face buffer).
+ *
+ * @return a native-order direct buffer, or null if no data is available
+ */
+ public IntBuffer getFaceOffsets() {
+ if (m_faceOffsets == null) {
+ return null;
+ }
+
+ return m_faceOffsets.asIntBuffer();
+ }
+
+
+
+ /**
+ * Returns a buffer containing vertex indices for the mesh's faces.
+ *
+ * This method may only be called on pure triangle meshes, i.e., meshes
+ * containing only triangles. The {@link #isPureTriangle()} method can be
+ * used to check whether this is the case.
+ *
+ * Indices are stored as integers, the buffer will therefore contain
+ *
+ *
+ * A normal consists of a triple of floats, the buffer will
+ * therefore contain
+ *
+ * A tangent consists of a triple of floats, the buffer will
+ * therefore contain
+ *
+ * A bitangent consists of a triple of floats, the buffer will
+ * therefore contain
+ *
+ * A vertex color consists of 4 floats (red, green, blue and alpha), the
+ * buffer will therefore contain
+ *
+ * A texture coordinate consists of up to 3 floats (u, v, w). The actual
+ * number can be queried via {@link #getNumUVComponents(int)}. The
+ * buffer will contain
+ *
+ *
+ * A face contains
+ *
+ * This method may only be called on 2- or 3-dimensional coordinate sets.
+ * Call
+ *
+ * This method may only be called on 3-dimensional coordinate sets.
+ * Call
+ *
+ * This method is part of the wrapped API (see {@link AiWrapperProvider}
+ * for details on wrappers).
+ *
+ * The built-in behavior is to return a {@link AiVector}.
+ *
+ * @param vertex the vertex index
+ * @param wrapperProvider the wrapper provider (used for type inference)
+ * @return the position wrapped as object
+ */
+ public
+ *
+ * This method is part of the wrapped API (see {@link AiWrapperProvider}
+ * for details on wrappers).
+ *
+ * The built-in behavior is to return a {@link AiVector}.
+ *
+ * @param vertex the vertex index
+ * @param wrapperProvider the wrapper provider (used for type inference)
+ * @return the normal wrapped as object
+ */
+ public
+ *
+ * This method is part of the wrapped API (see {@link AiWrapperProvider}
+ * for details on wrappers).
+ *
+ * The built-in behavior is to return a {@link AiVector}.
+ *
+ * @param vertex the vertex index
+ * @param wrapperProvider the wrapper provider (used for type inference)
+ * @return the tangent wrapped as object
+ */
+ public
+ *
+ * This method is part of the wrapped API (see {@link AiWrapperProvider}
+ * for details on wrappers).
+ *
+ * The built-in behavior is to return a {@link AiVector}.
+ *
+ * @param vertex the vertex index
+ * @param wrapperProvider the wrapper provider (used for type inference)
+ * @return the bitangent wrapped as object
+ */
+ public
+ *
+ * This method is part of the wrapped API (see {@link AiWrapperProvider}
+ * for details on wrappers).
+ *
+ * The built-in behavior is to return a {@link AiColor}.
+ *
+ * @param vertex the vertex index
+ * @param colorset the color set
+ * @param wrapperProvider the wrapper provider (used for type inference)
+ * @return the vertex color wrapped as object
+ */
+ public
+ *
+ * This method is part of the wrapped API (see {@link AiWrapperProvider}
+ * for details on wrappers).
+ *
+ * The built-in behavior is to return a {@link AiVector}.
+ *
+ * @param vertex the vertex index
+ * @param coords the texture coordinate set
+ * @param wrapperProvider the wrapper provider (used for type inference)
+ * @return the texture coordinates wrapped as object
+ */
+ public
+ *
+ * Sets the primitive types enum set
+ *
+ * @param types the bitwise or'ed c/c++ aiPrimitiveType enum values
+ */
+ @SuppressWarnings("unused")
+ private void setPrimitiveTypes(int types) {
+ AiPrimitiveType.fromRawValue(m_primitiveTypes, types);
+ }
+
+
+ /**
+ * This method is used by JNI. Do not call or modify.
+ *
+ * Allocates byte buffers
+ *
+ * @param numVertices the number of vertices in the mesh
+ * @param numFaces the number of faces in the mesh
+ * @param optimizedFaces set true for optimized face representation
+ * @param faceBufferSize size of face buffer for non-optimized face
+ * representation
+ */
+ @SuppressWarnings("unused")
+ private void allocateBuffers(int numVertices, int numFaces,
+ boolean optimizedFaces, int faceBufferSize) {
+ /*
+ * the allocated buffers are native order direct byte buffers, so they
+ * can be passed directly to LWJGL or similar graphics APIs
+ */
+
+ /* ensure face optimization is possible */
+ if (optimizedFaces && !isPureTriangle()) {
+ throw new IllegalArgumentException("mesh is not purely triangular");
+ }
+
+
+ m_numVertices = numVertices;
+ m_numFaces = numFaces;
+
+
+ /* allocate for each vertex 3 floats */
+ if (m_numVertices > 0) {
+ m_vertices = ByteBuffer.allocateDirect(numVertices * 3 *
+ SIZEOF_FLOAT);
+ m_vertices.order(ByteOrder.nativeOrder());
+ }
+
+
+ if (m_numFaces > 0) {
+ /* for optimized faces allocate 3 integers per face */
+ if (optimizedFaces) {
+ m_faces = ByteBuffer.allocateDirect(numFaces * 3 * SIZEOF_INT);
+ m_faces.order(ByteOrder.nativeOrder());
+ }
+ /*
+ * for non-optimized faces allocate the passed in buffer size
+ * and allocate the face index structure
+ */
+ else {
+ m_faces = ByteBuffer.allocateDirect(faceBufferSize);
+ m_faces.order(ByteOrder.nativeOrder());
+
+ m_faceOffsets = ByteBuffer.allocateDirect(numFaces *
+ SIZEOF_INT);
+ m_faceOffsets.order(ByteOrder.nativeOrder());
+ }
+ }
+ }
+
+
+ /**
+ * This method is used by JNI. Do not call or modify.
+ *
+ * Allocates a byte buffer for a vertex data channel
+ *
+ * @param channelType the channel type
+ * @param channelIndex sub-index, used for types that can have multiple
+ * channels, such as texture coordinates
+ */
+ @SuppressWarnings("unused")
+ private void allocateDataChannel(int channelType, int channelIndex) {
+ switch (channelType) {
+ case NORMALS:
+ m_normals = ByteBuffer.allocateDirect(
+ m_numVertices * 3 * SIZEOF_FLOAT);
+ m_normals.order(ByteOrder.nativeOrder());
+ break;
+ case TANGENTS:
+ m_tangents = ByteBuffer.allocateDirect(
+ m_numVertices * 3 * SIZEOF_FLOAT);
+ m_tangents.order(ByteOrder.nativeOrder());
+ break;
+ case BITANGENTS:
+ m_bitangents = ByteBuffer.allocateDirect(
+ m_numVertices * 3 * SIZEOF_FLOAT);
+ m_bitangents.order(ByteOrder.nativeOrder());
+ break;
+ case COLORSET:
+ m_colorsets[channelIndex] = ByteBuffer.allocateDirect(
+ m_numVertices * 4 * SIZEOF_FLOAT);
+ m_colorsets[channelIndex].order(ByteOrder.nativeOrder());
+ break;
+ case TEXCOORDS_1D:
+ m_numUVComponents[channelIndex] = 1;
+ m_texcoords[channelIndex] = ByteBuffer.allocateDirect(
+ m_numVertices * 1 * SIZEOF_FLOAT);
+ m_texcoords[channelIndex].order(ByteOrder.nativeOrder());
+ break;
+ case TEXCOORDS_2D:
+ m_numUVComponents[channelIndex] = 2;
+ m_texcoords[channelIndex] = ByteBuffer.allocateDirect(
+ m_numVertices * 2 * SIZEOF_FLOAT);
+ m_texcoords[channelIndex].order(ByteOrder.nativeOrder());
+ break;
+ case TEXCOORDS_3D:
+ m_numUVComponents[channelIndex] = 3;
+ m_texcoords[channelIndex] = ByteBuffer.allocateDirect(
+ m_numVertices * 3 * SIZEOF_FLOAT);
+ m_texcoords[channelIndex].order(ByteOrder.nativeOrder());
+ break;
+ default:
+ throw new IllegalArgumentException("unsupported channel type");
+ }
+ }
+ // }}
+
+
+ /**
+ * The primitive types used by this mesh.
+ */
+ private final Set
+ *
+ * Only used by meshes that are not pure triangular
+ */
+ private ByteBuffer m_faceOffsets = null;
+
+
+ /**
+ * Buffer for normals.
+ */
+ private ByteBuffer m_normals = null;
+
+
+ /**
+ * Buffer for tangents.
+ */
+ private ByteBuffer m_tangents = null;
+
+
+ /**
+ * Buffer for bitangents.
+ */
+ private ByteBuffer m_bitangents = null;
+
+
+ /**
+ * Vertex colors.
+ */
+ private ByteBuffer[] m_colorsets =
+ new ByteBuffer[JassimpConfig.MAX_NUMBER_COLORSETS];
+
+
+ /**
+ * Number of UV components for each texture coordinate set.
+ */
+ private int[] m_numUVComponents = new int[JassimpConfig.MAX_NUMBER_TEXCOORDS];
+
+
+ /**
+ * Texture coordinates.
+ */
+ private ByteBuffer[] m_texcoords =
+ new ByteBuffer[JassimpConfig.MAX_NUMBER_TEXCOORDS];
+
+
+ /**
+ * Bones.
+ */
+ private final List
+ *
+ * Each node has name, a parent node (except for the root node),
+ * a transformation relative to its parent and possibly several child nodes.
+ * Simple file formats don't support hierarchical structures - for these formats
+ * the imported scene consists of only a single root node without children.
+ */
+public final class AiNode {
+ /**
+ * Constructor.
+ *
+ * @param parent the parent node, may be null
+ * @param transform the transform matrix
+ * @param meshReferences array of mesh references
+ * @param name the name of the node
+ */
+ AiNode(AiNode parent, Object transform, int[] meshReferences, String name) {
+ m_parent = parent;
+ m_transformationMatrix = transform;
+ m_meshReferences = meshReferences;
+ m_name = name;
+
+ if (null != m_parent) {
+ m_parent.addChild(this);
+ }
+ }
+
+
+ /**
+ * Returns the name of this node.
+ *
+ * @return the name
+ */
+ public String getName() {
+ return m_name;
+ }
+
+
+ /**
+ * Returns the number of child nodes.
+ *
+ * This method exists for compatibility reasons with the native assimp API.
+ * The returned value is identical to
+ *
+ * This method is part of the wrapped API (see {@link AiWrapperProvider}
+ * for details on wrappers).
+ *
+ * The built in behavior is to return an {@link AiMatrix4f}.
+ *
+ * @param wrapperProvider the wrapper provider (used for type inference)
+ *
+ * @return a matrix
+ */
+ @SuppressWarnings("unchecked")
+ public
+ *
+ * This method exists for compatibility with the native assimp API.
+ * The returned value is identical to
+ *
+ * Each entry is an index into the mesh list stored in {@link AiScene}.
+ *
+ * @return an array of indices
+ */
+ public int[] getMeshes() {
+ return m_meshReferences;
+ }
+
+
+ /**
+ * Adds a child node.
+ *
+ * @param child the child to add
+ */
+ void addChild(AiNode child) {
+ m_children.add(child);
+ }
+
+
+ /**
+ * Name.
+ */
+ private final String m_name;
+
+
+ /**
+ * Parent node.
+ */
+ private final AiNode m_parent;
+
+
+ /**
+ * Mesh references.
+ */
+ private final int[] m_meshReferences;
+
+
+ /**
+ * List of children.
+ */
+ private final List
+ *
+ * The node name ({@link #getNodeName()} specifies the bone/node which is
+ * affected by this animation channel. The keyframes are given in three
+ * separate series of values, one each for position, rotation and scaling.
+ * The transformation matrix computed from these values replaces the node's
+ * original transformation matrix at a specific time.
+ *
+ * This means all keys are absolute and not relative to the bone default pose.
+ * The order in which the transformations are applied is - as usual -
+ * scaling, rotation, translation.
+ *
+ * Note: All keys are returned in their correct, chronological order.
+ * Duplicate keys don't pass the validation step. Most likely there
+ * will be no negative time values, but they are not forbidden also (so
+ * implementations need to cope with them!)
+ *
+ * Like {@link AiMesh}, the animation related classes offer a Buffer API, a
+ * Direct API and a wrapped API. Please consult the documentation of
+ * {@link AiMesh} for a description and comparison of these APIs.
+ */
+public final class AiNodeAnim {
+ /**
+ * Size of one position key entry (includes padding).
+ */
+ private static final int POS_KEY_SIZE = 24;
+
+ /**
+ * Size of one rotation key entry.
+ */
+ private static final int ROT_KEY_SIZE = 24;
+
+ /**
+ * Size of one scaling key entry (includes padding).
+ */
+ private static final int SCALE_KEY_SIZE = 24;
+
+
+ /**
+ * Constructor.
+ *
+ * @param nodeName name of corresponding scene graph node
+ * @param numPosKeys number of position keys
+ * @param numRotKeys number of rotation keys
+ * @param numScaleKeys number of scaling keys
+ * @param preBehavior behavior before animation start
+ * @param postBehavior behavior after animation end
+ */
+ AiNodeAnim(String nodeName, int numPosKeys, int numRotKeys,
+ int numScaleKeys, int preBehavior, int postBehavior) {
+
+ m_nodeName = nodeName;
+ m_numPosKeys = numPosKeys;
+ m_numRotKeys = numRotKeys;
+ m_numScaleKeys = numScaleKeys;
+ m_preState = AiAnimBehavior.fromRawValue(preBehavior);
+ m_postState = AiAnimBehavior.fromRawValue(postBehavior);
+
+ /* c data is padded -> 24 bytes with 20 bytes data */
+ m_posKeys = ByteBuffer.allocateDirect(numPosKeys * POS_KEY_SIZE);
+ m_posKeys.order(ByteOrder.nativeOrder());
+
+ m_rotKeys = ByteBuffer.allocateDirect(numRotKeys * 24);
+ m_rotKeys.order(ByteOrder.nativeOrder());
+
+ m_scaleKeys = ByteBuffer.allocateDirect(numScaleKeys * 24);
+ m_scaleKeys.order(ByteOrder.nativeOrder());
+ }
+
+
+ /**
+ * Returns the name of the scene graph node affected by this animation.
+ *
+ * The node must exist and it must be unique.
+ *
+ * @return the name of the affected node
+ */
+ public String getNodeName() {
+ return m_nodeName;
+ }
+
+
+ /**
+ * Returns the number of position keys.
+ *
+ * @return the number of position keys
+ */
+ public int getNumPosKeys() {
+ return m_numPosKeys;
+ }
+
+
+ /**
+ * Returns the buffer with position keys of this animation channel.
+ *
+ * Position keys consist of a time value (double) and a position (3D vector
+ * of floats), resulting in a total of 24 bytes per entry with padding.
+ * The buffer contains {@link #getNumPosKeys()} of these entries.
+ *
+ * If there are position keys, there will also be at least one
+ * scaling and one rotation key.
+ *
+ * @return a native order, direct ByteBuffer
+ */
+ public ByteBuffer getPosKeyBuffer() {
+ ByteBuffer buf = m_posKeys.duplicate();
+ buf.order(ByteOrder.nativeOrder());
+
+ return buf;
+ }
+
+
+ /**
+ * Returns the time component of the specified position key.
+ *
+ * @param keyIndex the index of the position key
+ * @return the time component
+ */
+ public double getPosKeyTime(int keyIndex) {
+ return m_posKeys.getDouble(POS_KEY_SIZE * keyIndex);
+ }
+
+
+ /**
+ * Returns the position x component of the specified position key.
+ *
+ * @param keyIndex the index of the position key
+ * @return the x component
+ */
+ public float getPosKeyX(int keyIndex) {
+ return m_posKeys.getFloat(POS_KEY_SIZE * keyIndex + 8);
+ }
+
+
+ /**
+ * Returns the position y component of the specified position key.
+ *
+ * @param keyIndex the index of the position key
+ * @return the y component
+ */
+ public float getPosKeyY(int keyIndex) {
+ return m_posKeys.getFloat(POS_KEY_SIZE * keyIndex + 12);
+ }
+
+
+ /**
+ * Returns the position z component of the specified position key.
+ *
+ * @param keyIndex the index of the position key
+ * @return the z component
+ */
+ public float getPosKeyZ(int keyIndex) {
+ return m_posKeys.getFloat(POS_KEY_SIZE * keyIndex + 16);
+ }
+
+
+ /**
+ * Returns the position as vector.
+ *
+ * This method is part of the wrapped API (see {@link AiWrapperProvider}
+ * for details on wrappers).
+ *
+ * The built in behavior is to return an {@link AiVector}.
+ *
+ * @param wrapperProvider the wrapper provider (used for type inference)
+ *
+ * @return the position as vector
+ */
+ public
+ *
+ * Rotation keys consist of a time value (double) and a quaternion (4D
+ * vector of floats), resulting in a total of 24 bytes per entry. The
+ * buffer contains {@link #getNumRotKeys()} of these entries.
+ *
+ * If there are rotation keys, there will also be at least one
+ * scaling and one position key.
+ *
+ * @return a native order, direct ByteBuffer
+ */
+ public ByteBuffer getRotKeyBuffer() {
+ ByteBuffer buf = m_rotKeys.duplicate();
+ buf.order(ByteOrder.nativeOrder());
+
+ return buf;
+ }
+
+
+ /**
+ * Returns the time component of the specified rotation key.
+ *
+ * @param keyIndex the index of the position key
+ * @return the time component
+ */
+ public double getRotKeyTime(int keyIndex) {
+ return m_rotKeys.getDouble(ROT_KEY_SIZE * keyIndex);
+ }
+
+
+ /**
+ * Returns the rotation w component of the specified rotation key.
+ *
+ * @param keyIndex the index of the position key
+ * @return the w component
+ */
+ public float getRotKeyW(int keyIndex) {
+ return m_rotKeys.getFloat(ROT_KEY_SIZE * keyIndex + 8);
+ }
+
+
+ /**
+ * Returns the rotation x component of the specified rotation key.
+ *
+ * @param keyIndex the index of the position key
+ * @return the x component
+ */
+ public float getRotKeyX(int keyIndex) {
+ return m_rotKeys.getFloat(ROT_KEY_SIZE * keyIndex + 12);
+ }
+
+
+ /**
+ * Returns the rotation y component of the specified rotation key.
+ *
+ * @param keyIndex the index of the position key
+ * @return the y component
+ */
+ public float getRotKeyY(int keyIndex) {
+ return m_rotKeys.getFloat(ROT_KEY_SIZE * keyIndex + 16);
+ }
+
+
+ /**
+ * Returns the rotation z component of the specified rotation key.
+ *
+ * @param keyIndex the index of the position key
+ * @return the z component
+ */
+ public float getRotKeyZ(int keyIndex) {
+ return m_rotKeys.getFloat(ROT_KEY_SIZE * keyIndex + 20);
+ }
+
+
+ /**
+ * Returns the rotation as quaternion.
+ *
+ * This method is part of the wrapped API (see {@link AiWrapperProvider}
+ * for details on wrappers).
+ *
+ * The built in behavior is to return an {@link AiQuaternion}.
+ *
+ * @param wrapperProvider the wrapper provider (used for type inference)
+ *
+ * @return the rotation as quaternion
+ */
+ public
+ *
+ * Scaling keys consist of a time value (double) and a 3D vector of floats,
+ * resulting in a total of 24 bytes per entry with padding. The buffer
+ * contains {@link #getNumScaleKeys()} of these entries.
+ *
+ * If there are scaling keys, there will also be at least one
+ * position and one rotation key.
+ *
+ * @return a native order, direct ByteBuffer
+ */
+ public ByteBuffer getScaleKeyBuffer() {
+ ByteBuffer buf = m_scaleKeys.duplicate();
+ buf.order(ByteOrder.nativeOrder());
+
+ return buf;
+ }
+
+
+ /**
+ * Returns the time component of the specified scaling key.
+ *
+ * @param keyIndex the index of the position key
+ * @return the time component
+ */
+ public double getScaleKeyTime(int keyIndex) {
+ return m_scaleKeys.getDouble(SCALE_KEY_SIZE * keyIndex);
+ }
+
+
+ /**
+ * Returns the scaling x component of the specified scaling key.
+ *
+ * @param keyIndex the index of the position key
+ * @return the x component
+ */
+ public float getScaleKeyX(int keyIndex) {
+ return m_scaleKeys.getFloat(SCALE_KEY_SIZE * keyIndex + 8);
+ }
+
+
+ /**
+ * Returns the scaling y component of the specified scaling key.
+ *
+ * @param keyIndex the index of the position key
+ * @return the y component
+ */
+ public float getScaleKeyY(int keyIndex) {
+ return m_scaleKeys.getFloat(SCALE_KEY_SIZE * keyIndex + 12);
+ }
+
+
+ /**
+ * Returns the scaling z component of the specified scaling key.
+ *
+ * @param keyIndex the index of the position key
+ * @return the z component
+ */
+ public float getScaleKeyZ(int keyIndex) {
+ return m_scaleKeys.getFloat(SCALE_KEY_SIZE * keyIndex + 16);
+ }
+
+
+ /**
+ * Returns the scaling factor as vector.
+ *
+ * This method is part of the wrapped API (see {@link AiWrapperProvider}
+ * for details on wrappers).
+ *
+ * The built in behavior is to return an {@link AiVector}.
+ *
+ * @param wrapperProvider the wrapper provider (used for type inference)
+ *
+ * @return the scaling factor as vector
+ */
+ public
+ *
+ * The default value is {@link AiAnimBehavior#DEFAULT} (the original
+ * transformation matrix of the affected node is used).
+ *
+ * @return the animation behavior before the first key
+ */
+ public AiAnimBehavior getPreState() {
+ return m_preState;
+ }
+
+
+ /**
+ * Defines how the animation behaves after the last key was processed.
+ *
+ * The default value is {@link AiAnimBehavior#DEFAULT} (the original
+ * transformation matrix of the affected node is taken).
+ *
+ * @return the animation behavior before after the last key
+ */
+ public AiAnimBehavior getPostState() {
+ return m_postState;
+ }
+
+
+ /**
+ * Node name.
+ */
+ private final String m_nodeName;
+
+
+ /**
+ * Number of position keys.
+ */
+ private final int m_numPosKeys;
+
+
+ /**
+ * Buffer with position keys.
+ */
+ private ByteBuffer m_posKeys;
+
+
+ /**
+ * Number of rotation keys.
+ */
+ private final int m_numRotKeys;
+
+
+ /**
+ * Buffer for rotation keys.
+ */
+ private ByteBuffer m_rotKeys;
+
+
+ /**
+ * Number of scaling keys.
+ */
+ private final int m_numScaleKeys;
+
+
+ /**
+ * Buffer for scaling keys.
+ */
+ private ByteBuffer m_scaleKeys;
+
+
+ /**
+ * Pre animation behavior.
+ */
+ private final AiAnimBehavior m_preState;
+
+
+ /**
+ * Post animation behavior.
+ */
+ private final AiAnimBehavior m_postState;
+}
diff --git a/port/jassimp/jassimp/src/jassimp/AiPostProcessSteps.java b/port/jassimp/jassimp/src/jassimp/AiPostProcessSteps.java
new file mode 100644
index 000000000..905229190
--- /dev/null
+++ b/port/jassimp/jassimp/src/jassimp/AiPostProcessSteps.java
@@ -0,0 +1,571 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library - Java Binding (jassimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2012, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+ copyright notice, this list of conditions and the
+ following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the
+ following disclaimer in the documentation and/or other
+ materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+ contributors may be used to endorse or promote products
+ derived from this software without specific prior
+ written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+package jassimp;
+
+import java.util.Set;
+
+/**
+ * Enumerates the post processing steps supported by assimp.
+ */
+public enum AiPostProcessSteps {
+
+ /**
+ * Calculates the tangents and bitangents for the imported meshes.
+ *
+ *
+ * Does nothing if a mesh does not have normals. You might want this post
+ * processing step to be executed if you plan to use tangent space
+ * calculations such as normal mapping applied to the meshes. There's a
+ * config setting, #AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE, which
+ * allows you to specify a maximum smoothing angle for the algorithm.
+ * However, usually you'll want to leave it at the default value.
+ */
+ CALC_TANGENT_SPACE(0x1),
+
+
+ /**
+ * Identifies and joins identical vertex data sets within all imported
+ * meshes.
+ *
+ * After this step is run, each mesh contains unique vertices, so a vertex
+ * may be used by multiple faces. You usually want to use this post
+ * processing step. If your application deals with indexed geometry, this
+ * step is compulsory or you'll just waste rendering time. If this flag
+ * is not specified, no vertices are referenced by more than one face
+ * and no index buffer is required for rendering.
+ */
+ JOIN_IDENTICAL_VERTICES(0x2),
+
+
+ /**
+ * Converts all the imported data to a left-handed coordinate space.
+ *
+ * By default the data is returned in a right-handed coordinate space (which
+ * OpenGL prefers). In this space, +X points to the right, +Z points towards
+ * the viewer, and +Y points upwards. In the DirectX coordinate space +X
+ * points to the right, +Y points upwards, and +Z points away from the
+ * viewer.
+ *
+ * You'll probably want to consider this flag if you use Direct3D for
+ * rendering. The #ConvertToLeftHanded flag supersedes this
+ * setting and bundles all conversions typically required for D3D-based
+ * applications.
+ */
+ MAKE_LEFT_HANDED(0x4),
+
+
+ /**
+ * Triangulates all faces of all meshes.
+ *
+ * By default the imported mesh data might contain faces with more than 3
+ * indices. For rendering you'll usually want all faces to be triangles.
+ * This post processing step splits up faces with more than 3 indices into
+ * triangles. Line and point primitives are *not* modified! If you want
+ * 'triangles only' with no other kinds of primitives, try the following
+ * solution:
+ *
+ *
+ * The components to be removed are specified in a separate configuration
+ * option, #AI_CONFIG_PP_RVC_FLAGS. This is quite useful if you
+ * don't need all parts of the output structure. Vertex colors are rarely
+ * used today for example... Calling this step to remove unneeded data from
+ * the pipeline as early as possible results in increased performance and a
+ * more optimized output data structure. This step is also useful if you
+ * want to force Assimp to recompute normals or tangents. The corresponding
+ * steps don't recompute them if they're already there (loaded from the
+ * source asset). By using this step you can make sure they are NOT there.
+ *
+ *
+ * This flag is a poor one, mainly because its purpose is usually
+ * misunderstood. Consider the following case: a 3D model has been exported
+ * from a CAD app, and it has per-face vertex colors. Vertex positions can't
+ * be shared, thus the #JoinIdenticalVertices step fails to
+ * optimize the data because of these nasty little vertex colors. Most apps
+ * don't even process them, so it's all for nothing. By using this step,
+ * unneeded components are excluded as early as possible thus opening more
+ * room for internal optimizations.
+ */
+ REMOVE_COMPONENT(0x10),
+
+
+ /**
+ * Generates normals for all faces of all meshes.
+ *
+ * This is ignored if normals are already there at the time this flag is
+ * evaluated. Model importers try to load them from the source file, so
+ * they're usually already there. Face normals are shared between all points
+ * of a single face, so a single point can have multiple normals, which
+ * forces the library to duplicate vertices in some cases.
+ * #JoinIdenticalVertices is *senseless* then.
+ *
+ * This flag may not be specified together with {@link #GEN_SMOOTH_NORMALS}.
+ */
+ GEN_NORMALS(0x20),
+
+
+ /**
+ * Generates smooth normals for all vertices in the mesh.
+ *
+ * This is ignored if normals are already there at the time this flag is
+ * evaluated. Model importers try to load them from the source file, so
+ * they're usually already there.
+ *
+ * This flag may not be specified together with {@link #GEN_NORMALS}
+ * There's a configuration option,
+ * #AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE which allows you to
+ * specify an angle maximum for the normal smoothing algorithm. Normals
+ * exceeding this limit are not smoothed, resulting in a 'hard' seam between
+ * two faces. Using a decent angle here (e.g. 80 degrees) results in very
+ * good visual appearance.
+ */
+ GEN_SMOOTH_NORMALS(0x40),
+
+
+ /**
+ * Splits large meshes into smaller sub-meshes.
+ *
+ * This is quite useful for real-time rendering, where the number of
+ * triangles which can be maximally processed in a single draw-call is
+ * limited by the video driver/hardware. The maximum vertex buffer is
+ * usually limited too. Both requirements can be met with this step: you may
+ * specify both a triangle and vertex limit for a single mesh.
+ *
+ * The split limits can (and should!) be set through the
+ * #AI_CONFIG_PP_SLM_VERTEX_LIMIT and
+ * #AI_CONFIG_PP_SLM_TRIANGLE_LIMIT settings. The default values
+ * are #AI_SLM_DEFAULT_MAX_VERTICES and
+ * #AI_SLM_DEFAULT_MAX_TRIANGLES.
+ *
+ * Note that splitting is generally a time-consuming task, but only if
+ * there's something to split. The use of this step is recommended for most
+ * users.
+ */
+ SPLIT_LARGE_MESHES(0x80),
+
+
+ /**
+ * Removes the node graph and pre-transforms all vertices with the local
+ * transformation matrices of their nodes.
+ *
+ * The output scene still contains nodes, however there is only a root node
+ * with children, each one referencing only one mesh, and each mesh
+ * referencing one material. For rendering, you can simply render all meshes
+ * in order - you don't need to pay attention to local transformations and
+ * the node hierarchy. Animations are removed during this step. This step is
+ * intended for applications without a scenegraph. The step CAN cause some
+ * problems: if e.g. a mesh of the asset contains normals and another, using
+ * the same material index, does not, they will be brought together, but the
+ * first meshes's part of the normal list is zeroed. However, these
+ * artifacts are rare.
+ *
+ * Note: The #AI_CONFIG_PP_PTV_NORMALIZE configuration
+ * property can be set to normalize the scene's spatial dimension to the
+ * -1...1 range.
+ */
+ PRE_TRANSFORM_VERTICES(0x100),
+
+
+ /**
+ * Limits the number of bones simultaneously affecting a single vertex to a
+ * maximum value.
+ *
+ * If any vertex is affected by more than the maximum number of bones, the
+ * least important vertex weights are removed and the remaining vertex
+ * weights are renormalized so that the weights still sum up to 1. The
+ * default bone weight limit is 4 (defined as #AI_LMW_MAX_WEIGHTS
+ * in config.h), but you can use the #AI_CONFIG_PP_LBW_MAX_WEIGHTS
+ * setting to supply your own limit to the post processing step.
+ *
+ * If you intend to perform the skinning in hardware, this post processing
+ * step might be of interest to you.
+ */
+ LIMIT_BONE_WEIGHTS(0x200),
+
+
+ /**
+ * Validates the imported scene data structure. This makes sure that all
+ * indices are valid, all animations and bones are linked correctly, all
+ * material references are correct .. etc.
+ *
+ * It is recommended that you capture Assimp's log output if you use this
+ * flag, so you can easily find out what's wrong if a file fails the
+ * validation. The validator is quite strict and will find *all*
+ * inconsistencies in the data structure... It is recommended that plugin
+ * developers use it to debug their loaders. There are two types of
+ * validation failures:
+ *
+ *
+ * The step tries to improve the ACMR (average post-transform vertex cache
+ * miss ratio) for all meshes. The implementation runs in O(n) and is
+ * roughly based on the 'tipsify' algorithm (see this
+ * paper).
+ *
+ * If you intend to render huge models in hardware, this step might be of
+ * interest to you. The #AI_CONFIG_PP_ICL_PTCACHE_SIZEconfig
+ * setting can be used to fine-tune the cache optimization.
+ */
+ IMPROVE_CACHE_LOCALITY(0x800),
+
+
+ /**
+ * Searches for redundant/unreferenced materials and removes them.
+ *
+ * This is especially useful in combination with the
+ * #PretransformVertices and #OptimizeMeshes flags. Both
+ * join small meshes with equal characteristics, but they can't do their
+ * work if two meshes have different materials. Because several material
+ * settings are lost during Assimp's import filters, (and because many
+ * exporters don't check for redundant materials), huge models often have
+ * materials which are are defined several times with exactly the same
+ * settings.
+ *
+ * Several material settings not contributing to the final appearance of a
+ * surface are ignored in all comparisons (e.g. the material name). So, if
+ * you're passing additional information through the content pipeline
+ * (probably using *magic* material names), don't specify this flag.
+ * Alternatively take a look at the #AI_CONFIG_PP_RRM_EXCLUDE_LIST
+ * setting.
+ */
+ REMOVE_REDUNDANT_MATERIALS(0x1000),
+
+
+ /**
+ * This step tries to determine which meshes have normal vectors that are
+ * facing inwards and inverts them.
+ *
+ * The algorithm is simple but effective: the bounding box of all vertices +
+ * their normals is compared against the volume of the bounding box of all
+ * vertices without their normals. This works well for most objects,
+ * problems might occur with planar surfaces. However, the step tries to
+ * filter such cases. The step inverts all in-facing normals. Generally it
+ * is recommended to enable this step, although the result is not always
+ * correct.
+ */
+ FIX_INFACING_NORMALS(0x2000),
+
+
+ /**
+ * This step splits meshes with more than one primitive type in homogeneous
+ * sub-meshes.
+ *
+ * The step is executed after the triangulation step. After the step
+ * returns, just one bit is set in aiMesh::mPrimitiveTypes. This is
+ * especially useful for real-time rendering where point and line primitives
+ * are often ignored or rendered separately. You can use the
+ * #AI_CONFIG_PP_SBP_REMOVE option to specify which primitive types
+ * you need. This can be used to easily exclude lines and points, which are
+ * rarely used, from the import.
+ */
+ SORT_BY_PTYPE(0x8000),
+
+
+ /**
+ * This step searches all meshes for degenerate primitives and converts them
+ * to proper lines or points.
+ *
+ * A face is 'degenerate' if one or more of its points are identical. To
+ * have the degenerate stuff not only detected and collapsed but removed,
+ * try one of the following procedures:
+ *
+ * This is especially useful for normals. If they are invalid, and the step
+ * recognizes this, they will be removed and can later be recomputed, i.e.
+ * by the {@link #GEN_SMOOTH_NORMALS} flag.
+ *
+ * The step will also remove meshes that are infinitely small and reduce
+ * animation tracks consisting of hundreds if redundant keys to a single
+ * key. The AI_CONFIG_PP_FID_ANIM_ACCURACY config property decides
+ * the accuracy of the check for duplicate animation tracks.
+ */
+ FIND_INVALID_DATA(0x20000),
+
+
+ /**
+ * This step converts non-UV mappings (such as spherical or cylindrical
+ * mapping) to proper texture coordinate channels.
+ *
+ * Most applications will support UV mapping only, so you will probably want
+ * to specify this step in every case. Note that Assimp is not always able
+ * to match the original mapping implementation of the 3D app which produced
+ * a model perfectly. It's always better to let the modelling app compute
+ * the UV channels - 3ds max, Maya, Blender, LightWave, and Modo do this for
+ * example.
+ *
+ * Note: If this step is not requested, you'll need to process the
+ * MATKEY_MAPPING material property in order to display all
+ * assets properly.
+ */
+ GEN_UV_COORDS(0x40000),
+
+
+ /**
+ * This step applies per-texture UV transformations and bakes them into
+ * stand-alone vtexture coordinate channels.
+ *
+ * UV transformations are specified per-texture - see the
+ * MATKEY_UVTRANSFORM material key for more information. This
+ * step processes all textures with transformed input UV coordinates and
+ * generates a new (pre-transformed) UV channel which replaces the old
+ * channel. Most applications won't support UV transformations, so you will
+ * probably want to specify this step.
+ *
+ * Note: UV transformations are usually implemented in real-time
+ * apps by transforming texture coordinates at vertex shader stage with a
+ * 3x3 (homogenous) transformation matrix.
+ */
+ TRANSFORM_UV_COORDS(0x80000),
+
+
+ /**
+ * This step searches for duplicate meshes and replaces them with references
+ * to the first mesh.
+ *
+ * This step takes a while, so don't use it if speed is a concern. Its main
+ * purpose is to workaround the fact that many export file formats don't
+ * support instanced meshes, so exporters need to duplicate meshes. This
+ * step removes the duplicates again. Please note that Assimp does not
+ * currently support per-node material assignment to meshes, which means
+ * that identical meshes with different materials are currently *not*
+ * joined, although this is planned for future versions.
+ */
+ FIND_INSTANCES(0x100000),
+
+
+ /**
+ * A postprocessing step to reduce the number of meshes.
+ *
+ * This will, in fact, reduce the number of draw calls.
+ *
+ * This is a very effective optimization and is recommended to be used
+ * together with #OptimizeGraph, if possible. The flag is fully
+ * compatible with both {@link #SPLIT_LARGE_MESHES} and
+ * {@link #SORT_BY_PTYPE}.
+ */
+ OPTIMIZE_MESHES(0x200000),
+
+
+ /**
+ * A postprocessing step to optimize the scene hierarchy.
+ *
+ * Nodes without animations, bones, lights or cameras assigned are collapsed
+ * and joined.
+ *
+ * Node names can be lost during this step. If you use special 'tag nodes'
+ * to pass additional information through your content pipeline, use the
+ * #AI_CONFIG_PP_OG_EXCLUDE_LIST setting to specify a list of node
+ * names you want to be kept. Nodes matching one of the names in this list
+ * won't be touched or modified.
+ *
+ * Use this flag with caution. Most simple files will be collapsed to a
+ * single node, so complex hierarchies are usually completely lost. This is
+ * not useful for editor environments, but probably a very effective
+ * optimization if you just want to get the model data, convert it to your
+ * own format, and render it as fast as possible.
+ *
+ * This flag is designed to be used with #OptimizeMeshes for best
+ * results.
+ *
+ * Note: 'Crappy' scenes with thousands of extremely small meshes
+ * packed in deeply nested nodes exist for almost all file formats.
+ * {@link #OPTIMIZE_MESHES} in combination with {@link #OPTIMIZE_GRAPH}
+ * usually fixes them all and makes them renderable.
+ */
+ OPTIMIZE_GRAPH(0x400000),
+
+
+ /**
+ * This step flips all UV coordinates along the y-axis and adjusts material
+ * settings and bitangents accordingly.
+ *
+ * Output UV coordinate system:
+ *
+ * You'll probably want to consider this flag if you use Direct3D for
+ * rendering. The {@link #MAKE_LEFT_HANDED} flag supersedes this setting
+ * and bundles all conversions typically required for D3D-based
+ * applications.
+ */
+ FLIP_UVS(0x800000),
+
+
+ /**
+ * This step adjusts the output face winding order to be CW.
+ *
+ * The default face winding order is counter clockwise (CCW).
+ *
+ * Output face order:
+ *
+ *
+ */
+ SPLIT_BY_BONE_COUNT(0x2000000),
+
+
+ /**
+ * This step removes bones losslessly or according to some threshold.
+ *
+ * In some cases (i.e. formats that require it) exporters are forced to
+ * assign dummy bone weights to otherwise static meshes assigned to animated
+ * meshes. Full, weight-based skinning is expensive while animating nodes is
+ * extremely cheap, so this step is offered to clean up the data in that
+ * regard.
+ *
+ * Use #AI_CONFIG_PP_DB_THRESHOLD to control this. Use
+ * #AI_CONFIG_PP_DB_ALL_OR_NONE if you want bones removed if and
+ * only if all bones within the scene qualify for removal.
+ */
+ DEBONE(0x4000000);
+
+
+ /**
+ * Utility method for converting to c/c++ based integer enums from java
+ * enums.
+ *
+ * This method is intended to be used from JNI and my change based on
+ * implementation needs.
+ *
+ * @param set the set to convert
+ * @return an integer based enum value (as defined by assimp)
+ */
+ static long toRawValue(Set
+ */
+public enum AiPrimitiveType {
+ /**
+ * A point primitive.
+ */
+ POINT(0x1),
+
+
+ /**
+ * A line primitive.
+ */
+ LINE(0x2),
+
+
+ /**
+ * A triangular primitive.
+ */
+ TRIANGLE(0x4),
+
+
+ /**
+ * A higher-level polygon with more than 3 edges.
+ *
+ * A triangle is a polygon, but polygon in this context means
+ * "all polygons that are not triangles". The "Triangulate"-Step is provided
+ * for your convenience, it splits all polygons in triangles (which are much
+ * easier to handle).
+ */
+ POLYGON(0x8);
+
+
+ /**
+ * Utility method for converting from c/c++ based integer enums to java
+ * enums.
+ *
+ * This method is intended to be used from JNI and my change based on
+ * implementation needs.
+ *
+ * @param set the target set to fill
+ * @param rawValue an integer based enum value (as defined by assimp)
+ */
+ static void fromRawValue(Set
+ *
+ * The wrapper is writable, i.e., changes performed via the set-methods will
+ * modify the underlying mesh/animation.
+ */
+public final class AiQuaternion {
+ /**
+ * Constructor.
+ *
+ * @param buffer the buffer to wrap
+ * @param offset offset into buffer
+ */
+ public AiQuaternion(ByteBuffer buffer, int offset) {
+ if (null == buffer) {
+ throw new IllegalArgumentException("buffer may not be null");
+ }
+
+ m_buffer = buffer;
+ m_offset = offset;
+ }
+
+
+ /**
+ * Returns the x value.
+ *
+ * @return the x value
+ */
+ public float getX() {
+ return m_buffer.getFloat(m_offset + 4);
+ }
+
+
+ /**
+ * Returns the y value.
+ *
+ * @return the y value
+ */
+ public float getY() {
+ return m_buffer.getFloat(m_offset + 8);
+ }
+
+
+ /**
+ * Returns the z value.
+ *
+ * @return the z value
+ */
+ public float getZ() {
+ return m_buffer.getFloat(m_offset + 12);
+ }
+
+
+ /**
+ * Returns the w value.
+ *
+ * @return the w value
+ */
+ public float getW() {
+ return m_buffer.getFloat(m_offset);
+ }
+
+
+ /**
+ * Sets the x component.
+ *
+ * @param x the new value
+ */
+ public void setX(float x) {
+ m_buffer.putFloat(m_offset + 4, x);
+ }
+
+
+ /**
+ * Sets the y component.
+ *
+ * @param y the new value
+ */
+ public void setY(float y) {
+ m_buffer.putFloat(m_offset + 8, y);
+ }
+
+
+ /**
+ * Sets the z component.
+ *
+ * @param z the new value
+ */
+ public void setZ(float z) {
+ m_buffer.putFloat(m_offset + 12, z);
+ }
+
+
+ /**
+ * Sets the z component.
+ *
+ * @param w the new value
+ */
+ public void setW(float w) {
+ m_buffer.putFloat(m_offset, w);
+ }
+
+
+ @Override
+ public String toString() {
+ return "[" + getX() + ", " + getY() + ", " + getZ() + ", " +
+ getW() + "]";
+ }
+
+
+ /**
+ * Wrapped buffer.
+ */
+ private final ByteBuffer m_buffer;
+
+
+ /**
+ * Offset into m_buffer.
+ */
+ private final int m_offset;
+}
\ No newline at end of file
diff --git a/port/jassimp/jassimp/src/jassimp/AiScene.java b/port/jassimp/jassimp/src/jassimp/AiScene.java
new file mode 100644
index 000000000..f13348dec
--- /dev/null
+++ b/port/jassimp/jassimp/src/jassimp/AiScene.java
@@ -0,0 +1,251 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library - Java Binding (jassimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2012, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+ copyright notice, this list of conditions and the
+ following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the
+ following disclaimer in the documentation and/or other
+ materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+ contributors may be used to endorse or promote products
+ derived from this software without specific prior
+ written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+package jassimp;
+
+import java.util.ArrayList;
+import java.util.List;
+
+
+/**
+ * The root structure of the imported data.
+ *
+ * Everything that was imported from the given file can be accessed from here.
+ *
+ * Jassimp copies all data into "java memory" during import and frees
+ * resources allocated by native code after scene loading is completed. No
+ * special care has to be taken for freeing resources, unreferenced jassimp
+ * objects (including the scene itself) are eligible to garbage collection like
+ * any other java object.
+ */
+public final class AiScene {
+ /**
+ * Constructor.
+ */
+ AiScene() {
+ /* nothing to do */
+ }
+
+
+ /**
+ * Returns the number of meshes contained in the scene.
+ *
+ * This method is provided for completeness reasons. It will return the
+ * same value as
+ *
+ * If there are no meshes in the scene, an empty collection is returned
+ *
+ * @return the list of meshes
+ */
+ public List
+ *
+ * This method is provided for completeness reasons. It will return the
+ * same value as
+ *
+ * Use the index given in each aiMesh structure to access this
+ * array. If the {@link AiSceneFlag#INCOMPLETE} flag is not set there will
+ * always be at least ONE material.
+ *
+ * @return the list of materials
+ */
+ public List
+ *
+ * This method is provided for completeness reasons. It will return the
+ * same value as
+ *
+ * This method is provided for completeness reasons. It will return the
+ * same value as
+ *
+ * Light sources are fully optional, the returned list may be empty
+ *
+ * @return a possibly empty list of lights
+ */
+ public List
+ *
+ * This method is provided for completeness reasons. It will return the
+ * same value as
+ *
+ * Cameras are fully optional, the returned list may be empty
+ *
+ * @return a possibly empty list of cameras
+ */
+ public List
+ *
+ * The built-in behavior is to return a {@link AiVector}.
+ *
+ * @param wrapperProvider the wrapper provider (used for type inference)
+ * @return the scene graph root
+ */
+ @SuppressWarnings("unchecked")
+ public
+ *
+ * This flag bypasses some internal validations and allows the import
+ * of animation skeletons, material libraries or camera animation paths
+ * using Assimp. Most applications won't support such data.
+ */
+ INCOMPLETE(0x1),
+
+
+ /**
+ * This flag is set by the validation
+ * ({@link AiPostProcessSteps#VALIDATE_DATA_STRUCTURE
+ * VALIDATE_DATA_STRUCTURE})
+ * postprocess-step if the validation is successful.
+ *
+ * In a validated scene you can be sure that any cross references in the
+ * data structure (e.g. vertex indices) are valid.
+ */
+ VALIDATED(0x2),
+
+
+ /**
+ * * This flag is set by the validation
+ * ({@link AiPostProcessSteps#VALIDATE_DATA_STRUCTURE
+ * VALIDATE_DATA_STRUCTURE})
+ * postprocess-step if the validation is successful but some issues have
+ * been found.
+ *
+ * This can for example mean that a texture that does not exist is
+ * referenced by a material or that the bone weights for a vertex don't sum
+ * to 1.0 ... . In most cases you should still be able to use the import.
+ * This flag could be useful for applications which don't capture Assimp's
+ * log output.
+ */
+ VALIDATION_WARNING(0x4),
+
+
+ /**
+ * This flag is currently only set by the
+ * {@link jassimp.AiPostProcessSteps#JOIN_IDENTICAL_VERTICES
+ * JOIN_IDENTICAL_VERTICES}.
+ *
+ * It indicates that the vertices of the output meshes aren't in the
+ * internal verbose format anymore. In the verbose format all vertices are
+ * unique, no vertex is ever referenced by more than one face.
+ */
+ NON_VERBOSE_FORMAT(0x8),
+
+
+ /**
+ * Denotes pure height-map terrain data.
+ *
+ * Pure terrains usually consist of quads, sometimes triangles, in a
+ * regular grid. The x,y coordinates of all vertex positions refer to the
+ * x,y coordinates on the terrain height map, the z-axis stores the
+ * elevation at a specific point.
+ *
+ * TER (Terragen) and HMP (3D Game Studio) are height map formats.
+ *
+ * Assimp is probably not the best choice for loading *huge* terrains -
+ * fully triangulated data takes extremely much free store and should be
+ * avoided as long as possible (typically you'll do the triangulation when
+ * you actually need to render it).
+ */
+ TERRAIN(0x10);
+
+
+ /**
+ * Utility method for converting from c/c++ based integer enums to java
+ * enums.
+ *
+ * This method is intended to be used from JNI and my change based on
+ * implementation needs.
+ *
+ * @param set the target set to fill
+ * @param rawValue an integer based enum value (as defined by assimp)
+ */
+ static void fromRawValue(Set
+ *
+ * The list of shading modes has been taken from Blender.
+ * See Blender documentation for more information. The API does
+ * not distinguish between "specular" and "diffuse" shaders (thus the
+ * specular term for diffuse shading models like Oren-Nayar remains
+ * undefined).
+ * Again, this value is just a hint. Assimp tries to select the shader whose
+ * most common implementation matches the original rendering results of the
+ * 3D modeller which wrote a particular model as closely as possible.
+ */
+public enum AiShadingMode {
+ /**
+ * Flat shading.
+ *
+ * Shading is done on per-face base, diffuse only. Also known as
+ * 'faceted shading'.
+ */
+ FLAT(0x1),
+
+
+ /**
+ * Simple Gouraud shading.
+ */
+ GOURAUD(0x2),
+
+
+ /**
+ * Phong-Shading.
+ */
+ PHONG(0x3),
+
+
+ /**
+ * Phong-Blinn-Shading.
+ */
+ BLINN(0x4),
+
+
+ /**
+ * Toon-Shading per pixel.
+ *
+ * Also known as 'comic' shader.
+ */
+ TOON(0x5),
+
+
+ /**
+ * OrenNayar-Shading per pixel.
+ *
+ * Extension to standard Lambertian shading, taking the roughness of the
+ * material into account
+ */
+ OREN_NAYAR(0x6),
+
+
+ /**
+ * Minnaert-Shading per pixel.
+ *
+ * Extension to standard Lambertian shading, taking the "darkness" of the
+ * material into account
+ */
+ MINNAERT(0x7),
+
+
+ /**
+ * CookTorrance-Shading per pixel.
+ *
+ * Special shader for metallic surfaces.
+ */
+ COOK_TORRANCE(0x8),
+
+
+ /**
+ * No shading at all.
+ *
+ * Constant light influence of 1.0.
+ */
+ NO_SHADING(0x9),
+
+
+ /**
+ * Fresnel shading.
+ */
+ FRESNEL(0xa);
+
+
+ /**
+ * Utility method for converting from c/c++ based integer enums to java
+ * enums.
+ *
+ * This method is intended to be used from JNI and my change based on
+ * implementation needs.
+ *
+ * @param rawValue an integer based enum value (as defined by assimp)
+ * @return the enum value corresponding to rawValue
+ */
+ static AiShadingMode fromRawValue(int rawValue) {
+ for (AiShadingMode type : AiShadingMode.values()) {
+ if (type.m_rawValue == rawValue) {
+ return type;
+ }
+ }
+
+ throw new IllegalArgumentException("unexptected raw value: " +
+ rawValue);
+ }
+
+
+ /**
+ * Constructor.
+ *
+ * @param rawValue maps java enum to c/c++ integer enum values
+ */
+ private AiShadingMode(int rawValue) {
+ m_rawValue = rawValue;
+ }
+
+
+ /**
+ * The mapped c/c++ integer enum value.
+ */
+ private final int m_rawValue;
+}
diff --git a/port/jassimp/jassimp/src/jassimp/AiTextureInfo.java b/port/jassimp/jassimp/src/jassimp/AiTextureInfo.java
new file mode 100644
index 000000000..bfa09397b
--- /dev/null
+++ b/port/jassimp/jassimp/src/jassimp/AiTextureInfo.java
@@ -0,0 +1,224 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library - Java Binding (jassimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2012, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+ copyright notice, this list of conditions and the
+ following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the
+ following disclaimer in the documentation and/or other
+ materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+ contributors may be used to endorse or promote products
+ derived from this software without specific prior
+ written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+package jassimp;
+
+
+/**
+ * Data structure for texture related material properties.
+ */
+public final class AiTextureInfo {
+
+ /**
+ * Constructor.
+ *
+ * @param type type
+ * @param index index
+ * @param file file
+ * @param uvIndex uv index
+ * @param blend blend factor
+ * @param texOp texture operation
+ * @param mmU map mode for u axis
+ * @param mmV map mode for v axis
+ * @param mmW map mode for w axis
+ */
+ AiTextureInfo(AiTextureType type, int index, String file,
+ int uvIndex, float blend, AiTextureOp texOp, AiTextureMapMode mmU,
+ AiTextureMapMode mmV, AiTextureMapMode mmW) {
+
+ m_type = type;
+ m_index = index;
+ m_file = file;
+ m_uvIndex = uvIndex;
+ m_blend = blend;
+ m_textureOp = texOp;
+ m_textureMapModeU = mmU;
+ m_textureMapModeV = mmV;
+ m_textureMapModeW = mmW;
+ }
+
+
+ /**
+ * Specifies the type of the texture (e.g. diffuse, specular, ...).
+ *
+ * @return the type.
+ */
+ public AiTextureType getType() {
+ return m_type;
+ }
+
+
+ /**
+ * Index of the texture in the texture stack.
+ *
+ * Each type maintains a stack of textures, i.e., there may be a diffuse.0,
+ * a diffuse.1, etc
+ *
+ * @return the index
+ */
+ public int getIndex() {
+ return m_index;
+ }
+
+
+ /**
+ * Returns the path to the texture file.
+ *
+ * @return the path
+ */
+ public String getFile() {
+ return m_file;
+ }
+
+
+ /**
+ * Returns the index of the UV coordinate set.
+ *
+ * @return the uv index
+ */
+ public int getUVIndex() {
+ return m_uvIndex;
+ }
+
+
+ /**
+ * Returns the blend factor.
+ *
+ * @return the blend factor
+ */
+ public float getBlend() {
+ return m_blend;
+ }
+
+
+ /**
+ * Returns the texture operation used to combine this texture and the
+ * preceding texture in the stack.
+ *
+ * @return the texture operation
+ */
+ public AiTextureOp getTextureOp() {
+ return m_textureOp;
+ }
+
+
+ /**
+ * Returns the texture map mode for U texture axis.
+ *
+ * @return the texture map mode
+ */
+ public AiTextureMapMode getTextureMapModeU() {
+ return m_textureMapModeU;
+ }
+
+
+ /**
+ * Returns the texture map mode for V texture axis.
+ *
+ * @return the texture map mode
+ */
+ public AiTextureMapMode getTextureMapModeV() {
+ return m_textureMapModeV;
+ }
+
+
+ /**
+ * Returns the texture map mode for W texture axis.
+ *
+ * @return the texture map mode
+ */
+ public AiTextureMapMode getTextureMapModeW() {
+ return m_textureMapModeW;
+ }
+
+
+ /**
+ * Type.
+ */
+ private final AiTextureType m_type;
+
+
+ /**
+ * Index.
+ */
+ private final int m_index;
+
+
+ /**
+ * Path.
+ */
+ private final String m_file;
+
+
+ /**
+ * UV index.
+ */
+ private final int m_uvIndex;
+
+
+ /**
+ * Blend factor.
+ */
+ private final float m_blend;
+
+
+ /**
+ * Texture operation.
+ */
+ private final AiTextureOp m_textureOp;
+
+
+ /**
+ * Map mode U axis.
+ */
+ private final AiTextureMapMode m_textureMapModeU;
+
+
+ /**
+ * Map mode V axis.
+ */
+ private final AiTextureMapMode m_textureMapModeV;
+
+
+ /**
+ * Map mode W axis.
+ */
+ private final AiTextureMapMode m_textureMapModeW;
+}
diff --git a/port/jassimp/jassimp/src/jassimp/AiTextureMapMode.java b/port/jassimp/jassimp/src/jassimp/AiTextureMapMode.java
new file mode 100644
index 000000000..f9e86dfc6
--- /dev/null
+++ b/port/jassimp/jassimp/src/jassimp/AiTextureMapMode.java
@@ -0,0 +1,113 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library - Java Binding (jassimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2012, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+ copyright notice, this list of conditions and the
+ following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the
+ following disclaimer in the documentation and/or other
+ materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+ contributors may be used to endorse or promote products
+ derived from this software without specific prior
+ written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+package jassimp;
+
+
+/**
+ * Defines how UV coordinates outside the [0...1] range are handled.
+ *
+ * Commonly refered to as 'wrapping mode'.
+ */
+public enum AiTextureMapMode {
+ /**
+ * A texture coordinate u|v is translated to u%1|v%1.
+ */
+ WRAP(0x0),
+
+
+ /**
+ * Texture coordinates outside [0...1] are clamped to the nearest
+ * valid value.
+ */
+ CLAMP(0x1),
+
+
+ /**
+ * A texture coordinate u|v becomes u%1|v%1 if (u-(u%1))%2 is zero and
+ * 1-(u%1)|1-(v%1) otherwise.
+ */
+ MIRROR(0x2),
+
+
+ /**
+ * If the texture coordinates for a pixel are outside [0...1] the texture
+ * is not applied to that pixel.
+ */
+ DECAL(0x3);
+
+
+ /**
+ * Utility method for converting from c/c++ based integer enums to java
+ * enums.
+ *
+ * This method is intended to be used from JNI and my change based on
+ * implementation needs.
+ *
+ * @param rawValue an integer based enum value (as defined by assimp)
+ * @return the enum value corresponding to rawValue
+ */
+ static AiTextureMapMode fromRawValue(int rawValue) {
+ for (AiTextureMapMode type : AiTextureMapMode.values()) {
+ if (type.m_rawValue == rawValue) {
+ return type;
+ }
+ }
+
+ throw new IllegalArgumentException("unexptected raw value: " +
+ rawValue);
+ }
+
+
+ /**
+ * Constructor.
+ *
+ * @param rawValue maps java enum to c/c++ integer enum values
+ */
+ private AiTextureMapMode(int rawValue) {
+ m_rawValue = rawValue;
+ }
+
+
+ /**
+ * The mapped c/c++ integer enum value.
+ */
+ private final int m_rawValue;
+}
diff --git a/port/jassimp/jassimp/src/jassimp/AiTextureMapping.java b/port/jassimp/jassimp/src/jassimp/AiTextureMapping.java
new file mode 100644
index 000000000..3112ba4bd
--- /dev/null
+++ b/port/jassimp/jassimp/src/jassimp/AiTextureMapping.java
@@ -0,0 +1,78 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library - Java Binding (jassimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2012, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+ copyright notice, this list of conditions and the
+ following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the
+ following disclaimer in the documentation and/or other
+ materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+ contributors may be used to endorse or promote products
+ derived from this software without specific prior
+ written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+package jassimp;
+
+
+/**
+ * Defines how the mapping coords for a texture are generated.
+ *
+ * Real-time applications typically require full UV coordinates, so the use of
+ * the {@link AiPostProcessSteps#GEN_UV_COORDS} step is highly recommended.
+ * It generates proper UV channels for non-UV mapped objects, as long as an
+ * accurate description how the mapping should look like (e.g spherical) is
+ * given.
+ */
+public enum AiTextureMapping {
+ /**
+ * The mapping coordinates are taken from an UV channel.
+ *
+ * The #AI_MATKEY_UVWSRC key specifies from which UV channel
+ * the texture coordinates are to be taken from (remember,
+ * meshes can have more than one UV channel).
+ */
+// aiTextureMapping_UV = 0x0,
+//
+// /** Spherical mapping */
+// aiTextureMapping_SPHERE = 0x1,
+//
+// /** Cylindrical mapping */
+// aiTextureMapping_CYLINDER = 0x2,
+//
+// /** Cubic mapping */
+// aiTextureMapping_BOX = 0x3,
+//
+// /** Planar mapping */
+// aiTextureMapping_PLANE = 0x4,
+//
+// /** Undefined mapping. Have fun. */
+// aiTextureMapping_OTHER = 0x5,
+
+}
diff --git a/port/jassimp/jassimp/src/jassimp/AiTextureOp.java b/port/jassimp/jassimp/src/jassimp/AiTextureOp.java
new file mode 100644
index 000000000..d928167ca
--- /dev/null
+++ b/port/jassimp/jassimp/src/jassimp/AiTextureOp.java
@@ -0,0 +1,137 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library - Java Binding (jassimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2012, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+ copyright notice, this list of conditions and the
+ following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the
+ following disclaimer in the documentation and/or other
+ materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+ contributors may be used to endorse or promote products
+ derived from this software without specific prior
+ written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+package jassimp;
+
+
+/**
+ * Defines how the Nth texture of a specific type is combined with the result
+ * of all previous layers.
+ *
+ * Example (left: key, right: value):
+ *
+ * This method is intended to be used from JNI and my change based on
+ * implementation needs.
+ *
+ * @param rawValue an integer based enum value (as defined by assimp)
+ * @return the enum value corresponding to rawValue
+ */
+ static AiTextureOp fromRawValue(int rawValue) {
+ for (AiTextureOp type : AiTextureOp.values()) {
+ if (type.m_rawValue == rawValue) {
+ return type;
+ }
+ }
+
+ throw new IllegalArgumentException("unexptected raw value: " +
+ rawValue);
+ }
+
+
+ /**
+ * Constructor.
+ *
+ * @param rawValue maps java enum to c/c++ integer enum values
+ */
+ private AiTextureOp(int rawValue) {
+ m_rawValue = rawValue;
+ }
+
+
+ /**
+ * The mapped c/c++ integer enum value.
+ */
+ private final int m_rawValue;
+}
diff --git a/port/jassimp/jassimp/src/jassimp/AiTextureType.java b/port/jassimp/jassimp/src/jassimp/AiTextureType.java
new file mode 100644
index 000000000..8756c18ee
--- /dev/null
+++ b/port/jassimp/jassimp/src/jassimp/AiTextureType.java
@@ -0,0 +1,212 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library - Java Binding (jassimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2012, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+ copyright notice, this list of conditions and the
+ following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the
+ following disclaimer in the documentation and/or other
+ materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+ contributors may be used to endorse or promote products
+ derived from this software without specific prior
+ written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+package jassimp;
+
+/**
+ * Defines the purpose of a texture.
+ *
+ * This is a very difficult topic. Different 3D packages support different
+ * kinds of textures. For very common texture types, such as bumpmaps, the
+ * rendering results depend on implementation details in the rendering
+ * pipelines of these applications. Assimp loads all texture references from
+ * the model file and tries to determine which of the predefined texture
+ * types below is the best choice to match the original use of the texture
+ * as closely as possible.
+ *
+ * In content pipelines you'll usually define how textures have to be handled,
+ * and the artists working on models have to conform to this specification,
+ * regardless which 3D tool they're using.
+ */
+public enum AiTextureType {
+ /**
+ * The texture is combined with the result of the diffuse
+ * lighting equation.
+ */
+ DIFFUSE(0x1),
+
+
+ /**
+ * The texture is combined with the result of the specular
+ * lighting equation.
+ */
+ SPECULAR(0x2),
+
+
+ /**
+ * The texture is combined with the result of the ambient
+ * lighting equation.
+ */
+ AMBIENT(0x3),
+
+
+ /**
+ * The texture is added to the result of the lighting
+ * calculation. It isn't influenced by incoming light.
+ */
+ EMISSIVE(0x4),
+
+
+ /**
+ * The texture is a height map.
+ *
+ * By convention, higher gray-scale values stand for
+ * higher elevations from the base height.
+ */
+ HEIGHT(0x5),
+
+
+ /**
+ * The texture is a (tangent space) normal-map.
+ *
+ * Again, there are several conventions for tangent-space
+ * normal maps. Assimp does (intentionally) not distinguish here.
+ */
+ NORMALS(0x6),
+
+
+ /**
+ * The texture defines the glossiness of the material.
+ *
+ * The glossiness is in fact the exponent of the specular
+ * (phong) lighting equation. Usually there is a conversion
+ * function defined to map the linear color values in the
+ * texture to a suitable exponent. Have fun.
+ */
+ SHININESS(0x7),
+
+
+ /**
+ * The texture defines per-pixel opacity.
+ *
+ * Usually 'white' means opaque and 'black' means
+ * 'transparency'. Or quite the opposite. Have fun.
+ */
+ OPACITY(0x8),
+
+
+ /**
+ * Displacement texture.
+ *
+ * The exact purpose and format is application-dependent.
+ * Higher color values stand for higher vertex displacements.
+ */
+ DISPLACEMENT(0x9),
+
+
+ /**
+ * Lightmap texture (aka Ambient Occlusion).
+ *
+ * Both 'Lightmaps' and dedicated 'ambient occlusion maps' are
+ * covered by this material property. The texture contains a
+ * scaling value for the final color value of a pixel. Its
+ * intensity is not affected by incoming light.
+ */
+ LIGHTMAP(0xA),
+
+
+ /**
+ * Reflection texture.
+ *
+ * Contains the color of a perfect mirror reflection.
+ * Rarely used, almost never for real-time applications.
+ */
+ REFLECTION(0xB),
+
+
+ /**
+ * Unknown texture.
+ *
+ * A texture reference that does not match any of the definitions
+ * above is considered to be 'unknown'. It is still imported,
+ * but is excluded from any further postprocessing.
+ */
+ UNKNOWN(0xC);
+
+
+ /**
+ * Utility method for converting from c/c++ based integer enums to java
+ * enums.
+ *
+ * This method is intended to be used from JNI and my change based on
+ * implementation needs.
+ *
+ * @param rawValue an integer based enum value (as defined by assimp)
+ * @return the enum value corresponding to rawValue
+ */
+ static AiTextureType fromRawValue(int rawValue) {
+ for (AiTextureType type : AiTextureType.values()) {
+ if (type.m_rawValue == rawValue) {
+ return type;
+ }
+ }
+
+ throw new IllegalArgumentException("unexptected raw value: " +
+ rawValue);
+ }
+
+
+ /**
+ * Utility method for converting from java enums to c/c++ based integer
+ * enums.
+ *
+ * @param type the type to convert, may not be null
+ * @return the rawValue corresponding to type
+ */
+ static int toRawValue(AiTextureType type) {
+ return type.m_rawValue;
+ }
+
+
+ /**
+ * Constructor.
+ *
+ * @param rawValue maps java enum to c/c++ integer enum values
+ */
+ private AiTextureType(int rawValue) {
+ m_rawValue = rawValue;
+ }
+
+
+ /**
+ * The mapped c/c++ integer enum value.
+ */
+ private final int m_rawValue;
+}
\ No newline at end of file
diff --git a/port/jassimp/jassimp/src/jassimp/AiVector.java b/port/jassimp/jassimp/src/jassimp/AiVector.java
new file mode 100644
index 000000000..3136f3888
--- /dev/null
+++ b/port/jassimp/jassimp/src/jassimp/AiVector.java
@@ -0,0 +1,195 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library - Java Binding (jassimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2012, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+ copyright notice, this list of conditions and the
+ following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the
+ following disclaimer in the documentation and/or other
+ materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+ contributors may be used to endorse or promote products
+ derived from this software without specific prior
+ written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+package jassimp;
+
+import java.nio.ByteBuffer;
+
+
+/**
+ * Wrapper for 3-dimensional vectors.
+ *
+ * This wrapper is also used to represent 1- and 2-dimensional vectors. In
+ * these cases only the x (or the x and y coordinate) will be used.
+ * Accessing unused components will throw UnsupportedOperationExceptions.
+ *
+ * The wrapper is writable, i.e., changes performed via the set-methods will
+ * modify the underlying mesh.
+ */
+public final class AiVector {
+ /**
+ * Constructor.
+ *
+ * @param buffer the buffer to wrap
+ * @param offset offset into buffer
+ * @param numComponents number vector of components
+ */
+ public AiVector(ByteBuffer buffer, int offset, int numComponents) {
+ if (null == buffer) {
+ throw new IllegalArgumentException("buffer may not be null");
+ }
+
+ m_buffer = buffer;
+ m_offset = offset;
+ m_numComponents = numComponents;
+ }
+
+
+ /**
+ * Returns the x value.
+ *
+ * @return the x value
+ */
+ public float getX() {
+ return m_buffer.getFloat(m_offset);
+ }
+
+
+ /**
+ * Returns the y value.
+ *
+ * May only be called on 2- or 3-dimensional vectors.
+ *
+ * @return the y value
+ */
+ public float getY() {
+ if (m_numComponents <= 1) {
+ throw new UnsupportedOperationException(
+ "vector has only 1 component");
+ }
+
+ return m_buffer.getFloat(m_offset + 4);
+ }
+
+
+ /**
+ * Returns the z value.
+ *
+ * May only be called on 3-dimensional vectors.
+ *
+ * @return the z value
+ */
+ public float getZ() {
+ if (m_numComponents <= 2) {
+ throw new UnsupportedOperationException(
+ "vector has only 2 components");
+ }
+
+ return m_buffer.getFloat(m_offset + 8);
+ }
+
+
+ /**
+ * Sets the x component.
+ *
+ * @param x the new value
+ */
+ public void setX(float x) {
+ m_buffer.putFloat(m_offset, x);
+ }
+
+
+ /**
+ * Sets the y component.
+ *
+ * May only be called on 2- or 3-dimensional vectors.
+ *
+ * @param y the new value
+ */
+ public void setY(float y) {
+ if (m_numComponents <= 1) {
+ throw new UnsupportedOperationException(
+ "vector has only 1 component");
+ }
+
+ m_buffer.putFloat(m_offset + 4, y);
+ }
+
+
+ /**
+ * Sets the z component.
+ *
+ * May only be called on 3-dimensional vectors.
+ *
+ * @param z the new value
+ */
+ public void setZ(float z) {
+ if (m_numComponents <= 2) {
+ throw new UnsupportedOperationException(
+ "vector has only 2 components");
+ }
+
+ m_buffer.putFloat(m_offset + 8, z);
+ }
+
+
+ /**
+ * Returns the number of components in this vector.
+ *
+ * @return the number of components
+ */
+ public int getNumComponents() {
+ return m_numComponents;
+ }
+
+
+ @Override
+ public String toString() {
+ return "[" + getX() + ", " + getY() + ", " + getZ() + "]";
+ }
+
+
+ /**
+ * Wrapped buffer.
+ */
+ private final ByteBuffer m_buffer;
+
+
+ /**
+ * Offset into m_buffer.
+ */
+ private final int m_offset;
+
+
+ /**
+ * Number of components.
+ */
+ private final int m_numComponents;
+}
diff --git a/port/jassimp/jassimp/src/jassimp/AiWrapperProvider.java b/port/jassimp/jassimp/src/jassimp/AiWrapperProvider.java
new file mode 100644
index 000000000..e916ad260
--- /dev/null
+++ b/port/jassimp/jassimp/src/jassimp/AiWrapperProvider.java
@@ -0,0 +1,149 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library - Java Binding (jassimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2012, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+ copyright notice, this list of conditions and the
+ following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the
+ following disclaimer in the documentation and/or other
+ materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+ contributors may be used to endorse or promote products
+ derived from this software without specific prior
+ written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+package jassimp;
+
+import java.nio.ByteBuffer;
+
+
+/**
+ * Provides wrapper objects for raw data buffers.
+ *
+ * It is likely that applications using Jassimp will already have a scene
+ * graph implementation and/ or the typical math related classes such as
+ * vectors, matrices, etc.
+ *
+ * To ease the integration with existing code, Jassimp can be customized to
+ * represent the scene graph and compound data structures such as vectors and
+ * matrices with user supplied classes.
+ *
+ * All methods returning wrapped objects rely on the AiWrapperProvider to
+ * create individual instances. Custom wrappers can be created by implementing
+ * AiWrapperProvider and registering the implementation via
+ * {@link Jassimp#setWrapperProvider(AiWrapperProvider)} before the
+ * scene is imported.
+ *
+ * The methods returning wrapped types take an AiWrapperProvider instance. This
+ * instance must match the instance set via
+ * {@link Jassimp#setWrapperProvider(AiWrapperProvider)}. The method parameter
+ * is used to infer the type of the returned object. The passed in wrapper
+ * provider is not necessarily used to actually create the wrapped object, as
+ * the object may be cached for performance reasons. It is not possible to
+ * use different AiWrapperProviders throughout the lifetime of an imported
+ * scene.
+ *
+ * @param
+ *
+ * Most vectors are 3-dimensional, i.e., with 3 components. The exception
+ * are texture coordinates, which may be 1- or 2-dimensional. A vector
+ * consists of numComponents floats (x,y,z) starting from offset
+ *
+ * @param buffer the buffer to wrap
+ * @param offset the offset into buffer
+ * @param numComponents the number of components
+ * @return the wrapped vector
+ */
+ V3 wrapVector3f(ByteBuffer buffer, int offset, int numComponents);
+
+
+ /**
+ * Wraps a 4x4 matrix of floats.
+ *
+ * The calling code will allocate a new array for each invocation of this
+ * method. It is safe to store a reference to the passed in array and
+ * use the array to store the matrix data.
+ *
+ * @param data the matrix data in row-major order
+ * @return the wrapped matrix
+ */
+ M4 wrapMatrix4f(float[] data);
+
+
+ /**
+ * Wraps a RGBA color.
+ *
+ * A color consists of 4 float values (r,g,b,a) starting from offset
+ *
+ * @param buffer the buffer to wrap
+ * @param offset the offset into buffer
+ * @return the wrapped color
+ */
+ C wrapColor(ByteBuffer buffer, int offset);
+
+
+ /**
+ * Wraps a scene graph node.
+ *
+ * See {@link AiNode} for a description of the scene graph structure used
+ * by assimp.
+ *
+ * The parent node is either null or an instance returned by this method.
+ * It is therefore safe to cast the passed in parent object to the
+ * implementation specific type
+ *
+ * @param parent the parent node
+ * @param matrix the transformation matrix
+ * @param meshReferences array of mesh references (indexes)
+ * @param name the name of the node
+ * @return the wrapped scene graph node
+ */
+ N wrapSceneNode(Object parent, Object matrix, int[] meshReferences,
+ String name);
+
+
+ /**
+ * Wraps a quaternion.
+ *
+ * A quaternion consists of 4 float values (w,x,y,z) starting from offset
+ *
+ * @param buffer the buffer to wrap
+ * @param offset the offset into buffer
+ * @return the wrapped quaternion
+ */
+ Q wrapQuaternion(ByteBuffer buffer, int offset);
+}
diff --git a/port/jassimp/jassimp/src/jassimp/JaiDebug.java b/port/jassimp/jassimp/src/jassimp/JaiDebug.java
new file mode 100644
index 000000000..0f91ce662
--- /dev/null
+++ b/port/jassimp/jassimp/src/jassimp/JaiDebug.java
@@ -0,0 +1,209 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library - Java Binding (jassimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2012, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+ copyright notice, this list of conditions and the
+ following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the
+ following disclaimer in the documentation and/or other
+ materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+ contributors may be used to endorse or promote products
+ derived from this software without specific prior
+ written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+package jassimp;
+
+import java.nio.ByteBuffer;
+
+
+/**
+ * Debug/utility methods.
+ */
+public final class JaiDebug {
+
+ /**
+ * Pure static class, no accessible constructor.
+ */
+ private JaiDebug() {
+ /* nothing to do */
+ }
+
+
+ /**
+ * Dumps vertex positions of a mesh to stdout.
+ *
+ * @param mesh the mesh
+ */
+ public static void dumpPositions(AiMesh mesh) {
+ if (!mesh.hasPositions()) {
+ System.out.println("mesh has no vertex positions");
+ return;
+ }
+
+ for (int i = 0; i < mesh.getNumVertives(); i++) {
+ System.out.println("[" +
+ mesh.getPositionX(i) + ", " +
+ mesh.getPositionY(i) + ", " +
+ mesh.getPositionZ(i) + "]"
+ );
+ }
+ }
+
+
+ /**
+ * Dumps faces of a mesh to stdout.
+ *
+ * @param mesh the mesh
+ */
+ public static void dumpFaces(AiMesh mesh) {
+ if (!mesh.hasFaces()) {
+ System.out.println("mesh has no faces");
+ return;
+ }
+
+ for (int face = 0; face < mesh.getNumFaces(); face++) {
+ int faceNumIndices = mesh.getFaceNumIndices(face);
+ System.out.print(faceNumIndices + ": ");
+
+ for (int vertex = 0; vertex < faceNumIndices; vertex++) {
+ int reference = mesh.getFaceVertex(face, vertex);
+
+ System.out.print("[" +
+ mesh.getPositionX(reference) + ", " +
+ mesh.getPositionY(reference) + ", " +
+ mesh.getPositionZ(reference) + "] "
+ );
+ }
+
+ System.out.println();
+ }
+ }
+
+
+ /**
+ * Dumps a vertex color set of a mesh to stdout.
+ *
+ * @param mesh the mesh
+ * @param colorset the color set
+ */
+ public static void dumpColorset(AiMesh mesh, int colorset) {
+ if (!mesh.hasColors(colorset)) {
+ System.out.println("mesh has no vertex color set " + colorset);
+ return;
+ }
+
+ for (int i = 0; i < mesh.getNumVertives(); i++) {
+ System.out.println("[" +
+ mesh.getColorR(i, colorset) + ", " +
+ mesh.getColorG(i, colorset) + ", " +
+ mesh.getColorB(i, colorset) + ", " +
+ mesh.getColorA(i, colorset) + "]"
+ );
+ }
+ }
+
+
+ /**
+ * Dumps a texture coordinate set of a mesh to stdout.
+ *
+ * @param mesh the mesh
+ * @param coords the coordinates
+ */
+ public static void dumpTexCoords(AiMesh mesh, int coords) {
+ if (!mesh.hasTexCoords(coords)) {
+ System.out.println("mesh has no texture coordinate set " + coords);
+ return;
+ }
+
+ for (int i = 0; i < mesh.getNumVertives(); i++) {
+ int numComponents = mesh.getNumUVComponents(coords);
+ System.out.print("[" + mesh.getTexCoordU(i, coords));
+
+ if (numComponents > 1) {
+ System.out.print(", " + mesh.getTexCoordV(i, coords));
+ }
+
+ if (numComponents > 2) {
+ System.out.print(", " + mesh.getTexCoordW(i, coords));
+ }
+
+ System.out.println("]");
+ }
+ }
+
+
+ /**
+ * Dumps a single material property to stdout.
+ *
+ * @param property the property
+ */
+ public static void dumpMaterialProperty(AiMaterial.Property property) {
+ System.out.print(property.getKey() + " " + property.getSemantic() +
+ " " + property.getIndex() + ": ");
+ Object data = property.getData();
+
+ if (data instanceof ByteBuffer) {
+ ByteBuffer buf = (ByteBuffer) data;
+ for (int i = 0; i < buf.capacity(); i++) {
+ System.out.print(Integer.toHexString(buf.get(i) & 0xFF) + " ");
+ }
+
+ System.out.println();
+ }
+ else {
+ System.out.println(data.toString());
+ }
+ }
+
+
+ /**
+ * Dumps all properties of a material to stdout.
+ *
+ * @param material the material
+ */
+ public static void dumpMaterial(AiMaterial material) {
+ for (AiMaterial.Property prop : material.getProperties()) {
+ dumpMaterialProperty(prop);
+ }
+ }
+
+
+ /**
+ * Dumps an animation channel to stdout.
+ *
+ * @param nodeAnim the channel
+ */
+ public static void dumpNodeAnim(AiNodeAnim nodeAnim) {
+ for (int i = 0; i < nodeAnim.getNumPosKeys(); i++) {
+ System.out.println(i + ": " + nodeAnim.getPosKeyTime(i) +
+ " ticks, " + nodeAnim.getPosKeyVector(i, Jassimp.BUILTIN));
+ }
+ }
+}
diff --git a/port/jassimp/jassimp/src/jassimp/Jassimp.java b/port/jassimp/jassimp/src/jassimp/Jassimp.java
new file mode 100644
index 000000000..238456c1d
--- /dev/null
+++ b/port/jassimp/jassimp/src/jassimp/Jassimp.java
@@ -0,0 +1,256 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library - Java Binding (jassimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2012, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+ copyright notice, this list of conditions and the
+ following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the
+ following disclaimer in the documentation and/or other
+ materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+ contributors may be used to endorse or promote products
+ derived from this software without specific prior
+ written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+package jassimp;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.EnumSet;
+import java.util.Set;
+
+
+
+/**
+ * Entry point to the jassimp library.
+ *
+ * Use {@link #importFile(String, Set)} to load a file.
+ *
+ *
+ *
+ * This method can be called when one of the import methods fails, i.e.,
+ * throws an exception, to get a human readable error description.
+ *
+ * @return the error string
+ */
+ public static native String getErrorString();
+
+
+ /**
+ * Returns the active wrapper provider.
+ *
+ * This method is part of the wrapped API (see {@link AiWrapperProvider}
+ * for details on wrappers).
+ *
+ * @return the active wrapper provider
+ */
+ public static AiWrapperProvider getWrapperProvider() {
+ return s_wrapperProvider;
+ }
+
+
+ /**
+ * Sets a new wrapper provider.
+ *
+ * This method is part of the wrapped API (see {@link AiWrapperProvider}
+ * for details on wrappers).
+ *
+ * @param wrapperProvider the new wrapper provider
+ */
+ public static void setWrapperProvider(AiWrapperProvider
+ wrapperProvider) {
+
+ s_wrapperProvider = wrapperProvider;
+ }
+
+
+ /**
+ * Helper method for wrapping a matrix.
+ *
+ * Used by JNI, do not modify!
+ *
+ * @param data the matrix data
+ * @return the wrapped matrix
+ */
+ static Object wrapMatrix(float[] data) {
+ return s_wrapperProvider.wrapMatrix4f(data);
+ }
+
+
+ /**
+ * Helper method for wrapping a color (rgb).
+ *
+ * Used by JNI, do not modify!
+ *
+ * @param red red component
+ * @param green green component
+ * @param blue blue component
+ * @return the wrapped color
+ */
+ static Object wrapColor3(float red, float green, float blue) {
+ return wrapColor4(red, green, blue, 1.0f);
+ }
+
+
+ /**
+ * Helper method for wrapping a color (rgba).
+ *
+ * Used by JNI, do not modify!
+ *
+ * @param red red component
+ * @param green green component
+ * @param blue blue component
+ * @param alpha alpha component
+ * @return the wrapped color
+ */
+ static Object wrapColor4(float red, float green, float blue, float alpha) {
+ ByteBuffer temp = ByteBuffer.allocate(4 * 4);
+ temp.putFloat(red);
+ temp.putFloat(green);
+ temp.putFloat(blue);
+ temp.putFloat(alpha);
+ temp.flip();
+ return s_wrapperProvider.wrapColor(temp, 0);
+ }
+
+
+ /**
+ * Helper method for wrapping a vector.
+ *
+ * Used by JNI, do not modify!
+ *
+ * @param x x component
+ * @param y y component
+ * @param z z component
+ * @return the wrapped vector
+ */
+ static Object wrapVec3(float x, float y, float z) {
+ ByteBuffer temp = ByteBuffer.allocate(3 * 4);
+ temp.putFloat(x);
+ temp.putFloat(y);
+ temp.putFloat(z);
+ temp.flip();
+ return s_wrapperProvider.wrapVector3f(temp, 0, 3);
+ }
+
+
+ /**
+ * Helper method for wrapping a scene graph node.
+ *
+ * Used by JNI, do not modify!
+ *
+ * @param parent the parent node
+ * @param matrix the transformation matrix
+ * @param meshRefs array of matrix references
+ * @param name the name of the node
+ * @return the wrapped matrix
+ */
+ static Object wrapSceneNode(Object parent, Object matrix, int[] meshRefs,
+ String name) {
+
+ return s_wrapperProvider.wrapSceneNode(parent, matrix, meshRefs, name);
+ }
+
+
+ /**
+ * The native interface.
+ *
+ * @param filename the file to load
+ * @param postProcessing post processing flags
+ * @return the loaded scene, or null if an error occurred
+ * @throws IOException if an error occurs
+ */
+ private static native AiScene aiImportFile(String filename,
+ long postProcessing) throws IOException;
+
+
+ /**
+ * The active wrapper provider.
+ */
+ private static AiWrapperProvider s_wrapperProvider =
+ new AiBuiltInWrapperProvider();
+
+
+ /**
+ * Pure static class, no accessible constructor.
+ */
+ private Jassimp() {
+ /* nothing to do */
+ }
+
+
+ static {
+ System.loadLibrary("jassimp");
+ }
+}
diff --git a/port/jassimp/jassimp/src/jassimp/JassimpConfig.java b/port/jassimp/jassimp/src/jassimp/JassimpConfig.java
new file mode 100644
index 000000000..8370bb9f0
--- /dev/null
+++ b/port/jassimp/jassimp/src/jassimp/JassimpConfig.java
@@ -0,0 +1,66 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library - Java Binding (jassimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2012, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+ copyright notice, this list of conditions and the
+ following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the
+ following disclaimer in the documentation and/or other
+ materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+ contributors may be used to endorse or promote products
+ derived from this software without specific prior
+ written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+package jassimp;
+
+
+/**
+ * Global configuration values (limits).
+ */
+public final class JassimpConfig {
+ /**
+ * Maximum number of vertex color sets.
+ */
+ public static final int MAX_NUMBER_COLORSETS = 8;
+
+
+ /**
+ * Maximum number of texture coordinate sets.
+ */
+ public static final int MAX_NUMBER_TEXCOORDS = 8;
+
+
+ /**
+ * Pure static class, no accessible constructor.
+ */
+ private JassimpConfig() {
+ /* nothing to do */
+ }
+}
diff --git a/port/jassimp/jassimp/src/jassimp/package-info.java b/port/jassimp/jassimp/src/jassimp/package-info.java
new file mode 100644
index 000000000..fa2883824
--- /dev/null
+++ b/port/jassimp/jassimp/src/jassimp/package-info.java
@@ -0,0 +1,45 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library - Java Binding (jassimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2012, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+ copyright notice, this list of conditions and the
+ following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the
+ following disclaimer in the documentation and/or other
+ materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+ contributors may be used to endorse or promote products
+ derived from this software without specific prior
+ written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/**
+ * Java binding for the Open Asset Import Library.
+ */
+package jassimp;
getMeshChannels().size()
+ *
+ * @return the number of mesh animation channels
+ */
+ public int getNumMeshChannels() {
+ throw new UnsupportedOperationException("not implemented yet");
+ }
+
+
+ /**
+ * Returns the list of mesh animation channels.
+ * SourceColor * SourceBlend + DestColor * DestBlend
+ *
+ * where DestColor is the previous color in the framebuffer at
+ * this position and SourceColor is the material color before the
+ * transparency calculation.
+ */
+public enum AiBlendMode {
+ /**
+ * Default blending.
+ * SourceColor*SourceAlpha + DestColor*(1-SourceAlpha)
+ *
+ */
+ DEFAULT(0x0),
+
+
+ /**
+ * Additive blending.
+ * SourceColor*1 + DestColor*1
+ *
+ */
+ ADDITIVE(0x1);
+
+
+ /**
+ * Utility method for converting from c/c++ based integer enums to java
+ * enums.getBoneWeights().size()
+ *
+ * @return the number of weights
+ */
+ public int getNumWeights() {
+ return m_boneWeights.size();
+ }
+
+
+ /**
+ * Returns a list of bone weights.
+ *
+ * @return the bone weights
+ */
+ public List
+ * // Get the camera matrix for a camera at a specific time
+ * // if the node hierarchy for the camera does not contain
+ * // at least one animated node this is a static computation
+ * get-camera-matrix (node sceneRoot, camera cam) : matrix
+ * {
+ * node cnd = find-node-for-camera(cam)
+ * matrix cmt = identity()
+ *
+ * // as usual - get the absolute camera transformation for this frame
+ * for each node nd in hierarchy from sceneRoot to cnd
+ * matrix cur
+ * if (is-animated(nd))
+ * cur = eval-animation(nd)
+ * else cur = nd->mTransformation;
+ * cmt = mult-matrices( cmt, cur )
+ * end for
+ *
+ * // now multiply with the camera's own local transform
+ * cam = mult-matrices (cam, get-camera-matrix(cmt) )
+ * }
+ *
+// * This option might be useful if you are using some magic node names
+// * to pass additional semantics through the content pipeline. This ensures
+// * they won't be optimized away, but a general optimization is still
+// * performed for nodes not contained in the list.
+// * Property type: String. Default value: n/a
+// * @note Linefeeds, tabs or carriage returns are treated as whitespace.
+// * Node names are case sensitive.
+// */
+// #define AI_CONFIG_PP_OG_EXCLUDE_LIST \
+// "PP_OG_EXCLUDE_LIST"
+//
+// // ---------------------------------------------------------------------------
+// /** @brief Set the maximum number of triangles in a mesh.
+// *
+// * This is used by the "SplitLargeMeshes" PostProcess-Step to determine
+// * whether a mesh must be split or not.
+// * @note The default value is AI_SLM_DEFAULT_MAX_TRIANGLES
+// * Property type: integer.
+// */
+// #define AI_CONFIG_PP_SLM_TRIANGLE_LIMIT \
+// "PP_SLM_TRIANGLE_LIMIT"
+//
+// // default value for AI_CONFIG_PP_SLM_TRIANGLE_LIMIT
+// #if (!defined AI_SLM_DEFAULT_MAX_TRIANGLES)
+// # define AI_SLM_DEFAULT_MAX_TRIANGLES 1000000
+// #endif
+//
+// // ---------------------------------------------------------------------------
+// /** @brief Set the maximum number of vertices in a mesh.
+// *
+// * This is used by the "SplitLargeMeshes" PostProcess-Step to determine
+// * whether a mesh must be split or not.
+// * @note The default value is AI_SLM_DEFAULT_MAX_VERTICES
+// * Property type: integer.
+// */
+// #define AI_CONFIG_PP_SLM_VERTEX_LIMIT \
+// "PP_SLM_VERTEX_LIMIT"
+//
+// // default value for AI_CONFIG_PP_SLM_VERTEX_LIMIT
+// #if (!defined AI_SLM_DEFAULT_MAX_VERTICES)
+// # define AI_SLM_DEFAULT_MAX_VERTICES 1000000
+// #endif
+//
+// // ---------------------------------------------------------------------------
+// /** @brief Set the maximum number of bones affecting a single vertex
+// *
+// * This is used by the #aiProcess_LimitBoneWeights PostProcess-Step.
+// * @note The default value is AI_LBW_MAX_WEIGHTS
+// * Property type: integer.*/
+// #define AI_CONFIG_PP_LBW_MAX_WEIGHTS \
+// "PP_LBW_MAX_WEIGHTS"
+//
+// // default value for AI_CONFIG_PP_LBW_MAX_WEIGHTS
+// #if (!defined AI_LMW_MAX_WEIGHTS)
+// # define AI_LMW_MAX_WEIGHTS 0x4
+// #endif // !! AI_LMW_MAX_WEIGHTS
+//
+// // ---------------------------------------------------------------------------
+// /** @brief Lower the deboning threshold in order to remove more bones.
+// *
+// * This is used by the #aiProcess_Debone PostProcess-Step.
+// * @note The default value is AI_DEBONE_THRESHOLD
+// * Property type: float.*/
+// #define AI_CONFIG_PP_DB_THRESHOLD \
+// "PP_DB_THRESHOLD"
+//
+// // default value for AI_CONFIG_PP_LBW_MAX_WEIGHTS
+// #if (!defined AI_DEBONE_THRESHOLD)
+// # define AI_DEBONE_THRESHOLD 1.0f
+// #endif // !! AI_DEBONE_THRESHOLD
+//
+// // ---------------------------------------------------------------------------
+// /** @brief Require all bones qualify for deboning before removing any
+// *
+// * This is used by the #aiProcess_Debone PostProcess-Step.
+// * @note The default value is 0
+// * Property type: bool.*/
+// #define AI_CONFIG_PP_DB_ALL_OR_NONE \
+// "PP_DB_ALL_OR_NONE"
+//
+// /** @brief Default value for the #AI_CONFIG_PP_ICL_PTCACHE_SIZE property
+// */
+// #ifndef PP_ICL_PTCACHE_SIZE
+// # define PP_ICL_PTCACHE_SIZE 12
+// #endif
+//
+// // ---------------------------------------------------------------------------
+// /** @brief Set the size of the post-transform vertex cache to optimize the
+// * vertices for. This configures the #aiProcess_ImproveCacheLocality step.
+// *
+// * The size is given in vertices. Of course you can't know how the vertex
+// * format will exactly look like after the import returns, but you can still
+// * guess what your meshes will probably have.
+// * @note The default value is #PP_ICL_PTCACHE_SIZE. That results in slight
+// * performance improvements for most nVidia/AMD cards since 2002.
+// * Property type: integer.
+// */
+// #define AI_CONFIG_PP_ICL_PTCACHE_SIZE "PP_ICL_PTCACHE_SIZE"
+//
+// // ---------------------------------------------------------------------------
+// /** @brief Enumerates components of the aiScene and aiMesh data structures
+// * that can be excluded from the import using the #aiPrpcess_RemoveComponent step.
+// *
+// * See the documentation to #aiProcess_RemoveComponent for more details.
+// */
+// enum aiComponent
+// {
+// /** Normal vectors */
+// #ifdef SWIG
+// aiComponent_NORMALS = 0x2,
+// #else
+// aiComponent_NORMALS = 0x2u,
+// #endif
+//
+// /** Tangents and bitangents go always together ... */
+// #ifdef SWIG
+// aiComponent_TANGENTS_AND_BITANGENTS = 0x4,
+// #else
+// aiComponent_TANGENTS_AND_BITANGENTS = 0x4u,
+// #endif
+//
+// /** ALL color sets
+// * Use aiComponent_COLORn(N) to specify the N'th set */
+// aiComponent_COLORS = 0x8,
+//
+// /** ALL texture UV sets
+// * aiComponent_TEXCOORDn(N) to specify the N'th set */
+// aiComponent_TEXCOORDS = 0x10,
+//
+// /** Removes all bone weights from all meshes.
+// * The scenegraph nodes corresponding to the bones are NOT removed.
+// * use the #aiProcess_OptimizeGraph step to do this */
+// aiComponent_BONEWEIGHTS = 0x20,
+//
+// /** Removes all node animations (aiScene::mAnimations).
+// * The corresponding scenegraph nodes are NOT removed.
+// * use the #aiProcess_OptimizeGraph step to do this */
+// aiComponent_ANIMATIONS = 0x40,
+//
+// /** Removes all embedded textures (aiScene::mTextures) */
+// aiComponent_TEXTURES = 0x80,
+//
+// /** Removes all light sources (aiScene::mLights).
+// * The corresponding scenegraph nodes are NOT removed.
+// * use the #aiProcess_OptimizeGraph step to do this */
+// aiComponent_LIGHTS = 0x100,
+//
+// /** Removes all light sources (aiScene::mCameras).
+// * The corresponding scenegraph nodes are NOT removed.
+// * use the #aiProcess_OptimizeGraph step to do this */
+// aiComponent_CAMERAS = 0x200,
+//
+// /** Removes all meshes (aiScene::mMeshes). */
+// aiComponent_MESHES = 0x400,
+//
+// /** Removes all materials. One default material will
+// * be generated, so aiScene::mNumMaterials will be 1. */
+// aiComponent_MATERIALS = 0x800,
+//
+//
+// /** This value is not used. It is just there to force the
+// * compiler to map this enum to a 32 Bit integer. */
+// #ifndef SWIG
+// _aiComponent_Force32Bit = 0x9fffffff
+// #endif
+// };
+//
+// // Remove a specific color channel 'n'
+// #define aiComponent_COLORSn(n) (1u << (n+20u))
+//
+// // Remove a specific UV channel 'n'
+// #define aiComponent_TEXCOORDSn(n) (1u << (n+25u))
+//
+// // ---------------------------------------------------------------------------
+// /** @brief Input parameter to the #aiProcess_RemoveComponent step:
+// * Specifies the parts of the data structure to be removed.
+// *
+// * See the documentation to this step for further details. The property
+// * is expected to be an integer, a bitwise combination of the
+// * #aiComponent flags defined above in this header. The default
+// * value is 0. Important: if no valid mesh is remaining after the
+// * step has been executed (e.g you thought it was funny to specify ALL
+// * of the flags defined above) the import FAILS. Mainly because there is
+// * no data to work on anymore ...
+// */
+// #define AI_CONFIG_PP_RVC_FLAGS \
+// "PP_RVC_FLAGS"
+//
+// // ---------------------------------------------------------------------------
+// /** @brief Input parameter to the #aiProcess_SortByPType step:
+// * Specifies which primitive types are removed by the step.
+// *
+// * This is a bitwise combination of the aiPrimitiveType flags.
+// * Specifying all of them is illegal, of course. A typical use would
+// * be to exclude all line and point meshes from the import. This
+// * is an integer property, its default value is 0.
+// */
+// #define AI_CONFIG_PP_SBP_REMOVE \
+// "PP_SBP_REMOVE"
+//
+// // ---------------------------------------------------------------------------
+// /** @brief Input parameter to the #aiProcess_FindInvalidData step:
+// * Specifies the floating-point accuracy for animation values. The step
+// * checks for animation tracks where all frame values are absolutely equal
+// * and removes them. This tweakable controls the epsilon for floating-point
+// * comparisons - two keys are considered equal if the invariant
+// * abs(n0-n1)>epsilon holds true for all vector respectively quaternion
+// * components. The default value is 0.f - comparisons are exact then.
+// */
+// #define AI_CONFIG_PP_FID_ANIM_ACCURACY \
+// "PP_FID_ANIM_ACCURACY"
+//
+//
+// // TransformUVCoords evaluates UV scalings
+// #define AI_UVTRAFO_SCALING 0x1
+//
+// // TransformUVCoords evaluates UV rotations
+// #define AI_UVTRAFO_ROTATION 0x2
+//
+// // TransformUVCoords evaluates UV translation
+// #define AI_UVTRAFO_TRANSLATION 0x4
+//
+// // Everything baked together -> default value
+// #define AI_UVTRAFO_ALL (AI_UVTRAFO_SCALING | AI_UVTRAFO_ROTATION | AI_UVTRAFO_TRANSLATION)
+//
+// // ---------------------------------------------------------------------------
+// /** @brief Input parameter to the #aiProcess_TransformUVCoords step:
+// * Specifies which UV transformations are evaluated.
+// *
+// * This is a bitwise combination of the AI_UVTRAFO_XXX flags (integer
+// * property, of course). By default all transformations are enabled
+// * (AI_UVTRAFO_ALL).
+// */
+// #define AI_CONFIG_PP_TUV_EVALUATE \
+// "PP_TUV_EVALUATE"
+//
+// // ---------------------------------------------------------------------------
+// /** @brief A hint to assimp to favour speed against import quality.
+// *
+// * Enabling this option may result in faster loading, but it needn't.
+// * It represents just a hint to loaders and post-processing steps to use
+// * faster code paths, if possible.
+// * This property is expected to be an integer, != 0 stands for true.
+// * The default value is 0.
+// */
+// #define AI_CONFIG_FAVOUR_SPEED \
+// "FAVOUR_SPEED"
+//
+//
+// // ###########################################################################
+// // IMPORTER SETTINGS
+// // Various stuff to fine-tune the behaviour of specific importer plugins.
+// // ###########################################################################
+//
+//
+// // ---------------------------------------------------------------------------
+// /** @brief Set the vertex animation keyframe to be imported
+// *
+// * ASSIMP does not support vertex keyframes (only bone animation is supported).
+// * The library reads only one frame of models with vertex animations.
+// * By default this is the first frame.
+// * \note The default value is 0. This option applies to all importers.
+// * However, it is also possible to override the global setting
+// * for a specific loader. You can use the AI_CONFIG_IMPORT_XXX_KEYFRAME
+// * options (where XXX is a placeholder for the file format for which you
+// * want to override the global setting).
+// * Property type: integer.
+// */
+// #define AI_CONFIG_IMPORT_GLOBAL_KEYFRAME "IMPORT_GLOBAL_KEYFRAME"
+//
+// #define AI_CONFIG_IMPORT_MD3_KEYFRAME "IMPORT_MD3_KEYFRAME"
+// #define AI_CONFIG_IMPORT_MD2_KEYFRAME "IMPORT_MD2_KEYFRAME"
+// #define AI_CONFIG_IMPORT_MDL_KEYFRAME "IMPORT_MDL_KEYFRAME"
+// #define AI_CONFIG_IMPORT_MDC_KEYFRAME "IMPORT_MDC_KEYFRAME"
+// #define AI_CONFIG_IMPORT_SMD_KEYFRAME "IMPORT_SMD_KEYFRAME"
+// #define AI_CONFIG_IMPORT_UNREAL_KEYFRAME "IMPORT_UNREAL_KEYFRAME"
+//
+//
+// // ---------------------------------------------------------------------------
+// /** @brief Configures the AC loader to collect all surfaces which have the
+// * "Backface cull" flag set in separate meshes.
+// *
+// * Property type: bool. Default value: true.
+// */
+// #define AI_CONFIG_IMPORT_AC_SEPARATE_BFCULL \
+// "IMPORT_AC_SEPARATE_BFCULL"
+//
+// // ---------------------------------------------------------------------------
+// /** @brief Configures whether the AC loader evaluates subdivision surfaces (
+// * indicated by the presence of the 'subdiv' attribute in the file). By
+// * default, Assimp performs the subdivision using the standard
+// * Catmull-Clark algorithm
+// *
+// * * Property type: bool. Default value: true.
+// */
+// #define AI_CONFIG_IMPORT_AC_EVAL_SUBDIVISION \
+// "IMPORT_AC_EVAL_SUBDIVISION"
+//
+// // ---------------------------------------------------------------------------
+// /** @brief Configures the UNREAL 3D loader to separate faces with different
+// * surface flags (e.g. two-sided vs. single-sided).
+// *
+// * * Property type: bool. Default value: true.
+// */
+// #define AI_CONFIG_IMPORT_UNREAL_HANDLE_FLAGS \
+// "UNREAL_HANDLE_FLAGS"
+//
+// // ---------------------------------------------------------------------------
+// /** @brief Configures the terragen import plugin to compute uv's for
+// * terrains, if not given. Furthermore a default texture is assigned.
+// *
+// * UV coordinates for terrains are so simple to compute that you'll usually
+// * want to compute them on your own, if you need them. This option is intended
+// * for model viewers which want to offer an easy way to apply textures to
+// * terrains.
+// * * Property type: bool. Default value: false.
+// */
+// #define AI_CONFIG_IMPORT_TER_MAKE_UVS \
+// "IMPORT_TER_MAKE_UVS"
+//
+// // ---------------------------------------------------------------------------
+// /** @brief Configures the ASE loader to always reconstruct normal vectors
+// * basing on the smoothing groups loaded from the file.
+// *
+// * Some ASE files have carry invalid normals, other don't.
+// * * Property type: bool. Default value: true.
+// */
+// #define AI_CONFIG_IMPORT_ASE_RECONSTRUCT_NORMALS \
+// "IMPORT_ASE_RECONSTRUCT_NORMALS"
+//
+// // ---------------------------------------------------------------------------
+// /** @brief Configures the M3D loader to detect and process multi-part
+// * Quake player models.
+// *
+// * These models usually consist of 3 files, lower.md3, upper.md3 and
+// * head.md3. If this property is set to true, Assimp will try to load and
+// * combine all three files if one of them is loaded.
+// * Property type: bool. Default value: true.
+// */
+// #define AI_CONFIG_IMPORT_MD3_HANDLE_MULTIPART \
+// "IMPORT_MD3_HANDLE_MULTIPART"
+//
+// // ---------------------------------------------------------------------------
+// /** @brief Tells the MD3 loader which skin files to load.
+// *
+// * When loading MD3 files, Assimp checks whether a file
+// *
+// * Property type: Integer. Default value: all layers are loaded.
+// */
+// #define AI_CONFIG_IMPORT_LWO_ONE_LAYER_ONLY \
+// "IMPORT_LWO_ONE_LAYER_ONLY"
+//
+// // ---------------------------------------------------------------------------
+// /** @brief Configures the MD5 loader to not load the MD5ANIM file for
+// * a MD5MESH file automatically.
+// *
+// * The default strategy is to look for a file with the same name but the
+// * MD5ANIM extension in the same directory. If it is found, it is loaded
+// * and combined with the MD5MESH file. This configuration option can be
+// * used to disable this behaviour.
+// *
+// * * Property type: bool. Default value: false.
+// */
+// #define AI_CONFIG_IMPORT_MD5_NO_ANIM_AUTOLOAD \
+// "IMPORT_MD5_NO_ANIM_AUTOLOAD"
+//
+// // ---------------------------------------------------------------------------
+// /** @brief Defines the begin of the time range for which the LWS loader
+// * evaluates animations and computes aiNodeAnim's.
+// *
+// * Assimp provides full conversion of LightWave's envelope system, including
+// * pre and post conditions. The loader computes linearly subsampled animation
+// * chanels with the frame rate given in the LWS file. This property defines
+// * the start time. Note: animation channels are only generated if a node
+// * has at least one envelope with more tan one key assigned. This property.
+// * is given in frames, '0' is the first frame. By default, if this property
+// * is not set, the importer takes the animation start from the input LWS
+// * file ('FirstFrame' line)
+// * Property type: Integer. Default value: taken from file.
+// *
+// * @see AI_CONFIG_IMPORT_LWS_ANIM_END - end of the imported time range
+// */
+// #define AI_CONFIG_IMPORT_LWS_ANIM_START \
+// "IMPORT_LWS_ANIM_START"
+// #define AI_CONFIG_IMPORT_LWS_ANIM_END \
+// "IMPORT_LWS_ANIM_END"
+//
+// // ---------------------------------------------------------------------------
+// /** @brief Defines the output frame rate of the IRR loader.
+// *
+// * IRR animations are difficult to convert for Assimp and there will
+// * always be a loss of quality. This setting defines how many keys per second
+// * are returned by the converter.
+// * Property type: integer. Default value: 100
+// */
+// #define AI_CONFIG_IMPORT_IRR_ANIM_FPS \
+// "IMPORT_IRR_ANIM_FPS"
+//
+//
+// // ---------------------------------------------------------------------------
+// /** @brief Ogre Importer will try to load this Materialfile.
+// *
+// * Ogre Meshes contain only the MaterialName, not the MaterialFile. If there
+// * is no material file with the same name as the material, Ogre Importer will
+// * try to load this file and search the material in it.
+// *
+// * Property type: String. Default value: guessed.
+// */
+// #define AI_CONFIG_IMPORT_OGRE_MATERIAL_FILE "IMPORT_OGRE_MATERIAL_FILE"
+//
+//
+// // ---------------------------------------------------------------------------
+// /** @brief Ogre Importer detect the texture usage from its filename
+// *
+// * Normally, a texture is loaded as a colormap, if no target is specified in the
+// * materialfile. Is this switch is enabled, texture names ending with _n, _l, _s
+// * are used as normalmaps, lightmaps or specularmaps.
+// *
+// * Property type: Bool. Default value: false.
+// */
+// #define AI_CONFIG_IMPORT_OGRE_TEXTURETYPE_FROM_FILENAME "IMPORT_OGRE_TEXTURETYPE_FROM_FILENAME"
+//
+//
+//
+// // ---------------------------------------------------------------------------
+// /** @brief Specifies whether the IFC loader skips over IfcSpace elements.
+// *
+// * IfcSpace elements (and their geometric representations) are used to
+// * represent, well, free space in a building storey.
+// * Property type: Bool. Default value: true.
+// */
+// #define AI_CONFIG_IMPORT_IFC_SKIP_SPACE_REPRESENTATIONS "IMPORT_IFC_SKIP_SPACE_REPRESENTATIONS"
+//
+//
+// // ---------------------------------------------------------------------------
+// /** @brief Specifies whether the IFC loader skips over
+// * shape representations of type 'Curve2D'.
+// *
+// * A lot of files contain both a faceted mesh representation and a outline
+// * with a presentation type of 'Curve2D'. Currently Assimp doesn't convert those,
+// * so turning this option off just clutters the log with errors.
+// * Property type: Bool. Default value: true.
+// */
+// #define AI_CONFIG_IMPORT_IFC_SKIP_CURVE_REPRESENTATIONS "IMPORT_IFC_SKIP_CURVE_REPRESENTATIONS"
+//
+// // ---------------------------------------------------------------------------
+// /** @brief Specifies whether the IFC loader will use its own, custom triangulation
+// * algorithm to triangulate wall and floor meshes.
+// *
+// * If this property is set to false, walls will be either triangulated by
+// * #aiProcess_Triangulate or will be passed through as huge polygons with
+// * faked holes (i.e. holes that are connected with the outer boundary using
+// * a dummy edge). It is highly recommended to set this property to true
+// * if you want triangulated data because #aiProcess_Triangulate is known to
+// * have problems with the kind of polygons that the IFC loader spits out for
+// * complicated meshes.
+// * Property type: Bool. Default value: true.
+// */
+// #define AI_CONFIG_IMPORT_IFC_CUSTOM_TRIANGULATION "IMPORT_IFC_CUSTOM_TRIANGULATION"
+//
+ ;
+
+ private AiConfigOptions(String name) {
+ m_name = name;
+ }
+
+
+ private final String m_name;
+}
diff --git a/port/jassimp/jassimp/src/jassimp/AiLight.java b/port/jassimp/jassimp/src/jassimp/AiLight.java
new file mode 100644
index 000000000..0b1dd2f67
--- /dev/null
+++ b/port/jassimp/jassimp/src/jassimp/AiLight.java
@@ -0,0 +1,387 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library - Java Binding (jassimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2012, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+ copyright notice, this list of conditions and the
+ following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the
+ following disclaimer in the documentation and/or other
+ materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+ contributors may be used to endorse or promote products
+ derived from this software without specific prior
+ written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+package jassimp;
+
+
+/**
+ * Describes a light source.Atten = 1/( att0 + att1 * d + att2 * d*d)
+ * This member corresponds to the att0 variable in the equation.
+ * Naturally undefined for directional lights.
+ *
+ * @return the constant light attenuation factor
+ */
+ public float getAttenuationConstant() {
+ return m_attenuationConstant;
+ }
+
+
+ /**
+ * Linear light attenuation factor.Atten = 1/( att0 + att1 * d + att2 * d*d)
+ * This member corresponds to the att1 variable in the equation.
+ * Naturally undefined for directional lights.
+ *
+ * @return the linear light attenuation factor
+ */
+ public float getAttenuationLinear() {
+ return m_attenuationLinear;
+ }
+
+
+ /**
+ * Quadratic light attenuation factor.Atten = 1/( att0 + att1 * d + att2 * d*d)
+ * This member corresponds to the att2 variable in the equation.
+ * Naturally undefined for directional lights.
+ *
+ * @return the quadratic light attenuation factor
+ */
+ public float getAttenuationQuadratic() {
+ return m_attenuationQuadratic;
+ }
+
+
+ /**
+ * Diffuse color of the light source.getXXX() for all supported properties. These
+ * methods are fail-save, i.e., will return a default value when the
+ * corresponding property is not set. To change the built in default values,
+ * use the setDefaultXXX() methods.getXXX() methods without special
+ * error handling code as the implementation guarantees to return default
+ * values for missing properties. This check will not work on texture related
+ * properties (i.e., properties starting with TEX_).
+ */
+public final class AiMaterial {
+ /**
+ * Enumerates all supported material properties.
+ */
+ public static enum PropertyKey {
+ /**
+ * Name.
+ */
+ NAME("?mat.name", String.class),
+
+ /**
+ * Two-sided flag.
+ */
+ TWO_SIDED("$mat.twosided", Integer.class),
+
+ /**
+ * Shading mode.
+ */
+ SHADING_MODE("$mat.shadingm", AiShadingMode.class),
+
+ /**
+ * Wireframe flag.
+ */
+ WIREFRAME("$mat.wireframe", Integer.class),
+
+ /**
+ * Blend mode.
+ */
+ BLEND_MODE("$mat.blend", AiBlendMode.class),
+
+ /**
+ * Opacity.
+ */
+ OPACITY("$mat.opacity", Float.class),
+
+ /**
+ * Bump scaling.
+ */
+ BUMP_SCALING("$mat.bumpscaling", Float.class),
+
+
+ /**
+ * Shininess.
+ */
+ SHININESS("$mat.shininess", Float.class),
+
+
+ /**
+ * Reflectivity.
+ */
+ REFLECTIVITY("$mat.reflectivity", Float.class),
+
+
+ /**
+ * Shininess strength.
+ */
+ SHININESS_STRENGTH("$mat.shinpercent", Float.class),
+
+
+ /**
+ * Refract index.
+ */
+ REFRACTI("$mat.refracti", Float.class),
+
+
+ /**
+ * Diffuse color.
+ */
+ COLOR_DIFFUSE("$clr.diffuse", Object.class),
+
+
+ /**
+ * Ambient color.
+ */
+ COLOR_AMBIENT("$clr.ambient", Object.class),
+
+
+ /**
+ * Ambient color.
+ */
+ COLOR_SPECULAR("$clr.specular", Object.class),
+
+
+ /**
+ * Emissive color.
+ */
+ COLOR_EMISSIVE("$clr.emissive", Object.class),
+
+
+ /**
+ * Transparent color.
+ */
+ COLOR_TRANSPARENT("$clr.transparent", Object.class),
+
+
+ /**
+ * Reflective color.
+ */
+ COLOR_REFLECTIVE("$clr.reflective", Object.class),
+
+
+ /**
+ * Global background image.
+ */
+ GLOBAL_BACKGROUND_IMAGE("?bg.global", String.class),
+
+
+ /**
+ * Texture file path.
+ */
+ TEX_FILE("$tex.file", String.class),
+
+
+ /**
+ * Texture uv index.
+ */
+ TEX_UV_INDEX("$tex.uvwsrc", Integer.class),
+
+
+ /**
+ * Texture blend factor.
+ */
+ TEX_BLEND("$tex.blend", Float.class),
+
+
+ /**
+ * Texture operation.
+ */
+ TEX_OP("$tex.op", AiTextureOp.class),
+
+
+ /**
+ * Texture map mode for u axis.
+ */
+ TEX_MAP_MODE_U("$tex.mapmodeu", AiTextureMapMode.class),
+
+
+ /**
+ * Texture map mode for v axis.
+ */
+ TEX_MAP_MODE_V("$tex.mapmodev", AiTextureMapMode.class),
+
+
+ /**
+ * Texture map mode for w axis.
+ */
+ TEX_MAP_MODE_W("$tex.mapmodew", AiTextureMapMode.class);
+
+ /**
+ * Constructor.
+ *
+ * @param key key name as used by assimp
+ * @param type key type, used for casts and checks
+ */
+ private PropertyKey(String key, Class type) {
+ m_key = key;
+ m_type = type;
+ }
+
+
+ /**
+ * Key.
+ */
+ private final String m_key;
+
+
+ /**
+ * Type.
+ */
+ private final Class m_type;
+ }
+
+
+ /**
+ * A very primitive RTTI system for the contents of material properties.
+ */
+ public static enum PropertyType {
+ /**
+ * Array of single-precision (32 Bit) floats.
+ */
+ FLOAT(0x1),
+
+
+ /**
+ * The material property is a string.
+ */
+ STRING(0x3),
+
+
+ /**
+ * Array of (32 Bit) integers.
+ */
+ INTEGER(0x4),
+
+
+ /**
+ * Simple binary buffer, content undefined. Not convertible to anything.
+ */
+ BUFFER(0x5);
+
+
+ /**
+ * Utility method for converting from c/c++ based integer enums to java
+ * enums.getXXX() method.
+ *
+ * @param key the key
+ * @param defaultValue the new default, may not be null
+ * @throws IllegalArgumentException if defaultValue is null or has a wrong
+ * type
+ */
+ public void setDefault(PropertyKey key, Object defaultValue) {
+ if (null == defaultValue) {
+ throw new IllegalArgumentException("defaultValue may not be null");
+ }
+ if (key.m_type != defaultValue.getClass()) {
+ throw new IllegalArgumentException(
+ "defaultValue has wrong type, " +
+ "expected: " + key.m_type + ", found: " +
+ defaultValue.getClass());
+ }
+
+ m_defaults.put(key, defaultValue);
+ }
+
+
+ // {{ Fail-save Getters
+ /**
+ * Returns the name of the material.GL20.glUniformMatrix4(). Be sure to set
+ * transpose to true in this case, as OpenGL
+ * expects the matrix in column order.
+ *
+ * @return a new native order, direct ByteBuffer
+ */
+ public FloatBuffer toByteBuffer() {
+ ByteBuffer bbuf = ByteBuffer.allocateDirect(16 * 4);
+ bbuf.order(ByteOrder.nativeOrder());
+ FloatBuffer fbuf = bbuf.asFloatBuffer();
+ fbuf.put(m_data);
+ fbuf.flip();
+
+ return fbuf;
+ }
+
+
+ @Override
+ public String toString() {
+ StringBuilder buf = new StringBuilder();
+
+ for (int row = 0; row < 4; row++) {
+ for (int col = 0; col < 4; col++) {
+ buf.append(m_data[row * 4 + col]).append(" ");
+ }
+ buf.append("\n");
+ }
+
+ return buf.toString();
+ }
+
+
+ /**
+ * Data buffer.
+ */
+ private final float[] m_data;
+}
diff --git a/port/jassimp/jassimp/src/jassimp/AiMesh.java b/port/jassimp/jassimp/src/jassimp/AiMesh.java
new file mode 100644
index 000000000..81ac0b775
--- /dev/null
+++ b/port/jassimp/jassimp/src/jassimp/AiMesh.java
@@ -0,0 +1,1429 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library - Java Binding (jassimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2012, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+ copyright notice, this list of conditions and the
+ following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the
+ following disclaimer in the documentation and/or other
+ materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+ contributors may be used to endorse or promote products
+ derived from this software without specific prior
+ written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+package jassimp;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.FloatBuffer;
+import java.nio.IntBuffer;
+import java.util.ArrayList;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.Set;
+
+
+/**
+ * A mesh represents a geometry or model with a single material.
+ * Data
+ * Meshes usually consist of a number of vertices and a series of faces
+ * referencing the vertices. In addition there might be a series of bones, each
+ * of them addressing a number of vertices with a certain weight. Vertex data is
+ * presented in channels with each channel containing a single per-vertex
+ * information such as a set of texture coordinates or a normal vector.API for vertex and face data
+ * The jassimp interface for accessing vertex and face data is not a one-to-one
+ * mapping of the c/c++ interface. The c/c++ interface uses an object-oriented
+ * approach to represent data, which provides a considerable
+ * overhead using a naive java based realization (cache locality would be
+ * unpredictable and most likely bad, bulk data transfer would be impossible).
+ *
+ *
+ *
+ * The Buffer API is optimized for use in conjunction with rendering APIs
+ * such as LWJGL. The returned buffers are guaranteed to have native byte order
+ * and to be direct byte buffers. They can be passed directly to LWJGL
+ * methods, e.g., to fill VBOs with data. Each invocation of a
+ * getXXXBuffer() methods return
+ * raw data buffers.
+ * getXXX() methods allow reading
+ * and writing of individual data values.
+ * getWrappedXXX() methods provide
+ * an object oriented view on the data.
+ * getXXXBuffer() method will return a new view of the internal
+ * buffer, i.e., if is safe to use the relative byte buffer operations.
+ * The Buffer API provides the best performance of all three APIs, especially
+ * if large data volumes have to be processed.getWrappedXXX() method, a new wrapper object
+ * is created. Iterating over mesh data via this interface will create many
+ * short-lived wrapper objects which -depending on usage and virtual machine-
+ * may cause considerable garbage collection overhead. The Wrapped API provides
+ * the worst performance of all three APIs, which may nevertheless still be
+ * good enough to warrant its usage. See {@link AiWrapperProvider} for more
+ * details on wrappers.
+ *
+ *
+ * API for bones
+ * As there is no standardized way for doing skinning in different graphics
+ * engines, bones are not represented as flat buffers but as object structure.
+ * Users of this library should convert this structure to the format required
+ * by the specific graphics engine.
+ *
+ *
+ * Changing Data
+ * This class is designed to be mutable, i.e., the returned objects and buffers
+ * may be modified. It is not possible to add/remove vertices as this would
+ * require reallocation of the data buffers. Wrapped objects may or may not
+ * propagate changes to the underlying data buffers. Consult the documentation
+ * of your wrapper provider for details. The built in wrappers will propagate
+ * changes.
+ * 3 * getNumVertives() floats
+ *
+ * @return a native-order direct buffer, or null if no data is available
+ */
+ public FloatBuffer getPositionBuffer() {
+ if (m_vertices == null) {
+ return null;
+ }
+
+ return m_vertices.asFloatBuffer();
+ }
+
+
+ /**
+ * Returns a buffer containing face data.3 * getNumVertives() integers (3 indices per triangle)
+ *
+ * @return a native-order direct buffer
+ * @throws UnsupportedOperationException
+ * if the mesh is not a pure triangle mesh
+ */
+ public IntBuffer getIndexBuffer() {
+ if (!isPureTriangle()) {
+ throw new UnsupportedOperationException(
+ "mesh is not a pure triangle mesh");
+ }
+
+ return getFaceBuffer();
+ }
+
+
+ /**
+ * Returns a buffer containing normals.3 * getNumVertives() floats
+ *
+ * @return a native-order direct buffer
+ */
+ public FloatBuffer getNormalBuffer() {
+ if (m_normals == null) {
+ return null;
+ }
+
+ return m_normals.asFloatBuffer();
+ }
+
+
+ /**
+ * Returns a buffer containing tangents.3 * getNumVertives() floats
+ *
+ * @return a native-order direct buffer
+ */
+ public FloatBuffer getTangentBuffer() {
+ if (m_tangents == null) {
+ return null;
+ }
+
+ return m_tangents.asFloatBuffer();
+ }
+
+
+ /**
+ * Returns a buffer containing bitangents.3 * getNumVertives() floats
+ *
+ * @return a native-order direct buffer
+ */
+ public FloatBuffer getBitangentBuffer() {
+ if (m_bitangents == null) {
+ return null;
+ }
+
+ return m_bitangents.asFloatBuffer();
+ }
+
+
+ /**
+ * Returns a buffer containing vertex colors for a color set.4 * getNumVertives() floats
+ *
+ * @param colorset the color set
+ *
+ * @return a native-order direct buffer, or null if no data is available
+ */
+ public FloatBuffer getColorBuffer(int colorset) {
+ if (m_colorsets[colorset] == null) {
+ return null;
+ }
+
+ return m_colorsets[colorset].asFloatBuffer();
+ }
+
+
+ /**
+ * Returns a buffer containing coordinates for a texture coordinate set.getNumUVComponents(coords) * getNumVertives() floats
+ *
+ * @param coords the texture coordinate set
+ *
+ * @return a native-order direct buffer, or null if no data is available
+ */
+ public FloatBuffer getTexCoordBuffer(int coords) {
+ if (m_texcoords[coords] == null) {
+ return null;
+ }
+
+ return m_texcoords[coords].asFloatBuffer();
+ }
+ // }}
+
+
+ // {{ Direct API
+ /**
+ * Returns the x-coordinate of a vertex position.
+ *
+ * @param vertex the vertex index
+ * @return the x coordinate
+ */
+ public float getPositionX(int vertex) {
+ if (!hasPositions()) {
+ throw new IllegalStateException("mesh has no positions");
+ }
+
+ checkVertexIndexBounds(vertex);
+
+ return m_vertices.getFloat(vertex * 3 * SIZEOF_FLOAT);
+ }
+
+
+ /**
+ * Returns the y-coordinate of a vertex position.
+ *
+ * @param vertex the vertex index
+ * @return the y coordinate
+ */
+ public float getPositionY(int vertex) {
+ if (!hasPositions()) {
+ throw new IllegalStateException("mesh has no positions");
+ }
+
+ checkVertexIndexBounds(vertex);
+
+ return m_vertices.getFloat((vertex * 3 + 1) * SIZEOF_FLOAT);
+ }
+
+ /**
+ * Returns the z-coordinate of a vertex position.
+ *
+ * @param vertex the vertex index
+ * @return the z coordinate
+ */
+ public float getPositionZ(int vertex) {
+ if (!hasPositions()) {
+ throw new IllegalStateException("mesh has no positions");
+ }
+
+ checkVertexIndexBounds(vertex);
+
+ return m_vertices.getFloat((vertex * 3 + 2) * SIZEOF_FLOAT);
+ }
+
+
+ /**
+ * Returns a vertex reference from a face.getFaceNumIndices(face) vertex references.
+ * This method returns the n'th of these. The returned index can be passed
+ * directly to the vertex oriented methods, such as
+ * getPosition() etc.
+ *
+ * @param face the face
+ * @param n the reference
+ * @return a vertex index
+ */
+ public int getFaceVertex(int face, int n) {
+ if (!hasFaces()) {
+ throw new IllegalStateException("mesh has no faces");
+ }
+
+ if (face >= m_numFaces || face < 0) {
+ throw new IndexOutOfBoundsException("Index: " + face + ", Size: " +
+ m_numFaces);
+ }
+ if (n >= getFaceNumIndices(face) || n < 0) {
+ throw new IndexOutOfBoundsException("Index: " + n + ", Size: " +
+ getFaceNumIndices(face));
+ }
+
+ int faceOffset = 0;
+ if (m_faceOffsets == null) {
+ faceOffset = 3 * face * SIZEOF_INT;
+ }
+ else {
+ faceOffset = m_faceOffsets.getInt(face * SIZEOF_INT) * SIZEOF_INT;
+ }
+
+ return m_faces.getInt(faceOffset + n * SIZEOF_INT);
+ }
+
+
+ /**
+ * Returns the x-coordinate of a vertex normal.
+ *
+ * @param vertex the vertex index
+ * @return the x coordinate
+ */
+ public float getNormalX(int vertex) {
+ if (!hasNormals()) {
+ throw new IllegalStateException("mesh has no normals");
+ }
+
+ checkVertexIndexBounds(vertex);
+
+ return m_normals.getFloat(vertex * 3 * SIZEOF_FLOAT);
+ }
+
+
+ /**
+ * Returns the y-coordinate of a vertex normal.
+ *
+ * @param vertex the vertex index
+ * @return the y coordinate
+ */
+ public float getNormalY(int vertex) {
+ if (!hasNormals()) {
+ throw new IllegalStateException("mesh has no normals");
+ }
+
+ checkVertexIndexBounds(vertex);
+
+ return m_normals.getFloat((vertex * 3 + 1) * SIZEOF_FLOAT);
+ }
+
+
+ /**
+ * Returns the z-coordinate of a vertex normal.
+ *
+ * @param vertex the vertex index
+ * @return the z coordinate
+ */
+ public float getNormalZ(int vertex) {
+ if (!hasNormals()) {
+ throw new IllegalStateException("mesh has no normals");
+ }
+
+ checkVertexIndexBounds(vertex);
+
+ return m_normals.getFloat((vertex * 3 + 2) * SIZEOF_FLOAT);
+ }
+
+
+ /**
+ * Returns the x-coordinate of a vertex tangent.
+ *
+ * @param vertex the vertex index
+ * @return the x coordinate
+ */
+ public float getTangentX(int vertex) {
+ if (!hasTangentsAndBitangents()) {
+ throw new IllegalStateException("mesh has no tangents");
+ }
+
+ checkVertexIndexBounds(vertex);
+
+ return m_tangents.getFloat(vertex * 3 * SIZEOF_FLOAT);
+ }
+
+
+ /**
+ * Returns the y-coordinate of a vertex bitangent.
+ *
+ * @param vertex the vertex index
+ * @return the y coordinate
+ */
+ public float getTangentY(int vertex) {
+ if (!hasTangentsAndBitangents()) {
+ throw new IllegalStateException("mesh has no bitangents");
+ }
+
+ checkVertexIndexBounds(vertex);
+
+ return m_tangents.getFloat((vertex * 3 + 1) * SIZEOF_FLOAT);
+ }
+
+
+ /**
+ * Returns the z-coordinate of a vertex tangent.
+ *
+ * @param vertex the vertex index
+ * @return the z coordinate
+ */
+ public float getTangentZ(int vertex) {
+ if (!hasTangentsAndBitangents()) {
+ throw new IllegalStateException("mesh has no tangents");
+ }
+
+ checkVertexIndexBounds(vertex);
+
+ return m_tangents.getFloat((vertex * 3 + 2) * SIZEOF_FLOAT);
+ }
+
+
+ /**
+ * Returns the x-coordinate of a vertex tangent.
+ *
+ * @param vertex the vertex index
+ * @return the x coordinate
+ */
+ public float getBitangentX(int vertex) {
+ if (!hasTangentsAndBitangents()) {
+ throw new IllegalStateException("mesh has no bitangents");
+ }
+
+ checkVertexIndexBounds(vertex);
+
+ return m_bitangents.getFloat(vertex * 3 * SIZEOF_FLOAT);
+ }
+
+
+ /**
+ * Returns the y-coordinate of a vertex tangent.
+ *
+ * @param vertex the vertex index
+ * @return the y coordinate
+ */
+ public float getBitangentY(int vertex) {
+ if (!hasTangentsAndBitangents()) {
+ throw new IllegalStateException("mesh has no bitangents");
+ }
+
+ checkVertexIndexBounds(vertex);
+
+ return m_bitangents.getFloat((vertex * 3 + 1) * SIZEOF_FLOAT);
+ }
+
+
+ /**
+ * Returns the z-coordinate of a vertex tangent.
+ *
+ * @param vertex the vertex index
+ * @return the z coordinate
+ */
+ public float getBitangentZ(int vertex) {
+ if (!hasTangentsAndBitangents()) {
+ throw new IllegalStateException("mesh has no bitangents");
+ }
+
+ checkVertexIndexBounds(vertex);
+
+ return m_bitangents.getFloat((vertex * 3 + 2) * SIZEOF_FLOAT);
+ }
+
+
+ /**
+ * Returns the red color component of a color from a vertex color set.
+ *
+ * @param vertex the vertex index
+ * @param colorset the color set
+ * @return the red color component
+ */
+ public float getColorR(int vertex, int colorset) {
+ if (!hasColors(colorset)) {
+ throw new IllegalStateException("mesh has no colorset " + colorset);
+ }
+
+ checkVertexIndexBounds(vertex);
+ /* bound checks for colorset are done by java for us */
+
+ return m_colorsets[colorset].getFloat(vertex * 4 * SIZEOF_FLOAT);
+ }
+
+
+ /**
+ * Returns the green color component of a color from a vertex color set.
+ *
+ * @param vertex the vertex index
+ * @param colorset the color set
+ * @return the green color component
+ */
+ public float getColorG(int vertex, int colorset) {
+ if (!hasColors(colorset)) {
+ throw new IllegalStateException("mesh has no colorset " + colorset);
+ }
+
+ checkVertexIndexBounds(vertex);
+ /* bound checks for colorset are done by java for us */
+
+ return m_colorsets[colorset].getFloat((vertex * 4 + 1) * SIZEOF_FLOAT);
+ }
+
+
+ /**
+ * Returns the blue color component of a color from a vertex color set.
+ *
+ * @param vertex the vertex index
+ * @param colorset the color set
+ * @return the blue color component
+ */
+ public float getColorB(int vertex, int colorset) {
+ if (!hasColors(colorset)) {
+ throw new IllegalStateException("mesh has no colorset " + colorset);
+ }
+
+ checkVertexIndexBounds(vertex);
+ /* bound checks for colorset are done by java for us */
+
+ return m_colorsets[colorset].getFloat((vertex * 4 + 2) * SIZEOF_FLOAT);
+ }
+
+
+ /**
+ * Returns the alpha color component of a color from a vertex color set.
+ *
+ * @param vertex the vertex index
+ * @param colorset the color set
+ * @return the alpha color component
+ */
+ public float getColorA(int vertex, int colorset) {
+ if (!hasColors(colorset)) {
+ throw new IllegalStateException("mesh has no colorset " + colorset);
+ }
+
+ checkVertexIndexBounds(vertex);
+ /* bound checks for colorset are done by java for us */
+
+ return m_colorsets[colorset].getFloat((vertex * 4 + 3) * SIZEOF_FLOAT);
+ }
+
+
+ /**
+ * Returns the u component of a coordinate from a texture coordinate set.
+ *
+ * @param vertex the vertex index
+ * @param coords the texture coordinate set
+ * @return the u component
+ */
+ public float getTexCoordU(int vertex, int coords) {
+ if (!hasTexCoords(coords)) {
+ throw new IllegalStateException(
+ "mesh has no texture coordinate set " + coords);
+ }
+
+ checkVertexIndexBounds(vertex);
+ /* bound checks for coords are done by java for us */
+
+ return m_texcoords[coords].getFloat(
+ vertex * m_numUVComponents[coords] * SIZEOF_FLOAT);
+ }
+
+
+ /**
+ * Returns the v component of a coordinate from a texture coordinate set.getNumUVComponents(coords) to determine how may
+ * coordinate components are available.
+ *
+ * @param vertex the vertex index
+ * @param coords the texture coordinate set
+ * @return the v component
+ */
+ public float getTexCoordV(int vertex, int coords) {
+ if (!hasTexCoords(coords)) {
+ throw new IllegalStateException(
+ "mesh has no texture coordinate set " + coords);
+ }
+
+ checkVertexIndexBounds(vertex);
+
+ /* bound checks for coords are done by java for us */
+
+ if (getNumUVComponents(coords) < 2) {
+ throw new IllegalArgumentException("coordinate set " + coords +
+ " does not contain 2D texture coordinates");
+ }
+
+ return m_texcoords[coords].getFloat(
+ (vertex * m_numUVComponents[coords] + 1) * SIZEOF_FLOAT);
+ }
+
+
+ /**
+ * Returns the w component of a coordinate from a texture coordinate set.getNumUVComponents(coords) to determine how may
+ * coordinate components are available.
+ *
+ * @param vertex the vertex index
+ * @param coords the texture coordinate set
+ * @return the w component
+ */
+ public float getTexCoordW(int vertex, int coords) {
+ if (!hasTexCoords(coords)) {
+ throw new IllegalStateException(
+ "mesh has no texture coordinate set " + coords);
+ }
+
+ checkVertexIndexBounds(vertex);
+
+ /* bound checks for coords are done by java for us */
+
+ if (getNumUVComponents(coords) < 3) {
+ throw new IllegalArgumentException("coordinate set " + coords +
+ " does not contain 3D texture coordinates");
+ }
+
+ return m_texcoords[coords].getFloat(
+ (vertex * m_numUVComponents[coords] + 1) * SIZEOF_FLOAT);
+ }
+ // }}
+
+
+ // {{ Wrapped API
+ /**
+ * Returns the vertex position as 3-dimensional vector.getChildren().size()
+ *
+ * @return the number of child nodes
+ */
+ public int getNumChildren() {
+ return getChildren().size();
+ }
+
+
+ /**
+ * Returns a 4x4 matrix that specifies the transformation relative to
+ * the parent node.getMeshes().length
+ *
+ * @return the number of references
+ */
+ public int getNumMeshes() {
+ return m_meshReferences.length;
+ }
+
+
+ /**
+ * Returns the meshes referenced by this node.
+ *
+ */
+ TRIANGULATE(0x8),
+
+
+ /**
+ * Removes some parts of the data structure (animations, materials, light
+ * sources, cameras, textures, vertex components).
+ *
+ *
+ * This post-processing step is not time-consuming. Its use is not
+ * compulsory, but recommended.
+ */
+ VALIDATE_DATA_STRUCTURE(0x400),
+
+
+ /**
+ * Reorders triangles for better vertex cache locality.
+ * 1. (if you support lines and points for rendering but don't want
+ * the degenerates)
+ *
+ *
+ *
+ * 2.(if you don't support lines and points at all)
+ *
+ *
+ * Note: Degenerated polygons are not necessarily evil and that's
+ * why they're not removed by default. There are several file formats
+ * which don't support lines or points, and some exporters bypass the
+ * format specification and write them as degenerate triangles instead.
+ */
+ FIND_DEGENERATES(0x10000),
+
+
+ /**
+ * This step searches all meshes for invalid data, such as zeroed normal
+ * vectors or invalid UV coords and removes/fixes them. This is intended to
+ * get rid of some common exporter errors.aiPrimitiveType_POINTS | aiPrimitiveType_LINES
+ * to cause SortByPType to reject point and line meshes from the
+ * scene.
+ *
+ *
+ * 0y|0y ---------- 1x|0y
+ * | |
+ * | |
+ * | |
+ * 0x|1y ---------- 1x|1y
+ *
+ * x2
+ *
+ * x0
+ * x1
+ *
getMeshes().size()
+ *
+ * @return the number of meshes
+ */
+ public int getNumMeshes() {
+ return m_meshes.size();
+ }
+
+
+ /**
+ * Returns the meshes contained in the scene.getMaterials().size()
+ *
+ * @return the number of materials
+ */
+ public int getNumMaterials() {
+ return m_materials.size();
+ }
+
+
+ /**
+ * Returns the list of materials.getAnimations().size()
+ *
+ * @return the number of materials
+ */
+ public int getNumAnimations() {
+ return m_animations.size();
+ }
+
+
+ /**
+ * Returns the list of animations.
+ *
+ * @return the list of animations
+ */
+ public ListgetLights().size()
+ *
+ * @return the number of lights
+ */
+ public int getNumLights() {
+ return m_lights.size();
+ }
+
+
+ /**
+ * Returns the list of light sources.getCameras().size()
+ *
+ * @return the number of cameras
+ */
+ public int getNumCameras() {
+ return m_cameras.size();
+ }
+
+
+ /**
+ * Returns the list of cameras.
+ *
+ * DiffColor0 - gray
+ * DiffTextureOp0 - aiTextureOpMultiply
+ * DiffTexture0 - tex1.png
+ * DiffTextureOp0 - aiTextureOpAdd
+ * DiffTexture1 - tex2.png
+ *
+ * diffFinal = DiffColor0 * sampleTex(DiffTexture0,UV0) +
+ * sampleTex(DiffTexture1,UV0) * diffContrib;
+ *
T = T1 * T2.
+ */
+ MULTIPLY(0x0),
+
+
+ /**
+ * T = T1 + T2.
+ */
+ ADD(0x1),
+
+
+ /**
+ * T = T1 - T2.
+ */
+ SUBTRACT(0x2),
+
+
+ /**
+ * T = T1 / T2.
+ */
+ DIVIDE(0x3),
+
+
+ /**
+ * T = (T1 + T2) - (T1 * T2) .
+ */
+ SMOOTH_ADD(0x4),
+
+
+ /**
+ * T = T1 + (T2-0.5).
+ */
+ SIGNED_ADD(0x5);
+
+
+ /**
+ * Utility method for converting from c/c++ based integer enums to java
+ * enums. the type used to represent quaternions
+ */
+public interface AiWrapperProvider
General Notes and Pitfalls
+ * Due to the loading via JNI, strings (for example as returned by the
+ * getName() methods) are not interned. You should therefore
+ * compare strings the way it should be done, i.e, via equals().
+ * Pointer comparison will fail.
+ */
+public final class Jassimp {
+
+ /**
+ * The default wrapper provider using built in types.
+ */
+ public static final AiWrapperProvider BUILTIN =
+ new AiBuiltInWrapperProvider();
+
+
+ /**
+ * Imports a file via assimp without post processing.
+ *
+ * @param filename the file to import
+ * @return the loaded scene
+ * @throws IOException if an error occurs
+ */
+ public static AiScene importFile(String filename) throws IOException {
+
+ return importFile(filename, EnumSet.noneOf(AiPostProcessSteps.class));
+ }
+
+
+ /**
+ * Imports a file via assimp.
+ *
+ * @param filename the file to import
+ * @param postProcessing post processing flags
+ * @return the loaded scene, or null if an error occurred
+ * @throws IOException if an error occurs
+ */
+ public static AiScene importFile(String filename,
+ Set