Advertisement
Guest User

Untitled

a guest
Apr 26th, 2017
286
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 13.49 KB | None | 0 0
  1. #include "SimpleInterface.h"
  2. #include <assimp/scene.h>
  3. //Scene
  4. bool aiScene_HasMaterials(const aiScene *ptrScene) {
  5.     return ptrScene->HasAnimations();
  6. }
  7. unsigned int aiScene_GetNumMaterials(const aiScene *ptrScene) {
  8.     return ptrScene->mNumMaterials;
  9. }
  10. unsigned int aiScene_GetNumMeshes(const aiScene *ptrScene) {
  11.     return ptrScene->mNumMeshes;
  12. }
  13. unsigned int aiScene_GetNumAnimations(const aiScene *ptrScene) {
  14.     return ptrScene->mNumAnimations;
  15. }
  16. bool aiScene_HasMeshes(const aiScene *ptrScene) {
  17.     return ptrScene->HasMeshes();
  18. }
  19. bool aiScene_HasAnimation(const aiScene *ptrScene) {
  20.     return ptrScene->HasAnimations();
  21. }
  22. const aiNode* aiScene_GetRootNode(const aiScene *ptrScene) {
  23.     return ptrScene->mRootNode;
  24. }
  25. const aiMaterial* aiScene_GetMaterial(const aiScene *ptrScene, unsigned int uintIndex) {
  26.     return ptrScene->mMaterials[uintIndex];
  27. }
  28. const aiMesh* aiScene_GetMesh(const aiScene *ptrScene, unsigned int uintIndex) {
  29.     return ptrScene->mMeshes[uintIndex];
  30. }
  31. const aiAnimation* aiScene_GetAnimation(const aiScene *ptrScene, unsigned int uintIndex) {
  32.     return ptrScene->mAnimations[uintIndex];
  33. }
  34. //Nodes
  35. const char* aiNode_GetName(const aiNode *ptrNode) {
  36.     return ptrNode->mName.C_Str();
  37. }
  38. unsigned int aiNode_GetNumChildren(const aiNode *ptrNode) {
  39.     return ptrNode->mNumChildren;
  40. }
  41. unsigned int aiNode_GetNumMeshes(const aiNode *ptrNode) {
  42.     return ptrNode->mNumMeshes;
  43. }
  44. const aiNode* aiNode_GetChildren(const aiNode *ptrNode, unsigned int uintIndex) {
  45.     return ptrNode->mChildren[uintIndex];
  46. }
  47. unsigned int aiNode_GetMeshIndex(const aiNode *ptrNode, unsigned int uintIndex) {
  48.     return ptrNode->mMeshes[uintIndex];
  49. }
  50. const aiNode* aiNode_GetParent(const aiNode *ptrNode) {
  51.     return ptrNode->mParent;
  52. }
  53. const aiMatrix4x4* aiNode_GetTransformation(const aiNode *ptrNode) {
  54.     return &ptrNode->mTransformation;
  55. }
  56. //Material
  57. bool aiMaterial_HasProperty(const aiMaterial *ptrMat, const char *strKey, unsigned int uintType, unsigned int uintIndex) {
  58.     for (unsigned int i = 0; i < ptrMat->mNumProperties; i++) {
  59.         aiMaterialProperty *pProp = ptrMat->mProperties[i];
  60.         if (pProp->mIndex == uintIndex && strcmp(pProp->mKey.C_Str(), strKey)) {
  61.             return true;
  62.         }
  63.     }
  64.     return false;
  65. }
  66. unsigned int aiMaterial_GetTextureCount(const aiMaterial *ptrMat, unsigned int uintType) {
  67.     return ptrMat->GetTextureCount(static_cast<aiTextureType>(uintType));
  68. }
  69. bool aiMaterial_HasTextureDiffuse(const aiMaterial *ptrMat, unsigned int uintType) {
  70.     return aiMaterial_HasProperty(ptrMat, AI_MATKEY_TEXTURE_DIFFUSE(uintType));
  71. }
  72. bool aiMaterial_GetTextureDiffuse(const aiMaterial *ptrMat, unsigned int uintType, char *strPath, unsigned int *uintMapping, unsigned int *uintUvIndex, ai_real *floatBlend, unsigned int *uintOp, unsigned int *uintMapMode) {
  73.     aiString *pString = new aiString();
  74.     bool success = AI_SUCCESS == ptrMat->GetTexture(aiTextureType_DIFFUSE, uintType, pString, (aiTextureMapping*)uintMapping, uintUvIndex, floatBlend, (aiTextureOp*)uintOp, (aiTextureMapMode*)uintMapMode);
  75.     strcpy(strPath, pString->C_Str());
  76.     delete(pString);
  77.     return success;
  78. }
  79. bool aiMaterial_HasTextureEmissive(const aiMaterial *ptrMat, unsigned int uintIndex) {
  80.     return aiMaterial_HasProperty(ptrMat, AI_MATKEY_TEXTURE_EMISSIVE(uintIndex));
  81. }
  82. bool aiMaterial_GetTextureEmissive(const aiMaterial *ptrMat, unsigned int uintIndex, char *strPath, unsigned int *uintMapping, unsigned int *uintUvIndex, ai_real *floatBlend, unsigned int *uintOp, unsigned int *uintMapMode) {
  83.     aiString *pString = new aiString();
  84.     bool success = AI_SUCCESS == ptrMat->GetTexture(aiTextureType_EMISSIVE, uintIndex, pString, (aiTextureMapping*)uintMapping, uintUvIndex, floatBlend, (aiTextureOp*)uintOp, (aiTextureMapMode*)uintMapMode);
  85.     strcpy(strPath, pString->C_Str());
  86.     delete(pString);
  87.     return success;
  88. }
  89. bool aiMaterial_HasTextureSpecular(const aiMaterial *ptrMat, unsigned int uintIndex) {
  90.     return aiMaterial_HasProperty(ptrMat, AI_MATKEY_TEXTURE_SPECULAR(uintIndex));
  91. }
  92. bool aiMaterial_GetTextureSpecular(const aiMaterial *ptrMat, unsigned int uintIndex, char *strPath, unsigned int *uintMapping, unsigned int *uintUvIndex, ai_real *floatBlend, unsigned int *uintOp, unsigned int *uintMapMode) {
  93.     aiString *pString = new aiString();
  94.     bool success = AI_SUCCESS == ptrMat->GetTexture(aiTextureType_SPECULAR, uintIndex, pString, (aiTextureMapping*)uintMapping, uintUvIndex, floatBlend, (aiTextureOp*)uintOp, (aiTextureMapMode*)uintMapMode);
  95.     strcpy(strPath, pString->C_Str());
  96.     delete(pString);
  97.     return success;
  98. }
  99. bool aiMaterial_HasTextureNormals(const aiMaterial *ptrMat, unsigned int uintIndex) {
  100.     return aiMaterial_HasProperty(ptrMat, AI_MATKEY_TEXTURE_NORMALS(uintIndex));
  101. }
  102. bool aiMaterial_GetTextureNormals(const aiMaterial *ptrMat, unsigned int uintIndex, char *strPath, unsigned int *uintMapping, unsigned int *uintUvIndex, ai_real *floatBlend, unsigned int *uintOp, unsigned int *uintMapMode) {
  103.     aiString *pString = new aiString();
  104.     bool success = AI_SUCCESS == ptrMat->GetTexture(aiTextureType_NORMALS, uintIndex, pString, (aiTextureMapping*)uintMapping, uintUvIndex, floatBlend, (aiTextureOp*)uintOp, (aiTextureMapMode*)uintMapMode);
  105.     strcpy(strPath, pString->C_Str());
  106.     delete(pString);
  107.     return success;
  108. }
  109. bool aiMaterial_HasTextureHeight(const aiMaterial *ptrMat, unsigned int uintIndex) {
  110.     return aiMaterial_HasProperty(ptrMat, AI_MATKEY_TEXTURE_HEIGHT(uintIndex));
  111. }
  112. bool aiMaterial_GetTextureHeight(const aiMaterial *ptrMat, unsigned int uintIndex, char *strPath, unsigned int *uintMapping, unsigned int *uintUvIndex, ai_real *floatBlend, unsigned int *uintOp, unsigned int *uintMapMode) {
  113.     aiString *pString = new aiString();
  114.     bool success = AI_SUCCESS == ptrMat->GetTexture(aiTextureType_HEIGHT, uintIndex, pString, (aiTextureMapping*)uintMapping, uintUvIndex, floatBlend, (aiTextureOp*)uintOp, (aiTextureMapMode*)uintMapMode);
  115.     strcpy(strPath, pString->C_Str());
  116.     delete(pString);
  117.     return success;
  118. }
  119. bool aiMaterial_HasAmbient(const aiMaterial *ptrMat) {
  120.     return aiMaterial_HasProperty(ptrMat, AI_MATKEY_COLOR_AMBIENT);
  121. }
  122. bool aiMaterial_GetAmbient(const aiMaterial *ptrMat, aiColor4D *colorOut) {
  123.     return AI_SUCCESS == aiGetMaterialColor(ptrMat, AI_MATKEY_COLOR_AMBIENT, colorOut);
  124. }
  125. bool aiMaterial_HasDiffuse(const aiMaterial *ptrMat) {
  126.     return aiMaterial_HasProperty(ptrMat, AI_MATKEY_COLOR_DIFFUSE);
  127. }
  128. bool aiMaterial_GetDiffuse(const aiMaterial *ptrMat, aiColor4D *colorOut) {
  129.     return AI_SUCCESS == aiGetMaterialColor(ptrMat, AI_MATKEY_COLOR_DIFFUSE, colorOut);
  130. }
  131. bool aiMaterial_HasSpecular(const aiMaterial *ptrMat) {
  132.     return aiMaterial_HasProperty(ptrMat, AI_MATKEY_COLOR_SPECULAR);
  133. }
  134. bool aiMaterial_GetSpecular(const aiMaterial *ptrMat, aiColor4D *colorOut) {
  135.     return AI_SUCCESS == aiGetMaterialColor(ptrMat, AI_MATKEY_COLOR_SPECULAR, colorOut);
  136. }
  137. bool aiMaterial_HasEmissive(const aiMaterial *ptrMat) {
  138.     return aiMaterial_HasProperty(ptrMat, AI_MATKEY_COLOR_EMISSIVE);
  139. }
  140. bool aiMaterial_GetEmissive(const aiMaterial *ptrMat, aiColor4D *colorOut) {
  141.     return AI_SUCCESS == aiGetMaterialColor(ptrMat, AI_MATKEY_COLOR_EMISSIVE, colorOut);
  142. }
  143. bool aiMaterial_HasName(const aiMaterial *ptrMat) {
  144.     return aiMaterial_HasProperty(ptrMat, AI_MATKEY_NAME);
  145. }
  146. bool aiMaterial_GetName(const aiMaterial *ptrMat, char *strName) {
  147.     aiString *pString = new aiString();
  148.     bool success = AI_SUCCESS == aiGetMaterialString(ptrMat, AI_MATKEY_NAME, pString);
  149.     strcpy(strName, pString->C_Str());
  150.     delete(pString);
  151.     return success;
  152. }
  153. bool aiMaterial_HasBumpScaling(const aiMaterial *ptrMat) {
  154.     return aiMaterial_HasProperty(ptrMat, AI_MATKEY_BUMPSCALING);
  155. }
  156. bool aiMaterial_GetBumpScaling(const aiMaterial *ptrMat, ai_real *floatOut) {
  157.     return AI_SUCCESS == aiGetMaterialFloat(ptrMat, AI_MATKEY_BUMPSCALING, floatOut);
  158. }
  159. bool aiMaterial_HasShininess(const aiMaterial *ptrMat) {
  160.     return aiMaterial_HasProperty(ptrMat, AI_MATKEY_SHININESS);
  161. }
  162. bool aiMaterial_GetShininess(const aiMaterial *ptrMat, ai_real *floatOut) {
  163.     return AI_SUCCESS == aiGetMaterialFloat(ptrMat, AI_MATKEY_SHININESS, floatOut);
  164. }
  165. bool aiMaterial_HasShininessStrength(const aiMaterial *ptrMat) {
  166.     return aiMaterial_HasProperty(ptrMat, AI_MATKEY_SHININESS_STRENGTH);
  167. }
  168. bool aiMaterial_GetShininessStrength(const aiMaterial *ptrMat, ai_real *floatOut) {
  169.     return AI_SUCCESS == aiGetMaterialFloat(ptrMat, AI_MATKEY_SHININESS_STRENGTH, floatOut);
  170. }
  171. //Mesh
  172. unsigned int aiMesh_VertexCount(const aiMesh *ptrMesh) {
  173.     return ptrMesh->mNumVertices;
  174. }
  175. bool aiMesh_HasNormals(const aiMesh *ptrMesh) {
  176.     return ptrMesh->HasNormals();
  177. }
  178. bool aiMesh_HasTangentsAndBitangents(const aiMesh *ptrMesh) {
  179.     return ptrMesh->HasTangentsAndBitangents();
  180. }
  181. bool aiMesh_HasTextureCoords(const aiMesh *ptrMesh, unsigned int uintIndex) {
  182.     return ptrMesh->HasTextureCoords(uintIndex);
  183. }
  184. bool aiMesh_HasVertexColors(const aiMesh *ptrMesh, unsigned int uintIndex) {
  185.     return ptrMesh->HasVertexColors(uintIndex);
  186. }
  187. const aiVector3D* aiMesh_GetVertex(const aiMesh *ptrMesh, unsigned int uintIndex) {
  188.     return &ptrMesh->mVertices[uintIndex];
  189. }
  190. const aiVector3D* aiMesh_GetNormal(const aiMesh *ptrMesh, unsigned int uintIndex) {
  191.     return &ptrMesh->mNormals[uintIndex];
  192. }
  193. const aiVector3D* aiMesh_GetTangent(const aiMesh *ptrMesh, unsigned int uintIndex) {
  194.     return &ptrMesh->mTangents[uintIndex];
  195. }
  196. const aiVector3D* aiMesh_GetBitangent(const aiMesh *ptrMesh, unsigned int uintIndex) {
  197.     return &ptrMesh->mBitangents[uintIndex];
  198. }
  199. const aiVector3D* aiMesh_GetTextureCoord(const aiMesh *ptrMesh, unsigned int uintIndex) {
  200.     return ptrMesh->mTextureCoords[uintIndex];
  201. }
  202. const aiColor4D* aiMesh_GetVertexColor(const aiMesh *ptrMesh, unsigned int uintIndex) {
  203.     return ptrMesh->mColors[uintIndex];
  204. }
  205. const char* aiMesh_GetName(const aiMesh *ptrMesh) {
  206.     return ptrMesh->mName.C_Str();
  207. }
  208. bool aiMesh_HasFaces(const aiMesh *ptrMesh) {
  209.     return ptrMesh->HasFaces();
  210. }
  211. unsigned int aiMesh_GetNumFaces(const aiMesh *ptrMesh) {
  212.     return ptrMesh->mNumFaces;
  213. }
  214. const aiFace* aiMesh_GetFace(const aiMesh *ptrMesh, unsigned int uintIndex) {
  215.     return &ptrMesh->mFaces[uintIndex];
  216. }
  217. bool aiMesh_HasBones(const aiMesh *ptrMesh) {
  218.     return ptrMesh->HasBones();
  219. }
  220. unsigned int aiMesh_GetNumBones(const aiMesh *ptrMesh) {
  221.     return ptrMesh->mNumBones;
  222. }
  223. const aiBone* aiMesh_GetBone(const aiMesh *ptrMesh, unsigned int uintIndex) {
  224.     return ptrMesh->mBones[uintIndex];
  225. }
  226. //Faces
  227. unsigned int aiFace_GetNumIndices(const aiFace *ptrFace) {
  228.     return ptrFace->mNumIndices;
  229. }
  230. unsigned int aiFace_GetIndex(const aiFace *ptrFace, unsigned int uintIndex) {
  231.     return ptrFace->mIndices[uintIndex];
  232. }
  233. //Bones
  234. const char* aiBone_GetName(const aiBone *ptrBone) {
  235.     return ptrBone->mName.C_Str();
  236. }
  237. unsigned int aiBone_GetNumWeights(const aiBone *ptrBone) {
  238.     return ptrBone->mNumWeights;
  239. }
  240. const aiVertexWeight* aiBone_GetWeights(const aiBone *ptrBone, unsigned int uintIndex) {
  241.     return &ptrBone->mWeights[uintIndex];
  242. }
  243. const aiMatrix4x4* aiBone_GetOffsetMatrix(const aiBone *ptrBone) {
  244.     return &ptrBone->mOffsetMatrix;
  245. }
  246. //Vertex Weight
  247. const float aiVertexWeight_GetWeight(const aiVertexWeight *ptrVweight) {
  248.     return ptrVweight->mWeight;
  249. }
  250. const unsigned int aiVertexWeight_GetVertexId(const aiVertexWeight *ptrVweight) {
  251.     return ptrVweight->mVertexId;
  252. }
  253. //Animation
  254. const char* aiAnimation_GetName(const aiAnimation *ptrAnimation) {
  255.     return ptrAnimation->mName.C_Str();
  256. }
  257. float aiAnimation_GetDuraction(const aiAnimation *ptrAnimation) {
  258.     return ptrAnimation->mDuration;
  259. }
  260. float aiAnimation_GetTicksPerSecond(const aiAnimation *ptrAnimation) {
  261.     return ptrAnimation->mTicksPerSecond;
  262. }
  263. unsigned int aiAnimation_GetNumChannels(const aiAnimation *ptrAnimation) {
  264.     return ptrAnimation->mNumChannels;
  265. }
  266. unsigned int aiAnimation_GetNumMorphChannels(const aiAnimation *ptrAnimation) {
  267.     return ptrAnimation->mNumMorphMeshChannels;
  268. }
  269. unsigned int aiAnimation_GetNumMeshChannels(const aiAnimation *ptrAnimation) {
  270.     return ptrAnimation->mNumMeshChannels;
  271. }
  272. const aiNodeAnim* aiAnimation_GetAnimationChannel(const aiAnimation *ptrAnimation, unsigned int uintIndex) {
  273.     return ptrAnimation->mChannels[uintIndex];
  274. }
  275. //Animation Channel
  276. const char* aiNodeAnim_GetNodeName(const aiNodeAnim *ptrNodeAnim) {
  277.     return ptrNodeAnim->mNodeName.C_Str();
  278. }
  279. unsigned int aiNodeAnim_GetNumPositionKeys(const aiNodeAnim *ptrNodeAnim) {
  280.     return ptrNodeAnim->mNumPositionKeys;
  281. }
  282. unsigned int aiNodeAnim_GetNumRotationKeys(const aiNodeAnim *ptrNodeAnim) {
  283.     return ptrNodeAnim->mNumRotationKeys;
  284. }
  285. unsigned int aiNodeAnim_GetNumScalingKeys(const aiNodeAnim *ptrNodeAnim) {
  286.     return ptrNodeAnim->mNumScalingKeys;
  287. }
  288. unsigned int aiNodeAnim_GetPostState(const aiNodeAnim *ptrNodeAnim) {
  289.     return ptrNodeAnim->mPostState;
  290. }
  291. unsigned int aiNodeAnim_GetPreState(const aiNodeAnim *ptrNodeAnim) {
  292.     return ptrNodeAnim->mPreState;
  293. }
  294. const aiVectorKey* aiNodeAnim_GetPositionKey(const aiNodeAnim *ptrNodeAnim, unsigned int uintIndex) {
  295.     return &ptrNodeAnim->mPositionKeys[uintIndex];
  296. }
  297. const aiQuatKey* aiNodeAnim_GetRotationKey(const aiNodeAnim *ptrNodeAnim, unsigned int uintIndex) {
  298.     return &ptrNodeAnim->mRotationKeys[uintIndex];
  299. }
  300. const aiVectorKey* aiNodeAnim_GetScalingKey(const aiNodeAnim *ptrNodeAnim, unsigned int uintIndex) {
  301.     return &ptrNodeAnim->mScalingKeys[uintIndex];
  302. }
  303. //Animation Vector Key
  304. float aiVectorKey_GetTime(const aiVectorKey *ptrVectorKey) {
  305.     return ptrVectorKey->mTime;
  306. }
  307. const aiVector3D* aiVectorKey_GetValue(const aiVectorKey *ptrVectorKey) {
  308.     return &ptrVectorKey->mValue;
  309. }
  310. //Animation Quat Key
  311. float aiQuatKey_GetTime(const aiQuatKey *ptrQuatKey) {
  312.     return ptrQuatKey->mTime;
  313. }
  314. const aiQuaternion* aiQuatKey_GetValue(const aiQuatKey *ptrQuatKey) {
  315.     return &ptrQuatKey->mValue;
  316. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement