720 lines
24 KiB
C++
720 lines
24 KiB
C++
/*
|
|
---------------------------------------------------------------------------
|
|
Open Asset Import Library (ASSIMP)
|
|
---------------------------------------------------------------------------
|
|
|
|
Copyright (c) 2006-2008, 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.
|
|
---------------------------------------------------------------------------
|
|
*/
|
|
|
|
/** @file Implementation of the JNI API for jAssimp */
|
|
|
|
#if (defined ASSIMP_JNI_EXPORT)
|
|
|
|
// include the header files generated by javah
|
|
#include "assimp_Importer.h"
|
|
#include "assimp_Animation.h"
|
|
#include "assimp_Node.h"
|
|
#include "assimp_Texture.h"
|
|
#include "assimp_Mesh.h"
|
|
#include "assimp_Material.h"
|
|
|
|
// include assimp
|
|
#include "../../include/aiTypes.h"
|
|
#include "../../include/aiMesh.h"
|
|
#include "../../include/aiAnim.h"
|
|
#include "../../include/aiScene.h"
|
|
#include "../../include/aiAssert.h"
|
|
#include "../../include/aiPostProcess.h"
|
|
#include "../../include/assimp.hpp"
|
|
|
|
#include "../../include/DefaultLogger.h"
|
|
|
|
#include "JNIEnvironment.h"
|
|
#include "JNILogger.h"
|
|
|
|
using namespace Assimp;
|
|
|
|
#include <list>
|
|
|
|
namespace Assimp {
|
|
namespace JNIBridge {
|
|
|
|
// used as error return code
|
|
#define AI_JNI_ERROR_RETURN 0xffffffff
|
|
|
|
// typedef for a jassimp context, used to uniquely identify
|
|
// the Importer object which belongs to a java Importer
|
|
|
|
typedef uint64_t JASSIMP_CONTEXT;
|
|
|
|
#if (defined _DEBUG)
|
|
|
|
typedef std::list< JASSIMP_CONTEXT > ImporterContextList;
|
|
static ImporterContextList g_listActiveContexts;
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
/* Used in debug builds to validate a context
|
|
*/
|
|
bool jValidateContext (JASSIMP_CONTEXT context)
|
|
{
|
|
for (ImporterContextList::const_iterator
|
|
i = g_listActiveContexts.begin();
|
|
i != g_listActiveContexts.end();++i)
|
|
{
|
|
if (context == *i)return true;
|
|
}
|
|
DefaultLogger::get()->error("[jnibridge] Invalid context");
|
|
return false;
|
|
}
|
|
// ------------------------------------------------------------------------------------------------
|
|
/* Used in debug builds to validate a given scene
|
|
*/
|
|
bool jValidateScene (const aiScene* scene)
|
|
{
|
|
if (!scene)
|
|
{
|
|
DefaultLogger::get()->error("[jnibridge] No asset loaded at the moment");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
#endif // ! ASSIMP_DEBUG
|
|
// ------------------------------------------------------------------------------------------------
|
|
/* Used in debug builds to validate a given scene
|
|
*/
|
|
Assimp::Importer* jGetValidImporterScenePair (JASSIMP_CONTEXT jvmcontext)
|
|
{
|
|
#if (defined _DEBUG)
|
|
if (!jValidateContext((JASSIMP_CONTEXT)jvmcontext))return NULL;
|
|
#endif // ! ASSIMP_DEBUG
|
|
|
|
// get the importer instance from the context
|
|
Assimp::Importer* pcImp = (Assimp::Importer*)jvmcontext;
|
|
|
|
#if (defined _DEBUG)
|
|
if (!jValidateScene(pcImp->GetScene()))return NULL;
|
|
#endif // ! ASSIMP_DEBUG
|
|
return pcImp;
|
|
}
|
|
// ------------------------------------------------------------------------------------------------
|
|
/*
|
|
* Class: assimp_Importer
|
|
* Method: _NativeInitContext
|
|
* Signature: ()I
|
|
*/
|
|
JNIEXPORT jlong JNICALL Java_assimp_Importer__1NativeInitContext
|
|
(JNIEnv * jvmenv, jobject jvmthis)
|
|
{
|
|
// 2^64-1 indicates error
|
|
JASSIMP_CONTEXT context = 0xffffffffffffffffL;
|
|
|
|
// create a new Importer instance
|
|
Assimp::Importer* pcImp = new Assimp::Importer();
|
|
context = (JASSIMP_CONTEXT)(uintptr_t)pcImp;
|
|
|
|
#if (defined _DEBUG)
|
|
g_listActiveContexts.push_back(context);
|
|
#endif // ! ASSIMP_DEBUG
|
|
|
|
// need to setup the logger
|
|
JNILogDispatcher* pcLogger;
|
|
if (DefaultLogger::isNullLogger())
|
|
{
|
|
pcLogger = new JNILogDispatcher();
|
|
DefaultLogger::set (pcLogger);
|
|
}
|
|
else
|
|
{
|
|
JNILogDispatcher* pcLogger = ( JNILogDispatcher* )DefaultLogger::get();
|
|
pcLogger->AddRef();
|
|
}
|
|
|
|
// setup the JNI environment ...
|
|
// simply setup the newest JNIEnv*
|
|
JNIEnvironment::Get()->AttachToCurrentThread(jvmenv);
|
|
|
|
return context;
|
|
}
|
|
// ------------------------------------------------------------------------------------------------
|
|
/*
|
|
* Class: assimp_Importer
|
|
* Method: _NativeFreeContext
|
|
* Signature: (I)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_assimp_Importer__1NativeFreeContext
|
|
(JNIEnv * jvmenv, jobject jvmthis, jlong jvmcontext)
|
|
{
|
|
|
|
#if (defined _DEBUG)
|
|
if (!jValidateContext((JASSIMP_CONTEXT)jvmcontext))return AI_JNI_ERROR_RETURN;
|
|
#endif // ! ASSIMP_DEBUG
|
|
|
|
// delete the Importer instance
|
|
Assimp::Importer* pcImp = (Assimp::Importer*)jvmcontext;
|
|
delete pcImp;
|
|
|
|
#if (defined _DEBUG)
|
|
g_listActiveContexts.remove(jvmcontext);
|
|
#endif // ! ASSIMP_DEBUG
|
|
|
|
JNIEnvironment::Get()->DetachFromCurrentThread();
|
|
return 0;
|
|
}
|
|
// ------------------------------------------------------------------------------------------------
|
|
/*
|
|
* Class: assimp_Importer
|
|
* Method: _NativeLoad
|
|
* Signature: (Ljava/lang/String;II)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_assimp_Importer__1NativeLoad
|
|
(JNIEnv *jvmenv, jobject jvmthis, jstring jvmpath, jint jvmflags, jlong jvmcontext)
|
|
{
|
|
jint iRet = 0;
|
|
|
|
#if (defined _DEBUG)
|
|
if (!jValidateContext((JASSIMP_CONTEXT)jvmcontext))return AI_JNI_ERROR_RETURN;
|
|
#endif // ! ASSIMP_DEBUG
|
|
|
|
// get the path from the jstring
|
|
const char* szPath = JNU_GetStringNativeChars(jvmenv,jvmpath);
|
|
if (!szPath)
|
|
{
|
|
DefaultLogger::get()->error("[jnibridge] Unable to get path string from the java vm");
|
|
return AI_JNI_ERROR_RETURN;
|
|
}
|
|
// get the importer instance from the context
|
|
Assimp::Importer* pcImp = (Assimp::Importer*)jvmcontext;
|
|
|
|
// and load the file. The aiScene object itself remains accessible
|
|
// via Importer.GetScene().
|
|
if(NULL == pcImp->ReadFile(std::string(szPath),(unsigned int)jvmflags))
|
|
{
|
|
DefaultLogger::get()->error("[jnibridge] Unable to load asset");
|
|
|
|
// release the path again
|
|
free((void*)szPath);
|
|
return AI_JNI_ERROR_RETURN;
|
|
}
|
|
// release the path again
|
|
free((void*)szPath);
|
|
return iRet;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
/*
|
|
* Class: assimp_PostProcessStep
|
|
* Method: _NativeSetVertexSplitLimit
|
|
* Signature: (I)V
|
|
*/
|
|
JNIEXPORT void JNICALL Java_assimp_PostProcessStep__1NativeSetVertexSplitLimit
|
|
(JNIEnv *jvmenv, jclass jvmthis, jint jvmlimit)
|
|
{
|
|
aiSetVertexSplitLimit(jvmlimit);
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
/*
|
|
* Class: assimp_PostProcessStep
|
|
* Method: _NativeSetTriangleSplitLimit
|
|
* Signature: (I)V
|
|
*/
|
|
JNIEXPORT void JNICALL Java_assimp_PostProcessStep__1NativeSetTriangleSplitLimit
|
|
(JNIEnv *jvmenv, jclass jvmthis, jint jvmlimit)
|
|
{
|
|
aiSetTriangleSplitLimit(jvmlimit);
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
/*
|
|
* Class: assimp_Scene
|
|
* Method: _NativeGetNumMeshes
|
|
* Signature: (I)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_assimp_Scene__1NativeGetNumMeshes
|
|
(JNIEnv *jvmenv, jobject jvmthis, jlong jvmcontext)
|
|
{
|
|
// we need a valid scene for this
|
|
Assimp::Importer* pcImp = jGetValidImporterScenePair(jvmcontext);
|
|
if (!pcImp)return AI_JNI_ERROR_RETURN;
|
|
return (jint)pcImp->GetScene()->mNumMeshes;
|
|
}
|
|
// ------------------------------------------------------------------------------------------------
|
|
/*
|
|
* Class: assimp_Scene
|
|
* Method: _NativeGetNumAnimations
|
|
* Signature: (I)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_assimp_Scene__1NativeGetNumAnimations
|
|
(JNIEnv *jvmenv, jobject jvmthis, jlong jvmcontext)
|
|
{
|
|
// we need a valid scene for this
|
|
Assimp::Importer* pcImp = jGetValidImporterScenePair(jvmcontext);
|
|
if (!pcImp)return AI_JNI_ERROR_RETURN;
|
|
return (jint)pcImp->GetScene()->mNumAnimations;
|
|
}
|
|
// ------------------------------------------------------------------------------------------------
|
|
/*
|
|
* Class: assimp_Scene
|
|
* Method: _NativeGetNumTextures
|
|
* Signature: (I)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_assimp_Scene__1NativeGetNumTextures
|
|
(JNIEnv *jvmenv, jobject jvmthis, jlong jvmcontext)
|
|
{
|
|
// we need a valid scene for this
|
|
Assimp::Importer* pcImp = jGetValidImporterScenePair(jvmcontext);
|
|
if (!pcImp)return AI_JNI_ERROR_RETURN;
|
|
return (jint)pcImp->GetScene()->mNumTextures;
|
|
}
|
|
// ------------------------------------------------------------------------------------------------
|
|
/*
|
|
* Class: assimp_Scene
|
|
* Method: _NativeGetNumMaterials
|
|
* Signature: (I)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_assimp_Scene__1NativeGetNumMaterials
|
|
(JNIEnv *jvmenv, jobject jvmthis, jlong jvmcontext)
|
|
{
|
|
// we need a valid scene for this
|
|
Assimp::Importer* pcImp = jGetValidImporterScenePair(jvmcontext);
|
|
if (!pcImp)return AI_JNI_ERROR_RETURN;
|
|
return (jint)pcImp->GetScene()->mNumMaterials;
|
|
}
|
|
// ------------------------------------------------------------------------------------------------
|
|
/*
|
|
* Class: assimp_Mesh
|
|
* Method: _NativeGetPresenceFlags
|
|
* Signature: (JJ)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_assimp_Mesh__1NativeGetPresenceFlags
|
|
(JNIEnv *jvmenv, jobject jvmthis, jlong jvmcontext, jlong jvmindex)
|
|
{
|
|
// we need a valid scene for this
|
|
Assimp::Importer* pcImp = jGetValidImporterScenePair(jvmcontext);
|
|
if (!pcImp)return AI_JNI_ERROR_RETURN;
|
|
|
|
// get the corresponding mesh
|
|
ai_assert(jvmindex < pcImp->GetScene()->mNumMeshes);
|
|
aiMesh* pcMesh = pcImp->GetScene()->mMeshes[jvmindex];
|
|
|
|
// now build the flag list
|
|
jint iRet = 0;
|
|
if (pcMesh->HasPositions())
|
|
iRet |= assimp_Mesh_PF_POSITION;
|
|
if (pcMesh->HasBones())
|
|
iRet |= assimp_Mesh_PF_BONES;
|
|
if (pcMesh->HasNormals())
|
|
iRet |= assimp_Mesh_PF_NORMAL;
|
|
if (pcMesh->HasTangentsAndBitangents())
|
|
iRet |= assimp_Mesh_PF_TANGENTBITANGENT;
|
|
|
|
unsigned int i = 0;
|
|
while (pcMesh->HasTextureCoords(i))
|
|
iRet |= assimp_Mesh_PF_UVCOORD << i++;
|
|
i = 0;
|
|
while (pcMesh->HasVertexColors(i))
|
|
iRet |= assimp_Mesh_PF_VERTEXCOLOR << i++;
|
|
|
|
return iRet;
|
|
}
|
|
// ------------------------------------------------------------------------------------------------
|
|
/*
|
|
* Class: assimp_Mesh
|
|
* Method: _NativeGetNumVertices
|
|
* Signature: (JJ)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_assimp_Mesh__1NativeGetNumVertices
|
|
(JNIEnv *jvmenv, jobject jvmthis, jlong jvmcontext, jlong jvmindex)
|
|
{
|
|
// we need a valid scene for this
|
|
Assimp::Importer* pcImp = jGetValidImporterScenePair(jvmcontext);
|
|
if (!pcImp)return AI_JNI_ERROR_RETURN;
|
|
|
|
// get the corresponding mesh
|
|
ai_assert(jvmindex < pcImp->GetScene()->mNumMeshes);
|
|
return pcImp->GetScene()->mMeshes[jvmindex]->mNumVertices;
|
|
}
|
|
// ------------------------------------------------------------------------------------------------
|
|
/*
|
|
* Class: assimp_Mesh
|
|
* Method: _NativeGetNumFaces
|
|
* Signature: (JJ)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_assimp_Mesh__1NativeGetNumFaces
|
|
(JNIEnv *jvmenv, jobject jvmthis, jlong jvmcontext, jlong jvmindex)
|
|
{
|
|
// we need a valid scene for this
|
|
Assimp::Importer* pcImp = jGetValidImporterScenePair(jvmcontext);
|
|
if (!pcImp)return AI_JNI_ERROR_RETURN;
|
|
|
|
// get the corresponding mesh
|
|
ai_assert(jvmindex < pcImp->GetScene()->mNumMeshes);
|
|
return pcImp->GetScene()->mMeshes[jvmindex]->mNumFaces;
|
|
}
|
|
// ------------------------------------------------------------------------------------------------
|
|
/*
|
|
* Class: assimp_Mesh
|
|
* Method: _NativeGetNumBones
|
|
* Signature: (JJ)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_assimp_Mesh__1NativeGetNumBones
|
|
(JNIEnv *jvmenv, jobject jvmthis, jlong jvmcontext, jlong jvmindex)
|
|
{
|
|
// we need a valid scene for this
|
|
Assimp::Importer* pcImp = jGetValidImporterScenePair(jvmcontext);
|
|
if (!pcImp)return AI_JNI_ERROR_RETURN;
|
|
|
|
// get the corresponding mesh
|
|
ai_assert(jvmindex < pcImp->GetScene()->mNumMeshes);
|
|
return pcImp->GetScene()->mMeshes[jvmindex]->mNumBones;
|
|
}
|
|
// ------------------------------------------------------------------------------------------------
|
|
/*
|
|
* Class: assimp_Mesh
|
|
* Method: _NativeGetMaterialIndex
|
|
* Signature: (JJ)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_assimp_Mesh__1NativeGetMaterialIndex
|
|
(JNIEnv *jvmenv, jobject jvmthis, jlong jvmcontext, jlong jvmindex)
|
|
{
|
|
// we need a valid scene for this
|
|
Assimp::Importer* pcImp = jGetValidImporterScenePair(jvmcontext);
|
|
if (!pcImp)return AI_JNI_ERROR_RETURN;
|
|
|
|
// get the corresponding mesh
|
|
ai_assert(jvmindex < pcImp->GetScene()->mNumMeshes);
|
|
return pcImp->GetScene()->mMeshes[jvmindex]->mMaterialIndex;
|
|
}
|
|
// ------------------------------------------------------------------------------------------------
|
|
/*
|
|
* Class: assimp_Mesh
|
|
* Method: _NativeGetNumUVComponents
|
|
* Signature: (JJ[I)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_assimp_Mesh__1NativeGetNumUVComponents
|
|
(JNIEnv *jvmenv, jobject jvmthis, jlong jvmcontext, jlong jvmindex, jintArray jvmout)
|
|
{
|
|
ai_assert(AI_MAX_NUMBER_OF_TEXTURECOORDS == jvmenv->GetArrayLength(jvmout) );
|
|
|
|
// we need a valid scene for this
|
|
Assimp::Importer* pcImp = jGetValidImporterScenePair(jvmcontext);
|
|
if (!pcImp)return AI_JNI_ERROR_RETURN;
|
|
|
|
// get the corresponding mesh
|
|
ai_assert(jvmindex < pcImp->GetScene()->mNumMeshes);
|
|
const unsigned int* piArray = pcImp->GetScene()->mMeshes[jvmindex]->mNumUVComponents;
|
|
|
|
jint* pArray = jvmenv->GetIntArrayElements(jvmout,NULL);
|
|
if (NULL == pArray)return AI_JNI_ERROR_RETURN;
|
|
|
|
for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS;++i)
|
|
pArray[i] = piArray[i];
|
|
|
|
jvmenv->ReleaseIntArrayElements(jvmout,pArray,0);
|
|
return 0;
|
|
}
|
|
// ------------------------------------------------------------------------------------------------
|
|
void CpyVectorToFloatArray(jfloat* pDest, const aiVector3D* pSource, unsigned int iNum)
|
|
{
|
|
jfloat* pCursor = pDest;
|
|
const aiVector3D* const pvEnd = pSource + iNum;
|
|
while (pvEnd != pSource)
|
|
{
|
|
*pCursor++ = pSource->x;
|
|
*pCursor++ = pSource->y;
|
|
*pCursor++ = pSource->z;
|
|
++pSource;
|
|
}
|
|
return;
|
|
}
|
|
// ------------------------------------------------------------------------------------------------
|
|
/*
|
|
* Class: assimp_Mesh
|
|
* Method: _NativeMapVertices
|
|
* Signature: (JJ[F)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_assimp_Mesh__1NativeMapVertices
|
|
(JNIEnv *jvmenv, jobject jvmthis, jlong jvmcontext, jlong jvmindex, jfloatArray jvmout)
|
|
{
|
|
// we need a valid scene for this
|
|
Assimp::Importer* pcImp = jGetValidImporterScenePair(jvmcontext);
|
|
if (!pcImp)return AI_JNI_ERROR_RETURN;
|
|
|
|
// get the corresponding mesh
|
|
ai_assert(jvmindex < pcImp->GetScene()->mNumMeshes);
|
|
aiMesh* pcMesh = (aiMesh*)pcImp->GetScene()->mMeshes[jvmindex];
|
|
ai_assert(jvmenv->GetArrayLength(jvmout) == pcMesh->mNumVertices * 3);
|
|
const aiVector3D* pcData = pcMesh->mVertices;
|
|
|
|
// now copy the data to the java array
|
|
jfloat* pArray = jvmenv->GetFloatArrayElements(jvmout,NULL);
|
|
CpyVectorToFloatArray(pArray,pcData,pcMesh->mNumVertices);
|
|
jvmenv->ReleaseFloatArrayElements(jvmout,pArray,0);
|
|
|
|
// delete the original data
|
|
delete[] pcMesh->mVertices;
|
|
pcMesh->mVertices = NULL;
|
|
return 0;
|
|
}
|
|
// ------------------------------------------------------------------------------------------------
|
|
/*
|
|
* Class: assimp_Mesh
|
|
* Method: _NativeMapNormals
|
|
* Signature: (JJ[F)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_assimp_Mesh__1NativeMapNormals
|
|
(JNIEnv *jvmenv, jobject jvmthis, jlong jvmcontext, jlong jvmindex, jfloatArray jvmout)
|
|
{
|
|
// we need a valid scene for this
|
|
Assimp::Importer* pcImp = jGetValidImporterScenePair(jvmcontext);
|
|
if (!pcImp)return AI_JNI_ERROR_RETURN;
|
|
|
|
// get the corresponding mesh
|
|
ai_assert(jvmindex < pcImp->GetScene()->mNumMeshes);
|
|
aiMesh* pcMesh = (aiMesh*)pcImp->GetScene()->mMeshes[jvmindex];
|
|
ai_assert(jvmenv->GetArrayLength(jvmout) == pcMesh->mNumVertices * 3);
|
|
const aiVector3D* pcData = pcMesh->mNormals;
|
|
|
|
// now copy the data to the java array
|
|
jfloat* pArray = jvmenv->GetFloatArrayElements(jvmout,NULL);
|
|
CpyVectorToFloatArray(pArray,pcData,pcMesh->mNumVertices);
|
|
jvmenv->ReleaseFloatArrayElements(jvmout,pArray,0);
|
|
|
|
// delete the original data
|
|
delete[] pcMesh->mNormals;
|
|
pcMesh->mNormals = NULL;
|
|
return 0;
|
|
}
|
|
// ------------------------------------------------------------------------------------------------
|
|
/*
|
|
* Class: assimp_Mesh
|
|
* Method: _NativeMapTangents
|
|
* Signature: (JJ[F)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_assimp_Mesh__1NativeMapTangents
|
|
(JNIEnv *jvmenv, jobject jvmthis, jlong jvmcontext, jlong jvmindex, jfloatArray jvmout)
|
|
{
|
|
// we need a valid scene for this
|
|
Assimp::Importer* pcImp = jGetValidImporterScenePair(jvmcontext);
|
|
if (!pcImp)return AI_JNI_ERROR_RETURN;
|
|
|
|
// get the corresponding mesh
|
|
ai_assert(jvmindex < pcImp->GetScene()->mNumMeshes);
|
|
aiMesh* pcMesh = (aiMesh*)pcImp->GetScene()->mMeshes[jvmindex];
|
|
ai_assert(jvmenv->GetArrayLength(jvmout) == pcMesh->mNumVertices * 3);
|
|
const aiVector3D* pcData = pcMesh->mTangents;
|
|
|
|
// now copy the data to the java array
|
|
jfloat* pArray = jvmenv->GetFloatArrayElements(jvmout,NULL);
|
|
CpyVectorToFloatArray(pArray,pcData,pcMesh->mNumVertices);
|
|
jvmenv->ReleaseFloatArrayElements(jvmout,pArray,0);
|
|
|
|
// delete the original data
|
|
delete[] pcMesh->mNormals;
|
|
pcMesh->mNormals = NULL;
|
|
return 0;
|
|
}
|
|
// ------------------------------------------------------------------------------------------------
|
|
/*
|
|
* Class: assimp_Mesh
|
|
* Method: _NativeMapBitangents
|
|
* Signature: (JJ[F)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_assimp_Mesh__1NativeMapBitangents
|
|
(JNIEnv *jvmenv, jobject jvmthis, jlong jvmcontext, jlong jvmindex, jfloatArray jvmout)
|
|
{
|
|
// we need a valid scene for this
|
|
Assimp::Importer* pcImp = jGetValidImporterScenePair(jvmcontext);
|
|
if (!pcImp)return AI_JNI_ERROR_RETURN;
|
|
|
|
// get the corresponding mesh
|
|
ai_assert(jvmindex < pcImp->GetScene()->mNumMeshes);
|
|
aiMesh* pcMesh = (aiMesh*)pcImp->GetScene()->mMeshes[jvmindex];
|
|
ai_assert(jvmenv->GetArrayLength(jvmout) == pcMesh->mNumVertices * 3);
|
|
const aiVector3D* pcData = pcMesh->mBitangents;
|
|
|
|
// now copy the data to the java array
|
|
jfloat* pArray = jvmenv->GetFloatArrayElements(jvmout,NULL);
|
|
CpyVectorToFloatArray(pArray,pcData,pcMesh->mNumVertices);
|
|
jvmenv->ReleaseFloatArrayElements(jvmout,pArray,0);
|
|
|
|
// delete the original data
|
|
delete[] pcMesh->mBitangents;
|
|
pcMesh->mBitangents = NULL;
|
|
return 0;
|
|
}
|
|
// ------------------------------------------------------------------------------------------------
|
|
void CpyColorToFloatArray(jfloat* pDest, const aiColor4D* pSource, unsigned int iNum)
|
|
{
|
|
jfloat* pCursor = pDest;
|
|
const aiColor4D* const pvEnd = pSource + iNum;
|
|
while (pvEnd != pSource)
|
|
{
|
|
*pCursor++ = pSource->r;
|
|
*pCursor++ = pSource->g;
|
|
*pCursor++ = pSource->b;
|
|
*pCursor++ = pSource->a;
|
|
++pSource;
|
|
}
|
|
return;
|
|
}
|
|
// ------------------------------------------------------------------------------------------------
|
|
void CpyVectorToFloatArray(jfloat* pDest, const aiVector3D* pSource,
|
|
unsigned int iNum, unsigned int iNumComponents)
|
|
{
|
|
jfloat* pCursor = pDest;
|
|
const aiVector3D* const pvEnd = pSource + iNum;
|
|
while (pvEnd != pSource)
|
|
{
|
|
if (iNumComponents >= 1)*pCursor++ = pSource->x;
|
|
if (iNumComponents >= 2)*pCursor++ = pSource->y;
|
|
if (iNumComponents >= 3)*pCursor++ = pSource->z;
|
|
++pSource;
|
|
}
|
|
return;
|
|
}
|
|
// ------------------------------------------------------------------------------------------------
|
|
/*
|
|
* Class: assimp_Mesh
|
|
* Method: _NativeMapUVs
|
|
* Signature: (JJI[F)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_assimp_Mesh__1NativeMapUVs
|
|
(JNIEnv *jvmenv, jobject jvmthis, jlong jvmcontext, jlong jvmindex,
|
|
jint jvmchannel, jfloatArray jvmout)
|
|
{
|
|
// we need a valid scene for this
|
|
Assimp::Importer* pcImp = jGetValidImporterScenePair(jvmcontext);
|
|
if (!pcImp)return AI_JNI_ERROR_RETURN;
|
|
|
|
// get the corresponding mesh
|
|
ai_assert(jvmindex < pcImp->GetScene()->mNumMeshes);
|
|
aiMesh* pcMesh = (aiMesh*)pcImp->GetScene()->mMeshes[jvmindex];
|
|
ai_assert(jvmenv->GetArrayLength(jvmout) == pcMesh->mNumVertices*pcMesh->mNumUVComponents[jvmchannel]);
|
|
const aiVector3D* pcData = pcMesh->mTextureCoords[jvmchannel];
|
|
|
|
// now copy the data to the java array
|
|
jfloat* pArray = jvmenv->GetFloatArrayElements(jvmout,NULL);
|
|
CpyVectorToFloatArray(pArray,pcData,pcMesh->mNumVertices,pcMesh->mNumUVComponents[jvmchannel]);
|
|
jvmenv->ReleaseFloatArrayElements(jvmout,pArray,0);
|
|
|
|
// delete the original data
|
|
delete[] pcMesh->mTextureCoords[jvmchannel];
|
|
pcMesh->mTextureCoords[jvmchannel] = NULL;
|
|
return 0;
|
|
}
|
|
// ------------------------------------------------------------------------------------------------
|
|
/*
|
|
* Class: assimp_Mesh
|
|
* Method: _NativeMapColors
|
|
* Signature: (JJI[F)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_assimp_Mesh__1NativeMapColors
|
|
(JNIEnv *jvmenv, jobject jvmthis, jlong jvmcontext, jlong jvmindex,
|
|
jint jvmchannel, jfloatArray jvmout)
|
|
{
|
|
// we need a valid scene for this
|
|
Assimp::Importer* pcImp = jGetValidImporterScenePair(jvmcontext);
|
|
if (!pcImp)return AI_JNI_ERROR_RETURN;
|
|
|
|
// get the corresponding mesh
|
|
ai_assert(jvmindex < pcImp->GetScene()->mNumMeshes);
|
|
aiMesh* pcMesh = (aiMesh*)pcImp->GetScene()->mMeshes[jvmindex];
|
|
ai_assert(jvmenv->GetArrayLength(jvmout) == pcMesh->mNumVertices*4);
|
|
const aiColor4D* pcData = pcMesh->mColors[jvmchannel];
|
|
|
|
// now copy the data to the java array
|
|
jfloat* pArray = jvmenv->GetFloatArrayElements(jvmout,NULL);
|
|
CpyColorToFloatArray(pArray,pcData,pcMesh->mNumVertices);
|
|
jvmenv->ReleaseFloatArrayElements(jvmout,pArray,0);
|
|
|
|
// delete the original data
|
|
delete[] pcMesh->mColors[jvmchannel];
|
|
pcMesh->mColors[jvmchannel] = NULL;
|
|
return 0;
|
|
}
|
|
// ------------------------------------------------------------------------------------------------
|
|
void CpyFacesToIntArray(jint* pDest, const aiFace* pSource, unsigned int iNum)
|
|
{
|
|
// assume that all faces are triangles
|
|
jint* pCursor = pDest;
|
|
const aiFace* const pvEnd = pSource + iNum;
|
|
while (pvEnd != pSource)
|
|
{
|
|
*pCursor++ = pSource->mIndices[0];
|
|
*pCursor++ = pSource->mIndices[1];
|
|
*pCursor++ = pSource->mIndices[2];
|
|
++pSource;
|
|
}
|
|
return;
|
|
}
|
|
// ------------------------------------------------------------------------------------------------
|
|
/*
|
|
* Class: assimp_Mesh
|
|
* Method: _NativeMapFaces
|
|
* Signature: (JJ[I)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_assimp_Mesh__1NativeMapFaces
|
|
(JNIEnv *jvmenv, jobject jvmthis, jlong jvmcontext, jlong jvmindex, jintArray jvmout)
|
|
{
|
|
// we need a valid scene for this
|
|
Assimp::Importer* pcImp = jGetValidImporterScenePair(jvmcontext);
|
|
if (!pcImp)return AI_JNI_ERROR_RETURN;
|
|
|
|
// get the corresponding mesh
|
|
ai_assert(jvmindex < pcImp->GetScene()->mNumMeshes);
|
|
aiMesh* pcMesh = (aiMesh*)pcImp->GetScene()->mMeshes[jvmindex];
|
|
ai_assert(jvmenv->GetArrayLength(jvmout) == pcMesh->mNumFaces*3);
|
|
const aiFace* pcData = pcMesh->mFaces;
|
|
|
|
// now copy the data to the java array
|
|
jint* pArray = jvmenv->GetIntArrayElements(jvmout,NULL);
|
|
CpyFacesToIntArray(pArray,pcData,pcMesh->mNumFaces);
|
|
jvmenv->ReleaseIntArrayElements(jvmout,pArray,0);
|
|
|
|
// delete the original data
|
|
for (unsigned int i = 0; i < pcMesh->mNumFaces;++i)
|
|
delete[] pcMesh->mFaces[i].mIndices;
|
|
delete[] pcMesh->mFaces;
|
|
pcMesh->mFaces = NULL;
|
|
return 0;
|
|
}
|
|
|
|
|
|
}; //! namespace JNIBridge
|
|
}; //! namespace Assimp
|
|
#endif // !ASSIMP_JNI_EXPORT
|