Index: trunk/nv/lib/assimp.hh =================================================================== --- trunk/nv/lib/assimp.hh (revision 247) +++ trunk/nv/lib/assimp.hh (revision 247) @@ -0,0 +1,98 @@ +// Copyright (C) 2014 ChaosForge Ltd +// http://chaosforge.org/ +// +// This file is part of NV Libraries. +// For conditions of distribution and use, see copyright notice in nv.hh + +#ifndef NV_LIB_ASSIMP_HH +#define NV_LIB_ASSIMP_HH + +#include +#include +#include +#include + +#define NV_ASSIMP_DYNAMIC +//#define NV_ASSIMP_SHARED + +#if NV_PLATFORM == NV_WINDOWS +# define NV_ASSIMP_PATH "assimp32.dll" +#elif NV_PLATFORM == NV_APPLE +# define NV_ASSIMP_PATH "" +#else +# define NV_ASSIMP_PATH "libassimp32.so" +#endif + +extern "C" { + +#if NV_PLATFORM == NV_WINDOWS +# define NV_ASSIMP_APIENTRY +#else +# define NV_ASSIMP_APIENTRY +#endif + +#if defined(NV_ASSIMP_SHARED) && (NV_PLATFORM == NV_WINDOWS) +# define NV_ASSIMP_API __declspec(dllimport) +#else +# define NV_ASSIMP_API extern +#endif + +#include + +#if defined(NV_ASSIMP_DYNAMIC) +# define NV_ASSIMP_FUN( rtype, fname, fparams ) NV_ASSIMP_API rtype ( NV_ASSIMP_APIENTRY *fname) fparams +#else +# define NV_ASSIMP_FUN( rtype, fname, fparams ) NV_ASSIMP_API rtype NV_ASSIMP_APIENTRY fname fparams +#endif + +#include + +#undef NV_ASSIMP_FUN + +} + +namespace nv +{ + + inline vec3 assimp_vec3_cast( const aiVector3D& v ) + { + return vec3( v.x, v.y, v.z ); + } + + inline vec2 assimp_st_cast( const aiVector3D& v ) + { + return vec2( v.x, 1-v.y ); + } + + inline mat4 assimp_mat4_cast( const aiMatrix4x4& m ) + { + const float* p = (float*)&m; + return glm::transpose( glm::make_mat4( p ) ); + } + + inline quat assimp_quat_cast( const aiQuaternion& q ) + { + return nv::quat( q.w, q.x, q.y, q.z ); + } + + inline void assimp_log_callback( const char* message, char* ) + { + NV_LOG( LOG_DEBUG, rtrimmed( message ) ); + } + + struct assimp_log_guard + { + assimp_log_guard(); + ~assimp_log_guard(); + }; + + /* Dynamic load support */ +# if defined( NV_ASSIMP_DYNAMIC ) + bool load_assimp_library( const char* path = NV_ASSIMP_PATH ); +# else + inline bool load_assimp_library( const char* path = "" ) { return true; } +# endif +} + + +#endif // NV_LIB_ASSIMP_HH Index: trunk/nv/lib/detail/assimp_functions.inc =================================================================== --- trunk/nv/lib/detail/assimp_functions.inc (revision 247) +++ trunk/nv/lib/detail/assimp_functions.inc (revision 247) @@ -0,0 +1,52 @@ +NV_ASSIMP_FUN( const aiScene*, aiImportFile, ( const char* pFile, unsigned int pFlags ) ); +NV_ASSIMP_FUN( const aiScene*, aiImportFileEx, ( const char* pFile, unsigned int pFlags, aiFileIO* pFS ) ); +NV_ASSIMP_FUN( const aiScene*, aiImportFileExWithProperties, ( const char* pFile, unsigned int pFlags, aiFileIO* pFS, const aiPropertyStore* pProps ) ); +NV_ASSIMP_FUN( const aiScene*, aiImportFileFromMemory, ( const char* pBuffer, unsigned int pLength, unsigned int pFlags, const char* pHint ) ); +NV_ASSIMP_FUN( const aiScene*, aiImportFileFromMemoryWithProperties, ( const char* pBuffer, unsigned int pLength, unsigned int pFlags, const char* pHint, const aiPropertyStore* pProps ) ); +NV_ASSIMP_FUN( const aiScene*, aiApplyPostProcessing, ( const aiScene* pScene, unsigned int pFlags ) ); +NV_ASSIMP_FUN( aiLogStream, aiGetPredefinedLogStream, ( aiDefaultLogStream pStreams, const char* file ) ); +NV_ASSIMP_FUN( void, aiAttachLogStream, ( const aiLogStream* stream ) ); +NV_ASSIMP_FUN( void, aiEnableVerboseLogging, (aiBool d) ); +NV_ASSIMP_FUN( aiReturn, aiDetachLogStream, ( const aiLogStream* stream ) ); +NV_ASSIMP_FUN( void, aiDetachAllLogStreams, ( void ) ); +NV_ASSIMP_FUN( void, aiReleaseImport, ( const aiScene* pScene ) ); +NV_ASSIMP_FUN( const char*, aiGetErrorString, () ); +NV_ASSIMP_FUN( aiBool, aiIsExtensionSupported, ( const char* szExtension ) ); +NV_ASSIMP_FUN( void, aiGetExtensionList, ( aiString* szOut ) ); +NV_ASSIMP_FUN( void, aiGetMemoryRequirements, ( const aiScene* pIn, aiMemoryInfo* in ) ); +NV_ASSIMP_FUN( aiPropertyStore*, aiCreatePropertyStore, ( void ) ); +NV_ASSIMP_FUN( void, aiReleasePropertyStore, ( aiPropertyStore* p ) ); +NV_ASSIMP_FUN( void, aiSetImportPropertyInteger, ( aiPropertyStore* store, const char* szName, int value ) ); +NV_ASSIMP_FUN( void, aiSetImportPropertyFloat, ( aiPropertyStore* store, const char* szName, float value ) ); +NV_ASSIMP_FUN( void, aiSetImportPropertyString, ( aiPropertyStore* store, const char* szName, const aiString* st ) ); +NV_ASSIMP_FUN( void, aiCreateQuaternionFromMatrix, ( aiQuaternion* quat, const aiMatrix3x3* mat ) ); +NV_ASSIMP_FUN( void, aiDecomposeMatrix, ( const aiMatrix4x4* mat, aiVector3D* scaling, aiQuaternion* rotation, aiVector3D* position ) ); +NV_ASSIMP_FUN( void, aiTransposeMatrix4, ( aiMatrix4x4* mat) ); +NV_ASSIMP_FUN( void, aiTransposeMatrix3, ( aiMatrix3x3* mat ) ); +NV_ASSIMP_FUN( void, aiTransformVecByMatrix3, ( aiVector3D* vec, const aiMatrix3x3* mat ) ); +NV_ASSIMP_FUN( void, aiTransformVecByMatrix4, ( aiVector3D* vec, const aiMatrix4x4* mat ) ); +NV_ASSIMP_FUN( void, aiMultiplyMatrix4, ( aiMatrix4x4* dst, const aiMatrix4x4* src ) ); +NV_ASSIMP_FUN( void, aiMultiplyMatrix3, ( aiMatrix3x3* dst, const aiMatrix3x3* src ) ); +NV_ASSIMP_FUN( void, aiIdentityMatrix3, ( aiMatrix3x3* mat ) ); +NV_ASSIMP_FUN( void, aiIdentityMatrix4, ( aiMatrix4x4* mat ) ); + +NV_ASSIMP_FUN( size_t, aiGetExportFormatCount, (void) ); +NV_ASSIMP_FUN( const aiExportFormatDesc*, aiGetExportFormatDescription, ( size_t pIndex ) ); +NV_ASSIMP_FUN( void, aiCopyScene, ( const aiScene* pIn, aiScene** pOut ) ); +NV_ASSIMP_FUN( aiReturn, aiExportScene, ( const aiScene* pScene, const char* pFormatId, const char* pFileName, unsigned int pPreprocessing ) ); +NV_ASSIMP_FUN( aiReturn, aiExportSceneEx, ( const aiScene* pScene, const char* pFormatId, const char* pFileName, aiFileIO* pIO, unsigned int pPreprocessing ) ); +NV_ASSIMP_FUN( const aiExportDataBlob*, aiExportSceneToBlob, ( const aiScene* pScene, const char* pFormatId, unsigned int pPreprocessing ) ); +NV_ASSIMP_FUN( void, aiReleaseExportBlob, ( const aiExportDataBlob* pData ) ); + +NV_ASSIMP_FUN( aiReturn, aiGetMaterialProperty, ( const aiMaterial* pMat, const char* pKey, unsigned int type, unsigned int index, const aiMaterialProperty** pPropOut ) ); +NV_ASSIMP_FUN( aiReturn, aiGetMaterialFloatArray, ( const aiMaterial* pMat, const char* pKey, unsigned int type, unsigned int index, float* pOut, unsigned int* pMax ) ); +NV_ASSIMP_FUN( aiReturn, aiGetMaterialIntegerArray, ( const aiMaterial* pMat, const char* pKey, unsigned int type, unsigned int index, int* pOut, unsigned int* pMax ) ); +NV_ASSIMP_FUN( aiReturn, aiGetMaterialColor, ( const aiMaterial* pMat, const char* pKey, unsigned int type, unsigned int index, aiColor4D* pOut ) ); +NV_ASSIMP_FUN( aiReturn, aiGetMaterialString, ( const aiMaterial* pMat, const char* pKey, unsigned int type, unsigned int index, aiString* pOut ) ); +NV_ASSIMP_FUN( unsigned int, aiGetMaterialTextureCount, ( const aiMaterial* pMat, aiTextureType type ) ); +NV_ASSIMP_FUN( aiReturn, aiGetMaterialTexture, ( const aiMaterial* mat, aiTextureType type, unsigned int index, aiString* path, aiTextureMapping* mapping, unsigned int* uvindex, float* blend, aiTextureOp* op, aiTextureMapMode* mapmode, unsigned int* flags ) ); + +NV_ASSIMP_FUN( const char*, aiGetLegalString, (void) ); +NV_ASSIMP_FUN( unsigned int, aiGetVersionMinor, (void) ); +NV_ASSIMP_FUN( unsigned int, aiGetVersionMajor, (void) ); +NV_ASSIMP_FUN( unsigned int, aiGetVersionRevision, (void) ); Index: trunk/nv/lib/detail/assimp_types.inc =================================================================== --- trunk/nv/lib/detail/assimp_types.inc (revision 247) +++ trunk/nv/lib/detail/assimp_types.inc (revision 247) @@ -0,0 +1,619 @@ +#define ASSIMP_CFLAGS_SHARED 0x1 +#define ASSIMP_CFLAGS_STLPORT 0x2 +#define ASSIMP_CFLAGS_DEBUG 0x4 +#define ASSIMP_CFLAGS_NOBOOST 0x8 +#define ASSIMP_CFLAGS_SINGLETHREADED 0x10 + +#define AI_MATH_PI (3.141592653589793238462643383279 ) +#define AI_MATH_TWO_PI (AI_MATH_PI * 2.0) +#define AI_MATH_HALF_PI (AI_MATH_PI * 0.5) + +#define AI_MATH_PI_F (3.1415926538f) +#define AI_MATH_TWO_PI_F (AI_MATH_PI_F * 2.0f) +#define AI_MATH_HALF_PI_F (AI_MATH_PI_F * 0.5f) + +#define AI_DEG_TO_RAD(x) (x*0.0174532925f) +#define AI_RAD_TO_DEG(x) (x*57.2957795f) + +typedef void (*aiLogStreamCallback)(const char* /* message */, char* /* user */); + +struct aiLogStream +{ + aiLogStreamCallback callback; + char* user; +}; + +struct aiPropertyStore { char sentinel; }; + +typedef int aiBool; + +#define AI_FALSE 0 +#define AI_TRUE 1 + +struct aiVector3D +{ + float x,y,z; +}; + +struct aiVector2D +{ + float x,y; +}; + +struct aiColor4D +{ + float r, g, b, a; +}; + +struct aiMatrix3x3 +{ + float a1, a2, a3; + float b1, b2, b3; + float c1, c2, c3; +}; + +struct aiMatrix4x4 +{ + float a1, a2, a3, a4; + float b1, b2, b3, b4; + float c1, c2, c3, c4; + float d1, d2, d3, d4; +}; + +struct aiQuaternion +{ + float w, x, y, z; +}; + +struct aiPlane +{ + float a,b,c,d; +}; + +struct aiRay +{ + aiVector3D pos, dir; +}; + +struct aiColor3D +{ + float r, g, b; +}; + +# define MAXLEN 1024 + +struct aiString +{ + size_t length; + char data[MAXLEN]; +}; + +enum aiReturn +{ + aiReturn_SUCCESS = 0x0, + aiReturn_FAILURE = -0x1, + aiReturn_OUTOFMEMORY = -0x3, + _AI_ENFORCE_ENUM_SIZE = 0x7fffffff +}; + +enum aiOrigin +{ + aiOrigin_SET = 0x0, + aiOrigin_CUR = 0x1, + aiOrigin_END = 0x2, + _AI_ORIGIN_ENFORCE_ENUM_SIZE = 0x7fffffff +}; + +enum aiDefaultLogStream +{ + aiDefaultLogStream_FILE = 0x1, + aiDefaultLogStream_STDOUT = 0x2, + aiDefaultLogStream_STDERR = 0x4, + aiDefaultLogStream_DEBUGGER = 0x8, + _AI_DLS_ENFORCE_ENUM_SIZE = 0x7fffffff +}; + +struct aiMemoryInfo +{ + unsigned int textures; + unsigned int materials; + unsigned int meshes; + unsigned int nodes; + unsigned int animations; + unsigned int cameras; + unsigned int lights; + unsigned int total; +}; + +struct aiTexel +{ + unsigned char b,g,r,a; +}; + +struct aiTexture +{ + unsigned int mWidth; + unsigned int mHeight; + char achFormatHint[4]; + aiTexel* pcData; +}; + +#define AI_MAX_FACE_INDICES 0x7fff +#define AI_MAX_BONE_WEIGHTS 0x7fffffff +#define AI_MAX_VERTICES 0x7fffffff +#define AI_MAX_FACES 0x7fffffff +#define AI_MAX_NUMBER_OF_COLOR_SETS 0x8 +#define AI_MAX_NUMBER_OF_TEXTURECOORDS 0x8 + +struct aiFace +{ + unsigned int mNumIndices; + unsigned int* mIndices; +}; + +struct aiVertexWeight +{ + unsigned int mVertexId; + float mWeight; +}; + +struct aiBone +{ + aiString mName; + unsigned int mNumWeights; + aiVertexWeight* mWeights; + aiMatrix4x4 mOffsetMatrix; +}; +enum aiPrimitiveType +{ + aiPrimitiveType_POINT = 0x1, + aiPrimitiveType_LINE = 0x2, + aiPrimitiveType_TRIANGLE = 0x4, + aiPrimitiveType_POLYGON = 0x8, + _aiPrimitiveType_Force32Bit = 0x9fffffff +}; + +#define AI_PRIMITIVE_TYPE_FOR_N_INDICES(n) \ + ((n) > 3 ? aiPrimitiveType_POLYGON : (aiPrimitiveType)(1u << ((n)-1))) + +struct aiAnimMesh +{ + aiVector3D* mVertices; + aiVector3D* mNormals; + aiVector3D* mTangents; + aiVector3D* mBitangents; + aiColor4D* mColors[AI_MAX_NUMBER_OF_COLOR_SETS]; + aiVector3D* mTextureCoords[AI_MAX_NUMBER_OF_TEXTURECOORDS]; + unsigned int mNumVertices; +}; + +struct aiMesh +{ + unsigned int mPrimitiveTypes; + unsigned int mNumVertices; + unsigned int mNumFaces; + aiVector3D* mVertices; + aiVector3D* mNormals; + aiVector3D* mTangents; + aiVector3D* mBitangents; + aiColor4D* mColors[AI_MAX_NUMBER_OF_COLOR_SETS]; + aiVector3D* mTextureCoords[AI_MAX_NUMBER_OF_TEXTURECOORDS]; + unsigned int mNumUVComponents[AI_MAX_NUMBER_OF_TEXTURECOORDS]; + aiFace* mFaces; + unsigned int mNumBones; + aiBone** mBones; + unsigned int mMaterialIndex; + aiString mName; + unsigned int mNumAnimMeshes; + aiAnimMesh** mAnimMeshes; +}; + +enum aiLightSourceType +{ + aiLightSource_UNDEFINED = 0x0, + aiLightSource_DIRECTIONAL = 0x1, + aiLightSource_POINT = 0x2, + aiLightSource_SPOT = 0x3, + _aiLightSource_Force32Bit = 0x9fffffff +}; + +struct aiLight +{ + aiString mName; + aiLightSourceType mType; + aiVector3D mPosition; + aiVector3D mDirection; + float mAttenuationConstant; + float mAttenuationLinear; + float mAttenuationQuadratic; + aiColor3D mColorDiffuse; + aiColor3D mColorSpecular; + aiColor3D mColorAmbient; + float mAngleInnerCone; + float mAngleOuterCone; +}; + +struct aiCamera +{ + aiString mName; + aiVector3D mPosition; + aiVector3D mUp; + aiVector3D mLookAt; + float mHorizontalFOV; + float mClipPlaneNear; + float mClipPlaneFar; + float mAspect; +}; + +#define AI_DEFAULT_MATERIAL_NAME "DefaultMaterial" + +enum aiTextureOp +{ + aiTextureOp_Multiply = 0x0, + aiTextureOp_Add = 0x1, + aiTextureOp_Subtract = 0x2, + aiTextureOp_Divide = 0x3, + aiTextureOp_SmoothAdd = 0x4, + aiTextureOp_SignedAdd = 0x5, + _aiTextureOp_Force32Bit = 0x9fffffff +}; + +enum aiTextureMapMode +{ + aiTextureMapMode_Wrap = 0x0, + aiTextureMapMode_Clamp = 0x1, + aiTextureMapMode_Decal = 0x3, + aiTextureMapMode_Mirror = 0x2, + _aiTextureMapMode_Force32Bit = 0x9fffffff +}; + +enum aiTextureMapping +{ + aiTextureMapping_UV = 0x0, + aiTextureMapping_SPHERE = 0x1, + aiTextureMapping_CYLINDER = 0x2, + aiTextureMapping_BOX = 0x3, + aiTextureMapping_PLANE = 0x4, + aiTextureMapping_OTHER = 0x5, + _aiTextureMapping_Force32Bit = 0x9fffffff +}; + +enum aiTextureType +{ + aiTextureType_NONE = 0x0, + aiTextureType_DIFFUSE = 0x1, + aiTextureType_SPECULAR = 0x2, + aiTextureType_AMBIENT = 0x3, + aiTextureType_EMISSIVE = 0x4, + aiTextureType_HEIGHT = 0x5, + aiTextureType_NORMALS = 0x6, + aiTextureType_SHININESS = 0x7, + aiTextureType_OPACITY = 0x8, + aiTextureType_DISPLACEMENT = 0x9, + aiTextureType_LIGHTMAP = 0xA, + aiTextureType_REFLECTION = 0xB, + aiTextureType_UNKNOWN = 0xC, + _aiTextureType_Force32Bit = 0x9fffffff +}; + +#define AI_TEXTURE_TYPE_MAX aiTextureType_UNKNOWN + +enum aiShadingMode +{ + aiShadingMode_Flat = 0x1, + aiShadingMode_Gouraud = 0x2, + aiShadingMode_Phong = 0x3, + aiShadingMode_Blinn = 0x4, + aiShadingMode_Toon = 0x5, + aiShadingMode_OrenNayar = 0x6, + aiShadingMode_Minnaert = 0x7, + aiShadingMode_CookTorrance = 0x8, + aiShadingMode_NoShading = 0x9, + aiShadingMode_Fresnel = 0xa, + _aiShadingMode_Force32Bit = 0x9fffffff +}; + +enum aiTextureFlags +{ + aiTextureFlags_Invert = 0x1, + aiTextureFlags_UseAlpha = 0x2, + aiTextureFlags_IgnoreAlpha = 0x4, + _aiTextureFlags_Force32Bit = 0x9fffffff +}; + +enum aiBlendMode +{ + aiBlendMode_Default = 0x0, + aiBlendMode_Additive = 0x1, + _aiBlendMode_Force32Bit = 0x9fffffff +}; + +struct aiUVTransform +{ + aiVector2D mTranslation; + aiVector2D mScaling; + float mRotation; +}; + +enum aiPropertyTypeInfo +{ + aiPTI_Float = 0x1, + aiPTI_String = 0x3, + aiPTI_Integer = 0x4, + aiPTI_Buffer = 0x5, + _aiPTI_Force32Bit = 0x9fffffff +}; + +struct aiMaterialProperty +{ + aiString mKey; + unsigned int mSemantic; + unsigned int mIndex; + unsigned int mDataLength; + aiPropertyTypeInfo mType; + char* mData; +}; + +struct aiMaterial +{ + aiMaterialProperty** mProperties; + unsigned int mNumProperties; + unsigned int mNumAllocated; +}; + +#define AI_MATKEY_NAME "?mat.name",0,0 +#define AI_MATKEY_TWOSIDED "$mat.twosided",0,0 +#define AI_MATKEY_SHADING_MODEL "$mat.shadingm",0,0 +#define AI_MATKEY_ENABLE_WIREFRAME "$mat.wireframe",0,0 +#define AI_MATKEY_BLEND_FUNC "$mat.blend",0,0 +#define AI_MATKEY_OPACITY "$mat.opacity",0,0 +#define AI_MATKEY_BUMPSCALING "$mat.bumpscaling",0,0 +#define AI_MATKEY_SHININESS "$mat.shininess",0,0 +#define AI_MATKEY_REFLECTIVITY "$mat.reflectivity",0,0 +#define AI_MATKEY_SHININESS_STRENGTH "$mat.shinpercent",0,0 +#define AI_MATKEY_REFRACTI "$mat.refracti",0,0 +#define AI_MATKEY_COLOR_DIFFUSE "$clr.diffuse",0,0 +#define AI_MATKEY_COLOR_AMBIENT "$clr.ambient",0,0 +#define AI_MATKEY_COLOR_SPECULAR "$clr.specular",0,0 +#define AI_MATKEY_COLOR_EMISSIVE "$clr.emissive",0,0 +#define AI_MATKEY_COLOR_TRANSPARENT "$clr.transparent",0,0 +#define AI_MATKEY_COLOR_REFLECTIVE "$clr.reflective",0,0 +#define AI_MATKEY_GLOBAL_BACKGROUND_IMAGE "?bg.global",0,0 + +#define _AI_MATKEY_TEXTURE_BASE "$tex.file" +#define _AI_MATKEY_UVWSRC_BASE "$tex.uvwsrc" +#define _AI_MATKEY_TEXOP_BASE "$tex.op" +#define _AI_MATKEY_MAPPING_BASE "$tex.mapping" +#define _AI_MATKEY_TEXBLEND_BASE "$tex.blend" +#define _AI_MATKEY_MAPPINGMODE_U_BASE "$tex.mapmodeu" +#define _AI_MATKEY_MAPPINGMODE_V_BASE "$tex.mapmodev" +#define _AI_MATKEY_TEXMAP_AXIS_BASE "$tex.mapaxis" +#define _AI_MATKEY_UVTRANSFORM_BASE "$tex.uvtrafo" +#define _AI_MATKEY_TEXFLAGS_BASE "$tex.flags" + +struct aiVectorKey +{ + double mTime; + aiVector3D mValue; +}; + +struct aiQuatKey +{ + double mTime; + aiQuaternion mValue; +}; + +struct aiMeshKey +{ + double mTime; + unsigned int mValue; +}; + +enum aiAnimBehaviour +{ + aiAnimBehaviour_DEFAULT = 0x0, + aiAnimBehaviour_CONSTANT = 0x1, + aiAnimBehaviour_LINEAR = 0x2, + aiAnimBehaviour_REPEAT = 0x3, + _aiAnimBehaviour_Force32Bit = 0x8fffffff +}; + +struct aiNodeAnim +{ + aiString mNodeName; + unsigned int mNumPositionKeys; + aiVectorKey* mPositionKeys; + unsigned int mNumRotationKeys; + aiQuatKey* mRotationKeys; + unsigned int mNumScalingKeys; + aiVectorKey* mScalingKeys; + aiAnimBehaviour mPreState; + aiAnimBehaviour mPostState; +}; + +struct aiMeshAnim +{ + aiString mName; + unsigned int mNumKeys; + aiMeshKey* mKeys; +}; + +struct aiAnimation +{ + aiString mName; + double mDuration; + double mTicksPerSecond; + unsigned int mNumChannels; + aiNodeAnim** mChannels; + unsigned int mNumMeshChannels; + aiMeshAnim** mMeshChannels; +}; + +struct aiNode +{ + aiString mName; + aiMatrix4x4 mTransformation; + aiNode* mParent; + unsigned int mNumChildren; + aiNode** mChildren; + unsigned int mNumMeshes; + unsigned int* mMeshes; +}; + +#define AI_SCENE_FLAGS_INCOMPLETE 0x1 +#define AI_SCENE_FLAGS_VALIDATED 0x2 +#define AI_SCENE_FLAGS_VALIDATION_WARNING 0x4 +#define AI_SCENE_FLAGS_NON_VERBOSE_FORMAT 0x8 +#define AI_SCENE_FLAGS_TERRAIN 0x10 + +struct aiScene +{ + unsigned int mFlags; + aiNode* mRootNode; + unsigned int mNumMeshes; + aiMesh** mMeshes; + unsigned int mNumMaterials; + aiMaterial** mMaterials; + unsigned int mNumAnimations; + aiAnimation** mAnimations; + unsigned int mNumTextures; + aiTexture** mTextures; + unsigned int mNumLights; + aiLight** mLights; + unsigned int mNumCameras; + aiCamera** mCameras; + char* mPrivate; +}; + +struct aiExportFormatDesc +{ + const char* id; + const char* description; + const char* fileExtension; +}; + +struct aiExportDataBlob +{ + size_t size; + void* data; + aiString name; + aiExportDataBlob * next; +}; + +enum aiImporterFlags +{ + aiImporterFlags_SupportTextFlavour = 0x1, + aiImporterFlags_SupportBinaryFlavour = 0x2, + aiImporterFlags_SupportCompressedFlavour = 0x4, + aiImporterFlags_LimitedSupport = 0x8, + aiImporterFlags_Experimental = 0x10, +}; + +struct aiImporterDesc +{ + const char* mName; + const char* mAuthor; + const char* mMaintainer; + const char* mComments; + unsigned int mFlags; + unsigned int mMinMajor; + unsigned int mMinMinor; + unsigned int mMaxMajor; + unsigned int mMaxMinor; + const char* mFileExtensions; +}; + +enum aiPostProcessSteps +{ + aiProcess_CalcTangentSpace = 0x1, + aiProcess_JoinIdenticalVertices = 0x2, + aiProcess_MakeLeftHanded = 0x4, + aiProcess_Triangulate = 0x8, + aiProcess_RemoveComponent = 0x10, + aiProcess_GenNormals = 0x20, + aiProcess_GenSmoothNormals = 0x40, + aiProcess_SplitLargeMeshes = 0x80, + aiProcess_PreTransformVertices = 0x100, + aiProcess_LimitBoneWeights = 0x200, + aiProcess_ValidateDataStructure = 0x400, + aiProcess_ImproveCacheLocality = 0x800, + aiProcess_RemoveRedundantMaterials = 0x1000, + aiProcess_FixInfacingNormals = 0x2000, + aiProcess_SortByPType = 0x8000, + aiProcess_FindDegenerates = 0x10000, + aiProcess_FindInvalidData = 0x20000, + aiProcess_GenUVCoords = 0x40000, + aiProcess_TransformUVCoords = 0x80000, + aiProcess_FindInstances = 0x100000, + aiProcess_OptimizeMeshes = 0x200000, + aiProcess_OptimizeGraph = 0x400000, + aiProcess_FlipUVs = 0x800000, + aiProcess_FlipWindingOrder = 0x1000000, + aiProcess_SplitByBoneCount = 0x2000000, + aiProcess_Debone = 0x4000000 +}; + +#define aiProcessPreset_TargetRealtime_Fast ( \ + aiProcess_CalcTangentSpace | \ + aiProcess_GenNormals | \ + aiProcess_JoinIdenticalVertices | \ + aiProcess_Triangulate | \ + aiProcess_GenUVCoords | \ + aiProcess_SortByPType | \ + 0 ) + +#define aiProcessPreset_TargetRealtime_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 | \ + 0 ) + +#define aiProcessPreset_TargetRealtime_MaxQuality ( \ + aiProcessPreset_TargetRealtime_Quality | \ + aiProcess_FindInstances | \ + aiProcess_ValidateDataStructure | \ + aiProcess_OptimizeMeshes | \ + aiProcess_Debone | \ + 0 ) + +struct aiFile; +struct aiFileIO; + +typedef size_t (*aiFileWriteProc) (aiFile*, const char*, size_t, size_t); +typedef size_t (*aiFileReadProc) (aiFile*, char*, size_t,size_t); +typedef size_t (*aiFileTellProc) (aiFile*); +typedef void (*aiFileFlushProc) (aiFile*); +typedef aiReturn (*aiFileSeek)(aiFile*, size_t, aiOrigin); + +typedef aiFile* (*aiFileOpenProc) (aiFileIO*, const char*, const char*); +typedef void (*aiFileCloseProc) (aiFileIO*, aiFile*); + +typedef char* aiUserData; + +struct aiFileIO +{ + aiFileOpenProc OpenProc; + aiFileCloseProc CloseProc; + aiUserData UserData; +}; + +struct aiFile +{ + aiFileReadProc ReadProc; + aiFileWriteProc WriteProc; + aiFileTellProc TellProc; + aiFileTellProc FileSizeProc; + aiFileSeek SeekProc; + aiFileFlushProc FlushProc; + aiUserData UserData; +}; +