bool Shader::compile() {
CORRADE_ASSERT(sources.size() > 1, "Shader::compile(): no files added", false);
/* Array of source string pointers and their lengths */
/** @todo Use `Containers::ArrayTuple` to avoid one allocation if it ever
gets to be implemented (we need properly aligned memory too) */
Containers::Array<const GLchar*> pointers(sources.size());
Containers::Array<GLint> sizes(sources.size());
for(std::size_t i = 0; i != sources.size(); ++i) {
pointers[i] = static_cast<const GLchar*>(sources[i].data());
sizes[i] = sources[i].size();
}
/* Create shader and set its source */
glShaderSource(_id, sources.size(), pointers, sizes);
/* Compile shader */
glCompileShader(_id);
/* Check compilation status */
GLint success, logLength;
glGetShaderiv(_id, GL_COMPILE_STATUS, &success);
glGetShaderiv(_id, GL_INFO_LOG_LENGTH, &logLength);
/* Error or warning message. The string is returned null-terminated, scrap
the \0 at the end afterwards */
std::string message(logLength, '\0');
if(message.size() > 1)
glGetShaderInfoLog(_id, message.size(), nullptr, &message[0]);
message.resize(std::max(logLength, 1)-1);
/* Show error log */
if(!success) {
Error out;
out.setFlag(Debug::NewLineAtTheEnd, false);
out.setFlag(Debug::SpaceAfterEachValue, false);
out << "Shader: " << shaderName(_type)
<< " shader failed to compile with the following message:\n"
<< message;
/* Or just message, if any */
} else if(!message.empty()) {
Error out;
out.setFlag(Debug::NewLineAtTheEnd, false);
out.setFlag(Debug::SpaceAfterEachValue, false);
out << "Shader: " << shaderName(_type)
<< " shader was successfully compiled with the following message:\n"
<< message;
}
return success;
}
bool Shader::compile() {
CORRADE_ASSERT(sources.size() > 1, "Shader::compile(): no files added", false);
/* Array of sources */
const GLchar** _sources = new const GLchar*[sources.size()];
for(std::size_t i = 0; i != sources.size(); ++i)
_sources[i] = static_cast<const GLchar*>(sources[i].c_str());
/* Create shader and set its source */
glShaderSource(_id, sources.size(), _sources, nullptr);
/* Compile shader */
glCompileShader(_id);
delete _sources;
/* Check compilation status */
GLint success, logLength;
glGetShaderiv(_id, GL_COMPILE_STATUS, &success);
glGetShaderiv(_id, GL_INFO_LOG_LENGTH, &logLength);
/* Error or warning message. The string is returned null-terminated, scrap
the \0 at the end afterwards */
std::string message(logLength, '\0');
if(message.size() > 1)
glGetShaderInfoLog(_id, message.size(), nullptr, &message[0]);
message.resize(std::max(logLength, 1)-1);
/* Show error log */
if(!success) {
Error out;
out.setFlag(Debug::NewLineAtTheEnd, false);
out.setFlag(Debug::SpaceAfterEachValue, false);
out << "Shader: " << shaderName(_type)
<< " shader failed to compile with the following message:\n"
<< message;
/* Or just message, if any */
} else if(!message.empty()) {
Error out;
out.setFlag(Debug::NewLineAtTheEnd, false);
out.setFlag(Debug::SpaceAfterEachValue, false);
out << "Shader: " << shaderName(_type)
<< " shader was successfully compiled with the following message:\n"
<< message;
}
return success;
}
// ---------------------------------------------------------------------
void MaterialService::createJorgeMaterial(const Ogre::String& resourceGroup) {
std::string shaderName("@template0");
if (!MaterialManager::getSingleton().resourceExists(shaderName)) {
MaterialPtr shadMat = MaterialManager::getSingleton().create(shaderName, resourceGroup);
shadMat->setReceiveShadows(true);
Pass *shadPass = shadMat->getTechnique(0)->getPass(0);
shadPass->setAmbient(0.5, 0.5, 0.5);
shadPass->setDiffuse(1, 1, 1, 1);
shadPass->setSpecular(1, 1, 1, 1);
// Texture unit state for the main texture...
// jorge.png is compiled-in - see the RenderService::prepareHardcodedMedia
TextureUnitState* tus = shadPass->createTextureUnitState("jorge.png");
// Set replace on all first layer textures for now
tus->setTextureAddressingMode(TextureUnitState::TAM_WRAP);
tus->setTextureCoordSet(0);
tus->setTextureFiltering(TFO_BILINEAR);
tus->setTextureUScale(1.0f);
tus->setTextureVScale(1.0f);
// No dynamic lighting
shadMat->setLightingEnabled(false);
shadMat->load();
addWorldMaterialTemplate(0, shadMat); // fixed at slot 0
}
}
// ---------------------------------------------------------------------
void MaterialService::createSkyHackMaterial(const Ogre::String& resourceGroup) {
// First, we'll create the sky materials, named SkyShader and WaterShader
// The sky material does basically only write the Z value (no color write), and should be rendered prior to any other material
// This is because we render sky(box/sphere/dome/plane) first, and we want it to be visible through the faces textured by this material
std::string shaderName("@template249");
if (!MaterialManager::getSingleton().resourceExists(shaderName)) {
MaterialPtr SkyShader = MaterialManager::getSingleton().create(shaderName, resourceGroup);
Pass *shadPass = SkyShader->getTechnique(0)->getPass(0);
// No texture for this pass
// Set the pass to be totally transparent - no color writing
shadPass->setColourWriteEnabled(false);
// Set culling mode to none
shadPass->setCullingMode(CULL_NONE);
// No dynamic lighting (Sky!)
shadPass->setLightingEnabled(false);
// ---- End of skyhack ----
addWorldMaterialTemplate(SKY_TEXTURE_ID, SkyShader); // fixed at slot 249
}
}
void GLRenderer::render(const Camera view) {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
Matrix<4, float> p_matrix = view.getProjectionMatrix();
Matrix<4, float> v_matrix = view.getViewMatrix();
while (!m_jobQueue.empty()) {
RenderObject job(m_jobQueue.front());
int modelName(job.getModelID());
string shaderName(job.getShaderName());
enableShaderProgram(shaderName);
string textureName(job.getTextureName());
if (textureName.length() > 0) {
enableTexture(textureName);
}
Matrix<4, float> m_matrix = job.getModelMatrix();
setUniform<Matrix<4, float>>(shaderName, "m_matrix", m_matrix);
setUniform<Matrix<4, float>>(shaderName, "v_matrix", v_matrix);
setUniform<Matrix<4, float>>(shaderName, "p_matrix", p_matrix);
setUniform<Vector<3, float>>(shaderName, "ambientLightColour", m_ambientLightSource.getColour());
setUniform<Vector<3, float>>(shaderName, "directionalLightColour", m_directionalLightSource.getColour());
setUniform<Vector<3, float>>(shaderName, "directionalLightDirection", m_directionalLightSource.getDirection());
if (m_staticMeshes[modelName] == nullptr) {
throw std::out_of_range("Error: Cannot draw the model with that handle as it does not exist.");
} else {
m_staticMeshes[modelName]->draw();
}
m_jobQueue.pop();
}
}
// Constructor
Shader(GLenum shaderType):
handle(glCreateShader(shaderType)),
name(shaderName(shaderType)),
compiled(false)
{
// do nothing
}
GPUuint Shader::createShader(const std::string &filename)
{
//compare file's extension name
std::string shaderName(filename);
size_t found = shaderName.rfind('.');
GLuint shaderId = 0;
GLenum shaderType;
if (shaderName.compare(found + 1, 4, "vert") == 0)
{
shaderType = GL_VERTEX_SHADER;
shaderId = glCreateShader(GL_VERTEX_SHADER);
}
else if (shaderName.compare(found + 1, 4, "frag") == 0)
{
shaderType = GL_FRAGMENT_SHADER;
shaderId = glCreateShader(GL_FRAGMENT_SHADER);
}
else if (shaderName.compare(found + 1, 4, "geom") == 0)
{
shaderType = GL_GEOMETRY_SHADER;
shaderId = glCreateShader(GL_GEOMETRY_SHADER);
}
else if (shaderName.compare(found + 1, 4, "comp") == 0)
{
shaderType = GL_COMPUTE_SHADER;
shaderId = glCreateShader(GL_COMPUTE_SHADER);
}
else
{
return 0;
}
const std::string shaderCode = parseShaderFile(filename);
const char *code = shaderCode.c_str();
glShaderSource(shaderId, 1, &code, NULL);
glCompileShader(shaderId);
GLint compileStatus;//whether compilation succeeds
glGetShaderiv(shaderId, GL_COMPILE_STATUS, &compileStatus);
if(GL_FALSE == compileStatus)
{
GLint infoLogLength;
glGetShaderiv(shaderId, GL_INFO_LOG_LENGTH, &infoLogLength);
GLchar *infoLog = new GLchar[infoLogLength + 1];
glGetShaderInfoLog(shaderId, infoLogLength, NULL, infoLog);
std::cerr << "Compile failure in " << shaderName << ": " << std::endl
<< infoLog << std::endl << std::endl;
delete [] infoLog;
}
return shaderId;
}
GLuint PagShaderProgram::compileShader(QString name, GLenum type)
{
QFileInfo shaderName(name);
if (!shaderName.exists())
{
//qDebug() << "No existe el shader source: " << name;
return 0;
}
std::string shaderString;
QFile shaderSource(name);
if (!shaderSource.open(QIODevice::ReadOnly))
{
qDebug() << "No se puede abrir el archivo " << name;
return 0;
}
shaderString = (std::string)shaderSource.readAll();
shaderSource.close();
GLuint shaderHandler = glCreateShader(type);
if (shaderHandler == 0) {
qDebug() << "No se puede crear el shader object";
return 0;
}
const char *c_str = shaderString.c_str();
glShaderSource(shaderHandler, 1, &c_str, NULL);
glCompileShader(shaderHandler);
GLint compileResult;
glGetShaderiv(shaderHandler,GL_COMPILE_STATUS, &compileResult);
if (compileResult == GL_FALSE) {
qDebug() << "Error al compilar el shader: " << name;
GLint logLen = 0;
glGetShaderiv(shaderHandler, GL_INFO_LOG_LENGTH, &logLen);
if (logLen > 0) {
char * log = new char[logLen];
GLint written = 0;
glGetShaderInfoLog(shaderHandler,logLen,&written, log);
qDebug() << log << endl;
delete [] log;
}
}
return shaderHandler;
}
