From 746fb7549ce7727c66f6e34079e808b136e6552e Mon Sep 17 00:00:00 2001 From: klickverbot Date: Fri, 31 Jul 2009 22:30:22 +0000 Subject: [PATCH] Imported D bindings into port/dAssimp. git-svn-id: https://assimp.svn.sourceforge.net/svnroot/assimp/trunk@455 67173fc5-114c-0410-ac8e-9d2fd5bffc1f --- port/dAssimp/README | 11 + port/dAssimp/assimp/animation.d | 236 +++++++++++ port/dAssimp/assimp/api.d | 670 ++++++++++++++++++++++++++++++ port/dAssimp/assimp/assimp.d | 63 +++ port/dAssimp/assimp/camera.d | 182 ++++++++ port/dAssimp/assimp/config.d | 626 ++++++++++++++++++++++++++++ port/dAssimp/assimp/fileIO.d | 140 +++++++ port/dAssimp/assimp/light.d | 215 ++++++++++ port/dAssimp/assimp/loader.d | 203 +++++++++ port/dAssimp/assimp/material.d | 640 ++++++++++++++++++++++++++++ port/dAssimp/assimp/math.d | 155 +++++++ port/dAssimp/assimp/mesh.d | 367 ++++++++++++++++ port/dAssimp/assimp/postprocess.d | 588 ++++++++++++++++++++++++++ port/dAssimp/assimp/scene.d | 306 ++++++++++++++ port/dAssimp/assimp/texture.d | 122 ++++++ port/dAssimp/assimp/types.d | 232 +++++++++++ port/dAssimp/assimp/versionInfo.d | 72 ++++ 17 files changed, 4828 insertions(+) create mode 100644 port/dAssimp/README create mode 100644 port/dAssimp/assimp/animation.d create mode 100644 port/dAssimp/assimp/api.d create mode 100644 port/dAssimp/assimp/assimp.d create mode 100644 port/dAssimp/assimp/camera.d create mode 100644 port/dAssimp/assimp/config.d create mode 100644 port/dAssimp/assimp/fileIO.d create mode 100644 port/dAssimp/assimp/light.d create mode 100644 port/dAssimp/assimp/loader.d create mode 100644 port/dAssimp/assimp/material.d create mode 100644 port/dAssimp/assimp/math.d create mode 100644 port/dAssimp/assimp/mesh.d create mode 100644 port/dAssimp/assimp/postprocess.d create mode 100644 port/dAssimp/assimp/scene.d create mode 100644 port/dAssimp/assimp/texture.d create mode 100644 port/dAssimp/assimp/types.d create mode 100644 port/dAssimp/assimp/versionInfo.d diff --git a/port/dAssimp/README b/port/dAssimp/README new file mode 100644 index 000000000..2b9341419 --- /dev/null +++ b/port/dAssimp/README @@ -0,0 +1,11 @@ +D bindings for the Assimp library (http://assimp.sf.net). +--- + +These bindings provide access to Assimp's C API. They were directly created +from the C header files. + +You should be able to create sufficient DDoc documentation for the bindings +using your favourite build tool (such as Rebuild). Please refer to the main +(Doxygen-generated) documentation for general topics. + +Please contact for any bindings-specific issues. diff --git a/port/dAssimp/assimp/animation.d b/port/dAssimp/assimp/animation.d new file mode 100644 index 000000000..7d4fc7e8e --- /dev/null +++ b/port/dAssimp/assimp/animation.d @@ -0,0 +1,236 @@ +/* +--------------------------------------------------------------------------- +Open Asset Import Library (ASSIMP) +--------------------------------------------------------------------------- + +Copyright (c) 2006-2009, ASSIMP Development 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 Development 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. +--------------------------------------------------------------------------- +*/ + +/** + * The data structures which are used to store the imported animation data. + */ +module assimp.animation; + +import assimp.math; +import assimp.types; + +extern ( C ) { + /** + * A time-value pair specifying a certain 3D vector for the given time. + */ + struct aiVectorKey { + /** + * The time of this key. + */ + double mTime; + + /** + * The value of this key. + */ + aiVector3D mValue; + } + + /** + * A time-value pair specifying a rotation for the given time. For joint + * animations, the rotation is usually expressed using a quaternion. + */ + struct aiQuatKey { + /** + * The time of this key. + */ + double mTime; + + /** + * The value of this key. + */ + aiQuaternion mValue; + } + + /** + * Defines how an animation channel behaves outside the defined time + * range. This corresponds to aiNodeAnim.mPreState and + * aiNodeAnim.mPostState. + */ + enum aiAnimBehaviour : uint { + /** + * The value from the default node transformation is used. + */ + DEFAULT = 0x0, + + /** + * The nearest key value is used without interpolation. + */ + CONSTANT = 0x1, + + /** + * The value of the nearest two keys is linearly extrapolated for the + * current time value. + */ + LINEAR = 0x2, + + /** + * The animation is repeated. + * + * 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 + } + + /** + * Describes the animation of a single node. The name 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. 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 (so you should + * be able to handle them). + */ + struct aiNodeAnim { + /** + * The name of the node affected by this animation. The node must exist + * and it must be unique. + */ + aiString mNodeName; + + /** + * The number of position keys. + */ + uint mNumPositionKeys; + + /** + * The position keys of this animation channel. Positions are specified + * as 3D vectors. The array is mNumPositionKeys in size. + * + * If there are position keys, there will also be at least one scaling + * and one rotation key. + */ + aiVectorKey* mPositionKeys; + + /** + * The number of rotation keys. + */ + uint mNumRotationKeys; + + /** + * The rotation keys of this animation channel. Rotations are given as + * quaternions. The array is mNumRotationKeys in size. + * + * If there are rotation keys, there will also be at least one scaling + * and one position key. + */ + aiQuatKey* mRotationKeys; + + + /** + * The number of scaling keys. + */ + uint mNumScalingKeys; + + /** + * The scaling keys of this animation channel. Scalings are specified as + * 3D vectors. The array is mNumScalingKeys in size. + * + * If there are scaling keys, there will also be at least one position + * and one rotation key. + */ + aiVectorKey* mScalingKeys; + + + /** + * Defines how the animation behaves before the first key is encountered. + * + * The default value is aiAnimBehaviour.DEFAULT (the original + * transformation matrix of the affected node is used). + */ + aiAnimBehaviour mPreState; + + /** + * Defines how the animation behaves after the last key was processed. + * + * The default value is aiAnimBehaviour.DEFAULT (the original + * transformation matrix of the affected node is used). + */ + aiAnimBehaviour mPostState; + } + + /** + * 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. + */ + struct aiAnimation { + /** + * 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). + */ + aiString mName; + + /** + * Duration of the animation in ticks. + */ + double mDuration; + + /** + * Ticks per second. 0 if not specified in the imported file. + */ + double mTicksPerSecond; + + /** + * The number of bone animation channels. + * + * Each channel affects a single node. + */ + uint mNumChannels; + + /** + * The node animation channels. The array is mNumChannels + * in size. + * + * Each channel affects a single node. + */ + aiNodeAnim** mChannels; + } +} \ No newline at end of file diff --git a/port/dAssimp/assimp/api.d b/port/dAssimp/assimp/api.d new file mode 100644 index 000000000..67cdfccbf --- /dev/null +++ b/port/dAssimp/assimp/api.d @@ -0,0 +1,670 @@ +/* +--------------------------------------------------------------------------- +Open Asset Import Library (ASSIMP) +--------------------------------------------------------------------------- + +Copyright (c) 2006-2009, ASSIMP Development 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 Development 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. +--------------------------------------------------------------------------- +*/ + +/** + * The C-style interface to the Open Asset import library. + * + * All functions of the C API have been collected in this module as function + * pointers, which are set by the dynamic library loader + * (assimp.loader). + */ +module assimp.api; + +import assimp.fileIO; +import assimp.material; +import assimp.math; +import assimp.scene; +import assimp.types; + +extern ( C ) { + /** + * Reads the given file and returns its content. + * + * If the call succeeds, the imported data is returned in an aiScene + * structure. The data is intended to be read-only, it stays property of the + * Assimp library and will be stable until aiReleaseImport() is + * called. After you're done with it, call aiReleaseImport() to + * free the resources associated with this file. + * + * If an error is encountered, null is returned instead. Call + * aiGetErrorString() to retrieve a human-readable error + * description. + * + * Params: + * pFile = Path and filename of the file to be imported, + * expected to be a null-terminated C-string. null is not a valid value. + * pFlags = Optional post processing steps to be executed after a + * successful import. Provide a bitwise combination of the + * aiPostProcessSteps flags. If you wish to inspect the + * imported scene first in order to fine-tune your post-processing + * setup, consider to use aiApplyPostProcessing(). + * + * Returns: + * A pointer to the imported data, null if the import failed. + */ + aiScene* function( char* pFile, uint pFile ) aiImportFile; + + /** + * Reads the given file using user-defined I/O functions and returns its + * content. + * + * If the call succeeds, the imported data is returned in an aiScene + * structure. The data is intended to be read-only, it stays property of the + * Assimp library and will be stable until aiReleaseImport() is + * called. After you're done with it, call aiReleaseImport() to + * free the resources associated with this file. + * + * If an error is encountered, null is returned instead. Call + * aiGetErrorString() to retrieve a human-readable error + * description. + * + * Params: + * pFile = Path and filename of the file to be imported, + * expected to be a null-terminated C-string. null is not a valid value. + * pFlags = Optional post processing steps to be executed after a + * successful import. Provide a bitwise combination of the + * aiPostProcessSteps flags. If you wish to inspect the + * imported scene first in order to fine-tune your post-processing + * setup, consider to use aiApplyPostProcessing(). + * pFS = An aiFileIO which will be used to open the model file itself + * and any other files the loader needs to open. + * + * Returns: + * A pointer to the imported data, null if the import failed. + */ + aiScene* function( char* pFile, uint pFlags, aiFileIO* pFS ) aiImportFileEx; + + /** + * Reads the scene from the given memory buffer. + * + * Reads the given file using user-defined I/O functions and returns its + * content. + * + * If the call succeeds, the imported data is returned in an aiScene + * structure. The data is intended to be read-only, it stays property of the + * Assimp library and will be stable until aiReleaseImport() is + * called. After you're done with it, call aiReleaseImport() to + * free the resources associated with this file. + * + * If an error is encountered, null is returned instead. Call + * aiGetErrorString() to retrieve a human-readable error + * description. + * + * Params: + * pBuffer = Pointer to the scene data. + * pLength = Size of pBuffer in bytes. + * pFlags = Optional post processing steps to be executed after a + * successful import. Provide a bitwise combination of the + * aiPostProcessSteps flags. If you wish to inspect the + * imported scene first in order to fine-tune your post-processing + * setup, consider to use aiApplyPostProcessing(). + * pHint = An additional hint to the library. If this is a non empty + * string, the library looks for a loader to support the file + * extension specified and passes the file to the first matching + * loader. If this loader is unable to complete the request, the + * library continues and tries to determine the file format on its + * own, a task that may or may not be successful. + * + * Returns: + * A pointer to the imported data, null if the import failed. + * + * Note: + * This is a straightforward way to decode models from memory buffers, + * but it doesn't handle model formats spreading their data across + * multiple files or even directories. Examples include OBJ or MD3, which + * outsource parts of their material stuff into external scripts. If you + * need the full functionality, provide a custom IOSystem to make Assimp + * find these files. + */ + aiScene* function( + char* pBuffer, + uint pLength, + uint pFlags, + char* pHint + ) aiImportFileFromMemory; + + /** + * Apply post-processing to an already-imported scene. + * + * This is strictly equivalent to calling aiImportFile() or + * aiImportFileEx() with the same flags. However, you can use + * this separate function to inspect the imported scene first to fine-tune + * your post-processing setup. + * + * Params: + * pScene = Scene to work on. + * pFlags = Provide a bitwise combination of the + * aiPostProcessSteps flags. + * + * Returns: + * A pointer to the post-processed data. Post processing is done in-place, + * meaning this is still the same aiScene which you passed + * for pScene. However, if post-processing failed, the scene could now be + * null. That's quite a rare case, post processing steps are not really + * designed to fail. To be exact, aiProcess.ValidateDS is + * currently the only post processing step which can actually cause the + * scene to be reset to null. + */ + aiScene* function( aiScene* pScene, uint pFlags ) aiApplyPostProcessing; + + /** + * Get one of the predefined log streams. This is the quick'n'easy solution + * to access Assimp's log system. Attaching a log stream can slightly reduce + * Assimp's overall import performance. + * + * Examples: + * --- + * aiLogStream stream = aiGetPredefinedLogStream( + * aiDefaultLogStream.FILE, "assimp.log.txt" ); + * if ( stream.callback !is null ) { + * aiAttachLogStream( &stream ); + * } + * --- + * + * Params: + * pStreams = The log stream destination. + * file = Solely for the aiDefaultLogStream.FILE flag: + * specifies the file to write to. Pass null for all other flags. + * + * Returns: + * The log stream, null if something went wrong. + */ + aiLogStream function( aiDefaultLogStream pStreams, char* file ) aiGetPredefinedLogStream; + + /** + * Attach a custom log stream to the libraries' logging system. + * + * Attaching a log stream can slightly reduce Assimp's overall import + * performance. Multiple log-streams can be attached. + * + * Params: + * stream = Describes the new log stream. + * + * Note: To ensure proper destruction of the logging system, you need to + * manually call aiDetachLogStream() on every single log + * stream you attach. Alternatively, aiDetachAllLogStreams() + * is provided. + */ + void function( aiLogStream* stream ) aiAttachLogStream; + + /** + * Enable verbose logging. + * + * Verbose logging includes debug-related stuff and detailed import + * statistics. This can have severe impact on import performance and memory + * consumption. However, it might be useful to find out why a file is not + * read correctly. + * + * Param: + * d = Whether verbose logging should be enabled. + */ + void function( aiBool d ) aiEnableVerboseLogging; + + /** + * Detach a custom log stream from the libraries' logging system. + * + * This is the counterpart of #aiAttachPredefinedLogStream. If you attached a stream, + * don't forget to detach it again. + * + * Params: + * stream = The log stream to be detached. + * + * Returns: + * aiReturn.SUCCESS if the log stream has been detached + * successfully. + * + * See: aiDetachAllLogStreams + */ + aiReturn function( aiLogStream* stream ) aiDetachLogStream; + + /** + * Detach all active log streams from the libraries' logging system. + * + * This ensures that the logging system is terminated properly and all + * resources allocated by it are actually freed. If you attached a stream, + * don't forget to detach it again. + * + * See: aiAttachLogStream, aiDetachLogStream + */ + void function() aiDetachAllLogStreams; + + /** + * Releases all resources associated with the given import process. + * + * Call this function after you're done with the imported data. + * + * Params: + * pScene = The imported data to release. null is a valid value. + */ + void function( aiScene* pScene ) aiReleaseImport; + + /** + * Returns the error text of the last failed import process. + * + * Returns: + * A textual description of the error that occurred at the last importing + * process. null if there was no error. There can't be an error if you + * got a non-null aiScene from + * aiImportFile()/aiImportFileEx()/aiApplyPostProcessing(). + */ + char* function() aiGetErrorString; + + /** + * Returns whether a given file extension is supported by this Assimp build. + * + * Params: + * szExtension = Extension for which to query support. Must include a + * leading dot '.'. Example: ".3ds", ".md3" + * + * Returns: + * TRUE if the file extension is supported. + */ + aiBool function( char* szExtension ) aiIsExtensionSupported; + + /** + * Gets a list of all file extensions supported by ASSIMP. + * + * Format of the list: "*.3ds;*.obj;*.dae". + * + * If a file extension is contained in the list this does, of course, not + * mean that Assimp is able to load all files with this extension. + * + * Params: + * szOut = String to receive the extension list. null is not a valid + * parameter. + */ + void function( aiString* szOut ) aiGetExtensionList; + + /** + * Gets the storage required by an imported asset + * + * Params: + * pIn = Asset to query storage size for. + * info = Data structure to be filled. + */ + void function( aiScene* pIn, aiMemoryInfo* info ) aiGetMemoryRequirements; + + /** + * Sets an integer property. + * + * Properties are always shared by all imports. It is not possible to + * specify them per import. + * + * Params: + * szName = Name of the configuration property to be set. All supported + * public properties are defined in the config module. + * value = New value for the property. + */ + void function( char* szName, int value ) aiSetImportPropertyInteger; + + /** + * Sets a floating-point property. + * + * Properties are always shared by all imports. It is not possible to + * specify them per import. + * + * Params: + * szName = Name of the configuration property to be set. All supported + * public properties are defined in the config module. + * value = New value for the property. + */ + void function( char* szName, float value ) aiSetImportPropertyFloat; + + /** + * Sets a string property. + * + * Properties are always shared by all imports. It is not possible to + * specify them per import. + * + * Params: + * szName = Name of the configuration property to be set. All supported + * public properties are defined in the config module. + * st = New value for the property. + */ + void function( char* szName, aiString* st ) aiSetImportPropertyString; + + + /* + * Mathematical helper functions. + */ + + /** + * Constructs a quaternion from a 3x3 rotation matrix. + * + * Params: + * quat = Receives the output quaternion. + * mat = Matrix to 'quaternionize'. + */ + void function( aiQuaternion* quat, aiMatrix3x3* mat ) aiCreateQuaternionFromMatrix; + + /** + * Decomposes a transformation matrix into its rotational, translational and + * scaling components. + * + * Params: + * mat = Matrix to decompose. + * scaling = Receives the scaling component. + * rotation = Receives the rotational component. + * position = Receives the translational component. + */ + void function( + aiMatrix4x4* mat, + aiVector3D* scaling, + aiQuaternion* rotation, + aiVector3D* position + ) aiDecomposeMatrix; + + /** + * Transposes a 4x4 matrix (in-place). + * + * Params: + * mat = The matrix to be transposed. + */ + void function( aiMatrix4x4* mat ) aiTransposeMatrix4; + + /** + * Transposes a 3x3 matrix (in-place). + * + * Params: + * mat = The matrix to be transposed. + */ + void function( aiMatrix3x3* mat ) aiTransposeMatrix3; + + /** + * Transforms a vector by a 3x3 matrix (in-place). + * + * Params: + * vec = Vector to be transformed. + * mat = Matrix to transform the vector with. + */ + void function( aiVector3D* vec, aiMatrix3x3* mat ) aiTransformVecByMatrix3; + + /** + * Transforms a vector by a 4x4 matrix (in-place). + * + * Params: + * vec = Vector to be transformed. + * mat = Matrix to transform the vector with. + */ + void function( aiVector3D* vec, aiMatrix4x4* mat ) aiTransformVecByMatrix4; + + /** + * Multiplies two 4x4 matrices. + * + * Params: + * dst = First factor, receives result. + * src = Matrix to be multiplied with 'dst'. + */ + void function( aiMatrix4x4* dst, aiMatrix4x4* src ) aiMultiplyMatrix4; + + /** + * Multiplies two 3x3 matrices. + * + * Params: + * dst = First factor, receives result. + * src = Matrix to be multiplied with 'dst'. + */ + void function( aiMatrix3x3* dst, aiMatrix3x3* src ) aiMultiplyMatrix3; + + /** + * Constructs a 3x3 identity matrix. + * + * Params: + * mat = Matrix to receive its personal identity. + */ + void function( aiMatrix3x3* mat ) aiIdentityMatrix3; + + /** + * Constructs a 4x4 identity matrix. + * + * Params: + * mat = Matrix to receive its personal identity. + */ + void function( aiMatrix4x4* mat ) aiIdentityMatrix4; + + + /* + * Material system functions. + */ + + /** + * Retrieves a material property with a specific key from the material. + * + * Params: + * pMat = Pointer to the input material. May not be null. + * pKey = Key to search for. One of the AI_MATKEY_XXX + * constants. + * type = Specifies the aiTextureType of the texture to be + * retrieved, 0 for non-texture properties. + * index = Index of the texture to be retrieved, + * 0 for non-texture properties. + * pPropOut = Pointer to receive a pointer to a valid + * aiMaterialProperty structure or null if the key has + * not been found. + */ + aiReturn function( + aiMaterial* pMat, + char* pKey, + aiTextureType type, + uint index, + aiMaterialProperty** pPropOut + ) aiGetMaterialProperty; + + /** + * Retrieves a single float value or an array of float values from the + * material. + * + * Examples: + * --- + * const FLOATS_IN_UV_TRANSFORM = ( aiUVTransform.sizeof / float.sizeof ); + * uint valuesRead = FLOATS_IN_UV_TRANSFORM; + * bool success = + * ( aiGetMaterialFloatArray( &material, AI_MATKEY_UVTRANSFORM, + * aiTextureType.DIFFUSE, 0, cast( float* ) &trafo, &valuesRead ) == + * aiReturn.SUCCESS ) && + * ( valuesRead == FLOATS_IN_UV_TRANSFORM ); + * --- + * + * Params: + * pMat = Pointer to the input material. May not be null. + * pKey = Key to search for. One of the AI_MATKEY_XXX constants. + * type = Specifies the aiTextureType of the texture to be + * retrieved, 0 for non-texture properties. + * index = Index of the texture to be retrieved, + * 0 for non-texture properties. + * pOut = Pointer to a buffer to receive the result. + * pMax = Specifies the size of the given buffer in floats. Receives the + * number of values (not bytes!) read. null to read a scalar property. + * + * Returns: + * Specifies whether the key has been found. If not, the output arrays + * remains unmodified and pMax is set to 0. + */ + aiReturn function( + aiMaterial* pMat, + char* pKey, + uint type, + uint index, + float* pOut, + uint* pMax = null + ) aiGetMaterialFloatArray; + + /** + * Convenience alias for aiGetMaterialFloatArray(). + */ + alias aiGetMaterialFloatArray aiGetMaterialFloat; + + /** + * Retrieves a single integer value or an array of integer values from the + * material. + * + * See: aiGetMaterialFloatArray() + */ + aiReturn function( + aiMaterial* pMat, + char* pKey, + uint type, + uint index, + int* pOut, + uint* pMax = null + ) aiGetMaterialIntegerArray; + + /** + * Convenience alias for aiGetMaterialIntegerArray(). + */ + alias aiGetMaterialIntegerArray aiGetMaterialInteger; + + /** + * Retrieves a color value from the material. + * + * See: aiGetMaterialFloatArray() + */ + aiReturn function( + aiMaterial* pMat, + char* pKey, + uint type, + uint index, + aiColor4D* pOut + ) aiGetMaterialColor; + + /** + * Retrieves a string value from the material. + * + * See: aiGetMaterialFloatArray() + */ + aiReturn function( + aiMaterial* pMat, + char* pKey, + uint type, + uint index, + aiString* pOut + ) aiGetMaterialString; + + /** + * Helper function for retrieving a texture from the material. + * + * This function is provided just for convenience. You could also read the + * texture by reading all of its properties manually. This function bundles + * all of them in a huge function-monster. + * + * Params: + * mat = Pointer to the input material. May not be null. + * type = Specifies the aiTextureType of the texture to be + * retrieved. + * index = Index of the texture to be retrieved. + * path = Receives the output path. null is not a valid value. + * mapping = Recieves the texture mapping mode to be used. + * Pass null if you are not interested in this information. + * uvindex = For UV-mapped textures: receives the index of the UV source + * channel. Unmodified otherwise. Pass null if you are not interested + * in this information. + * blend = Receives the blend factor for the texture. + * Pass null if you are not interested in this information. + * op = Receives the texture blend operation to be perform between this + * texture and the previous texture. Pass null if you are not + * interested in this information. + * mapmode = Receives the mapping modes to be used for the texture. Pass + * a pointer to an array of two aiTextureMapMode's (one for each axis, + * UV order) or null if you are not interested in this information. + * + * Returns: + * aiReturn.SUCCESS on success, something else otherwise. + */ + aiReturn function( + aiMaterial* mat, + aiTextureType type, + uint index, + aiString* path, + aiTextureMapping* mapping = null, + uint* uvindex = null, + float* blend = null, + aiTextureOp* op = null, + aiTextureMapMode* mapmode = null + ) aiGetMaterialTexture; + + + /* + * Versioning functions. + */ + + /** + * Returns a string with legal copyright and licensing information about + * Assimp. + * + * The string may include multiple lines. + * + * Returns: + * Pointer to static string. + */ + char* function() aiGetLegalString; + + /** + * Returns the current minor version number of the Assimp library. + * + * Returns: + * Minor version of the Assimp library. + */ + uint function() aiGetVersionMinor; + + /** + * Returns the current major version number of the Assimp library. + * + * Returns: + * Major version of the Assimp library. + */ + uint function() aiGetVersionMajor; + + /** + * Returns the repository revision of the Assimp library. + * + * Returns: + * SVN Repository revision number of the Assimp library. + */ + uint function() aiGetVersionRevision; + + /** + * Returns the flags Assimp was compiled with. + * + * Returns: + * Any bitwise combination of the ASSIMP_CFLAGS_xxx constants. + */ + uint function() aiGetCompileFlags; +} diff --git a/port/dAssimp/assimp/assimp.d b/port/dAssimp/assimp/assimp.d new file mode 100644 index 000000000..f0474bebf --- /dev/null +++ b/port/dAssimp/assimp/assimp.d @@ -0,0 +1,63 @@ +/* +--------------------------------------------------------------------------- +Open Asset Import Library (ASSIMP) +--------------------------------------------------------------------------- + +Copyright (c) 2006-2009, ASSIMP Development 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 Development 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. +--------------------------------------------------------------------------- +*/ + +/** + * Include-all module provided for convenience. + */ +module assimp.assimp; + +public { + import assimp.animation; + import assimp.api; + import assimp.camera; + import assimp.config; + import assimp.fileIO; + import assimp.light; + import assimp.loader; + import assimp.material; + import assimp.math; + import assimp.mesh; + import assimp.postprocess; + import assimp.scene; + import assimp.texture; + import assimp.types; + import assimp.versionInfo; +} diff --git a/port/dAssimp/assimp/camera.d b/port/dAssimp/assimp/camera.d new file mode 100644 index 000000000..8a2c3c0b8 --- /dev/null +++ b/port/dAssimp/assimp/camera.d @@ -0,0 +1,182 @@ +/* +--------------------------------------------------------------------------- +Open Asset Import Library (ASSIMP) +--------------------------------------------------------------------------- + +Copyright (c) 2006-2009, ASSIMP Development 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 Development 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. +--------------------------------------------------------------------------- +*/ + +/** + * Contains the data structure which is used to store the imported information + * about the virtual cameras in the scene. + */ +module assimp.camera; + +import assimp.math; +import assimp.types; + +extern ( C ) { + /** + * 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. Static cameras parameters like the look-at or up vectors are + * usually specified directly in the class members, but beware, they could + * also be encoded in the node transformation. The following (pseudo)code + * sample shows how to do it. + * + * Examples: + * --- + * // 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) ) + * } + * --- + * + * Note: Some file formats (such as 3DS, ASE) export a "target point" – the + * point the camera is looking at (it can even be animated). Assimp + * writes the target point as a subnode of the camera's main node, called + * ".Target". However, this is just additional information; the + * transformation applied to the main camera node already makes the + * camera face the right direction. + */ + struct aiCamera { + /** + * The name of the camera. + * + * 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. + */ + aiString mName; + + + /** + * Position of the camera relative to the coordinate space defined by the + * corresponding node. + * + * The default value is 0|0|0. + */ + aiVector3D mPosition; + + /** + * Up vector of the camera coordinate system relative to the + * coordinate space defined by the corresponding node. + * + * 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. + */ + aiVector3D mUp; + + /** + * Look-at vector of the camera coordinate system 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. + */ + aiVector3D mLookAt; + + + /** + * Half horizontal field of view angle, in radians. + * + * 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 PI/4. + */ + float mHorizontalFOV; + + /** + * 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. + */ + float mClipPlaneNear; + + /** + * 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 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. + * + * The default value is 1000.f. + */ + float mClipPlaneFar; + + /** + * 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. + */ + float mAspect; + } +} diff --git a/port/dAssimp/assimp/config.d b/port/dAssimp/assimp/config.d new file mode 100644 index 000000000..b9e26e732 --- /dev/null +++ b/port/dAssimp/assimp/config.d @@ -0,0 +1,626 @@ +/* +--------------------------------------------------------------------------- +Open Asset Import Library (ASSIMP) +--------------------------------------------------------------------------- + +Copyright (c) 2006-2009, ASSIMP Development 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 Development 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. +--------------------------------------------------------------------------- +*/ + +/** + * Defines constants for configurable properties for the library. + * + * These are set via aiSetImportPropertyInteger(), + * aiSetImportPropertyFloat() and + * aiSetImportPropertyString(). + */ +module assimp.config; + +extern ( C ) { + /* + * Post processing settings. + * + * Various options to fine-tune the behavior of a specific post processing step. + */ + + /** + * Specifies the maximum angle that may be between two vertex tangents that + * their tangents and bitangents are smoothed. + * + * This applies to the CalcTangentSpace step. The angle is + * specified in degrees, so 180 corresponds to PI radians. + * + * The default value is 45, the maximum value is 175. + * + * Property type: float. + */ + const char* AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE = "PP_CT_MAX_SMOOTHING_ANGLE"; + + /** + * 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 corresponds to PI radians. + * + * 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 AI_CONFIG_FAVOUR_SPEED + * flag is set but the output quality may be reduced. + */ + const char* AI_CONFIG_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. + */ + const char* AI_CONFIG_IMPORT_MDL_COLORMAP = "IMPORT_MDL_COLORMAP"; + + /** + * Configures the 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\'". + * Linefeeds, tabs or carriage returns are treated as 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. + * + * Default value: n/a + * + * Property type: string. + * + * Note: Material names are case sensitive. + */ + const char* AI_CONFIG_PP_RRM_EXCLUDE_LIST = "PP_RRM_EXCLUDE_LIST"; + + /** + * Configures the PretransformVertices step to keep the scene + * hierarchy. Meshes are moved to worldspace, but no optimization is + * performed (means: meshes 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 want to interpret. + * For rendering, you can still render all meshes in the scene without + * any transformations. + * + * Default value: false. + * + * Property type: integer (0: false; !0: true). + */ + const char* AI_CONFIG_PP_PTV_KEEP_HIERARCHY = "PP_PTV_KEEP_HIERARCHY"; + + /** + * Configures the FindDegenerates 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 + * FindDegenerates step for a detailed example of the various + * ways to get rid of these lines and points if you don't want them. + * + * Default value: false. + * + * Property type: integer (0: false; !0: true). + */ + const char* AI_CONFIG_PP_FD_REMOVE = "PP_FD_REMOVE"; + + /** + * Configures the 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 anotherMaterialToBeKept \'name with whitespace\'". + * Linefeeds, tabs or carriage returns are treated as whitespace. + * + * If a node matches on of these names, it will not be modified or + * removed by the postprocessing step. + * + * 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. + * + * Default value: n/a + * + * Property type: string. + * + * Note: Node names are case sensitive. + */ + const char* AI_CONFIG_PP_OG_EXCLUDE_LIST = "PP_OG_EXCLUDE_LIST"; + + /** + * Sets the maximum number of triangles in a mesh. + * + * This is used by the SplitLargeMeshes step to determine + * whether a mesh must be split or not. + * + * Default value: AI_SLM_DEFAULT_MAX_TRIANGLES. + * + * Property type: integer. + */ + const char* AI_CONFIG_PP_SLM_TRIANGLE_LIMIT = "PP_SLM_TRIANGLE_LIMIT"; + + /** + * The default value for the AI_CONFIG_PP_SLM_TRIANGLE_LIMIT setting. + */ + const AI_SLM_DEFAULT_MAX_TRIANGLES = 1000000; + + /** + * Sets the maximum number of vertices in a mesh. + * + * This is used by the SplitLargeMeshes step to determine + * whether a mesh must be split or not. + * + * Default value: AI_SLM_DEFAULT_MAX_VERTICES + * + * Property type: integer. + */ + const char* AI_CONFIG_PP_SLM_VERTEX_LIMIT = "PP_SLM_VERTEX_LIMIT"; + + /** + * The default value for the AI_CONFIG_PP_SLM_VERTEX_LIMIT setting. + */ + const AI_SLM_DEFAULT_MAX_VERTICES = 1000000; + + /** + * Sets the maximum number of bones affecting a single vertex. + * + * This is used by the LimitBoneWeights step. + * + * Default value: AI_LBW_MAX_WEIGHTS + * + * Property type: integer. + */ + const char* AI_CONFIG_PP_LBW_MAX_WEIGHTS = "PP_LBW_MAX_WEIGHTS"; + + /** + * The default value for the AI_CONFIG_PP_LBW_MAX_WEIGHTS setting. + */ + const AI_LMW_MAX_WEIGHTS = 0x4; + + /** + * Sets the size of the post-transform vertex cache to optimize the + * vertices for. This configures the 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. + * + * The default value results in slight performance improvements for most + * nVidia/AMD cards since 2002. + * + * Default value: PP_ICL_PTCACHE_SIZE + * + * Property type: integer. + */ + const char* AI_CONFIG_PP_ICL_PTCACHE_SIZE = "PP_ICL_PTCACHE_SIZE"; + + /** + * The default value for the AI_CONFIG_PP_ICL_PTCACHE_SIZE config option. + */ + const PP_ICL_PTCACHE_SIZE = 12; + + /** + * Components of the aiScene and aiMesh data + * structures that can be excluded from the import by using the + * RemoveComponent step. + * + * See the documentation to RemoveComponent for more details. + */ + enum aiComponent : uint { + /** + * Normal vectors. + */ + NORMALS = 0x2, + + /** + * Tangents and bitangents. + */ + TANGENTS_AND_BITANGENTS = 0x4, + + /** + * All color sets. + * + * Use aiComponent_COLORSn( N ) to specify the N'th set. + */ + COLORS = 0x8, + + /** + * All texture UV coordinate sets. + * + * Use aiComponent_TEXCOORDn( N ) to specify the N'th set. + */ + TEXCOORDS = 0x10, + + /** + * Bone weights from all meshes. + * + * The corresponding scenegraph nodes are not removed. Use the + * OptimizeGraph step to do this. + */ + BONEWEIGHTS = 0x20, + + /** + * Node animations (aiScene.mAnimations). + * + * The corresponding scenegraph nodes are not removed. Use the + * OptimizeGraph step to do this. + */ + ANIMATIONS = 0x40, + + /** + * Embedded textures (aiScene.mTextures). + */ + TEXTURES = 0x80, + + /** + * Light sources (aiScene.mLights). + * + * The corresponding scenegraph nodes are not removed. Use the + * OptimizeGraph step to do this. + */ + LIGHTS = 0x100, + + /** + * Cameras (aiScene.mCameras). + * + * The corresponding scenegraph nodes are not removed. Use the + * OptimizeGraph step to do this. + */ + CAMERAS = 0x200, + + /** + * Meshes (aiScene.mMeshes). + */ + MESHES = 0x400, + + /** Materials. + * + * One default material will be generated, so + * aiScene.mNumMaterials will be 1. + */ + MATERIALS = 0x800 + } + + /** + * Specifies a certain color channel to remove. + */ + uint aiComponent_COLORSn( uint n ) { return 1u << ( n + 20u ); } + + /** + * Specifies a certain UV coordinate channel to remove. + */ + uint aiComponent_TEXCOORDSn( uint n ) { return 1u << ( n + 25u ); } + + /** + * Input parameter to the RemoveComponent step: + * Specifies the parts of the data structure to be removed. + * + * See the documentation to this step for further details. + * + * Default value: 0 + * + * Property type: integer (bitwise combination of aiComponent + * flags). + * + * Note: If no valid mesh is remaining after the step has been executed, the + * import fails, because there is no data to work on anymore. + */ + const char* AI_CONFIG_PP_RVC_FLAGS = "PP_RVC_FLAGS"; + + /** + * Input parameter to the 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. + * + * Default value: 0 + * + * Property type: integer. + */ + const char* AI_CONFIG_PP_SBP_REMOVE = "PP_SBP_REMOVE"; + + + /** + * The TransformUVCoords step evaluates UV scalings. + */ + const AI_UVTRAFO_SCALING = 0x1; + + /** + * The TransformUVCoords step evaluates UV rotations. + */ + const AI_UVTRAFO_ROTATION = 0x2; + + /** + * The TransformUVCoords step evaluates UV translation. + */ + const AI_UVTRAFO_TRANSLATION = 0x4; + + /** + * The TransformUVCoords step evaluates all UV translations. + */ + const AI_UVTRAFO_ALL = + AI_UVTRAFO_SCALING + | AI_UVTRAFO_ROTATION + | AI_UVTRAFO_TRANSLATION; + + /** + * Input parameter to the TransformUVCoords step: Specifies + * which UV transformations are evaluated. + * + * Default value: AI_UVTRAFO_ALL. + * + * Property type: integer (bitwise combination of the + * AI_UVTRAFO_XXX flag). + */ + const char* AI_CONFIG_PP_TUV_EVALUATE = "PP_TUV_EVALUATE"; + + /** + * 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. + * + * Default value: false. + * + * Property type: integer (0: false; !0: true). + */ + const char* AI_CONFIG_FAVOUR_SPEED = "FAVOUR_SPEED"; + + + /* + * Importer settings. + * + * Various stuff to fine-tune the behaviour of a specific importer plugin. + */ + + /** + * 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. + * + * Default value: 0 (first frame). + * + * Property type: integer. + * + * Note: 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). + */ + const char* AI_CONFIG_IMPORT_GLOBAL_KEYFRAME = "IMPORT_GLOBAL_KEYFRAME"; + + const char* AI_CONFIG_IMPORT_MD3_KEYFRAME = "IMPORT_MD3_KEYFRAME"; + const char* AI_CONFIG_IMPORT_MD2_KEYFRAME = "IMPORT_MD2_KEYFRAME"; + const char* AI_CONFIG_IMPORT_MDL_KEYFRAME = "IMPORT_MDL_KEYFRAME"; + const char* AI_CONFIG_IMPORT_MDC_KEYFRAME = "IMPORT_MDC_KEYFRAME"; + const char* AI_CONFIG_IMPORT_SMD_KEYFRAME = "IMPORT_SMD_KEYFRAME"; + const char* AI_CONFIG_IMPORT_UNREAL_KEYFRAME = "IMPORT_UNREAL_KEYFRAME"; + + + /** + * Configures the AC loader to collect all surfaces which have the + * "Backface cull" flag set in separate meshes. + * + * Default value: true. + * + * Property type: integer (0: false; !0: true). + */ + const char* AI_CONFIG_IMPORT_AC_SEPARATE_BFCULL = "IMPORT_AC_SEPARATE_BFCULL"; + + /** + * Configures the UNREAL 3D loader to separate faces with different surface + * flags (e.g. two-sided vs. single-sided). + * + * Default value: true. + * + * Property type: integer (0: false; !0: true). + */ + const char* AI_CONFIG_IMPORT_UNREAL_HANDLE_FLAGS = "UNREAL_HANDLE_FLAGS"; + + /** + * 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. + * + * Default value: false. + * + * Property type: integer (0: false; !0: true). + */ + const char* AI_CONFIG_IMPORT_TER_MAKE_UVS = "IMPORT_TER_MAKE_UVS"; + + /** + * Configures the ASE loader to always reconstruct normal vectors basing on + * the smoothing groups loaded from the file. + * + * Many ASE files have invalid normals (they're not orthonormal). + * + * Default value: true. + * + * Property type: integer (0: false; !0: true). + */ + const char* AI_CONFIG_IMPORT_ASE_RECONSTRUCT_NORMALS = "IMPORT_ASE_RECONSTRUCT_NORMALS"; + + /** + * Configures the M3D loader to process multi-part player models. + * + * These models usually consist of three 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. + * + * Default value: true. + * + * Property type: integer (0: false; !0: true). + */ + const char* AI_CONFIG_IMPORT_MD3_HANDLE_MULTIPART = "IMPORT_MD3_HANDLE_MULTIPART"; + + /** + * Tells the MD3 loader which skin files to load. + * + * When loading MD3 files, Assimp checks whether a file + * _.skin is existing. These files + * are used by Quake 3 to be able to assign different skins (e.g. red and + * blue team) to models. 'default', 'red', 'blue' are typical skin names. + * + * Default value: "default". + * + * Property type: string. + */ + const char* AI_CONFIG_IMPORT_MD3_SKIN_NAME = "IMPORT_MD3_SKIN_NAME"; + + /** + * Specify the Quake 3 shader file to be used for a particular MD3 file. + * This can also be a search path. + * + * By default Assimp's behaviour is as follows: If a MD3 file + * [any_path]/models/[any_q3_subdir]/[model_name]/[file_name].md3 + * is loaded, the library tries to locate the corresponding shader file in + * [any_path]/scripts/[model_name].shader. This property + * overrides this behaviour. It can either specify a full path to the shader + * to be loaded or alternatively the path (relative or absolute) to the + * directory where the shaders for all MD3s to be loaded reside. Assimp + * attempts to open [dir]/[model_name].shader first, + * [dir]/[file_name].shader is the fallback file. Note that + * [dir] should have a terminal (back)slash. + * + * Default value: n/a. + * + * Property type: string. + */ + const char* AI_CONFIG_IMPORT_MD3_SHADER_SRC = "IMPORT_MD3_SHADER_SRC"; + + /** + * Configures the LWO loader to load just one layer from the model. + * + * LWO files consist of layers and in some cases it could be useful to load + * only one of them. This property can be either a string – which specifies + * the name of the layer – or an integer – the index of the layer. If the + * property is not set the whole LWO model is loaded. Loading fails if the + * requested layer is not available. The layer index is zero-based and the + * layer name may not be empty. + * + * Default value: all layers are loaded. + * + * Property type: integer/string. + */ + const char* AI_CONFIG_IMPORT_LWO_ONE_LAYER_ONLY = "IMPORT_LWO_ONE_LAYER_ONLY"; + + /** + * 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. + * + * Default value: false. + * + * Property type: integer (0: false; !0: true). + */ + const char* AI_CONFIG_IMPORT_MD5_NO_ANIM_AUTOLOAD = "IMPORT_MD5_NO_ANIM_AUTOLOAD"; + + /** + * Defines the begin of the time range for which the LWS loader evaluates + * animations and computes aiNodeAnims. + * + * 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). + * + * Default value: read from file. + * + * Property type: integer. + * + * See: AI_CONFIG_IMPORT_LWS_ANIM_END – end of the imported + * time range + */ + const char* AI_CONFIG_IMPORT_LWS_ANIM_START = "IMPORT_LWS_ANIM_START"; + const char* AI_CONFIG_IMPORT_LWS_ANIM_END = "IMPORT_LWS_ANIM_END"; + + /** + * 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. + * + * Default value: 100. + * + * Property type: integer. + */ + const char* AI_CONFIG_IMPORT_IRR_ANIM_FPS = "IMPORT_IRR_ANIM_FPS"; +} \ No newline at end of file diff --git a/port/dAssimp/assimp/fileIO.d b/port/dAssimp/assimp/fileIO.d new file mode 100644 index 000000000..d0ee2ed87 --- /dev/null +++ b/port/dAssimp/assimp/fileIO.d @@ -0,0 +1,140 @@ +/* +--------------------------------------------------------------------------- +Open Asset Import Library (ASSIMP) +--------------------------------------------------------------------------- + +Copyright (c) 2006-2009, ASSIMP Development 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 Development 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. +--------------------------------------------------------------------------- +*/ + +/** + * The data structures necessary to use Assimip with a custom IO system. + */ +module assimp.fileIO; + +import assimp.types; + +extern ( C ) { + // aiFile callbacks + alias size_t function( aiFile*, char*, size_t, size_t ) aiFileWriteProc; + alias size_t function( aiFile*, char*, size_t, size_t ) aiFileReadProc; + alias size_t function( aiFile* ) aiFileTellProc; + alias void function( aiFile* ) aiFileFlushProc; + alias aiReturn function( aiFile*, size_t, aiOrigin ) aiFileSeek; + + // aiFileIO callbacks + alias aiFile* function( aiFileIO*, char*, char* ) aiFileOpenProc; + alias void function( aiFileIO*, aiFile* ) aiFileCloseProc; + + /** + * Represents user-defined data. + */ + alias char* aiUserData; + + /** + * Defines Assimp's way of accessing files. + * + * Provided are functions to open and close files. Supply a custom structure + * to the import function. If you don't, a default implementation is used. + * Use this to enable reading from other sources, such as ZIPs or memory + * locations. + */ + struct aiFileIO { + /** + * Function used to open a new file + */ + aiFileOpenProc OpenProc; + + /** + * Function used to close an existing file + */ + aiFileCloseProc CloseProc; + + /** + * User-defined, opaque data. + */ + aiUserData UserData; + } + + /** + * Represents a read/write file. + * + * Actually, it's a data structure to wrap a set of fXXXX + * (e.g fopen()) replacement functions. + * + * The default implementation of the functions utilizes the fXXX + * functions from the CRT. However, you can supply a custom implementation + * to Assimp by passing a custom aiFileIO. Use this to enable + * reading from other sources such as ZIP archives or memory locations. + */ + struct aiFile { + /** + * Callback to read from a file. + */ + aiFileReadProc ReadProc; + + /** + * Callback to write to a file. + */ + aiFileWriteProc WriteProc; + + /** + * Callback to retrieve the current position of the file cursor + * (ftell()). + */ + aiFileTellProc TellProc; + + /** + * Callback to retrieve the size of the file, in bytes. + */ + aiFileTellProc FileSizeProc; + + /** + * Callback to set the current position of the file cursor + * (fseek()). + */ + aiFileSeek SeekProc; + + /** + * Callback to flush the file contents. + */ + aiFileFlushProc FlushProc; + + /** + * User-defined, opaque data. + */ + aiUserData UserData; + } +} diff --git a/port/dAssimp/assimp/light.d b/port/dAssimp/assimp/light.d new file mode 100644 index 000000000..8d782396d --- /dev/null +++ b/port/dAssimp/assimp/light.d @@ -0,0 +1,215 @@ +/* +--------------------------------------------------------------------------- +Open Asset Import Library (ASSIMP) +--------------------------------------------------------------------------- + +Copyright (c) 2006-2009, ASSIMP Development 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 Development 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. +--------------------------------------------------------------------------- +*/ + +/** + * Contains the data structures which are used to store the imported information + * about the light sources in the scene. + */ +module assimp.light; + +import assimp.math; +import assimp.types; + +extern ( C ) { + /** + * Enumerates all supported types of light sources. + */ + enum aiLightSourceType : uint { + UNDEFINED = 0x0, + + /** + * A directional light source 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 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 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 + } + + /** + * Helper structure to describe a light source. + * + * 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. + */ + struct aiLight { + /** + * 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 scenehierarchy and can be + * animated. + */ + aiString mName; + + /** + * The type of the light source. + * + * aiLightSource.UNDEFINED is not a valid value for this + * member. + */ + aiLightSourceType mType; + + /** + * Position of the light source in space. Relative to the transformation + * of the node corresponding to the light. + * + * The position is undefined for directional lights. + */ + aiVector3D mPosition; + + /** + * Direction of the light source in space. Relative to the transformation + * of the node corresponding to the light. + * + * The direction is undefined for point lights. The vector may be + * normalized, but it needn't. + */ + aiVector3D mDirection; + + /** + * Constant light attenuation factor. + * + * The intensity of the light source at a given distance + * d from the light's position is + * 1/( att0 + att1 * d + att2 * d * d ). This member + * corresponds to the att0 variable in the equation. + * + * Naturally undefined for directional lights. + */ + float mAttenuationConstant; + + /** + * Linear light attenuation factor. + * + * The intensity of the light source at a given distance + * d from the light's position is + * 1/( att0 + att1 * d + att2 * d * d ). This member + * corresponds to the att1 variable in the equation. + * + * Naturally undefined for directional lights. + */ + float mAttenuationLinear; + + /** + * Quadratic light attenuation factor. + * + * The intensity of the light source at a given distance + * d from the light's position is + * 1/( att0 + att1 * d + att2 * d * d ). This member + * corresponds to the att2 variable in the equation. + * + * Naturally undefined for directional lights. + */ + float mAttenuationQuadratic; + + /** + * Diffuse color of the light source + * + * The diffuse light color is multiplied with the diffuse material color + * to obtain the final color that contributes to the diffuse shading term. + */ + aiColor3D mColorDiffuse; + + /** + * Specular color of the light source + * + * The specular light color is multiplied with the specular material + * color to obtain the final color that contributes to the specular + * shading term. + */ + aiColor3D mColorSpecular; + + /** + * Ambient color of the light source + * + * 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. + */ + aiColor3D mColorAmbient; + + /** + * Inner angle of a spot light's light cone. + * + * 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. + */ + float mAngleInnerCone; + + /** + * 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. + */ + float mAngleOuterCone; + } +} diff --git a/port/dAssimp/assimp/loader.d b/port/dAssimp/assimp/loader.d new file mode 100644 index 000000000..22d1a4c15 --- /dev/null +++ b/port/dAssimp/assimp/loader.d @@ -0,0 +1,203 @@ +/* +--------------------------------------------------------------------------- +Open Asset Import Library (ASSIMP) +--------------------------------------------------------------------------- + +Copyright (c) 2006-2009, ASSIMP Development 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 Development 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. +--------------------------------------------------------------------------- +*/ + +/** + * Provides facilities for dynamically loading the Assimp library. + * + * Currently requires Tango, but there is no reason why Phobos could not be + * supported too. + */ +module assimp.loader; + +import assimp.api; +import tango.io.Stdout; +import tango.sys.SharedLib; + +const uint ASSIMP_BINDINGS_MAJOR = 0; +const uint ASSIMP_BINDINGS_MINOR = 5; + +/** + * Loader class for dynamically loading the Assimp library. + * + * The library is »reference-counted«, meaning that the library is not + * unloaded on a call to unload() if there are still other + * references to it. + */ +struct Assimp { +public: + /** + * Loads the library if it is not already loaded and increases the + * reference counter. + * + * The library file (libassimp.so on POSIX systems, + * Assimp32.dll on Win32) is loaded via Tango's SharedLib + * class. + */ + static void load() { + if ( m_sRefCount == 0 ) { + version ( Posix ) { + m_sLibrary = SharedLib.load( "libassimp.so" ); + } + version ( Win32 ) { + m_sLibrary = SharedLib.load( "Assimp32.dll" ); + } + + // Versioning + bind( aiGetLegalString )( "aiGetLegalString" ); + bind( aiGetVersionMinor )( "aiGetVersionMinor" ); + bind( aiGetVersionMajor )( "aiGetVersionMajor" ); + bind( aiGetVersionRevision )( "aiGetVersionRevision" ); + bind( aiGetCompileFlags )( "aiGetCompileFlags" ); + + // Check for version mismatch between the external, dynamically loaded + // library and the version the bindings were created against. + uint libMajor = aiGetVersionMajor(); + uint libMinor = aiGetVersionMinor(); + + if ( ( libMajor < ASSIMP_BINDINGS_MAJOR ) || + ( libMinor < ASSIMP_BINDINGS_MINOR ) ) { + Stdout.format( + "WARNING: Assimp version too old (loaded library: {}.{}, " ~ + "bindings: {}.{})!", + libMajor, + libMinor, + ASSIMP_BINDINGS_MAJOR, + ASSIMP_BINDINGS_MINOR + ).newline; + } + + if ( libMajor > ASSIMP_BINDINGS_MAJOR ) { + Stdout.format( + "WARNING: Assimp version too new (loaded library: {}.{}, " ~ + "bindings: {}.{})!", + libMajor, + libMinor, + ASSIMP_BINDINGS_MAJOR, + ASSIMP_BINDINGS_MINOR + ).newline; + } + + // General API + bind( aiImportFile )( "aiImportFile" ); + bind( aiImportFileEx )( "aiImportFileEx" ); + bind( aiImportFileFromMemory )( "aiImportFileFromMemory" ); + bind( aiApplyPostProcessing )( "aiApplyPostProcessing" ); + bind( aiGetPredefinedLogStream )( "aiGetPredefinedLogStream" ); + bind( aiAttachLogStream )( "aiAttachLogStream" ); + bind( aiEnableVerboseLogging )( "aiEnableVerboseLogging" ); + bind( aiDetachLogStream )( "aiDetachLogStream" ); + bind( aiDetachAllLogStreams )( "aiDetachAllLogStreams" ); + bind( aiReleaseImport )( "aiReleaseImport" ); + bind( aiGetErrorString )( "aiGetErrorString" ); + bind( aiIsExtensionSupported )( "aiIsExtensionSupported" ); + bind( aiGetExtensionList )( "aiGetExtensionList" ); + bind( aiGetMemoryRequirements )( "aiGetMemoryRequirements" ); + bind( aiSetImportPropertyInteger )( "aiSetImportPropertyInteger" ); + bind( aiSetImportPropertyFloat )( "aiSetImportPropertyFloat" ); + bind( aiSetImportPropertyString )( "aiSetImportPropertyString" ); + + // Mathematical functions + bind( aiCreateQuaternionFromMatrix )( "aiCreateQuaternionFromMatrix" ); + bind( aiDecomposeMatrix )( "aiDecomposeMatrix" ); + bind( aiTransposeMatrix4 )( "aiTransposeMatrix4" ); + bind( aiTransposeMatrix3 )( "aiTransposeMatrix3" ); + bind( aiTransformVecByMatrix3 )( "aiTransformVecByMatrix3" ); + bind( aiTransformVecByMatrix4 )( "aiTransformVecByMatrix4" ); + bind( aiMultiplyMatrix4 )( "aiMultiplyMatrix4" ); + bind( aiMultiplyMatrix3 )( "aiMultiplyMatrix3" ); + bind( aiIdentityMatrix3 )( "aiIdentityMatrix3" ); + bind( aiIdentityMatrix4 )( "aiIdentityMatrix4" ); + + // Material system + //bind( aiGetMaterialProperty )( "aiGetMaterialProperty" ); + bind( aiGetMaterialFloatArray )( "aiGetMaterialFloatArray" ); + bind( aiGetMaterialIntegerArray )( "aiGetMaterialIntegerArray" ); + bind( aiGetMaterialColor )( "aiGetMaterialColor" ); + bind( aiGetMaterialString )( "aiGetMaterialString" ); + bind( aiGetMaterialTexture )( "aiGetMaterialTexture" ); + } + ++m_sRefCount; + } + + /** + * Decreases the reference counter and unloads the library if this was the + * last reference. + */ + static void unload() { + assert( m_sRefCount > 0 ); + --m_sRefCount; + + if ( m_sRefCount == 0 ) { + m_sLibrary.unload(); + } + } + +private: + // The binding magic is heavily inspired by the Derelict loading code. + struct Binder { + public: + static Binder opCall( void** functionPointerAddress ) { + Binder binder; + binder.m_functionPointerAddress = functionPointerAddress; + return binder; + } + + void opCall( char* name ) { + *m_functionPointerAddress = m_sLibrary.getSymbol( name ); + } + + private: + void** m_functionPointerAddress; + } + + template bind( Function ) { + static Binder bind( inout Function a ) { + Binder binder = Binder( cast( void** ) &a ); + return binder; + } + } + + /// Current number of references to the library. + static uint m_sRefCount; + + /// Library handle. + static SharedLib m_sLibrary; +} diff --git a/port/dAssimp/assimp/material.d b/port/dAssimp/assimp/material.d new file mode 100644 index 000000000..8927fb8b6 --- /dev/null +++ b/port/dAssimp/assimp/material.d @@ -0,0 +1,640 @@ +/* +--------------------------------------------------------------------------- +Open Asset Import Library (ASSIMP) +--------------------------------------------------------------------------- + +Copyright (c) 2006-2009, ASSIMP Development 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 Development 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. +--------------------------------------------------------------------------- +*/ + +/** + * Contains the material system which stores the imported material information. + */ +module assimp.material; + +import assimp.math; +import assimp.types; + +extern ( C ) { + /** + * Default material names for meshes without UV coordinates. + */ + const char* AI_DEFAULT_MATERIAL_NAME = "aiDefaultMat"; + + /** + * Default material names for meshes with UV coordinates. + */ + const char* AI_DEFAULT_TEXTURED_MATERIAL_NAME = "TexturedDefaultMaterial"; + + /** + * Defines how the Nth texture of a specific type is combined with the + * result of all previous layers. + * + * Example (left: key, right: value): + * 
 DiffColor0     - gray
