void Shader::setUniform(const std::string & uniformName, const glm::vec3 & vector)
{
if (m_uniforms_locations.count(uniformName))
{
glProgramUniform3fv(m_program_id, m_uniforms_locations[uniformName], 1, glm::value_ptr(vector));
}
else
{
if (getUniformLocation(uniformName))
{
glProgramUniform3fv(m_program_id, m_uniforms_locations[uniformName], 1, glm::value_ptr(vector));
}
}
}
void RMesh_CreatePrograms (void)
{
glGetIntegerv (GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &gl_meshuboblocksize);
if (gl_meshuboblocksize < sizeof (meshubo_t))
{
int addsize = gl_meshuboblocksize;
while (gl_meshuboblocksize < sizeof (meshubo_t))
gl_meshuboblocksize += addsize;
}
gl_meshprog = GL_CreateShaderFromName ("glsl/mesh.glsl", "MeshVS", "MeshFS");
glUniformBlockBinding (gl_meshprog, glGetUniformBlockIndex (gl_meshprog, "MeshUniforms"), gl_meshubobinding);
glProgramUniform1i (gl_meshprog, glGetUniformLocation (gl_meshprog, "diffuse"), 0);
glProgramUniform3fv (gl_meshprog, glGetUniformLocation (gl_meshprog, "lightnormal"), 162, (float *) r_avertexnormals);
u_meshMaxLights = glGetUniformLocation(gl_meshprog, "r_maxLights");
u_meshEntOrig = glGetUniformLocation(gl_meshprog, "r_entOrig");
for (int i = 0; i < MAX_LIGHTS; ++i)
{
u_meshLightPos[i] = glGetUniformLocation(gl_meshprog, va("Lights.origin[%i]", i));
u_meshLightColor[i] = glGetUniformLocation(gl_meshprog, va("Lights.color[%i]", i));
u_meshLightAtten[i] = glGetUniformLocation(gl_meshprog, va("Lights.radius[%i]", i));
}
glGenBuffers (1, &gl_meshubo);
glNamedBufferDataEXT (gl_meshubo, MESH_UBO_MAX_BLOCKS * gl_meshuboblocksize, NULL, GL_STREAM_DRAW);
}
static void shader_setval_data(shader_t shader, sparam_t param,
const void *val, int count)
{
if (!matching_shader(shader, param))
return;
if (param->type == SHADER_PARAM_BOOL ||
param->type == SHADER_PARAM_INT) {
glProgramUniform1iv(shader->program, param->param, count, val);
gl_success("glProgramUniform1iv");
} else if (param->type == SHADER_PARAM_FLOAT) {
glProgramUniform1fv(shader->program, param->param, count, val);
gl_success("glProgramUniform1fv");
} else if (param->type == SHADER_PARAM_VEC2) {
glProgramUniform2fv(shader->program, param->param, count, val);
gl_success("glProgramUniform2fv");
} else if (param->type == SHADER_PARAM_VEC3) {
glProgramUniform3fv(shader->program, param->param, count, val);
gl_success("glProgramUniform3fv");
} else if (param->type == SHADER_PARAM_VEC4) {
glProgramUniform4fv(shader->program, param->param, count, val);
gl_success("glProgramUniform4fv");
} else if (param->type == SHADER_PARAM_MATRIX4X4) {
glProgramUniformMatrix4fv(shader->program, param->param,
count, false, val);
gl_success("glProgramUniformMatrix4fv");
}
}
void
ShaderProgram::setUniform(const char* param, const glm::vec3& val)
{
unsigned int loc = getUniformLocation(param);
// gl_check(glUniform3fv(m_programId, loc, 1, glm::value_ptr(val)));
gl_check(glProgramUniform3fv(m_programId, loc, 1, glm::value_ptr(val)));
}
void cShader::SetUniform3(GLuint handle, const tVector& data) const
{
float f_data[] = {static_cast<float>(data[0]),
static_cast<float>(data[1]),
static_cast<float>(data[2])};
glProgramUniform3fv(mProg, handle, 1, f_data);
}
void shader_setvec3(shader_t shader, sparam_t param,
const struct vec3 *val)
{
if (matching_shader(shader, param)) {
glProgramUniform3fv(shader->program, param->param, 1, val->ptr);
gl_success("glProgramUniform3fv");
}
}
void ProgramMonolithicDsa::setUniform3fv(handle uniformHandle, const float *value)
{
if (static_cast<OpenGLRenderer&>(getRenderer()).getExtensions().isGL_ARB_direct_state_access())
{
glProgramUniform3fv(mOpenGLProgram, static_cast<GLint>(uniformHandle), 1, value);
}
else
{
glProgramUniform3fvEXT(mOpenGLProgram, static_cast<GLint>(uniformHandle), 1, value);
}
}
void ProgramSeparateDsa::setUniform3fv(handle uniformHandle, const float *value)
{
if (static_cast<OpenGLRenderer&>(getRenderer()).getExtensions().isGL_ARB_direct_state_access())
{
glProgramUniform3fv(mVertexShaderSeparate->getOpenGLShaderProgram(), static_cast<GLint>(uniformHandle), 1, value);
}
else
{
glProgramUniform3fvEXT(mVertexShaderSeparate->getOpenGLShaderProgram(), static_cast<GLint>(uniformHandle), 1, value);
}
}
void RenderCB(GlRunner *runner)
{
glClearColor(0.0, 0.0, 0.0, 1.0);
glClearDepthf(1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// fix point light location, and move ground instead
model_mat = glm::translate(glm::vec3(roam_x, roam_y, roam_z));
glProgramUniformMatrix4fv(VS, glGetUniformLocation(VS, "uModel"), 1, GL_FALSE, &model_mat[0][0]);
glProgramUniformMatrix4fv(VS, glGetUniformLocation(VS, "uView"), 1, GL_FALSE, &view_mat[0][0]);
glProgramUniformMatrix4fv(VS, glGetUniformLocation(VS, "uProj"), 1, GL_FALSE, &proj_mat[0][0]);
glProgramUniform3fv(FS, glGetUniformLocation(FS, "uLightLoc"), 1, &light_loc[0]);
glProgramUniform3fv(FS, glGetUniformLocation(FS, "uAntenna"), 1, &light_antenna[0]);
glProgramUniform1f(FS, glGetUniformLocation(FS, "uRadians"), 3.1415926/6.0);
glDrawArrays(GL_TRIANGLES, 0, 6);
}
void Shader::SendVector(int location, const Vector3f& vector) const
{
if (location == -1)
return;
if (glProgramUniform3fv)
glProgramUniform3fv(m_program, location, 1, vector);
else
{
OpenGL::BindProgram(m_program);
glUniform3fv(location, 1, vector);
}
}
// Set a vec3
void Material::SetVec3( const std::string& name, const glm::vec3& value )
{
GLint location = GetUniformLocation( name );
if ( glProgramUniform3fv )
{
glProgramUniform3fv( _program, location, 1, glm::value_ptr( value ) );
}
else
{
glUseProgram( _program );
glUniform3fv( location, 1, glm::value_ptr( value ) );
}
}
void Shader::SendVectorArray(int location, const Vector3f* vectors, unsigned int count) const
{
if (location == -1)
return;
if (glProgramUniform3fv)
glProgramUniform3fv(m_program, location, count, reinterpret_cast<const float*>(vectors));
else
{
OpenGL::BindProgram(m_program);
glUniform3fv(location, count, reinterpret_cast<const float*>(vectors));
}
}
void
program::set_uniform3fv(char const* varname, GLsizei count, GLfloat* value) const
{
GLint location = get_uniform_location(varname);
if (location >= 0)
{
#if GPUCAST_GL_DIRECT_STATE_ACCESS
glProgramUniform3fv(id_, location, count, value);
#else
glUniform3fv(location, count, value);
#endif
}
}
void init()
{
// Build our program and an empty VAO
gs.program = buildProgram("basic.vsl", "basic.fsl");
gs.mesh = Mesh(glm::vec3(0,0,0),"monkey_smooth.obj");
gs.bufferSize = 0;
float* data = gs.mesh.getVertices(gs.bufferSize);
glEnable(GL_DEPTH_TEST);
//glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
glGenBuffers(1, &gs.buffer);
glBindBuffer(GL_ARRAY_BUFFER, gs.buffer);
//glBufferData(GL_ARRAY_BUFFER, 12 * sizeof(float), gs.data, GL_STATIC_DRAW);
glBufferData(GL_ARRAY_BUFFER, gs.bufferSize * sizeof(float), data, GL_STATIC_DRAW);
//// Mesh Principal
glCreateVertexArrays(1, &gs.vao);
glBindVertexArray(gs.vao);
// Position des points
glVertexAttribPointer(POINTS, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), 0);
glEnableVertexAttribArray(POINTS);
// Normales
glVertexAttribPointer(NORMALS, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)(3 * sizeof(float)));
glEnableVertexAttribArray(NORMALS);
//// Light
glProgramUniform3fv(gs.program, LIGHT, 1, &gs.lightPosition[0]);
//// Shadow map
glGenTextures(1, &gs.depthTexture);
glBindTexture(GL_TEXTURE_2D, gs.depthTexture);
glTexStorage2D(GL_TEXTURE_2D, 1, GL_DEPTH_COMPONENT32F, TEXTURESIZE, TEXTURESIZE);
glGenFramebuffers(1, &gs.fbo);
glBindFramebuffer(GL_FRAMEBUFFER, gs.fbo);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, gs.depthTexture, 0);
assert(glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, gs.depthTexture);
glBindVertexArray(0);
}
void pass(int width, int height, PassType type)
{
glClear(GL_DEPTH_BUFFER_BIT);
glClear(GL_COLOR_BUFFER_BIT);
glProgramUniform1f(gs.program, COLOR, gs.color);
//gs.lightPosition = glm::vec3(sin(gs.time / 10) * 1.5, cos(gs.time / 10) * 1.5, 3.5);
glProgramUniform3fv(gs.program, LIGHT, 1, &gs.lightPosition[0]);
switch (type)
{
case PassType::light:
{
glm::mat4 perspective = glm::perspective(45.0, (double)width / (double)height, 1.0, 100.0);
glm::mat4 lookAt = glm::lookAt(gs.lightPosition, glm::vec3(0, 0, 0), glm::vec3(0, 0, 1));
gs.mat = perspective*lookAt;
gs.matLight = gs.mat;
break;
}
default:
case PassType::mainCamera:
{
glm::mat4 perspective = glm::perspective(45.0, (double)width / (double)height, 1.0, 100.0);
//glm::mat4 lookAt = glm::lookAt(glm::vec3(3.5, 3.5, 2.5), glm::vec3(0, 0, 0), glm::vec3(0, 0, 1));
glm::mat4 lookAt = glm::lookAt(glm::vec3(sin(gs.time / 10)*5.0, cos(gs.time / 10)*5.0, 1.5), glm::vec3(0, 0, 0), glm::vec3(0, 0, 1));
gs.mat = perspective*lookAt;
break;
}
}
glProgramUniformMatrix4fv(gs.program, MATRIX, 1, false, &gs.mat[0][0]);
glProgramUniformMatrix4fv(gs.program, MATRIXLIGHT, 1, false, &gs.matLight[0][0]);
glUseProgram(gs.program);
glBindVertexArray(gs.vao);
{
glDrawArrays(GL_TRIANGLES, 0, gs.bufferSize);
}
glBindVertexArray(0);
glUseProgram(0);
}
void Variable::set(const glm::vec3& value)
{
glProgramUniform3fv(program, location, 1, &value[0]);
}
void GLSLSeparableProgram::updateUniforms(GpuProgramParametersSharedPtr params,
uint16 mask, GpuProgramType fromProgType)
{
// Iterate through uniform reference list and update uniform values
GLUniformReferenceIterator currentUniform = mGLUniformReferences.begin();
GLUniformReferenceIterator endUniform = mGLUniformReferences.end();
// determine if we need to transpose matrices when binding
int transpose = GL_TRUE;
if ((fromProgType == GPT_FRAGMENT_PROGRAM && mVertexShader && (!mVertexShader->getColumnMajorMatrices())) ||
(fromProgType == GPT_VERTEX_PROGRAM && mFragmentShader && (!mFragmentShader->getColumnMajorMatrices())) ||
(fromProgType == GPT_GEOMETRY_PROGRAM && mGeometryShader && (!mGeometryShader->getColumnMajorMatrices())) ||
(fromProgType == GPT_HULL_PROGRAM && mHullShader && (!mHullShader->getColumnMajorMatrices())) ||
(fromProgType == GPT_DOMAIN_PROGRAM && mDomainShader && (!mDomainShader->getColumnMajorMatrices())) ||
(fromProgType == GPT_COMPUTE_PROGRAM && mComputeShader && (!mComputeShader->getColumnMajorMatrices())))
{
transpose = GL_FALSE;
}
GLuint progID = 0;
if (fromProgType == GPT_VERTEX_PROGRAM)
{
progID = mVertexShader->getGLProgramHandle();
}
else if (fromProgType == GPT_FRAGMENT_PROGRAM)
{
progID = mFragmentShader->getGLProgramHandle();
}
else if (fromProgType == GPT_GEOMETRY_PROGRAM)
{
progID = mGeometryShader->getGLProgramHandle();
}
else if (fromProgType == GPT_HULL_PROGRAM)
{
progID = mHullShader->getGLProgramHandle();
}
else if (fromProgType == GPT_DOMAIN_PROGRAM)
{
progID = mDomainShader->getGLProgramHandle();
}
else if (fromProgType == GPT_COMPUTE_PROGRAM)
{
progID = mComputeShader->getGLProgramHandle();
}
for (; currentUniform != endUniform; ++currentUniform)
{
// Only pull values from buffer it's supposed to be in (vertex or fragment)
// This method will be called once per shader stage.
if (fromProgType == currentUniform->mSourceProgType)
{
const GpuConstantDefinition* def = currentUniform->mConstantDef;
if (def->variability & mask)
{
GLsizei glArraySize = (GLsizei)def->arraySize;
// Get the index in the parameter real list
switch (def->constType)
{
case GCT_FLOAT1:
OGRE_CHECK_GL_ERROR(glProgramUniform1fv(progID, currentUniform->mLocation, glArraySize,
params->getFloatPointer(def->physicalIndex)));
break;
case GCT_FLOAT2:
OGRE_CHECK_GL_ERROR(glProgramUniform2fv(progID, currentUniform->mLocation, glArraySize,
params->getFloatPointer(def->physicalIndex)));
break;
case GCT_FLOAT3:
OGRE_CHECK_GL_ERROR(glProgramUniform3fv(progID, currentUniform->mLocation, glArraySize,
params->getFloatPointer(def->physicalIndex)));
break;
case GCT_FLOAT4:
OGRE_CHECK_GL_ERROR(glProgramUniform4fv(progID, currentUniform->mLocation, glArraySize,
params->getFloatPointer(def->physicalIndex)));
break;
case GCT_MATRIX_2X2:
OGRE_CHECK_GL_ERROR(glProgramUniformMatrix2fv(progID, currentUniform->mLocation, glArraySize,
transpose, params->getFloatPointer(def->physicalIndex)));
break;
case GCT_MATRIX_3X3:
OGRE_CHECK_GL_ERROR(glProgramUniformMatrix3fv(progID, currentUniform->mLocation, glArraySize,
transpose, params->getFloatPointer(def->physicalIndex)));
break;
case GCT_MATRIX_4X4:
OGRE_CHECK_GL_ERROR(glProgramUniformMatrix4fv(progID, currentUniform->mLocation, glArraySize,
transpose, params->getFloatPointer(def->physicalIndex)));
break;
case GCT_INT1:
OGRE_CHECK_GL_ERROR(glProgramUniform1iv(progID, currentUniform->mLocation, glArraySize,
params->getIntPointer(def->physicalIndex)));
break;
case GCT_INT2:
OGRE_CHECK_GL_ERROR(glProgramUniform2iv(progID, currentUniform->mLocation, glArraySize,
params->getIntPointer(def->physicalIndex)));
break;
case GCT_INT3:
OGRE_CHECK_GL_ERROR(glProgramUniform3iv(progID, currentUniform->mLocation, glArraySize,
params->getIntPointer(def->physicalIndex)));
break;
case GCT_INT4:
OGRE_CHECK_GL_ERROR(glProgramUniform4iv(progID, currentUniform->mLocation, glArraySize,
params->getIntPointer(def->physicalIndex)));
break;
case GCT_MATRIX_2X3:
OGRE_CHECK_GL_ERROR(glProgramUniformMatrix2x3fv(progID, currentUniform->mLocation, glArraySize,
transpose, params->getFloatPointer(def->physicalIndex)));
break;
case GCT_MATRIX_2X4:
OGRE_CHECK_GL_ERROR(glProgramUniformMatrix2x4fv(progID, currentUniform->mLocation, glArraySize,
transpose, params->getFloatPointer(def->physicalIndex)));
break;
case GCT_MATRIX_3X2:
OGRE_CHECK_GL_ERROR(glProgramUniformMatrix3x2fv(progID, currentUniform->mLocation, glArraySize,
transpose, params->getFloatPointer(def->physicalIndex)));
break;
case GCT_MATRIX_3X4:
OGRE_CHECK_GL_ERROR(glProgramUniformMatrix3x4fv(progID, currentUniform->mLocation, glArraySize,
transpose, params->getFloatPointer(def->physicalIndex)));
break;
case GCT_MATRIX_4X2:
OGRE_CHECK_GL_ERROR(glProgramUniformMatrix4x2fv(progID, currentUniform->mLocation, glArraySize,
transpose, params->getFloatPointer(def->physicalIndex)));
break;
case GCT_MATRIX_4X3:
OGRE_CHECK_GL_ERROR(glProgramUniformMatrix4x3fv(progID, currentUniform->mLocation, glArraySize,
transpose, params->getFloatPointer(def->physicalIndex)));
break;
case GCT_DOUBLE1:
OGRE_CHECK_GL_ERROR(glProgramUniform1dv(progID, currentUniform->mLocation, glArraySize,
params->getDoublePointer(def->physicalIndex)));
break;
case GCT_DOUBLE2:
OGRE_CHECK_GL_ERROR(glProgramUniform2dv(progID, currentUniform->mLocation, glArraySize,
params->getDoublePointer(def->physicalIndex)));
break;
case GCT_DOUBLE3:
OGRE_CHECK_GL_ERROR(glProgramUniform3dv(progID, currentUniform->mLocation, glArraySize,
params->getDoublePointer(def->physicalIndex)));
break;
case GCT_DOUBLE4:
OGRE_CHECK_GL_ERROR(glProgramUniform4dv(progID, currentUniform->mLocation, glArraySize,
params->getDoublePointer(def->physicalIndex)));
break;
case GCT_MATRIX_DOUBLE_2X2:
OGRE_CHECK_GL_ERROR(glProgramUniformMatrix2dv(progID, currentUniform->mLocation, glArraySize,
transpose, params->getDoublePointer(def->physicalIndex)));
break;
case GCT_MATRIX_DOUBLE_3X3:
OGRE_CHECK_GL_ERROR(glProgramUniformMatrix3dv(progID, currentUniform->mLocation, glArraySize,
transpose, params->getDoublePointer(def->physicalIndex)));
break;
case GCT_MATRIX_DOUBLE_4X4:
OGRE_CHECK_GL_ERROR(glProgramUniformMatrix4dv(progID, currentUniform->mLocation, glArraySize,
transpose, params->getDoublePointer(def->physicalIndex)));
break;
case GCT_MATRIX_DOUBLE_2X3:
OGRE_CHECK_GL_ERROR(glProgramUniformMatrix2x3dv(progID, currentUniform->mLocation, glArraySize,
transpose, params->getDoublePointer(def->physicalIndex)));
break;
case GCT_MATRIX_DOUBLE_2X4:
OGRE_CHECK_GL_ERROR(glProgramUniformMatrix2x4dv(progID, currentUniform->mLocation, glArraySize,
transpose, params->getDoublePointer(def->physicalIndex)));
break;
case GCT_MATRIX_DOUBLE_3X2:
OGRE_CHECK_GL_ERROR(glProgramUniformMatrix3x2dv(progID, currentUniform->mLocation, glArraySize,
transpose, params->getDoublePointer(def->physicalIndex)));
break;
case GCT_MATRIX_DOUBLE_3X4:
OGRE_CHECK_GL_ERROR(glProgramUniformMatrix3x4dv(progID, currentUniform->mLocation, glArraySize,
transpose, params->getDoublePointer(def->physicalIndex)));
break;
case GCT_MATRIX_DOUBLE_4X2:
OGRE_CHECK_GL_ERROR(glProgramUniformMatrix4x2dv(progID, currentUniform->mLocation, glArraySize,
transpose, params->getDoublePointer(def->physicalIndex)));
break;
case GCT_MATRIX_DOUBLE_4X3:
OGRE_CHECK_GL_ERROR(glProgramUniformMatrix4x3dv(progID, currentUniform->mLocation, glArraySize,
transpose, params->getDoublePointer(def->physicalIndex)));
break;
case GCT_UINT1:
case GCT_BOOL1:
OGRE_CHECK_GL_ERROR(glProgramUniform1uiv(progID, currentUniform->mLocation, glArraySize,
params->getUnsignedIntPointer(def->physicalIndex)));
break;
case GCT_UINT2:
case GCT_BOOL2:
OGRE_CHECK_GL_ERROR(glProgramUniform2uiv(progID, currentUniform->mLocation, glArraySize,
params->getUnsignedIntPointer(def->physicalIndex)));
break;
case GCT_UINT3:
case GCT_BOOL3:
OGRE_CHECK_GL_ERROR(glProgramUniform3uiv(progID, currentUniform->mLocation, glArraySize,
params->getUnsignedIntPointer(def->physicalIndex)));
break;
case GCT_UINT4:
case GCT_BOOL4:
OGRE_CHECK_GL_ERROR(glProgramUniform4uiv(progID, currentUniform->mLocation, glArraySize,
params->getUnsignedIntPointer(def->physicalIndex)));
break;
case GCT_SAMPLER1D:
case GCT_SAMPLER1DSHADOW:
case GCT_SAMPLER2D:
case GCT_SAMPLER2DSHADOW:
case GCT_SAMPLER2DARRAY:
case GCT_SAMPLER3D:
case GCT_SAMPLERCUBE:
case GCT_SAMPLERRECT:
// Samplers handled like 1-element ints
OGRE_CHECK_GL_ERROR(glProgramUniform1iv(progID, currentUniform->mLocation, 1,
params->getIntPointer(def->physicalIndex)));
break;
case GCT_UNKNOWN:
case GCT_SUBROUTINE:
break;
} // End switch
} // Variability & mask
} // fromProgType == currentUniform->mSourceProgType
} // End for
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL41_nglProgramUniform3fv(JNIEnv *env, jclass clazz, jint program, jint location, jint count, jlong value, jlong function_pointer) {
const GLfloat *value_address = (const GLfloat *)(intptr_t)value;
glProgramUniform3fvPROC glProgramUniform3fv = (glProgramUniform3fvPROC)((intptr_t)function_pointer);
glProgramUniform3fv(program, location, count, value_address);
}
///
//Renders a gameobject as it's mesh.
//
//Parameters:
// GO: Game object to render
void RenderingManager_Render(LinkedList* gameObjects)
{
//Clear buffers
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//Set directional light
glProgramUniform3fv(renderingBuffer->shaderPrograms[0]->shaderProgramID, renderingBuffer->shaderPrograms[0]->directionalLightVectorLocation, 1, renderingBuffer->directionalLightVector->components);
Matrix modelMatrix;
Matrix_INIT_ON_STACK(modelMatrix, 4, 4);
Matrix viewMatrix;
Matrix_INIT_ON_STACK(viewMatrix, 4, 4);
Matrix modelViewProjectionMatrix;
Matrix_INIT_ON_STACK(modelViewProjectionMatrix, 4, 4);
//Turn camera's frame of reference into view matrix
Camera_ToMatrix4(renderingBuffer->camera, &viewMatrix);
//Set viewMatrix uniform
glProgramUniformMatrix4fv(renderingBuffer->shaderPrograms[0]->shaderProgramID, renderingBuffer->shaderPrograms[0]->viewMatrixLocation, 1, GL_TRUE, viewMatrix.components);
//Set projectionMatrix Uniform
glProgramUniformMatrix4fv(renderingBuffer->shaderPrograms[0]->shaderProgramID, renderingBuffer->shaderPrograms[0]->projectionMatrixLocation, 1, GL_TRUE, renderingBuffer->camera->projectionMatrix->components);
struct LinkedList_Node* current = gameObjects->head;
while (current != NULL)
{
GObject* gameObj = (GObject*)(current->data);
//Render gameobject's mesh if it exists
if (gameObj->mesh != NULL)
{
//Set color matrix
glProgramUniformMatrix4fv(renderingBuffer->shaderPrograms[0]->shaderProgramID, renderingBuffer->shaderPrograms[0]->colorMatrixLocation, 1, GL_TRUE, gameObj->colorMatrix->components);
//Set modelMatrix uniform
FrameOfReference_ToMatrix4(gameObj->frameOfReference, &modelMatrix);
glProgramUniformMatrix4fv(renderingBuffer->shaderPrograms[0]->shaderProgramID, renderingBuffer->shaderPrograms[0]->modelMatrixLocation, 1, GL_TRUE, modelMatrix.components);
//Construct modelViewProjectionMatrix
Matrix_Copy(&modelViewProjectionMatrix, &modelMatrix);
Matrix_TransformMatrix(&viewMatrix, &modelViewProjectionMatrix);
Matrix_TransformMatrix(renderingBuffer->camera->projectionMatrix, &modelViewProjectionMatrix);
//Set modelViewProjectionMatrix uniform
glProgramUniformMatrix4fv(renderingBuffer->shaderPrograms[0]->shaderProgramID, renderingBuffer->shaderPrograms[0]->modelViewProjectionMatrixLocation, 1, GL_TRUE, modelViewProjectionMatrix.components);
if (gameObj->texture != NULL)
{
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, gameObj->texture->textureID);
//Send texture to uniform
glUniform1i(renderingBuffer->shaderPrograms[0]->textureLocation, 0);
}
else
{
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, AssetManager_LookupTexture("Test")->textureID);
//Send texture to uniform
glUniform1i(renderingBuffer->shaderPrograms[0]->textureLocation, 0);
}
//Setup GPU program to draw this mesh
Mesh_Render(gameObj->mesh, gameObj->mesh->primitive);
}
//Render gameObject's collider if it exists & in debug mode
if(gameObj->collider != NULL && gameObj->collider->debug)
{
//Set color matrix
glProgramUniformMatrix4fv(renderingBuffer->shaderPrograms[0]->shaderProgramID, renderingBuffer->shaderPrograms[0]->colorMatrixLocation, 1, GL_TRUE, gameObj->collider->colorMatrix->components);
//Create modelMatrix from correct Frame Of Reference
if(gameObj->body != NULL)
{
FrameOfReference_ToMatrix4(gameObj->body->frame, &modelMatrix);
}
else
{
FrameOfReference_ToMatrix4(gameObj->frameOfReference, &modelMatrix);
}
//If the object has an AABB collider, take into account the offset
if(gameObj->collider->type == COLLIDER_AABB)
{
ColliderData_AABB* AABB = gameObj->collider->data->AABBData;
*Matrix_Index(&modelMatrix, 0, 3) += AABB->centroid->components[0];
*Matrix_Index(&modelMatrix, 1, 3) += AABB->centroid->components[1];
*Matrix_Index(&modelMatrix, 2, 3) += AABB->centroid->components[2];
}
//Set the modelMatrix
glProgramUniformMatrix4fv(renderingBuffer->shaderPrograms[0]->shaderProgramID, renderingBuffer->shaderPrograms[0]->modelMatrixLocation, 1, GL_TRUE, modelMatrix.components);
//Construct modelViewProjectionMatrix
Matrix_Copy(&modelViewProjectionMatrix, &modelMatrix);
Matrix_TransformMatrix(&viewMatrix, &modelViewProjectionMatrix);
Matrix_TransformMatrix(renderingBuffer->camera->projectionMatrix, &modelViewProjectionMatrix);
//Set modelViewProjectionMatrix uniform
glProgramUniformMatrix4fv(renderingBuffer->shaderPrograms[0]->shaderProgramID, renderingBuffer->shaderPrograms[0]->modelViewProjectionMatrixLocation, 1, GL_TRUE, modelViewProjectionMatrix.components);
//Bind white texture
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, AssetManager_LookupTexture("White")->textureID);
//Send texture to uniform
glUniform1i(renderingBuffer->shaderPrograms[0]->textureLocation, 0);
//Setup GPU program to draw this mesh
Mesh_Render(gameObj->collider->representation, GL_LINES);
//TODO: Remove
//Change the color of colliders to green until they collide
*Matrix_Index(gameObj->collider->colorMatrix, 0, 0) = 0.0f;
*Matrix_Index(gameObj->collider->colorMatrix, 1, 1) = 1.0f;
*Matrix_Index(gameObj->collider->colorMatrix, 2, 2) = 0.0f;
}
current = current->next;
}
//Render the oct tree
if(renderingBuffer->debugOctTree)
{
//Set the color matrix
Matrix octTreeColor;
Matrix_INIT_ON_STACK(octTreeColor, 4, 4);
*Matrix_Index(&octTreeColor, 0, 0) = 0.0f;
*Matrix_Index(&octTreeColor, 1, 1) = 1.0f;
*Matrix_Index(&octTreeColor, 2, 2) = 0.0f;
glProgramUniformMatrix4fv(renderingBuffer->shaderPrograms[0]->shaderProgramID, renderingBuffer->shaderPrograms[0]->colorMatrixLocation, 1, GL_TRUE, octTreeColor.components);
Mesh* cube = AssetManager_LookupMesh("CubeWire");
Texture* white = AssetManager_LookupTexture("White");
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, white->textureID);
//Send texture to uniform
glUniform1i(renderingBuffer->shaderPrograms[0]->textureLocation, 0);
RenderingManager_RenderOctTree(ObjectManager_GetObjectBuffer().octTree->root, &modelViewProjectionMatrix, &viewMatrix, renderingBuffer->camera->projectionMatrix, cube);
}
//Start drawing threads on gpu
glFlush();
}
void Shader::uniform3f(GLint location, const glm::vec3& vec) const
{
glProgramUniform3fv(id_, location, 1, glm::value_ptr(vec));
}
void
VSShaderLib::setUniform(std::string name, void *value) {
myUniforms u = pUniforms[name];
switch (u.type) {
// Floats
case GL_FLOAT:
glProgramUniform1fv(pProgram, u.location, u.size, (const GLfloat *)value);
break;
case GL_FLOAT_VEC2:
glProgramUniform2fv(pProgram, u.location, u.size, (const GLfloat *)value);
break;
case GL_FLOAT_VEC3:
glProgramUniform3fv(pProgram, u.location, u.size, (const GLfloat *)value);
break;
case GL_FLOAT_VEC4:
glProgramUniform4fv(pProgram, u.location, u.size, (const GLfloat *)value);
break;
#ifndef __ANDROID_API__
// Doubles
case GL_DOUBLE:
glProgramUniform1dv(pProgram, u.location, u.size, (const GLdouble *)value);
break;
case GL_DOUBLE_VEC2:
glProgramUniform2dv(pProgram, u.location, u.size, (const GLdouble *)value);
break;
case GL_DOUBLE_VEC3:
glProgramUniform3dv(pProgram, u.location, u.size, (const GLdouble *)value);
break;
case GL_DOUBLE_VEC4:
glProgramUniform4dv(pProgram, u.location, u.size, (const GLdouble *)value);
break;
#endif
// Samplers, Ints and Bools
#ifndef __ANDROID_API__
case GL_IMAGE_1D :
case GL_IMAGE_2D_RECT :
case GL_IMAGE_BUFFER :
case GL_IMAGE_1D_ARRAY :
case GL_IMAGE_CUBE_MAP_ARRAY :
case GL_IMAGE_2D_MULTISAMPLE :
case GL_IMAGE_2D_MULTISAMPLE_ARRAY :
case GL_INT_IMAGE_1D :
case GL_INT_IMAGE_2D_RECT :
case GL_INT_IMAGE_BUFFER :
case GL_INT_IMAGE_1D_ARRAY :
case GL_INT_IMAGE_CUBE_MAP_ARRAY :
case GL_INT_IMAGE_2D_MULTISAMPLE :
case GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY :
case GL_UNSIGNED_INT_IMAGE_1D :
case GL_UNSIGNED_INT_IMAGE_2D_RECT :
case GL_UNSIGNED_INT_IMAGE_BUFFER :
case GL_UNSIGNED_INT_IMAGE_1D_ARRAY :
case GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY :
case GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE :
case GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY :
#endif
case GL_IMAGE_2D :
case GL_IMAGE_3D :
case GL_IMAGE_CUBE :
case GL_IMAGE_2D_ARRAY :
case GL_INT_IMAGE_2D :
case GL_INT_IMAGE_3D :
case GL_INT_IMAGE_CUBE :
case GL_INT_IMAGE_2D_ARRAY :
case GL_UNSIGNED_INT_IMAGE_2D :
case GL_UNSIGNED_INT_IMAGE_3D :
case GL_UNSIGNED_INT_IMAGE_CUBE :
case GL_UNSIGNED_INT_IMAGE_2D_ARRAY :
#ifndef __ANDROID_API__
case GL_SAMPLER_1D:
case GL_SAMPLER_1D_SHADOW:
case GL_SAMPLER_1D_ARRAY:
case GL_SAMPLER_1D_ARRAY_SHADOW:
case GL_SAMPLER_2D_MULTISAMPLE_ARRAY:
case GL_SAMPLER_BUFFER:
case GL_SAMPLER_2D_RECT:
case GL_SAMPLER_2D_RECT_SHADOW:
case GL_INT_SAMPLER_1D:
case GL_INT_SAMPLER_1D_ARRAY:
case GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY:
case GL_INT_SAMPLER_BUFFER:
case GL_INT_SAMPLER_2D_RECT:
case GL_UNSIGNED_INT_SAMPLER_1D:
case GL_UNSIGNED_INT_SAMPLER_1D_ARRAY:
case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY:
case GL_UNSIGNED_INT_SAMPLER_BUFFER:
case GL_UNSIGNED_INT_SAMPLER_2D_RECT:
#endif
case GL_SAMPLER_2D:
case GL_SAMPLER_3D:
case GL_SAMPLER_CUBE:
case GL_SAMPLER_2D_SHADOW:
case GL_SAMPLER_2D_ARRAY:
case GL_SAMPLER_2D_ARRAY_SHADOW:
case GL_SAMPLER_2D_MULTISAMPLE:
case GL_SAMPLER_CUBE_SHADOW:
case GL_INT_SAMPLER_2D:
case GL_INT_SAMPLER_3D:
case GL_INT_SAMPLER_CUBE:
case GL_INT_SAMPLER_2D_ARRAY:
case GL_INT_SAMPLER_2D_MULTISAMPLE:
case GL_UNSIGNED_INT_SAMPLER_2D:
case GL_UNSIGNED_INT_SAMPLER_3D:
case GL_UNSIGNED_INT_SAMPLER_CUBE:
case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:
case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE:
case GL_BOOL:
case GL_INT :
glProgramUniform1iv(pProgram, u.location, u.size, (const GLint *)value);
break;
case GL_BOOL_VEC2:
case GL_INT_VEC2:
glProgramUniform2iv(pProgram, u.location, u.size, (const GLint *)value);
break;
case GL_BOOL_VEC3:
case GL_INT_VEC3:
glProgramUniform3iv(pProgram, u.location, u.size, (const GLint *)value);
break;
case GL_BOOL_VEC4:
case GL_INT_VEC4:
glProgramUniform4iv(pProgram, u.location, u.size, (const GLint *)value);
break;
// Unsigned ints
case GL_UNSIGNED_INT:
glProgramUniform1uiv(pProgram, u.location, u.size, (const GLuint *)value);
break;
case GL_UNSIGNED_INT_VEC2:
glProgramUniform2uiv(pProgram, u.location, u.size, (const GLuint *)value);
break;
case GL_UNSIGNED_INT_VEC3:
glProgramUniform3uiv(pProgram, u.location, u.size, (const GLuint *)value);
break;
case GL_UNSIGNED_INT_VEC4:
glProgramUniform4uiv(pProgram, u.location, u.size, (const GLuint *)value);
break;
// Float Matrices
case GL_FLOAT_MAT2:
glProgramUniformMatrix2fv(pProgram, u.location, u.size, GL_FALSE, (const GLfloat *)value);
break;
case GL_FLOAT_MAT3:
glProgramUniformMatrix3fv(pProgram, u.location, u.size, GL_FALSE, (const GLfloat *)value);
break;
case GL_FLOAT_MAT4:
glProgramUniformMatrix4fv(pProgram, u.location, u.size, GL_FALSE, (const GLfloat *)value);
break;
case GL_FLOAT_MAT2x3:
glProgramUniformMatrix2x3fv(pProgram, u.location, u.size, GL_FALSE, (const GLfloat *)value);
break;
case GL_FLOAT_MAT2x4:
glProgramUniformMatrix2x4fv(pProgram, u.location, u.size, GL_FALSE, (const GLfloat *)value);
break;
case GL_FLOAT_MAT3x2:
glProgramUniformMatrix3x2fv(pProgram, u.location, u.size, GL_FALSE, (const GLfloat *)value);
break;
case GL_FLOAT_MAT3x4:
glProgramUniformMatrix3x4fv(pProgram, u.location, u.size, GL_FALSE, (const GLfloat *)value);
break;
case GL_FLOAT_MAT4x2:
glProgramUniformMatrix4x2fv(pProgram, u.location, u.size, GL_FALSE, (const GLfloat *)value);
break;
case GL_FLOAT_MAT4x3:
glProgramUniformMatrix4x3fv(pProgram, u.location, u.size, GL_FALSE, (const GLfloat *)value);
break;
#ifndef __ANDROID_API__
// Double Matrices
case GL_DOUBLE_MAT2:
glProgramUniformMatrix2dv(pProgram, u.location, u.size, false, (const GLdouble *)value);
break;
case GL_DOUBLE_MAT3:
glProgramUniformMatrix3dv(pProgram, u.location, u.size, false, (const GLdouble *)value);
break;
case GL_DOUBLE_MAT4:
glProgramUniformMatrix4dv(pProgram, u.location, u.size, false, (const GLdouble *)value);
break;
case GL_DOUBLE_MAT2x3:
glProgramUniformMatrix2x3dv(pProgram, u.location, u.size, false, (const GLdouble *)value);
break;
case GL_DOUBLE_MAT2x4:
glProgramUniformMatrix2x4dv(pProgram, u.location, u.size, false, (const GLdouble *)value);
break;
case GL_DOUBLE_MAT3x2:
glProgramUniformMatrix3x2dv(pProgram, u.location, u.size, false, (const GLdouble *)value);
break;
case GL_DOUBLE_MAT3x4:
glProgramUniformMatrix3x4dv(pProgram, u.location, u.size, false, (const GLdouble *)value);
break;
case GL_DOUBLE_MAT4x2:
glProgramUniformMatrix4x2dv(pProgram, u.location, u.size, false, (const GLdouble *)value);
break;
case GL_DOUBLE_MAT4x3:
glProgramUniformMatrix4x3dv(pProgram, u.location, u.size, false, (const GLdouble *)value);
break;
#endif
}
}
void UniformImplementation_SeparateShaderObjectsARB::set(const Program * program, const GLint location, const std::vector<glm::vec3> & value) const
{
glProgramUniform3fv(program->id(), location, static_cast<GLint>(value.size()), reinterpret_cast<const float*>(value.data()));
}
void UniformImplementation_SeparateShaderObjectsARB::set(const Program * program, const GLint location, const glm::vec3 & value) const
{
glProgramUniform3fv(program->id(), location, 1, glm::value_ptr(value));
}
void RenderCB(GlRunner *runner)
{
glClearColor(0.2, 0.1, 0.2, 1.0);
glClearDepthf(1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// 3. render the model for optimization
glUseProgramStages(pipe, GL_VERTEX_SHADER_BIT, VS[0]);
glUseProgramStages(pipe, GL_FRAGMENT_SHADER_BIT, FS[0]);
// 3.1 prepare matrix
glm::mat4 Model = glm::mat4(1.0);
glm::mat4 ModelTranslation = glm::translate(glm::vec3(HorizontalDelta, VerticalDelta, 0));
Model = ModelTranslation * Model;
glm::mat4 View = glm::lookAt(
RoamCameraLoc, RoamLensDirect, RoamCameraUp);
glm::mat4 Projection = glm::perspective(glm::radians(FOV), Ratio, Near, Far);
// 3.2 choose refraction or reflection
glProgramUniform1i(FS[0], glGetUniformLocation(FS[0], "uIsRefractionMode"), oFlipMode);
glProgramUniform1f(FS[0], glGetUniformLocation(FS[0], "uRefractionRatio"), oRefractionRatio);
glBindTexture(GL_TEXTURE_CUBE_MAP, skyboxID);
glActiveTexture(GL_TEXTURE0);
glProgramUniform1i(FS[0], glGetUniformLocation(FS[0], "uCubeTetxure"), 0);
// 3.3 update uniform per frame
glProgramUniformMatrix4fv(VS[0], glGetUniformLocation(VS[0], "uModel"), 1, GL_FALSE, &Model[0][0]);
glProgramUniformMatrix4fv(VS[0], glGetUniformLocation(VS[0], "uView"), 1, GL_FALSE, &View[0][0]);
glProgramUniformMatrix4fv(VS[0], glGetUniformLocation(VS[0], "uProjection"), 1, GL_FALSE, &Projection[0][0]);
glProgramUniform3fv(FS[0], glGetUniformLocation(FS[0], "uCameraLoc"), 1, &RoamCameraLoc[0]);
// 3.4 trigger model draw
pMeshContainer->RenderMesh();
// 4.1 render the skybox last
glDepthMask(GL_FALSE);
glBindVertexArray(VAO);
glUseProgramStages(pipe, GL_VERTEX_SHADER_BIT, VS[1]);
glUseProgramStages(pipe, GL_FRAGMENT_SHADER_BIT, FS[1]);
// 4.2 update cubemap model-view-perspective
glm::mat4 SkyboxModel = glm::mat4(1.0);
glm::mat4 SkyboxView = glm::lookAt(
glm::vec3(0, 0, 0),
glm::vec3(1, 0, 1),
glm::vec3(0, 1, 0)
);
glm::mat4 SkyboxProj = glm::perspective(glm::radians(FOV), Ratio, Near, Far);
glProgramUniformMatrix4fv(VS[1], glGetUniformLocation(VS[1], "uModel"), 1, GL_FALSE, &SkyboxModel[0][0]);
glProgramUniformMatrix4fv(VS[1], glGetUniformLocation(VS[1], "uView"), 1, GL_FALSE, &SkyboxView[0][0]);
glProgramUniformMatrix4fv(VS[1], glGetUniformLocation(VS[1], "uProj"), 1, GL_FALSE, &SkyboxProj[0][0]);
glDrawElements(GL_TRIANGLES, 36, GL_UNSIGNED_SHORT, (void *)0);
// restore depth mask before swap
glDepthMask(GL_TRUE);
}
void kore::BindUniform::execute(void) {
if(!_componentUniform) {
Log::getInstance()->write("[ERROR] Uniform binding undefined");
return;
}
GLerror::gl_ErrorCheckStart();
switch (_componentUniform->type) {
case GL_FLOAT_VEC2:
glProgramUniform2fv(_shaderHandle, _shaderUniform->location, 1,
static_cast<GLfloat*>(_componentUniform->data));
break;
case GL_FLOAT_VEC3:
glProgramUniform3fv(_shaderHandle, _shaderUniform->location, 1,
static_cast<GLfloat*>(_componentUniform->data));
break;
case GL_FLOAT_VEC4:
glProgramUniform4fv(_shaderHandle, _shaderUniform->location, 1,
static_cast<GLfloat*>(_componentUniform->data));
break;
case GL_DOUBLE:
glProgramUniform1d(_shaderHandle, _shaderUniform->location,
*static_cast<GLdouble*>(_componentUniform->data));
break;
case GL_DOUBLE_VEC2:
glProgramUniform2dv(_shaderHandle, _shaderUniform->location, 1,
static_cast<GLdouble*>(_componentUniform->data));
break;
case GL_DOUBLE_VEC3:
glProgramUniform3dv(_shaderHandle, _shaderUniform->location, 1,
static_cast<GLdouble*>(_componentUniform->data));
break;
case GL_DOUBLE_VEC4:
glProgramUniform4dv(_shaderHandle, _shaderUniform->location, 1,
static_cast<GLdouble*>(_componentUniform->data));
break;
case GL_BOOL:
case GL_INT:
glProgramUniform1i(_shaderHandle, _shaderUniform->location,
*static_cast<GLint*>(_componentUniform->data));
break;
case GL_BOOL_VEC2:
case GL_INT_VEC2:
glProgramUniform2iv(_shaderHandle, _shaderUniform->location, 1,
static_cast<GLint*>(_componentUniform->data));
break;
case GL_BOOL_VEC3:
case GL_INT_VEC3:
glProgramUniform3iv(_shaderHandle, _shaderUniform->location, 1,
static_cast<GLint*>(_componentUniform->data));
break;
case GL_BOOL_VEC4:
case GL_INT_VEC4:
glProgramUniform4iv(_shaderHandle, _shaderUniform->location, 1,
static_cast<GLint*>(_componentUniform->data));
break;
case GL_UNSIGNED_INT:
glProgramUniform1ui(_shaderHandle, _shaderUniform->location,
*static_cast<GLuint*>(_componentUniform->data));
break;
case GL_UNSIGNED_INT_VEC2:
glProgramUniform2uiv(_shaderHandle, _shaderUniform->location, 1,
static_cast<GLuint*>(_componentUniform->data));
break;
case GL_UNSIGNED_INT_VEC3:
glProgramUniform3uiv(_shaderHandle, _shaderUniform->location, 1,
static_cast<GLuint*>(_componentUniform->data));
break;
case GL_UNSIGNED_INT_VEC4:
glProgramUniform4uiv(_shaderHandle, _shaderUniform->location, 1,
static_cast<GLuint*>(_componentUniform->data));
break;
case GL_FLOAT_MAT2:
glProgramUniformMatrix2fv(_shaderHandle, _shaderUniform->location, 1,
GL_FALSE, static_cast<GLfloat*>(_componentUniform->data));
break;
case GL_FLOAT_MAT3:
glProgramUniformMatrix3fv(_shaderHandle, _shaderUniform->location, 1,
GL_FALSE, static_cast<GLfloat*>(_componentUniform->data));
break;
case GL_FLOAT_MAT4:
glProgramUniformMatrix4fv(_shaderHandle, _shaderUniform->location, 1,
GL_FALSE, static_cast<GLfloat*>(_componentUniform->data));
break;
case GL_FLOAT_MAT2x3:
glProgramUniformMatrix2x3fv(_shaderHandle, _shaderUniform->location, 1,
GL_FALSE, static_cast<GLfloat*>(_componentUniform->data));
break;
case GL_FLOAT_MAT2x4:
glProgramUniformMatrix2x4fv(_shaderHandle, _shaderUniform->location, 1,
GL_FALSE,
static_cast<GLfloat*>(_componentUniform->data));
break;
case GL_FLOAT_MAT3x2:
glProgramUniformMatrix3x2fv(_shaderHandle, _shaderUniform->location, 1,
GL_FALSE,
static_cast<GLfloat*>(_componentUniform->data));
break;
case GL_FLOAT_MAT3x4:
glProgramUniformMatrix3x4fv(_shaderHandle, _shaderUniform->location, 1,
GL_FALSE, static_cast<GLfloat*>(_componentUniform->data));
break;
case GL_FLOAT_MAT4x2:
glProgramUniformMatrix4x2fv(_shaderHandle, _shaderUniform->location, 1,
GL_FALSE, static_cast<GLfloat*>(_componentUniform->data));
break;
case GL_FLOAT_MAT4x3:
glProgramUniformMatrix3x4fv(_shaderHandle, _shaderUniform->location, 1,
GL_FALSE, static_cast<GLfloat*>(_componentUniform->data));
break;
case GL_DOUBLE_MAT2:
glProgramUniformMatrix2dv(_shaderHandle, _shaderUniform->location, 1,
GL_FALSE, static_cast<GLdouble*>(_componentUniform->data));
break;
case GL_DOUBLE_MAT3:
glProgramUniformMatrix3dv(_shaderHandle, _shaderUniform->location, 1,
GL_FALSE, static_cast<GLdouble*>(_componentUniform->data));
break;
case GL_DOUBLE_MAT4:
glProgramUniformMatrix4dv(_shaderHandle, _shaderUniform->location, 1,
GL_FALSE, static_cast<GLdouble*>(_componentUniform->data));
break;
case GL_DOUBLE_MAT2x3:
glProgramUniformMatrix2x3dv(_shaderHandle, _shaderUniform->location, 1,
GL_FALSE, static_cast<GLdouble*>(_componentUniform->data));
break;
case GL_DOUBLE_MAT2x4:
glProgramUniformMatrix2x4dv(_shaderHandle, _shaderUniform->location, 1,
GL_FALSE, static_cast<GLdouble*>(_componentUniform->data));
break;
case GL_DOUBLE_MAT3x2:
glProgramUniformMatrix3x2dv(_shaderHandle, _shaderUniform->location, 1,
GL_FALSE, static_cast<GLdouble*>(_componentUniform->data));
break;
case GL_DOUBLE_MAT3x4:
glProgramUniformMatrix3x4dv(_shaderHandle, _shaderUniform->location, 1,
GL_FALSE, static_cast<GLdouble*>(_componentUniform->data));
break;
case GL_DOUBLE_MAT4x2:
glProgramUniformMatrix4x2dv(_shaderHandle, _shaderUniform->location, 1,
GL_FALSE, static_cast<GLdouble*>(_componentUniform->data));
break;
case GL_DOUBLE_MAT4x3:
glProgramUniformMatrix4x3dv(_shaderHandle, _shaderUniform->location, 1,
GL_FALSE, static_cast<GLdouble*>(_componentUniform->data));
break;
// Note(dlazarek): Currently, we handle texture-bindings outside of
// Uniform-bindigs for sorting and performance-reasons.
case GL_SAMPLER_1D:
case GL_SAMPLER_2D:
case GL_SAMPLER_3D:
case GL_SAMPLER_CUBE:
case GL_SAMPLER_1D_SHADOW:
case GL_SAMPLER_2D_SHADOW:
case GL_SAMPLER_CUBE_SHADOW:
case GL_SAMPLER_1D_ARRAY:
case GL_SAMPLER_2D_ARRAY:
case GL_SAMPLER_1D_ARRAY_SHADOW:
case GL_SAMPLER_2D_ARRAY_SHADOW:
case GL_SAMPLER_2D_MULTISAMPLE:
case GL_SAMPLER_2D_MULTISAMPLE_ARRAY:
case GL_SAMPLER_BUFFER:
case GL_SAMPLER_2D_RECT:
case GL_SAMPLER_2D_RECT_SHADOW:
case GL_INT_SAMPLER_1D:
case GL_INT_SAMPLER_2D:
case GL_INT_SAMPLER_3D:
case GL_INT_SAMPLER_CUBE:
case GL_INT_SAMPLER_1D_ARRAY:
case GL_INT_SAMPLER_2D_ARRAY:
case GL_INT_SAMPLER_2D_MULTISAMPLE:
case GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY:
case GL_INT_SAMPLER_BUFFER:
case GL_INT_SAMPLER_2D_RECT:
case GL_UNSIGNED_INT_SAMPLER_1D:
case GL_UNSIGNED_INT_SAMPLER_2D:
case GL_UNSIGNED_INT_SAMPLER_3D:
case GL_UNSIGNED_INT_SAMPLER_CUBE:
case GL_UNSIGNED_INT_SAMPLER_1D_ARRAY:
case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:
case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE:
case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY:
case GL_UNSIGNED_INT_SAMPLER_BUFFER:
case GL_UNSIGNED_INT_SAMPLER_2D_RECT:
//glActiveTexture(GL_TEXTURE0 + _componentUniform->texUnit);
//glProgramUniform1i(_shaderID, _shaderUniform->location, _componentUniform->texUnit);
kore::Log::getInstance()->write("[ERROR] sampler type was adressed"
"as uniform");
break;
/*
break;
case GL_IMAGE_1D:
break;
case GL_IMAGE_2D:
break;
case GL_IMAGE_3D:
break;
case GL_IMAGE_2D_RECT:
break;
case GL_IMAGE_CUBE:
break;
case GL_IMAGE_BUFFER:
break;
case GL_IMAGE_1D_ARRAY:
break;
case GL_IMAGE_2D_ARRAY:
break;
case GL_IMAGE_2D_MULTISAMPLE:
break;
case GL_IMAGE_2D_MULTISAMPLE_ARRAY:
break;
case GL_INT_IMAGE_1D:
break;
case GL_INT_IMAGE_2D:
break;
case GL_INT_IMAGE_3D:
break;
case GL_INT_IMAGE_2D_RECT:
break;
case GL_INT_IMAGE_CUBE:
break;
case GL_INT_IMAGE_BUFFER:
break;
case GL_INT_IMAGE_1D_ARRAY:
break;
case GL_INT_IMAGE_2D_ARRAY:
break;
case GL_INT_IMAGE_2D_MULTISAMPLE:
break;
case GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY:
break;
case GL_UNSIGNED_INT_IMAGE_1D:
break;
case GL_UNSIGNED_INT_IMAGE_2D:
break;
case GL_UNSIGNED_INT_IMAGE_3D:
break;
case GL_UNSIGNED_INT_IMAGE_2D_RECT:
break;
case GL_UNSIGNED_INT_IMAGE_CUBE:
break;
case GL_UNSIGNED_INT_IMAGE_BUFFER:
break;
case GL_UNSIGNED_INT_IMAGE_1D_ARRAY:
break;
case GL_UNSIGNED_INT_IMAGE_2D_ARRAY:
break;
case GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE:
break;
case GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY:
break; */
default:
kore::Log::getInstance()->write("[ERROR] Unknown uniform binding\n");
break;
}
GLerror::gl_ErrorCheckFinish("BindUniformOperation: " +
_shaderUniform->name);
}
static bool
test_float(const char *version_string)
{
GLint loc;
bool pass = true;
float values[4];
float got[ARRAY_SIZE(values)];
GLuint prog;
static const char subtest_name[] = "float scalar and vectors";
const char *const shader_strings[] = {
version_string,
float_code,
common_body
};
BUILD_SHADER(true);
/* Try float
*/
loc = glGetUniformLocation(prog, "v1");
random_floats(values, ARRAY_SIZE(values));
glProgramUniform1f(prog, loc,
values[0]);
pass = piglit_check_gl_error(0) && pass;
glGetUniformfv(prog, loc, got);
pass = piglit_check_gl_error(0) && pass;
pass = check_float_values(values, got, 1) && pass;
random_floats(values, ARRAY_SIZE(values));
glProgramUniform1fv(prog, loc, 1, values);
pass = piglit_check_gl_error(0) && pass;
glGetUniformfv(prog, loc, got);
pass = piglit_check_gl_error(0) && pass;
pass = check_float_values(values, got, 1) && pass;
/* Try vec2
*/
loc = glGetUniformLocation(prog, "v2");
random_floats(values, ARRAY_SIZE(values));
glProgramUniform2f(prog, loc,
values[0], values[1]);
pass = piglit_check_gl_error(0) && pass;
glGetUniformfv(prog, loc, got);
pass = piglit_check_gl_error(0) && pass;
pass = check_float_values(values, got, 2) && pass;
random_floats(values, ARRAY_SIZE(values));
glProgramUniform2fv(prog, loc, 1, values);
pass = piglit_check_gl_error(0) && pass;
glGetUniformfv(prog, loc, got);
pass = piglit_check_gl_error(0) && pass;
pass = check_float_values(values, got, 2) && pass;
/* Try vec3
*/
loc = glGetUniformLocation(prog, "v3");
random_floats(values, ARRAY_SIZE(values));
glProgramUniform3f(prog, loc,
values[0], values[1], values[2]);
pass = piglit_check_gl_error(0) && pass;
glGetUniformfv(prog, loc, got);
pass = piglit_check_gl_error(0) && pass;
pass = check_float_values(values, got, 3) && pass;
random_floats(values, ARRAY_SIZE(values));
glProgramUniform3fv(prog, loc, 1, values);
pass = piglit_check_gl_error(0) && pass;
glGetUniformfv(prog, loc, got);
pass = piglit_check_gl_error(0) && pass;
pass = check_float_values(values, got, 3) && pass;
/* Try vec4
*/
loc = glGetUniformLocation(prog, "v4");
random_floats(values, ARRAY_SIZE(values));
glProgramUniform4f(prog, loc,
values[0], values[1], values[2], values[3]);
pass = piglit_check_gl_error(0) && pass;
glGetUniformfv(prog, loc, got);
pass = piglit_check_gl_error(0) && pass;
pass = check_float_values(values, got, 4) && pass;
random_floats(values, ARRAY_SIZE(values));
glProgramUniform4fv(prog, loc, 1, values);
pass = piglit_check_gl_error(0) && pass;
glGetUniformfv(prog, loc, got);
pass = piglit_check_gl_error(0) && pass;
pass = check_float_values(values, got, 4) && pass;
piglit_report_subtest_result(pass ? PIGLIT_PASS : PIGLIT_FAIL,
subtest_name);
glDeleteProgram(prog);
return pass;
}
void GLSeparableProgram::setUniformVector3f( GLint uniformLocation, const Vector3f& v )
{
assert( isValid() );
glProgramUniform3fv( id(), uniformLocation, 1, v );
}
void ae3d::Shader::SetVector3( const char* name, const float* vec3 )
{
glProgramUniform3fv( id, uniformLocations[ name ].i, 1, vec3 );
}
void render(GLFWwindow* window)
{
int width, height;
glfwGetFramebufferSize(window, &width, &height);
inputHandling(window);
/********** Section camera view **********/
glm::vec3 cameraPosition(0,2,7);
glm::vec4 cameraPositionTransformed =
glm::rotate(glm::mat4(1.0f), angleX, glm::vec3(0,1,0)) *
glm::rotate(glm::mat4(1.0f), angleY, glm::vec3(1,0,0))* glm::vec4(cameraPosition, 1.0f);
cameraPosition = glm::vec3(XYZ(cameraPositionTransformed));
// come from http://www.opengl-tutorial.org/fr/beginners-tutorials/tutorial-3-matrices/
glm::mat4 Projection = glm::perspective(glm::radians(45.0f), (float)width / (float)height, 0.1f, 50.0f);
// Camera matrix
glm::mat4 ViewCamera = glm::lookAt(
cameraPosition, // Camera is at (4,3,3), in World Space
glm::vec3(0,0,0), // and looks at the origin
glm::vec3(0,1,0) // Head is up (set to 0,-1,0 to look upside-down)
);
glm::mat4 Model = glm::mat4(1.0f);
glm::mat4 mvpCamera = Projection * ViewCamera * Model; // Remember, matrix multiplication is the other way around
//glProgramUniformMatrix4fv(gs.programView, 23, 1, GL_FALSE, &mvpCamera[0][0]);
/********** Section lumière **********/
glm::vec3 lightPosition(0, 5.f, 15.f);
glm::vec4 lightPositionTransformed =
glm::rotate(glm::mat4(1.0f), anglePhiLight, glm::vec3(0,1,0)) *
glm::rotate(glm::mat4(1.0f), angleTetaLight, glm::vec3(1,0,0)) * glm::vec4(lightPosition,1.0f);
/*** calcul du mvp de la caméra lumière (déplacement de la lumière donc calcule ici) ***/
lightPosition = glm::vec3(XYZ(lightPositionTransformed));
Projection = glm::perspective(glm::radians(45.0f), (float)width / (float)height, 0.1f, 50.0f);
// Light Camera matrix
glm::mat4 ViewLightCamera = glm::lookAt(
lightPosition, // Camera is at (4,3,3), in World Space
glm::vec3(0,0,0), // and looks at the origin
glm::vec3(0,1,0) // Head is up (set to 0,-1,0 to look upside-down)
);
// Our ModelViewProjection : multiplication of our 3 matrices
glm::mat4 mvpLightCamera = Projection * ViewLightCamera * Model; // Remember, matrix multiplication is the other way around
//glProgramUniformMatrix4fv(gs.programView, 22, 1, GL_FALSE, &mvpLightCamera[0][0]);
float color[3] = { 0, 1, 0 };
glProgramUniform3fv(gs.programView, 3, 1, color);
glProgramUniform3fv(gs.programView, 4, 1, glm::value_ptr(lightPosition));
glBindFramebuffer(GL_FRAMEBUFFER, gs.fbo);
glViewport(0, 0, width, height);
glClear(GL_COLOR_BUFFER_BIT);
glClear(GL_DEPTH_BUFFER_BIT);
glUseProgram(gs.programView);
glBindVertexArray(gs.vao);
{
glProgramUniformMatrix4fv(gs.programView, 22, 1, GL_FALSE, &mvpLightCamera[0][0]);
glProgramUniformMatrix4fv(gs.programView, 23, 1, GL_FALSE, &mvpLightCamera[0][0]);
glProgramUniform3fv(gs.programView, 3, 1, color);
glProgramUniform3fv(gs.programView, 4, 1, glm::value_ptr(lightPosition));
glDrawArrays(GL_TRIANGLES, 0, nbVertex*4);
}
//glBindFramebuffer(GL_FRAMEBUFFER, 0);
//glBindVertexArray(0);
//glUseProgram(0);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glViewport(0, 0, width, height);
glClear(GL_COLOR_BUFFER_BIT);
glClear(GL_DEPTH_BUFFER_BIT);
//glUseProgram(gs.programView);
//glBindVertexArray(gs.vao);
{
glProgramUniformMatrix4fv(gs.programView, 23, 1, GL_FALSE, &mvpCamera[0][0]);
glProgramUniformMatrix4fv(gs.programView, 22, 1, GL_FALSE, &mvpLightCamera[0][0]);
glProgramUniform3fv(gs.programView, 3, 1, color);
glProgramUniform3fv(gs.programView, 4, 1, glm::value_ptr(lightPosition));
glDrawArrays(GL_TRIANGLES, 0, nbVertex*4);
}
glBindVertexArray(0);
glUseProgram(0);
}
i32 main(i32 ArgCount, char ** Args)
{
char * path_exe = SDL_GetBasePath();
for(u32 i = 0, size = sizeof(RESRC); i < size; i += MAX_STR)
{
char path_res[MAX_STR];
SDL_memcpy(path_res, &RESRC.c[i], MAX_STR);
SDL_snprintf(&RESRC.c[i], MAX_STR, "%s%s", path_exe, path_res);
}
SDL_Window * sdl_window;
SDL_GLContext sdl_glcontext;
gfWindow(&sdl_window, &sdl_glcontext, 0, 0, "App", 1280, 720, 4);
const char * bobs[] =
{
RESRC.monkey_bob,
RESRC.sphere_bob,
RESRC.teapot_bob,
};
bob_t meshes = gfBobCreate(countof(bobs), bobs);
const char * bmps[] =
{
RESRC.texture_1,
RESRC.texture_2,
RESRC.texture_3,
};
gpu_texture_t textures = gfTextureCreateFromBmp(512, 512, 4, countof(bmps), bmps);
const char * cubemap_px[] = { RESRC.cubemap_px };
const char * cubemap_nx[] = { RESRC.cubemap_nx };
const char * cubemap_py[] = { RESRC.cubemap_py };
const char * cubemap_ny[] = { RESRC.cubemap_ny };
const char * cubemap_pz[] = { RESRC.cubemap_pz };
const char * cubemap_nz[] = { RESRC.cubemap_nz };
gpu_texture_t cubemaps = gfCubemapCreateFromBmp(512, 512, 4, countof(cubemap_px),
cubemap_px, cubemap_nx, cubemap_py, cubemap_ny, cubemap_pz, cubemap_nz
);
u32 vs_mesh = gfProgramCreateFromFile(GL_VERTEX_SHADER, RESRC.vs_mesh);
u32 fs_mesh = gfProgramCreateFromFile(GL_FRAGMENT_SHADER, RESRC.fs_mesh);
u32 pp_mesh = gfProgramPipelineCreate(vs_mesh, fs_mesh);
u32 vs_quad = gfProgramCreateFromFile(GL_VERTEX_SHADER, RESRC.vs_quad);
u32 fs_quad = gfProgramCreateFromFile(GL_FRAGMENT_SHADER, RESRC.fs_quad);
u32 pp_quad = gfProgramPipelineCreate(vs_quad, fs_quad);
u32 vs_cubemap = gfProgramCreateFromFile(GL_VERTEX_SHADER, RESRC.vs_cubemap);
u32 fs_cubemap = gfProgramCreateFromFile(GL_FRAGMENT_SHADER, RESRC.fs_cubemap);
u32 pp_cubemap = gfProgramPipelineCreate(vs_cubemap, fs_cubemap);
gpu_cmd_t cmd[3] = {0};
cmd[0].first = meshes.first.as_u32[0];
cmd[1].first = meshes.first.as_u32[1];
cmd[2].first = meshes.first.as_u32[2];
cmd[0].count = meshes.count.as_u32[0];
cmd[1].count = meshes.count.as_u32[1];
cmd[2].count = meshes.count.as_u32[2];
cmd[0].instance_first = 0;
cmd[1].instance_first = 30;
cmd[2].instance_first = 60;
cmd[0].instance_count = 30;
cmd[1].instance_count = 30;
cmd[2].instance_count = 30;
gpu_storage_t ins_first = gfStorageCreate(.format = x_u32, .count = countof(cmd));
gpu_storage_t ins_pos = gfStorageCreate(.format = xyz_f32, .count = 90);
for(u32 i = 0; i < ins_first.count; ++i)
{
ins_first.as_u32[i] = cmd[i].instance_first;
}
for(u32 i = 0, row = 10, space = 3; i < 90; ++i)
{
ins_pos.as_vec3[i].x = i * space - (i / row) * row * space;
ins_pos.as_vec3[i].y = 0;
ins_pos.as_vec3[i].z = (i / row) * space;
}
gpu_texture_t fbo_depth = gfTextureCreate(.w = 1280, 720, .format = depth_b32);
gpu_texture_t fbo_color = gfTextureCreate(.w = 1280, 720, .format = srgba_b8);
u32 fbo_colors[] =
{
[0] = fbo_color.id,
};
u32 fbo = gfFboCreate(fbo_depth.id, 0, countof(fbo_colors), fbo_colors, 0);
gpu_sampler_t s_textures = gfSamplerCreate(4);
gpu_sampler_t s_fbo = gfSamplerCreate(.min = GL_NEAREST, GL_NEAREST);
u32 state_textures[16] =
{
[0] = meshes.mesh_id.id,
[1] = meshes.attr_first.id,
[2] = meshes.attr_id.id,
[3] = meshes.pos.id,
[4] = meshes.uv.id,
[5] = meshes.normal.id,
[6] = ins_first.id,
[7] = ins_pos.id,
[8] = textures.id,
[9] = cubemaps.id,
[10] = fbo_color.id,
};
u32 state_samplers[16] =
{
[8] = s_textures.id,
[9] = s_textures.id,
[10] = s_fbo.id,
};
glBindTextures(0, 16, state_textures);
glBindSamplers(0, 16, state_samplers);
vec3 cam_pos = {23.518875f, 5.673130f, 26.649000f};
vec4 cam_rot = {-0.351835f, 0.231701f, 0.090335f, 0.902411f};
vec4 cam_prj = {0.f};
mat3 cam_mat = {0.f};
Perspective(
&cam_prj.x,
Aspect(sdl_window),
85.f * QFPC_TO_RAD,
0.01f, 1000.f
);
SDL_SetRelativeMouseMode(1);
u32 t_prev = SDL_GetTicks();
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glEnable(GL_BLEND);
while(1)
{
u32 t_curr = SDL_GetTicks();
f64 dt = ((t_curr - t_prev) * 60.0) / 1000.0;
SDL_PumpEvents();
i32 mouse_x_rel = 0;
i32 mouse_y_rel = 0;
SDL_GetRelativeMouseState(&mouse_x_rel, &mouse_y_rel);
const u8 * key = SDL_GetKeyboardState(NULL);
quatFirstPersonCamera(
&cam_pos.x,
&cam_rot.x,
&cam_mat.sd_x,
0.10f,
0.05f * (f32)dt,
mouse_x_rel,
mouse_y_rel,
key[SDL_SCANCODE_W],
key[SDL_SCANCODE_A],
key[SDL_SCANCODE_S],
key[SDL_SCANCODE_D],
key[SDL_SCANCODE_E],
key[SDL_SCANCODE_Q]
);
static int show_pass = 0;
if(key[SDL_SCANCODE_1]) show_pass = 0;
if(key[SDL_SCANCODE_2]) show_pass = 1;
if(key[SDL_SCANCODE_3]) show_pass = 2;
if(key[SDL_SCANCODE_4]) show_pass = 3;
if(key[SDL_SCANCODE_5]) show_pass = 4;
glProgramUniform3fv(vs_mesh, 0, 1, &cam_pos.x);
glProgramUniform4fv(vs_mesh, 1, 1, &cam_rot.x);
glProgramUniform4fv(vs_mesh, 2, 1, &cam_prj.x);
glProgramUniform3fv(fs_mesh, 0, 1, &cam_pos.x);
glProgramUniform1iv(fs_mesh, 1, 1, &show_pass);
glProgramUniform4fv(vs_cubemap, 0, 1, &cam_rot.x);
glProgramUniform4fv(vs_cubemap, 1, 1, &cam_prj.x);
for(u32 i = 0; i < 90; ++i)
ins_pos.as_vec3[i].y = (f32)sin((t_curr * 0.0015f) + (i * 0.5f)) * 0.3f;
gfFboBind(fbo);
gfClear();
gfDraw(pp_mesh, countof(cmd), cmd);
gfFboBind(0);
gfClear();
if(!show_pass)
{
glDisable(GL_DEPTH_TEST);
gfFire(pp_cubemap, 36);
glEnable(GL_DEPTH_TEST);
}
gfFire(pp_quad, 6);
SDL_Event event;
while(SDL_PollEvent(&event))
{
if(event.type == SDL_QUIT)
goto exit;
}
SDL_GL_SwapWindow(sdl_window);
glFinish();
t_prev = t_curr;
}
exit: return 0;
}
