Merge commit 'cc3f8b82f9f6fb4b295a39a3f7ac55154145cc04' into contrib
Conflicts: CMakeLists.txtpull/261/head
Léo Terziman
commit
d28fc25c5c
|
|
@ -0,0 +1,176 @@
|
|||
/*
|
||||
Open Asset Import Library (assimp)
|
||||
----------------------------------------------------------------------
|
||||
|
||||
Copyright (c) 2006-2013, assimp 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 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 BlenderBMesh.cpp
|
||||
* @brief Conversion of Blender's new BMesh stuff
|
||||
*/
|
||||
|
||||
#include "AssimpPCH.h"
|
||||
|
||||
#ifndef ASSIMP_BUILD_NO_BLEND_IMPORTER
|
||||
|
||||
#include "BlenderDNA.h"
|
||||
#include "BlenderScene.h"
|
||||
#include "BlenderBMesh.h"
|
||||
#include "BlenderTessellator.h"
|
||||
|
||||
namespace Assimp
|
||||
{
|
||||
template< > const std::string LogFunctions< BlenderBMeshConverter >::log_prefix = "BLEND_BMESH: ";
|
||||
}
|
||||
|
||||
using namespace Assimp;
|
||||
using namespace Assimp::Blender;
|
||||
using namespace Assimp::Formatter;
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
BlenderBMeshConverter::BlenderBMeshConverter( const Mesh* mesh ):
|
||||
BMesh( mesh ),
|
||||
triMesh( NULL )
|
||||
{
|
||||
AssertValidMesh( );
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
BlenderBMeshConverter::~BlenderBMeshConverter( )
|
||||
{
|
||||
DestroyTriMesh( );
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
bool BlenderBMeshConverter::ContainsBMesh( ) const
|
||||
{
|
||||
// TODO - Should probably do some additional verification here
|
||||
return BMesh->totpoly && BMesh->totloop && BMesh->totvert;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
const Mesh* BlenderBMeshConverter::TriangulateBMesh( )
|
||||
{
|
||||
AssertValidMesh( );
|
||||
AssertValidSizes( );
|
||||
PrepareTriMesh( );
|
||||
|
||||
for ( int i = 0; i < BMesh->totpoly; ++i )
|
||||
{
|
||||
const MPoly& poly = BMesh->mpoly[ i ];
|
||||
ConvertPolyToFaces( poly );
|
||||
}
|
||||
|
||||
return triMesh;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void BlenderBMeshConverter::AssertValidMesh( )
|
||||
{
|
||||
if ( !ContainsBMesh( ) )
|
||||
{
|
||||
ThrowException( "BlenderBMeshConverter requires a BMesh with \"polygons\" - please call BlenderBMeshConverter::ContainsBMesh to check this first" );
|
||||
}
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void BlenderBMeshConverter::AssertValidSizes( )
|
||||
{
|
||||
if ( BMesh->totpoly != BMesh->mpoly.size( ) )
|
||||
{
|
||||
ThrowException( "BMesh poly array has incorrect size" );
|
||||
}
|
||||
if ( BMesh->totloop != BMesh->mloop.size( ) )
|
||||
{
|
||||
ThrowException( "BMesh loop array has incorrect size" );
|
||||
}
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void BlenderBMeshConverter::PrepareTriMesh( )
|
||||
{
|
||||
if ( triMesh )
|
||||
{
|
||||
DestroyTriMesh( );
|
||||
}
|
||||
|
||||
triMesh = new Mesh( *BMesh );
|
||||
triMesh->totface = 0;
|
||||
triMesh->mface.clear( );
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void BlenderBMeshConverter::DestroyTriMesh( )
|
||||
{
|
||||
delete triMesh;
|
||||
triMesh = NULL;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void BlenderBMeshConverter::ConvertPolyToFaces( const MPoly& poly )
|
||||
{
|
||||
const MLoop* polyLoop = &BMesh->mloop[ poly.loopstart ];
|
||||
if ( poly.totloop == 3 || poly.totloop == 4 )
|
||||
{
|
||||
AddFace( polyLoop[ 0 ].v, polyLoop[ 1 ].v, polyLoop[ 2 ].v, poly.totloop == 4 ? polyLoop[ 3 ].v : 0 );
|
||||
}
|
||||
else if ( poly.totloop > 4 )
|
||||
{
|
||||
#if ASSIMP_BLEND_WITH_GLU_TESSELLATE
|
||||
BlenderTessellatorGL tessGL( *this );
|
||||
tessGL.Tessellate( polyLoop, poly.totloop, triMesh->mvert );
|
||||
#elif ASSIMP_BLEND_WITH_POLY_2_TRI
|
||||
BlenderTessellatorP2T tessP2T( *this );
|
||||
tessP2T.Tessellate( polyLoop, poly.totloop, triMesh->mvert );
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void BlenderBMeshConverter::AddFace( int v1, int v2, int v3, int v4 )
|
||||
{
|
||||
MFace face;
|
||||
face.v1 = v1;
|
||||
face.v2 = v2;
|
||||
face.v3 = v3;
|
||||
face.v4 = v4;
|
||||
// TODO - Work out how materials work
|
||||
face.mat_nr = 0;
|
||||
triMesh->mface.push_back( face );
|
||||
triMesh->totface = triMesh->mface.size( );
|
||||
}
|
||||
|
||||
#endif // ASSIMP_BUILD_NO_BLEND_IMPORTER
|
||||
|
|
@ -0,0 +1,93 @@
|
|||
/*
|
||||
Open Asset Import Library (assimp)
|
||||
----------------------------------------------------------------------
|
||||
|
||||
Copyright (c) 2006-2013, assimp 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 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 BlenderBMesh.h
|
||||
* @brief Conversion of Blender's new BMesh stuff
|
||||
*/
|
||||
#ifndef INCLUDED_AI_BLEND_BMESH_H
|
||||
#define INCLUDED_AI_BLEND_BMESH_H
|
||||
|
||||
#include "LogAux.h"
|
||||
|
||||
namespace Assimp
|
||||
{
|
||||
// TinyFormatter.h
|
||||
namespace Formatter
|
||||
{
|
||||
template < typename T,typename TR, typename A > class basic_formatter;
|
||||
typedef class basic_formatter< char, std::char_traits< char >, std::allocator< char > > format;
|
||||
}
|
||||
|
||||
// BlenderScene.h
|
||||
namespace Blender
|
||||
{
|
||||
struct Mesh;
|
||||
struct MPoly;
|
||||
struct MLoop;
|
||||
}
|
||||
|
||||
class BlenderBMeshConverter: public LogFunctions< BlenderBMeshConverter >
|
||||
{
|
||||
public:
|
||||
BlenderBMeshConverter( const Blender::Mesh* mesh );
|
||||
~BlenderBMeshConverter( );
|
||||
|
||||
bool ContainsBMesh( ) const;
|
||||
|
||||
const Blender::Mesh* TriangulateBMesh( );
|
||||
|
||||
private:
|
||||
void AssertValidMesh( );
|
||||
void AssertValidSizes( );
|
||||
void PrepareTriMesh( );
|
||||
void DestroyTriMesh( );
|
||||
void ConvertPolyToFaces( const Blender::MPoly& poly );
|
||||
void AddFace( int v1, int v2, int v3, int v4 = 0 );
|
||||
|
||||
const Blender::Mesh* BMesh;
|
||||
Blender::Mesh* triMesh;
|
||||
|
||||
friend class BlenderTessellatorGL;
|
||||
friend class BlenderTessellatorP2T;
|
||||
};
|
||||
|
||||
} // end of namespace Assimp
|
||||
|
||||
#endif // INCLUDED_AI_BLEND_BMESH_H
|
||||
|
|
@ -51,6 +51,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
|
||||
#include "BlenderIntermediate.h"
|
||||
#include "BlenderModifier.h"
|
||||
#include "BlenderBMesh.h"
|
||||
|
||||
#include "StreamReader.h"
|
||||
#include "MemoryIOWrapper.h"
|
||||
|
|
@ -658,6 +659,12 @@ void BlenderImporter::ConvertMesh(const Scene& /*in*/, const Object* /*obj*/, co
|
|||
ConversionData& conv_data, TempArray<std::vector,aiMesh>& temp
|
||||
)
|
||||
{
|
||||
BlenderBMeshConverter BMeshConverter( mesh );
|
||||
if ( BMeshConverter.ContainsBMesh( ) )
|
||||
{
|
||||
mesh = BMeshConverter.TriangulateBMesh( );
|
||||
}
|
||||
|
||||
typedef std::pair<const int,size_t> MyPair;
|
||||
if ((!mesh->totface && !mesh->totloop) || !mesh->totvert) {
|
||||
return;
|
||||
|
|
|
|||
|
|
@ -0,0 +1,520 @@
|
|||
/*
|
||||
Open Asset Import Library (assimp)
|
||||
----------------------------------------------------------------------
|
||||
|
||||
Copyright (c) 2006-2013, assimp 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 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 BlenderTessellator.cpp
|
||||
* @brief A simple tessellation wrapper
|
||||
*/
|
||||
|
||||
#include "AssimpPCH.h"
|
||||
|
||||
#ifndef ASSIMP_BUILD_NO_BLEND_IMPORTER
|
||||
|
||||
#include "BlenderDNA.h"
|
||||
#include "BlenderScene.h"
|
||||
#include "BlenderBMesh.h"
|
||||
#include "BlenderTessellator.h"
|
||||
|
||||
#define BLEND_TESS_MAGIC ( 0x83ed9ac3 )
|
||||
|
||||
#if ASSIMP_BLEND_WITH_GLU_TESSELLATE
|
||||
|
||||
namespace Assimp
|
||||
{
|
||||
template< > const std::string LogFunctions< BlenderTessellatorGL >::log_prefix = "BLEND_TESS_GL: ";
|
||||
}
|
||||
|
||||
using namespace Assimp;
|
||||
using namespace Assimp::Blender;
|
||||
|
||||
#ifndef CALLBACK
|
||||
#define CALLBACK
|
||||
#endif
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
BlenderTessellatorGL::BlenderTessellatorGL( BlenderBMeshConverter& converter ):
|
||||
converter( &converter )
|
||||
{
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
BlenderTessellatorGL::~BlenderTessellatorGL( )
|
||||
{
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void BlenderTessellatorGL::Tessellate( const MLoop* polyLoop, int vertexCount, const std::vector< MVert >& vertices )
|
||||
{
|
||||
AssertVertexCount( vertexCount );
|
||||
|
||||
std::vector< VertexGL > polyLoopGL;
|
||||
GenerateLoopVerts( polyLoopGL, polyLoop, vertexCount, vertices );
|
||||
|
||||
TessDataGL tessData;
|
||||
Tesssellate( polyLoopGL, tessData );
|
||||
|
||||
TriangulateDrawCalls( tessData );
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void BlenderTessellatorGL::AssertVertexCount( int vertexCount )
|
||||
{
|
||||
if ( vertexCount <= 4 )
|
||||
{
|
||||
ThrowException( "Expected more than 4 vertices for tessellation" );
|
||||
}
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void BlenderTessellatorGL::GenerateLoopVerts( std::vector< VertexGL >& polyLoopGL, const MLoop* polyLoop, int vertexCount, const std::vector< MVert >& vertices )
|
||||
{
|
||||
for ( int i = 0; i < vertexCount; ++i )
|
||||
{
|
||||
const MLoop& loopItem = polyLoop[ i ];
|
||||
const MVert& vertex = vertices[ loopItem.v ];
|
||||
polyLoopGL.push_back( VertexGL( vertex.co[ 0 ], vertex.co[ 1 ], vertex.co[ 2 ], loopItem.v, BLEND_TESS_MAGIC ) );
|
||||
}
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void BlenderTessellatorGL::Tesssellate( std::vector< VertexGL >& polyLoopGL, TessDataGL& tessData )
|
||||
{
|
||||
GLUtesselator* tessellator = gluNewTess( );
|
||||
gluTessCallback( tessellator, GLU_TESS_BEGIN_DATA, reinterpret_cast< void ( CALLBACK * )( ) >( TessellateBegin ) );
|
||||
gluTessCallback( tessellator, GLU_TESS_END_DATA, reinterpret_cast< void ( CALLBACK * )( ) >( TessellateEnd ) );
|
||||
gluTessCallback( tessellator, GLU_TESS_VERTEX_DATA, reinterpret_cast< void ( CALLBACK * )( ) >( TessellateVertex ) );
|
||||
gluTessCallback( tessellator, GLU_TESS_COMBINE_DATA, reinterpret_cast< void ( CALLBACK * )( ) >( TessellateCombine ) );
|
||||
gluTessCallback( tessellator, GLU_TESS_EDGE_FLAG_DATA, reinterpret_cast< void ( CALLBACK * )( ) >( TessellateEdgeFlag ) );
|
||||
gluTessCallback( tessellator, GLU_TESS_ERROR_DATA, reinterpret_cast< void ( CALLBACK * )( ) >( TessellateError ) );
|
||||
gluTessProperty( tessellator, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_NONZERO );
|
||||
|
||||
gluTessBeginPolygon( tessellator, &tessData );
|
||||
gluTessBeginContour( tessellator );
|
||||
|
||||
for ( unsigned int i = 0; i < polyLoopGL.size( ); ++i )
|
||||
{
|
||||
gluTessVertex( tessellator, reinterpret_cast< GLdouble* >( &polyLoopGL[ i ] ), &polyLoopGL[ i ] );
|
||||
}
|
||||
|
||||
gluTessEndContour( tessellator );
|
||||
gluTessEndPolygon( tessellator );
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void BlenderTessellatorGL::TriangulateDrawCalls( const TessDataGL& tessData )
|
||||
{
|
||||
// NOTE - Because we are supplying a callback to GLU_TESS_EDGE_FLAG_DATA we don't technically
|
||||
// need support for GL_TRIANGLE_STRIP and GL_TRIANGLE_FAN but we'll keep it here in case
|
||||
// GLU tessellate changes or tristrips and fans are wanted.
|
||||
// See: http://www.opengl.org/sdk/docs/man2/xhtml/gluTessCallback.xml
|
||||
for ( unsigned int i = 0; i < tessData.drawCalls.size( ); ++i )
|
||||
{
|
||||
const DrawCallGL& drawCallGL = tessData.drawCalls[ i ];
|
||||
const VertexGL* vertices = &tessData.vertices[ drawCallGL.baseVertex ];
|
||||
if ( drawCallGL.drawMode == GL_TRIANGLES )
|
||||
{
|
||||
MakeFacesFromTris( vertices, drawCallGL.vertexCount );
|
||||
}
|
||||
else if ( drawCallGL.drawMode == GL_TRIANGLE_STRIP )
|
||||
{
|
||||
MakeFacesFromTriStrip( vertices, drawCallGL.vertexCount );
|
||||
}
|
||||
else if ( drawCallGL.drawMode == GL_TRIANGLE_FAN )
|
||||
{
|
||||
MakeFacesFromTriFan( vertices, drawCallGL.vertexCount );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void BlenderTessellatorGL::MakeFacesFromTris( const VertexGL* vertices, int vertexCount )
|
||||
{
|
||||
int triangleCount = vertexCount / 3;
|
||||
for ( int i = 0; i < triangleCount; ++i )
|
||||
{
|
||||
int vertexBase = i * 3;
|
||||
converter->AddFace( vertices[ vertexBase + 0 ].index, vertices[ vertexBase + 1 ].index, vertices[ vertexBase + 2 ].index );
|
||||
}
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void BlenderTessellatorGL::MakeFacesFromTriStrip( const VertexGL* vertices, int vertexCount )
|
||||
{
|
||||
int triangleCount = vertexCount - 2;
|
||||
for ( int i = 0; i < triangleCount; ++i )
|
||||
{
|
||||
int vertexBase = i;
|
||||
converter->AddFace( vertices[ vertexBase + 0 ].index, vertices[ vertexBase + 1 ].index, vertices[ vertexBase + 2 ].index );
|
||||
}
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void BlenderTessellatorGL::MakeFacesFromTriFan( const VertexGL* vertices, int vertexCount )
|
||||
{
|
||||
int triangleCount = vertexCount - 2;
|
||||
for ( int i = 0; i < triangleCount; ++i )
|
||||
{
|
||||
int vertexBase = i;
|
||||
converter->AddFace( vertices[ 0 ].index, vertices[ vertexBase + 1 ].index, vertices[ vertexBase + 2 ].index );
|
||||
}
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void BlenderTessellatorGL::TessellateBegin( GLenum drawModeGL, void* userData )
|
||||
{
|
||||
TessDataGL& tessData = *reinterpret_cast< TessDataGL* >( userData );
|
||||
tessData.drawCalls.push_back( DrawCallGL( drawModeGL, tessData.vertices.size( ) ) );
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void BlenderTessellatorGL::TessellateEnd( void* )
|
||||
{
|
||||
// Do nothing
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void BlenderTessellatorGL::TessellateVertex( const void* vtxData, void* userData )
|
||||
{
|
||||
TessDataGL& tessData = *reinterpret_cast< TessDataGL* >( userData );
|
||||
|
||||
const VertexGL& vertex = *reinterpret_cast< const VertexGL* >( vtxData );
|
||||
if ( vertex.magic != BLEND_TESS_MAGIC )
|
||||
{
|
||||
ThrowException( "Point returned by GLU Tessellate was probably not one of ours. This indicates we need a new way to store vertex information" );
|
||||
}
|
||||
tessData.vertices.push_back( vertex );
|
||||
if ( tessData.drawCalls.size( ) == 0 )
|
||||
{
|
||||
ThrowException( "\"Vertex\" callback received before \"Begin\"" );
|
||||
}
|
||||
++( tessData.drawCalls.back( ).vertexCount );
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void BlenderTessellatorGL::TessellateCombine( const GLdouble intersection[ 3 ], const GLdouble* [ 4 ], const GLfloat [ 4 ], GLdouble** out, void* userData )
|
||||
{
|
||||
ThrowException( "Intersected polygon loops are not yet supported" );
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void BlenderTessellatorGL::TessellateEdgeFlag( GLboolean, void* )
|
||||
{
|
||||
// Do nothing
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void BlenderTessellatorGL::TessellateError( GLenum errorCode, void* )
|
||||
{
|
||||
ThrowException( reinterpret_cast< const char* >( gluErrorString( errorCode ) ) );
|
||||
}
|
||||
|
||||
#endif // ASSIMP_BLEND_WITH_GLU_TESSELLATE
|
||||
|
||||
#if ASSIMP_BLEND_WITH_POLY_2_TRI
|
||||
|
||||
namespace Assimp
|
||||
{
|
||||
template< > const std::string LogFunctions< BlenderTessellatorP2T >::log_prefix = "BLEND_TESS_P2T: ";
|
||||
}
|
||||
|
||||
using namespace Assimp;
|
||||
using namespace Assimp::Blender;
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
BlenderTessellatorP2T::BlenderTessellatorP2T( BlenderBMeshConverter& converter ):
|
||||
converter( &converter )
|
||||
{
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
BlenderTessellatorP2T::~BlenderTessellatorP2T( )
|
||||
{
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void BlenderTessellatorP2T::Tessellate( const MLoop* polyLoop, int vertexCount, const std::vector< MVert >& vertices )
|
||||
{
|
||||
AssertVertexCount( vertexCount );
|
||||
|
||||
// NOTE - We have to hope that points in a Blender polygon are roughly on the same plane.
|
||||
// There may be some triangulation artifacts if they are wildly different.
|
||||
|
||||
std::vector< PointP2T > points;
|
||||
Copy3DVertices( polyLoop, vertexCount, vertices, points );
|
||||
|
||||
PlaneP2T plane = FindLLSQPlane( points );
|
||||
|
||||
aiMatrix4x4 transform = GeneratePointTransformMatrix( plane );
|
||||
|
||||
TransformAndFlattenVectices( transform, points );
|
||||
|
||||
std::vector< p2t::Point* > pointRefs;
|
||||
ReferencePoints( points, pointRefs );
|
||||
|
||||
p2t::CDT cdt( pointRefs );
|
||||
|
||||
cdt.Triangulate( );
|
||||
std::vector< p2t::Triangle* > triangles = cdt.GetTriangles( );
|
||||
|
||||
MakeFacesFromTriangles( triangles );
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void BlenderTessellatorP2T::AssertVertexCount( int vertexCount )
|
||||
{
|
||||
if ( vertexCount <= 4 )
|
||||
{
|
||||
ThrowException( "Expected more than 4 vertices for tessellation" );
|
||||
}
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void BlenderTessellatorP2T::Copy3DVertices( const MLoop* polyLoop, int vertexCount, const std::vector< MVert >& vertices, std::vector< PointP2T >& points ) const
|
||||
{
|
||||
points.resize( vertexCount );
|
||||
for ( int i = 0; i < vertexCount; ++i )
|
||||
{
|
||||
const MLoop& loop = polyLoop[ i ];
|
||||
const MVert& vert = vertices[ loop.v ];
|
||||
|
||||
PointP2T& point = points[ i ];
|
||||
point.point3D.Set( vert.co[ 0 ], vert.co[ 1 ], vert.co[ 2 ] );
|
||||
point.index = loop.v;
|
||||
point.magic = BLEND_TESS_MAGIC;
|
||||
}
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
aiMatrix4x4 BlenderTessellatorP2T::GeneratePointTransformMatrix( const Blender::PlaneP2T& plane ) const
|
||||
{
|
||||
aiVector3D sideA( 1.0f, 0.0f, 0.0f );
|
||||
if ( fabs( plane.normal * sideA ) > 0.999f )
|
||||
{
|
||||
sideA = aiVector3D( 0.0f, 1.0f, 0.0f );
|
||||
}
|
||||
|
||||
aiVector3D sideB( plane.normal ^ sideA );
|
||||
sideB.Normalize( );
|
||||
sideA = sideB ^ plane.normal;
|
||||
|
||||
aiMatrix4x4 result;
|
||||
result.a1 = sideA.x;
|
||||
result.a2 = sideA.y;
|
||||
result.a3 = sideA.z;
|
||||
result.b1 = sideB.x;
|
||||
result.b2 = sideB.y;
|
||||
result.b3 = sideB.z;
|
||||
result.c1 = plane.normal.x;
|
||||
result.c2 = plane.normal.y;
|
||||
result.c3 = plane.normal.z;
|
||||
result.a4 = plane.centre.x;
|
||||
result.b4 = plane.centre.y;
|
||||
result.c4 = plane.centre.z;
|
||||
result.Inverse( );
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void BlenderTessellatorP2T::TransformAndFlattenVectices( const aiMatrix4x4& transform, std::vector< Blender::PointP2T >& vertices ) const
|
||||
{
|
||||
for ( unsigned int i = 0; i < vertices.size( ); ++i )
|
||||
{
|
||||
PointP2T& point = vertices[ i ];
|
||||
point.point3D = transform * point.point3D;
|
||||
point.point2D.set( point.point3D.y, point.point3D.z );
|
||||
}
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void BlenderTessellatorP2T::ReferencePoints( std::vector< Blender::PointP2T >& points, std::vector< p2t::Point* >& pointRefs ) const
|
||||
{
|
||||
pointRefs.resize( points.size( ) );
|
||||
for ( unsigned int i = 0; i < points.size( ); ++i )
|
||||
{
|
||||
pointRefs[ i ] = &points[ i ].point2D;
|
||||
}
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// Yes this is filthy... but we have no choice
|
||||
#define OffsetOf( Class, Member ) ( static_cast< unsigned int >( \
|
||||
reinterpret_cast<uint8_t*>(&( reinterpret_cast< Class* >( NULL )->*( &Class::Member ) )) - \
|
||||
static_cast<uint8_t*>(NULL) ) )
|
||||
|
||||
inline PointP2T& BlenderTessellatorP2T::GetActualPointStructure( p2t::Point& point ) const
|
||||
{
|
||||
unsigned int pointOffset = OffsetOf( PointP2T, point2D );
|
||||
PointP2T& pointStruct = *reinterpret_cast< PointP2T* >( reinterpret_cast< char* >( &point ) - pointOffset );
|
||||
if ( pointStruct.magic != BLEND_TESS_MAGIC )
|
||||
{
|
||||
ThrowException( "Point returned by poly2tri was probably not one of ours. This indicates we need a new way to store vertex information" );
|
||||
}
|
||||
return pointStruct;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void BlenderTessellatorP2T::MakeFacesFromTriangles( std::vector< p2t::Triangle* >& triangles ) const
|
||||
{
|
||||
for ( unsigned int i = 0; i < triangles.size( ); ++i )
|
||||
{
|
||||
p2t::Triangle& Triangle = *triangles[ i ];
|
||||
|
||||
PointP2T& pointA = GetActualPointStructure( *Triangle.GetPoint( 0 ) );
|
||||
PointP2T& pointB = GetActualPointStructure( *Triangle.GetPoint( 1 ) );
|
||||
PointP2T& pointC = GetActualPointStructure( *Triangle.GetPoint( 2 ) );
|
||||
|
||||
converter->AddFace( pointA.index, pointB.index, pointC.index );
|
||||
}
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
inline float p2tMax( float a, float b )
|
||||
{
|
||||
return a > b ? a : b;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// Adapted from: http://missingbytes.blogspot.co.uk/2012/06/fitting-plane-to-point-cloud.html
|
||||
float BlenderTessellatorP2T::FindLargestMatrixElem( const aiMatrix3x3& mtx ) const
|
||||
{
|
||||
float result = 0.0f;
|
||||
|
||||
for ( int x = 0; x < 3; ++x )
|
||||
{
|
||||
for ( int y = 0; y < 3; ++y )
|
||||
{
|
||||
result = p2tMax( fabs( mtx[ x ][ y ] ), result );
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// Aparently Assimp doesn't have matrix scaling
|
||||
aiMatrix3x3 BlenderTessellatorP2T::ScaleMatrix( const aiMatrix3x3& mtx, float scale ) const
|
||||
{
|
||||
aiMatrix3x3 result;
|
||||
|
||||
for ( int x = 0; x < 3; ++x )
|
||||
{
|
||||
for ( int y = 0; y < 3; ++y )
|
||||
{
|
||||
result[ x ][ y ] = mtx[ x ][ y ] * scale;
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// Adapted from: http://missingbytes.blogspot.co.uk/2012/06/fitting-plane-to-point-cloud.html
|
||||
aiVector3D BlenderTessellatorP2T::GetEigenVectorFromLargestEigenValue( const aiMatrix3x3& mtx ) const
|
||||
{
|
||||
float scale = FindLargestMatrixElem( mtx );
|
||||
aiMatrix3x3 mc = ScaleMatrix( mtx, 1.0f / scale );
|
||||
mc = mc * mc * mc;
|
||||
|
||||
aiVector3D v( 1.0f );
|
||||
aiVector3D lastV = v;
|
||||
for ( int i = 0; i < 100; ++i )
|
||||
{
|
||||
v = mc * v;
|
||||
v.Normalize( );
|
||||
if ( ( v - lastV ).SquareLength( ) < 1e-16f )
|
||||
{
|
||||
break;
|
||||
}
|
||||
lastV = v;
|
||||
}
|
||||
return v;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// Adapted from: http://missingbytes.blogspot.co.uk/2012/06/fitting-plane-to-point-cloud.html
|
||||
PlaneP2T BlenderTessellatorP2T::FindLLSQPlane( const std::vector< PointP2T >& points ) const
|
||||
{
|
||||
PlaneP2T result;
|
||||
|
||||
aiVector3D sum( 0.0f );
|
||||
for ( unsigned int i = 0; i < points.size( ); ++i )
|
||||
{
|
||||
sum += points[ i ].point3D;
|
||||
}
|
||||
result.centre = sum * ( 1.0f / points.size( ) );
|
||||
|
||||
float sumXX = 0.0f;
|
||||
float sumXY = 0.0f;
|
||||
float sumXZ = 0.0f;
|
||||
float sumYY = 0.0f;
|
||||
float sumYZ = 0.0f;
|
||||
float sumZZ = 0.0f;
|
||||
for ( unsigned int i = 0; i < points.size( ); ++i )
|
||||
{
|
||||
aiVector3D offset = points[ i ].point3D - result.centre;
|
||||
sumXX += offset.x * offset.x;
|
||||
sumXY += offset.x * offset.y;
|
||||
sumXZ += offset.x * offset.z;
|
||||
sumYY += offset.y * offset.y;
|
||||
sumYZ += offset.y * offset.z;
|
||||
sumZZ += offset.z * offset.z;
|
||||
}
|
||||
|
||||
aiMatrix3x3 mtx( sumXX, sumXY, sumXZ, sumXY, sumYY, sumYZ, sumXZ, sumYZ, sumZZ );
|
||||
|
||||
float det = mtx.Determinant( );
|
||||
if ( det == 0.0f )
|
||||
{
|
||||
result.normal = aiVector3D( 0.0f );
|
||||
}
|
||||
else
|
||||
{
|
||||
aiMatrix3x3 invMtx = mtx;
|
||||
invMtx.Inverse( );
|
||||
result.normal = GetEigenVectorFromLargestEigenValue( invMtx );
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
#endif // ASSIMP_BLEND_WITH_POLY_2_TRI
|
||||
|
||||
#endif // ASSIMP_BUILD_NO_BLEND_IMPORTER
|
||||
|
|
@ -0,0 +1,208 @@
|
|||
/*
|
||||
Open Asset Import Library (assimp)
|
||||
----------------------------------------------------------------------
|
||||
|
||||
Copyright (c) 2006-2013, assimp 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 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 BlenderTessellator.h
|
||||
* @brief A simple tessellation wrapper
|
||||
*/
|
||||
#ifndef INCLUDED_AI_BLEND_TESSELLATOR_H
|
||||
#define INCLUDED_AI_BLEND_TESSELLATOR_H
|
||||
|
||||
// Use these to toggle between GLU Tessellate or poly2tri
|
||||
// Note (acg) keep GLU Tesselate disabled by default - if it is turned on,
|
||||
// assimp needs to be linked against GLU, which is currently not yet
|
||||
// made configurable in CMake and potentially not wanted by most users
|
||||
// as it requires a Gl environment.
|
||||
#ifndef ASSIMP_BLEND_WITH_GLU_TESSELLATE
|
||||
# define ASSIMP_BLEND_WITH_GLU_TESSELLATE 0
|
||||
#endif
|
||||
|
||||
#ifndef ASSIMP_BLEND_WITH_POLY_2_TRI
|
||||
# define ASSIMP_BLEND_WITH_POLY_2_TRI 1
|
||||
#endif
|
||||
|
||||
#include "LogAux.h"
|
||||
|
||||
#if ASSIMP_BLEND_WITH_GLU_TESSELLATE
|
||||
|
||||
#if defined( WIN32 ) || defined( _WIN32 ) || defined( _MSC_VER )
|
||||
#include <windows.h>
|
||||
#endif
|
||||
#include <GL/glu.h>
|
||||
|
||||
namespace Assimp
|
||||
{
|
||||
class BlenderBMeshConverter;
|
||||
|
||||
// TinyFormatter.h
|
||||
namespace Formatter
|
||||
{
|
||||
template < typename T,typename TR, typename A > class basic_formatter;
|
||||
typedef class basic_formatter< char, std::char_traits< char >, std::allocator< char > > format;
|
||||
}
|
||||
|
||||
// BlenderScene.h
|
||||
namespace Blender
|
||||
{
|
||||
struct MLoop;
|
||||
struct MVert;
|
||||
|
||||
struct VertexGL
|
||||
{
|
||||
GLdouble X;
|
||||
GLdouble Y;
|
||||
GLdouble Z;
|
||||
int index;
|
||||
int magic;
|
||||
|
||||
VertexGL( GLdouble X, GLdouble Y, GLdouble Z, int index, int magic ): X( X ), Y( Y ), Z( Z ), index( index ), magic( magic ) { }
|
||||
};
|
||||
|
||||
struct DrawCallGL
|
||||
{
|
||||
GLenum drawMode;
|
||||
int baseVertex;
|
||||
int vertexCount;
|
||||
|
||||
DrawCallGL( GLenum drawMode, int baseVertex ): drawMode( drawMode ), baseVertex( baseVertex ), vertexCount( 0 ) { }
|
||||
};
|
||||
|
||||
struct TessDataGL
|
||||
{
|
||||
std::vector< DrawCallGL > drawCalls;
|
||||
std::vector< VertexGL > vertices;
|
||||
};
|
||||
}
|
||||
|
||||
class BlenderTessellatorGL: public LogFunctions< BlenderTessellatorGL >
|
||||
{
|
||||
public:
|
||||
BlenderTessellatorGL( BlenderBMeshConverter& converter );
|
||||
~BlenderTessellatorGL( );
|
||||
|
||||
void Tessellate( const Blender::MLoop* polyLoop, int vertexCount, const std::vector< Blender::MVert >& vertices );
|
||||
|
||||
private:
|
||||
void AssertVertexCount( int vertexCount );
|
||||
void GenerateLoopVerts( std::vector< Blender::VertexGL >& polyLoopGL, const Blender::MLoop* polyLoop, int vertexCount, const std::vector< Blender::MVert >& vertices );
|
||||
void Tesssellate( std::vector< Blender::VertexGL >& polyLoopGL, Blender::TessDataGL& tessData );
|
||||
void TriangulateDrawCalls( const Blender::TessDataGL& tessData );
|
||||
void MakeFacesFromTris( const Blender::VertexGL* vertices, int vertexCount );
|
||||
void MakeFacesFromTriStrip( const Blender::VertexGL* vertices, int vertexCount );
|
||||
void MakeFacesFromTriFan( const Blender::VertexGL* vertices, int vertexCount );
|
||||
|
||||
static void TessellateBegin( GLenum drawModeGL, void* userData );
|
||||
static void TessellateEnd( void* userData );
|
||||
static void TessellateVertex( const void* vtxData, void* userData );
|
||||
static void TessellateCombine( const GLdouble intersection[ 3 ], const GLdouble* [ 4 ], const GLfloat [ 4 ], GLdouble** out, void* userData );
|
||||
static void TessellateEdgeFlag( GLboolean edgeFlag, void* userData );
|
||||
static void TessellateError( GLenum errorCode, void* userData );
|
||||
|
||||
BlenderBMeshConverter* converter;
|
||||
};
|
||||
} // end of namespace Assimp
|
||||
|
||||
#endif // ASSIMP_BLEND_WITH_GLU_TESSELLATE
|
||||
|
||||
#if ASSIMP_BLEND_WITH_POLY_2_TRI
|
||||
|
||||
#include "../contrib/poly2tri/poly2tri/poly2tri.h"
|
||||
|
||||
namespace Assimp
|
||||
{
|
||||
class BlenderBMeshConverter;
|
||||
|
||||
// TinyFormatter.h
|
||||
namespace Formatter
|
||||
{
|
||||
template < typename T,typename TR, typename A > class basic_formatter;
|
||||
typedef class basic_formatter< char, std::char_traits< char >, std::allocator< char > > format;
|
||||
}
|
||||
|
||||
// BlenderScene.h
|
||||
namespace Blender
|
||||
{
|
||||
struct MLoop;
|
||||
struct MVert;
|
||||
|
||||
struct PointP2T
|
||||
{
|
||||
aiVector3D point3D;
|
||||
p2t::Point point2D;
|
||||
int magic;
|
||||
int index;
|
||||
};
|
||||
|
||||
struct PlaneP2T
|
||||
{
|
||||
aiVector3D centre;
|
||||
aiVector3D normal;
|
||||
};
|
||||
}
|
||||
|
||||
class BlenderTessellatorP2T: public LogFunctions< BlenderTessellatorP2T >
|
||||
{
|
||||
public:
|
||||
BlenderTessellatorP2T( BlenderBMeshConverter& converter );
|
||||
~BlenderTessellatorP2T( );
|
||||
|
||||
void Tessellate( const Blender::MLoop* polyLoop, int vertexCount, const std::vector< Blender::MVert >& vertices );
|
||||
|
||||
private:
|
||||
void AssertVertexCount( int vertexCount );
|
||||
void Copy3DVertices( const Blender::MLoop* polyLoop, int vertexCount, const std::vector< Blender::MVert >& vertices, std::vector< Blender::PointP2T >& targetVertices ) const;
|
||||
aiMatrix4x4 GeneratePointTransformMatrix( const Blender::PlaneP2T& plane ) const;
|
||||
void TransformAndFlattenVectices( const aiMatrix4x4& transform, std::vector< Blender::PointP2T >& vertices ) const;
|
||||
void ReferencePoints( std::vector< Blender::PointP2T >& points, std::vector< p2t::Point* >& pointRefs ) const;
|
||||
inline Blender::PointP2T& GetActualPointStructure( p2t::Point& point ) const;
|
||||
void MakeFacesFromTriangles( std::vector< p2t::Triangle* >& triangles ) const;
|
||||
|
||||
// Adapted from: http://missingbytes.blogspot.co.uk/2012/06/fitting-plane-to-point-cloud.html
|
||||
float FindLargestMatrixElem( const aiMatrix3x3& mtx ) const;
|
||||
aiMatrix3x3 ScaleMatrix( const aiMatrix3x3& mtx, float scale ) const;
|
||||
aiVector3D GetEigenVectorFromLargestEigenValue( const aiMatrix3x3& mtx ) const;
|
||||
Blender::PlaneP2T FindLLSQPlane( const std::vector< Blender::PointP2T >& points ) const;
|
||||
|
||||
BlenderBMeshConverter* converter;
|
||||
};
|
||||
} // end of namespace Assimp
|
||||
|
||||
#endif // ASSIMP_BLEND_WITH_POLY_2_TRI
|
||||
|
||||
#endif // INCLUDED_AI_BLEND_TESSELLATOR_H
|
||||
|
|
@ -362,6 +362,10 @@ SET(BLENDER_SRCS
|
|||
BlenderIntermediate.h
|
||||
BlenderModifier.h
|
||||
BlenderModifier.cpp
|
||||
BlenderBMesh.h
|
||||
BlenderBMesh.cpp
|
||||
BlenderTessellator.h
|
||||
BlenderTessellator.cpp
|
||||
)
|
||||
SOURCE_GROUP( BLENDER FILES ${BLENDER_SRCS})
|
||||
|
||||
|
|
|
|||
|
|
@ -292,16 +292,16 @@ void Document::ReadHeader()
|
|||
|
||||
// while we maye have some success with newer files, we don't support
|
||||
// the older 6.n fbx format
|
||||
if(fbxVersion < 7200) {
|
||||
DOMError("unsupported, old format version, supported are only FBX 2012 and FBX 2013");
|
||||
if(fbxVersion < 7100) {
|
||||
DOMError("unsupported, old format version, supported are only FBX 2011, FBX 2012 and FBX 2013");
|
||||
}
|
||||
if(fbxVersion > 7300) {
|
||||
if(Settings().strictMode) {
|
||||
DOMError("unsupported, newer format version, supported are only FBX 2012 and FBX 2013"
|
||||
DOMError("unsupported, newer format version, supported are only FBX 2011, FBX 2012 and FBX 2013"
|
||||
" (turn off strict mode to try anyhow) ");
|
||||
}
|
||||
else {
|
||||
DOMWarning("unsupported, newer format version, supported are only FBX 2012 and FBX 2013,"
|
||||
DOMWarning("unsupported, newer format version, supported are only FBX 2011, FBX 2012 and FBX 2013,"
|
||||
" trying to read it nevertheless");
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -563,7 +563,7 @@ void MS3DImporter::InternReadFile( const std::string& pFile,
|
|||
}
|
||||
|
||||
// ... add dummy nodes under a single root, each holding a reference to one
|
||||
// mesh. If we didn't do this, we'd loose the group name.
|
||||
// mesh. If we didn't do this, we'd lose the group name.
|
||||
aiNode* rt = pScene->mRootNode = new aiNode("<MS3DRoot>");
|
||||
|
||||
#ifdef ASSIMP_BUILD_MS3D_ONE_NODE_PER_MESH
|
||||
|
|
|
|||
|
|
@ -191,7 +191,7 @@ can use a comfortable installer from <a href="http://www.boost-consulting.com/pr
|
|||
http://www.boost-consulting.com/products/free</a>. Choose the appropriate version of boost for your runtime of choice.
|
||||
|
||||
<b>If you don't want to use boost</b>, you can build against our <i>"Boost-Workaround"</i>. It consists of very small
|
||||
implementations of the various boost utility classes used. However, you'll loose functionality (e.g. threading) by doing this.
|
||||
implementations of the various boost utility classes used. However, you'll lose functionality (e.g. threading) by doing this.
|
||||
So, if you can use boost, you should use boost. Otherwise, See the @link use_noboost NoBoost-Section @endlink
|
||||
later on this page for the details of the workaround.
|
||||
|
||||
|
|
|
|||
|
|
@ -50,6 +50,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
#include <memory.h>
|
||||
#include <math.h>
|
||||
#include <stddef.h>
|
||||
#include <string.h>
|
||||
#include <limits.h>
|
||||
|
||||
// Our compile configuration
|
||||
|
|
|
|||
|
|
@ -30,6 +30,10 @@ if os.name=='posix':
|
|||
|
||||
elif os.name=='nt':
|
||||
ext_whitelist.append('.dll')
|
||||
path_dirs = os.environ['PATH'].split(';')
|
||||
for dir_candidate in path_dirs:
|
||||
if 'assimp' in dir_candidate.lower():
|
||||
additional_dirs.append(dir_candidate)
|
||||
|
||||
#print(additional_dirs)
|
||||
def vec2tuple(x):
|
||||
|
|
|
|||
|
|
@ -22,8 +22,6 @@ INCLUDE_DIRECTORIES(
|
|||
LINK_DIRECTORIES(
|
||||
${Assimp_BINARY_DIR}
|
||||
${Assimp_BINARY_DIR}/lib/
|
||||
${Assimp_SOURCE_DIR}/samples/glut/
|
||||
${Assimp_SOURCE_DIR}/samples/DevIL/lib/
|
||||
)
|
||||
|
||||
ADD_EXECUTABLE( assimp_simpletexturedogl WIN32
|
||||
|
|
|
|||
|
|
@ -17,9 +17,9 @@
|
|||
|
||||
#include <windows.h>
|
||||
#include <stdio.h>
|
||||
#include <gl\GL.h>
|
||||
#include <gl\GLU.h>
|
||||
#include <IL\il.h>
|
||||
#include <GL/gl.h>
|
||||
#include <GL/glu.h>
|
||||
#include <IL/il.h>
|
||||
|
||||
#include <fstream>
|
||||
|
||||
|
|
@ -30,8 +30,8 @@
|
|||
|
||||
// assimp include files. These three are usually needed.
|
||||
#include "assimp/Importer.hpp" //OO version Header!
|
||||
#include "assimp/PostProcess.h"
|
||||
#include "assimp/Scene.h"
|
||||
#include "assimp/postprocess.h"
|
||||
#include "assimp/scene.h"
|
||||
#include "assimp/DefaultLogger.hpp"
|
||||
#include "assimp/LogStream.hpp"
|
||||
|
||||
|
|
@ -177,7 +177,6 @@ int LoadGLTextures(const aiScene* scene)
|
|||
/* Before calling ilInit() version should be checked. */
|
||||
if (ilGetInteger(IL_VERSION_NUM) < IL_VERSION)
|
||||
{
|
||||
ILint test = ilGetInteger(IL_VERSION_NUM);
|
||||
/// wrong DevIL version ///
|
||||
std::string err_msg = "Wrong DevIL version. Old devil.dll in system32/SysWow64?";
|
||||
char* cErr_msg = (char *) err_msg.c_str();
|
||||
|
|
|
|||
|
|
@ -139,7 +139,7 @@ IMPLEMENTATION DEPENDENT DIFFERENCES:
|
|||
Specifically, the "window manager" in Win32 uses a "click to
|
||||
focus" policy. That is, in order for a window to receive
|
||||
focus, a mouse button must be clicked in it. Likewise, in
|
||||
order for a window to loose focus, a mouse button must be
|
||||
order for a window to lose focus, a mouse button must be
|
||||
clicked outside the window (or in another window).
|
||||
Therefore, the Enter and Leave notification provided by GLUT
|
||||
may behave differently in the Win32 and in X11 versions.
|
||||
|
|
|
|||
|
|
@ -139,19 +139,20 @@ class AssetHelper
|
|||
:
|
||||
piVB (NULL),
|
||||
piIB (NULL),
|
||||
piEffect (NULL),
|
||||
piVBNormals (NULL),
|
||||
piEffect (NULL),
|
||||
bSharedFX (false),
|
||||
piDiffuseTexture (NULL),
|
||||
piSpecularTexture (NULL),
|
||||
piAmbientTexture (NULL),
|
||||
piNormalTexture (NULL),
|
||||
piEmissiveTexture (NULL),
|
||||
piNormalTexture (NULL),
|
||||
piOpacityTexture (NULL),
|
||||
piShininessTexture (NULL),
|
||||
piLightmapTexture (NULL),
|
||||
pvOriginalNormals (NULL),
|
||||
bSharedFX(false),
|
||||
twosided (false){}
|
||||
twosided (false),
|
||||
pvOriginalNormals (NULL)
|
||||
{}
|
||||
|
||||
~MeshHelper ()
|
||||
{
|
||||
|
|
|
|||
|
|
@ -47,10 +47,10 @@ class CBackgroundPainter
|
|||
{
|
||||
CBackgroundPainter()
|
||||
:
|
||||
pcTexture(NULL),
|
||||
clrColor(D3DCOLOR_ARGB(0xFF,100,100,100)),
|
||||
eMode(SIMPLE_COLOR),
|
||||
piSkyBoxEffect(NULL)
|
||||
pcTexture(NULL),
|
||||
piSkyBoxEffect(NULL),
|
||||
eMode(SIMPLE_COLOR)
|
||||
{}
|
||||
|
||||
public:
|
||||
|
|
|
|||
|
|
@ -43,8 +43,11 @@ ADD_EXECUTABLE( assimp_viewer WIN32
|
|||
|
||||
SET_PROPERTY(TARGET assimp_viewer PROPERTY DEBUG_POSTFIX ${ASSIMP_DEBUG_POSTFIX})
|
||||
|
||||
ADD_DEFINITIONS( -D_SCL_SECURE_NO_WARNINGS )
|
||||
ADD_DEFINITIONS( -D_CRT_SECURE_NO_WARNINGS )
|
||||
|
||||
IF ( MSVC )
|
||||
ADD_DEFINITIONS( -D_SCL_SECURE_NO_WARNINGS )
|
||||
ADD_DEFINITIONS( -D_CRT_SECURE_NO_WARNINGS )
|
||||
ENDIF ( MSVC )
|
||||
|
||||
|
||||
#
|
||||
|
|
@ -54,7 +57,7 @@ ADD_CUSTOM_COMMAND(TARGET assimp_viewer
|
|||
MAIN_DEPENDENCY assimp)
|
||||
|
||||
# Link the executable to the assimp + dx libs.
|
||||
TARGET_LINK_LIBRARIES ( assimp_viewer assimp ${DirectX_LIBRARY} ${DirectX_D3DX9_LIBRARY} comctl32.lib Winmm.lib )
|
||||
TARGET_LINK_LIBRARIES ( assimp_viewer assimp ${DirectX_LIBRARY} ${DirectX_D3DX9_LIBRARY} comctl32.lib winmm.lib )
|
||||
|
||||
INSTALL( TARGETS assimp_viewer
|
||||
DESTINATION "${ASSIMP_BIN_INSTALL_DIR}" COMPONENT assimp-dev
|
||||
|
|
|
|||
|
|
@ -55,8 +55,8 @@ class Camera
|
|||
:
|
||||
|
||||
vPos(0.0f,0.0f,-10.0f),
|
||||
vLookAt(0.0f,0.0f,1.0f),
|
||||
vUp(0.0f,1.0f,0.0f),
|
||||
vLookAt(0.0f,0.0f,1.0f),
|
||||
vRight(0.0f,1.0f,0.0f)
|
||||
{
|
||||
|
||||
|
|
|
|||
|
|
@ -287,10 +287,6 @@ int CDisplay::ReplaceCurrentTexture(const char* szPath)
|
|||
TreeView_SetItem(GetDlgItem(g_hDlg,IDC_TREE1),
|
||||
m_pcCurrentTexture->hTreeItem);
|
||||
|
||||
// change this in the old aiMaterial structure, too
|
||||
aiMaterial* pcMat = (aiMaterial*)
|
||||
g_pcAsset->pcScene->mMaterials[m_pcCurrentTexture->iMatIndex];
|
||||
|
||||
// update all meshes referencing this material
|
||||
for (unsigned int i = 0; i < g_pcAsset->pcScene->mNumMeshes;++i)
|
||||
{
|
||||
|
|
@ -1187,7 +1183,7 @@ int CDisplay::HandleTreeViewPopup(WPARAM wParam,LPARAM lParam)
|
|||
{
|
||||
// get the current selected material
|
||||
std::vector<Info> apclrOut;
|
||||
const char* szMatKey;
|
||||
const char* szMatKey = "";
|
||||
|
||||
switch (LOWORD(wParam))
|
||||
{
|
||||
|
|
@ -1255,7 +1251,7 @@ int CDisplay::HandleTreeViewPopup(WPARAM wParam,LPARAM lParam)
|
|||
clr.lpCustColors = g_aclCustomColors;
|
||||
clr.lpfnHook = NULL;
|
||||
clr.lpTemplateName = NULL;
|
||||
clr.lCustData = NULL;
|
||||
clr.lCustData = 0;
|
||||
|
||||
ChooseColor(&clr);
|
||||
|
||||
|
|
|
|||
|
|
@ -42,7 +42,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
#include "stdafx.h"
|
||||
#include "assimp_view.h"
|
||||
|
||||
#include "RICHEDIT.H"
|
||||
#include "richedit.h"
|
||||
|
||||
namespace AssimpView {
|
||||
|
||||
|
|
@ -53,7 +53,7 @@ namespace AssimpView {
|
|||
INT_PTR CALLBACK HelpDialogProc(HWND hwndDlg,UINT uMsg,
|
||||
WPARAM wParam,LPARAM lParam)
|
||||
{
|
||||
lParam;
|
||||
(void)lParam;
|
||||
switch (uMsg)
|
||||
{
|
||||
case WM_INITDIALOG:
|
||||
|
|
@ -70,7 +70,6 @@ INT_PTR CALLBACK HelpDialogProc(HWND hwndDlg,UINT uMsg,
|
|||
SendDlgItemMessage(hwndDlg,IDC_RICHEDIT21,
|
||||
EM_SETTEXTEX,(WPARAM)&sInfo,( LPARAM) pData);
|
||||
|
||||
UnlockResource(hg);
|
||||
FreeResource(hg);
|
||||
return TRUE;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -41,7 +41,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
|
||||
#include "stdafx.h"
|
||||
#include "assimp_view.h"
|
||||
#include "RichEdit.h"
|
||||
#include "richedit.h"
|
||||
|
||||
namespace AssimpView {
|
||||
|
||||
|
|
@ -70,7 +70,7 @@ static const char* AI_VIEW_RTF_LOG_HEADER =
|
|||
INT_PTR CALLBACK LogDialogProc(HWND hwndDlg,UINT uMsg,
|
||||
WPARAM wParam,LPARAM lParam)
|
||||
{
|
||||
lParam;
|
||||
(void)lParam;
|
||||
switch (uMsg)
|
||||
{
|
||||
case WM_INITDIALOG:
|
||||
|
|
|
|||
|
|
@ -299,7 +299,7 @@ int CMaterialManager::FindValidPath(aiString* p_szString)
|
|||
if( !q ) q=strrchr( tmp2,'\\' );
|
||||
if( q ){
|
||||
strcpy( q+1,p+1 );
|
||||
if(pFile=fopen( tmp2,"r" ) ){
|
||||
if((pFile=fopen( tmp2,"r" ))){
|
||||
fclose( pFile );
|
||||
strcpy(p_szString->data,tmp2);
|
||||
p_szString->length = strlen(tmp2);
|
||||
|
|
|
|||
|
|
@ -61,7 +61,7 @@ int CMeshRenderer::DrawUnsorted(unsigned int iIndex)
|
|||
|
||||
g_piDevice->SetIndices(g_pcAsset->apcMeshes[iIndex]->piIB);
|
||||
|
||||
D3DPRIMITIVETYPE type;
|
||||
D3DPRIMITIVETYPE type = D3DPT_POINTLIST;
|
||||
switch (g_pcAsset->pcScene->mMeshes[iIndex]->mPrimitiveTypes) {
|
||||
case aiPrimitiveType_POINT:
|
||||
type = D3DPT_POINTLIST;break;
|
||||
|
|
|
|||
|
|
@ -41,7 +41,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
|
||||
#include "stdafx.h"
|
||||
#include "assimp_view.h"
|
||||
#include <Windowsx.h>
|
||||
#include <windowsx.h>
|
||||
|
||||
namespace AssimpView {
|
||||
|
||||
|
|
@ -95,16 +95,16 @@ void MakeFileAssociations()
|
|||
ai_assert(sz[0] == '*');
|
||||
sprintf(buf,"Software\\Classes\\%s",sz+1);
|
||||
|
||||
RegCreateKeyEx(HKEY_CURRENT_USER,buf,NULL,NULL,0,KEY_ALL_ACCESS, NULL, &g_hRegistry,NULL);
|
||||
RegCreateKeyEx(HKEY_CURRENT_USER,buf,0,NULL,0,KEY_ALL_ACCESS, NULL, &g_hRegistry,NULL);
|
||||
RegSetValueEx(g_hRegistry,"",0,REG_SZ,(const BYTE*)"ASSIMPVIEW_CLASS",(DWORD)strlen("ASSIMPVIEW_CLASS")+1);
|
||||
RegCloseKey(g_hRegistry);
|
||||
}
|
||||
while (sz = strtok(NULL,";"));
|
||||
while ((sz = strtok(NULL,";")));
|
||||
|
||||
RegCreateKeyEx(HKEY_CURRENT_USER,"Software\\Classes\\ASSIMPVIEW_CLASS",NULL,NULL,0,KEY_ALL_ACCESS, NULL, &g_hRegistry,NULL);
|
||||
RegCreateKeyEx(HKEY_CURRENT_USER,"Software\\Classes\\ASSIMPVIEW_CLASS",0,NULL,0,KEY_ALL_ACCESS, NULL, &g_hRegistry,NULL);
|
||||
RegCloseKey(g_hRegistry);
|
||||
|
||||
RegCreateKeyEx(HKEY_CURRENT_USER,"Software\\Classes\\ASSIMPVIEW_CLASS\\shell\\open\\command",NULL,NULL,0,KEY_ALL_ACCESS, NULL, &g_hRegistry,NULL);
|
||||
RegCreateKeyEx(HKEY_CURRENT_USER,"Software\\Classes\\ASSIMPVIEW_CLASS\\shell\\open\\command",0,NULL,0,KEY_ALL_ACCESS, NULL, &g_hRegistry,NULL);
|
||||
RegSetValueEx(g_hRegistry,"",0,REG_SZ,(const BYTE*)szTemp,(DWORD)strlen(szTemp)+1);
|
||||
RegCloseKey(g_hRegistry);
|
||||
|
||||
|
|
@ -522,7 +522,7 @@ void DisplayColorDialog(D3DCOLOR* pclrResult)
|
|||
clr.lpCustColors = g_aclCustomColors;
|
||||
clr.lpfnHook = NULL;
|
||||
clr.lpTemplateName = NULL;
|
||||
clr.lCustData = NULL;
|
||||
clr.lCustData = 0;
|
||||
|
||||
ChooseColor(&clr);
|
||||
|
||||
|
|
@ -549,7 +549,7 @@ void DisplayColorDialog(D3DXVECTOR4* pclrResult)
|
|||
clr.lpCustColors = g_aclCustomColors;
|
||||
clr.lpfnHook = NULL;
|
||||
clr.lpTemplateName = NULL;
|
||||
clr.lCustData = NULL;
|
||||
clr.lCustData = 0;
|
||||
|
||||
ChooseColor(&clr);
|
||||
|
||||
|
|
@ -1120,7 +1120,7 @@ void InitUI()
|
|||
|
||||
// store the key in a global variable for later use
|
||||
RegCreateKeyEx(HKEY_CURRENT_USER,"Software\\ASSIMP\\Viewer",
|
||||
NULL,NULL,0,KEY_ALL_ACCESS, NULL, &g_hRegistry,NULL);
|
||||
0,NULL,0,KEY_ALL_ACCESS, NULL, &g_hRegistry,NULL);
|
||||
|
||||
if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"LastUIState",NULL,NULL,
|
||||
(BYTE*)&dwValue,&dwTemp))
|
||||
|
|
@ -2411,7 +2411,7 @@ int APIENTRY _tWinMain(HINSTANCE hInstance,
|
|||
};
|
||||
DWORD dwTemp = MAX_PATH;
|
||||
RegCreateKeyEx(HKEY_CURRENT_USER,
|
||||
"Software\\ASSIMP\\Viewer",NULL,NULL,0,KEY_ALL_ACCESS, NULL, &g_hRegistry,NULL);
|
||||
"Software\\ASSIMP\\Viewer",0,NULL,0,KEY_ALL_ACCESS, NULL, &g_hRegistry,NULL);
|
||||
if(ERROR_SUCCESS == RegQueryValueEx(g_hRegistry,"LastSkyBoxSrc",NULL,NULL,
|
||||
(BYTE*)szFileName,&dwTemp) && '\0' != szFileName[0])
|
||||
{
|
||||
|
|
|
|||
|
|
@ -60,16 +60,16 @@ class RenderOptions
|
|||
bSuperSample (false),
|
||||
bRenderMats (true),
|
||||
bRenderNormals (false),
|
||||
eDrawMode (NORMAL),
|
||||
b3Lights (false),
|
||||
bLightRotate (false),
|
||||
bRotate (true),
|
||||
bLowQuality (false),
|
||||
bNoSpecular (false),
|
||||
bStereoView (false),
|
||||
bNoAlphaBlending(false),
|
||||
eDrawMode (NORMAL),
|
||||
bCulling (false),
|
||||
bSkeleton (false),
|
||||
bNoAlphaBlending(false)
|
||||
bSkeleton (false)
|
||||
|
||||
{}
|
||||
|
||||
|
|
|
|||
|
|
@ -106,7 +106,7 @@ aiVector3D g_vRotateSpeed = aiVector3D(0.5f,0.5f,0.5f);
|
|||
aiVector3D g_avLightDirs[1] =
|
||||
{ aiVector3D(-0.5f,0.6f,0.2f) };
|
||||
|
||||
extern D3DCOLOR g_avLightColors[3] =
|
||||
D3DCOLOR g_avLightColors[3] =
|
||||
{
|
||||
D3DCOLOR_ARGB(0xFF,0xFF,0xFF,0xFF),
|
||||
D3DCOLOR_ARGB(0xFF,0xFF,0x00,0x00),
|
||||
|
|
@ -872,12 +872,10 @@ int CreateHUDTexture()
|
|||
g_pcTexture = NULL;
|
||||
g_szImageMask = NULL;
|
||||
|
||||
UnlockResource(hg);
|
||||
FreeResource(hg);
|
||||
return 0;
|
||||
}
|
||||
|
||||
UnlockResource(hg);
|
||||
FreeResource(hg);
|
||||
|
||||
D3DSURFACE_DESC sDesc;
|
||||
|
|
@ -909,12 +907,10 @@ int CreateHUDTexture()
|
|||
D3DCOLOR_ARGB(0xFF,0xFF,0,0));
|
||||
g_szImageMask = NULL;
|
||||
|
||||
UnlockResource(hg);
|
||||
FreeResource(hg);
|
||||
return 0;
|
||||
}
|
||||
|
||||
UnlockResource(hg);
|
||||
FreeResource(hg);
|
||||
|
||||
// lock the texture and copy it to get a pointer
|
||||
|
|
|
|||
|
|
@ -44,14 +44,14 @@
|
|||
|
||||
#include <d3d9.h>
|
||||
#include <d3dx9.h>
|
||||
#include <D3DX9Mesh.h>
|
||||
#include <d3dx9mesh.h>
|
||||
|
||||
// ShellExecute()
|
||||
#include <shellapi.h>
|
||||
#include <commctrl.h>
|
||||
|
||||
// GetOpenFileName()
|
||||
#include <Commdlg.h>
|
||||
#include <commdlg.h>
|
||||
#include <algorithm>
|
||||
#include <mmsystem.h>
|
||||
|
||||
|
|
@ -60,13 +60,15 @@
|
|||
#include <list>
|
||||
#include <vector>
|
||||
|
||||
#if defined _MSC_VER
|
||||
// Windows CommonControls 6.0 Manifest Extensions
|
||||
#if defined _M_IX86
|
||||
# if defined _M_IX86
|
||||
# pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='x86' publicKeyToken='6595b64144ccf1df' language='*'\"")
|
||||
#elif defined _M_IA64
|
||||
# elif defined _M_IA64
|
||||
# pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='ia64' publicKeyToken='6595b64144ccf1df' language='*'\"")
|
||||
#elif defined _M_X64
|
||||
# elif defined _M_X64
|
||||
# pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='amd64' publicKeyToken='6595b64144ccf1df' language='*'\"")
|
||||
#else
|
||||
# else
|
||||
# pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"")
|
||||
# endif
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -1867,6 +1867,14 @@
|
|||
<Filter
|
||||
Name="blend"
|
||||
>
|
||||
<File
|
||||
RelativePath="..\..\code\BlenderBMesh.cpp"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath="..\..\code\BlenderBMesh.h"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath="..\..\code\BlenderDNA.cpp"
|
||||
>
|
||||
|
|
@ -1911,6 +1919,14 @@
|
|||
RelativePath="..\..\code\BlenderSceneGen.h"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath="..\..\code\BlenderTessellator.cpp"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath="..\..\code\BlenderTessellator.h"
|
||||
>
|
||||
</File>
|
||||
</Filter>
|
||||
<Filter
|
||||
Name="q3bsp"
|
||||
|
|
|
|||
Loading…
Reference in New Issue