Merge branch 'master' into gltf2-mesh-export-fix
Kim Kulling
GitHub
commit
de1ec4ee5d
|
|
@ -5,8 +5,7 @@
|
|||
#
|
||||
# License see LICENSE file
|
||||
#
|
||||
function generate()
|
||||
{
|
||||
function generate() {
|
||||
OPTIONS="-DASSIMP_WERROR=ON"
|
||||
|
||||
if [ "$DISABLE_EXPORTERS" = "YES" ] ; then
|
||||
|
|
|
|||
|
|
@ -18,10 +18,6 @@ before_install:
|
|||
# install latest LCOV (1.9 was failing)
|
||||
- if [ "$TRAVIS_OS_NAME" = "linux" ]; then cd ${TRAVIS_BUILD_DIR} && wget http://ftp.de.debian.org/debian/pool/main/l/lcov/lcov_1.11.orig.tar.gz && tar xf lcov_1.11.orig.tar.gz && sudo make -C lcov-1.11/ install && gem install coveralls-lcov && lcov --version && g++ --version ; fi
|
||||
|
||||
branches:
|
||||
only:
|
||||
- master
|
||||
|
||||
os:
|
||||
- linux
|
||||
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
prefix=@CMAKE_INSTALL_PREFIX@
|
||||
exec_prefix=@CMAKE_INSTALL_PREFIX@/
|
||||
libdir=@CMAKE_INSTALL_PREFIX@/@ASSIMP_LIB_INSTALL_DIR@
|
||||
includedir=@CMAKE_INSTALL_PREFIX@/@ASSIMP_INCLUDE_INSTALL_DIR@/assimp
|
||||
includedir=@CMAKE_INSTALL_PREFIX@/@ASSIMP_INCLUDE_INSTALL_DIR@
|
||||
|
||||
Name: @CMAKE_PROJECT_NAME@
|
||||
Description: Import various well-known 3D model formats in an uniform manner.
|
||||
|
|
|
|||
|
|
@ -310,7 +310,7 @@ foreach (GCOV_FILE ${GCOV_FILES})
|
|||
message("MD5: ${GCOV_SRC_PATH} = ${GCOV_CONTENTS_MD5}")
|
||||
|
||||
# Loads the gcov file as a list of lines.
|
||||
# (We first open the file and replace all occurences of [] with _
|
||||
# (We first open the file and replace all occurrences of [] with _
|
||||
# because CMake will fail to parse a line containing unmatched brackets...
|
||||
# also the \ to escaped \n in macros screws up things.)
|
||||
# https://public.kitware.com/Bug/view.php?id=15369
|
||||
|
|
@ -329,7 +329,7 @@ foreach (GCOV_FILE ${GCOV_FILES})
|
|||
# Instead of trying to parse the source from the
|
||||
# gcov file, simply read the file contents from the source file.
|
||||
# (Parsing it from the gcov is hard because C-code uses ; in many places
|
||||
# which also happens to be the same as the CMake list delimeter).
|
||||
# which also happens to be the same as the CMake list delimiter).
|
||||
file(READ ${GCOV_SRC_PATH} GCOV_FILE_SOURCE)
|
||||
|
||||
string(REPLACE "\\" "\\\\" GCOV_FILE_SOURCE "${GCOV_FILE_SOURCE}")
|
||||
|
|
|
|||
|
|
@ -151,7 +151,7 @@ namespace {
|
|||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// Worker function for exporting a scene to 3DS. Prototyped and registered in Exporter.cpp
|
||||
void ExportScene3DS(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* pProperties)
|
||||
void ExportScene3DS(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/)
|
||||
{
|
||||
std::shared_ptr<IOStream> outfile (pIOSystem->Open(pFile, "wb"));
|
||||
if(!outfile) {
|
||||
|
|
|
|||
|
|
@ -249,7 +249,7 @@ private:
|
|||
|
||||
/// \fn size_t PostprocessHelper_GetTextureID_Or_Create(const std::string& pID_R, const std::string& pID_G, const std::string& pID_B, const std::string& pID_A)
|
||||
/// Return converted texture ID which related to specified source textures ID's. If converted texture does not exist then it will be created and ID on new
|
||||
/// converted texture will be returned. Convertion: set of textures from \ref CAMFImporter_NodeElement_Texture to one \ref SPP_Texture and place it
|
||||
/// converted texture will be returned. Conversion: set of textures from \ref CAMFImporter_NodeElement_Texture to one \ref SPP_Texture and place it
|
||||
/// to converted textures list.
|
||||
/// Any of source ID's can be absent(empty string) or even one ID only specified. But at least one ID must be specified.
|
||||
/// \param [in] pID_R - ID of source "red" texture.
|
||||
|
|
@ -378,7 +378,7 @@ private:
|
|||
void XML_CheckNode_MustHaveChildren();
|
||||
|
||||
/// \fn bool XML_CheckNode_NameEqual(const std::string& pNodeName)
|
||||
/// Chek if current node name is equal to pNodeName.
|
||||
/// Check if current node name is equal to pNodeName.
|
||||
/// \param [in] pNodeName - name for checking.
|
||||
/// return true if current node name is equal to pNodeName, else - false.
|
||||
bool XML_CheckNode_NameEqual(const std::string& pNodeName) { return mReader->getNodeName() == pNodeName; }
|
||||
|
|
|
|||
|
|
@ -137,7 +137,7 @@ struct CAMFImporter_NodeElement_Instance : public CAMFImporter_NodeElement
|
|||
{
|
||||
/****************** Variables ******************/
|
||||
|
||||
std::string ObjectID;///< ID of object for instanciation.
|
||||
std::string ObjectID;///< ID of object for instantiation.
|
||||
/// \var Delta - The distance of translation in the x, y, or z direction, respectively, in the referenced object's coordinate system, to
|
||||
/// create an instance of the object in the current constellation.
|
||||
aiVector3D Delta;
|
||||
|
|
|
|||
|
|
@ -60,7 +60,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
namespace Assimp
|
||||
{
|
||||
|
||||
aiColor4D AMFImporter::SPP_Material::GetColor(const float pX, const float pY, const float pZ) const
|
||||
aiColor4D AMFImporter::SPP_Material::GetColor(const float /*pX*/, const float /*pY*/, const float /*pZ*/) const
|
||||
{
|
||||
aiColor4D tcol;
|
||||
|
||||
|
|
|
|||
|
|
@ -810,7 +810,7 @@ inline size_t WriteArray(IOStream * stream, const T* in, unsigned int size)
|
|||
}
|
||||
};
|
||||
|
||||
void ExportSceneAssbin(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* pProperties)
|
||||
void ExportSceneAssbin(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/)
|
||||
{
|
||||
AssbinExport exporter;
|
||||
exporter.WriteBinaryDump( pFile, pIOSystem, pScene );
|
||||
|
|
|
|||
|
|
@ -200,6 +200,7 @@ template <typename T> void ReadBounds( IOStream * stream, T* /*p*/, unsigned int
|
|||
|
||||
void AssbinImporter::ReadBinaryNode( IOStream * stream, aiNode** node, aiNode* parent ) {
|
||||
uint32_t chunkID = Read<uint32_t>(stream);
|
||||
(void)(chunkID);
|
||||
ai_assert(chunkID == ASSBIN_CHUNK_AINODE);
|
||||
/*uint32_t size =*/ Read<uint32_t>(stream);
|
||||
|
||||
|
|
@ -274,6 +275,7 @@ void AssbinImporter::ReadBinaryNode( IOStream * stream, aiNode** node, aiNode* p
|
|||
void AssbinImporter::ReadBinaryBone( IOStream * stream, aiBone* b )
|
||||
{
|
||||
uint32_t chunkID = Read<uint32_t>(stream);
|
||||
(void)(chunkID);
|
||||
ai_assert(chunkID == ASSBIN_CHUNK_AIBONE);
|
||||
/*uint32_t size =*/ Read<uint32_t>(stream);
|
||||
|
||||
|
|
@ -298,6 +300,7 @@ void AssbinImporter::ReadBinaryBone( IOStream * stream, aiBone* b )
|
|||
void AssbinImporter::ReadBinaryMesh( IOStream * stream, aiMesh* mesh )
|
||||
{
|
||||
uint32_t chunkID = Read<uint32_t>(stream);
|
||||
(void)(chunkID);
|
||||
ai_assert(chunkID == ASSBIN_CHUNK_AIMESH);
|
||||
/*uint32_t size =*/ Read<uint32_t>(stream);
|
||||
|
||||
|
|
@ -423,6 +426,7 @@ void AssbinImporter::ReadBinaryMesh( IOStream * stream, aiMesh* mesh )
|
|||
void AssbinImporter::ReadBinaryMaterialProperty(IOStream * stream, aiMaterialProperty* prop)
|
||||
{
|
||||
uint32_t chunkID = Read<uint32_t>(stream);
|
||||
(void)(chunkID);
|
||||
ai_assert(chunkID == ASSBIN_CHUNK_AIMATERIALPROPERTY);
|
||||
/*uint32_t size =*/ Read<uint32_t>(stream);
|
||||
|
||||
|
|
@ -440,6 +444,7 @@ void AssbinImporter::ReadBinaryMaterialProperty(IOStream * stream, aiMaterialPro
|
|||
void AssbinImporter::ReadBinaryMaterial(IOStream * stream, aiMaterial* mat)
|
||||
{
|
||||
uint32_t chunkID = Read<uint32_t>(stream);
|
||||
(void)(chunkID);
|
||||
ai_assert(chunkID == ASSBIN_CHUNK_AIMATERIAL);
|
||||
/*uint32_t size =*/ Read<uint32_t>(stream);
|
||||
|
||||
|
|
@ -462,6 +467,7 @@ void AssbinImporter::ReadBinaryMaterial(IOStream * stream, aiMaterial* mat)
|
|||
void AssbinImporter::ReadBinaryNodeAnim(IOStream * stream, aiNodeAnim* nd)
|
||||
{
|
||||
uint32_t chunkID = Read<uint32_t>(stream);
|
||||
(void)(chunkID);
|
||||
ai_assert(chunkID == ASSBIN_CHUNK_AINODEANIM);
|
||||
/*uint32_t size =*/ Read<uint32_t>(stream);
|
||||
|
||||
|
|
@ -511,6 +517,7 @@ void AssbinImporter::ReadBinaryNodeAnim(IOStream * stream, aiNodeAnim* nd)
|
|||
void AssbinImporter::ReadBinaryAnim( IOStream * stream, aiAnimation* anim )
|
||||
{
|
||||
uint32_t chunkID = Read<uint32_t>(stream);
|
||||
(void)(chunkID);
|
||||
ai_assert(chunkID == ASSBIN_CHUNK_AIANIMATION);
|
||||
/*uint32_t size =*/ Read<uint32_t>(stream);
|
||||
|
||||
|
|
@ -532,6 +539,7 @@ void AssbinImporter::ReadBinaryAnim( IOStream * stream, aiAnimation* anim )
|
|||
void AssbinImporter::ReadBinaryTexture(IOStream * stream, aiTexture* tex)
|
||||
{
|
||||
uint32_t chunkID = Read<uint32_t>(stream);
|
||||
(void)(chunkID);
|
||||
ai_assert(chunkID == ASSBIN_CHUNK_AITEXTURE);
|
||||
/*uint32_t size =*/ Read<uint32_t>(stream);
|
||||
|
||||
|
|
@ -556,6 +564,7 @@ void AssbinImporter::ReadBinaryTexture(IOStream * stream, aiTexture* tex)
|
|||
void AssbinImporter::ReadBinaryLight( IOStream * stream, aiLight* l )
|
||||
{
|
||||
uint32_t chunkID = Read<uint32_t>(stream);
|
||||
(void)(chunkID);
|
||||
ai_assert(chunkID == ASSBIN_CHUNK_AILIGHT);
|
||||
/*uint32_t size =*/ Read<uint32_t>(stream);
|
||||
|
||||
|
|
@ -583,6 +592,7 @@ void AssbinImporter::ReadBinaryLight( IOStream * stream, aiLight* l )
|
|||
void AssbinImporter::ReadBinaryCamera( IOStream * stream, aiCamera* cam )
|
||||
{
|
||||
uint32_t chunkID = Read<uint32_t>(stream);
|
||||
(void)(chunkID);
|
||||
ai_assert(chunkID == ASSBIN_CHUNK_AICAMERA);
|
||||
/*uint32_t size =*/ Read<uint32_t>(stream);
|
||||
|
||||
|
|
@ -599,6 +609,7 @@ void AssbinImporter::ReadBinaryCamera( IOStream * stream, aiCamera* cam )
|
|||
void AssbinImporter::ReadBinaryScene( IOStream * stream, aiScene* scene )
|
||||
{
|
||||
uint32_t chunkID = Read<uint32_t>(stream);
|
||||
(void)(chunkID);
|
||||
ai_assert(chunkID == ASSBIN_CHUNK_AISCENE);
|
||||
/*uint32_t size =*/ Read<uint32_t>(stream);
|
||||
|
||||
|
|
|
|||
|
|
@ -631,7 +631,7 @@ void WriteDump(const aiScene* scene, IOStream* io, bool shortened) {
|
|||
|
||||
} // end of namespace AssxmlExport
|
||||
|
||||
void ExportSceneAssxml(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* pProperties)
|
||||
void ExportSceneAssxml(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/)
|
||||
{
|
||||
IOStream * out = pIOSystem->Open( pFile, "wt" );
|
||||
if (!out) return;
|
||||
|
|
|
|||
|
|
@ -110,7 +110,7 @@ namespace Blender {
|
|||
void operator= (const TempArray&) {
|
||||
}
|
||||
|
||||
TempArray(const TempArray& arr) {
|
||||
TempArray(const TempArray& /*arr*/) {
|
||||
}
|
||||
|
||||
private:
|
||||
|
|
|
|||
|
|
@ -68,7 +68,7 @@ namespace Assimp
|
|||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// Worker function for exporting a scene to Collada. Prototyped and registered in Exporter.cpp
|
||||
void ExportSceneCollada(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* pProperties)
|
||||
void ExportSceneCollada(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/)
|
||||
{
|
||||
std::string path = DefaultIOSystem::absolutePath(std::string(pFile));
|
||||
std::string file = DefaultIOSystem::completeBaseName(std::string(pFile));
|
||||
|
|
@ -142,6 +142,9 @@ void ColladaExporter::WriteFile()
|
|||
|
||||
WriteSceneLibrary();
|
||||
|
||||
// customized, Writes the animation library
|
||||
WriteAnimationsLibrary();
|
||||
|
||||
// useless Collada fu at the end, just in case we haven't had enough indirections, yet.
|
||||
mOutput << startstr << "<scene>" << endstr;
|
||||
PushTag();
|
||||
|
|
@ -1129,6 +1132,7 @@ void ColladaExporter::WriteFloatArray( const std::string& pIdString, FloatDataTy
|
|||
case FloatType_Color: floatsPerElement = 3; break;
|
||||
case FloatType_Mat4x4: floatsPerElement = 16; break;
|
||||
case FloatType_Weight: floatsPerElement = 1; break;
|
||||
case FloatType_Time: floatsPerElement = 1; break;
|
||||
default:
|
||||
return;
|
||||
}
|
||||
|
|
@ -1205,7 +1209,13 @@ void ColladaExporter::WriteFloatArray( const std::string& pIdString, FloatDataTy
|
|||
case FloatType_Weight:
|
||||
mOutput << startstr << "<param name=\"WEIGHT\" type=\"float\" />" << endstr;
|
||||
break;
|
||||
}
|
||||
|
||||
// customized, add animation related
|
||||
case FloatType_Time:
|
||||
mOutput << startstr << "<param name=\"TIME\" type=\"float\" />" << endstr;
|
||||
break;
|
||||
|
||||
}
|
||||
|
||||
PopTag();
|
||||
mOutput << startstr << "</accessor>" << endstr;
|
||||
|
|
@ -1235,7 +1245,172 @@ void ColladaExporter::WriteSceneLibrary()
|
|||
PopTag();
|
||||
mOutput << startstr << "</library_visual_scenes>" << endstr;
|
||||
}
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void ColladaExporter::WriteAnimationLibrary(size_t pIndex)
|
||||
{
|
||||
const aiAnimation * anim = mScene->mAnimations[pIndex];
|
||||
|
||||
if ( anim->mNumChannels == 0 && anim->mNumMeshChannels == 0 && anim->mNumMorphMeshChannels ==0 )
|
||||
return;
|
||||
|
||||
const std::string animation_name_escaped = XMLEscape( anim->mName.C_Str() );
|
||||
std::string idstr = anim->mName.C_Str();
|
||||
std::string ending = std::string( "AnimId" ) + to_string(pIndex);
|
||||
if (idstr.length() >= ending.length()) {
|
||||
if (0 != idstr.compare (idstr.length() - ending.length(), ending.length(), ending)) {
|
||||
idstr = idstr + ending;
|
||||
}
|
||||
} else {
|
||||
idstr = idstr + ending;
|
||||
}
|
||||
|
||||
const std::string idstrEscaped = XMLEscape(idstr);
|
||||
|
||||
mOutput << startstr << "<animation id=\"" + idstrEscaped + "\" name=\"" + animation_name_escaped + "\">" << endstr;
|
||||
PushTag();
|
||||
|
||||
for (size_t a = 0; a < anim->mNumChannels; ++a) {
|
||||
const aiNodeAnim * nodeAnim = anim->mChannels[a];
|
||||
|
||||
// sanity check
|
||||
if ( nodeAnim->mNumPositionKeys != nodeAnim->mNumScalingKeys || nodeAnim->mNumPositionKeys != nodeAnim->mNumRotationKeys ) continue;
|
||||
|
||||
{
|
||||
const std::string node_idstr = nodeAnim->mNodeName.data + std::string("_matrix-input");
|
||||
|
||||
std::vector<ai_real> frames;
|
||||
for( size_t i = 0; i < nodeAnim->mNumPositionKeys; ++i) {
|
||||
frames.push_back(nodeAnim->mPositionKeys[i].mTime);
|
||||
}
|
||||
|
||||
WriteFloatArray( node_idstr , FloatType_Time, (const ai_real*) frames.data(), frames.size());
|
||||
frames.clear();
|
||||
}
|
||||
|
||||
{
|
||||
const std::string node_idstr = nodeAnim->mNodeName.data + std::string("_matrix-output");
|
||||
|
||||
std::vector<ai_real> keyframes;
|
||||
keyframes.reserve(nodeAnim->mNumPositionKeys * 16);
|
||||
for( size_t i = 0; i < nodeAnim->mNumPositionKeys; ++i) {
|
||||
|
||||
aiVector3D Scaling = nodeAnim->mScalingKeys[i].mValue;
|
||||
aiMatrix4x4 ScalingM; // identity
|
||||
ScalingM[0][0] = Scaling.x; ScalingM[1][1] = Scaling.y; ScalingM[2][2] = Scaling.z;
|
||||
|
||||
aiQuaternion RotationQ = nodeAnim->mRotationKeys[i].mValue;
|
||||
aiMatrix4x4 s = aiMatrix4x4( RotationQ.GetMatrix() );
|
||||
aiMatrix4x4 RotationM(s.a1, s.a2, s.a3, 0, s.b1, s.b2, s.b3, 0, s.c1, s.c2, s.c3, 0, 0, 0, 0, 1);
|
||||
|
||||
aiVector3D Translation = nodeAnim->mPositionKeys[i].mValue;
|
||||
aiMatrix4x4 TranslationM; // identity
|
||||
TranslationM[0][3] = Translation.x; TranslationM[1][3] = Translation.y; TranslationM[2][3] = Translation.z;
|
||||
|
||||
// Combine the above transformations
|
||||
aiMatrix4x4 mat = TranslationM * RotationM * ScalingM;
|
||||
|
||||
for( size_t j = 0; j < 4; ++j) {
|
||||
keyframes.insert(keyframes.end(), mat[j], mat[j] + 4);
|
||||
}
|
||||
}
|
||||
|
||||
WriteFloatArray( node_idstr, FloatType_Mat4x4, (const ai_real*) keyframes.data(), keyframes.size() / 16);
|
||||
}
|
||||
|
||||
{
|
||||
std::vector<std::string> names;
|
||||
for ( size_t i = 0; i < nodeAnim->mNumPositionKeys; ++i) {
|
||||
if ( nodeAnim->mPreState == aiAnimBehaviour_DEFAULT
|
||||
|| nodeAnim->mPreState == aiAnimBehaviour_LINEAR
|
||||
|| nodeAnim->mPreState == aiAnimBehaviour_REPEAT
|
||||
) {
|
||||
names.push_back( "LINEAR" );
|
||||
} else if (nodeAnim->mPostState == aiAnimBehaviour_CONSTANT) {
|
||||
names.push_back( "STEP" );
|
||||
}
|
||||
}
|
||||
|
||||
const std::string node_idstr = nodeAnim->mNodeName.data + std::string("_matrix-interpolation");
|
||||
std::string arrayId = node_idstr + "-array";
|
||||
|
||||
mOutput << startstr << "<source id=\"" << XMLEscape(node_idstr) << "\">" << endstr;
|
||||
PushTag();
|
||||
|
||||
// source array
|
||||
mOutput << startstr << "<Name_array id=\"" << XMLEscape(arrayId) << "\" count=\"" << names.size() << "\"> ";
|
||||
for( size_t a = 0; a < names.size(); ++a ) {
|
||||
mOutput << names[a] << " ";
|
||||
}
|
||||
mOutput << "</Name_array>" << endstr;
|
||||
|
||||
mOutput << startstr << "<technique_common>" << endstr;
|
||||
PushTag();
|
||||
|
||||
mOutput << startstr << "<accessor source=\"#" << XMLEscape(arrayId) << "\" count=\"" << names.size() << "\" stride=\"" << 1 << "\">" << endstr;
|
||||
PushTag();
|
||||
|
||||
mOutput << startstr << "<param name=\"INTERPOLATION\" type=\"name\"></param>" << endstr;
|
||||
|
||||
PopTag();
|
||||
mOutput << startstr << "</accessor>" << endstr;
|
||||
|
||||
PopTag();
|
||||
mOutput << startstr << "</technique_common>" << endstr;
|
||||
|
||||
PopTag();
|
||||
mOutput << startstr << "</source>" << endstr;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
for (size_t a = 0; a < anim->mNumChannels; ++a) {
|
||||
const aiNodeAnim * nodeAnim = anim->mChannels[a];
|
||||
|
||||
{
|
||||
// samplers
|
||||
const std::string node_idstr = nodeAnim->mNodeName.data + std::string("_matrix-sampler");
|
||||
mOutput << startstr << "<sampler id=\"" << XMLEscape(node_idstr) << "\">" << endstr;
|
||||
PushTag();
|
||||
|
||||
mOutput << startstr << "<input semantic=\"INPUT\" source=\"#" << XMLEscape( nodeAnim->mNodeName.data + std::string("_matrix-input") ) << "\"/>" << endstr;
|
||||
mOutput << startstr << "<input semantic=\"OUTPUT\" source=\"#" << XMLEscape( nodeAnim->mNodeName.data + std::string("_matrix-output") ) << "\"/>" << endstr;
|
||||
mOutput << startstr << "<input semantic=\"INTERPOLATION\" source=\"#" << XMLEscape( nodeAnim->mNodeName.data + std::string("_matrix-interpolation") ) << "\"/>" << endstr;
|
||||
|
||||
PopTag();
|
||||
mOutput << startstr << "</sampler>" << endstr;
|
||||
}
|
||||
}
|
||||
|
||||
for (size_t a = 0; a < anim->mNumChannels; ++a) {
|
||||
const aiNodeAnim * nodeAnim = anim->mChannels[a];
|
||||
|
||||
{
|
||||
// channels
|
||||
mOutput << startstr << "<channel source=\"#" << XMLEscape( nodeAnim->mNodeName.data + std::string("_matrix-sampler") ) << "\" target=\"" << XMLEscape(nodeAnim->mNodeName.data) << "/matrix\"/>" << endstr;
|
||||
}
|
||||
}
|
||||
|
||||
PopTag();
|
||||
mOutput << startstr << "</animation>" << endstr;
|
||||
|
||||
}
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void ColladaExporter::WriteAnimationsLibrary()
|
||||
{
|
||||
const std::string scene_name_escaped = XMLEscape(mScene->mRootNode->mName.C_Str());
|
||||
|
||||
if ( mScene->mNumAnimations > 0 ) {
|
||||
mOutput << startstr << "<library_animations>" << endstr;
|
||||
PushTag();
|
||||
|
||||
// start recursive write at the root node
|
||||
for( size_t a = 0; a < mScene->mNumAnimations; ++a)
|
||||
WriteAnimationLibrary( a );
|
||||
|
||||
PopTag();
|
||||
mOutput << startstr << "</library_animations>" << endstr;
|
||||
}
|
||||
}
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// Helper to find a bone by name in the scene
|
||||
aiBone* findBone( const aiScene* scene, const char * name) {
|
||||
|
|
@ -1251,6 +1426,59 @@ aiBone* findBone( const aiScene* scene, const char * name) {
|
|||
return NULL;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
const aiNode * findBoneNode( const aiNode* aNode, const aiBone* bone)
|
||||
{
|
||||
if ( aNode && bone && aNode->mName == bone->mName ) {
|
||||
return aNode;
|
||||
}
|
||||
|
||||
if ( aNode && bone ) {
|
||||
for (unsigned int i=0; i < aNode->mNumChildren; ++i) {
|
||||
aiNode * aChild = aNode->mChildren[i];
|
||||
const aiNode * foundFromChild = 0;
|
||||
if ( aChild ) {
|
||||
foundFromChild = findBoneNode( aChild, bone );
|
||||
if ( foundFromChild ) return foundFromChild;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const aiNode * findSkeletonRootNode( const aiScene* scene, const aiMesh * mesh)
|
||||
{
|
||||
std::set<const aiNode*> topParentBoneNodes;
|
||||
if ( mesh && mesh->mNumBones > 0 ) {
|
||||
for (unsigned int i=0; i < mesh->mNumBones; ++i) {
|
||||
aiBone * bone = mesh->mBones[i];
|
||||
|
||||
const aiNode * node = findBoneNode( scene->mRootNode, bone);
|
||||
if ( node ) {
|
||||
while ( node->mParent && findBone(scene, node->mParent->mName.C_Str() ) != 0 ) {
|
||||
node = node->mParent;
|
||||
}
|
||||
topParentBoneNodes.insert( node );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if ( !topParentBoneNodes.empty() ) {
|
||||
const aiNode * parentBoneNode = *topParentBoneNodes.begin();
|
||||
if ( topParentBoneNodes.size() == 1 ) {
|
||||
return parentBoneNode;
|
||||
} else {
|
||||
for (auto it : topParentBoneNodes) {
|
||||
if ( it->mParent ) return it->mParent;
|
||||
}
|
||||
return parentBoneNode;
|
||||
}
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// Recursively writes the given node
|
||||
void ColladaExporter::WriteNode( const aiScene* pScene, aiNode* pNode)
|
||||
|
|
@ -1278,12 +1506,22 @@ void ColladaExporter::WriteNode( const aiScene* pScene, aiNode* pNode)
|
|||
}
|
||||
|
||||
const std::string node_name_escaped = XMLEscape(pNode->mName.data);
|
||||
/* // customized, Note! the id field is crucial for inter-xml look up, it cannot be replaced with sid ?!
|
||||
mOutput << startstr
|
||||
<< "<node ";
|
||||
if(is_skeleton_root)
|
||||
mOutput << "id=\"" << "skeleton_root" << "\" "; // For now, only support one skeleton in a scene.
|
||||
mOutput << (is_joint ? "s" : "") << "id=\"" << node_name_escaped;
|
||||
mOutput << "\" name=\"" << node_name_escaped
|
||||
*/
|
||||
mOutput << startstr << "<node ";
|
||||
if(is_skeleton_root) {
|
||||
mOutput << "id=\"" << node_name_escaped << "\" " << (is_joint ? "sid=\"" + node_name_escaped +"\"" : "") ; // For now, only support one skeleton in a scene.
|
||||
mFoundSkeletonRootNodeID = node_name_escaped;
|
||||
} else {
|
||||
mOutput << "id=\"" << node_name_escaped << "\" " << (is_joint ? "sid=\"" + node_name_escaped +"\"": "") ;
|
||||
}
|
||||
|
||||
mOutput << " name=\"" << node_name_escaped
|
||||
<< "\" type=\"" << node_type
|
||||
<< "\">" << endstr;
|
||||
PushTag();
|
||||
|
|
@ -1291,7 +1529,11 @@ void ColladaExporter::WriteNode( const aiScene* pScene, aiNode* pNode)
|
|||
// write transformation - we can directly put the matrix there
|
||||
// TODO: (thom) decompose into scale - rot - quad to allow addressing it by animations afterwards
|
||||
const aiMatrix4x4& mat = pNode->mTransformation;
|
||||
mOutput << startstr << "<matrix sid=\"transform\">";
|
||||
|
||||
// customized, sid should be 'matrix' to match with loader code.
|
||||
//mOutput << startstr << "<matrix sid=\"transform\">";
|
||||
mOutput << startstr << "<matrix sid=\"matrix\">";
|
||||
|
||||
mOutput << mat.a1 << " " << mat.a2 << " " << mat.a3 << " " << mat.a4 << " ";
|
||||
mOutput << mat.b1 << " " << mat.b2 << " " << mat.b3 << " " << mat.b4 << " ";
|
||||
mOutput << mat.c1 << " " << mat.c2 << " " << mat.c3 << " " << mat.c4 << " ";
|
||||
|
|
@ -1319,7 +1561,7 @@ void ColladaExporter::WriteNode( const aiScene* pScene, aiNode* pNode)
|
|||
for( size_t a = 0; a < pNode->mNumMeshes; ++a )
|
||||
{
|
||||
const aiMesh* mesh = mScene->mMeshes[pNode->mMeshes[a]];
|
||||
// do not instanciate mesh if empty. I wonder how this could happen
|
||||
// do not instantiate mesh if empty. I wonder how this could happen
|
||||
if( mesh->mNumFaces == 0 || mesh->mNumVertices == 0 )
|
||||
continue;
|
||||
|
||||
|
|
@ -1335,7 +1577,13 @@ void ColladaExporter::WriteNode( const aiScene* pScene, aiNode* pNode)
|
|||
<< endstr;
|
||||
PushTag();
|
||||
|
||||
mOutput << startstr << "<skeleton>#skeleton_root</skeleton>" << endstr;
|
||||
// note! this mFoundSkeletonRootNodeID some how affects animation, it makes the mesh attaches to armature skeleton root node.
|
||||
// use the first bone to find skeleton root
|
||||
const aiNode * skeletonRootBoneNode = findSkeletonRootNode( pScene, mesh );
|
||||
if ( skeletonRootBoneNode ) {
|
||||
mFoundSkeletonRootNodeID = XMLEscape( skeletonRootBoneNode->mName.C_Str() );
|
||||
}
|
||||
mOutput << startstr << "<skeleton>#" << mFoundSkeletonRootNodeID << "</skeleton>" << endstr;
|
||||
}
|
||||
mOutput << startstr << "<bind_material>" << endstr;
|
||||
PushTag();
|
||||
|
|
|
|||
|
|
@ -114,7 +114,9 @@ protected:
|
|||
/// Writes the given mesh
|
||||
void WriteGeometry( size_t pIndex);
|
||||
|
||||
enum FloatDataType { FloatType_Vector, FloatType_TexCoord2, FloatType_TexCoord3, FloatType_Color, FloatType_Mat4x4, FloatType_Weight };
|
||||
//enum FloatDataType { FloatType_Vector, FloatType_TexCoord2, FloatType_TexCoord3, FloatType_Color, FloatType_Mat4x4, FloatType_Weight };
|
||||
// customized to add animation related type
|
||||
enum FloatDataType { FloatType_Vector, FloatType_TexCoord2, FloatType_TexCoord3, FloatType_Color, FloatType_Mat4x4, FloatType_Weight, FloatType_Time };
|
||||
|
||||
/// Writes a float array of the given type
|
||||
void WriteFloatArray( const std::string& pIdString, FloatDataType pType, const ai_real* pData, size_t pElementCount);
|
||||
|
|
@ -122,6 +124,11 @@ protected:
|
|||
/// Writes the scene library
|
||||
void WriteSceneLibrary();
|
||||
|
||||
// customized, Writes the animation library
|
||||
void WriteAnimationsLibrary();
|
||||
void WriteAnimationLibrary( size_t pIndex);
|
||||
std::string mFoundSkeletonRootNodeID = "skeleton_root"; // will be replaced by found node id in the WriteNode call.
|
||||
|
||||
/// Recursively writes the given node
|
||||
void WriteNode( const aiScene* scene, aiNode* pNode);
|
||||
|
||||
|
|
|
|||
|
|
@ -302,7 +302,7 @@ struct Accessor
|
|||
size_t mOffset; // in number of values
|
||||
size_t mStride; // Stride in number of values
|
||||
std::vector<std::string> mParams; // names of the data streams in the accessors. Empty string tells to ignore.
|
||||
size_t mSubOffset[4]; // Suboffset inside the object for the common 4 elements. For a vector, thats XYZ, for a color RGBA and so on.
|
||||
size_t mSubOffset[4]; // Suboffset inside the object for the common 4 elements. For a vector, that's XYZ, for a color RGBA and so on.
|
||||
// For example, SubOffset[0] denotes which of the values inside the object is the vector X component.
|
||||
std::string mSource; // URL of the source array
|
||||
mutable const Data* mData; // Pointer to the source array, if resolved. NULL else
|
||||
|
|
|
|||
|
|
@ -1619,7 +1619,7 @@ void ColladaLoader::FillMaterials( const ColladaParser& pParser, aiScene* /*pSce
|
|||
mat.AddProperty( &effect.mRefractIndex, 1, AI_MATKEY_REFRACTI);
|
||||
|
||||
// transparency, a very hard one. seemingly not all files are following the
|
||||
// specification here (1.0 transparency => completly opaque)...
|
||||
// specification here (1.0 transparency => completely opaque)...
|
||||
// therefore, we let the opportunity for the user to manually invert
|
||||
// the transparency if necessary and we add preliminary support for RGB_ZERO mode
|
||||
if(effect.mTransparency >= 0.f && effect.mTransparency <= 1.f) {
|
||||
|
|
|
|||
|
|
@ -224,7 +224,7 @@ void ColladaParser::ReadStructure()
|
|||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// Reads asset informations such as coordinate system informations and legal blah
|
||||
// Reads asset information such as coordinate system information and legal blah
|
||||
void ColladaParser::ReadAssetInfo()
|
||||
{
|
||||
if( mReader->isEmptyElement())
|
||||
|
|
@ -2469,8 +2469,7 @@ void ColladaParser::CopyVertex(size_t currentVertex, size_t numOffsets, size_t n
|
|||
size_t baseOffset = currentPrimitive * numOffsets * numPoints + currentVertex * numOffsets;
|
||||
|
||||
// don't overrun the boundaries of the index list
|
||||
size_t maxIndexRequested = baseOffset + numOffsets - 1;
|
||||
ai_assert(maxIndexRequested < indices.size());
|
||||
ai_assert((baseOffset + numOffsets - 1) < indices.size());
|
||||
|
||||
// extract per-vertex channels using the global per-vertex offset
|
||||
for (std::vector<InputChannel>::iterator it = pMesh->mPerVertexData.begin(); it != pMesh->mPerVertexData.end(); ++it)
|
||||
|
|
|
|||
|
|
@ -77,7 +77,7 @@ namespace Assimp
|
|||
/** Reads the structure of the file */
|
||||
void ReadStructure();
|
||||
|
||||
/** Reads asset informations such as coordinate system informations and legal blah */
|
||||
/** Reads asset information such as coordinate system information and legal blah */
|
||||
void ReadAssetInfo();
|
||||
|
||||
/** Reads the animation library */
|
||||
|
|
|
|||
|
|
@ -344,7 +344,7 @@ bool D3MFImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool
|
|||
return false;
|
||||
}
|
||||
|
||||
void D3MFImporter::SetupProperties(const Importer *pImp)
|
||||
void D3MFImporter::SetupProperties(const Importer */*pImp*/)
|
||||
{
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -379,6 +379,7 @@ IOStream *D3MFZipArchive::Open(const char* pFile, const char* /*pMode*/) {
|
|||
// ------------------------------------------------------------------------------------------------
|
||||
// Close a filestream.
|
||||
void D3MFZipArchive::Close(IOStream *pFile) {
|
||||
(void)(pFile);
|
||||
ai_assert(pFile != NULL);
|
||||
|
||||
// We don't do anything in case the file would be opened again in the future
|
||||
|
|
|
|||
|
|
@ -83,6 +83,7 @@ void ExportSceneCollada(const char*,IOSystem*, const aiScene*, const ExportPrope
|
|||
void ExportSceneXFile(const char*,IOSystem*, const aiScene*, const ExportProperties*);
|
||||
void ExportSceneStep(const char*,IOSystem*, const aiScene*, const ExportProperties*);
|
||||
void ExportSceneObj(const char*,IOSystem*, const aiScene*, const ExportProperties*);
|
||||
void ExportSceneObjNoMtl(const char*,IOSystem*, const aiScene*, const ExportProperties*);
|
||||
void ExportSceneSTL(const char*,IOSystem*, const aiScene*, const ExportProperties*);
|
||||
void ExportSceneSTLBinary(const char*,IOSystem*, const aiScene*, const ExportProperties*);
|
||||
void ExportScenePly(const char*,IOSystem*, const aiScene*, const ExportProperties*);
|
||||
|
|
@ -115,6 +116,8 @@ Exporter::ExportFormatEntry gExporters[] =
|
|||
#ifndef ASSIMP_BUILD_NO_OBJ_EXPORTER
|
||||
Exporter::ExportFormatEntry( "obj", "Wavefront OBJ format", "obj", &ExportSceneObj,
|
||||
aiProcess_GenSmoothNormals /*| aiProcess_PreTransformVertices */),
|
||||
Exporter::ExportFormatEntry( "objnomtl", "Wavefront OBJ format without material file", "obj", &ExportSceneObjNoMtl,
|
||||
aiProcess_GenSmoothNormals /*| aiProcess_PreTransformVertices */),
|
||||
#endif
|
||||
|
||||
#ifndef ASSIMP_BUILD_NO_STL_EXPORTER
|
||||
|
|
@ -241,7 +244,7 @@ bool Exporter::IsDefaultIOHandler() const {
|
|||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
const aiExportDataBlob* Exporter::ExportToBlob( const aiScene* pScene, const char* pFormatId,
|
||||
unsigned int, const ExportProperties* pProperties ) {
|
||||
unsigned int, const ExportProperties* /*pProperties*/ ) {
|
||||
if (pimpl->blob) {
|
||||
delete pimpl->blob;
|
||||
pimpl->blob = NULL;
|
||||
|
|
|
|||
|
|
@ -645,7 +645,6 @@ void Converter::ConvertCameras( const Model& model )
|
|||
}
|
||||
}
|
||||
|
||||
|
||||
void Converter::ConvertLight( const Model& model, const Light& light )
|
||||
{
|
||||
lights.push_back( new aiLight() );
|
||||
|
|
@ -783,7 +782,6 @@ const char* Converter::NameTransformationComp( TransformationComp comp )
|
|||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
const char* Converter::NameTransformationCompProperty( TransformationComp comp )
|
||||
{
|
||||
switch ( comp )
|
||||
|
|
@ -2239,9 +2237,17 @@ void Converter::ConvertAnimations()
|
|||
}
|
||||
}
|
||||
|
||||
void Converter::RenameNode( const std::string& fixed_name, const std::string& new_name ) {
|
||||
if ( node_names.find( fixed_name ) == node_names.end() ) {
|
||||
FBXImporter::LogError( "Cannot rename node " + fixed_name + ", not existing.");
|
||||
return;
|
||||
}
|
||||
|
||||
if ( node_names.find( new_name ) != node_names.end() ) {
|
||||
FBXImporter::LogError( "Cannot rename node " + fixed_name + " to " + new_name +", name already existing." );
|
||||
return;
|
||||
}
|
||||
|
||||
void Converter::RenameNode( const std::string& fixed_name, const std::string& new_name )
|
||||
{
|
||||
ai_assert( node_names.find( fixed_name ) != node_names.end() );
|
||||
ai_assert( node_names.find( new_name ) == node_names.end() );
|
||||
|
||||
|
|
@ -2429,6 +2435,7 @@ void Converter::ConvertAnimationStack( const AnimationStack& st )
|
|||
anim->mTicksPerSecond = anim_fps;
|
||||
}
|
||||
|
||||
#ifdef ASSIMP_BUILD_DEBUG
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// sanity check whether the input is ok
|
||||
static void validateAnimCurveNodes( const std::vector<const AnimationCurveNode*>& curves,
|
||||
|
|
@ -2446,6 +2453,7 @@ static void validateAnimCurveNodes( const std::vector<const AnimationCurveNode*>
|
|||
}
|
||||
}
|
||||
}
|
||||
#endif // ASSIMP_BUILD_DEBUG
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void Converter::GenerateNodeAnimations( std::vector<aiNodeAnim*>& node_anims,
|
||||
|
|
|
|||
|
|
@ -103,6 +103,7 @@ namespace {
|
|||
T SafeParse(const char* data, const char* end) {
|
||||
// Actual size validation happens during Tokenization so
|
||||
// this is valid as an assertion.
|
||||
(void)(end);
|
||||
ai_assert(static_cast<size_t>(end - data) >= sizeof(T));
|
||||
T result = static_cast<T>(0);
|
||||
::memcpy(&result, data, sizeof(T));
|
||||
|
|
|
|||
|
|
@ -1776,17 +1776,17 @@ public:
|
|||
return reader->getParserFormat();
|
||||
}
|
||||
|
||||
virtual std::shared_ptr<const FIValue> getAttributeEncodedValue(int idx) const /*override*/ {
|
||||
virtual std::shared_ptr<const FIValue> getAttributeEncodedValue(int /*idx*/) const /*override*/ {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
virtual std::shared_ptr<const FIValue> getAttributeEncodedValue(const char* name) const /*override*/ {
|
||||
virtual std::shared_ptr<const FIValue> getAttributeEncodedValue(const char* /*name*/) const /*override*/ {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
virtual void registerDecoder(const std::string &algorithmUri, std::unique_ptr<FIDecoder> decoder) /*override*/ {}
|
||||
virtual void registerDecoder(const std::string &/*algorithmUri*/, std::unique_ptr<FIDecoder> /*decoder*/) /*override*/ {}
|
||||
|
||||
virtual void registerVocabulary(const std::string &vocabularyUri, const FIVocabulary *vocabulary) /*override*/ {}
|
||||
virtual void registerVocabulary(const std::string &/*vocabularyUri*/, const FIVocabulary */*vocabulary*/) /*override*/ {}
|
||||
|
||||
private:
|
||||
|
||||
|
|
|
|||
|
|
@ -169,8 +169,8 @@ void FindInvalidDataProcess::Execute( aiScene* pScene)
|
|||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
template <typename T>
|
||||
inline const char* ValidateArrayContents(const T* arr, unsigned int size,
|
||||
const std::vector<bool>& dirtyMask, bool mayBeIdentical = false, bool mayBeZero = true)
|
||||
inline const char* ValidateArrayContents(const T* /*arr*/, unsigned int /*size*/,
|
||||
const std::vector<bool>& /*dirtyMask*/, bool /*mayBeIdentical = false*/, bool /*mayBeZero = true*/)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -513,6 +513,7 @@ IfcFloat Curve::GetParametricRangeDelta() const {
|
|||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
size_t Curve::EstimateSampleCount(IfcFloat a, IfcFloat b) const {
|
||||
(void)(a); (void)(b);
|
||||
ai_assert( InRange( a ) );
|
||||
ai_assert( InRange( b ) );
|
||||
|
||||
|
|
|
|||
|
|
@ -1045,7 +1045,7 @@ void IFC::GetSchema(EXPRESS::ConversionSchema& out)
|
|||
namespace STEP {
|
||||
|
||||
// -----------------------------------------------------------------------------------------------------------
|
||||
template <> size_t GenericFill<NotImplemented>(const STEP::DB& db, const LIST& params, NotImplemented* in)
|
||||
template <> size_t GenericFill<NotImplemented>(const STEP::DB& /*db*/, const LIST& /*params*/, NotImplemented* /*in*/)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1253,7 +1253,7 @@ template <> size_t GenericFill<IfcPerformanceHistory>(const DB& db, const LIST&
|
|||
return base;
|
||||
}
|
||||
// -----------------------------------------------------------------------------------------------------------
|
||||
template <> size_t GenericFill<IfcRepresentationItem>(const DB& db, const LIST& params, IfcRepresentationItem* in)
|
||||
template <> size_t GenericFill<IfcRepresentationItem>(const DB& /*db*/, const LIST& /*params*/, IfcRepresentationItem* /*in*/)
|
||||
{
|
||||
size_t base = 0;
|
||||
return base;
|
||||
|
|
@ -1715,7 +1715,7 @@ template <> size_t GenericFill<IfcPlateType>(const DB& db, const LIST& params, I
|
|||
return base;
|
||||
}
|
||||
// -----------------------------------------------------------------------------------------------------------
|
||||
template <> size_t GenericFill<IfcObjectPlacement>(const DB& db, const LIST& params, IfcObjectPlacement* in)
|
||||
template <> size_t GenericFill<IfcObjectPlacement>(const DB& /*db*/, const LIST& /*params*/, IfcObjectPlacement* /*in*/)
|
||||
{
|
||||
size_t base = 0;
|
||||
return base;
|
||||
|
|
|
|||
|
|
@ -394,7 +394,7 @@ void IRRImporter::ComputeAnimations(Node* root, aiNode* real, std::vector<aiNode
|
|||
angles[1] %= 360;
|
||||
angles[2] %= 360;
|
||||
|
||||
if ((angles[0]*angles[1]) && (angles[1]*angles[2]))
|
||||
if ( bool(angles[0]*angles[1]) && bool(angles[1]*angles[2]) )
|
||||
{
|
||||
FindSuitableMultiple(angles[0]);
|
||||
FindSuitableMultiple(angles[1]);
|
||||
|
|
|
|||
|
|
@ -483,7 +483,7 @@ void LWOImporter::FindVCChannels(const LWO::Surface& surf, LWO::SortedRep& sorte
|
|||
const LWO::VColorChannel& vc = layer.mVColorChannels[i];
|
||||
|
||||
if (surf.mVCMap == vc.name) {
|
||||
// The vertex color map is explicitely requested by the surface so we need to take special care of it
|
||||
// The vertex color map is explicitly requested by the surface so we need to take special care of it
|
||||
for (unsigned int a = 0; a < std::min(next,AI_MAX_NUMBER_OF_COLOR_SETS-1u); ++a) {
|
||||
out[a+1] = out[a];
|
||||
}
|
||||
|
|
|
|||
|
|
@ -471,7 +471,7 @@ void LWSImporter::BuildGraph(aiNode* nd, LWS::NodeDesc& src, std::vector<Attachm
|
|||
// Determine the exact location of a LWO file
|
||||
std::string LWSImporter::FindLWOFile(const std::string& in)
|
||||
{
|
||||
// insert missing directory seperator if necessary
|
||||
// insert missing directory separator if necessary
|
||||
std::string tmp;
|
||||
if (in.length() > 3 && in[1] == ':'&& in[2] != '\\' && in[2] != '/')
|
||||
{
|
||||
|
|
|
|||
|
|
@ -274,11 +274,9 @@ void MD2Importer::InternReadFile( const std::string& pFile,
|
|||
aiMesh* pcMesh = pScene->mMeshes[0] = new aiMesh();
|
||||
pcMesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
|
||||
|
||||
// navigate to the begin of the frame data
|
||||
BE_NCONST MD2::Frame* pcFrame = (BE_NCONST MD2::Frame*) ((uint8_t*)
|
||||
m_pcHeader + m_pcHeader->offsetFrames);
|
||||
|
||||
pcFrame += configFrameID;
|
||||
// navigate to the begin of the current frame data
|
||||
BE_NCONST MD2::Frame* pcFrame = (BE_NCONST MD2::Frame*) ((uint8_t*)
|
||||
m_pcHeader + m_pcHeader->offsetFrames + (m_pcHeader->frameSize * configFrameID));
|
||||
|
||||
// navigate to the begin of the triangle data
|
||||
MD2::Triangle* pcTriangles = (MD2::Triangle*) ((uint8_t*)
|
||||
|
|
|
|||
|
|
@ -107,7 +107,7 @@ const aiImporterDesc *MMDImporter::GetInfo() const { return &desc; }
|
|||
// ------------------------------------------------------------------------------------------------
|
||||
// MMD import implementation
|
||||
void MMDImporter::InternReadFile(const std::string &file, aiScene *pScene,
|
||||
IOSystem *pIOHandler) {
|
||||
IOSystem */*pIOHandler*/) {
|
||||
// Read file by istream
|
||||
std::filebuf fb;
|
||||
if (!fb.open(file, std::ios::in | std::ios::binary)) {
|
||||
|
|
|
|||
|
|
@ -471,7 +471,7 @@ namespace pmx
|
|||
stream->read((char*) &this->is_near, sizeof(uint8_t));
|
||||
}
|
||||
|
||||
void PmxSoftBody::Read(std::istream *stream, PmxSetting *setting)
|
||||
void PmxSoftBody::Read(std::istream */*stream*/, PmxSetting */*setting*/)
|
||||
{
|
||||
// 未実装
|
||||
std::cerr << "Not Implemented Exception" << std::endl;
|
||||
|
|
|
|||
|
|
@ -302,7 +302,7 @@ namespace vmd
|
|||
return result;
|
||||
}
|
||||
|
||||
bool SaveToFile(const std::u16string& filename)
|
||||
bool SaveToFile(const std::u16string& /*filename*/)
|
||||
{
|
||||
// TODO: How to adapt u16string to string?
|
||||
/*
|
||||
|
|
|
|||
|
|
@ -58,7 +58,7 @@ namespace Assimp {
|
|||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// Worker function for exporting a scene to Wavefront OBJ. Prototyped and registered in Exporter.cpp
|
||||
void ExportSceneObj(const char* pFile,IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* pProperties) {
|
||||
void ExportSceneObj(const char* pFile,IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/) {
|
||||
// invoke the exporter
|
||||
ObjExporter exporter(pFile, pScene);
|
||||
|
||||
|
|
@ -83,12 +83,34 @@ void ExportSceneObj(const char* pFile,IOSystem* pIOSystem, const aiScene* pScene
|
|||
}
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// Worker function for exporting a scene to Wavefront OBJ without the material file. Prototyped and registered in Exporter.cpp
|
||||
void ExportSceneObjNoMtl(const char* pFile,IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* pProperties) {
|
||||
// invoke the exporter
|
||||
ObjExporter exporter(pFile, pScene, true);
|
||||
|
||||
if (exporter.mOutput.fail() || exporter.mOutputMat.fail()) {
|
||||
throw DeadlyExportError("output data creation failed. Most likely the file became too large: " + std::string(pFile));
|
||||
}
|
||||
|
||||
// we're still here - export successfully completed. Write both the main OBJ file and the material script
|
||||
{
|
||||
std::unique_ptr<IOStream> outfile (pIOSystem->Open(pFile,"wt"));
|
||||
if(outfile == NULL) {
|
||||
throw DeadlyExportError("could not open output .obj file: " + std::string(pFile));
|
||||
}
|
||||
outfile->Write( exporter.mOutput.str().c_str(), static_cast<size_t>(exporter.mOutput.tellp()),1);
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
} // end of namespace Assimp
|
||||
|
||||
static const std::string MaterialExt = ".mtl";
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
ObjExporter::ObjExporter(const char* _filename, const aiScene* pScene)
|
||||
ObjExporter::ObjExporter(const char* _filename, const aiScene* pScene, bool noMtl)
|
||||
: filename(_filename)
|
||||
, pScene(pScene)
|
||||
, vp()
|
||||
|
|
@ -108,8 +130,9 @@ ObjExporter::ObjExporter(const char* _filename, const aiScene* pScene)
|
|||
mOutputMat.imbue(l);
|
||||
mOutputMat.precision(16);
|
||||
|
||||
WriteGeometryFile();
|
||||
WriteMaterialFile();
|
||||
WriteGeometryFile(noMtl);
|
||||
if (!noMtl)
|
||||
WriteMaterialFile();
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
|
|
@ -132,7 +155,7 @@ std::string ObjExporter :: GetMaterialLibName()
|
|||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
std::string ObjExporter::GetMaterialLibFileName() {
|
||||
// Remove existing .obj file extention so that the final material file name will be fileName.mtl and not fileName.obj.mtl
|
||||
// Remove existing .obj file extension so that the final material file name will be fileName.mtl and not fileName.obj.mtl
|
||||
size_t lastdot = filename.find_last_of('.');
|
||||
if (lastdot != std::string::npos)
|
||||
return filename.substr(0, lastdot) + MaterialExt;
|
||||
|
|
@ -235,10 +258,10 @@ void ObjExporter::WriteMaterialFile()
|
|||
}
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void ObjExporter::WriteGeometryFile() {
|
||||
void ObjExporter::WriteGeometryFile(bool noMtl) {
|
||||
WriteHeader(mOutput);
|
||||
mOutput << "mtllib " << GetMaterialLibName() << endl << endl;
|
||||
if (!noMtl)
|
||||
mOutput << "mtllib " << GetMaterialLibName() << endl << endl;
|
||||
|
||||
// collect mesh geometry
|
||||
aiMatrix4x4 mBase;
|
||||
|
|
@ -256,8 +279,10 @@ void ObjExporter::WriteGeometryFile() {
|
|||
mOutput << "# " << vp.size() << " vertex positions and colors" << endl;
|
||||
size_t colIdx = 0;
|
||||
for ( const aiVector3D& v : vp ) {
|
||||
mOutput << "v " << v.x << " " << v.y << " " << v.z << " " << vc[ colIdx ].r << " " << vc[ colIdx ].g << " " << vc[ colIdx ].b << endl;
|
||||
colIdx++;
|
||||
if ( colIdx < vc.size() ) {
|
||||
mOutput << "v " << v.x << " " << v.y << " " << v.z << " " << vc[ colIdx ].r << " " << vc[ colIdx ].g << " " << vc[ colIdx ].b << endl;
|
||||
}
|
||||
++colIdx;
|
||||
}
|
||||
}
|
||||
mOutput << endl;
|
||||
|
|
@ -284,7 +309,8 @@ void ObjExporter::WriteGeometryFile() {
|
|||
if (!m.name.empty()) {
|
||||
mOutput << "g " << m.name << endl;
|
||||
}
|
||||
mOutput << "usemtl " << m.matname << endl;
|
||||
if (!noMtl)
|
||||
mOutput << "usemtl " << m.matname << endl;
|
||||
|
||||
for(const Face& f : m.faces) {
|
||||
mOutput << f.kind << ' ';
|
||||
|
|
@ -358,7 +384,7 @@ void ObjExporter::AddMesh(const aiString& name, const aiMesh* m, const aiMatrix4
|
|||
mMeshes.push_back(MeshInstance());
|
||||
MeshInstance& mesh = mMeshes.back();
|
||||
|
||||
mesh.name = std::string(name.data,name.length) + (m->mName.length ? "_" + std::string(m->mName.data,m->mName.length) : "");
|
||||
mesh.name = std::string( name.data, name.length );
|
||||
mesh.matname = GetMaterialName(m->mMaterialIndex);
|
||||
|
||||
mesh.faces.resize(m->mNumFaces);
|
||||
|
|
|
|||
|
|
@ -62,7 +62,7 @@ namespace Assimp {
|
|||
class ObjExporter {
|
||||
public:
|
||||
/// Constructor for a specific scene to export
|
||||
ObjExporter(const char* filename, const aiScene* pScene);
|
||||
ObjExporter(const char* filename, const aiScene* pScene, bool noMtl=false);
|
||||
~ObjExporter();
|
||||
std::string GetMaterialLibName();
|
||||
std::string GetMaterialLibFileName();
|
||||
|
|
@ -97,7 +97,7 @@ private:
|
|||
|
||||
void WriteHeader(std::ostringstream& out);
|
||||
void WriteMaterialFile();
|
||||
void WriteGeometryFile();
|
||||
void WriteGeometryFile(bool noMtl=false);
|
||||
std::string GetMaterialName(unsigned int index);
|
||||
void AddMesh(const aiString& name, const aiMesh* m, const aiMatrix4x4& mat);
|
||||
void AddNode(const aiNode* nd, const aiMatrix4x4& mParent);
|
||||
|
|
|
|||
|
|
@ -477,6 +477,9 @@ void ObjFileParser::getFace( aiPrimitiveType type ) {
|
|||
}
|
||||
} else {
|
||||
//On error, std::atoi will return 0 which is not a valid value
|
||||
delete face;
|
||||
delete m_pModel;
|
||||
m_pModel = nullptr;
|
||||
throw DeadlyImportError("OBJ: Invalid face indice");
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -258,7 +258,7 @@ aiMaterial* OgreImporter::ReadMaterial(const std::string &pFile, Assimp::IOSyste
|
|||
ReadTechnique(Trim(techniqueName), ss, material);
|
||||
}
|
||||
|
||||
// Read informations from a custom material
|
||||
// Read information from a custom material
|
||||
/** @todo This "set $x y" does not seem to be a official Ogre material system feature.
|
||||
Materials can inherit other materials and override texture units by using the (unique)
|
||||
parent texture unit name in your cloned material.
|
||||
|
|
|
|||
|
|
@ -51,7 +51,7 @@ OpenGEXExporter::OpenGEXExporter() {
|
|||
OpenGEXExporter::~OpenGEXExporter() {
|
||||
}
|
||||
|
||||
bool OpenGEXExporter::exportScene( const char *filename, const aiScene* pScene ) {
|
||||
bool OpenGEXExporter::exportScene( const char */*filename*/, const aiScene* /*pScene*/ ) {
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -431,7 +431,7 @@ void OpenGEXImporter::handleNodes( DDLNode *node, aiScene *pScene ) {
|
|||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------
|
||||
void OpenGEXImporter::handleMetricNode( DDLNode *node, aiScene *pScene ) {
|
||||
void OpenGEXImporter::handleMetricNode( DDLNode *node, aiScene * /*pScene*/ ) {
|
||||
if( nullptr == node || nullptr == m_ctx ) {
|
||||
return;
|
||||
}
|
||||
|
|
@ -467,7 +467,7 @@ void OpenGEXImporter::handleMetricNode( DDLNode *node, aiScene *pScene ) {
|
|||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------
|
||||
void OpenGEXImporter::handleNameNode( DDLNode *node, aiScene *pScene ) {
|
||||
void OpenGEXImporter::handleNameNode( DDLNode *node, aiScene * /*pScene*/ ) {
|
||||
if( nullptr == m_currentNode ) {
|
||||
throw DeadlyImportError( "No current node for name." );
|
||||
return;
|
||||
|
|
@ -512,7 +512,7 @@ static void getRefNames( DDLNode *node, std::vector<std::string> &names ) {
|
|||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------
|
||||
void OpenGEXImporter::handleObjectRefNode( DDLNode *node, aiScene *pScene ) {
|
||||
void OpenGEXImporter::handleObjectRefNode( DDLNode *node, aiScene * /*pScene*/ ) {
|
||||
if( nullptr == m_currentNode ) {
|
||||
throw DeadlyImportError( "No parent node for name." );
|
||||
return;
|
||||
|
|
@ -536,7 +536,7 @@ void OpenGEXImporter::handleObjectRefNode( DDLNode *node, aiScene *pScene ) {
|
|||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------
|
||||
void OpenGEXImporter::handleMaterialRefNode( ODDLParser::DDLNode *node, aiScene *pScene ) {
|
||||
void OpenGEXImporter::handleMaterialRefNode( ODDLParser::DDLNode *node, aiScene * /*pScene*/ ) {
|
||||
if( nullptr == m_currentNode ) {
|
||||
throw DeadlyImportError( "No parent node for name." );
|
||||
return;
|
||||
|
|
@ -674,7 +674,7 @@ static void setMatrix( aiNode *node, DataArrayList *transformData ) {
|
|||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------
|
||||
void OpenGEXImporter::handleTransformNode( ODDLParser::DDLNode *node, aiScene *pScene ) {
|
||||
void OpenGEXImporter::handleTransformNode( ODDLParser::DDLNode *node, aiScene * /*pScene*/ ) {
|
||||
if( nullptr == m_currentNode ) {
|
||||
throw DeadlyImportError( "No parent node for name." );
|
||||
return;
|
||||
|
|
@ -819,7 +819,7 @@ static void copyColor4DArray( size_t numItems, DataArrayList *vaList, aiColor4D
|
|||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------
|
||||
void OpenGEXImporter::handleVertexArrayNode( ODDLParser::DDLNode *node, aiScene *pScene ) {
|
||||
void OpenGEXImporter::handleVertexArrayNode( ODDLParser::DDLNode *node, aiScene * /*pScene*/ ) {
|
||||
if( nullptr == node ) {
|
||||
throw DeadlyImportError( "No parent node for name." );
|
||||
return;
|
||||
|
|
@ -862,7 +862,7 @@ void OpenGEXImporter::handleVertexArrayNode( ODDLParser::DDLNode *node, aiScene
|
|||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------
|
||||
void OpenGEXImporter::handleIndexArrayNode( ODDLParser::DDLNode *node, aiScene *pScene ) {
|
||||
void OpenGEXImporter::handleIndexArrayNode( ODDLParser::DDLNode *node, aiScene * /*pScene*/ ) {
|
||||
if( nullptr == node ) {
|
||||
throw DeadlyImportError( "No parent node for name." );
|
||||
return;
|
||||
|
|
@ -1001,7 +1001,7 @@ void OpenGEXImporter::handleMaterialNode( ODDLParser::DDLNode *node, aiScene *pS
|
|||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------
|
||||
void OpenGEXImporter::handleColorNode( ODDLParser::DDLNode *node, aiScene *pScene ) {
|
||||
void OpenGEXImporter::handleColorNode( ODDLParser::DDLNode *node, aiScene * /*pScene*/ ) {
|
||||
if( nullptr == node ) {
|
||||
return;
|
||||
}
|
||||
|
|
@ -1040,7 +1040,7 @@ void OpenGEXImporter::handleColorNode( ODDLParser::DDLNode *node, aiScene *pScen
|
|||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------
|
||||
void OpenGEXImporter::handleTextureNode( ODDLParser::DDLNode *node, aiScene *pScene ) {
|
||||
void OpenGEXImporter::handleTextureNode( ODDLParser::DDLNode *node, aiScene * /*pScene*/ ) {
|
||||
if( nullptr == node ) {
|
||||
return;
|
||||
}
|
||||
|
|
@ -1074,7 +1074,7 @@ void OpenGEXImporter::handleTextureNode( ODDLParser::DDLNode *node, aiScene *pSc
|
|||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------
|
||||
void OpenGEXImporter::handleParamNode( ODDLParser::DDLNode *node, aiScene *pScene ) {
|
||||
void OpenGEXImporter::handleParamNode( ODDLParser::DDLNode *node, aiScene * /*pScene*/ ) {
|
||||
if ( nullptr == node ) {
|
||||
return;
|
||||
}
|
||||
|
|
@ -1103,7 +1103,7 @@ void OpenGEXImporter::handleParamNode( ODDLParser::DDLNode *node, aiScene *pScen
|
|||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------
|
||||
void OpenGEXImporter::handleAttenNode( ODDLParser::DDLNode *node, aiScene *pScene ) {
|
||||
void OpenGEXImporter::handleAttenNode( ODDLParser::DDLNode *node, aiScene * /*pScene*/ ) {
|
||||
if ( nullptr == node ) {
|
||||
return;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -65,7 +65,7 @@ template<> const char* type_of(double&) { return "double"; }
|
|||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// Worker function for exporting a scene to PLY. Prototyped and registered in Exporter.cpp
|
||||
void ExportScenePly(const char* pFile,IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* pProperties)
|
||||
void ExportScenePly(const char* pFile,IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/)
|
||||
{
|
||||
// invoke the exporter
|
||||
PlyExporter exporter(pFile, pScene);
|
||||
|
|
@ -83,7 +83,7 @@ void ExportScenePly(const char* pFile,IOSystem* pIOSystem, const aiScene* pScene
|
|||
outfile->Write( exporter.mOutput.str().c_str(), static_cast<size_t>(exporter.mOutput.tellp()),1);
|
||||
}
|
||||
|
||||
void ExportScenePlyBinary(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* pProperties)
|
||||
void ExportScenePlyBinary(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/)
|
||||
{
|
||||
// invoke the exporter
|
||||
PlyExporter exporter(pFile, pScene, true);
|
||||
|
|
|
|||
|
|
@ -381,6 +381,11 @@ bool PLY::Element::ParseElement(IOStreamBuffer<char> &streamBuffer, std::vector<
|
|||
{
|
||||
char* endPos = &buffer[0] + (strlen(&buffer[0]) - 1);
|
||||
pOut->szName = std::string(&buffer[0], endPos);
|
||||
|
||||
// go to the next line
|
||||
PLY::DOM::SkipSpacesAndLineEnd(buffer);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
//parse the number of occurrences of this element
|
||||
|
|
|
|||
|
|
@ -255,6 +255,7 @@ IOStream *Q3BSPZipArchive::Open(const char* pFile, const char* /*pMode*/) {
|
|||
// ------------------------------------------------------------------------------------------------
|
||||
// Close a filestream.
|
||||
void Q3BSPZipArchive::Close(IOStream *pFile) {
|
||||
(void)(pFile);
|
||||
ai_assert(pFile != NULL);
|
||||
|
||||
// We don't do anything in case the file would be opened again in the future
|
||||
|
|
|
|||
|
|
@ -163,7 +163,7 @@ static aiColor3D ReadColor(StreamReaderLE* stream)
|
|||
return aiColor3D(r, g, b);
|
||||
}
|
||||
|
||||
static void UnknownChunk(StreamReaderLE* stream, const SIBChunk& chunk)
|
||||
static void UnknownChunk(StreamReaderLE* /*stream*/, const SIBChunk& chunk)
|
||||
{
|
||||
char temp[5] = {
|
||||
static_cast<char>(( chunk.Tag>>24 ) & 0xff),
|
||||
|
|
|
|||
|
|
@ -334,7 +334,7 @@ bool STEP::StringToUTF8(std::string& s)
|
|||
size_t j = basei, jend = s.size()-3;
|
||||
|
||||
for (; j < jend; ++j) {
|
||||
if (s[j] == '\\' && s[j] == 'X' && s[j] == '0' && s[j] == '\\') {
|
||||
if (s[j] == '\\' && s[j+1] == 'X' && s[j+2] == '0' && s[j+3] == '\\') {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -57,7 +57,7 @@ namespace Assimp {
|
|||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// Worker function for exporting a scene to Stereolithograpy. Prototyped and registered in Exporter.cpp
|
||||
void ExportSceneSTL(const char* pFile,IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* pProperties)
|
||||
void ExportSceneSTL(const char* pFile,IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/)
|
||||
{
|
||||
// invoke the exporter
|
||||
STLExporter exporter(pFile, pScene);
|
||||
|
|
@ -74,7 +74,7 @@ void ExportSceneSTL(const char* pFile,IOSystem* pIOSystem, const aiScene* pScene
|
|||
|
||||
outfile->Write( exporter.mOutput.str().c_str(), static_cast<size_t>(exporter.mOutput.tellp()),1);
|
||||
}
|
||||
void ExportSceneSTLBinary(const char* pFile,IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* pProperties)
|
||||
void ExportSceneSTLBinary(const char* pFile,IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/)
|
||||
{
|
||||
// invoke the exporter
|
||||
STLExporter exporter(pFile, pScene, true);
|
||||
|
|
|
|||
|
|
@ -80,7 +80,9 @@ static bool IsBinarySTL(const char* buffer, unsigned int fileSize) {
|
|||
return false;
|
||||
}
|
||||
|
||||
const uint32_t faceCount = *reinterpret_cast<const uint32_t*>(buffer + 80);
|
||||
const char *facecount_pos = buffer + 80;
|
||||
uint32_t faceCount( 0 );
|
||||
::memcpy( &faceCount, facecount_pos, sizeof( uint32_t ) );
|
||||
const uint32_t expectedBinaryFileSize = faceCount * 50 + 84;
|
||||
|
||||
return expectedBinaryFileSize == fileSize;
|
||||
|
|
@ -200,17 +202,17 @@ void STLImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
|
|||
if (IsBinarySTL(mBuffer, fileSize)) {
|
||||
bMatClr = LoadBinaryFile();
|
||||
} else if (IsAsciiSTL(mBuffer, fileSize)) {
|
||||
LoadASCIIFile();
|
||||
LoadASCIIFile( pScene->mRootNode );
|
||||
} else {
|
||||
throw DeadlyImportError( "Failed to determine STL storage representation for " + pFile + ".");
|
||||
}
|
||||
|
||||
// add all created meshes to the single node
|
||||
pScene->mRootNode->mNumMeshes = pScene->mNumMeshes;
|
||||
/*pScene->mRootNode->mNumMeshes = pScene->mNumMeshes;
|
||||
pScene->mRootNode->mMeshes = new unsigned int[pScene->mNumMeshes];
|
||||
for (unsigned int i = 0; i < pScene->mNumMeshes; i++)
|
||||
pScene->mRootNode->mMeshes[i] = i;
|
||||
|
||||
*/
|
||||
// create a single default material, using a white diffuse color for consistency with
|
||||
// other geometric types (e.g., PLY).
|
||||
aiMaterial* pcMat = new aiMaterial();
|
||||
|
|
@ -231,11 +233,12 @@ void STLImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
|
|||
pScene->mMaterials = new aiMaterial*[1];
|
||||
pScene->mMaterials[0] = pcMat;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// Read an ASCII STL file
|
||||
void STLImporter::LoadASCIIFile()
|
||||
{
|
||||
void STLImporter::LoadASCIIFile( aiNode *root ) {
|
||||
std::vector<aiMesh*> meshes;
|
||||
std::vector<aiNode*> nodes;
|
||||
const char* sz = mBuffer;
|
||||
const char* bufferEnd = mBuffer + fileSize;
|
||||
std::vector<aiVector3D> positionBuffer;
|
||||
|
|
@ -247,12 +250,15 @@ void STLImporter::LoadASCIIFile()
|
|||
positionBuffer.reserve(sizeEstimate);
|
||||
normalBuffer.reserve(sizeEstimate);
|
||||
|
||||
while (IsAsciiSTL(sz, static_cast<unsigned int>(bufferEnd - sz)))
|
||||
{
|
||||
while (IsAsciiSTL(sz, static_cast<unsigned int>(bufferEnd - sz))) {
|
||||
std::vector<unsigned int> meshIndices;
|
||||
aiMesh* pMesh = new aiMesh();
|
||||
pMesh->mMaterialIndex = 0;
|
||||
meshIndices.push_back( meshes.size() );
|
||||
meshes.push_back(pMesh);
|
||||
|
||||
aiNode *node = new aiNode;
|
||||
node->mParent = root;
|
||||
nodes.push_back( node );
|
||||
SkipSpaces(&sz);
|
||||
ai_assert(!IsLineEnd(sz));
|
||||
|
||||
|
|
@ -265,20 +271,21 @@ void STLImporter::LoadASCIIFile()
|
|||
|
||||
size_t temp;
|
||||
// setup the name of the node
|
||||
if ((temp = (size_t)(sz-szMe))) {
|
||||
if ((temp = (size_t)(sz-szMe))) {
|
||||
if (temp >= MAXLEN) {
|
||||
throw DeadlyImportError( "STL: Node name too long" );
|
||||
}
|
||||
|
||||
pScene->mRootNode->mName.length = temp;
|
||||
memcpy(pScene->mRootNode->mName.data,szMe,temp);
|
||||
pScene->mRootNode->mName.data[temp] = '\0';
|
||||
std::string name( szMe, temp );
|
||||
node->mName.Set( name.c_str() );
|
||||
//pScene->mRootNode->mName.length = temp;
|
||||
//memcpy(pScene->mRootNode->mName.data,szMe,temp);
|
||||
//pScene->mRootNode->mName.data[temp] = '\0';
|
||||
} else {
|
||||
pScene->mRootNode->mName.Set("<STL_ASCII>");
|
||||
}
|
||||
else pScene->mRootNode->mName.Set("<STL_ASCII>");
|
||||
|
||||
unsigned int faceVertexCounter = 3;
|
||||
for ( ;; )
|
||||
{
|
||||
for ( ;; ) {
|
||||
// go to the next token
|
||||
if(!SkipSpacesAndLineEnd(&sz))
|
||||
{
|
||||
|
|
@ -300,9 +307,7 @@ void STLImporter::LoadASCIIFile()
|
|||
SkipSpaces(&sz);
|
||||
if (strncmp(sz,"normal",6)) {
|
||||
DefaultLogger::get()->warn("STL: a facet normal vector was expected but not found");
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
if (sz[6] == '\0') {
|
||||
throw DeadlyImportError("STL: unexpected EOF while parsing facet");
|
||||
}
|
||||
|
|
@ -316,16 +321,11 @@ void STLImporter::LoadASCIIFile()
|
|||
normalBuffer.push_back(*vn);
|
||||
normalBuffer.push_back(*vn);
|
||||
}
|
||||
}
|
||||
// vertex 1.50000 1.50000 0.00000
|
||||
else if (!strncmp(sz,"vertex",6) && ::IsSpaceOrNewLine(*(sz+6)))
|
||||
{
|
||||
} else if (!strncmp(sz,"vertex",6) && ::IsSpaceOrNewLine(*(sz+6))) { // vertex 1.50000 1.50000 0.00000
|
||||
if (faceVertexCounter >= 3) {
|
||||
DefaultLogger::get()->error("STL: a facet with more than 3 vertices has been found");
|
||||
++sz;
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
if (sz[6] == '\0') {
|
||||
throw DeadlyImportError("STL: unexpected EOF while parsing facet");
|
||||
}
|
||||
|
|
@ -340,17 +340,14 @@ void STLImporter::LoadASCIIFile()
|
|||
sz = fast_atoreal_move<ai_real>(sz, (ai_real&)vn->z );
|
||||
faceVertexCounter++;
|
||||
}
|
||||
}
|
||||
else if (!::strncmp(sz,"endsolid",8)) {
|
||||
} else if (!::strncmp(sz,"endsolid",8)) {
|
||||
do {
|
||||
++sz;
|
||||
} while (!::IsLineEnd(*sz));
|
||||
SkipSpacesAndLineEnd(&sz);
|
||||
// finished!
|
||||
break;
|
||||
}
|
||||
// else skip the whole identifier
|
||||
else {
|
||||
} else { // else skip the whole identifier
|
||||
do {
|
||||
++sz;
|
||||
} while (!::IsSpaceOrNewLine(*sz));
|
||||
|
|
@ -380,13 +377,22 @@ void STLImporter::LoadASCIIFile()
|
|||
|
||||
// now copy faces
|
||||
addFacesToMesh(pMesh);
|
||||
|
||||
// assign the meshes to the current node
|
||||
pushMeshesToNode( meshIndices, node );
|
||||
}
|
||||
|
||||
// now add the loaded meshes
|
||||
pScene->mNumMeshes = (unsigned int)meshes.size();
|
||||
pScene->mMeshes = new aiMesh*[pScene->mNumMeshes];
|
||||
for (size_t i = 0; i < meshes.size(); i++)
|
||||
{
|
||||
pScene->mMeshes[i] = meshes[i];
|
||||
for (size_t i = 0; i < meshes.size(); i++) {
|
||||
pScene->mMeshes[ i ] = meshes[i];
|
||||
}
|
||||
|
||||
root->mNumChildren = nodes.size();
|
||||
root->mChildren = new aiNode*[ root->mNumChildren ];
|
||||
for ( size_t i=0; i<nodes.size(); ++i ) {
|
||||
root->mChildren[ i ] = nodes[ i ];
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -513,4 +519,18 @@ bool STLImporter::LoadBinaryFile()
|
|||
return false;
|
||||
}
|
||||
|
||||
void STLImporter::pushMeshesToNode( std::vector<unsigned int> &meshIndices, aiNode *node ) {
|
||||
ai_assert( nullptr != node );
|
||||
if ( meshIndices.empty() ) {
|
||||
return;
|
||||
}
|
||||
|
||||
node->mNumMeshes = static_cast<unsigned int>( meshIndices.size() );
|
||||
node->mMeshes = new unsigned int[ meshIndices.size() ];
|
||||
for ( size_t i=0; i<meshIndices.size(); ++i ) {
|
||||
node->mMeshes[ i ] = meshIndices[ i ];
|
||||
}
|
||||
meshIndices.clear();
|
||||
}
|
||||
|
||||
#endif // !! ASSIMP_BUILD_NO_STL_IMPORTER
|
||||
|
|
|
|||
|
|
@ -48,53 +48,61 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
#include "BaseImporter.h"
|
||||
#include <assimp/types.h>
|
||||
|
||||
namespace Assimp {
|
||||
// Forward declarations
|
||||
struct aiNode;
|
||||
|
||||
namespace Assimp {
|
||||
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
/** Importer class for the sterolithography STL file format
|
||||
*/
|
||||
class STLImporter : public BaseImporter
|
||||
{
|
||||
/**
|
||||
* @brief Importer class for the sterolithography STL file format.
|
||||
*/
|
||||
class STLImporter : public BaseImporter {
|
||||
public:
|
||||
/**
|
||||
* @brief STLImporter, the class default constructor.
|
||||
*/
|
||||
STLImporter();
|
||||
|
||||
/**
|
||||
* @brief The class destructor.
|
||||
*/
|
||||
~STLImporter();
|
||||
|
||||
|
||||
public:
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
/** Returns whether the class can handle the format of the given file.
|
||||
* See BaseImporter::CanRead() for details.
|
||||
/**
|
||||
* @brief Returns whether the class can handle the format of the given file.
|
||||
* See BaseImporter::CanRead() for details.
|
||||
*/
|
||||
bool CanRead( const std::string& pFile, IOSystem* pIOHandler,
|
||||
bool checkSig) const;
|
||||
bool CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const;
|
||||
|
||||
protected:
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
/** Return importer meta information.
|
||||
* See #BaseImporter::GetInfo for the details
|
||||
/**
|
||||
* @brief Return importer meta information.
|
||||
* See #BaseImporter::GetInfo for the details
|
||||
*/
|
||||
const aiImporterDesc* GetInfo () const;
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
/** Imports the given file into the given scene structure.
|
||||
/**
|
||||
* @brief Imports the given file into the given scene structure.
|
||||
* See BaseImporter::InternReadFile() for details
|
||||
*/
|
||||
void InternReadFile( const std::string& pFile, aiScene* pScene,
|
||||
IOSystem* pIOHandler);
|
||||
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
/** Loads a binary .stl file
|
||||
/**
|
||||
* @brief Loads a binary .stl file
|
||||
* @return true if the default vertex color must be used as material color
|
||||
*/
|
||||
*/
|
||||
bool LoadBinaryFile();
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
/** Loads a ASCII text .stl file
|
||||
*/
|
||||
void LoadASCIIFile();
|
||||
/**
|
||||
* @brief Loads a ASCII text .stl file
|
||||
*/
|
||||
void LoadASCIIFile( aiNode *root );
|
||||
|
||||
void pushMeshesToNode( std::vector<unsigned int> &meshIndices, aiNode *node );
|
||||
|
||||
protected:
|
||||
|
||||
|
|
|
|||
|
|
@ -40,10 +40,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
*/
|
||||
|
||||
/** @file Defines a helper class to evaluate subdivision surfaces.*/
|
||||
#pragma once
|
||||
#ifndef AI_SUBDISIVION_H_INC
|
||||
#define AI_SUBDISIVION_H_INC
|
||||
|
||||
#include <cstddef>
|
||||
#include <assimp/types.h>
|
||||
|
||||
struct aiMesh;
|
||||
|
||||
namespace Assimp {
|
||||
|
|
@ -52,8 +55,7 @@ namespace Assimp {
|
|||
/** Helper class to evaluate subdivision surfaces. Different algorithms
|
||||
* are provided for choice. */
|
||||
// ------------------------------------------------------------------------------
|
||||
class Subdivider
|
||||
{
|
||||
class ASSIMP_API Subdivider {
|
||||
public:
|
||||
|
||||
/** Enumerates all supported subvidision algorithms */
|
||||
|
|
@ -61,12 +63,7 @@ public:
|
|||
CATMULL_CLARKE = 0x1
|
||||
};
|
||||
|
||||
public:
|
||||
|
||||
virtual ~Subdivider() {
|
||||
}
|
||||
|
||||
public:
|
||||
virtual ~Subdivider();
|
||||
|
||||
// ---------------------------------------------------------------
|
||||
/** Create a subdivider of a specific type
|
||||
|
|
@ -119,9 +116,13 @@ public:
|
|||
unsigned int num,
|
||||
bool discard_input = false) = 0;
|
||||
|
||||
private:
|
||||
};
|
||||
|
||||
inline
|
||||
Subdivider::~Subdivider() {
|
||||
// empty
|
||||
}
|
||||
|
||||
} // end namespace Assimp
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -317,7 +317,7 @@ void TextureTransformStep::Execute( aiScene* pScene)
|
|||
info.lockedPos = AI_TT_UV_IDX_LOCK_TBD;
|
||||
}
|
||||
|
||||
// Get all coresponding meshes
|
||||
// Get all corresponding meshes
|
||||
for (unsigned int n = 0; n < pScene->mNumMeshes;++n) {
|
||||
aiMesh* mesh = pScene->mMeshes[n];
|
||||
if (mesh->mMaterialIndex != i || !mesh->mTextureCoords[0])
|
||||
|
|
|
|||
|
|
@ -692,7 +692,7 @@ bool found = false;
|
|||
return true;
|
||||
}
|
||||
|
||||
X3DExporter::X3DExporter(const char* pFileName, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* pProperties)
|
||||
X3DExporter::X3DExporter(const char* pFileName, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/)
|
||||
: mScene(pScene)
|
||||
{
|
||||
list<SAttribute> attr_list;
|
||||
|
|
|
|||
|
|
@ -27,7 +27,7 @@ namespace Assimp
|
|||
///
|
||||
/// Pay attention that X3D is format for interactive graphic and simulations for web browsers. aiScene can not contain all features of the X3D format.
|
||||
/// Also, aiScene contain rasterized-like data. For example, X3D can describe circle all cylinder with one tag, but aiScene contain result of tesselation:
|
||||
/// vertices, faces etc. Yes, you can use algorithm for detecting figures or shapes, but thats not good idea at all.
|
||||
/// vertices, faces etc. Yes, you can use algorithm for detecting figures or shapes, but that's not a good idea at all.
|
||||
///
|
||||
/// Supported nodes:
|
||||
/// Core component:
|
||||
|
|
@ -96,7 +96,7 @@ private:
|
|||
aiMatrix4x4 Matrix_GlobalToCurrent(const aiNode& pNode) const;
|
||||
|
||||
/// \fn void AttrHelper_CommaToPoint(std::string& pStringWithComma)
|
||||
/// Convert commas in string to points. Thats need because "std::to_string" result depend on locale (regional settings).
|
||||
/// Convert commas in string to points. That's needed because "std::to_string" result depends on locale (regional settings).
|
||||
/// \param [in, out] pStringWithComma - reference to string, which must be modified.
|
||||
void AttrHelper_CommaToPoint(std::string& pStringWithComma) { for(char& c: pStringWithComma) { if(c == ',') c = '.'; } }
|
||||
|
||||
|
|
|
|||
|
|
@ -176,7 +176,7 @@ namespace Assimp {
|
|||
/// Ignored attributes: "creaseAngle", "convex", "solid".
|
||||
///
|
||||
/// Texture coordinates generating: only for Sphere, Cone, Cylinder. In all other case used PLANE mapping.
|
||||
/// It's better that Assimp main code has powerfull texture coordinates generator. Then is not needed to
|
||||
/// It's better that Assimp main code has powerful texture coordinates generator. Then is not needed to
|
||||
/// duplicate this code in every importer.
|
||||
///
|
||||
/// Lighting limitations.
|
||||
|
|
@ -401,10 +401,10 @@ private:
|
|||
/************** Functions: XML set *************/
|
||||
/***********************************************/
|
||||
|
||||
/// Chek if current node is empty: <node />. If not then exception will throwed.
|
||||
/// Check if current node is empty: <node />. If not then exception will throwed.
|
||||
void XML_CheckNode_MustBeEmpty();
|
||||
|
||||
/// Chek if current node name is equal to pNodeName.
|
||||
/// Check if current node name is equal to pNodeName.
|
||||
/// \param [in] pNodeName - name for checking.
|
||||
/// return true if current node name is equal to pNodeName, else - false.
|
||||
bool XML_CheckNode_NameEqual(const std::string& pNodeName) { return mReader->getNodeName() == pNodeName; }
|
||||
|
|
|
|||
|
|
@ -105,7 +105,7 @@ bool X3DImporter::ParseHelper_CheckRead_X3DMetadataObject()
|
|||
return true;
|
||||
}
|
||||
|
||||
void X3DImporter::ParseNode_Metadata(CX3DImporter_NodeElement* pParentElement, const std::string& pNodeName)
|
||||
void X3DImporter::ParseNode_Metadata(CX3DImporter_NodeElement* pParentElement, const std::string& /*pNodeName*/)
|
||||
{
|
||||
ParseHelper_Node_Enter(pParentElement);
|
||||
MACRO_NODECHECK_METADATA(mReader->getNodeName());
|
||||
|
|
|
|||
|
|
@ -403,7 +403,7 @@ namespace glTF2
|
|||
virtual ~Object() {}
|
||||
|
||||
//! Maps special IDs to another ID, where needed. Subclasses may override it (statically)
|
||||
static const char* TranslateId(Asset& r, const char* id)
|
||||
static const char* TranslateId(Asset& /*r*/, const char* id)
|
||||
{ return id; }
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -332,7 +332,7 @@ inline Buffer::~Buffer()
|
|||
for(SEncodedRegion* reg : EncodedRegion_List) delete reg;
|
||||
}
|
||||
|
||||
inline const char* Buffer::TranslateId(Asset& r, const char* id)
|
||||
inline const char* Buffer::TranslateId(Asset& /*r*/, const char* id)
|
||||
{
|
||||
return id;
|
||||
}
|
||||
|
|
@ -667,7 +667,7 @@ inline Image::Image()
|
|||
|
||||
}
|
||||
|
||||
inline void Image::Read(Value& obj, Asset& r)
|
||||
inline void Image::Read(Value& obj, Asset& /*r*/)
|
||||
{
|
||||
if (!mDataLength) {
|
||||
if (Value* uri = FindString(obj, "uri")) {
|
||||
|
|
@ -712,7 +712,7 @@ inline void Image::SetData(uint8_t* data, size_t length, Asset& r)
|
|||
}
|
||||
}
|
||||
|
||||
inline void Sampler::Read(Value& obj, Asset& r)
|
||||
inline void Sampler::Read(Value& obj, Asset& /*r*/)
|
||||
{
|
||||
SetDefaults();
|
||||
|
||||
|
|
@ -930,7 +930,7 @@ inline void Mesh::Read(Value& pJSON_Object, Asset& pAsset_Root)
|
|||
}
|
||||
}
|
||||
|
||||
inline void Camera::Read(Value& obj, Asset& r)
|
||||
inline void Camera::Read(Value& obj, Asset& /*r*/)
|
||||
{
|
||||
type = MemberOrDefault(obj, "type", Camera::Perspective);
|
||||
|
||||
|
|
@ -1131,7 +1131,7 @@ inline void Asset::ReadExtensionsUsed(Document& doc)
|
|||
#undef CHECK_EXT
|
||||
}
|
||||
|
||||
inline IOStream* Asset::OpenFile(std::string path, const char* mode, bool absolute)
|
||||
inline IOStream* Asset::OpenFile(std::string path, const char* mode, bool /*absolute*/)
|
||||
{
|
||||
#ifdef ASSIMP_API
|
||||
return mIOSystem->Open(path, mode);
|
||||
|
|
|
|||
|
|
@ -72,7 +72,7 @@ namespace glTF2 {
|
|||
return val;
|
||||
}
|
||||
|
||||
inline Value& MakeValue(Value& val, float r, MemoryPoolAllocator<>& al) {
|
||||
inline Value& MakeValue(Value& val, float r, MemoryPoolAllocator<>& /*al*/) {
|
||||
val.SetDouble(r);
|
||||
|
||||
return val;
|
||||
|
|
@ -171,7 +171,7 @@ namespace glTF2 {
|
|||
obj.AddMember("target", int(bv.target), w.mAl);
|
||||
}
|
||||
|
||||
inline void Write(Value& obj, Camera& c, AssetWriter& w)
|
||||
inline void Write(Value& /*obj*/, Camera& /*c*/, AssetWriter& /*w*/)
|
||||
{
|
||||
|
||||
}
|
||||
|
|
@ -432,7 +432,7 @@ namespace glTF2 {
|
|||
}
|
||||
}
|
||||
|
||||
inline void Write(Value& obj, Program& b, AssetWriter& w)
|
||||
inline void Write(Value& /*obj*/, Program& /*b*/, AssetWriter& /*w*/)
|
||||
{
|
||||
|
||||
}
|
||||
|
|
@ -465,7 +465,7 @@ namespace glTF2 {
|
|||
AddRefsVector(scene, "nodes", s.nodes, w.mAl);
|
||||
}
|
||||
|
||||
inline void Write(Value& obj, Shader& b, AssetWriter& w)
|
||||
inline void Write(Value& /*obj*/, Shader& /*b*/, AssetWriter& /*w*/)
|
||||
{
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -56,7 +56,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
#include <assimp/material.h>
|
||||
#include <assimp/scene.h>
|
||||
|
||||
// Header files, standart library.
|
||||
// Header files, standard library.
|
||||
#include <memory>
|
||||
#include <inttypes.h>
|
||||
|
||||
|
|
@ -80,7 +80,7 @@ namespace Assimp {
|
|||
} // end of namespace Assimp
|
||||
|
||||
glTF2Exporter::glTF2Exporter(const char* filename, IOSystem* pIOSystem, const aiScene* pScene,
|
||||
const ExportProperties* pProperties, bool isBinary)
|
||||
const ExportProperties* pProperties, bool /*isBinary*/)
|
||||
: mFilename(filename)
|
||||
, mIOSystem(pIOSystem)
|
||||
, mProperties(pProperties)
|
||||
|
|
|
|||
|
|
@ -159,21 +159,21 @@ static void CopyValue(const glTF2::mat4& v, aiMatrix4x4& o)
|
|||
o.a4 = v[12]; o.b4 = v[13]; o.c4 = v[14]; o.d4 = v[15];
|
||||
}
|
||||
|
||||
inline void SetMaterialColorProperty(Asset& r, vec4& prop, aiMaterial* mat, const char* pKey, unsigned int type, unsigned int idx)
|
||||
inline void SetMaterialColorProperty(Asset& /*r*/, vec4& prop, aiMaterial* mat, const char* pKey, unsigned int type, unsigned int idx)
|
||||
{
|
||||
aiColor4D col;
|
||||
CopyValue(prop, col);
|
||||
mat->AddProperty(&col, 1, pKey, type, idx);
|
||||
}
|
||||
|
||||
inline void SetMaterialColorProperty(Asset& r, vec3& prop, aiMaterial* mat, const char* pKey, unsigned int type, unsigned int idx)
|
||||
inline void SetMaterialColorProperty(Asset& /*r*/, vec3& prop, aiMaterial* mat, const char* pKey, unsigned int type, unsigned int idx)
|
||||
{
|
||||
aiColor4D col;
|
||||
CopyValue(prop, col);
|
||||
mat->AddProperty(&col, 1, pKey, type, idx);
|
||||
}
|
||||
|
||||
inline void SetMaterialTextureProperty(std::vector<int>& embeddedTexIdxs, Asset& r, glTF2::TextureInfo prop, aiMaterial* mat, aiTextureType texType, unsigned int texSlot = 0)
|
||||
inline void SetMaterialTextureProperty(std::vector<int>& embeddedTexIdxs, Asset& /*r*/, glTF2::TextureInfo prop, aiMaterial* mat, aiTextureType texType, unsigned int texSlot = 0)
|
||||
{
|
||||
if (prop.texture && prop.texture->source) {
|
||||
aiString uri(prop.texture->source->uri);
|
||||
|
|
@ -296,6 +296,7 @@ static inline void SetFace(aiFace& face, int a, int b, int c)
|
|||
face.mIndices[2] = c;
|
||||
}
|
||||
|
||||
#ifdef ASSIMP_BUILD_DEBUG
|
||||
static inline bool CheckValidFacesIndices(aiFace* faces, unsigned nFaces, unsigned nVerts)
|
||||
{
|
||||
for (unsigned i = 0; i < nFaces; ++i) {
|
||||
|
|
@ -307,6 +308,7 @@ static inline bool CheckValidFacesIndices(aiFace* faces, unsigned nFaces, unsign
|
|||
}
|
||||
return true;
|
||||
}
|
||||
#endif // ASSIMP_BUILD_DEBUG
|
||||
|
||||
void glTF2Importer::ImportMeshes(glTF2::Asset& r)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -393,7 +393,7 @@ namespace glTF
|
|||
virtual ~Object() {}
|
||||
|
||||
//! Maps special IDs to another ID, where needed. Subclasses may override it (statically)
|
||||
static const char* TranslateId(Asset& r, const char* id)
|
||||
static const char* TranslateId(Asset& /*r*/, const char* id)
|
||||
{ return id; }
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -675,7 +675,7 @@ inline void Image::SetData(uint8_t* data, size_t length, Asset& r)
|
|||
}
|
||||
}
|
||||
|
||||
inline void Sampler::Read(Value& obj, Asset& r)
|
||||
inline void Sampler::Read(Value& obj, Asset& /*r*/)
|
||||
{
|
||||
SetDefaults();
|
||||
|
||||
|
|
@ -1093,7 +1093,7 @@ Ref<Buffer> buf = pAsset_Root.buffers.Get(pCompression_Open3DGC.Buffer);
|
|||
}
|
||||
#endif
|
||||
|
||||
inline void Camera::Read(Value& obj, Asset& r)
|
||||
inline void Camera::Read(Value& obj, Asset& /*r*/)
|
||||
{
|
||||
type = MemberOrDefault(obj, "type", Camera::Perspective);
|
||||
|
||||
|
|
@ -1116,7 +1116,7 @@ inline void Camera::Read(Value& obj, Asset& r)
|
|||
}
|
||||
}
|
||||
|
||||
inline void Light::Read(Value& obj, Asset& r)
|
||||
inline void Light::Read(Value& obj, Asset& /*r*/)
|
||||
{
|
||||
SetDefaults();
|
||||
|
||||
|
|
@ -1414,7 +1414,7 @@ inline void Asset::ReadExtensionsUsed(Document& doc)
|
|||
#undef CHECK_EXT
|
||||
}
|
||||
|
||||
inline IOStream* Asset::OpenFile(std::string path, const char* mode, bool absolute)
|
||||
inline IOStream* Asset::OpenFile(std::string path, const char* mode, bool /*absolute*/)
|
||||
{
|
||||
#ifdef ASSIMP_API
|
||||
return mIOSystem->Open(path, mode);
|
||||
|
|
|
|||
|
|
@ -187,7 +187,7 @@ namespace glTF {
|
|||
obj.AddMember("target", int(bv.target), w.mAl);
|
||||
}
|
||||
|
||||
inline void Write(Value& obj, Camera& c, AssetWriter& w)
|
||||
inline void Write(Value& /*obj*/, Camera& /*c*/, AssetWriter& /*w*/)
|
||||
{
|
||||
|
||||
}
|
||||
|
|
@ -398,7 +398,7 @@ namespace glTF {
|
|||
}
|
||||
}
|
||||
|
||||
inline void Write(Value& obj, Program& b, AssetWriter& w)
|
||||
inline void Write(Value& /*obj*/, Program& /*b*/, AssetWriter& /*w*/)
|
||||
{
|
||||
|
||||
}
|
||||
|
|
@ -424,7 +424,7 @@ namespace glTF {
|
|||
AddRefsVector(scene, "nodes", s.nodes, w.mAl);
|
||||
}
|
||||
|
||||
inline void Write(Value& obj, Shader& b, AssetWriter& w)
|
||||
inline void Write(Value& /*obj*/, Shader& /*b*/, AssetWriter& /*w*/)
|
||||
{
|
||||
|
||||
}
|
||||
|
|
@ -452,7 +452,7 @@ namespace glTF {
|
|||
|
||||
}
|
||||
|
||||
inline void Write(Value& obj, Technique& b, AssetWriter& w)
|
||||
inline void Write(Value& /*obj*/, Technique& /*b*/, AssetWriter& /*w*/)
|
||||
{
|
||||
|
||||
}
|
||||
|
|
@ -467,7 +467,7 @@ namespace glTF {
|
|||
}
|
||||
}
|
||||
|
||||
inline void Write(Value& obj, Light& b, AssetWriter& w)
|
||||
inline void Write(Value& /*obj*/, Light& /*b*/, AssetWriter& /*w*/)
|
||||
{
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -56,7 +56,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
#include <assimp/material.h>
|
||||
#include <assimp/scene.h>
|
||||
|
||||
// Header files, standart library.
|
||||
// Header files, standard library.
|
||||
#include <memory>
|
||||
#include <inttypes.h>
|
||||
|
||||
|
|
|
|||
|
|
@ -154,7 +154,7 @@ static void CopyValue(const glTF::mat4& v, aiMatrix4x4& o)
|
|||
o.a4 = v[12]; o.b4 = v[13]; o.c4 = v[14]; o.d4 = v[15];
|
||||
}
|
||||
|
||||
inline void SetMaterialColorProperty(std::vector<int>& embeddedTexIdxs, Asset& r, glTF::TexProperty prop, aiMaterial* mat,
|
||||
inline void SetMaterialColorProperty(std::vector<int>& embeddedTexIdxs, Asset& /*r*/, glTF::TexProperty prop, aiMaterial* mat,
|
||||
aiTextureType texType, const char* pKey, unsigned int type, unsigned int idx)
|
||||
{
|
||||
if (prop.texture) {
|
||||
|
|
@ -234,6 +234,7 @@ static inline void SetFace(aiFace& face, int a, int b, int c)
|
|||
face.mIndices[2] = c;
|
||||
}
|
||||
|
||||
#ifdef ASSIMP_BUILD_DEBUG
|
||||
static inline bool CheckValidFacesIndices(aiFace* faces, unsigned nFaces, unsigned nVerts)
|
||||
{
|
||||
for (unsigned i = 0; i < nFaces; ++i) {
|
||||
|
|
@ -245,6 +246,7 @@ static inline bool CheckValidFacesIndices(aiFace* faces, unsigned nFaces, unsign
|
|||
}
|
||||
return true;
|
||||
}
|
||||
#endif // ASSIMP_BUILD_DEBUG
|
||||
|
||||
void glTFImporter::ImportMeshes(glTF::Asset& r)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -125,7 +125,7 @@ namespace o3dgc
|
|||
}
|
||||
return true;
|
||||
}
|
||||
inline bool IsCase6(long degree, long numIndices, const long * const ops, const long * const indices)
|
||||
inline bool IsCase6(long degree, long numIndices, const long * const ops, const long * const /*indices*/)
|
||||
{
|
||||
// ops: 0000000 indices:
|
||||
if (numIndices!= 0)
|
||||
|
|
|
|||
|
|
@ -191,7 +191,7 @@ Reference *DDLNode::getReferences() const {
|
|||
return m_references;
|
||||
}
|
||||
|
||||
void DDLNode::dump(IOStreamBase &stream) {
|
||||
void DDLNode::dump(IOStreamBase &/*stream*/) {
|
||||
// Todo!
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -294,7 +294,7 @@ Reference *Value::getRef() const {
|
|||
return (Reference*) m_data;
|
||||
}
|
||||
|
||||
void Value::dump( IOStreamBase &stream ) {
|
||||
void Value::dump( IOStreamBase &/*stream*/ ) {
|
||||
switch( m_type ) {
|
||||
case ddl_none:
|
||||
std::cout << "None" << std::endl;
|
||||
|
|
|
|||
|
|
@ -42,6 +42,10 @@ struct Property;
|
|||
template<class T>
|
||||
inline
|
||||
bool isEmbeddedCommentOpenTag( T *in, T *end ) {
|
||||
if ( in == end ) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if ( in == '/' && in+1 == '*' ) {
|
||||
return true;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -725,7 +725,7 @@ RECURSIVE = YES
|
|||
# Note that relative paths are relative to the directory from which doxygen is
|
||||
# run.
|
||||
|
||||
EXCLUDE =
|
||||
EXCLUDE = irrXML.h
|
||||
|
||||
# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
|
||||
# directories that are symbolic links (a Unix file system feature) are excluded
|
||||
|
|
@ -1742,7 +1742,7 @@ UML_LOOK = NO
|
|||
# the class node. If there are many fields or methods and many nodes the
|
||||
# graph may become too big to be useful. The UML_LIMIT_NUM_FIELDS
|
||||
# threshold limits the number of items for each type to make the size more
|
||||
# managable. Set this to 0 for no limit. Note that the threshold may be
|
||||
# manageable. Set this to 0 for no limit. Note that the threshold may be
|
||||
# exceeded by 50% before the limit is enforced.
|
||||
|
||||
UML_LIMIT_NUM_FIELDS = 10
|
||||
|
|
|
|||
10
doc/dox.h
10
doc/dox.h
|
|
@ -60,7 +60,7 @@ that it has not been implemented yet and some (most ...) formats lack proper spe
|
|||
<b>Stanford Ply</b> ( <i>*.ply</i> )<br>
|
||||
<b>TrueSpace</b> ( <i>*.cob, *.scn</i> )<sup>2</sup><br><br>
|
||||
</tt>
|
||||
See the @link importer_notes Importer Notes Page @endlink for informations, what a specific importer can do and what not.
|
||||
See the @link importer_notes Importer Notes Page @endlink for information, what a specific importer can do and what not.
|
||||
Note that although this paper claims to be the official documentation,
|
||||
http://assimp.sourceforge.net/main_features_formats.html
|
||||
<br>is usually the most up-to-date list of file formats supported by the library. <br>
|
||||
|
|
@ -81,7 +81,7 @@ formats handle the required endian conversion correctly, so large parts of the l
|
|||
|
||||
The assimp linker library and viewer application are provided under the BSD 3-clause license. This basically means
|
||||
that you are free to use it in open- or closed-source projects, for commercial or non-commercial purposes as you like
|
||||
as long as you retain the license informations and take own responsibility for what you do with it. For details see
|
||||
as long as you retain the license information and take own responsibility for what you do with it. For details see
|
||||
the LICENSE file.
|
||||
|
||||
You can find test models for almost all formats in the <assimp_root>/test/models directory. Beware, they're *free*,
|
||||
|
|
@ -1420,7 +1420,7 @@ IFC file properties (IfcPropertySet) are kept as per-node metadata, see aiNode::
|
|||
|
||||
This section contains implementations notes for the OgreXML importer.
|
||||
@subsection overview Overview
|
||||
Ogre importer is currently optimized for the Blender Ogre exporter, because thats the only one that I use. You can find the Blender Ogre exporter at: http://www.ogre3d.org/forums/viewtopic.php?f=8&t=45922
|
||||
Ogre importer is currently optimized for the Blender Ogre exporter, because that's the only one that I use. You can find the Blender Ogre exporter at: http://www.ogre3d.org/forums/viewtopic.php?f=8&t=45922
|
||||
|
||||
@subsection what What will be loaded?
|
||||
|
||||
|
|
@ -1434,7 +1434,7 @@ Skeleton: Skeleton with Bone hierarchy (Position and Rotation, but no Scaling in
|
|||
animations with rotation, translation and scaling keys.
|
||||
|
||||
@subsection export_Blender How to export Files from Blender
|
||||
You can find informations about how to use the Ogreexporter by your own, so here are just some options that you need, so the assimp
|
||||
You can find information about how to use the Ogreexporter by your own, so here are just some options that you need, so the assimp
|
||||
importer will load everything correctly:
|
||||
- Use either "Rendering Material" or "Custom Material" see @ref material
|
||||
- do not use "Flip Up Axies to Y"
|
||||
|
|
@ -1543,7 +1543,7 @@ Done! Please, share your loader that everyone can profit from it!
|
|||
|
||||
@section properties Properties
|
||||
|
||||
You can use properties to chance the behavior of you importer. In order to do so, you have to overide BaseImporter::SetupProperties, and specify
|
||||
You can use properties to chance the behavior of you importer. In order to do so, you have to override BaseImporter::SetupProperties, and specify
|
||||
you custom properties in config.h. Just have a look to the other AI_CONFIG_IMPORT_* defines and you will understand, how it works.
|
||||
|
||||
The properties can be set with Importer::SetProperty***() and can be accessed in your SetupProperties function with Importer::GetProperty***(). You can
|
||||
|
|
|
|||
|
|
@ -171,7 +171,7 @@ public:
|
|||
* Any IO handlers set via #SetIOHandler are ignored here.
|
||||
* @note Use aiCopyScene() to get a modifiable copy of a previously
|
||||
* imported scene. */
|
||||
const aiExportDataBlob* ExportToBlob( const aiScene* pScene, const char* pFormatId, unsigned int pPreprocessing = 0u, const ExportProperties* pProperties = NULL);
|
||||
const aiExportDataBlob* ExportToBlob(const aiScene* pScene, const char* pFormatId, unsigned int pPreprocessing = 0u, const ExportProperties* = NULL);
|
||||
const aiExportDataBlob* ExportToBlob( const aiScene* pScene, const std::string& pFormatId, unsigned int pPreprocessing = 0u, const ExportProperties* pProperties = NULL);
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
|
|
|
|||
|
|
@ -903,7 +903,7 @@ enum aiComponent
|
|||
/** @brief Set the tessellation for IFC cylindrical shapes.
|
||||
*
|
||||
* This is used by the IFC importer to determine the tessellation parameter
|
||||
* for cylindrical shapes, i.e. the number of segments used to aproximate a circle.
|
||||
* for cylindrical shapes, i.e. the number of segments used to approximate a circle.
|
||||
* @note The default value is AI_IMPORT_IFC_DEFAULT_CYLINDRICAL_TESSELLATION and the
|
||||
* accepted values are in range [3, 180].
|
||||
* Property type: Integer.
|
||||
|
|
|
|||
|
|
@ -206,7 +206,7 @@ class MeshKey(Structure):
|
|||
("mTime", c_double),
|
||||
|
||||
# Index into the aiMesh::mAnimMeshes array of the
|
||||
# mesh coresponding to the
|
||||
# mesh corresponding to the
|
||||
#aiMeshAnim hosting this
|
||||
# key frame. The referenced anim mesh is evaluated
|
||||
# according to the rules defined in the docs for
|
||||
|
|
|
|||
|
|
@ -895,7 +895,7 @@ class PyAssimp3DViewer:
|
|||
aspect = camera.aspect
|
||||
|
||||
u = 0.1 # unit size (in m)
|
||||
l = 3 * u # lenght of the camera cone
|
||||
l = 3 * u # length of the camera cone
|
||||
f = 3 * u # aperture of the camera cone
|
||||
|
||||
glPushMatrix()
|
||||
|
|
|
|||
|
|
@ -897,7 +897,7 @@ class PyAssimp3DViewer:
|
|||
aspect = camera.aspect
|
||||
|
||||
u = 0.1 # unit size (in m)
|
||||
l = 3 * u # lenght of the camera cone
|
||||
l = 3 * u # length of the camera cone
|
||||
f = 3 * u # aperture of the camera cone
|
||||
|
||||
glPushMatrix()
|
||||
|
|
|
|||
|
|
@ -583,7 +583,7 @@ def clip_matrix(left, right, bottom, top, near, far, perspective=False):
|
|||
orthographic canonical view volume (a box).
|
||||
|
||||
Homogeneous coordinates transformed by the perspective clip matrix
|
||||
need to be dehomogenized (devided by w coordinate).
|
||||
need to be dehomogenized (divided by w coordinate).
|
||||
|
||||
>>> frustrum = numpy.random.rand(6)
|
||||
>>> frustrum[1] += frustrum[0]
|
||||
|
|
|
|||
|
|
@ -51,7 +51,7 @@ import assimp.types;
|
|||
extern ( C ) {
|
||||
/*
|
||||
* These limits are required to match the settings Assimp was compiled
|
||||
* against. Therfore, do not redefine them unless you build the library
|
||||
* against. Therefore, do not redefine them unless you build the library
|
||||
* from source using the same definitions.
|
||||
*/
|
||||
|
||||
|
|
|
|||
|
|
@ -1951,7 +1951,7 @@ error:
|
|||
|
||||
if (NULL == exception)
|
||||
{
|
||||
/* thats really a problem because we cannot throw in this case */
|
||||
/* that's really a problem because we cannot throw in this case */
|
||||
env->FatalError("could not throw java.io.IOException");
|
||||
}
|
||||
gLastErrorString = imp.GetErrorString();
|
||||
|
|
|
|||
|
|
@ -114,7 +114,7 @@
|
|||
%include "interface/IOSystem.i"
|
||||
|
||||
|
||||
// We have to "instanciate" the templates used by the ASSSIMP_*_ARRAY macros
|
||||
// We have to "instantiate" the templates used by the ASSSIMP_*_ARRAY macros
|
||||
// here at the end to avoid running into forward reference issues (SWIG would
|
||||
// spit out the helper functions before the header includes for the element
|
||||
// types otherwise).
|
||||
|
|
|
|||
|
|
@ -641,7 +641,7 @@ static CVReturn MyDisplayLinkCallback(CVDisplayLinkRef displayLink,const CVTimeS
|
|||
{
|
||||
for(MeshHelper* helper in modelMeshes)
|
||||
{
|
||||
// Set up meterial state.
|
||||
// Set up material state.
|
||||
glCallList(helper.displayList);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -179,7 +179,7 @@ extern void exit(int);
|
|||
glutSpecialUpFunc, glutIgnoreKeyRepeat, glutSetKeyRepeat,
|
||||
glutJoystickFunc, glutForceJoystickFunc (NOT FINALIZED!).
|
||||
**/
|
||||
#ifndef GLUT_API_VERSION /* allow this to be overriden */
|
||||
#ifndef GLUT_API_VERSION /* allow this to be overridden */
|
||||
#define GLUT_API_VERSION 3
|
||||
#endif
|
||||
|
||||
|
|
@ -219,7 +219,7 @@ extern void exit(int);
|
|||
|
||||
GLUT_XLIB_IMPLEMENTATION=15 mjk's GLUT 3.7 beta sync'ed with Mesa <GL/glut.h>
|
||||
**/
|
||||
#ifndef GLUT_XLIB_IMPLEMENTATION /* Allow this to be overriden. */
|
||||
#ifndef GLUT_XLIB_IMPLEMENTATION /* Allow this to be overridden. */
|
||||
#define GLUT_XLIB_IMPLEMENTATION 15
|
||||
#endif
|
||||
|
||||
|
|
|
|||
|
|
@ -129,8 +129,10 @@ SET( TEST_SRCS
|
|||
unit/utVersion.cpp
|
||||
unit/utVector3.cpp
|
||||
unit/utXImporterExporter.cpp
|
||||
unit/utX3DImportExport.cpp
|
||||
unit/utD3MFImportExport.cpp
|
||||
unit/utQ3DImportExport.cpp
|
||||
unit/utSTLImportExport.cpp
|
||||
unit/utProfiler.cpp
|
||||
)
|
||||
SET( POST_PROCESSES
|
||||
|
|
|
|||
|
|
@ -32,7 +32,7 @@ L'utilizzo della Creative Commons non influisce su questo diritto.
|
|||
************************************************
|
||||
|
||||
This model is released under Creative Commons Licence, Attribution 2.0
|
||||
for informations see:
|
||||
for information see:
|
||||
http://creativecommons.org
|
||||
http://creativecommons.org/licenses/by/2.0/
|
||||
feel free to use and improve it.
|
||||
|
|
|
|||
|
|
@ -1 +1 @@
|
|||
Simple models for testing importer. No desription because models are simple and created by hands.
|
||||
Simple models for testing importer. No description because models are simple and created by hand.
|
||||
|
|
|
|||
|
|
@ -0,0 +1,18 @@
|
|||
solid testTriangle_1
|
||||
facet normal 0.0 0.0 1.0
|
||||
outer loop
|
||||
vertex 1.0 1.0 0.0
|
||||
vertex -1.0 1.0 0.0
|
||||
vertex 0.0 -1.0 0.0
|
||||
endloop
|
||||
endfacet
|
||||
endsolid
|
||||
solid testTriangle_2
|
||||
facet normal 0.0 0.0 1.0
|
||||
outer loop
|
||||
vertex 3.0 3.0 0.0
|
||||
vertex 2.0 3.0 0.0
|
||||
vertex 0.0 2.0 0.0
|
||||
endloop
|
||||
endfacet
|
||||
endsolid
|
||||
|
|
@ -205,6 +205,7 @@ protected:
|
|||
const aiScene *scene = importer.ReadFile( ASSIMP_TEST_MODELS_DIR "/OBJ/spider.obj", 0 );
|
||||
EXPECT_NE( nullptr, scene );
|
||||
EXPECT_EQ( aiReturn_SUCCESS, exporter.Export( scene, "obj", ASSIMP_TEST_MODELS_DIR "/OBJ/spider_test.obj" ) );
|
||||
EXPECT_EQ( aiReturn_SUCCESS, exporter.Export( scene, "objnomtl", ASSIMP_TEST_MODELS_DIR "/OBJ/spider_nomtl_test.obj" ) );
|
||||
|
||||
return true;
|
||||
}
|
||||
|
|
@ -305,3 +306,38 @@ TEST_F(utObjImportExport, relative_indices_Test) {
|
|||
}
|
||||
|
||||
}
|
||||
|
||||
TEST_F(utObjImportExport, homogeneous_coordinates_Test) {
|
||||
static const std::string ObjModel =
|
||||
"v -0.500000 0.000000 0.400000 0.50000\n"
|
||||
"v -0.500000 0.000000 -0.800000 1.00000\n"
|
||||
"v 0.500000 1.000000 -0.800000 0.5000\n"
|
||||
"f 1 2 3\nB";
|
||||
|
||||
Assimp::Importer myimporter;
|
||||
const aiScene *scene = myimporter.ReadFileFromMemory(ObjModel.c_str(), ObjModel.size(), aiProcess_ValidateDataStructure);
|
||||
EXPECT_NE(nullptr, scene);
|
||||
|
||||
EXPECT_EQ(scene->mNumMeshes, 1);
|
||||
const aiMesh *mesh = scene->mMeshes[0];
|
||||
EXPECT_EQ(mesh->mNumVertices, 3);
|
||||
EXPECT_EQ(mesh->mNumFaces, 1);
|
||||
const aiFace face = mesh->mFaces[0];
|
||||
EXPECT_EQ(face.mNumIndices, 3);
|
||||
const aiVector3D vertice = mesh->mVertices[0];
|
||||
EXPECT_EQ(vertice.x, -1.0f);
|
||||
EXPECT_EQ(vertice.y, 0.0f);
|
||||
EXPECT_EQ(vertice.z, 0.8f);
|
||||
}
|
||||
|
||||
TEST_F(utObjImportExport, 0based_array_Test) {
|
||||
static const std::string ObjModel =
|
||||
"v -0.500000 0.000000 0.400000\n"
|
||||
"v -0.500000 0.000000 -0.800000\n"
|
||||
"v -0.500000 1.000000 -0.800000\n"
|
||||
"f 0 1 2\nB";
|
||||
|
||||
Assimp::Importer myimporter;
|
||||
const aiScene *scene = myimporter.ReadFileFromMemory(ObjModel.c_str(), ObjModel.size(), 0);
|
||||
EXPECT_EQ(nullptr, scene);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -0,0 +1,68 @@
|
|||
/*
|
||||
---------------------------------------------------------------------------
|
||||
Open Asset Import Library (assimp)
|
||||
---------------------------------------------------------------------------
|
||||
|
||||
Copyright (c) 2006-2017, assimp team
|
||||
|
||||
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use of this software in source and binary forms,
|
||||
with or without modification, are permitted provided that the following
|
||||
conditions are met:
|
||||
|
||||
* Redistributions of source code must retain the above
|
||||
copyright notice, this list of conditions and the
|
||||
following disclaimer.
|
||||
|
||||
* Redistributions in binary form must reproduce the above
|
||||
copyright notice, this list of conditions and the
|
||||
following disclaimer in the documentation and/or other
|
||||
materials provided with the distribution.
|
||||
|
||||
* Neither the name of the assimp team, nor the names of its
|
||||
contributors may be used to endorse or promote products
|
||||
derived from this software without specific prior
|
||||
written permission of the assimp team.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
---------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
#include "UnitTestPCH.h"
|
||||
#include "SceneDiffer.h"
|
||||
#include "AbstractImportExportBase.h"
|
||||
|
||||
#include <assimp/Importer.hpp>
|
||||
|
||||
using namespace Assimp;
|
||||
|
||||
class utSTLImporterExporter : public AbstractImportExportBase {
|
||||
public:
|
||||
virtual bool importerTest() {
|
||||
Assimp::Importer importer;
|
||||
const aiScene *scene = importer.ReadFile( ASSIMP_TEST_MODELS_DIR "/STL/Spider_ascii.stl", 0 );
|
||||
return nullptr != scene;
|
||||
}
|
||||
};
|
||||
|
||||
TEST_F( utSTLImporterExporter, importXFromFileTest ) {
|
||||
EXPECT_TRUE( importerTest() );
|
||||
}
|
||||
|
||||
TEST_F( utSTLImporterExporter, test_with_two_solids ) {
|
||||
Assimp::Importer importer;
|
||||
const aiScene *scene = importer.ReadFile( ASSIMP_TEST_MODELS_DIR "/STL/triangle_with_two_solids.stl", 0 );
|
||||
EXPECT_NE( nullptr, scene );
|
||||
}
|
||||
|
|
@ -0,0 +1,62 @@
|
|||
/*
|
||||
---------------------------------------------------------------------------
|
||||
Open Asset Import Library (assimp)
|
||||
---------------------------------------------------------------------------
|
||||
|
||||
Copyright (c) 2006-2017, assimp team
|
||||
|
||||
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use of this software in source and binary forms,
|
||||
with or without modification, are permitted provided that the following
|
||||
conditions are met:
|
||||
|
||||
* Redistributions of source code must retain the above
|
||||
copyright notice, this list of conditions and the
|
||||
following disclaimer.
|
||||
|
||||
* Redistributions in binary form must reproduce the above
|
||||
copyright notice, this list of conditions and the
|
||||
following disclaimer in the documentation and/or other
|
||||
materials provided with the distribution.
|
||||
|
||||
* Neither the name of the assimp team, nor the names of its
|
||||
contributors may be used to endorse or promote products
|
||||
derived from this software without specific prior
|
||||
written permission of the assimp team.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
---------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
#include "UnitTestPCH.h"
|
||||
#include "SceneDiffer.h"
|
||||
#include "AbstractImportExportBase.h"
|
||||
|
||||
#include <assimp/Importer.hpp>
|
||||
|
||||
using namespace Assimp;
|
||||
|
||||
class utX3DImportExport : public AbstractImportExportBase {
|
||||
public:
|
||||
virtual bool importerTest() {
|
||||
Assimp::Importer importer;
|
||||
const aiScene *scene = importer.ReadFile( ASSIMP_TEST_MODELS_DIR "/X3D/ComputerKeyboard.x3d", 0 );
|
||||
return nullptr != scene;
|
||||
}
|
||||
};
|
||||
|
||||
TEST_F( utX3DImportExport, importX3DFromFileTest ) {
|
||||
EXPECT_TRUE( importerTest() );
|
||||
}
|
||||
|
|
@ -561,7 +561,7 @@ void CGLView::Enable_Textures(const bool pEnable)
|
|||
}
|
||||
|
||||
/********************************************************************/
|
||||
/*********************** Overrided functions ************************/
|
||||
/*********************** Override functions ************************/
|
||||
/********************************************************************/
|
||||
|
||||
void CGLView::initializeGL()
|
||||
|
|
|
|||
|
|
@ -249,13 +249,13 @@ private:
|
|||
void Draw_BBox(const SBBox& pBBox);
|
||||
|
||||
/********************************************************************/
|
||||
/*********************** Overrided functions ************************/
|
||||
/*********************** Override functions ************************/
|
||||
/********************************************************************/
|
||||
|
||||
protected:
|
||||
void drawCoordSystem();
|
||||
/// \fn void initializeGL() override
|
||||
/// Overrided function for initialise OpenGL.
|
||||
/// Override function to initialise OpenGL.
|
||||
void initializeGL() override;
|
||||
|
||||
/// \fn void resizeGL(int pWidth, int pHeight) override
|
||||
|
|
@ -264,7 +264,7 @@ protected:
|
|||
void resizeGL(int pWidth, int pHeight) override;
|
||||
|
||||
/// \fn void paintGL() override
|
||||
/// Overrided function for rendering.
|
||||
/// Override function for rendering.
|
||||
void paintGL() override;
|
||||
|
||||
public:
|
||||
|
|
|
|||
|
|
@ -107,7 +107,7 @@ void MainWindow::LogError(const QString& pMessage)
|
|||
}
|
||||
|
||||
/********************************************************************/
|
||||
/*********************** Overrided functions ************************/
|
||||
/*********************** Override functions ************************/
|
||||
/********************************************************************/
|
||||
|
||||
void MainWindow::mousePressEvent(QMouseEvent* pEvent)
|
||||
|
|
|
|||
|
|
@ -65,23 +65,23 @@ private:
|
|||
void LogError(const QString& pMessage);
|
||||
|
||||
/********************************************************************/
|
||||
/*********************** Overrided functions ************************/
|
||||
/*********************** Override functions ************************/
|
||||
/********************************************************************/
|
||||
|
||||
protected:
|
||||
|
||||
/// \fn void mousePressEvent(QMouseEvent* pEvent) override
|
||||
/// Overrided function which handle mouse event "button pressed".
|
||||
/// Override function which handles mouse event "button pressed".
|
||||
/// \param [in] pEvent - pointer to event data.
|
||||
void mousePressEvent(QMouseEvent* pEvent) override;
|
||||
|
||||
/// \fn void mouseMoveEvent(QMouseEvent* pEvent) override
|
||||
/// Overrided function which handle mouse event "move".
|
||||
/// Override function which handles mouse event "move".
|
||||
/// \param [in] pEvent - pointer to event data.
|
||||
void mouseMoveEvent(QMouseEvent* pEvent) override;
|
||||
|
||||
/// \fn void keyPressEvent(QKeyEvent* pEvent) override
|
||||
/// Overrided function which handle key event "key pressed".
|
||||
/// Override function which handles key event "key pressed".
|
||||
/// \param [in] pEvent - pointer to event data.
|
||||
void keyPressEvent(QKeyEvent* pEvent) override;
|
||||
|
||||
|
|
|
|||
|
|
@ -189,7 +189,7 @@ BEGIN
|
|||
LTEXT "Angle limit (in degrees):",IDC_STATIC,13,10,76,8
|
||||
LTEXT "The angle limit defines the maximum angle that may be between two adjacent face normals that they're smoothed together.",IDC_STATIC,13,31,253,19
|
||||
CONTROL "",IDC_STATIC,"Static",SS_ETCHEDHORZ,0,113,278,1
|
||||
LTEXT "This setting is also used during import, but it can be overriden by single model importers to match the original look of a model as closely as possible. Examples include 3DS, ASE and LWO, all of them relying on smoothing groups and their own angle limits. ",IDC_STATIC,13,51,254,33
|
||||
LTEXT "This setting is also used during import, but it can be overridden by single model importers to match the original look of a model as closely as possible. Examples include 3DS, ASE and LWO, all of them relying on smoothing groups and their own angle limits. ",IDC_STATIC,13,51,254,33
|
||||
LTEXT "NOTE: New settings don't take effect immediately, use 'Smooth Normals' or 'Reload' to update the model.",IDC_STATIC,14,118,254,22
|
||||
CONTROL "",IDC_STATIC,"Static",SS_ETCHEDHORZ,0,90,277,1
|
||||
END
|
||||
|
|
|
|||
Loading…
Reference in New Issue