void Uniform4f::apply() { glUniform4f(location(), m_val[0], m_val[1], m_val[2], m_val[3]); }
void CustomShader::render(const glm::mat4& mvp_matrix, RenderData* render_data, Material* material, bool right) { for (auto it = texture_keys_.begin(); it != texture_keys_.end(); ++it) { Texture* texture = material->getTextureNoError(it->second); // If any texture is not ready, do not render the material at all if (texture == NULL || !texture->isReady()) { return; } } Mesh* mesh = render_data->mesh(); glUseProgram(program_->id()); if(mesh->isVaoDirty()) { for (auto it = attribute_float_keys_.begin(); it != attribute_float_keys_.end(); ++it) { mesh->setVertexAttribLocF(it->first, it->second); } for (auto it = attribute_vec2_keys_.begin(); it != attribute_vec2_keys_.end(); ++it) { mesh->setVertexAttribLocV2(it->first, it->second); } for (auto it = attribute_vec3_keys_.begin(); it != attribute_vec3_keys_.end(); ++it) { mesh->setVertexAttribLocV3(it->first, it->second); } for (auto it = attribute_vec4_keys_.begin(); it != attribute_vec4_keys_.end(); ++it) { mesh->setVertexAttribLocV4(it->first, it->second); } mesh->unSetVaoDirty(); } mesh->generateVAO(); // setup VAO ///////////// uniform ///////// for (auto it = uniform_float_keys_.begin(); it != uniform_float_keys_.end(); ++it) { glUniform1f(it->first, material->getFloat(it->second)); } if (u_mvp_ != -1) { glUniformMatrix4fv(u_mvp_, 1, GL_FALSE, glm::value_ptr(mvp_matrix)); } if (u_right_ != 0) { glUniform1i(u_right_, right ? 1 : 0); } int texture_index = 0; for (auto it = texture_keys_.begin(); it != texture_keys_.end(); ++it) { glActiveTexture(getGLTexture(texture_index)); Texture* texture = material->getTexture(it->second); glBindTexture(texture->getTarget(), texture->getId()); glUniform1i(it->first, texture_index++); } for (auto it = uniform_vec2_keys_.begin(); it != uniform_vec2_keys_.end(); ++it) { glm::vec2 v = material->getVec2(it->second); glUniform2f(it->first, v.x, v.y); } for (auto it = uniform_vec3_keys_.begin(); it != uniform_vec3_keys_.end(); ++it) { glm::vec3 v = material->getVec3(it->second); glUniform3f(it->first, v.x, v.y, v.z); } for (auto it = uniform_vec4_keys_.begin(); it != uniform_vec4_keys_.end(); ++it) { glm::vec4 v = material->getVec4(it->second); glUniform4f(it->first, v.x, v.y, v.z, v.w); } for (auto it = uniform_mat4_keys_.begin(); it != uniform_mat4_keys_.end(); ++it) { glm::mat4 m = material->getMat4(it->second); glUniformMatrix4fv(it->first, 1, GL_FALSE, glm::value_ptr(m)); } glBindVertexArray(mesh->getVAOId(material->shader_type())); glDrawElements(render_data->draw_mode(), mesh->indices().size(), GL_UNSIGNED_SHORT, 0); glBindVertexArray(0); checkGlError("CustomShader::render"); }
void ShaderNode::updateUniforms( QList<ShaderBindData> &Bindings, qint64 pTimeStamp ) { bool NumberOK; for( ShaderUniformMap::iterator it = mShaderUniformTypes.begin() ; it != mShaderUniformTypes.end() ; it++ ) { ShaderUniformData &UniformData = it.value(); QSharedPointer<InterfacePin> PIN = mNode->findPinByName( it.key() ); if( PIN == 0 ) { continue; } if( !PIN->isConnected() ) { continue; } QSharedPointer<InterfacePinControl> PinControl = PIN->connectedPin()->control(); if( PinControl == 0 ) { continue; } if( UniformData.mSampler && UniformData.mSize == 1 ) { bindTexture( Bindings, PinControl, UniformData ); continue; } // if( mLastShaderLoad < pTimeStamp )//&& !PIN->isUpdated( pTimeStamp ) ) // { // if( PIN->controlUuid() == PID_TRIGGER ) // { // switch( UniformData.mType ) // { // case GL_BOOL: // glUniform1f( UniformData.mLocation, false ); // break; // } // } // continue; // } if( true ) { InterfaceVariant *PinVariant = qobject_cast<InterfaceVariant *>( PinControl->object() ); if( PinVariant != 0 ) { switch( UniformData.mType ) { case GL_BOOL: { GLboolean NewVal = PinVariant->variant().toBool(); glUniform1ui( UniformData.mLocation, NewVal ); } break; case GL_INT: { GLint NewVal = PinVariant->variant().toInt( &NumberOK ); if( NumberOK ) { glUniform1i( UniformData.mLocation, NewVal ); } } break; case GL_FLOAT: { GLfloat NewVal = PinVariant->variant().toFloat( &NumberOK ); if( NumberOK ) { glUniform1f( UniformData.mLocation, NewVal ); } } break; case GL_FLOAT_VEC2: { QVector2D Vec2 = PinVariant->variant().value<QVector2D>(); glUniform2f( UniformData.mLocation, Vec2.x(), Vec2.y() ); } break; case GL_FLOAT_VEC3: { QVector3D Vec3 = PinVariant->variant().value<QVector3D>(); glUniform3f( UniformData.mLocation, Vec3.x(), Vec3.y(), Vec3.z() ); } break; case GL_FLOAT_VEC4: { QVector4D Vec4 = PinVariant->variant().value<QVector4D>(); glUniform4f( UniformData.mLocation, Vec4.x(), Vec4.y(), Vec4.z(), Vec4.w() ); } break; case GL_FLOAT_MAT2: { QMatrix4x4 Mat4 = PinVariant->variant().value<QMatrix4x4>(); QMatrix2x2 Mat2 = Mat4.toGenericMatrix<2,2>(); glUniformMatrix2fv( UniformData.mLocation, 1, GL_FALSE, Mat2.constData() ); } break; case GL_FLOAT_MAT3: { QMatrix4x4 Mat4 = PinVariant->variant().value<QMatrix4x4>(); QMatrix3x3 Mat3 = Mat4.toGenericMatrix<3,3>(); //qDebug() << Mat4; //qDebug() << Mat3; glUniformMatrix3fv( UniformData.mLocation, 1, GL_FALSE, Mat3.constData() ); } break; case GL_FLOAT_MAT4: { QMatrix4x4 NewVal = PinVariant->variant().value<QMatrix4x4>(); glUniformMatrix4fv( UniformData.mLocation, 1, GL_FALSE, NewVal.constData() ); } break; } OPENGL_PLUGIN_DEBUG; continue; } } if( true ) { InterfaceColour *PinColour = qobject_cast<InterfaceColour *>( PinControl->object() ); if( PinColour != 0 ) { switch( UniformData.mType ) { case GL_FLOAT_VEC3: glUniform3f( UniformData.mLocation, PinColour->colour().redF(), PinColour->colour().greenF(), PinColour->colour().blueF() ); break; case GL_FLOAT_VEC4: glUniform4f( UniformData.mLocation, PinColour->colour().redF(), PinColour->colour().greenF(), PinColour->colour().blueF(), PinColour->colour().alphaF() ); break; } OPENGL_PLUGIN_DEBUG; continue; } } if( true ) { if( PIN->controlUuid() == PID_TRIGGER ) { switch( UniformData.mType ) { case GL_BOOL: glUniform1f( UniformData.mLocation, true ); break; } OPENGL_PLUGIN_DEBUG; continue; } } } }
void Shader::setVec4( const std::string& p_name, const float p_x, const float p_y, const float p_z, const float p_w ) const { glUniform4f( glGetUniformLocation( m_program, p_name.c_str( ) ), p_x, p_y, p_z, p_w ); }
Response ToolButton::Draw (AbstractWindow* context) { AbstractWindow::shaders()->widget_inner_program()->use(); if (is_down()) { glUniform1i( AbstractWindow::shaders()->location(Shaders::WIDGET_INNER_GAMMA), 0); glUniform1i( AbstractWindow::shaders()->location(Shaders::WIDGET_INNER_SHADED), context->theme()->tool().shaded); glUniform4fv( AbstractWindow::shaders()->location(Shaders::WIDGET_INNER_COLOR), 1, AbstractWindow::theme()->tool().inner_sel.data()); glBindVertexArray(vao_[0]); glDrawArrays(GL_TRIANGLE_FAN, 0, outline_vertex_count(round_type()) + 2); AbstractWindow::shaders()->widget_outer_program()->use(); glUniform2f( AbstractWindow::shaders()->location(Shaders::WIDGET_OUTER_OFFSET), 0.f, 0.f); glUniform4fv( AbstractWindow::shaders()->location(Shaders::WIDGET_OUTER_COLOR), 1, AbstractWindow::theme()->tool().outline.data()); glBindVertexArray(vao_[1]); glDrawArrays(GL_TRIANGLE_STRIP, 0, outline_vertex_count(round_type()) * 2 + 2); if (emboss()) { glUniform4f( AbstractWindow::shaders()->location(Shaders::WIDGET_OUTER_COLOR), 1.0f, 1.0f, 1.0f, 0.16f); glUniform2f( AbstractWindow::shaders()->location(Shaders::WIDGET_OUTER_OFFSET), 0.f, -1.f); glDrawArrays(GL_TRIANGLE_STRIP, 0, emboss_vertex_count(round_type()) * 2); } } else { if (hover_) { AbstractWindow::shaders()->widget_outer_program()->use(); glUniform2f( AbstractWindow::shaders()->location(Shaders::WIDGET_OUTER_OFFSET), 0.f, 0.f); glUniform4fv( AbstractWindow::shaders()->location(Shaders::WIDGET_OUTER_COLOR), 1, AbstractWindow::theme()->tool().outline.data()); glBindVertexArray(vao_[1]); glDrawArrays(GL_TRIANGLE_STRIP, 0, outline_vertex_count(round_type()) * 2 + 2); if (emboss()) { glUniform4f( AbstractWindow::shaders()->location(Shaders::WIDGET_OUTER_COLOR), 1.0f, 1.0f, 1.0f, 0.16f); glUniform2f( AbstractWindow::shaders()->location(Shaders::WIDGET_OUTER_OFFSET), 0.f, -1.f); glDrawArrays(GL_TRIANGLE_STRIP, 0, emboss_vertex_count(round_type()) * 2); } } } DrawAction(); return Finish; }
ShaderUniform& ShaderUniform::operator =(const glm::vec4 &v) { glUniform4f(m_location, v.x, v.y, v.z, v.w); return *this; }
void Shader::setUniform4f(const std::string& name, float v1, float v2, float v3, float v4) { GLuint loc = glGetUniformLocation(_program,name.c_str()); glUniform4f(loc,v1,v2,v3,v4); }
bool Target_draw() { GLshort vertices[12]; unsigned int touchIndex; if (darkClearColor) { glClearColor(0.0f, 0.25f, 0.5f, 0.0f); } else { glClearColor(0.25f, 0.5f, 0.75f, 0.0f); } glClear(GL_COLOR_BUFFER_BIT); if (EAGLShell_getOpenGLAPIVersion() == EAGLShellOpenGLVersion_ES1) { glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrthof(0, viewportWidth, viewportHeight, 0, -1, 1); glMatrixMode(GL_MODELVIEW); if (lastAccelerometerReading.x != 0.0) { vertices[0] = viewportWidth / 3 - 5; vertices[1] = viewportHeight / 2; vertices[2] = viewportWidth / 3 + 5; vertices[3] = viewportHeight / 2; vertices[4] = viewportWidth / 3 + 5; vertices[5] = viewportHeight / 2 + lastAccelerometerReading.x * viewportHeight / 6; vertices[6] = viewportWidth / 3 - 5; vertices[7] = viewportHeight / 2 + lastAccelerometerReading.x * viewportHeight / 6; glVertexPointer(2, GL_SHORT, 0, vertices); glColor4ub(0xFF, 0x00, 0x00, 0xFF); glDrawArrays(GL_TRIANGLE_FAN, 0, 4); } if (lastAccelerometerReading.y != 0.0) { vertices[0] = viewportWidth / 2 - 5; vertices[1] = viewportHeight / 2; vertices[2] = viewportWidth / 2 + 5; vertices[3] = viewportHeight / 2; vertices[4] = viewportWidth / 2 + 5; vertices[5] = viewportHeight / 2 + lastAccelerometerReading.y * viewportHeight / 6; vertices[6] = viewportWidth / 2 - 5; vertices[7] = viewportHeight / 2 + lastAccelerometerReading.y * viewportHeight / 6; glVertexPointer(2, GL_SHORT, 0, vertices); glColor4ub(0x00, 0xFF, 0x00, 0xFF); glDrawArrays(GL_TRIANGLE_FAN, 0, 4); } if (lastAccelerometerReading.z != 0.0) { vertices[0] = viewportWidth - viewportWidth / 3 - 5; vertices[1] = viewportHeight / 2; vertices[2] = viewportWidth - viewportWidth / 3 + 5; vertices[3] = viewportHeight / 2; vertices[4] = viewportWidth - viewportWidth / 3 + 5; vertices[5] = viewportHeight / 2 + lastAccelerometerReading.z * viewportHeight / 6; vertices[6] = viewportWidth - viewportWidth / 3 - 5; vertices[7] = viewportHeight / 2 + lastAccelerometerReading.z * viewportHeight / 6; glVertexPointer(2, GL_SHORT, 0, vertices); glColor4ub(0x00, 0x00, 0xFF, 0xFF); glDrawArrays(GL_TRIANGLE_FAN, 0, 4); } vertices[0] = 0; vertices[1] = 0; vertices[2] = 16; vertices[3] = 0; vertices[4] = 0; vertices[5] = 16; vertices[6] = viewportWidth; vertices[7] = viewportHeight; vertices[8] = viewportWidth - 16; vertices[9] = viewportHeight; vertices[10] = viewportWidth; vertices[11] = viewportHeight - 16; glVertexPointer(2, GL_SHORT, 0, vertices); glColor4ub(0xFF, 0xFF, 0xFF, 0xFF); glDrawArrays(GL_TRIANGLES, 0, 6); for (touchIndex = 0; touchIndex < 32; touchIndex++) { if (touches[touchIndex].active) { vertices[0] = touches[touchIndex].x - 24; vertices[1] = touches[touchIndex].y - 24; vertices[2] = touches[touchIndex].x - 24; vertices[3] = touches[touchIndex].y + 24; vertices[4] = touches[touchIndex].x + 24; vertices[5] = touches[touchIndex].y + 24; vertices[6] = touches[touchIndex].x + 24; vertices[7] = touches[touchIndex].y - 24; glVertexPointer(2, GL_SHORT, 0, vertices); glColor4ub(0x7F, 0xFF, 0x7F, 0xFF); glDrawArrays(GL_TRIANGLE_FAN, 0, 4); } } } else { GLfloat projectionMatrix[16] = { 2.0f / viewportWidth, 0.0f, 0.0f, 0.0f, 0.0f, -2.0f / viewportHeight, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f, 0.0f, -1.0f, 1.0f, 0.0f, 1.0f }; GLfloat modelviewMatrix[16] = { 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f }; glUseProgram(shaderProgram); glUniformMatrix4fv(projectionMatrixUniform, 1, GL_FALSE, projectionMatrix); glUniformMatrix4fv(modelviewMatrixUniform, 1, GL_FALSE, modelviewMatrix); if (lastAccelerometerReading.x != 0.0) { vertices[0] = viewportWidth / 3 - 5; vertices[1] = viewportHeight / 2; vertices[2] = viewportWidth / 3 + 5; vertices[3] = viewportHeight / 2; vertices[4] = viewportWidth / 3 + 5; vertices[5] = viewportHeight / 2 + lastAccelerometerReading.x * viewportHeight / 6; vertices[6] = viewportWidth / 3 - 5; vertices[7] = viewportHeight / 2 + lastAccelerometerReading.x * viewportHeight / 6; glVertexAttribPointer(VERTEX_ATTRIB_INDEX, 2, GL_SHORT, GL_FALSE, 0, vertices); glUniform4f(constantColorUniform, 1.0f, 0.0f, 0.0f, 1.0f); glDrawArrays(GL_TRIANGLE_FAN, 0, 4); } if (lastAccelerometerReading.y != 0.0) { vertices[0] = viewportWidth / 2 - 5; vertices[1] = viewportHeight / 2; vertices[2] = viewportWidth / 2 + 5; vertices[3] = viewportHeight / 2; vertices[4] = viewportWidth / 2 + 5; vertices[5] = viewportHeight / 2 + lastAccelerometerReading.y * viewportHeight / 6; vertices[6] = viewportWidth / 2 - 5; vertices[7] = viewportHeight / 2 + lastAccelerometerReading.y * viewportHeight / 6; glVertexAttribPointer(VERTEX_ATTRIB_INDEX, 2, GL_SHORT, GL_FALSE, 0, vertices); glUniform4f(constantColorUniform, 0.0f, 1.0f, 0.0f, 1.0f); glDrawArrays(GL_TRIANGLE_FAN, 0, 4); } if (lastAccelerometerReading.z != 0.0) { vertices[0] = viewportWidth - viewportWidth / 3 - 5; vertices[1] = viewportHeight / 2; vertices[2] = viewportWidth - viewportWidth / 3 + 5; vertices[3] = viewportHeight / 2; vertices[4] = viewportWidth - viewportWidth / 3 + 5; vertices[5] = viewportHeight / 2 + lastAccelerometerReading.z * viewportHeight / 6; vertices[6] = viewportWidth - viewportWidth / 3 - 5; vertices[7] = viewportHeight / 2 + lastAccelerometerReading.z * viewportHeight / 6; glVertexAttribPointer(VERTEX_ATTRIB_INDEX, 2, GL_SHORT, GL_FALSE, 0, vertices); glUniform4f(constantColorUniform, 0.0f, 0.0f, 1.0f, 1.0f); glDrawArrays(GL_TRIANGLE_FAN, 0, 4); } vertices[0] = 0; vertices[1] = 0; vertices[2] = 16; vertices[3] = 0; vertices[4] = 0; vertices[5] = 16; vertices[6] = viewportWidth; vertices[7] = viewportHeight; vertices[8] = viewportWidth - 16; vertices[9] = viewportHeight; vertices[10] = viewportWidth; vertices[11] = viewportHeight - 16; glVertexAttribPointer(VERTEX_ATTRIB_INDEX, 2, GL_SHORT, GL_FALSE, 0, vertices); glUniform4f(constantColorUniform, 1.0f, 1.0f, 1.0f, 1.0f); glDrawArrays(GL_TRIANGLES, 0, 6); for (touchIndex = 0; touchIndex < 32; touchIndex++) { if (touches[touchIndex].active) { vertices[0] = touches[touchIndex].x - 24; vertices[1] = touches[touchIndex].y - 24; vertices[2] = touches[touchIndex].x - 24; vertices[3] = touches[touchIndex].y + 24; vertices[4] = touches[touchIndex].x + 24; vertices[5] = touches[touchIndex].y + 24; vertices[6] = touches[touchIndex].x + 24; vertices[7] = touches[touchIndex].y - 24; glVertexAttribPointer(VERTEX_ATTRIB_INDEX, 2, GL_SHORT, GL_FALSE, 0, vertices); glUniform4f(constantColorUniform, 0.5f, 1.0f, 0.5f, 1.0f); glDrawArrays(GL_TRIANGLE_FAN, 0, 4); } } } if (postRedisplayAtEndOfTarget_draw) { darkClearColor = !darkClearColor; Shell_redisplay(); } return true; }
void ShaderProgram::setUniform(std::string name, glm::vec4 &&value) { glUseProgram(this->id); GLint uid = this->getUniformLocation(name); glUniform4f(uid, value.x, value.y, value.z, value.w); glUseProgram(ShaderProgram::currentProgram); }
void GL::GLProgram::setUniform(const char* name, const glm::vec4& u) { int loc = getUniformByName(name); //assert(loc > -1); glUniform4f(loc, u.x, u.y, u.z, u.w); }
void Shader2d::SetColor(const glm::vec4 &color) { glUniform4f(colorUniform, color.r, color.g, color.b, color.a); }
int main(void) { // initialise the windows GLFWwindow *window; glfwSetErrorCallback(error_callback); if (!glfwInit()) { return -1; } window = glfwCreateWindow(640, 480, "Test", NULL, NULL); if (window == nullptr) { std::cout << "Erreur lors du chargement de la fenetree "; glfwTerminate(); return -1; } glfwMakeContextCurrent(window); printf("OpenGL Version:%s\n", glGetString(GL_VERSION)); printf("GLSL Version :%s\n", glGetString(GL_SHADING_LANGUAGE_VERSION)); // create a windows if (!window) { fprintf(stderr, "Failed to initialize GLFW\n"); glfwTerminate(); return -1; } // make the window's current context // loop until the window close glfwSetKeyCallback(window, key_callback); // triangle // must be normalized to be inside the screen // GLEW INITIALISATION glewExperimental = GL_TRUE; if (glewInit() != GLEW_OK) { std::cout << "Failed to initialize GLEW" << std::endl; } GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER); GLuint fragmentShaderOrange = glCreateShader(GL_FRAGMENT_SHADER); // The first fragment shader that outputs the color orange GLuint shaderProgramOrange = glCreateProgram(); glShaderSource(vertexShader, 1, &vertexShaderSource, NULL); glCompileShader(vertexShader); glShaderSource(fragmentShaderOrange, 1, &fragmentShaderSource, NULL); glCompileShader(fragmentShaderOrange); // Link the first program object glAttachShader(shaderProgramOrange, vertexShader); glAttachShader(shaderProgramOrange, fragmentShaderOrange); glLinkProgram(shaderProgramOrange); GLfloat firstTriangle[] = { //position // color 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 0.0f, // Bottom Right -0.5f, -0.5f, 0.0f, 0.0f, 1.0f, 0.0f, // Bottom Left 0.0f, 0.5f, 0.0f, 0.0f, 0.0f, 1.0f // Top }; GLuint VBO, VAO; glGenVertexArrays(1, &VAO); glGenBuffers(1, &VBO); // Bind the Vertex Array Object first, then bind and set vertex buffer(s) and attribute pointer(s). glBindVertexArray(VAO); glBindBuffer(GL_ARRAY_BUFFER, VBO); //say to opengl how to interpret the data (say how to link the data with the fragment shader) glBufferData(GL_ARRAY_BUFFER, sizeof(firstTriangle), firstTriangle, GL_STATIC_DRAW); // position attribute glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid*)0); // Vertex attributes stay the same glEnableVertexAttribArray(0); // say to the VBO that data are stored at the first index glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat))); glEnableVertexAttribArray(1); // unbind the vao glBindVertexArray(0); while (!glfwWindowShouldClose(window)) { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glClearColor(0.2f, 0.3f, 0.3f, 1.0f); // swap back and front buffers // every object drawn after this will use those shaders glUseProgram(shaderProgramOrange); // get the current time GLfloat timeValue = glfwGetTime(); // modulate the green value GLfloat greenValue = (sin(timeValue) / 2) + 0.5; // get the uniform vector and then set the color GLint vertexColorLocation = glGetUniformLocation(shaderProgramOrange, "ourColor"); glUniform4f(vertexColorLocation, 0.0f, greenValue, 0.0f, 1.0f); // Draw the first triangle using the data from our first VAO glBindVertexArray(VAO); glDrawArrays(GL_TRIANGLES, 0, 3); glBindVertexArray(0); glBindVertexArray(0); // Swap the screen buffers glfwSwapBuffers(window); // poll the events glfwPollEvents(); } std::cout << "finished "; // de allocate all ressources glDeleteVertexArrays(1, &VAO); glDeleteBuffers(1, &VBO); glfwTerminate(); return 0; }
uintptr_t processFn(struct fnargs* args, char* parg) { uintptr_t ret = 0; switch (args->fn) { case glfnUNDEFINED: abort(); // bad glfn break; case glfnActiveTexture: glActiveTexture((GLenum)args->a0); break; case glfnAttachShader: glAttachShader((GLint)args->a0, (GLint)args->a1); break; case glfnBindAttribLocation: glBindAttribLocation((GLint)args->a0, (GLint)args->a1, (GLchar*)args->a2); break; case glfnBindBuffer: glBindBuffer((GLenum)args->a0, (GLuint)args->a1); break; case glfnBindFramebuffer: glBindFramebuffer((GLenum)args->a0, (GLint)args->a1); break; case glfnBindRenderbuffer: glBindRenderbuffer((GLenum)args->a0, (GLint)args->a1); break; case glfnBindTexture: glBindTexture((GLenum)args->a0, (GLint)args->a1); break; case glfnBlendColor: glBlendColor(*(GLfloat*)&args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3); break; case glfnBlendEquation: glBlendEquation((GLenum)args->a0); break; case glfnBlendEquationSeparate: glBlendEquationSeparate((GLenum)args->a0, (GLenum)args->a1); break; case glfnBlendFunc: glBlendFunc((GLenum)args->a0, (GLenum)args->a1); break; case glfnBlendFuncSeparate: glBlendFuncSeparate((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLenum)args->a3); break; case glfnBufferData: glBufferData((GLenum)args->a0, (GLsizeiptr)args->a1, (GLvoid*)parg, (GLenum)args->a2); break; case glfnBufferSubData: glBufferSubData((GLenum)args->a0, (GLint)args->a1, (GLsizeiptr)args->a2, (GLvoid*)parg); break; case glfnCheckFramebufferStatus: ret = glCheckFramebufferStatus((GLenum)args->a0); break; case glfnClear: glClear((GLenum)args->a0); break; case glfnClearColor: glClearColor(*(GLfloat*)&args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3); break; case glfnClearDepthf: glClearDepthf(*(GLfloat*)&args->a0); break; case glfnClearStencil: glClearStencil((GLint)args->a0); break; case glfnColorMask: glColorMask((GLboolean)args->a0, (GLboolean)args->a1, (GLboolean)args->a2, (GLboolean)args->a3); break; case glfnCompileShader: glCompileShader((GLint)args->a0); break; case glfnCompressedTexImage2D: glCompressedTexImage2D((GLenum)args->a0, (GLint)args->a1, (GLenum)args->a2, (GLint)args->a3, (GLint)args->a4, (GLint)args->a5, (GLsizeiptr)args->a6, (GLvoid*)parg); break; case glfnCompressedTexSubImage2D: glCompressedTexSubImage2D((GLenum)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3, (GLint)args->a4, (GLint)args->a5, (GLenum)args->a6, (GLsizeiptr)args->a7, (GLvoid*)parg); break; case glfnCopyTexImage2D: glCopyTexImage2D((GLenum)args->a0, (GLint)args->a1, (GLenum)args->a2, (GLint)args->a3, (GLint)args->a4, (GLint)args->a5, (GLint)args->a6, (GLint)args->a7); break; case glfnCopyTexSubImage2D: glCopyTexSubImage2D((GLenum)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3, (GLint)args->a4, (GLint)args->a5, (GLint)args->a6, (GLint)args->a7); break; case glfnCreateProgram: ret = glCreateProgram(); break; case glfnCreateShader: ret = glCreateShader((GLenum)args->a0); break; case glfnCullFace: glCullFace((GLenum)args->a0); break; case glfnDeleteBuffer: glDeleteBuffers(1, (const GLuint*)(&args->a0)); break; case glfnDeleteFramebuffer: glDeleteFramebuffers(1, (const GLuint*)(&args->a0)); break; case glfnDeleteProgram: glDeleteProgram((GLint)args->a0); break; case glfnDeleteRenderbuffer: glDeleteRenderbuffers(1, (const GLuint*)(&args->a0)); break; case glfnDeleteShader: glDeleteShader((GLint)args->a0); break; case glfnDeleteTexture: glDeleteTextures(1, (const GLuint*)(&args->a0)); break; case glfnDepthFunc: glDepthFunc((GLenum)args->a0); break; case glfnDepthMask: glDepthMask((GLboolean)args->a0); break; case glfnDepthRangef: glDepthRangef(*(GLfloat*)&args->a0, *(GLfloat*)&args->a1); break; case glfnDetachShader: glDetachShader((GLint)args->a0, (GLint)args->a1); break; case glfnDisable: glDisable((GLenum)args->a0); break; case glfnDisableVertexAttribArray: glDisableVertexAttribArray((GLint)args->a0); break; case glfnDrawArrays: glDrawArrays((GLenum)args->a0, (GLint)args->a1, (GLint)args->a2); break; case glfnDrawElements: glDrawElements((GLenum)args->a0, (GLint)args->a1, (GLenum)args->a2, (void*)args->a3); break; case glfnEnable: glEnable((GLenum)args->a0); break; case glfnEnableVertexAttribArray: glEnableVertexAttribArray((GLint)args->a0); break; case glfnFinish: glFinish(); break; case glfnFlush: glFlush(); break; case glfnFramebufferRenderbuffer: glFramebufferRenderbuffer((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLint)args->a3); break; case glfnFramebufferTexture2D: glFramebufferTexture2D((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLint)args->a3, (GLint)args->a4); break; case glfnFrontFace: glFrontFace((GLenum)args->a0); break; case glfnGenBuffer: glGenBuffers(1, (GLuint*)&ret); break; case glfnGenFramebuffer: glGenFramebuffers(1, (GLuint*)&ret); break; case glfnGenRenderbuffer: glGenRenderbuffers(1, (GLuint*)&ret); break; case glfnGenTexture: glGenTextures(1, (GLuint*)&ret); break; case glfnGenerateMipmap: glGenerateMipmap((GLenum)args->a0); break; case glfnGetActiveAttrib: glGetActiveAttrib( (GLuint)args->a0, (GLuint)args->a1, (GLsizei)args->a2, NULL, (GLint*)&ret, (GLenum*)args->a3, (GLchar*)parg); break; case glfnGetActiveUniform: glGetActiveUniform( (GLuint)args->a0, (GLuint)args->a1, (GLsizei)args->a2, NULL, (GLint*)&ret, (GLenum*)args->a3, (GLchar*)parg); break; case glfnGetAttachedShaders: glGetAttachedShaders((GLuint)args->a0, (GLsizei)args->a1, (GLsizei*)&ret, (GLuint*)parg); break; case glfnGetAttribLocation: ret = glGetAttribLocation((GLint)args->a0, (GLchar*)args->a1); break; case glfnGetBooleanv: glGetBooleanv((GLenum)args->a0, (GLboolean*)parg); break; case glfnGetBufferParameteri: glGetBufferParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLint*)&ret); break; case glfnGetFloatv: glGetFloatv((GLenum)args->a0, (GLfloat*)parg); break; case glfnGetIntegerv: glGetIntegerv((GLenum)args->a0, (GLint*)parg); break; case glfnGetError: ret = glGetError(); break; case glfnGetFramebufferAttachmentParameteriv: glGetFramebufferAttachmentParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLint*)&ret); break; case glfnGetProgramiv: glGetProgramiv((GLint)args->a0, (GLenum)args->a1, (GLint*)&ret); break; case glfnGetProgramInfoLog: glGetProgramInfoLog((GLuint)args->a0, (GLsizei)args->a1, 0, (GLchar*)parg); break; case glfnGetRenderbufferParameteriv: glGetRenderbufferParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLint*)&ret); break; case glfnGetShaderiv: glGetShaderiv((GLint)args->a0, (GLenum)args->a1, (GLint*)&ret); break; case glfnGetShaderInfoLog: glGetShaderInfoLog((GLuint)args->a0, (GLsizei)args->a1, 0, (GLchar*)parg); break; case glfnGetShaderPrecisionFormat: glGetShaderPrecisionFormat((GLenum)args->a0, (GLenum)args->a1, (GLint*)parg, &((GLint*)parg)[2]); break; case glfnGetShaderSource: glGetShaderSource((GLuint)args->a0, (GLsizei)args->a1, 0, (GLchar*)parg); break; case glfnGetString: ret = (uintptr_t)glGetString((GLenum)args->a0); break; case glfnGetTexParameterfv: glGetTexParameterfv((GLenum)args->a0, (GLenum)args->a1, (GLfloat*)parg); break; case glfnGetTexParameteriv: glGetTexParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLint*)parg); break; case glfnGetUniformfv: glGetUniformfv((GLuint)args->a0, (GLint)args->a1, (GLfloat*)parg); break; case glfnGetUniformiv: glGetUniformiv((GLuint)args->a0, (GLint)args->a1, (GLint*)parg); break; case glfnGetUniformLocation: ret = glGetUniformLocation((GLint)args->a0, (GLchar*)args->a1); break; case glfnGetVertexAttribfv: glGetVertexAttribfv((GLuint)args->a0, (GLenum)args->a1, (GLfloat*)parg); break; case glfnGetVertexAttribiv: glGetVertexAttribiv((GLuint)args->a0, (GLenum)args->a1, (GLint*)parg); break; case glfnHint: glHint((GLenum)args->a0, (GLenum)args->a1); break; case glfnIsBuffer: ret = glIsBuffer((GLint)args->a0); break; case glfnIsEnabled: ret = glIsEnabled((GLenum)args->a0); break; case glfnIsFramebuffer: ret = glIsFramebuffer((GLint)args->a0); break; case glfnIsProgram: ret = glIsProgram((GLint)args->a0); break; case glfnIsRenderbuffer: ret = glIsRenderbuffer((GLint)args->a0); break; case glfnIsShader: ret = glIsShader((GLint)args->a0); break; case glfnIsTexture: ret = glIsTexture((GLint)args->a0); break; case glfnLineWidth: glLineWidth(*(GLfloat*)&args->a0); break; case glfnLinkProgram: glLinkProgram((GLint)args->a0); break; case glfnPixelStorei: glPixelStorei((GLenum)args->a0, (GLint)args->a1); break; case glfnPolygonOffset: glPolygonOffset(*(GLfloat*)&args->a0, *(GLfloat*)&args->a1); break; case glfnReadPixels: glReadPixels((GLint)args->a0, (GLint)args->a1, (GLsizei)args->a2, (GLsizei)args->a3, (GLenum)args->a4, (GLenum)args->a5, (void*)parg); break; case glfnReleaseShaderCompiler: glReleaseShaderCompiler(); break; case glfnRenderbufferStorage: glRenderbufferStorage((GLenum)args->a0, (GLenum)args->a1, (GLint)args->a2, (GLint)args->a3); break; case glfnSampleCoverage: glSampleCoverage(*(GLfloat*)&args->a0, (GLboolean)args->a1); break; case glfnScissor: glScissor((GLint)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3); break; case glfnShaderSource: #if defined(os_ios) || defined(os_osx) glShaderSource((GLuint)args->a0, (GLsizei)args->a1, (const GLchar *const *)args->a2, NULL); #else glShaderSource((GLuint)args->a0, (GLsizei)args->a1, (const GLchar **)args->a2, NULL); #endif break; case glfnStencilFunc: glStencilFunc((GLenum)args->a0, (GLint)args->a1, (GLuint)args->a2); break; case glfnStencilFuncSeparate: glStencilFuncSeparate((GLenum)args->a0, (GLenum)args->a1, (GLint)args->a2, (GLuint)args->a3); break; case glfnStencilMask: glStencilMask((GLuint)args->a0); break; case glfnStencilMaskSeparate: glStencilMaskSeparate((GLenum)args->a0, (GLuint)args->a1); break; case glfnStencilOp: glStencilOp((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2); break; case glfnStencilOpSeparate: glStencilOpSeparate((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLenum)args->a3); break; case glfnTexImage2D: glTexImage2D( (GLenum)args->a0, (GLint)args->a1, (GLint)args->a2, (GLsizei)args->a3, (GLsizei)args->a4, 0, // border (GLenum)args->a5, (GLenum)args->a6, (const GLvoid*)parg); break; case glfnTexSubImage2D: glTexSubImage2D( (GLenum)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3, (GLsizei)args->a4, (GLsizei)args->a5, (GLenum)args->a6, (GLenum)args->a7, (const GLvoid*)parg); break; case glfnTexParameterf: glTexParameterf((GLenum)args->a0, (GLenum)args->a1, *(GLfloat*)&args->a2); break; case glfnTexParameterfv: glTexParameterfv((GLenum)args->a0, (GLenum)args->a1, (GLfloat*)parg); break; case glfnTexParameteri: glTexParameteri((GLenum)args->a0, (GLenum)args->a1, (GLint)args->a2); break; case glfnTexParameteriv: glTexParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLint*)parg); break; case glfnUniform1f: glUniform1f((GLint)args->a0, *(GLfloat*)&args->a1); break; case glfnUniform1fv: glUniform1fv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)parg); break; case glfnUniform1i: glUniform1i((GLint)args->a0, (GLint)args->a1); break; case glfnUniform1iv: glUniform1iv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)parg); break; case glfnUniform2f: glUniform2f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2); break; case glfnUniform2fv: glUniform2fv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)parg); break; case glfnUniform2i: glUniform2i((GLint)args->a0, (GLint)args->a1, (GLint)args->a2); break; case glfnUniform2iv: glUniform2iv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)parg); break; case glfnUniform3f: glUniform3f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3); break; case glfnUniform3fv: glUniform3fv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)parg); break; case glfnUniform3i: glUniform3i((GLint)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3); break; case glfnUniform3iv: glUniform3iv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)parg); break; case glfnUniform4f: glUniform4f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3, *(GLfloat*)&args->a4); break; case glfnUniform4fv: glUniform4fv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)parg); break; case glfnUniform4i: glUniform4i((GLint)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3, (GLint)args->a4); break; case glfnUniform4iv: glUniform4iv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)parg); break; case glfnUniformMatrix2fv: glUniformMatrix2fv((GLint)args->a0, (GLsizeiptr)args->a1, 0, (GLvoid*)parg); break; case glfnUniformMatrix3fv: glUniformMatrix3fv((GLint)args->a0, (GLsizeiptr)args->a1, 0, (GLvoid*)parg); break; case glfnUniformMatrix4fv: glUniformMatrix4fv((GLint)args->a0, (GLsizeiptr)args->a1, 0, (GLvoid*)parg); break; case glfnUseProgram: glUseProgram((GLint)args->a0); break; case glfnValidateProgram: glValidateProgram((GLint)args->a0); break; case glfnVertexAttrib1f: glVertexAttrib1f((GLint)args->a0, *(GLfloat*)&args->a1); break; case glfnVertexAttrib1fv: glVertexAttrib1fv((GLint)args->a0, (GLfloat*)parg); break; case glfnVertexAttrib2f: glVertexAttrib2f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2); break; case glfnVertexAttrib2fv: glVertexAttrib2fv((GLint)args->a0, (GLfloat*)parg); break; case glfnVertexAttrib3f: glVertexAttrib3f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3); break; case glfnVertexAttrib3fv: glVertexAttrib3fv((GLint)args->a0, (GLfloat*)parg); break; case glfnVertexAttrib4f: glVertexAttrib4f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3, *(GLfloat*)&args->a4); break; case glfnVertexAttrib4fv: glVertexAttrib4fv((GLint)args->a0, (GLfloat*)parg); break; case glfnVertexAttribPointer: glVertexAttribPointer((GLuint)args->a0, (GLint)args->a1, (GLenum)args->a2, (GLboolean)args->a3, (GLsizei)args->a4, (const GLvoid*)args->a5); break; case glfnViewport: glViewport((GLint)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3); break; } return ret; }
void Shader::BindFloat(const std::string &name, float v0, float v1, float v2, float v3) { int id = GetUniformLocation(name); if (id != -1) glUniform4f(id, v0, v1, v2, v3); }
//------------------------------------------------------------------------------ void ShaderProgram::setParam(const std::string & name, f32 x, f32 y, f32 z, f32 w) { glCheck(glUniform4f(getUniformLocation(name), x, y, z, w)); }
Uniform &Uniform::operator=(glm::vec4 &&val) { glUseProgram(this->program); glUniform4f(this->id, val.x, val.y, val.z, val.w); glUseProgram(ShaderProgram::currentProgram); return *this; }
void Render() { auto width = glutGet(GLUT_WINDOW_WIDTH); auto height = glutGet(GLUT_WINDOW_HEIGHT); glClearColor(0.5f, 0.5f, 0.5f, 1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); auto program = basicShader.GetProgram(); glUseProgram(program); // variables uniformes (constantes) g_Camera.projectionMatrix = glm::perspectiveFov(45.f, (float)width, (float)height, 0.1f, 1000.f); // rotation orbitale de la camera float rotY = glm::radians(g_Camera.rotation.y); glm::vec4 position = glm::eulerAngleY(rotY) * glm::vec4(0.0f, 0.0f, 80.0f, 1.0f); g_Camera.viewMatrix = glm::lookAt(glm::vec3(position), glm::vec3(0.f), glm::vec3(0.f, 1.f, 0.f)); // IL FAUT TRANSFERER LES MATRICES VIEW ET PROJ AU SHADER glBindBuffer(GL_UNIFORM_BUFFER, g_Camera.UBO); glBufferData(GL_UNIFORM_BUFFER, sizeof(glm::mat4) * 2, glm::value_ptr(g_Camera.viewMatrix), GL_STREAM_DRAW); float yaw = glm::radians(g_Cube.rotation.y); float pitch = glm::radians(g_Cube.rotation.x); float roll = glm::radians(g_Cube.rotation.z); g_Cube.worldMatrix = glm::eulerAngleYXZ(yaw, pitch, roll); auto worldLocation = glGetUniformLocation(program, "u_worldMatrix"); auto colorLocation = glGetUniformLocation(program, "u_objectColor"); glBindVertexArray(g_Cube.VAO); //glBindBuffer(GL_ARRAY_BUFFER, g_Cube.VBO); glBindVertexArray(g_Cube.IBO); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_Cube.IBO); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 6, 0); // Layout (1) pour l'attribut des normales glEnableVertexAttribArray(1); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 6, 0); for (float x = -24.f; x < 24.f; x += 3.0f) { for (float y = -24.f; y < 24.f; y += 3.0f) { for (float z = -24.f; z < 24.f; z += 3.0f) { glUniform4f(colorLocation, (x + 24.0f) / 48.f, (y + 24.0f) / 48.f, (z + 24.0f) / 48.f, 1.0f); //glm::mat4 transform = glm::translate(g_Cube.worldMatrix, glm::vec3(x, y, z)); glm::mat4& transform = g_Cube.worldMatrix; transform[3] = glm::vec4(x, y, z, 1.0f); glUniformMatrix4fv(worldLocation, 1, GL_FALSE, glm::value_ptr(transform)); glDrawElements(GL_TRIANGLES, g_Cube.ElementCount, GL_UNSIGNED_INT, 0); } } } glDisableVertexAttribArray(0); glDisableVertexAttribArray(1); glBindVertexArray(0); //glBindBuffer(GL_ARRAY_BUFFER, 0); glutSwapBuffers(); }
//-------------------------------------------------------------- void ofShader::setUniform4f(const char* name, float v1, float v2, float v3, float v4) { if(bLoaded) glUniform4f(getUniformLocation(name), v1, v2, v3, v4); }
void b2DebugDraw::SetColor(const b2Color& c, float ratio) { glUniform4f(ev_program_get_uniform_loc(mShader, "u_color"), c.r * ratio, c.g * ratio, c.b * ratio, ratio); }
void Shader::SetVector4f(const GLchar *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w, GLboolean useShader) { if (useShader) this->Use(); glUniform4f(glGetUniformLocation(this->ID, name), x, y, z, w); }
void CSlideShowPic::Render(float *x, float *y, CBaseTexture* pTexture, color_t color) { #ifdef HAS_DX static const DWORD FVF_VERTEX = D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1; Vertex vertex[5]; for (int i = 0; i < 4; i++) { vertex[i].pos = XMFLOAT3( x[i], y[i], 0); CD3DHelper::XMStoreColor(&vertex[i].color, color); vertex[i].texCoord = XMFLOAT2(0.0f, 0.0f); vertex[i].texCoord2 = XMFLOAT2(0.0f, 0.0f); } if (pTexture) { vertex[1].texCoord.x = vertex[2].texCoord.x = (float) pTexture->GetWidth() / pTexture->GetTextureWidth(); vertex[2].texCoord.y = vertex[3].texCoord.y = (float) pTexture->GetHeight() / pTexture->GetTextureHeight(); } else { vertex[1].texCoord.x = vertex[2].texCoord.x = 1.0f; vertex[2].texCoord.y = vertex[3].texCoord.y = 1.0f; } vertex[4] = vertex[0]; // Not used when pTexture != NULL CGUIShaderDX* pGUIShader = g_Windowing.GetGUIShader(); pGUIShader->Begin(SHADER_METHOD_RENDER_TEXTURE_BLEND); // Set state to render the image if (pTexture) { pTexture->LoadToGPU(); CDXTexture* dxTexture = reinterpret_cast<CDXTexture*>(pTexture); ID3D11ShaderResourceView* shaderRes = dxTexture->GetShaderResource(); pGUIShader->SetShaderViews(1, &shaderRes); pGUIShader->DrawQuad(vertex[0], vertex[1], vertex[2], vertex[3]); } else { if (!UpdateVertexBuffer(vertex)) return; ID3D11DeviceContext* pContext = g_Windowing.Get3D11Context(); unsigned stride = sizeof(Vertex); unsigned offset = 0; pContext->IASetVertexBuffers(0, 1, &m_vb, &stride, &offset); pContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_LINESTRIP); pGUIShader->Draw(5, 0); pGUIShader->RestoreBuffers(); } #elif defined(HAS_GL) if (pTexture) { int unit = 0; pTexture->LoadToGPU(); pTexture->BindToUnit(unit++); glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_BLEND); // Turn Blending On // diffuse coloring glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE); glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_MODULATE); glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_TEXTURE0); glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR); glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_PRIMARY_COLOR); glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR); if(g_Windowing.UseLimitedColor()) { // compress range pTexture->BindToUnit(unit++); // dummy bind const GLfloat rgba1[4] = {(235.0 - 16.0f) / 255.0f, (235.0 - 16.0f) / 255.0f, (235.0 - 16.0f) / 255.0f, 1.0f}; glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE , GL_COMBINE); glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, rgba1); glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_RGB , GL_MODULATE); glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_RGB , GL_PREVIOUS); glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE1_RGB , GL_CONSTANT); glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_RGB , GL_SRC_COLOR); glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND1_RGB , GL_SRC_COLOR); glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_ALPHA , GL_REPLACE); glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_ALPHA , GL_PREVIOUS); // transition pTexture->BindToUnit(unit++); // dummy bind const GLfloat rgba2[4] = {16.0f / 255.0f, 16.0f / 255.0f, 16.0f / 255.0f, 0.0f}; glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE , GL_COMBINE); glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, rgba2); glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_RGB , GL_ADD); glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_RGB , GL_PREVIOUS); glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE1_RGB , GL_CONSTANT); glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_RGB , GL_SRC_COLOR); glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND1_RGB , GL_SRC_COLOR); glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_ALPHA , GL_REPLACE); glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_ALPHA , GL_PREVIOUS); } } else glDisable(GL_TEXTURE_2D); glPolygonMode(GL_FRONT_AND_BACK, pTexture ? GL_FILL : GL_LINE); glBegin(GL_QUADS); float u1 = 0, u2 = 1, v1 = 0, v2 = 1; if (pTexture) { u2 = (float)pTexture->GetWidth() / pTexture->GetTextureWidth(); v2 = (float)pTexture->GetHeight() / pTexture->GetTextureHeight(); } glColor4ub((GLubyte)GET_R(color), (GLubyte)GET_G(color), (GLubyte)GET_B(color), (GLubyte)GET_A(color)); glTexCoord2f(u1, v1); glVertex3f(x[0], y[0], 0); // Bottom-left vertex (corner) glColor4ub((GLubyte)GET_R(color), (GLubyte)GET_G(color), (GLubyte)GET_B(color), (GLubyte)GET_A(color)); glTexCoord2f(u2, v1); glVertex3f(x[1], y[1], 0); // Bottom-right vertex (corner) glColor4ub((GLubyte)GET_R(color), (GLubyte)GET_G(color), (GLubyte)GET_B(color), (GLubyte)GET_A(color)); glTexCoord2f(u2, v2); glVertex3f(x[2], y[2], 0); // Top-right vertex (corner) glColor4ub((GLubyte)GET_R(color), (GLubyte)GET_G(color), (GLubyte)GET_B(color), (GLubyte)GET_A(color)); glTexCoord2f(u1, v2); glVertex3f(x[3], y[3], 0); glEnd(); #elif defined(HAS_GLES) if (pTexture) { pTexture->LoadToGPU(); pTexture->BindToUnit(0); glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_BLEND); // Turn Blending On g_Windowing.EnableGUIShader(SM_TEXTURE); } else { glDisable(GL_TEXTURE_2D); g_Windowing.EnableGUIShader(SM_DEFAULT); } float u1 = 0, u2 = 1, v1 = 0, v2 = 1; if (pTexture) { u2 = (float)pTexture->GetWidth() / pTexture->GetTextureWidth(); v2 = (float)pTexture->GetHeight() / pTexture->GetTextureHeight(); } GLubyte col[4]; GLfloat ver[4][3]; GLfloat tex[4][2]; GLubyte idx[4] = {0, 1, 3, 2}; //determines order of triangle strip GLint posLoc = g_Windowing.GUIShaderGetPos(); GLint tex0Loc = g_Windowing.GUIShaderGetCoord0(); GLint uniColLoc= g_Windowing.GUIShaderGetUniCol(); glVertexAttribPointer(posLoc, 3, GL_FLOAT, 0, 0, ver); glVertexAttribPointer(tex0Loc, 2, GL_FLOAT, 0, 0, tex); glEnableVertexAttribArray(posLoc); glEnableVertexAttribArray(tex0Loc); // Setup Colour values col[0] = (GLubyte)GET_R(color); col[1] = (GLubyte)GET_G(color); col[2] = (GLubyte)GET_B(color); col[3] = (GLubyte)GET_A(color); for (int i=0; i<4; i++) { // Setup vertex position values ver[i][0] = x[i]; ver[i][1] = y[i]; ver[i][2] = 0.0f; } // Setup texture coordinates tex[0][0] = tex[3][0] = u1; tex[0][1] = tex[1][1] = v1; tex[1][0] = tex[2][0] = u2; tex[2][1] = tex[3][1] = v2; glUniform4f(uniColLoc,(col[0] / 255.0f), (col[1] / 255.0f), (col[2] / 255.0f), (col[3] / 255.0f)); glDrawElements(GL_TRIANGLE_STRIP, 4, GL_UNSIGNED_BYTE, idx); glDisableVertexAttribArray(posLoc); glDisableVertexAttribArray(tex0Loc); g_Windowing.DisableGUIShader(); #else // SDL render g_Windowing.BlitToScreen(m_pImage, NULL, NULL); #endif }
void Shader::SetVector4f(const GLchar *name, const glm::vec4 &value, GLboolean useShader) { if (useShader) this->Use(); glUniform4f(glGetUniformLocation(this->ID, name), value.x, value.y, value.z, value.w); }
GLUSboolean update(GLUSfloat time) { static GLfloat angle = 0.0f; GLfloat modelViewMatrix[16]; GLfloat viewMatrix[16]; GLfloat shadowProjectionMatrix[16]; GLfloat modelMatrix[16]; GLfloat normalMatrix[9]; // This shadow plane represents mathematically the background plane GLfloat shadowPlane[4] = {0.0f, 0.0f, 1.0f, 5.0f}; glusMatrix4x4LookAtf(viewMatrix, g_cameraPosition[0], g_cameraPosition[1], g_cameraPosition[2], 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // // Render the scene. // glUseProgram(g_program.program); glUniformMatrix4fv(g_viewMatrixLocation, 1, GL_FALSE, viewMatrix); // Background Plane glusMatrix4x4Identityf(modelMatrix); glusMatrix4x4Translatef(modelMatrix, 0.0f, 0.0f, -5.0f); glusMatrix4x4Multiplyf(modelViewMatrix, viewMatrix, modelMatrix); glusMatrix4x4ExtractMatrix3x3f(normalMatrix, modelViewMatrix); glUniformMatrix4fv(g_modelMatrixLocation, 1, GL_FALSE, modelMatrix); glUniformMatrix3fv(g_normalMatrixLocation, 1, GL_FALSE, normalMatrix); glUniform4f(g_colorLocation, 0.0f, 0.5f, 0.0f, 1.0f); glBindVertexArray(g_vaoBackground); glDrawElements(GL_TRIANGLES, g_numberIndicesBackground, GL_UNSIGNED_INT, 0); // // Render the planar shadow // glUseProgram(g_programShadow.program); glUniformMatrix4fv(g_viewMatrixShadowLocation, 1, GL_FALSE, viewMatrix); // Torus projected as a shadow glusMatrix4x4PlanarShadowDirectionalLightf(shadowProjectionMatrix, shadowPlane, g_lightDirection); glUniformMatrix4fv(g_shadowProjectionMatrixShadowLocation, 1, GL_FALSE, shadowProjectionMatrix); glusMatrix4x4Identityf(modelMatrix); glusMatrix4x4RotateRzRxRyf(modelMatrix, 0.0f, 0.0f, angle); glUniformMatrix4fv(g_modelMatrixShadowLocation, 1, GL_FALSE, modelMatrix); glBindVertexArray(g_vaoShadow); // Overwrite the background plane glDisable(GL_DEPTH_TEST); glDrawElements(GL_TRIANGLES, g_numberIndicesTorus, GL_UNSIGNED_INT, 0); glEnable(GL_DEPTH_TEST); // Torus with color glUseProgram(g_program.program); glusMatrix4x4Multiplyf(modelViewMatrix, viewMatrix, modelMatrix); glusMatrix4x4ExtractMatrix3x3f(normalMatrix, modelViewMatrix); glUniformMatrix4fv(g_modelMatrixLocation, 1, GL_FALSE, modelMatrix); glUniformMatrix3fv(g_normalMatrixLocation, 1, GL_FALSE, normalMatrix); glUniform4f(g_colorLocation, 0.33f, 0.0f, 0.5f, 1.0f); glBindVertexArray(g_vao); glDrawElements(GL_TRIANGLES, g_numberIndicesTorus, GL_UNSIGNED_INT, 0); // angle += 20.0f * time; return GLUS_TRUE; }
void Shader::SetUniform4f(const char* name, const maths::Vec4& vector) { glUniform4f(GetUniformLocation(name), vector.x, vector.y, vector.z, vector.w); }
void glamor_set_destination_drawable(DrawablePtr drawable, int box_index, Bool do_drawable_translate, Bool center_offset, GLint matrix_uniform_location, int *p_off_x, int *p_off_y) { ScreenPtr screen = drawable->pScreen; glamor_screen_private *glamor_priv = glamor_get_screen_private(screen); PixmapPtr pixmap = glamor_get_drawable_pixmap(drawable); glamor_pixmap_private *pixmap_priv = glamor_get_pixmap_private(pixmap); int off_x, off_y; BoxPtr box = glamor_pixmap_box_at(pixmap_priv, box_index); int w = box->x2 - box->x1; int h = box->y2 - box->y1; float scale_x = 2.0f / (float) w; float scale_y = 2.0f / (float) h; float center_adjust = 0.0f; glamor_get_drawable_deltas(drawable, pixmap, &off_x, &off_y); off_x -= box->x1; off_y -= box->y1; if (p_off_x) { *p_off_x = off_x; *p_off_y = off_y; } /* A tricky computation to find the right value for the two linear functions * that transform rendering coordinates to pixmap coordinates * * pixmap_x = render_x + drawable->x + off_x * pixmap_y = render_y + drawable->y + off_y * * gl_x = pixmap_x * 2 / width - 1 * gl_y = pixmap_y * 2 / height - 1 * * gl_x = (render_x + drawable->x + off_x) * 2 / width - 1 * * gl_x = (render_x) * 2 / width + (drawable->x + off_x) * 2 / width - 1 */ if (do_drawable_translate) { off_x += drawable->x; off_y += drawable->y; } /* * To get GL_POINTS drawn in the right spot, we need to adjust the * coordinates by 1/2 a pixel. */ if (center_offset) center_adjust = 0.5f; glUniform4f(matrix_uniform_location, scale_x, (off_x + center_adjust) * scale_x - 1.0f, scale_y, (off_y + center_adjust) * scale_y - 1.0f); glamor_set_destination_pixmap_fbo(glamor_priv, glamor_pixmap_fbo_at(pixmap_priv, box_index), 0, 0, w, h); }
void gShaderProgram::SetUniform(const char* _uniform, float _a, float _b, float _c, float _d) { GLint loc = getLocation(_uniform); glUniform4f( loc, _a, _b, _c, _d ); }
//Called to update the display. //You should call glutSwapBuffers after all of your rendering to display what you rendered. //If you need continuous updates of the screen, call glutPostRedisplay() at the end of the function. void display() { g_lights.UpdateTime(); glm::vec4 bkg = g_lights.GetBackgroundColor(); glClearColor(bkg[0], bkg[1], bkg[2], bkg[3]); glClearDepth(1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glutil::MatrixStack modelMatrix; modelMatrix.SetMatrix(g_viewPole.CalcMatrix()); const glm::mat4 &worldToCamMat = modelMatrix.Top(); LightBlock lightData = g_lights.GetLightInformation(worldToCamMat); glBindBuffer(GL_UNIFORM_BUFFER, g_lightUniformBuffer); glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(lightData), &lightData); glBindBuffer(GL_UNIFORM_BUFFER, 0); if(g_pScene) { glutil::PushStack push(modelMatrix); g_pScene->Draw(modelMatrix, g_materialBlockIndex, g_lights.GetTimerValue("tetra")); } { glutil::PushStack push(modelMatrix); //Render the sun { glutil::PushStack push(modelMatrix); glm::vec3 sunlightDir(g_lights.GetSunlightDirection()); modelMatrix.Translate(sunlightDir * 500.0f); modelMatrix.Scale(30.0f, 30.0f, 30.0f); glUseProgram(g_Unlit.theProgram); glUniformMatrix4fv(g_Unlit.modelToCameraMatrixUnif, 1, GL_FALSE, glm::value_ptr(modelMatrix.Top())); glm::vec4 lightColor = g_lights.GetSunlightIntensity(); glUniform4fv(g_Unlit.objectColorUnif, 1, glm::value_ptr(lightColor)); g_pScene->GetSphereMesh()->Render("flat"); } //Render the lights if(g_bDrawLights) { for(int light = 0; light < g_lights.GetNumberOfPointLights(); light++) { glutil::PushStack push(modelMatrix); modelMatrix.Translate(g_lights.GetWorldLightPosition(light)); glUseProgram(g_Unlit.theProgram); glUniformMatrix4fv(g_Unlit.modelToCameraMatrixUnif, 1, GL_FALSE, glm::value_ptr(modelMatrix.Top())); glm::vec4 lightColor = g_lights.GetPointLightIntensity(light); glUniform4fv(g_Unlit.objectColorUnif, 1, glm::value_ptr(lightColor)); g_pScene->GetCubeMesh()->Render("flat"); } } if(g_bDrawCameraPos) { glutil::PushStack push(modelMatrix); modelMatrix.SetIdentity(); modelMatrix.Translate(glm::vec3(0.0f, 0.0f, -g_viewPole.GetView().radius)); glDisable(GL_DEPTH_TEST); glDepthMask(GL_FALSE); glUseProgram(g_Unlit.theProgram); glUniformMatrix4fv(g_Unlit.modelToCameraMatrixUnif, 1, GL_FALSE, glm::value_ptr(modelMatrix.Top())); glUniform4f(g_Unlit.objectColorUnif, 0.25f, 0.25f, 0.25f, 1.0f); g_pScene->GetCubeMesh()->Render("flat"); glDepthMask(GL_TRUE); glEnable(GL_DEPTH_TEST); glUniform4f(g_Unlit.objectColorUnif, 1.0f, 1.0f, 1.0f, 1.0f); g_pScene->GetCubeMesh()->Render("flat"); } } glutPostRedisplay(); glutSwapBuffers(); }
void Shader::setUniform( const std::string & str, float x0, float x1, float x2, float x3 ) const { std::map< std::string, unsigned int >::const_iterator iter = uniforms.find( str ); glUniform4f( iter->second, x0, x1, x2, x3 ); }
void ShaderProgram::setUniformf(const std::string& _name, float _value0, float _value1, float _value2, float _value3) { use(); GLint location = getUniformLocation(_name); glUniform4f(location, _value0, _value1, _value2, _value3); }
void DayTime::update( const UINT& dt ) { float hours = 24.0f * dt / (conf.dayLength * 10000.0f); Time = fmod( Time + hours , 24.0f ); if( Time > 22 || Time < 2){ if( sfield->clr.a != night ) sfield->clr.a = night; if ( Time < 2 ){ if( !Updated ){ Day++; night = BASE_NIGHT + MOON_MOD * ( ( Day % 29 ) / 29 ); Updated = true; } }else{ if( Updated ) Updated = false; } if(text) text->setText("Midnight"); }else if( Time > 18 ){ float p = (Time - 18) / 4.0f; sfield->clr.a = static_cast<int>( night * p ); //sfield->clr.a = std::min( night, static_cast<UINT>( 255 * p ) ); if(Time > 20.0){ if(text) text->setText("Twilight"); }else{ if(text) text->setText("Evening"); } }else if( Time < 6 ){ float p = 1 - (Time - 2) / 4.0f; sfield->clr.a = std::min( night , static_cast<UINT>( 256 * p ) ); //sfield->clr.a = static_cast<int>( night * p ); if( Time > 4 ){ if(text) text->setText("Dawn"); }else{ if(text) text->setText("Night"); } }else{ if( sfield->clr.a != 0 ) sfield->clr.a = 0; if( Time < 11 ){ if(text) text->setText("Morning"); }else if( Time > 14 ){ if(text) text->setText("Afternoon"); }else{ if(text) text->setText("Noon"); } } glUseProgram( sfield->shader ); if( Time > 4 && Time < 8 ){ float p = (Time - 4.0f) / 4.0f; glUniform4f( colorLight, p, p, 0.0f, 0.25f * (float)sin( M_PI * ( 1.0f - p )) ); }else{ glUniform4f( colorLight, 0.0f, 0.0f, 0.0f, 0.0f ); } glUseProgram( 0 ); }