void GLMaterial::apply()
{
glUseProgram(gProgram); // needed to update uniforms on ATI?
glAssertError();
glMaterialf(GL_FRONT, GL_SHININESS, shininess);
glMaterialfv(GL_FRONT, GL_AMBIENT, &ambient.r);
glMaterialfv(GL_FRONT, GL_DIFFUSE, &diffuse.r);
glMaterialfv(GL_FRONT, GL_SPECULAR, &specular.r);
glMaterialfv(GL_FRONT, GL_EMISSION, &emissive.r);
glAssertError();
glActiveTexture(GL_TEXTURE0);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, ambientMap);
glAssertError();
glActiveTexture(GL_TEXTURE1);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, diffuseMap);
glAssertError();
glActiveTexture(GL_TEXTURE2);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, specularMap);
glAssertError();
glActiveTexture(GL_TEXTURE3);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, emissiveMap);
glAssertError();
glActiveTexture(GL_TEXTURE4);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, opacityMap);
glAssertError();
glProgramUniform1i(gProgram, uniformAmbientMap, 0);
glProgramUniform1i(gProgram, uniformDiffuseMap, 1);
glProgramUniform1i(gProgram, uniformSpecularMap, 2);
glProgramUniform1i(gProgram, uniformEmissiveMap, 3);
glProgramUniform1i(gProgram, uniformOpacityMap, 4);
glAssertError();
if (opacityMap != defaultOpacityMap)
{
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
//glEnable(GL_ALPHA_TEST);
//glAlphaFunc(GL_GREATER, 0.04f);
glDepthMask(GL_FALSE);
}
else
{
glDisable(GL_BLEND);
//glDisable(GL_ALPHA_TEST);
glDepthMask(GL_TRUE);
}
}
void SurfaceReconstruction::SetEnvironmentMap (const Texture *_envmap)
{
envmap = _envmap;
if (envmap != NULL)
{
glProgramUniform1i (fsquadprog.get (), fsquadprog.GetUniformLocation ("useenvmap"), 1);
}
else
{
glProgramUniform1i (fsquadprog.get (), fsquadprog.GetUniformLocation ("useenvmap"), 0);
}
}
void renderVis(double peak)
{
double transition = 0.0;
time++;
totaltime++;
if(time > SHADER_TIME){
active++;
if(active == SHADER_AMOUNT){
active = 0;
}
time = 0;
}
if(time <= TRANSITION_TIME){
transition = 1.0 - time / TRANSITION_TIME;
int prev = active > 0 ? active - 1 : SHADER_AMOUNT - 1;
glUseProgram(progs[prev].program);
glClearColor(0, 0, 0, 1);
glClear(GL_COLOR_BUFFER_BIT);
glProgramUniform1f(progs[prev].program, progs[prev].peak, peak);
glProgramUniform1f(progs[prev].program, progs[prev].transition, 0);
glProgramUniform1f(progs[prev].program, progs[prev].time, totaltime);
glProgramUniform2f(progs[prev].program, progs[prev].size, width, height);
glProgramUniform1i(progs[prev].program, progs[prev].texture, 0);
glBindVertexArray(vao);
glDrawArrays(GL_TRIANGLES, 0, 6);
glBindVertexArray(0);
glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, width, height, 0);
glUseProgram(progs[active].program);
glProgramUniform1i(progs[active].program, progs[active].texture, 0);
}
glClearColor(0, 0, 0, 1);
glClear(GL_COLOR_BUFFER_BIT);
glProgramUniform1f(progs[active].program, progs[active].peak, peak);
glProgramUniform1f(progs[active].program, progs[active].transition, transition);
glProgramUniform1f(progs[active].program, progs[active].time, totaltime);
glProgramUniform2f(progs[active].program, progs[active].size, width, height);
glBindVertexArray(vao);
glDrawArrays(GL_TRIANGLES, 0, 6);
glBindVertexArray(0);
}
// #### _CreateDrawConfig
//
// Called by base registry when a draw config is requested.
// Returns a compiled and linked shader program corresponding to
// a previously created DrawSourceConfig. The effect registry also
// caches these for efficient re-use.
//
EffectDrawRegistry::ConfigType *
EffectDrawRegistry::_CreateDrawConfig(
DescType const & desc,
SourceConfigType const * sconfig)
{
ConfigType * config = BaseRegistry::_CreateDrawConfig(desc.first, sconfig);
assert(config);
// Assign binding points to uniform blocks
//* XXX dyu can use layout(binding=) with GLSL 4.20 and beyond */
/* struct Transform */
g_transformBinding = 0;
glUniformBlockBinding(config->program,
glGetUniformBlockIndex(config->program, "Transform"),
g_transformBinding);
/* struct Tessellation */
g_tessellationBinding = 1;
glUniformBlockBinding(config->program,
glGetUniformBlockIndex(config->program, "Tessellation"),
g_tessellationBinding);
/* struct Lighting */
g_lightingBinding = 2;
glUniformBlockBinding(config->program,
glGetUniformBlockIndex(config->program, "Lighting"),
g_lightingBinding);
// Specify texture buffer ID uniforms in shader
GLint loc;
if ((loc = glGetUniformLocation(config->program, "OsdVertexBuffer")) != -1) {
glProgramUniform1i(config->program, loc, 0); // GL_TEXTURE0
}
if ((loc = glGetUniformLocation(config->program, "OsdValenceBuffer")) != -1) {
glProgramUniform1i(config->program, loc, 1); // GL_TEXTURE1
}
if ((loc = glGetUniformLocation(config->program, "OsdQuadOffsetBuffer")) != -1) {
glProgramUniform1i(config->program, loc, 2); // GL_TEXTURE2
}
if ((loc = glGetUniformLocation(config->program, "OsdPatchParamBuffer")) != -1) {
glProgramUniform1i(config->program, loc, 3); // GL_TEXTURE3
}
if ((loc = glGetUniformLocation(config->program, "OsdFVarDataBuffer")) != -1) {
glProgramUniform1i(config->program, loc, 4); // GL_TEXTURE4
}
CHECK_GL_ERROR("CreateDrawConfig leave\n");
return config;
}
void Shader::setUniform(const std::string & uniformName, int value)
{
if (m_uniforms_locations.count(uniformName))
{
glProgramUniform1i(m_program_id, m_uniforms_locations[uniformName], value);
}
else
{
if (getUniformLocation(uniformName))
{
glProgramUniform1i(m_program_id, m_uniforms_locations[uniformName], value);
}
}
}
void display()
{
glm::mat4 Projection = glm::ortho(-1.0f, 1.0f, 1.0f,-1.0f, 1.0f, -1.0f);
glm::mat4 View = glm::mat4(1.0f);
glm::mat4 Model = glm::mat4(1.0f);
glm::mat4 MVP = Projection * View * Model;
glProgramUniformMatrix4fv(ProgramName[LAYERING], UniformMVP[LAYERING], 1, GL_FALSE, &MVP[0][0]);
glProgramUniformMatrix4fv(ProgramName[IMAGE_2D], UniformMVP[IMAGE_2D], 1, GL_FALSE, &MVP[0][0]);
glProgramUniform1i(ProgramName[IMAGE_2D], UniformDiffuse, 0);
// Pass 1
{
glBindSampler(0, 0);
glBindFramebuffer(GL_FRAMEBUFFER, FramebufferName);
glViewportIndexedf(0, 0, 0, float(FRAMEBUFFER_SIZE.x), float(FRAMEBUFFER_SIZE.y));
glUseProgram(ProgramName[LAYERING]);
glBindVertexArray(VertexArrayName[LAYERING]);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, BufferName[BUFFER_ELEMENT]);
glDrawElementsInstancedBaseVertex(GL_TRIANGLES, ElementCount, GL_UNSIGNED_SHORT, NULL, 1, 0);
}
// Pass 2
{
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glUseProgram(ProgramName[IMAGE_2D]);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D_ARRAY, TextureColorbufferName);
glBindSampler(0, SamplerName);
glBindVertexArray(VertexArrayName[IMAGE_2D]);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, BufferName[BUFFER_ELEMENT]);
for(int i = 0; i < 4; ++i)
{
glProgramUniform1i(ProgramName[IMAGE_2D], UniformLayer, i);
glViewportIndexedfv(0, &glm::vec4(Viewport[i])[0]);
glDrawElementsInstancedBaseVertex(GL_TRIANGLES, ElementCount, GL_UNSIGNED_SHORT, NULL, 1, 0);
}
}
glf::checkError("display");
glf::swapBuffers();
}
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 ViewTranslateZ = glm::translate(glm::mat4(1.0), glm::vec3(0.0f, 0.0f, -Window.TranlationCurrent.y));
glm::mat4 ViewRotateX = glm::rotate(ViewTranslateZ, float(Window.RotationCurrent.y), glm::vec3(1.f, 0.f, 0.f));
glm::mat4 ViewRotateY = glm::rotate(ViewRotateX, float(Window.RotationCurrent.x), glm::vec3(0.f, 1.f, 0.f));
glm::mat4 View = ViewRotateY;
glm::mat4 Model = glm::mat4(1.0f);
glm::mat4 MVP = Projection * View * Model;
glProgramUniformMatrix4fv(ProgramName[program::VERT], UniformMVP, 1, GL_FALSE, &MVP[0][0]);
glProgramUniform1i(ProgramName[program::FRAG], UniformDiffuse, 0);
glViewportIndexedfv(0, &glm::vec4(0, 0, Window.Size.x, Window.Size.y)[0]);
glClearBufferfv(GL_COLOR, 0, &glm::vec4(0.0f)[0]);
glBindProgramPipeline(PipelineName);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, Texture2DName);
glBindVertexArray(VertexArrayName);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, BufferName[buffer::ELEMENT]); //!\ Need to be called after glBindVertexArray
glDrawElementsInstancedBaseVertex(GL_TRIANGLES, ElementCount, GL_UNSIGNED_INT, NULL, 1, 0);
glf::checkError("display");
glf::swapBuffers();
}
void display()
{
glProgramUniform1i(ProgramName, UniformDiffuse, 0);
// Clear the framebuffer
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glClearBufferfv(GL_COLOR, 0, &glm::vec4(1.0f, 0.5f, 0.0f, 1.0f)[0]);
glUseProgram(ProgramName);
// Pass 1
// Render the scene in a multisampled framebuffer
glEnable(GL_MULTISAMPLE);
renderFBO(ProgramName, FramebufferRenderName);
glDisable(GL_MULTISAMPLE);
// Resolved multisampling
glBindFramebuffer(GL_READ_FRAMEBUFFER, FramebufferRenderName);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, FramebufferResolveName);
glBlitFramebuffer(
0, 0, FRAMEBUFFER_SIZE.x, FRAMEBUFFER_SIZE.y,
0, 0, FRAMEBUFFER_SIZE.x, FRAMEBUFFER_SIZE.y,
GL_COLOR_BUFFER_BIT, GL_LINEAR);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
// Pass 2
// Render the colorbuffer from the multisampled framebuffer
renderFB(ProgramName, ColorTextureName);
glf::checkError("display");
glf::swapBuffers();
}
void renderFBO(GLuint Framebuffer)
{
glm::mat4 Perspective = glm::perspective(45.0f, float(FRAMEBUFFER_SIZE.x) / FRAMEBUFFER_SIZE.y, 0.1f, 100.0f);
glm::mat4 ViewFlip = glm::scale(glm::mat4(1.0f), glm::vec3(1.0f,-1.0f, 1.0f));
glm::mat4 ViewTranslate = glm::translate(ViewFlip, glm::vec3(0.0f, 0.0f, -Window.TranlationCurrent.y * 2.0));
glm::mat4 View = glm::rotate(ViewTranslate,-15.f, glm::vec3(0.f, 0.f, 1.f));
glm::mat4 Model = glm::mat4(1.0f);
glm::mat4 MVP = Perspective * View * Model;
glProgramUniformMatrix4fv(ProgramName[program::VERTEX], UniformMVP, 1, GL_FALSE, &MVP[0][0]);
glProgramUniform1i(ProgramName[program::FRAGMENT], UniformDiffuse, 0);
glViewportIndexedf(0, 0, 0, float(FRAMEBUFFER_SIZE.x), float(FRAMEBUFFER_SIZE.y));
glBindFramebuffer(GL_FRAMEBUFFER, Framebuffer);
glClearBufferfv(GL_COLOR, 0, &glm::vec4(0.0f, 0.5f, 1.0f, 1.0f)[0]);
glBindMultiTextureEXT(GL_TEXTURE0, GL_TEXTURE_2D, TextureName);
glBindSampler(0, SamplerName);
glBindVertexArray(VertexArrayName);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, BufferName[buffer::ELEMENT]);
glDrawElementsInstancedBaseVertex(GL_TRIANGLES, ElementCount, GL_UNSIGNED_SHORT, NULL, 1, 0);
glf::checkError("renderFBO");
}
void OpenGLEngine::EnableTextureArrays (Shader const* shader, GLuint program)
{
auto const textures = shader->GetData (TextureArray::shaderLookUp);
for (auto texture = textures.begin (); texture != textures.end (); texture ++)
{
if (texture->object)
{
std::shared_ptr<OGLTextureArray> oglTex = std::static_pointer_cast<OGLTextureArray> (Bind (texture->object));
if (oglTex)
{
auto target = oglTex->GetTarget ();
auto oglObject = oglTex->GetOGLDrawObject ();
auto location = texture->bindPoint;
int unit = m_TextureUnitMap.AskConnectionUnit (program, location);
glProgramUniform1i (program, location, unit);
glActiveTexture (GL_TEXTURE0 + unit);
glBindTexture (target, oglObject);
}
else
{
fprintf (stderr, "The enable texture arrays method in OpenGLEngine failed, because the binding of the object failed.\n");
}
}
else
{
fprintf (stderr, "The enable texture arrays method in OpenGLEngine failed, because the object in the buffer is null.\n");
}
}
}
void
ShaderProgram::setUniform(const char* param, int val)
{
unsigned int loc = getUniformLocation(param);
// gl_check(glUniform1f(m_programId, loc, val));
gl_check(glProgramUniform1i(m_programId, loc, val));
}
void OGL4ShaderProgram::BindTextures()
{
int slot = 0;
for(auto v : m_texLinks)
{
if(v.pTex == nullptr)
{
continue;
}
glActiveTexture(GL_TEXTURE0 + slot);
OGL4Texture* pGLTex = (OGL4Texture*)v.pTex.get();
OGL4Sampler* pSampler = (OGL4Sampler*)v.pSampler.get();
pSampler ? pSampler->Bind(slot) : (void)0;
GLenum target = OGL4Convert::TexTypeToGLTarget(pGLTex->GetType());
glBindTexture(target, pGLTex->GetTextureObject());
glProgramUniform1i(m_program, v.index, slot);
slot++;
}
}
//------------------------------------------------------------------------------
void
drawPtexLayout(int page) {
glUseProgram(g_debugProgram);
GLint width, height, depth;
glGetTexLevelParameteriv(GL_TEXTURE_2D_ARRAY, 0, GL_TEXTURE_WIDTH, &width);
glGetTexLevelParameteriv(GL_TEXTURE_2D_ARRAY, 0, GL_TEXTURE_HEIGHT, &height);
glGetTexLevelParameteriv(GL_TEXTURE_2D_ARRAY, 0, GL_TEXTURE_DEPTH, &depth);
GLint pageUniform = glGetUniformLocation(g_debugProgram, "ptexDebugPage");
glProgramUniform1i(g_debugProgram, pageUniform, page);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(-1, 1, -1, 1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glBegin(GL_TRIANGLE_STRIP);
glVertex3f(0, 0, 0);
glVertex3f(0, 1, 0);
glVertex3f(1, 0, 0);
glVertex3f(1, 1, 0);
glEnd();
glUseProgram(0);
drawFmtString(g_width/2, g_height - 10, "Size = %dx%d, Page = %d/%d", width, height, page, depth);
}
void linkDebugProgram() {
if (g_debugProgram)
glDeleteProgram(g_debugProgram);
GLuint vertexShader = compileShader(GL_VERTEX_SHADER,
"PTEX_DEBUG_VERTEX_SHADER");
GLuint fragmentShader = compileShader(GL_FRAGMENT_SHADER,
"PTEX_DEBUG_FRAGMENT_SHADER");
g_debugProgram = glCreateProgram();
glAttachShader(g_debugProgram, vertexShader);
glAttachShader(g_debugProgram, fragmentShader);
glLinkProgram(g_debugProgram);
glDeleteShader(fragmentShader);
GLint status;
glGetProgramiv(g_debugProgram, GL_LINK_STATUS, &status );
if( status == GL_FALSE ) {
GLchar emsg[1024];
glGetProgramInfoLog(g_debugProgram, sizeof(emsg), 0, emsg);
fprintf(stderr, "Error linking GLSL program : %s\n", emsg );
exit(0);
}
GLint texData = glGetUniformLocation(g_debugProgram, "ptexDebugData");
glProgramUniform1i(g_debugProgram, texData, 0);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D_ARRAY, g_osdPTexImage->GetTexelsTexture());
}
void shader_setbool(shader_t shader, sparam_t param, bool val)
{
if (matching_shader(shader, param)) {
glProgramUniform1i(shader->program, param->param, (GLint)val);
gl_success("glProgramUniform1i");
}
}
void bindPTexture(OpenSubdiv::OsdPTexture *osdPTex, GLuint data, GLuint packing, GLuint pages, int samplerUnit)
{
glProgramUniform1i(g_program, data, samplerUnit + 0);
glActiveTexture(GL_TEXTURE0 + samplerUnit + 0);
glBindTexture(GL_TEXTURE_2D_ARRAY, osdPTex->GetTexelsTexture());
glProgramUniform1i(g_program, packing, samplerUnit + 1);
glActiveTexture(GL_TEXTURE0 + samplerUnit + 1);
glBindTexture(GL_TEXTURE_BUFFER, osdPTex->GetLayoutTextureBuffer());
glProgramUniform1i(g_program, pages, samplerUnit + 2);
glActiveTexture(GL_TEXTURE0 + samplerUnit + 2);
glBindTexture(GL_TEXTURE_BUFFER, osdPTex->GetPagesTextureBuffer());
glActiveTexture(GL_TEXTURE0);
}
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);
}
void ShaderProgram::bindTextures() const
{
for(const auto& i : textures_)
{
//Activate the appropriate texture unit and texture
Texture::setActiveUnit(i.first);
i.second.second->bind();
if(!ext::separateShaderObjects()) //If we can't do uniforms without binding
{
//Get the currently-bound program and bind this program
auto previous = getBound();
bind();
//Set the uniform
glCheck(glUniform1i(i.second.first, i.first));
//Set the previous values back
glCheck(glUseProgram(previous));
}
else //If we can do uniforms without binding
{
//Set the uniform with this program
glCheck(glProgramUniform1i(program_, i.second.first, i.first));
}
}
//Reset the active texture unit to 0
Texture::setActiveUnit(0);
}
void shader_setint(shader_t shader, sparam_t param, int val)
{
if (matching_shader(shader, param)) {
glProgramUniform1i(shader->program, param->param, val);
gl_success("glProgramUniform1i");
}
}
bool render()
{
glm::vec2 WindowSize(this->getWindowSize());
glm::mat4 Projection = glm::perspective(glm::pi<float>() * 0.25f, 4.0f / 3.0f, 0.1f, 100.0f);
glm::mat4 Model = glm::mat4(1.0f);
glm::mat4 MVP = Projection * this->view() * Model;
glProgramUniformMatrix4fv(ProgramName[program::VERT], UniformMVP, 1, GL_FALSE, &MVP[0][0]);
glProgramUniform1i(ProgramName[program::FRAG], UniformDiffuse, 0);
glViewportIndexedfv(0, &glm::vec4(0, 0, WindowSize.x, WindowSize.y)[0]);
glClearBufferfv(GL_COLOR, 0, &glm::vec4(0.0f)[0]);
glBindProgramPipeline(PipelineName);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, Texture2DName);
glBindVertexArray(VertexArrayName);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, BufferName[buffer::ELEMENT]); //!\ Need to be called after glBindVertexArray
glDrawElementsInstancedBaseVertex(GL_TRIANGLES, ElementCount, GL_UNSIGNED_INT, nullptr, 1, 0);
return true;
}
int main(int, char **)
{
glDispatchCompute(1, 1, 1);
glProgramUniform1i(0, 0, 0);
return 0;
}
void RadixSort::SortBits (int bits)
{
// pass current bit shift to the shader programs
glProgramUniform1i (counting.get (), counting_bitshift, bits);
glProgramUniform1i (globalsort.get (), globalsort_bitshift, bits);
// set buffer bindings
{
GLuint bufs[4] = { buffer, prefixsums, blocksums.front (), result };
glBindBuffersBase (GL_SHADER_STORAGE_BUFFER, 0, 4, bufs);
}
// counting
counting.Use ();
glDispatchCompute (numblocks, 1, 1);
glMemoryBarrier (GL_SHADER_STORAGE_BARRIER_BIT);
// create block sums level by level
blockscan.Use ();
uint32_t numblocksums = (4 * numblocks) / blocksize;
for (int i = 0; i < blocksums.size () - 1; i++)
{
glBindBuffersBase (GL_SHADER_STORAGE_BUFFER, 0, 2, &blocksums[i]);
glDispatchCompute (numblocksums > 0 ? numblocksums : 1, 1, 1);
numblocksums /= blocksize;
glMemoryBarrier (GL_SHADER_STORAGE_BARRIER_BIT);
}
// add block sums level by level (in reversed order)
addblocksum.Use ();
for (int i = blocksums.size () - 3; i >= 0; i--)
{
uint32_t numblocksums = (4 * numblocks) / intpow (blocksize, i + 1);
glBindBuffersBase (GL_SHADER_STORAGE_BUFFER, 0, 2, &blocksums[i]);
glDispatchCompute (numblocksums > 0 ? numblocksums : 1, 1, 1);
glMemoryBarrier (GL_SHADER_STORAGE_BARRIER_BIT);
}
// map values to their global position in the output buffer
{
GLuint bufs[2] = { buffer, prefixsums };
glBindBuffersBase (GL_SHADER_STORAGE_BUFFER, 0, 2, bufs);
}
globalsort.Use ();
glDispatchCompute (numblocks, 1, 1);
glMemoryBarrier (GL_SHADER_STORAGE_BARRIER_BIT);
}
EffectDrawRegistry::ConfigType *
EffectDrawRegistry::_CreateDrawConfig(
DescType const & desc,
SourceConfigType const * sconfig)
{
ConfigType * config = BaseRegistry::_CreateDrawConfig(desc.first, sconfig);
assert(config);
// XXXdyu can use layout(binding=) with GLSL 4.20 and beyond
g_transformBinding = 0;
glUniformBlockBinding(config->program,
glGetUniformBlockIndex(config->program, "Transform"),
g_transformBinding);
g_tessellationBinding = 1;
glUniformBlockBinding(config->program,
glGetUniformBlockIndex(config->program, "Tessellation"),
g_tessellationBinding);
g_lightingBinding = 2;
glUniformBlockBinding(config->program,
glGetUniformBlockIndex(config->program, "Lighting"),
g_lightingBinding);
CHECK_GL_ERROR("CreateDrawConfig B \n");
GLint loc;
if ((loc = glGetUniformLocation(config->program, "g_VertexBuffer")) != -1) {
glProgramUniform1i(config->program, loc, 0); // GL_TEXTURE0
}
if ((loc = glGetUniformLocation(config->program, "g_ValenceBuffer")) != -1) {
glProgramUniform1i(config->program, loc, 1); // GL_TEXTURE1
}
if ((loc = glGetUniformLocation(config->program, "g_QuadOffsetBuffer")) != -1) {
glProgramUniform1i(config->program, loc, 2); // GL_TEXTURE2
}
if ((loc = glGetUniformLocation(config->program, "g_patchLevelBuffer")) != -1) {
glProgramUniform1i(config->program, loc, 3); // GL_TEXTURE3
}
if ((loc = glGetUniformLocation(config->program, "g_ptexIndicesBuffer")) != -1) {
glProgramUniform1i(config->program, loc, 4); // GL_TEXTURE4
}
CHECK_GL_ERROR("CreateDrawConfig leave\n");
return config;
}
void
VSShaderLib::setUniform(std::string name, int value) {
int val = value;
myUniforms u = pUniforms[name];
glProgramUniform1i(pProgram, u.location, val);
}
void RSky_CreatePrograms (void)
{
gl_skycubeprog = GL_CreateShaderFromName ("glsl/sky.glsl", "SkyVS", "SkyFS");
u_skylocalMatrix = glGetUniformLocation (gl_skycubeprog, "localMatrix");
u_skytexturematrix = glGetUniformLocation (gl_skycubeprog, "skymatrix");
glProgramUniform1i (gl_skycubeprog, glGetUniformLocation (gl_skycubeprog, "skydiffuse"), 0);
}
int main()
{
GlRunner *runner = new GlRunner(RenderCB);
runner->UpdateKeyboardCB(self_key_cb);
VS = runner->BuildShaderProgram("shaders/point_light.vert", GL_VERTEX_SHADER);
FS = runner->BuildShaderProgram("shaders/spot_light.frag", GL_FRAGMENT_SHADER);
GLuint pipe = runner->BuildProgramPipeline();
glUseProgramStages(pipe, GL_VERTEX_SHADER_BIT, VS);
glUseProgramStages(pipe, GL_FRAGMENT_SHADER_BIT, FS);
GLuint VAO;
GLuint VBO[3];
glGenVertexArrays(1, &VAO);
glBindVertexArray(VAO);
glGenBuffers(3, VBO);
glBindBuffer(GL_ARRAY_BUFFER, VBO[0]);
glBufferData(GL_ARRAY_BUFFER, sizeof(ground), ground, GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3*sizeof(GLfloat), (GLvoid *)0);
glEnableVertexAttribArray(0);
glBindBuffer(GL_ARRAY_BUFFER, VBO[1]);
glBufferData(GL_ARRAY_BUFFER, sizeof(texcoord), texcoord, GL_STATIC_DRAW);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 2*sizeof(GLfloat), (GLvoid *)0);
glEnableVertexAttribArray(1);
glBindBuffer(GL_ARRAY_BUFFER, VBO[2]);
glBufferData(GL_ARRAY_BUFFER, sizeof(normal), normal, GL_STATIC_DRAW);
glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, 3*sizeof(GLfloat), (GLvoid *)0);
glEnableVertexAttribArray(2);
GLuint textureGround;
glGenTextures(1, &textureGround);
glBindTexture(GL_TEXTURE_2D, textureGround);
int w, h;
unsigned char *img = SOIL_load_image("materials/dark-wood.jpg", &w, &h, 0, SOIL_LOAD_RGBA);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, img);
SOIL_free_image_data(img);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glActiveTexture(GL_TEXTURE0);
glProgramUniform1i(FS, glGetUniformLocation(FS, "color2D"), 0);
runner->OnRender();
return 0;
}
void gfxBindTextures2D(uint32* texs, int8* locations, uint8 numTextures, uint32 program) {
for (uint8 i=0; i<numTextures; i++)
{
if (locations[i] == -1) // Invalid location - uniform not active
continue;
glActiveTexture(GL_TEXTURE0 + i);
glBindTexture(GL_TEXTURE_2D, texs[i]);
glProgramUniform1i(program, 0, locations[i]);
}
}
void
VSShaderLib::setUniform(std::string name, int value) {
// assert(pUniforms.count(name) != 0);
int val = value;
myUniforms u = pUniforms[name];
glProgramUniform1i(pProgram, u.location, val);
}
/*virtual*/
void
HdStSurfaceShader::BindResources(HdSt_ResourceBinder const &binder, int program)
{
// XXX: there's an issue where other shaders try to use textures.
int samplerUnit = binder.GetNumReservedTextureUnits();
TF_FOR_ALL(it, _textureDescriptors) {
HdBinding binding = binder.GetBinding(it->name);
// XXX: put this into resource binder.
if (binding.GetType() == HdBinding::TEXTURE_2D) {
glActiveTexture(GL_TEXTURE0 + samplerUnit);
glBindTexture(GL_TEXTURE_2D, (GLuint)it->handle);
glBindSampler(samplerUnit, it->sampler);
glProgramUniform1i(program, binding.GetLocation(), samplerUnit);
samplerUnit++;
} else if (binding.GetType() == HdBinding::TEXTURE_UDIM_ARRAY) {
glActiveTexture(GL_TEXTURE0 + samplerUnit);
glBindTexture(GL_TEXTURE_2D_ARRAY, (GLuint)it->handle);
glBindSampler(samplerUnit, it->sampler);
glProgramUniform1i(program, binding.GetLocation(), samplerUnit);
samplerUnit++;
} else if (binding.GetType() == HdBinding::TEXTURE_UDIM_LAYOUT) {
glActiveTexture(GL_TEXTURE0 + samplerUnit);
glBindTexture(GL_TEXTURE_1D, (GLuint)it->handle);
glProgramUniform1i(program, binding.GetLocation(), samplerUnit);
samplerUnit++;
} else if (binding.GetType() == HdBinding::TEXTURE_PTEX_TEXEL) {
glActiveTexture(GL_TEXTURE0 + samplerUnit);
glBindTexture(GL_TEXTURE_2D_ARRAY, (GLuint)it->handle);
glProgramUniform1i(program, binding.GetLocation(), samplerUnit);
samplerUnit++;
} else if (binding.GetType() == HdBinding::TEXTURE_PTEX_LAYOUT) {
glActiveTexture(GL_TEXTURE0 + samplerUnit);
glBindTexture(GL_TEXTURE_BUFFER, (GLuint)it->handle);
glProgramUniform1i(program, binding.GetLocation(), samplerUnit);
samplerUnit++;
}
}
void display()
{
GLsizeiptr BufferSize = sizeof(glm::mat4);
{
glBindBuffer(GL_UNIFORM_BUFFER, BufferName[buffer::TRANSFORM]);
glm::byte* Pointer = (glm::byte*)glMapBufferRange(
GL_UNIFORM_BUFFER, 0, BufferSize,
GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT | GL_MAP_UNSYNCHRONIZED_BIT);
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 + 45.0f, glm::vec3(1.f, 0.f, 0.f));
glm::mat4 View = glm::rotate(ViewRotateX, Window.RotationCurrent.x + 45.0f, glm::vec3(0.f, 1.f, 0.f));
glm::mat4 Model = glm::mat4(1.0f);
glm::mat4 MVP = Projection * View * Model;
*(glm::mat4*)Pointer = MVP;
}
{
glm::mat4 ViewRotateX = glm::rotate(ViewTranslate, Window.RotationCurrent.y + 45.0f, glm::vec3(1.f, 0.f, 0.f));
glm::mat4 View = glm::rotate(ViewRotateX, Window.RotationCurrent.x + 90.f + 45.0f, glm::vec3(0.f, 1.f, 0.f));
glm::mat4 Model = glm::mat4(1.0f);
glm::mat4 MVP = Projection * View * Model;
*(glm::mat4*)(Pointer + UniformBufferOffset) = MVP;
}
// Make sure the uniform buffer is uploaded
glUnmapBuffer(GL_UNIFORM_BUFFER);
}
glViewportIndexedf(0, 0, 0, float(Window.Size.x), float(Window.Size.y));
glClearBufferfv(GL_COLOR, 0, &glm::vec4(0.0f, 0.0f, 0.0f, 1.0f)[0]);
glBindProgramPipeline(PipelineName);
glBindVertexArray(VertexArrayName);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, BufferName[buffer::ELEMENT]);
glBindBufferRange(GL_UNIFORM_BUFFER, glf::semantic::uniform::TRANSFORM0, BufferName[buffer::TRANSFORM], 0, BufferSize);
glBindBufferRange(GL_UNIFORM_BUFFER, glf::semantic::uniform::TRANSFORM1, BufferName[buffer::TRANSFORM], UniformBufferOffset, BufferSize);
glBindBufferBase(GL_UNIFORM_BUFFER, glf::semantic::uniform::MATERIAL, BufferName[buffer::MATERIAL]);
for(GLint i = 0; i < 2; ++i)
{
glProgramUniform1i(ProgramName, UniformInstance, i);
glDrawElementsInstancedBaseVertexBaseInstance(
GL_TRIANGLES, ElementCount, GL_UNSIGNED_SHORT, 0, 1, 0, 0);
}
glf::swapBuffers();
}
