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