summaryrefslogtreecommitdiff
path: root/src/mesh/assimp-master/code/AssetLib/Blender/BlenderTessellator.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/mesh/assimp-master/code/AssetLib/Blender/BlenderTessellator.cpp')
-rw-r--r--src/mesh/assimp-master/code/AssetLib/Blender/BlenderTessellator.cpp532
1 files changed, 532 insertions, 0 deletions
diff --git a/src/mesh/assimp-master/code/AssetLib/Blender/BlenderTessellator.cpp b/src/mesh/assimp-master/code/AssetLib/Blender/BlenderTessellator.cpp
new file mode 100644
index 0000000..d3d463e
--- /dev/null
+++ b/src/mesh/assimp-master/code/AssetLib/Blender/BlenderTessellator.cpp
@@ -0,0 +1,532 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, 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
+ */
+
+
+#ifndef ASSIMP_BUILD_NO_BLEND_IMPORTER
+
+#include "BlenderDNA.h"
+#include "BlenderScene.h"
+#include "BlenderBMesh.h"
+#include "BlenderTessellator.h"
+
+#include <stddef.h>
+
+static const unsigned int BLEND_TESS_MAGIC = 0x83ed9ac3;
+
+#if ASSIMP_BLEND_WITH_GLU_TESSELLATE
+
+namspace Assimp
+{
+ template< > const char* LogFunctions< BlenderTessellatorGL >::Prefix()
+ {
+ static auto prefix = "BLEND_TESS_GL: ";
+ return prefix;
+ }
+}
+
+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 tri-strips 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 )
+{
+ const 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 )
+{
+ const 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 )
+{
+ const 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 char* LogFunctions< BlenderTessellatorP2T >::Prefix()
+ {
+ static auto prefix = "BLEND_TESS_P2T: ";
+ return prefix;
+ }
+}
+
+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 ( std::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 ( size_t 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 ( size_t i = 0; i < points.size( ); ++i )
+ {
+ pointRefs[ i ] = &points[ i ].point2D;
+ }
+}
+
+// ------------------------------------------------------------------------------------------------
+inline PointP2T& BlenderTessellatorP2T::GetActualPointStructure( p2t::Point& point ) const
+{
+#if defined __clang__
+# pragma clang diagnostic push
+# pragma clang diagnostic ignored "-Winvalid-offsetof"
+#endif // __clang__
+ unsigned int pointOffset = offsetof( PointP2T, point2D );
+#if defined __clang__
+# pragma clang diagnostic pop
+#endif
+ PointP2T& pointStruct = *reinterpret_cast< PointP2T* >( reinterpret_cast< char* >( &point ) - pointOffset );
+ if ( pointStruct.magic != static_cast<int>( 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 ( size_t 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 ( unsigned int x = 0; x < 3; ++x )
+ {
+ for ( unsigned int y = 0; y < 3; ++y )
+ {
+ result = p2tMax( std::fabs( mtx[ x ][ y ] ), result );
+ }
+ }
+
+ return result;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Apparently Assimp doesn't have matrix scaling
+aiMatrix3x3 BlenderTessellatorP2T::ScaleMatrix( const aiMatrix3x3& mtx, float scale ) const
+{
+ aiMatrix3x3 result;
+
+ for ( unsigned int x = 0; x < 3; ++x )
+ {
+ for ( unsigned 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
+{
+ 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.0 );
+ for ( size_t i = 0; i < points.size( ); ++i )
+ {
+ sum += points[ i ].point3D;
+ }
+ result.centre = sum * (ai_real)( 1.0 / points.size( ) );
+
+ ai_real sumXX = 0.0;
+ ai_real sumXY = 0.0;
+ ai_real sumXZ = 0.0;
+ ai_real sumYY = 0.0;
+ ai_real sumYZ = 0.0;
+ ai_real sumZZ = 0.0;
+ for ( size_t 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 );
+
+ const ai_real 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