////////////////////////////////////////////////////////////
/// 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);
}
}
