diff --git a/CMakeLists.txt b/CMakeLists.txt index 0539a4717..f5391f7d2 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -82,7 +82,7 @@ ELSE ( ASSIMP_ENABLE_BOOST_WORKAROUND ) MESSAGE( FATAL_ERROR "Boost libraries (http://www.boost.org/) not found. " "You can build a non-boost version of Assimp with slightly reduced " - "functionality by specifying -DENABLE_BOOST_WORKAROUND=ON." + "functionality by specifying -DASSIMP_ENABLE_BOOST_WORKAROUND=ON." ) ENDIF ( NOT Boost_FOUND ) diff --git a/CREDITS b/CREDITS index a46aa2332..6fee05163 100644 --- a/CREDITS +++ b/CREDITS @@ -135,4 +135,10 @@ Several LWO and LWS fixes (pivoting). GCC/Linux fixes for the SimpleOpenGL sample. - Brian Miller -Bugfix for a compiler fix for iOS on arm. \ No newline at end of file +Bugfix for a compiler fix for iOS on arm. + +- Séverin Lemaignan +Rewrite of PyAssimp, distutils and Python3 support + +- albert-wang +Bugfixes for the collada parser \ No newline at end of file diff --git a/code/ASEParser.cpp b/code/ASEParser.cpp index 2cbad8499..04cd871ff 100644 --- a/code/ASEParser.cpp +++ b/code/ASEParser.cpp @@ -44,6 +44,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "AssimpPCH.h" +#ifndef ASSIMP_BUILD_NO_ASE_IMPORTER // internal headers #include "TextureTransform.h" @@ -2148,3 +2149,5 @@ void Parser::ParseLV4MeshLong(unsigned int& iOut) // parse the value iOut = strtoul10(filePtr,&filePtr); } + +#endif // !! ASSIMP_BUILD_NO_BASE_IMPORTER diff --git a/code/ColladaLoader.cpp b/code/ColladaLoader.cpp index bdda06531..5d83ccaba 100644 --- a/code/ColladaLoader.cpp +++ b/code/ColladaLoader.cpp @@ -514,7 +514,8 @@ void ColladaLoader::BuildMeshesForNode( const ColladaParser& pParser, const Coll // assign the material index dstMesh->mMaterialIndex = matIdx; - } + dstMesh->mName = mid.mMeshOrController; + } } } diff --git a/code/ColladaParser.cpp b/code/ColladaParser.cpp index 43ee1940e..0058e8680 100644 --- a/code/ColladaParser.cpp +++ b/code/ColladaParser.cpp @@ -1369,9 +1369,11 @@ void ColladaParser::ReadEffectColor( aiColor4D& pColor, Sampler& pSampler) int attrTex = GetAttribute( "texture"); pSampler.mName = mReader->getAttributeValue( attrTex); - // get name of UV source channel - attrTex = GetAttribute( "texcoord"); - pSampler.mUVChannel = mReader->getAttributeValue( attrTex); + // get name of UV source channel. Specification demands it to be there, but some exporters + // don't write it. It will be the default UV channel in case it's missing. + attrTex = TestAttribute( "texcoord"); + if( attrTex >= 0 ) + pSampler.mUVChannel = mReader->getAttributeValue( attrTex); //SkipElement(); } else if( IsElement( "technique")) @@ -1795,14 +1797,13 @@ void ColladaParser::ReadAccessor( const std::string& pID) SkipElement(); } else { - ThrowException( "Unexpected sub element in tag \"accessor\"."); + ThrowException( boost::str( boost::format( "Unexpected sub element <%s> in tag ") % mReader->getNodeName())); } } else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) { if( strcmp( mReader->getNodeName(), "accessor") != 0) - ThrowException( "Expected end of \"accessor\" element."); - + ThrowException( "Expected end of element."); break; } } @@ -1826,13 +1827,13 @@ void ColladaParser::ReadVertexData( Mesh* pMesh) ReadInputChannel( pMesh->mPerVertexData); } else { - ThrowException( "Unexpected sub element in tag \"vertices\"."); + ThrowException( boost::str( boost::format( "Unexpected sub element <%s> in tag ") % mReader->getNodeName())); } } else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) { if( strcmp( mReader->getNodeName(), "vertices") != 0) - ThrowException( "Expected end of \"vertices\" element."); + ThrowException( "Expected end of element."); break; } @@ -1919,13 +1920,13 @@ void ColladaParser::ReadIndexData( Mesh* pMesh) } } else { - ThrowException( "Unexpected sub element in tag \"vertices\"."); + ThrowException( boost::str( boost::format( "Unexpected sub element <%s> in tag <%s>") % mReader->getNodeName() % elementName)); } } else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) { if( mReader->getNodeName() != elementName) - ThrowException( boost::str( boost::format( "Expected end of \"%s\" element.") % elementName)); + ThrowException( boost::str( boost::format( "Expected end of <%s> element.") % elementName)); break; } @@ -2063,7 +2064,7 @@ void ColladaParser::ReadPrimitives( Mesh* pMesh, std::vector& pPer { // warn if the vertex channel does not refer to the element in the same mesh if( input.mAccessor != pMesh->mVertexID) - ThrowException( "Unsupported vertex referencing scheme. I fucking hate Collada."); + ThrowException( "Unsupported vertex referencing scheme."); continue; } @@ -2230,7 +2231,13 @@ void ColladaParser::ExtractDataObjectFromChannel( const InputChannel& pInput, si pMesh->mColors[pInput.mIndex].insert( pMesh->mColors[pInput.mIndex].end(), pMesh->mPositions.size() - pMesh->mColors[pInput.mIndex].size() - 1, aiColor4D( 0, 0, 0, 1)); - pMesh->mColors[pInput.mIndex].push_back( aiColor4D( obj[0], obj[1], obj[2], obj[3])); + //pMesh->mColors[pInput.mIndex].push_back( aiColor4D( obj[0], obj[1], obj[2], obj[3])); + aiColor4D result(0, 0, 0, 1); + for (size_t i = 0; i < pInput.mResolved->mSize; ++i) + { + result[i] = obj[pInput.mResolved->mSubOffset[i]]; + } + pMesh->mColors[pInput.mIndex].push_back(result); } else { DefaultLogger::get()->error("Collada: too many vertex color sets. Skipping."); diff --git a/code/IFCGeometry.cpp b/code/IFCGeometry.cpp index 525208abc..03b8d4f80 100644 --- a/code/IFCGeometry.cpp +++ b/code/IFCGeometry.cpp @@ -64,6 +64,15 @@ namespace Assimp { //#define to_int64(p) (static_cast( std::max( 0., std::min( static_cast((p)), 1.) ) * max_ulong64 )) #define to_int64(p) (static_cast(static_cast((p) ) * max_ulong64 )) #define from_int64(p) (static_cast((p)) / max_ulong64) +#define one_vec (IfcVector2(static_cast(1.0),static_cast(1.0))) + + + bool GenerateOpenings(std::vector& openings, + const std::vector& nors, + TempMesh& curmesh, + bool check_intersection = true, + bool generate_connection_geometry = true); + // ------------------------------------------------------------------------------------------------ bool ProcessPolyloop(const IfcPolyLoop& loop, TempMesh& meshout, ConversionData& /*conv*/) @@ -92,338 +101,125 @@ bool ProcessPolyloop(const IfcPolyLoop& loop, TempMesh& meshout, ConversionData& } // ------------------------------------------------------------------------------------------------ -void ComputePolygonNormals(const TempMesh& meshout, std::vector& normals, bool normalize = true, size_t ofs = 0) +void ProcessPolygonBoundaries(TempMesh& result, const TempMesh& inmesh, size_t master_bounds = (size_t)-1) { - size_t max_vcount = 0; - std::vector::const_iterator begin=meshout.vertcnt.begin()+ofs, end=meshout.vertcnt.end(), iit; - for(iit = begin; iit != end; ++iit) { - max_vcount = std::max(max_vcount,static_cast(*iit)); + // handle all trivial cases + if(inmesh.vertcnt.empty()) { + return; } - - std::vector temp((max_vcount+2)*4); - normals.reserve( normals.size() + meshout.vertcnt.size()-ofs ); - - // `NewellNormal()` currently has a relatively strange interface and need to - // re-structure things a bit to meet them. - size_t vidx = std::accumulate(meshout.vertcnt.begin(),begin,0); - for(iit = begin; iit != end; vidx += *iit++) { - if (!*iit) { - normals.push_back(IfcVector3()); - continue; - } - for(size_t vofs = 0, cnt = 0; vofs < *iit; ++vofs) { - const IfcVector3& v = meshout.verts[vidx+vofs]; - temp[cnt++] = v.x; - temp[cnt++] = v.y; - temp[cnt++] = v.z; -#ifdef _DEBUG - temp[cnt] = std::numeric_limits::quiet_NaN(); -#endif - ++cnt; - } - - normals.push_back(IfcVector3()); - NewellNormal<4,4,4>(normals.back(),*iit,&temp[0],&temp[1],&temp[2]); - } - - if(normalize) { - BOOST_FOREACH(IfcVector3& n, normals) { - n.Normalize(); - } - } -} - -// ------------------------------------------------------------------------------------------------ -// Compute the normal of the last polygon in the given mesh -IfcVector3 ComputePolygonNormal(const TempMesh& inmesh, bool normalize = true) -{ - size_t total = inmesh.vertcnt.back(), vidx = inmesh.verts.size() - total; - std::vector temp((total+2)*3); - for(size_t vofs = 0, cnt = 0; vofs < total; ++vofs) { - const IfcVector3& v = inmesh.verts[vidx+vofs]; - temp[cnt++] = v.x; - temp[cnt++] = v.y; - temp[cnt++] = v.z; - } - IfcVector3 nor; - NewellNormal<3,3,3>(nor,total,&temp[0],&temp[1],&temp[2]); - return normalize ? nor.Normalize() : nor; -} - -// ------------------------------------------------------------------------------------------------ -void FixupFaceOrientation(TempMesh& result) -{ - const IfcVector3 vavg = result.Center(); - - std::vector normals; - ComputePolygonNormals(result,normals); - - size_t c = 0, ofs = 0; - BOOST_FOREACH(unsigned int cnt, result.vertcnt) { - if (cnt>2){ - const IfcVector3& thisvert = result.verts[c]; - if (normals[ofs]*(thisvert-vavg) < 0) { - std::reverse(result.verts.begin()+c,result.verts.begin()+cnt+c); - } - } - c += cnt; - ++ofs; - } -} - -// ------------------------------------------------------------------------------------------------ -void RecursiveMergeBoundaries(TempMesh& final_result, const TempMesh& in, const TempMesh& boundary, std::vector& normals, const IfcVector3& nor_boundary) -{ - ai_assert(in.vertcnt.size() >= 1); - ai_assert(boundary.vertcnt.size() == 1); - std::vector::const_iterator end = in.vertcnt.end(), begin=in.vertcnt.begin(), iit, best_iit; - - TempMesh out; - - // iterate through all other bounds and find the one for which the shortest connection - // to the outer boundary is actually the shortest possible. - size_t vidx = 0, best_vidx_start = 0; - size_t best_ofs, best_outer = boundary.verts.size(); - IfcFloat best_dist = 1e10; - for(std::vector::const_iterator iit = begin; iit != end; vidx += *iit++) { - - for(size_t vofs = 0; vofs < *iit; ++vofs) { - const IfcVector3& v = in.verts[vidx+vofs]; - - for(size_t outer = 0; outer < boundary.verts.size(); ++outer) { - const IfcVector3& o = boundary.verts[outer]; - const IfcFloat d = (o-v).SquareLength(); - - if (d < best_dist) { - best_dist = d; - best_ofs = vofs; - best_outer = outer; - best_iit = iit; - best_vidx_start = vidx; - } - } - } - } - - ai_assert(best_outer != boundary.verts.size()); - - - // now that we collected all vertex connections to be added, build the output polygon - const size_t cnt = boundary.verts.size() + *best_iit+2; - out.verts.reserve(cnt); - - for(size_t outer = 0; outer < boundary.verts.size(); ++outer) { - const IfcVector3& o = boundary.verts[outer]; - out.verts.push_back(o); - - if (outer == best_outer) { - for(size_t i = best_ofs; i < *best_iit; ++i) { - out.verts.push_back(in.verts[best_vidx_start + i]); - } - - // we need the first vertex of the inner polygon twice as we return to the - // outer loop through the very same connection through which we got there. - for(size_t i = 0; i <= best_ofs; ++i) { - out.verts.push_back(in.verts[best_vidx_start + i]); - } - - // reverse face winding if the normal of the sub-polygon points in the - // same direction as the normal of the outer polygonal boundary - if (normals[std::distance(begin,best_iit)] * nor_boundary > 0) { - std::reverse(out.verts.rbegin(),out.verts.rbegin()+*best_iit+1); - } - - // also append a copy of the initial insertion point to be able to continue the outer polygon - out.verts.push_back(o); - } - } - out.vertcnt.push_back(cnt); - ai_assert(out.verts.size() == cnt); - - if (in.vertcnt.size()-std::count(begin,end,0) > 1) { - // Recursively apply the same algorithm if there are more boundaries to merge. The - // current implementation is relatively inefficient, though. - - TempMesh temp; - - // drop the boundary that we just processed - const size_t dist = std::distance(begin, best_iit); - TempMesh remaining = in; - remaining.vertcnt.erase(remaining.vertcnt.begin() + dist); - remaining.verts.erase(remaining.verts.begin()+best_vidx_start,remaining.verts.begin()+best_vidx_start+*best_iit); - - normals.erase(normals.begin() + dist); - RecursiveMergeBoundaries(temp,remaining,out,normals,nor_boundary); - - final_result.Append(temp); - } - else final_result.Append(out); -} - -// ------------------------------------------------------------------------------------------------ -void MergePolygonBoundaries(TempMesh& result, const TempMesh& inmesh, size_t master_bounds = -1) -{ - // standard case - only one boundary, just copy it to the result vector - if (inmesh.vertcnt.size() <= 1) { + if(inmesh.vertcnt.size() == 1) { result.Append(inmesh); return; } - result.vertcnt.reserve(inmesh.vertcnt.size()+result.vertcnt.size()); + ai_assert(std::count(inmesh.vertcnt.begin(), inmesh.vertcnt.end(), 0) == 0); - // XXX get rid of the extra copy if possible - TempMesh meshout = inmesh; + typedef std::vector::const_iterator face_iter; - // handle polygons with holes. Our built in triangulation won't handle them as is, but - // the ear cutting algorithm is solid enough to deal with them if we join the inner - // holes with the outer boundaries by dummy connections. - IFCImporter::LogDebug("fixing polygon with holes for triangulation via ear-cutting"); - std::vector::iterator outer_polygon = meshout.vertcnt.end(), begin=meshout.vertcnt.begin(), end=outer_polygon, iit; + face_iter begin = inmesh.vertcnt.begin(), end = inmesh.vertcnt.end(), iit; + std::vector::const_iterator outer_polygon_it = end; - // each hole results in two extra vertices - result.verts.reserve(meshout.verts.size()+meshout.vertcnt.size()*2+result.verts.size()); - size_t outer_polygon_start = 0; + // major task here: given a list of nested polygon boundaries (one of which + // is the outer contour), reduce the triangulation task arising here to + // one that can be solved using the "quadrulation" algorithm which we use + // for pouring windows out of walls. The algorithm does not handle all + // cases but at least it is numerically stable and gives "nice" triangles. + // first compute normals for all polygons using Newell's algorithm // do not normalize 'normals', we need the original length for computing the polygon area std::vector normals; - ComputePolygonNormals(meshout,normals,false); + inmesh.ComputePolygonNormals(normals,false); - // see if one of the polygons is a IfcFaceOuterBound (in which case `master_bounds` is its index). - // sadly we can't rely on it, the docs say 'At most one of the bounds shall be of the type IfcFaceOuterBound' + // One of the polygons might be a IfcFaceOuterBound (in which case `master_bounds` + // is its index). Sadly we can't rely on it, the docs say 'At most one of the bounds + // shall be of the type IfcFaceOuterBound' IfcFloat area_outer_polygon = 1e-10f; if (master_bounds != (size_t)-1) { - outer_polygon = begin + master_bounds; - outer_polygon_start = std::accumulate(begin,outer_polygon,0); - area_outer_polygon = normals[master_bounds].SquareLength(); + ai_assert(master_bounds < inmesh.vertcnt.size()); + outer_polygon_it = begin + master_bounds; } else { - size_t vidx = 0; - for(iit = begin; iit != meshout.vertcnt.end(); vidx += *iit++) { - // find the polygon with the largest area, it must be the outer bound. + for(iit = begin; iit != end; iit++) { + // find the polygon with the largest area and take it as the outer bound. IfcVector3& n = normals[std::distance(begin,iit)]; const IfcFloat area = n.SquareLength(); if (area > area_outer_polygon) { area_outer_polygon = area; - outer_polygon = iit; - outer_polygon_start = vidx; + outer_polygon_it = iit; } } } - ai_assert(outer_polygon != meshout.vertcnt.end()); - std::vector& in = meshout.verts; + ai_assert(outer_polygon_it != end); - // skip over extremely small boundaries - this is a workaround to fix cases - // in which the number of holes is so extremely large that the - // triangulation code fails. -#define IFC_VERTICAL_HOLE_SIZE_THRESHOLD 0.000001f - size_t vidx = 0, removed = 0, index = 0; - const IfcFloat threshold = area_outer_polygon * IFC_VERTICAL_HOLE_SIZE_THRESHOLD; - for(iit = begin; iit != end ;++index) { - const IfcFloat sqlen = normals[index].SquareLength(); - if (sqlen < threshold) { - std::vector::iterator inbase = in.begin()+vidx; - in.erase(inbase,inbase+*iit); - - outer_polygon_start -= outer_polygon_start>vidx ? *iit : 0; - *iit++ = 0; - ++removed; + const size_t outer_polygon_size = *outer_polygon_it; + const IfcVector3& master_normal = normals[std::distance(begin, outer_polygon_it)]; + const IfcVector3& master_normal_norm = IfcVector3(master_normal).Normalize(); - IFCImporter::LogDebug("skip small hole below threshold"); - } - else { - normals[index] /= sqrt(sqlen); - vidx += *iit++; - } - } - // see if one or more of the hole has a face that lies directly on an outer bound. - // this happens for doors, for example. - vidx = 0; - for(iit = begin; ; vidx += *iit++) { -next_loop: - if (iit == end) { - break; - } - if (iit == outer_polygon) { + // Generate fake openings to meet the interface for the quadrulate + // algorithm. It boils down to generating small boxes given the + // inner polygon and the surface normal of the outer contour. + // It is important that we use the outer contour's normal because + // this is the plane onto which the quadrulate algorithm will + // project the entire mesh. + std::vector fake_openings; + fake_openings.reserve(inmesh.vertcnt.size()-1); + + std::vector::const_iterator vit = inmesh.verts.begin(), outer_vit; + + for(iit = begin; iit != end; vit += *iit++) { + if (iit == outer_polygon_it) { + outer_vit = vit; continue; } - for(size_t vofs = 0; vofs < *iit; ++vofs) { - if (!*iit) { - continue; - } - const size_t next = (vofs+1)%*iit; - const IfcVector3& v = in[vidx+vofs], &vnext = in[vidx+next],&vd = (vnext-v).Normalize(); - - for(size_t outer = 0; outer < *outer_polygon; ++outer) { - const IfcVector3& o = in[outer_polygon_start+outer], &onext = in[outer_polygon_start+(outer+1)%*outer_polygon], &od = (onext-o).Normalize(); - - if (fabs(vd * od) > 1.f-1e-6f && (onext-v).Normalize() * vd > 1.f-1e-6f && (onext-v)*(o-v) < 0) { - IFCImporter::LogDebug("got an inner hole that lies partly on the outer polygonal boundary, merging them to a single contour"); - - // in between outer and outer+1 insert all vertices of this loop, then drop the original altogether. - std::vector tmp(*iit); - - const size_t start = (v-o).SquareLength() > (vnext-o).SquareLength() ? vofs : next; - std::vector::iterator inbase = in.begin()+vidx, it = std::copy(inbase+start, inbase+*iit,tmp.begin()); - std::copy(inbase, inbase+start,it); - std::reverse(tmp.begin(),tmp.end()); - - in.insert(in.begin()+outer_polygon_start+(outer+1)%*outer_polygon,tmp.begin(),tmp.end()); - vidx += outer_polygon_startvidx ? *iit : 0; - - *outer_polygon += tmp.size(); - *iit++ = 0; - ++removed; - goto next_loop; - } - } + // Filter degenerate polygons to keep them from causing trouble later on + IfcVector3& n = normals[std::distance(begin,iit)]; + const IfcFloat area = n.SquareLength(); + if (area < 1e-5f) { + IFCImporter::LogWarn("skipping degenerate polygon (ProcessPolygonBoundaries)"); + continue; } + + fake_openings.push_back(TempOpening()); + TempOpening& opening = fake_openings.back(); + + opening.extrusionDir = master_normal; + opening.solid = NULL; + + opening.profileMesh = boost::make_shared(); + opening.profileMesh->verts.reserve(*iit); + opening.profileMesh->vertcnt.push_back(*iit); + + std::copy(vit, vit + *iit, std::back_inserter(opening.profileMesh->verts)); } - if ( meshout.vertcnt.size() - removed <= 1) { - result.Append(meshout); - return; - } + // fill a mesh with ONLY the main polygon + TempMesh temp; + temp.verts.reserve(outer_polygon_size); + temp.vertcnt.push_back(outer_polygon_size); + std::copy(outer_vit, outer_vit+outer_polygon_size, + std::back_inserter(temp.verts)); - // extract the outer boundary and move it to a separate mesh - TempMesh boundary; - boundary.vertcnt.resize(1,*outer_polygon); - boundary.verts.resize(*outer_polygon); - - std::vector::iterator b = in.begin()+outer_polygon_start; - std::copy(b,b+*outer_polygon,boundary.verts.begin()); - in.erase(b,b+*outer_polygon); - - std::vector::iterator norit = normals.begin()+std::distance(meshout.vertcnt.begin(),outer_polygon); - const IfcVector3 nor_boundary = *norit; - normals.erase(norit); - meshout.vertcnt.erase(outer_polygon); - - // keep merging the closest inner boundary with the outer boundary until no more boundaries are left - RecursiveMergeBoundaries(result,meshout,boundary,normals,nor_boundary); + GenerateOpenings(fake_openings, normals, temp, false, false); + result.Append(temp); } - // ------------------------------------------------------------------------------------------------ void ProcessConnectedFaceSet(const IfcConnectedFaceSet& fset, TempMesh& result, ConversionData& conv) { BOOST_FOREACH(const IfcFace& face, fset.CfsFaces) { - // size_t ob = -1, cnt = 0; TempMesh meshout; BOOST_FOREACH(const IfcFaceBound& bound, face.Bounds) { - // XXX implement proper merging for polygonal loops if(const IfcPolyLoop* const polyloop = bound.Bound->ToPtr()) { if(ProcessPolyloop(*polyloop, meshout,conv)) { + // The outer boundary is better determined by checking which + // polygon covers the largest area. + //if(bound.ToPtr()) { // ob = cnt; //} @@ -436,6 +232,9 @@ void ProcessConnectedFaceSet(const IfcConnectedFaceSet& fset, TempMesh& result, continue; } + // And this, even though it is sometimes TRUE and sometimes FALSE, + // does not really improve results. + /*if(!IsTrue(bound.Orientation)) { size_t c = 0; BOOST_FOREACH(unsigned int& c, meshout.vertcnt) { @@ -443,14 +242,11 @@ void ProcessConnectedFaceSet(const IfcConnectedFaceSet& fset, TempMesh& result, cnt += c; } }*/ - } - MergePolygonBoundaries(result,meshout); + ProcessPolygonBoundaries(result, meshout); } } - - // ------------------------------------------------------------------------------------------------ void ProcessRevolvedAreaSolid(const IfcRevolvedAreaSolid& solid, TempMesh& result, ConversionData& conv) { @@ -581,6 +377,8 @@ void ProcessSweptDiskSolid(const IfcSweptDiskSolid solid, TempMesh& result, Conv startvec.y = 1.0f; startvec.z = 1.0f; + unsigned int last_dir = 0; + // generate circles at the sweep positions for(size_t i = 0; i < samples; ++i) { @@ -596,24 +394,34 @@ void ProcessSweptDiskSolid(const IfcSweptDiskSolid solid, TempMesh& result, Conv // figure out an arbitrary point q so that (p-q) * d = 0, // try to maximize ||(p-q)|| * ||(p_last-q_last)|| IfcVector3 q; - if (abs(d.x) > 1e-6) { - q.y = startvec.y; - q.z = startvec.z; - q.x = -(d.y * q.y + d.z * q.z) / d.x; - } - else if (abs(d.y) > 1e-6) { - q.x = startvec.x; - q.z = startvec.z; - q.y = -(d.x * q.x + d.z * q.z) / d.y; - } - else { // if (abs(d.z) > 1e-6) - q.y = startvec.y; - q.x = startvec.x; - q.z = -(d.y * q.y + d.x * q.x) / d.z; + bool take_any = false; + + for (unsigned int i = 0; i < 2; ++i, take_any = true) { + if ((last_dir == 0 || take_any) && abs(d.x) > 1e-6) { + q.y = startvec.y; + q.z = startvec.z; + q.x = -(d.y * q.y + d.z * q.z) / d.x; + last_dir = 0; + break; + } + else if ((last_dir == 1 || take_any) && abs(d.y) > 1e-6) { + q.x = startvec.x; + q.z = startvec.z; + q.y = -(d.x * q.x + d.z * q.z) / d.y; + last_dir = 1; + break; + } + else if ((last_dir == 2 && abs(d.z) > 1e-6) || take_any) { + q.y = startvec.y; + q.x = startvec.x; + q.z = -(d.y * q.y + d.x * q.x) / d.z; + last_dir = 2; + break; + } } - startvec = q; q *= solid.Radius / q.Length(); + startvec = q; // generate a rotation matrix to rotate q around d IfcMatrix4 rot; @@ -630,12 +438,37 @@ void ProcessSweptDiskSolid(const IfcSweptDiskSolid solid, TempMesh& result, Conv // make quads for(size_t i = 0; i < samples - 1; ++i) { - for (unsigned int seg = 0; seg < cnt_segments - 1; ++seg) { + const aiVector3D& this_start = points[ i * cnt_segments ]; - result.verts.push_back(points[ i * cnt_segments + seg]); - result.verts.push_back(points[ i * cnt_segments + seg + 1]); - result.verts.push_back(points[ (i+1) * cnt_segments + seg + 1]); - result.verts.push_back(points[ (i+1) * cnt_segments + seg]); + // locate corresponding point on next sample ring + unsigned int best_pair_offset = 0; + float best_distance_squared = 1e10f; + for (unsigned int seg = 0; seg < cnt_segments; ++seg) { + const aiVector3D& p = points[ (i+1) * cnt_segments + seg]; + const float l = (p-this_start).SquareLength(); + + if(l < best_distance_squared) { + best_pair_offset = seg; + best_distance_squared = l; + } + } + + for (unsigned int seg = 0; seg < cnt_segments; ++seg) { + + result.verts.push_back(points[ i * cnt_segments + (seg % cnt_segments)]); + result.verts.push_back(points[ i * cnt_segments + (seg + 1) % cnt_segments]); + result.verts.push_back(points[ (i+1) * cnt_segments + ((seg + 1 + best_pair_offset) % cnt_segments)]); + result.verts.push_back(points[ (i+1) * cnt_segments + ((seg + best_pair_offset) % cnt_segments)]); + + IfcVector3& v1 = *(result.verts.end()-1); + IfcVector3& v2 = *(result.verts.end()-2); + IfcVector3& v3 = *(result.verts.end()-3); + IfcVector3& v4 = *(result.verts.end()-4); + + if (((v4-v3) ^ (v4-v1)) * (v4 - curve_points[i]) < 0.0f) { + std::swap(v4, v1); + std::swap(v3, v2); + } result.vertcnt.push_back(4); } @@ -645,40 +478,52 @@ void ProcessSweptDiskSolid(const IfcSweptDiskSolid solid, TempMesh& result, Conv } // ------------------------------------------------------------------------------------------------ -IfcMatrix3 DerivePlaneCoordinateSpace(const TempMesh& curmesh) { - +IfcMatrix3 DerivePlaneCoordinateSpace(const TempMesh& curmesh, bool& ok, IfcFloat* d = NULL) +{ const std::vector& out = curmesh.verts; IfcMatrix3 m; + ok = true; + const size_t s = out.size(); assert(curmesh.vertcnt.size() == 1 && curmesh.vertcnt.back() == s); const IfcVector3 any_point = out[s-1]; IfcVector3 nor; - // The input polygon is arbitrarily shaped, so we might need some tries - // until we find a suitable normal (and it does not even need to be - // right in all cases, Newell's algorithm would be the correct one ... ). + // The input polygon is arbitrarily shaped, therefore we might need some tries + // until we find a suitable normal. Note that Newells algorithm would give + // a more robust result, but this variant also gives us a suitable first + // axis for the 2D coordinate space on the polygon plane, exploiting the + // fact that the input polygon is nearly always a quad. + bool done = false; size_t base = s-curmesh.vertcnt.back(), i, j; - for (i = base; i < s-1; ++i) { + for (i = base; !done && i < s-1; !done && ++i) { for (j = i+1; j < s; ++j) { nor = -((out[i]-any_point)^(out[j]-any_point)); if(fabs(nor.Length()) > 1e-8f) { - goto out; + done = true; + break; } } } - assert(0); - -out: + if(!done) { + ok = false; + return m; + } nor.Normalize(); IfcVector3 r = (out[i]-any_point); r.Normalize(); - // reconstruct orthonormal basis + if(d) { + *d = -any_point * nor; + } + + // Reconstruct orthonormal basis + // XXX use Gram Schmidt for increased robustness IfcVector3 u = r ^ nor; u.Normalize(); @@ -698,15 +543,22 @@ out: } // ------------------------------------------------------------------------------------------------ -bool TryAddOpenings_Poly2Tri(const std::vector& openings,const std::vector& nors, TempMesh& curmesh) +bool TryAddOpenings_Poly2Tri(const std::vector& openings,const std::vector& nors, + TempMesh& curmesh) { + IFCImporter::LogWarn("forced to use poly2tri fallback method to generate wall openings"); std::vector& out = curmesh.verts; bool result = false; // Try to derive a solid base plane within the current surface for use as // working coordinate system. - const IfcMatrix3& m = DerivePlaneCoordinateSpace(curmesh); + bool ok; + const IfcMatrix3& m = DerivePlaneCoordinateSpace(curmesh, ok); + if (!ok) { + return false; + } + const IfcMatrix3 minv = IfcMatrix3(m).Inverse(); const IfcVector3& nor = IfcVector3(m.c1, m.c2, m.c3); @@ -1012,7 +864,8 @@ typedef std::map XYSortedField; // ------------------------------------------------------------------------------------------------ -void QuadrifyPart(const IfcVector2& pmin, const IfcVector2& pmax, XYSortedField& field, const std::vector< BoundingBox >& bbs, +void QuadrifyPart(const IfcVector2& pmin, const IfcVector2& pmax, XYSortedField& field, + const std::vector< BoundingBox >& bbs, std::vector& out) { if (!(pmin.x-pmax.x) || !(pmin.y-pmax.y)) { @@ -1071,7 +924,7 @@ void QuadrifyPart(const IfcVector2& pmin, const IfcVector2& pmax, XYSortedField& found = true; const IfcFloat ys = std::max(bb.first.y,pmin.y), ye = std::min(bb.second.y,pmax.y); - if (ys - ylast) { + if (ys - ylast > 0.0f) { QuadrifyPart( IfcVector2(xs,ylast), IfcVector2(xe,ys) ,field,bbs,out); } @@ -1102,23 +955,104 @@ void QuadrifyPart(const IfcVector2& pmin, const IfcVector2& pmax, XYSortedField& } } +typedef std::vector Contour; +typedef std::vector SkipList; // should probably use int for performance reasons + +struct ProjectedWindowContour +{ + Contour contour; + BoundingBox bb; + SkipList skiplist; + + + ProjectedWindowContour(const Contour& contour, const BoundingBox& bb) + : contour(contour) + , bb(bb) + {} + + + bool IsInvalid() const { + return contour.empty(); + } + + void FlagInvalid() { + contour.clear(); + } + + void PrepareSkiplist() { + skiplist.resize(contour.size(),false); + } +}; + +typedef std::vector< ProjectedWindowContour > ContourVector; + // ------------------------------------------------------------------------------------------------ -void InsertWindowContours(const std::vector< BoundingBox >& bbs, - const std::vector< std::vector >& contours, +bool BoundingBoxesOverlapping( const BoundingBox &ibb, const BoundingBox &bb ) +{ + // count the '=' case as non-overlapping but as adjacent to each other + return ibb.first.x < bb.second.x && ibb.second.x > bb.first.x && + ibb.first.y < bb.second.y && ibb.second.y > bb.first.y; +} + +// ------------------------------------------------------------------------------------------------ +bool IsDuplicateVertex(const IfcVector2& vv, const std::vector& temp_contour) +{ + // sanity check for duplicate vertices + BOOST_FOREACH(const IfcVector2& cp, temp_contour) { + if ((cp-vv).SquareLength() < 1e-5f) { + return true; + } + } + return false; +} + +// ------------------------------------------------------------------------------------------------ +void ExtractVerticesFromClipper(const ClipperLib::Polygon& poly, std::vector& temp_contour, + bool filter_duplicates = false) +{ + temp_contour.clear(); + BOOST_FOREACH(const ClipperLib::IntPoint& point, poly) { + IfcVector2 vv = IfcVector2( from_int64(point.X), from_int64(point.Y)); + vv = std::max(vv,IfcVector2()); + vv = std::min(vv,one_vec); + + if (!filter_duplicates || !IsDuplicateVertex(vv, temp_contour)) { + temp_contour.push_back(vv); + } + } +} + +// ------------------------------------------------------------------------------------------------ +BoundingBox GetBoundingBox(const ClipperLib::Polygon& poly) +{ + IfcVector2 newbb_min, newbb_max; + MinMaxChooser()(newbb_min, newbb_max); + + BOOST_FOREACH(const ClipperLib::IntPoint& point, poly) { + IfcVector2 vv = IfcVector2( from_int64(point.X), from_int64(point.Y)); + + // sanity rounding + vv = std::max(vv,IfcVector2()); + vv = std::min(vv,one_vec); + + newbb_min = std::min(newbb_min,vv); + newbb_max = std::max(newbb_max,vv); + } + return BoundingBox(newbb_min, newbb_max); +} + +// ------------------------------------------------------------------------------------------------ +void InsertWindowContours(const ContourVector& contours, const std::vector& openings, - const std::vector& nors, - const IfcMatrix3& minv, - const IfcVector2& scale, - const IfcVector2& offset, - IfcFloat coord, TempMesh& curmesh) { - ai_assert(contours.size() == bbs.size()); - // fix windows - we need to insert the real, polygonal shapes into the quadratic holes that we have now for(size_t i = 0; i < contours.size();++i) { - const BoundingBox& bb = bbs[i]; - const std::vector& contour = contours[i]; + const BoundingBox& bb = contours[i].bb; + const std::vector& contour = contours[i].contour; + if(contour.empty()) { + continue; + } // check if we need to do it at all - many windows just fit perfectly into their quadratic holes, // i.e. their contours *are* already their bounding boxes. @@ -1186,8 +1120,7 @@ void InsertWindowContours(const std::vector< BoundingBox >& bbs, if ((contour[a] - edge).SquareLength() > diag*diag*0.7) { continue; } - const IfcVector3 v3 = minv * IfcVector3(offset.x + contour[a].x * scale.x, offset.y + contour[a].y * scale.y,coord); - curmesh.verts.push_back(v3); + curmesh.verts.push_back(IfcVector3(contour[a].x, contour[a].y, 0.0f)); } if (edge != contour[last_hit]) { @@ -1208,8 +1141,7 @@ void InsertWindowContours(const std::vector< BoundingBox >& bbs, corner.y = bb.second.y; } - const IfcVector3 v3 = minv * IfcVector3(offset.x + corner.x * scale.x, offset.y + corner.y * scale.y,coord); - curmesh.verts.push_back(v3); + curmesh.verts.push_back(IfcVector3(corner.x, corner.y, 0.0f)); } else if (cnt == 1) { // avoid degenerate polygons (also known as lines or points) @@ -1235,8 +1167,12 @@ void InsertWindowContours(const std::vector< BoundingBox >& bbs, } // ------------------------------------------------------------------------------------------------ -void MergeContours (const std::vector& a, const std::vector& b, ClipperLib::ExPolygons& out) +void MergeWindowContours (const std::vector& a, + const std::vector& b, + ClipperLib::ExPolygons& out) { + out.clear(); + ClipperLib::Clipper clipper; ClipperLib::Polygon clip; @@ -1264,173 +1200,101 @@ void MergeContours (const std::vector& a, const std::vector& openings,const std::vector& nors, TempMesh& curmesh) +// Subtract a from b +void MakeDisjunctWindowContours (const std::vector& a, + const std::vector& b, + ClipperLib::ExPolygons& out) { - std::vector& out = curmesh.verts; + out.clear(); - // Try to derive a solid base plane within the current surface for use as - // working coordinate system. - const IfcMatrix3& m = DerivePlaneCoordinateSpace(curmesh); - const IfcMatrix3 minv = IfcMatrix3(m).Inverse(); - const IfcVector3& nor = IfcVector3(m.c1, m.c2, m.c3); + ClipperLib::Clipper clipper; + ClipperLib::Polygon clip; - IfcFloat coord = -1; - - std::vector contour_flat; - contour_flat.reserve(out.size()); - - IfcVector2 vmin, vmax; - MinMaxChooser()(vmin, vmax); - - // Move all points into the new coordinate system, collecting min/max verts on the way - BOOST_FOREACH(IfcVector3& x, out) { - const IfcVector3 vv = m * x; - - // keep Z offset in the plane coordinate system. Ignoring precision issues - // (which are present, of course), this should be the same value for - // all polygon vertices (assuming the polygon is planar). - - - // XXX this should be guarded, but we somehow need to pick a suitable - // epsilon - // if(coord != -1.0f) { - // assert(fabs(coord - vv.z) < 1e-3f); - // } - - coord = vv.z; - vmin = std::min(IfcVector2(vv.x, vv.y), vmin); - vmax = std::max(IfcVector2(vv.x, vv.y), vmax); - - contour_flat.push_back(IfcVector2(vv.x,vv.y)); + BOOST_FOREACH(const IfcVector2& pip, a) { + clip.push_back(ClipperLib::IntPoint( to_int64(pip.x), to_int64(pip.y) )); } - // With the current code in DerivePlaneCoordinateSpace, - // vmin,vmax should always be the 0...1 rectangle (+- numeric inaccuracies) - // but here we won't rely on this. - - vmax -= vmin; - BOOST_FOREACH(IfcVector2& vv, contour_flat) { - vv.x = (vv.x - vmin.x) / vmax.x; - vv.y = (vv.y - vmin.y) / vmax.y; + if (ClipperLib::Orientation(clip)) { + std::reverse(clip.begin(), clip.end()); } - // project all points into the coordinate system defined by the p+sv*tu plane - // and compute bounding boxes for them - std::vector< BoundingBox > bbs; - std::vector< std::vector > contours; + clipper.AddPolygon(clip, ClipperLib::ptClip); + clip.clear(); - size_t c = 0; - BOOST_FOREACH(const TempOpening& t,openings) { - const IfcVector3& outernor = nors[c++]; - const IfcFloat dot = nor * outernor; - if (fabs(dot)<1.f-1e-6f) { - continue; - } - - const std::vector& va = t.profileMesh->verts; - if(va.size() <= 2) { - continue; - } - - IfcVector2 vpmin,vpmax; - MinMaxChooser()(vpmin,vpmax); - - std::vector contour; - - BOOST_FOREACH(const IfcVector3& x, t.profileMesh->verts) { - const IfcVector3 v = m * x; - - IfcVector2 vv(v.x, v.y); - - // rescale - vv.x = (vv.x - vmin.x) / vmax.x; - vv.y = (vv.y - vmin.y) / vmax.y; - - vpmin = std::min(vpmin,vv); - vpmax = std::max(vpmax,vv); - - contour.push_back(vv); - } - - BoundingBox bb = BoundingBox(vpmin,vpmax); - - // see if this BB intersects any other, in which case we could not use the Quadrify() - // algorithm and would revert to Poly2Tri only. - for (std::vector::iterator it = bbs.begin(); it != bbs.end();) { - const BoundingBox& ibb = *it; - - if (ibb.first.x < bb.second.x && ibb.second.x > bb.first.x && - ibb.first.y < bb.second.y && ibb.second.y > bb.second.x) { - - // take these two contours and try to merge them. If they overlap (which - // should not happen, but in fact happens-in-the-real-world [tm] ), - // resume using a single contour and a single bounding box. - const std::vector& other = contours[std::distance(bbs.begin(),it)]; - - ClipperLib::ExPolygons poly; - MergeContours(contour, other, poly); - - if (poly.size() > 1) { - IFCImporter::LogWarn("cannot use quadrify algorithm to generate wall openings due to " - "bounding box overlaps, using poly2tri fallback"); - return TryAddOpenings_Poly2Tri(openings, nors, curmesh); - } - else if (poly.size() == 0) { - IFCImporter::LogWarn("ignoring duplicate opening"); - contour.clear(); - break; - } - else { - IFCImporter::LogDebug("merging oberlapping openings, this should not happen"); - - contour.clear(); - BOOST_FOREACH(const ClipperLib::IntPoint& point, poly[0].outer) { - contour.push_back( IfcVector2( from_int64(point.X), from_int64(point.Y))); - } - - bb.first = std::min(bb.first, ibb.first); - bb.second = std::max(bb.second, ibb.second); - - contours.erase(contours.begin() + std::distance(bbs.begin(),it)); - it = bbs.erase(it); - continue; - } - } - ++it; - } - - if(contour.size()) { - contours.push_back(contour); - bbs.push_back(bb); - } + BOOST_FOREACH(const IfcVector2& pip, b) { + clip.push_back(ClipperLib::IntPoint( to_int64(pip.x), to_int64(pip.y) )); } - if (bbs.empty()) { - return false; + if (ClipperLib::Orientation(clip)) { + std::reverse(clip.begin(), clip.end()); } - XYSortedField field; - for (std::vector::iterator it = bbs.begin(); it != bbs.end(); ++it) { - if (field.find((*it).first) != field.end()) { - IFCImporter::LogWarn("constraint failure during generation of wall openings, results may be faulty"); + clipper.AddPolygon(clip, ClipperLib::ptSubject); + clipper.Execute(ClipperLib::ctDifference, out,ClipperLib::pftNonZero,ClipperLib::pftNonZero); +} + +// ------------------------------------------------------------------------------------------------ +void CleanupWindowContour(ProjectedWindowContour& window) +{ + std::vector scratch; + std::vector& contour = window.contour; + + ClipperLib::Polygon subject; + ClipperLib::Clipper clipper; + ClipperLib::ExPolygons clipped; + + BOOST_FOREACH(const IfcVector2& pip, contour) { + subject.push_back(ClipperLib::IntPoint( to_int64(pip.x), to_int64(pip.y) )); + } + + clipper.AddPolygon(subject,ClipperLib::ptSubject); + clipper.Execute(ClipperLib::ctUnion,clipped,ClipperLib::pftNonZero,ClipperLib::pftNonZero); + + // This should yield only one polygon or something went wrong + if (clipped.size() != 1) { + + // Empty polygon? drop the contour altogether + if(clipped.empty()) { + IFCImporter::LogError("error during polygon clipping, window contour is degenerate"); + window.FlagInvalid(); + return; } - field[(*it).first] = std::distance(bbs.begin(),it); + + // Else: take the first only + IFCImporter::LogError("error during polygon clipping, window contour is not convex"); } - std::vector outflat; - outflat.reserve(openings.size()*4); - QuadrifyPart(IfcVector2(0.f,0.f),IfcVector2(1.f,1.f),field,bbs,outflat); - ai_assert(!(outflat.size() % 4)); + ExtractVerticesFromClipper(clipped[0].outer, scratch); + // Assume the bounding box doesn't change during this operation +} +// ------------------------------------------------------------------------------------------------ +void CleanupWindowContours(ContourVector& contours) +{ + // Use PolyClipper to clean up window contours + try { + BOOST_FOREACH(ProjectedWindowContour& window, contours) { + CleanupWindowContour(window); + } + } + catch (const char* sx) { + IFCImporter::LogError("error during polygon clipping, window shape may be wrong: (Clipper: " + + std::string(sx) + ")"); + } +} + +// ------------------------------------------------------------------------------------------------ +void CleanupOuterContour(const std::vector& contour_flat, TempMesh& curmesh) +{ std::vector vold; std::vector iold; - vold.reserve(outflat.size()); - iold.reserve(outflat.size() / 4); + vold.reserve(curmesh.verts.size()); + iold.reserve(curmesh.vertcnt.size()); // Fix the outer contour using polyclipper try { - + ClipperLib::Polygon subject; ClipperLib::Clipper clipper; ClipperLib::ExPolygons clipped; @@ -1445,18 +1309,25 @@ bool TryAddOpenings_Quadrulate(const std::vector& openings,const st std::reverse(clip.begin(), clip.end()); } - // We need to run polyclipper on every single quad -- we can't run it one all + // We need to run polyclipper on every single polygon -- we can't run it one all // of them at once or it would merge them all together which would undo all // previous steps subject.reserve(4); - size_t cnt = 0; - BOOST_FOREACH(const IfcVector2& pip, outflat) { + size_t index = 0; + size_t countdown = 0; + BOOST_FOREACH(const IfcVector3& pip, curmesh.verts) { + if (!countdown) { + countdown = curmesh.vertcnt[index++]; + if (!countdown) { + continue; + } + } subject.push_back(ClipperLib::IntPoint( to_int64(pip.x), to_int64(pip.y) )); - if (!(++cnt % 4)) { + if (--countdown == 0) { if (!ClipperLib::Orientation(subject)) { std::reverse(subject.begin(), subject.end()); } - + clipper.AddPolygon(subject,ClipperLib::ptSubject); clipper.AddPolygon(clip,ClipperLib::ptClip); @@ -1465,10 +1336,10 @@ bool TryAddOpenings_Quadrulate(const std::vector& openings,const st BOOST_FOREACH(const ClipperLib::ExPolygon& ex, clipped) { iold.push_back(ex.outer.size()); BOOST_FOREACH(const ClipperLib::IntPoint& point, ex.outer) { - vold.push_back( minv * IfcVector3( - vmin.x + from_int64(point.X) * vmax.x, - vmin.y + from_int64(point.Y) * vmax.y, - coord)); + vold.push_back(IfcVector3( + from_int64(point.X), + from_int64(point.Y), + 0.0f)); } } @@ -1477,32 +1348,685 @@ bool TryAddOpenings_Quadrulate(const std::vector& openings,const st clipper.Clear(); } } - - assert(!(cnt % 4)); } catch (const char* sx) { - IFCImporter::LogError("Ifc: error during polygon clipping, contour line may be wrong: (Clipper: " + IFCImporter::LogError("Ifc: error during polygon clipping, wall contour line may be wrong: (Clipper: " + std::string(sx) + ")"); - iold.resize(outflat.size()/4,4); + return; + } - BOOST_FOREACH(const IfcVector2& vproj, outflat) { - const IfcVector3 v3 = minv * IfcVector3(vmin.x + vproj.x * vmax.x, vmin.y + vproj.y * vmax.y,coord); - vold.push_back(v3); + // swap data arrays + std::swap(vold,curmesh.verts); + std::swap(iold,curmesh.vertcnt); +} + +typedef std::vector OpeningRefs; +typedef std::vector OpeningRefVector; + +typedef std::vector +> ContourRefVector; + +// ------------------------------------------------------------------------------------------------ +bool BoundingBoxesAdjacent(const BoundingBox& bb, const BoundingBox& ibb) +{ + // TODO: I'm pretty sure there is a much more compact way to check this + const IfcFloat epsilon = 1e-5f; + return (fabs(bb.second.x - ibb.first.x) < epsilon && bb.first.y <= ibb.second.y && bb.second.y >= ibb.first.y) || + (fabs(bb.first.x - ibb.second.x) < epsilon && ibb.first.y <= bb.second.y && ibb.second.y >= bb.first.y) || + (fabs(bb.second.y - ibb.first.y) < epsilon && bb.first.x <= ibb.second.x && bb.second.x >= ibb.first.x) || + (fabs(bb.first.y - ibb.second.y) < epsilon && ibb.first.x <= bb.second.x && ibb.second.x >= bb.first.x); +} + +// ------------------------------------------------------------------------------------------------ +// Check if m0,m1 intersects n0,n1 assuming same ordering of the points in the line segments +// output the intersection points on n0,n1 +bool IntersectingLineSegments(const IfcVector2& n0, const IfcVector2& n1, + const IfcVector2& m0, const IfcVector2& m1, + IfcVector2& out0, IfcVector2& out1) +{ + const IfcVector2& m0_to_m1 = m1 - m0; + const IfcVector2& n0_to_n1 = n1 - n0; + + const IfcVector2& n0_to_m0 = m0 - n0; + const IfcVector2& n1_to_m1 = m1 - n1; + + const IfcVector2& n0_to_m1 = m1 - n0; + + const IfcFloat e = 1e-5f; + + if (!(n0_to_m0.SquareLength() < e*e || fabs(n0_to_m0 * n0_to_n1) / (n0_to_m0.Length() * n0_to_n1.Length()) > 1-1e-5 )) { + return false; + } + + if (!(n1_to_m1.SquareLength() < e*e || fabs(n1_to_m1 * n0_to_n1) / (n1_to_m1.Length() * n0_to_n1.Length()) > 1-1e-5 )) { + return false; + } + + IfcFloat s0; + IfcFloat s1; + if(fabs(n0_to_n1.x) > e) { + ai_assert(fabs(n0_to_m0.x) > e); + s0 = n0_to_m0.x / n0_to_n1.x; + s1 = n0_to_m1.x / n0_to_n1.x; + } + else { + ai_assert(fabs(n0_to_n1.y) > e); + s0 = n0_to_m0.y / n0_to_n1.y; + s1 = n0_to_m1.y / n0_to_n1.y; + } + + if (s1 < s0) { + std::swap(s1,s0); + } + + s0 = std::max(0.0,s0); + s1 = std::max(0.0,s1); + + s0 = std::min(1.0,s0); + s1 = std::min(1.0,s1); + + if (fabs(s1-s0) < e) { + return false; + } + + out0 = n0 + s0 * n0_to_n1; + out1 = n0 + s1 * n0_to_n1; + + return true; +} + +// ------------------------------------------------------------------------------------------------ +void FindAdjacentContours(ContourVector::iterator current, const ContourVector& contours) +{ + const BoundingBox& bb = (*current).bb; + + // What is to be done here is to populate the skip lists for the contour + // and to add necessary padding points when needed. + SkipList& skiplist = (*current).skiplist; + + // First step to find possible adjacent contours is to check for adjacent bounding + // boxes. If the bounding boxes are not adjacent, the contours lines cannot possibly be. + for (ContourVector::const_iterator it = contours.begin(), end = contours.end(); it != end; ++it) { + if ((*it).IsInvalid()) { + continue; + } + + if(it == current) { + continue; + } + + const BoundingBox& ibb = (*it).bb; + + // Assumption: the bounding boxes are pairwise disjoint + ai_assert(!BoundingBoxesOverlapping(bb, ibb)); + + if (BoundingBoxesAdjacent(bb, ibb)) { + + // Now do a each-against-everyone check for intersecting contour + // lines. This obviously scales terribly, but in typical real + // world Ifc files it will not matter since most windows that + // are adjacent to each others are rectangular anyway. + + Contour& ncontour = (*current).contour; + const Contour& mcontour = (*it).contour; + + for (size_t n = 0, nend = ncontour.size(); n < nend; ++n) { + const IfcVector2& n0 = ncontour[n]; + const IfcVector2& n1 = ncontour[(n+1) % ncontour.size()]; + + for (size_t m = 0, mend = mcontour.size(); m < nend; ++m) { + const IfcVector2& m0 = mcontour[m]; + const IfcVector2& m1 = mcontour[(m+1) % mcontour.size()]; + + IfcVector2 isect0, isect1; + if (IntersectingLineSegments(n0,n1, m0, m1, isect0, isect1)) { + + if ((isect0 - n0).SquareLength() > 1e-5) { + ++n; + + ncontour.insert(ncontour.begin() + n, isect0); + skiplist.insert(skiplist.begin() + n, true); + } + else { + skiplist[n] = true; + } + + if ((isect1 - n1).SquareLength() > 1e-5) { + ++n; + + ncontour.insert(ncontour.begin() + n, isect1); + skiplist.insert(skiplist.begin() + n, false); + } + } + } + } + } + } +} + +// ------------------------------------------------------------------------------------------------ +void FindBorderContours(ContourVector::iterator current) +{ + const IfcFloat border_epsilon_upper = static_cast(1-1e-4); + const IfcFloat border_epsilon_lower = static_cast(1e-4); + const IfcFloat dot_point_epsilon = static_cast(1e-5); + + bool outer_border = false; + bool start_on_outer_border = false; + + SkipList& skiplist = (*current).skiplist; + IfcVector2 last_proj_point; + + const Contour::const_iterator cbegin = (*current).contour.begin(), cend = (*current).contour.end(); + + for (Contour::const_iterator cit = cbegin; cit != cend; ++cit) { + const IfcVector2& proj_point = *cit; + + // Check if this connection is along the outer boundary of the projection + // plane. In such a case we better drop it because such 'edges' should + // not have any geometry to close them (think of door openings). + if (proj_point.x <= border_epsilon_lower || proj_point.x >= border_epsilon_upper || + proj_point.y <= border_epsilon_lower || proj_point.y >= border_epsilon_upper) { + + if (outer_border) { + ai_assert(cit != cbegin); + if (fabs((proj_point.x - last_proj_point.x) * (proj_point.y - last_proj_point.y)) < dot_point_epsilon) { + skiplist[std::distance(cbegin, cit) - 1] = true; + } + } + else if (cit == cbegin) { + start_on_outer_border = true; + } + + outer_border = true; + } + else { + outer_border = false; + } + + last_proj_point = proj_point; + } + + // handle first segment + if (outer_border && start_on_outer_border) { + const IfcVector2& proj_point = *cbegin; + if (fabs((proj_point.x - last_proj_point.x) * (proj_point.y - last_proj_point.y)) < dot_point_epsilon) { + skiplist[0] = true; + } + } +} + +// ------------------------------------------------------------------------------------------------ +void CloseWindows(ContourVector& contours, + const IfcMatrix4& minv, + OpeningRefVector contours_to_openings, + TempMesh& curmesh) +{ + // For all contour points, check if one of the assigned openings does + // already have points assigned to it. In this case, assume this is + // the other side of the wall and generate connections between + // the two holes in order to close the window. + + // All this gets complicated by the fact that contours may pertain to + // multiple openings(due to merging of adjacent or overlapping openings). + // The code is based on the assumption that this happens symmetrically + // on both sides of the wall. If it doesn't (which would be a bug anyway) + // wrong geometry may be generated. + for (ContourVector::iterator it = contours.begin(), end = contours.end(); it != end; ++it) { + if ((*it).IsInvalid()) { + continue; + } + OpeningRefs& refs = contours_to_openings[std::distance(contours.begin(), it)]; + + bool has_other_side = false; + BOOST_FOREACH(const TempOpening* opening, refs) { + if(!opening->wallPoints.empty()) { + has_other_side = true; + break; + } + } + + ContourRefVector adjacent_contours; + + // prepare a skiplist for this contour. The skiplist is used to + // eliminate unwanted contour lines for adjacent windows and + // those bordering the outer frame. + (*it).PrepareSkiplist(); + + FindAdjacentContours(it, contours); + FindBorderContours(it); + + ai_assert((*it).skiplist.size() == (*it).contour.size()); + + SkipList::const_iterator skipbegin = (*it).skiplist.begin(), skipend = (*it).skiplist.end(); + const Contour::const_iterator cbegin = (*it).contour.begin(), cend = (*it).contour.end(); + + if (has_other_side) { + curmesh.verts.reserve(curmesh.verts.size() + (*it).contour.size() * 4); + curmesh.vertcnt.reserve(curmesh.vertcnt.size() + (*it).contour.size()); + + // XXX this algorithm is really a bit inefficient - both in terms + // of constant factor and of asymptotic runtime. + size_t vstart = curmesh.verts.size(); + std::vector::const_iterator skipit = skipbegin; + + IfcVector3 start0; + IfcVector3 start1; + + bool drop_this_edge = false; + for (Contour::const_iterator cit = cbegin; cit != cend; ++cit, drop_this_edge = *skipit++) { + const IfcVector2& proj_point = *cit; + + // Locate the closest opposite point. This should be a good heuristic to + // connect only the points that are really intended to be connected. + IfcFloat best = static_cast(1e10); + IfcVector3 bestv; + + const IfcVector3& world_point = minv * IfcVector3(proj_point.x,proj_point.y,0.0f); + + BOOST_FOREACH(const TempOpening* opening, refs) { + BOOST_FOREACH(const IfcVector3& other, opening->wallPoints) { + const IfcFloat sqdist = (world_point - other).SquareLength(); + if (sqdist < best) { + bestv = other; + best = sqdist; + } + } + } + + IfcVector3 diff = bestv - world_point; + diff.Normalize(); + + if (drop_this_edge) { + curmesh.verts.pop_back(); + curmesh.verts.pop_back(); + } + else { + curmesh.verts.push_back(cit == cbegin ? world_point : bestv); + curmesh.verts.push_back(cit == cbegin ? bestv : world_point); + + curmesh.vertcnt.push_back(4); + } + + if (cit == cbegin) { + start0 = world_point; + start1 = bestv; + continue; + } + + curmesh.verts.push_back(world_point); + curmesh.verts.push_back(bestv); + + if (cit == cend - 1) { + drop_this_edge = *skipit; + + // Check if the final connection (last to first element) is itself + // a border edge that needs to be dropped. + if (drop_this_edge) { + curmesh.vertcnt.pop_back(); + curmesh.verts.pop_back(); + curmesh.verts.pop_back(); + } + else { + curmesh.verts.push_back(start1); + curmesh.verts.push_back(start0); + } + } + } + } + else { + BOOST_FOREACH(TempOpening* opening, refs) { + opening->wallPoints.reserve(opening->wallPoints.capacity() + (*it).contour.size()); + for (Contour::const_iterator cit = cbegin; cit != cend; ++cit) { + + const IfcVector2& proj_point = *cit; + opening->wallPoints.push_back(minv * IfcVector3(proj_point.x,proj_point.y,0.0f)); + } + } + } + } +} + +// ------------------------------------------------------------------------------------------------ +void Quadrify(const std::vector< BoundingBox >& bbs, TempMesh& curmesh) +{ + ai_assert(curmesh.IsEmpty()); + + std::vector quads; + quads.reserve(bbs.size()*4); + + // sort openings by x and y axis as a preliminiary to the QuadrifyPart() algorithm + XYSortedField field; + for (std::vector::const_iterator it = bbs.begin(); it != bbs.end(); ++it) { + if (field.find((*it).first) != field.end()) { + IFCImporter::LogWarn("constraint failure during generation of wall openings, results may be faulty"); + } + field[(*it).first] = std::distance(bbs.begin(),it); + } + + QuadrifyPart(IfcVector2(),one_vec,field,bbs,quads); + ai_assert(!(quads.size() % 4)); + + curmesh.vertcnt.resize(quads.size()/4,4); + curmesh.verts.reserve(quads.size()); + BOOST_FOREACH(const IfcVector2& v2, quads) { + curmesh.verts.push_back(IfcVector3(v2.x, v2.y, static_cast(0.0))); + } +} + +// ------------------------------------------------------------------------------------------------ +void Quadrify(const ContourVector& contours, TempMesh& curmesh) +{ + std::vector bbs; + bbs.reserve(contours.size()); + + BOOST_FOREACH(const ContourVector::value_type& val, contours) { + bbs.push_back(val.bb); + } + + Quadrify(bbs, curmesh); +} + +// ------------------------------------------------------------------------------------------------ +IfcMatrix4 ProjectOntoPlane(std::vector& out_contour, const TempMesh& in_mesh, + IfcFloat& out_base_d, bool &ok) +{ + const std::vector& in_verts = in_mesh.verts; + ok = true; + + IfcMatrix4 m = IfcMatrix4(DerivePlaneCoordinateSpace(in_mesh, ok, &out_base_d)); + if(!ok) { + return IfcMatrix4(); + } + + + IfcFloat coord = -1; + out_contour.reserve(in_verts.size()); + + IfcVector2 vmin, vmax; + MinMaxChooser()(vmin, vmax); + + // Project all points into the new coordinate system, collect min/max verts on the way + BOOST_FOREACH(const IfcVector3& x, in_verts) { + const IfcVector3& vv = m * x; + // keep Z offset in the plane coordinate system. Ignoring precision issues + // (which are present, of course), this should be the same value for + // all polygon vertices (assuming the polygon is planar). + + // XXX this should be guarded, but we somehow need to pick a suitable + // epsilon + // if(coord != -1.0f) { + // assert(fabs(coord - vv.z) < 1e-3f); + // } + coord = vv.z; + vmin = std::min(IfcVector2(vv.x, vv.y), vmin); + vmax = std::max(IfcVector2(vv.x, vv.y), vmax); + + out_contour.push_back(IfcVector2(vv.x,vv.y)); + } + + // Further improve the projection by mapping the entire working set into + // [0,1] range. This gives us a consistent data range so all epsilons + // used below can be constants. + vmax -= vmin; + BOOST_FOREACH(IfcVector2& vv, out_contour) { + vv.x = (vv.x - vmin.x) / vmax.x; + vv.y = (vv.y - vmin.y) / vmax.y; + + // sanity rounding + vv = std::max(vv,IfcVector2()); + vv = std::min(vv,one_vec); + } + + IfcMatrix4 mult; + mult.a1 = static_cast(1.0) / vmax.x; + mult.b2 = static_cast(1.0) / vmax.y; + + mult.a4 = -vmin.x * mult.a1; + mult.b4 = -vmin.y * mult.b2; + mult.c4 = -coord; + m = mult * m; + + return m; +} + +// ------------------------------------------------------------------------------------------------ +bool GenerateOpenings(std::vector& openings, + const std::vector& nors, + TempMesh& curmesh, + bool check_intersection, + bool generate_connection_geometry) +{ + std::vector& out = curmesh.verts; + OpeningRefVector contours_to_openings; + + // Try to derive a solid base plane within the current surface for use as + // working coordinate system. Map all vertices onto this plane and + // rescale them to [0,1] range. This normalization means all further + // epsilons need not be scaled. + bool ok = true; + + std::vector contour_flat; + IfcFloat base_d; + + const IfcMatrix4& m = ProjectOntoPlane(contour_flat, curmesh, base_d, ok); + if(!ok) { + return false; + } + + const IfcVector3& nor = IfcVector3(m.c1, m.c2, m.c3); + + // Obtain inverse transform for getting back to world space later on + const IfcMatrix4& minv = IfcMatrix4(m).Inverse(); + + // Compute bounding boxes for all 2D openings in projection space + ContourVector contours; + + std::vector temp_contour; + + size_t c = 0; + BOOST_FOREACH(TempOpening& opening,openings) { + std::vector profile_verts = opening.profileMesh->verts; + std::vector profile_vertcnts = opening.profileMesh->vertcnt; + if(profile_verts.size() <= 2) { + continue; + } + + IfcVector2 vpmin,vpmax; + MinMaxChooser()(vpmin,vpmax); + + // The opening meshes are real 3D meshes so skip over all faces + // clearly facing into the wrong direction. Also, we need to check + // whether the meshes do actually intersect the base surface plane. + // This is done by recording minimum and maximum values for the + // d component of the plane equation for all polys and checking + // against surface d. + IfcFloat dmin, dmax; + MinMaxChooser()(dmin,dmax); + + temp_contour.clear(); + for (size_t f = 0, vi_total = 0, fend = profile_vertcnts.size(); f < fend; ++f) { + const IfcVector3& face_nor = ((profile_verts[vi_total+2] - profile_verts[vi_total]) ^ + (profile_verts[vi_total+1] - profile_verts[vi_total])).Normalize(); + + const IfcFloat abs_dot_face_nor = abs(nor * face_nor); + if (abs_dot_face_nor < 0.5) { + vi_total += profile_vertcnts[f]; + continue; + } + + for (unsigned int vi = 0, vend = profile_vertcnts[f]; vi < vend; ++vi, ++vi_total) { + const IfcVector3& x = profile_verts[vi_total]; + + if(check_intersection) { + const IfcFloat vert_d = -(x * nor); + dmin = std::min(dmin, vert_d); + dmax = std::max(dmax, vert_d); + } + + const IfcVector3& v = m * x; + IfcVector2 vv(v.x, v.y); + + // sanity rounding + vv = std::max(vv,IfcVector2()); + vv = std::min(vv,one_vec); + + vpmin = std::min(vpmin,vv); + vpmax = std::max(vpmax,vv); + + if (!IsDuplicateVertex(vv, temp_contour)) { + temp_contour.push_back(vv); + } + } + } + + if(temp_contour.size() <= 2) { + continue; + } + + // TODO: This epsilon may be too large + const IfcFloat epsilon = fabs(dmax-dmin) * 0.01; + if (check_intersection && (base_d < dmin-epsilon || base_d > dmax+epsilon)) { + continue; + } + + BoundingBox bb = BoundingBox(vpmin,vpmax); + + // Skip over very small openings - these are likely projection errors + // (i.e. they don't belong to this side of the wall) + if(fabs(vpmax.x - vpmin.x) * fabs(vpmax.y - vpmin.y) < static_cast(1e-5)) { + continue; + } + std::vector joined_openings(1, &opening); + + // See if this BB intersects or is in close adjacency to any other BB we have so far. + for (ContourVector::iterator it = contours.begin(); it != contours.end(); ) { + const BoundingBox& ibb = (*it).bb; + + if (BoundingBoxesOverlapping(ibb, bb)) { + + const std::vector& other = (*it).contour; + ClipperLib::ExPolygons poly; + + // First check whether subtracting the old contour (to which ibb belongs) + // from the new contour (to which bb belongs) yields an updated bb which + // no longer overlaps ibb + MakeDisjunctWindowContours(other, temp_contour, poly); + if(poly.size() == 1) { + + const BoundingBox& newbb = GetBoundingBox(poly[0].outer); + if (!BoundingBoxesOverlapping(ibb, newbb )) { + // Good guy bounding box + bb = newbb ; + + ExtractVerticesFromClipper(poly[0].outer, temp_contour, false); + continue; + } + } + + // Take these two overlapping contours and try to merge them. If they + // overlap (which should not happen, but in fact happens-in-the-real- + // world [tm] ), resume using a single contour and a single bounding box. + MergeWindowContours(temp_contour, other, poly); + + if (poly.size() > 1) { + return TryAddOpenings_Poly2Tri(openings, nors, curmesh); + } + else if (poly.size() == 0) { + IFCImporter::LogWarn("ignoring duplicate opening"); + temp_contour.clear(); + break; + } + else { + IFCImporter::LogDebug("merging overlapping openings"); + ExtractVerticesFromClipper(poly[0].outer, temp_contour, true); + + // Generate the union of the bounding boxes + bb.first = std::min(bb.first, ibb.first); + bb.second = std::max(bb.second, ibb.second); + + // Update contour-to-opening tables accordingly + if (generate_connection_geometry) { + std::vector& t = contours_to_openings[std::distance(contours.begin(),it)]; + joined_openings.insert(joined_openings.end(), t.begin(), t.end()); + + contours_to_openings.erase(contours_to_openings.begin() + std::distance(contours.begin(),it)); + } + + contours.erase(it); + + // Restart from scratch because the newly formed BB might now + // overlap any other BB which its constituent BBs didn't + // previously overlap. + it = contours.begin(); + continue; + } + } + ++it; + } + + if(!temp_contour.empty()) { + if (generate_connection_geometry) { + contours_to_openings.push_back(std::vector( + joined_openings.begin(), + joined_openings.end())); + } + + contours.push_back(ProjectedWindowContour(temp_contour, bb)); } } - // undo the projection, generate output quads - std::swap(vold,curmesh.verts); - std::swap(iold,curmesh.vertcnt); + // Check if we still have any openings left - it may well be that this is + // not the cause, for example if all the opening candidates don't intersect + // this surface or point into a direction perpendicular to it. + if (contours.empty()) { + return false; + } - InsertWindowContours(bbs,contours,openings, nors,minv,vmax, vmin, coord, curmesh); + curmesh.Clear(); + + // Generate a base subdivision into quads to accommodate the given list + // of window bounding boxes. + Quadrify(contours,curmesh); + + // Run a sanity cleanup pass on the window contours to avoid generating + // artifacts during the contour generation phase later on. + CleanupWindowContours(contours); + + // Previously we reduced all windows to rectangular AABBs in projection + // space, now it is time to fill the gaps between the BBs and the real + // window openings. + InsertWindowContours(contours,openings, curmesh); + + // Clip the entire outer contour of our current result against the real + // outer contour of the surface. This is necessary because the result + // of the Quadrify() algorithm is always a square area spanning + // over [0,1]^2 (i.e. entire projection space). + CleanupOuterContour(contour_flat, curmesh); + + // Undo the projection and get back to world (or local object) space + BOOST_FOREACH(IfcVector3& v3, curmesh.verts) { + v3 = minv * v3; + } + + // TODO: + // This should connect the window openings on both sides of the wall, + // but it produces lots of artifacts which are not resolved yet. + // Most of all, it makes all cases in which adjacent openings are + // not correctly merged together glaringly obvious. + if (generate_connection_geometry) { + CloseWindows(contours, minv, contours_to_openings, curmesh); + } return true; } // ------------------------------------------------------------------------------------------------ -void ProcessExtrudedAreaSolid(const IfcExtrudedAreaSolid& solid, TempMesh& result, ConversionData& conv) +void ProcessExtrudedAreaSolid(const IfcExtrudedAreaSolid& solid, TempMesh& result, + ConversionData& conv) { TempMesh meshout; @@ -1544,11 +2068,13 @@ void ProcessExtrudedAreaSolid(const IfcExtrudedAreaSolid& solid, TempMesh& resul IfcVector3 min = in[0]; dir *= IfcMatrix3(trafo); + std::vector nors; const bool openings = !!conv.apply_openings && conv.apply_openings->size(); // Compute the normal vectors for all opening polygons as a prerequisite // to TryAddOpenings_Poly2Tri() + // XXX this belongs into the aforementioned function if (openings) { if (!conv.settings.useCustomTriangulation) { @@ -1588,7 +2114,7 @@ void ProcessExtrudedAreaSolid(const IfcExtrudedAreaSolid& solid, TempMesh& resul out.push_back(in[next]); if(openings) { - if(TryAddOpenings_Quadrulate(*conv.apply_openings,nors,temp)) { + if(GenerateOpenings(*conv.apply_openings,nors,temp)) { ++sides_with_openings; } @@ -1607,7 +2133,7 @@ void ProcessExtrudedAreaSolid(const IfcExtrudedAreaSolid& solid, TempMesh& resul curmesh.vertcnt.push_back(size); if(openings && size > 2) { - if(TryAddOpenings_Quadrulate(*conv.apply_openings,nors,temp)) { + if(GenerateOpenings(*conv.apply_openings,nors,temp)) { ++sides_with_v_openings; } @@ -1617,36 +2143,18 @@ void ProcessExtrudedAreaSolid(const IfcExtrudedAreaSolid& solid, TempMesh& resul } } - - if(openings && ((sides_with_openings != 2 && sides_with_openings) || (sides_with_v_openings != 2 && sides_with_v_openings))) { + if(openings && ((sides_with_openings == 1 && sides_with_openings) || (sides_with_v_openings == 2 && sides_with_v_openings))) { IFCImporter::LogWarn("failed to resolve all openings, presumably their topology is not supported by Assimp"); } IFCImporter::LogDebug("generate mesh procedurally by extrusion (IfcExtrudedAreaSolid)"); } - - // ------------------------------------------------------------------------------------------------ -void ProcessSweptAreaSolid(const IfcSweptAreaSolid& swept, TempMesh& meshout, ConversionData& conv) +void ProcessSweptAreaSolid(const IfcSweptAreaSolid& swept, TempMesh& meshout, + ConversionData& conv) { if(const IfcExtrudedAreaSolid* const solid = swept.ToPtr()) { - // Do we just collect openings for a parent element (i.e. a wall)? - // In this case we don't extrude the surface yet, just keep the profile and transform it correctly - if(conv.collect_openings) { - boost::shared_ptr meshtmp(new TempMesh()); - ProcessProfile(swept.SweptArea,*meshtmp,conv); - - IfcMatrix4 m; - ConvertAxisPlacement(m,solid->Position); - meshtmp->Transform(m); - - IfcVector3 dir; - ConvertDirection(dir,solid->ExtrudedDirection); - conv.collect_openings->push_back(TempOpening(solid, IfcMatrix3(m) * (dir*static_cast(solid->Depth)),meshtmp)); - return; - } - ProcessExtrudedAreaSolid(*solid,meshout,conv); } else if(const IfcRevolvedAreaSolid* const rev = swept.ToPtr()) { @@ -1657,7 +2165,6 @@ void ProcessSweptAreaSolid(const IfcSweptAreaSolid& swept, TempMesh& meshout, Co } } - // ------------------------------------------------------------------------------------------------ enum Intersect { Intersect_No, @@ -1666,7 +2173,9 @@ enum Intersect { }; // ------------------------------------------------------------------------------------------------ -Intersect IntersectSegmentPlane(const IfcVector3& p,const IfcVector3& n, const IfcVector3& e0, const IfcVector3& e1, IfcVector3& out) +Intersect IntersectSegmentPlane(const IfcVector3& p,const IfcVector3& n, const IfcVector3& e0, + const IfcVector3& e1, + IfcVector3& out) { const IfcVector3 pdelta = e0 - p, seg = e1-e0; const IfcFloat dotOne = n*seg, dotTwo = -(n*pdelta); @@ -1684,138 +2193,219 @@ Intersect IntersectSegmentPlane(const IfcVector3& p,const IfcVector3& n, const I return Intersect_Yes; } +// ------------------------------------------------------------------------------------------------ +void ProcessBooleanHalfSpaceDifference(const IfcHalfSpaceSolid* hs, TempMesh& result, + const TempMesh& first_operand, + ConversionData& conv) +{ + ai_assert(hs != NULL); + + const IfcPlane* const plane = hs->BaseSurface->ToPtr(); + if(!plane) { + IFCImporter::LogError("expected IfcPlane as base surface for the IfcHalfSpaceSolid"); + return; + } + + // extract plane base position vector and normal vector + IfcVector3 p,n(0.f,0.f,1.f); + if (plane->Position->Axis) { + ConvertDirection(n,plane->Position->Axis.Get()); + } + ConvertCartesianPoint(p,plane->Position->Location); + + if(!IsTrue(hs->AgreementFlag)) { + n *= -1.f; + } + + // clip the current contents of `meshout` against the plane we obtained from the second operand + const std::vector& in = first_operand.verts; + std::vector& outvert = result.verts; + + std::vector::const_iterator begin = first_operand.vertcnt.begin(), + end = first_operand.vertcnt.end(), iit; + + outvert.reserve(in.size()); + result.vertcnt.reserve(first_operand.vertcnt.size()); + + unsigned int vidx = 0; + for(iit = begin; iit != end; vidx += *iit++) { + + unsigned int newcount = 0; + for(unsigned int i = 0; i < *iit; ++i) { + const IfcVector3& e0 = in[vidx+i], e1 = in[vidx+(i+1)%*iit]; + + // does the next segment intersect the plane? + IfcVector3 isectpos; + const Intersect isect = IntersectSegmentPlane(p,n,e0,e1,isectpos); + if (isect == Intersect_No || isect == Intersect_LiesOnPlane) { + if ( (e0-p).Normalize()*n > 0 ) { + outvert.push_back(e0); + ++newcount; + } + } + else if (isect == Intersect_Yes) { + if ( (e0-p).Normalize()*n > 0 ) { + // e0 is on the right side, so keep it + outvert.push_back(e0); + outvert.push_back(isectpos); + newcount += 2; + } + else { + // e0 is on the wrong side, so drop it and keep e1 instead + outvert.push_back(isectpos); + ++newcount; + } + } + } + + if (!newcount) { + continue; + } + + IfcVector3 vmin,vmax; + ArrayBounds(&*(outvert.end()-newcount),newcount,vmin,vmax); + + // filter our IfcFloat points - those may happen if a point lies + // directly on the intersection line. However, due to IfcFloat + // precision a bitwise comparison is not feasible to detect + // this case. + const IfcFloat epsilon = (vmax-vmin).SquareLength() / 1e6f; + FuzzyVectorCompare fz(epsilon); + + std::vector::iterator e = std::unique( outvert.end()-newcount, outvert.end(), fz ); + + if (e != outvert.end()) { + newcount -= static_cast(std::distance(e,outvert.end())); + outvert.erase(e,outvert.end()); + } + if (fz(*( outvert.end()-newcount),outvert.back())) { + outvert.pop_back(); + --newcount; + } + if(newcount > 2) { + result.vertcnt.push_back(newcount); + } + else while(newcount-->0) { + result.verts.pop_back(); + } + + } + IFCImporter::LogDebug("generating CSG geometry by plane clipping (IfcBooleanClippingResult)"); +} + +// ------------------------------------------------------------------------------------------------ +void ProcessBooleanExtrudedAreaSolidDifference(const IfcExtrudedAreaSolid* as, TempMesh& result, + const TempMesh& first_operand, + ConversionData& conv) +{ + ai_assert(as != NULL); + + // This case is handled by reduction to an instance of the quadrify() algorithm. + // Obviously, this won't work for arbitrarily complex cases. In fact, the first + // operand should be near-planar. Luckily, this is usually the case in Ifc + // buildings. + + boost::shared_ptr meshtmp(new TempMesh()); + ProcessExtrudedAreaSolid(*as,*meshtmp,conv); + + std::vector openings(1, TempOpening(as,IfcVector3(0,0,0),meshtmp)); + + result = first_operand; + + TempMesh temp; + + std::vector::const_iterator vit = first_operand.verts.begin(); + BOOST_FOREACH(unsigned int pcount, first_operand.vertcnt) { + temp.Clear(); + + temp.verts.insert(temp.verts.end(), vit, vit + pcount); + temp.vertcnt.push_back(pcount); + + // The algorithms used to generate mesh geometry sometimes + // spit out lines or other degenerates which must be + // filtered to avoid running into assertions later on. + + // ComputePolygonNormal returns the Newell normal, so the + // length of the normal is the area of the polygon. + const IfcVector3& normal = temp.ComputeLastPolygonNormal(false); + if (normal.SquareLength() < static_cast(1e-5)) { + IFCImporter::LogWarn("skipping degenerate polygon (ProcessBooleanExtrudedAreaSolidDifference)"); + continue; + } + + GenerateOpenings(openings, std::vector(1,IfcVector3(1,0,0)), temp); + result.Append(temp); + + vit += pcount; + } + + IFCImporter::LogDebug("generating CSG geometry by geometric difference to a solid (IfcExtrudedAreaSolid)"); +} + // ------------------------------------------------------------------------------------------------ void ProcessBoolean(const IfcBooleanResult& boolean, TempMesh& result, ConversionData& conv) { + // supported CSG operations: + // DIFFERENCE if(const IfcBooleanResult* const clip = boolean.ToPtr()) { if(clip->Operator != "DIFFERENCE") { IFCImporter::LogWarn("encountered unsupported boolean operator: " + (std::string)clip->Operator); return; } - TempMesh meshout; + // supported cases (1st operand): + // IfcBooleanResult -- call ProcessBoolean recursively + // IfcSweptAreaSolid -- obtain polygonal geometry first + + // supported cases (2nd operand): + // IfcHalfSpaceSolid -- easy, clip against plane + // IfcExtrudedAreaSolid -- reduce to an instance of the quadrify() algorithm + + const IfcHalfSpaceSolid* const hs = clip->SecondOperand->ResolveSelectPtr(conv.db); - if(!hs) { - IFCImporter::LogError("expected IfcHalfSpaceSolid as second clipping operand"); - return; - } - - const IfcPlane* const plane = hs->BaseSurface->ToPtr(); - if(!plane) { - IFCImporter::LogError("expected IfcPlane as base surface for the IfcHalfSpaceSolid"); + const IfcExtrudedAreaSolid* const as = clip->SecondOperand->ResolveSelectPtr(conv.db); + if(!hs && !as) { + IFCImporter::LogError("expected IfcHalfSpaceSolid or IfcExtrudedAreaSolid as second clipping operand"); return; } + TempMesh first_operand; if(const IfcBooleanResult* const op0 = clip->FirstOperand->ResolveSelectPtr(conv.db)) { - ProcessBoolean(*op0,meshout,conv); + ProcessBoolean(*op0,first_operand,conv); } else if (const IfcSweptAreaSolid* const swept = clip->FirstOperand->ResolveSelectPtr(conv.db)) { - ProcessSweptAreaSolid(*swept,meshout,conv); + ProcessSweptAreaSolid(*swept,first_operand,conv); } else { IFCImporter::LogError("expected IfcSweptAreaSolid or IfcBooleanResult as first clipping operand"); return; } - // extract plane base position vector and normal vector - IfcVector3 p,n(0.f,0.f,1.f); - if (plane->Position->Axis) { - ConvertDirection(n,plane->Position->Axis.Get()); + if(hs) { + ProcessBooleanHalfSpaceDifference(hs, result, first_operand, conv); } - ConvertCartesianPoint(p,plane->Position->Location); - - if(!IsTrue(hs->AgreementFlag)) { - n *= -1.f; + else { + ProcessBooleanExtrudedAreaSolidDifference(as, result, first_operand, conv); } - - // clip the current contents of `meshout` against the plane we obtained from the second operand - const std::vector& in = meshout.verts; - std::vector& outvert = result.verts; - std::vector::const_iterator begin=meshout.vertcnt.begin(), end=meshout.vertcnt.end(), iit; - - outvert.reserve(in.size()); - result.vertcnt.reserve(meshout.vertcnt.size()); - - unsigned int vidx = 0; - for(iit = begin; iit != end; vidx += *iit++) { - - unsigned int newcount = 0; - for(unsigned int i = 0; i < *iit; ++i) { - const IfcVector3& e0 = in[vidx+i], e1 = in[vidx+(i+1)%*iit]; - - // does the next segment intersect the plane? - IfcVector3 isectpos; - const Intersect isect = IntersectSegmentPlane(p,n,e0,e1,isectpos); - if (isect == Intersect_No || isect == Intersect_LiesOnPlane) { - if ( (e0-p).Normalize()*n > 0 ) { - outvert.push_back(e0); - ++newcount; - } - } - else if (isect == Intersect_Yes) { - if ( (e0-p).Normalize()*n > 0 ) { - // e0 is on the right side, so keep it - outvert.push_back(e0); - outvert.push_back(isectpos); - newcount += 2; - } - else { - // e0 is on the wrong side, so drop it and keep e1 instead - outvert.push_back(isectpos); - ++newcount; - } - } - } - - if (!newcount) { - continue; - } - - IfcVector3 vmin,vmax; - ArrayBounds(&*(outvert.end()-newcount),newcount,vmin,vmax); - - // filter our IfcFloat points - those may happen if a point lies - // directly on the intersection line. However, due to IfcFloat - // precision a bitwise comparison is not feasible to detect - // this case. - const IfcFloat epsilon = (vmax-vmin).SquareLength() / 1e6f; - FuzzyVectorCompare fz(epsilon); - - std::vector::iterator e = std::unique( outvert.end()-newcount, outvert.end(), fz ); - if (e != outvert.end()) { - newcount -= static_cast(std::distance(e,outvert.end())); - outvert.erase(e,outvert.end()); - } - if (fz(*( outvert.end()-newcount),outvert.back())) { - outvert.pop_back(); - --newcount; - } - if(newcount > 2) { - result.vertcnt.push_back(newcount); - } - else while(newcount-->0)result.verts.pop_back(); - - } - IFCImporter::LogDebug("generating CSG geometry by plane clipping (IfcBooleanClippingResult)"); } else { IFCImporter::LogWarn("skipping unknown IfcBooleanResult entity, type is " + boolean.GetClassName()); } } - - // ------------------------------------------------------------------------------------------------ -bool ProcessGeometricItem(const IfcRepresentationItem& geo, std::vector& mesh_indices, ConversionData& conv) +bool ProcessGeometricItem(const IfcRepresentationItem& geo, std::vector& mesh_indices, + ConversionData& conv) { - TempMesh meshtmp; + bool fix_orientation = true; + boost::shared_ptr< TempMesh > meshtmp = boost::make_shared(); if(const IfcShellBasedSurfaceModel* shellmod = geo.ToPtr()) { BOOST_FOREACH(boost::shared_ptr shell,shellmod->SbsmBoundary) { try { const EXPRESS::ENTITY& e = shell->To(); const IfcConnectedFaceSet& fs = conv.db.MustGetObject(e).To(); - ProcessConnectedFaceSet(fs,meshtmp,conv); + ProcessConnectedFaceSet(fs,*meshtmp.get(),conv); } catch(std::bad_cast&) { IFCImporter::LogWarn("unexpected type error, IfcShell ought to inherit from IfcConnectedFaceSet"); @@ -1823,24 +2413,25 @@ bool ProcessGeometricItem(const IfcRepresentationItem& geo, std::vector()) { - ProcessConnectedFaceSet(*fset,meshtmp,conv); + ProcessConnectedFaceSet(*fset,*meshtmp.get(),conv); } else if(const IfcSweptAreaSolid* swept = geo.ToPtr()) { - ProcessSweptAreaSolid(*swept,meshtmp,conv); + ProcessSweptAreaSolid(*swept,*meshtmp.get(),conv); } else if(const IfcSweptDiskSolid* disk = geo.ToPtr()) { - ProcessSweptDiskSolid(*disk,meshtmp,conv); + ProcessSweptDiskSolid(*disk,*meshtmp.get(),conv); + fix_orientation = false; } else if(const IfcManifoldSolidBrep* brep = geo.ToPtr()) { - ProcessConnectedFaceSet(brep->Outer,meshtmp,conv); + ProcessConnectedFaceSet(brep->Outer,*meshtmp.get(),conv); } else if(const IfcFaceBasedSurfaceModel* surf = geo.ToPtr()) { BOOST_FOREACH(const IfcConnectedFaceSet& fc, surf->FbsmFaces) { - ProcessConnectedFaceSet(fc,meshtmp,conv); + ProcessConnectedFaceSet(fc,*meshtmp.get(),conv); } } else if(const IfcBooleanResult* boolean = geo.ToPtr()) { - ProcessBoolean(*boolean,meshtmp,conv); + ProcessBoolean(*boolean,*meshtmp.get(),conv); } else if(geo.ToPtr()) { // silently skip over bounding boxes @@ -1851,10 +2442,23 @@ bool ProcessGeometricItem(const IfcRepresentationItem& geo, std::vectorRemoveAdjacentDuplicates(); + meshtmp->RemoveDegenerates(); - aiMesh* const mesh = meshtmp.ToMesh(); + // Do we just collect openings for a parent element (i.e. a wall)? + // In such a case, we generate the polygonal extrusion mesh as usual, + // but attach it to a TempOpening instance which will later be applied + // to the wall it pertains to. + if(conv.collect_openings) { + conv.collect_openings->push_back(TempOpening(geo.ToPtr(),IfcVector3(0,0,0),meshtmp)); + return true; + } + + if(fix_orientation) { + meshtmp->FixupFaceOrientation(); + } + + aiMesh* const mesh = meshtmp->ToMesh(); if(mesh) { mesh->mMaterialIndex = ProcessMaterials(geo,conv); mesh_indices.push_back(conv.meshes.size()); @@ -1865,7 +2469,8 @@ bool ProcessGeometricItem(const IfcRepresentationItem& geo, std::vector& mesh_indices,aiNode* nd,ConversionData& /*conv*/) +void AssignAddedMeshes(std::vector& mesh_indices,aiNode* nd, + ConversionData& /*conv*/) { if (!mesh_indices.empty()) { @@ -1884,7 +2489,9 @@ void AssignAddedMeshes(std::vector& mesh_indices,aiNode* nd,Conver } // ------------------------------------------------------------------------------------------------ -bool TryQueryMeshCache(const IfcRepresentationItem& item, std::vector& mesh_indices, ConversionData& conv) +bool TryQueryMeshCache(const IfcRepresentationItem& item, + std::vector& mesh_indices, + ConversionData& conv) { ConversionData::MeshCache::const_iterator it = conv.cached_meshes.find(&item); if (it != conv.cached_meshes.end()) { @@ -1895,13 +2502,17 @@ bool TryQueryMeshCache(const IfcRepresentationItem& item, std::vector& mesh_indices, ConversionData& conv) +void PopulateMeshCache(const IfcRepresentationItem& item, + const std::vector& mesh_indices, + ConversionData& conv) { conv.cached_meshes[&item] = mesh_indices; } // ------------------------------------------------------------------------------------------------ -bool ProcessRepresentationItem(const IfcRepresentationItem& item, std::vector& mesh_indices, ConversionData& conv) +bool ProcessRepresentationItem(const IfcRepresentationItem& item, + std::vector& mesh_indices, + ConversionData& conv) { if (!TryQueryMeshCache(item,mesh_indices,conv)) { if(ProcessGeometricItem(item,mesh_indices,conv)) { @@ -1916,7 +2527,7 @@ bool ProcessRepresentationItem(const IfcRepresentationItem& item, std::vector normals; + ComputePolygonNormals(normals, false); + + bool drop = false; + size_t inor = 0; + + std::vector::iterator vit = verts.begin(); + for (std::vector::iterator it = vertcnt.begin(); it != vertcnt.end(); ++inor) { + const unsigned int pcount = *it; + + if (normals[inor].SquareLength() < 1e-5f) { + it = vertcnt.erase(it); + vit = verts.erase(vit, vit + pcount); + + drop = true; + continue; + } + + vit += pcount; + ++it; + } + + if(drop) { + IFCImporter::LogDebug("removing degenerate faces"); + } +} + +// ------------------------------------------------------------------------------------------------ +void TempMesh::ComputePolygonNormals(std::vector& normals, + bool normalize, + size_t ofs) const +{ + size_t max_vcount = 0; + std::vector::const_iterator begin = vertcnt.begin()+ofs, end = vertcnt.end(), iit; + for(iit = begin; iit != end; ++iit) { + max_vcount = std::max(max_vcount,static_cast(*iit)); + } + + std::vector temp((max_vcount+2)*4); + normals.reserve( normals.size() + vertcnt.size()-ofs ); + + // `NewellNormal()` currently has a relatively strange interface and need to + // re-structure things a bit to meet them. + size_t vidx = std::accumulate(vertcnt.begin(),begin,0); + for(iit = begin; iit != end; vidx += *iit++) { + if (!*iit) { + normals.push_back(IfcVector3()); + continue; + } + for(size_t vofs = 0, cnt = 0; vofs < *iit; ++vofs) { + const IfcVector3& v = verts[vidx+vofs]; + temp[cnt++] = v.x; + temp[cnt++] = v.y; + temp[cnt++] = v.z; +#ifdef _DEBUG + temp[cnt] = std::numeric_limits::quiet_NaN(); +#endif + ++cnt; + } + + normals.push_back(IfcVector3()); + NewellNormal<4,4,4>(normals.back(),*iit,&temp[0],&temp[1],&temp[2]); + } + + if(normalize) { + BOOST_FOREACH(IfcVector3& n, normals) { + n.Normalize(); + } + } +} + +// ------------------------------------------------------------------------------------------------ +// Compute the normal of the last polygon in the given mesh +IfcVector3 TempMesh::ComputeLastPolygonNormal(bool normalize) const +{ + size_t total = vertcnt.back(), vidx = verts.size() - total; + std::vector temp((total+2)*3); + for(size_t vofs = 0, cnt = 0; vofs < total; ++vofs) { + const IfcVector3& v = verts[vidx+vofs]; + temp[cnt++] = v.x; + temp[cnt++] = v.y; + temp[cnt++] = v.z; + } + IfcVector3 nor; + NewellNormal<3,3,3>(nor,total,&temp[0],&temp[1],&temp[2]); + return normalize ? nor.Normalize() : nor; +} + +// ------------------------------------------------------------------------------------------------ +void TempMesh::FixupFaceOrientation() +{ + const IfcVector3 vavg = Center(); + + std::vector normals; + ComputePolygonNormals(normals); + + size_t c = 0, ofs = 0; + BOOST_FOREACH(unsigned int cnt, vertcnt) { + if (cnt>2){ + const IfcVector3& thisvert = verts[c]; + if (normals[ofs]*(thisvert-vavg) < 0) { + std::reverse(verts.begin()+c,verts.begin()+cnt+c); + } + } + c += cnt; + ++ofs; + } +} + // ------------------------------------------------------------------------------------------------ void TempMesh::RemoveAdjacentDuplicates() { @@ -189,7 +307,7 @@ void TempMesh::RemoveAdjacentDuplicates() base += cnt; } if(drop) { - IFCImporter::LogDebug("removed duplicate vertices"); + IFCImporter::LogDebug("removing duplicate vertices"); } } diff --git a/code/IFCUtil.h b/code/IFCUtil.h index a8fe6f680..aa835f270 100644 --- a/code/IFCUtil.h +++ b/code/IFCUtil.h @@ -76,12 +76,27 @@ struct delete_fun struct TempMesh; struct TempOpening { - const IFC::IfcExtrudedAreaSolid* solid; + const IFC::IfcSolidModel* solid; IfcVector3 extrusionDir; boost::shared_ptr profileMesh; + // list of points generated for this opening. This is used to + // create connections between two opposing holes created + // from a single opening instance (two because walls tend to + // have two sides). If !empty(), the other side of the wall + // has already been processed. + std::vector wallPoints; + // ------------------------------------------------------------------------------ - TempOpening(const IFC::IfcExtrudedAreaSolid* solid,IfcVector3 extrusionDir,boost::shared_ptr profileMesh) + TempOpening() + : solid() + , extrusionDir() + , profileMesh() + { + } + + // ------------------------------------------------------------------------------ + TempOpening(const IFC::IfcSolidModel* solid,IfcVector3 extrusionDir,boost::shared_ptr profileMesh) : solid(solid) , extrusionDir(extrusionDir) , profileMesh(profileMesh) @@ -168,7 +183,19 @@ struct TempMesh void Transform(const IfcMatrix4& mat); IfcVector3 Center() const; void Append(const TempMesh& other); + + bool IsEmpty() const { + return verts.empty() && vertcnt.empty(); + } + void RemoveAdjacentDuplicates(); + void RemoveDegenerates(); + + void FixupFaceOrientation(); + IfcVector3 ComputeLastPolygonNormal(bool normalize = true) const; + void ComputePolygonNormals(std::vector& normals, + bool normalize = true, + size_t ofs = 0) const; }; diff --git a/code/IRRLoader.cpp b/code/IRRLoader.cpp index 253b333f4..eab7d3eee 100644 --- a/code/IRRLoader.cpp +++ b/code/IRRLoader.cpp @@ -45,6 +45,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "AssimpPCH.h" +#ifndef ASSIMP_BUILD_NO_IRR_IMPORTER + #include "IRRLoader.h" #include "ParsingUtils.h" #include "fast_atof.h" @@ -1471,3 +1473,5 @@ void IRRImporter::InternReadFile( const std::string& pFile, */ return; } + +#endif // !! ASSIMP_BUILD_NO_IRR_IMPORTER diff --git a/code/IRRMeshLoader.cpp b/code/IRRMeshLoader.cpp index 84f7169c7..b27b2eaac 100644 --- a/code/IRRMeshLoader.cpp +++ b/code/IRRMeshLoader.cpp @@ -43,6 +43,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "AssimpPCH.h" +#ifndef ASSIMP_BUILD_NO_IRR_IMPORTER + #include "IRRMeshLoader.h" #include "ParsingUtils.h" #include "fast_atof.h" @@ -509,3 +511,5 @@ void IRRMeshImporter::InternReadFile( const std::string& pFile, delete reader; AI_DEBUG_INVALIDATE_PTR(reader); } + +#endif // !! ASSIMP_BUILD_NO_IRR_IMPORTER diff --git a/code/IRRShared.cpp b/code/IRRShared.cpp index f3faff878..bd95de1d1 100644 --- a/code/IRRShared.cpp +++ b/code/IRRShared.cpp @@ -45,6 +45,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "AssimpPCH.h" +#ifndef ASSIMP_BUILD_NO_IRR_IMPORTER + #include "IRRShared.h" #include "ParsingUtils.h" #include "fast_atof.h" @@ -494,3 +496,5 @@ aiMaterial* IrrlichtBase::ParseMaterial(unsigned int& matFlags) DefaultLogger::get()->error("IRRMESH: Unexpected end of file. Material is not complete"); return mat; } + +#endif // !! ASSIMP_BUILD_NO_IRR_IMPORTER diff --git a/code/LWSLoader.cpp b/code/LWSLoader.cpp index 91c3bc6a3..cfd72766b 100644 --- a/code/LWSLoader.cpp +++ b/code/LWSLoader.cpp @@ -44,6 +44,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "AssimpPCH.h" +#ifndef ASSIMP_BUILD_NO_LWS_IMPORTER #include "LWSLoader.h" #include "ParsingUtils.h" @@ -918,3 +919,5 @@ void LWSImporter::InternReadFile( const std::string& pFile, aiScene* pScene, } } + +#endif // !! ASSIMP_BUILD_NO_LWS_IMPORTER diff --git a/code/ObjFileData.h b/code/ObjFileData.h index 0075fd58f..51a2088f1 100644 --- a/code/ObjFileData.h +++ b/code/ObjFileData.h @@ -310,7 +310,7 @@ struct Model m_Groups.clear(); for ( std::map::iterator it = m_MaterialMap.begin(); it != m_MaterialMap.end(); ++it ) { -// delete it->second; + delete it->second; } } }; diff --git a/code/OgreImporter.cpp b/code/OgreImporter.cpp index c16cfc0f0..72141e437 100644 --- a/code/OgreImporter.cpp +++ b/code/OgreImporter.cpp @@ -100,7 +100,7 @@ void OgreImporter::InternReadFile(const std::string &pFile, aiScene *pScene, Ass //Read the Mesh File: boost::scoped_ptr mIOWrapper( new CIrrXML_IOStreamReader( file.get())); - XmlReader* MeshFile = irr::io::createIrrXMLReader(mIOWrapper.get()); + boost::scoped_ptr MeshFile(irr::io::createIrrXMLReader(mIOWrapper.get())); if(!MeshFile)//parse the xml file throw DeadlyImportError("Failed to create XML Reader for "+pFile); @@ -108,21 +108,21 @@ void OgreImporter::InternReadFile(const std::string &pFile, aiScene *pScene, Ass DefaultLogger::get()->debug("Mesh File opened"); //Read root Node: - if(!(XmlRead(MeshFile) && string(MeshFile->getNodeName())=="mesh")) + if(!(XmlRead(MeshFile.get()) && string(MeshFile->getNodeName())=="mesh")) { throw DeadlyImportError("Root Node is not ! "+pFile+" "+MeshFile->getNodeName()); } //eventually load shared geometry - XmlRead(MeshFile);//shared geometry is optional, so we need a reed for the next two if's + XmlRead(MeshFile.get());//shared geometry is optional, so we need a reed for the next two if's if(MeshFile->getNodeName()==string("sharedgeometry")) { - unsigned int NumVertices=GetAttribute(MeshFile, "vertexcount");; + unsigned int NumVertices=GetAttribute(MeshFile.get(), "vertexcount");; - XmlRead(MeshFile); + XmlRead(MeshFile.get()); while(MeshFile->getNodeName()==string("vertexbuffer")) { - ReadVertexBuffer(m_SharedGeometry, MeshFile, NumVertices); + ReadVertexBuffer(m_SharedGeometry, MeshFile.get(), NumVertices); } } @@ -136,13 +136,13 @@ void OgreImporter::InternReadFile(const std::string &pFile, aiScene *pScene, Ass //-------------------Read the submeshs and materials:----------------------- std::list > SubMeshes; vector Materials; - XmlRead(MeshFile); + XmlRead(MeshFile.get()); while(MeshFile->getNodeName()==string("submesh")) { SubMesh* theSubMesh=new SubMesh(); - theSubMesh->MaterialName=GetAttribute(MeshFile, "material"); + theSubMesh->MaterialName=GetAttribute(MeshFile.get(), "material"); DefaultLogger::get()->debug("Loading Submehs with Material: "+theSubMesh->MaterialName); - ReadSubMesh(*theSubMesh, MeshFile); + ReadSubMesh(*theSubMesh, MeshFile.get()); //just a index in a array, we add a mesh in each loop cycle, so we get indicies like 0, 1, 2 ... n; //so it is important to do this before pushing the mesh in the vector! @@ -170,9 +170,9 @@ void OgreImporter::InternReadFile(const std::string &pFile, aiScene *pScene, Ass vector Animations; if(MeshFile->getNodeName()==string("skeletonlink")) { - string SkeletonFile=GetAttribute(MeshFile, "name"); + string SkeletonFile=GetAttribute(MeshFile.get(), "name"); LoadSkeleton(SkeletonFile, Bones, Animations); - XmlRead(MeshFile); + XmlRead(MeshFile.get()); } else { @@ -185,7 +185,7 @@ void OgreImporter::InternReadFile(const std::string &pFile, aiScene *pScene, Ass //now there might be boneassignments for the shared geometry: if(MeshFile->getNodeName()==string("boneassignments")) { - ReadBoneWeights(m_SharedGeometry, MeshFile); + ReadBoneWeights(m_SharedGeometry, MeshFile.get()); } diff --git a/code/OgreMaterial.cpp b/code/OgreMaterial.cpp index 95ca1cf42..48ab75523 100644 --- a/code/OgreMaterial.cpp +++ b/code/OgreMaterial.cpp @@ -148,12 +148,22 @@ aiMaterial* OgreImporter::LoadMaterial(const std::string MaterialName) const } } } + //Fill the stream boost::scoped_ptr MaterialFile(MatFilePtr); - vector FileData(MaterialFile->FileSize()); - MaterialFile->Read(&FileData[0], MaterialFile->FileSize(), 1); - BaseImporter::ConvertToUTF8(FileData); + if(MaterialFile->FileSize()>0) + { + vector FileData(MaterialFile->FileSize()); + MaterialFile->Read(&FileData[0], MaterialFile->FileSize(), 1); + BaseImporter::ConvertToUTF8(FileData); - ss << &FileData[0]; + FileData.push_back('\0');//terminate the string with zero, so that the ss can parse it correctly + ss << &FileData[0]; + } + else + { + DefaultLogger::get()->warn("Material " + MaterialName + " seams to be empty"); + return NULL; + } } //create the material diff --git a/code/Q3BSPFileImporter.cpp b/code/Q3BSPFileImporter.cpp index 28b04a59b..6ea67305a 100644 --- a/code/Q3BSPFileImporter.cpp +++ b/code/Q3BSPFileImporter.cpp @@ -640,6 +640,7 @@ bool Q3BSPFileImporter::importTextureFromArchive( const Q3BSP::Q3BSPModel *pMode std::vector supportedExtensions; supportedExtensions.push_back( ".jpg" ); supportedExtensions.push_back( ".png" ); + supportedExtensions.push_back( ".tga" ); if ( NULL == pArchive || NULL == pArchive || NULL == pMatHelper ) { return false; @@ -670,10 +671,10 @@ bool Q3BSPFileImporter::importTextureFromArchive( const Q3BSP::Q3BSPModel *pMode (void)readSize; ai_assert( readSize == pTexture->mWidth ); pTexture->pcData = reinterpret_cast( pData ); - pTexture->achFormatHint[ 0 ] = ext[ 0 ]; - pTexture->achFormatHint[ 1 ] = ext[ 1 ]; - pTexture->achFormatHint[ 2 ] = ext[ 2 ]; - pTexture->achFormatHint[ 2 ] = '\0'; + pTexture->achFormatHint[ 0 ] = ext[ 1 ]; + pTexture->achFormatHint[ 1 ] = ext[ 2 ]; + pTexture->achFormatHint[ 2 ] = ext[ 3 ]; + pTexture->achFormatHint[ 3 ] = '\0'; res = true; aiString name; diff --git a/code/Q3BSPFileParser.cpp b/code/Q3BSPFileParser.cpp index 57382c68c..600a20f2b 100644 --- a/code/Q3BSPFileParser.cpp +++ b/code/Q3BSPFileParser.cpp @@ -38,6 +38,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ---------------------------------------------------------------------- */ #include "AssimpPCH.h" + +#ifndef ASSIMP_BUILD_NO_Q3BSP_IMPORTER + #include "Q3BSPFileParser.h" #include "DefaultIOSystem.h" #include "Q3BSPFileData.h" @@ -273,3 +276,5 @@ void Q3BSPFileParser::getEntities() // ------------------------------------------------------------------------------------------------ } // Namespace Assimp + +#endif // ASSIMP_BUILD_NO_Q3BSP_IMPORTER diff --git a/code/Q3BSPZipArchive.cpp b/code/Q3BSPZipArchive.cpp index 4d80352ed..e01ed3fec 100644 --- a/code/Q3BSPZipArchive.cpp +++ b/code/Q3BSPZipArchive.cpp @@ -39,6 +39,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "AssimpPCH.h" + +#ifndef ASSIMP_BUILD_NO_Q3BSP_IMPORTER + #include "Q3BSPZipArchive.h" #include #include @@ -194,3 +197,5 @@ bool Q3BSPZipArchive::mapArchive() } // Namespace Q3BSP } // Namespace Assimp + +#endif // ASSIMP_BUILD_NO_Q3BSP_IMPORTER diff --git a/code/SMDLoader.cpp b/code/SMDLoader.cpp index 3abe862fe..2bc73abec 100644 --- a/code/SMDLoader.cpp +++ b/code/SMDLoader.cpp @@ -684,7 +684,7 @@ void SMDImporter::ParseFile() const char* szCurrent = mBuffer; // read line per line ... - while (true) + for ( ;; ) { if(!SkipSpacesAndLineEnd(szCurrent,&szCurrent)) break; @@ -750,7 +750,7 @@ unsigned int SMDImporter::GetTextureIndex(const std::string& filename) void SMDImporter::ParseNodesSection(const char* szCurrent, const char** szCurrentOut) { - while (true) + for ( ;; ) { // "end\n" - Ends the nodes section if (0 == ASSIMP_strincmp(szCurrent,"end",3) && @@ -772,7 +772,7 @@ void SMDImporter::ParseTrianglesSection(const char* szCurrent, { // Parse a triangle, parse another triangle, parse the next triangle ... // and so on until we reach a token that looks quite similar to "end" - while (true) + for ( ;; ) { if(!SkipSpacesAndLineEnd(szCurrent,&szCurrent)) break; @@ -790,7 +790,7 @@ void SMDImporter::ParseVASection(const char* szCurrent, const char** szCurrentOut) { unsigned int iCurIndex = 0; - while (true) + for ( ;; ) { if(!SkipSpacesAndLineEnd(szCurrent,&szCurrent)) break; @@ -833,7 +833,7 @@ void SMDImporter::ParseSkeletonSection(const char* szCurrent, const char** szCurrentOut) { int iTime = 0; - while (true) + for ( ;; ) { if(!SkipSpacesAndLineEnd(szCurrent,&szCurrent)) break; @@ -887,7 +887,7 @@ void SMDImporter::ParseNodeInfo(const char* szCurrent, else ++szCurrent; const char* szEnd = szCurrent; - while (true) + for ( ;; ) { if (bQuota && '\"' == *szEnd) { diff --git a/code/STEPFile.h b/code/STEPFile.h index f958956bc..3c63bd700 100644 --- a/code/STEPFile.h +++ b/code/STEPFile.h @@ -192,19 +192,19 @@ namespace STEP { } // utilities to deal with SELECT entities, which currently lack automatic - // conversion support. - template - const T& ResolveSelect(const DB& db) const { - return Couple(db).MustGetObject(To())->To(); - } - - template - const T* ResolveSelectPtr(const DB& db) const { - const EXPRESS::ENTITY* e = ToPtr(); - return e?Couple(db).MustGetObject(*e)->ToPtr():(const T*)0; - } - - public: + // conversion support. + template + const T& ResolveSelect(const DB& db) const { + return Couple(db).MustGetObject(To())->template To(); + } + + template + const T* ResolveSelectPtr(const DB& db) const { + const EXPRESS::ENTITY* e = ToPtr(); + return e?Couple(db).MustGetObject(*e)->template ToPtr():(const T*)0; + } + + public: /** parse a variable from a string and set 'inout' to the character * behind the last consumed character. An optional schema enables, diff --git a/code/STEPFileReader.cpp b/code/STEPFileReader.cpp index 66e08fcb5..c812187fb 100644 --- a/code/STEPFileReader.cpp +++ b/code/STEPFileReader.cpp @@ -160,6 +160,30 @@ STEP::DB* STEP::ReadFileHeader(boost::shared_ptr stream) } +namespace { + +// ------------------------------------------------------------------------------------------------ +// check whether the given line contains an entity definition (i.e. starts with "#=") +bool IsEntityDef(const std::string& snext) +{ + if (snext[0] == '#') { + // it is only a new entity if it has a '=' after the + // entity ID. + for(std::string::const_iterator it = snext.begin()+1; it != snext.end(); ++it) { + if (*it == '=') { + return true; + } + if (*it < '0' || *it > '9') { + break; + } + } + } + return false; +} + +} + + // ------------------------------------------------------------------------------------------------ void STEP::ReadFile(DB& db,const EXPRESS::ConversionSchema& scheme, const char* const* types_to_track, size_t len, @@ -171,8 +195,9 @@ void STEP::ReadFile(DB& db,const EXPRESS::ConversionSchema& scheme, const DB::ObjectMap& map = db.GetObjects(); LineSplitter& splitter = db.GetSplitter(); - for(; splitter; ++splitter) { - const std::string& s = *splitter; + while (splitter) { + bool has_next = false; + std::string s = *splitter; if (s == "ENDSEC;") { break; } @@ -184,6 +209,7 @@ void STEP::ReadFile(DB& db,const EXPRESS::ConversionSchema& scheme, ai_assert(s.length()); if (s[0] != '#') { DefaultLogger::get()->warn(AddLineNumber("expected token \'#\'",line)); + ++splitter; continue; } @@ -195,25 +221,75 @@ void STEP::ReadFile(DB& db,const EXPRESS::ConversionSchema& scheme, const std::string::size_type n0 = s.find_first_of('='); if (n0 == std::string::npos) { DefaultLogger::get()->warn(AddLineNumber("expected token \'=\'",line)); + ++splitter; continue; } const uint64_t id = strtoul10_64(s.substr(1,n0-1).c_str()); if (!id) { DefaultLogger::get()->warn(AddLineNumber("expected positive, numeric entity id",line)); + ++splitter; continue; } - const std::string::size_type n1 = s.find_first_of('(',n0); + std::string::size_type n1 = s.find_first_of('(',n0); if (n1 == std::string::npos) { - DefaultLogger::get()->warn(AddLineNumber("expected token \'(\'",line)); - continue; + + has_next = true; + bool ok = false; + + for( ++splitter; splitter; ++splitter) { + const std::string& snext = *splitter; + if (snext.empty()) { + continue; + } + + // the next line doesn't start an entity, so maybe it is + // just a continuation for this line, keep going + if (!IsEntityDef(snext)) { + s.append(snext); + n1 = s.find_first_of('(',n0); + ok = (n1 != std::string::npos); + } + else { + break; + } + } + + if(!ok) { + DefaultLogger::get()->warn(AddLineNumber("expected token \'(\'",line)); + continue; + } } - const std::string::size_type n2 = s.find_last_of(')'); - if (n2 == std::string::npos || n2 < n1) { - DefaultLogger::get()->warn(AddLineNumber("expected token \')\'",line)); - continue; + std::string::size_type n2 = s.find_last_of(')'); + if (n2 == std::string::npos || n2 < n1 || n2 == s.length() - 1 || s[n2 + 1] != ';') { + + has_next = true; + bool ok = false; + + for( ++splitter; splitter; ++splitter) { + const std::string& snext = *splitter; + if (snext.empty()) { + continue; + } + + // the next line doesn't start an entity, so maybe it is + // just a continuation for this line, keep going + if (!IsEntityDef(snext)) { + s.append(snext); + n2 = s.find_last_of(')'); + ok = !(n2 == std::string::npos || n2 < n1 || n2 == s.length() - 1 || s[n2 + 1] != ';'); + } + else { + break; + } + } + + if(!ok) { + DefaultLogger::get()->warn(AddLineNumber("expected token \')\'",line)); + continue; + } } if (map.find(id) != map.end()) { @@ -239,6 +315,10 @@ void STEP::ReadFile(DB& db,const EXPRESS::ConversionSchema& scheme, db.InternInsert(new LazyObject(db,id,line,sz,copysz)); } + + if(!has_next) { + ++splitter; + } } if (!splitter) { diff --git a/code/STLLoader.cpp b/code/STLLoader.cpp index e96d38397..2c43b8258 100644 --- a/code/STLLoader.cpp +++ b/code/STLLoader.cpp @@ -203,7 +203,7 @@ void STLImporter::LoadASCIIFile() pMesh->mNormals = new aiVector3D[pMesh->mNumVertices]; unsigned int curFace = 0, curVertex = 3; - while (true) + for ( ;; ) { // go to the next token if(!SkipSpacesAndLineEnd(&sz)) diff --git a/code/StringComparison.h b/code/StringComparison.h index ca6f3e87f..0743c41be 100644 --- a/code/StringComparison.h +++ b/code/StringComparison.h @@ -87,7 +87,7 @@ inline unsigned int ASSIMP_itoa10( char* out, unsigned int max, int32_t number) // print all future zeroes from now mustPrint = true; - *out++ = '0'+digit; + *out++ = '0'+static_cast(digit); ++written; number -= digit*cur; diff --git a/code/TriangulateProcess.cpp b/code/TriangulateProcess.cpp index 05c7eb979..15c74277c 100644 --- a/code/TriangulateProcess.cpp +++ b/code/TriangulateProcess.cpp @@ -188,6 +188,8 @@ bool TriangulateProcess::TriangulateMesh( aiMesh* pMesh) FILE* fout = fopen(POLY_OUTPUT_FILE,"a"); #endif + const aiVector3D* verts = pMesh->mVertices; + // use boost::scoped_array to avoid slow std::vector specialiations boost::scoped_array done(new bool[max_out]); for( unsigned int a = 0; a < pMesh->mNumFaces; a++) { @@ -216,24 +218,59 @@ bool TriangulateProcess::TriangulateMesh( aiMesh* pMesh) face.mIndices = NULL; continue; - } /* does not handle concave quads + } // optimized code for quadrilaterals else if ( face.mNumIndices == 4) { + + // quads can have at maximum one concave vertex. Determine + // this vertex (if it exists) and start tri-fanning from + // it. + unsigned int start_vertex = 0; + for (unsigned int i = 0; i < 4; ++i) { + const aiVector3D& v0 = verts[face.mIndices[(i+3) % 4]]; + const aiVector3D& v1 = verts[face.mIndices[(i+2) % 4]]; + const aiVector3D& v2 = verts[face.mIndices[(i+1) % 4]]; + + const aiVector3D& v = verts[face.mIndices[i]]; + + aiVector3D left = (v0-v); + aiVector3D diag = (v1-v); + aiVector3D right = (v2-v); + + left.Normalize(); + diag.Normalize(); + right.Normalize(); + + const float angle = acos(left*diag) + acos(right*diag); + if (angle > AI_MATH_PI_F) { + // this is the concave point + start_vertex = i; + break; + } + } + + const unsigned int temp[] = {face.mIndices[0], face.mIndices[1], face.mIndices[2], face.mIndices[3]}; + aiFace& nface = *curOut++; nface.mNumIndices = 3; nface.mIndices = face.mIndices; + nface.mIndices[0] = temp[start_vertex]; + nface.mIndices[1] = temp[(start_vertex + 1) % 4]; + nface.mIndices[2] = temp[(start_vertex + 2) % 4]; + aiFace& sface = *curOut++; sface.mNumIndices = 3; sface.mIndices = new unsigned int[3]; - sface.mIndices[0] = face.mIndices[0]; - sface.mIndices[1] = face.mIndices[2]; - sface.mIndices[2] = face.mIndices[3]; - + sface.mIndices[0] = temp[start_vertex]; + sface.mIndices[1] = temp[(start_vertex + 2) % 4]; + sface.mIndices[2] = temp[(start_vertex + 3) % 4]; + + // prevent double deletion of the indices field face.mIndices = NULL; continue; - } */ + } else { // A polygon with more than 3 vertices can be either concave or convex. @@ -246,7 +283,6 @@ bool TriangulateProcess::TriangulateMesh( aiMesh* pMesh) // We project it onto a plane to get a 2d triangle. // Collect all vertices of of the polygon. - const aiVector3D* verts = pMesh->mVertices; for (tmp = 0; tmp < max; ++tmp) { temp_verts3d[tmp] = verts[idx[tmp]]; } diff --git a/code/XFileImporter.cpp b/code/XFileImporter.cpp index b763489f5..d636e6954 100644 --- a/code/XFileImporter.cpp +++ b/code/XFileImporter.cpp @@ -52,7 +52,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. using namespace Assimp; static const aiImporterDesc desc = { - "Collada Importer", + "Direct3D XFile Importer", "", "", "", @@ -594,8 +594,9 @@ void XFileImporter::ConvertMaterials( aiScene* pScene, const std::vectorAddProperty( &shadeMode, 1, AI_MATKEY_SHADING_MODEL); // material colours - // FIX: Setup this as ambient not as emissive color - mat->AddProperty( &oldMat.mEmissive, 1, AI_MATKEY_COLOR_AMBIENT); + // Unclear: there's no ambient colour, but emissive. What to put for ambient? + // Probably nothing at all, let the user select a suitable default. + mat->AddProperty( &oldMat.mEmissive, 1, AI_MATKEY_COLOR_EMISSIVE); mat->AddProperty( &oldMat.mDiffuse, 1, AI_MATKEY_COLOR_DIFFUSE); mat->AddProperty( &oldMat.mSpecular, 1, AI_MATKEY_COLOR_SPECULAR); mat->AddProperty( &oldMat.mSpecularExponent, 1, AI_MATKEY_SHININESS); diff --git a/code/XFileParser.cpp b/code/XFileParser.cpp index 73914c516..018be3102 100644 --- a/code/XFileParser.cpp +++ b/code/XFileParser.cpp @@ -460,7 +460,7 @@ void XFileParser::ParseDataObjectMesh( Mesh* pMesh) Face& face = pMesh->mPosFaces[a]; for( unsigned int b = 0; b < numIndices; b++) face.mIndices.push_back( ReadInt()); - CheckForSeparator(); + TestForSeparator(); } // here, other data objects may follow @@ -583,7 +583,7 @@ void XFileParser::ParseDataObjectMeshNormals( Mesh* pMesh) for( unsigned int b = 0; b < numIndices; b++) face.mIndices.push_back( ReadInt()); - CheckForSeparator(); + TestForSeparator(); } CheckForClosingBrace(); diff --git a/contrib/clipper/clipper.cpp b/contrib/clipper/clipper.cpp index daea1d4b9..b9754e4eb 100644 --- a/contrib/clipper/clipper.cpp +++ b/contrib/clipper/clipper.cpp @@ -1,10 +1,10 @@ /******************************************************************************* * * * Author : Angus Johnson * -* Version : 4.6.3 * -* Date : 11 November 2011 * +* Version : 4.8.8 * +* Date : 30 August 2012 * * Website : http://www.angusj.com * -* Copyright : Angus Johnson 2010-2011 * +* Copyright : Angus Johnson 2010-2012 * * * * License: * * Use, modification & distribution is subject to Boost Software License Ver 1. * @@ -49,11 +49,10 @@ namespace ClipperLib { -static long64 const loRange = 1518500249; //sqrt(2^63 -1)/2 -static long64 const hiRange = 6521908912666391106LL; //sqrt(2^127 -1)/2 +static long64 const loRange = 0x3FFFFFFF; +static long64 const hiRange = 0x3FFFFFFFFFFFFFFFLL; static double const pi = 3.141592653589793238; enum Direction { dRightToLeft, dLeftToRight }; -enum RangeTest { rtLo, rtHi, rtError }; #define HORIZONTAL (-1.0E+40) #define TOLERANCE (1.0e-20) @@ -62,7 +61,7 @@ enum RangeTest { rtLo, rtHi, rtError }; inline long64 Abs(long64 val) { - if (val < 0) return -val; else return val; + return val < 0 ? -val : val; } //------------------------------------------------------------------------------ @@ -80,43 +79,47 @@ class Int128 Int128(long64 _lo = 0) { - hi = 0; - if (_lo < 0) { - lo = -_lo; - Negate(*this); - } else - lo = _lo; + lo = _lo; + if (lo < 0) hi = -1; else hi = 0; } Int128(const Int128 &val): hi(val.hi), lo(val.lo){} long64 operator = (const long64 &val) { - hi = 0; - lo = Abs(val); - if (val < 0) Negate(*this); + lo = val; + if (lo < 0) hi = -1; else hi = 0; return val; } bool operator == (const Int128 &val) const {return (hi == val.hi && lo == val.lo);} - bool operator != (const Int128 &val) const { return !(*this == val);} + bool operator != (const Int128 &val) const + { return !(*this == val);} bool operator > (const Int128 &val) const { - if (hi > val.hi) return true; - else if (hi < val.hi) return false; - else return ulong64(lo) > ulong64(val.lo); + if (hi != val.hi) + return hi > val.hi; + else + return lo > val.lo; } bool operator < (const Int128 &val) const { - if (hi < val.hi) return true; - else if (hi > val.hi) return false; - else return ulong64(lo) < ulong64(val.lo); + if (hi != val.hi) + return hi < val.hi; + else + return lo < val.lo; } + bool operator >= (const Int128 &val) const + { return !(*this < val);} + + bool operator <= (const Int128 &val) const + { return !(*this > val);} + Int128& operator += (const Int128 &rhs) { hi += rhs.hi; @@ -140,14 +143,28 @@ class Int128 return *this; } + //Int128 operator -() const + //{ + // Int128 result(*this); + // if (result.lo == 0) { + // if (result.hi != 0) result.hi = -1; + // } + // else { + // result.lo = -result.lo; + // result.hi = ~result.hi; + // } + // return result; + //} + Int128 operator - (const Int128 &rhs) const { Int128 result(*this); - result-= rhs; + result -= rhs; return result; } - Int128 operator * (const Int128 &rhs) const { + Int128 operator * (const Int128 &rhs) const + { if ( !(hi == 0 || hi == -1) || !(rhs.hi == 0 || rhs.hi == -1)) throw "Int128 operator*: overflow error"; bool negate = (hi < 0) != (rhs.hi < 0); @@ -225,25 +242,25 @@ class Int128 } //for bug testing ... - std::string AsString() const - { - std::string result; - unsigned char r = 0; - Int128 tmp(0), val(*this); - if (hi < 0) Negate(val); - result.resize(50); - std::string::size_type i = result.size() -1; - while (val.hi != 0 || val.lo != 0) - { - Div10(val, tmp, r); - result[i--] = char('0' + r); - val = tmp; - } - if (hi < 0) result[i--] = '-'; - result.erase(0,i+1); - if (result.size() == 0) result = "0"; - return result; - } + //std::string AsString() const + //{ + // std::string result; + // unsigned char r = 0; + // Int128 tmp(0), val(*this); + // if (hi < 0) Negate(val); + // result.resize(50); + // std::string::size_type i = result.size() -1; + // while (val.hi != 0 || val.lo != 0) + // { + // Div10(val, tmp, r); + // result[i--] = char('0' + r); + // val = tmp; + // } + // if (hi < 0) result[i--] = '-'; + // result.erase(0,i+1); + // if (result.size() == 0) result = "0"; + // return result; + //} private: long64 hi; @@ -251,79 +268,70 @@ private: static void Negate(Int128 &val) { - if (val.lo == 0) - { - if( val.hi == 0) return; - val.lo = ~val.lo; - val.hi = ~val.hi +1; + if (val.lo == 0) { + if (val.hi != 0) val.hi = -val.hi;; } - else - { - val.lo = ~val.lo +1; + else { + val.lo = -val.lo; val.hi = ~val.hi; } } //debugging only ... - void Div10(const Int128 val, Int128& result, unsigned char & remainder) const - { - remainder = 0; - result = 0; - for (int i = 63; i >= 0; --i) - { - if ((val.hi & ((long64)1 << i)) != 0) - remainder = char((remainder * 2) + 1); else - remainder *= char(2); - if (remainder >= 10) - { - result.hi += ((long64)1 << i); - remainder -= char(10); - } - } - for (int i = 63; i >= 0; --i) - { - if ((val.lo & ((long64)1 << i)) != 0) - remainder = char((remainder * 2) + 1); else - remainder *= char(2); - if (remainder >= 10) - { - result.lo += ((long64)1 << i); - remainder -= char(10); - } - } - } + //void Div10(const Int128 val, Int128& result, unsigned char & remainder) const + //{ + // remainder = 0; + // result = 0; + // for (int i = 63; i >= 0; --i) + // { + // if ((val.hi & ((long64)1 << i)) != 0) + // remainder = char((remainder * 2) + 1); else + // remainder *= char(2); + // if (remainder >= 10) + // { + // result.hi += ((long64)1 << i); + // remainder -= char(10); + // } + // } + // for (int i = 63; i >= 0; --i) + // { + // if ((val.lo & ((long64)1 << i)) != 0) + // remainder = char((remainder * 2) + 1); else + // remainder *= char(2); + // if (remainder >= 10) + // { + // result.lo += ((long64)1 << i); + // remainder -= char(10); + // } + // } + //} }; //------------------------------------------------------------------------------ //------------------------------------------------------------------------------ -RangeTest TestRange(const Polygon &pts) +bool FullRangeNeeded(const Polygon &pts) { - RangeTest result = rtLo; + bool result = false; for (Polygon::size_type i = 0; i < pts.size(); ++i) { if (Abs(pts[i].X) > hiRange || Abs(pts[i].Y) > hiRange) - return rtError; + throw "Coordinate exceeds range bounds."; else if (Abs(pts[i].X) > loRange || Abs(pts[i].Y) > loRange) - result = rtHi; + result = true; } return result; } //------------------------------------------------------------------------------ - + bool Orientation(const Polygon &poly) { int highI = (int)poly.size() -1; if (highI < 2) return false; - bool UseFullInt64Range = false; int j = 0, jplus, jminus; for (int i = 0; i <= highI; ++i) { - if (Abs(poly[i].X) > hiRange || Abs(poly[i].Y) > hiRange) - throw "Coordinate exceeds range bounds."; - if (Abs(poly[i].X) > loRange || Abs(poly[i].Y) > loRange) - UseFullInt64Range = true; if (poly[i].Y < poly[j].Y) continue; if ((poly[i].Y > poly[j].Y || poly[i].X < poly[j].X)) j = i; }; @@ -339,21 +347,30 @@ bool Orientation(const Polygon &poly) vec2.X = poly[jplus].X - poly[j].X; vec2.Y = poly[jplus].Y - poly[j].Y; - if (UseFullInt64Range) + if (Abs(vec1.X) > loRange || Abs(vec1.Y) > loRange || + Abs(vec2.X) > loRange || Abs(vec2.Y) > loRange) { + if (Abs(vec1.X) > hiRange || Abs(vec1.Y) > hiRange || + Abs(vec2.X) > hiRange || Abs(vec2.Y) > hiRange) + throw "Coordinate exceeds range bounds."; Int128 cross = Int128(vec1.X) * Int128(vec2.Y) - Int128(vec2.X) * Int128(vec1.Y); - return cross > 0; + return cross >= 0; } else - { - return (vec1.X * vec2.Y - vec2.X * vec1.Y) > 0; - } + return (vec1.X * vec2.Y - vec2.X * vec1.Y) >= 0; +} +//------------------------------------------------------------------------------ + +inline bool PointsEqual( const IntPoint &pt1, const IntPoint &pt2) +{ + return ( pt1.X == pt2.X && pt1.Y == pt2.Y ); } //------------------------------------------------------------------------------ bool Orientation(OutRec *outRec, bool UseFullInt64Range) { + //first make sure bottomPt is correctly assigned ... OutPt *opBottom = outRec->pts, *op = outRec->pts->next; while (op != outRec->pts) { @@ -364,28 +381,28 @@ bool Orientation(OutRec *outRec, bool UseFullInt64Range) } op = op->next; } + outRec->bottomPt = opBottom; + opBottom->idx = outRec->idx; - IntPoint vec1, vec2; - vec1.X = op->pt.X - op->prev->pt.X; - vec1.Y = op->pt.Y - op->prev->pt.Y; - vec2.X = op->next->pt.X - op->pt.X; - vec2.Y = op->next->pt.Y - op->pt.Y; + op = opBottom; + //find vertices either side of bottomPt (skipping duplicate points) .... + OutPt *opPrev = op->prev; + OutPt *opNext = op->next; + while (op != opPrev && PointsEqual(op->pt, opPrev->pt)) + opPrev = opPrev->prev; + while (op != opNext && PointsEqual(op->pt, opNext->pt)) + opNext = opNext->next; + + IntPoint ip1, ip2; + ip1.X = op->pt.X - opPrev->pt.X; + ip1.Y = op->pt.Y - opPrev->pt.Y; + ip2.X = opNext->pt.X - op->pt.X; + ip2.Y = opNext->pt.Y - op->pt.Y; if (UseFullInt64Range) - { - Int128 cross = Int128(vec1.X) * Int128(vec2.Y) - Int128(vec2.X) * Int128(vec1.Y); - return cross > 0; - } + return Int128(ip1.X) * Int128(ip2.Y) - Int128(ip2.X) * Int128(ip1.Y) >= 0; else - { - return (vec1.X * vec2.Y - vec2.X * vec1.Y) > 0; - } -} -//------------------------------------------------------------------------------ - -inline bool PointsEqual( const IntPoint &pt1, const IntPoint &pt2) -{ - return ( pt1.X == pt2.X && pt1.Y == pt2.Y ); + return (ip1.X * ip2.Y - ip2.X * ip1.Y) >= 0; } //------------------------------------------------------------------------------ @@ -393,21 +410,9 @@ double Area(const Polygon &poly) { int highI = (int)poly.size() -1; if (highI < 2) return 0; - bool UseFullInt64Range; - RangeTest rt = TestRange(poly); - switch (rt) { - case rtLo: - UseFullInt64Range = false; - break; - case rtHi: - UseFullInt64Range = true; - break; - default: - throw "Coordinate exceeds range bounds."; - } - if (UseFullInt64Range) { - Int128 a(0); + if (FullRangeNeeded(poly)) { + Int128 a; a = (Int128(poly[highI].X) * Int128(poly[0].Y)) - Int128(poly[0].X) * Int128(poly[highI].Y); for (int i = 0; i < highI; ++i) @@ -426,6 +431,30 @@ double Area(const Polygon &poly) } //------------------------------------------------------------------------------ +double Area(const OutRec &outRec, bool UseFullInt64Range) +{ + OutPt *op = outRec.pts; + if (UseFullInt64Range) { + Int128 a(0); + do { + a += (Int128(op->prev->pt.X) * Int128(op->pt.Y)) - + Int128(op->pt.X) * Int128(op->prev->pt.Y); + op = op->next; + } while (op != outRec.pts); + return a.AsDouble() / 2; + } + else + { + double a = 0; + do { + a += (op->prev->pt.X * op->pt.Y) - (op->pt.X * op->prev->pt.Y); + op = op->next; + } while (op != outRec.pts); + return a/2; + } +} +//------------------------------------------------------------------------------ + bool PointIsVertex(const IntPoint &pt, OutPt *pp) { OutPt *pp2 = pp; @@ -473,9 +502,7 @@ bool PointInPolygon(const IntPoint &pt, OutPt *pp, bool UseFullInt64Range) bool SlopesEqual(TEdge &e1, TEdge &e2, bool UseFullInt64Range) { - if (e1.ybot == e1.ytop) return (e2.ybot == e2.ytop); - else if (e1.xbot == e1.xtop) return (e2.xbot == e2.xtop); - else if (UseFullInt64Range) + if (UseFullInt64Range) return Int128(e1.ytop - e1.ybot) * Int128(e2.xtop - e2.xbot) == Int128(e1.xtop - e1.xbot) * Int128(e2.ytop - e2.ybot); else return (e1.ytop - e1.ybot)*(e2.xtop - e2.xbot) == @@ -486,9 +513,7 @@ bool SlopesEqual(TEdge &e1, TEdge &e2, bool UseFullInt64Range) bool SlopesEqual(const IntPoint pt1, const IntPoint pt2, const IntPoint pt3, bool UseFullInt64Range) { - if (pt1.Y == pt2.Y) return (pt2.Y == pt3.Y); - else if (pt1.X == pt2.X) return (pt2.X == pt3.X); - else if (UseFullInt64Range) + if (UseFullInt64Range) return Int128(pt1.Y-pt2.Y) * Int128(pt2.X-pt3.X) == Int128(pt1.X-pt2.X) * Int128(pt2.Y-pt3.Y); else return (pt1.Y-pt2.Y)*(pt2.X-pt3.X) == (pt1.X-pt2.X)*(pt2.Y-pt3.Y); @@ -498,9 +523,7 @@ bool SlopesEqual(const IntPoint pt1, const IntPoint pt2, bool SlopesEqual(const IntPoint pt1, const IntPoint pt2, const IntPoint pt3, const IntPoint pt4, bool UseFullInt64Range) { - if (pt1.Y == pt2.Y) return (pt3.Y == pt4.Y); - else if (pt1.X == pt2.X) return (pt3.X == pt4.X); - else if (UseFullInt64Range) + if (UseFullInt64Range) return Int128(pt1.Y-pt2.Y) * Int128(pt3.X-pt4.X) == Int128(pt1.X-pt2.X) * Int128(pt3.Y-pt4.Y); else return (pt1.Y-pt2.Y)*(pt3.X-pt4.X) == (pt1.X-pt2.X)*(pt3.Y-pt4.Y); @@ -509,17 +532,15 @@ bool SlopesEqual(const IntPoint pt1, const IntPoint pt2, double GetDx(const IntPoint pt1, const IntPoint pt2) { - if (pt1.Y == pt2.Y) return HORIZONTAL; - else return - (double)(pt2.X - pt1.X) / (double)(pt2.Y - pt1.Y); + return (pt1.Y == pt2.Y) ? + HORIZONTAL : (double)(pt2.X - pt1.X) / (double)(pt2.Y - pt1.Y); } //--------------------------------------------------------------------------- void SetDx(TEdge &e) { if (e.ybot == e.ytop) e.dx = HORIZONTAL; - else e.dx = - (double)(e.xtop - e.xbot) / (double)(e.ytop - e.ybot); + else e.dx = (double)(e.xtop - e.xbot) / (double)(e.ytop - e.ybot); } //--------------------------------------------------------------------------- @@ -541,15 +562,15 @@ void SwapPolyIndexes(TEdge &edge1, TEdge &edge2) inline long64 Round(double val) { - if ((val < 0)) return static_cast(val - 0.5); - else return static_cast(val + 0.5); + return (val < 0) ? + static_cast(val - 0.5) : static_cast(val + 0.5); } //------------------------------------------------------------------------------ long64 TopX(TEdge &edge, const long64 currentY) { - if( currentY == edge.ytop ) return edge.xtop; - return edge.xbot + Round(edge.dx *(currentY - edge.ybot)); + return ( currentY == edge.ytop ) ? + edge.xtop : edge.xbot + Round(edge.dx *(currentY - edge.ybot)); } //------------------------------------------------------------------------------ @@ -709,17 +730,60 @@ bool GetOverlapSegment(IntPoint pt1a, IntPoint pt1b, IntPoint pt2a, } //------------------------------------------------------------------------------ -OutPt* PolygonBottom(OutPt* pp) +bool FirstIsBottomPt(const OutPt* btmPt1, const OutPt* btmPt2) { + OutPt *p = btmPt1->prev; + while (PointsEqual(p->pt, btmPt1->pt) && (p != btmPt1)) p = p->prev; + double dx1p = std::fabs(GetDx(btmPt1->pt, p->pt)); + p = btmPt1->next; + while (PointsEqual(p->pt, btmPt1->pt) && (p != btmPt1)) p = p->next; + double dx1n = std::fabs(GetDx(btmPt1->pt, p->pt)); + + p = btmPt2->prev; + while (PointsEqual(p->pt, btmPt2->pt) && (p != btmPt2)) p = p->prev; + double dx2p = std::fabs(GetDx(btmPt2->pt, p->pt)); + p = btmPt2->next; + while (PointsEqual(p->pt, btmPt2->pt) && (p != btmPt2)) p = p->next; + double dx2n = std::fabs(GetDx(btmPt2->pt, p->pt)); + return (dx1p >= dx2p && dx1p >= dx2n) || (dx1n >= dx2p && dx1n >= dx2n); +} +//------------------------------------------------------------------------------ + +OutPt* GetBottomPt(OutPt *pp) +{ + OutPt* dups = 0; OutPt* p = pp->next; - OutPt* result = pp; while (p != pp) { - if (p->pt.Y > result->pt.Y) result = p; - else if (p->pt.Y == result->pt.Y && p->pt.X < result->pt.X) result = p; + if (p->pt.Y > pp->pt.Y) + { + pp = p; + dups = 0; + } + else if (p->pt.Y == pp->pt.Y && p->pt.X <= pp->pt.X) + { + if (p->pt.X < pp->pt.X) + { + dups = 0; + pp = p; + } else + { + if (p->next != pp && p->prev != pp) dups = p; + } + } p = p->next; } - return result; + if (dups) + { + //there appears to be at least 2 vertices at bottomPt so ... + while (dups != p) + { + if (!FirstIsBottomPt(p, dups)) pp = dups; + dups = dups->next; + while (!PointsEqual(dups->pt, pp->pt)) dups = dups->next; + } + } + return pp; } //------------------------------------------------------------------------------ @@ -805,11 +869,9 @@ bool ClipperBase::AddPolygon( const Polygon &pg, PolyType polyType) { if (Abs(pg[i].X) > maxVal || Abs(pg[i].Y) > maxVal) { - if (m_UseFullRange) + if (Abs(pg[i].X) > hiRange || Abs(pg[i].Y) > hiRange) throw "Coordinate exceeds range bounds"; maxVal = hiRange; - if (Abs(pg[i].X) > maxVal || Abs(pg[i].Y) > maxVal) - throw "Coordinate exceeds range bounds"; m_UseFullRange = true; } @@ -823,7 +885,7 @@ bool ClipperBase::AddPolygon( const Polygon &pg, PolyType polyType) if (j < 2) return false; len = j+1; - for (;;) + while (len > 2) { //nb: test for point equality before testing slopes ... if (PointsEqual(p[j], p[0])) j--; @@ -836,9 +898,8 @@ bool ClipperBase::AddPolygon( const Polygon &pg, PolyType polyType) for (int i = 2; i <= j; ++i) p[i-1] = p[i]; j--; } - //exit loop if nothing is changed or there are too few vertices ... - if (j == len-1 || j < 2) break; - len = j +1; + else break; + len--; } if (len < 3) return false; @@ -961,9 +1022,9 @@ TEdge* ClipperBase::AddBoundsToLML(TEdge *e) bool ClipperBase::AddPolygons(const Polygons &ppg, PolyType polyType) { - bool result = true; + bool result = false; for (Polygons::size_type i = 0; i < ppg.size(); ++i) - if (AddPolygon(ppg[i], polyType)) result = false; + if (AddPolygon(ppg[i], polyType)) result = true; return result; } //------------------------------------------------------------------------------ @@ -1116,6 +1177,7 @@ void Clipper::Reset() m_Scanbeam = 0; m_ActiveEdges = 0; m_SortedEdges = 0; + DisposeAllPolyPts(); LocalMinima* lm = m_MinimaList; while (lm) { @@ -1165,7 +1227,7 @@ bool PolySort(OutRec *or1, OutRec *or2) { if (or1->pts != or2->pts) { - if (or1->pts) return true; else return false; + return or1->pts ? true : false; } else return false; } @@ -1179,8 +1241,7 @@ bool PolySort(OutRec *or1, OutRec *or2) int result = i1 - i2; if (result == 0 && (or1->isHole != or2->isHole)) { - if (or1->isHole) return false; - else return true; + return or1->isHole ? false : true; } else return result < 0; } @@ -1250,6 +1311,11 @@ bool Clipper::ExecuteInternal(bool fixHoleLinkages) FixupOutPolygon(*outRec); if (!outRec->pts) continue; if (outRec->isHole && fixHoleLinkages) FixHoleLinkage(outRec); + + if (outRec->bottomPt == outRec->bottomFlag && + (Orientation(outRec, m_UseFullRange) != (Area(*outRec, m_UseFullRange) > 0))) + DisposeBottomPt(*outRec); + if (outRec->isHole == (m_ReverseOutput ^ Orientation(outRec, m_UseFullRange))) ReversePolyPtLinks(*outRec->pts); @@ -1310,10 +1376,10 @@ void Clipper::DisposeAllPolyPts(){ } //------------------------------------------------------------------------------ -void Clipper::DisposeOutRec(PolyOutList::size_type index, bool ignorePts) +void Clipper::DisposeOutRec(PolyOutList::size_type index) { OutRec *outRec = m_PolyOuts[index]; - if (!ignorePts && outRec->pts) DisposeOutPts(outRec->pts); + if (outRec->pts) DisposeOutPts(outRec->pts); delete outRec; m_PolyOuts[index] = 0; } @@ -1476,32 +1542,49 @@ bool Clipper::IsContributing(const TEdge& edge) const void Clipper::AddLocalMinPoly(TEdge *e1, TEdge *e2, const IntPoint &pt) { + TEdge *e, *prevE; if( NEAR_EQUAL(e2->dx, HORIZONTAL) || ( e1->dx > e2->dx ) ) { - AddOutPt( e1, e2, pt ); + AddOutPt( e1, pt ); e2->outIdx = e1->outIdx; e1->side = esLeft; e2->side = esRight; + e = e1; + if (e->prevInAEL == e2) + prevE = e2->prevInAEL; + else + prevE = e->prevInAEL; } else { - AddOutPt( e2, e1, pt ); + AddOutPt( e2, pt ); e1->outIdx = e2->outIdx; e1->side = esRight; e2->side = esLeft; + e = e2; + if (e->prevInAEL == e1) + prevE = e1->prevInAEL; + else + prevE = e->prevInAEL; } + if (prevE && prevE->outIdx >= 0 && + (TopX(*prevE, pt.Y) == TopX(*e, pt.Y)) && + SlopesEqual(*e, *prevE, m_UseFullRange)) + AddJoin(e, prevE, -1, -1); } //------------------------------------------------------------------------------ void Clipper::AddLocalMaxPoly(TEdge *e1, TEdge *e2, const IntPoint &pt) { - AddOutPt( e1, 0, pt ); + AddOutPt( e1, pt ); if( e1->outIdx == e2->outIdx ) { e1->outIdx = -1; e2->outIdx = -1; } - else - AppendPolygon( e1, e2 ); + else if (e1->outIdx < e2->outIdx) + AppendPolygon(e1, e2); + else + AppendPolygon(e2, e1); } //------------------------------------------------------------------------------ @@ -1620,12 +1703,6 @@ void Clipper::InsertLocalMinimaIntoAEL( const long64 botY) if( IsContributing(*lb) ) AddLocalMinPoly( lb, rb, IntPoint(lb->xcurr, m_CurrentLM->Y) ); - //if output polygons share an edge, they'll need joining later ... - if (lb->outIdx >= 0 && lb->prevInAEL && - lb->prevInAEL->outIdx >= 0 && lb->prevInAEL->xcurr == lb->xbot && - SlopesEqual(*lb, *lb->prevInAEL, m_UseFullRange)) - AddJoin(lb, lb->prevInAEL); - //if any output polygons share an edge, they'll need joining later ... if (rb->outIdx >= 0) { @@ -1818,10 +1895,8 @@ void Clipper::IntersectEdges(TEdge *e1, TEdge *e2, AddLocalMinPoly(e1, e2, pt); break; case ctDifference: - if ((e1->polyType == ptClip && e2->polyType == ptClip && - e1Wc2 > 0 && e2Wc2 > 0) || - (e1->polyType == ptSubject && e2->polyType == ptSubject && - e1Wc2 <= 0 && e2Wc2 <= 0)) + if (((e1->polyType == ptClip) && (e1Wc2 > 0) && (e2Wc2 > 0)) || + ((e1->polyType == ptSubject) && (e1Wc2 <= 0) && (e2Wc2 <= 0))) AddLocalMinPoly(e1, e2, pt); break; case ctXor: @@ -1862,24 +1937,6 @@ void Clipper::SetHoleState(TEdge *e, OutRec *outRec) } //------------------------------------------------------------------------------ -bool GetNextNonDupOutPt(OutPt* pp, OutPt*& next) -{ - next = pp->next; - while (next != pp && PointsEqual(pp->pt, next->pt)) - next = next->next; - return next != pp; -} -//------------------------------------------------------------------------------ - -bool GetPrevNonDupOutPt(OutPt* pp, OutPt*& prev) -{ - prev = pp->prev; - while (prev != pp && PointsEqual(pp->pt, prev->pt)) - prev = prev->prev; - return prev != pp; -} -//------------------------------------------------------------------------------ - OutRec* GetLowermostRec(OutRec *outRec1, OutRec *outRec2) { //work out which polygon fragment has the correct hole state ... @@ -1889,21 +1946,21 @@ OutRec* GetLowermostRec(OutRec *outRec1, OutRec *outRec2) else if (outPt1->pt.Y < outPt2->pt.Y) return outRec2; else if (outPt1->pt.X < outPt2->pt.X) return outRec1; else if (outPt1->pt.X > outPt2->pt.X) return outRec2; - else if (outRec1->bottomE2 == 0) return outRec2; - else if (outRec2->bottomE2 == 0) return outRec1; - else + else if (outPt1->next == outPt1) return outRec2; + else if (outPt2->next == outPt2) return outRec1; + else if (FirstIsBottomPt(outPt1, outPt2)) return outRec1; + else return outRec2; +} +//------------------------------------------------------------------------------ + +bool Param1RightOfParam2(OutRec* outRec1, OutRec* outRec2) +{ + do { - long64 y1 = std::max(outRec1->bottomE1->ybot, outRec1->bottomE2->ybot); - long64 y2 = std::max(outRec2->bottomE1->ybot, outRec2->bottomE2->ybot); - if (y2 == y1 || (y1 > outPt1->pt.Y && y2 > outPt1->pt.Y)) - { - double dx1 = std::max(outRec1->bottomE1->dx, outRec1->bottomE2->dx); - double dx2 = std::max(outRec2->bottomE1->dx, outRec2->bottomE2->dx); - if (dx2 > dx1) return outRec2; else return outRec1; - } - else if (y2 > y1) return outRec2; - else return outRec1; - } + outRec1 = outRec1->FirstLeft; + if (outRec1 == outRec2) return true; + } while (outRec1); + return false; } //------------------------------------------------------------------------------ @@ -1912,13 +1969,11 @@ void Clipper::AppendPolygon(TEdge *e1, TEdge *e2) //get the start and ends of both output polygons ... OutRec *outRec1 = m_PolyOuts[e1->outIdx]; OutRec *outRec2 = m_PolyOuts[e2->outIdx]; - OutRec *holeStateRec = GetLowermostRec(outRec1, outRec2); - //fixup hole status ... - if (holeStateRec == outRec2) - outRec1->isHole = outRec2->isHole; - else - outRec2->isHole = outRec1->isHole; + OutRec *holeStateRec; + if (Param1RightOfParam2(outRec1, outRec2)) holeStateRec = outRec2; + else if (Param1RightOfParam2(outRec2, outRec1)) holeStateRec = outRec1; + else holeStateRec = GetLowermostRec(outRec1, outRec2); OutPt* p1_lft = outRec1->pts; OutPt* p1_rt = p1_lft->prev; @@ -1973,11 +2028,9 @@ void Clipper::AppendPolygon(TEdge *e1, TEdge *e2) { outRec1->bottomPt = outRec2->bottomPt; outRec1->bottomPt->idx = outRec1->idx; - outRec1->bottomE1 = outRec2->bottomE1; - outRec1->bottomE2 = outRec2->bottomE2; - if (outRec2->FirstLeft != outRec1) outRec1->FirstLeft = outRec2->FirstLeft; + outRec1->isHole = outRec2->isHole; } outRec2->pts = 0; outRec2->bottomPt = 0; @@ -2023,11 +2076,27 @@ OutRec* Clipper::CreateOutRec() result->AppendLink = 0; result->pts = 0; result->bottomPt = 0; + result->sides = esNeither; + result->bottomFlag = 0; + return result; } //------------------------------------------------------------------------------ -void Clipper::AddOutPt(TEdge *e, TEdge *altE, const IntPoint &pt) +void Clipper::DisposeBottomPt(OutRec &outRec) +{ + OutPt* next = outRec.bottomPt->next; + OutPt* prev = outRec.bottomPt->prev; + if (outRec.pts == outRec.bottomPt) outRec.pts = next; + delete outRec.bottomPt; + next->prev = prev; + prev->next = next; + outRec.bottomPt = next; + FixupOutPolygon(outRec); +} +//------------------------------------------------------------------------------ + +void Clipper::AddOutPt(TEdge *e, const IntPoint &pt) { bool ToFront = (e->side == esLeft); if( e->outIdx < 0 ) @@ -2038,8 +2107,6 @@ void Clipper::AddOutPt(TEdge *e, TEdge *altE, const IntPoint &pt) e->outIdx = outRec->idx; OutPt* op = new OutPt; outRec->pts = op; - outRec->bottomE1 = e; - outRec->bottomE2 = altE; outRec->bottomPt = op; op->pt = pt; op->idx = outRec->idx; @@ -2052,16 +2119,59 @@ void Clipper::AddOutPt(TEdge *e, TEdge *altE, const IntPoint &pt) OutPt* op = outRec->pts; if ((ToFront && PointsEqual(pt, op->pt)) || (!ToFront && PointsEqual(pt, op->prev->pt))) return; + + if ((e->side | outRec->sides) != outRec->sides) + { + //check for 'rounding' artefacts ... + if (outRec->sides == esNeither && pt.Y == op->pt.Y) + if (ToFront) + { + if (pt.X == op->pt.X +1) return; //ie wrong side of bottomPt + } + else if (pt.X == op->pt.X -1) return; //ie wrong side of bottomPt + + outRec->sides = (EdgeSide)(outRec->sides | e->side); + if (outRec->sides == esBoth) + { + //A vertex from each side has now been added. + //Vertices of one side of an output polygon are quite commonly close to + //or even 'touching' edges of the other side of the output polygon. + //Very occasionally vertices from one side can 'cross' an edge on the + //the other side. The distance 'crossed' is always less that a unit + //and is purely an artefact of coordinate rounding. Nevertheless, this + //results in very tiny self-intersections. Because of the way + //orientation is calculated, even tiny self-intersections can cause + //the Orientation function to return the wrong result. Therefore, it's + //important to ensure that any self-intersections close to BottomPt are + //detected and removed before orientation is assigned. + + OutPt *opBot, *op2; + if (ToFront) + { + opBot = outRec->pts; + op2 = opBot->next; //op2 == right side + if (opBot->pt.Y != op2->pt.Y && opBot->pt.Y != pt.Y && + ((opBot->pt.X - pt.X)/(opBot->pt.Y - pt.Y) < + (opBot->pt.X - op2->pt.X)/(opBot->pt.Y - op2->pt.Y))) + outRec->bottomFlag = opBot; + } else + { + opBot = outRec->pts->prev; + op2 = opBot->prev; //op2 == left side + if (opBot->pt.Y != op2->pt.Y && opBot->pt.Y != pt.Y && + ((opBot->pt.X - pt.X)/(opBot->pt.Y - pt.Y) > + (opBot->pt.X - op2->pt.X)/(opBot->pt.Y - op2->pt.Y))) + outRec->bottomFlag = opBot; + } + } + } + OutPt* op2 = new OutPt; op2->pt = pt; op2->idx = outRec->idx; if (op2->pt.Y == outRec->bottomPt->pt.Y && op2->pt.X < outRec->bottomPt->pt.X) - { - outRec->bottomPt = op2; - outRec->bottomE1 = e; - outRec->bottomE2 = altE; - } + outRec->bottomPt = op2; op2->next = op; op2->prev = op->prev; op2->prev->next = op2; @@ -2216,8 +2326,7 @@ void Clipper::SwapPositionsInSEL(TEdge *edge1, TEdge *edge2) TEdge* GetNextInAEL(TEdge *e, Direction dir) { - if( dir == dLeftToRight ) return e->nextInAEL; - else return e->prevInAEL; + return dir == dLeftToRight ? e->nextInAEL : e->prevInAEL; } //------------------------------------------------------------------------------ @@ -2310,7 +2419,7 @@ void Clipper::ProcessHorizontal(TEdge *horzEdge) if( horzEdge->nextInLML ) { if( horzEdge->outIdx >= 0 ) - AddOutPt( horzEdge, 0, IntPoint(horzEdge->xtop, horzEdge->ytop)); + AddOutPt( horzEdge, IntPoint(horzEdge->xtop, horzEdge->ytop)); UpdateEdgeIntoAEL( horzEdge ); } else @@ -2426,7 +2535,7 @@ void Clipper::BuildIntersectList(const long64 botY, const long64 topY) } //------------------------------------------------------------------------------ -bool Process1Before2(IntersectNode &node1, IntersectNode &node2) +bool ProcessParam1BeforeParam2(IntersectNode &node1, IntersectNode &node2) { bool result; if (node1.pt.Y == node2.pt.Y) @@ -2434,12 +2543,12 @@ bool Process1Before2(IntersectNode &node1, IntersectNode &node2) if (node1.edge1 == node2.edge1 || node1.edge2 == node2.edge1) { result = node2.pt.X > node1.pt.X; - if (node2.edge1->dx > 0) return !result; else return result; + return node2.edge1->dx > 0 ? !result : result; } else if (node1.edge1 == node2.edge2 || node1.edge2 == node2.edge2) { result = node2.pt.X > node1.pt.X; - if (node2.edge2->dx > 0) return !result; else return result; + return node2.edge2->dx > 0 ? !result : result; } else return node2.pt.X > node1.pt.X; } @@ -2455,7 +2564,7 @@ void Clipper::AddIntersectNode(TEdge *e1, TEdge *e2, const IntPoint &pt) newNode->pt = pt; newNode->next = 0; if( !m_IntersectNodes ) m_IntersectNodes = newNode; - else if( Process1Before2(*newNode, *m_IntersectNodes) ) + else if( ProcessParam1BeforeParam2(*newNode, *m_IntersectNodes) ) { newNode->next = m_IntersectNodes; m_IntersectNodes = newNode; @@ -2463,7 +2572,7 @@ void Clipper::AddIntersectNode(TEdge *e1, TEdge *e2, const IntPoint &pt) else { IntersectNode* iNode = m_IntersectNodes; - while( iNode->next && Process1Before2(*iNode->next, *newNode) ) + while( iNode->next && ProcessParam1BeforeParam2(*iNode->next, *newNode) ) iNode = iNode->next; newNode->next = iNode->next; iNode->next = newNode; @@ -2533,7 +2642,7 @@ void Clipper::ProcessEdgesAtTopOfScanbeam(const long64 topY) { if (e->outIdx >= 0) { - AddOutPt(e, 0, IntPoint(e->xtop, e->ytop)); + AddOutPt(e, IntPoint(e->xtop, e->ytop)); for (HorzJoinList::size_type i = 0; i < m_HorizJoins.size(); ++i) { @@ -2569,7 +2678,7 @@ void Clipper::ProcessEdgesAtTopOfScanbeam(const long64 topY) { if( IsIntermediate( e, topY ) ) { - if( e->outIdx >= 0 ) AddOutPt(e, 0, IntPoint(e->xtop,e->ytop)); + if( e->outIdx >= 0 ) AddOutPt(e, IntPoint(e->xtop,e->ytop)); UpdateEdgeIntoAEL(e); //if output polygons share an edge, they'll need joining later ... @@ -2579,18 +2688,18 @@ void Clipper::ProcessEdgesAtTopOfScanbeam(const long64 topY) IntPoint(e->xbot,e->ybot), IntPoint(e->prevInAEL->xtop, e->prevInAEL->ytop), m_UseFullRange)) { - AddOutPt(e->prevInAEL, 0, IntPoint(e->xbot, e->ybot)); + AddOutPt(e->prevInAEL, IntPoint(e->xbot, e->ybot)); AddJoin(e, e->prevInAEL); } else if (e->outIdx >= 0 && e->nextInAEL && e->nextInAEL->outIdx >= 0 && e->nextInAEL->ycurr > e->nextInAEL->ytop && - e->nextInAEL->ycurr < e->nextInAEL->ybot && + e->nextInAEL->ycurr <= e->nextInAEL->ybot && e->nextInAEL->xcurr == e->xbot && e->nextInAEL->ycurr == e->ybot && SlopesEqual(IntPoint(e->xbot,e->ybot), IntPoint(e->xtop, e->ytop), IntPoint(e->xbot,e->ybot), IntPoint(e->nextInAEL->xtop, e->nextInAEL->ytop), m_UseFullRange)) { - AddOutPt(e->nextInAEL, 0, IntPoint(e->xbot, e->ybot)); + AddOutPt(e->nextInAEL, IntPoint(e->xbot, e->ybot)); AddJoin(e, e->nextInAEL); } } @@ -2623,13 +2732,7 @@ void Clipper::FixupOutPolygon(OutRec &outRec) lastOK = 0; OutPt *tmp = pp; if (pp == outRec.bottomPt) - { - if (tmp->prev->pt.Y > tmp->next->pt.Y) - outRec.bottomPt = tmp->prev; else - outRec.bottomPt = tmp->next; - outRec.pts = outRec.bottomPt; - outRec.bottomPt->idx = outRec.idx; - } + outRec.bottomPt = 0; //flags need for updating pp->prev->next = pp->next; pp->next->prev = pp->prev; pp = pp->prev; @@ -2642,6 +2745,11 @@ void Clipper::FixupOutPolygon(OutRec &outRec) pp = pp->next; } } + if (!outRec.bottomPt) { + outRec.bottomPt = GetBottomPt(pp); + outRec.bottomPt->idx = outRec.idx; + outRec.pts = outRec.bottomPt; + } } //------------------------------------------------------------------------------ @@ -2766,8 +2874,7 @@ bool Clipper::FixupIntersections() bool E2InsertsBeforeE1(TEdge &e1, TEdge &e2) { - if (e2.xcurr == e1.xcurr) return e2.dx > e1.dx; - else return e2.xcurr < e1.xcurr; + return e2.xcurr == e1.xcurr ? e2.dx > e1.dx : e2.xcurr < e1.xcurr; } //------------------------------------------------------------------------------ @@ -2799,7 +2906,7 @@ void Clipper::InsertEdgeIntoAEL(TEdge *edge) void Clipper::DoEdge1(TEdge *edge1, TEdge *edge2, const IntPoint &pt) { - AddOutPt(edge1, edge2, pt); + AddOutPt(edge1, pt); SwapSides(*edge1, *edge2); SwapPolyIndexes(*edge1, *edge2); } @@ -2807,7 +2914,7 @@ void Clipper::DoEdge1(TEdge *edge1, TEdge *edge2, const IntPoint &pt) void Clipper::DoEdge2(TEdge *edge1, TEdge *edge2, const IntPoint &pt) { - AddOutPt(edge2, edge1, pt); + AddOutPt(edge2, pt); SwapSides(*edge1, *edge2); SwapPolyIndexes(*edge1, *edge2); } @@ -2815,8 +2922,8 @@ void Clipper::DoEdge2(TEdge *edge1, TEdge *edge2, const IntPoint &pt) void Clipper::DoBothEdges(TEdge *edge1, TEdge *edge2, const IntPoint &pt) { - AddOutPt(edge1, edge2, pt); - AddOutPt(edge2, edge1, pt); + AddOutPt(edge1, pt); + AddOutPt(edge2, pt); SwapSides( *edge1 , *edge2 ); SwapPolyIndexes( *edge1 , *edge2 ); } @@ -2920,31 +3027,37 @@ void Clipper::JoinCommonEdges(bool fixHoleLinkages) { //instead of joining two polygons, we've just created a new one by //splitting one polygon into two. - outRec1->pts = PolygonBottom(p1); + outRec1->pts = GetBottomPt(p1); outRec1->bottomPt = outRec1->pts; outRec1->bottomPt->idx = outRec1->idx; outRec2 = CreateOutRec(); m_PolyOuts.push_back(outRec2); outRec2->idx = (int)m_PolyOuts.size()-1; j->poly2Idx = outRec2->idx; - outRec2->pts = PolygonBottom(p2); + outRec2->pts = GetBottomPt(p2); outRec2->bottomPt = outRec2->pts; outRec2->bottomPt->idx = outRec2->idx; if (PointInPolygon(outRec2->pts->pt, outRec1->pts, m_UseFullRange)) { + //outRec2 is contained by outRec1 ... outRec2->isHole = !outRec1->isHole; outRec2->FirstLeft = outRec1; - if (outRec2->isHole == Orientation(outRec2, m_UseFullRange)) - ReversePolyPtLinks(*outRec2->pts); + if (outRec2->isHole == + (m_ReverseOutput ^ Orientation(outRec2, m_UseFullRange))) + ReversePolyPtLinks(*outRec2->pts); } else if (PointInPolygon(outRec1->pts->pt, outRec2->pts, m_UseFullRange)) { + //outRec1 is contained by outRec2 ... outRec2->isHole = outRec1->isHole; outRec1->isHole = !outRec2->isHole; outRec2->FirstLeft = outRec1->FirstLeft; outRec1->FirstLeft = outRec2; - if (outRec1->isHole == Orientation(outRec1, m_UseFullRange)) - ReversePolyPtLinks(*outRec1->pts); + if (outRec1->isHole == + (m_ReverseOutput ^ Orientation(outRec1, m_UseFullRange))) + ReversePolyPtLinks(*outRec1->pts); + //make sure any contained holes now link to the correct polygon ... + if (fixHoleLinkages) CheckHoleLinkages1(outRec1, outRec2); } else { outRec2->isHole = outRec1->isHole; @@ -2966,6 +3079,12 @@ void Clipper::JoinCommonEdges(bool fixHoleLinkages) //now cleanup redundant edges too ... FixupOutPolygon(*outRec1); FixupOutPolygon(*outRec2); + + if (Orientation(outRec1, m_UseFullRange) != (Area(*outRec1, m_UseFullRange) > 0)) + DisposeBottomPt(*outRec1); + if (Orientation(outRec2, m_UseFullRange) != (Area(*outRec2, m_UseFullRange) > 0)) + DisposeBottomPt(*outRec2); + } else { //joined 2 polygons together ... @@ -2973,14 +3092,22 @@ void Clipper::JoinCommonEdges(bool fixHoleLinkages) //make sure any holes contained by outRec2 now link to outRec1 ... if (fixHoleLinkages) CheckHoleLinkages2(outRec1, outRec2); + //now cleanup redundant edges too ... + FixupOutPolygon(*outRec1); + + if (outRec1->pts) + { + outRec1->isHole = !Orientation(outRec1, m_UseFullRange); + if (outRec1->isHole && !outRec1->FirstLeft) + outRec1->FirstLeft = outRec2->FirstLeft; + } + //delete the obsolete pointer ... int OKIdx = outRec1->idx; int ObsoleteIdx = outRec2->idx; outRec2->pts = 0; outRec2->bottomPt = 0; outRec2->AppendLink = outRec1; - //holes are practically always joined to outers, not vice versa ... - if (outRec1->isHole && !outRec2->isHole) outRec1->isHole = false; //now fixup any subsequent Joins that match this polygon for (JoinList::size_type k = i+1; k < m_Joins.size(); k++) @@ -2989,27 +3116,21 @@ void Clipper::JoinCommonEdges(bool fixHoleLinkages) if (j2->poly1Idx == ObsoleteIdx) j2->poly1Idx = OKIdx; if (j2->poly2Idx == ObsoleteIdx) j2->poly2Idx = OKIdx; } - - //now cleanup redundant edges too ... - if (outRec1->pts) - FixupOutPolygon(*outRec1); - else - FixupOutPolygon(*outRec2); } } } //------------------------------------------------------------------------------ -void ReversePoints(Polygon& p) +void ReversePolygon(Polygon& p) { std::reverse(p.begin(), p.end()); } //------------------------------------------------------------------------------ -void ReversePoints(Polygons& p) +void ReversePolygons(Polygons& p) { for (Polygons::size_type i = 0; i < p.size(); ++i) - ReversePoints(p[i]); + ReversePolygon(p[i]); } //------------------------------------------------------------------------------ @@ -3027,12 +3148,13 @@ struct DoublePoint Polygon BuildArc(const IntPoint &pt, const double a1, const double a2, const double r) { - int steps = std::max(6, int(std::sqrt(std::fabs(r)) * std::fabs(a2 - a1))); - Polygon result(steps); - int n = steps - 1; - double da = (a2 - a1) / n; + long64 steps = std::max(6, int(std::sqrt(std::fabs(r)) * std::fabs(a2 - a1))); + if (steps > 0x100000) steps = 0x100000; + int n = (unsigned)steps; + Polygon result(n); + double da = (a2 - a1) / (n -1); double a = a1; - for (int i = 0; i <= n; ++i) + for (int i = 0; i < n; ++i) { result[i].X = pt.X + Round(std::cos(a)*r); result[i].Y = pt.Y + Round(std::sin(a)*r); @@ -3160,7 +3282,7 @@ PolyOffsetBuilder(const Polygons& in_polys, Polygons& out_polys, if (clpr.Execute(ctUnion, out_polys, pftNegative, pftNegative)) { out_polys.erase(out_polys.begin()); - ReversePoints(out_polys); + ReversePolygons(out_polys); } else out_polys.clear(); @@ -3187,23 +3309,23 @@ void DoSquare(double mul = 1.0) (long64)Round(m_p[m_i][m_j].Y + normals[m_j].Y * m_delta)); if ((normals[m_k].X * normals[m_j].Y - normals[m_j].X * normals[m_k].Y) * m_delta >= 0) { - double a1 = std::atan2(normals[m_k].Y, normals[m_k].X); - double a2 = std::atan2(-normals[m_j].Y, -normals[m_j].X); - a1 = std::fabs(a2 - a1); - if (a1 > pi) a1 = pi * 2 - a1; - double dx = std::tan((pi - a1)/4) * std::fabs(m_delta * mul); - pt1 = IntPoint((long64)(pt1.X -normals[m_k].Y * dx), - (long64)(pt1.Y + normals[m_k].X * dx)); - AddPoint(pt1); - pt2 = IntPoint((long64)(pt2.X + normals[m_j].Y * dx), - (long64)(pt2.Y -normals[m_j].X * dx)); - AddPoint(pt2); + double a1 = std::atan2(normals[m_k].Y, normals[m_k].X); + double a2 = std::atan2(-normals[m_j].Y, -normals[m_j].X); + a1 = std::fabs(a2 - a1); + if (a1 > pi) a1 = pi * 2 - a1; + double dx = std::tan((pi - a1)/4) * std::fabs(m_delta * mul); + pt1 = IntPoint((long64)(pt1.X -normals[m_k].Y * dx), + (long64)(pt1.Y + normals[m_k].X * dx)); + AddPoint(pt1); + pt2 = IntPoint((long64)(pt2.X + normals[m_j].Y * dx), + (long64)(pt2.Y -normals[m_j].X * dx)); + AddPoint(pt2); } else { - AddPoint(pt1); - AddPoint(m_p[m_i][m_j]); - AddPoint(pt2); + AddPoint(pt1); + AddPoint(m_p[m_i][m_j]); + AddPoint(pt2); } } //------------------------------------------------------------------------------ @@ -3274,6 +3396,28 @@ void OffsetPolygons(const Polygons &in_polys, Polygons &out_polys, } //------------------------------------------------------------------------------ +void SimplifyPolygon(const Polygon &in_poly, Polygons &out_polys, PolyFillType fillType) +{ + Clipper c; + c.AddPolygon(in_poly, ptSubject); + c.Execute(ctUnion, out_polys, fillType, fillType); +} +//------------------------------------------------------------------------------ + +void SimplifyPolygons(const Polygons &in_polys, Polygons &out_polys, PolyFillType fillType) +{ + Clipper c; + c.AddPolygons(in_polys, ptSubject); + c.Execute(ctUnion, out_polys, fillType, fillType); +} +//------------------------------------------------------------------------------ + +void SimplifyPolygons(Polygons &polys, PolyFillType fillType) +{ + SimplifyPolygons(polys, polys, fillType); +} +//------------------------------------------------------------------------------ + std::ostream& operator <<(std::ostream &s, IntPoint& p) { s << p.X << ' ' << p.Y << "\n"; diff --git a/contrib/clipper/clipper.hpp b/contrib/clipper/clipper.hpp index a56a46155..7cbe898df 100644 --- a/contrib/clipper/clipper.hpp +++ b/contrib/clipper/clipper.hpp @@ -1,10 +1,10 @@ /******************************************************************************* * * * Author : Angus Johnson * -* Version : 4.6.3 * -* Date : 11 November 2011 * +* Version : 4.8.8 * +* Date : 30 August 2012 * * Website : http://www.angusj.com * -* Copyright : Angus Johnson 2010-2011 * +* Copyright : Angus Johnson 2010-2012 * * * * License: * * Use, modification & distribution is subject to Boost Software License Ver 1. * @@ -73,18 +73,21 @@ struct ExPolygon { }; typedef std::vector< ExPolygon > ExPolygons; -enum JoinType { jtSquare, jtMiter, jtRound }; +enum JoinType { jtSquare, jtRound, jtMiter }; bool Orientation(const Polygon &poly); double Area(const Polygon &poly); void OffsetPolygons(const Polygons &in_polys, Polygons &out_polys, double delta, JoinType jointype = jtSquare, double MiterLimit = 2); +void SimplifyPolygon(const Polygon &in_poly, Polygons &out_polys, PolyFillType fillType = pftEvenOdd); +void SimplifyPolygons(const Polygons &in_polys, Polygons &out_polys, PolyFillType fillType = pftEvenOdd); +void SimplifyPolygons(Polygons &polys, PolyFillType fillType = pftEvenOdd); -void ReversePoints(Polygon& p); -void ReversePoints(Polygons& p); +void ReversePolygon(Polygon& p); +void ReversePolygons(Polygons& p); //used internally ... -enum EdgeSide { esLeft, esRight }; +enum EdgeSide { esNeither = 0, esLeft = 1, esRight = 2, esBoth = 3 }; enum IntersectProtects { ipNone = 0, ipLeft = 1, ipRight = 2, ipBoth = 3 }; struct TEdge { @@ -139,8 +142,8 @@ struct OutRec { OutRec *AppendLink; OutPt *pts; OutPt *bottomPt; - TEdge *bottomE1; - TEdge *bottomE2; + OutPt *bottomFlag; + EdgeSide sides; }; struct OutPt { @@ -256,9 +259,10 @@ private: void IntersectEdges(TEdge *e1, TEdge *e2, const IntPoint &pt, IntersectProtects protects); OutRec* CreateOutRec(); - void AddOutPt(TEdge *e, TEdge *altE, const IntPoint &pt); + void AddOutPt(TEdge *e, const IntPoint &pt); + void DisposeBottomPt(OutRec &outRec); void DisposeAllPolyPts(); - void DisposeOutRec(PolyOutList::size_type index, bool ignorePts = false); + void DisposeOutRec(PolyOutList::size_type index); bool ProcessIntersections(const long64 botY, const long64 topY); void AddIntersectNode(TEdge *e1, TEdge *e2, const IntPoint &pt); void BuildIntersectList(const long64 botY, const long64 topY); diff --git a/include/assimp/defs.h b/include/assimp/defs.h index 4d85e618f..200add7a5 100644 --- a/include/assimp/defs.h +++ b/include/assimp/defs.h @@ -135,6 +135,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. /* Tells the compiler that a function never returns. Used in code analysis * to skip dead paths (e.g. after an assertion evaluated to false). */ # define AI_WONT_RETURN __declspec(noreturn) + +#elif defined(SWIG) + + /* Do nothing, the relevant defines are all in AssimpSwigPort.i */ + #else # define AI_WONT_RETURN diff --git a/include/assimp/quaternion.h b/include/assimp/quaternion.h index c404af5ea..112d5766d 100644 --- a/include/assimp/quaternion.h +++ b/include/assimp/quaternion.h @@ -56,8 +56,8 @@ class aiQuaterniont { public: aiQuaterniont() : w(), x(), y(), z() {} - aiQuaterniont(TReal w, TReal x, TReal y, TReal z) - : w(w), x(x), y(y), z(z) {} + aiQuaterniont(TReal pw, TReal px, TReal py, TReal pz) + : w(pw), x(px), y(py), z(pz) {} /** Construct from rotation matrix. Result is undefined if the matrix is not orthonormal. */ aiQuaterniont( const aiMatrix3x3t& pRotMatrix); diff --git a/include/assimp/types.h b/include/assimp/types.h index dc75f4db4..592a128f2 100644 --- a/include/assimp/types.h +++ b/include/assimp/types.h @@ -178,7 +178,7 @@ struct aiColor3D /** Component-wise subtraction */ aiColor3D operator-(const aiColor3D& c) const { - return aiColor3D(r+c.r,g+c.g,b+c.b); + return aiColor3D(r-c.r,g-c.g,b-c.b); } /** Component-wise multiplication */ @@ -314,7 +314,7 @@ struct aiString /** Append a string to the string */ void Append (const char* app) { - const size_t len = strlen(app); + const size_t len = ::strlen(app); if (!len) { return; } diff --git a/port/Assimp.NET/Assimp.NET/AssimpSwigPort.i b/port/Assimp.NET/Assimp.NET/AssimpSwigPort.i index 38d79b76a..681b4f1a1 100644 --- a/port/Assimp.NET/Assimp.NET/AssimpSwigPort.i +++ b/port/Assimp.NET/Assimp.NET/AssimpSwigPort.i @@ -43,38 +43,39 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. %include "carrays.i" %include "typemaps.i" %{ -#include "..\..\..\include\aiDefines.h" -#include "..\..\..\include\aiConfig.h" -#include "..\..\..\include\aiTypes.h" -#include "..\..\..\include\aiVersion.h" -#include "..\..\..\include\aiPostProcess.h" -#include "..\..\..\include\aiVector2D.h" -#include "..\..\..\include\aiVector3D.h" -#include "..\..\..\include\aiColor4D.h" -#include "..\..\..\include\aiMatrix3x3.h" -#include "..\..\..\include\aiMatrix4x4.h" -#include "..\..\..\include\aiCamera.h" -#include "..\..\..\include\aiLight.h" -#include "..\..\..\include\aiAnim.h" -#include "..\..\..\include\aiMesh.h" -#include "..\..\..\include\aiFileIO.h" -#include "..\..\..\include\aiMaterial.h" -#include "..\..\..\include\aiQuaternion.h" -#include "..\..\..\include\aiScene.h" -#include "..\..\..\include\aiTexture.h" -#include "..\..\..\include\assimp.hpp" -#include "..\..\..\include\IOSystem.h" -#include "..\..\..\include\IOStream.h" -#include "..\..\..\include\Logger.h" -#include "..\..\..\include\LogStream.h" -#include "..\..\..\include\NullLogger.h" -#include "..\..\..\include\ProgressHandler.h" +#include "..\..\..\include\assimp\defs.h" +#include "..\..\..\include\assimp\config.h" +#include "..\..\..\include\assimp\types.h" +#include "..\..\..\include\assimp\version.h" +#include "..\..\..\include\assimp\postprocess.h" +#include "..\..\..\include\assimp\vector2.h" +#include "..\..\..\include\assimp\vector3.h" +#include "..\..\..\include\assimp\color4.h" +#include "..\..\..\include\assimp\matrix3x3.h" +#include "..\..\..\include\assimp\matrix4x4.h" +#include "..\..\..\include\assimp\camera.h" +#include "..\..\..\include\assimp\light.h" +#include "..\..\..\include\assimp\anim.h" +#include "..\..\..\include\assimp\mesh.h" +#include "..\..\..\include\assimp\cfileio.h" +#include "..\..\..\include\assimp\material.h" +#include "..\..\..\include\assimp\quaternion.h" +#include "..\..\..\include\assimp\scene.h" +#include "..\..\..\include\assimp\texture.h" +#include "..\..\..\include\assimp\Importer.hpp" +#include "..\..\..\include\assimp\IOSystem.hpp" +#include "..\..\..\include\assimp\IOStream.hpp" +#include "..\..\..\include\assimp\Logger.hpp" +#include "..\..\..\include\assimp\LogStream.hpp" +#include "..\..\..\include\assimp\NullLogger.hpp" +#include "..\..\..\include\assimp\ProgressHandler.hpp" %} #define C_STRUCT #define C_ENUM #define ASSIMP_API #define PACK_STRUCT +#define AI_FORCE_INLINE %rename(__add__) operator+; %rename(__addnset__) operator+=; @@ -504,33 +505,43 @@ ASSIMP_POINTER_POINTER(aiScene,aiTexture,mTextures,$self->mNumTextures); %ignore ::aiGetMaterialTexture; -%include "..\..\..\include\aiDefines.h" -%include "..\..\..\include\aiConfig.h" -%include "..\..\..\include\aiTypes.h" -%include "..\..\..\include\aiVersion.h" -%include "..\..\..\include\aiPostProcess.h" -%include "..\..\..\include\aiVector2D.h" -%include "..\..\..\include\aiVector3D.h" -%include "..\..\..\include\aiColor4D.h" -%include "..\..\..\include\aiMatrix3x3.h" -%include "..\..\..\include\aiMatrix4x4.h" -%include "..\..\..\include\aiCamera.h" -%include "..\..\..\include\aiLight.h" -%include "..\..\..\include\aiAnim.h" -%include "..\..\..\include\aiMesh.h" -%include "..\..\..\include\aiFileIO.h" -%include "..\..\..\include\aiMaterial.h" -%include "..\..\..\include\aiQuaternion.h" -%include "..\..\..\include\aiScene.h" -%include "..\..\..\include\aiTexture.h" -%include "..\..\..\include\assimp.hpp" -%include "..\..\..\include\ProgressHandler.h" +%include "..\..\..\include\assimp\defs.h" +%include "..\..\..\include\assimp\config.h" +%include "..\..\..\include\assimp\types.h" +%include "..\..\..\include\assimp\version.h" +%include "..\..\..\include\assimp\postprocess.h" +%include "..\..\..\include\assimp\vector2.h" +%include "..\..\..\include\assimp\vector3.h" +%include "..\..\..\include\assimp\color4.h" +%include "..\..\..\include\assimp\matrix3x3.h" +%include "..\..\..\include\assimp\matrix4x4.h" +%include "..\..\..\include\assimp\camera.h" +%include "..\..\..\include\assimp\light.h" +%include "..\..\..\include\assimp\anim.h" +%include "..\..\..\include\assimp\mesh.h" +%include "..\..\..\include\assimp\cfileio.h" +%include "..\..\..\include\assimp\material.h" +%include "..\..\..\include\assimp\quaternion.h" +%include "..\..\..\include\assimp\scene.h" +%include "..\..\..\include\assimp\texture.h" +%include "..\..\..\include\assimp\Importer.hpp" +%include "..\..\..\include\assimp\ProgressHandler.hpp" //%include "..\..\..\include\IOSystem.h" //%include "..\..\..\include\IOStream.h" //%include "..\..\..\include\Logger.h" //%include "..\..\..\include\LogStream.h" //%include "..\..\..\include\NullLogger.h" + +%template(aiColor4D) aiColor4t; + +%template(aiVector3D) aiVector3t; +%template(aiVector2D) aiVector2t; + +%template(aiQuaternion) aiQuaterniont; +%template(aiMatrix3x3) aiMatrix3x3t; +%template(aiMatrix4x4) aiMatrix4x4t; + %template(FloatVector) std::vector; %template(UintVector) std::vector; %template(aiAnimationVector) std::vector; diff --git a/port/Assimp.NET/Assimp.NET/AssimpSwigPort_wrap.cxx b/port/Assimp.NET/Assimp.NET/AssimpSwigPort_wrap.cxx index 34f8bb0c4..650552373 100644 --- a/port/Assimp.NET/Assimp.NET/AssimpSwigPort_wrap.cxx +++ b/port/Assimp.NET/Assimp.NET/AssimpSwigPort_wrap.cxx @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * This file is not intended to be easily readable and contains a number of * coding conventions designed to improve portability and efficiency. Do not make @@ -280,32 +280,32 @@ SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_Assimp(SWIG_CSharpStringH #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else -#include "..\..\..\include\aiDefines.h" -#include "..\..\..\include\aiConfig.h" -#include "..\..\..\include\aiTypes.h" -#include "..\..\..\include\aiVersion.h" -#include "..\..\..\include\aiPostProcess.h" -#include "..\..\..\include\aiVector2D.h" -#include "..\..\..\include\aiVector3D.h" -#include "..\..\..\include\aiColor4D.h" -#include "..\..\..\include\aiMatrix3x3.h" -#include "..\..\..\include\aiMatrix4x4.h" -#include "..\..\..\include\aiCamera.h" -#include "..\..\..\include\aiLight.h" -#include "..\..\..\include\aiAnim.h" -#include "..\..\..\include\aiMesh.h" -#include "..\..\..\include\aiFileIO.h" -#include "..\..\..\include\aiMaterial.h" -#include "..\..\..\include\aiQuaternion.h" -#include "..\..\..\include\aiScene.h" -#include "..\..\..\include\aiTexture.h" -#include "..\..\..\include\assimp.hpp" -#include "..\..\..\include\IOSystem.h" -#include "..\..\..\include\IOStream.h" -#include "..\..\..\include\Logger.h" -#include "..\..\..\include\LogStream.h" -#include "..\..\..\include\NullLogger.h" -#include "..\..\..\include\ProgressHandler.h" +#include "..\..\..\include\assimp\defs.h" +#include "..\..\..\include\assimp\config.h" +#include "..\..\..\include\assimp\types.h" +#include "..\..\..\include\assimp\version.h" +#include "..\..\..\include\assimp\postprocess.h" +#include "..\..\..\include\assimp\vector2.h" +#include "..\..\..\include\assimp\vector3.h" +#include "..\..\..\include\assimp\color4.h" +#include "..\..\..\include\assimp\matrix3x3.h" +#include "..\..\..\include\assimp\matrix4x4.h" +#include "..\..\..\include\assimp\camera.h" +#include "..\..\..\include\assimp\light.h" +#include "..\..\..\include\assimp\anim.h" +#include "..\..\..\include\assimp\mesh.h" +#include "..\..\..\include\assimp\cfileio.h" +#include "..\..\..\include\assimp\material.h" +#include "..\..\..\include\assimp\quaternion.h" +#include "..\..\..\include\assimp\scene.h" +#include "..\..\..\include\assimp\texture.h" +#include "..\..\..\include\assimp\Importer.hpp" +#include "..\..\..\include\assimp\IOSystem.hpp" +#include "..\..\..\include\assimp\IOStream.hpp" +#include "..\..\..\include\assimp\Logger.hpp" +#include "..\..\..\include\assimp\LogStream.hpp" +#include "..\..\..\include\assimp\NullLogger.hpp" +#include "..\..\..\include\assimp\ProgressHandler.hpp" #include @@ -1432,52 +1432,52 @@ SWIGINTERN bool std_vector_Sl_aiCamera_Sm__Sg__Remove(std::vector< aiCamera * > return false; } SWIGINTERN std::vector< std::vector< aiColor4D * > > *new_std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg___SWIG_2(int capacity){ - std::vector< std::vector< aiColor4D * > >* pv = 0; + std::vector< std::vector< aiColor4t< float > * > >* pv = 0; if (capacity >= 0) { - pv = new std::vector< std::vector< aiColor4D * > >(); + pv = new std::vector< std::vector< aiColor4t< float > * > >(); pv->reserve(capacity); } else { throw std::out_of_range("capacity"); } return pv; } -SWIGINTERN std::vector< aiColor4D * > std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__getitemcopy(std::vector< std::vector< aiColor4D * > > *self,int index){ +SWIGINTERN std::vector< aiColor4t< float > * > std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__getitemcopy(std::vector< std::vector< aiColor4D * > > *self,int index){ if (index>=0 && index<(int)self->size()) return (*self)[index]; else throw std::out_of_range("index"); } -SWIGINTERN std::vector< std::vector< aiColor4D * > >::const_reference std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__getitem(std::vector< std::vector< aiColor4D * > > *self,int index){ +SWIGINTERN std::vector< std::vector< aiColor4t< float > * > >::const_reference std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__getitem(std::vector< std::vector< aiColor4D * > > *self,int index){ if (index>=0 && index<(int)self->size()) return (*self)[index]; else throw std::out_of_range("index"); } -SWIGINTERN void std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__setitem(std::vector< std::vector< aiColor4D * > > *self,int index,std::vector< aiColor4D * > const &val){ +SWIGINTERN void std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__setitem(std::vector< std::vector< aiColor4D * > > *self,int index,std::vector< aiColor4t< float > * > const &val){ if (index>=0 && index<(int)self->size()) (*self)[index] = val; else throw std::out_of_range("index"); } -SWIGINTERN void std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__AddRange(std::vector< std::vector< aiColor4D * > > *self,std::vector< std::vector< aiColor4D * > > const &values){ +SWIGINTERN void std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__AddRange(std::vector< std::vector< aiColor4D * > > *self,std::vector< std::vector< aiColor4t< float > * > > const &values){ self->insert(self->end(), values.begin(), values.end()); } -SWIGINTERN std::vector< std::vector< aiColor4D * > > *std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__GetRange(std::vector< std::vector< aiColor4D * > > *self,int index,int count){ +SWIGINTERN std::vector< std::vector< aiColor4t< float > * > > *std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__GetRange(std::vector< std::vector< aiColor4D * > > *self,int index,int count){ if (index < 0) throw std::out_of_range("index"); if (count < 0) throw std::out_of_range("count"); if (index >= (int)self->size()+1 || index+count > (int)self->size()) throw std::invalid_argument("invalid range"); - return new std::vector< std::vector< aiColor4D * > >(self->begin()+index, self->begin()+index+count); + return new std::vector< std::vector< aiColor4t< float > * > >(self->begin()+index, self->begin()+index+count); } -SWIGINTERN void std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__Insert(std::vector< std::vector< aiColor4D * > > *self,int index,std::vector< aiColor4D * > const &x){ +SWIGINTERN void std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__Insert(std::vector< std::vector< aiColor4D * > > *self,int index,std::vector< aiColor4t< float > * > const &x){ if (index>=0 && index<(int)self->size()+1) self->insert(self->begin()+index, x); else throw std::out_of_range("index"); } -SWIGINTERN void std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__InsertRange(std::vector< std::vector< aiColor4D * > > *self,int index,std::vector< std::vector< aiColor4D * > > const &values){ +SWIGINTERN void std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__InsertRange(std::vector< std::vector< aiColor4D * > > *self,int index,std::vector< std::vector< aiColor4t< float > * > > const &values){ if (index>=0 && index<(int)self->size()+1) self->insert(self->begin()+index, values.begin(), values.end()); else @@ -1498,10 +1498,10 @@ SWIGINTERN void std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__RemoveRange(st throw std::invalid_argument("invalid range"); self->erase(self->begin()+index, self->begin()+index+count); } -SWIGINTERN std::vector< std::vector< aiColor4D * > > *std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__Repeat(std::vector< aiColor4D * > const &value,int count){ +SWIGINTERN std::vector< std::vector< aiColor4t< float > * > > *std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__Repeat(std::vector< aiColor4t< float > * > const &value,int count){ if (count < 0) throw std::out_of_range("count"); - return new std::vector< std::vector< aiColor4D * > >(count, value); + return new std::vector< std::vector< aiColor4t< float > * > >(count, value); } SWIGINTERN void std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__Reverse__SWIG_0(std::vector< std::vector< aiColor4D * > > *self){ std::reverse(self->begin(), self->end()); @@ -1515,7 +1515,7 @@ SWIGINTERN void std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__Reverse__SWIG_ throw std::invalid_argument("invalid range"); std::reverse(self->begin()+index, self->begin()+index+count); } -SWIGINTERN void std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__SetRange(std::vector< std::vector< aiColor4D * > > *self,int index,std::vector< std::vector< aiColor4D * > > const &values){ +SWIGINTERN void std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__SetRange(std::vector< std::vector< aiColor4D * > > *self,int index,std::vector< std::vector< aiColor4t< float > * > > const &values){ if (index < 0) throw std::out_of_range("index"); if (index+values.size() > self->size()) @@ -1523,52 +1523,52 @@ SWIGINTERN void std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__SetRange(std:: std::copy(values.begin(), values.end(), self->begin()+index); } SWIGINTERN std::vector< aiColor4D * > *new_std_vector_Sl_aiColor4D_Sm__Sg___SWIG_2(int capacity){ - std::vector< aiColor4D * >* pv = 0; + std::vector< aiColor4t< float > * >* pv = 0; if (capacity >= 0) { - pv = new std::vector< aiColor4D * >(); + pv = new std::vector< aiColor4t< float > * >(); pv->reserve(capacity); } else { throw std::out_of_range("capacity"); } return pv; } -SWIGINTERN aiColor4D *std_vector_Sl_aiColor4D_Sm__Sg__getitemcopy(std::vector< aiColor4D * > *self,int index){ +SWIGINTERN aiColor4t< float > *std_vector_Sl_aiColor4D_Sm__Sg__getitemcopy(std::vector< aiColor4D * > *self,int index){ if (index>=0 && index<(int)self->size()) return (*self)[index]; else throw std::out_of_range("index"); } -SWIGINTERN std::vector< aiColor4D * >::const_reference std_vector_Sl_aiColor4D_Sm__Sg__getitem(std::vector< aiColor4D * > *self,int index){ +SWIGINTERN std::vector< aiColor4t< float > * >::const_reference std_vector_Sl_aiColor4D_Sm__Sg__getitem(std::vector< aiColor4D * > *self,int index){ if (index>=0 && index<(int)self->size()) return (*self)[index]; else throw std::out_of_range("index"); } -SWIGINTERN void std_vector_Sl_aiColor4D_Sm__Sg__setitem(std::vector< aiColor4D * > *self,int index,aiColor4D *const &val){ +SWIGINTERN void std_vector_Sl_aiColor4D_Sm__Sg__setitem(std::vector< aiColor4D * > *self,int index,aiColor4t< float > *const &val){ if (index>=0 && index<(int)self->size()) (*self)[index] = val; else throw std::out_of_range("index"); } -SWIGINTERN void std_vector_Sl_aiColor4D_Sm__Sg__AddRange(std::vector< aiColor4D * > *self,std::vector< aiColor4D * > const &values){ +SWIGINTERN void std_vector_Sl_aiColor4D_Sm__Sg__AddRange(std::vector< aiColor4D * > *self,std::vector< aiColor4t< float > * > const &values){ self->insert(self->end(), values.begin(), values.end()); } -SWIGINTERN std::vector< aiColor4D * > *std_vector_Sl_aiColor4D_Sm__Sg__GetRange(std::vector< aiColor4D * > *self,int index,int count){ +SWIGINTERN std::vector< aiColor4t< float > * > *std_vector_Sl_aiColor4D_Sm__Sg__GetRange(std::vector< aiColor4D * > *self,int index,int count){ if (index < 0) throw std::out_of_range("index"); if (count < 0) throw std::out_of_range("count"); if (index >= (int)self->size()+1 || index+count > (int)self->size()) throw std::invalid_argument("invalid range"); - return new std::vector< aiColor4D * >(self->begin()+index, self->begin()+index+count); + return new std::vector< aiColor4t< float > * >(self->begin()+index, self->begin()+index+count); } -SWIGINTERN void std_vector_Sl_aiColor4D_Sm__Sg__Insert(std::vector< aiColor4D * > *self,int index,aiColor4D *const &x){ +SWIGINTERN void std_vector_Sl_aiColor4D_Sm__Sg__Insert(std::vector< aiColor4D * > *self,int index,aiColor4t< float > *const &x){ if (index>=0 && index<(int)self->size()+1) self->insert(self->begin()+index, x); else throw std::out_of_range("index"); } -SWIGINTERN void std_vector_Sl_aiColor4D_Sm__Sg__InsertRange(std::vector< aiColor4D * > *self,int index,std::vector< aiColor4D * > const &values){ +SWIGINTERN void std_vector_Sl_aiColor4D_Sm__Sg__InsertRange(std::vector< aiColor4D * > *self,int index,std::vector< aiColor4t< float > * > const &values){ if (index>=0 && index<(int)self->size()+1) self->insert(self->begin()+index, values.begin(), values.end()); else @@ -1589,10 +1589,10 @@ SWIGINTERN void std_vector_Sl_aiColor4D_Sm__Sg__RemoveRange(std::vector< aiColor throw std::invalid_argument("invalid range"); self->erase(self->begin()+index, self->begin()+index+count); } -SWIGINTERN std::vector< aiColor4D * > *std_vector_Sl_aiColor4D_Sm__Sg__Repeat(aiColor4D *const &value,int count){ +SWIGINTERN std::vector< aiColor4t< float > * > *std_vector_Sl_aiColor4D_Sm__Sg__Repeat(aiColor4t< float > *const &value,int count){ if (count < 0) throw std::out_of_range("count"); - return new std::vector< aiColor4D * >(count, value); + return new std::vector< aiColor4t< float > * >(count, value); } SWIGINTERN void std_vector_Sl_aiColor4D_Sm__Sg__Reverse__SWIG_0(std::vector< aiColor4D * > *self){ std::reverse(self->begin(), self->end()); @@ -1606,32 +1606,32 @@ SWIGINTERN void std_vector_Sl_aiColor4D_Sm__Sg__Reverse__SWIG_1(std::vector< aiC throw std::invalid_argument("invalid range"); std::reverse(self->begin()+index, self->begin()+index+count); } -SWIGINTERN void std_vector_Sl_aiColor4D_Sm__Sg__SetRange(std::vector< aiColor4D * > *self,int index,std::vector< aiColor4D * > const &values){ +SWIGINTERN void std_vector_Sl_aiColor4D_Sm__Sg__SetRange(std::vector< aiColor4D * > *self,int index,std::vector< aiColor4t< float > * > const &values){ if (index < 0) throw std::out_of_range("index"); if (index+values.size() > self->size()) throw std::out_of_range("index"); std::copy(values.begin(), values.end(), self->begin()+index); } -SWIGINTERN bool std_vector_Sl_aiColor4D_Sm__Sg__Contains(std::vector< aiColor4D * > *self,aiColor4D *const &value){ +SWIGINTERN bool std_vector_Sl_aiColor4D_Sm__Sg__Contains(std::vector< aiColor4D * > *self,aiColor4t< float > *const &value){ return std::find(self->begin(), self->end(), value) != self->end(); } -SWIGINTERN int std_vector_Sl_aiColor4D_Sm__Sg__IndexOf(std::vector< aiColor4D * > *self,aiColor4D *const &value){ +SWIGINTERN int std_vector_Sl_aiColor4D_Sm__Sg__IndexOf(std::vector< aiColor4D * > *self,aiColor4t< float > *const &value){ int index = -1; - std::vector< aiColor4D * >::iterator it = std::find(self->begin(), self->end(), value); + std::vector< aiColor4t< float > * >::iterator it = std::find(self->begin(), self->end(), value); if (it != self->end()) index = (int)(it - self->begin()); return index; } -SWIGINTERN int std_vector_Sl_aiColor4D_Sm__Sg__LastIndexOf(std::vector< aiColor4D * > *self,aiColor4D *const &value){ +SWIGINTERN int std_vector_Sl_aiColor4D_Sm__Sg__LastIndexOf(std::vector< aiColor4D * > *self,aiColor4t< float > *const &value){ int index = -1; - std::vector< aiColor4D * >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value); + std::vector< aiColor4t< float > * >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value); if (rit != self->rend()) index = (int)(self->rend() - 1 - rit); return index; } -SWIGINTERN bool std_vector_Sl_aiColor4D_Sm__Sg__Remove(std::vector< aiColor4D * > *self,aiColor4D *const &value){ - std::vector< aiColor4D * >::iterator it = std::find(self->begin(), self->end(), value); +SWIGINTERN bool std_vector_Sl_aiColor4D_Sm__Sg__Remove(std::vector< aiColor4D * > *self,aiColor4t< float > *const &value){ + std::vector< aiColor4t< float > * >::iterator it = std::find(self->begin(), self->end(), value); if (it != self->end()) { self->erase(it); return true; @@ -2799,52 +2799,52 @@ SWIGINTERN bool std_vector_Sl_aiTexture_Sm__Sg__Remove(std::vector< aiTexture * return false; } SWIGINTERN std::vector< aiVector3D * > *new_std_vector_Sl_aiVector3D_Sm__Sg___SWIG_2(int capacity){ - std::vector< aiVector3D * >* pv = 0; + std::vector< aiVector3t< float > * >* pv = 0; if (capacity >= 0) { - pv = new std::vector< aiVector3D * >(); + pv = new std::vector< aiVector3t< float > * >(); pv->reserve(capacity); } else { throw std::out_of_range("capacity"); } return pv; } -SWIGINTERN aiVector3D *std_vector_Sl_aiVector3D_Sm__Sg__getitemcopy(std::vector< aiVector3D * > *self,int index){ +SWIGINTERN aiVector3t< float > *std_vector_Sl_aiVector3D_Sm__Sg__getitemcopy(std::vector< aiVector3D * > *self,int index){ if (index>=0 && index<(int)self->size()) return (*self)[index]; else throw std::out_of_range("index"); } -SWIGINTERN std::vector< aiVector3D * >::const_reference std_vector_Sl_aiVector3D_Sm__Sg__getitem(std::vector< aiVector3D * > *self,int index){ +SWIGINTERN std::vector< aiVector3t< float > * >::const_reference std_vector_Sl_aiVector3D_Sm__Sg__getitem(std::vector< aiVector3D * > *self,int index){ if (index>=0 && index<(int)self->size()) return (*self)[index]; else throw std::out_of_range("index"); } -SWIGINTERN void std_vector_Sl_aiVector3D_Sm__Sg__setitem(std::vector< aiVector3D * > *self,int index,aiVector3D *const &val){ +SWIGINTERN void std_vector_Sl_aiVector3D_Sm__Sg__setitem(std::vector< aiVector3D * > *self,int index,aiVector3t< float > *const &val){ if (index>=0 && index<(int)self->size()) (*self)[index] = val; else throw std::out_of_range("index"); } -SWIGINTERN void std_vector_Sl_aiVector3D_Sm__Sg__AddRange(std::vector< aiVector3D * > *self,std::vector< aiVector3D * > const &values){ +SWIGINTERN void std_vector_Sl_aiVector3D_Sm__Sg__AddRange(std::vector< aiVector3D * > *self,std::vector< aiVector3t< float > * > const &values){ self->insert(self->end(), values.begin(), values.end()); } -SWIGINTERN std::vector< aiVector3D * > *std_vector_Sl_aiVector3D_Sm__Sg__GetRange(std::vector< aiVector3D * > *self,int index,int count){ +SWIGINTERN std::vector< aiVector3t< float > * > *std_vector_Sl_aiVector3D_Sm__Sg__GetRange(std::vector< aiVector3D * > *self,int index,int count){ if (index < 0) throw std::out_of_range("index"); if (count < 0) throw std::out_of_range("count"); if (index >= (int)self->size()+1 || index+count > (int)self->size()) throw std::invalid_argument("invalid range"); - return new std::vector< aiVector3D * >(self->begin()+index, self->begin()+index+count); + return new std::vector< aiVector3t< float > * >(self->begin()+index, self->begin()+index+count); } -SWIGINTERN void std_vector_Sl_aiVector3D_Sm__Sg__Insert(std::vector< aiVector3D * > *self,int index,aiVector3D *const &x){ +SWIGINTERN void std_vector_Sl_aiVector3D_Sm__Sg__Insert(std::vector< aiVector3D * > *self,int index,aiVector3t< float > *const &x){ if (index>=0 && index<(int)self->size()+1) self->insert(self->begin()+index, x); else throw std::out_of_range("index"); } -SWIGINTERN void std_vector_Sl_aiVector3D_Sm__Sg__InsertRange(std::vector< aiVector3D * > *self,int index,std::vector< aiVector3D * > const &values){ +SWIGINTERN void std_vector_Sl_aiVector3D_Sm__Sg__InsertRange(std::vector< aiVector3D * > *self,int index,std::vector< aiVector3t< float > * > const &values){ if (index>=0 && index<(int)self->size()+1) self->insert(self->begin()+index, values.begin(), values.end()); else @@ -2865,10 +2865,10 @@ SWIGINTERN void std_vector_Sl_aiVector3D_Sm__Sg__RemoveRange(std::vector< aiVect throw std::invalid_argument("invalid range"); self->erase(self->begin()+index, self->begin()+index+count); } -SWIGINTERN std::vector< aiVector3D * > *std_vector_Sl_aiVector3D_Sm__Sg__Repeat(aiVector3D *const &value,int count){ +SWIGINTERN std::vector< aiVector3t< float > * > *std_vector_Sl_aiVector3D_Sm__Sg__Repeat(aiVector3t< float > *const &value,int count){ if (count < 0) throw std::out_of_range("count"); - return new std::vector< aiVector3D * >(count, value); + return new std::vector< aiVector3t< float > * >(count, value); } SWIGINTERN void std_vector_Sl_aiVector3D_Sm__Sg__Reverse__SWIG_0(std::vector< aiVector3D * > *self){ std::reverse(self->begin(), self->end()); @@ -2882,32 +2882,32 @@ SWIGINTERN void std_vector_Sl_aiVector3D_Sm__Sg__Reverse__SWIG_1(std::vector< ai throw std::invalid_argument("invalid range"); std::reverse(self->begin()+index, self->begin()+index+count); } -SWIGINTERN void std_vector_Sl_aiVector3D_Sm__Sg__SetRange(std::vector< aiVector3D * > *self,int index,std::vector< aiVector3D * > const &values){ +SWIGINTERN void std_vector_Sl_aiVector3D_Sm__Sg__SetRange(std::vector< aiVector3D * > *self,int index,std::vector< aiVector3t< float > * > const &values){ if (index < 0) throw std::out_of_range("index"); if (index+values.size() > self->size()) throw std::out_of_range("index"); std::copy(values.begin(), values.end(), self->begin()+index); } -SWIGINTERN bool std_vector_Sl_aiVector3D_Sm__Sg__Contains(std::vector< aiVector3D * > *self,aiVector3D *const &value){ +SWIGINTERN bool std_vector_Sl_aiVector3D_Sm__Sg__Contains(std::vector< aiVector3D * > *self,aiVector3t< float > *const &value){ return std::find(self->begin(), self->end(), value) != self->end(); } -SWIGINTERN int std_vector_Sl_aiVector3D_Sm__Sg__IndexOf(std::vector< aiVector3D * > *self,aiVector3D *const &value){ +SWIGINTERN int std_vector_Sl_aiVector3D_Sm__Sg__IndexOf(std::vector< aiVector3D * > *self,aiVector3t< float > *const &value){ int index = -1; - std::vector< aiVector3D * >::iterator it = std::find(self->begin(), self->end(), value); + std::vector< aiVector3t< float > * >::iterator it = std::find(self->begin(), self->end(), value); if (it != self->end()) index = (int)(it - self->begin()); return index; } -SWIGINTERN int std_vector_Sl_aiVector3D_Sm__Sg__LastIndexOf(std::vector< aiVector3D * > *self,aiVector3D *const &value){ +SWIGINTERN int std_vector_Sl_aiVector3D_Sm__Sg__LastIndexOf(std::vector< aiVector3D * > *self,aiVector3t< float > *const &value){ int index = -1; - std::vector< aiVector3D * >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value); + std::vector< aiVector3t< float > * >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value); if (rit != self->rend()) index = (int)(self->rend() - 1 - rit); return index; } -SWIGINTERN bool std_vector_Sl_aiVector3D_Sm__Sg__Remove(std::vector< aiVector3D * > *self,aiVector3D *const &value){ - std::vector< aiVector3D * >::iterator it = std::find(self->begin(), self->end(), value); +SWIGINTERN bool std_vector_Sl_aiVector3D_Sm__Sg__Remove(std::vector< aiVector3D * > *self,aiVector3t< float > *const &value){ + std::vector< aiVector3t< float > * >::iterator it = std::find(self->begin(), self->end(), value); if (it != self->end()) { self->erase(it); return true; @@ -2930,7 +2930,7 @@ SWIGINTERN std::vector< aiVector3D * > std_vector_Sl_std_vector_Sl_aiVector3D_Sm else throw std::out_of_range("index"); } -SWIGINTERN std::vector< std::vector< aiVector3D * > >::const_reference std_vector_Sl_std_vector_Sl_aiVector3D_Sm__Sg__Sg__getitem(std::vector< std::vector< aiVector3D * > > *self,int index){ +SWIGINTERN std::vector< std::vector< aiVector3t< float > * > >::const_reference std_vector_Sl_std_vector_Sl_aiVector3D_Sm__Sg__Sg__getitem(std::vector< std::vector< aiVector3D * > > *self,int index){ if (index>=0 && index<(int)self->size()) return (*self)[index]; else @@ -3312,6 +3312,26 @@ SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_GLOB_MEASURE_TIME_get() { } +SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_PP_SBBC_MAX_BONES_get() { + char * jresult ; + char *result = 0 ; + + result = (char *)("PP_SBBC_MAX_BONES"); + jresult = SWIG_csharp_string_callback((const char *)result); + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_AI_SBBC_DEFAULT_MAX_BONES_get() { + int jresult ; + int result; + + result = (int)(60); + jresult = result; + return jresult; +} + + SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE_get() { char * jresult ; char *result = 0 ; @@ -3322,6 +3342,16 @@ SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE_get() { } +SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_PP_CT_TEXTURE_CHANNEL_INDEX_get() { + char * jresult ; + char *result = 0 ; + + result = (char *)("PP_CT_TEXTURE_CHANNEL_INDEX"); + jresult = SWIG_csharp_string_callback((const char *)result); + return jresult; +} + + SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE_get() { char * jresult ; char *result = 0 ; @@ -3452,6 +3482,36 @@ SWIGEXPORT int SWIGSTDCALL CSharp_AI_LMW_MAX_WEIGHTS_get() { } +SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_PP_DB_THRESHOLD_get() { + char * jresult ; + char *result = 0 ; + + result = (char *)("PP_DB_THRESHOLD"); + jresult = SWIG_csharp_string_callback((const char *)result); + return jresult; +} + + +SWIGEXPORT double SWIGSTDCALL CSharp_AI_DEBONE_THRESHOLD_get() { + double jresult ; + double result; + + result = (double)(1.0); + jresult = result; + return jresult; +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_PP_DB_ALL_OR_NONE_get() { + char * jresult ; + char *result = 0 ; + + result = (char *)("PP_DB_ALL_OR_NONE"); + jresult = SWIG_csharp_string_callback((const char *)result); + return jresult; +} + + SWIGEXPORT int SWIGSTDCALL CSharp_PP_ICL_PTCACHE_SIZE_get() { int jresult ; int result; @@ -3772,6 +3832,46 @@ SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_IMPORT_OGRE_MATERIAL_FILE_get() { } +SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_IMPORT_OGRE_TEXTURETYPE_FROM_FILENAME_get() { + char * jresult ; + char *result = 0 ; + + result = (char *)("IMPORT_OGRE_TEXTURETYPE_FROM_FILENAME"); + jresult = SWIG_csharp_string_callback((const char *)result); + return jresult; +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_IMPORT_IFC_SKIP_SPACE_REPRESENTATIONS_get() { + char * jresult ; + char *result = 0 ; + + result = (char *)("IMPORT_IFC_SKIP_SPACE_REPRESENTATIONS"); + jresult = SWIG_csharp_string_callback((const char *)result); + return jresult; +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_IMPORT_IFC_SKIP_CURVE_REPRESENTATIONS_get() { + char * jresult ; + char *result = 0 ; + + result = (char *)("IMPORT_IFC_SKIP_CURVE_REPRESENTATIONS"); + jresult = SWIG_csharp_string_callback((const char *)result); + return jresult; +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_AI_CONFIG_IMPORT_IFC_CUSTOM_TRIANGULATION_get() { + char * jresult ; + char *result = 0 ; + + result = (char *)("IMPORT_IFC_CUSTOM_TRIANGULATION"); + jresult = SWIG_csharp_string_callback((const char *)result); + return jresult; +} + + SWIGEXPORT unsigned long SWIGSTDCALL CSharp_MAXLEN_get() { unsigned long jresult ; size_t result; @@ -4373,6 +4473,18 @@ SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiString___nequal__(void * jarg1, voi } +SWIGEXPORT char * SWIGSTDCALL CSharp_aiString_C_Str(void * jarg1) { + char * jresult ; + aiString *arg1 = (aiString *) 0 ; + char *result = 0 ; + + arg1 = (aiString *)jarg1; + result = (char *)((aiString const *)arg1)->C_Str(); + jresult = SWIG_csharp_string_callback((const char *)result); + return jresult; +} + + SWIGEXPORT void SWIGSTDCALL CSharp_aiString_Length_set(void * jarg1, unsigned long jarg2) { aiString *arg1 = (aiString *) 0 ; size_t arg2 ; @@ -4726,2182 +4838,6 @@ SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiGetCompileFlags() { } -SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiVector2D__SWIG_0() { - void * jresult ; - aiVector2D *result = 0 ; - - result = (aiVector2D *)new aiVector2D(); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiVector2D__SWIG_1(float jarg1, float jarg2) { - void * jresult ; - float arg1 ; - float arg2 ; - aiVector2D *result = 0 ; - - arg1 = (float)jarg1; - arg2 = (float)jarg2; - result = (aiVector2D *)new aiVector2D(arg1,arg2); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiVector2D__SWIG_2(float jarg1) { - void * jresult ; - float arg1 ; - aiVector2D *result = 0 ; - - arg1 = (float)jarg1; - result = (aiVector2D *)new aiVector2D(arg1); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiVector2D__SWIG_3(void * jarg1) { - void * jresult ; - aiVector2D *arg1 = 0 ; - aiVector2D *result = 0 ; - - arg1 = (aiVector2D *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2D const & type is null", 0); - return 0; - } - result = (aiVector2D *)new aiVector2D((aiVector2D const &)*arg1); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_aiVector2D_Set(void * jarg1, float jarg2, float jarg3) { - aiVector2D *arg1 = (aiVector2D *) 0 ; - float arg2 ; - float arg3 ; - - arg1 = (aiVector2D *)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - (arg1)->Set(arg2,arg3); -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiVector2D_SquareLength(void * jarg1) { - float jresult ; - aiVector2D *arg1 = (aiVector2D *) 0 ; - float result; - - arg1 = (aiVector2D *)jarg1; - result = (float)((aiVector2D const *)arg1)->SquareLength(); - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiVector2D_Length(void * jarg1) { - float jresult ; - aiVector2D *arg1 = (aiVector2D *) 0 ; - float result; - - arg1 = (aiVector2D *)jarg1; - result = (float)((aiVector2D const *)arg1)->Length(); - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector2D_Normalize(void * jarg1) { - void * jresult ; - aiVector2D *arg1 = (aiVector2D *) 0 ; - aiVector2D *result = 0 ; - - arg1 = (aiVector2D *)jarg1; - result = (aiVector2D *) &(arg1)->Normalize(); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector2D___addnset__(void * jarg1, void * jarg2) { - void * jresult ; - aiVector2D *arg1 = (aiVector2D *) 0 ; - aiVector2D *arg2 = 0 ; - aiVector2D *result = 0 ; - - arg1 = (aiVector2D *)jarg1; - arg2 = (aiVector2D *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2D const & type is null", 0); - return 0; - } - result = (aiVector2D *) &(arg1)->operator +=((aiVector2D const &)*arg2); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector2D___subnset__(void * jarg1, void * jarg2) { - void * jresult ; - aiVector2D *arg1 = (aiVector2D *) 0 ; - aiVector2D *arg2 = 0 ; - aiVector2D *result = 0 ; - - arg1 = (aiVector2D *)jarg1; - arg2 = (aiVector2D *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2D const & type is null", 0); - return 0; - } - result = (aiVector2D *) &(arg1)->operator -=((aiVector2D const &)*arg2); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector2D___mulnset__(void * jarg1, float jarg2) { - void * jresult ; - aiVector2D *arg1 = (aiVector2D *) 0 ; - float arg2 ; - aiVector2D *result = 0 ; - - arg1 = (aiVector2D *)jarg1; - arg2 = (float)jarg2; - result = (aiVector2D *) &(arg1)->operator *=(arg2); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector2D___divnset__(void * jarg1, float jarg2) { - void * jresult ; - aiVector2D *arg1 = (aiVector2D *) 0 ; - float arg2 ; - aiVector2D *result = 0 ; - - arg1 = (aiVector2D *)jarg1; - arg2 = (float)jarg2; - result = (aiVector2D *) &(arg1)->operator /=(arg2); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiVector2D___idx____SWIG_0(void * jarg1, unsigned int jarg2) { - float jresult ; - aiVector2D *arg1 = (aiVector2D *) 0 ; - unsigned int arg2 ; - float result; - - arg1 = (aiVector2D *)jarg1; - arg2 = (unsigned int)jarg2; - result = (float)((aiVector2D const *)arg1)->operator [](arg2); - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiVector2D___equal__(void * jarg1, void * jarg2) { - unsigned int jresult ; - aiVector2D *arg1 = (aiVector2D *) 0 ; - aiVector2D *arg2 = 0 ; - bool result; - - arg1 = (aiVector2D *)jarg1; - arg2 = (aiVector2D *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2D const & type is null", 0); - return 0; - } - result = (bool)((aiVector2D const *)arg1)->operator ==((aiVector2D const &)*arg2); - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiVector2D___nequal__(void * jarg1, void * jarg2) { - unsigned int jresult ; - aiVector2D *arg1 = (aiVector2D *) 0 ; - aiVector2D *arg2 = 0 ; - bool result; - - arg1 = (aiVector2D *)jarg1; - arg2 = (aiVector2D *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2D const & type is null", 0); - return 0; - } - result = (bool)((aiVector2D const *)arg1)->operator !=((aiVector2D const &)*arg2); - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector2D___set__(void * jarg1, float jarg2) { - void * jresult ; - aiVector2D *arg1 = (aiVector2D *) 0 ; - float arg2 ; - aiVector2D *result = 0 ; - - arg1 = (aiVector2D *)jarg1; - arg2 = (float)jarg2; - result = (aiVector2D *) &(arg1)->operator =(arg2); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector2D_SymMul(void * jarg1, void * jarg2) { - void * jresult ; - aiVector2D *arg1 = (aiVector2D *) 0 ; - aiVector2D *arg2 = 0 ; - aiVector2D result; - - arg1 = (aiVector2D *)jarg1; - arg2 = (aiVector2D *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2D const & type is null", 0); - return 0; - } - result = (arg1)->SymMul((aiVector2D const &)*arg2); - jresult = new aiVector2D((const aiVector2D &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_aiVector2D_x_set(void * jarg1, float jarg2) { - aiVector2D *arg1 = (aiVector2D *) 0 ; - float arg2 ; - - arg1 = (aiVector2D *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->x = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiVector2D_x_get(void * jarg1) { - float jresult ; - aiVector2D *arg1 = (aiVector2D *) 0 ; - float result; - - arg1 = (aiVector2D *)jarg1; - result = (float) ((arg1)->x); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_aiVector2D_y_set(void * jarg1, float jarg2) { - aiVector2D *arg1 = (aiVector2D *) 0 ; - float arg2 ; - - arg1 = (aiVector2D *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->y = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiVector2D_y_get(void * jarg1) { - float jresult ; - aiVector2D *arg1 = (aiVector2D *) 0 ; - float result; - - arg1 = (aiVector2D *)jarg1; - result = (float) ((arg1)->y); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiVector2D(void * jarg1) { - aiVector2D *arg1 = (aiVector2D *) 0 ; - - arg1 = (aiVector2D *)jarg1; - delete arg1; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp___add__(void * jarg1, void * jarg2) { - void * jresult ; - aiVector2D *arg1 = 0 ; - aiVector2D *arg2 = 0 ; - aiVector2D result; - - arg1 = (aiVector2D *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2D const & type is null", 0); - return 0; - } - arg2 = (aiVector2D *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2D const & type is null", 0); - return 0; - } - result = operator +((aiVector2D const &)*arg1,(aiVector2D const &)*arg2); - jresult = new aiVector2D((const aiVector2D &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp___sub____SWIG_0(void * jarg1, void * jarg2) { - void * jresult ; - aiVector2D *arg1 = 0 ; - aiVector2D *arg2 = 0 ; - aiVector2D result; - - arg1 = (aiVector2D *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2D const & type is null", 0); - return 0; - } - arg2 = (aiVector2D *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2D const & type is null", 0); - return 0; - } - result = operator -((aiVector2D const &)*arg1,(aiVector2D const &)*arg2); - jresult = new aiVector2D((const aiVector2D &)result); - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp___mul____SWIG_0(void * jarg1, void * jarg2) { - float jresult ; - aiVector2D *arg1 = 0 ; - aiVector2D *arg2 = 0 ; - float result; - - arg1 = (aiVector2D *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2D const & type is null", 0); - return 0; - } - arg2 = (aiVector2D *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2D const & type is null", 0); - return 0; - } - result = (float)operator *((aiVector2D const &)*arg1,(aiVector2D const &)*arg2); - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp___mul____SWIG_1(float jarg1, void * jarg2) { - void * jresult ; - float arg1 ; - aiVector2D *arg2 = 0 ; - aiVector2D result; - - arg1 = (float)jarg1; - arg2 = (aiVector2D *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2D const & type is null", 0); - return 0; - } - result = operator *(arg1,(aiVector2D const &)*arg2); - jresult = new aiVector2D((const aiVector2D &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp___mul____SWIG_2(void * jarg1, float jarg2) { - void * jresult ; - aiVector2D *arg1 = 0 ; - float arg2 ; - aiVector2D result; - - arg1 = (aiVector2D *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2D const & type is null", 0); - return 0; - } - arg2 = (float)jarg2; - result = operator *((aiVector2D const &)*arg1,arg2); - jresult = new aiVector2D((const aiVector2D &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp___div____SWIG_0(void * jarg1, float jarg2) { - void * jresult ; - aiVector2D *arg1 = 0 ; - float arg2 ; - aiVector2D result; - - arg1 = (aiVector2D *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2D const & type is null", 0); - return 0; - } - arg2 = (float)jarg2; - result = operator /((aiVector2D const &)*arg1,arg2); - jresult = new aiVector2D((const aiVector2D &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp___div____SWIG_1(void * jarg1, void * jarg2) { - void * jresult ; - aiVector2D *arg1 = 0 ; - aiVector2D *arg2 = 0 ; - aiVector2D result; - - arg1 = (aiVector2D *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2D const & type is null", 0); - return 0; - } - arg2 = (aiVector2D *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2D const & type is null", 0); - return 0; - } - result = operator /((aiVector2D const &)*arg1,(aiVector2D const &)*arg2); - jresult = new aiVector2D((const aiVector2D &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp___sub____SWIG_1(void * jarg1) { - void * jresult ; - aiVector2D *arg1 = 0 ; - aiVector2D result; - - arg1 = (aiVector2D *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2D const & type is null", 0); - return 0; - } - result = operator -((aiVector2D const &)*arg1); - jresult = new aiVector2D((const aiVector2D &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiVector3D__SWIG_0() { - void * jresult ; - aiVector3D *result = 0 ; - - result = (aiVector3D *)new aiVector3D(); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiVector3D__SWIG_1(float jarg1, float jarg2, float jarg3) { - void * jresult ; - float arg1 ; - float arg2 ; - float arg3 ; - aiVector3D *result = 0 ; - - arg1 = (float)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - result = (aiVector3D *)new aiVector3D(arg1,arg2,arg3); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiVector3D__SWIG_2(float jarg1) { - void * jresult ; - float arg1 ; - aiVector3D *result = 0 ; - - arg1 = (float)jarg1; - result = (aiVector3D *)new aiVector3D(arg1); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiVector3D__SWIG_3(void * jarg1) { - void * jresult ; - aiVector3D *arg1 = 0 ; - aiVector3D *result = 0 ; - - arg1 = (aiVector3D *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3D const & type is null", 0); - return 0; - } - result = (aiVector3D *)new aiVector3D((aiVector3D const &)*arg1); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector3D___addnset__(void * jarg1, void * jarg2) { - void * jresult ; - aiVector3D *arg1 = (aiVector3D *) 0 ; - aiVector3D *arg2 = 0 ; - aiVector3D *result = 0 ; - - arg1 = (aiVector3D *)jarg1; - arg2 = (aiVector3D *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3D const & type is null", 0); - return 0; - } - result = (aiVector3D *) &(arg1)->operator +=((aiVector3D const &)*arg2); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector3D___subnset__(void * jarg1, void * jarg2) { - void * jresult ; - aiVector3D *arg1 = (aiVector3D *) 0 ; - aiVector3D *arg2 = 0 ; - aiVector3D *result = 0 ; - - arg1 = (aiVector3D *)jarg1; - arg2 = (aiVector3D *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3D const & type is null", 0); - return 0; - } - result = (aiVector3D *) &(arg1)->operator -=((aiVector3D const &)*arg2); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector3D___mulnset____SWIG_0(void * jarg1, float jarg2) { - void * jresult ; - aiVector3D *arg1 = (aiVector3D *) 0 ; - float arg2 ; - aiVector3D *result = 0 ; - - arg1 = (aiVector3D *)jarg1; - arg2 = (float)jarg2; - result = (aiVector3D *) &(arg1)->operator *=(arg2); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector3D___divnset__(void * jarg1, float jarg2) { - void * jresult ; - aiVector3D *arg1 = (aiVector3D *) 0 ; - float arg2 ; - aiVector3D *result = 0 ; - - arg1 = (aiVector3D *)jarg1; - arg2 = (float)jarg2; - result = (aiVector3D *) &(arg1)->operator /=(arg2); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector3D___mulnset____SWIG_1(void * jarg1, void * jarg2) { - void * jresult ; - aiVector3D *arg1 = (aiVector3D *) 0 ; - aiMatrix3x3 *arg2 = 0 ; - aiVector3D *result = 0 ; - - arg1 = (aiVector3D *)jarg1; - arg2 = (aiMatrix3x3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix3x3 const & type is null", 0); - return 0; - } - result = (aiVector3D *) &(arg1)->operator *=((aiMatrix3x3 const &)*arg2); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector3D___mulnset____SWIG_2(void * jarg1, void * jarg2) { - void * jresult ; - aiVector3D *arg1 = (aiVector3D *) 0 ; - aiMatrix4x4 *arg2 = 0 ; - aiVector3D *result = 0 ; - - arg1 = (aiVector3D *)jarg1; - arg2 = (aiMatrix4x4 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix4x4 const & type is null", 0); - return 0; - } - result = (aiVector3D *) &(arg1)->operator *=((aiMatrix4x4 const &)*arg2); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiVector3D___idx____SWIG_0(void * jarg1, unsigned int jarg2) { - float jresult ; - aiVector3D *arg1 = (aiVector3D *) 0 ; - unsigned int arg2 ; - float result; - - arg1 = (aiVector3D *)jarg1; - arg2 = (unsigned int)jarg2; - result = (float)((aiVector3D const *)arg1)->operator [](arg2); - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiVector3D___equal__(void * jarg1, void * jarg2) { - unsigned int jresult ; - aiVector3D *arg1 = (aiVector3D *) 0 ; - aiVector3D *arg2 = 0 ; - bool result; - - arg1 = (aiVector3D *)jarg1; - arg2 = (aiVector3D *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3D const & type is null", 0); - return 0; - } - result = (bool)((aiVector3D const *)arg1)->operator ==((aiVector3D const &)*arg2); - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiVector3D___nequal__(void * jarg1, void * jarg2) { - unsigned int jresult ; - aiVector3D *arg1 = (aiVector3D *) 0 ; - aiVector3D *arg2 = 0 ; - bool result; - - arg1 = (aiVector3D *)jarg1; - arg2 = (aiVector3D *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3D const & type is null", 0); - return 0; - } - result = (bool)((aiVector3D const *)arg1)->operator !=((aiVector3D const &)*arg2); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3D_Set(void * jarg1, float jarg2, float jarg3, float jarg4) { - aiVector3D *arg1 = (aiVector3D *) 0 ; - float arg2 ; - float arg3 ; - float arg4 = (float) 0. ; - - arg1 = (aiVector3D *)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - arg4 = (float)jarg4; - (arg1)->Set(arg2,arg3,arg4); -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiVector3D_SquareLength(void * jarg1) { - float jresult ; - aiVector3D *arg1 = (aiVector3D *) 0 ; - float result; - - arg1 = (aiVector3D *)jarg1; - result = (float)((aiVector3D const *)arg1)->SquareLength(); - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiVector3D_Length(void * jarg1) { - float jresult ; - aiVector3D *arg1 = (aiVector3D *) 0 ; - float result; - - arg1 = (aiVector3D *)jarg1; - result = (float)((aiVector3D const *)arg1)->Length(); - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector3D_Normalize(void * jarg1) { - void * jresult ; - aiVector3D *arg1 = (aiVector3D *) 0 ; - aiVector3D *result = 0 ; - - arg1 = (aiVector3D *)jarg1; - result = (aiVector3D *) &(arg1)->Normalize(); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector3D_SymMul(void * jarg1, void * jarg2) { - void * jresult ; - aiVector3D *arg1 = (aiVector3D *) 0 ; - aiVector3D *arg2 = 0 ; - aiVector3D result; - - arg1 = (aiVector3D *)jarg1; - arg2 = (aiVector3D *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3D const & type is null", 0); - return 0; - } - result = (arg1)->SymMul((aiVector3D const &)*arg2); - jresult = new aiVector3D((const aiVector3D &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3D_x_set(void * jarg1, float jarg2) { - aiVector3D *arg1 = (aiVector3D *) 0 ; - float arg2 ; - - arg1 = (aiVector3D *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->x = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiVector3D_x_get(void * jarg1) { - float jresult ; - aiVector3D *arg1 = (aiVector3D *) 0 ; - float result; - - arg1 = (aiVector3D *)jarg1; - result = (float) ((arg1)->x); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3D_y_set(void * jarg1, float jarg2) { - aiVector3D *arg1 = (aiVector3D *) 0 ; - float arg2 ; - - arg1 = (aiVector3D *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->y = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiVector3D_y_get(void * jarg1) { - float jresult ; - aiVector3D *arg1 = (aiVector3D *) 0 ; - float result; - - arg1 = (aiVector3D *)jarg1; - result = (float) ((arg1)->y); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3D_z_set(void * jarg1, float jarg2) { - aiVector3D *arg1 = (aiVector3D *) 0 ; - float arg2 ; - - arg1 = (aiVector3D *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->z = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiVector3D_z_get(void * jarg1) { - float jresult ; - aiVector3D *arg1 = (aiVector3D *) 0 ; - float result; - - arg1 = (aiVector3D *)jarg1; - result = (float) ((arg1)->z); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiVector3D(void * jarg1) { - aiVector3D *arg1 = (aiVector3D *) 0 ; - - arg1 = (aiVector3D *)jarg1; - delete arg1; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiColor4D__SWIG_0() { - void * jresult ; - aiColor4D *result = 0 ; - - result = (aiColor4D *)new aiColor4D(); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiColor4D__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) { - void * jresult ; - float arg1 ; - float arg2 ; - float arg3 ; - float arg4 ; - aiColor4D *result = 0 ; - - arg1 = (float)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - arg4 = (float)jarg4; - result = (aiColor4D *)new aiColor4D(arg1,arg2,arg3,arg4); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiColor4D__SWIG_2(float jarg1) { - void * jresult ; - float arg1 ; - aiColor4D *result = 0 ; - - arg1 = (float)jarg1; - result = (aiColor4D *)new aiColor4D(arg1); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiColor4D__SWIG_3(void * jarg1) { - void * jresult ; - aiColor4D *arg1 = 0 ; - aiColor4D *result = 0 ; - - arg1 = (aiColor4D *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiColor4D const & type is null", 0); - return 0; - } - result = (aiColor4D *)new aiColor4D((aiColor4D const &)*arg1); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_aiColor4D___addnset__(void * jarg1, void * jarg2) { - void * jresult ; - aiColor4D *arg1 = (aiColor4D *) 0 ; - aiColor4D *arg2 = 0 ; - aiColor4D *result = 0 ; - - arg1 = (aiColor4D *)jarg1; - arg2 = (aiColor4D *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiColor4D const & type is null", 0); - return 0; - } - result = (aiColor4D *) &(arg1)->operator +=((aiColor4D const &)*arg2); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_aiColor4D___subnset__(void * jarg1, void * jarg2) { - void * jresult ; - aiColor4D *arg1 = (aiColor4D *) 0 ; - aiColor4D *arg2 = 0 ; - aiColor4D *result = 0 ; - - arg1 = (aiColor4D *)jarg1; - arg2 = (aiColor4D *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiColor4D const & type is null", 0); - return 0; - } - result = (aiColor4D *) &(arg1)->operator -=((aiColor4D const &)*arg2); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_aiColor4D___mulnset__(void * jarg1, float jarg2) { - void * jresult ; - aiColor4D *arg1 = (aiColor4D *) 0 ; - float arg2 ; - aiColor4D *result = 0 ; - - arg1 = (aiColor4D *)jarg1; - arg2 = (float)jarg2; - result = (aiColor4D *) &(arg1)->operator *=(arg2); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_aiColor4D___divnset__(void * jarg1, float jarg2) { - void * jresult ; - aiColor4D *arg1 = (aiColor4D *) 0 ; - float arg2 ; - aiColor4D *result = 0 ; - - arg1 = (aiColor4D *)jarg1; - arg2 = (float)jarg2; - result = (aiColor4D *) &(arg1)->operator /=(arg2); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiColor4D___equal__(void * jarg1, void * jarg2) { - unsigned int jresult ; - aiColor4D *arg1 = (aiColor4D *) 0 ; - aiColor4D *arg2 = 0 ; - bool result; - - arg1 = (aiColor4D *)jarg1; - arg2 = (aiColor4D *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiColor4D const & type is null", 0); - return 0; - } - result = (bool)((aiColor4D const *)arg1)->operator ==((aiColor4D const &)*arg2); - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiColor4D___nequal__(void * jarg1, void * jarg2) { - unsigned int jresult ; - aiColor4D *arg1 = (aiColor4D *) 0 ; - aiColor4D *arg2 = 0 ; - bool result; - - arg1 = (aiColor4D *)jarg1; - arg2 = (aiColor4D *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiColor4D const & type is null", 0); - return 0; - } - result = (bool)((aiColor4D const *)arg1)->operator !=((aiColor4D const &)*arg2); - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiColor4D___idx____SWIG_0(void * jarg1, unsigned int jarg2) { - float jresult ; - aiColor4D *arg1 = (aiColor4D *) 0 ; - unsigned int arg2 ; - float result; - - arg1 = (aiColor4D *)jarg1; - arg2 = (unsigned int)jarg2; - result = (float)((aiColor4D const *)arg1)->operator [](arg2); - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiColor4D_IsBlack(void * jarg1) { - unsigned int jresult ; - aiColor4D *arg1 = (aiColor4D *) 0 ; - bool result; - - arg1 = (aiColor4D *)jarg1; - result = (bool)((aiColor4D const *)arg1)->IsBlack(); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4D_r_set(void * jarg1, float jarg2) { - aiColor4D *arg1 = (aiColor4D *) 0 ; - float arg2 ; - - arg1 = (aiColor4D *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->r = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiColor4D_r_get(void * jarg1) { - float jresult ; - aiColor4D *arg1 = (aiColor4D *) 0 ; - float result; - - arg1 = (aiColor4D *)jarg1; - result = (float) ((arg1)->r); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4D_g_set(void * jarg1, float jarg2) { - aiColor4D *arg1 = (aiColor4D *) 0 ; - float arg2 ; - - arg1 = (aiColor4D *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->g = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiColor4D_g_get(void * jarg1) { - float jresult ; - aiColor4D *arg1 = (aiColor4D *) 0 ; - float result; - - arg1 = (aiColor4D *)jarg1; - result = (float) ((arg1)->g); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4D_b_set(void * jarg1, float jarg2) { - aiColor4D *arg1 = (aiColor4D *) 0 ; - float arg2 ; - - arg1 = (aiColor4D *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->b = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiColor4D_b_get(void * jarg1) { - float jresult ; - aiColor4D *arg1 = (aiColor4D *) 0 ; - float result; - - arg1 = (aiColor4D *)jarg1; - result = (float) ((arg1)->b); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4D_a_set(void * jarg1, float jarg2) { - aiColor4D *arg1 = (aiColor4D *) 0 ; - float arg2 ; - - arg1 = (aiColor4D *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->a = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiColor4D_a_get(void * jarg1) { - float jresult ; - aiColor4D *arg1 = (aiColor4D *) 0 ; - float result; - - arg1 = (aiColor4D *)jarg1; - result = (float) ((arg1)->a); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiColor4D(void * jarg1) { - aiColor4D *arg1 = (aiColor4D *) 0 ; - - arg1 = (aiColor4D *)jarg1; - delete arg1; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiMatrix3x3__SWIG_0() { - void * jresult ; - aiMatrix3x3 *result = 0 ; - - result = (aiMatrix3x3 *)new aiMatrix3x3(); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiMatrix3x3__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7, float jarg8, float jarg9) { - void * jresult ; - float arg1 ; - float arg2 ; - float arg3 ; - float arg4 ; - float arg5 ; - float arg6 ; - float arg7 ; - float arg8 ; - float arg9 ; - aiMatrix3x3 *result = 0 ; - - arg1 = (float)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - arg4 = (float)jarg4; - arg5 = (float)jarg5; - arg6 = (float)jarg6; - arg7 = (float)jarg7; - arg8 = (float)jarg8; - arg9 = (float)jarg9; - result = (aiMatrix3x3 *)new aiMatrix3x3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiMatrix3x3__SWIG_2(void * jarg1) { - void * jresult ; - aiMatrix4x4 *arg1 = 0 ; - aiMatrix3x3 *result = 0 ; - - arg1 = (aiMatrix4x4 *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix4x4 const & type is null", 0); - return 0; - } - result = (aiMatrix3x3 *)new aiMatrix3x3((aiMatrix4x4 const &)*arg1); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix3x3_Transpose(void * jarg1) { - void * jresult ; - aiMatrix3x3 *arg1 = (aiMatrix3x3 *) 0 ; - aiMatrix3x3 *result = 0 ; - - arg1 = (aiMatrix3x3 *)jarg1; - result = (aiMatrix3x3 *) &(arg1)->Transpose(); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix3x3_Inverse(void * jarg1) { - void * jresult ; - aiMatrix3x3 *arg1 = (aiMatrix3x3 *) 0 ; - aiMatrix3x3 *result = 0 ; - - arg1 = (aiMatrix3x3 *)jarg1; - result = (aiMatrix3x3 *) &(arg1)->Inverse(); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix3x3_Determinant(void * jarg1) { - float jresult ; - aiMatrix3x3 *arg1 = (aiMatrix3x3 *) 0 ; - float result; - - arg1 = (aiMatrix3x3 *)jarg1; - result = (float)((aiMatrix3x3 const *)arg1)->Determinant(); - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix3x3_RotationZ(float jarg1, void * jarg2) { - void * jresult ; - float arg1 ; - aiMatrix3x3 *arg2 = 0 ; - aiMatrix3x3 *result = 0 ; - - arg1 = (float)jarg1; - arg2 = (aiMatrix3x3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix3x3 & type is null", 0); - return 0; - } - result = (aiMatrix3x3 *) &aiMatrix3x3::RotationZ(arg1,*arg2); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix3x3_Rotation(float jarg1, void * jarg2, void * jarg3) { - void * jresult ; - float arg1 ; - aiVector3D *arg2 = 0 ; - aiMatrix3x3 *arg3 = 0 ; - aiMatrix3x3 *result = 0 ; - - arg1 = (float)jarg1; - arg2 = (aiVector3D *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3D const & type is null", 0); - return 0; - } - arg3 = (aiMatrix3x3 *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix3x3 & type is null", 0); - return 0; - } - result = (aiMatrix3x3 *) &aiMatrix3x3::Rotation(arg1,(aiVector3D const &)*arg2,*arg3); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix3x3_Translation(void * jarg1, void * jarg2) { - void * jresult ; - aiVector2D *arg1 = 0 ; - aiMatrix3x3 *arg2 = 0 ; - aiMatrix3x3 *result = 0 ; - - arg1 = (aiVector2D *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2D const & type is null", 0); - return 0; - } - arg2 = (aiMatrix3x3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix3x3 & type is null", 0); - return 0; - } - result = (aiMatrix3x3 *) &aiMatrix3x3::Translation((aiVector2D const &)*arg1,*arg2); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix3x3_FromToMatrix(void * jarg1, void * jarg2, void * jarg3) { - void * jresult ; - aiVector3D *arg1 = 0 ; - aiVector3D *arg2 = 0 ; - aiMatrix3x3 *arg3 = 0 ; - aiMatrix3x3 *result = 0 ; - - arg1 = (aiVector3D *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3D const & type is null", 0); - return 0; - } - arg2 = (aiVector3D *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3D const & type is null", 0); - return 0; - } - arg3 = (aiMatrix3x3 *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix3x3 & type is null", 0); - return 0; - } - result = (aiMatrix3x3 *) &aiMatrix3x3::FromToMatrix((aiVector3D const &)*arg1,(aiVector3D const &)*arg2,*arg3); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix3x3_a1_set(void * jarg1, float jarg2) { - aiMatrix3x3 *arg1 = (aiMatrix3x3 *) 0 ; - float arg2 ; - - arg1 = (aiMatrix3x3 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->a1 = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix3x3_a1_get(void * jarg1) { - float jresult ; - aiMatrix3x3 *arg1 = (aiMatrix3x3 *) 0 ; - float result; - - arg1 = (aiMatrix3x3 *)jarg1; - result = (float) ((arg1)->a1); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix3x3_a2_set(void * jarg1, float jarg2) { - aiMatrix3x3 *arg1 = (aiMatrix3x3 *) 0 ; - float arg2 ; - - arg1 = (aiMatrix3x3 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->a2 = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix3x3_a2_get(void * jarg1) { - float jresult ; - aiMatrix3x3 *arg1 = (aiMatrix3x3 *) 0 ; - float result; - - arg1 = (aiMatrix3x3 *)jarg1; - result = (float) ((arg1)->a2); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix3x3_a3_set(void * jarg1, float jarg2) { - aiMatrix3x3 *arg1 = (aiMatrix3x3 *) 0 ; - float arg2 ; - - arg1 = (aiMatrix3x3 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->a3 = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix3x3_a3_get(void * jarg1) { - float jresult ; - aiMatrix3x3 *arg1 = (aiMatrix3x3 *) 0 ; - float result; - - arg1 = (aiMatrix3x3 *)jarg1; - result = (float) ((arg1)->a3); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix3x3_b1_set(void * jarg1, float jarg2) { - aiMatrix3x3 *arg1 = (aiMatrix3x3 *) 0 ; - float arg2 ; - - arg1 = (aiMatrix3x3 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->b1 = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix3x3_b1_get(void * jarg1) { - float jresult ; - aiMatrix3x3 *arg1 = (aiMatrix3x3 *) 0 ; - float result; - - arg1 = (aiMatrix3x3 *)jarg1; - result = (float) ((arg1)->b1); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix3x3_b2_set(void * jarg1, float jarg2) { - aiMatrix3x3 *arg1 = (aiMatrix3x3 *) 0 ; - float arg2 ; - - arg1 = (aiMatrix3x3 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->b2 = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix3x3_b2_get(void * jarg1) { - float jresult ; - aiMatrix3x3 *arg1 = (aiMatrix3x3 *) 0 ; - float result; - - arg1 = (aiMatrix3x3 *)jarg1; - result = (float) ((arg1)->b2); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix3x3_b3_set(void * jarg1, float jarg2) { - aiMatrix3x3 *arg1 = (aiMatrix3x3 *) 0 ; - float arg2 ; - - arg1 = (aiMatrix3x3 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->b3 = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix3x3_b3_get(void * jarg1) { - float jresult ; - aiMatrix3x3 *arg1 = (aiMatrix3x3 *) 0 ; - float result; - - arg1 = (aiMatrix3x3 *)jarg1; - result = (float) ((arg1)->b3); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix3x3_c1_set(void * jarg1, float jarg2) { - aiMatrix3x3 *arg1 = (aiMatrix3x3 *) 0 ; - float arg2 ; - - arg1 = (aiMatrix3x3 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->c1 = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix3x3_c1_get(void * jarg1) { - float jresult ; - aiMatrix3x3 *arg1 = (aiMatrix3x3 *) 0 ; - float result; - - arg1 = (aiMatrix3x3 *)jarg1; - result = (float) ((arg1)->c1); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix3x3_c2_set(void * jarg1, float jarg2) { - aiMatrix3x3 *arg1 = (aiMatrix3x3 *) 0 ; - float arg2 ; - - arg1 = (aiMatrix3x3 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->c2 = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix3x3_c2_get(void * jarg1) { - float jresult ; - aiMatrix3x3 *arg1 = (aiMatrix3x3 *) 0 ; - float result; - - arg1 = (aiMatrix3x3 *)jarg1; - result = (float) ((arg1)->c2); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix3x3_c3_set(void * jarg1, float jarg2) { - aiMatrix3x3 *arg1 = (aiMatrix3x3 *) 0 ; - float arg2 ; - - arg1 = (aiMatrix3x3 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->c3 = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix3x3_c3_get(void * jarg1) { - float jresult ; - aiMatrix3x3 *arg1 = (aiMatrix3x3 *) 0 ; - float result; - - arg1 = (aiMatrix3x3 *)jarg1; - result = (float) ((arg1)->c3); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiMatrix3x3(void * jarg1) { - aiMatrix3x3 *arg1 = (aiMatrix3x3 *) 0 ; - - arg1 = (aiMatrix3x3 *)jarg1; - delete arg1; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiMatrix4x4__SWIG_0() { - void * jresult ; - aiMatrix4x4 *result = 0 ; - - result = (aiMatrix4x4 *)new aiMatrix4x4(); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiMatrix4x4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7, float jarg8, float jarg9, float jarg10, float jarg11, float jarg12, float jarg13, float jarg14, float jarg15, float jarg16) { - void * jresult ; - float arg1 ; - float arg2 ; - float arg3 ; - float arg4 ; - float arg5 ; - float arg6 ; - float arg7 ; - float arg8 ; - float arg9 ; - float arg10 ; - float arg11 ; - float arg12 ; - float arg13 ; - float arg14 ; - float arg15 ; - float arg16 ; - aiMatrix4x4 *result = 0 ; - - arg1 = (float)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - arg4 = (float)jarg4; - arg5 = (float)jarg5; - arg6 = (float)jarg6; - arg7 = (float)jarg7; - arg8 = (float)jarg8; - arg9 = (float)jarg9; - arg10 = (float)jarg10; - arg11 = (float)jarg11; - arg12 = (float)jarg12; - arg13 = (float)jarg13; - arg14 = (float)jarg14; - arg15 = (float)jarg15; - arg16 = (float)jarg16; - result = (aiMatrix4x4 *)new aiMatrix4x4(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiMatrix4x4__SWIG_2(void * jarg1) { - void * jresult ; - aiMatrix3x3 *arg1 = 0 ; - aiMatrix4x4 *result = 0 ; - - arg1 = (aiMatrix3x3 *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix3x3 const & type is null", 0); - return 0; - } - result = (aiMatrix4x4 *)new aiMatrix4x4((aiMatrix3x3 const &)*arg1); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix4x4_Transpose(void * jarg1) { - void * jresult ; - aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ; - aiMatrix4x4 *result = 0 ; - - arg1 = (aiMatrix4x4 *)jarg1; - result = (aiMatrix4x4 *) &(arg1)->Transpose(); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix4x4_Inverse(void * jarg1) { - void * jresult ; - aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ; - aiMatrix4x4 *result = 0 ; - - arg1 = (aiMatrix4x4 *)jarg1; - result = (aiMatrix4x4 *) &(arg1)->Inverse(); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_Determinant(void * jarg1) { - float jresult ; - aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ; - float result; - - arg1 = (aiMatrix4x4 *)jarg1; - result = (float)((aiMatrix4x4 const *)arg1)->Determinant(); - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMatrix4x4_IsIdentity(void * jarg1) { - unsigned int jresult ; - aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ; - bool result; - - arg1 = (aiMatrix4x4 *)jarg1; - result = (bool)((aiMatrix4x4 const *)arg1)->IsIdentity(); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_Decompose(void * jarg1, void * jarg2, void * jarg3, void * jarg4) { - aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ; - aiVector3D *arg2 = 0 ; - aiQuaternion *arg3 = 0 ; - aiVector3D *arg4 = 0 ; - - arg1 = (aiMatrix4x4 *)jarg1; - arg2 = (aiVector3D *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3D & type is null", 0); - return ; - } - arg3 = (aiQuaternion *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiQuaternion & type is null", 0); - return ; - } - arg4 = (aiVector3D *)jarg4; - if (!arg4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3D & type is null", 0); - return ; - } - ((aiMatrix4x4 const *)arg1)->Decompose(*arg2,*arg3,*arg4); -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_DecomposeNoScaling(void * jarg1, void * jarg2, void * jarg3) { - aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ; - aiQuaternion *arg2 = 0 ; - aiVector3D *arg3 = 0 ; - - arg1 = (aiMatrix4x4 *)jarg1; - arg2 = (aiQuaternion *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiQuaternion & type is null", 0); - return ; - } - arg3 = (aiVector3D *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3D & type is null", 0); - return ; - } - ((aiMatrix4x4 const *)arg1)->DecomposeNoScaling(*arg2,*arg3); -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix4x4_FromEulerAnglesXYZ__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) { - void * jresult ; - aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ; - float arg2 ; - float arg3 ; - float arg4 ; - aiMatrix4x4 *result = 0 ; - - arg1 = (aiMatrix4x4 *)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - arg4 = (float)jarg4; - result = (aiMatrix4x4 *) &(arg1)->FromEulerAnglesXYZ(arg2,arg3,arg4); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix4x4_FromEulerAnglesXYZ__SWIG_1(void * jarg1, void * jarg2) { - void * jresult ; - aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ; - aiVector3D *arg2 = 0 ; - aiMatrix4x4 *result = 0 ; - - arg1 = (aiMatrix4x4 *)jarg1; - arg2 = (aiVector3D *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3D const & type is null", 0); - return 0; - } - result = (aiMatrix4x4 *) &(arg1)->FromEulerAnglesXYZ((aiVector3D const &)*arg2); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix4x4_RotationX(float jarg1, void * jarg2) { - void * jresult ; - float arg1 ; - aiMatrix4x4 *arg2 = 0 ; - aiMatrix4x4 *result = 0 ; - - arg1 = (float)jarg1; - arg2 = (aiMatrix4x4 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix4x4 & type is null", 0); - return 0; - } - result = (aiMatrix4x4 *) &aiMatrix4x4::RotationX(arg1,*arg2); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix4x4_RotationY(float jarg1, void * jarg2) { - void * jresult ; - float arg1 ; - aiMatrix4x4 *arg2 = 0 ; - aiMatrix4x4 *result = 0 ; - - arg1 = (float)jarg1; - arg2 = (aiMatrix4x4 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix4x4 & type is null", 0); - return 0; - } - result = (aiMatrix4x4 *) &aiMatrix4x4::RotationY(arg1,*arg2); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix4x4_RotationZ(float jarg1, void * jarg2) { - void * jresult ; - float arg1 ; - aiMatrix4x4 *arg2 = 0 ; - aiMatrix4x4 *result = 0 ; - - arg1 = (float)jarg1; - arg2 = (aiMatrix4x4 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix4x4 & type is null", 0); - return 0; - } - result = (aiMatrix4x4 *) &aiMatrix4x4::RotationZ(arg1,*arg2); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix4x4_Rotation(float jarg1, void * jarg2, void * jarg3) { - void * jresult ; - float arg1 ; - aiVector3D *arg2 = 0 ; - aiMatrix4x4 *arg3 = 0 ; - aiMatrix4x4 *result = 0 ; - - arg1 = (float)jarg1; - arg2 = (aiVector3D *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3D const & type is null", 0); - return 0; - } - arg3 = (aiMatrix4x4 *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix4x4 & type is null", 0); - return 0; - } - result = (aiMatrix4x4 *) &aiMatrix4x4::Rotation(arg1,(aiVector3D const &)*arg2,*arg3); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix4x4_Translation(void * jarg1, void * jarg2) { - void * jresult ; - aiVector3D *arg1 = 0 ; - aiMatrix4x4 *arg2 = 0 ; - aiMatrix4x4 *result = 0 ; - - arg1 = (aiVector3D *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3D const & type is null", 0); - return 0; - } - arg2 = (aiMatrix4x4 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix4x4 & type is null", 0); - return 0; - } - result = (aiMatrix4x4 *) &aiMatrix4x4::Translation((aiVector3D const &)*arg1,*arg2); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix4x4_Scaling(void * jarg1, void * jarg2) { - void * jresult ; - aiVector3D *arg1 = 0 ; - aiMatrix4x4 *arg2 = 0 ; - aiMatrix4x4 *result = 0 ; - - arg1 = (aiVector3D *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3D const & type is null", 0); - return 0; - } - arg2 = (aiMatrix4x4 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix4x4 & type is null", 0); - return 0; - } - result = (aiMatrix4x4 *) &aiMatrix4x4::Scaling((aiVector3D const &)*arg1,*arg2); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix4x4_FromToMatrix(void * jarg1, void * jarg2, void * jarg3) { - void * jresult ; - aiVector3D *arg1 = 0 ; - aiVector3D *arg2 = 0 ; - aiMatrix4x4 *arg3 = 0 ; - aiMatrix4x4 *result = 0 ; - - arg1 = (aiVector3D *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3D const & type is null", 0); - return 0; - } - arg2 = (aiVector3D *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3D const & type is null", 0); - return 0; - } - arg3 = (aiMatrix4x4 *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix4x4 & type is null", 0); - return 0; - } - result = (aiMatrix4x4 *) &aiMatrix4x4::FromToMatrix((aiVector3D const &)*arg1,(aiVector3D const &)*arg2,*arg3); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_a1_set(void * jarg1, float jarg2) { - aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ; - float arg2 ; - - arg1 = (aiMatrix4x4 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->a1 = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_a1_get(void * jarg1) { - float jresult ; - aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ; - float result; - - arg1 = (aiMatrix4x4 *)jarg1; - result = (float) ((arg1)->a1); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_a2_set(void * jarg1, float jarg2) { - aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ; - float arg2 ; - - arg1 = (aiMatrix4x4 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->a2 = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_a2_get(void * jarg1) { - float jresult ; - aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ; - float result; - - arg1 = (aiMatrix4x4 *)jarg1; - result = (float) ((arg1)->a2); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_a3_set(void * jarg1, float jarg2) { - aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ; - float arg2 ; - - arg1 = (aiMatrix4x4 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->a3 = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_a3_get(void * jarg1) { - float jresult ; - aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ; - float result; - - arg1 = (aiMatrix4x4 *)jarg1; - result = (float) ((arg1)->a3); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_a4_set(void * jarg1, float jarg2) { - aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ; - float arg2 ; - - arg1 = (aiMatrix4x4 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->a4 = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_a4_get(void * jarg1) { - float jresult ; - aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ; - float result; - - arg1 = (aiMatrix4x4 *)jarg1; - result = (float) ((arg1)->a4); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_b1_set(void * jarg1, float jarg2) { - aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ; - float arg2 ; - - arg1 = (aiMatrix4x4 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->b1 = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_b1_get(void * jarg1) { - float jresult ; - aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ; - float result; - - arg1 = (aiMatrix4x4 *)jarg1; - result = (float) ((arg1)->b1); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_b2_set(void * jarg1, float jarg2) { - aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ; - float arg2 ; - - arg1 = (aiMatrix4x4 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->b2 = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_b2_get(void * jarg1) { - float jresult ; - aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ; - float result; - - arg1 = (aiMatrix4x4 *)jarg1; - result = (float) ((arg1)->b2); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_b3_set(void * jarg1, float jarg2) { - aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ; - float arg2 ; - - arg1 = (aiMatrix4x4 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->b3 = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_b3_get(void * jarg1) { - float jresult ; - aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ; - float result; - - arg1 = (aiMatrix4x4 *)jarg1; - result = (float) ((arg1)->b3); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_b4_set(void * jarg1, float jarg2) { - aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ; - float arg2 ; - - arg1 = (aiMatrix4x4 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->b4 = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_b4_get(void * jarg1) { - float jresult ; - aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ; - float result; - - arg1 = (aiMatrix4x4 *)jarg1; - result = (float) ((arg1)->b4); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_c1_set(void * jarg1, float jarg2) { - aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ; - float arg2 ; - - arg1 = (aiMatrix4x4 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->c1 = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_c1_get(void * jarg1) { - float jresult ; - aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ; - float result; - - arg1 = (aiMatrix4x4 *)jarg1; - result = (float) ((arg1)->c1); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_c2_set(void * jarg1, float jarg2) { - aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ; - float arg2 ; - - arg1 = (aiMatrix4x4 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->c2 = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_c2_get(void * jarg1) { - float jresult ; - aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ; - float result; - - arg1 = (aiMatrix4x4 *)jarg1; - result = (float) ((arg1)->c2); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_c3_set(void * jarg1, float jarg2) { - aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ; - float arg2 ; - - arg1 = (aiMatrix4x4 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->c3 = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_c3_get(void * jarg1) { - float jresult ; - aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ; - float result; - - arg1 = (aiMatrix4x4 *)jarg1; - result = (float) ((arg1)->c3); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_c4_set(void * jarg1, float jarg2) { - aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ; - float arg2 ; - - arg1 = (aiMatrix4x4 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->c4 = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_c4_get(void * jarg1) { - float jresult ; - aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ; - float result; - - arg1 = (aiMatrix4x4 *)jarg1; - result = (float) ((arg1)->c4); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_d1_set(void * jarg1, float jarg2) { - aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ; - float arg2 ; - - arg1 = (aiMatrix4x4 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->d1 = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_d1_get(void * jarg1) { - float jresult ; - aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ; - float result; - - arg1 = (aiMatrix4x4 *)jarg1; - result = (float) ((arg1)->d1); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_d2_set(void * jarg1, float jarg2) { - aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ; - float arg2 ; - - arg1 = (aiMatrix4x4 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->d2 = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_d2_get(void * jarg1) { - float jresult ; - aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ; - float result; - - arg1 = (aiMatrix4x4 *)jarg1; - result = (float) ((arg1)->d2); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_d3_set(void * jarg1, float jarg2) { - aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ; - float arg2 ; - - arg1 = (aiMatrix4x4 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->d3 = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_d3_get(void * jarg1) { - float jresult ; - aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ; - float result; - - arg1 = (aiMatrix4x4 *)jarg1; - result = (float) ((arg1)->d3); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_d4_set(void * jarg1, float jarg2) { - aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ; - float arg2 ; - - arg1 = (aiMatrix4x4 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->d4 = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_d4_get(void * jarg1) { - float jresult ; - aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ; - float result; - - arg1 = (aiMatrix4x4 *)jarg1; - result = (float) ((arg1)->d4); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiMatrix4x4(void * jarg1) { - aiMatrix4x4 *arg1 = (aiMatrix4x4 *) 0 ; - - arg1 = (aiMatrix4x4 *)jarg1; - delete arg1; -} - - SWIGEXPORT void SWIGSTDCALL CSharp_aiCamera_mName_set(void * jarg1, void * jarg2) { aiCamera *arg1 = (aiCamera *) 0 ; aiString *arg2 = (aiString *) 0 ; @@ -8300,7 +6236,7 @@ SWIGEXPORT int SWIGSTDCALL CSharp_AI_MAX_NUMBER_OF_COLOR_SETS_get() { int jresult ; int result; - result = (int)(0x4); + result = (int)(0x8); jresult = result; return jresult; } @@ -8310,7 +6246,7 @@ SWIGEXPORT int SWIGSTDCALL CSharp_AI_MAX_NUMBER_OF_TEXTURECOORDS_get() { int jresult ; int result; - result = (int)(0x4); + result = (int)(0x8); jresult = result; return jresult; } @@ -9166,16 +7102,6 @@ SWIGEXPORT char * SWIGSTDCALL CSharp_AI_DEFAULT_MATERIAL_NAME_get() { } -SWIGEXPORT char * SWIGSTDCALL CSharp_AI_DEFAULT_TEXTURED_MATERIAL_NAME_get() { - char * jresult ; - char *result = 0 ; - - result = (char *)("TexturedDefaultMaterial"); - jresult = SWIG_csharp_string_callback((const char *)result); - return jresult; -} - - SWIGEXPORT void SWIGSTDCALL CSharp_aiUVTransform_mTranslation_set(void * jarg1, void * jarg2) { aiUVTransform *arg1 = (aiUVTransform *) 0 ; aiVector2D *arg2 = (aiVector2D *) 0 ; @@ -9377,7 +7303,7 @@ SWIGEXPORT void SWIGSTDCALL CSharp_aiMaterialProperty_mData_set(void * jarg1, ch arg1 = (aiMaterialProperty *)jarg1; arg2 = (char *)jarg2; { - if (arg1->mData) delete [] arg1->mData; + delete [] arg1->mData; if (arg2) { arg1->mData = (char *) (new char[strlen((const char *)arg2)+1]); strcpy((char *)arg1->mData, (const char *)arg2); @@ -9450,6 +7376,150 @@ SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMaterial_GetTextureCount(void * jar } +SWIGEXPORT int SWIGSTDCALL CSharp_aiMaterial_AddBinaryProperty(void * jarg1, void * jarg2, unsigned int jarg3, char * jarg4, unsigned int jarg5, unsigned int jarg6, int jarg7) { + int jresult ; + aiMaterial *arg1 = (aiMaterial *) 0 ; + void *arg2 = (void *) 0 ; + unsigned int arg3 ; + char *arg4 = (char *) 0 ; + unsigned int arg5 ; + unsigned int arg6 ; + aiPropertyTypeInfo arg7 ; + aiReturn result; + + arg1 = (aiMaterial *)jarg1; + arg2 = (void *)jarg2; + arg3 = (unsigned int)jarg3; + arg4 = (char *)jarg4; + arg5 = (unsigned int)jarg5; + arg6 = (unsigned int)jarg6; + arg7 = (aiPropertyTypeInfo)jarg7; + result = (aiReturn)(arg1)->AddBinaryProperty((void const *)arg2,arg3,(char const *)arg4,arg5,arg6,arg7); + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_aiMaterial_AddProperty__SWIG_0(void * jarg1, void * jarg2, char * jarg3, unsigned int jarg4, unsigned int jarg5) { + int jresult ; + aiMaterial *arg1 = (aiMaterial *) 0 ; + aiString *arg2 = (aiString *) 0 ; + char *arg3 = (char *) 0 ; + unsigned int arg4 ; + unsigned int arg5 ; + aiReturn result; + + arg1 = (aiMaterial *)jarg1; + arg2 = (aiString *)jarg2; + arg3 = (char *)jarg3; + arg4 = (unsigned int)jarg4; + arg5 = (unsigned int)jarg5; + result = (aiReturn)(arg1)->AddProperty((aiString const *)arg2,(char const *)arg3,arg4,arg5); + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_aiMaterial_AddProperty__SWIG_1(void * jarg1, void * jarg2, char * jarg3, unsigned int jarg4) { + int jresult ; + aiMaterial *arg1 = (aiMaterial *) 0 ; + aiString *arg2 = (aiString *) 0 ; + char *arg3 = (char *) 0 ; + unsigned int arg4 ; + aiReturn result; + + arg1 = (aiMaterial *)jarg1; + arg2 = (aiString *)jarg2; + arg3 = (char *)jarg3; + arg4 = (unsigned int)jarg4; + result = (aiReturn)(arg1)->AddProperty((aiString const *)arg2,(char const *)arg3,arg4); + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_aiMaterial_AddProperty__SWIG_2(void * jarg1, void * jarg2, char * jarg3) { + int jresult ; + aiMaterial *arg1 = (aiMaterial *) 0 ; + aiString *arg2 = (aiString *) 0 ; + char *arg3 = (char *) 0 ; + aiReturn result; + + arg1 = (aiMaterial *)jarg1; + arg2 = (aiString *)jarg2; + arg3 = (char *)jarg3; + result = (aiReturn)(arg1)->AddProperty((aiString const *)arg2,(char const *)arg3); + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_aiMaterial_RemoveProperty__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3, unsigned int jarg4) { + int jresult ; + aiMaterial *arg1 = (aiMaterial *) 0 ; + char *arg2 = (char *) 0 ; + unsigned int arg3 ; + unsigned int arg4 ; + aiReturn result; + + arg1 = (aiMaterial *)jarg1; + arg2 = (char *)jarg2; + arg3 = (unsigned int)jarg3; + arg4 = (unsigned int)jarg4; + result = (aiReturn)(arg1)->RemoveProperty((char const *)arg2,arg3,arg4); + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_aiMaterial_RemoveProperty__SWIG_1(void * jarg1, char * jarg2, unsigned int jarg3) { + int jresult ; + aiMaterial *arg1 = (aiMaterial *) 0 ; + char *arg2 = (char *) 0 ; + unsigned int arg3 ; + aiReturn result; + + arg1 = (aiMaterial *)jarg1; + arg2 = (char *)jarg2; + arg3 = (unsigned int)jarg3; + result = (aiReturn)(arg1)->RemoveProperty((char const *)arg2,arg3); + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_aiMaterial_RemoveProperty__SWIG_2(void * jarg1, char * jarg2) { + int jresult ; + aiMaterial *arg1 = (aiMaterial *) 0 ; + char *arg2 = (char *) 0 ; + aiReturn result; + + arg1 = (aiMaterial *)jarg1; + arg2 = (char *)jarg2; + result = (aiReturn)(arg1)->RemoveProperty((char const *)arg2); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiMaterial_Clear(void * jarg1) { + aiMaterial *arg1 = (aiMaterial *) 0 ; + + arg1 = (aiMaterial *)jarg1; + (arg1)->Clear(); +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiMaterial_CopyPropertyList(void * jarg1, void * jarg2) { + aiMaterial *arg1 = (aiMaterial *) 0 ; + aiMaterial *arg2 = (aiMaterial *) 0 ; + + arg1 = (aiMaterial *)jarg1; + arg2 = (aiMaterial *)jarg2; + aiMaterial::CopyPropertyList(arg1,(aiMaterial const *)arg2); +} + + SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMaterial_GetDiffuse(void * jarg1, void * jarg2) { unsigned int jresult ; aiMaterial *arg1 = (aiMaterial *) 0 ; @@ -9844,334 +7914,6 @@ SWIGEXPORT char * SWIGSTDCALL CSharp__AI_MATKEY_TEXFLAGS_BASE_get() { } -SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiQuaternion__SWIG_0() { - void * jresult ; - aiQuaternion *result = 0 ; - - result = (aiQuaternion *)new aiQuaternion(); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiQuaternion__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) { - void * jresult ; - float arg1 ; - float arg2 ; - float arg3 ; - float arg4 ; - aiQuaternion *result = 0 ; - - arg1 = (float)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - arg4 = (float)jarg4; - result = (aiQuaternion *)new aiQuaternion(arg1,arg2,arg3,arg4); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiQuaternion__SWIG_2(void * jarg1) { - void * jresult ; - aiMatrix3x3 *arg1 = 0 ; - aiQuaternion *result = 0 ; - - arg1 = (aiMatrix3x3 *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix3x3 const & type is null", 0); - return 0; - } - result = (aiQuaternion *)new aiQuaternion((aiMatrix3x3 const &)*arg1); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiQuaternion__SWIG_3(float jarg1, float jarg2, float jarg3) { - void * jresult ; - float arg1 ; - float arg2 ; - float arg3 ; - aiQuaternion *result = 0 ; - - arg1 = (float)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - result = (aiQuaternion *)new aiQuaternion(arg1,arg2,arg3); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiQuaternion__SWIG_4(void * jarg1, float jarg2) { - void * jresult ; - aiVector3D arg1 ; - float arg2 ; - aiVector3D *argp1 ; - aiQuaternion *result = 0 ; - - argp1 = (aiVector3D *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null aiVector3D", 0); - return 0; - } - arg1 = *argp1; - arg2 = (float)jarg2; - result = (aiQuaternion *)new aiQuaternion(arg1,arg2); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiQuaternion__SWIG_5(void * jarg1) { - void * jresult ; - aiVector3D arg1 ; - aiVector3D *argp1 ; - aiQuaternion *result = 0 ; - - argp1 = (aiVector3D *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null aiVector3D", 0); - return 0; - } - arg1 = *argp1; - result = (aiQuaternion *)new aiQuaternion(arg1); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_aiQuaternion_GetMatrix(void * jarg1) { - void * jresult ; - aiQuaternion *arg1 = (aiQuaternion *) 0 ; - aiMatrix3x3 result; - - arg1 = (aiQuaternion *)jarg1; - result = ((aiQuaternion const *)arg1)->GetMatrix(); - jresult = new aiMatrix3x3((const aiMatrix3x3 &)result); - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiQuaternion___equal__(void * jarg1, void * jarg2) { - unsigned int jresult ; - aiQuaternion *arg1 = (aiQuaternion *) 0 ; - aiQuaternion *arg2 = 0 ; - bool result; - - arg1 = (aiQuaternion *)jarg1; - arg2 = (aiQuaternion *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiQuaternion const & type is null", 0); - return 0; - } - result = (bool)((aiQuaternion const *)arg1)->operator ==((aiQuaternion const &)*arg2); - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiQuaternion___nequal__(void * jarg1, void * jarg2) { - unsigned int jresult ; - aiQuaternion *arg1 = (aiQuaternion *) 0 ; - aiQuaternion *arg2 = 0 ; - bool result; - - arg1 = (aiQuaternion *)jarg1; - arg2 = (aiQuaternion *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiQuaternion const & type is null", 0); - return 0; - } - result = (bool)((aiQuaternion const *)arg1)->operator !=((aiQuaternion const &)*arg2); - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_aiQuaternion_Normalize(void * jarg1) { - void * jresult ; - aiQuaternion *arg1 = (aiQuaternion *) 0 ; - aiQuaternion *result = 0 ; - - arg1 = (aiQuaternion *)jarg1; - result = (aiQuaternion *) &(arg1)->Normalize(); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_aiQuaternion_Conjugate(void * jarg1) { - void * jresult ; - aiQuaternion *arg1 = (aiQuaternion *) 0 ; - aiQuaternion *result = 0 ; - - arg1 = (aiQuaternion *)jarg1; - result = (aiQuaternion *) &(arg1)->Conjugate(); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_aiQuaternion_Rotate(void * jarg1, void * jarg2) { - void * jresult ; - aiQuaternion *arg1 = (aiQuaternion *) 0 ; - aiVector3D *arg2 = 0 ; - aiVector3D result; - - arg1 = (aiQuaternion *)jarg1; - arg2 = (aiVector3D *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3D const & type is null", 0); - return 0; - } - result = (arg1)->Rotate((aiVector3D const &)*arg2); - jresult = new aiVector3D((const aiVector3D &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_aiQuaternion___mul__(void * jarg1, void * jarg2) { - void * jresult ; - aiQuaternion *arg1 = (aiQuaternion *) 0 ; - aiQuaternion *arg2 = 0 ; - aiQuaternion result; - - arg1 = (aiQuaternion *)jarg1; - arg2 = (aiQuaternion *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiQuaternion const & type is null", 0); - return 0; - } - result = ((aiQuaternion const *)arg1)->operator *((aiQuaternion const &)*arg2); - jresult = new aiQuaternion((const aiQuaternion &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_aiQuaternion_Interpolate(void * jarg1, void * jarg2, void * jarg3, float jarg4) { - aiQuaternion *arg1 = 0 ; - aiQuaternion *arg2 = 0 ; - aiQuaternion *arg3 = 0 ; - float arg4 ; - - arg1 = (aiQuaternion *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiQuaternion & type is null", 0); - return ; - } - arg2 = (aiQuaternion *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiQuaternion const & type is null", 0); - return ; - } - arg3 = (aiQuaternion *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiQuaternion const & type is null", 0); - return ; - } - arg4 = (float)jarg4; - aiQuaternion::Interpolate(*arg1,(aiQuaternion const &)*arg2,(aiQuaternion const &)*arg3,arg4); -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_aiQuaternion_w_set(void * jarg1, float jarg2) { - aiQuaternion *arg1 = (aiQuaternion *) 0 ; - float arg2 ; - - arg1 = (aiQuaternion *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->w = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiQuaternion_w_get(void * jarg1) { - float jresult ; - aiQuaternion *arg1 = (aiQuaternion *) 0 ; - float result; - - arg1 = (aiQuaternion *)jarg1; - result = (float) ((arg1)->w); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_aiQuaternion_x_set(void * jarg1, float jarg2) { - aiQuaternion *arg1 = (aiQuaternion *) 0 ; - float arg2 ; - - arg1 = (aiQuaternion *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->x = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiQuaternion_x_get(void * jarg1) { - float jresult ; - aiQuaternion *arg1 = (aiQuaternion *) 0 ; - float result; - - arg1 = (aiQuaternion *)jarg1; - result = (float) ((arg1)->x); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_aiQuaternion_y_set(void * jarg1, float jarg2) { - aiQuaternion *arg1 = (aiQuaternion *) 0 ; - float arg2 ; - - arg1 = (aiQuaternion *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->y = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiQuaternion_y_get(void * jarg1) { - float jresult ; - aiQuaternion *arg1 = (aiQuaternion *) 0 ; - float result; - - arg1 = (aiQuaternion *)jarg1; - result = (float) ((arg1)->y); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_aiQuaternion_z_set(void * jarg1, float jarg2) { - aiQuaternion *arg1 = (aiQuaternion *) 0 ; - float arg2 ; - - arg1 = (aiQuaternion *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->z = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_aiQuaternion_z_get(void * jarg1) { - float jresult ; - aiQuaternion *arg1 = (aiQuaternion *) 0 ; - float result; - - arg1 = (aiQuaternion *)jarg1; - result = (float) ((arg1)->z); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiQuaternion(void * jarg1) { - aiQuaternion *arg1 = (aiQuaternion *) 0 ; - - arg1 = (aiQuaternion *)jarg1; - delete arg1; -} - - SWIGEXPORT void SWIGSTDCALL CSharp_aiNode_mName_set(void * jarg1, void * jarg2) { aiNode *arg1 = (aiNode *) 0 ; aiString *arg2 = (aiString *) 0 ; @@ -10689,6 +8431,28 @@ SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiScene_HasAnimations(void * jarg1) { } +SWIGEXPORT void SWIGSTDCALL CSharp_aiScene_mPrivate_set(void * jarg1, void * jarg2) { + aiScene *arg1 = (aiScene *) 0 ; + void *arg2 = (void *) 0 ; + + arg1 = (aiScene *)jarg1; + arg2 = (void *)jarg2; + if (arg1) (arg1)->mPrivate = arg2; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiScene_mPrivate_get(void * jarg1) { + void * jresult ; + aiScene *arg1 = (aiScene *) 0 ; + void *result = 0 ; + + arg1 = (aiScene *)jarg1; + result = (void *) ((arg1)->mPrivate); + jresult = (void *)result; + return jresult; +} + + SWIGEXPORT void * SWIGSTDCALL CSharp_aiScene_GetmAnimations(void * jarg1) { void * jresult ; aiScene *arg1 = (aiScene *) 0 ; @@ -11040,24 +8804,6 @@ SWIGEXPORT int SWIGSTDCALL CSharp_AI_PROPERTY_WAS_NOT_EXISTING_get() { } -SWIGEXPORT void * SWIGSTDCALL CSharp_aiImportFileFromMemory(char * jarg1, unsigned int jarg2, unsigned int jarg3, char * jarg4) { - void * jresult ; - char *arg1 = (char *) 0 ; - unsigned int arg2 ; - unsigned int arg3 ; - char *arg4 = (char *) 0 ; - aiScene *result = 0 ; - - arg1 = (char *)jarg1; - arg2 = (unsigned int)jarg2; - arg3 = (unsigned int)jarg3; - arg4 = (char *)jarg4; - result = (aiScene *)aiImportFileFromMemory((char const *)arg1,arg2,arg3,(char const *)arg4); - jresult = (void *)result; - return jresult; -} - - SWIGEXPORT void * SWIGSTDCALL CSharp_new_Importer__SWIG_0() { void * jresult ; Assimp::Importer *result = 0 ; @@ -11313,6 +9059,30 @@ SWIGEXPORT char * SWIGSTDCALL CSharp_Importer_GetErrorString(void * jarg1) { } +SWIGEXPORT void * SWIGSTDCALL CSharp_Importer_GetScene(void * jarg1) { + void * jresult ; + Assimp::Importer *arg1 = (Assimp::Importer *) 0 ; + aiScene *result = 0 ; + + arg1 = (Assimp::Importer *)jarg1; + result = (aiScene *)((Assimp::Importer const *)arg1)->GetScene(); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Importer_GetOrphanedScene(void * jarg1) { + void * jresult ; + Assimp::Importer *arg1 = (Assimp::Importer *) 0 ; + aiScene *result = 0 ; + + arg1 = (Assimp::Importer *)jarg1; + result = (aiScene *)(arg1)->GetOrphanedScene(); + jresult = (void *)result; + return jresult; +} + + SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Importer_IsExtensionSupported__SWIG_0(void * jarg1, char * jarg2) { unsigned int jresult ; Assimp::Importer *arg1 = (Assimp::Importer *) 0 ; @@ -11355,30 +9125,74 @@ SWIGEXPORT void SWIGSTDCALL CSharp_Importer_GetExtensionList__SWIG_1(void * jarg } -SWIGEXPORT void * SWIGSTDCALL CSharp_Importer_GetScene(void * jarg1) { - void * jresult ; +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Importer_GetImporterCount(void * jarg1) { + unsigned long jresult ; Assimp::Importer *arg1 = (Assimp::Importer *) 0 ; - aiScene *result = 0 ; + size_t result; arg1 = (Assimp::Importer *)jarg1; - result = (aiScene *)((Assimp::Importer const *)arg1)->GetScene(); + result = ((Assimp::Importer const *)arg1)->GetImporterCount(); + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Importer_GetImporterInfo(void * jarg1, unsigned long jarg2) { + void * jresult ; + Assimp::Importer *arg1 = (Assimp::Importer *) 0 ; + size_t arg2 ; + aiImporterDesc *result = 0 ; + + arg1 = (Assimp::Importer *)jarg1; + arg2 = (size_t)jarg2; + result = (aiImporterDesc *)((Assimp::Importer const *)arg1)->GetImporterInfo(arg2); jresult = (void *)result; return jresult; } -SWIGEXPORT void * SWIGSTDCALL CSharp_Importer_GetOrphanedScene(void * jarg1) { +SWIGEXPORT void * SWIGSTDCALL CSharp_Importer_GetImporter__SWIG_0(void * jarg1, unsigned long jarg2) { void * jresult ; Assimp::Importer *arg1 = (Assimp::Importer *) 0 ; - aiScene *result = 0 ; + size_t arg2 ; + Assimp::BaseImporter *result = 0 ; arg1 = (Assimp::Importer *)jarg1; - result = (aiScene *)(arg1)->GetOrphanedScene(); + arg2 = (size_t)jarg2; + result = (Assimp::BaseImporter *)((Assimp::Importer const *)arg1)->GetImporter(arg2); jresult = (void *)result; return jresult; } +SWIGEXPORT void * SWIGSTDCALL CSharp_Importer_GetImporter__SWIG_1(void * jarg1, char * jarg2) { + void * jresult ; + Assimp::Importer *arg1 = (Assimp::Importer *) 0 ; + char *arg2 = (char *) 0 ; + Assimp::BaseImporter *result = 0 ; + + arg1 = (Assimp::Importer *)jarg1; + arg2 = (char *)jarg2; + result = (Assimp::BaseImporter *)((Assimp::Importer const *)arg1)->GetImporter((char const *)arg2); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Importer_GetImporterIndex(void * jarg1, char * jarg2) { + unsigned long jresult ; + Assimp::Importer *arg1 = (Assimp::Importer *) 0 ; + char *arg2 = (char *) 0 ; + size_t result; + + arg1 = (Assimp::Importer *)jarg1; + arg2 = (char *)jarg2; + result = ((Assimp::Importer const *)arg1)->GetImporterIndex((char const *)arg2); + jresult = (unsigned long)result; + return jresult; +} + + SWIGEXPORT void SWIGSTDCALL CSharp_Importer_GetMemoryRequirements(void * jarg1, void * jarg2) { Assimp::Importer *arg1 = (Assimp::Importer *) 0 ; aiMemoryInfo *arg2 = 0 ; @@ -11403,6 +9217,18 @@ SWIGEXPORT void SWIGSTDCALL CSharp_Importer_SetExtraVerbose(void * jarg1, unsign } +SWIGEXPORT void * SWIGSTDCALL CSharp_Importer_Pimpl__SWIG_0(void * jarg1) { + void * jresult ; + Assimp::Importer *arg1 = (Assimp::Importer *) 0 ; + Assimp::ImporterPimpl *result = 0 ; + + arg1 = (Assimp::Importer *)jarg1; + result = (Assimp::ImporterPimpl *)(arg1)->Pimpl(); + jresult = (void *)result; + return jresult; +} + + SWIGEXPORT char * SWIGSTDCALL CSharp_Importer_GetExtensionList__SWIG_2(void * jarg1) { char * jresult ; Assimp::Importer *arg1 = (Assimp::Importer *) 0 ; @@ -11449,6 +9275,2532 @@ SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ProgressHandler_Update__SWIG_1(void * } +SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiColor4D__SWIG_0() { + void * jresult ; + aiColor4t< float > *result = 0 ; + + result = (aiColor4t< float > *)new aiColor4t< float >(); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiColor4D__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) { + void * jresult ; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + aiColor4t< float > *result = 0 ; + + arg1 = (float)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + arg4 = (float)jarg4; + result = (aiColor4t< float > *)new aiColor4t< float >(arg1,arg2,arg3,arg4); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiColor4D__SWIG_2(float jarg1) { + void * jresult ; + float arg1 ; + aiColor4t< float > *result = 0 ; + + arg1 = (float)jarg1; + result = (aiColor4t< float > *)new aiColor4t< float >(arg1); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiColor4D__SWIG_3(void * jarg1) { + void * jresult ; + aiColor4t< float > *arg1 = 0 ; + aiColor4t< float > *result = 0 ; + + arg1 = (aiColor4t< float > *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiColor4t< float > const & type is null", 0); + return 0; + } + result = (aiColor4t< float > *)new aiColor4t< float >((aiColor4t< float > const &)*arg1); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiColor4D___addnset__(void * jarg1, void * jarg2) { + void * jresult ; + aiColor4t< float > *arg1 = (aiColor4t< float > *) 0 ; + aiColor4t< float > *arg2 = 0 ; + aiColor4t< float > *result = 0 ; + + arg1 = (aiColor4t< float > *)jarg1; + arg2 = (aiColor4t< float > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiColor4t< float > const & type is null", 0); + return 0; + } + result = (aiColor4t< float > *) &(arg1)->operator +=((aiColor4t< float > const &)*arg2); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiColor4D___subnset__(void * jarg1, void * jarg2) { + void * jresult ; + aiColor4t< float > *arg1 = (aiColor4t< float > *) 0 ; + aiColor4t< float > *arg2 = 0 ; + aiColor4t< float > *result = 0 ; + + arg1 = (aiColor4t< float > *)jarg1; + arg2 = (aiColor4t< float > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiColor4t< float > const & type is null", 0); + return 0; + } + result = (aiColor4t< float > *) &(arg1)->operator -=((aiColor4t< float > const &)*arg2); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiColor4D___mulnset__(void * jarg1, float jarg2) { + void * jresult ; + aiColor4t< float > *arg1 = (aiColor4t< float > *) 0 ; + float arg2 ; + aiColor4t< float > *result = 0 ; + + arg1 = (aiColor4t< float > *)jarg1; + arg2 = (float)jarg2; + result = (aiColor4t< float > *) &(arg1)->operator *=(arg2); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiColor4D___divnset__(void * jarg1, float jarg2) { + void * jresult ; + aiColor4t< float > *arg1 = (aiColor4t< float > *) 0 ; + float arg2 ; + aiColor4t< float > *result = 0 ; + + arg1 = (aiColor4t< float > *)jarg1; + arg2 = (float)jarg2; + result = (aiColor4t< float > *) &(arg1)->operator /=(arg2); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiColor4D___equal__(void * jarg1, void * jarg2) { + unsigned int jresult ; + aiColor4t< float > *arg1 = (aiColor4t< float > *) 0 ; + aiColor4t< float > *arg2 = 0 ; + bool result; + + arg1 = (aiColor4t< float > *)jarg1; + arg2 = (aiColor4t< float > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiColor4t< float > const & type is null", 0); + return 0; + } + result = (bool)((aiColor4t< float > const *)arg1)->operator ==((aiColor4t< float > const &)*arg2); + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiColor4D___nequal__(void * jarg1, void * jarg2) { + unsigned int jresult ; + aiColor4t< float > *arg1 = (aiColor4t< float > *) 0 ; + aiColor4t< float > *arg2 = 0 ; + bool result; + + arg1 = (aiColor4t< float > *)jarg1; + arg2 = (aiColor4t< float > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiColor4t< float > const & type is null", 0); + return 0; + } + result = (bool)((aiColor4t< float > const *)arg1)->operator !=((aiColor4t< float > const &)*arg2); + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiColor4D___idx____SWIG_0(void * jarg1, unsigned int jarg2) { + float jresult ; + aiColor4t< float > *arg1 = (aiColor4t< float > *) 0 ; + unsigned int arg2 ; + float result; + + arg1 = (aiColor4t< float > *)jarg1; + arg2 = (unsigned int)jarg2; + result = (float)((aiColor4t< float > const *)arg1)->operator [](arg2); + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiColor4D_IsBlack(void * jarg1) { + unsigned int jresult ; + aiColor4t< float > *arg1 = (aiColor4t< float > *) 0 ; + bool result; + + arg1 = (aiColor4t< float > *)jarg1; + result = (bool)((aiColor4t< float > const *)arg1)->IsBlack(); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4D_r_set(void * jarg1, float jarg2) { + aiColor4t< float > *arg1 = (aiColor4t< float > *) 0 ; + float arg2 ; + + arg1 = (aiColor4t< float > *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->r = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiColor4D_r_get(void * jarg1) { + float jresult ; + aiColor4t< float > *arg1 = (aiColor4t< float > *) 0 ; + float result; + + arg1 = (aiColor4t< float > *)jarg1; + result = (float) ((arg1)->r); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4D_g_set(void * jarg1, float jarg2) { + aiColor4t< float > *arg1 = (aiColor4t< float > *) 0 ; + float arg2 ; + + arg1 = (aiColor4t< float > *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->g = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiColor4D_g_get(void * jarg1) { + float jresult ; + aiColor4t< float > *arg1 = (aiColor4t< float > *) 0 ; + float result; + + arg1 = (aiColor4t< float > *)jarg1; + result = (float) ((arg1)->g); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4D_b_set(void * jarg1, float jarg2) { + aiColor4t< float > *arg1 = (aiColor4t< float > *) 0 ; + float arg2 ; + + arg1 = (aiColor4t< float > *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->b = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiColor4D_b_get(void * jarg1) { + float jresult ; + aiColor4t< float > *arg1 = (aiColor4t< float > *) 0 ; + float result; + + arg1 = (aiColor4t< float > *)jarg1; + result = (float) ((arg1)->b); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4D_a_set(void * jarg1, float jarg2) { + aiColor4t< float > *arg1 = (aiColor4t< float > *) 0 ; + float arg2 ; + + arg1 = (aiColor4t< float > *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->a = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiColor4D_a_get(void * jarg1) { + float jresult ; + aiColor4t< float > *arg1 = (aiColor4t< float > *) 0 ; + float result; + + arg1 = (aiColor4t< float > *)jarg1; + result = (float) ((arg1)->a); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiColor4D(void * jarg1) { + aiColor4t< float > *arg1 = (aiColor4t< float > *) 0 ; + + arg1 = (aiColor4t< float > *)jarg1; + delete arg1; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiVector3D__SWIG_0() { + void * jresult ; + aiVector3t< float > *result = 0 ; + + result = (aiVector3t< float > *)new aiVector3t< float >(); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiVector3D__SWIG_1(float jarg1, float jarg2, float jarg3) { + void * jresult ; + float arg1 ; + float arg2 ; + float arg3 ; + aiVector3t< float > *result = 0 ; + + arg1 = (float)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + result = (aiVector3t< float > *)new aiVector3t< float >(arg1,arg2,arg3); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiVector3D__SWIG_2(float jarg1) { + void * jresult ; + float arg1 ; + aiVector3t< float > *result = 0 ; + + arg1 = (float)jarg1; + result = (aiVector3t< float > *)new aiVector3t< float >(arg1); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiVector3D__SWIG_3(void * jarg1) { + void * jresult ; + aiVector3t< float > *arg1 = 0 ; + aiVector3t< float > *result = 0 ; + + arg1 = (aiVector3t< float > *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3t< float > const & type is null", 0); + return 0; + } + result = (aiVector3t< float > *)new aiVector3t< float >((aiVector3t< float > const &)*arg1); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector3D___addnset__(void * jarg1, void * jarg2) { + void * jresult ; + aiVector3t< float > *arg1 = (aiVector3t< float > *) 0 ; + aiVector3t< float > *arg2 = 0 ; + aiVector3t< float > *result = 0 ; + + arg1 = (aiVector3t< float > *)jarg1; + arg2 = (aiVector3t< float > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3t< float > const & type is null", 0); + return 0; + } + result = (aiVector3t< float > *) &(arg1)->operator +=((aiVector3t< float > const &)*arg2); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector3D___subnset__(void * jarg1, void * jarg2) { + void * jresult ; + aiVector3t< float > *arg1 = (aiVector3t< float > *) 0 ; + aiVector3t< float > *arg2 = 0 ; + aiVector3t< float > *result = 0 ; + + arg1 = (aiVector3t< float > *)jarg1; + arg2 = (aiVector3t< float > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3t< float > const & type is null", 0); + return 0; + } + result = (aiVector3t< float > *) &(arg1)->operator -=((aiVector3t< float > const &)*arg2); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector3D___mulnset____SWIG_0(void * jarg1, float jarg2) { + void * jresult ; + aiVector3t< float > *arg1 = (aiVector3t< float > *) 0 ; + float arg2 ; + aiVector3t< float > *result = 0 ; + + arg1 = (aiVector3t< float > *)jarg1; + arg2 = (float)jarg2; + result = (aiVector3t< float > *) &(arg1)->operator *=(arg2); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector3D___divnset__(void * jarg1, float jarg2) { + void * jresult ; + aiVector3t< float > *arg1 = (aiVector3t< float > *) 0 ; + float arg2 ; + aiVector3t< float > *result = 0 ; + + arg1 = (aiVector3t< float > *)jarg1; + arg2 = (float)jarg2; + result = (aiVector3t< float > *) &(arg1)->operator /=(arg2); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector3D___mulnset____SWIG_1(void * jarg1, void * jarg2) { + void * jresult ; + aiVector3t< float > *arg1 = (aiVector3t< float > *) 0 ; + aiMatrix3x3t< float > *arg2 = 0 ; + aiVector3t< float > *result = 0 ; + + arg1 = (aiVector3t< float > *)jarg1; + arg2 = (aiMatrix3x3t< float > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix3x3t< float > const & type is null", 0); + return 0; + } + result = (aiVector3t< float > *) &(arg1)->operator *=((aiMatrix3x3t< float > const &)*arg2); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector3D___mulnset____SWIG_2(void * jarg1, void * jarg2) { + void * jresult ; + aiVector3t< float > *arg1 = (aiVector3t< float > *) 0 ; + aiMatrix4x4t< float > *arg2 = 0 ; + aiVector3t< float > *result = 0 ; + + arg1 = (aiVector3t< float > *)jarg1; + arg2 = (aiMatrix4x4t< float > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix4x4t< float > const & type is null", 0); + return 0; + } + result = (aiVector3t< float > *) &(arg1)->operator *=((aiMatrix4x4t< float > const &)*arg2); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiVector3D___idx____SWIG_0(void * jarg1, unsigned int jarg2) { + float jresult ; + aiVector3t< float > *arg1 = (aiVector3t< float > *) 0 ; + unsigned int arg2 ; + float result; + + arg1 = (aiVector3t< float > *)jarg1; + arg2 = (unsigned int)jarg2; + result = (float)((aiVector3t< float > const *)arg1)->operator [](arg2); + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiVector3D___equal__(void * jarg1, void * jarg2) { + unsigned int jresult ; + aiVector3t< float > *arg1 = (aiVector3t< float > *) 0 ; + aiVector3t< float > *arg2 = 0 ; + bool result; + + arg1 = (aiVector3t< float > *)jarg1; + arg2 = (aiVector3t< float > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3t< float > const & type is null", 0); + return 0; + } + result = (bool)((aiVector3t< float > const *)arg1)->operator ==((aiVector3t< float > const &)*arg2); + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiVector3D___nequal__(void * jarg1, void * jarg2) { + unsigned int jresult ; + aiVector3t< float > *arg1 = (aiVector3t< float > *) 0 ; + aiVector3t< float > *arg2 = 0 ; + bool result; + + arg1 = (aiVector3t< float > *)jarg1; + arg2 = (aiVector3t< float > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3t< float > const & type is null", 0); + return 0; + } + result = (bool)((aiVector3t< float > const *)arg1)->operator !=((aiVector3t< float > const &)*arg2); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3D_Set(void * jarg1, float jarg2, float jarg3, float jarg4) { + aiVector3t< float > *arg1 = (aiVector3t< float > *) 0 ; + float arg2 ; + float arg3 ; + float arg4 ; + + arg1 = (aiVector3t< float > *)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + arg4 = (float)jarg4; + (arg1)->Set(arg2,arg3,arg4); +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiVector3D_SquareLength(void * jarg1) { + float jresult ; + aiVector3t< float > *arg1 = (aiVector3t< float > *) 0 ; + float result; + + arg1 = (aiVector3t< float > *)jarg1; + result = (float)((aiVector3t< float > const *)arg1)->SquareLength(); + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiVector3D_Length(void * jarg1) { + float jresult ; + aiVector3t< float > *arg1 = (aiVector3t< float > *) 0 ; + float result; + + arg1 = (aiVector3t< float > *)jarg1; + result = (float)((aiVector3t< float > const *)arg1)->Length(); + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector3D_Normalize(void * jarg1) { + void * jresult ; + aiVector3t< float > *arg1 = (aiVector3t< float > *) 0 ; + aiVector3t< float > *result = 0 ; + + arg1 = (aiVector3t< float > *)jarg1; + result = (aiVector3t< float > *) &(arg1)->Normalize(); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector3D_SymMul(void * jarg1, void * jarg2) { + void * jresult ; + aiVector3t< float > *arg1 = (aiVector3t< float > *) 0 ; + aiVector3t< float > *arg2 = 0 ; + aiVector3t< float > result; + + arg1 = (aiVector3t< float > *)jarg1; + arg2 = (aiVector3t< float > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3t< float > const & type is null", 0); + return 0; + } + result = (arg1)->SymMul((aiVector3t< float > const &)*arg2); + jresult = new aiVector3t< float >((const aiVector3t< float > &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3D_x_set(void * jarg1, float jarg2) { + aiVector3t< float > *arg1 = (aiVector3t< float > *) 0 ; + float arg2 ; + + arg1 = (aiVector3t< float > *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->x = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiVector3D_x_get(void * jarg1) { + float jresult ; + aiVector3t< float > *arg1 = (aiVector3t< float > *) 0 ; + float result; + + arg1 = (aiVector3t< float > *)jarg1; + result = (float) ((arg1)->x); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3D_y_set(void * jarg1, float jarg2) { + aiVector3t< float > *arg1 = (aiVector3t< float > *) 0 ; + float arg2 ; + + arg1 = (aiVector3t< float > *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->y = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiVector3D_y_get(void * jarg1) { + float jresult ; + aiVector3t< float > *arg1 = (aiVector3t< float > *) 0 ; + float result; + + arg1 = (aiVector3t< float > *)jarg1; + result = (float) ((arg1)->y); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3D_z_set(void * jarg1, float jarg2) { + aiVector3t< float > *arg1 = (aiVector3t< float > *) 0 ; + float arg2 ; + + arg1 = (aiVector3t< float > *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->z = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiVector3D_z_get(void * jarg1) { + float jresult ; + aiVector3t< float > *arg1 = (aiVector3t< float > *) 0 ; + float result; + + arg1 = (aiVector3t< float > *)jarg1; + result = (float) ((arg1)->z); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiVector3D(void * jarg1) { + aiVector3t< float > *arg1 = (aiVector3t< float > *) 0 ; + + arg1 = (aiVector3t< float > *)jarg1; + delete arg1; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiVector2D__SWIG_0() { + void * jresult ; + aiVector2t< float > *result = 0 ; + + result = (aiVector2t< float > *)new aiVector2t< float >(); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiVector2D__SWIG_1(float jarg1, float jarg2) { + void * jresult ; + float arg1 ; + float arg2 ; + aiVector2t< float > *result = 0 ; + + arg1 = (float)jarg1; + arg2 = (float)jarg2; + result = (aiVector2t< float > *)new aiVector2t< float >(arg1,arg2); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiVector2D__SWIG_2(float jarg1) { + void * jresult ; + float arg1 ; + aiVector2t< float > *result = 0 ; + + arg1 = (float)jarg1; + result = (aiVector2t< float > *)new aiVector2t< float >(arg1); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiVector2D__SWIG_3(void * jarg1) { + void * jresult ; + aiVector2t< float > *arg1 = 0 ; + aiVector2t< float > *result = 0 ; + + arg1 = (aiVector2t< float > *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2t< float > const & type is null", 0); + return 0; + } + result = (aiVector2t< float > *)new aiVector2t< float >((aiVector2t< float > const &)*arg1); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiVector2D_Set(void * jarg1, float jarg2, float jarg3) { + aiVector2t< float > *arg1 = (aiVector2t< float > *) 0 ; + float arg2 ; + float arg3 ; + + arg1 = (aiVector2t< float > *)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + (arg1)->Set(arg2,arg3); +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiVector2D_SquareLength(void * jarg1) { + float jresult ; + aiVector2t< float > *arg1 = (aiVector2t< float > *) 0 ; + float result; + + arg1 = (aiVector2t< float > *)jarg1; + result = (float)((aiVector2t< float > const *)arg1)->SquareLength(); + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiVector2D_Length(void * jarg1) { + float jresult ; + aiVector2t< float > *arg1 = (aiVector2t< float > *) 0 ; + float result; + + arg1 = (aiVector2t< float > *)jarg1; + result = (float)((aiVector2t< float > const *)arg1)->Length(); + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector2D_Normalize(void * jarg1) { + void * jresult ; + aiVector2t< float > *arg1 = (aiVector2t< float > *) 0 ; + aiVector2t< float > *result = 0 ; + + arg1 = (aiVector2t< float > *)jarg1; + result = (aiVector2t< float > *) &(arg1)->Normalize(); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector2D___addnset__(void * jarg1, void * jarg2) { + void * jresult ; + aiVector2t< float > *arg1 = (aiVector2t< float > *) 0 ; + aiVector2t< float > *arg2 = 0 ; + aiVector2t< float > *result = 0 ; + + arg1 = (aiVector2t< float > *)jarg1; + arg2 = (aiVector2t< float > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2t< float > const & type is null", 0); + return 0; + } + result = (aiVector2t< float > *) &(arg1)->operator +=((aiVector2t< float > const &)*arg2); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector2D___subnset__(void * jarg1, void * jarg2) { + void * jresult ; + aiVector2t< float > *arg1 = (aiVector2t< float > *) 0 ; + aiVector2t< float > *arg2 = 0 ; + aiVector2t< float > *result = 0 ; + + arg1 = (aiVector2t< float > *)jarg1; + arg2 = (aiVector2t< float > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2t< float > const & type is null", 0); + return 0; + } + result = (aiVector2t< float > *) &(arg1)->operator -=((aiVector2t< float > const &)*arg2); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector2D___mulnset__(void * jarg1, float jarg2) { + void * jresult ; + aiVector2t< float > *arg1 = (aiVector2t< float > *) 0 ; + float arg2 ; + aiVector2t< float > *result = 0 ; + + arg1 = (aiVector2t< float > *)jarg1; + arg2 = (float)jarg2; + result = (aiVector2t< float > *) &(arg1)->operator *=(arg2); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector2D___divnset__(void * jarg1, float jarg2) { + void * jresult ; + aiVector2t< float > *arg1 = (aiVector2t< float > *) 0 ; + float arg2 ; + aiVector2t< float > *result = 0 ; + + arg1 = (aiVector2t< float > *)jarg1; + arg2 = (float)jarg2; + result = (aiVector2t< float > *) &(arg1)->operator /=(arg2); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiVector2D___idx____SWIG_0(void * jarg1, unsigned int jarg2) { + float jresult ; + aiVector2t< float > *arg1 = (aiVector2t< float > *) 0 ; + unsigned int arg2 ; + float result; + + arg1 = (aiVector2t< float > *)jarg1; + arg2 = (unsigned int)jarg2; + result = (float)((aiVector2t< float > const *)arg1)->operator [](arg2); + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiVector2D___equal__(void * jarg1, void * jarg2) { + unsigned int jresult ; + aiVector2t< float > *arg1 = (aiVector2t< float > *) 0 ; + aiVector2t< float > *arg2 = 0 ; + bool result; + + arg1 = (aiVector2t< float > *)jarg1; + arg2 = (aiVector2t< float > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2t< float > const & type is null", 0); + return 0; + } + result = (bool)((aiVector2t< float > const *)arg1)->operator ==((aiVector2t< float > const &)*arg2); + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiVector2D___nequal__(void * jarg1, void * jarg2) { + unsigned int jresult ; + aiVector2t< float > *arg1 = (aiVector2t< float > *) 0 ; + aiVector2t< float > *arg2 = 0 ; + bool result; + + arg1 = (aiVector2t< float > *)jarg1; + arg2 = (aiVector2t< float > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2t< float > const & type is null", 0); + return 0; + } + result = (bool)((aiVector2t< float > const *)arg1)->operator !=((aiVector2t< float > const &)*arg2); + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector2D___set__(void * jarg1, float jarg2) { + void * jresult ; + aiVector2t< float > *arg1 = (aiVector2t< float > *) 0 ; + float arg2 ; + aiVector2t< float > *result = 0 ; + + arg1 = (aiVector2t< float > *)jarg1; + arg2 = (float)jarg2; + result = (aiVector2t< float > *) &(arg1)->operator =(arg2); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector2D_SymMul(void * jarg1, void * jarg2) { + void * jresult ; + aiVector2t< float > *arg1 = (aiVector2t< float > *) 0 ; + aiVector2t< float > *arg2 = 0 ; + aiVector2t< float > result; + + arg1 = (aiVector2t< float > *)jarg1; + arg2 = (aiVector2t< float > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2t< float > const & type is null", 0); + return 0; + } + result = (arg1)->SymMul((aiVector2t< float > const &)*arg2); + jresult = new aiVector2t< float >((const aiVector2t< float > &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiVector2D_x_set(void * jarg1, float jarg2) { + aiVector2t< float > *arg1 = (aiVector2t< float > *) 0 ; + float arg2 ; + + arg1 = (aiVector2t< float > *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->x = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiVector2D_x_get(void * jarg1) { + float jresult ; + aiVector2t< float > *arg1 = (aiVector2t< float > *) 0 ; + float result; + + arg1 = (aiVector2t< float > *)jarg1; + result = (float) ((arg1)->x); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiVector2D_y_set(void * jarg1, float jarg2) { + aiVector2t< float > *arg1 = (aiVector2t< float > *) 0 ; + float arg2 ; + + arg1 = (aiVector2t< float > *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->y = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiVector2D_y_get(void * jarg1) { + float jresult ; + aiVector2t< float > *arg1 = (aiVector2t< float > *) 0 ; + float result; + + arg1 = (aiVector2t< float > *)jarg1; + result = (float) ((arg1)->y); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiVector2D(void * jarg1) { + aiVector2t< float > *arg1 = (aiVector2t< float > *) 0 ; + + arg1 = (aiVector2t< float > *)jarg1; + delete arg1; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiQuaternion__SWIG_0() { + void * jresult ; + aiQuaterniont< float > *result = 0 ; + + result = (aiQuaterniont< float > *)new aiQuaterniont< float >(); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiQuaternion__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) { + void * jresult ; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + aiQuaterniont< float > *result = 0 ; + + arg1 = (float)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + arg4 = (float)jarg4; + result = (aiQuaterniont< float > *)new aiQuaterniont< float >(arg1,arg2,arg3,arg4); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiQuaternion__SWIG_2(void * jarg1) { + void * jresult ; + aiMatrix3x3t< float > *arg1 = 0 ; + aiQuaterniont< float > *result = 0 ; + + arg1 = (aiMatrix3x3t< float > *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix3x3t< float > const & type is null", 0); + return 0; + } + result = (aiQuaterniont< float > *)new aiQuaterniont< float >((aiMatrix3x3t< float > const &)*arg1); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiQuaternion__SWIG_3(float jarg1, float jarg2, float jarg3) { + void * jresult ; + float arg1 ; + float arg2 ; + float arg3 ; + aiQuaterniont< float > *result = 0 ; + + arg1 = (float)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + result = (aiQuaterniont< float > *)new aiQuaterniont< float >(arg1,arg2,arg3); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiQuaternion__SWIG_4(void * jarg1, float jarg2) { + void * jresult ; + aiVector3t< float > arg1 ; + float arg2 ; + aiVector3t< float > *argp1 ; + aiQuaterniont< float > *result = 0 ; + + argp1 = (aiVector3t< float > *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null aiVector3t< float >", 0); + return 0; + } + arg1 = *argp1; + arg2 = (float)jarg2; + result = (aiQuaterniont< float > *)new aiQuaterniont< float >(arg1,arg2); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiQuaternion__SWIG_5(void * jarg1) { + void * jresult ; + aiVector3t< float > arg1 ; + aiVector3t< float > *argp1 ; + aiQuaterniont< float > *result = 0 ; + + argp1 = (aiVector3t< float > *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null aiVector3t< float >", 0); + return 0; + } + arg1 = *argp1; + result = (aiQuaterniont< float > *)new aiQuaterniont< float >(arg1); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiQuaternion_GetMatrix(void * jarg1) { + void * jresult ; + aiQuaterniont< float > *arg1 = (aiQuaterniont< float > *) 0 ; + aiMatrix3x3t< float > result; + + arg1 = (aiQuaterniont< float > *)jarg1; + result = ((aiQuaterniont< float > const *)arg1)->GetMatrix(); + jresult = new aiMatrix3x3t< float >((const aiMatrix3x3t< float > &)result); + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiQuaternion___equal__(void * jarg1, void * jarg2) { + unsigned int jresult ; + aiQuaterniont< float > *arg1 = (aiQuaterniont< float > *) 0 ; + aiQuaterniont< float > *arg2 = 0 ; + bool result; + + arg1 = (aiQuaterniont< float > *)jarg1; + arg2 = (aiQuaterniont< float > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiQuaterniont< float > const & type is null", 0); + return 0; + } + result = (bool)((aiQuaterniont< float > const *)arg1)->operator ==((aiQuaterniont< float > const &)*arg2); + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiQuaternion___nequal__(void * jarg1, void * jarg2) { + unsigned int jresult ; + aiQuaterniont< float > *arg1 = (aiQuaterniont< float > *) 0 ; + aiQuaterniont< float > *arg2 = 0 ; + bool result; + + arg1 = (aiQuaterniont< float > *)jarg1; + arg2 = (aiQuaterniont< float > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiQuaterniont< float > const & type is null", 0); + return 0; + } + result = (bool)((aiQuaterniont< float > const *)arg1)->operator !=((aiQuaterniont< float > const &)*arg2); + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiQuaternion_Normalize(void * jarg1) { + void * jresult ; + aiQuaterniont< float > *arg1 = (aiQuaterniont< float > *) 0 ; + aiQuaterniont< float > *result = 0 ; + + arg1 = (aiQuaterniont< float > *)jarg1; + result = (aiQuaterniont< float > *) &(arg1)->Normalize(); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiQuaternion_Conjugate(void * jarg1) { + void * jresult ; + aiQuaterniont< float > *arg1 = (aiQuaterniont< float > *) 0 ; + aiQuaterniont< float > *result = 0 ; + + arg1 = (aiQuaterniont< float > *)jarg1; + result = (aiQuaterniont< float > *) &(arg1)->Conjugate(); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiQuaternion_Rotate(void * jarg1, void * jarg2) { + void * jresult ; + aiQuaterniont< float > *arg1 = (aiQuaterniont< float > *) 0 ; + aiVector3t< float > *arg2 = 0 ; + aiVector3t< float > result; + + arg1 = (aiQuaterniont< float > *)jarg1; + arg2 = (aiVector3t< float > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3t< float > const & type is null", 0); + return 0; + } + result = (arg1)->Rotate((aiVector3t< float > const &)*arg2); + jresult = new aiVector3t< float >((const aiVector3t< float > &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiQuaternion___mul__(void * jarg1, void * jarg2) { + void * jresult ; + aiQuaterniont< float > *arg1 = (aiQuaterniont< float > *) 0 ; + aiQuaterniont< float > *arg2 = 0 ; + aiQuaterniont< float > result; + + arg1 = (aiQuaterniont< float > *)jarg1; + arg2 = (aiQuaterniont< float > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiQuaterniont< float > const & type is null", 0); + return 0; + } + result = ((aiQuaterniont< float > const *)arg1)->operator *((aiQuaterniont< float > const &)*arg2); + jresult = new aiQuaterniont< float >((const aiQuaterniont< float > &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiQuaternion_Interpolate(void * jarg1, void * jarg2, void * jarg3, float jarg4) { + aiQuaterniont< float > *arg1 = 0 ; + aiQuaterniont< float > *arg2 = 0 ; + aiQuaterniont< float > *arg3 = 0 ; + float arg4 ; + + arg1 = (aiQuaterniont< float > *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiQuaterniont< float > & type is null", 0); + return ; + } + arg2 = (aiQuaterniont< float > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiQuaterniont< float > const & type is null", 0); + return ; + } + arg3 = (aiQuaterniont< float > *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiQuaterniont< float > const & type is null", 0); + return ; + } + arg4 = (float)jarg4; + aiQuaterniont< float >::SWIGTEMPLATEDISAMBIGUATOR Interpolate(*arg1,(aiQuaterniont< float > const &)*arg2,(aiQuaterniont< float > const &)*arg3,arg4); +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiQuaternion_w_set(void * jarg1, float jarg2) { + aiQuaterniont< float > *arg1 = (aiQuaterniont< float > *) 0 ; + float arg2 ; + + arg1 = (aiQuaterniont< float > *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->w = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiQuaternion_w_get(void * jarg1) { + float jresult ; + aiQuaterniont< float > *arg1 = (aiQuaterniont< float > *) 0 ; + float result; + + arg1 = (aiQuaterniont< float > *)jarg1; + result = (float) ((arg1)->w); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiQuaternion_x_set(void * jarg1, float jarg2) { + aiQuaterniont< float > *arg1 = (aiQuaterniont< float > *) 0 ; + float arg2 ; + + arg1 = (aiQuaterniont< float > *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->x = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiQuaternion_x_get(void * jarg1) { + float jresult ; + aiQuaterniont< float > *arg1 = (aiQuaterniont< float > *) 0 ; + float result; + + arg1 = (aiQuaterniont< float > *)jarg1; + result = (float) ((arg1)->x); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiQuaternion_y_set(void * jarg1, float jarg2) { + aiQuaterniont< float > *arg1 = (aiQuaterniont< float > *) 0 ; + float arg2 ; + + arg1 = (aiQuaterniont< float > *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->y = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiQuaternion_y_get(void * jarg1) { + float jresult ; + aiQuaterniont< float > *arg1 = (aiQuaterniont< float > *) 0 ; + float result; + + arg1 = (aiQuaterniont< float > *)jarg1; + result = (float) ((arg1)->y); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiQuaternion_z_set(void * jarg1, float jarg2) { + aiQuaterniont< float > *arg1 = (aiQuaterniont< float > *) 0 ; + float arg2 ; + + arg1 = (aiQuaterniont< float > *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->z = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiQuaternion_z_get(void * jarg1) { + float jresult ; + aiQuaterniont< float > *arg1 = (aiQuaterniont< float > *) 0 ; + float result; + + arg1 = (aiQuaterniont< float > *)jarg1; + result = (float) ((arg1)->z); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiQuaternion(void * jarg1) { + aiQuaterniont< float > *arg1 = (aiQuaterniont< float > *) 0 ; + + arg1 = (aiQuaterniont< float > *)jarg1; + delete arg1; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiMatrix3x3__SWIG_0() { + void * jresult ; + aiMatrix3x3t< float > *result = 0 ; + + result = (aiMatrix3x3t< float > *)new aiMatrix3x3t< float >(); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiMatrix3x3__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7, float jarg8, float jarg9) { + void * jresult ; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + float arg7 ; + float arg8 ; + float arg9 ; + aiMatrix3x3t< float > *result = 0 ; + + arg1 = (float)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + arg4 = (float)jarg4; + arg5 = (float)jarg5; + arg6 = (float)jarg6; + arg7 = (float)jarg7; + arg8 = (float)jarg8; + arg9 = (float)jarg9; + result = (aiMatrix3x3t< float > *)new aiMatrix3x3t< float >(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix3x3___mulnset__(void * jarg1, void * jarg2) { + void * jresult ; + aiMatrix3x3t< float > *arg1 = (aiMatrix3x3t< float > *) 0 ; + aiMatrix3x3t< float > *arg2 = 0 ; + aiMatrix3x3t< float > *result = 0 ; + + arg1 = (aiMatrix3x3t< float > *)jarg1; + arg2 = (aiMatrix3x3t< float > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix3x3t< float > const & type is null", 0); + return 0; + } + result = (aiMatrix3x3t< float > *) &(arg1)->operator *=((aiMatrix3x3t< float > const &)*arg2); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix3x3___mul__(void * jarg1, void * jarg2) { + void * jresult ; + aiMatrix3x3t< float > *arg1 = (aiMatrix3x3t< float > *) 0 ; + aiMatrix3x3t< float > *arg2 = 0 ; + aiMatrix3x3t< float > result; + + arg1 = (aiMatrix3x3t< float > *)jarg1; + arg2 = (aiMatrix3x3t< float > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix3x3t< float > const & type is null", 0); + return 0; + } + result = ((aiMatrix3x3t< float > const *)arg1)->operator *((aiMatrix3x3t< float > const &)*arg2); + jresult = new aiMatrix3x3t< float >((const aiMatrix3x3t< float > &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix3x3___idx____SWIG_0(void * jarg1, unsigned int jarg2) { + void * jresult ; + aiMatrix3x3t< float > *arg1 = (aiMatrix3x3t< float > *) 0 ; + unsigned int arg2 ; + float *result = 0 ; + + arg1 = (aiMatrix3x3t< float > *)jarg1; + arg2 = (unsigned int)jarg2; + result = (float *)(arg1)->operator [](arg2); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMatrix3x3___equal__(void * jarg1, void * jarg2) { + unsigned int jresult ; + aiMatrix3x3t< float > *arg1 = (aiMatrix3x3t< float > *) 0 ; + aiMatrix4x4t< float > arg2 ; + aiMatrix4x4t< float > const *argp2 ; + bool result; + + arg1 = (aiMatrix3x3t< float > *)jarg1; + argp2 = (aiMatrix4x4t< float > *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null aiMatrix4x4t< float > const", 0); + return 0; + } + arg2 = *argp2; + result = (bool)((aiMatrix3x3t< float > const *)arg1)->operator ==(arg2); + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMatrix3x3___nequal__(void * jarg1, void * jarg2) { + unsigned int jresult ; + aiMatrix3x3t< float > *arg1 = (aiMatrix3x3t< float > *) 0 ; + aiMatrix4x4t< float > arg2 ; + aiMatrix4x4t< float > const *argp2 ; + bool result; + + arg1 = (aiMatrix3x3t< float > *)jarg1; + argp2 = (aiMatrix4x4t< float > *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null aiMatrix4x4t< float > const", 0); + return 0; + } + arg2 = *argp2; + result = (bool)((aiMatrix3x3t< float > const *)arg1)->operator !=(arg2); + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiMatrix3x3__SWIG_2(void * jarg1) { + void * jresult ; + aiMatrix4x4t< float > *arg1 = 0 ; + aiMatrix3x3t< float > *result = 0 ; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix4x4t< float > const & type is null", 0); + return 0; + } + result = (aiMatrix3x3t< float > *)new aiMatrix3x3t< float >((aiMatrix4x4t< float > const &)*arg1); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix3x3_Transpose(void * jarg1) { + void * jresult ; + aiMatrix3x3t< float > *arg1 = (aiMatrix3x3t< float > *) 0 ; + aiMatrix3x3t< float > *result = 0 ; + + arg1 = (aiMatrix3x3t< float > *)jarg1; + result = (aiMatrix3x3t< float > *) &(arg1)->Transpose(); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix3x3_Inverse(void * jarg1) { + void * jresult ; + aiMatrix3x3t< float > *arg1 = (aiMatrix3x3t< float > *) 0 ; + aiMatrix3x3t< float > *result = 0 ; + + arg1 = (aiMatrix3x3t< float > *)jarg1; + result = (aiMatrix3x3t< float > *) &(arg1)->Inverse(); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix3x3_Determinant(void * jarg1) { + float jresult ; + aiMatrix3x3t< float > *arg1 = (aiMatrix3x3t< float > *) 0 ; + float result; + + arg1 = (aiMatrix3x3t< float > *)jarg1; + result = (float)((aiMatrix3x3t< float > const *)arg1)->Determinant(); + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix3x3_RotationZ(float jarg1, void * jarg2) { + void * jresult ; + float arg1 ; + aiMatrix3x3t< float > *arg2 = 0 ; + aiMatrix3x3t< float > *result = 0 ; + + arg1 = (float)jarg1; + arg2 = (aiMatrix3x3t< float > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix3x3t< float > & type is null", 0); + return 0; + } + result = (aiMatrix3x3t< float > *) &aiMatrix3x3t< float >::SWIGTEMPLATEDISAMBIGUATOR RotationZ(arg1,*arg2); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix3x3_Rotation(float jarg1, void * jarg2, void * jarg3) { + void * jresult ; + float arg1 ; + aiVector3t< float > *arg2 = 0 ; + aiMatrix3x3t< float > *arg3 = 0 ; + aiMatrix3x3t< float > *result = 0 ; + + arg1 = (float)jarg1; + arg2 = (aiVector3t< float > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3t< float > const & type is null", 0); + return 0; + } + arg3 = (aiMatrix3x3t< float > *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix3x3t< float > & type is null", 0); + return 0; + } + result = (aiMatrix3x3t< float > *) &aiMatrix3x3t< float >::SWIGTEMPLATEDISAMBIGUATOR Rotation(arg1,(aiVector3t< float > const &)*arg2,*arg3); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix3x3_Translation(void * jarg1, void * jarg2) { + void * jresult ; + aiVector2t< float > *arg1 = 0 ; + aiMatrix3x3t< float > *arg2 = 0 ; + aiMatrix3x3t< float > *result = 0 ; + + arg1 = (aiVector2t< float > *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector2t< float > const & type is null", 0); + return 0; + } + arg2 = (aiMatrix3x3t< float > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix3x3t< float > & type is null", 0); + return 0; + } + result = (aiMatrix3x3t< float > *) &aiMatrix3x3t< float >::SWIGTEMPLATEDISAMBIGUATOR Translation((aiVector2t< float > const &)*arg1,*arg2); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix3x3_FromToMatrix(void * jarg1, void * jarg2, void * jarg3) { + void * jresult ; + aiVector3t< float > *arg1 = 0 ; + aiVector3t< float > *arg2 = 0 ; + aiMatrix3x3t< float > *arg3 = 0 ; + aiMatrix3x3t< float > *result = 0 ; + + arg1 = (aiVector3t< float > *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3t< float > const & type is null", 0); + return 0; + } + arg2 = (aiVector3t< float > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3t< float > const & type is null", 0); + return 0; + } + arg3 = (aiMatrix3x3t< float > *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix3x3t< float > & type is null", 0); + return 0; + } + result = (aiMatrix3x3t< float > *) &aiMatrix3x3t< float >::SWIGTEMPLATEDISAMBIGUATOR FromToMatrix((aiVector3t< float > const &)*arg1,(aiVector3t< float > const &)*arg2,*arg3); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix3x3_a1_set(void * jarg1, float jarg2) { + aiMatrix3x3t< float > *arg1 = (aiMatrix3x3t< float > *) 0 ; + float arg2 ; + + arg1 = (aiMatrix3x3t< float > *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->a1 = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix3x3_a1_get(void * jarg1) { + float jresult ; + aiMatrix3x3t< float > *arg1 = (aiMatrix3x3t< float > *) 0 ; + float result; + + arg1 = (aiMatrix3x3t< float > *)jarg1; + result = (float) ((arg1)->a1); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix3x3_a2_set(void * jarg1, float jarg2) { + aiMatrix3x3t< float > *arg1 = (aiMatrix3x3t< float > *) 0 ; + float arg2 ; + + arg1 = (aiMatrix3x3t< float > *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->a2 = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix3x3_a2_get(void * jarg1) { + float jresult ; + aiMatrix3x3t< float > *arg1 = (aiMatrix3x3t< float > *) 0 ; + float result; + + arg1 = (aiMatrix3x3t< float > *)jarg1; + result = (float) ((arg1)->a2); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix3x3_a3_set(void * jarg1, float jarg2) { + aiMatrix3x3t< float > *arg1 = (aiMatrix3x3t< float > *) 0 ; + float arg2 ; + + arg1 = (aiMatrix3x3t< float > *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->a3 = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix3x3_a3_get(void * jarg1) { + float jresult ; + aiMatrix3x3t< float > *arg1 = (aiMatrix3x3t< float > *) 0 ; + float result; + + arg1 = (aiMatrix3x3t< float > *)jarg1; + result = (float) ((arg1)->a3); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix3x3_b1_set(void * jarg1, float jarg2) { + aiMatrix3x3t< float > *arg1 = (aiMatrix3x3t< float > *) 0 ; + float arg2 ; + + arg1 = (aiMatrix3x3t< float > *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->b1 = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix3x3_b1_get(void * jarg1) { + float jresult ; + aiMatrix3x3t< float > *arg1 = (aiMatrix3x3t< float > *) 0 ; + float result; + + arg1 = (aiMatrix3x3t< float > *)jarg1; + result = (float) ((arg1)->b1); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix3x3_b2_set(void * jarg1, float jarg2) { + aiMatrix3x3t< float > *arg1 = (aiMatrix3x3t< float > *) 0 ; + float arg2 ; + + arg1 = (aiMatrix3x3t< float > *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->b2 = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix3x3_b2_get(void * jarg1) { + float jresult ; + aiMatrix3x3t< float > *arg1 = (aiMatrix3x3t< float > *) 0 ; + float result; + + arg1 = (aiMatrix3x3t< float > *)jarg1; + result = (float) ((arg1)->b2); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix3x3_b3_set(void * jarg1, float jarg2) { + aiMatrix3x3t< float > *arg1 = (aiMatrix3x3t< float > *) 0 ; + float arg2 ; + + arg1 = (aiMatrix3x3t< float > *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->b3 = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix3x3_b3_get(void * jarg1) { + float jresult ; + aiMatrix3x3t< float > *arg1 = (aiMatrix3x3t< float > *) 0 ; + float result; + + arg1 = (aiMatrix3x3t< float > *)jarg1; + result = (float) ((arg1)->b3); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix3x3_c1_set(void * jarg1, float jarg2) { + aiMatrix3x3t< float > *arg1 = (aiMatrix3x3t< float > *) 0 ; + float arg2 ; + + arg1 = (aiMatrix3x3t< float > *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->c1 = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix3x3_c1_get(void * jarg1) { + float jresult ; + aiMatrix3x3t< float > *arg1 = (aiMatrix3x3t< float > *) 0 ; + float result; + + arg1 = (aiMatrix3x3t< float > *)jarg1; + result = (float) ((arg1)->c1); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix3x3_c2_set(void * jarg1, float jarg2) { + aiMatrix3x3t< float > *arg1 = (aiMatrix3x3t< float > *) 0 ; + float arg2 ; + + arg1 = (aiMatrix3x3t< float > *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->c2 = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix3x3_c2_get(void * jarg1) { + float jresult ; + aiMatrix3x3t< float > *arg1 = (aiMatrix3x3t< float > *) 0 ; + float result; + + arg1 = (aiMatrix3x3t< float > *)jarg1; + result = (float) ((arg1)->c2); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix3x3_c3_set(void * jarg1, float jarg2) { + aiMatrix3x3t< float > *arg1 = (aiMatrix3x3t< float > *) 0 ; + float arg2 ; + + arg1 = (aiMatrix3x3t< float > *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->c3 = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix3x3_c3_get(void * jarg1) { + float jresult ; + aiMatrix3x3t< float > *arg1 = (aiMatrix3x3t< float > *) 0 ; + float result; + + arg1 = (aiMatrix3x3t< float > *)jarg1; + result = (float) ((arg1)->c3); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiMatrix3x3(void * jarg1) { + aiMatrix3x3t< float > *arg1 = (aiMatrix3x3t< float > *) 0 ; + + arg1 = (aiMatrix3x3t< float > *)jarg1; + delete arg1; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiMatrix4x4__SWIG_0() { + void * jresult ; + aiMatrix4x4t< float > *result = 0 ; + + result = (aiMatrix4x4t< float > *)new aiMatrix4x4t< float >(); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiMatrix4x4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7, float jarg8, float jarg9, float jarg10, float jarg11, float jarg12, float jarg13, float jarg14, float jarg15, float jarg16) { + void * jresult ; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + float arg7 ; + float arg8 ; + float arg9 ; + float arg10 ; + float arg11 ; + float arg12 ; + float arg13 ; + float arg14 ; + float arg15 ; + float arg16 ; + aiMatrix4x4t< float > *result = 0 ; + + arg1 = (float)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + arg4 = (float)jarg4; + arg5 = (float)jarg5; + arg6 = (float)jarg6; + arg7 = (float)jarg7; + arg8 = (float)jarg8; + arg9 = (float)jarg9; + arg10 = (float)jarg10; + arg11 = (float)jarg11; + arg12 = (float)jarg12; + arg13 = (float)jarg13; + arg14 = (float)jarg14; + arg15 = (float)jarg15; + arg16 = (float)jarg16; + result = (aiMatrix4x4t< float > *)new aiMatrix4x4t< float >(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_aiMatrix4x4__SWIG_2(void * jarg1) { + void * jresult ; + aiMatrix3x3t< float > *arg1 = 0 ; + aiMatrix4x4t< float > *result = 0 ; + + arg1 = (aiMatrix3x3t< float > *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix3x3t< float > const & type is null", 0); + return 0; + } + result = (aiMatrix4x4t< float > *)new aiMatrix4x4t< float >((aiMatrix3x3t< float > const &)*arg1); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix4x4___idx____SWIG_0(void * jarg1, unsigned int jarg2) { + void * jresult ; + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + unsigned int arg2 ; + float *result = 0 ; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + arg2 = (unsigned int)jarg2; + result = (float *)(arg1)->operator [](arg2); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMatrix4x4___equal__(void * jarg1, void * jarg2) { + unsigned int jresult ; + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + aiMatrix4x4t< float > arg2 ; + aiMatrix4x4t< float > const *argp2 ; + bool result; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + argp2 = (aiMatrix4x4t< float > *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null aiMatrix4x4t< float > const", 0); + return 0; + } + arg2 = *argp2; + result = (bool)((aiMatrix4x4t< float > const *)arg1)->operator ==(arg2); + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMatrix4x4___nequal__(void * jarg1, void * jarg2) { + unsigned int jresult ; + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + aiMatrix4x4t< float > arg2 ; + aiMatrix4x4t< float > const *argp2 ; + bool result; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + argp2 = (aiMatrix4x4t< float > *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null aiMatrix4x4t< float > const", 0); + return 0; + } + arg2 = *argp2; + result = (bool)((aiMatrix4x4t< float > const *)arg1)->operator !=(arg2); + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix4x4___mulnset__(void * jarg1, void * jarg2) { + void * jresult ; + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + aiMatrix4x4t< float > *arg2 = 0 ; + aiMatrix4x4t< float > *result = 0 ; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + arg2 = (aiMatrix4x4t< float > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix4x4t< float > const & type is null", 0); + return 0; + } + result = (aiMatrix4x4t< float > *) &(arg1)->operator *=((aiMatrix4x4t< float > const &)*arg2); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix4x4___mul__(void * jarg1, void * jarg2) { + void * jresult ; + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + aiMatrix4x4t< float > *arg2 = 0 ; + aiMatrix4x4t< float > result; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + arg2 = (aiMatrix4x4t< float > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix4x4t< float > const & type is null", 0); + return 0; + } + result = ((aiMatrix4x4t< float > const *)arg1)->operator *((aiMatrix4x4t< float > const &)*arg2); + jresult = new aiMatrix4x4t< float >((const aiMatrix4x4t< float > &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix4x4_Transpose(void * jarg1) { + void * jresult ; + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + aiMatrix4x4t< float > *result = 0 ; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + result = (aiMatrix4x4t< float > *) &(arg1)->Transpose(); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix4x4_Inverse(void * jarg1) { + void * jresult ; + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + aiMatrix4x4t< float > *result = 0 ; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + result = (aiMatrix4x4t< float > *) &(arg1)->Inverse(); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_Determinant(void * jarg1) { + float jresult ; + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + float result; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + result = (float)((aiMatrix4x4t< float > const *)arg1)->Determinant(); + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiMatrix4x4_IsIdentity(void * jarg1) { + unsigned int jresult ; + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + bool result; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + result = (bool)((aiMatrix4x4t< float > const *)arg1)->IsIdentity(); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_Decompose(void * jarg1, void * jarg2, void * jarg3, void * jarg4) { + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + aiVector3t< float > *arg2 = 0 ; + aiQuaterniont< float > *arg3 = 0 ; + aiVector3t< float > *arg4 = 0 ; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + arg2 = (aiVector3t< float > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3t< float > & type is null", 0); + return ; + } + arg3 = (aiQuaterniont< float > *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiQuaterniont< float > & type is null", 0); + return ; + } + arg4 = (aiVector3t< float > *)jarg4; + if (!arg4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3t< float > & type is null", 0); + return ; + } + ((aiMatrix4x4t< float > const *)arg1)->Decompose(*arg2,*arg3,*arg4); +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_DecomposeNoScaling(void * jarg1, void * jarg2, void * jarg3) { + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + aiQuaterniont< float > *arg2 = 0 ; + aiVector3t< float > *arg3 = 0 ; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + arg2 = (aiQuaterniont< float > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiQuaterniont< float > & type is null", 0); + return ; + } + arg3 = (aiVector3t< float > *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3t< float > & type is null", 0); + return ; + } + ((aiMatrix4x4t< float > const *)arg1)->DecomposeNoScaling(*arg2,*arg3); +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix4x4_FromEulerAnglesXYZ__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) { + void * jresult ; + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + float arg2 ; + float arg3 ; + float arg4 ; + aiMatrix4x4t< float > *result = 0 ; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + arg4 = (float)jarg4; + result = (aiMatrix4x4t< float > *) &(arg1)->FromEulerAnglesXYZ(arg2,arg3,arg4); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix4x4_FromEulerAnglesXYZ__SWIG_1(void * jarg1, void * jarg2) { + void * jresult ; + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + aiVector3t< float > *arg2 = 0 ; + aiMatrix4x4t< float > *result = 0 ; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + arg2 = (aiVector3t< float > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3t< float > const & type is null", 0); + return 0; + } + result = (aiMatrix4x4t< float > *) &(arg1)->FromEulerAnglesXYZ((aiVector3t< float > const &)*arg2); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix4x4_RotationX(float jarg1, void * jarg2) { + void * jresult ; + float arg1 ; + aiMatrix4x4t< float > *arg2 = 0 ; + aiMatrix4x4t< float > *result = 0 ; + + arg1 = (float)jarg1; + arg2 = (aiMatrix4x4t< float > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix4x4t< float > & type is null", 0); + return 0; + } + result = (aiMatrix4x4t< float > *) &aiMatrix4x4t< float >::SWIGTEMPLATEDISAMBIGUATOR RotationX(arg1,*arg2); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix4x4_RotationY(float jarg1, void * jarg2) { + void * jresult ; + float arg1 ; + aiMatrix4x4t< float > *arg2 = 0 ; + aiMatrix4x4t< float > *result = 0 ; + + arg1 = (float)jarg1; + arg2 = (aiMatrix4x4t< float > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix4x4t< float > & type is null", 0); + return 0; + } + result = (aiMatrix4x4t< float > *) &aiMatrix4x4t< float >::SWIGTEMPLATEDISAMBIGUATOR RotationY(arg1,*arg2); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix4x4_RotationZ(float jarg1, void * jarg2) { + void * jresult ; + float arg1 ; + aiMatrix4x4t< float > *arg2 = 0 ; + aiMatrix4x4t< float > *result = 0 ; + + arg1 = (float)jarg1; + arg2 = (aiMatrix4x4t< float > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix4x4t< float > & type is null", 0); + return 0; + } + result = (aiMatrix4x4t< float > *) &aiMatrix4x4t< float >::SWIGTEMPLATEDISAMBIGUATOR RotationZ(arg1,*arg2); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix4x4_Rotation(float jarg1, void * jarg2, void * jarg3) { + void * jresult ; + float arg1 ; + aiVector3t< float > *arg2 = 0 ; + aiMatrix4x4t< float > *arg3 = 0 ; + aiMatrix4x4t< float > *result = 0 ; + + arg1 = (float)jarg1; + arg2 = (aiVector3t< float > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3t< float > const & type is null", 0); + return 0; + } + arg3 = (aiMatrix4x4t< float > *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix4x4t< float > & type is null", 0); + return 0; + } + result = (aiMatrix4x4t< float > *) &aiMatrix4x4t< float >::SWIGTEMPLATEDISAMBIGUATOR Rotation(arg1,(aiVector3t< float > const &)*arg2,*arg3); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix4x4_Translation(void * jarg1, void * jarg2) { + void * jresult ; + aiVector3t< float > *arg1 = 0 ; + aiMatrix4x4t< float > *arg2 = 0 ; + aiMatrix4x4t< float > *result = 0 ; + + arg1 = (aiVector3t< float > *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3t< float > const & type is null", 0); + return 0; + } + arg2 = (aiMatrix4x4t< float > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix4x4t< float > & type is null", 0); + return 0; + } + result = (aiMatrix4x4t< float > *) &aiMatrix4x4t< float >::SWIGTEMPLATEDISAMBIGUATOR Translation((aiVector3t< float > const &)*arg1,*arg2); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix4x4_Scaling(void * jarg1, void * jarg2) { + void * jresult ; + aiVector3t< float > *arg1 = 0 ; + aiMatrix4x4t< float > *arg2 = 0 ; + aiMatrix4x4t< float > *result = 0 ; + + arg1 = (aiVector3t< float > *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3t< float > const & type is null", 0); + return 0; + } + arg2 = (aiMatrix4x4t< float > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix4x4t< float > & type is null", 0); + return 0; + } + result = (aiMatrix4x4t< float > *) &aiMatrix4x4t< float >::SWIGTEMPLATEDISAMBIGUATOR Scaling((aiVector3t< float > const &)*arg1,*arg2); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_aiMatrix4x4_FromToMatrix(void * jarg1, void * jarg2, void * jarg3) { + void * jresult ; + aiVector3t< float > *arg1 = 0 ; + aiVector3t< float > *arg2 = 0 ; + aiMatrix4x4t< float > *arg3 = 0 ; + aiMatrix4x4t< float > *result = 0 ; + + arg1 = (aiVector3t< float > *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3t< float > const & type is null", 0); + return 0; + } + arg2 = (aiVector3t< float > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiVector3t< float > const & type is null", 0); + return 0; + } + arg3 = (aiMatrix4x4t< float > *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "aiMatrix4x4t< float > & type is null", 0); + return 0; + } + result = (aiMatrix4x4t< float > *) &aiMatrix4x4t< float >::SWIGTEMPLATEDISAMBIGUATOR FromToMatrix((aiVector3t< float > const &)*arg1,(aiVector3t< float > const &)*arg2,*arg3); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_a1_set(void * jarg1, float jarg2) { + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + float arg2 ; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->a1 = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_a1_get(void * jarg1) { + float jresult ; + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + float result; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + result = (float) ((arg1)->a1); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_a2_set(void * jarg1, float jarg2) { + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + float arg2 ; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->a2 = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_a2_get(void * jarg1) { + float jresult ; + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + float result; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + result = (float) ((arg1)->a2); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_a3_set(void * jarg1, float jarg2) { + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + float arg2 ; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->a3 = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_a3_get(void * jarg1) { + float jresult ; + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + float result; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + result = (float) ((arg1)->a3); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_a4_set(void * jarg1, float jarg2) { + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + float arg2 ; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->a4 = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_a4_get(void * jarg1) { + float jresult ; + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + float result; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + result = (float) ((arg1)->a4); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_b1_set(void * jarg1, float jarg2) { + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + float arg2 ; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->b1 = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_b1_get(void * jarg1) { + float jresult ; + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + float result; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + result = (float) ((arg1)->b1); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_b2_set(void * jarg1, float jarg2) { + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + float arg2 ; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->b2 = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_b2_get(void * jarg1) { + float jresult ; + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + float result; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + result = (float) ((arg1)->b2); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_b3_set(void * jarg1, float jarg2) { + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + float arg2 ; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->b3 = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_b3_get(void * jarg1) { + float jresult ; + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + float result; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + result = (float) ((arg1)->b3); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_b4_set(void * jarg1, float jarg2) { + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + float arg2 ; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->b4 = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_b4_get(void * jarg1) { + float jresult ; + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + float result; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + result = (float) ((arg1)->b4); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_c1_set(void * jarg1, float jarg2) { + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + float arg2 ; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->c1 = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_c1_get(void * jarg1) { + float jresult ; + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + float result; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + result = (float) ((arg1)->c1); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_c2_set(void * jarg1, float jarg2) { + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + float arg2 ; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->c2 = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_c2_get(void * jarg1) { + float jresult ; + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + float result; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + result = (float) ((arg1)->c2); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_c3_set(void * jarg1, float jarg2) { + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + float arg2 ; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->c3 = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_c3_get(void * jarg1) { + float jresult ; + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + float result; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + result = (float) ((arg1)->c3); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_c4_set(void * jarg1, float jarg2) { + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + float arg2 ; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->c4 = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_c4_get(void * jarg1) { + float jresult ; + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + float result; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + result = (float) ((arg1)->c4); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_d1_set(void * jarg1, float jarg2) { + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + float arg2 ; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->d1 = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_d1_get(void * jarg1) { + float jresult ; + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + float result; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + result = (float) ((arg1)->d1); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_d2_set(void * jarg1, float jarg2) { + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + float arg2 ; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->d2 = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_d2_get(void * jarg1) { + float jresult ; + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + float result; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + result = (float) ((arg1)->d2); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_d3_set(void * jarg1, float jarg2) { + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + float arg2 ; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->d3 = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_d3_get(void * jarg1) { + float jresult ; + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + float result; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + result = (float) ((arg1)->d3); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_aiMatrix4x4_d4_set(void * jarg1, float jarg2) { + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + float arg2 ; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->d4 = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_aiMatrix4x4_d4_get(void * jarg1) { + float jresult ; + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + float result; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + result = (float) ((arg1)->d4); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_delete_aiMatrix4x4(void * jarg1) { + aiMatrix4x4t< float > *arg1 = (aiMatrix4x4t< float > *) 0 ; + + arg1 = (aiMatrix4x4t< float > *)jarg1; + delete arg1; +} + + SWIGEXPORT void SWIGSTDCALL CSharp_FloatVector_Clear(void * jarg1) { std::vector< float > *arg1 = (std::vector< float > *) 0 ; @@ -14075,22 +14427,22 @@ SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVectorVector_Clear(void * jarg1) { SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVectorVector_Add(void * jarg1, void * jarg2) { std::vector< std::vector< aiColor4D * > > *arg1 = (std::vector< std::vector< aiColor4D * > > *) 0 ; - std::vector< aiColor4D * > *arg2 = 0 ; + std::vector< aiColor4t< float > * > *arg2 = 0 ; arg1 = (std::vector< std::vector< aiColor4D * > > *)jarg1; - arg2 = (std::vector< aiColor4D * > *)jarg2; + arg2 = (std::vector< aiColor4t< float > * > *)jarg2; if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiColor4D * > const & type is null", 0); + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiColor4t< float > * > const & type is null", 0); return ; } - (arg1)->push_back((std::vector< aiColor4D * > const &)*arg2); + (arg1)->push_back((std::vector< aiColor4t< float > * > const &)*arg2); } SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiColor4DVectorVector_size(void * jarg1) { unsigned long jresult ; std::vector< std::vector< aiColor4D * > > *arg1 = (std::vector< std::vector< aiColor4D * > > *) 0 ; - std::vector< std::vector< aiColor4D * > >::size_type result; + std::vector< std::vector< aiColor4t< float > * > >::size_type result; arg1 = (std::vector< std::vector< aiColor4D * > > *)jarg1; result = ((std::vector< std::vector< aiColor4D * > > const *)arg1)->size(); @@ -14102,7 +14454,7 @@ SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiColor4DVectorVector_size(void * ja SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiColor4DVectorVector_capacity(void * jarg1) { unsigned long jresult ; std::vector< std::vector< aiColor4D * > > *arg1 = (std::vector< std::vector< aiColor4D * > > *) 0 ; - std::vector< std::vector< aiColor4D * > >::size_type result; + std::vector< std::vector< aiColor4t< float > * > >::size_type result; arg1 = (std::vector< std::vector< aiColor4D * > > *)jarg1; result = ((std::vector< std::vector< aiColor4D * > > const *)arg1)->capacity(); @@ -14113,10 +14465,10 @@ SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiColor4DVectorVector_capacity(void SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVectorVector_reserve(void * jarg1, unsigned long jarg2) { std::vector< std::vector< aiColor4D * > > *arg1 = (std::vector< std::vector< aiColor4D * > > *) 0 ; - std::vector< std::vector< aiColor4D * > >::size_type arg2 ; + std::vector< std::vector< aiColor4t< float > * > >::size_type arg2 ; arg1 = (std::vector< std::vector< aiColor4D * > > *)jarg1; - arg2 = (std::vector< std::vector< aiColor4D * > >::size_type)jarg2; + arg2 = (std::vector< std::vector< aiColor4t< float > * > >::size_type)jarg2; (arg1)->reserve(arg2); } @@ -14170,7 +14522,7 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_aiColor4DVectorVector_getitemcopy(void * ja void * jresult ; std::vector< std::vector< aiColor4D * > > *arg1 = (std::vector< std::vector< aiColor4D * > > *) 0 ; int arg2 ; - std::vector< aiColor4D * > result; + std::vector< aiColor4t< float > * > result; arg1 = (std::vector< std::vector< aiColor4D * > > *)jarg1; arg2 = (int)jarg2; @@ -14182,7 +14534,7 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_aiColor4DVectorVector_getitemcopy(void * ja return 0; } - jresult = new std::vector< aiColor4D * >((const std::vector< aiColor4D * > &)result); + jresult = new std::vector< aiColor4t< float > * >((const std::vector< aiColor4t< float > * > &)result); return jresult; } @@ -14191,12 +14543,12 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_aiColor4DVectorVector_getitem(void * jarg1, void * jresult ; std::vector< std::vector< aiColor4D * > > *arg1 = (std::vector< std::vector< aiColor4D * > > *) 0 ; int arg2 ; - std::vector< aiColor4D * > *result = 0 ; + std::vector< aiColor4t< float > * > *result = 0 ; arg1 = (std::vector< std::vector< aiColor4D * > > *)jarg1; arg2 = (int)jarg2; try { - result = (std::vector< aiColor4D * > *) &std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__getitem(arg1,arg2); + result = (std::vector< aiColor4t< float > * > *) &std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__getitem(arg1,arg2); } catch(std::out_of_range &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); @@ -14211,17 +14563,17 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_aiColor4DVectorVector_getitem(void * jarg1, SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVectorVector_setitem(void * jarg1, int jarg2, void * jarg3) { std::vector< std::vector< aiColor4D * > > *arg1 = (std::vector< std::vector< aiColor4D * > > *) 0 ; int arg2 ; - std::vector< aiColor4D * > *arg3 = 0 ; + std::vector< aiColor4t< float > * > *arg3 = 0 ; arg1 = (std::vector< std::vector< aiColor4D * > > *)jarg1; arg2 = (int)jarg2; - arg3 = (std::vector< aiColor4D * > *)jarg3; + arg3 = (std::vector< aiColor4t< float > * > *)jarg3; if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiColor4D * > const & type is null", 0); + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiColor4t< float > * > const & type is null", 0); return ; } try { - std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__setitem(arg1,arg2,(std::vector< aiColor4D * > const &)*arg3); + std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__setitem(arg1,arg2,(std::vector< aiColor4t< float > * > const &)*arg3); } catch(std::out_of_range &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); @@ -14233,15 +14585,15 @@ SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVectorVector_setitem(void * jarg1, i SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVectorVector_AddRange(void * jarg1, void * jarg2) { std::vector< std::vector< aiColor4D * > > *arg1 = (std::vector< std::vector< aiColor4D * > > *) 0 ; - std::vector< std::vector< aiColor4D * > > *arg2 = 0 ; + std::vector< std::vector< aiColor4t< float > * > > *arg2 = 0 ; arg1 = (std::vector< std::vector< aiColor4D * > > *)jarg1; - arg2 = (std::vector< std::vector< aiColor4D * > > *)jarg2; + arg2 = (std::vector< std::vector< aiColor4t< float > * > > *)jarg2; if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< aiColor4D * > > const & type is null", 0); + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< aiColor4t< float > * > > const & type is null", 0); return ; } - std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__AddRange(arg1,(std::vector< std::vector< aiColor4D * > > const &)*arg2); + std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__AddRange(arg1,(std::vector< std::vector< aiColor4t< float > * > > const &)*arg2); } @@ -14250,13 +14602,13 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_aiColor4DVectorVector_GetRange(void * jarg1 std::vector< std::vector< aiColor4D * > > *arg1 = (std::vector< std::vector< aiColor4D * > > *) 0 ; int arg2 ; int arg3 ; - std::vector< std::vector< aiColor4D * > > *result = 0 ; + std::vector< std::vector< aiColor4t< float > * > > *result = 0 ; arg1 = (std::vector< std::vector< aiColor4D * > > *)jarg1; arg2 = (int)jarg2; arg3 = (int)jarg3; try { - result = (std::vector< std::vector< aiColor4D * > > *)std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__GetRange(arg1,arg2,arg3); + result = (std::vector< std::vector< aiColor4t< float > * > > *)std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__GetRange(arg1,arg2,arg3); } catch(std::out_of_range &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); @@ -14275,17 +14627,17 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_aiColor4DVectorVector_GetRange(void * jarg1 SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVectorVector_Insert(void * jarg1, int jarg2, void * jarg3) { std::vector< std::vector< aiColor4D * > > *arg1 = (std::vector< std::vector< aiColor4D * > > *) 0 ; int arg2 ; - std::vector< aiColor4D * > *arg3 = 0 ; + std::vector< aiColor4t< float > * > *arg3 = 0 ; arg1 = (std::vector< std::vector< aiColor4D * > > *)jarg1; arg2 = (int)jarg2; - arg3 = (std::vector< aiColor4D * > *)jarg3; + arg3 = (std::vector< aiColor4t< float > * > *)jarg3; if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiColor4D * > const & type is null", 0); + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiColor4t< float > * > const & type is null", 0); return ; } try { - std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__Insert(arg1,arg2,(std::vector< aiColor4D * > const &)*arg3); + std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__Insert(arg1,arg2,(std::vector< aiColor4t< float > * > const &)*arg3); } catch(std::out_of_range &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); @@ -14298,17 +14650,17 @@ SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVectorVector_Insert(void * jarg1, in SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVectorVector_InsertRange(void * jarg1, int jarg2, void * jarg3) { std::vector< std::vector< aiColor4D * > > *arg1 = (std::vector< std::vector< aiColor4D * > > *) 0 ; int arg2 ; - std::vector< std::vector< aiColor4D * > > *arg3 = 0 ; + std::vector< std::vector< aiColor4t< float > * > > *arg3 = 0 ; arg1 = (std::vector< std::vector< aiColor4D * > > *)jarg1; arg2 = (int)jarg2; - arg3 = (std::vector< std::vector< aiColor4D * > > *)jarg3; + arg3 = (std::vector< std::vector< aiColor4t< float > * > > *)jarg3; if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< aiColor4D * > > const & type is null", 0); + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< aiColor4t< float > * > > const & type is null", 0); return ; } try { - std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__InsertRange(arg1,arg2,(std::vector< std::vector< aiColor4D * > > const &)*arg3); + std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__InsertRange(arg1,arg2,(std::vector< std::vector< aiColor4t< float > * > > const &)*arg3); } catch(std::out_of_range &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); @@ -14360,18 +14712,18 @@ SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVectorVector_RemoveRange(void * jarg SWIGEXPORT void * SWIGSTDCALL CSharp_aiColor4DVectorVector_Repeat(void * jarg1, int jarg2) { void * jresult ; - std::vector< aiColor4D * > *arg1 = 0 ; + std::vector< aiColor4t< float > * > *arg1 = 0 ; int arg2 ; - std::vector< std::vector< aiColor4D * > > *result = 0 ; + std::vector< std::vector< aiColor4t< float > * > > *result = 0 ; - arg1 = (std::vector< aiColor4D * > *)jarg1; + arg1 = (std::vector< aiColor4t< float > * > *)jarg1; if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiColor4D * > const & type is null", 0); + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiColor4t< float > * > const & type is null", 0); return 0; } arg2 = (int)jarg2; try { - result = (std::vector< std::vector< aiColor4D * > > *)std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__Repeat((std::vector< aiColor4D * > const &)*arg1,arg2); + result = (std::vector< std::vector< aiColor4t< float > * > > *)std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__Repeat((std::vector< aiColor4t< float > * > const &)*arg1,arg2); } catch(std::out_of_range &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); @@ -14417,17 +14769,17 @@ SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVectorVector_Reverse__SWIG_1(void * SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVectorVector_SetRange(void * jarg1, int jarg2, void * jarg3) { std::vector< std::vector< aiColor4D * > > *arg1 = (std::vector< std::vector< aiColor4D * > > *) 0 ; int arg2 ; - std::vector< std::vector< aiColor4D * > > *arg3 = 0 ; + std::vector< std::vector< aiColor4t< float > * > > *arg3 = 0 ; arg1 = (std::vector< std::vector< aiColor4D * > > *)jarg1; arg2 = (int)jarg2; - arg3 = (std::vector< std::vector< aiColor4D * > > *)jarg3; + arg3 = (std::vector< std::vector< aiColor4t< float > * > > *)jarg3; if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< aiColor4D * > > const & type is null", 0); + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< aiColor4t< float > * > > const & type is null", 0); return ; } try { - std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__SetRange(arg1,arg2,(std::vector< std::vector< aiColor4D * > > const &)*arg3); + std_vector_Sl_std_vector_Sl_aiColor4D_Sm__Sg__Sg__SetRange(arg1,arg2,(std::vector< std::vector< aiColor4t< float > * > > const &)*arg3); } catch(std::out_of_range &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); @@ -14455,20 +14807,20 @@ SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVector_Clear(void * jarg1) { SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVector_Add(void * jarg1, void * jarg2) { std::vector< aiColor4D * > *arg1 = (std::vector< aiColor4D * > *) 0 ; - aiColor4D **arg2 = 0 ; - aiColor4D *temp2 = 0 ; + aiColor4t< float > **arg2 = 0 ; + aiColor4t< float > *temp2 = 0 ; arg1 = (std::vector< aiColor4D * > *)jarg1; - temp2 = (aiColor4D *)jarg2; - arg2 = (aiColor4D **)&temp2; - (arg1)->push_back((aiColor4D *const &)*arg2); + temp2 = (aiColor4t< float > *)jarg2; + arg2 = (aiColor4t< float > **)&temp2; + (arg1)->push_back((aiColor4t< float > *const &)*arg2); } SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiColor4DVector_size(void * jarg1) { unsigned long jresult ; std::vector< aiColor4D * > *arg1 = (std::vector< aiColor4D * > *) 0 ; - std::vector< aiColor4D * >::size_type result; + std::vector< aiColor4t< float > * >::size_type result; arg1 = (std::vector< aiColor4D * > *)jarg1; result = ((std::vector< aiColor4D * > const *)arg1)->size(); @@ -14480,7 +14832,7 @@ SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiColor4DVector_size(void * jarg1) { SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiColor4DVector_capacity(void * jarg1) { unsigned long jresult ; std::vector< aiColor4D * > *arg1 = (std::vector< aiColor4D * > *) 0 ; - std::vector< aiColor4D * >::size_type result; + std::vector< aiColor4t< float > * >::size_type result; arg1 = (std::vector< aiColor4D * > *)jarg1; result = ((std::vector< aiColor4D * > const *)arg1)->capacity(); @@ -14491,10 +14843,10 @@ SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiColor4DVector_capacity(void * jarg SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVector_reserve(void * jarg1, unsigned long jarg2) { std::vector< aiColor4D * > *arg1 = (std::vector< aiColor4D * > *) 0 ; - std::vector< aiColor4D * >::size_type arg2 ; + std::vector< aiColor4t< float > * >::size_type arg2 ; arg1 = (std::vector< aiColor4D * > *)jarg1; - arg2 = (std::vector< aiColor4D * >::size_type)jarg2; + arg2 = (std::vector< aiColor4t< float > * >::size_type)jarg2; (arg1)->reserve(arg2); } @@ -14548,12 +14900,12 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_aiColor4DVector_getitemcopy(void * jarg1, i void * jresult ; std::vector< aiColor4D * > *arg1 = (std::vector< aiColor4D * > *) 0 ; int arg2 ; - aiColor4D *result = 0 ; + aiColor4t< float > *result = 0 ; arg1 = (std::vector< aiColor4D * > *)jarg1; arg2 = (int)jarg2; try { - result = (aiColor4D *)std_vector_Sl_aiColor4D_Sm__Sg__getitemcopy(arg1,arg2); + result = (aiColor4t< float > *)std_vector_Sl_aiColor4D_Sm__Sg__getitemcopy(arg1,arg2); } catch(std::out_of_range &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); @@ -14569,12 +14921,12 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_aiColor4DVector_getitem(void * jarg1, int j void * jresult ; std::vector< aiColor4D * > *arg1 = (std::vector< aiColor4D * > *) 0 ; int arg2 ; - aiColor4D **result = 0 ; + aiColor4t< float > **result = 0 ; arg1 = (std::vector< aiColor4D * > *)jarg1; arg2 = (int)jarg2; try { - result = (aiColor4D **) &std_vector_Sl_aiColor4D_Sm__Sg__getitem(arg1,arg2); + result = (aiColor4t< float > **) &std_vector_Sl_aiColor4D_Sm__Sg__getitem(arg1,arg2); } catch(std::out_of_range &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); @@ -14589,15 +14941,15 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_aiColor4DVector_getitem(void * jarg1, int j SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVector_setitem(void * jarg1, int jarg2, void * jarg3) { std::vector< aiColor4D * > *arg1 = (std::vector< aiColor4D * > *) 0 ; int arg2 ; - aiColor4D **arg3 = 0 ; - aiColor4D *temp3 = 0 ; + aiColor4t< float > **arg3 = 0 ; + aiColor4t< float > *temp3 = 0 ; arg1 = (std::vector< aiColor4D * > *)jarg1; arg2 = (int)jarg2; - temp3 = (aiColor4D *)jarg3; - arg3 = (aiColor4D **)&temp3; + temp3 = (aiColor4t< float > *)jarg3; + arg3 = (aiColor4t< float > **)&temp3; try { - std_vector_Sl_aiColor4D_Sm__Sg__setitem(arg1,arg2,(aiColor4D *const &)*arg3); + std_vector_Sl_aiColor4D_Sm__Sg__setitem(arg1,arg2,(aiColor4t< float > *const &)*arg3); } catch(std::out_of_range &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); @@ -14609,15 +14961,15 @@ SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVector_setitem(void * jarg1, int jar SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVector_AddRange(void * jarg1, void * jarg2) { std::vector< aiColor4D * > *arg1 = (std::vector< aiColor4D * > *) 0 ; - std::vector< aiColor4D * > *arg2 = 0 ; + std::vector< aiColor4t< float > * > *arg2 = 0 ; arg1 = (std::vector< aiColor4D * > *)jarg1; - arg2 = (std::vector< aiColor4D * > *)jarg2; + arg2 = (std::vector< aiColor4t< float > * > *)jarg2; if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiColor4D * > const & type is null", 0); + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiColor4t< float > * > const & type is null", 0); return ; } - std_vector_Sl_aiColor4D_Sm__Sg__AddRange(arg1,(std::vector< aiColor4D * > const &)*arg2); + std_vector_Sl_aiColor4D_Sm__Sg__AddRange(arg1,(std::vector< aiColor4t< float > * > const &)*arg2); } @@ -14626,13 +14978,13 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_aiColor4DVector_GetRange(void * jarg1, int std::vector< aiColor4D * > *arg1 = (std::vector< aiColor4D * > *) 0 ; int arg2 ; int arg3 ; - std::vector< aiColor4D * > *result = 0 ; + std::vector< aiColor4t< float > * > *result = 0 ; arg1 = (std::vector< aiColor4D * > *)jarg1; arg2 = (int)jarg2; arg3 = (int)jarg3; try { - result = (std::vector< aiColor4D * > *)std_vector_Sl_aiColor4D_Sm__Sg__GetRange(arg1,arg2,arg3); + result = (std::vector< aiColor4t< float > * > *)std_vector_Sl_aiColor4D_Sm__Sg__GetRange(arg1,arg2,arg3); } catch(std::out_of_range &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); @@ -14651,15 +15003,15 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_aiColor4DVector_GetRange(void * jarg1, int SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVector_Insert(void * jarg1, int jarg2, void * jarg3) { std::vector< aiColor4D * > *arg1 = (std::vector< aiColor4D * > *) 0 ; int arg2 ; - aiColor4D **arg3 = 0 ; - aiColor4D *temp3 = 0 ; + aiColor4t< float > **arg3 = 0 ; + aiColor4t< float > *temp3 = 0 ; arg1 = (std::vector< aiColor4D * > *)jarg1; arg2 = (int)jarg2; - temp3 = (aiColor4D *)jarg3; - arg3 = (aiColor4D **)&temp3; + temp3 = (aiColor4t< float > *)jarg3; + arg3 = (aiColor4t< float > **)&temp3; try { - std_vector_Sl_aiColor4D_Sm__Sg__Insert(arg1,arg2,(aiColor4D *const &)*arg3); + std_vector_Sl_aiColor4D_Sm__Sg__Insert(arg1,arg2,(aiColor4t< float > *const &)*arg3); } catch(std::out_of_range &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); @@ -14672,17 +15024,17 @@ SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVector_Insert(void * jarg1, int jarg SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVector_InsertRange(void * jarg1, int jarg2, void * jarg3) { std::vector< aiColor4D * > *arg1 = (std::vector< aiColor4D * > *) 0 ; int arg2 ; - std::vector< aiColor4D * > *arg3 = 0 ; + std::vector< aiColor4t< float > * > *arg3 = 0 ; arg1 = (std::vector< aiColor4D * > *)jarg1; arg2 = (int)jarg2; - arg3 = (std::vector< aiColor4D * > *)jarg3; + arg3 = (std::vector< aiColor4t< float > * > *)jarg3; if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiColor4D * > const & type is null", 0); + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiColor4t< float > * > const & type is null", 0); return ; } try { - std_vector_Sl_aiColor4D_Sm__Sg__InsertRange(arg1,arg2,(std::vector< aiColor4D * > const &)*arg3); + std_vector_Sl_aiColor4D_Sm__Sg__InsertRange(arg1,arg2,(std::vector< aiColor4t< float > * > const &)*arg3); } catch(std::out_of_range &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); @@ -14734,16 +15086,16 @@ SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVector_RemoveRange(void * jarg1, int SWIGEXPORT void * SWIGSTDCALL CSharp_aiColor4DVector_Repeat(void * jarg1, int jarg2) { void * jresult ; - aiColor4D **arg1 = 0 ; + aiColor4t< float > **arg1 = 0 ; int arg2 ; - aiColor4D *temp1 = 0 ; - std::vector< aiColor4D * > *result = 0 ; + aiColor4t< float > *temp1 = 0 ; + std::vector< aiColor4t< float > * > *result = 0 ; - temp1 = (aiColor4D *)jarg1; - arg1 = (aiColor4D **)&temp1; + temp1 = (aiColor4t< float > *)jarg1; + arg1 = (aiColor4t< float > **)&temp1; arg2 = (int)jarg2; try { - result = (std::vector< aiColor4D * > *)std_vector_Sl_aiColor4D_Sm__Sg__Repeat((aiColor4D *const &)*arg1,arg2); + result = (std::vector< aiColor4t< float > * > *)std_vector_Sl_aiColor4D_Sm__Sg__Repeat((aiColor4t< float > *const &)*arg1,arg2); } catch(std::out_of_range &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); @@ -14789,17 +15141,17 @@ SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVector_Reverse__SWIG_1(void * jarg1, SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVector_SetRange(void * jarg1, int jarg2, void * jarg3) { std::vector< aiColor4D * > *arg1 = (std::vector< aiColor4D * > *) 0 ; int arg2 ; - std::vector< aiColor4D * > *arg3 = 0 ; + std::vector< aiColor4t< float > * > *arg3 = 0 ; arg1 = (std::vector< aiColor4D * > *)jarg1; arg2 = (int)jarg2; - arg3 = (std::vector< aiColor4D * > *)jarg3; + arg3 = (std::vector< aiColor4t< float > * > *)jarg3; if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiColor4D * > const & type is null", 0); + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiColor4t< float > * > const & type is null", 0); return ; } try { - std_vector_Sl_aiColor4D_Sm__Sg__SetRange(arg1,arg2,(std::vector< aiColor4D * > const &)*arg3); + std_vector_Sl_aiColor4D_Sm__Sg__SetRange(arg1,arg2,(std::vector< aiColor4t< float > * > const &)*arg3); } catch(std::out_of_range &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); @@ -14812,14 +15164,14 @@ SWIGEXPORT void SWIGSTDCALL CSharp_aiColor4DVector_SetRange(void * jarg1, int ja SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiColor4DVector_Contains(void * jarg1, void * jarg2) { unsigned int jresult ; std::vector< aiColor4D * > *arg1 = (std::vector< aiColor4D * > *) 0 ; - aiColor4D **arg2 = 0 ; - aiColor4D *temp2 = 0 ; + aiColor4t< float > **arg2 = 0 ; + aiColor4t< float > *temp2 = 0 ; bool result; arg1 = (std::vector< aiColor4D * > *)jarg1; - temp2 = (aiColor4D *)jarg2; - arg2 = (aiColor4D **)&temp2; - result = (bool)std_vector_Sl_aiColor4D_Sm__Sg__Contains(arg1,(aiColor4D *const &)*arg2); + temp2 = (aiColor4t< float > *)jarg2; + arg2 = (aiColor4t< float > **)&temp2; + result = (bool)std_vector_Sl_aiColor4D_Sm__Sg__Contains(arg1,(aiColor4t< float > *const &)*arg2); jresult = result; return jresult; } @@ -14828,14 +15180,14 @@ SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiColor4DVector_Contains(void * jarg1 SWIGEXPORT int SWIGSTDCALL CSharp_aiColor4DVector_IndexOf(void * jarg1, void * jarg2) { int jresult ; std::vector< aiColor4D * > *arg1 = (std::vector< aiColor4D * > *) 0 ; - aiColor4D **arg2 = 0 ; - aiColor4D *temp2 = 0 ; + aiColor4t< float > **arg2 = 0 ; + aiColor4t< float > *temp2 = 0 ; int result; arg1 = (std::vector< aiColor4D * > *)jarg1; - temp2 = (aiColor4D *)jarg2; - arg2 = (aiColor4D **)&temp2; - result = (int)std_vector_Sl_aiColor4D_Sm__Sg__IndexOf(arg1,(aiColor4D *const &)*arg2); + temp2 = (aiColor4t< float > *)jarg2; + arg2 = (aiColor4t< float > **)&temp2; + result = (int)std_vector_Sl_aiColor4D_Sm__Sg__IndexOf(arg1,(aiColor4t< float > *const &)*arg2); jresult = result; return jresult; } @@ -14844,14 +15196,14 @@ SWIGEXPORT int SWIGSTDCALL CSharp_aiColor4DVector_IndexOf(void * jarg1, void * j SWIGEXPORT int SWIGSTDCALL CSharp_aiColor4DVector_LastIndexOf(void * jarg1, void * jarg2) { int jresult ; std::vector< aiColor4D * > *arg1 = (std::vector< aiColor4D * > *) 0 ; - aiColor4D **arg2 = 0 ; - aiColor4D *temp2 = 0 ; + aiColor4t< float > **arg2 = 0 ; + aiColor4t< float > *temp2 = 0 ; int result; arg1 = (std::vector< aiColor4D * > *)jarg1; - temp2 = (aiColor4D *)jarg2; - arg2 = (aiColor4D **)&temp2; - result = (int)std_vector_Sl_aiColor4D_Sm__Sg__LastIndexOf(arg1,(aiColor4D *const &)*arg2); + temp2 = (aiColor4t< float > *)jarg2; + arg2 = (aiColor4t< float > **)&temp2; + result = (int)std_vector_Sl_aiColor4D_Sm__Sg__LastIndexOf(arg1,(aiColor4t< float > *const &)*arg2); jresult = result; return jresult; } @@ -14860,14 +15212,14 @@ SWIGEXPORT int SWIGSTDCALL CSharp_aiColor4DVector_LastIndexOf(void * jarg1, void SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiColor4DVector_Remove(void * jarg1, void * jarg2) { unsigned int jresult ; std::vector< aiColor4D * > *arg1 = (std::vector< aiColor4D * > *) 0 ; - aiColor4D **arg2 = 0 ; - aiColor4D *temp2 = 0 ; + aiColor4t< float > **arg2 = 0 ; + aiColor4t< float > *temp2 = 0 ; bool result; arg1 = (std::vector< aiColor4D * > *)jarg1; - temp2 = (aiColor4D *)jarg2; - arg2 = (aiColor4D **)&temp2; - result = (bool)std_vector_Sl_aiColor4D_Sm__Sg__Remove(arg1,(aiColor4D *const &)*arg2); + temp2 = (aiColor4t< float > *)jarg2; + arg2 = (aiColor4t< float > **)&temp2; + result = (bool)std_vector_Sl_aiColor4D_Sm__Sg__Remove(arg1,(aiColor4t< float > *const &)*arg2); jresult = result; return jresult; } @@ -19251,20 +19603,20 @@ SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3DVector_Clear(void * jarg1) { SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3DVector_Add(void * jarg1, void * jarg2) { std::vector< aiVector3D * > *arg1 = (std::vector< aiVector3D * > *) 0 ; - aiVector3D **arg2 = 0 ; - aiVector3D *temp2 = 0 ; + aiVector3t< float > **arg2 = 0 ; + aiVector3t< float > *temp2 = 0 ; arg1 = (std::vector< aiVector3D * > *)jarg1; - temp2 = (aiVector3D *)jarg2; - arg2 = (aiVector3D **)&temp2; - (arg1)->push_back((aiVector3D *const &)*arg2); + temp2 = (aiVector3t< float > *)jarg2; + arg2 = (aiVector3t< float > **)&temp2; + (arg1)->push_back((aiVector3t< float > *const &)*arg2); } SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiVector3DVector_size(void * jarg1) { unsigned long jresult ; std::vector< aiVector3D * > *arg1 = (std::vector< aiVector3D * > *) 0 ; - std::vector< aiVector3D * >::size_type result; + std::vector< aiVector3t< float > * >::size_type result; arg1 = (std::vector< aiVector3D * > *)jarg1; result = ((std::vector< aiVector3D * > const *)arg1)->size(); @@ -19276,7 +19628,7 @@ SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiVector3DVector_size(void * jarg1) SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiVector3DVector_capacity(void * jarg1) { unsigned long jresult ; std::vector< aiVector3D * > *arg1 = (std::vector< aiVector3D * > *) 0 ; - std::vector< aiVector3D * >::size_type result; + std::vector< aiVector3t< float > * >::size_type result; arg1 = (std::vector< aiVector3D * > *)jarg1; result = ((std::vector< aiVector3D * > const *)arg1)->capacity(); @@ -19287,10 +19639,10 @@ SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiVector3DVector_capacity(void * jar SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3DVector_reserve(void * jarg1, unsigned long jarg2) { std::vector< aiVector3D * > *arg1 = (std::vector< aiVector3D * > *) 0 ; - std::vector< aiVector3D * >::size_type arg2 ; + std::vector< aiVector3t< float > * >::size_type arg2 ; arg1 = (std::vector< aiVector3D * > *)jarg1; - arg2 = (std::vector< aiVector3D * >::size_type)jarg2; + arg2 = (std::vector< aiVector3t< float > * >::size_type)jarg2; (arg1)->reserve(arg2); } @@ -19344,12 +19696,12 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector3DVector_getitemcopy(void * jarg1, void * jresult ; std::vector< aiVector3D * > *arg1 = (std::vector< aiVector3D * > *) 0 ; int arg2 ; - aiVector3D *result = 0 ; + aiVector3t< float > *result = 0 ; arg1 = (std::vector< aiVector3D * > *)jarg1; arg2 = (int)jarg2; try { - result = (aiVector3D *)std_vector_Sl_aiVector3D_Sm__Sg__getitemcopy(arg1,arg2); + result = (aiVector3t< float > *)std_vector_Sl_aiVector3D_Sm__Sg__getitemcopy(arg1,arg2); } catch(std::out_of_range &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); @@ -19365,12 +19717,12 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector3DVector_getitem(void * jarg1, int void * jresult ; std::vector< aiVector3D * > *arg1 = (std::vector< aiVector3D * > *) 0 ; int arg2 ; - aiVector3D **result = 0 ; + aiVector3t< float > **result = 0 ; arg1 = (std::vector< aiVector3D * > *)jarg1; arg2 = (int)jarg2; try { - result = (aiVector3D **) &std_vector_Sl_aiVector3D_Sm__Sg__getitem(arg1,arg2); + result = (aiVector3t< float > **) &std_vector_Sl_aiVector3D_Sm__Sg__getitem(arg1,arg2); } catch(std::out_of_range &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); @@ -19385,15 +19737,15 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector3DVector_getitem(void * jarg1, int SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3DVector_setitem(void * jarg1, int jarg2, void * jarg3) { std::vector< aiVector3D * > *arg1 = (std::vector< aiVector3D * > *) 0 ; int arg2 ; - aiVector3D **arg3 = 0 ; - aiVector3D *temp3 = 0 ; + aiVector3t< float > **arg3 = 0 ; + aiVector3t< float > *temp3 = 0 ; arg1 = (std::vector< aiVector3D * > *)jarg1; arg2 = (int)jarg2; - temp3 = (aiVector3D *)jarg3; - arg3 = (aiVector3D **)&temp3; + temp3 = (aiVector3t< float > *)jarg3; + arg3 = (aiVector3t< float > **)&temp3; try { - std_vector_Sl_aiVector3D_Sm__Sg__setitem(arg1,arg2,(aiVector3D *const &)*arg3); + std_vector_Sl_aiVector3D_Sm__Sg__setitem(arg1,arg2,(aiVector3t< float > *const &)*arg3); } catch(std::out_of_range &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); @@ -19405,15 +19757,15 @@ SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3DVector_setitem(void * jarg1, int ja SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3DVector_AddRange(void * jarg1, void * jarg2) { std::vector< aiVector3D * > *arg1 = (std::vector< aiVector3D * > *) 0 ; - std::vector< aiVector3D * > *arg2 = 0 ; + std::vector< aiVector3t< float > * > *arg2 = 0 ; arg1 = (std::vector< aiVector3D * > *)jarg1; - arg2 = (std::vector< aiVector3D * > *)jarg2; + arg2 = (std::vector< aiVector3t< float > * > *)jarg2; if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiVector3D * > const & type is null", 0); + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiVector3t< float > * > const & type is null", 0); return ; } - std_vector_Sl_aiVector3D_Sm__Sg__AddRange(arg1,(std::vector< aiVector3D * > const &)*arg2); + std_vector_Sl_aiVector3D_Sm__Sg__AddRange(arg1,(std::vector< aiVector3t< float > * > const &)*arg2); } @@ -19422,13 +19774,13 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector3DVector_GetRange(void * jarg1, int std::vector< aiVector3D * > *arg1 = (std::vector< aiVector3D * > *) 0 ; int arg2 ; int arg3 ; - std::vector< aiVector3D * > *result = 0 ; + std::vector< aiVector3t< float > * > *result = 0 ; arg1 = (std::vector< aiVector3D * > *)jarg1; arg2 = (int)jarg2; arg3 = (int)jarg3; try { - result = (std::vector< aiVector3D * > *)std_vector_Sl_aiVector3D_Sm__Sg__GetRange(arg1,arg2,arg3); + result = (std::vector< aiVector3t< float > * > *)std_vector_Sl_aiVector3D_Sm__Sg__GetRange(arg1,arg2,arg3); } catch(std::out_of_range &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); @@ -19447,15 +19799,15 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector3DVector_GetRange(void * jarg1, int SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3DVector_Insert(void * jarg1, int jarg2, void * jarg3) { std::vector< aiVector3D * > *arg1 = (std::vector< aiVector3D * > *) 0 ; int arg2 ; - aiVector3D **arg3 = 0 ; - aiVector3D *temp3 = 0 ; + aiVector3t< float > **arg3 = 0 ; + aiVector3t< float > *temp3 = 0 ; arg1 = (std::vector< aiVector3D * > *)jarg1; arg2 = (int)jarg2; - temp3 = (aiVector3D *)jarg3; - arg3 = (aiVector3D **)&temp3; + temp3 = (aiVector3t< float > *)jarg3; + arg3 = (aiVector3t< float > **)&temp3; try { - std_vector_Sl_aiVector3D_Sm__Sg__Insert(arg1,arg2,(aiVector3D *const &)*arg3); + std_vector_Sl_aiVector3D_Sm__Sg__Insert(arg1,arg2,(aiVector3t< float > *const &)*arg3); } catch(std::out_of_range &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); @@ -19468,17 +19820,17 @@ SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3DVector_Insert(void * jarg1, int jar SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3DVector_InsertRange(void * jarg1, int jarg2, void * jarg3) { std::vector< aiVector3D * > *arg1 = (std::vector< aiVector3D * > *) 0 ; int arg2 ; - std::vector< aiVector3D * > *arg3 = 0 ; + std::vector< aiVector3t< float > * > *arg3 = 0 ; arg1 = (std::vector< aiVector3D * > *)jarg1; arg2 = (int)jarg2; - arg3 = (std::vector< aiVector3D * > *)jarg3; + arg3 = (std::vector< aiVector3t< float > * > *)jarg3; if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiVector3D * > const & type is null", 0); + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiVector3t< float > * > const & type is null", 0); return ; } try { - std_vector_Sl_aiVector3D_Sm__Sg__InsertRange(arg1,arg2,(std::vector< aiVector3D * > const &)*arg3); + std_vector_Sl_aiVector3D_Sm__Sg__InsertRange(arg1,arg2,(std::vector< aiVector3t< float > * > const &)*arg3); } catch(std::out_of_range &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); @@ -19530,16 +19882,16 @@ SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3DVector_RemoveRange(void * jarg1, in SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector3DVector_Repeat(void * jarg1, int jarg2) { void * jresult ; - aiVector3D **arg1 = 0 ; + aiVector3t< float > **arg1 = 0 ; int arg2 ; - aiVector3D *temp1 = 0 ; - std::vector< aiVector3D * > *result = 0 ; + aiVector3t< float > *temp1 = 0 ; + std::vector< aiVector3t< float > * > *result = 0 ; - temp1 = (aiVector3D *)jarg1; - arg1 = (aiVector3D **)&temp1; + temp1 = (aiVector3t< float > *)jarg1; + arg1 = (aiVector3t< float > **)&temp1; arg2 = (int)jarg2; try { - result = (std::vector< aiVector3D * > *)std_vector_Sl_aiVector3D_Sm__Sg__Repeat((aiVector3D *const &)*arg1,arg2); + result = (std::vector< aiVector3t< float > * > *)std_vector_Sl_aiVector3D_Sm__Sg__Repeat((aiVector3t< float > *const &)*arg1,arg2); } catch(std::out_of_range &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); @@ -19585,17 +19937,17 @@ SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3DVector_Reverse__SWIG_1(void * jarg1 SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3DVector_SetRange(void * jarg1, int jarg2, void * jarg3) { std::vector< aiVector3D * > *arg1 = (std::vector< aiVector3D * > *) 0 ; int arg2 ; - std::vector< aiVector3D * > *arg3 = 0 ; + std::vector< aiVector3t< float > * > *arg3 = 0 ; arg1 = (std::vector< aiVector3D * > *)jarg1; arg2 = (int)jarg2; - arg3 = (std::vector< aiVector3D * > *)jarg3; + arg3 = (std::vector< aiVector3t< float > * > *)jarg3; if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiVector3D * > const & type is null", 0); + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< aiVector3t< float > * > const & type is null", 0); return ; } try { - std_vector_Sl_aiVector3D_Sm__Sg__SetRange(arg1,arg2,(std::vector< aiVector3D * > const &)*arg3); + std_vector_Sl_aiVector3D_Sm__Sg__SetRange(arg1,arg2,(std::vector< aiVector3t< float > * > const &)*arg3); } catch(std::out_of_range &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); @@ -19608,14 +19960,14 @@ SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3DVector_SetRange(void * jarg1, int j SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiVector3DVector_Contains(void * jarg1, void * jarg2) { unsigned int jresult ; std::vector< aiVector3D * > *arg1 = (std::vector< aiVector3D * > *) 0 ; - aiVector3D **arg2 = 0 ; - aiVector3D *temp2 = 0 ; + aiVector3t< float > **arg2 = 0 ; + aiVector3t< float > *temp2 = 0 ; bool result; arg1 = (std::vector< aiVector3D * > *)jarg1; - temp2 = (aiVector3D *)jarg2; - arg2 = (aiVector3D **)&temp2; - result = (bool)std_vector_Sl_aiVector3D_Sm__Sg__Contains(arg1,(aiVector3D *const &)*arg2); + temp2 = (aiVector3t< float > *)jarg2; + arg2 = (aiVector3t< float > **)&temp2; + result = (bool)std_vector_Sl_aiVector3D_Sm__Sg__Contains(arg1,(aiVector3t< float > *const &)*arg2); jresult = result; return jresult; } @@ -19624,14 +19976,14 @@ SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiVector3DVector_Contains(void * jarg SWIGEXPORT int SWIGSTDCALL CSharp_aiVector3DVector_IndexOf(void * jarg1, void * jarg2) { int jresult ; std::vector< aiVector3D * > *arg1 = (std::vector< aiVector3D * > *) 0 ; - aiVector3D **arg2 = 0 ; - aiVector3D *temp2 = 0 ; + aiVector3t< float > **arg2 = 0 ; + aiVector3t< float > *temp2 = 0 ; int result; arg1 = (std::vector< aiVector3D * > *)jarg1; - temp2 = (aiVector3D *)jarg2; - arg2 = (aiVector3D **)&temp2; - result = (int)std_vector_Sl_aiVector3D_Sm__Sg__IndexOf(arg1,(aiVector3D *const &)*arg2); + temp2 = (aiVector3t< float > *)jarg2; + arg2 = (aiVector3t< float > **)&temp2; + result = (int)std_vector_Sl_aiVector3D_Sm__Sg__IndexOf(arg1,(aiVector3t< float > *const &)*arg2); jresult = result; return jresult; } @@ -19640,14 +19992,14 @@ SWIGEXPORT int SWIGSTDCALL CSharp_aiVector3DVector_IndexOf(void * jarg1, void * SWIGEXPORT int SWIGSTDCALL CSharp_aiVector3DVector_LastIndexOf(void * jarg1, void * jarg2) { int jresult ; std::vector< aiVector3D * > *arg1 = (std::vector< aiVector3D * > *) 0 ; - aiVector3D **arg2 = 0 ; - aiVector3D *temp2 = 0 ; + aiVector3t< float > **arg2 = 0 ; + aiVector3t< float > *temp2 = 0 ; int result; arg1 = (std::vector< aiVector3D * > *)jarg1; - temp2 = (aiVector3D *)jarg2; - arg2 = (aiVector3D **)&temp2; - result = (int)std_vector_Sl_aiVector3D_Sm__Sg__LastIndexOf(arg1,(aiVector3D *const &)*arg2); + temp2 = (aiVector3t< float > *)jarg2; + arg2 = (aiVector3t< float > **)&temp2; + result = (int)std_vector_Sl_aiVector3D_Sm__Sg__LastIndexOf(arg1,(aiVector3t< float > *const &)*arg2); jresult = result; return jresult; } @@ -19656,14 +20008,14 @@ SWIGEXPORT int SWIGSTDCALL CSharp_aiVector3DVector_LastIndexOf(void * jarg1, voi SWIGEXPORT unsigned int SWIGSTDCALL CSharp_aiVector3DVector_Remove(void * jarg1, void * jarg2) { unsigned int jresult ; std::vector< aiVector3D * > *arg1 = (std::vector< aiVector3D * > *) 0 ; - aiVector3D **arg2 = 0 ; - aiVector3D *temp2 = 0 ; + aiVector3t< float > **arg2 = 0 ; + aiVector3t< float > *temp2 = 0 ; bool result; arg1 = (std::vector< aiVector3D * > *)jarg1; - temp2 = (aiVector3D *)jarg2; - arg2 = (aiVector3D **)&temp2; - result = (bool)std_vector_Sl_aiVector3D_Sm__Sg__Remove(arg1,(aiVector3D *const &)*arg2); + temp2 = (aiVector3t< float > *)jarg2; + arg2 = (aiVector3t< float > **)&temp2; + result = (bool)std_vector_Sl_aiVector3D_Sm__Sg__Remove(arg1,(aiVector3t< float > *const &)*arg2); jresult = result; return jresult; } @@ -19702,7 +20054,7 @@ SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3DVectorVector_Add(void * jarg1, void SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiVector3DVectorVector_size(void * jarg1) { unsigned long jresult ; std::vector< std::vector< aiVector3D * > > *arg1 = (std::vector< std::vector< aiVector3D * > > *) 0 ; - std::vector< std::vector< aiVector3D * > >::size_type result; + std::vector< std::vector< aiVector3t< float > * > >::size_type result; arg1 = (std::vector< std::vector< aiVector3D * > > *)jarg1; result = ((std::vector< std::vector< aiVector3D * > > const *)arg1)->size(); @@ -19714,7 +20066,7 @@ SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiVector3DVectorVector_size(void * j SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiVector3DVectorVector_capacity(void * jarg1) { unsigned long jresult ; std::vector< std::vector< aiVector3D * > > *arg1 = (std::vector< std::vector< aiVector3D * > > *) 0 ; - std::vector< std::vector< aiVector3D * > >::size_type result; + std::vector< std::vector< aiVector3t< float > * > >::size_type result; arg1 = (std::vector< std::vector< aiVector3D * > > *)jarg1; result = ((std::vector< std::vector< aiVector3D * > > const *)arg1)->capacity(); @@ -19725,10 +20077,10 @@ SWIGEXPORT unsigned long SWIGSTDCALL CSharp_aiVector3DVectorVector_capacity(void SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3DVectorVector_reserve(void * jarg1, unsigned long jarg2) { std::vector< std::vector< aiVector3D * > > *arg1 = (std::vector< std::vector< aiVector3D * > > *) 0 ; - std::vector< std::vector< aiVector3D * > >::size_type arg2 ; + std::vector< std::vector< aiVector3t< float > * > >::size_type arg2 ; arg1 = (std::vector< std::vector< aiVector3D * > > *)jarg1; - arg2 = (std::vector< std::vector< aiVector3D * > >::size_type)jarg2; + arg2 = (std::vector< std::vector< aiVector3t< float > * > >::size_type)jarg2; (arg1)->reserve(arg2); } @@ -19833,7 +20185,7 @@ SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3DVectorVector_setitem(void * jarg1, return ; } try { - std_vector_Sl_std_vector_Sl_aiVector3D_Sm__Sg__Sg__setitem(arg1,arg2,(std::vector< aiVector3D * > const &)*arg3); + std_vector_Sl_std_vector_Sl_aiVector3D_Sm__Sg__Sg__setitem(arg1,arg2,(std::vector< aiVector3t< float > * > const &)*arg3); } catch(std::out_of_range &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); @@ -19853,7 +20205,7 @@ SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3DVectorVector_AddRange(void * jarg1, SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< aiVector3D * > > const & type is null", 0); return ; } - std_vector_Sl_std_vector_Sl_aiVector3D_Sm__Sg__Sg__AddRange(arg1,(std::vector< std::vector< aiVector3D * > > const &)*arg2); + std_vector_Sl_std_vector_Sl_aiVector3D_Sm__Sg__Sg__AddRange(arg1,(std::vector< std::vector< aiVector3t< float > * > > const &)*arg2); } @@ -19897,7 +20249,7 @@ SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3DVectorVector_Insert(void * jarg1, i return ; } try { - std_vector_Sl_std_vector_Sl_aiVector3D_Sm__Sg__Sg__Insert(arg1,arg2,(std::vector< aiVector3D * > const &)*arg3); + std_vector_Sl_std_vector_Sl_aiVector3D_Sm__Sg__Sg__Insert(arg1,arg2,(std::vector< aiVector3t< float > * > const &)*arg3); } catch(std::out_of_range &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); @@ -19920,7 +20272,7 @@ SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3DVectorVector_InsertRange(void * jar return ; } try { - std_vector_Sl_std_vector_Sl_aiVector3D_Sm__Sg__Sg__InsertRange(arg1,arg2,(std::vector< std::vector< aiVector3D * > > const &)*arg3); + std_vector_Sl_std_vector_Sl_aiVector3D_Sm__Sg__Sg__InsertRange(arg1,arg2,(std::vector< std::vector< aiVector3t< float > * > > const &)*arg3); } catch(std::out_of_range &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); @@ -19983,7 +20335,7 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_aiVector3DVectorVector_Repeat(void * jarg1, } arg2 = (int)jarg2; try { - result = (std::vector< std::vector< aiVector3D * > > *)std_vector_Sl_std_vector_Sl_aiVector3D_Sm__Sg__Sg__Repeat((std::vector< aiVector3D * > const &)*arg1,arg2); + result = (std::vector< std::vector< aiVector3D * > > *)std_vector_Sl_std_vector_Sl_aiVector3D_Sm__Sg__Sg__Repeat((std::vector< aiVector3t< float > * > const &)*arg1,arg2); } catch(std::out_of_range &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); @@ -20039,7 +20391,7 @@ SWIGEXPORT void SWIGSTDCALL CSharp_aiVector3DVectorVector_SetRange(void * jarg1, return ; } try { - std_vector_Sl_std_vector_Sl_aiVector3D_Sm__Sg__Sg__SetRange(arg1,arg2,(std::vector< std::vector< aiVector3D * > > const &)*arg3); + std_vector_Sl_std_vector_Sl_aiVector3D_Sm__Sg__Sg__SetRange(arg1,arg2,(std::vector< std::vector< aiVector3t< float > * > > const &)*arg3); } catch(std::out_of_range &_e) { SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); diff --git a/port/Assimp.NET/Assimp.NET_CS/Assimp.NET_CS.csproj b/port/Assimp.NET/Assimp.NET_CS/Assimp.NET_CS.csproj index 00722fa93..68cf68760 100644 --- a/port/Assimp.NET/Assimp.NET_CS/Assimp.NET_CS.csproj +++ b/port/Assimp.NET/Assimp.NET_CS/Assimp.NET_CS.csproj @@ -3,7 +3,7 @@ Debug AnyCPU - 9.0.30729 + 9.0.21022 2.0 {A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131} Library @@ -142,9 +142,24 @@ + + Code + + + Code + + + Code + + + Code + Code + + Code + diff --git a/port/Assimp.NET/Assimp.NET_CS/Assimp.cs b/port/Assimp.NET/Assimp.NET_CS/Assimp.cs index 4e64ed430..26ebf63a4 100644 --- a/port/Assimp.NET/Assimp.NET_CS/Assimp.cs +++ b/port/Assimp.NET/Assimp.NET_CS/Assimp.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. @@ -43,60 +43,6 @@ public class Assimp { return ret; } - public static aiVector2D __add__(aiVector2D v1, aiVector2D v2) { - aiVector2D ret = new aiVector2D(AssimpPINVOKE.__add__(aiVector2D.getCPtr(v1), aiVector2D.getCPtr(v2)), true); - if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve(); - return ret; - } - - public static aiVector2D __sub__(aiVector2D v1, aiVector2D v2) { - aiVector2D ret = new aiVector2D(AssimpPINVOKE.__sub____SWIG_0(aiVector2D.getCPtr(v1), aiVector2D.getCPtr(v2)), true); - if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve(); - return ret; - } - - public static float __mul__(aiVector2D v1, aiVector2D v2) { - float ret = AssimpPINVOKE.__mul____SWIG_0(aiVector2D.getCPtr(v1), aiVector2D.getCPtr(v2)); - if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve(); - return ret; - } - - public static aiVector2D __mul__(float f, aiVector2D v) { - aiVector2D ret = new aiVector2D(AssimpPINVOKE.__mul____SWIG_1(f, aiVector2D.getCPtr(v)), true); - if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve(); - return ret; - } - - public static aiVector2D __mul__(aiVector2D v, float f) { - aiVector2D ret = new aiVector2D(AssimpPINVOKE.__mul____SWIG_2(aiVector2D.getCPtr(v), f), true); - if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve(); - return ret; - } - - public static aiVector2D __div__(aiVector2D v, float f) { - aiVector2D ret = new aiVector2D(AssimpPINVOKE.__div____SWIG_0(aiVector2D.getCPtr(v), f), true); - if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve(); - return ret; - } - - public static aiVector2D __div__(aiVector2D v, aiVector2D v2) { - aiVector2D ret = new aiVector2D(AssimpPINVOKE.__div____SWIG_1(aiVector2D.getCPtr(v), aiVector2D.getCPtr(v2)), true); - if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve(); - return ret; - } - - public static aiVector2D __sub__(aiVector2D v) { - aiVector2D ret = new aiVector2D(AssimpPINVOKE.__sub____SWIG_1(aiVector2D.getCPtr(v)), true); - if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve(); - return ret; - } - - public static aiScene aiImportFileFromMemory(string arg0, uint arg1, uint arg2, string arg3) { - IntPtr cPtr = AssimpPINVOKE.aiImportFileFromMemory(arg0, arg1, arg2, arg3); - aiScene ret = (cPtr == IntPtr.Zero) ? null : new aiScene(cPtr, false); - return ret; - } - public static readonly double AI_MATH_PI = AssimpPINVOKE.AI_MATH_PI_get(); public static readonly double AI_MATH_TWO_PI = AssimpPINVOKE.AI_MATH_TWO_PI_get(); public static readonly double AI_MATH_HALF_PI = AssimpPINVOKE.AI_MATH_HALF_PI_get(); @@ -104,7 +50,10 @@ public class Assimp { public static readonly double AI_MATH_TWO_PI_F = AssimpPINVOKE.AI_MATH_TWO_PI_F_get(); public static readonly double AI_MATH_HALF_PI_F = AssimpPINVOKE.AI_MATH_HALF_PI_F_get(); public static readonly string AI_CONFIG_GLOB_MEASURE_TIME = AssimpPINVOKE.AI_CONFIG_GLOB_MEASURE_TIME_get(); + public static readonly string AI_CONFIG_PP_SBBC_MAX_BONES = AssimpPINVOKE.AI_CONFIG_PP_SBBC_MAX_BONES_get(); + public static readonly int AI_SBBC_DEFAULT_MAX_BONES = AssimpPINVOKE.AI_SBBC_DEFAULT_MAX_BONES_get(); public static readonly string AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE = AssimpPINVOKE.AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE_get(); + public static readonly string AI_CONFIG_PP_CT_TEXTURE_CHANNEL_INDEX = AssimpPINVOKE.AI_CONFIG_PP_CT_TEXTURE_CHANNEL_INDEX_get(); public static readonly string AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE = AssimpPINVOKE.AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE_get(); public static readonly string AI_CONFIG_IMPORT_MDL_COLORMAP = AssimpPINVOKE.AI_CONFIG_IMPORT_MDL_COLORMAP_get(); public static readonly string AI_CONFIG_PP_RRM_EXCLUDE_LIST = AssimpPINVOKE.AI_CONFIG_PP_RRM_EXCLUDE_LIST_get(); @@ -118,6 +67,9 @@ public class Assimp { public static readonly int AI_SLM_DEFAULT_MAX_VERTICES = AssimpPINVOKE.AI_SLM_DEFAULT_MAX_VERTICES_get(); public static readonly string AI_CONFIG_PP_LBW_MAX_WEIGHTS = AssimpPINVOKE.AI_CONFIG_PP_LBW_MAX_WEIGHTS_get(); public static readonly int AI_LMW_MAX_WEIGHTS = AssimpPINVOKE.AI_LMW_MAX_WEIGHTS_get(); + public static readonly string AI_CONFIG_PP_DB_THRESHOLD = AssimpPINVOKE.AI_CONFIG_PP_DB_THRESHOLD_get(); + public static readonly double AI_DEBONE_THRESHOLD = AssimpPINVOKE.AI_DEBONE_THRESHOLD_get(); + public static readonly string AI_CONFIG_PP_DB_ALL_OR_NONE = AssimpPINVOKE.AI_CONFIG_PP_DB_ALL_OR_NONE_get(); public static readonly int PP_ICL_PTCACHE_SIZE = AssimpPINVOKE.PP_ICL_PTCACHE_SIZE_get(); public static readonly string AI_CONFIG_PP_ICL_PTCACHE_SIZE = AssimpPINVOKE.AI_CONFIG_PP_ICL_PTCACHE_SIZE_get(); public static readonly string AI_CONFIG_PP_RVC_FLAGS = AssimpPINVOKE.AI_CONFIG_PP_RVC_FLAGS_get(); @@ -150,6 +102,10 @@ public class Assimp { public static readonly string AI_CONFIG_IMPORT_LWS_ANIM_END = AssimpPINVOKE.AI_CONFIG_IMPORT_LWS_ANIM_END_get(); public static readonly string AI_CONFIG_IMPORT_IRR_ANIM_FPS = AssimpPINVOKE.AI_CONFIG_IMPORT_IRR_ANIM_FPS_get(); public static readonly string AI_CONFIG_IMPORT_OGRE_MATERIAL_FILE = AssimpPINVOKE.AI_CONFIG_IMPORT_OGRE_MATERIAL_FILE_get(); + public static readonly string AI_CONFIG_IMPORT_OGRE_TEXTURETYPE_FROM_FILENAME = AssimpPINVOKE.AI_CONFIG_IMPORT_OGRE_TEXTURETYPE_FROM_FILENAME_get(); + public static readonly string AI_CONFIG_IMPORT_IFC_SKIP_SPACE_REPRESENTATIONS = AssimpPINVOKE.AI_CONFIG_IMPORT_IFC_SKIP_SPACE_REPRESENTATIONS_get(); + public static readonly string AI_CONFIG_IMPORT_IFC_SKIP_CURVE_REPRESENTATIONS = AssimpPINVOKE.AI_CONFIG_IMPORT_IFC_SKIP_CURVE_REPRESENTATIONS_get(); + public static readonly string AI_CONFIG_IMPORT_IFC_CUSTOM_TRIANGULATION = AssimpPINVOKE.AI_CONFIG_IMPORT_IFC_CUSTOM_TRIANGULATION_get(); public static readonly int ASSIMP_CFLAGS_SHARED = AssimpPINVOKE.ASSIMP_CFLAGS_SHARED_get(); public static readonly int ASSIMP_CFLAGS_STLPORT = AssimpPINVOKE.ASSIMP_CFLAGS_STLPORT_get(); public static readonly int ASSIMP_CFLAGS_DEBUG = AssimpPINVOKE.ASSIMP_CFLAGS_DEBUG_get(); @@ -162,7 +118,6 @@ public class Assimp { public static readonly int AI_MAX_NUMBER_OF_COLOR_SETS = AssimpPINVOKE.AI_MAX_NUMBER_OF_COLOR_SETS_get(); public static readonly int AI_MAX_NUMBER_OF_TEXTURECOORDS = AssimpPINVOKE.AI_MAX_NUMBER_OF_TEXTURECOORDS_get(); public static readonly string AI_DEFAULT_MATERIAL_NAME = AssimpPINVOKE.AI_DEFAULT_MATERIAL_NAME_get(); - public static readonly string AI_DEFAULT_TEXTURED_MATERIAL_NAME = AssimpPINVOKE.AI_DEFAULT_TEXTURED_MATERIAL_NAME_get(); public static readonly string _AI_MATKEY_TEXTURE_BASE = AssimpPINVOKE._AI_MATKEY_TEXTURE_BASE_get(); public static readonly string _AI_MATKEY_UVWSRC_BASE = AssimpPINVOKE._AI_MATKEY_UVWSRC_BASE_get(); public static readonly string _AI_MATKEY_TEXOP_BASE = AssimpPINVOKE._AI_MATKEY_TEXOP_BASE_get(); diff --git a/port/Assimp.NET/Assimp.NET_CS/AssimpPINVOKE.cs b/port/Assimp.NET/Assimp.NET_CS/AssimpPINVOKE.cs index 188d5a976..6fc33db12 100644 --- a/port/Assimp.NET/Assimp.NET_CS/AssimpPINVOKE.cs +++ b/port/Assimp.NET/Assimp.NET_CS/AssimpPINVOKE.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. @@ -209,9 +209,18 @@ class AssimpPINVOKE { [DllImport("Assimp", EntryPoint="CSharp_AI_CONFIG_GLOB_MEASURE_TIME_get")] public static extern string AI_CONFIG_GLOB_MEASURE_TIME_get(); + [DllImport("Assimp", EntryPoint="CSharp_AI_CONFIG_PP_SBBC_MAX_BONES_get")] + public static extern string AI_CONFIG_PP_SBBC_MAX_BONES_get(); + + [DllImport("Assimp", EntryPoint="CSharp_AI_SBBC_DEFAULT_MAX_BONES_get")] + public static extern int AI_SBBC_DEFAULT_MAX_BONES_get(); + [DllImport("Assimp", EntryPoint="CSharp_AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE_get")] public static extern string AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE_get(); + [DllImport("Assimp", EntryPoint="CSharp_AI_CONFIG_PP_CT_TEXTURE_CHANNEL_INDEX_get")] + public static extern string AI_CONFIG_PP_CT_TEXTURE_CHANNEL_INDEX_get(); + [DllImport("Assimp", EntryPoint="CSharp_AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE_get")] public static extern string AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE_get(); @@ -251,6 +260,15 @@ class AssimpPINVOKE { [DllImport("Assimp", EntryPoint="CSharp_AI_LMW_MAX_WEIGHTS_get")] public static extern int AI_LMW_MAX_WEIGHTS_get(); + [DllImport("Assimp", EntryPoint="CSharp_AI_CONFIG_PP_DB_THRESHOLD_get")] + public static extern string AI_CONFIG_PP_DB_THRESHOLD_get(); + + [DllImport("Assimp", EntryPoint="CSharp_AI_DEBONE_THRESHOLD_get")] + public static extern double AI_DEBONE_THRESHOLD_get(); + + [DllImport("Assimp", EntryPoint="CSharp_AI_CONFIG_PP_DB_ALL_OR_NONE_get")] + public static extern string AI_CONFIG_PP_DB_ALL_OR_NONE_get(); + [DllImport("Assimp", EntryPoint="CSharp_PP_ICL_PTCACHE_SIZE_get")] public static extern int PP_ICL_PTCACHE_SIZE_get(); @@ -347,6 +365,18 @@ class AssimpPINVOKE { [DllImport("Assimp", EntryPoint="CSharp_AI_CONFIG_IMPORT_OGRE_MATERIAL_FILE_get")] public static extern string AI_CONFIG_IMPORT_OGRE_MATERIAL_FILE_get(); + [DllImport("Assimp", EntryPoint="CSharp_AI_CONFIG_IMPORT_OGRE_TEXTURETYPE_FROM_FILENAME_get")] + public static extern string AI_CONFIG_IMPORT_OGRE_TEXTURETYPE_FROM_FILENAME_get(); + + [DllImport("Assimp", EntryPoint="CSharp_AI_CONFIG_IMPORT_IFC_SKIP_SPACE_REPRESENTATIONS_get")] + public static extern string AI_CONFIG_IMPORT_IFC_SKIP_SPACE_REPRESENTATIONS_get(); + + [DllImport("Assimp", EntryPoint="CSharp_AI_CONFIG_IMPORT_IFC_SKIP_CURVE_REPRESENTATIONS_get")] + public static extern string AI_CONFIG_IMPORT_IFC_SKIP_CURVE_REPRESENTATIONS_get(); + + [DllImport("Assimp", EntryPoint="CSharp_AI_CONFIG_IMPORT_IFC_CUSTOM_TRIANGULATION_get")] + public static extern string AI_CONFIG_IMPORT_IFC_CUSTOM_TRIANGULATION_get(); + [DllImport("Assimp", EntryPoint="CSharp_MAXLEN_get")] public static extern uint MAXLEN_get(); @@ -485,6 +515,9 @@ class AssimpPINVOKE { [DllImport("Assimp", EntryPoint="CSharp_aiString___nequal__")] public static extern bool aiString___nequal__(HandleRef jarg1, HandleRef jarg2); + [DllImport("Assimp", EntryPoint="CSharp_aiString_C_Str")] + public static extern string aiString_C_Str(HandleRef jarg1); + [DllImport("Assimp", EntryPoint="CSharp_aiString_Length_set")] public static extern void aiString_Length_set(HandleRef jarg1, uint jarg2); @@ -584,474 +617,6 @@ class AssimpPINVOKE { [DllImport("Assimp", EntryPoint="CSharp_aiGetCompileFlags")] public static extern uint aiGetCompileFlags(); - [DllImport("Assimp", EntryPoint="CSharp_new_aiVector2D__SWIG_0")] - public static extern IntPtr new_aiVector2D__SWIG_0(); - - [DllImport("Assimp", EntryPoint="CSharp_new_aiVector2D__SWIG_1")] - public static extern IntPtr new_aiVector2D__SWIG_1(float jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_new_aiVector2D__SWIG_2")] - public static extern IntPtr new_aiVector2D__SWIG_2(float jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_new_aiVector2D__SWIG_3")] - public static extern IntPtr new_aiVector2D__SWIG_3(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiVector2D_Set")] - public static extern void aiVector2D_Set(HandleRef jarg1, float jarg2, float jarg3); - - [DllImport("Assimp", EntryPoint="CSharp_aiVector2D_SquareLength")] - public static extern float aiVector2D_SquareLength(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiVector2D_Length")] - public static extern float aiVector2D_Length(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiVector2D_Normalize")] - public static extern IntPtr aiVector2D_Normalize(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiVector2D___addnset__")] - public static extern IntPtr aiVector2D___addnset__(HandleRef jarg1, HandleRef jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiVector2D___subnset__")] - public static extern IntPtr aiVector2D___subnset__(HandleRef jarg1, HandleRef jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiVector2D___mulnset__")] - public static extern IntPtr aiVector2D___mulnset__(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiVector2D___divnset__")] - public static extern IntPtr aiVector2D___divnset__(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiVector2D___idx____SWIG_0")] - public static extern float aiVector2D___idx____SWIG_0(HandleRef jarg1, uint jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiVector2D___equal__")] - public static extern bool aiVector2D___equal__(HandleRef jarg1, HandleRef jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiVector2D___nequal__")] - public static extern bool aiVector2D___nequal__(HandleRef jarg1, HandleRef jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiVector2D___set__")] - public static extern IntPtr aiVector2D___set__(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiVector2D_SymMul")] - public static extern IntPtr aiVector2D_SymMul(HandleRef jarg1, HandleRef jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiVector2D_x_set")] - public static extern void aiVector2D_x_set(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiVector2D_x_get")] - public static extern float aiVector2D_x_get(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiVector2D_y_set")] - public static extern void aiVector2D_y_set(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiVector2D_y_get")] - public static extern float aiVector2D_y_get(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_delete_aiVector2D")] - public static extern void delete_aiVector2D(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp___add__")] - public static extern IntPtr __add__(HandleRef jarg1, HandleRef jarg2); - - [DllImport("Assimp", EntryPoint="CSharp___sub____SWIG_0")] - public static extern IntPtr __sub____SWIG_0(HandleRef jarg1, HandleRef jarg2); - - [DllImport("Assimp", EntryPoint="CSharp___mul____SWIG_0")] - public static extern float __mul____SWIG_0(HandleRef jarg1, HandleRef jarg2); - - [DllImport("Assimp", EntryPoint="CSharp___mul____SWIG_1")] - public static extern IntPtr __mul____SWIG_1(float jarg1, HandleRef jarg2); - - [DllImport("Assimp", EntryPoint="CSharp___mul____SWIG_2")] - public static extern IntPtr __mul____SWIG_2(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp___div____SWIG_0")] - public static extern IntPtr __div____SWIG_0(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp___div____SWIG_1")] - public static extern IntPtr __div____SWIG_1(HandleRef jarg1, HandleRef jarg2); - - [DllImport("Assimp", EntryPoint="CSharp___sub____SWIG_1")] - public static extern IntPtr __sub____SWIG_1(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_new_aiVector3D__SWIG_0")] - public static extern IntPtr new_aiVector3D__SWIG_0(); - - [DllImport("Assimp", EntryPoint="CSharp_new_aiVector3D__SWIG_1")] - public static extern IntPtr new_aiVector3D__SWIG_1(float jarg1, float jarg2, float jarg3); - - [DllImport("Assimp", EntryPoint="CSharp_new_aiVector3D__SWIG_2")] - public static extern IntPtr new_aiVector3D__SWIG_2(float jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_new_aiVector3D__SWIG_3")] - public static extern IntPtr new_aiVector3D__SWIG_3(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiVector3D___addnset__")] - public static extern IntPtr aiVector3D___addnset__(HandleRef jarg1, HandleRef jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiVector3D___subnset__")] - public static extern IntPtr aiVector3D___subnset__(HandleRef jarg1, HandleRef jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiVector3D___mulnset____SWIG_0")] - public static extern IntPtr aiVector3D___mulnset____SWIG_0(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiVector3D___divnset__")] - public static extern IntPtr aiVector3D___divnset__(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiVector3D___mulnset____SWIG_1")] - public static extern IntPtr aiVector3D___mulnset____SWIG_1(HandleRef jarg1, HandleRef jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiVector3D___mulnset____SWIG_2")] - public static extern IntPtr aiVector3D___mulnset____SWIG_2(HandleRef jarg1, HandleRef jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiVector3D___idx____SWIG_0")] - public static extern float aiVector3D___idx____SWIG_0(HandleRef jarg1, uint jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiVector3D___equal__")] - public static extern bool aiVector3D___equal__(HandleRef jarg1, HandleRef jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiVector3D___nequal__")] - public static extern bool aiVector3D___nequal__(HandleRef jarg1, HandleRef jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiVector3D_Set")] - public static extern void aiVector3D_Set(HandleRef jarg1, float jarg2, float jarg3, float jarg4); - - [DllImport("Assimp", EntryPoint="CSharp_aiVector3D_SquareLength")] - public static extern float aiVector3D_SquareLength(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiVector3D_Length")] - public static extern float aiVector3D_Length(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiVector3D_Normalize")] - public static extern IntPtr aiVector3D_Normalize(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiVector3D_SymMul")] - public static extern IntPtr aiVector3D_SymMul(HandleRef jarg1, HandleRef jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiVector3D_x_set")] - public static extern void aiVector3D_x_set(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiVector3D_x_get")] - public static extern float aiVector3D_x_get(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiVector3D_y_set")] - public static extern void aiVector3D_y_set(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiVector3D_y_get")] - public static extern float aiVector3D_y_get(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiVector3D_z_set")] - public static extern void aiVector3D_z_set(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiVector3D_z_get")] - public static extern float aiVector3D_z_get(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_delete_aiVector3D")] - public static extern void delete_aiVector3D(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_new_aiColor4D__SWIG_0")] - public static extern IntPtr new_aiColor4D__SWIG_0(); - - [DllImport("Assimp", EntryPoint="CSharp_new_aiColor4D__SWIG_1")] - public static extern IntPtr new_aiColor4D__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4); - - [DllImport("Assimp", EntryPoint="CSharp_new_aiColor4D__SWIG_2")] - public static extern IntPtr new_aiColor4D__SWIG_2(float jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_new_aiColor4D__SWIG_3")] - public static extern IntPtr new_aiColor4D__SWIG_3(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiColor4D___addnset__")] - public static extern IntPtr aiColor4D___addnset__(HandleRef jarg1, HandleRef jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiColor4D___subnset__")] - public static extern IntPtr aiColor4D___subnset__(HandleRef jarg1, HandleRef jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiColor4D___mulnset__")] - public static extern IntPtr aiColor4D___mulnset__(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiColor4D___divnset__")] - public static extern IntPtr aiColor4D___divnset__(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiColor4D___equal__")] - public static extern bool aiColor4D___equal__(HandleRef jarg1, HandleRef jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiColor4D___nequal__")] - public static extern bool aiColor4D___nequal__(HandleRef jarg1, HandleRef jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiColor4D___idx____SWIG_0")] - public static extern float aiColor4D___idx____SWIG_0(HandleRef jarg1, uint jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiColor4D_IsBlack")] - public static extern bool aiColor4D_IsBlack(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiColor4D_r_set")] - public static extern void aiColor4D_r_set(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiColor4D_r_get")] - public static extern float aiColor4D_r_get(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiColor4D_g_set")] - public static extern void aiColor4D_g_set(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiColor4D_g_get")] - public static extern float aiColor4D_g_get(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiColor4D_b_set")] - public static extern void aiColor4D_b_set(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiColor4D_b_get")] - public static extern float aiColor4D_b_get(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiColor4D_a_set")] - public static extern void aiColor4D_a_set(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiColor4D_a_get")] - public static extern float aiColor4D_a_get(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_delete_aiColor4D")] - public static extern void delete_aiColor4D(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_new_aiMatrix3x3__SWIG_0")] - public static extern IntPtr new_aiMatrix3x3__SWIG_0(); - - [DllImport("Assimp", EntryPoint="CSharp_new_aiMatrix3x3__SWIG_1")] - public static extern IntPtr new_aiMatrix3x3__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7, float jarg8, float jarg9); - - [DllImport("Assimp", EntryPoint="CSharp_new_aiMatrix3x3__SWIG_2")] - public static extern IntPtr new_aiMatrix3x3__SWIG_2(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_Transpose")] - public static extern IntPtr aiMatrix3x3_Transpose(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_Inverse")] - public static extern IntPtr aiMatrix3x3_Inverse(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_Determinant")] - public static extern float aiMatrix3x3_Determinant(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_RotationZ")] - public static extern IntPtr aiMatrix3x3_RotationZ(float jarg1, HandleRef jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_Rotation")] - public static extern IntPtr aiMatrix3x3_Rotation(float jarg1, HandleRef jarg2, HandleRef jarg3); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_Translation")] - public static extern IntPtr aiMatrix3x3_Translation(HandleRef jarg1, HandleRef jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_FromToMatrix")] - public static extern IntPtr aiMatrix3x3_FromToMatrix(HandleRef jarg1, HandleRef jarg2, HandleRef jarg3); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_a1_set")] - public static extern void aiMatrix3x3_a1_set(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_a1_get")] - public static extern float aiMatrix3x3_a1_get(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_a2_set")] - public static extern void aiMatrix3x3_a2_set(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_a2_get")] - public static extern float aiMatrix3x3_a2_get(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_a3_set")] - public static extern void aiMatrix3x3_a3_set(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_a3_get")] - public static extern float aiMatrix3x3_a3_get(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_b1_set")] - public static extern void aiMatrix3x3_b1_set(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_b1_get")] - public static extern float aiMatrix3x3_b1_get(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_b2_set")] - public static extern void aiMatrix3x3_b2_set(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_b2_get")] - public static extern float aiMatrix3x3_b2_get(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_b3_set")] - public static extern void aiMatrix3x3_b3_set(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_b3_get")] - public static extern float aiMatrix3x3_b3_get(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_c1_set")] - public static extern void aiMatrix3x3_c1_set(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_c1_get")] - public static extern float aiMatrix3x3_c1_get(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_c2_set")] - public static extern void aiMatrix3x3_c2_set(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_c2_get")] - public static extern float aiMatrix3x3_c2_get(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_c3_set")] - public static extern void aiMatrix3x3_c3_set(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_c3_get")] - public static extern float aiMatrix3x3_c3_get(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_delete_aiMatrix3x3")] - public static extern void delete_aiMatrix3x3(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_new_aiMatrix4x4__SWIG_0")] - public static extern IntPtr new_aiMatrix4x4__SWIG_0(); - - [DllImport("Assimp", EntryPoint="CSharp_new_aiMatrix4x4__SWIG_1")] - public static extern IntPtr new_aiMatrix4x4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7, float jarg8, float jarg9, float jarg10, float jarg11, float jarg12, float jarg13, float jarg14, float jarg15, float jarg16); - - [DllImport("Assimp", EntryPoint="CSharp_new_aiMatrix4x4__SWIG_2")] - public static extern IntPtr new_aiMatrix4x4__SWIG_2(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_Transpose")] - public static extern IntPtr aiMatrix4x4_Transpose(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_Inverse")] - public static extern IntPtr aiMatrix4x4_Inverse(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_Determinant")] - public static extern float aiMatrix4x4_Determinant(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_IsIdentity")] - public static extern bool aiMatrix4x4_IsIdentity(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_Decompose")] - public static extern void aiMatrix4x4_Decompose(HandleRef jarg1, HandleRef jarg2, HandleRef jarg3, HandleRef jarg4); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_DecomposeNoScaling")] - public static extern void aiMatrix4x4_DecomposeNoScaling(HandleRef jarg1, HandleRef jarg2, HandleRef jarg3); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_FromEulerAnglesXYZ__SWIG_0")] - public static extern IntPtr aiMatrix4x4_FromEulerAnglesXYZ__SWIG_0(HandleRef jarg1, float jarg2, float jarg3, float jarg4); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_FromEulerAnglesXYZ__SWIG_1")] - public static extern IntPtr aiMatrix4x4_FromEulerAnglesXYZ__SWIG_1(HandleRef jarg1, HandleRef jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_RotationX")] - public static extern IntPtr aiMatrix4x4_RotationX(float jarg1, HandleRef jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_RotationY")] - public static extern IntPtr aiMatrix4x4_RotationY(float jarg1, HandleRef jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_RotationZ")] - public static extern IntPtr aiMatrix4x4_RotationZ(float jarg1, HandleRef jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_Rotation")] - public static extern IntPtr aiMatrix4x4_Rotation(float jarg1, HandleRef jarg2, HandleRef jarg3); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_Translation")] - public static extern IntPtr aiMatrix4x4_Translation(HandleRef jarg1, HandleRef jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_Scaling")] - public static extern IntPtr aiMatrix4x4_Scaling(HandleRef jarg1, HandleRef jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_FromToMatrix")] - public static extern IntPtr aiMatrix4x4_FromToMatrix(HandleRef jarg1, HandleRef jarg2, HandleRef jarg3); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_a1_set")] - public static extern void aiMatrix4x4_a1_set(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_a1_get")] - public static extern float aiMatrix4x4_a1_get(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_a2_set")] - public static extern void aiMatrix4x4_a2_set(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_a2_get")] - public static extern float aiMatrix4x4_a2_get(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_a3_set")] - public static extern void aiMatrix4x4_a3_set(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_a3_get")] - public static extern float aiMatrix4x4_a3_get(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_a4_set")] - public static extern void aiMatrix4x4_a4_set(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_a4_get")] - public static extern float aiMatrix4x4_a4_get(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_b1_set")] - public static extern void aiMatrix4x4_b1_set(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_b1_get")] - public static extern float aiMatrix4x4_b1_get(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_b2_set")] - public static extern void aiMatrix4x4_b2_set(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_b2_get")] - public static extern float aiMatrix4x4_b2_get(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_b3_set")] - public static extern void aiMatrix4x4_b3_set(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_b3_get")] - public static extern float aiMatrix4x4_b3_get(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_b4_set")] - public static extern void aiMatrix4x4_b4_set(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_b4_get")] - public static extern float aiMatrix4x4_b4_get(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_c1_set")] - public static extern void aiMatrix4x4_c1_set(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_c1_get")] - public static extern float aiMatrix4x4_c1_get(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_c2_set")] - public static extern void aiMatrix4x4_c2_set(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_c2_get")] - public static extern float aiMatrix4x4_c2_get(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_c3_set")] - public static extern void aiMatrix4x4_c3_set(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_c3_get")] - public static extern float aiMatrix4x4_c3_get(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_c4_set")] - public static extern void aiMatrix4x4_c4_set(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_c4_get")] - public static extern float aiMatrix4x4_c4_get(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_d1_set")] - public static extern void aiMatrix4x4_d1_set(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_d1_get")] - public static extern float aiMatrix4x4_d1_get(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_d2_set")] - public static extern void aiMatrix4x4_d2_set(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_d2_get")] - public static extern float aiMatrix4x4_d2_get(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_d3_set")] - public static extern void aiMatrix4x4_d3_set(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_d3_get")] - public static extern float aiMatrix4x4_d3_get(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_d4_set")] - public static extern void aiMatrix4x4_d4_set(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_d4_get")] - public static extern float aiMatrix4x4_d4_get(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_delete_aiMatrix4x4")] - public static extern void delete_aiMatrix4x4(HandleRef jarg1); - [DllImport("Assimp", EntryPoint="CSharp_aiCamera_mName_set")] public static extern void aiCamera_mName_set(HandleRef jarg1, HandleRef jarg2); @@ -1637,9 +1202,6 @@ class AssimpPINVOKE { [DllImport("Assimp", EntryPoint="CSharp_AI_DEFAULT_MATERIAL_NAME_get")] public static extern string AI_DEFAULT_MATERIAL_NAME_get(); - [DllImport("Assimp", EntryPoint="CSharp_AI_DEFAULT_TEXTURED_MATERIAL_NAME_get")] - public static extern string AI_DEFAULT_TEXTURED_MATERIAL_NAME_get(); - [DllImport("Assimp", EntryPoint="CSharp_aiUVTransform_mTranslation_set")] public static extern void aiUVTransform_mTranslation_set(HandleRef jarg1, HandleRef jarg2); @@ -1715,6 +1277,33 @@ class AssimpPINVOKE { [DllImport("Assimp", EntryPoint="CSharp_aiMaterial_GetTextureCount")] public static extern uint aiMaterial_GetTextureCount(HandleRef jarg1, int jarg2); + [DllImport("Assimp", EntryPoint="CSharp_aiMaterial_AddBinaryProperty")] + public static extern int aiMaterial_AddBinaryProperty(HandleRef jarg1, HandleRef jarg2, uint jarg3, string jarg4, uint jarg5, uint jarg6, int jarg7); + + [DllImport("Assimp", EntryPoint="CSharp_aiMaterial_AddProperty__SWIG_0")] + public static extern int aiMaterial_AddProperty__SWIG_0(HandleRef jarg1, HandleRef jarg2, string jarg3, uint jarg4, uint jarg5); + + [DllImport("Assimp", EntryPoint="CSharp_aiMaterial_AddProperty__SWIG_1")] + public static extern int aiMaterial_AddProperty__SWIG_1(HandleRef jarg1, HandleRef jarg2, string jarg3, uint jarg4); + + [DllImport("Assimp", EntryPoint="CSharp_aiMaterial_AddProperty__SWIG_2")] + public static extern int aiMaterial_AddProperty__SWIG_2(HandleRef jarg1, HandleRef jarg2, string jarg3); + + [DllImport("Assimp", EntryPoint="CSharp_aiMaterial_RemoveProperty__SWIG_0")] + public static extern int aiMaterial_RemoveProperty__SWIG_0(HandleRef jarg1, string jarg2, uint jarg3, uint jarg4); + + [DllImport("Assimp", EntryPoint="CSharp_aiMaterial_RemoveProperty__SWIG_1")] + public static extern int aiMaterial_RemoveProperty__SWIG_1(HandleRef jarg1, string jarg2, uint jarg3); + + [DllImport("Assimp", EntryPoint="CSharp_aiMaterial_RemoveProperty__SWIG_2")] + public static extern int aiMaterial_RemoveProperty__SWIG_2(HandleRef jarg1, string jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiMaterial_Clear")] + public static extern void aiMaterial_Clear(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiMaterial_CopyPropertyList")] + public static extern void aiMaterial_CopyPropertyList(HandleRef jarg1, HandleRef jarg2); + [DllImport("Assimp", EntryPoint="CSharp_aiMaterial_GetDiffuse")] public static extern bool aiMaterial_GetDiffuse(HandleRef jarg1, HandleRef jarg2); @@ -1808,75 +1397,6 @@ class AssimpPINVOKE { [DllImport("Assimp", EntryPoint="CSharp__AI_MATKEY_TEXFLAGS_BASE_get")] public static extern string _AI_MATKEY_TEXFLAGS_BASE_get(); - [DllImport("Assimp", EntryPoint="CSharp_new_aiQuaternion__SWIG_0")] - public static extern IntPtr new_aiQuaternion__SWIG_0(); - - [DllImport("Assimp", EntryPoint="CSharp_new_aiQuaternion__SWIG_1")] - public static extern IntPtr new_aiQuaternion__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4); - - [DllImport("Assimp", EntryPoint="CSharp_new_aiQuaternion__SWIG_2")] - public static extern IntPtr new_aiQuaternion__SWIG_2(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_new_aiQuaternion__SWIG_3")] - public static extern IntPtr new_aiQuaternion__SWIG_3(float jarg1, float jarg2, float jarg3); - - [DllImport("Assimp", EntryPoint="CSharp_new_aiQuaternion__SWIG_4")] - public static extern IntPtr new_aiQuaternion__SWIG_4(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_new_aiQuaternion__SWIG_5")] - public static extern IntPtr new_aiQuaternion__SWIG_5(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiQuaternion_GetMatrix")] - public static extern IntPtr aiQuaternion_GetMatrix(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiQuaternion___equal__")] - public static extern bool aiQuaternion___equal__(HandleRef jarg1, HandleRef jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiQuaternion___nequal__")] - public static extern bool aiQuaternion___nequal__(HandleRef jarg1, HandleRef jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiQuaternion_Normalize")] - public static extern IntPtr aiQuaternion_Normalize(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiQuaternion_Conjugate")] - public static extern IntPtr aiQuaternion_Conjugate(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiQuaternion_Rotate")] - public static extern IntPtr aiQuaternion_Rotate(HandleRef jarg1, HandleRef jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiQuaternion___mul__")] - public static extern IntPtr aiQuaternion___mul__(HandleRef jarg1, HandleRef jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiQuaternion_Interpolate")] - public static extern void aiQuaternion_Interpolate(HandleRef jarg1, HandleRef jarg2, HandleRef jarg3, float jarg4); - - [DllImport("Assimp", EntryPoint="CSharp_aiQuaternion_w_set")] - public static extern void aiQuaternion_w_set(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiQuaternion_w_get")] - public static extern float aiQuaternion_w_get(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiQuaternion_x_set")] - public static extern void aiQuaternion_x_set(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiQuaternion_x_get")] - public static extern float aiQuaternion_x_get(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiQuaternion_y_set")] - public static extern void aiQuaternion_y_set(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiQuaternion_y_get")] - public static extern float aiQuaternion_y_get(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_aiQuaternion_z_set")] - public static extern void aiQuaternion_z_set(HandleRef jarg1, float jarg2); - - [DllImport("Assimp", EntryPoint="CSharp_aiQuaternion_z_get")] - public static extern float aiQuaternion_z_get(HandleRef jarg1); - - [DllImport("Assimp", EntryPoint="CSharp_delete_aiQuaternion")] - public static extern void delete_aiQuaternion(HandleRef jarg1); - [DllImport("Assimp", EntryPoint="CSharp_aiNode_mName_set")] public static extern void aiNode_mName_set(HandleRef jarg1, HandleRef jarg2); @@ -2015,6 +1535,12 @@ class AssimpPINVOKE { [DllImport("Assimp", EntryPoint="CSharp_aiScene_HasAnimations")] public static extern bool aiScene_HasAnimations(HandleRef jarg1); + [DllImport("Assimp", EntryPoint="CSharp_aiScene_mPrivate_set")] + public static extern void aiScene_mPrivate_set(HandleRef jarg1, HandleRef jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiScene_mPrivate_get")] + public static extern IntPtr aiScene_mPrivate_get(HandleRef jarg1); + [DllImport("Assimp", EntryPoint="CSharp_aiScene_GetmAnimations")] public static extern IntPtr aiScene_GetmAnimations(HandleRef jarg1); @@ -2105,9 +1631,6 @@ class AssimpPINVOKE { [DllImport("Assimp", EntryPoint="CSharp_AI_PROPERTY_WAS_NOT_EXISTING_get")] public static extern int AI_PROPERTY_WAS_NOT_EXISTING_get(); - [DllImport("Assimp", EntryPoint="CSharp_aiImportFileFromMemory")] - public static extern IntPtr aiImportFileFromMemory(string jarg1, uint jarg2, uint jarg3, string jarg4); - [DllImport("Assimp", EntryPoint="CSharp_new_Importer__SWIG_0")] public static extern IntPtr new_Importer__SWIG_0(); @@ -2165,6 +1688,12 @@ class AssimpPINVOKE { [DllImport("Assimp", EntryPoint="CSharp_Importer_GetErrorString")] public static extern string Importer_GetErrorString(HandleRef jarg1); + [DllImport("Assimp", EntryPoint="CSharp_Importer_GetScene")] + public static extern IntPtr Importer_GetScene(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_Importer_GetOrphanedScene")] + public static extern IntPtr Importer_GetOrphanedScene(HandleRef jarg1); + [DllImport("Assimp", EntryPoint="CSharp_Importer_IsExtensionSupported__SWIG_0")] public static extern bool Importer_IsExtensionSupported__SWIG_0(HandleRef jarg1, string jarg2); @@ -2174,11 +1703,20 @@ class AssimpPINVOKE { [DllImport("Assimp", EntryPoint="CSharp_Importer_GetExtensionList__SWIG_1")] public static extern void Importer_GetExtensionList__SWIG_1(HandleRef jarg1, HandleRef jarg2); - [DllImport("Assimp", EntryPoint="CSharp_Importer_GetScene")] - public static extern IntPtr Importer_GetScene(HandleRef jarg1); + [DllImport("Assimp", EntryPoint="CSharp_Importer_GetImporterCount")] + public static extern uint Importer_GetImporterCount(HandleRef jarg1); - [DllImport("Assimp", EntryPoint="CSharp_Importer_GetOrphanedScene")] - public static extern IntPtr Importer_GetOrphanedScene(HandleRef jarg1); + [DllImport("Assimp", EntryPoint="CSharp_Importer_GetImporterInfo")] + public static extern IntPtr Importer_GetImporterInfo(HandleRef jarg1, uint jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_Importer_GetImporter__SWIG_0")] + public static extern IntPtr Importer_GetImporter__SWIG_0(HandleRef jarg1, uint jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_Importer_GetImporter__SWIG_1")] + public static extern IntPtr Importer_GetImporter__SWIG_1(HandleRef jarg1, string jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_Importer_GetImporterIndex")] + public static extern uint Importer_GetImporterIndex(HandleRef jarg1, string jarg2); [DllImport("Assimp", EntryPoint="CSharp_Importer_GetMemoryRequirements")] public static extern void Importer_GetMemoryRequirements(HandleRef jarg1, HandleRef jarg2); @@ -2186,6 +1724,9 @@ class AssimpPINVOKE { [DllImport("Assimp", EntryPoint="CSharp_Importer_SetExtraVerbose")] public static extern void Importer_SetExtraVerbose(HandleRef jarg1, bool jarg2); + [DllImport("Assimp", EntryPoint="CSharp_Importer_Pimpl__SWIG_0")] + public static extern IntPtr Importer_Pimpl__SWIG_0(HandleRef jarg1); + [DllImport("Assimp", EntryPoint="CSharp_Importer_GetExtensionList__SWIG_2")] public static extern string Importer_GetExtensionList__SWIG_2(HandleRef jarg1); @@ -2198,6 +1739,549 @@ class AssimpPINVOKE { [DllImport("Assimp", EntryPoint="CSharp_ProgressHandler_Update__SWIG_1")] public static extern bool ProgressHandler_Update__SWIG_1(HandleRef jarg1); + [DllImport("Assimp", EntryPoint="CSharp_new_aiColor4D__SWIG_0")] + public static extern IntPtr new_aiColor4D__SWIG_0(); + + [DllImport("Assimp", EntryPoint="CSharp_new_aiColor4D__SWIG_1")] + public static extern IntPtr new_aiColor4D__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4); + + [DllImport("Assimp", EntryPoint="CSharp_new_aiColor4D__SWIG_2")] + public static extern IntPtr new_aiColor4D__SWIG_2(float jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_new_aiColor4D__SWIG_3")] + public static extern IntPtr new_aiColor4D__SWIG_3(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiColor4D___addnset__")] + public static extern IntPtr aiColor4D___addnset__(HandleRef jarg1, HandleRef jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiColor4D___subnset__")] + public static extern IntPtr aiColor4D___subnset__(HandleRef jarg1, HandleRef jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiColor4D___mulnset__")] + public static extern IntPtr aiColor4D___mulnset__(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiColor4D___divnset__")] + public static extern IntPtr aiColor4D___divnset__(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiColor4D___equal__")] + public static extern bool aiColor4D___equal__(HandleRef jarg1, HandleRef jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiColor4D___nequal__")] + public static extern bool aiColor4D___nequal__(HandleRef jarg1, HandleRef jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiColor4D___idx____SWIG_0")] + public static extern float aiColor4D___idx____SWIG_0(HandleRef jarg1, uint jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiColor4D_IsBlack")] + public static extern bool aiColor4D_IsBlack(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiColor4D_r_set")] + public static extern void aiColor4D_r_set(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiColor4D_r_get")] + public static extern float aiColor4D_r_get(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiColor4D_g_set")] + public static extern void aiColor4D_g_set(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiColor4D_g_get")] + public static extern float aiColor4D_g_get(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiColor4D_b_set")] + public static extern void aiColor4D_b_set(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiColor4D_b_get")] + public static extern float aiColor4D_b_get(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiColor4D_a_set")] + public static extern void aiColor4D_a_set(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiColor4D_a_get")] + public static extern float aiColor4D_a_get(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_delete_aiColor4D")] + public static extern void delete_aiColor4D(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_new_aiVector3D__SWIG_0")] + public static extern IntPtr new_aiVector3D__SWIG_0(); + + [DllImport("Assimp", EntryPoint="CSharp_new_aiVector3D__SWIG_1")] + public static extern IntPtr new_aiVector3D__SWIG_1(float jarg1, float jarg2, float jarg3); + + [DllImport("Assimp", EntryPoint="CSharp_new_aiVector3D__SWIG_2")] + public static extern IntPtr new_aiVector3D__SWIG_2(float jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_new_aiVector3D__SWIG_3")] + public static extern IntPtr new_aiVector3D__SWIG_3(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiVector3D___addnset__")] + public static extern IntPtr aiVector3D___addnset__(HandleRef jarg1, HandleRef jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiVector3D___subnset__")] + public static extern IntPtr aiVector3D___subnset__(HandleRef jarg1, HandleRef jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiVector3D___mulnset____SWIG_0")] + public static extern IntPtr aiVector3D___mulnset____SWIG_0(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiVector3D___divnset__")] + public static extern IntPtr aiVector3D___divnset__(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiVector3D___mulnset____SWIG_1")] + public static extern IntPtr aiVector3D___mulnset____SWIG_1(HandleRef jarg1, HandleRef jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiVector3D___mulnset____SWIG_2")] + public static extern IntPtr aiVector3D___mulnset____SWIG_2(HandleRef jarg1, HandleRef jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiVector3D___idx____SWIG_0")] + public static extern float aiVector3D___idx____SWIG_0(HandleRef jarg1, uint jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiVector3D___equal__")] + public static extern bool aiVector3D___equal__(HandleRef jarg1, HandleRef jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiVector3D___nequal__")] + public static extern bool aiVector3D___nequal__(HandleRef jarg1, HandleRef jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiVector3D_Set")] + public static extern void aiVector3D_Set(HandleRef jarg1, float jarg2, float jarg3, float jarg4); + + [DllImport("Assimp", EntryPoint="CSharp_aiVector3D_SquareLength")] + public static extern float aiVector3D_SquareLength(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiVector3D_Length")] + public static extern float aiVector3D_Length(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiVector3D_Normalize")] + public static extern IntPtr aiVector3D_Normalize(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiVector3D_SymMul")] + public static extern IntPtr aiVector3D_SymMul(HandleRef jarg1, HandleRef jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiVector3D_x_set")] + public static extern void aiVector3D_x_set(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiVector3D_x_get")] + public static extern float aiVector3D_x_get(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiVector3D_y_set")] + public static extern void aiVector3D_y_set(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiVector3D_y_get")] + public static extern float aiVector3D_y_get(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiVector3D_z_set")] + public static extern void aiVector3D_z_set(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiVector3D_z_get")] + public static extern float aiVector3D_z_get(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_delete_aiVector3D")] + public static extern void delete_aiVector3D(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_new_aiVector2D__SWIG_0")] + public static extern IntPtr new_aiVector2D__SWIG_0(); + + [DllImport("Assimp", EntryPoint="CSharp_new_aiVector2D__SWIG_1")] + public static extern IntPtr new_aiVector2D__SWIG_1(float jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_new_aiVector2D__SWIG_2")] + public static extern IntPtr new_aiVector2D__SWIG_2(float jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_new_aiVector2D__SWIG_3")] + public static extern IntPtr new_aiVector2D__SWIG_3(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiVector2D_Set")] + public static extern void aiVector2D_Set(HandleRef jarg1, float jarg2, float jarg3); + + [DllImport("Assimp", EntryPoint="CSharp_aiVector2D_SquareLength")] + public static extern float aiVector2D_SquareLength(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiVector2D_Length")] + public static extern float aiVector2D_Length(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiVector2D_Normalize")] + public static extern IntPtr aiVector2D_Normalize(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiVector2D___addnset__")] + public static extern IntPtr aiVector2D___addnset__(HandleRef jarg1, HandleRef jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiVector2D___subnset__")] + public static extern IntPtr aiVector2D___subnset__(HandleRef jarg1, HandleRef jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiVector2D___mulnset__")] + public static extern IntPtr aiVector2D___mulnset__(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiVector2D___divnset__")] + public static extern IntPtr aiVector2D___divnset__(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiVector2D___idx____SWIG_0")] + public static extern float aiVector2D___idx____SWIG_0(HandleRef jarg1, uint jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiVector2D___equal__")] + public static extern bool aiVector2D___equal__(HandleRef jarg1, HandleRef jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiVector2D___nequal__")] + public static extern bool aiVector2D___nequal__(HandleRef jarg1, HandleRef jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiVector2D___set__")] + public static extern IntPtr aiVector2D___set__(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiVector2D_SymMul")] + public static extern IntPtr aiVector2D_SymMul(HandleRef jarg1, HandleRef jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiVector2D_x_set")] + public static extern void aiVector2D_x_set(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiVector2D_x_get")] + public static extern float aiVector2D_x_get(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiVector2D_y_set")] + public static extern void aiVector2D_y_set(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiVector2D_y_get")] + public static extern float aiVector2D_y_get(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_delete_aiVector2D")] + public static extern void delete_aiVector2D(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_new_aiQuaternion__SWIG_0")] + public static extern IntPtr new_aiQuaternion__SWIG_0(); + + [DllImport("Assimp", EntryPoint="CSharp_new_aiQuaternion__SWIG_1")] + public static extern IntPtr new_aiQuaternion__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4); + + [DllImport("Assimp", EntryPoint="CSharp_new_aiQuaternion__SWIG_2")] + public static extern IntPtr new_aiQuaternion__SWIG_2(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_new_aiQuaternion__SWIG_3")] + public static extern IntPtr new_aiQuaternion__SWIG_3(float jarg1, float jarg2, float jarg3); + + [DllImport("Assimp", EntryPoint="CSharp_new_aiQuaternion__SWIG_4")] + public static extern IntPtr new_aiQuaternion__SWIG_4(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_new_aiQuaternion__SWIG_5")] + public static extern IntPtr new_aiQuaternion__SWIG_5(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiQuaternion_GetMatrix")] + public static extern IntPtr aiQuaternion_GetMatrix(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiQuaternion___equal__")] + public static extern bool aiQuaternion___equal__(HandleRef jarg1, HandleRef jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiQuaternion___nequal__")] + public static extern bool aiQuaternion___nequal__(HandleRef jarg1, HandleRef jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiQuaternion_Normalize")] + public static extern IntPtr aiQuaternion_Normalize(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiQuaternion_Conjugate")] + public static extern IntPtr aiQuaternion_Conjugate(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiQuaternion_Rotate")] + public static extern IntPtr aiQuaternion_Rotate(HandleRef jarg1, HandleRef jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiQuaternion___mul__")] + public static extern IntPtr aiQuaternion___mul__(HandleRef jarg1, HandleRef jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiQuaternion_Interpolate")] + public static extern void aiQuaternion_Interpolate(HandleRef jarg1, HandleRef jarg2, HandleRef jarg3, float jarg4); + + [DllImport("Assimp", EntryPoint="CSharp_aiQuaternion_w_set")] + public static extern void aiQuaternion_w_set(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiQuaternion_w_get")] + public static extern float aiQuaternion_w_get(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiQuaternion_x_set")] + public static extern void aiQuaternion_x_set(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiQuaternion_x_get")] + public static extern float aiQuaternion_x_get(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiQuaternion_y_set")] + public static extern void aiQuaternion_y_set(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiQuaternion_y_get")] + public static extern float aiQuaternion_y_get(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiQuaternion_z_set")] + public static extern void aiQuaternion_z_set(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiQuaternion_z_get")] + public static extern float aiQuaternion_z_get(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_delete_aiQuaternion")] + public static extern void delete_aiQuaternion(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_new_aiMatrix3x3__SWIG_0")] + public static extern IntPtr new_aiMatrix3x3__SWIG_0(); + + [DllImport("Assimp", EntryPoint="CSharp_new_aiMatrix3x3__SWIG_1")] + public static extern IntPtr new_aiMatrix3x3__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7, float jarg8, float jarg9); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3___mulnset__")] + public static extern IntPtr aiMatrix3x3___mulnset__(HandleRef jarg1, HandleRef jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3___mul__")] + public static extern IntPtr aiMatrix3x3___mul__(HandleRef jarg1, HandleRef jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3___idx____SWIG_0")] + public static extern IntPtr aiMatrix3x3___idx____SWIG_0(HandleRef jarg1, uint jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3___equal__")] + public static extern bool aiMatrix3x3___equal__(HandleRef jarg1, HandleRef jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3___nequal__")] + public static extern bool aiMatrix3x3___nequal__(HandleRef jarg1, HandleRef jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_new_aiMatrix3x3__SWIG_2")] + public static extern IntPtr new_aiMatrix3x3__SWIG_2(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_Transpose")] + public static extern IntPtr aiMatrix3x3_Transpose(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_Inverse")] + public static extern IntPtr aiMatrix3x3_Inverse(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_Determinant")] + public static extern float aiMatrix3x3_Determinant(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_RotationZ")] + public static extern IntPtr aiMatrix3x3_RotationZ(float jarg1, HandleRef jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_Rotation")] + public static extern IntPtr aiMatrix3x3_Rotation(float jarg1, HandleRef jarg2, HandleRef jarg3); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_Translation")] + public static extern IntPtr aiMatrix3x3_Translation(HandleRef jarg1, HandleRef jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_FromToMatrix")] + public static extern IntPtr aiMatrix3x3_FromToMatrix(HandleRef jarg1, HandleRef jarg2, HandleRef jarg3); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_a1_set")] + public static extern void aiMatrix3x3_a1_set(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_a1_get")] + public static extern float aiMatrix3x3_a1_get(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_a2_set")] + public static extern void aiMatrix3x3_a2_set(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_a2_get")] + public static extern float aiMatrix3x3_a2_get(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_a3_set")] + public static extern void aiMatrix3x3_a3_set(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_a3_get")] + public static extern float aiMatrix3x3_a3_get(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_b1_set")] + public static extern void aiMatrix3x3_b1_set(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_b1_get")] + public static extern float aiMatrix3x3_b1_get(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_b2_set")] + public static extern void aiMatrix3x3_b2_set(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_b2_get")] + public static extern float aiMatrix3x3_b2_get(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_b3_set")] + public static extern void aiMatrix3x3_b3_set(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_b3_get")] + public static extern float aiMatrix3x3_b3_get(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_c1_set")] + public static extern void aiMatrix3x3_c1_set(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_c1_get")] + public static extern float aiMatrix3x3_c1_get(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_c2_set")] + public static extern void aiMatrix3x3_c2_set(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_c2_get")] + public static extern float aiMatrix3x3_c2_get(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_c3_set")] + public static extern void aiMatrix3x3_c3_set(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix3x3_c3_get")] + public static extern float aiMatrix3x3_c3_get(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_delete_aiMatrix3x3")] + public static extern void delete_aiMatrix3x3(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_new_aiMatrix4x4__SWIG_0")] + public static extern IntPtr new_aiMatrix4x4__SWIG_0(); + + [DllImport("Assimp", EntryPoint="CSharp_new_aiMatrix4x4__SWIG_1")] + public static extern IntPtr new_aiMatrix4x4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7, float jarg8, float jarg9, float jarg10, float jarg11, float jarg12, float jarg13, float jarg14, float jarg15, float jarg16); + + [DllImport("Assimp", EntryPoint="CSharp_new_aiMatrix4x4__SWIG_2")] + public static extern IntPtr new_aiMatrix4x4__SWIG_2(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4___idx____SWIG_0")] + public static extern IntPtr aiMatrix4x4___idx____SWIG_0(HandleRef jarg1, uint jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4___equal__")] + public static extern bool aiMatrix4x4___equal__(HandleRef jarg1, HandleRef jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4___nequal__")] + public static extern bool aiMatrix4x4___nequal__(HandleRef jarg1, HandleRef jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4___mulnset__")] + public static extern IntPtr aiMatrix4x4___mulnset__(HandleRef jarg1, HandleRef jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4___mul__")] + public static extern IntPtr aiMatrix4x4___mul__(HandleRef jarg1, HandleRef jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_Transpose")] + public static extern IntPtr aiMatrix4x4_Transpose(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_Inverse")] + public static extern IntPtr aiMatrix4x4_Inverse(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_Determinant")] + public static extern float aiMatrix4x4_Determinant(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_IsIdentity")] + public static extern bool aiMatrix4x4_IsIdentity(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_Decompose")] + public static extern void aiMatrix4x4_Decompose(HandleRef jarg1, HandleRef jarg2, HandleRef jarg3, HandleRef jarg4); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_DecomposeNoScaling")] + public static extern void aiMatrix4x4_DecomposeNoScaling(HandleRef jarg1, HandleRef jarg2, HandleRef jarg3); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_FromEulerAnglesXYZ__SWIG_0")] + public static extern IntPtr aiMatrix4x4_FromEulerAnglesXYZ__SWIG_0(HandleRef jarg1, float jarg2, float jarg3, float jarg4); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_FromEulerAnglesXYZ__SWIG_1")] + public static extern IntPtr aiMatrix4x4_FromEulerAnglesXYZ__SWIG_1(HandleRef jarg1, HandleRef jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_RotationX")] + public static extern IntPtr aiMatrix4x4_RotationX(float jarg1, HandleRef jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_RotationY")] + public static extern IntPtr aiMatrix4x4_RotationY(float jarg1, HandleRef jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_RotationZ")] + public static extern IntPtr aiMatrix4x4_RotationZ(float jarg1, HandleRef jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_Rotation")] + public static extern IntPtr aiMatrix4x4_Rotation(float jarg1, HandleRef jarg2, HandleRef jarg3); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_Translation")] + public static extern IntPtr aiMatrix4x4_Translation(HandleRef jarg1, HandleRef jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_Scaling")] + public static extern IntPtr aiMatrix4x4_Scaling(HandleRef jarg1, HandleRef jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_FromToMatrix")] + public static extern IntPtr aiMatrix4x4_FromToMatrix(HandleRef jarg1, HandleRef jarg2, HandleRef jarg3); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_a1_set")] + public static extern void aiMatrix4x4_a1_set(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_a1_get")] + public static extern float aiMatrix4x4_a1_get(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_a2_set")] + public static extern void aiMatrix4x4_a2_set(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_a2_get")] + public static extern float aiMatrix4x4_a2_get(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_a3_set")] + public static extern void aiMatrix4x4_a3_set(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_a3_get")] + public static extern float aiMatrix4x4_a3_get(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_a4_set")] + public static extern void aiMatrix4x4_a4_set(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_a4_get")] + public static extern float aiMatrix4x4_a4_get(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_b1_set")] + public static extern void aiMatrix4x4_b1_set(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_b1_get")] + public static extern float aiMatrix4x4_b1_get(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_b2_set")] + public static extern void aiMatrix4x4_b2_set(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_b2_get")] + public static extern float aiMatrix4x4_b2_get(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_b3_set")] + public static extern void aiMatrix4x4_b3_set(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_b3_get")] + public static extern float aiMatrix4x4_b3_get(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_b4_set")] + public static extern void aiMatrix4x4_b4_set(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_b4_get")] + public static extern float aiMatrix4x4_b4_get(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_c1_set")] + public static extern void aiMatrix4x4_c1_set(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_c1_get")] + public static extern float aiMatrix4x4_c1_get(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_c2_set")] + public static extern void aiMatrix4x4_c2_set(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_c2_get")] + public static extern float aiMatrix4x4_c2_get(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_c3_set")] + public static extern void aiMatrix4x4_c3_set(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_c3_get")] + public static extern float aiMatrix4x4_c3_get(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_c4_set")] + public static extern void aiMatrix4x4_c4_set(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_c4_get")] + public static extern float aiMatrix4x4_c4_get(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_d1_set")] + public static extern void aiMatrix4x4_d1_set(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_d1_get")] + public static extern float aiMatrix4x4_d1_get(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_d2_set")] + public static extern void aiMatrix4x4_d2_set(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_d2_get")] + public static extern float aiMatrix4x4_d2_get(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_d3_set")] + public static extern void aiMatrix4x4_d3_set(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_d3_get")] + public static extern float aiMatrix4x4_d3_get(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_d4_set")] + public static extern void aiMatrix4x4_d4_set(HandleRef jarg1, float jarg2); + + [DllImport("Assimp", EntryPoint="CSharp_aiMatrix4x4_d4_get")] + public static extern float aiMatrix4x4_d4_get(HandleRef jarg1); + + [DllImport("Assimp", EntryPoint="CSharp_delete_aiMatrix4x4")] + public static extern void delete_aiMatrix4x4(HandleRef jarg1); + [DllImport("Assimp", EntryPoint="CSharp_FloatVector_Clear")] public static extern void FloatVector_Clear(HandleRef jarg1); diff --git a/port/Assimp.NET/Assimp.NET_CS/FloatVector.cs b/port/Assimp.NET/Assimp.NET_CS/FloatVector.cs index 5fb6144ee..d8e9f212f 100644 --- a/port/Assimp.NET/Assimp.NET_CS/FloatVector.cs +++ b/port/Assimp.NET/Assimp.NET_CS/FloatVector.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/Importer.cs b/port/Assimp.NET/Assimp.NET_CS/Importer.cs index 111c70622..9709b38c2 100644 --- a/port/Assimp.NET/Assimp.NET_CS/Importer.cs +++ b/port/Assimp.NET/Assimp.NET_CS/Importer.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. @@ -128,6 +128,18 @@ public class Importer : IDisposable { return ret; } + public aiScene GetScene() { + IntPtr cPtr = AssimpPINVOKE.Importer_GetScene(swigCPtr); + aiScene ret = (cPtr == IntPtr.Zero) ? null : new aiScene(cPtr, false); + return ret; + } + + public aiScene GetOrphanedScene() { + IntPtr cPtr = AssimpPINVOKE.Importer_GetOrphanedScene(swigCPtr); + aiScene ret = (cPtr == IntPtr.Zero) ? null : new aiScene(cPtr, false); + return ret; + } + public bool IsExtensionSupported(string szExtension) { bool ret = AssimpPINVOKE.Importer_IsExtensionSupported__SWIG_0(swigCPtr, szExtension); return ret; @@ -143,15 +155,31 @@ public class Importer : IDisposable { if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve(); } - public aiScene GetScene() { - IntPtr cPtr = AssimpPINVOKE.Importer_GetScene(swigCPtr); - aiScene ret = (cPtr == IntPtr.Zero) ? null : new aiScene(cPtr, false); + public uint GetImporterCount() { + uint ret = AssimpPINVOKE.Importer_GetImporterCount(swigCPtr); return ret; } - public aiScene GetOrphanedScene() { - IntPtr cPtr = AssimpPINVOKE.Importer_GetOrphanedScene(swigCPtr); - aiScene ret = (cPtr == IntPtr.Zero) ? null : new aiScene(cPtr, false); + public SWIGTYPE_p_aiImporterDesc GetImporterInfo(uint index) { + IntPtr cPtr = AssimpPINVOKE.Importer_GetImporterInfo(swigCPtr, index); + SWIGTYPE_p_aiImporterDesc ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_aiImporterDesc(cPtr, false); + return ret; + } + + public SWIGTYPE_p_Assimp__BaseImporter GetImporter(uint index) { + IntPtr cPtr = AssimpPINVOKE.Importer_GetImporter__SWIG_0(swigCPtr, index); + SWIGTYPE_p_Assimp__BaseImporter ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_Assimp__BaseImporter(cPtr, false); + return ret; + } + + public SWIGTYPE_p_Assimp__BaseImporter GetImporter(string szExtension) { + IntPtr cPtr = AssimpPINVOKE.Importer_GetImporter__SWIG_1(swigCPtr, szExtension); + SWIGTYPE_p_Assimp__BaseImporter ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_Assimp__BaseImporter(cPtr, false); + return ret; + } + + public uint GetImporterIndex(string szExtension) { + uint ret = AssimpPINVOKE.Importer_GetImporterIndex(swigCPtr, szExtension); return ret; } @@ -164,6 +192,12 @@ public class Importer : IDisposable { AssimpPINVOKE.Importer_SetExtraVerbose(swigCPtr, bDo); } + public SWIGTYPE_p_Assimp__ImporterPimpl Pimpl() { + IntPtr cPtr = AssimpPINVOKE.Importer_Pimpl__SWIG_0(swigCPtr); + SWIGTYPE_p_Assimp__ImporterPimpl ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_Assimp__ImporterPimpl(cPtr, false); + return ret; + } + public string GetExtensionList() { string ret = AssimpPINVOKE.Importer_GetExtensionList__SWIG_2(swigCPtr); return ret; diff --git a/port/Assimp.NET/Assimp.NET_CS/ProgressHandler.cs b/port/Assimp.NET/Assimp.NET_CS/ProgressHandler.cs index e27527f92..4493930f3 100644 --- a/port/Assimp.NET/Assimp.NET_CS/ProgressHandler.cs +++ b/port/Assimp.NET/Assimp.NET_CS/ProgressHandler.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_Assimp__BaseImporter.cs b/port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_Assimp__BaseImporter.cs new file mode 100644 index 000000000..a6b0c4d74 --- /dev/null +++ b/port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_Assimp__BaseImporter.cs @@ -0,0 +1,27 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.8 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + + +using System; +using System.Runtime.InteropServices; + +public class SWIGTYPE_p_Assimp__BaseImporter { + private HandleRef swigCPtr; + + internal SWIGTYPE_p_Assimp__BaseImporter(IntPtr cPtr, bool futureUse) { + swigCPtr = new HandleRef(this, cPtr); + } + + protected SWIGTYPE_p_Assimp__BaseImporter() { + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + + internal static HandleRef getCPtr(SWIGTYPE_p_Assimp__BaseImporter obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } +} diff --git a/port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_Assimp__ImporterPimpl.cs b/port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_Assimp__ImporterPimpl.cs new file mode 100644 index 000000000..45900e9ec --- /dev/null +++ b/port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_Assimp__ImporterPimpl.cs @@ -0,0 +1,27 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.8 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + + +using System; +using System.Runtime.InteropServices; + +public class SWIGTYPE_p_Assimp__ImporterPimpl { + private HandleRef swigCPtr; + + internal SWIGTYPE_p_Assimp__ImporterPimpl(IntPtr cPtr, bool futureUse) { + swigCPtr = new HandleRef(this, cPtr); + } + + protected SWIGTYPE_p_Assimp__ImporterPimpl() { + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + + internal static HandleRef getCPtr(SWIGTYPE_p_Assimp__ImporterPimpl obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } +} diff --git a/port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_aiImporterDesc.cs b/port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_aiImporterDesc.cs new file mode 100644 index 000000000..90e310079 --- /dev/null +++ b/port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_aiImporterDesc.cs @@ -0,0 +1,27 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.8 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + + +using System; +using System.Runtime.InteropServices; + +public class SWIGTYPE_p_aiImporterDesc { + private HandleRef swigCPtr; + + internal SWIGTYPE_p_aiImporterDesc(IntPtr cPtr, bool futureUse) { + swigCPtr = new HandleRef(this, cPtr); + } + + protected SWIGTYPE_p_aiImporterDesc() { + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + + internal static HandleRef getCPtr(SWIGTYPE_p_aiImporterDesc obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } +} diff --git a/port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_float.cs b/port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_float.cs new file mode 100644 index 000000000..7d117d2a7 --- /dev/null +++ b/port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_float.cs @@ -0,0 +1,27 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.8 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + + +using System; +using System.Runtime.InteropServices; + +public class SWIGTYPE_p_float { + private HandleRef swigCPtr; + + internal SWIGTYPE_p_float(IntPtr cPtr, bool futureUse) { + swigCPtr = new HandleRef(this, cPtr); + } + + protected SWIGTYPE_p_float() { + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + + internal static HandleRef getCPtr(SWIGTYPE_p_float obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } +} diff --git a/port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_std__string.cs b/port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_std__string.cs index bcc27ba4d..e539303f1 100644 --- a/port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_std__string.cs +++ b/port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_std__string.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_void.cs b/port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_void.cs new file mode 100644 index 000000000..f87f7e5ee --- /dev/null +++ b/port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_void.cs @@ -0,0 +1,27 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.8 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + + +using System; +using System.Runtime.InteropServices; + +public class SWIGTYPE_p_void { + private HandleRef swigCPtr; + + internal SWIGTYPE_p_void(IntPtr cPtr, bool futureUse) { + swigCPtr = new HandleRef(this, cPtr); + } + + protected SWIGTYPE_p_void() { + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + + internal static HandleRef getCPtr(SWIGTYPE_p_void obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } +} diff --git a/port/Assimp.NET/Assimp.NET_CS/UintVector.cs b/port/Assimp.NET/Assimp.NET_CS/UintVector.cs index 11cd9944a..def1a50de 100644 --- a/port/Assimp.NET/Assimp.NET_CS/UintVector.cs +++ b/port/Assimp.NET/Assimp.NET_CS/UintVector.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiAnimBehaviour.cs b/port/Assimp.NET/Assimp.NET_CS/aiAnimBehaviour.cs index a0cbecbc7..0483fd585 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiAnimBehaviour.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiAnimBehaviour.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiAnimMesh.cs b/port/Assimp.NET/Assimp.NET_CS/aiAnimMesh.cs index 2e0b25f60..b61b4da19 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiAnimMesh.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiAnimMesh.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiAnimMeshVector.cs b/port/Assimp.NET/Assimp.NET_CS/aiAnimMeshVector.cs index 5ad7bbaa9..0a4445949 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiAnimMeshVector.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiAnimMeshVector.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiAnimation.cs b/port/Assimp.NET/Assimp.NET_CS/aiAnimation.cs index 375a4e1ab..e9b30800f 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiAnimation.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiAnimation.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiAnimationVector.cs b/port/Assimp.NET/Assimp.NET_CS/aiAnimationVector.cs index 6e5a0c899..6a21f1242 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiAnimationVector.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiAnimationVector.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiBlendMode.cs b/port/Assimp.NET/Assimp.NET_CS/aiBlendMode.cs index 2aa7c59dd..ab8e563a6 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiBlendMode.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiBlendMode.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiBone.cs b/port/Assimp.NET/Assimp.NET_CS/aiBone.cs index df3aa5904..226ce943e 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiBone.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiBone.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiBoneVector.cs b/port/Assimp.NET/Assimp.NET_CS/aiBoneVector.cs index 077d05f28..a6feb46ff 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiBoneVector.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiBoneVector.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiCamera.cs b/port/Assimp.NET/Assimp.NET_CS/aiCamera.cs index 5bfda016e..3c96d0d21 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiCamera.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiCamera.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiCameraVector.cs b/port/Assimp.NET/Assimp.NET_CS/aiCameraVector.cs index 66a12d5d6..1cbc857e1 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiCameraVector.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiCameraVector.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiColor3D.cs b/port/Assimp.NET/Assimp.NET_CS/aiColor3D.cs index 3c87df89d..8590b614f 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiColor3D.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiColor3D.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiColor4D.cs b/port/Assimp.NET/Assimp.NET_CS/aiColor4D.cs index c8e0110ea..435ec505a 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiColor4D.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiColor4D.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiColor4DVector.cs b/port/Assimp.NET/Assimp.NET_CS/aiColor4DVector.cs index 0608bac52..3b1b76920 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiColor4DVector.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiColor4DVector.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiColor4DVectorVector.cs b/port/Assimp.NET/Assimp.NET_CS/aiColor4DVectorVector.cs index 8440965be..ffe291d0e 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiColor4DVectorVector.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiColor4DVectorVector.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiComponent.cs b/port/Assimp.NET/Assimp.NET_CS/aiComponent.cs index 5daf83b2c..63e94d36a 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiComponent.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiComponent.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiDefaultLogStream.cs b/port/Assimp.NET/Assimp.NET_CS/aiDefaultLogStream.cs index 1d1dd7bfa..a39efdbd3 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiDefaultLogStream.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiDefaultLogStream.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiFace.cs b/port/Assimp.NET/Assimp.NET_CS/aiFace.cs index 71eb36fcf..5d2a2528f 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiFace.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiFace.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiFaceVector.cs b/port/Assimp.NET/Assimp.NET_CS/aiFaceVector.cs index 416733bc8..9c612e6e0 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiFaceVector.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiFaceVector.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiLight.cs b/port/Assimp.NET/Assimp.NET_CS/aiLight.cs index 9ff95c11b..8207ef21a 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiLight.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiLight.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiLightSourceType.cs b/port/Assimp.NET/Assimp.NET_CS/aiLightSourceType.cs index 1b022d756..aedc03417 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiLightSourceType.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiLightSourceType.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiLightVector.cs b/port/Assimp.NET/Assimp.NET_CS/aiLightVector.cs index a87e8a7f6..6bf566e1e 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiLightVector.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiLightVector.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiMaterial.cs b/port/Assimp.NET/Assimp.NET_CS/aiMaterial.cs index 58c951829..11e9354c3 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiMaterial.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiMaterial.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. @@ -76,6 +76,49 @@ public class aiMaterial : IDisposable { return ret; } + public aiReturn AddBinaryProperty(SWIGTYPE_p_void pInput, uint pSizeInBytes, string pKey, uint type, uint index, aiPropertyTypeInfo pType) { + aiReturn ret = (aiReturn)AssimpPINVOKE.aiMaterial_AddBinaryProperty(swigCPtr, SWIGTYPE_p_void.getCPtr(pInput), pSizeInBytes, pKey, type, index, (int)pType); + return ret; + } + + public aiReturn AddProperty(aiString pInput, string pKey, uint type, uint index) { + aiReturn ret = (aiReturn)AssimpPINVOKE.aiMaterial_AddProperty__SWIG_0(swigCPtr, aiString.getCPtr(pInput), pKey, type, index); + return ret; + } + + public aiReturn AddProperty(aiString pInput, string pKey, uint type) { + aiReturn ret = (aiReturn)AssimpPINVOKE.aiMaterial_AddProperty__SWIG_1(swigCPtr, aiString.getCPtr(pInput), pKey, type); + return ret; + } + + public aiReturn AddProperty(aiString pInput, string pKey) { + aiReturn ret = (aiReturn)AssimpPINVOKE.aiMaterial_AddProperty__SWIG_2(swigCPtr, aiString.getCPtr(pInput), pKey); + return ret; + } + + public aiReturn RemoveProperty(string pKey, uint type, uint index) { + aiReturn ret = (aiReturn)AssimpPINVOKE.aiMaterial_RemoveProperty__SWIG_0(swigCPtr, pKey, type, index); + return ret; + } + + public aiReturn RemoveProperty(string pKey, uint type) { + aiReturn ret = (aiReturn)AssimpPINVOKE.aiMaterial_RemoveProperty__SWIG_1(swigCPtr, pKey, type); + return ret; + } + + public aiReturn RemoveProperty(string pKey) { + aiReturn ret = (aiReturn)AssimpPINVOKE.aiMaterial_RemoveProperty__SWIG_2(swigCPtr, pKey); + return ret; + } + + public void Clear() { + AssimpPINVOKE.aiMaterial_Clear(swigCPtr); + } + + public static void CopyPropertyList(aiMaterial pcDest, aiMaterial pcSrc) { + AssimpPINVOKE.aiMaterial_CopyPropertyList(aiMaterial.getCPtr(pcDest), aiMaterial.getCPtr(pcSrc)); + } + public bool GetDiffuse(aiColor4D INOUT) { bool ret = AssimpPINVOKE.aiMaterial_GetDiffuse(swigCPtr, aiColor4D.getCPtr(INOUT)); return ret; diff --git a/port/Assimp.NET/Assimp.NET_CS/aiMaterialProperty.cs b/port/Assimp.NET/Assimp.NET_CS/aiMaterialProperty.cs index 3d72905c5..b32e11a6b 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiMaterialProperty.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiMaterialProperty.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiMaterialVector.cs b/port/Assimp.NET/Assimp.NET_CS/aiMaterialVector.cs index b3a2e97ec..13c19ce1a 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiMaterialVector.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiMaterialVector.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiMatrix3x3.cs b/port/Assimp.NET/Assimp.NET_CS/aiMatrix3x3.cs index cc4cb6506..633f06721 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiMatrix3x3.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiMatrix3x3.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. @@ -46,6 +46,36 @@ public class aiMatrix3x3 : IDisposable { public aiMatrix3x3(float _a1, float _a2, float _a3, float _b1, float _b2, float _b3, float _c1, float _c2, float _c3) : this(AssimpPINVOKE.new_aiMatrix3x3__SWIG_1(_a1, _a2, _a3, _b1, _b2, _b3, _c1, _c2, _c3), true) { } + public aiMatrix3x3 __mulnset__(aiMatrix3x3 m) { + aiMatrix3x3 ret = new aiMatrix3x3(AssimpPINVOKE.aiMatrix3x3___mulnset__(swigCPtr, aiMatrix3x3.getCPtr(m)), false); + if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public aiMatrix3x3 __mul__(aiMatrix3x3 m) { + aiMatrix3x3 ret = new aiMatrix3x3(AssimpPINVOKE.aiMatrix3x3___mul__(swigCPtr, aiMatrix3x3.getCPtr(m)), true); + if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public SWIGTYPE_p_float __idx__(uint p_iIndex) { + IntPtr cPtr = AssimpPINVOKE.aiMatrix3x3___idx____SWIG_0(swigCPtr, p_iIndex); + SWIGTYPE_p_float ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_float(cPtr, false); + return ret; + } + + public bool __equal__(aiMatrix4x4 m) { + bool ret = AssimpPINVOKE.aiMatrix3x3___equal__(swigCPtr, aiMatrix4x4.getCPtr(m)); + if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public bool __nequal__(aiMatrix4x4 m) { + bool ret = AssimpPINVOKE.aiMatrix3x3___nequal__(swigCPtr, aiMatrix4x4.getCPtr(m)); + if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + public aiMatrix3x3(aiMatrix4x4 pMatrix) : this(AssimpPINVOKE.new_aiMatrix3x3__SWIG_2(aiMatrix4x4.getCPtr(pMatrix)), true) { if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve(); } diff --git a/port/Assimp.NET/Assimp.NET_CS/aiMatrix4x4.cs b/port/Assimp.NET/Assimp.NET_CS/aiMatrix4x4.cs index f01a413b1..aae451646 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiMatrix4x4.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiMatrix4x4.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. @@ -50,6 +50,36 @@ public class aiMatrix4x4 : IDisposable { if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve(); } + public SWIGTYPE_p_float __idx__(uint p_iIndex) { + IntPtr cPtr = AssimpPINVOKE.aiMatrix4x4___idx____SWIG_0(swigCPtr, p_iIndex); + SWIGTYPE_p_float ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_float(cPtr, false); + return ret; + } + + public bool __equal__(aiMatrix4x4 m) { + bool ret = AssimpPINVOKE.aiMatrix4x4___equal__(swigCPtr, aiMatrix4x4.getCPtr(m)); + if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public bool __nequal__(aiMatrix4x4 m) { + bool ret = AssimpPINVOKE.aiMatrix4x4___nequal__(swigCPtr, aiMatrix4x4.getCPtr(m)); + if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public aiMatrix4x4 __mulnset__(aiMatrix4x4 m) { + aiMatrix4x4 ret = new aiMatrix4x4(AssimpPINVOKE.aiMatrix4x4___mulnset__(swigCPtr, aiMatrix4x4.getCPtr(m)), false); + if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public aiMatrix4x4 __mul__(aiMatrix4x4 m) { + aiMatrix4x4 ret = new aiMatrix4x4(AssimpPINVOKE.aiMatrix4x4___mul__(swigCPtr, aiMatrix4x4.getCPtr(m)), true); + if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + public aiMatrix4x4 Transpose() { aiMatrix4x4 ret = new aiMatrix4x4(AssimpPINVOKE.aiMatrix4x4_Transpose(swigCPtr), false); return ret; diff --git a/port/Assimp.NET/Assimp.NET_CS/aiMemoryInfo.cs b/port/Assimp.NET/Assimp.NET_CS/aiMemoryInfo.cs index cc60edbab..734f00606 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiMemoryInfo.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiMemoryInfo.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiMesh.cs b/port/Assimp.NET/Assimp.NET_CS/aiMesh.cs index 2f640d8e4..bf55782ce 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiMesh.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiMesh.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiMeshAnim.cs b/port/Assimp.NET/Assimp.NET_CS/aiMeshAnim.cs index 4e0a28285..78237a555 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiMeshAnim.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiMeshAnim.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiMeshAnimVector.cs b/port/Assimp.NET/Assimp.NET_CS/aiMeshAnimVector.cs index 2d7ae7b5b..c862c258c 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiMeshAnimVector.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiMeshAnimVector.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiMeshKey.cs b/port/Assimp.NET/Assimp.NET_CS/aiMeshKey.cs index b1f72533f..af16589ff 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiMeshKey.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiMeshKey.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiMeshKeyVector.cs b/port/Assimp.NET/Assimp.NET_CS/aiMeshKeyVector.cs index 7a37dbd2a..73039be46 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiMeshKeyVector.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiMeshKeyVector.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiMeshVector.cs b/port/Assimp.NET/Assimp.NET_CS/aiMeshVector.cs index 35153ca0d..8ea841cf2 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiMeshVector.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiMeshVector.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiNode.cs b/port/Assimp.NET/Assimp.NET_CS/aiNode.cs index c830734e2..0e650c0d4 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiNode.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiNode.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiNodeAnim.cs b/port/Assimp.NET/Assimp.NET_CS/aiNodeAnim.cs index 5fcd60adf..629f4f2a9 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiNodeAnim.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiNodeAnim.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiNodeAnimVector.cs b/port/Assimp.NET/Assimp.NET_CS/aiNodeAnimVector.cs index d34f0078c..08ba41850 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiNodeAnimVector.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiNodeAnimVector.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiNodeVector.cs b/port/Assimp.NET/Assimp.NET_CS/aiNodeVector.cs index 66eafbf6b..5f7e0c7fd 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiNodeVector.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiNodeVector.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiOrigin.cs b/port/Assimp.NET/Assimp.NET_CS/aiOrigin.cs index 8e43dbdbe..8dded0e55 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiOrigin.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiOrigin.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiPlane.cs b/port/Assimp.NET/Assimp.NET_CS/aiPlane.cs index dafd23abe..e19fd572a 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiPlane.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiPlane.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiPostProcessSteps.cs b/port/Assimp.NET/Assimp.NET_CS/aiPostProcessSteps.cs index 65bf020e8..e5e0d18a8 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiPostProcessSteps.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiPostProcessSteps.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. @@ -31,7 +31,9 @@ public enum aiPostProcessSteps { aiProcess_OptimizeMeshes = 0x200000, aiProcess_OptimizeGraph = 0x400000, aiProcess_FlipUVs = 0x800000, - aiProcess_FlipWindingOrder = 0x1000000 + aiProcess_FlipWindingOrder = 0x1000000, + aiProcess_SplitByBoneCount = 0x2000000, + aiProcess_Debone = 0x4000000 , aiProcess_ConvertToLeftHanded = aiProcess_MakeLeftHanded|aiProcess_FlipUVs|aiProcess_FlipWindingOrder, } diff --git a/port/Assimp.NET/Assimp.NET_CS/aiPrimitiveType.cs b/port/Assimp.NET/Assimp.NET_CS/aiPrimitiveType.cs index bf1421f04..7c1411611 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiPrimitiveType.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiPrimitiveType.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiPropertyTypeInfo.cs b/port/Assimp.NET/Assimp.NET_CS/aiPropertyTypeInfo.cs index 478846059..efac6be5e 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiPropertyTypeInfo.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiPropertyTypeInfo.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiQuatKey.cs b/port/Assimp.NET/Assimp.NET_CS/aiQuatKey.cs index 01ada5475..62c31f803 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiQuatKey.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiQuatKey.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiQuatKeyVector.cs b/port/Assimp.NET/Assimp.NET_CS/aiQuatKeyVector.cs index 902b031c3..eac1fde9c 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiQuatKeyVector.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiQuatKeyVector.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiQuaternion.cs b/port/Assimp.NET/Assimp.NET_CS/aiQuaternion.cs index 0e9a186ec..2a0ebccf4 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiQuaternion.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiQuaternion.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. @@ -43,7 +43,7 @@ public class aiQuaternion : IDisposable { public aiQuaternion() : this(AssimpPINVOKE.new_aiQuaternion__SWIG_0(), true) { } - public aiQuaternion(float _w, float _x, float _y, float _z) : this(AssimpPINVOKE.new_aiQuaternion__SWIG_1(_w, _x, _y, _z), true) { + public aiQuaternion(float w, float x, float y, float z) : this(AssimpPINVOKE.new_aiQuaternion__SWIG_1(w, x, y, z), true) { } public aiQuaternion(aiMatrix3x3 pRotMatrix) : this(AssimpPINVOKE.new_aiQuaternion__SWIG_2(aiMatrix3x3.getCPtr(pRotMatrix)), true) { diff --git a/port/Assimp.NET/Assimp.NET_CS/aiRay.cs b/port/Assimp.NET/Assimp.NET_CS/aiRay.cs index ebf9d74ab..85a1c986e 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiRay.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiRay.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiReturn.cs b/port/Assimp.NET/Assimp.NET_CS/aiReturn.cs index 7805d24a3..4e4fde423 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiReturn.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiReturn.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiScene.cs b/port/Assimp.NET/Assimp.NET_CS/aiScene.cs index 0e3542f37..d7048cbc1 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiScene.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiScene.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. @@ -161,6 +161,17 @@ public class aiScene : IDisposable { return ret; } + public SWIGTYPE_p_void mPrivate { + set { + AssimpPINVOKE.aiScene_mPrivate_set(swigCPtr, SWIGTYPE_p_void.getCPtr(value)); + } + get { + IntPtr cPtr = AssimpPINVOKE.aiScene_mPrivate_get(swigCPtr); + SWIGTYPE_p_void ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_void(cPtr, false); + return ret; + } + } + private aiAnimationVector GetmAnimations() { IntPtr cPtr = AssimpPINVOKE.aiScene_GetmAnimations(swigCPtr); aiAnimationVector ret = (cPtr == IntPtr.Zero) ? null : new aiAnimationVector(cPtr, true); diff --git a/port/Assimp.NET/Assimp.NET_CS/aiShadingMode.cs b/port/Assimp.NET/Assimp.NET_CS/aiShadingMode.cs index 261eb4158..775417918 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiShadingMode.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiShadingMode.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiString.cs b/port/Assimp.NET/Assimp.NET_CS/aiString.cs index 9706533a0..f55ea8197 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiString.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiString.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. @@ -70,6 +70,11 @@ public class aiString : IDisposable { return ret; } + public string C_Str() { + string ret = AssimpPINVOKE.aiString_C_Str(swigCPtr); + return ret; + } + public uint Length { set { AssimpPINVOKE.aiString_Length_set(swigCPtr, value); diff --git a/port/Assimp.NET/Assimp.NET_CS/aiTexel.cs b/port/Assimp.NET/Assimp.NET_CS/aiTexel.cs index 98b6c8fbf..bfd42ce84 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiTexel.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiTexel.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiTexture.cs b/port/Assimp.NET/Assimp.NET_CS/aiTexture.cs index 12be87b0f..87f756edc 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiTexture.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiTexture.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiTextureFlags.cs b/port/Assimp.NET/Assimp.NET_CS/aiTextureFlags.cs index 6618e5582..7f58f533b 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiTextureFlags.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiTextureFlags.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiTextureMapMode.cs b/port/Assimp.NET/Assimp.NET_CS/aiTextureMapMode.cs index 43feda716..dfd7c8821 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiTextureMapMode.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiTextureMapMode.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiTextureMapping.cs b/port/Assimp.NET/Assimp.NET_CS/aiTextureMapping.cs index 0f9830b92..f1f58d416 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiTextureMapping.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiTextureMapping.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiTextureOp.cs b/port/Assimp.NET/Assimp.NET_CS/aiTextureOp.cs index cbef3f0eb..bf844aacf 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiTextureOp.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiTextureOp.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiTextureType.cs b/port/Assimp.NET/Assimp.NET_CS/aiTextureType.cs index 012dbf1a0..0b9ffb14f 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiTextureType.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiTextureType.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiTextureVector.cs b/port/Assimp.NET/Assimp.NET_CS/aiTextureVector.cs index 4ebca3840..745a44ec8 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiTextureVector.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiTextureVector.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiUVTransform.cs b/port/Assimp.NET/Assimp.NET_CS/aiUVTransform.cs index 18391e899..0452ee461 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiUVTransform.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiUVTransform.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiVector2D.cs b/port/Assimp.NET/Assimp.NET_CS/aiVector2D.cs index c7b96a878..98074e6d1 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiVector2D.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiVector2D.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiVector3D.cs b/port/Assimp.NET/Assimp.NET_CS/aiVector3D.cs index 9fde01f51..c09201dbf 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiVector3D.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiVector3D.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiVector3DVector.cs b/port/Assimp.NET/Assimp.NET_CS/aiVector3DVector.cs index 6b8b028cf..19e6c958c 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiVector3DVector.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiVector3DVector.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiVector3DVectorVector.cs b/port/Assimp.NET/Assimp.NET_CS/aiVector3DVectorVector.cs index e962738a7..6326be345 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiVector3DVectorVector.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiVector3DVectorVector.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiVectorKey.cs b/port/Assimp.NET/Assimp.NET_CS/aiVectorKey.cs index e83573dba..13eb78c8f 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiVectorKey.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiVectorKey.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiVectorKeyVector.cs b/port/Assimp.NET/Assimp.NET_CS/aiVectorKeyVector.cs index 0054a8f7b..aee1d002e 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiVectorKeyVector.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiVectorKeyVector.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiVertexWeight.cs b/port/Assimp.NET/Assimp.NET_CS/aiVertexWeight.cs index f19c9bd5a..ddb2c4efb 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiVertexWeight.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiVertexWeight.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_CS/aiVertexWeightVector.cs b/port/Assimp.NET/Assimp.NET_CS/aiVertexWeightVector.cs index 1abebdd2b..bcdb1ca92 100644 --- a/port/Assimp.NET/Assimp.NET_CS/aiVertexWeightVector.cs +++ b/port/Assimp.NET/Assimp.NET_CS/aiVertexWeightVector.cs @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 2.0.1 + * Version 2.0.8 * * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. diff --git a/port/Assimp.NET/Assimp.NET_DEMO/AssimpView.cs b/port/Assimp.NET/Assimp.NET_DEMO/AssimpView.cs index bff7e9574..270494fa4 100644 --- a/port/Assimp.NET/Assimp.NET_DEMO/AssimpView.cs +++ b/port/Assimp.NET/Assimp.NET_DEMO/AssimpView.cs @@ -184,7 +184,7 @@ namespace Assimp.Viewer (aiPostProcessSteps)0); // default model - var path = "../../../../../../test/models/3DS/test1.3ds"; + var path = "../../../../../test/models/3DS/test1.3ds"; importer = new Importer(); string[] args = Environment.GetCommandLineArgs(); diff --git a/port/PyAssimp/README b/port/PyAssimp/README deleted file mode 100644 index 1d4a71487..000000000 --- a/port/PyAssimp/README +++ /dev/null @@ -1,66 +0,0 @@ - PyAssimp Readme - --------------- - - --- a simple Python wrapper for Assimp using ctypes to access -the library. Tested for Python 2.6. Known not to work with -Python 2.4. - - -Note that pyassimp is by no means considered mature. It works, -but it is far away from wrapping Assimp perfectly. - - -USAGE -===== - -To get started with pyAssimp, examine the sample.py script, which -illustrates the basic usage. All Assimp data structures are -wrapped using ctypes. All the data+length fields in Assimp's -data structures (such as 'aiMesh::mNumVertices','aiMesh::mVertices') -are replaced by simple python lists, so you can call len() on -them to get their respective size and access members using -[]. - -For example, to load a file named 'hello.3ds' and print the first -vertex of the first mesh, you would do (proper error handling -substituted by assertions ...): - -> from pyassimp import pyassimp, errors -> -> try: -> scene = pyassimp.load('hello.3ds') -> except AssimpError, msg: -> print(msg) -> return - -> assert len(scene.meshes) -> mesh = scene.meshes[0] - -> assert len(mesh.vertices) -> print(mesh.vertices[0]) - -> # don't forget this one, or you will leak! -> pyassimp.release(scene) - - -INSTALL -======= - -PyAssimp requires a assimp dynamic library (DLL on windows, -so on linux :-) in order to work. The default search directories -are: - -- the current directory -- on linux additionally: /usr/local/lib - -To build that library, refer to the Assimp master INSTALL -instructions. To look in more places, edit ./pyassimp/helper.py. -There's an 'additional_dirs' list waiting for your entries. - - - - - - - diff --git a/port/PyAssimp/README.md b/port/PyAssimp/README.md new file mode 100644 index 000000000..5bec88711 --- /dev/null +++ b/port/PyAssimp/README.md @@ -0,0 +1,74 @@ +PyAssimp Readme +=============== + +-- a simple Python wrapper for Assimp using ctypes to access +the library. Requires Python >= 2.6. + +Python 3 support is mostly here, but not well tested. + +Note that pyassimp is not complete. Many ASSIMP features are missing. In +particular, only loading of models is currently supported (no export). + +USAGE +----- + +To get started with pyAssimp, examine the sample.py script in scripts/, which +illustrates the basic usage. All Assimp data structures are wrapped using +ctypes. All the data+length fields in Assimp's data structures (such as +'aiMesh::mNumVertices','aiMesh::mVertices') are replaced by simple python +lists, so you can call len() on them to get their respective size and access +members using []. + +For example, to load a file named 'hello.3ds' and print the first +vertex of the first mesh, you would do (proper error handling +substituted by assertions ...): + +```python + +from pyassimp.core import * +scene = load('hello.3ds') + +assert len(scene.meshes) +mesh = scene.meshes[0] + +assert len(mesh.vertices) +print(mesh.vertices[0]) + +# don't forget this one, or you will leak! +release(scene) + +``` + +Another example to list the 'top nodes' in a +scene: + +```python + +from pyassimp.core import * +scene = load('hello.3ds') + +for c in scene.rootnode.children: + print(str(c)) + +release(scene) + +``` + +INSTALL +------- + +Install pyassimp by running: + +> python setup.py install + +PyAssimp requires a assimp dynamic library (DLL on windows, +so on linux :-) in order to work. The default search directories +are: + +- the current directory +- on linux additionally: /usr/lib and /usr/local/lib + +To build that library, refer to the Assimp master INSTALL +instructions. To look in more places, edit ./pyassimp/helper.py. +There's an 'additional_dirs' list waiting for your entries. + diff --git a/port/PyAssimp/gen/structsgen.py b/port/PyAssimp/gen/structsgen.py index 8c356b0ba..f2ee95eb5 100644 --- a/port/PyAssimp/gen/structsgen.py +++ b/port/PyAssimp/gen/structsgen.py @@ -41,7 +41,11 @@ # --------------------------------------------------------------------------- """Update PyAssimp's data structures to keep up with the -C/C++ headers.""" +C/C++ headers. + +This script is meant to be executed in the source tree, directly from +port/PyAssimp/gen +""" import os import re @@ -96,7 +100,7 @@ def GetType(type, prefix='c_'): return None t = t.strip() - types = {'unsigned int':'uint', 'unsigned char':'ubyte', 'size_t':'uint',} + types = {'unsigned int':'uint', 'unsigned char':'ubyte',} if t in types: t = types[t] t = prefix + t @@ -210,9 +214,11 @@ def Structify(fileName): # Restructure text = RErestruc.sub(restructure, text) - # Replace comments - text = RErpcom.sub('#\g', text) + text = RErpcom.sub('# \g', text) + text = text.replace("),#", "),\n#") + text = text.replace("#", "\n#") + text = "".join([l for l in text.splitlines(True) if not l.strip().endswith("#")]) # remove empty comment lines # Whether it's selfreferencing: ex. struct Node { Node* parent; }; selfreferencing = text.find('POINTER('+name+')') != -1 @@ -245,20 +251,21 @@ def Structify(fileName): text = text.replace('$DEFINES$', defines) else: text = text.replace('$DEFINES$', '') + result.append((primitive, selfreferencing, complex, text)) return result text = "#-*- coding: UTF-8 -*-\n\n" -text += "from ctypes import POINTER, c_int, c_uint, c_char, c_float, Structure, c_char_p, c_double, c_ubyte\n\n" +text += "from ctypes import POINTER, c_int, c_uint, c_size_t, c_char, c_float, Structure, c_char_p, c_double, c_ubyte\n\n" structs1 = "" structs2 = "" structs3 = "" structs4 = "" -path = '../include/' +path = '../../../include/assimp' files = os.listdir (path) #files = ["aiScene.h", "aiTypes.h"] for fileName in files: @@ -276,6 +283,8 @@ for fileName in files: text += structs1 + structs2 + structs3 + structs4 -file = open('structs.txt', 'w') +file = open('structs.py', 'w') file.write(text) file.close() + +print("Generation done. You can now review the file 'structs.py' and merge it.") diff --git a/port/PyAssimp/pyassimp/__init__.py b/port/PyAssimp/pyassimp/__init__.py index 229d2296c..e69de29bb 100644 --- a/port/PyAssimp/pyassimp/__init__.py +++ b/port/PyAssimp/pyassimp/__init__.py @@ -1 +0,0 @@ -#-*- coding: UTF-8 -*- diff --git a/port/PyAssimp/pyassimp/core.py b/port/PyAssimp/pyassimp/core.py new file mode 100644 index 000000000..731dcd5a3 --- /dev/null +++ b/port/PyAssimp/pyassimp/core.py @@ -0,0 +1,415 @@ +#-*- coding: UTF-8 -*- + +""" +PyAssimp + +This is the main-module of PyAssimp. +""" + +import sys +if sys.version_info < (2,6): + raise 'pyassimp: need python 2.6 or newer' + + +import ctypes +import os +import numpy + +import logging; logger = logging.getLogger("pyassimp") + +# Attach a default, null handler, to the logger. +# applications can easily get log messages from pyassimp +# by calling for instance +# >>> logging.basicConfig(level=logging.DEBUG) +# before importing pyassimp +class NullHandler(logging.Handler): + def emit(self, record): + pass +h = NullHandler() +logger.addHandler(h) + +from . import structs +from .errors import AssimpError +from . import helper + + +assimp_structs_as_tuple = ( + structs.Matrix4x4, + structs.Matrix3x3, + structs.Vector2D, + structs.Vector3D, + structs.Color3D, + structs.Color4D, + structs.Quaternion, + structs.Plane, + structs.Texel) + +def make_tuple(ai_obj, type = None): + res = None + + if isinstance(ai_obj, structs.Matrix4x4): + res = numpy.array([getattr(ai_obj, e[0]) for e in ai_obj._fields_]).reshape((4,4)) + #import pdb;pdb.set_trace() + elif isinstance(ai_obj, structs.Matrix3x3): + res = numpy.array([getattr(ai_obj, e[0]) for e in ai_obj._fields_]).reshape((3,3)) + else: + res = numpy.array([getattr(ai_obj, e[0]) for e in ai_obj._fields_]) + + return res + +def call_init(obj, caller = None): + # init children + if hasattr(obj, '_init'): + obj._init(parent = caller) + + # pointers + elif hasattr(obj, 'contents'): + if hasattr(obj.contents, '_init'): + obj.contents._init(target = obj, parent = caller) + + + +def _init(self, target = None, parent = None): + """ + Custom initialize() for C structs, adds safely accessable member functionality. + + :param target: set the object which receive the added methods. Useful when manipulating + pointers, to skip the intermediate 'contents' deferencing. + """ + if hasattr(self, '_is_init'): + return self + self._is_init = True + + if not target: + target = self + + for m in dir(self): + + name = m[1:].lower() + + if m.startswith("_"): + continue + + obj = getattr(self, m) + + if m.startswith('mNum'): + if 'm' + m[4:] in dir(self): + continue # will be processed later on + else: + setattr(target, name, obj) + + + + # Create tuples + if isinstance(obj, assimp_structs_as_tuple): + setattr(target, name, make_tuple(obj)) + logger.debug(str(self) + ": Added array " + str(getattr(target, name)) + " as self." + name.lower()) + continue + + + if isinstance(obj, structs.String): + setattr(target, 'name', str(obj.data)) + setattr(target.__class__, '__repr__', lambda x: str(x.__class__) + "(" + x.name + ")") + setattr(target.__class__, '__str__', lambda x: x.name) + continue + + + if m.startswith('m'): + + if name == "parent": + setattr(target, name, parent) + logger.debug("Added a parent as self." + name) + continue + + if hasattr(self, 'mNum' + m[1:]): + + length = getattr(self, 'mNum' + m[1:]) + + # -> special case: properties are + # stored as a dict. + if m == 'mProperties': + setattr(target, name, _get_properties(obj, length)) + continue + + + if not length: # empty! + setattr(target, name, []) + logger.debug(str(self) + ": " + name + " is an empty list.") + continue + + + try: + if obj._type_ in assimp_structs_as_tuple: + setattr(target, name, numpy.array([make_tuple(obj[i]) for i in range(length)], dtype=numpy.float32)) + + logger.debug(str(self) + ": Added an array of numpy arrays (type "+ str(type(obj)) + ") as self." + name) + + else: + setattr(target, name, [obj[i] for i in range(length)]) #TODO: maybe not necessary to recreate an array? + + logger.debug(str(self) + ": Added list of " + str(obj) + " " + name + " as self." + name + " (type: " + str(type(obj)) + ")") + + # initialize array elements + for e in getattr(target, name): + call_init(e, caller = target) + + + except IndexError: + logger.error("in " + str(self) +" : mismatch between mNum" + name + " and the actual amount of data in m" + name + ". This may be due to version mismatch between libassimp and pyassimp. Quitting now.") + sys.exit(1) + + except ValueError as e: + + logger.error("In " + str(self) + "->" + name + ": " + str(e) + ". Quitting now.") + if "setting an array element with a sequence" in str(e): + logger.error("Note that pyassimp does not currently " + "support meshes with mixed triangles " + "and quads. Try to load your mesh with" + " a post-processing to triangulate your" + " faces.") + sys.exit(1) + + + else: # starts with 'm' but not iterable + + setattr(target, name, obj) + logger.debug("Added " + name + " as self." + name + " (type: " + str(type(obj)) + ")") + + call_init(obj, caller = target) + + + + + if isinstance(self, structs.Mesh): + _finalize_mesh(self, target) + + if isinstance(self, structs.Texture): + _finalize_texture(self, target) + + + return self + + +""" +Python magic to add the _init() function to all C struct classes. +""" +for struct in dir(structs): + if not (struct.startswith('_') or struct.startswith('c_') or struct == "Structure" or struct == "POINTER") and not isinstance(getattr(structs, struct),int): + + setattr(getattr(structs, struct), '_init', _init) + + +class AssimpLib(object): + """ + Assimp-Singleton + """ + load, release, dll = helper.search_library() + +#the loader as singleton +_assimp_lib = AssimpLib() + +def pythonize_assimp(type, obj, scene): + """ This method modify the Assimp data structures + to make them easier to work with in Python. + + Supported operations: + - MESH: replace a list of mesh IDs by reference to these meshes + - ADDTRANSFORMATION: add a reference to an object's transformation taken from their associated node. + + :param type: the type of modification to operate (cf above) + :param obj: the input object to modify + :param scene: a reference to the whole scene + """ + + if type == "MESH": + meshes = [] + for i in obj: + meshes.append(scene.meshes[i]) + return meshes + + if type == "ADDTRANSFORMATION": + + def getnode(node, name): + if node.name == name: return node + for child in node.children: + n = getnode(child, name) + if n: return n + + node = getnode(scene.rootnode, obj.name) + if not node: + raise AssimpError("Object " + str(obj) + " has no associated node!") + setattr(obj, "transformation", node.transformation) + + +def recur_pythonize(node, scene): + """ Recursively call pythonize_assimp on + nodes tree to apply several post-processing to + pythonize the assimp datastructures. + """ + + node.meshes = pythonize_assimp("MESH", node.meshes, scene) + + for mesh in node.meshes: + mesh.material = scene.materials[mesh.materialindex] + + for cam in scene.cameras: + pythonize_assimp("ADDTRANSFORMATION", cam, scene) + + #for light in scene.lights: + # pythonize_assimp("ADDTRANSFORMATION", light, scene) + + for c in node.children: + recur_pythonize(c, scene) + + +def load(filename, processing=0): + """ + Loads the model with some specific processing parameters. + + filename - file to load model from + processing - processing parameters + + result Scene-object with model-data + + throws AssimpError - could not open file + """ + #read pure data + #from ctypes import c_char_p, c_uint + #model = _assimp_lib.load(c_char_p(filename), c_uint(processing)) + model = _assimp_lib.load(filename.encode("ascii"), processing) + if not model: + #Uhhh, something went wrong! + raise AssimpError("could not import file: %s" % filename) + + scene = model.contents._init() + + recur_pythonize(scene.rootnode, scene) + + return scene + +def release(scene): + from ctypes import pointer + _assimp_lib.release(pointer(scene)) + +def _finalize_texture(tex, target): + setattr(target, "achformathint", tex.achFormatHint) + data = numpy.array([make_tuple(getattr(tex, pcData)[i]) for i in range(tex.mWidth * tex.mHeight)]) + setattr(target, "data", data) + + + +def _finalize_mesh(mesh, target): + """ Building of meshes is a bit specific. + + We override here the various datasets that can + not be process as regular fields. + + For instance, the length of the normals array is + mNumVertices (no mNumNormals is available) + """ + nb_vertices = getattr(mesh, "mNumVertices") + + def fill(name): + mAttr = getattr(mesh, name) + if mAttr: + data = numpy.array([make_tuple(getattr(mesh, name)[i]) for i in range(nb_vertices)], dtype=numpy.float32) + setattr(target, name[1:].lower(), data) + else: + setattr(target, name[1:].lower(), []) + + def fillarray(name): + mAttr = getattr(mesh, name) + + data = [] + for index, mSubAttr in enumerate(mAttr): + if mSubAttr: + data.append([make_tuple(getattr(mesh, name)[index][i]) for i in range(nb_vertices)]) + + setattr(target, name[1:].lower(), numpy.array(data, dtype=numpy.float32)) + + fill("mNormals") + fill("mTangents") + fill("mBitangents") + + fillarray("mColors") + fillarray("mTextureCoords") + + # prepare faces + faces = numpy.array([f.indices for f in target.faces], dtype=numpy.int32) + setattr(target, 'faces', faces) + +def _get_properties(properties, length): + """ + Convenience Function to get the material properties as a dict + and values in a python format. + """ + result = {} + #read all properties + for p in [properties[i] for i in range(length)]: + #the name + p = p.contents + key = str(p.mKey.data) + + #the data + from ctypes import POINTER, cast, c_int, c_float, sizeof + if p.mType == 1: + arr = cast(p.mData, POINTER(c_float * int(p.mDataLength/sizeof(c_float)) )).contents + value = numpy.array([x for x in arr]) + elif p.mType == 3: #string can't be an array + value = cast(p.mData, POINTER(structs.String)).contents.data + elif p.mType == 4: + arr = cast(p.mData, POINTER(c_int * int(p.mDataLength/sizeof(c_int)) )).contents + value = numpy.array([x for x in arr]) + else: + value = p.mData[:p.mDataLength] + + result[key] = value + + return result + +def aiGetMaterialFloatArray(material, key): + AI_SUCCESS = 0 + from ctypes import byref, pointer, cast, c_float, POINTER, sizeof, c_uint + out = structs.Color4D() + max = c_uint(sizeof(structs.Color4D)) + r=_assimp_lib.dll.aiGetMaterialFloatArray(pointer(material), + key[0], + key[1], + key[2], + byref(out), + byref(max)) + + if (r != AI_SUCCESS): + raise AssimpError("aiGetMaterialFloatArray failed!") + + out._init() + return [out[i] for i in range(max.value)] + +def aiGetMaterialString(material, key): + AI_SUCCESS = 0 + from ctypes import byref, pointer, cast, c_float, POINTER, sizeof, c_uint + out = structs.String() + r=_assimp_lib.dll.aiGetMaterialString(pointer(material), + key[0], + key[1], + key[2], + byref(out)) + + if (r != AI_SUCCESS): + raise AssimpError("aiGetMaterialString failed!") + + return str(out.data) + + + +def decompose_matrix(matrix): + if not isinstance(matrix, structs.Matrix4x4): + raise AssimpError("pyassimp.decompose_matrix failed: Not a Matrix4x4!") + + scaling = structs.Vector3D() + rotation = structs.Quaternion() + position = structs.Vector3D() + + from ctypes import byref, pointer + _assimp_lib.dll.aiDecomposeMatrix(pointer(matrix), byref(scaling), byref(rotation), byref(position)) + return scaling._init(), rotation._init(), position._init() diff --git a/port/PyAssimp/pyassimp/helper.py b/port/PyAssimp/pyassimp/helper.py index ca7bd5d99..a01da375c 100644 --- a/port/PyAssimp/pyassimp/helper.py +++ b/port/PyAssimp/pyassimp/helper.py @@ -6,17 +6,20 @@ Some fancy helper functions. import os import ctypes -import structs -import operator - -from errors import AssimpError from ctypes import POINTER +import operator +import numpy + +import logging;logger = logging.getLogger("pyassimp") + +from .errors import AssimpError additional_dirs, ext_whitelist = [],[] # populate search directories and lists of allowed file extensions # depending on the platform we're running on. if os.name=='posix': + additional_dirs.append('/usr/lib/') additional_dirs.append('/usr/local/lib/') # note - this won't catch libassimp.so.N.n, but @@ -27,11 +30,43 @@ if os.name=='posix': elif os.name=='nt': ext_whitelist.append('.dll') -print(additional_dirs) +#print(additional_dirs) def vec2tuple(x): """ Converts a VECTOR3D to a Tuple """ return (x.x, x.y, x.z) +def transform(vector3, matrix4x4): + """ Apply a transformation matrix on a 3D vector. + + :param vector3: a numpy array with 3 elements + :param matrix4x4: a numpy 4x4 matrix + """ + return numpy.dot(matrix4x4, numpy.append(vector3, 1.)) + + +def get_bounding_box(scene): + bb_min = [1e10, 1e10, 1e10] # x,y,z + bb_max = [-1e10, -1e10, -1e10] # x,y,z + return get_bounding_box_for_node(scene.rootnode, bb_min, bb_max) + +def get_bounding_box_for_node(node, bb_min, bb_max): + for mesh in node.meshes: + for v in mesh.vertices: + v = transform(v, node.transformation) + bb_min[0] = min(bb_min[0], v[0]) + bb_min[1] = min(bb_min[1], v[1]) + bb_min[2] = min(bb_min[2], v[2]) + bb_max[0] = max(bb_max[0], v[0]) + bb_max[1] = max(bb_max[1], v[1]) + bb_max[2] = max(bb_max[2], v[2]) + + + for child in node.children: + bb_min, bb_max = get_bounding_box_for_node(child, bb_min, bb_max) + + return bb_min, bb_max + + def try_load_functions(library,dll,candidates): """try to functbind to aiImportFile and aiReleaseImport @@ -54,7 +89,8 @@ def try_load_functions(library,dll,candidates): pass else: #Library found! - load.restype = POINTER(structs.Scene) + from .structs import Scene + load.restype = POINTER(Scene) candidates.append((library, load, release, dll)) @@ -88,10 +124,11 @@ def search_library(): continue library = os.path.join(curfolder, filename) - print 'Try ',library + logger.debug('Try ' + library) try: dll = ctypes.cdll.LoadLibrary(library) - except: + except Exception as e: + logger.warning(str(e)) # OK, this except is evil. But different OSs will throw different # errors. So just ignore any errors. continue @@ -100,12 +137,12 @@ def search_library(): if not candidates: # no library found - raise AssimpError, "assimp library not found" + raise AssimpError("assimp library not found") else: # get the newest library candidates = map(lambda x: (os.lstat(x[0])[-2], x), candidates) res = max(candidates, key=operator.itemgetter(0))[1] - print 'Taking ',res[0] + logger.debug('Using assimp library located at ' + res[0]) # XXX: if there are 1000 dll/so files containing 'assimp' # in their name, do we have all of them in our address diff --git a/port/PyAssimp/pyassimp/postprocess.py b/port/PyAssimp/pyassimp/postprocess.py new file mode 100644 index 000000000..932c7c660 --- /dev/null +++ b/port/PyAssimp/pyassimp/postprocess.py @@ -0,0 +1,529 @@ +#
Calculates the tangents and bitangents for the imported meshes. +# +# Does nothing if a mesh does not have normals. You might want this post +# processing step to be executed if you plan to use tangent space calculations +# such as normal mapping applied to the meshes. There's a config setting, +# #AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE, which allows you to specify +# a maximum smoothing angle for the algorithm. However, usually you'll +# want to leave it at the default value. +# +aiProcess_CalcTangentSpace = 0x1 + +##
Identifies and joins identical vertex data sets within all +# imported meshes. +# +# After this step is run, each mesh contains unique vertices, +# so a vertex may be used by multiple faces. You usually want +# to use this post processing step. If your application deals with +# indexed geometry, this step is compulsory or you'll just waste rendering +# time. If this flag is not specified, no vertices are referenced by +# more than one face and no index buffer is required for rendering. +# +aiProcess_JoinIdenticalVertices = 0x2 + +##
Converts all the imported data to a left-handed coordinate space. +# +# By default the data is returned in a right-handed coordinate space (which +# OpenGL prefers). In this space, +X points to the right, +# +Z points towards the viewer, and +Y points upwards. In the DirectX +# coordinate space +X points to the right, +Y points upwards, and +Z points +# away from the viewer. +# +# You'll probably want to consider this flag if you use Direct3D for +# rendering. The #aiProcess_ConvertToLeftHanded flag supersedes this +# setting and bundles all conversions typically required for D3D-based +# applications. +# +aiProcess_MakeLeftHanded = 0x4 + +##
Triangulates all faces of all meshes. +# +# By default the imported mesh data might contain faces with more than 3 +# indices. For rendering you'll usually want all faces to be triangles. +# This post processing step splits up faces with more than 3 indices into +# triangles. Line and point primitives are #not# modified! If you want +# 'triangles only' with no other kinds of primitives, try the following +# solution: +#