diff options
Diffstat (limited to 'src/mesh/assimp-master/port/dAssimp/assimp')
16 files changed, 5031 insertions, 0 deletions
diff --git a/src/mesh/assimp-master/port/dAssimp/assimp/animation.d b/src/mesh/assimp-master/port/dAssimp/assimp/animation.d new file mode 100644 index 0000000..9a36940 --- /dev/null +++ b/src/mesh/assimp-master/port/dAssimp/assimp/animation.d @@ -0,0 +1,240 @@ +/* +--------------------------------------------------------------------------- +Open Asset Import Library (ASSIMP) +--------------------------------------------------------------------------- + +Copyright (c) 2006-2020, 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 <code>aiNodeAnim.mPreState</code> and + * <code>aiNodeAnim.mPostState</code>. + */ + 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. This means all keys are absolute and not + * relative to the bone default pose. + * + * The order in which the transformations are applied is – + * as usual – scaling, rotation, translation. + * + * Note: All keys are returned in their correct, chronological order. + * Duplicate keys don't pass the validation step. Most likely there will + * be no negative time values, but they are not forbidden (so + * implementations need to cope with 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 <code>mNumPositionKeys</code> 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 <code>mNumRotationKeys</code> 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 <code>mNumScalingKeys</code> 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 <code>aiAnimBehaviour.DEFAULT</code> (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 <code>aiAnimBehaviour.DEFAULT</code> (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 <code>mNumChannels</code> + * in size. + * + * Each channel affects a single node. + */ + aiNodeAnim** mChannels; + } +}
\ No newline at end of file diff --git a/src/mesh/assimp-master/port/dAssimp/assimp/api.d b/src/mesh/assimp-master/port/dAssimp/assimp/api.d new file mode 100644 index 0000000..bc7a157 --- /dev/null +++ b/src/mesh/assimp-master/port/dAssimp/assimp/api.d @@ -0,0 +1,686 @@ +/* +--------------------------------------------------------------------------- +Open Asset Import Library (ASSIMP) +--------------------------------------------------------------------------- + +Copyright (c) 2006-2020, 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 + * (<code>assimp.loader</code>). + */ +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 <code>aiScene</code> + * structure. The data is intended to be read-only, it stays property of the + * Assimp library and will be stable until <code>aiReleaseImport()</code> is + * called. After you're done with it, call <code>aiReleaseImport()</code> to + * free the resources associated with this file. + * + * If an error is encountered, null is returned instead. Call + * <code>aiGetErrorString()</code> 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 + * <code>aiPostProcessSteps</code> flags. If you wish to inspect the + * imported scene first in order to fine-tune your post-processing + * setup, consider to use <code>aiApplyPostProcessing()</code>. + * + * 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 <code>aiScene</code> + * structure. The data is intended to be read-only, it stays property of the + * Assimp library and will be stable until <code>aiReleaseImport()</code> is + * called. After you're done with it, call <code>aiReleaseImport()</code> to + * free the resources associated with this file. + * + * If an error is encountered, null is returned instead. Call + * <code>aiGetErrorString()</code> 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 + * <code>aiPostProcessSteps</code> flags. If you wish to inspect the + * imported scene first in order to fine-tune your post-processing + * setup, consider to use <code>aiApplyPostProcessing()</code>. + * 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 <code>aiScene</code> + * structure. The data is intended to be read-only, it stays property of the + * Assimp library and will be stable until <code>aiReleaseImport()</code> is + * called. After you're done with it, call <code>aiReleaseImport()</code> to + * free the resources associated with this file. + * + * If an error is encountered, null is returned instead. Call + * <code>aiGetErrorString()</code> 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 + * <code>aiPostProcessSteps</code> flags. If you wish to inspect the + * imported scene first in order to fine-tune your post-processing + * setup, consider to use <code>aiApplyPostProcessing()</code>. + * 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 <code>aiImportFile()</code> or + * <code>aiImportFileEx()</code> 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 + * <code>aiPostProcessSteps</code> flags. + * + * Returns: + * A pointer to the post-processed data. Post processing is done in-place, + * meaning this is still the same <code>aiScene</code> 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, <code>aiProcess.ValidateDS</code> 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 <code>aiDefaultLogStream.FILE</code> 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 <code>aiDetachLogStream()</code> on every single log + * stream you attach. Alternatively, <code>aiDetachAllLogStreams()</code> + * 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: + * <code>aiReturn.SUCCESS</code> if the log stream has been detached + * successfully. + * + * See: <code>aiDetachAllLogStreams</code> + */ + 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: <code>aiAttachLogStream</code>, <code>aiDetachLogStream</code> + */ + 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 <code>aiScene</code> from + * <code>aiImportFile()/aiImportFileEx()/aiApplyPostProcessing()</code>. + */ + 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: + * <code>TRUE</code> 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 <code>config</code> 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 <code>config</code> 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 <code>config</code> 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 <code>AI_MATKEY_XXX</code> + * constants. + * type = Specifies the <code>aiTextureType</code> 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 + * <code>aiMaterialProperty</code> structure or null if the key has + * not been found. + */ + aiReturn function( + aiMaterial* pMat, + char* pKey, + uint 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 <code>aiTextureType</code> 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 <code>aiGetMaterialFloatArray()</code>. + */ + alias aiGetMaterialFloatArray aiGetMaterialFloat; + + /** + * Retrieves a single integer value or an array of integer values from the + * material. + * + * See: <code>aiGetMaterialFloatArray()</code> + */ + aiReturn function( + aiMaterial* pMat, + char* pKey, + uint type, + uint index, + int* pOut, + uint* pMax = null + ) aiGetMaterialIntegerArray; + + /** + * Convenience alias for <code>aiGetMaterialIntegerArray()</code>. + */ + alias aiGetMaterialIntegerArray aiGetMaterialInteger; + + /** + * Retrieves a color value from the material. + * + * See: <code>aiGetMaterialFloatArray()</code> + */ + aiReturn function( + aiMaterial* pMat, + char* pKey, + uint type, + uint index, + aiColor4D* pOut + ) aiGetMaterialColor; + + /** + * Retrieves a string value from the material. + * + * See: <code>aiGetMaterialFloatArray()</code> + */ + aiReturn function( + aiMaterial* pMat, + char* pKey, + uint type, + uint index, + aiString* pOut + ) aiGetMaterialString; + + /** + * Get the number of textures for a particular texture type. + * + * Params: + * pMat = Pointer to the input material. May not be NULL + * type = Texture type to check for + * + * Returns: + * Number of textures for this type. + */ + uint function( aiMaterial* pMat, aiTextureType type ) aiGetMaterialTextureCount; + + /** + * Helper function to get all values pertaining to a particular texture slot + * from a material structure. + * + * This function is provided just for convenience. You could also read the + * texture by parsing 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 texture stack (<code>aiTextureType</code>) to + * read from. + * index = Index of the texture. The function fails if the requested + * index is not available for this texture type. + * <code>aiGetMaterialTextureCount()</code> can be used to determine + * the number of textures in a particular texture stack. + * path = Receives the output path. null is not a valid value. + * mapping = Receives 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: + * <code>aiReturn.SUCCESS</code> on success, otherwise something else. + */ + 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/src/mesh/assimp-master/port/dAssimp/assimp/assimp.d b/src/mesh/assimp-master/port/dAssimp/assimp/assimp.d new file mode 100644 index 0000000..a147ee2 --- /dev/null +++ b/src/mesh/assimp-master/port/dAssimp/assimp/assimp.d @@ -0,0 +1,63 @@ +/* +--------------------------------------------------------------------------- +Open Asset Import Library (ASSIMP) +--------------------------------------------------------------------------- + +Copyright (c) 2006-2020, 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/src/mesh/assimp-master/port/dAssimp/assimp/camera.d b/src/mesh/assimp-master/port/dAssimp/assimp/camera.d new file mode 100644 index 0000000..5567be2 --- /dev/null +++ b/src/mesh/assimp-master/port/dAssimp/assimp/camera.d @@ -0,0 +1,182 @@ +/* +--------------------------------------------------------------------------- +Open Asset Import Library (ASSIMP) +--------------------------------------------------------------------------- + +Copyright (c) 2006-2020, 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 <em>relative</em> 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 + * "<camName>.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/src/mesh/assimp-master/port/dAssimp/assimp/config.d b/src/mesh/assimp-master/port/dAssimp/assimp/config.d new file mode 100644 index 0000000..761156b --- /dev/null +++ b/src/mesh/assimp-master/port/dAssimp/assimp/config.d @@ -0,0 +1,705 @@ +/* +--------------------------------------------------------------------------- +Open Asset Import Library (ASSIMP) +--------------------------------------------------------------------------- + +Copyright (c) 2006-2020, 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 <code>aiSetImportPropertyInteger()</code>, + * <code>aiSetImportPropertyFloat()</code> and + * <code>aiSetImportPropertyString()</code>. + */ +module assimp.config; + +extern ( C ) { + /* + * Library settings. + * + * General, global settings. + */ + + /** + * Enables time measurements. + * + * If enabled, measures the time needed for each part of the loading + * process (i.e. IO time, importing, postprocessing, ..) and dumps these + * timings to the DefaultLogger. See the performance page in the main + * Assimp docs information on this topic. + * + * Property type: bool. Default value: false. + */ + const char* AI_CONFIG_GLOB_MEASURE_TIME = "GLOB_MEASURE_TIME"; + + version( none ) { // not implemented yet + /** + * Set Assimp's multithreading policy. + * + * This setting is ignored if Assimp was built without boost.thread support + * (<code>ASSIMP_BUILD_NO_THREADING</code>, which is implied by + * <code>ASSIMP_BUILD_BOOST_WORKAROUND</code>). + * + * Possible values are: -1 to let Assimp decide what to do, 0 to disable + * multithreading entirely and any number larger than 0 to force a specific + * number of threads. Assimp is always free to ignore this settings, which + * is merely a hint. Usually, the default value (-1) will be fine. However, + * if Assimp is used concurrently from multiple user threads, it might be + * useful to limit each Importer instance to a specific number of cores. + * + * For more information, see the threading page in the main Assimp docs. + * + * Property type: int, default value: -1. + */ + const char* AI_CONFIG_GLOB_MULTITHREADING = "GLOB_MULTITHREADING"; + } + + + /* + * 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 <code>CalcTangentSpace</code> 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 <code>GenSmoothNormals</code> 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 <code>AI_CONFIG_FAVOUR_SPEED</code> + * 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 <code>RemoveRedundantMaterials</code> 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 <em>single</em> + * quotation marks. For example: <code> + * "keep-me and_me_to anotherMaterialToBeKept \'name with whitespace\'"</code>. + * 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 <code>PretransformVertices</code> step to keep the scene + * hierarchy. Meshes are moved to worldspace, but no optimization is + * performed (meshes with equal materials are not joined, the total number + * of meshes will not change). + * + * This option could be of use for you if the scene hierarchy contains + * important additional information which you intend to parse. + * For rendering, you can still render all meshes in the scene without + * any transformations. + * + * Default value: false. + * + * Property type: bool. + */ + const char* AI_CONFIG_PP_PTV_KEEP_HIERARCHY = "PP_PTV_KEEP_HIERARCHY"; + + /** + * Configures the <code>PretransformVertices</code> step to normalize all + * vertex components into the -1...1 range. That is, a bounding box for the + * whole scene is computed, the maximum component is taken and all meshes + * are scaled appropriately (uniformly of course!). + * + * This might be useful if you don't know the spatial dimension of the input + * data. + */ + const char* AI_CONFIG_PP_PTV_NORMALIZE = "PP_PTV_NORMALIZE"; + + /** + * Configures the <code>FindDegenerates</code> 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 + * <code>FindDegenerates</code> 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: bool. + */ + const char* AI_CONFIG_PP_FD_REMOVE = "PP_FD_REMOVE"; + + /** + * Configures the <code>OptimizeGraph</code> 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 <em>single</em> + * quotation marks. For example: <code> + * "keep-me and_me_to anotherMaterialToBeKept \'name with whitespace\'"</code>. + * 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 <code>SplitLargeMeshes</code> 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 <code>SplitLargeMeshes</code> 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 <code>LimitBoneWeights</code> 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 <code>ImproveCacheLocality</code> 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 <code>aiScene</code> and <code>aiMesh</code> data + * structures that can be excluded from the import by using the + * <code>RemoveComponent</code> step. + * + * See the documentation to <code>RemoveComponent</code> for more details. + */ + enum aiComponent : uint { + /** + * Normal vectors. + */ + NORMALS = 0x2, + + /** + * Tangents and bitangents. + */ + TANGENTS_AND_BITANGENTS = 0x4, + + /** + * <em>All</em> color sets. + * + * Use aiComponent_COLORSn( N ) to specify the N'th set. + */ + COLORS = 0x8, + + /** + * <em>All</em> 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 <em>not</em> removed. Use the + * <code>OptimizeGraph</code> step to do this. + */ + BONEWEIGHTS = 0x20, + + /** + * Node animations (<code>aiScene.mAnimations</code>). + * + * The corresponding scenegraph nodes are <em>not</em> removed. Use the + * <code>OptimizeGraph</code> step to do this. + */ + ANIMATIONS = 0x40, + + /** + * Embedded textures (<code>aiScene.mTextures</code>). + */ + TEXTURES = 0x80, + + /** + * Light sources (<code>aiScene.mLights</code>). + * + * The corresponding scenegraph nodes are <em>not</em> removed. Use the + * <code>OptimizeGraph</code> step to do this. + */ + LIGHTS = 0x100, + + /** + * Cameras (<code>aiScene.mCameras</code>). + * + * The corresponding scenegraph nodes are <em>not</em> removed. Use the + * <code>OptimizeGraph</code> step to do this. + */ + CAMERAS = 0x200, + + /** + * Meshes (<code>aiScene.mMeshes</code>). + */ + MESHES = 0x400, + + /** Materials. + * + * One default material will be generated, so + * <code>aiScene.mNumMaterials</code> 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 <code>RemoveComponent</code> 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 <code>aiComponent</code> + * flags). + * + * Note: If no valid mesh is remaining after the step has been executed, the + * import <em>fails</em>, because there is no data to work on anymore. + */ + const char* AI_CONFIG_PP_RVC_FLAGS = "PP_RVC_FLAGS"; + + /** + * Input parameter to the <code>SortByPType</code> step: + * Specifies which primitive types are removed by the step. + * + * This is a bitwise combination of the <code>aiPrimitiveType</code> 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"; + + /** + * Input parameter to the <code>FindInvalidData</code> step: + * Specifies the floating-point accuracy for animation values. + * + * The step checks for animation tracks where all frame values are + * absolutely equal and removes them. This tweakable controls the epsilon + * for floating-point comparisons – two keys are considered equal if the + * invariant abs(n0-n1) > epsilon holds true for all vector respectively + * quaternion components. + * + * Default value: 0 (exact comparison). + * + * Property type: float. + */ + const char* AI_CONFIG_PP_FID_ANIM_ACCURACY = "PP_FID_ANIM_ACCURACY"; + + /** + * The <code>TransformUVCoords</code> step evaluates UV scalings. + */ + const AI_UVTRAFO_SCALING = 0x1; + + /** + * The <code>TransformUVCoords</code> step evaluates UV rotations. + */ + const AI_UVTRAFO_ROTATION = 0x2; + + /** + * The <code>TransformUVCoords</code> step evaluates UV translation. + */ + const AI_UVTRAFO_TRANSLATION = 0x4; + + /** + * The <code>TransformUVCoords</code> step evaluates all UV translations. + */ + const AI_UVTRAFO_ALL = + AI_UVTRAFO_SCALING + | AI_UVTRAFO_ROTATION + | AI_UVTRAFO_TRANSLATION; + + /** + * Input parameter to the <code>TransformUVCoords</code> step: Specifies + * which UV transformations are evaluated. + * + * Default value: AI_UVTRAFO_ALL. + * + * Property type: integer (bitwise combination of the + * <code>AI_UVTRAFO_XXX<code> 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: bool. + */ + const char* AI_CONFIG_FAVOUR_SPEED = "FAVOUR_SPEED"; + + + /* + * Importer settings. + * + * Various stuff to fine-tune the behaviour of specific importer plugins. + */ + + /** + * 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: bool. + */ + 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: bool. + */ + 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: bool. + */ + 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: bool. + */ + const char* AI_CONFIG_IMPORT_ASE_RECONSTRUCT_NORMALS = "IMPORT_ASE_RECONSTRUCT_NORMALS"; + + /** + * Configures the M3D loader to detect and process multi-part Quake player + * models. + * + * These models usually consist of three files, <code>lower.md3</code>, + * <code>upper.md3</code> and <code>head.md3</code>. 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: bool. + */ + 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 + * <code><md3_file_name>_<skin_name>.skin</code> 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 + * <code>[any_path]/models/[any_q3_subdir]/[model_name]/[file_name].md3</code> + * is loaded, the library tries to locate the corresponding shader file in + * <code>[any_path]/scripts/[model_name].shader</code>. 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 <code>[dir]/[model_name].shader</code> first, + * <code>[dir]/[file_name].shader</code> is the fallback file. Note that + * <code>[dir]</code> 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: bool. + */ + 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 <code>aiNodeAnim</code>s. + * + * Assimp provides full conversion of LightWave's envelope system, including + * pre and post conditions. The loader computes linearly subsampled animation + * chanels with the frame rate given in the LWS file. This property defines + * the start time. Note: animation channels are only generated if a node + * has at least one envelope with more tan one key assigned. This property. + * is given in frames, '0' is the first frame. By default, if this property + * is not set, the importer takes the animation start from the input LWS + * file ('FirstFrame' line). + * + * Default value: read from file. + * + * Property type: integer. + * + * See: <code>AI_CONFIG_IMPORT_LWS_ANIM_END</code> – 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"; + + /** + * Ogre Importer will try to load this material file. + * + * Ogre Mehs contain only the material name, not the material file. If there + * is no material file with the same name as the material, Ogre Importer + * will try to load this file and search the material in it. + * + * Property type: string. Default value: "Scene.material". + */ + const char* AI_CONFIG_IMPORT_OGRE_MATERIAL_FILE = "IMPORT_OGRE_MATERIAL_FILE"; +} diff --git a/src/mesh/assimp-master/port/dAssimp/assimp/fileIO.d b/src/mesh/assimp-master/port/dAssimp/assimp/fileIO.d new file mode 100644 index 0000000..108d883 --- /dev/null +++ b/src/mesh/assimp-master/port/dAssimp/assimp/fileIO.d @@ -0,0 +1,140 @@ +/* +--------------------------------------------------------------------------- +Open Asset Import Library (ASSIMP) +--------------------------------------------------------------------------- + +Copyright (c) 2006-2020, 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; + + /** + * File system callbacks. + * + * 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 custom file systems 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; + } + + /** + * File callbacks. + * + * Actually, it's a data structure to wrap a set of <code>fXXXX</code> + * (e.g <code>fopen()</code>) replacement functions. + * + * The default implementation of the functions utilizes the <code>fXXX</code> + * functions from the CRT. However, you can supply a custom implementation + * to Assimp by passing a custom <code>aiFileIO</code>. 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 + * (<code>ftell()</code>). + */ + aiFileTellProc TellProc; + + /** + * Callback to retrieve the size of the file, in bytes. + */ + aiFileTellProc FileSizeProc; + + /** + * Callback to set the current position of the file cursor + * (<code>fseek()</code>). + */ + aiFileSeek SeekProc; + + /** + * Callback to flush the file contents. + */ + aiFileFlushProc FlushProc; + + /** + * User-defined, opaque data. + */ + aiUserData UserData; + } +} diff --git a/src/mesh/assimp-master/port/dAssimp/assimp/light.d b/src/mesh/assimp-master/port/dAssimp/assimp/light.d new file mode 100644 index 0000000..0842d67 --- /dev/null +++ b/src/mesh/assimp-master/port/dAssimp/assimp/light.d @@ -0,0 +1,215 @@ +/* +--------------------------------------------------------------------------- +Open Asset Import Library (ASSIMP) +--------------------------------------------------------------------------- + +Copyright (c) 2006-2020, 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 + * <code>[spotName].Target</code>. 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. + * + * <code>aiLightSource.UNDEFINED</code> 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 + * <code>d</code> from the light's position is + * <code>1/( att0 + att1 * d + att2 * d * d )</code>. This member + * corresponds to the <code>att0</code> 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 + * <code>d</code> from the light's position is + * <code>1/( att0 + att1 * d + att2 * d * d )</code>. This member + * corresponds to the <code>att1</code> 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 + * <code>d</code> from the light's position is + * <code>1/( att0 + att1 * d + att2 * d * d )</code>. This member + * corresponds to the <code>att2</code> 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/src/mesh/assimp-master/port/dAssimp/assimp/loader.d b/src/mesh/assimp-master/port/dAssimp/assimp/loader.d new file mode 100644 index 0000000..279f0a7 --- /dev/null +++ b/src/mesh/assimp-master/port/dAssimp/assimp/loader.d @@ -0,0 +1,193 @@ +/* +--------------------------------------------------------------------------- +Open Asset Import Library (ASSIMP) +--------------------------------------------------------------------------- + +Copyright (c) 2006-2020, 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 = 2; +const uint ASSIMP_BINDINGS_MINOR = 0; + +/** + * Loader class for dynamically loading the Assimp library. + * + * The library is »reference-counted«, meaning that the library is not + * unloaded on a call to <code>unload()</code> 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 (<code>libassimp.so</code> on POSIX systems, + * <code>Assimp32.dll</code> on Win32) is loaded via Tango's SharedLib + * class. + */ + static void load() { + if ( m_sRefCount == 0 ) { + version ( Posix ) { + version ( OSX ) { + m_sLibrary = SharedLib.load( "libassimp.dylib" ); + } else { + m_sLibrary = SharedLib.load( "libassimp.so" ); + } + } + version ( Win32 ) { + m_sLibrary = SharedLib.load( "Assimp32.dll" ); + } + + // Versioning + mixin( bindCode( "aiGetLegalString" ) ); + mixin( bindCode( "aiGetVersionMinor" ) ); + mixin( bindCode( "aiGetVersionMajor" ) ); + mixin( bindCode( "aiGetVersionRevision" ) ); + mixin( bindCode( "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 + mixin( bindCode( "aiImportFile" ) ); + mixin( bindCode( "aiImportFileEx" ) ); + mixin( bindCode( "aiImportFileFromMemory" ) ); + mixin( bindCode( "aiApplyPostProcessing" ) ); + mixin( bindCode( "aiGetPredefinedLogStream" ) ); + mixin( bindCode( "aiAttachLogStream" ) ); + mixin( bindCode( "aiEnableVerboseLogging" ) ); + mixin( bindCode( "aiDetachLogStream" ) ); + mixin( bindCode( "aiDetachAllLogStreams" ) ); + mixin( bindCode( "aiReleaseImport" ) ); + mixin( bindCode( "aiGetErrorString" ) ); + mixin( bindCode( "aiIsExtensionSupported" ) ); + mixin( bindCode( "aiGetExtensionList" ) ); + mixin( bindCode( "aiGetMemoryRequirements" ) ); + mixin( bindCode( "aiSetImportPropertyInteger" ) ); + mixin( bindCode( "aiSetImportPropertyFloat" ) ); + mixin( bindCode( "aiSetImportPropertyString" ) ); + + // Mathematical functions + mixin( bindCode( "aiCreateQuaternionFromMatrix" ) ); + mixin( bindCode( "aiDecomposeMatrix" ) ); + mixin( bindCode( "aiTransposeMatrix4" ) ); + mixin( bindCode( "aiTransposeMatrix3" ) ); + mixin( bindCode( "aiTransformVecByMatrix3" ) ); + mixin( bindCode( "aiTransformVecByMatrix4" ) ); + mixin( bindCode( "aiMultiplyMatrix4" ) ); + mixin( bindCode( "aiMultiplyMatrix3" ) ); + mixin( bindCode( "aiIdentityMatrix3" ) ); + mixin( bindCode( "aiIdentityMatrix4" ) ); + + // Material system + mixin( bindCode( "aiGetMaterialProperty" ) ); + mixin( bindCode( "aiGetMaterialFloatArray" ) ); + mixin( bindCode( "aiGetMaterialIntegerArray" ) ); + mixin( bindCode( "aiGetMaterialColor" ) ); + mixin( bindCode( "aiGetMaterialString" ) ); + mixin( bindCode( "aiGetMaterialTextureCount" ) ); + mixin( bindCode( "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: + /// Current number of references to the library. + static uint m_sRefCount; + + /// Library handle. + static SharedLib m_sLibrary; +} + +/** + * Private helper function which constructs the bind command for a symbol to + * keep the code DRY. + */ +private char[] bindCode( char[] symbol ) { + return symbol ~ " = cast( typeof( " ~ symbol ~ + " ) )m_sLibrary.getSymbol( `" ~ symbol ~ "` );"; +} diff --git a/src/mesh/assimp-master/port/dAssimp/assimp/material.d b/src/mesh/assimp-master/port/dAssimp/assimp/material.d new file mode 100644 index 0000000..f0eae86 --- /dev/null +++ b/src/mesh/assimp-master/port/dAssimp/assimp/material.d @@ -0,0 +1,641 @@ +/* +--------------------------------------------------------------------------- +Open Asset Import Library (ASSIMP) +--------------------------------------------------------------------------- + +Copyright (c) 2006-2020, 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): + * <pre> DiffColor0 - gray + * DiffTextureOp0 - aiTextureOpMultiply + * DiffTexture0 - tex1.png + * DiffTextureOp0 - aiTextureOpAdd + * DiffTexture1 - tex2.png</pre> + * Written as equation, the final diffuse term for a specific pixel would be: + * <pre>diffFinal = DiffColor0 * sampleTex( DiffTexture0, UV0 ) + + * sampleTex( DiffTexture1, UV0 ) * diffContrib;</pre> + * where <code>diffContrib</code> is the intensity of the incoming light for + * that pixel. + */ + enum aiTextureOp : uint { + /** + * <code>T = T1 * T2</code> + */ + Multiply = 0x0, + + /** + * <code>T = T1 + T2</code> + */ + Add = 0x1, + + /** + * <code>T = T1 - T2</code> + */ + Subtract = 0x2, + + /** + * <code>T = T1 / T2</code> + */ + Divide = 0x3, + + /** + * <code>T = ( T1 + T2 ) - ( T1 * T2 )</code> + */ + SmoothAdd = 0x4, + + /** + * <code>T = T1 + ( T2 - 0.5 )</code> + */ + SignedAdd = 0x5 + } + + /** + * Defines how UV coordinates outside the <code>[0..1]</code> range are + * handled. + * + * Commonly referred to as 'wrapping mode'. + */ + enum aiTextureMapMode : uint { + /** + * A texture coordinate <code>u | v</code> is translated to + * <code>(u%1) | (v%1)</code>. + */ + Wrap = 0x0, + + /** + * Texture coordinates are clamped to the nearest valid value. + */ + Clamp = 0x1, + + /** + * If the texture coordinates for a pixel are outside + * <code>[0..1]</code>, the texture is not applied to that pixel. + */ + Decal = 0x3, + + /** + * A texture coordinate <code>u | v</code> becomes + * <code>(u%1) | (v%1)</code> if <code>(u-(u%1))%2</code> is + * zero and <code>(1-(u%1)) | (1-(v%1))</code> 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 <code>aiProcess.GenUVCoords</code> 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 <code>AI_MATKEY_MAPPING</code> property for more details. + */ + enum aiTextureMapping : uint { + /** + * The mapping coordinates are taken from an UV channel. + * + * The <code>AI_MATKEY_UVSRC</code> 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 + * <code>aiMaterialProperty.mSemantic</code> for all material properties + * <em>not</em> 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 <code>AI_MATKEY_TEXFLAGS</code> property. + */ + enum aiTextureFlags : uint { + /** + * The texture's color values have to be inverted (i.e. <code>1-n</code> + * component-wise). + */ + Invert = 0x1, + + /** + * Explicit request to the application to process the alpha channel of the + * texture. + * + * Mutually exclusive with <code>IgnoreAlpha</code>. 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 <code>UseAlpha</code>. + */ + 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 + * <code>SourceColor * SourceBlend + DestColor * DestBlend</code>, + * where <code>DestColor</code> is the previous color in the framebuffer at + * this position and <code>SourceColor</code> is the material color before + * the transparency calculation. + * + * This corresponds to the <code>AI_MATKEY_BLEND_FUNC</code> property. + */ + enum aiBlendMode :uint { + /** + * Formula: + * <code>SourceColor * SourceAlpha + DestColor * (1 - SourceAlpha)</code> + */ + Default = 0x0, + + /** + * Additive blending. + * + * Formula: <code>SourceColor*1 + DestColor*1</code> + */ + Additive = 0x1 + } + + /** + * Defines how an UV channel is transformed. + * + * This is just a helper structure for the <code>AI_MATKEY_UVTRANSFORM</code> + * 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 <code>aiGetMaterialInteger[Array]()</code> 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, <code>aiGetMaterialString()</code> + * must be used to query a string property. + */ + String = 0x3, + + /** + * Array of (32 bit) integers. + * + * It is possible to use <code>aiGetMaterialFloat[Array]()</code> 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 <code>aiGetMaterialXXX()</code> 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: + * + * <code>$[name]</code>: A public property, there must be a corresponding + * AI_MATKEY_XXX constant. + * + * <code>?[name]</code>: Also public, but ignored by the + * <code>aiProcess.RemoveRedundantMaterials</code> post-processing step. + * + * <code>~[name]</code>: 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 + * <code>aiTextureType.NONE</code>). + */ + 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 <code>mData</code> 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 <code>mDataLength</code>. + */ + char* mData; + } + + /** + * Data structure for a material + * + * Material data is stored using a key-value structure. A single key-value + * pair is called a <em>material property</em>. The properties can be + * queried using the <code>aiMaterialGetXXX</code> 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_REFLECTIVITY = "$mat.reflectivity"; /// 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/src/mesh/assimp-master/port/dAssimp/assimp/math.d b/src/mesh/assimp-master/port/dAssimp/assimp/math.d new file mode 100644 index 0000000..057bbd5 --- /dev/null +++ b/src/mesh/assimp-master/port/dAssimp/assimp/math.d @@ -0,0 +1,155 @@ +/* +--------------------------------------------------------------------------- +Open Asset Import Library (ASSIMP) +--------------------------------------------------------------------------- + +Copyright (c) 2006-2020, 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 (column vs. row order). This + * is <em>always</em> a row-major matrix, even when using the + * <code>ConvertToLeftHanded</code> 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 (column vs. row order). This + * is <em>always</em> a row-major matrix, even when using the + * <code>ConvertToLeftHanded</code> 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 (<code>ax + by + cz = d</code>). + */ + 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/src/mesh/assimp-master/port/dAssimp/assimp/mesh.d b/src/mesh/assimp-master/port/dAssimp/assimp/mesh.d new file mode 100644 index 0000000..48162b7 --- /dev/null +++ b/src/mesh/assimp-master/port/dAssimp/assimp/mesh.d @@ -0,0 +1,465 @@ +/* +--------------------------------------------------------------------------- +Open Asset Import Library (ASSIMP) +--------------------------------------------------------------------------- + +Copyright (c) 2006-2020, 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 ) { + /* + * These limits are required to match the settings Assimp was compiled + * against. Therefore, do not redefine them unless you build the library + * from source using the same definitions. + */ + + /** + * Maximum number of indices per face (polygon). + */ + const AI_MAX_FACE_INDICES = 0x7fff; + + /** + * Maximum number of indices per face (polygon). + */ + const AI_MAX_BONE_WEIGHTS = 0x7fffffff; + + /** + * Maximum number of vertices per mesh. + */ + const AI_MAX_VERTICES = 0x7fffffff; + + /** + * Maximum number of faces per mesh. + */ + const AI_MAX_FACES = 0x7fffffff; + + /** + * Supported number of vertex color sets per mesh. + */ + const AI_MAX_NUMBER_OF_COLOR_SETS = 0x4; + + /** + * Supported number of texture coord sets (UV(W) channels) per mesh. + */ + const AI_MAX_NUMBER_OF_TEXTURECOORDS = 0x4; + + + /** + * A single face in a mesh, referring to multiple vertices. + * + * If <code>mNumIndices</code> is 3, we call the face <em>triangle</em>, for + * for <code>mNumIndices > 3</code> it's called <em>polygon</em>. + * + * <code>aiMesh.mPrimitiveTypes</code> can be queried to quickly examine + * which types of primitive are actually present in a mesh. The + * <code>aiProcess.SortByPType</code> 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 + * (<code>AI_CONFIG_PP_SBP_REMOVE</code>) to force <code>SortByPType</code> + * to completely remove specific kinds of primitives from the imported scene. + * In many cases you'll probably want to set this setting to + * <code>aiPrimitiveType.LINE | aiPrimitiveType.POINT</code>. Together with + * the <code>aiProcess.Triangulate</code> flag you can then be sure that + * <code>mNumIndices</code> is always 3. + */ + struct aiFace { + /** + * Number of indices defining this face. + * + * The maximum value for this member is <code>AI_MAX_FACE_INDICES</code>. + */ + uint mNumIndices; + + /** + * Array of the indices defining the face. + * + * The size is given in <code>mNumIndices</code>. + */ + 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 <code>[0..1]</code>. + * + * 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. + * + * The maximum value for this member is <code>AI_MAX_BONE_WEIGHTS</code>. + */ + uint mNumWeights; + + /** + * The vertices affected by this bone. + * + * This array is <code>mNumWeights</code> entries in size. + */ + aiVertexWeight* mWeights; + + /** + * Matrix that transforms from mesh space to bone space (in the bind + * pose). + */ + aiMatrix4x4 mOffsetMatrix; + } + + /** + * Enumerates the types of geometric primitives supported by Assimp. + * + * See: <code>aiFace</code>, <code>aiProcess.SortByPType</code>, + * <code>aiProcess.Triangulate</code>, + * <code>AI_CONFIG_PP_SBP_REMOVE</code>. + */ + enum aiPrimitiveType : uint { + /** A point primitive. + * + * This is just a single vertex in the virtual world, + * <code>aiFace</code> 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. + * <code>aiFace</code> 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 <code>Triangulate</code> + * post processing step is provided for your convenience, 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. + + /** + * NOT CURRENTLY IN USE. An AnimMesh is an attachment to an #aiMesh stores + * per-vertex animations for a particular frame. + * + * You may think of an <code>aiAnimMesh</code> as a `patch` for the host + * mesh, which replaces only certain vertex data streams at a particular + * time. + * + * Each mesh stores n attached attached meshes (<code>aiMesh.mAnimMeshes</code>). + * The actual relationship between the time line and anim meshes is + * established by #aiMeshAnim, which references singular mesh attachments + * by their ID and binds them to a time offset. + */ + struct aiAnimMesh { + /** + * Replacement for aiMesh.mVertices. + * + * If this array is non-null, it *must* contain mNumVertices entries. + * The corresponding array in the host mesh must be non-null as well - + * animation meshes may neither add or nor remove vertex components (if + * a replacement array is NULL and the corresponding source array is + * not, the source data is taken instead). + */ + aiVector3D* mVertices; + + /// Replacement for <code>aiMesh.mNormals</code>. + aiVector3D* mNormals; + + /// Replacement for <code>aiMesh.mTangents</code>. + aiVector3D* mTangents; + + /// Replacement for <code>aiMesh.mBitangents</code>. + aiVector3D* mBitangents; + + /// Replacement for <code>aiMesh.mColors</code>. + aiColor4D* mColors[ AI_MAX_NUMBER_OF_COLOR_SETS ]; + + /// Replacement for <code>aiMesh.mTextureCoords</code>. + aiVector3D* mTextureCoords[ AI_MAX_NUMBER_OF_TEXTURECOORDS ]; + + /** + * The number of vertices in the aiAnimMesh, and thus the length of all + * the member arrays. + * + * This has always the same value as the mNumVertices property in the + * corresponding aiMesh. It is duplicated here merely to make the length + * of the member arrays accessible even if the aiMesh is not known, e.g. + * from language bindings. + */ + uint mNumVertices; + } + + /** + * 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 <code>mPositions</code> member is usually not optional. + * However, vertex positions <em>could</em> be missing if the + * <code>AI_SCENE_FLAGS_INCOMPLETE</code> flag is set in + * <code>aiScene.mFlags</code>. + */ + struct aiMesh { + /** + * Bitwise combination of <code>aiPrimitiveType</code> members. + * + * This specifies which types of primitives are present in the mesh. + * The <code>SortByPrimitiveType</code> 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. The + * maximum value for this member is <code>AI_MAX_VERTICES</code>. + */ + uint mNumVertices; + + /** + * The number of primitives (triangles, polygons, lines) in this mesh. + * + * This is also the size of the <code>mFaces</code> array. The maximum + * value for this member is <code>AI_MAX_FACES</code>. + */ + uint mNumFaces; + + /** + * Vertex positions. + * + * This array is always present in a mesh. The array is + * <code>mNumVertices</code> in size. + */ + aiVector3D* mVertices; + + /** + * Vertex normals. + * + * The array contains normalized vectors, null if not present. + * The array is <code>mNumVertices</code> 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 <code>QNAN</code>. + * + * 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 <code>mNumVertices</code> 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 + * <code>QNAN</code>. + * + * 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 <code>mNumVertices</code> in size. + * + * Note: If the mesh contains tangents, it automatically also contains + * bitangents. + */ + aiVector3D* mBitangents; + + /** + * Vertex color sets. + * + * A mesh may contain 0 to <code>AI_MAX_NUMBER_OF_COLOR_SETS</code> + * vertex colors per vertex. null if not present. + * + * Each array is <code>mNumVertices</code> 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 <code>AI_MAX_NUMBER_OF_TEXTURECOORDS</code> + * per vertex. null if not present. + * + * Each array is <code>mNumVertices</code> 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 <code>n</code>, the + * component <code>p.z</code> of <code>mTextureCoords[n][p]</code> is set + * to 0. If the value is 1 for a given channel, <code>p.y</code> 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 refers to a number of vertices by their indices. + * This array is always present in a mesh, its size is given + * in <code>mNumFaces</code>. If the + * <code>AI_SCENE_FLAGS_NON_VERBOSE_FORMAT</code> is <em>not</em> 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 <code>mBones</code> 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; + + /** + * Name of the mesh. + * + * Meshes can be named, but this is not a requirement and leaving this + * field empty is totally fine. + * + * There are mainly three uses for mesh names: + * - Some formats name nodes and meshes independently. + * - Importers tend to split meshes up to meet the one-material-per-mesh + * requirement. Assigning the same (dummy) name to each of the result + * meshes aids the caller at recovering the original mesh partitioning. + * - Vertex animations refer to meshes by their names. + */ + aiString mName; + + /// NOT CURRENTLY IN USE. The number of attachment meshes. + uint mNumAnimMeshes; + + /** + * NOT CURRENTLY IN USE. Attachment meshes for this mesh, for vertex- + * based animation. + * + * Attachment meshes carry replacement data for some of the mesh's + * vertex components (usually positions, normals). + */ + aiAnimMesh** mAnimMeshes; + } +} diff --git a/src/mesh/assimp-master/port/dAssimp/assimp/postprocess.d b/src/mesh/assimp-master/port/dAssimp/assimp/postprocess.d new file mode 100644 index 0000000..343bb36 --- /dev/null +++ b/src/mesh/assimp-master/port/dAssimp/assimp/postprocess.d @@ -0,0 +1,597 @@ +/* +--------------------------------------------------------------------------- +Open Asset Import Library (ASSIMP) +--------------------------------------------------------------------------- + +Copyright (c) 2006-2020, 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: <code>aiImportFile</code>, <code>aiImportFileEx</code> + */ + 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, <code>AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE</code>, + * 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. <em>If this flag is not specified</em>, no vertices + * are referenced by more than one face and <em>no index buffer is + * required</em> 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 <code>ConvertToLeftHanded</code> 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 <em>not</em> modified!. + * + * If you want »triangles only« with no other kinds of primitives, + * specify both <code>Triangulate</code> and <code>SortByPType</code> 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, <code>AI_CONFIG_PP_RVC_FLAGS</code>. 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), + * <code>JoinIdenticalVertices</code> 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. <code>JoinIdenticalVertices</code> + * is <em>useless</em> then. + * + * This flag may not be specified together with + * <code>GenSmoothNormals</code>. + */ + 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, + * <code>AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE</code> 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 + * <code>AI_CONFIG_PP_SLM_VERTEX_LIMIT</code> and + * <code>AI_CONFIG_PP_SLM_TRIANGLE_LIMIT</code> settings. The default + * values are <code>AI_SLM_DEFAULT_MAX_VERTICES</code> and + * <code>AI_SLM_DEFAULT_MAX_TRIANGLES</code>. + * + * 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 <em>can</em> cause some problems: if e.g. a mesh of the asset + * contains normals and another, using the same material index, does not, + * they will be brought together, but the first meshes's part of the + * normal list is zeroed. However, these artifacts are rare. + * + * Note: The <code>AI_CONFIG_PP_PTV_NORMALIZE</code> configuration + * property can be set to normalize the scene's spatial dimension + * to the -1...1 range. + */ + 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 (<code>AI_LMW_MAX_WEIGHTS</code>), + * but you can use the <code>#AI_CONFIG_PP_LBW_MAX_WEIGHTS</code> 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 <em>all</em> + * inconsistencies in the data structure. + * + * Plugin developers are recommended to use it to debug their loaders. + * + * There are two types of validation failures: + * <ul> + * <li>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 <code>aiGetErrorString()</code> for the + * error message.</li> + * <li>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, <code>AI_SCENE_FLAGS_VALIDATION_WARNING</code> is + * set in <code>aiScene::mFlags</code></li> + * </ul> + * + * 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 + * <tt>http://www.cs.princeton.edu/gfx/pubs/Sander_2007_%3ETR/tipsy.pdf</tt>). + * + * If you intend to render huge models in hardware, this step might + * be of interest for you. The <code>AI_CONFIG_PP_ICL_PTCACHE_SIZE</code> + * 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 + * <code>PretransformVertices</code> and <code>OptimizeMeshes</code> + * 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 + * <code>AI_CONFIG_PP_RRM_EXCLUDE_LIST</code> 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 <code>aiMesh.mPrimitiveTypes</code>. + * This is especially useful for real-time rendering where point and line + * primitives are often ignored or rendered separately. + * + * You can use the <code>AI_CONFIG_PP_SBP_REMOVE</code> 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: + * + * <b>1.</b> (if you support lines and points for rendering but don't + * want the degenerates) + * <ul> + * <li>Specify the <code>FindDegenerates</code> flag.</li> + * <li>Set the <code>AI_CONFIG_PP_FD_REMOVE</code> 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.</li> + * </ul> + * + * <b>2.</b>(if you don't support lines and points at all ...) + * <ul> + * <li>Specify the <code>FindDegenerates</code> flag.</li> + * <li>Specify the <code>SortByPType</code> flag. This moves line and + * point primitives to separate meshes.</li> + * <li>Set the <code>AI_CONFIG_PP_SBP_REMOVE</codet> option to + * <code>aiPrimitiveType_POINTS | aiPrimitiveType_LINES</code> + * to cause SortByPType to reject point and line meshes from the + * scene.</li> + * </ul> + * + * 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/fixes them. This is intended + * to get rid of some common exporter errors. + * + * This is especially useful for normals. If they are invalid, and the + * step recognizes this, they will be removed and can later be + * recomputed, e.g. by the <code>GenSmoothNormals</code> step. + * + * The step will also remove meshes that are infinitely small and reduce + * animation tracks consisting of hundreds if redundant keys to a single + * key. The <code>AI_CONFIG_PP_FID_ANIM_ACCURACY</code> config property + * decides the accuracy of the check for duplicate animation tracks. + */ + 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 + * <code>AI_MATKEY_MAPPING</code> 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 + * <code>AI_MATKEY_UVTRANSFORM</code> 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 + * <em>not</em> 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 <code>OptimizeGraph</code>, if possible. The flag is + * fully compatible with both <code>SplitLargeMeshes</code> and + * <code>SortByPType</code>. + */ + 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 + * <code>AI_CONFIG_PP_OG_EXCLUDE_LIST</code> 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 <code>OptimizeMeshes</code> for + * best results. + * + * Note: »Crappy« scenes with thousands of extremely small meshes packed + * in deeply nested nodes exist for almost all file formats. + * <code>OptimizeMeshes</code> in combination with + * <code>OptimizeGraph</code> 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: + * <pre> 0y|0y ---------- 1x|0y + * | | + * | | + * | | + * 0x|1y ---------- 1x|1y</pre> + * You'll probably want to consider this flag if you use Direct3D for + * rendering. The <code>AI_PROCESS_CONVERT_TO_LEFT_HANDED</code> 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: + * <pre> x2 + * + * x0 + * x1</pre> + */ + FlipWindingOrder = 0x1000000 + } + + /** + * Abbrevation for convenience. + */ + alias aiPostProcessSteps aiProcess; + + /** + * Shortcut flag for Direct3D-based applications. + * + * Combines the <code>MakeLeftHanded</code>, <code>FlipUVs</code> and + * <code>FlipWindingOrder</code> 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 <code>ConvertToLeftHanded</code> step. If you don't support UV + * transformations in your application, apply the + * <code>TransformUVCoords</code> 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 <code>AI_PROCESS_PRESET_TARGET_REALTIME_FAST</code>, 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 <code>ConvertToLeftHanded</code> step. If you don't support UV + * transformations in your application, apply the + * <code>TransformUVCoords</code> 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 <code>ConvertToLeftHanded</code> step. If you don't support UV + * transformations in your application, apply the + * <code>TransformUVCoords</code> 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/src/mesh/assimp-master/port/dAssimp/assimp/scene.d b/src/mesh/assimp-master/port/dAssimp/assimp/scene.d new file mode 100644 index 0000000..deee75a --- /dev/null +++ b/src/mesh/assimp-master/port/dAssimp/assimp/scene.d @@ -0,0 +1,306 @@ +/* +--------------------------------------------------------------------------- +Open Asset Import Library (ASSIMP) +--------------------------------------------------------------------------- + +Copyright (c) 2006-2020, 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 <code>aiBone</code> and <code>aiMesh.mBones</code>) + * <em>must</em> 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 <code>mNumChildren</code> is 0. + */ + aiNode** mChildren; + + /** + * The number of meshes of this node. + */ + int mNumMeshes; + + /** + * The meshes of this node. + * + * Each entry is an index for <code>aiScene.mMeshes</code>. + */ + uint* mMeshes; + } + + /** + * Flags which are combinated in <code>aiScene.mFlags</code> 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 + * (<code>aiProcess.ValidateDS</code>) 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 + * (<code>aiProcess.ValidateDS</code>) 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 + * <code>aiProcess.JoinIdenticalVertices</code> 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 <em>huge</em> + * 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 <code>aiSceneFlags</code>. By default, this + * value is 0, no flags are set. + * + * Most applications will want to reject all scenes with the + * <code>aiSceneFlags.INCOMPLETE</code> 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 <code>aiNode</code> structure to access + * this array. The array is <code>mNumMeshes</code> in size. + * + * If the <code>aiSceneFlags.INCOMPLETE</code> 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 <code>aiMesh</code> structure to access + * this array. The array is <code>mNumMaterials</code> in size. + * + * If the <code>aiSceneFlags.INCOMPLETE</code> 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 <code>mNumAnimations</code> 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 <code>MDL</code> 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 <code>mNumLights</code> 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 + * <code>mNumCameras</code> in size. + * + * The first camera in the array (if existing) is the default camera view + * at the scene. + */ + aiCamera** mCameras; + } +} diff --git a/src/mesh/assimp-master/port/dAssimp/assimp/texture.d b/src/mesh/assimp-master/port/dAssimp/assimp/texture.d new file mode 100644 index 0000000..83453b9 --- /dev/null +++ b/src/mesh/assimp-master/port/dAssimp/assimp/texture.d @@ -0,0 +1,122 @@ +/* +--------------------------------------------------------------------------- +Open Asset Import Library (ASSIMP) +--------------------------------------------------------------------------- + +Copyright (c) 2006-2020, 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: + * + * <em>1. Uncompressed textures</em>: The color data is given in an + * uncompressed format. + * + * <em>2. Compressed textures</em> 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 <code>mHeight</code> is zero the texture is compressed in a format + * like JPEG. In this case, this value specifies the size of the memory + * area <code>pcData</code> is pointing to, in bytes. + */ + uint mWidth; + + /** + * Height of the texture, in pixels. + * + * If this value is zero, <code>pcData</code> 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 <code>mHeight</code> 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 <code>mWidth * mHeight</code> + * <code>aiTexel</code>s. The format of the texture data is always + * ARGB8888 to make the implementation for user of the library as easy as + * possible. + * + * If <code>mHeight</code> is 0, this is a pointer to a memory buffer of + * size <code>mWidth</code> containing the compressed texture data. + */ + aiTexel* pcData; + } +} diff --git a/src/mesh/assimp-master/port/dAssimp/assimp/types.d b/src/mesh/assimp-master/port/dAssimp/assimp/types.d new file mode 100644 index 0000000..5aa4d54 --- /dev/null +++ b/src/mesh/assimp-master/port/dAssimp/assimp/types.d @@ -0,0 +1,249 @@ +/* +--------------------------------------------------------------------------- +Open Asset Import Library (ASSIMP) +--------------------------------------------------------------------------- + +Copyright (c) 2006-2020, 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: <code>aiGetPredefinedLogStream</code>, + * <code>aiAttachLogStream</code> and <code>aiDetachLogStream</code>. + */ + 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 <code>aiString</code>s. + * + * Assimp strings are zero terminated. + */ + const size_t MAXLEN = 1024; + + /** + * Represents an UTF-8 string, zero byte terminated. + * + * The length of such a string is limited to <code>MAXLEN</code> bytes + * (excluding the terminal \0). + * + * The character set of an aiString is explicitly defined to be UTF-8. This + * Unicode transformation was chosen in the belief that most strings in 3d + * model files are limited to ASCII characters, thus the character set + * needed to be ASCII compatible. + * + * Most text file loaders provide proper Unicode input file handling, + * special unicode characters are correctly transcoded to UTF-8 and are kept + * throughout the libraries' import pipeline. + * + * For most applications, it will be absolutely sufficient to interpret the + * aiString as ASCII data and work with it as one would work with a plain + * char[]. + * + * 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). + * + * This is <em>not</em> the logical length of strings containing UTF-8 + * multibyte sequences, but the number of bytes from the beginning of the + * string to its end. + */ + size_t length; + + /** + * String buffer. + * + * Size limit is <code>MAXLEN</code>. + */ + 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 + * <code>aiAttachPredefinedLogStream()</code>. + */ + 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 + * <code>OutputDebugString</code> 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/src/mesh/assimp-master/port/dAssimp/assimp/versionInfo.d b/src/mesh/assimp-master/port/dAssimp/assimp/versionInfo.d new file mode 100644 index 0000000..5a7e9b9 --- /dev/null +++ b/src/mesh/assimp-master/port/dAssimp/assimp/versionInfo.d @@ -0,0 +1,72 @@ +/* +--------------------------------------------------------------------------- +Open Asset Import Library (ASSIMP) +--------------------------------------------------------------------------- + +Copyright (c) 2006-2020, 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 <code>aiGetCompileFlags()</code>. + */ +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; +} |