aiTextureMapMode map_mode[2] = {
aiTextureMapMode_Wrap, aiTextureMapMode_Wrap
};
- float blend = 1.0f;
+ ai_real blend = 1.0;
if (mat.GetTexture(type, 0, &path, NULL, NULL, &blend, NULL, map_mode) != AI_SUCCESS || !path.length) {
return;
}
writer.PutF4(f);
}
+// ------------------------------------------------------------------------------------------------
+void Discreet3DSExporter::WritePercentChunk(double f) {
+ ChunkWriter chunk(writer, Discreet3DS::CHUNK_PERCENTD);
+ writer.PutF8(f);
+}
+
#endif // ASSIMP_BUILD_NO_3DS_EXPORTER
#endif // ASSIMP_BUILD_NO_EXPORT
void WriteString(const aiString& s);
void WriteColor(const aiColor3D& color);
void WritePercentChunk(float f);
+ void WritePercentChunk(double f);
private:
CHUNK_PERCENTW = 0x0030, // int2 percentage
CHUNK_PERCENTF = 0x0031, // float4 percentage
+ CHUNK_PERCENTD = 0x0032, // float8 percentage
// ********************************************************************
// Prj master chunk
break;
+ case Discreet3DS::CHUNK_PERCENTD:
+ // Manually parse the blend factor
+ pcOut->mTextureBlend = stream->GetF8();
+ break;
+
case Discreet3DS::CHUNK_PERCENTF:
// Manually parse the blend factor
pcOut->mTextureBlend = stream->GetF4();
const char* pKey,
unsigned int type,
unsigned int index,
- float* pOut,
+ ai_real* pOut,
unsigned int* pMax)
{
ai_assert (pOut != NULL);
return AI_FAILURE;
}
- // data is given in floats, simply copy it
+ // data is given in floats, convert to ai_real
unsigned int iWrite = 0;
if( aiPTI_Float == prop->mType || aiPTI_Buffer == prop->mType) {
iWrite = prop->mDataLength / sizeof(float);
iWrite = std::min(*pMax,iWrite); ;
}
for (unsigned int a = 0; a < iWrite;++a) {
- pOut[a] = static_cast<float> ( reinterpret_cast<float*>(prop->mData)[a] );
+ pOut[a] = static_cast<ai_real> ( reinterpret_cast<float*>(prop->mData)[a] );
+ }
+ if (pMax) {
+ *pMax = iWrite;
+ }
+ }
+ // data is given in doubles, convert to float
+ else if( aiPTI_Double == prop->mType) {
+ iWrite = prop->mDataLength / sizeof(double);
+ if (pMax) {
+ iWrite = std::min(*pMax,iWrite); ;
+ }
+ for (unsigned int a = 0; a < iWrite;++a) {
+ pOut[a] = static_cast<ai_real> ( reinterpret_cast<double*>(prop->mData)[a] );
}
if (pMax) {
*pMax = iWrite;
iWrite = std::min(*pMax,iWrite); ;
}
for (unsigned int a = 0; a < iWrite;++a) {
- pOut[a] = static_cast<float> ( reinterpret_cast<int32_t*>(prop->mData)[a] );
+ pOut[a] = static_cast<ai_real> ( reinterpret_cast<int32_t*>(prop->mData)[a] );
}
if (pMax) {
*pMax = iWrite;
const char* cur = prop->mData+4;
ai_assert(prop->mDataLength>=5 && !prop->mData[prop->mDataLength-1]);
for (unsigned int a = 0; ;++a) {
- cur = fast_atoreal_move<float>(cur,pOut[a]);
+ cur = fast_atoreal_move<ai_real>(cur,pOut[a]);
if(a==iWrite-1) {
break;
}
aiColor4D* pOut)
{
unsigned int iMax = 4;
- const aiReturn eRet = aiGetMaterialFloatArray(pMat,pKey,type,index,(float*)pOut,&iMax);
+ const aiReturn eRet = aiGetMaterialFloatArray(pMat,pKey,type,index,(ai_real*)pOut,&iMax);
// if no alpha channel is defined: set it to 1.0
if (3 == iMax) {
- pOut->a = 1.0f;
+ pOut->a = 1.0;
}
return eRet;
aiUVTransform* pOut)
{
unsigned int iMax = 4;
- return aiGetMaterialFloatArray(pMat,pKey,type,index,(float*)pOut,&iMax);
+ return aiGetMaterialFloatArray(pMat,pKey,type,index,(ai_real*)pOut,&iMax);
}
// ------------------------------------------------------------------------------------------------
C_STRUCT aiString* path,
aiTextureMapping* _mapping /*= NULL*/,
unsigned int* uvindex /*= NULL*/,
- float* blend /*= NULL*/,
+ ai_real* blend /*= NULL*/,
aiTextureOp* op /*= NULL*/,
aiTextureMapMode* mapmode /*= NULL*/,
unsigned int* flags /*= NULL*/
}
// make some more specific tests
- float fTemp;
+ ai_real fTemp;
int iShading;
if (AI_SUCCESS == aiGetMaterialInteger( pMaterial,AI_MATKEY_SHADING_MODEL,&iShading)) {
switch ((aiShadingMode)iShading)
};
}
- if (AI_SUCCESS == aiGetMaterialFloat( pMaterial,AI_MATKEY_OPACITY,&fTemp) && (!fTemp || fTemp > 1.01f)) {
+ if (AI_SUCCESS == aiGetMaterialFloat( pMaterial,AI_MATKEY_OPACITY,&fTemp) && (!fTemp || fTemp > 1.01)) {
ReportWarning("Invalid opacity value (must be 0 < opacity < 1.0)");
}
unsigned int idx, int* pOut, unsigned int* pMax) const;
aiReturn Get(const char* pKey,unsigned int type,
- unsigned int idx, float* pOut, unsigned int* pMax) const;
+ unsigned int idx, ai_real* pOut, unsigned int* pMax) const;
// -------------------------------------------------------------------
/** @brief Retrieve a Type value with a specific key
unsigned int idx, int& pOut) const;
aiReturn Get(const char* pKey,unsigned int type,
- unsigned int idx, float& pOut) const;
+ unsigned int idx, ai_real& pOut) const;
aiReturn Get(const char* pKey,unsigned int type,
unsigned int idx, aiString& pOut) const;
C_STRUCT aiString* path,
aiTextureMapping* mapping = NULL,
unsigned int* uvindex = NULL,
- float* blend = NULL,
+ ai_real* blend = NULL,
aiTextureOp* op = NULL,
aiTextureMapMode* mapmode = NULL) const;
* structure or NULL if the key has not been found. */
// ---------------------------------------------------------------------------
ASSIMP_API C_ENUM aiReturn aiGetMaterialProperty(
- const C_STRUCT aiMaterial* pMat,
+ const C_STRUCT aiMaterial* pMat,
const char* pKey,
- unsigned int type,
+ unsigned int type,
unsigned int index,
const C_STRUCT aiMaterialProperty** pPropOut);
const char* pKey,
unsigned int type,
unsigned int index,
- float* pOut,
+ ai_real* pOut,
unsigned int* pMax);
const char* pKey,
unsigned int type,
unsigned int index,
- float* pOut)
+ ai_real* pOut)
{
return aiGetMaterialFloatArray(pMat,pKey,type,index,pOut,(unsigned int*)0x0);
}
inline aiReturn aiGetMaterialInteger(const C_STRUCT aiMaterial* pMat,
const char* pKey,
unsigned int type,
- unsigned int index,
+ unsigned int index,
int* pOut)
{
return aiGetMaterialIntegerArray(pMat,pKey,type,index,pOut,(unsigned int*)0x0);
aiString* path,
aiTextureMapping* mapping = NULL,
unsigned int* uvindex = NULL,
- float* blend = NULL,
+ ai_real* blend = NULL,
aiTextureOp* op = NULL,
aiTextureMapMode* mapmode = NULL,
unsigned int* flags = NULL);
C_STRUCT aiString* path,
C_ENUM aiTextureMapping* mapping /*= NULL*/,
unsigned int* uvindex /*= NULL*/,
- float* blend /*= NULL*/,
+ ai_real* blend /*= NULL*/,
C_ENUM aiTextureOp* op /*= NULL*/,
C_ENUM aiTextureMapMode* mapmode /*= NULL*/,
unsigned int* flags /*= NULL*/);
C_STRUCT aiString* path,
aiTextureMapping* mapping /*= NULL*/,
unsigned int* uvindex /*= NULL*/,
- float* blend /*= NULL*/,
+ ai_real* blend /*= NULL*/,
aiTextureOp* op /*= NULL*/,
aiTextureMapMode* mapmode /*= NULL*/) const
{
// ---------------------------------------------------------------------------
inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
- unsigned int idx,float* pOut,
+ unsigned int idx,ai_real* pOut,
unsigned int* pMax) const
{
return ::aiGetMaterialFloatArray(this,pKey,type,idx,pOut,pMax);
}
// ---------------------------------------------------------------------------
inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
- unsigned int idx,float& pOut) const
+ unsigned int idx,ai_real& pOut) const
{
return aiGetMaterialFloat(this,pKey,type,idx,&pOut);
}
unsigned int index)
{
return AddBinaryProperty((const void*)pInput,
- pNumValues * sizeof(float),
+ pNumValues * sizeof(double),
pKey,type,index,aiPTI_Double);
}
{
return AddBinaryProperty((const void*)pInput,
pNumValues * sizeof(aiUVTransform),
- pKey,type,index,aiPTI_Float);
+ pKey,type,index,aiPTI_Float); //TODO could be Double ...
}
// ---------------------------------------------------------------------------
{
return AddBinaryProperty((const void*)pInput,
pNumValues * sizeof(aiColor4D),
- pKey,type,index,aiPTI_Float);
+ pKey,type,index,aiPTI_Float); //TODO could be Double ...
}
// ---------------------------------------------------------------------------
{
return AddBinaryProperty((const void*)pInput,
pNumValues * sizeof(aiColor3D),
- pKey,type,index,aiPTI_Float);
+ pKey,type,index,aiPTI_Float); //TODO could be Double ...
}
// ---------------------------------------------------------------------------
{
return AddBinaryProperty((const void*)pInput,
pNumValues * sizeof(aiVector3D),
- pKey,type,index,aiPTI_Float);
+ pKey,type,index,aiPTI_Float); //TODO could be Double ...
}
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
template<>
+inline aiReturn aiMaterial::AddProperty<double>(const double* pInput,
+ const unsigned int pNumValues,
+ const char* pKey,
+ unsigned int type,
+ unsigned int index)
+{
+ return AddBinaryProperty((const void*)pInput,
+ pNumValues * sizeof(double),
+ pKey,type,index,aiPTI_Double);
+}
+
+// ---------------------------------------------------------------------------
+template<>
inline aiReturn aiMaterial::AddProperty<aiUVTransform>(const aiUVTransform* pInput,
const unsigned int pNumValues,
const char* pKey,
// It takes a file name as command line parameter, loads it using standard
// settings and displays it.
//
-// If you intend to _use_ this code sample in your app, do yourself a favour
+// If you intend to _use_ this code sample in your app, do yourself a favour
// and replace immediate mode calls with VBOs ...
//
// The vc8 solution links against assimp-release-dll_win32 - be sure to
}
/* ---------------------------------------------------------------------------- */
-void get_bounding_box_for_node (const struct aiNode* nd,
- struct aiVector3D* min,
- struct aiVector3D* max,
+void get_bounding_box_for_node (const struct aiNode* nd,
+ struct aiVector3D* min,
+ struct aiVector3D* max,
struct aiMatrix4x4* trafo
){
struct aiMatrix4x4 prev;
struct aiColor4D specular;
struct aiColor4D ambient;
struct aiColor4D emission;
- float shininess, strength;
+ ai_real shininess, strength;
int two_sided;
int wireframe;
unsigned int max;
max = 1;
if((AI_SUCCESS == aiGetMaterialIntegerArray(mtl, AI_MATKEY_TWOSIDED, &two_sided, &max)) && two_sided)
glDisable(GL_CULL_FACE);
- else
+ else
glEnable(GL_CULL_FACE);
}
int index = face->mIndices[i];
if(mesh->mColors[0] != NULL)
glColor4fv((GLfloat*)&mesh->mColors[0][index]);
- if(mesh->mNormals != NULL)
+ if(mesh->mNormals != NULL)
glNormal3fv(&mesh->mNormals[index].x);
glVertex3fv(&mesh->mVertices[index].x);
}
aiAttachLogStream(&stream);
/* the model name can be specified on the command line. If none
- is specified, we try to locate one of the more expressive test
- models from the repository (/models-nonbsd may be missing in
+ is specified, we try to locate one of the more expressive test
+ models from the repository (/models-nonbsd may be missing in
some distributions so we need a fallback from /models!). */
if( 0 != loadasset( argc >= 2 ? argv[1] : "../../test/models-nonbsd/X/dwarf.x")) {
- if( argc != 1 || (0 != loadasset( "../../../../test/models-nonbsd/X/dwarf.x") && 0 != loadasset( "../../test/models/X/Testwuson.X"))) {
+ if( argc != 1 || (0 != loadasset( "../../../../test/models-nonbsd/X/dwarf.x") && 0 != loadasset( "../../test/models/X/Testwuson.X"))) {
return -1;
}
}
glEnable(GL_NORMALIZE);
/* XXX docs say all polygons are emitted CCW, but tests show that some aren't. */
- if(getenv("MODEL_IS_BROKEN"))
+ if(getenv("MODEL_IS_BROKEN"))
glFrontFace(GL_CW);
glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
glutGet(GLUT_ELAPSED_TIME);
glutMainLoop();
- /* cleanup - calling 'aiReleaseImport' is important, as the library
- keeps internal resources until the scene is freed again. Not
+ /* cleanup - calling 'aiReleaseImport' is important, as the library
+ keeps internal resources until the scene is freed again. Not
doing so can cause severe resource leaking. */
aiReleaseImport(scene);
aiDetachAllLogStreams();
return 0;
}
-
}
// Resize And Initialize The GL Window
-void ReSizeGLScene(GLsizei width, GLsizei height)
+void ReSizeGLScene(GLsizei width, GLsizei height)
{
// Prevent A Divide By Zero By
- if (height==0)
+ if (height==0)
{
// Making Height Equal One
- height=1;
+ height=1;
}
glViewport(0, 0, width, height); // Reset The Current Viewport
if (success) /* If no error occurred: */
{
- // Convert every colour component into unsigned byte.If your image contains
+ // Convert every colour component into unsigned byte.If your image contains
// alpha channel you can replace IL_RGB with IL_RGBA
success = ilConvertImage(IL_RGB, IL_UNSIGNED_BYTE);
if (!success)
return -1;
}
// Binding of texture name
- glBindTexture(GL_TEXTURE_2D, textureIds[i]);
+ glBindTexture(GL_TEXTURE_2D, textureIds[i]);
// redefine standard texture values
// We will use linear interpolation for magnification filter
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
// Texture specification
glTexImage2D(GL_TEXTURE_2D, 0, ilGetInteger(IL_IMAGE_BPP), ilGetInteger(IL_IMAGE_WIDTH),
ilGetInteger(IL_IMAGE_HEIGHT), 0, ilGetInteger(IL_IMAGE_FORMAT), GL_UNSIGNED_BYTE,
- ilGetData());
+ ilGetData());
// we also want to be able to deal with odd texture dimensions
glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
glPixelStorei( GL_UNPACK_ROW_LENGTH, 0 );
}
}
// Because we have already copied image data into texture data we can release memory used by image.
- ilDeleteImages(numTextures, imageIds);
+ ilDeleteImages(numTextures, imageIds);
// Cleanup
delete [] imageIds;
aiColor4D specular;
aiColor4D ambient;
aiColor4D emission;
- float shininess, strength;
+ ai_real shininess, strength;
int two_sided;
int wireframe;
unsigned int max; // changed: to unsigned