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, 0 insertions, 532 deletions
diff --git a/src/mesh/assimp-master/code/AssetLib/Blender/BlenderTessellator.cpp b/src/mesh/assimp-master/code/AssetLib/Blender/BlenderTessellator.cpp
deleted file mode 100644
index d3d463e..0000000
--- a/src/mesh/assimp-master/code/AssetLib/Blender/BlenderTessellator.cpp
+++ /dev/null
@@ -1,532 +0,0 @@
-/*
-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