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