+    * DiffTextureOp0 - aiTextureOpMultiply
+    * DiffTexture0   - tex1.png
+    * DiffTextureOp0 - aiTextureOpAdd
+    * DiffTexture1   - tex2.png
+ * Written as equation, the final diffuse term for a specific pixel would be: + * 
diffFinal = DiffColor0 * sampleTex( DiffTexture0, UV0 ) +
+    *     sampleTex( DiffTexture1, UV0 ) * diffContrib;
+ * where diffContrib is the intensity of the incoming light for + * that pixel. + */ + enum aiTextureOp : uint { + /** + * 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 ) + */ + SmoothAdd = 0x4, + + /** + * T = T1 + ( T2 - 0.5 ) + */ + SignedAdd = 0x5 + } + + /** + * Defines how UV coordinates outside the [0..1] range are + * handled. + * + * Commonly refered to as 'wrapping mode'. + */ + enum aiTextureMapMode : uint { + /** + * A texture coordinate u | v is translated to + * (u%1) | (v%1). + */ + Wrap = 0x0, + + /** + * Texture coordinates are clamped to the nearest valid value. + */ + Clamp = 0x1, + + /** + * If the texture coordinates for a pixel are outside + * [0..1], the texture is not applied to that pixel. + */ + Decal = 0x3, + + /** + * 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 + } + + /** + * Defines how the mapping coords for a texture are generated. + * + * Real-time applications typically require full UV coordinates, so the use of + * the aiProcess.GenUVCoords 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. See the AI_MATKEY_MAPPING property for more details. + */ + enum aiTextureMapping : uint { + /** + * The mapping coordinates are taken from an UV channel. + * + * The AI_MATKEY_UVSRC key specifies from which (remember, + * meshes can have more than one UV channel). + */ + UV = 0x0, + + /** + * Spherical mapping. + */ + SPHERE = 0x1, + + /** + * Cylindrical mapping. + */ + CYLINDER = 0x2, + + /** + * Cubic mapping. + */ + BOX = 0x3, + + /** + * Planar mapping. + */ + PLANE = 0x4, + + /** + * Undefined mapping. + */ + OTHER = 0x5 + } + + /** + * 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. + */ + enum aiTextureType : uint { + /** + * No texture, but the value to be used for + * aiMaterialProperty.mSemantic for all material properties + * not related to textures. + */ + NONE = 0x0, + + /** + * 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 grey-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 differenciate 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. + */ + SHININESS = 0x7, + + /** + * The texture defines per-pixel opacity. + * + * Usually white means opaque and black means transparent. + */ + OPACITY = 0x8, + + /** + * Displacement texture. + * + * The exact purpose and format is application-dependent. Higher color + * values stand for higher vertex displacements. + */ + DISPLACEMENT = 0x9, + + /** + * Lightmap or ambient occlusion texture. + * + * 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 + } + + /** + * Defines all shading models supported by the library + * + * 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. + */ + enum aiShadingMode : uint { + /** + * 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, + + /** + * Per-pixel toon shading. + * + * Often referred to as »comic shading«. + */ + Toon = 0x5, + + /** + * Per-pixel Oren-Nayar shading. + * + * Extension to standard Lambertian shading, taking the roughness of the + * material into account. + */ + OrenNayar = 0x6, + + /** + * Per-pixel Minnaert shading. + * + * Extension to standard Lambertian shading, taking the "darkness" of the + * material into account. + */ + Minnaert = 0x7, + + /** + * Per-pixel Cook-Torrance shading. + * + * Special shader for metallic surfaces. + */ + CookTorrance = 0x8, + + /** + * No shading at all. + * + * Constant light influence of 1. + */ + NoShading = 0x9, + + /** + * Fresnel shading. + */ + Fresnel = 0xa + } + + /** + * Defines some mixed flags for a particular texture. + * + * Usually you'll instruct your cg artists how textures have to look like + * and how they will be processed in your application. However, if you use + * Assimp for completely generic loading purposes you might also need to + * process these flags in order to display as many 'unknown' 3D models as + * possible correctly. + * + * This corresponds to the AI_MATKEY_TEXFLAGS property. + */ + enum aiTextureFlags : uint { + /** + * The texture's color values have to be inverted (i.e. 1-n + * component-wise). + */ + Invert = 0x1, + + /** + * Explicit request to the application to process the alpha channel of the + * texture. + * + * Mutually exclusive with IgnoreAlpha. These flags are + * set if the library can say for sure that the alpha channel is used/is + * not used. If the model format does not define this, it is left to the + * application to decide whether the texture alpha channel – if any – is + * evaluated or not. + */ + UseAlpha = 0x2, + + /** + * Explicit request to the application to ignore the alpha channel of the + * texture. + * + * Mutually exclusive with UseAlpha. + */ + IgnoreAlpha = 0x4 + } + + + /** + * Defines alpha-blend flags. + * + * 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, based on + * the previous color at that pixel and the new color value from the + * material. + * + * The basic blending formula is + * 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. + * + * This corresponds to the AI_MATKEY_BLEND_FUNC property. + */ + enum aiBlendMode :uint { + /** + * Formula: + * SourceColor * SourceAlpha + DestColor * (1 - SourceAlpha) + */ + Default = 0x0, + + /** + * Additive blending. + * + * Formula: SourceColor*1 + DestColor*1 + */ + Additive = 0x1 + } + + /** + * Defines how an UV channel is transformed. + * + * This is just a helper structure for the AI_MATKEY_UVTRANSFORM + * key. See its documentation for more details. + */ + struct aiUVTransform { + align ( 1 ) : + /** + * Translation on the u and v axes. + * + * The default value is (0|0). + */ + aiVector2D mTranslation; + + /** + * Scaling on the u and v axes. + * + * The default value is (1|1). + */ + aiVector2D mScaling; + + /** + * Rotation - in counter-clockwise direction. + * + * The rotation angle is specified in radians. The rotation center is + * 0.5|0.5. The default value is 0. + */ + float mRotation; + } + + /** + * A very primitive RTTI system to store the data type of a material + * property. + */ + enum aiPropertyTypeInfo : uint { + /** + * Array of single-precision (32 bit) floats. + * + * It is possible to use aiGetMaterialInteger[Array]() to + * query properties stored in floating-point format. The material system + * performs the type conversion automatically. + */ + Float = 0x1, + + /** + * aiString property. + * + * Arrays of strings aren't possible, aiGetMaterialString() + * must be used to query a string property. + */ + String = 0x3, + + /** + * Array of (32 bit) integers. + * + * It is possible to use aiGetMaterialFloat[Array]() to + * query properties stored in integer format. The material system + * performs the type conversion automatically. + */ + Integer = 0x4, + + /** + * Simple binary buffer, content undefined. Not convertible to anything. + */ + Buffer = 0x5 + } + + /** + * 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 aiGetMaterialXXX() functions to query + * material properties easily. Processing them manually is faster, but it is + * not the recommended way. It isn't worth the effort. + * + * Material property names follow a simple scheme: + * + * $[name]: A public property, there must be a corresponding + * AI_MATKEY_XXX constant. + * + * ?[name]: Also public, but ignored by the + * aiProcess.RemoveRedundantMaterials post-processing step. + * + * ~[name]: A temporary property for internal use. + */ + struct aiMaterialProperty { + /** + * Specifies the name of the property (key). + * + * Keys are generally case insensitive. + */ + aiString mKey; + + /** + * For texture properties, this specifies the exact usage semantic. + * + * For non-texture properties, this member is always 0 (or rather + * aiTextureType.NONE). + */ + uint mSemantic; + + /** + * For texture properties, this specifies the index of the texture. + * + * For non-texture properties, this member is always 0. + */ + uint mIndex; + + /** + * Size of the buffer mData is pointing to (in bytes). + * + * This value may not be 0. + */ + uint mDataLength; + + /** + * 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. + */ + aiPropertyTypeInfo mType; + + /** + * Binary buffer to hold the property's value. + * + * The size of the buffer is always mDataLength. + */ + char* mData; + } + + /** + * Data structure for a material + * + * Material data is stored using a key-value structure. A single key-value + * pair is called a material property. The properties can be + * queried using the aiMaterialGetXXX family of functions. The + * library defines a set of standard keys (AI_MATKEY_XXX). + */ + struct aiMaterial { + /** + * List of all material properties loaded. + */ + aiMaterialProperty** mProperties; + + /** + * Number of properties loaded. + */ + uint mNumProperties; + uint mNumAllocated; /// ditto + } + + /** + * Standard material property keys. Always pass 0 for texture type and index + * when querying these keys. + */ + const char* AI_MATKEY_NAME = "?mat.name"; + const char* AI_MATKEY_TWOSIDED = "$mat.twosided"; /// ditto + const char* AI_MATKEY_SHADING_MODEL = "$mat.shadingm"; /// ditto + const char* AI_MATKEY_ENABLE_WIREFRAME = "$mat.wireframe"; /// ditto + const char* AI_MATKEY_BLEND_FUNC = "$mat.blend"; /// ditto + const char* AI_MATKEY_OPACITY = "$mat.opacity"; /// ditto + const char* AI_MATKEY_BUMPSCALING = "$mat.bumpscaling"; /// ditto + const char* AI_MATKEY_SHININESS = "$mat.shininess"; /// ditto + const char* AI_MATKEY_SHININESS_STRENGTH = "$mat.shinpercent"; /// ditto + const char* AI_MATKEY_REFRACTI = "$mat.refracti"; /// ditto + const char* AI_MATKEY_COLOR_DIFFUSE = "$clr.diffuse"; /// ditto + const char* AI_MATKEY_COLOR_AMBIENT = "$clr.ambient"; /// ditto + const char* AI_MATKEY_COLOR_SPECULAR = "$clr.specular"; /// ditto + const char* AI_MATKEY_COLOR_EMISSIVE = "$clr.emissive"; /// ditto + const char* AI_MATKEY_COLOR_TRANSPARENT = "$clr.transparent"; /// ditto + const char* AI_MATKEY_COLOR_REFLECTIVE = "$clr.reflective"; /// ditto + const char* AI_MATKEY_GLOBAL_BACKGROUND_IMAGE = "?bg.global"; /// ditto + + /** + * Texture material property keys. Do not forget to specify texture type and + * index for these keys. + */ + const char* AI_MATKEY_TEXTURE = "$tex.file"; + const char* AI_MATKEY_UVWSRC = "$tex.uvwsrc"; /// ditto + const char* AI_MATKEY_TEXOP = "$tex.op"; /// ditto + const char* AI_MATKEY_MAPPING = "$tex.mapping"; /// ditto + const char* AI_MATKEY_TEXBLEND = "$tex.blend"; /// ditto + const char* AI_MATKEY_MAPPINGMODE_U = "$tex.mapmodeu"; /// ditto + const char* AI_MATKEY_MAPPINGMODE_V = "$tex.mapmodev"; /// ditto + const char* AI_MATKEY_TEXMAP_AXIS = "$tex.mapaxis"; /// ditto + const char* AI_MATKEY_UVTRANSFORM = "$tex.uvtrafo"; /// ditto + const char* AI_MATKEY_TEXFLAGS = "$tex.flags"; /// ditto +} diff --git a/port/dAssimp/assimp/math.d b/port/dAssimp/assimp/math.d new file mode 100644 index 000000000..f63d8e23a --- /dev/null +++ b/port/dAssimp/assimp/math.d @@ -0,0 +1,155 @@ +/* +--------------------------------------------------------------------------- +Open Asset Import Library (ASSIMP) +--------------------------------------------------------------------------- + +Copyright (c) 2006-2009, ASSIMP Development 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 Development 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. +--------------------------------------------------------------------------- +*/ + +/** + * Mathematical structures in which the imported data is stored. + */ +module assimp.math; + +extern( C ) { + /** + * Represents a two-dimensional vector. + */ + struct aiVector2D { + align ( 1 ): + float x, y; + } + + /** + * Represents a three-dimensional vector. + */ + struct aiVector3D { + align ( 1 ): + float x, y, z; + } + + /** + * Represents a quaternion. + */ + struct aiQuaternion { + float w, x, y, z; + } + + /** + * Represents a row-major 3x3 matrix + * + * There is much confusion about matrix layouts (colum vs. row order). This + * is always a row-major matrix, even when using the + * ConvertToLeftHanded post processing step. + */ + struct aiMatrix3x3 { + float a1, a2, a3; + float b1, b2, b3; + float c1, c2, c3; + } + + /** + * Represents a row-major 3x3 matrix + * + * There is much confusion about matrix layouts (colum vs. row order). This + * is always a row-major matrix, even when using the + * ConvertToLeftHanded post processing step. + */ + struct aiMatrix4x4 { + align ( 1 ): + float a1, a2, a3, a4; + float b1, b2, b3, b4; + float c1, c2, c3, c4; + float d1, d2, d3, d4; + } + + /** + * Represents a plane in a three-dimensional, euclidean space + */ + struct aiPlane { + align ( 1 ): + /** + * Coefficients of the plane equation (ax + by + cz = d). + */ + float a; + float b; /// ditto + float c; /// ditto + float d; /// ditto + } + + /** + * Represents a ray. + */ + struct aiRay { + align ( 1 ): + /** + * Origin of the ray. + */ + aiVector3D pos; + + /** + * Direction of the ray. + */ + aiVector3D dir; + } + + /** + * Represents a color in RGB space. + */ + struct aiColor3D { + align ( 1 ): + /** + * Red, green and blue values. + */ + float r; + float g; /// ditto + float b; /// ditto + } + + /** + * Represents a color in RGB space including an alpha component. + */ + struct aiColor4D { + align ( 1 ): + /** + * Red, green, blue and alpha values. + */ + float r; + float g; /// ditto + float b; /// ditto + float a; /// ditto + } +} diff --git a/port/dAssimp/assimp/mesh.d b/port/dAssimp/assimp/mesh.d new file mode 100644 index 000000000..d8db0e664 --- /dev/null +++ b/port/dAssimp/assimp/mesh.d @@ -0,0 +1,367 @@ +/* +--------------------------------------------------------------------------- +Open Asset Import Library (ASSIMP) +--------------------------------------------------------------------------- + +Copyright (c) 2006-2009, ASSIMP Development 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 Development 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. +--------------------------------------------------------------------------- +*/ + +/** + * Contains the data structures in which the imported geometry is returned by + * Assimp. + */ +module assimp.mesh; + +import assimp.math; +import assimp.types; + +extern ( C ) { + /** + * A single face in a mesh, referring to multiple vertices. + * + * If mNumIndices is 3, we call the face triangle, for + * for mNumIndices > 3 it's called polygon. + * + * aiMesh.mPrimitiveTypes can be queried to quickly examine + * which types of primitive are actually present in a mesh. The + * aiProcess.SortByPType flag post-processing step splits + * meshes containing different primitive types (e.g. lines and triangles) in + * several "clean" submeshes. + * + * Furthermore, there is a configuration option + * (AI_CONFIG_PP_SBP_REMOVE) to force SortByPType + * to completely remove specific kinds of primitives from the imported scene. + * In many cases you'll probably want to set this setting to + * aiPrimitiveType.LINE | aiPrimitiveType.POINT. Together with + * the aiProcess.Triangulate flag you can then be sure that + * mNumIndices is always 3. + */ + struct aiFace { + /** + * Number of indices defining this face (3 for a triangle, >3 for a + * polygon). + */ + uint mNumIndices; + + /** + * Array of the indicies defining the face. + * + * The size is given in mNumIndices. + */ + uint* mIndices; + } + + /** + * A single influence of a bone on a vertex. + */ + struct aiVertexWeight { + /** + * Index of the vertex which is influenced by the bone. + */ + uint mVertexId; + + /** + * The strength of the influence in the range [0..1]. + * + * The influence from all bones at one vertex sums up to 1. + */ + float mWeight; + } + + /** + * 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. + */ + struct aiBone { + /** + * The name of the bone. + */ + aiString mName; + + /** + * The number of vertices affected by this bone. + */ + uint mNumWeights; + + /** + * The vertices affected by this bone. + * + * This array is mNumWeights entries in size. + */ + aiVertexWeight* mWeights; + + /** + * Matrix that transforms from mesh space to bone space (in the bind + * pose). + */ + aiMatrix4x4 mOffsetMatrix; + } + + /** + * Maximum number of vertex color sets per mesh. + * + * Normally: Diffuse, specular, ambient and emissive. However, one could use + * the vertex color sets for any other purpose, too. + * + * Note: Some internal structures expect (and assert) this value to be at + * least 4. For the moment it is absolutely safe to assume that this will + * not change. + */ + const uint AI_MAX_NUMBER_OF_COLOR_SETS = 0x4; + + /** + * Maximum number of texture coord sets (UV(W) channels) per mesh + * + * The material system uses the AI_MATKEY_UVWSRC_XXX keys to + * specify which UVW channel serves as data source for a texture. + * + * Note: Some internal structures expect (and assert) this value to be at + * least 4. For the moment it is absolutely safe to assume that this will + * not change. + */ + const uint AI_MAX_NUMBER_OF_TEXTURECOORDS = 0x4; + + /** + * Enumerates the types of geometric primitives supported by Assimp. + * + * See: aiFace, aiProcess.SortByPType, + * aiProcess.Triangulate, + * AI_CONFIG_PP_SBP_REMOVE. + */ + enum aiPrimitiveType : uint { + /** A point primitive. + * + * This is just a single vertex in the virtual world, + * aiFace contains just one index for such a primitive. + */ + POINT = 0x1, + + /** A line primitive. + * + * This is a line defined through a start and an end position. + * aiFace contains exactly two indices for such a primitive. + */ + LINE = 0x2, + + /** A triangular primitive. + * + * A triangle consists of three indices. + */ + TRIANGLE = 0x4, + + /** A higher-level polygon with more than 3 edges. + * + * A triangle is a polygon, but in this context, polygon means + * "all polygons that are not triangles". The Triangulate + * post processing step is provided for your convinience, it splits all + * polygons in triangles (which are much easier to handle). + */ + POLYGON = 0x8 + } + + // Note: The AI_PRIMITIVE_TYPE_FOR_N_INDICES(n) macro from the C headers is + // missing since there is probably not much use for it when just reading + // scene files. + + /** + * A mesh represents a geometry or model with a single material. + * + * It usually consists of a number of vertices and a series + * primitives/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 + * coords or a normal vector. If a data pointer is non-null, the + * corresponding data stream is present. + * + * A mesh uses only a single material which is referenced by a material ID. + * + * Note: The mPositions member is usually not optional. + * However, vertex positions could be missing if the + * AI_SCENE_FLAGS_INCOMPLETE flag is set in + * aiScene.mFlags. + */ + struct aiMesh { + /** + * Bitwise combination of aiPrimitiveType members. + * + * This specifies which types of primitives are present in the mesh. + * The SortByPrimitiveType post processing step can be used + * to make sure the output meshes consist of one primitive type each. + */ + uint mPrimitiveTypes; + + /** + * The number of vertices in this mesh. + * + * This is also the size of all of the per-vertex data arrays. + */ + uint mNumVertices; + + /** + * The number of primitives (triangles, polygons, lines) in this mesh. + * This is also the size of the mFaces array. + */ + uint mNumFaces; + + /** + * Vertex positions. + * + * This array is always present in a mesh. The array is + * mNumVertices in size. + */ + aiVector3D* mVertices; + + /** + * Vertex normals. + * + * The array contains normalized vectors, null if not present. + * The array is mNumVertices in size. + * + * Normals are undefined for point and line primitives. A mesh + * consisting of points and lines only may not have normal vectors. + * Meshes with mixed primitive types (i.e. lines and triangles) may have + * normals, but the normals for vertices that are only referenced by + * point or line primitives are undefined and set to QNAN. + * + * Note: Normal vectors computed by Assimp are always unit-length. + * However, this needn't apply for normals that have been taken + * directly from the model file. + */ + aiVector3D* mNormals; + + /** + * Vertex tangents. + * + * The tangent of a vertex points in the direction of the positive x + * texture axis. The array contains normalized vectors, null if + * not present. The array is mNumVertices in size. + * + * A mesh consisting of points and lines only may not have normal + * vectors. Meshes with mixed primitive types (i.e. lines and triangles) + * may have normals, but the normals for vertices that are only + * referenced by point or line primitives are undefined and set to + * QNAN. + * + * Note: If the mesh contains tangents, it automatically also contains + * bitangents (the bitangent is just the cross product of tangent and + * normal vectors). + */ + aiVector3D* mTangents; + + /** + * Vertex bitangents. + * + * The bitangent of a vertex points in the direction of the positive Y + * texture axis. The array contains normalized vectors, null if not + * present. The array is mNumVertices in size. + * + * Note: If the mesh contains tangents, it automatically also contains + * bitangents. + */ + aiVector3D* mBitangents; + + /** + * Vertex color sets. + * + * A mesh may contain 0 to AI_MAX_NUMBER_OF_COLOR_SETS + * vertex colors per vertex. null if not present. + * + * Each array is mNumVertices in size if present. + */ + aiColor4D* mColors[ AI_MAX_NUMBER_OF_COLOR_SETS ]; + + /** + * Vertex texture coords, also known as UV channels. + * A mesh may contain 0 to AI_MAX_NUMBER_OF_TEXTURECOORDS + * per vertex. null if not present. + * + * Each array is mNumVertices in size. + */ + aiVector3D* mTextureCoords[ AI_MAX_NUMBER_OF_TEXTURECOORDS ]; + + /** + * Specifies the number of components for a given UV channel. + * + * Up to three channels are supported (UVW, for accessing volume or cube + * maps). If the value is 2 for a given channel n, the + * component p.z of mTextureCoords[n][p] is set + * to 0. If the value is 1 for a given channel, p.y is set + * to 0, too. If this value is 0, 2 should be assumed. + * + * Note: 4D coords are not supported. + */ + uint mNumUVComponents[ AI_MAX_NUMBER_OF_TEXTURECOORDS ]; + + /** + * The faces the mesh is contstructed from. + * + * Each face referrs to a number of vertices by their indices. + * This array is always present in a mesh, its size is given + * in mNumFaces. If the + * AI_SCENE_FLAGS_NON_VERBOSE_FORMAT is not set, + * each face references an unique set of vertices. + */ + aiFace* mFaces; + + /** + * The number of bones this mesh contains. + * + * Can be 0, in which case the mBones array is null. + */ + uint mNumBones; + + /** + * The bones of this mesh. + * + * A bone consists of a name by which it can be found in the frame + * hierarchy and a set of vertex weights. + */ + aiBone** mBones; + + /** + * 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. + */ + uint mMaterialIndex; + } +} diff --git a/port/dAssimp/assimp/postprocess.d b/port/dAssimp/assimp/postprocess.d new file mode 100644 index 000000000..377d5b934 --- /dev/null +++ b/port/dAssimp/assimp/postprocess.d @@ -0,0 +1,588 @@ +/* +--------------------------------------------------------------------------- +Open Asset Import Library (ASSIMP) +--------------------------------------------------------------------------- + +Copyright (c) 2006-2009, ASSIMP Development 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 Development 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. +--------------------------------------------------------------------------- +*/ + +/** + * Definitions for import post processing steps. + */ +module assimp.postprocess; + +extern ( C ) { + /** + * Defines the flags for all possible post processing steps. + * + * See: aiImportFile, aiImportFileEx + */ + 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 is 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 will want to use the default value. + */ + CalcTangentSpace = 0x1, + + /** + * Identifies and joins identical vertex data sets within all imported + * meshes. + * + * After this step is run each mesh does contain only unique vertices + * anymore, so a vertex is possibly 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 will 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. + */ + JoinIdenticalVertices = 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 for example OpenGL prefers. In this space, +X points to the + * right, +Z points towards the viewer and 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 will 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. + */ + MakeLeftHanded = 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 all higher faces to triangles. + * Line and point primitives are not modified!. + * + * If you want »triangles only« with no other kinds of primitives, + * specify both Triangulate and SortByPType and + * ignore all point and line meshes when you process Assimp's output. + */ + Triangulate = 0x8, + + /** + * Removes some parts of the data structure (animations, materials, light + * sources, cameras, textures, vertex components). + * + * 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. Especially vertex + * colors are rarely used today. + * + * Calling this step to remove unrequired stuff from the pipeline as + * early as possible results in an increased performance and a better + * optimized output data structure. + * + * This step is also useful if you want to force Assimp to recompute + * normals or tangents since the corresponding steps don't recompute them + * if they have already been loaded from the source asset. + * + * 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, it has per-face vertex colors. Because of the vertex + * colors (which are not even used by most apps), + * JoinIdenticalVertices cannot join vertices at the same + * position. By using this step, unneeded components are excluded as + * early as possible thus opening more room for internal optimzations. + */ + RemoveComponent = 0x10, + + /** + * Generates normals for all faces of all meshes. + * + * This is ignored if normals are already there at the time where this + * flag is evaluated. Model importers try to load them from the source + * file, so they are usually already there. Face normals are shared + * between all points of a single face, so a single point can have + * multiple normals, which, in other words, enforces the library to + * duplicate vertices in some cases. JoinIdenticalVertices + * is useless then. + * + * This flag may not be specified together with + * GenSmoothNormals. + */ + GenNormals = 0x20, + + /** + * Generates smooth normals for all vertices in the mesh. + * + * This is ignored if normals are already there at the time where this + * flag is evaluated. Model importers try to load them from the source file, so + * they are usually already there. + * + * There is 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°) results in + * very good visual appearance. + */ + GenSmoothNormals = 0x40, + + /** + * Splits large meshes into smaller submeshes. + * + * This is quite useful for realtime rendering where the number of triangles + * which can be maximally processed in a single draw-call is usually 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 not if + * there's nothing to split. The use of this step is recommended for most + * users. + */ + SplitLargeMeshes = 0x80, + + /** + * Removes the node graph and pre-transforms all vertices with the local + * transformation matrices of their nodes. + * + * The output scene does still contain nodes, however, there is only a + * root node with children, each one referencing only one mesh, 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 that have no 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 will be zeroed. + */ + PreTransformVertices = 0x100, + + /** + * Limits the number of bones simultaneously affecting a single vertex to + * a maximum value. + * + * If any vertex is affected by more than that 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 (AI_LMW_MAX_WEIGHTS), + * 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 for you. + */ + LimitBoneWeights = 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 to capture Assimp's log output if you use this flag, + * so you can easily find ot what's actually wrong if a file fails the + * validation. The validator is quite rude and will find all + * inconsistencies in the data structure. + * + * Plugin developers are recommended to use it to debug their loaders. + * + * There are two types of validation failures: + *
    + *
  • Error: There's something wrong with the imported data. Further + * postprocessing is not possible and the data is not usable at all. + * The import fails, see aiGetErrorString() for the + * error message.
    • + *
  • Warning: There are some minor issues (e.g. 1000000 animation + * keyframes with the same time), but further postprocessing and use + * of the data structure is still safe. Warning details are written + * to the log file, AI_SCENE_FLAGS_VALIDATION_WARNING is + * set in aiScene::mFlags
    • + *
+ * + * This post-processing step is not time-consuming. It's use is not + * compulsory, but recommended. + */ + ValidateDataStructure = 0x400, + + /** + * Reorders triangles for better vertex cache locality. + * + * 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 + * http://www.cs.princeton.edu/gfx/pubs/Sander_2007_%3ETR/tipsy.pdf). + * + * If you intend to render huge models in hardware, this step might + * be of interest for you. The AI_CONFIG_PP_ICL_PTCACHE_SIZE + * config setting can be used to fine-tune the cache optimization. + */ + ImproveCacheLocality = 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 always 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; the material name is one of + * them. So, if you are 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. + */ + RemoveRedundantMaterials = 0x1000, + + /** + * This step tries to determine which meshes have normal vectors that are + * acing inwards. + * + * The algorithm is simple but effective: The bounding box of all + * vertices and 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. + */ + FixInfacingNormals = 0x2000, + + /** + * This step splits meshes with more than one primitive type in + * homogeneous submeshes. + * + * 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. + */ + SortByPType = 0x8000, + + /** + * This step searches all meshes for degenerated primitives and converts + * them to proper lines or points. + * + * A face is »degenerated« if one or more of its points are identical. + * To have the degenerated stuff not only detected and collapsed but also + * removed, try one of the following procedures: + * + * 1. (if you support lines and points for rendering but don't + * want the degenerates) + *
    + *
  • Specify the FindDegenerates flag.
    • + *
  • Set the AI_CONFIG_PP_FD_REMOVE option to 1. This will + * cause the step to remove degenerated triangles from the import + * as soon as they're detected. They won't pass any further + * pipeline steps.
    • + *
+ * + * 2.(if you don't support lines and points at all ...) + *
    + *
  • Specify the FindDegenerates flag.
    • + *
  • Specify the SortByPType flag. This moves line and + * point primitives to separate meshes.
    • + *
  • Set the AI_CONFIG_PP_SBP_REMOVE option to + * aiPrimitiveType_POINTS | aiPrimitiveType_LINES + * to cause SortByPType to reject point and line meshes from the + * scene.
    • + *
+ * + * Note: Degenerated polygons are not necessarily bad and that's why + * they're not removed by default. There are several file formats + * which don't support lines or points. Some exporters bypass the + * format specification and write them as degenerated triangle + * instead. + */ + FindDegenerates = 0x10000, + + /** + * This step searches all meshes for invalid data, such as zeroed normal + * vectors or invalid UV coords and removes them. + * + * This is especially useful for normals. If they are invalid, and the + * step recognizes this, they will be removed and can later be computed + * by one of the other steps. + * + * The step will also remove meshes that are infinitely small. + */ + FindInvalidData = 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 tha 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 father app + * compute the UV channels, at least 3ds max, maja, blender, lightwave, + * modo, ... are able to achieve this. + * + * Note: If this step is not requested, you'll need to process the + * AI_MATKEY_MAPPING material property in order to + * display all assets properly. + */ + GenUVCoords = 0x40000, + + /** + * This step applies per-texture UV transformations and bakes them to + * stand-alone vtexture coordinate channelss. + * + * UV transformations are specified per-texture – see the + * AI_MATKEY_UVTRANSFORM material key for more information. + * This step processes all textures with transformed input UV coordinates + * and generates new (pretransformed) UV channel which replace 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 realtime apps by + * transforming texture coordinates at vertex shader stage with a 3x3 + * (homogenous) transformation matrix. + */ + TransformUVCoords = 0x80000, + + /** + * This step searches for duplicate meshes and replaces duplicates with + * references to the first mesh. + * + * This step takes a while, don't use it if you have no time. Its main + * purpose is to workaround the limitation 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 + * currently not support per-node material assignment to meshes, which + * means that identical meshes with differnent materials are currently + * not joined, although this is planned for future versions. + */ + FindInstances = 0x100000, + + /** + * A postprocessing step to reduce the number of meshes. + * + * In fact, it will reduce the number of drawcalls. + * + * This is a very effective optimization and is recommended to be used + * together with OptimizeGraph, if possible. The flag is + * fully compatible with both SplitLargeMeshes and + * SortByPType. + */ + OptimizeMeshes = 0x200000, + + /** + * A postprocessing step to optimize the scene hierarchy. + * + * Nodes with no 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, complex hierarchies are usually completely lost. That's + * note the right choice 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. + * OptimizeMeshes in combination with + * OptimizeGraph usually fixes them all and makes them + * renderable. + */ + OptimizeGraph = 0x400000, + + /** This step flips all UV coordinates along the y-axis and adjusts + * material settings and bitangents accordingly. + * + * Output UV coordinate system: + * 
 0y|0y ---------- 1x|0y
+       * |                 |
+       * |                 |
+       * |                 |
+       * 0x|1y ---------- 1x|1y
+ * You'll probably want to consider this flag if you use Direct3D for + * rendering. The AI_PROCESS_CONVERT_TO_LEFT_HANDED flag + * supersedes this setting and bundles all conversions typically required + * for D3D-based applications. + */ + FlipUVs = 0x800000, + + /** + * This step adjusts the output face winding order to be clockwise. + * + * The default face winding order is counter clockwise. + * + * Output face order: + * 
       x2
+       *
+       *                         x0
+       *  x1
+ */ + FlipWindingOrder = 0x1000000 + } + + /** + * Abbrevation for convenience. + */ + alias aiPostProcessSteps aiProcess; + + /** + * Shortcut flag for Direct3D-based applications. + * + * Combines the MakeLeftHanded, FlipUVs and + * FlipWindingOrder flags. The output data matches Direct3D's + * conventions: left-handed geometry, upper-left origin for UV coordinates + * and clockwise face order, suitable for CCW culling. + */ + const aiPostProcessSteps AI_PROCESS_CONVERT_TO_LEFT_HANDED = + aiProcess.MakeLeftHanded | + aiProcess.FlipUVs | + aiProcess.FlipWindingOrder; + + /** + * Default postprocess configuration optimizing the data for real-time rendering. + * + * Applications would want to use this preset to load models on end-user + * PCs, maybe for direct use in game. + * + * If you're using DirectX, don't forget to combine this value with + * the ConvertToLeftHanded step. If you don't support UV + * transformations in your application, apply the + * TransformUVCoords step, too. + * + * Note: Please take the time to read the doc for the steps enabled by this + * preset. Some of them offer further configurable properties, some of + * them might not be of use for you so it might be better to not specify + * them. + */ + const aiPostProcessSteps AI_PROCESS_PRESET_TARGET_REALTIME_FAST = + aiProcess.CalcTangentSpace | + aiProcess.GenNormals | + aiProcess.JoinIdenticalVertices | + aiProcess.Triangulate | + aiProcess.GenUVCoords | + aiProcess.SortByPType; + + /** + * Default postprocess configuration optimizing the data for real-time + * rendering. + * + * Unlike AI_PROCESS_PRESET_TARGET_REALTIME_FAST, this + * configuration performs some extra optimizations to improve rendering + * speed and to minimize memory usage. It could be a good choice for a + * level editor environment where import speed is not so important. + * + * If you're using DirectX, don't forget to combine this value with + * the ConvertToLeftHanded step. If you don't support UV + * transformations in your application, apply the + * TransformUVCoords step, too. + * + * Note: Please take the time to read the doc for the steps enabled by this + * preset. Some of them offer further configurable properties, some of + * them might not be of use for you so it might be better to not specify + * them. + */ + const aiPostProcessSteps AI_PROCESS_PRESET_TARGET_REALTIME_QUALITY = + aiProcess.CalcTangentSpace | + aiProcess.GenSmoothNormals | + aiProcess.JoinIdenticalVertices | + aiProcess.ImproveCacheLocality | + aiProcess.LimitBoneWeights | + aiProcess.RemoveRedundantMaterials | + aiProcess.SplitLargeMeshes | + aiProcess.Triangulate | + aiProcess.GenUVCoords | + aiProcess.SortByPType | + aiProcess.FindDegenerates | + aiProcess.FindInvalidData; + + /** + * Default postprocess configuration optimizing the data for real-time + * rendering. + * + * This preset enables almost every optimization step to achieve perfectly + * optimized data. It's your choice for level editor environments where + * import speed is not important. + * + * If you're using DirectX, don't forget to combine this value with + * the ConvertToLeftHanded step. If you don't support UV + * transformations in your application, apply the + * TransformUVCoords step, too. + * + * Note: Please take the time to read the doc for the steps enabled by this + * preset. Some of them offer further configurable properties, some of + * them might not be of use for you so it might be better to not specify + * them. + */ + const aiPostProcessSteps AI_PROCESS_PRESET_TARGET_REALTIME_MAX_QUALITY = + AI_PROCESS_PRESET_TARGET_REALTIME_QUALITY | + aiProcess.FindInstances | + aiProcess.ValidateDataStructure | + aiProcess.OptimizeMeshes; +} diff --git a/port/dAssimp/assimp/scene.d b/port/dAssimp/assimp/scene.d new file mode 100644 index 000000000..ab545b192 --- /dev/null +++ b/port/dAssimp/assimp/scene.d @@ -0,0 +1,306 @@ +/* +--------------------------------------------------------------------------- +Open Asset Import Library (ASSIMP) +--------------------------------------------------------------------------- + +Copyright (c) 2006-2009, ASSIMP Development 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 Development 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. +--------------------------------------------------------------------------- +*/ + +/** + * Contains the data structures which store the hierarchy fo the imported data. + */ +module assimp.scene; + +import assimp.animation; +import assimp.camera; +import assimp.light; +import assimp.math; +import assimp.mesh; +import assimp.material; +import assimp.texture; +import assimp.types; + +extern ( C ) { + /** + * A node in the imported hierarchy. + * + * 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 does consist of only a single root node with + * no childs. + */ + struct aiNode { + /** + * The name of the node. + * + * The name might be empty (length of zero) but all nodes which need to + * be accessed afterwards by bones or animations are usually named. + * Multiple nodes may have the same name, but nodes which are accessed + * by bones (see aiBone and aiMesh.mBones) + * must be unique. + * + * Cameras and lights are assigned to a specific node name – if there are + * multiple nodes with this name, they are assigned to each of them. + * + * There are no limitations regarding the characters contained in this + * string. You should be able to handle stuff like whitespace, tabs, + * linefeeds, quotation marks, ampersands, … + */ + aiString mName; + + /** + * The transformation relative to the node's parent. + */ + aiMatrix4x4 mTransformation; + + /** + * Parent node. + * + * null if this node is the root node. + */ + aiNode* mParent; + + /** + * The number of child nodes of this node. + */ + uint mNumChildren; + + /** + * The child nodes of this node. + * + * null if mNumChildren is 0. + */ + aiNode** mChildren; + + /** + * The number of meshes of this node. + */ + int mNumMeshes; + + /** + * The meshes of this node. + * + * Each entry is an index for aiScene.mMeshes. + */ + uint* mMeshes; + } + + /** + * Flags which are combinated in aiScene.mFlags to store + * auxiliary information about the imported scene. + */ + enum aiSceneFlags : uint { + /** + * Specifies that the scene data structure that was imported is not + * complete. + * + * 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 post-processing step + * (aiProcess.ValidateDS) if the validation was 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 post-processing step + * (aiProcess.ValidateDS) 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. 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 + * aiProcess.JoinIdenticalVertices post-processing step. 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. + * + * Note: Assimp is probably not the best choice for loading huge + * terrains – fully triangulated data takes extremely much storage + * space and should be avoided as long as possible (typically you will + * perform the triangulation when you actually need to render it). + */ + FLAGS_TERRAIN = 0x10 + } + + /** + * The root structure of the imported data. + * + * Everything that was imported from the given file can be accessed from here. + * Objects of this class are generally maintained and owned by Assimp, not + * by the caller. You shouldn't want to instance it, nor should you ever try to + * delete a given scene on your own. + */ + struct aiScene { + /** + * Any combination of the aiSceneFlags. By default, this + * value is 0, no flags are set. + * + * Most applications will want to reject all scenes with the + * aiSceneFlags.INCOMPLETE bit set. + */ + uint mFlags; + + /** + * The root node of the hierarchy. + * + * There will always be at least the root node if the import was + * successful (and no special flags have been set). Presence of further + * nodes depends on the format and contents of the imported file. + */ + aiNode* mRootNode; + + /** + * The number of meshes in the scene. + */ + uint mNumMeshes; + + /** + * The array of meshes. + * + * Use the indices given in the aiNode structure to access + * this array. The array is mNumMeshes in size. + * + * If the aiSceneFlags.INCOMPLETE flag is not set, there + * will always be at least one mesh. + */ + aiMesh** mMeshes; + + /** + * The number of materials in the scene. + */ + uint mNumMaterials; + + /** + * The array of meshes. + * + * Use the indices given in the aiMesh structure to access + * this array. The array is mNumMaterials in size. + * + * If the aiSceneFlags.INCOMPLETE flag is not set, there + * will always be at least one material. + */ + aiMaterial** mMaterials; + + /** + * The number of animations in the scene. + */ + uint mNumAnimations; + + /** + * The array of animations. + * + * All animations imported from the given file are listed here. The array + * is mNumAnimations in size. + */ + aiAnimation** mAnimations; + + /** + * The number of textures embedded into the file. + */ + uint mNumTextures; + + /** + * The array of embedded textures. + * + * Not many file formats embed their textures into the file. An example + * is Quake's MDL format (which is also used by some + * GameStudio versions). + */ + aiTexture** mTextures; + + /** + * The number of light sources in the scene. + * + * Light sources are fully optional, in most cases this attribute will be + * 0. + */ + uint mNumLights; + + /** + * The array of light sources. + * + * All light sources imported from the given file are listed here. The + * array is mNumLights in size. + */ + aiLight** mLights; + + /** + * The number of cameras in the scene. + * + * Cameras are fully optional, in most cases this attribute + * will be 0. + */ + uint mNumCameras; + + /** + * The array of cameras. + * + * All cameras imported from the given file are listed here. The array is + * mNumCameras in size. + * + * The first camera in the array (if existing) is the default camera view + * at the scene. + */ + aiCamera** mCameras; + } +} diff --git a/port/dAssimp/assimp/texture.d b/port/dAssimp/assimp/texture.d new file mode 100644 index 000000000..0f46ff551 --- /dev/null +++ b/port/dAssimp/assimp/texture.d @@ -0,0 +1,122 @@ +/* +--------------------------------------------------------------------------- +Open Asset Import Library (ASSIMP) +--------------------------------------------------------------------------- + +Copyright (c) 2006-2009, ASSIMP Development 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 Development 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. +--------------------------------------------------------------------------- +*/ + +/** + * Contains helper structures to handle textures in Assimp. + * + * Used for file formats which embed their textures into the model file. + * Supported are both normal textures, which are stored as uncompressed pixels, + * and "compressed" textures, which are stored in a file format such as PNG or + * TGA. + */ +module assimp.texture; + +extern ( C ) { + /** + * Helper structure to represent a texel in a ARGB8888 format. + * + * Used by aiTexture. + */ + struct aiTexel { + align ( 1 ): + ubyte b, g, r, a; + } + + /** + * Helper structure to describe an embedded texture. + * + * Usually textures are contained in external files but some file formats + * embed them directly in the model file. There are two types of + * embedded textures: + * + * 1. Uncompressed textures: The color data is given in an + * uncompressed format. + * + * 2. Compressed textures stored in a file format like PNG or JPEG. + * The raw file bytes are given so the application must utilize an image + * decoder (e.g. DevIL) to get access to the actual color data. + */ + struct aiTexture { + /** + * Width of the texture, in pixels. + * + * If mHeight is zero the texture is compressed in a format + * like JPEG. In this case, this value specifies the size of the memory + * area pcData is pointing to, in bytes. + */ + uint mWidth; + + /** + * Height of the texture, in pixels. + * + * If this value is zero, pcData points to an compressed + * texture in any format (e.g. JPEG). + */ + uint mHeight; + + /** + * A hint from the loader to make it easier for applications to determine + * the type of embedded compressed textures. + * + * If mHeight is not 0, this member is undefined. Otherwise + * it is set set to '\0\0\0\0' if the loader has no additional + * information about the texture file format used, or the file extension + * of the format without a trailing dot. If there are multiple file + * extensions for a format, the shortest extension is chosen (JPEG maps + * to 'jpg', not to 'jpeg'). E.g. 'dds\0', 'pcx\0', 'jpg\0'. All + * characters are lower-case. The fourth byte will always be '\0'. + */ + char achFormatHint[4]; + + /** + * Data of the texture. + * + * Points to an array of mWidth * mHeight + * aiTexels. The format of the texture data is always + * ARGB8888 to make the implementation for user of the library as easy as + * possible. + * + * If mHeight is 0, this is a pointer to a memory buffer of + * size mWidth containing the compressed texture data. + */ + aiTexel* pcData; + } +} diff --git a/port/dAssimp/assimp/types.d b/port/dAssimp/assimp/types.d new file mode 100644 index 000000000..3b2def9f0 --- /dev/null +++ b/port/dAssimp/assimp/types.d @@ -0,0 +1,232 @@ +/* +--------------------------------------------------------------------------- +Open Asset Import Library (ASSIMP) +--------------------------------------------------------------------------- + +Copyright (c) 2006-2009, ASSIMP Development 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 Development 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. +--------------------------------------------------------------------------- +*/ + +/** + * Contains miscellaneous types used in Assimp's C API. + */ +module assimp.types; + +extern ( C ) { + /** + * Our own C boolean type. + */ + enum aiBool : int { + FALSE = 0, + TRUE = 1 + } + + /** + * Type definition for log stream callback function pointers. + */ + alias void function( char* message, char* user ) aiLogStreamCallback; + + /** + * Represents a log stream. A log stream receives all log messages and + * streams them somewhere. + * + * See: aiGetPredefinedLogStream, + * aiAttachLogStream and aiDetachLogStream. + */ + struct aiLogStream { + /** + * Callback function to be called when a new message arrives. + */ + aiLogStreamCallback callback; + + /** + * User data to be passed to the callback. + */ + char* user; + } + + /** + * Maximum dimension for aiStrings. + * + * Assimp strings are zero terminated. + */ + const size_t MAXLEN = 1024; + + /** + * Represents a string, zero byte terminated. + * + * The length of such a string is limited to MAXLEN characters + * (excluding the terminal \0). + * + * To access an aiString from D you might want to use something like the + * following piece of code: + * --- + * char[] importAiString( aiString* s ) { + * return s.data[ 0 .. s.length ]; + * } + * --- + */ + struct aiString { + /** + * Length of the string (excluding the terminal \0). + */ + size_t length; + + /** + * String buffer. + * + * Size limit is MAXLEN. + */ + char data[ MAXLEN ]; + } + + /** + * Standard return type for some library functions. + */ + enum aiReturn : uint { + /** + * Indicates that a function was successful. + */ + SUCCESS = 0x0, + + /** + * Indicates that a function failed. + */ + FAILURE = -0x1, + + /** + * Indicates that not enough memory was available to perform the + * requested operation. + */ + OUTOFMEMORY = -0x3 + } + + /** + * Seek origins (for the virtual file system API). + */ + enum aiOrigin : uint { + /** + * Beginning of the file. + */ + SET = 0x0, + + /** + * Current position of the file pointer. + */ + CUR = 0x1, + + /** + * End of the file. + * + * Offsets must be negative. + */ + END = 0x2 + } + + /** + * Enumerates predefined log streaming destinations. + * + * Logging to these streams can be enabled with a single call to + * aiAttachPredefinedLogStream(). + */ + enum aiDefaultLogStream :uint { + /** + * Stream the log to a file. + */ + FILE = 0x1, + + /** + * Stream the log to standard output. + */ + STDOUT = 0x2, + + /** + * Stream the log to standard error. + */ + STDERR = 0x4, + + /** + * MSVC only: Stream the log the the debugger (this relies on + * OutputDebugString from the Win32 SDK). + */ + DEBUGGER = 0x8 + } + + /** + * Stores the memory requirements for different components (e.g. meshes, + * materials, animations) of an import. All sizes are in bytes. + */ + struct aiMemoryInfo { + /** + * Storage allocated for texture data. + */ + uint textures; + + /** + * Storage allocated for material data. + */ + uint materials; + + /** + * Storage allocated for mesh data. + */ + uint meshes; + + /** + * Storage allocated for node data. + */ + uint nodes; + + /** + * Storage allocated for animation data. + */ + uint animations; + + /** + * Storage allocated for camera data. + */ + uint cameras; + + /** + * Storage allocated for light data. + */ + uint lights; + + /** + * Total storage allocated for the full import. + */ + uint total; + } +} diff --git a/port/dAssimp/assimp/versionInfo.d b/port/dAssimp/assimp/versionInfo.d new file mode 100644 index 000000000..498115524 --- /dev/null +++ b/port/dAssimp/assimp/versionInfo.d @@ -0,0 +1,72 @@ +/* +--------------------------------------------------------------------------- +Open Asset Import Library (ASSIMP) +--------------------------------------------------------------------------- + +Copyright (c) 2006-2009, ASSIMP Development 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 Development 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. +--------------------------------------------------------------------------- +*/ + +/** + * Flags returned by aiGetCompileFlags(). + */ +module assimp.versionInfo; + +extern ( C ) { + /** + * Assimp was compiled as a shared object (Windows: DLL). + */ + const uint ASSIMP_CFLAGS_SHARED = 0x1; + + /** + * Assimp was compiled against STLport. + */ + const uint ASSIMP_CFLAGS_STLPORT = 0x2; + + /** + * Assimp was compiled as a debug build. + */ + const uint ASSIMP_CFLAGS_DEBUG = 0x4; + + /** + * Assimp was compiled with ASSIMP_BUILD_BOOST_WORKAROUND defined. + */ + const uint ASSIMP_CFLAGS_NOBOOST = 0x8; + + /** + * Assimp was compiled with ASSIMP_BUILD_SINGLETHREADED defined. + */ + const uint ASSIMP_CFLAGS_SINGLETHREADED = 0x10; +}