//////////////////////////////////////////////////////////// /// Construit le shader à partir des 2 fichiers /// <name>.vert /// <name>.frag /// /// \param shaderFile_ : fichier vertex shader : <name>.vertexshader /// //////////////////////////////////////////////////////////// GLShader::GLShader(IFile *pFile_) { std::string fragmentFile = pFile_->Filename(); size_t pos = fragmentFile.find(IRenderer::Get().GetShaderFileExtension()); if (pos != std::string::npos) { fragmentFile = fragmentFile.substr(0, pos) + ".frag"; IFile *pFragFile = MediaManager::Instance().FindMedia(fragmentFile, false); if (pFragFile == nullptr) { throw CLoadingFailed(fragmentFile, "GLShader() : Can't find the fragment shader (maybe add a reference to the right directory ?)"); } if (pFragFile->Exists() == false) { throw CLoadingFailed(fragmentFile, "GLShader() : The fragment shader doesn't exist"); } m_ProgramID = LoadShaderFrombuffer(pFile_->GetBuffer(), pFragFile->GetBuffer()); DELETE_AO pFragFile; } else { CA_ERROR("GLShader() : Can't find the character '%s' in the filename '%s' to get the fragment shader.", IRenderer::Get().GetShaderFileExtension(), pFile_->Filename().c_str()); } }
void HandleXmlError(XMLError error_, const std::string& Filename = "") { if (error_ != XML_SUCCESS) { std::string msg = "tinyxml2 error : "; switch(error_) { case XML_NO_ATTRIBUTE: msg+= "XML_NO_ATTRIBUTE"; break; case XML_WRONG_ATTRIBUTE_TYPE: msg+= "XML_WRONG_ATTRIBUTE_TYPE"; break; case XML_ERROR_FILE_NOT_FOUND: msg+= "XML_ERROR_FILE_NOT_FOUND"; break; case XML_ERROR_FILE_COULD_NOT_BE_OPENED: msg+= "XML_ERROR_FILE_COULD_NOT_BE_OPENED"; break; case XML_ERROR_FILE_READ_ERROR: msg+= "XML_ERROR_FILE_READ_ERROR"; break; case XML_ERROR_ELEMENT_MISMATCH: msg+= "XML_ERROR_ELEMENT_MISMATCH"; break; case XML_ERROR_PARSING_ELEMENT: msg+= "XML_ERROR_PARSING_ELEMENT"; break; case XML_ERROR_PARSING_ATTRIBUTE: msg+= "XML_ERROR_PARSING_ATTRIBUTE"; break; case XML_ERROR_IDENTIFYING_TAG: msg+= "XML_ERROR_IDENTIFYING_TAG"; break; case XML_ERROR_PARSING_TEXT: msg+= "XML_ERROR_PARSING_TEXT"; break; case XML_ERROR_PARSING_CDATA: msg+= "XML_ERROR_PARSING_CDATA"; break; case XML_ERROR_PARSING_COMMENT: msg+= "XML_ERROR_PARSING_COMMENT"; break; case XML_ERROR_PARSING_DECLARATION: msg+= "XML_ERROR_PARSING_DECLARATION"; break; case XML_ERROR_PARSING_UNKNOWN: msg+= "XML_ERROR_PARSING_UNKNOWN"; break; case XML_ERROR_EMPTY_DOCUMENT: msg+= "XML_ERROR_EMPTY_DOCUMENT"; break; case XML_ERROR_MISMATCHED_ELEMENT: msg+= "XML_ERROR_MISMATCHED_ELEMENT"; break; case XML_ERROR_PARSING: msg+= "XML_ERROR_PARSING"; break; case XML_CAN_NOT_CONVERT_TEXT: msg+= "XML_CAN_NOT_CONVERT_TEXT"; break; case XML_NO_TEXT_NODE: msg+= "XML_NO_TEXT_NODE"; break; default: msg+= "unknown"; break; } throw NEW_AO CLoadingFailed(Filename, msg); } }
const std::string ShaderCompiler::LoadFile(const std::string& path) { std::ifstream file(path.c_str(), std::ios::in); // Check if the file is open if (!file) // if not { throw CLoadingFailed(path, "enable to load the source shader"); } std::stringstream buffer; // read all the file buffer << file.rdbuf(); //Close the file file.close(); // retrun the buffer return buffer.str(); }
bool CShaderLoader::loadFromFile(const CString& fileName) { m_fileName = fileName; // Chargement et compilation du shader CGprogram program; try { program = cgCreateProgramFromFile( m_context, CG_SOURCE, m_fileName.toCharArray(), Game::renderer->getShaderProfile(m_type), "main", const_cast<const char **>(Game::renderer->getShaderOptions(m_type))); } catch (IException& e) { throw CLoadingFailed(m_fileName.toCharArray(), e.what() + std::string("\n") + cgGetLastListing(m_context)); } m_shader = Game::renderer->createShader(program, m_type); return true; }
///////////////////////////////////////////////////////////// /// Cherche un fichier dans les r�pertoires de recherche /// /// \param Filename : Chemin du media /// /// \return Chemin complet du media, exception si non trouv� /// //////////////////////////////////////////////////////////// CFile CMediaManager::FindMedia(const CFile& Filename) const { // Parcours de la liste des chemins de recherche for (std::set<std::string>::const_iterator i = m_Paths.begin(); i != m_Paths.end(); ++i) { CFile RetFile = *i + Filename.Fullname(); if (RetFile.Exists()) return RetFile; } //// DEBUG Logger::Log() << "===== PATH : \n"; for (std::set<std::string>::const_iterator i = m_Paths.begin(); i != m_Paths.end(); ++i) { Logger::Log() << " * " << *i + Filename.Fullname() << "\n"; } // Si le fichier est introuvable, on lance une exception throw CLoadingFailed(Filename.Fullname(), "Fichier introuvable dans les repertoires de recherche"); }
Shader* ShadersLoader::LoadFromFile(const std::string& Filename) { TiXmlDocument doc(Filename.c_str()); if (!doc.LoadFile()) { Logger::Log() << "[ERROR] TinyXML error : " << doc.ErrorDesc() << "\n"; throw CLoadingFailed(Filename, "unable to load xml with TinyXML"); } // Get the root TiXmlHandle hdl(&doc); TiXmlElement *root = hdl.FirstChild("Shader").Element(); // Problem to find the root if (!root) { throw CLoadingFailed(Filename, "unable to find root (Shader)"); } // Get the shader name and display it std::string name; std::string shaderTypeName; TinyXMLGetAttributeValue<std::string>(root, "name", &name); TinyXMLGetAttributeValue<std::string>(root, "type", &shaderTypeName); Logger::Log() << "[INFO] Load shader : " << name << " ( " << shaderTypeName << " ) ... \n"; ShaderType shaderType; if (shaderTypeName == "Basic") shaderType = BASIC_SHADER; else if (shaderTypeName == "GBuffer") shaderType = GBUFFER_SHADER; else throw CException("unknow shader type"); // Load the shader compiler config ShaderCompilerConfig config = LoadShaderCompilerConfig(root); // Get the 2 files name // * Vertex shader TiXmlElement *shadername = root->FirstChildElement("VertexShader"); if (!shadername) { throw CLoadingFailed(Filename, "unable to find VertexShader (Shader)"); } std::string vertexShadername = std::string( shadername->Attribute("filename")); Logger::Log() << " * Vertex shader : " << vertexShadername << "\n"; // * Fragment shader shadername = root->FirstChildElement("FragmentShader"); if (!shadername) { throw CLoadingFailed(Filename, "unable to find VertexShader (Shader)"); } std::string fragmentShadername = std::string( shadername->Attribute("filename")); Logger::Log() << " * Fragment shader : " << fragmentShadername << "\n"; /* * Find full path */ vertexShadername = CMediaManager::Instance().FindMedia(vertexShadername).Fullname(); fragmentShadername = CMediaManager::Instance().FindMedia(fragmentShadername).Fullname(); Shader* shader = 0; shadername = root->FirstChildElement("GeometryShader"); if (shadername != 0) { std::string geometryShadername = std::string( shadername->Attribute("filename")); Logger::Log() << " * Geometry shader : " << geometryShadername << "\n"; geometryShadername = CMediaManager::Instance().FindMedia( geometryShadername).Fullname(); std::string in, out; TinyXMLGetAttributeValue(shadername, "in", &in); TinyXMLGetAttributeValue(shadername, "out", &out); shader = CShaderManager::Instance().loadfromFile( vertexShadername.c_str(), fragmentShadername.c_str(), geometryShadername.c_str(), shaderType, config); shader->SetGeometryShaderParameters(OpenGLEnumFromString(in), OpenGLEnumFromString(out)); } else { Logger::Log() << " * No Geometry shader\n"; // Shader creation .... shader = CShaderManager::Instance().loadfromFile( vertexShadername.c_str(), fragmentShadername.c_str(), shaderType, config); } shader->Link(); // Attrib blinding ... LoadShaderAttributs(shader, root); // Textures uniform LoadShaderTextures(shader, root); // Matrix uniform LoadShaderMatrix(shader, root); // FBO LoadShaderFBO(shader, root); // Materials LoadMaterials(shader, root); // Update all bindings // * Warning : Need to relink after shader->UpdateAll(); return shader; }
// Load the config file // caution: Need the relative path void CSettingsManager::LoadFile(const std::string& path) { //XXX: Proteger les appels TinyXML avec le Helper TiXmlDocument doc(path.c_str()); if (!doc.LoadFile()) { Logger::Log() << "[ERROR] TinyXML error : " << doc.ErrorDesc() << "\n"; throw CLoadingFailed(path, "unable to load xml with TinyXML"); } // Get the root TiXmlHandle hdl(&doc); TiXmlElement *rootConfig = hdl.FirstChild("Config").Element(); if (!rootConfig) { throw CLoadingFailed(path, "unable to find Config node in the XML file"); } ///////////////// // Extract Data ///////////////// // * Logger TiXmlElement* nodeLogger = rootConfig->FirstChildElement("Logger"); if (nodeLogger) { std::string loggerType = std::string(nodeLogger->Attribute("type")); if (loggerType == "File") { std::string fileLog = std::string(nodeLogger->Attribute("file")); Logger::SetLogger(new LoggerFile(fileLog)); Logger::Log() << "[INFO] SettingsManager : Log to a file : " << fileLog << "\n"; } else if (loggerType == "Debug") { Logger::SetLogger(new LoggerDebug); } else { throw CLoadingFailed(path, "unknow logger type in the XML file"); } } // * Resolution TiXmlElement* nodeResolution = rootConfig->FirstChildElement("Resolution"); if (nodeResolution) { int x, y; nodeResolution->Attribute("x", &x); nodeResolution->Attribute("y", &y); Logger::Log() << "[INFO] SettingsManager : Resolution = " << x << "x" << y << "\n"; SetSizeRenderingWindow(Math::TVector2I(x, y)); } // * Data TiXmlElement* nodeData = rootConfig->FirstChildElement("Data"); if (nodeData) { std::string rootDataDir = std::string(nodeData->Attribute("rootDir")); Logger::Log() << "[INFO] SettingsManager : Root data dir : " << rootDataDir << "\n"; m_RootDataDir = rootDataDir; CMediaManager::Instance().AddSearchPathAndChilds(rootDataDir); } // * Projection TiXmlElement* nodeProjection = rootConfig->FirstChildElement("Projection"); if (nodeProjection) { float fov, near, far; TinyXMLGetAttributeValue(nodeProjection, "fov", &fov); TinyXMLGetAttributeValue(nodeProjection, "near", &near); TinyXMLGetAttributeValue(nodeProjection, "far", &far); Logger::Log() << "[INFO] SettingsManager : Projection Settings : \n"; Logger::Log() << " * FOV : " << fov << "\n"; Logger::Log() << " * Near : " << near << "\n"; Logger::Log() << " * Far : " << far << "\n"; SetProjection(near, far, fov); } }