enum piglit_result piglit_display(void) { static const float gray[] = { 0.5, 0.5, 0.5, 1.0 }; static const float green[] = { 0.0, 1.0, 0.0, 0.0 }; static const float red[] = { 1.0, 0.0, 0.0, 0.0 }; bool pass = true; glProgramUniform4fv(vs, loc_vs, 1, red); glProgramUniform4fv(fs, loc_fs, 1, green); glClearColor(gray[0], gray[1], gray[2], gray[3]); glClear(GL_COLOR_BUFFER_BIT); piglit_draw_rect(-1, -1, 1, 2); pass = piglit_probe_rect_rgb(0, 0, piglit_width / 2, piglit_height, gray) && pass; pass = piglit_probe_rect_rgb(piglit_width / 2, 0, piglit_width / 2, piglit_height, green) && pass; piglit_present_results(); pass = piglit_check_gl_error(0) && pass; return pass ? PIGLIT_PASS : PIGLIT_FAIL; }
void Shader::setUniform(const std::string & uniformName, const glm::vec4 & vector) { if (m_uniforms_locations.count(uniformName)) { glProgramUniform4fv(m_program_id, m_uniforms_locations[uniformName], 1, glm::value_ptr(vector)); } else { if (getUniformLocation(uniformName)) { glProgramUniform4fv(m_program_id, m_uniforms_locations[uniformName], 1, glm::value_ptr(vector)); } } }
bool render() { glm::vec2 WindowSize(this->getWindowSize()); // Compute the MVP (Model View Projection matrix) glm::mat4 Projection = glm::perspective(glm::pi<float>() * 0.25f, WindowSize.x / WindowSize.y, 0.1f, 100.0f); glm::mat4 Model = glm::mat4(1.0f); glm::mat4 MVP = Projection * this->view() * Model; // Set the value of uniforms glProgramUniformMatrix4fv(ProgramName[program::VERT], UniformMVP, 1, GL_FALSE, &MVP[0][0]); glProgramUniform4fv(ProgramName[program::FRAG], UniformDiffuse, 1, &glm::vec4(1.0f, 0.5f, 0.0f, 1.0f)[0]); // Set the display viewport glViewportIndexedfv(0, &glm::vec4(0, 0, WindowSize.x, WindowSize.y)[0]); // Clear color buffer with white float Depth(1.0f); glClearBufferfv(GL_DEPTH, 0, &Depth); glClearBufferfv(GL_COLOR, 0, &glm::vec4(1.0f)[0]); // Bind program glBindProgramPipeline(PipelineName); // Bind vertex array & draw glBindVertexArray(VertexArrayName); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, BufferName[buffer::ELEMENT]); // Must be called after glBindVertexArray glDrawElementsInstancedBaseVertex(GL_TRIANGLES, ElementCount, GL_UNSIGNED_SHORT, nullptr, 1, 0); return true; }
void display() { glm::mat4 Projection = glm::perspective(45.0f, 4.0f / 3.0f, 0.1f, 100.0f); glm::mat4 ViewTranslate = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -Window.TranlationCurrent.y)); glm::mat4 ViewRotateX = glm::rotate(ViewTranslate, Window.RotationCurrent.y, glm::vec3(1.f, 0.f, 0.f)); glm::mat4 View = glm::rotate(ViewRotateX, Window.RotationCurrent.x, glm::vec3(0.f, 1.f, 0.f)); glm::mat4 Model = glm::mat4(1.0f); glm::mat4 MVP = Projection * View * Model; glProgramUniform4fv(ProgramName, UniformDiffuse, 1, &glm::vec4(1.0f, 0.5f, 0.0f, 1.0f)[0]); glProgramUniformMatrix4fv(ProgramName, UniformMVP, 1, GL_FALSE, &MVP[0][0]); glViewportIndexedf(0, 0, 0, float(Window.Size.x), float(Window.Size.y)); float Depth(1.0f); glClearBufferfv(GL_DEPTH, 0, &Depth); glClearBufferfv(GL_COLOR, 0, &glm::vec4(0.0f, 0.0f, 0.0f, 1.0f)[0]); glUseProgram(ProgramName); glBindVertexArray(VertexArrayName); glDrawArraysInstanced(GL_TRIANGLES, 0, 6, 1); glf::swapBuffers(); glf::checkError("display"); }
void ShaderProgram::setUniform(const char* param, const glm::vec4& val) { unsigned int loc = getUniformLocation(param); // gl_check(glUniform4fv(loc, 1, glm::value_ptr(val))); gl_check(glProgramUniform4fv(m_programId, loc, 1, glm::value_ptr(val))); }
void display() { // Compute the MVP (Model View Projection matrix) glm::mat4 Projection = glm::perspective(45.0f, 4.0f / 3.0f, 0.1f, 100.0f); glm::mat4 ViewTranslate = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -Window.TranlationCurrent.y)); glm::mat4 ViewRotateX = glm::rotate(ViewTranslate, Window.RotationCurrent.y, glm::vec3(1.f, 0.f, 0.f)); glm::mat4 View = glm::rotate(ViewRotateX, Window.RotationCurrent.x, glm::vec3(0.f, 1.f, 0.f)); glm::mat4 Model = glm::mat4(1.0f); glm::mat4 MVP = Projection * View * Model; // Set the value of uniforms glProgramUniformMatrix4fv(ProgramName[program::VERT], UniformMVP, 1, GL_FALSE, &MVP[0][0]); glProgramUniform4fv(ProgramName[program::FRAG], UniformDiffuse, 1, &glm::vec4(1.0f, 0.5f, 0.0f, 1.0f)[0]); // Set the display viewport glViewportIndexedfv(0, &glm::vec4(0, 0, Window.Size.x, Window.Size.y)[0]); // Clear color buffer with white float Depth(1.0f); glClearBufferfv(GL_DEPTH, 0, &Depth); glClearBufferfv(GL_COLOR, 0, &glm::vec4(1.0f)[0]); // Bind program glBindProgramPipeline(PipelineName); // Bind vertex array & draw glBindVertexArray(VertexArrayName); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, BufferName[buffer::ELEMENT]); // Must be called after glBindVertexArray glDrawElementsInstancedBaseVertex(GL_TRIANGLES, ElementCount, GL_UNSIGNED_SHORT, NULL, 1, 0); glf::checkError("display"); glf::swapBuffers(); }
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 shader_setvec4(shader_t shader, sparam_t param, const struct vec4 *val) { if (matching_shader(shader, param)) { glProgramUniform4fv(shader->program, param->param, 1, val->ptr); gl_success("glProgramUniform4fv"); } }
void cShader::SetUniform4(GLuint handle, const tVector& data) const { float f_data[] = {static_cast<float>(data[0]), static_cast<float>(data[1]), static_cast<float>(data[2]), static_cast<float>(data[3])}; glProgramUniform4fv(mProg, handle, 1, f_data); }
void ProgramSeparateDsa::setUniform4fv(handle uniformHandle, const float *value) { if (static_cast<OpenGLRenderer&>(getRenderer()).getExtensions().isGL_ARB_direct_state_access()) { glProgramUniform4fv(mVertexShaderSeparate->getOpenGLShaderProgram(), static_cast<GLint>(uniformHandle), 1, value); } else { glProgramUniform4fvEXT(mVertexShaderSeparate->getOpenGLShaderProgram(), static_cast<GLint>(uniformHandle), 1, value); } }
void ProgramMonolithicDsa::setUniform4fv(handle uniformHandle, const float *value) { if (static_cast<OpenGLRenderer&>(getRenderer()).getExtensions().isGL_ARB_direct_state_access()) { glProgramUniform4fv(mOpenGLProgram, static_cast<GLint>(uniformHandle), 1, value); } else { glProgramUniform4fvEXT(mOpenGLProgram, static_cast<GLint>(uniformHandle), 1, value); } }
void Shader::SendVectorArray(int location, const Vector4f* vectors, unsigned int count) const { if (location == -1) return; if (glProgramUniform4fv) glProgramUniform4fv(m_program, location, count, reinterpret_cast<const float*>(vectors)); else { OpenGL::BindProgram(m_program); glUniform4fv(location, count, reinterpret_cast<const float*>(vectors)); } }
// Set a vec4 void Material::SetVec4( const std::string& name, const glm::vec4& value ) { GLint location = GetUniformLocation( name ); if ( glProgramUniform4fv ) { glProgramUniform4fv( _program, location, 1, glm::value_ptr( value ) ); } else { glUseProgram( _program ); glUniform4fv( location, 1, glm::value_ptr( value ) ); } }
void Shader::SendVector(int location, const Vector4f& vector) const { if (location == -1) return; if (glProgramUniform4fv) glProgramUniform4fv(m_program, location, 1, vector); else { OpenGL::BindProgram(m_program); glUniform4fv(location, 1, vector); } }
void program::set_uniform4fv(char const* varname, GLsizei count, GLfloat* value) const { GLint location = get_uniform_location(varname); if (location >= 0) { #if GPUCAST_GL_DIRECT_STATE_ACCESS glProgramUniform4fv(id_, location, count, value); #else glUniform4fv(location, count, value); #endif } }
void Shader::SendColor(int location, const Color& color) const { if (location == -1) return; Vector4f vecColor(color.r/255.f, color.g/255.f, color.b/255.f, color.a/255.f); if (glProgramUniform4fv) glProgramUniform4fv(m_program, location, 1, vecColor); else { OpenGL::BindProgram(m_program); glUniform4fv(location, 1, vecColor); } }
void Triangle::render() { glBindVertexArray(m_vao); glBindProgramPipeline(m_pipe); glm::mat4 model = glm::mat4(1.0f); glm::mat4 view = glm::lookAt(glm::vec3(0.0f, 0.0f, 3.0f), glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f)); glm::mat4 proj = glm::perspective(45.0f, 1.2f, 1.0f, 1000.0f); glm::mat4 mvp = model * view * proj; glProgramUniformMatrix4fv(m_vert, mvp_loc, 1, GL_FALSE, &mvp[0][0]); const static GLfloat color[4] ={ 1.0f, 0.0f, 0.0f, 1.0f }; glProgramUniform4fv(m_frag, color_loc, 1, color); glDrawElements(GL_TRIANGLES, 3, GL_UNSIGNED_INT, 0); glBindVertexArray(0); glBindProgramPipeline(0); }
void Shader::uniform4f(GLint location, const glm::vec4& vec) const { glProgramUniform4fv(id_, location, 1, glm::value_ptr(vec)); }
void ComputeWaterSimulation::simulateWaterGPU() { nv::vec4f disturbance[NUM_WAVES]; GLint loc; if (mSettings.Animate) { nv::vec3f point(mDisturbance.x, 0.0f, mDisturbance.y); nv::vec2f gridPos; // compute disturbance for each wave for(uint32_t i = 0; i < mNumWaves; i++) { if (mWaves[i]->mapPointXZToGridPos(point, gridPos)) { disturbance[i] = nv::vec4f(gridPos.x, gridPos.y, mSettings.Size * mWaveScale, mSettings.Strength * mWaveScale); } } loc = glGetUniformLocation(mTransformProgram, "Damping"); glProgramUniform1f(mTransformProgram, loc, mSettings.Damping); loc = glGetUniformLocation(mTransformProgram, "GridSize"); glProgramUniform1ui(mTransformProgram, loc, mGridSize + 2); glBindProgramPipeline(mTransformPipeline); for(uint32_t i = 0; i < mNumWaves; i++) { loc = glGetUniformLocation(mTransformProgram, "Disturbance"); glProgramUniform4fv(mTransformProgram, loc, 1, disturbance[i]._array); GLuint heightBuffer = mWaves[i]->getRenderer().m_waterYVBO[mWaves[i]->getRenderer().m_renderCurrent]; glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, mHeightBuffer[i]); glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, heightBuffer); glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 3, mVelocityBuffer[i]); glDispatchCompute((mGridSize / WORK_GROUP_SIZE) + 1, (mGridSize / WORK_GROUP_SIZE) + 1, 1); glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT); //glMemoryBarrier(GL_ALL_BARRIER_BITS); CHECK_GL_ERROR(); glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, 0); glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, 0); glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 3, 0); } glBindProgramPipeline(0); CHECK_GL_ERROR(); } // On non-NV, we are seeing corruption caused by glMemoryBarrier not actually synchronizing if (m_hackMemoryBarrier) glFinish(); // calculate gradients glBindProgramPipeline(mGradientsPipeline); loc = glGetUniformLocation(mGradientsProgram, "GridSize"); glProgramUniform1ui(mGradientsProgram, loc, mGridSize + 2); for(uint32_t i = 0; i < mNumWaves; i++) { GLuint heightBuffer = mWaves[i]->getRenderer().m_waterYVBO[mWaves[i]->getRenderer().m_renderCurrent]; glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, heightBuffer); GLuint gradientsBuffer = mWaves[i]->getRenderer().m_waterGVBO[mWaves[i]->getRenderer().m_renderCurrent]; glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, gradientsBuffer); glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 3, mHeightBuffer[i]); glDispatchCompute((mGridSize / WORK_GROUP_SIZE) + 1, (mGridSize / WORK_GROUP_SIZE) + 1, 1); //glDispatchCompute(4, 4, 1); glMemoryBarrier(GL_SHADER_STORAGE_BUFFER); //glMemoryBarrier(GL_ALL_BARRIER_BITS); CHECK_GL_ERROR(); glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, 0); glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, 0); glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 3, 0); } glBindProgramPipeline(0); CHECK_GL_ERROR(); // On non-NV, we are seeing corruption caused by glMemoryBarrier not actually synchronizing if (m_hackMemoryBarrier) glFinish(); }
void UniformImplementation_SeparateShaderObjectsARB::set(const Program * program, const GLint location, const std::vector<glm::vec4> & value) const { glProgramUniform4fv(program->id(), location, static_cast<GLint>(value.size()), reinterpret_cast<const float*>(value.data())); }
void ae3d::Shader::SetVector4( const char* name, const float* vec4 ) { glProgramUniform4fv( id, uniformLocations[ name ].i, 1, vec4 ); }
void UniformImplementation_SeparateShaderObjectsARB::set(const Program * program, const GLint location, const glm::vec4 & value) const { glProgramUniform4fv(program->id(), location, 1, glm::value_ptr(value)); }
void GLSeparableProgram::setUniformVector4f( GLint uniformLocation, const Vector4f& v ) { assert( isValid() ); glProgramUniform4fv( id(), uniformLocation, 1, v ); }
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 } }
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; }
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL41_nglProgramUniform4fv(JNIEnv *env, jclass clazz, jint program, jint location, jint count, jlong value, jlong function_pointer) { const GLfloat *value_address = (const GLfloat *)(intptr_t)value; glProgramUniform4fvPROC glProgramUniform4fv = (glProgramUniform4fvPROC)((intptr_t)function_pointer); glProgramUniform4fv(program, location, count, value_address); }
GLuint OpenSubdivPtexShader::bindProgram(const MHWRender::MDrawContext & mDrawContext, OpenSubdiv::OsdGLDrawContext *osdDrawContext, const OpenSubdiv::OsdPatchArray & patch) { CHECK_GL_ERROR("bindProgram begin\n"); // Build shader Effect effect; effect.color = _enableColor; effect.occlusion = _enableOcclusion; effect.displacement = _enableDisplacement; effect.normal = _enableNormal; EffectDesc effectDesc( patch.desc, effect ); EffectDrawRegistry::ConfigType * config = effectRegistry.GetDrawConfig(effectDesc); // Install shader GLuint program = config->program; glUseProgram(program); // Update and bind transform state struct Transform { float ModelViewMatrix[16]; float ProjectionMatrix[16]; float ModelViewProjectionMatrix[16]; } transformData; setMatrix(mDrawContext.getMatrix(MHWRender::MDrawContext::kWorldViewMtx), transformData.ModelViewMatrix); setMatrix(mDrawContext.getMatrix(MHWRender::MDrawContext::kProjectionMtx), transformData.ProjectionMatrix); setMatrix(mDrawContext.getMatrix(MHWRender::MDrawContext::kWorldViewProjMtx), transformData.ModelViewProjectionMatrix); if (!g_transformUB) { glGenBuffers(1, &g_transformUB); glBindBuffer(GL_UNIFORM_BUFFER, g_transformUB); glBufferData(GL_UNIFORM_BUFFER, sizeof(transformData), NULL, GL_STATIC_DRAW); }; glBindBuffer(GL_UNIFORM_BUFFER, g_transformUB); glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(transformData), &transformData); glBindBuffer(GL_UNIFORM_BUFFER, 0); glBindBufferBase(GL_UNIFORM_BUFFER, g_transformBinding, g_transformUB); // Update and bind tessellation state struct Tessellation { float TessLevel; int GregoryQuadOffsetBase; int PrimitiveIdBase; } tessellationData; tessellationData.TessLevel = static_cast<float>(1 << _tessFactor); tessellationData.GregoryQuadOffsetBase = patch.GetQuadOffsetBase; tessellationData.PrimitiveIdBase = patch.GetPatchIndex();; if (!g_tessellationUB) { glGenBuffers(1, &g_tessellationUB); glBindBuffer(GL_UNIFORM_BUFFER, g_tessellationUB); glBufferData(GL_UNIFORM_BUFFER, sizeof(tessellationData), NULL, GL_STATIC_DRAW); }; glBindBuffer(GL_UNIFORM_BUFFER, g_tessellationUB); glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(tessellationData), &tessellationData); glBindBuffer(GL_UNIFORM_BUFFER, 0); glBindBufferBase(GL_UNIFORM_BUFFER, g_tessellationBinding, g_tessellationUB); #ifdef USE_NON_IMAGE_BASED_LIGHTING // Update and bind lighting state int numLights = mDrawContext.numberOfActiveLights(); struct Lighting { struct Light { float position[4]; float diffuse[4]; float ambient[4]; float specular[4]; } lightSource[2]; } lightingData; memset(&lightingData, 0, sizeof(lightingData)); for (int i = 0; i < numLights && i < 1; ++i) { MFloatPointArray positions; MFloatVector direction; float intensity; MColor color; bool hasDirection, hasPosition; mDrawContext.getLightInformation(i, positions, direction, intensity, color, hasDirection, hasPosition); Lighting::Light &light = lightingData.lightSource[i]; if (hasDirection) { light.position[0] = -direction[0]; light.position[1] = -direction[1]; light.position[2] = -direction[2]; for (int j = 0; j < 4; ++j) { light.diffuse[j] = color[j] * intensity; light.ambient[j] = color[j] * intensity; light.specular[j] = color[j] * intensity; } } } if (!g_lightingUB) { glGenBuffers(1, &g_lightingUB); glBindBuffer(GL_UNIFORM_BUFFER, g_lightingUB); glBufferData(GL_UNIFORM_BUFFER, sizeof(lightingData), NULL, GL_STATIC_DRAW); }; glBindBuffer(GL_UNIFORM_BUFFER, g_lightingUB); glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(lightingData), &lightingData); glBindBuffer(GL_UNIFORM_BUFFER, 0); glBindBufferBase(GL_UNIFORM_BUFFER, g_lightingBinding, g_lightingUB); #endif GLint eye = glGetUniformLocation(program, "eyePositionInWorld"); MPoint e = MPoint(0, 0, 0) * mDrawContext.getMatrix(MHWRender::MDrawContext::kWorldViewInverseMtx); glProgramUniform3f(program, eye, static_cast<float>(e.x), static_cast<float>(e.y), static_cast<float>(e.z)); // update other uniforms float color[4] = { 0, 0, 0, 1 }; _diffuse.get(color); glProgramUniform4fv(program, glGetUniformLocation(program, "diffuseColor"), 1, color); _ambient.get(color); glProgramUniform4fv(program, glGetUniformLocation(program, "ambientColor"), 1, color); _specular.get(color); glProgramUniform4fv(program, glGetUniformLocation(program, "specularColor"), 1, color); glProgramUniform1f(program, glGetUniformLocation(program, "fresnelBias"), _fresnelBias); glProgramUniform1f(program, glGetUniformLocation(program, "fresnelScale"), _fresnelScale); glProgramUniform1f(program, glGetUniformLocation(program, "fresnelPower"), _fresnelPower); // Ptex bindings // color ptex if (effectRegistry.getPtexColorValid()) { GLint texData = glGetUniformLocation(program, "textureImage_Data"); glProgramUniform1i(program, texData, CLR_TEXTURE_UNIT + 0); GLint texPacking = glGetUniformLocation(program, "textureImage_Packing"); glProgramUniform1i(program, texPacking, CLR_TEXTURE_UNIT + 1); GLint texPages = glGetUniformLocation(program, "textureImage_Pages"); glProgramUniform1i(program, texPages, CLR_TEXTURE_UNIT + 2); } // displacement ptex if (effectRegistry.getPtexDisplacementValid()) { GLint texData = glGetUniformLocation(program, "textureDisplace_Data"); glProgramUniform1i(program, texData, DISP_TEXTURE_UNIT + 0); GLint texPacking = glGetUniformLocation(program, "textureDisplace_Packing"); glProgramUniform1i(program, texPacking, DISP_TEXTURE_UNIT + 1); GLint texPages = glGetUniformLocation(program, "textureDisplace_Pages"); glProgramUniform1i(program, texPages, DISP_TEXTURE_UNIT + 2); } // occlusion ptex if (effectRegistry.getPtexOcclusionValid()) { GLint texData = glGetUniformLocation(program, "textureOcclusion_Data"); glProgramUniform1i(program, texData, OCC_TEXTURE_UNIT + 0); GLint texPacking = glGetUniformLocation(program, "textureOcclusion_Packing"); glProgramUniform1i(program, texPacking, OCC_TEXTURE_UNIT + 1); GLint texPages = glGetUniformLocation(program, "textureOcclusion_Pages"); glProgramUniform1i(program, texPages, OCC_TEXTURE_UNIT + 2); } // diffuse environment map if (effectRegistry.getDiffuseEnvironmentId() != 0) { GLint difmap = glGetUniformLocation(program, "diffuseEnvironmentMap"); glProgramUniform1i(program, difmap, DIFF_TEXTURE_UNIT); } // specular environment map if (effectRegistry.getSpecularEnvironmentId() != 0) { GLint envmap = glGetUniformLocation(program, "specularEnvironmentMap"); glProgramUniform1i(program, envmap, ENV_TEXTURE_UNIT); } glActiveTexture(GL_TEXTURE0); CHECK_GL_ERROR("bindProgram leave\n"); return program; }
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 }
// #### bindProgram // // Do all the work to build and install shader including // set up buffer blocks for uniform variables, set up // default lighting parameters, pass material uniforms // and bind texture buffers used by texture maps and by // OpenSubdiv's built-in shading code. // GLuint OpenSubdivShader::bindProgram(const MHWRender::MDrawContext & mDrawContext, OpenSubdiv::OsdGLDrawContext *osdDrawContext, const OpenSubdiv::OsdDrawContext::PatchArray & patch) { CHECK_GL_ERROR("bindProgram begin\n"); // Primitives are triangles for Loop subdivision, quads otherwise Effect effect = kFill; EffectDesc effectDesc( patch.GetDescriptor(), effect ); // Build shader EffectDrawRegistry::ConfigType * config = g_effectRegistry.GetDrawConfig(effectDesc); // Install shader GLuint program = config->program; glUseProgram(program); // Update and bind transform state struct Transform { float ModelViewMatrix[16]; float ProjectionMatrix[16]; float ModelViewProjectionMatrix[16]; } transformData; setMatrix(mDrawContext.getMatrix(MHWRender::MDrawContext::kWorldViewMtx), transformData.ModelViewMatrix); setMatrix(mDrawContext.getMatrix(MHWRender::MDrawContext::kProjectionMtx), transformData.ProjectionMatrix); setMatrix(mDrawContext.getMatrix(MHWRender::MDrawContext::kWorldViewProjMtx), transformData.ModelViewProjectionMatrix); if (!g_transformUB) { glGenBuffers(1, &g_transformUB); glBindBuffer(GL_UNIFORM_BUFFER, g_transformUB); glBufferData(GL_UNIFORM_BUFFER, sizeof(transformData), NULL, GL_STATIC_DRAW); }; glBindBuffer(GL_UNIFORM_BUFFER, g_transformUB); glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(transformData), &transformData); glBindBuffer(GL_UNIFORM_BUFFER, 0); glBindBufferBase(GL_UNIFORM_BUFFER, g_transformBinding, g_transformUB); // Update and bind tessellation state struct Tessellation { float TessLevel; } tessellationData; tessellationData.TessLevel = static_cast<float>(1 << _tessFactor); if (!g_tessellationUB) { glGenBuffers(1, &g_tessellationUB); glBindBuffer(GL_UNIFORM_BUFFER, g_tessellationUB); glBufferData(GL_UNIFORM_BUFFER, sizeof(tessellationData), NULL, GL_STATIC_DRAW); }; glBindBuffer(GL_UNIFORM_BUFFER, g_tessellationUB); glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(tessellationData), &tessellationData); glBindBuffer(GL_UNIFORM_BUFFER, 0); glBindBufferBase(GL_UNIFORM_BUFFER, g_tessellationBinding, g_tessellationUB); // Update and bind lighting state int numLights = mDrawContext.numberOfActiveLights(); struct Lighting { struct Light { float position[4]; float diffuse[4]; float ambient[4]; float specular[4]; } lightSource[2]; } lightingData; memset(&lightingData, 0, sizeof(lightingData)); for (int i = 0; i < numLights && i < 2; ++i) { MFloatPointArray positions; MFloatVector direction; float intensity; MColor color; bool hasDirection, hasPosition; mDrawContext.getLightInformation(i, positions, direction, intensity, color, hasDirection, hasPosition); MMatrix modelView = mDrawContext.getMatrix(MHWRender::MDrawContext::kWorldViewMtx); direction = MVector(direction) * modelView; Lighting::Light &light = lightingData.lightSource[i]; if (hasDirection) { light.position[0] = -direction[0]; light.position[1] = -direction[1]; light.position[2] = -direction[2]; for (int j = 0; j < 4; ++j) { light.diffuse[j] = color[j] * intensity; light.ambient[j] = color[j] * intensity; light.specular[j] = color[j] * intensity; } } } if (!g_lightingUB) { glGenBuffers(1, &g_lightingUB); glBindBuffer(GL_UNIFORM_BUFFER, g_lightingUB); glBufferData(GL_UNIFORM_BUFFER, sizeof(lightingData), NULL, GL_STATIC_DRAW); }; glBindBuffer(GL_UNIFORM_BUFFER, g_lightingUB); glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(lightingData), &lightingData); glBindBuffer(GL_UNIFORM_BUFFER, 0); glBindBufferBase(GL_UNIFORM_BUFFER, g_lightingBinding, g_lightingUB); // Update other uniforms float color[4] = { 0, 0, 0, 1 }; _diffuse.get(color); glProgramUniform4fv(program, glGetUniformLocation(program, "diffuseColor"), 1, color); _ambient.get(color); glProgramUniform4fv(program, glGetUniformLocation(program, "ambientColor"), 1, color); _specular.get(color); glProgramUniform4fv(program, glGetUniformLocation(program, "specularColor"), 1, color); glProgramUniform1f(program, glGetUniformLocation(program, "shininess"), _shininess); // Bind diffuse map if (g_effectRegistry.getDiffuseId()!=0) { GLint difmap = glGetUniformLocation(program, "diffuseMap"); glProgramUniform1i(program, difmap, DIFF_TEXTURE_UNIT); } // Bind all texture buffers // OpenSubdiv's geometric shading code depends on additional // GL texture buffers. These are managed by the DrawContext // and must be bound for use by the program in addition to // any buffers used by the client/application shading code. if (osdDrawContext->GetVertexTextureBuffer()) { glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_BUFFER, osdDrawContext->GetVertexTextureBuffer()); } if (osdDrawContext->GetVertexValenceTextureBuffer()) { glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_BUFFER, osdDrawContext->GetVertexValenceTextureBuffer()); } if (osdDrawContext->GetQuadOffsetsTextureBuffer()) { glActiveTexture(GL_TEXTURE2); glBindTexture(GL_TEXTURE_BUFFER, osdDrawContext->GetQuadOffsetsTextureBuffer()); } if (osdDrawContext->GetPatchParamTextureBuffer()) { glActiveTexture(GL_TEXTURE3); glBindTexture(GL_TEXTURE_BUFFER, osdDrawContext->GetPatchParamTextureBuffer()); } if (osdDrawContext->GetFvarDataTextureBuffer()) { glActiveTexture(GL_TEXTURE4); glBindTexture(GL_TEXTURE_BUFFER, osdDrawContext->GetFvarDataTextureBuffer() ); } glActiveTexture(GL_TEXTURE0); CHECK_GL_ERROR("bindProgram leave\n"); return program; }
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); }