//-----------------------------------------------------------------------------
//! 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";
}
/*! 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;
}