/*! Scans all meshes in the assimp scene and populates nameToBone and jointGroups */ void SLAssimpImporter::findJoints(const aiScene* scene) { for (SLuint i = 0; i < scene->mNumMeshes; i++) { aiMesh* mesh = scene->mMeshes[i]; if(!mesh->HasBones()) continue; logMessage(LV_normal, " Mesh '%s' contains %d joints.\n", mesh->mName.C_Str(), mesh->mNumBones); for (SLuint j = 0; j < mesh->mNumBones; j++) { SLstring name = mesh->mBones[j]->mName.C_Str(); std::map<SLstring, SLMat4f>::iterator it = _jointOffsets.find(name); if(it != _jointOffsets.end()) continue; // add the offset matrix to our offset matrix map SLMat4f offsetMat; memcpy(&offsetMat, &mesh->mBones[j]->mOffsetMatrix, sizeof(SLMat4f)); offsetMat.transpose(); _jointOffsets[name] = offsetMat; logMessage(LV_detailed, " Bone '%s' found.\n", name.c_str()); } } }
/*! SLFileSystem::fileExists returns true if the file exists. This code works only on windows because the file check is done case insensitive. */ SLbool SLFileSystem::fileExists(SLstring& pathfilename) { struct stat stFileInfo; if (stat(pathfilename.c_str(), &stFileInfo) == 0) return true; return false; }
//----------------------------------------------------------------------------- //! Scans the assimp scene graph structure and populates nameToNode void SLAssimpImporter::findNodes(aiNode* node, SLstring padding, SLbool lastChild) { SLstring name = node->mName.C_Str(); /* /// @todo we can't allow for duplicate node names, ever at the moment. The 'solution' below /// only hides the problem and moves it to a different part. // rename duplicate node names SLstring renamedString; if (_nodeMap.find(name) != _nodeMap.end()) { SLint index = 0; std::ostringstream ss; SLstring lastMatch = name; while (_nodeMap.find(lastMatch) != _nodeMap.end()) { ss.str(SLstring()); ss.clear(); ss << name << "_" << std::setw( 2 ) << std::setfill( '0' ) << index; lastMatch = ss.str(); index++; } ss.str(SLstring()); ss.clear(); ss << "(renamed from '" << name << "')"; renamedString = ss.str(); name = lastMatch; }*/ // this should not happen assert(_nodeMap.find(name) == _nodeMap.end() && "Duplicated node name found!"); _nodeMap[name] = node; //logMessage(LV_Detailed, "%s |\n", padding.c_str()); logMessage(LV_detailed, "%s |-[%s] (%d children, %d meshes)\n", padding.c_str(), name.c_str(), node->mNumChildren, node->mNumMeshes); if (lastChild) padding += " "; else padding += " |"; for (SLuint i = 0; i < node->mNumChildren; i++) { findNodes(node->mChildren[i], padding, (i == node->mNumChildren-1)); } }
//----------------------------------------------------------------------------- //! SLGLShader::load loads a shader file into string _shaderSource void SLGLShader::load(SLstring filename) { fstream shaderFile(filename.c_str(), ios::in); if (!shaderFile.is_open()) { SL_LOG("File open failed: %s\n", filename.c_str()); exit(1); } std::stringstream buffer; buffer << shaderFile.rdbuf(); // remove comments because some stupid ARM compiler can't handle GLSL comments #ifdef SL_OS_MACIOS _code = buffer.str(); #else _code = SLUtils::removeComments(buffer.str()); #endif }
//----------------------------------------------------------------------------- //! SLGLShader::createAndCompile creates & compiles the OpenGL shader object SLbool SLGLShader::createAndCompile() { // delete if object already exits if (_objectGL) glDeleteShader(_objectGL); if (_code!="") { switch (_type) { case VertexShader: _objectGL = glCreateShader(GL_VERTEX_SHADER); break; case FragmentShader: _objectGL = glCreateShader(GL_FRAGMENT_SHADER); break; default: SL_EXIT_MSG("SLGLShader::load: Unknown shader type."); } //SLstring verGLSL = SLGLState::getInstance()->glSLVersionNO(); //SLstring srcVersion = "#version " + verGLSL + "\n"; //if (verGLSL > "120") //{ if (_type == VertexShader) // { SLUtils::replaceString(_code, "attribute", "in"); // SLUtils::replaceString(_code, "varying", "out"); // } // if (_type == FragmentShader) // { SLUtils::replaceString(_code, "varying", "in"); // } //} //SLstring scrComplete = srcVersion + _code; SLstring scrComplete = _code; const char* src = scrComplete.c_str(); glShaderSource(_objectGL, 1, &src, 0); glCompileShader(_objectGL); // Check compiler log SLint compileSuccess = 0; glGetShaderiv(_objectGL, GL_COMPILE_STATUS, &compileSuccess); if (compileSuccess == GL_FALSE) { GLchar log[256]; glGetShaderInfoLog(_objectGL, sizeof(log), 0, &log[0]); SL_LOG("*** COMPILER ERROR ***\n"); SL_LOG("Source file: %s\n", _file.c_str()); SL_LOG("%s\n\n", log); return false; } return true; } else SL_WARN_MSG("SLGLShader::createAndCompile: Nothing to compile!"); return false; }
/*! SLAssimpImporter::checkFilePath tries to build the full absolut texture file path. Some file formats have absolute path stored, some have relative paths. 1st attempt: modelPath + aiTexFile 2nd attempt: aiTexFile 3rd attempt: modelPath + getFileName(aiTexFile) If a model contains absolute path it is best to put all texture files beside the model file in the same folder. */ SLstring SLAssimpImporter::checkFilePath(SLstring modelPath, SLstring aiTexFile) { // Check path & file combination SLstring pathFile = modelPath + aiTexFile; if (SLFileSystem::fileExists(pathFile)) return pathFile; // Check file alone if (SLFileSystem::fileExists(aiTexFile)) return aiTexFile; // Check path & file combination pathFile = modelPath + SLUtils::getFileName(aiTexFile); if (SLFileSystem::fileExists(pathFile)) return pathFile; SLstring msg = "SLAssimpImporter: Texture file not found: \n" + aiTexFile + "\non model path: " + modelPath + "\n"; SL_WARN_MSG(msg.c_str()); // Return path for texture not found image; return SLGLTexture::defaultPath + "TexNotFound.png"; }
/*! SLAssimpImporter::loadAnimation loads the scene graph node tree recursively. */ SLAnimation* SLAssimpImporter::loadAnimation(aiAnimation* anim) { int animCount = 0; if (_skeleton) animCount = _skeleton->numAnimations(); ostringstream oss; oss << "unnamed_anim_" << animCount; SLstring animName = oss.str(); SLfloat animTicksPerSec = (anim->mTicksPerSecond == 0) ? 30.0f : (SLfloat)anim->mTicksPerSecond; SLfloat animDuration = (SLfloat)anim->mDuration / animTicksPerSec; if (anim->mName.length > 0) animName = anim->mName.C_Str(); // log logMessage(LV_minimal, "\nLoading animation %s\n", animName.c_str()); logMessage(LV_normal, " Duration(seconds): %f \n", animDuration); logMessage(LV_normal, " Duration(ticks): %f \n", anim->mDuration); logMessage(LV_normal, " Ticks per second: %f \n", animTicksPerSec); logMessage(LV_normal, " Num channels: %d\n", anim->mNumChannels); // exit if we didn't load a skeleton but have animations for one if (_skinnedMeshes.size() > 0) assert(_skeleton != nullptr && "The skeleton wasn't impoted correctly."); // create the animation SLAnimation* result; if (_skeleton) result = _skeleton->createAnimation(animName, animDuration); else { result = SLScene::current->animManager().createNodeAnimation(animName, animDuration); _nodeAnimations.push_back(result); } SLbool isSkeletonAnim = false; for (SLuint i = 0; i < anim->mNumChannels; i++) { aiNodeAnim* channel = anim->mChannels[i]; // find the node that is animated by this channel SLstring nodeName = channel->mNodeName.C_Str(); SLNode* affectedNode = _sceneRoot->find<SLNode>(nodeName); SLuint id = 0; SLbool isJointNode = (affectedNode == nullptr); // @todo: this is currently a work around but it can happen that we receive normal node animationtracks and joint animationtracks // we don't allow node animation tracks in a skeleton animation, so we should split an animation in two seperate // animations if this happens. for now we just ignore node animation tracks if we already have joint tracks // ofc this will crash if the first track is a node anim but its just temporary if (!isJointNode && isSkeletonAnim) continue; // is there a skeleton and is this animation channel not affecting a normal node? if (_skeletonRoot && !affectedNode) { isSkeletonAnim = true; SLJoint* affectedJoint = _skeleton->getJoint(nodeName); if (affectedJoint == nullptr) break; id = affectedJoint->id(); // @todo warn if we find an animation with some node channels and some joint channels // this shouldn't happen! /// @todo [high priority!] Address the problem of some bones not containing an animation channel /// when importing. Current workaround is to set their reset position to their bind pose. /// This will however fail if we have multiple animations affecting a single model and fading /// some of them out or in. This will require us to provide animations that have a channel /// for all bones even if they're just positional. // What does this next line do? // // The testimportfile we used (Astroboy.dae) has the following properties: // > It has joints in the skeleton that aren't animated by any channel. // > The joints need a reset position of (0, 0, 0) to work properly // because the joint position is contained in a single keyframe for every joint // // Since some of the joints don't have a channel that animates them, they also lack // the joint position that the other joints get from their animation channel. // So we need to set the initial state for all joints that have a channel // to identity. // All joints that arent in a channel will receive their local joint bind pose as // reset position. // // The problem stems from the design desicion to reset a whole skeleton before applying // animations to it. If we were to reset each joint just before applying a channel to it // we wouldn't have this problem. But we coulnd't blend animations as easily. // SLMat4f prevOM = affectedJoint->om(); affectedJoint->om(SLMat4f()); affectedJoint->setInitialState(); affectedJoint->om(prevOM); } // log logMessage(LV_normal, "\n Channel %d %s", i, (isJointNode) ? "(joint animation)\n" : "\n"); logMessage(LV_normal, " Affected node: %s\n", channel->mNodeName.C_Str()); logMessage(LV_detailed, " Num position keys: %d\n", channel->mNumPositionKeys); logMessage(LV_detailed, " Num rotation keys: %d\n", channel->mNumRotationKeys); logMessage(LV_detailed, " Num scaling keys: %d\n", channel->mNumScalingKeys); // joint animation channels should receive the correct node id, normal node animations just get 0 SLNodeAnimTrack* track = result->createNodeAnimationTrack(id); // this is a node animation only, so we add a reference to the affected node to the track if (affectedNode && !isSkeletonAnim) { track->animatedNode(affectedNode); } KeyframeMap keyframes; // add position keys for (SLuint i = 0; i < channel->mNumPositionKeys; i++) { SLfloat time = (SLfloat)channel->mPositionKeys[i].mTime; keyframes[time] = SLImportKeyframe(&channel->mPositionKeys[i], nullptr, nullptr); } // add rotation keys for (SLuint i = 0; i < channel->mNumRotationKeys; i++) { SLfloat time = (SLfloat)channel->mRotationKeys[i].mTime; if (keyframes.find(time) == keyframes.end()) keyframes[time] = SLImportKeyframe(nullptr, &channel->mRotationKeys[i], nullptr); else { // @todo this shouldn't abort but just throw an exception assert(keyframes[time].rotation == nullptr && "There were two rotation keys assigned to the same timestamp."); keyframes[time].rotation = &channel->mRotationKeys[i]; } } // add scaleing keys for (SLuint i = 0; i < channel->mNumScalingKeys; i++) { SLfloat time = (SLfloat)channel->mScalingKeys[i].mTime; if (keyframes.find(time) == keyframes.end()) keyframes[time] = SLImportKeyframe(nullptr, nullptr, &channel->mScalingKeys[i]); else { // @todo this shouldn't abort but just throw an exception assert(keyframes[time].scaling == nullptr && "There were two scaling keys assigned to the same timestamp."); keyframes[time].scaling = &channel->mScalingKeys[i]; } } logMessage(LV_normal, " Found %d distinct keyframe timestamp(s).\n", keyframes.size()); for (auto it : keyframes) { SLTransformKeyframe* kf = track->createNodeKeyframe(it.first); kf->translation(getTranslation(it.first, keyframes)); kf->rotation(getRotation(it.first, keyframes)); kf->scale(getScaling(it.first, keyframes)); // log logMessage(LV_detailed, "\n Generating keyframe at time '%.2f'\n", it.first); logMessage(LV_detailed, " Translation: (%.2f, %.2f, %.2f) %s\n", kf->translation().x, kf->translation().y, kf->translation().z, (it.second.translation != nullptr) ? "imported" : "generated"); logMessage(LV_detailed, " Rotation: (%.2f, %.2f, %.2f, %.2f) %s\n", kf->rotation().x(), kf->rotation().y(), kf->rotation().z(), kf->rotation().w(), (it.second.rotation != nullptr) ? "imported" : "generated"); logMessage(LV_detailed, " Scale: (%.2f, %.2f, %.2f) %s\n", kf->scale().x, kf->scale().y, kf->scale().z, (it.second.scaling != nullptr) ? "imported" : "generated"); } } return result; }
/*! SLAssimpImporter::loadMaterial loads the AssImp material an returns the SLMaterial. The materials and textures are added to the SLScene material and texture vectors. */ SLMaterial* SLAssimpImporter::loadMaterial(SLint index, aiMaterial *material, SLstring modelPath) { // Get the materials name aiString matName; material->Get(AI_MATKEY_NAME, matName); SLstring name = matName.data; if (name.empty()) name = "Import Material"; // Create SLMaterial instance. It is also added to the SLScene::_materials vector SLMaterial* mat = new SLMaterial(name.c_str()); // set the texture types to import into our material const SLint textureCount = 4; aiTextureType textureTypes[textureCount]; textureTypes[0] = aiTextureType_DIFFUSE; textureTypes[1] = aiTextureType_NORMALS; textureTypes[2] = aiTextureType_SPECULAR; textureTypes[3] = aiTextureType_HEIGHT; // load all the textures for this material and add it to the material vector for(SLint i = 0; i < textureCount; ++i) { if(material->GetTextureCount(textureTypes[i]) > 0) { aiString aipath; material->GetTexture(textureTypes[i], 0, &aipath, nullptr, nullptr, nullptr, nullptr, nullptr); SLTextureType texType = textureTypes[i]==aiTextureType_DIFFUSE ? TT_color : textureTypes[i]==aiTextureType_NORMALS ? TT_normal : textureTypes[i]==aiTextureType_SPECULAR ? TT_gloss : textureTypes[i]==aiTextureType_HEIGHT ? TT_height : TT_unknown; SLstring texFile = checkFilePath(modelPath, aipath.data); SLGLTexture* tex = loadTexture(texFile, texType); mat->textures().push_back(tex); } } // get color data aiColor3D ambient, diffuse, specular, emissive; SLfloat shininess, refracti, reflectivity, opacity; material->Get(AI_MATKEY_COLOR_AMBIENT, ambient); material->Get(AI_MATKEY_COLOR_DIFFUSE, diffuse); material->Get(AI_MATKEY_COLOR_SPECULAR, specular); material->Get(AI_MATKEY_COLOR_EMISSIVE, emissive); material->Get(AI_MATKEY_SHININESS, shininess); material->Get(AI_MATKEY_REFRACTI, refracti); material->Get(AI_MATKEY_REFLECTIVITY, reflectivity); material->Get(AI_MATKEY_OPACITY, opacity); // increase shininess if specular color is not low. // The material will otherwise be to bright if (specular.r > 0.5f && specular.g > 0.5f && specular.b > 0.5f && shininess < 0.01f) shininess = 10.0f; // set color data mat->ambient(SLCol4f(ambient.r, ambient.g, ambient.b)); mat->diffuse(SLCol4f(diffuse.r, diffuse.g, diffuse.b)); mat->specular(SLCol4f(specular.r, specular.g, specular.b)); mat->emission(SLCol4f(emissive.r, emissive.g, emissive.b)); mat->shininess(shininess); //mat->kr(reflectivity); //mat->kt(1.0f-opacity); //mat->kn(refracti); return mat; }
/*! Loads the scene from a file and creates materials with textures, the meshes and the nodes for the scene graph. Materials, textures and meshes are added to the according vectors of SLScene for later deallocation. */ SLNode* SLAssimpImporter::load(SLstring file, //!< File with path or on default path SLbool loadMeshesOnly, //!< Only load nodes with meshes SLuint flags) //!< Import flags (see assimp/postprocess.h) { // clear the intermediate data clear(); // Check existance if (!SLFileSystem::fileExists(file)) { file = defaultPath + file; if (!SLFileSystem::fileExists(file)) { SLstring msg = "SLAssimpImporter: File not found: " + file + "\n"; SL_WARN_MSG(msg.c_str()); return nullptr; } } // Import file with assimp importer Assimp::Importer ai; const aiScene* scene = ai.ReadFile(file.c_str(), (SLuint)flags); if (!scene) { SLstring msg = "Failed to load file: " + file + "\n" + ai.GetErrorString() + "\n"; SL_WARN_MSG(msg.c_str()); return nullptr; } // initial scan of the scene performInitialScan(scene); // load skeleton loadSkeleton(nullptr, _skeletonRoot); // load materials SLstring modelPath = SLUtils::getPath(file); SLVMaterial materials; for(SLint i = 0; i < (SLint)scene->mNumMaterials; i++) materials.push_back(loadMaterial(i, scene->mMaterials[i], modelPath)); // load meshes & set their material std::map<int, SLMesh*> meshMap; // map from the ai index to our mesh for(SLint i = 0; i < (SLint)scene->mNumMeshes; i++) { SLMesh* mesh = loadMesh(scene->mMeshes[i]); if (mesh != 0) { mesh->mat = materials[scene->mMeshes[i]->mMaterialIndex]; _meshes.push_back(mesh); meshMap[i] = mesh; } else SL_LOG("SLAsssimpImporter::load failed: %s\nin path: %s\n", file.c_str(), modelPath.c_str()); } // load the scene nodes recursively _sceneRoot = loadNodesRec(nullptr, scene->mRootNode, meshMap, loadMeshesOnly); // load animations vector<SLAnimation*> animations; for (SLint i = 0; i < (SLint)scene->mNumAnimations; i++) animations.push_back(loadAnimation(scene->mAnimations[i])); logMessage(LV_minimal, "\n---------------------------\n\n"); return _sceneRoot; }