// -------------------------------------------------------------------------------------------------------------------- bool TexturedQuadsGLTextureArray::Init(const std::vector<TexturedQuadsProblem::Vertex>& _vertices, const std::vector<TexturedQuadsProblem::Index>& _indices, const std::vector<TextureDetails*>& _textures, size_t _objectCount) { if (!TexturedQuadsSolution::Init(_vertices, _indices, _textures, _objectCount)) { return false; } // Prerequisites auto numTextures = _textures.size(); if (!mTexManager.Init(false, numTextures)) { return false; } // Program const char* kUniformNames[] = { "ViewProjection", "TexContainer", nullptr }; mProgram = CreateProgramT("textures_gl_texture_array_vs.glsl", "textures_gl_texture_array_fs.glsl", kUniformNames, &mUniformLocation); if (mProgram == 0) { console::warn("Unable to initialize solution '%s', shader compilation/linking failed.", GetName().c_str()); return false; } // Textures for (auto it = _textures.begin(); it != _textures.end(); ++it) { mTextures.push_back(mTexManager.newTexture2DFromDetails(*it)); } GLint lastTexId = -1; GLint lastTexUnit = -1; std::vector<DenseTexAddress> texAddress(numTextures); for (size_t i = 0; i < numTextures; ++i) { auto texture = mTextures[i]; auto texId = texture->GetTexId(); if (lastTexId != texId) { lastTexId = texId; lastTexUnit = (GLint) mTexUnits.size(); glActiveTexture(GL_TEXTURE0 + lastTexUnit); glBindTexture(GL_TEXTURE_2D_ARRAY, texId); mTexUnits.push_back(lastTexUnit); } texAddress[i].m_container_index = lastTexUnit; texAddress[i].m_layer = ((float) texture->getSliceNum() + 0.5f) / numTextures; } std::vector<DenseTexAddress> texAddressContents(_objectCount); for (uint32_t i = 0; i < _objectCount; ++i) { texAddressContents[i] = texAddress[i % numTextures]; } mTexAddressBuffer = NewBufferFromVector(GL_SHADER_STORAGE_BUFFER, texAddressContents, GL_DYNAMIC_DRAW); glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, mTexAddressBuffer); // Buffers glGenVertexArrays(1, &mVertexArray); glBindVertexArray(mVertexArray); mVertexBuffer = NewBufferFromVector(GL_ARRAY_BUFFER, _vertices, GL_STATIC_DRAW); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(TexturedQuadsProblem::Vertex), (void*)offsetof(TexturedQuadsProblem::Vertex, pos)); glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(TexturedQuadsProblem::Vertex), (void*)offsetof(TexturedQuadsProblem::Vertex, tex)); glEnableVertexAttribArray(0); glEnableVertexAttribArray(1); std::vector<uint32_t> drawids(_objectCount); for (uint32_t i = 0; i < _objectCount; ++i) { drawids[i] = i; } mDrawIDBuffer = NewBufferFromVector(GL_ARRAY_BUFFER, drawids, GL_STATIC_DRAW); glVertexAttribIPointer(2, 1, GL_UNSIGNED_INT, sizeof(uint32_t), 0); glVertexAttribDivisor(2, 1); glEnableVertexAttribArray(2); mIndexBuffer = NewBufferFromVector(GL_ELEMENT_ARRAY_BUFFER, _indices, GL_STATIC_DRAW); glGenBuffers(1, &mTransformBuffer); glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, mTransformBuffer); return GLRenderer::GetApiError() == GL_NO_ERROR; }
bool GLUniform::CreateUBO(GLuint program, GLuint location, GLenum draw) { GLint size; GLint type; GLint offset; std::string uname; GLsizei dataSize = 0; GLsizeiptr uniformSize; Uniform unif; this->location = location; GLint numUniforms; GLuint index; GLint padding = 0; this->block = glGetUniformBlockIndex(program, this->name.c_str()); std::cout<<"Block index "<<block<< " and location "<<location<<std::endl; glGetActiveUniformBlockiv( program, this->block, GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS, &numUniforms ); GLint *indices = new GLint[numUniforms]; glGetActiveUniformBlockiv( program, this->block, GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES, indices ); for( int i = 0; i < numUniforms; i++) { index = (GLuint)indices[i]; glGetActiveUniformName(program, index, 256, 0, &uname[0]); glGetActiveUniformsiv(program, 1, &index, GL_UNIFORM_TYPE, &type); glGetActiveUniformsiv(program, 1, &index, GL_UNIFORM_OFFSET, &offset); glGetActiveUniformsiv(program, 1, &index, GL_UNIFORM_SIZE, &size); if(type == GL_FLOAT_VEC3) uniformSize = sizeof(glm::vec3); else if(type == GL_FLOAT_VEC2) uniformSize = sizeof(glm::vec2); else if(type == GL_FLOAT_VEC4) uniformSize = sizeof(glm::vec4); else if(type == GL_FLOAT_MAT4) uniformSize = sizeof(glm::mat4); else if(type == GL_FLOAT_MAT3) uniformSize = sizeof(glm::mat3); else if(type == GL_INT) { uniformSize = sizeof(int); padding += 3*sizeof(int); } else if(type == GL_FLOAT) { uniformSize = sizeof(float); padding += 3*sizeof(float); } else uniformSize = 0.0f; dataSize += size*uniformSize; unif = {&uname[0], static_cast<GLint>(size*uniformSize), index, offset}; this->uniforms[&uname[0]] = unif; std::cout << "Uniform <" << unif.name << "> (offset): " << unif.offset <<", (size): " <<unif.size<< ", (index): "<<unif.index<< std::endl; } GLBufferObject ubo(name.c_str(), dataSize + padding, (GLuint)1, GL_UNIFORM_BUFFER, draw); if( ubo.Status(GL_UNIFORM_BUFFER, dataSize) ) { std::cerr << "[E] Buffer " << name << " not created."<<std::endl; return false; } glBindBufferBase(ubo.Type(), location, ubo.Buffer()); this->block = glGetUniformBlockIndex(program, this->name.c_str()); std::cout<<"Block index "<<this->block<< " after bind "<<std::endl; ubo.SetBlockIndex(this->block); this->id = ubo.Buffer(); glBindBuffer(GL_UNIFORM_BUFFER, 0); delete [] indices; return true; }
void Initialize() { printf("Version Pilote OpenGL : %s\n", glGetString(GL_VERSION)); printf("Type de GPU : %s\n", glGetString(GL_RENDERER)); printf("Fabricant : %s\n", glGetString(GL_VENDOR)); printf("Version GLSL : %s\n", glGetString(GL_SHADING_LANGUAGE_VERSION)); int numExtensions; glGetIntegerv(GL_NUM_EXTENSIONS, &numExtensions); GLenum error = glewInit(); if (error != GL_NO_ERROR) { // TODO } #if LIST_EXTENSIONS for (int index = 0; index < numExtensions; ++index) { printf("Extension[%d] : %s\n", index, glGetStringi(GL_EXTENSIONS, index)); } #endif #ifdef _WIN32 // on coupe la synchro vertical pour voir l'effet du delta time wglSwapIntervalEXT(0); #endif // render states par defaut glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LESS); glEnable(GL_CULL_FACE); // AntTweakBar TwInit(TW_OPENGL, NULL); // ou TW_OPENGL_CORE selon le cas de figure objTweakBar = TwNewBar("Multiple Point Lights"); TwAddVarRW(objTweakBar, "Num Point Lights", TW_TYPE_UINT32, &g_NumPointLights, ""); TwAddButton(objTweakBar, "Quitter", &ExitCallbackTw, nullptr, ""); // Objets OpenGL glGenBuffers(1, &g_Camera.UBO); glBindBuffer(GL_UNIFORM_BUFFER, g_Camera.UBO); glBufferData(GL_UNIFORM_BUFFER, sizeof(glm::mat4) * 2, nullptr, GL_STREAM_DRAW); glGenBuffers(1, &PointLight::UBO); glBindBuffer(GL_UNIFORM_BUFFER, PointLight::UBO); glBufferData(GL_UNIFORM_BUFFER, sizeof(PointLight) * MAX_POINT_LIGHTS, nullptr, GL_STREAM_DRAW); glGenBuffers(1, &Material::UBO); glBindBuffer(GL_UNIFORM_BUFFER, Material::UBO); glBufferData(GL_UNIFORM_BUFFER, sizeof(Material), &g_ShinyMaterial, GL_STATIC_DRAW); error = glGetError(); assert(error == GL_NO_ERROR); g_AmbientShader.LoadVertexShader("ambient.vs"); g_AmbientShader.LoadFragmentShader("ambient.fs"); g_AmbientShader.Create(); auto program = g_AmbientShader.GetProgram(); glBindBufferBase(GL_UNIFORM_BUFFER, 0, g_Camera.UBO); auto blockIndex = glGetUniformBlockIndex(program, "ViewProj"); glUniformBlockBinding(program, blockIndex, 0); error = glGetError(); assert(error == GL_NO_ERROR); g_BlinnPhongShader.LoadVertexShader("blinnPhong.vs"); g_BlinnPhongShader.LoadFragmentShader("blinnPhong.fs"); g_BlinnPhongShader.Create(); program = g_BlinnPhongShader.GetProgram(); //glBindBufferBase(GL_UNIFORM_BUFFER, 0, g_Camera.UBO); // deja bound blockIndex = glGetUniformBlockIndex(program, "ViewProj"); glUniformBlockBinding(program, blockIndex, 0); glBindBufferBase(GL_UNIFORM_BUFFER, 1, PointLight::UBO); blockIndex = glGetUniformBlockIndex(program, "Lights"); glUniformBlockBinding(program, blockIndex, 1); glBindBufferBase(GL_UNIFORM_BUFFER, 2, Material::UBO); blockIndex = glGetUniformBlockIndex(program, "Material"); glUniformBlockBinding(program, blockIndex, 2); // Setup error = glGetError(); assert(error == GL_NO_ERROR); previousTime = glutGet(GLUT_ELAPSED_TIME); LoadMesh(g_WallMesh, g_Room); LoadAndCreateTextureRGBA("wall_color_map.jpg", g_Walls.textures[Walls::gWallTexture]); glBindTexture(GL_TEXTURE_2D, g_Walls.textures[Walls::gWallTexture]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); LoadAndCreateTextureRGBA("floor_color_map.jpg", g_Walls.textures[Walls::gFloorTexture]); glBindTexture(GL_TEXTURE_2D, g_Walls.textures[Walls::gFloorTexture]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); LoadAndCreateTextureRGBA("ceiling_color_map.jpg", g_Walls.textures[Walls::gCeilingTexture]); glBindTexture(GL_TEXTURE_2D, g_Walls.textures[Walls::gCeilingTexture]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); const std::string inputFile = "sphere.obj"; LoadOBJ(g_SphereMesh, inputFile); g_Spheres.resize(g_NumPointLights); for (uint32_t index = 0; index < g_NumPointLights; ++index) { g_Spheres[index].initialize(index); } error = glGetError(); assert(error == GL_NO_ERROR); }
void ViewportArrayApplication::Initialize(const char * title) { int i; base::Initialize(title); glGenTransformFeedbacks(1, &xfb); glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, xfb); sort_prog = glCreateProgram(); static const char sort_vs_source[] = "#version 410\n" "\n" "uniform mat4 model_matrix;\n" "\n" "layout (location = 0) in vec4 position;\n" "layout (location = 1) in vec3 normal;\n" "\n" "out vec3 vs_normal;\n" "\n" "void main(void)\n" "{\n" " vs_normal = (model_matrix * vec4(normal, 0.0)).xyz;\n" " gl_Position = model_matrix * position;\n" "}\n"; static const char sort_gs_source[] = "#version 410\n" "\n" "layout (triangles) in;\n" "layout (points, max_vertices = 3) out;\n" "\n" "uniform mat4 projection_matrix;\n" "\n" "in vec3 vs_normal[];\n" "\n" "layout (stream = 0) out vec4 rf_position;\n" "layout (stream = 0) out vec3 rf_normal;\n" "\n" "layout (stream = 1) out vec4 lf_position;\n" "layout (stream = 1) out vec3 lf_normal;\n" "\n" "void main(void)\n" "{\n" " vec4 A = gl_in[0].gl_Position;\n" " vec4 B = gl_in[1].gl_Position;\n" " vec4 C = gl_in[2].gl_Position;\n" " vec3 AB = (B - A).xyz;\n" " vec3 AC = (C - A).xyz;\n" " vec3 face_normal = cross(AB, AC);\n" " int i;\n" "\n" " if (face_normal.x < 0.0)\n" " {\n" " for (i = 0; i < gl_in.length(); i++)\n" " {\n" " rf_position = projection_matrix * (gl_in[i].gl_Position - vec4(30.0, 0.0, 0.0, 0.0));\n" " rf_normal = vs_normal[i];\n" " EmitStreamVertex(0);\n" " }\n" " EndStreamPrimitive(0);\n" " }\n" " else\n" " {\n" " for (i = 0; i < gl_in.length(); i++)\n" " {\n" " lf_position = projection_matrix * (gl_in[i].gl_Position + vec4(30.0, 0.0, 0.0, 0.0));\n" " lf_normal = vs_normal[i];\n" " EmitStreamVertex(1);\n" " }\n" " EndStreamPrimitive(1);\n" " }\n" "}\n"; vglAttachShaderSource(sort_prog, GL_VERTEX_SHADER, sort_vs_source); vglAttachShaderSource(sort_prog, GL_GEOMETRY_SHADER, sort_gs_source); static const char * varyings[] = { "rf_position", "rf_normal", "gl_NextBuffer", "lf_position", "lf_normal" }; glTransformFeedbackVaryings(sort_prog, 5, varyings, GL_INTERLEAVED_ATTRIBS); glLinkProgram(sort_prog); glUseProgram(sort_prog); model_matrix_pos = glGetUniformLocation(sort_prog, "model_matrix"); projection_matrix_pos = glGetUniformLocation(sort_prog, "projection_matrix"); glGenVertexArrays(2, vao); glGenBuffers(2, vbo); for (i = 0; i < 2; i++) { glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, vbo[i]); glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 1024 * 1024 * sizeof(GLfloat), NULL, GL_DYNAMIC_COPY); glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, i, vbo[i]); glBindVertexArray(vao[i]); glBindBuffer(GL_ARRAY_BUFFER, vbo[i]); glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(vmath::vec4) + sizeof(vmath::vec3), NULL); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(vmath::vec4) + sizeof(vmath::vec3), (GLvoid *)(sizeof(vmath::vec4))); glEnableVertexAttribArray(0); glEnableVertexAttribArray(1); } render_prog = glCreateProgram(); static const char render_vs_source[] = "#version 410\n" "\n" "layout (location = 0) in vec4 position;\n" "layout (location = 1) in vec3 normal;\n" "\n" "out vec3 vs_normal;\n" "\n" "void main(void)\n" "{\n" " vs_normal = normal;\n" " gl_Position = position;\n" "}\n"; static const char render_fs_source[] = "#version 410\n" "\n" "layout (location = 0) out vec4 color;\n" "\n" "uniform vec4 pass_color;\n" "\n" "in vec3 vs_normal;\n" "\n" "void main(void)\n" "{\n" " color = pass_color * (0.2 + pow(abs(vs_normal.z), 4.0)) + vec4(1.0, 1.0, 1.0, 0.0) * pow(abs(vs_normal.z), 37.0);\n" "}\n"; vglAttachShaderSource(render_prog, GL_VERTEX_SHADER, render_vs_source); vglAttachShaderSource(render_prog, GL_FRAGMENT_SHADER, render_fs_source); glLinkProgram(render_prog); object.LoadFromVBM("D:/svn/Vermilion-Book/trunk/Code/media/ninja.vbm", 0, 1, 2); }
void DeferredPainter::Initialize(GLuint FBO, GLuint dummyVAO) { BasePainter::Initialize(FBO, dummyVAO); //TODO: CHANGE THIS INTO A PROPER STATIC SHADER m_shaderManager->CreateProgram("StaticMesh"); m_shaderManager->LoadShader("shaders/geometry/SimpleGeometryVS.glsl", "StaticMeshVS", GL_VERTEX_SHADER); m_shaderManager->LoadShader("shaders/geometry/SimpleGeometryFS.glsl", "StaticMeshFS", GL_FRAGMENT_SHADER); m_shaderManager->AttachShader("StaticMeshVS", "StaticMesh"); m_shaderManager->AttachShader("StaticMeshFS", "StaticMesh"); m_shaderManager->LinkProgram("StaticMesh"); //Normal mapped, non-animated shader m_shaderManager->CreateProgram("NormalMappedStatic"); m_shaderManager->LoadShader("shaders/geometry/StaticNormalVS.glsl", "NormalMappedStaticVS", GL_VERTEX_SHADER); m_shaderManager->LoadShader("shaders/geometry/NormalMappedFS.glsl", "NormalMappedStaticFS", GL_FRAGMENT_SHADER); m_shaderManager->AttachShader("NormalMappedStaticVS", "NormalMappedStatic"); m_shaderManager->AttachShader("NormalMappedStaticFS", "NormalMappedStatic"); m_shaderManager->LinkProgram("NormalMappedStatic"); // Normal map shaders m_shaderManager->CreateProgram("StaticNormal"); m_shaderManager->LoadShader("shaders/geometry/StaticNormalVS.glsl", "StaticNormalVS", GL_VERTEX_SHADER); m_shaderManager->LoadShader("shaders/geometry/StaticNormalFS.glsl", "StaticNormalFS", GL_FRAGMENT_SHADER); m_shaderManager->AttachShader("StaticNormalVS", "StaticNormal"); m_shaderManager->AttachShader("StaticNormalFS", "StaticNormal"); m_shaderManager->LinkProgram("StaticNormal"); m_staticNormal = m_shaderManager->GetShaderProgramID("StaticNormal"); m_shaderManager->CreateProgram("AnimatedNormal"); m_shaderManager->LoadShader("shaders/geometry/AnimatedNormalVS.glsl", "AnimatedNormalVS", GL_VERTEX_SHADER); m_shaderManager->LoadShader("shaders/geometry/StaticNormalFS.glsl", "AnimatedNormalFS", GL_FRAGMENT_SHADER); m_shaderManager->AttachShader("AnimatedNormalVS", "AnimatedNormal"); m_shaderManager->AttachShader("AnimatedNormalFS", "AnimatedNormal"); m_shaderManager->LinkProgram("AnimatedNormal"); m_animatedNormal = m_shaderManager->GetShaderProgramID("AnimatedNormal"); // Blend map shaders m_shaderManager->CreateProgram("StaticBlend"); m_shaderManager->LoadShader("shaders/geometry/StaticBlendVS.glsl", "StaticBlendVS", GL_VERTEX_SHADER); m_shaderManager->LoadShader("shaders/geometry/StaticBlendFS.glsl", "StaticBlendFS", GL_FRAGMENT_SHADER); m_shaderManager->AttachShader("StaticBlendVS", "StaticBlend"); m_shaderManager->AttachShader("StaticBlendFS", "StaticBlend"); m_shaderManager->LinkProgram("StaticBlend"); m_staticBlend = m_shaderManager->GetShaderProgramID("StaticBlend"); m_shaderManager->CreateProgram("AnimatedBlend"); m_shaderManager->LoadShader("shaders/geometry/AnimatedBlendVS.glsl", "AnimatedBlendVS", GL_VERTEX_SHADER); m_shaderManager->LoadShader("shaders/geometry/StaticBlendFS.glsl", "AnimatedBlendFS", GL_FRAGMENT_SHADER); m_shaderManager->AttachShader("AnimatedBlendVS", "AnimatedBlend"); m_shaderManager->AttachShader("AnimatedBlendFS", "AnimatedBlend"); m_shaderManager->LinkProgram("AnimatedBlend"); m_animatedBlend = m_shaderManager->GetShaderProgramID("AnimatedBlend"); m_shaderManager->CreateProgram("AnimatedOutline"); m_shaderManager->LoadShader("shaders/Outline/AnimatedOutlineVS.glsl", "AnimatedOutlineVS", GL_VERTEX_SHADER); m_shaderManager->LoadShader("shaders/Outline/OutlineFS.glsl", "AnimatedOutlineFS", GL_FRAGMENT_SHADER); m_shaderManager->AttachShader("AnimatedOutlineVS", "AnimatedOutline"); m_shaderManager->AttachShader("AnimatedOutlineFS", "AnimatedOutline"); m_shaderManager->LinkProgram("AnimatedOutline"); m_shaderManager->CreateProgram("StaticOutline"); m_shaderManager->LoadShader("shaders/Outline/StaticOutlineVS.glsl", "StaticOutlineVS", GL_VERTEX_SHADER); m_shaderManager->LoadShader("shaders/Outline/OutlineFS.glsl", "StaticOutlineFS", GL_FRAGMENT_SHADER); m_shaderManager->AttachShader("StaticOutlineVS", "StaticOutline"); m_shaderManager->AttachShader("StaticOutlineFS", "StaticOutline"); m_shaderManager->LinkProgram("StaticOutline"); m_uniformBufferManager->SetUniformBlockBindingIndex(m_shaderManager->GetShaderProgramID("StaticMesh"), "PerFrameBlock", UniformBufferManager::CAMERA_BINDING_INDEX); m_uniformBufferManager->SetUniformBlockBindingIndex(m_shaderManager->GetShaderProgramID("NormalMappedStatic"), "PerFrameBlock", UniformBufferManager::CAMERA_BINDING_INDEX); m_uniformBufferManager->SetUniformBlockBindingIndex(m_shaderManager->GetShaderProgramID("StaticNormal"), "PerFrameBlock", UniformBufferManager::CAMERA_BINDING_INDEX); m_uniformBufferManager->SetUniformBlockBindingIndex(m_shaderManager->GetShaderProgramID("AnimatedNormal"), "PerFrameBlock", UniformBufferManager::CAMERA_BINDING_INDEX); m_uniformBufferManager->SetUniformBlockBindingIndex(m_shaderManager->GetShaderProgramID("StaticBlend"), "PerFrameBlock", UniformBufferManager::CAMERA_BINDING_INDEX); m_uniformBufferManager->SetUniformBlockBindingIndex(m_shaderManager->GetShaderProgramID("AnimatedBlend"), "PerFrameBlock", UniformBufferManager::CAMERA_BINDING_INDEX); m_uniformBufferManager->SetUniformBlockBindingIndex(m_shaderManager->GetShaderProgramID("AnimatedOutline"), "PerFrameBlock", UniformBufferManager::CAMERA_BINDING_INDEX); m_uniformBufferManager->SetUniformBlockBindingIndex(m_shaderManager->GetShaderProgramID("StaticOutline"), "PerFrameBlock", UniformBufferManager::CAMERA_BINDING_INDEX); m_uniformBufferManager->SetUniformBlockBindingIndex(m_shaderManager->GetShaderProgramID("StaticMesh"), "instanceBufferOffset", UniformBufferManager::INSTANCE_ID_OFFSET_INDEX); m_uniformBufferManager->SetUniformBlockBindingIndex(m_shaderManager->GetShaderProgramID("NormalMappedStatic"), "instanceBufferOffset", UniformBufferManager::INSTANCE_ID_OFFSET_INDEX); m_uniformBufferManager->SetUniformBlockBindingIndex(m_shaderManager->GetShaderProgramID("StaticNormal"), "instanceBufferOffset", UniformBufferManager::INSTANCE_ID_OFFSET_INDEX); m_uniformBufferManager->SetUniformBlockBindingIndex(m_shaderManager->GetShaderProgramID("AnimatedNormal"), "instanceBufferOffset", UniformBufferManager::INSTANCE_ID_OFFSET_INDEX); m_uniformBufferManager->SetUniformBlockBindingIndex(m_shaderManager->GetShaderProgramID("StaticBlend"), "instanceBufferOffset", UniformBufferManager::INSTANCE_ID_OFFSET_INDEX); m_uniformBufferManager->SetUniformBlockBindingIndex(m_shaderManager->GetShaderProgramID("AnimatedBlend"), "instanceBufferOffset", UniformBufferManager::INSTANCE_ID_OFFSET_INDEX); m_uniformBufferManager->SetUniformBlockBindingIndex(m_shaderManager->GetShaderProgramID("AnimatedOutline"), "instanceBufferOffset", UniformBufferManager::INSTANCE_ID_OFFSET_INDEX); m_uniformBufferManager->SetUniformBlockBindingIndex(m_shaderManager->GetShaderProgramID("StaticOutline"), "instanceBufferOffset", UniformBufferManager::INSTANCE_ID_OFFSET_INDEX); m_outlineThickness = 2; m_staticInstances = new InstanceData[MAX_INSTANCES]; glGenBuffers(1, &m_instanceBuffer); glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 4, m_instanceBuffer); glBufferData(GL_SHADER_STORAGE_BUFFER, MAX_INSTANCES * sizeof(InstanceData), NULL, GL_STREAM_COPY); glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 4, 0); glGenBuffers(1, &m_instanceOffsetBuffer); glBindBuffer(GL_UNIFORM_BUFFER, m_instanceOffsetBuffer); glBufferData(GL_UNIFORM_BUFFER, 4*sizeof(unsigned int), NULL, GL_DYNAMIC_DRAW); glBindBufferBase(GL_UNIFORM_BUFFER, UniformBufferManager::INSTANCE_ID_OFFSET_INDEX, 0); }
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 LevelBase; } tessellationData; tessellationData.TessLevel = static_cast<float>(1 << _tessFactor); tessellationData.GregoryQuadOffsetBase = patch.gregoryQuadOffsetBase; tessellationData.LevelBase = patch.levelBase; 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 Render(float alpha, float elapsedtime) { float tmp[16]; float texmat[16]; float view[16]; float viewinv[16]; float proj[16]; float viewproj[16]; float lightview[16]; float lightproj[16]; float lightviewproj[16]; float globalambient[4] = { 0.01f, 0.01f, 0.01f, 1.0f }; float moonlight[] = { -0.25f, 0.65f, -1, 0 }; float mooncolor[] = { 0.6f, 0.6f, 1, 1 }; float eye[3] = { 0, 0, 8 }; float look[3] = { 0, 0, 0 }; float up[3] = { 0, 1, 0 }; float screensize[2] = { (float)screenwidth, (float)screenheight }; float lightclip[2]; float clipplanes[2]; float orient[2]; // setup camera cameraangle.smooth(orient, alpha); GLMatrixRotationAxis(view, orient[1], 1, 0, 0); GLMatrixRotationAxis(tmp, orient[0], 0, 1, 0); GLMatrixMultiply(view, view, tmp); GLVec3Transform(eye, eye, view); GLFitToBox(clipplanes[0], clipplanes[1], eye, look, scenebox); GLMatrixPerspectiveFovRH(proj, (60.0f * 3.14159f) / 180.f, (float)screenwidth / (float)screenheight, clipplanes[0], clipplanes[1]); GLMatrixLookAtRH(view, eye, look, up); GLMatrixMultiply(viewproj, view, proj); // setup moonlight GLMatrixInverse(viewinv, view); GLVec3Transform(moonlight, moonlight, viewinv); GLVec3Normalize(moonlight, moonlight); // should be that value in view space (background is fix) // but let y stay in world space, so we see shadow moonlight[1] = 0.65f; GLMatrixViewVector(lightview, moonlight); GLFitToBox(lightproj, lightclip, lightview, scenebox); GLMatrixMultiply(lightviewproj, lightview, lightproj); // render shadow map glClearColor(0, 0, 0, 1); varianceshadow->SetMatrix("matViewProj", lightviewproj); varianceshadow->SetVector("clipPlanes", lightclip); shadowmap->Set(); { glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); varianceshadow->Begin(); { RenderScene(varianceshadow); } varianceshadow->End(); } shadowmap->Unset(); // blur it float texelsize[] = { 1.0f / SHADOWMAP_SIZE, 1.0f / SHADOWMAP_SIZE }; glDepthMask(GL_FALSE); glBindTexture(GL_TEXTURE_2D, shadowmap->GetColorAttachment(0)); boxblur3x3->SetVector("texelSize", texelsize); blurredshadow->Set(); { boxblur3x3->Begin(); { screenquad->Draw(); } boxblur3x3->End(); } blurredshadow->Unset(); glDepthMask(GL_TRUE); // STEP 1: z pass ambient->SetMatrix("matViewProj", viewproj); ambient->SetVector("matAmbient", globalambient); framebuffer->Set(); { glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); // draw background first glDisable(GL_DEPTH_TEST); glDepthMask(GL_FALSE); glBindTexture(GL_TEXTURE_2D, texture3); float scaledx = 1360.0f * (screenheight / 768.0f); float scale = screenwidth / scaledx; GLMatrixTranslation(tmp, -0.5f, 0, 0); GLMatrixScaling(texmat, scale, 1, 1); GLMatrixMultiply(texmat, tmp, texmat); GLMatrixTranslation(tmp, 0.5f, 0, 0); GLMatrixMultiply(texmat, texmat, tmp); GLMatrixRotationAxis(tmp, M_PI, 0, 0, 1); GLMatrixMultiply(texmat, texmat, tmp); basic2D->SetMatrix("matTexture", texmat); basic2D->Begin(); { screenquad->Draw(); } basic2D->End(); glEnable(GL_DEPTH_TEST); glDepthMask(GL_TRUE); // then fill zbuffer ambient->Begin(); { RenderScene(ambient); } ambient->End(); } framebuffer->Unset(); // STEP 2: cull lights if( lightcull && timeout > DELAY ) { lightcull->SetFloat("alpha", alpha); lightcull->SetVector("clipPlanes", clipplanes); lightcull->SetVector("screenSize", screensize); lightcull->SetMatrix("matProj", proj); lightcull->SetMatrix("matView", view); lightcull->SetMatrix("matViewProj", viewproj); glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, counterbuffer); GLuint* counter = (GLuint*)glMapBuffer(GL_ATOMIC_COUNTER_BUFFER, GL_WRITE_ONLY); *counter = 0; glUnmapBuffer(GL_ATOMIC_COUNTER_BUFFER); glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, headbuffer); glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, nodebuffer); glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, lightbuffer); glBindBufferBase(GL_ATOMIC_COUNTER_BUFFER, 0, counterbuffer); glBindTexture(GL_TEXTURE_2D, framebuffer->GetDepthAttachment()); lightcull->Begin(); { glDispatchCompute(workgroupsx, workgroupsy, 1); } lightcull->End(); glBindBufferBase(GL_ATOMIC_COUNTER_BUFFER, 0, 0); glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, 0); glBindTexture(GL_TEXTURE_2D, 0); } // STEP 3: add some moonlight with shadow glEnable(GL_BLEND); glBlendFunc(GL_ONE, GL_ONE); glDepthMask(GL_FALSE); framebuffer->Set(); shadowedlight->SetMatrix("matViewProj", viewproj); shadowedlight->SetMatrix("lightViewProj", lightviewproj); shadowedlight->SetVector("eyePos", eye); shadowedlight->SetVector("lightPos", moonlight); shadowedlight->SetVector("lightColor", mooncolor); shadowedlight->SetVector("clipPlanes", lightclip); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, blurredshadow->GetColorAttachment(0)); glActiveTexture(GL_TEXTURE0); shadowedlight->Begin(); { RenderScene(shadowedlight); } shadowedlight->End(); // STEP 4: accumulate lighting if( lightaccum && timeout > DELAY ) { lightaccum->SetMatrix("matViewProj", viewproj); lightaccum->SetVector("eyePos", eye); lightaccum->SetFloat("alpha", alpha); lightaccum->SetInt("numTilesX", workgroupsx); lightaccum->Begin(); { RenderScene(lightaccum); } lightaccum->End(); glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, 0); glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, 0); glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, 0); } framebuffer->Unset(); glDisable(GL_BLEND); glDepthMask(GL_TRUE); // STEP 4: gamma correct glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); glBindTexture(GL_TEXTURE_2D, framebuffer->GetColorAttachment(0)); gammacorrect->Begin(); { screenquad->Draw(); } gammacorrect->End(); #ifdef _DEBUG // check errors GLenum err = glGetError(); if( err != GL_NO_ERROR ) std::cout << "Error\n"; #endif SwapBuffers(hdc); mousedx = mousedy = 0; }
// -------------------------------------------------------------------------------------------------------------------- bool TexturedQuadsGLBindlessMultiDraw::Init(const std::vector<TexturedQuadsProblem::Vertex>& _vertices, const std::vector<TexturedQuadsProblem::Index>& _indices, const std::vector<TextureDetails*>& _textures, size_t _objectCount) { if (!TexturedQuadsSolution::Init(_vertices, _indices, _textures, _objectCount)) { return false; } // Prerequisites if (glGetTextureHandleARB == nullptr) { console::warn("Unable to initialize solution '%s', requires support for bindless textures (not present).", GetName().c_str()); return false; } // Programs mProgram = CreateProgram("textures_gl_bindless_multidraw_vs.glsl", "textures_gl_bindless_multidraw_fs.glsl"); if (mProgram == 0) { console::warn("Unable to initialize solution '%s', shader compilation/linking failed.", GetName().c_str()); return false; } // Textures for (auto it = _textures.begin(); it != _textures.end(); ++it) { GLuint tex = NewTex2DFromDetails(*(*it)); if (!tex) { console::warn("Unable to initialize solution '%s', texture creation failed.", GetName().c_str()); return false; } // Needs to be freed later. mTextures.push_back(tex); GLuint64 texHandle = glGetTextureHandleARB(tex); if (texHandle == 0) { console::warn("Unable to initialize solution '%s', couldn't get texture handle.", GetName().c_str()); } mTexHandles.push_back(texHandle); } // Buffers mVertexBuffer = NewBufferFromVector(GL_ARRAY_BUFFER, _vertices, GL_STATIC_DRAW); mIndexBuffer = NewBufferFromVector(GL_ELEMENT_ARRAY_BUFFER, _indices, GL_STATIC_DRAW); glGenBuffers(1, &mTransformBuffer); glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, mTransformBuffer); auto srcIt = mTexHandles.cbegin(); std::vector<GLuint64> texAddressContents(_objectCount); for (auto dstIt = texAddressContents.begin(); dstIt != texAddressContents.end(); ++dstIt) { if (srcIt == mTexHandles.cend()) { srcIt = mTexHandles.cbegin(); } (*dstIt) = *srcIt; ++srcIt; } mTexAddressBuffer = NewBufferFromVector(GL_SHADER_STORAGE_BUFFER, texAddressContents, GL_STATIC_DRAW); glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, mTexAddressBuffer); mCommands.resize(_objectCount); return GLRenderer::GetApiError() == GL_NO_ERROR; }
void renderScene(void) { int i; int count; glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); setCamera(1.5,1.5,3.5,1.5,1.5,0); glUseProgram(p); setUniforms(); for (count = 0; count < 3; ++count) { glBindVertexArray(vao[count]); glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, tfbuf[count]); glEnable(GL_RASTERIZER_DISCARD); glBeginTransformFeedback(GL_TRIANGLES); glDrawArrays(GL_TRIANGLES, 0, 3); glEndTransformFeedback(); glDisable(GL_RASTERIZER_DISCARD); glBindBuffer(GL_ARRAY_BUFFER, tfbuf[count]); glDrawArrays(GL_TRIANGLES, 0, 3); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, tfbuf[count]); float *pos = (float *)glMapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, GL_READ_WRITE); int i; if (pos != NULL) { printf("Triangle #%d\n", count + 1); for (i = 0; i < 3; ++i) { printf(" Vertex #%d\n", i); printf(" Color: \t%f %f %f %f\n", pos[8 * i], pos[8 * i + 1], pos[8 * i + 2], pos[8 * i + 3]); printf(" Pos: \t%f %f %f %f\n", pos[8 * i + 4], pos[8 * i + 5], pos[8 * i + 6], pos[8 * i + 7]); } } if (pos != NULL && dump_vertex) { FILE * pFile; int n; pFile = fopen ("glsl_solid_triangles_overlap_vertex.txt","w"); fprintf(pFile, "Triangle #%d\n", count + 1); for (n=0 ; n<3 ; n++) { fprintf(pFile, " Vertex #%d\n", i); fprintf(pFile, " Color: \t%f %f %f %f\n", pos[8 * i], pos[8 * i + 1], pos[8 * i + 2], pos[8 * i + 3]); fprintf(pFile, " Pos: \t%f %f %f %f\n", pos[8 * i + 4], pos[8 * i + 5], pos[8 * i + 6], pos[8 * i + 7]); } fclose (pFile); } } glutSwapBuffers(); }
void indexed_buffer_target_t::reset_binding( ) { reset_current_buffer(); glBindBufferBase(gl_target_type(type()), idx_, 0); }
void indexed_buffer_target_t::bind_buffer( buffer_ptr buffer ) { set_current_buffer(buffer); glBindBufferBase(gl_target_type(type()), idx_, buffer->gl_id()); }
GLUSboolean init(GLUSvoid) { GLUStextfile vertexSource; GLUStextfile fragmentSource; GLUStextfile computeSource; glusLoadTextFile("../Example30/shader/fullscreen.vert.glsl", &vertexSource); glusLoadTextFile("../Example30/shader/texture.frag.glsl", &fragmentSource); glusBuildProgramFromSource(&g_program, (const GLchar**)&vertexSource.text, 0, 0, 0, (const GLchar**)&fragmentSource.text); glusDestroyTextFile(&vertexSource); glusDestroyTextFile(&fragmentSource); glusLoadTextFile("../Example30/shader/raytrace.comp.glsl", &computeSource); glusBuildComputeProgramFromSource(&g_computeProgram, (const GLchar**)&computeSource.text); glusDestroyTextFile(&computeSource); // // Retrieve the uniform locations in the program. g_textureLocation = glGetUniformLocation(g_program.program, "u_texture"); // // Generate and bind a texture. glGenTextures(1, &g_texture); glBindTexture(GL_TEXTURE_2D, g_texture); // Create an empty image. glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, g_imageWidth, g_imageHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0); // Setting the texture parameters. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glBindTexture(GL_TEXTURE_2D, 0); // // glUseProgram(g_program.program); glGenVertexArrays(1, &g_vao); glBindVertexArray(g_vao); // // Also bind created texture ... glBindTexture(GL_TEXTURE_2D, g_texture); // ... and bind this texture as an image, as we will write to it. see binding = 0 in shader. glBindImageTexture(0, g_texture, 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA8); // ... and as this is texture number 0, bind the uniform to the program. glUniform1i(g_textureLocation, 0); // // glUseProgram(g_computeProgram.program); // // Generate the ray directions depending on FOV, width and height. if (!glusRaytracePerspectivef(g_directionBuffer, PADDING, 30.0f, WIDTH, HEIGHT)) { printf("Error: Could not create direction buffer.\n"); return GLUS_FALSE; } // Compute shader will use these textures just for input. glusRaytraceLookAtf(g_positionBuffer, g_directionBuffer, g_directionBuffer, PADDING, WIDTH, HEIGHT, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f); // // Buffers with the initial ray position and direction. // glGenBuffers(1, &g_directionSSBO); glBindBuffer(GL_SHADER_STORAGE_BUFFER, g_directionSSBO); glBufferData(GL_SHADER_STORAGE_BUFFER, WIDTH * HEIGHT * (3 + PADDING) * sizeof(GLfloat), g_directionBuffer, GL_STATIC_READ); // see binding = 1 in the shader glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, g_directionSSBO); // glGenBuffers(1, &g_positionSSBO); glBindBuffer(GL_SHADER_STORAGE_BUFFER, g_positionSSBO); glBufferData(GL_SHADER_STORAGE_BUFFER, WIDTH * HEIGHT * 4 * sizeof(GLfloat), g_positionBuffer, GL_STATIC_READ); // see binding = 2 in the shader glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, g_positionSSBO); return GLUS_TRUE; }
void CommandBuffer::flushDrawStates() { glBindFramebuffer(GL_FRAMEBUFFER, m_framebuffer); glUseProgram(m_program); if (m_depthEnable) { glEnable(GL_DEPTH_TEST); } else { glDisable(GL_DEPTH_TEST); } int textureSlot = 0; for (unsigned index = 0; index < m_shaderResourceViewCountPS; ++index) { if (m_shaderResourceViewsPS[index]) { glUniform1i(index, textureSlot++); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, m_shaderResourceViewsPS[0]->getTexture()->getNative()); glBindSampler(0, m_samplersPS[0]->getNative()); } } static const GLsizei cTempVertexSize = 32; static const uintptr_t cTempNormalOffset = 12; static const uintptr_t cTempTexOffset = 24; glBindVertexArray(m_vao); const GLint positionIndex = glGetAttribLocation(m_program, "g_position"); if (positionIndex != -1) { glVertexAttribPointer(positionIndex, 3, GL_FLOAT, GL_FALSE, cTempVertexSize, 0); glEnableVertexAttribArray(positionIndex); } const GLint normalIndex = glGetAttribLocation(m_program, "g_normal"); if (normalIndex != -1) { glVertexAttribPointer(normalIndex, 3, GL_FLOAT, GL_FALSE, cTempVertexSize, reinterpret_cast<void*>(cTempNormalOffset)); glEnableVertexAttribArray(normalIndex); } const GLint texIndex = glGetAttribLocation(m_program, "g_tex"); if (texIndex != -1) { glVertexAttribPointer(texIndex, 2, GL_FLOAT, GL_FALSE, cTempVertexSize, reinterpret_cast<void*>(cTempTexOffset)); glEnableVertexAttribArray(texIndex); } if (m_vertexBuffers[0]) { glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffers[0]->getNative()); } glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexBuffer ? m_indexBuffer->getNative() : 0); GLuint bindingIndex = 0; for (unsigned blockIndex = 0; blockIndex < m_constantBufferCountVS; ++blockIndex) { if (m_constantBuffersVS[blockIndex]) { glUniformBlockBinding(m_program, blockIndex, bindingIndex); const auto nativeConstantBuffer = m_constantBuffersVS[blockIndex]->getNative(); glBindBufferBase(GL_UNIFORM_BUFFER, bindingIndex++, nativeConstantBuffer); } } for (unsigned blockIndex = 0; blockIndex < m_constantBufferCountPS; ++blockIndex) { if (m_constantBuffersPS[blockIndex]) { glUniformBlockBinding(m_program, blockIndex, bindingIndex); const auto nativeConstantBuffer = m_constantBuffersPS[blockIndex]->getNative(); glBindBufferBase(GL_UNIFORM_BUFFER, bindingIndex++, nativeConstantBuffer); } } }
void GP_Buffer::bind(GLuint bindingPoint) { glBindBufferBase(GL_SHADER_STORAGE_BUFFER, bindingPoint, id); }
Particles::Particles(shared_ptr<ShaderGroup> m_updateShader, shared_ptr<ShaderGroup> m_renderShader) { this->m_updateShader = m_updateShader; this->m_renderShader = m_renderShader; m_currVB = 0; m_currTFB = 1; m_isFirst = true; float g_radiusRange = 150; float g_heightRange = 35; vector<particle_t> particles; for (int i = 0; i < NUM_RAIN; i++) { particle_t pt; particles.push_back(pt); float SeedX; float SeedY = random()*g_heightRange; float SeedZ; bool pointIsInside = false; while (!pointIsInside) { SeedX = random() - 0.5f; SeedZ = random() - 0.5f; if (sqrt(SeedX*SeedX + SeedZ*SeedZ) <= 0.5f) pointIsInside = true; } //save these random locations for reinitializing rain particles that have fallen out of bounds SeedX *= g_radiusRange; SeedZ *= g_radiusRange; particles[i].seed = glm::vec3(SeedX, SeedY, SeedZ); float SpeedX = 40.0f*(random() / 10.0f); float SpeedZ = 40.0f*(random() / -10.0f); float SpeedY = -40.0f*(random() / 10.0f); particles[i].speed = glm::vec3(SpeedX, SpeedY, SpeedZ); particles[i].pos = glm::vec3(SeedX, SeedY, SeedZ); particles[i].type = floor(random() * 6 + 1); particles[i].random = 0.5f + random()*0.5f; } glGenVertexArrays(2, m_vao); glGenTransformFeedbacks(2, m_transformFeedback); glGenBuffers(2, m_particleBuffer); GL_CHECK_ERRORS(); for (unsigned int i = 0; i < 2; i++) { //init buffers glBindVertexArray(m_vao[i]); glBindBuffer(GL_ARRAY_BUFFER, m_particleBuffer[i]); glBufferData(GL_ARRAY_BUFFER, sizeof(particle_t) * particles.size(), particles.data(), GL_DYNAMIC_DRAW); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(particle_t), 0); // vec3 pos glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(particle_t), (const GLvoid*)(3 * sizeof GLfloat)); // vec3 seed glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, sizeof(particle_t), (const GLvoid*)(6 * sizeof GLfloat)); // vec3 speed glVertexAttribPointer(3, 1, GL_FLOAT, GL_FALSE, sizeof(particle_t), (const GLvoid*)(9 * sizeof GLfloat)); // float random glVertexAttribPointer(4, 1, GL_FLOAT, GL_FALSE, sizeof(particle_t), (const GLvoid*)(10 * sizeof GLfloat)); // int type glBindBuffer(GL_ARRAY_BUFFER, 0); glEnableVertexAttribArray(0); glEnableVertexAttribArray(1); glEnableVertexAttribArray(2); glEnableVertexAttribArray(3); glEnableVertexAttribArray(4); glBindVertexArray(0); //bind feedback buffers glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, m_transformFeedback[i]); glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_particleBuffer[i]); glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0); } GL_CHECK_ERRORS(); }
int FLightBuffer::UploadLights(FDynLightData &data) { int size0 = data.arrays[0].Size()/4; int size1 = data.arrays[1].Size()/4; int size2 = data.arrays[2].Size()/4; int totalsize = size0 + size1 + size2 + 1; // pointless type casting because some compilers can't print enough warnings. if (mBlockAlign > 0 && (unsigned int)totalsize + (mIndex % mBlockAlign) > mBlockSize) { mIndex = ((mIndex + mBlockAlign) / mBlockAlign) * mBlockAlign; // can't be rendered all at once. if ((unsigned int)totalsize > mBlockSize) { int diff = totalsize - (int)mBlockSize; size2 -= diff; if (size2 < 0) { size1 += size2; size2 = 0; } if (size1 < 0) { size0 += size1; size1 = 0; } totalsize = size0 + size1 + size2 + 1; } } if (totalsize <= 1) return -1; if (mIndex + totalsize > mBufferSize/4) { // reallocate the buffer with twice the size unsigned int newbuffer; // first unmap the old buffer glBindBuffer(mBufferType, mBufferId); glUnmapBuffer(mBufferType); // create and bind the new buffer, bind the old one to a copy target (too bad that DSA is not yet supported well enough to omit this crap.) glGenBuffers(1, &newbuffer); glBindBufferBase(mBufferType, LIGHTBUF_BINDINGPOINT, newbuffer); glBindBuffer(mBufferType, newbuffer); // Note: Some older AMD drivers don't do that in glBindBufferBase, as they should. glBindBuffer(GL_COPY_READ_BUFFER, mBufferId); // create the new buffer's storage (twice as large as the old one) mBufferSize *= 2; mByteSize *= 2; if (gl.lightmethod == LM_DIRECT) { glBufferStorage(mBufferType, mByteSize, NULL, GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT); mBufferPointer = (float*)glMapBufferRange(mBufferType, 0, mByteSize, GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT); } else { glBufferData(mBufferType, mByteSize, NULL, GL_DYNAMIC_DRAW); mBufferPointer = (float*)glMapBufferRange(mBufferType, 0, mByteSize, GL_MAP_WRITE_BIT|GL_MAP_INVALIDATE_BUFFER_BIT); } // copy contents and delete the old buffer. glCopyBufferSubData(GL_COPY_READ_BUFFER, mBufferType, 0, 0, mByteSize/2); glBindBuffer(GL_COPY_READ_BUFFER, 0); glDeleteBuffers(1, &mBufferId); mBufferId = newbuffer; } float *copyptr; assert(mBufferPointer != NULL); if (mBufferPointer == NULL) return -1; copyptr = mBufferPointer + mIndex * 4; float parmcnt[] = { 0, float(size0), float(size0 + size1), float(size0 + size1 + size2) }; memcpy(©ptr[0], parmcnt, 4 * sizeof(float)); memcpy(©ptr[4], &data.arrays[0][0], 4 * size0*sizeof(float)); memcpy(©ptr[4 + 4*size0], &data.arrays[1][0], 4 * size1*sizeof(float)); memcpy(©ptr[4 + 4*(size0 + size1)], &data.arrays[2][0], 4 * size2*sizeof(float)); unsigned int bufferindex = mIndex; mIndex += totalsize; draw_dlight += (totalsize-1) / 2; return bufferindex; }
void ShaderEffect::SetUniformBlock(std::string& name, uint_t bufIndex, uint_t ubo) { glBindBufferBase(GL_UNIFORM_BUFFER, bufIndex, ubo); SetUniformBlock(name, bufIndex); }
void Mercury::draw(void) { glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); if (mReset) { mReset = false; mParticles->reset(); mTweakBar->syncValues(); } // // Compute matrices without the legacy matrix stack support // nv::matrix4f projectionMatrix; nv::perspective( projectionMatrix, 45.0f * 2.0f*3.14159f / 360.0f, (float)m_width/(float)m_height, 0.1f, 10.0f); nv::matrix4f viewMatrix = m_transformer->getModelViewMat(); // // update struct representing UBO // mShaderParams.numParticles = mParticles->getSize(); mShaderParams.ModelView = viewMatrix; mShaderParams.InvViewMatrix = inverse(viewMatrix); mShaderParams.ModelViewProjection = projectionMatrix * viewMatrix; mShaderParams.ProjectionMatrix = projectionMatrix; // bind the buffer for the UBO, and update it with the latest values from the CPU-side struct glBindBufferBase(GL_UNIFORM_BUFFER, 1, mUBO); glBindBuffer( GL_UNIFORM_BUFFER, mUBO); glBufferSubData( GL_UNIFORM_BUFFER, 0, sizeof(ShaderParams), &mShaderParams); if (mAnimate) { float timeDelta = getFrameDeltaTime(); mParticles->update(timeDelta); } else { // float timeDelta = getFrameDeltaTime(); mParticles->update(0); } // Display Binary Space Partitions if (mPolygonize) { mSurfaceRenderProg->enable(); glBindFramebuffer(GL_FRAMEBUFFER, fbo); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); uint32_t cellsDim = mParticles->getMCPolygonizer()->getCellsDim(); mShaderParams.cellsize = mParticles->getMCPolygonizer()->getCellSize(); glEnable(GL_CULL_FACE); glEnable(GL_DEPTH_TEST); // Bind packed vertex-isovalue buffer. glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, mParticles->getMCPolygonizer()->getPackedPosValBuffer()); // Bind triangle list hash table for marching cubes algorithm to be referenced from Geometry Shader glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, mParticles->getMCPolygonizer()->getTriTableBuffer()); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mParticles->getMCPolygonizer()->getIndexBuffer()); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_CUBE_MAP, mSkyBoxTexID); GLuint loc = glGetUniformLocation(mSurfaceRenderProg->getProgram(), "skyBoxTex"); glProgramUniform1i(mSurfaceRenderProg->getProgram(), loc, 1); glDrawElements(GL_TRIANGLES, cellsDim * cellsDim * cellsDim * 3, GL_UNSIGNED_INT, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, 0); glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, 0); glDisable(GL_DEPTH_TEST); glDisable(GL_CULL_FACE); glBindFramebuffer(GL_FRAMEBUFFER, 0); mSurfaceRenderProg->disable(); glClearColor(0.0, 0.0, 0.0, 1.0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Draw final scene mQuadProg->enable(); glActiveTexture(GL_TEXTURE3); glBindTexture(GL_TEXTURE_2D, gbuffer_tex[0]); loc = glGetUniformLocation(mQuadProg->getProgram(), "gbuf0"); glProgramUniform1i(mQuadProg->getProgram(), loc, 3); glActiveTexture(GL_TEXTURE4); glBindTexture(GL_TEXTURE_2D, gbuffer_tex[1]); loc = glGetUniformLocation(mQuadProg->getProgram(), "gbuf1"); glProgramUniform1i(mQuadProg->getProgram(), loc, 4); glActiveTexture(GL_TEXTURE5); glBindTexture(GL_TEXTURE_2D, gbuffer_tex[2]); loc = glGetUniformLocation(mQuadProg->getProgram(), "gbuf2"); glProgramUniform1i(mQuadProg->getProgram(), loc, 5); drawScreenAlignedQuad(mQuadProg->getProgram()); mQuadProg->disable(); } else { mParticlesRenderProg->enable(); // draw particles glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE); // additive blend glDisable(GL_DEPTH_TEST); glDisable(GL_CULL_FACE); glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, mParticles->getPosBuffer()->getBuffer()); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mParticles->getIndexBuffer()->getBuffer()); glDrawElements(GL_TRIANGLES, mParticles->getSize() * 6, GL_UNSIGNED_INT, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, 0); glDisable(GL_BLEND); mParticlesRenderProg->disable(); } }
void OsdGLSLComputeContext::UnbindEditShaderStorageBuffers() { glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 9, 0); glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 10, 0); }
static int create_texture(void) { GLuint tex; float *ptr; /* Generate mipmap level 0 */ tex = piglit_rgbw_texture(GL_RGBA, TEX_WIDTH, TEX_WIDTH, GL_FALSE, GL_TRUE, GL_FLOAT); glBindTexture(GL_TEXTURE_2D, tex); if (!piglit_check_gl_error(GL_NO_ERROR)) piglit_report_result(PIGLIT_FAIL); /* Go into appropriate transform feedback or discard state */ if (discard) glEnable(GL_RASTERIZER_DISCARD); if (buffer || prims_written) { float buffer[4096]; buffer[0] = 12345.0; glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, xfb_buf); glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, sizeof(buffer), buffer, GL_STREAM_READ); glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, xfb_buf); glUseProgram(xfb_prog); glBeginTransformFeedback(GL_POINTS); } if (prims_written) { glBeginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, prims_written_query); } if (prims_generated) { glBeginQuery(GL_PRIMITIVES_GENERATED, prims_generated_query); } /* Ask the implementation to generate the remaining mipmap levels. */ glGenerateMipmapEXT(GL_TEXTURE_2D); if (!piglit_check_gl_error(0)) piglit_report_result(PIGLIT_FAIL); /* Check state */ if (discard) { if (!glIsEnabled(GL_RASTERIZER_DISCARD)) { printf("GL_RASTERIZER_DISCARD state not restored " "after glGenerateMipmapEXT\n"); piglit_report_result(PIGLIT_FAIL); } glDisable(GL_RASTERIZER_DISCARD); } if (buffer || prims_written) { glEndTransformFeedback(); glUseProgram(0); } if (buffer) { ptr = glMapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER_EXT, GL_READ_ONLY); if (ptr[0] != 12345.0) { printf("Transform feedback buffer was overwritten " "during glGenerateMipmapEXT\n"); piglit_report_result(PIGLIT_FAIL); } } if (prims_written) { GLuint result; glEndQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN); glGetQueryObjectuiv(prims_written_query, GL_QUERY_RESULT, &result); if (result != 0) { printf("PRIMITIVES_WRITTEN counter was incremented " "during glGenerateMipmapEXT\n"); piglit_report_result(PIGLIT_FAIL); } } if (prims_generated) { GLuint result; glEndQuery(GL_PRIMITIVES_GENERATED); glGetQueryObjectuiv(prims_generated_query, GL_QUERY_RESULT, &result); if (result != 0) { printf("PRIMITIVES_GENERATED counter was incremented " "during glGenerateMipmapEXT\n"); piglit_report_result(PIGLIT_FAIL); } } return tex; }
/** * @brief draw particles */ void ParticleSystem::drawPoints() { // glEnable(GL_PROGRAM_POINT_SZE); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); updateParticles(); // -------------------------------------------------- // transform feedback // -------------------------------------------------- glUseProgram(program_transform); glEnable(GL_RASTERIZER_DISCARD); setUniforms(); glBindBuffer(GL_ARRAY_BUFFER, vbo_position); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0,0); glBindBuffer(GL_ARRAY_BUFFER, vbo_speed); glEnableVertexAttribArray(1); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0,0); glBindBuffer(GL_ARRAY_BUFFER, vbo_ID); glEnableVertexAttribArray(2); glVertexAttribPointer(2, 1, GL_FLOAT, GL_FALSE, 0,0); glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER,0, vbo_draw); glBeginTransformFeedback(GL_POINTS); glDrawArrays(GL_POINTS, 0, num_points); glEndTransformFeedback(); glBindBuffer(GL_ARRAY_BUFFER, 0); glDisable(GL_RASTERIZER_DISCARD); glUseProgram(0); // -------------------------------------------------- // use the results from transformation to draw the particles // -------------------------------------------------- srand (time(NULL)); glm::vec3 r = glm::vec3(static_cast <float> (rand()) / static_cast <float> (RAND_MAX), static_cast <float> (rand()) / static_cast <float> (RAND_MAX), static_cast <float> (rand()) / static_cast <float> (RAND_MAX)); shaderCtrlPoints.Bind(); glUniform1f(shaderCtrlPoints.GetUniformLocation("pointSize"), (float)pointSize); glUniform3f(shaderCtrlPoints.GetUniformLocation("rand"), r.x, r.y, r.z); glUniformMatrix4fv(shaderCtrlPoints.GetUniformLocation("projMX"), 1, GL_FALSE, glm::value_ptr(projMX)); glUniformMatrix4fv(shaderCtrlPoints.GetUniformLocation("viewMX"), 1, GL_FALSE, glm::value_ptr(viewMX)); glUniform3f(shaderCtrlPoints.GetUniformLocation("translate"), 0.5f, 0.5f, 0.5f); currentTime+=deltaT; if(currentTime > 1000000.0f) currentTime = 0.0f; glUniform1f(shaderCtrlPoints.GetUniformLocation("time"), currentTime); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, randomTex); glUniform1i(shaderCtrlPoints.GetUniformLocation("randomtex"), 0); glBindBuffer(GL_ARRAY_BUFFER, vbo_draw); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0,0); glBindBuffer(GL_ARRAY_BUFFER, vbo_speed); glEnableVertexAttribArray(1); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0,0); glDrawArraysInstanced(GL_POINTS, 0, num_points, num_instances); glBindBuffer(GL_ARRAY_BUFFER, 0); shaderCtrlPoints.Release(); // -------------------------------------------------- // swap buffers for particles position (ping-pong update model) // -------------------------------------------------- std::swap(vbo_position, vbo_draw); }
void gfxBindUniformBuffer(uint32 ubo, void* data, size_t size, uint32 bindingPoint) { glBindBufferBase(GL_UNIFORM_BUFFER, bindingPoint, ubo); glBufferSubData(GL_UNIFORM_BUFFER, 0, size, data); }
void DeferredPainter::Render(AnimationManagerGFX* animationManager, unsigned int& renderIndex, FBOTexture* depthBuffer, FBOTexture* normalDepth, FBOTexture* diffuse, FBOTexture* specular, FBOTexture* glowMatID, glm::mat4 viewMatrix, glm::mat4 projMatrix, const float& gamma, RenderInfo& out_RenderInfo) { BasePainter::Render(); unsigned int numDrawCalls = 0; unsigned int numTris = 0; BindGBuffer(depthBuffer, normalDepth, diffuse, specular, glowMatID); glEnable(GL_DEPTH_TEST); glDisable(GL_BLEND); glClearStencil(0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); // Clear depth RT float c[4] = { 0.0f, 0.0f, 0.0f, 1.0f }; glClearBufferfv(GL_COLOR, 1, &glm::vec4(0.0f, 0.0f, 0.0f, 1.0f)[0]); m_shaderManager->UseProgram("StaticBlend"); BasicCamera bc; bc.viewMatrix = viewMatrix; bc.projMatrix = projMatrix; m_uniformBufferManager->SetBasicCameraUBO(bc); std::vector<RenderJobManager::RenderJob> renderJobs = m_renderJobManager->GetJobs(); unsigned int currentShader = std::numeric_limits<decltype(currentShader)>::max(); unsigned int currentMaterial = std::numeric_limits<decltype(currentMaterial)>::max(); unsigned int currentMesh = std::numeric_limits<decltype(currentMesh)>::max(); unsigned int currentLayer = std::numeric_limits<decltype(currentMesh)>::max(); unsigned int objType = std::numeric_limits<decltype(objType)>::max(); unsigned int viewport = std::numeric_limits<decltype(viewport)>::max(); unsigned int layer = std::numeric_limits<decltype(layer)>::max(); unsigned int translucency = std::numeric_limits<decltype(translucency)>::max(); unsigned int meshID = std::numeric_limits<decltype(meshID)>::max(); unsigned int material = std::numeric_limits<decltype(material)>::max(); unsigned int depth = std::numeric_limits<decltype(depth)>::max(); int instanceBufferSize = 0; { Material mat; Mesh mesh; GFXBitmask bitmask; int instanceCount = 0; unsigned int instanceOffset = 0; unsigned int i; bool endMe = false; for (i = renderIndex; i < renderJobs.size(); i++) { bitmask = renderJobs[i].bitmask; objType = GetBitmaskValue(bitmask, BITMASK::TYPE); // Break if no opaque object if (objType != GFX::OBJECT_TYPES::OPAQUE_GEOMETRY) { endMe = true; } if (!endMe) { viewport = GetBitmaskValue(bitmask, BITMASK::VIEWPORT_ID); layer = GetBitmaskValue(bitmask, BITMASK::LAYER); translucency = GetBitmaskValue(bitmask, BITMASK::TRANSLUCENCY_TYPE); meshID = GetBitmaskValue(bitmask, BITMASK::MESH_ID); material = GetBitmaskValue(bitmask, BITMASK::MATERIAL_ID); depth = GetBitmaskValue(bitmask, BITMASK::DEPTH); } if (material == currentMaterial && meshID == currentMesh && !endMe && instanceCount < MAX_INSTANCES && layer == currentLayer) { InstanceData smid = *(InstanceData*)renderJobs.at(i).value; m_staticInstances[instanceOffset + instanceCount] = smid; instanceCount++; instanceBufferSize++; } else { if (i > 0) { instanceOffset += instanceCount; instanceCount = 0; } if (endMe) break; if (material != currentMaterial) { mat = m_materialManager->GetMaterial(material); currentMaterial = material; //compare shader if (mat.shaderProgramID != currentShader) { currentShader = mat.shaderProgramID; } } if (meshID != currentMesh) { mesh = m_meshManager->GetMesh(meshID); currentMesh = meshID; } if (layer != currentLayer) { currentLayer = layer; } InstanceData smid = *(InstanceData*)renderJobs.at(i).value; m_staticInstances[instanceOffset + instanceCount] = smid; instanceCount++; instanceBufferSize++; } } } glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 4, m_instanceBuffer); InstanceData* pData = (InstanceData*)glMapBufferRange(GL_SHADER_STORAGE_BUFFER, 0, MAX_INSTANCES * sizeof(InstanceData), GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT | GL_MAP_UNSYNCHRONIZED_BIT); memcpy(pData, m_staticInstances, instanceBufferSize * sizeof(InstanceData)); glUnmapBuffer(GL_SHADER_STORAGE_BUFFER); currentShader = std::numeric_limits<decltype(currentShader)>::max(); currentMaterial = std::numeric_limits<decltype(currentMaterial)>::max(); currentMesh = std::numeric_limits<decltype(currentMesh)>::max(); currentLayer = std::numeric_limits<decltype(currentMesh)>::max(); objType = std::numeric_limits<decltype(objType)>::max(); viewport = std::numeric_limits<decltype(viewport)>::max(); layer = std::numeric_limits<decltype(layer)>::max(); translucency = std::numeric_limits<decltype(translucency)>::max(); meshID = std::numeric_limits<decltype(meshID)>::max(); material = std::numeric_limits<decltype(material)>::max(); depth = std::numeric_limits<decltype(depth)>::max(); Material mat; Mesh mesh; GFXBitmask bitmask; int instanceCount = 0; unsigned int instanceOffset = 0; unsigned int i; bool endMe = false; for (i = renderIndex; i < renderJobs.size(); i++) { bitmask = renderJobs[i].bitmask; objType = GetBitmaskValue(bitmask, BITMASK::TYPE); // Break if no opaque object if (objType != GFX::OBJECT_TYPES::OPAQUE_GEOMETRY) { endMe = true; } if (!endMe) { viewport = GetBitmaskValue(bitmask, BITMASK::VIEWPORT_ID); layer = GetBitmaskValue(bitmask, BITMASK::LAYER); translucency = GetBitmaskValue(bitmask, BITMASK::TRANSLUCENCY_TYPE); meshID = GetBitmaskValue(bitmask, BITMASK::MESH_ID); material = GetBitmaskValue(bitmask, BITMASK::MATERIAL_ID); depth = GetBitmaskValue(bitmask, BITMASK::DEPTH); } if (material == currentMaterial && meshID == currentMesh && !endMe && instanceCount < MAX_INSTANCES && layer == currentLayer) { //InstanceData smid = *(InstanceData*)renderJobs.at(i).value; //m_staticInstances[instanceOffset+instanceCount] = smid; instanceCount++; } else { if (i > 0) { unsigned int asd[4] = {instanceOffset, 0U, 0U, 0U}; glBindBufferBase(GL_UNIFORM_BUFFER, UniformBufferManager::INSTANCE_ID_OFFSET_INDEX, m_instanceOffsetBuffer); glBufferSubData(GL_UNIFORM_BUFFER, 0, 4*sizeof(unsigned int), asd); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mesh.IBO); if (currentLayer == LAYER_TYPES::OUTLINE_LAYER) { glEnable(GL_STENCIL_TEST); glStencilFunc(GL_ALWAYS, 1, -1); glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE); glEnable(GL_DEPTH_TEST); } glDrawElementsInstanced(GL_TRIANGLES, mesh.indexCount, GL_UNSIGNED_INT, (GLvoid*)0, instanceCount); numDrawCalls++; numTris += (mesh.indexCount / 3) * instanceCount; if (currentLayer == LAYER_TYPES::OUTLINE_LAYER) { glDisable(GL_DEPTH_TEST); glStencilFunc(GL_NOTEQUAL, 1, -1); glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE); glLineWidth(m_staticInstances[instanceOffset + instanceCount - 1].outlineColor[3]); glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); if (currentShader == m_staticBlend || currentShader == m_staticNormal) m_shaderManager->UseProgram("StaticOutline"); else if (currentShader == m_animatedBlend || currentShader == m_animatedNormal) m_shaderManager->UseProgram("AnimatedOutline"); glDrawElementsInstanced(GL_TRIANGLES, mesh.indexCount, GL_UNSIGNED_INT, (GLvoid*)0, instanceCount); numDrawCalls++; numTris += (mesh.indexCount / 3) * instanceCount; glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); glUseProgram(currentShader); glEnable(GL_DEPTH_TEST); glDisable(GL_STENCIL_TEST); } instanceOffset += instanceCount; instanceCount = 0; } if (endMe) break; if (material != currentMaterial) { mat = m_materialManager->GetMaterial(material); //It's possible that a material is removed before an entity. Should this be ok, do we need to be // more rigorous from the outside? if (mat.textures.size() != 4) { LOG_ERROR << "Trying to render object with invalid material" << std::endl; continue; } //alt //assert(mat.textures.size() == 4); currentMaterial = material; //compare shader if (mat.shaderProgramID != currentShader) { glUseProgram(mat.shaderProgramID); currentShader = mat.shaderProgramID; m_uniformTexture0 = m_shaderManager->GetUniformLocation(currentShader, "gDiffuse"); m_uniformTexture1 = m_shaderManager->GetUniformLocation(currentShader, "gNormal"); m_uniformTexture2 = m_shaderManager->GetUniformLocation(currentShader, "gSpecular"); m_uniformTexture3 = m_shaderManager->GetUniformLocation(currentShader, "gGlow"); m_gammaUniform = m_shaderManager->GetUniformLocation(currentShader, "gGamma"); } //set textures m_textureManager->BindTexture(m_textureManager->GetTexture(mat.textures[0]).textureHandle, m_uniformTexture0, 0, GL_TEXTURE_2D); m_textureManager->BindTexture(m_textureManager->GetTexture(mat.textures[1]).textureHandle, m_uniformTexture1, 1, GL_TEXTURE_2D); m_textureManager->BindTexture(m_textureManager->GetTexture(mat.textures[2]).textureHandle, m_uniformTexture2, 2, GL_TEXTURE_2D); m_textureManager->BindTexture(m_textureManager->GetTexture(mat.textures[3]).textureHandle, m_uniformTexture3, 3, GL_TEXTURE_2D); //Set gamma m_shaderManager->SetUniform(gamma, m_gammaUniform); } if (meshID != currentMesh) { mesh = m_meshManager->GetMesh(meshID); currentMesh = meshID; glBindVertexArray(mesh.VAO); } if (layer != currentLayer) { currentLayer = layer; } instanceCount++; } } m_shaderManager->ResetProgram(); glClearStencil(0); glClear(GL_STENCIL_BUFFER_BIT); glDisable(GL_STENCIL_TEST); ClearFBO(); renderIndex = i; out_RenderInfo.numDrawCalls = numDrawCalls; out_RenderInfo.numTris = numTris; }
void piglit_init(int argc, char **argv) { bool pass = true; GLuint buffer[2]; unsigned int i; float ssbo_values[SSBO_SIZE] = {0}; float *map; int index; piglit_require_extension("GL_ARB_shader_storage_buffer_object"); piglit_require_extension("GL_ARB_program_interface_query"); prog = piglit_build_simple_program(vs_pass_thru_text, fs_source); glUseProgram(prog); glClearColor(0, 0, 0, 0); glGenBuffers(2, buffer); glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, buffer[0]); glBufferData(GL_SHADER_STORAGE_BUFFER, SSBO_SIZE*sizeof(GLfloat), &ssbo_values[0], GL_DYNAMIC_DRAW); /* Change binding point */ index = glGetProgramResourceIndex(prog, GL_SHADER_STORAGE_BLOCK, "ssbo[0]"); glShaderStorageBlockBinding(prog, index, 4); glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 4, buffer[1]); glBufferData(GL_SHADER_STORAGE_BUFFER, SSBO_SIZE*sizeof(GLfloat), &ssbo_values[0], GL_DYNAMIC_DRAW); glViewport(0, 0, piglit_width, piglit_height); piglit_draw_rect(-1, -1, 2, 2); glBindBuffer(GL_SHADER_STORAGE_BUFFER, buffer[0]); map = (float *) glMapBuffer(GL_SHADER_STORAGE_BUFFER, GL_READ_ONLY); /* Former bound buffer should not be modified */ for (i = 0; i < SSBO_SIZE; i++) { if (map[i] != 0) { printf("Wrong %d value in buffer[0]: %.2f\n", i, map[i]); pass = false; } } glUnmapBuffer(GL_SHADER_STORAGE_BUFFER); glBindBuffer(GL_SHADER_STORAGE_BUFFER, buffer[1]); map = (float *) glMapBuffer(GL_SHADER_STORAGE_BUFFER, GL_READ_ONLY); for (i = 0; i < SSBO_SIZE; i++) { /* Values should be below ten but different than zero */ if (map[i] == 0 || map[i] > 10) { printf("Wrong %d value in buffer[1]: %.2f\n", i, map[i]); pass = false; } } glUnmapBuffer(GL_SHADER_STORAGE_BUFFER); if (!piglit_check_gl_error(GL_NO_ERROR)) pass = false; piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL); }
void IrrDriver::renderScene(scene::ICameraSceneNode * const camnode, unsigned pointlightcount, std::vector<GlowData>& glows, float dt, bool hasShadow, bool forceRTT) { glBindBufferBase(GL_UNIFORM_BUFFER, 0, SharedObject::ViewProjectionMatrixesUBO); m_scene_manager->setActiveCamera(camnode); PROFILER_PUSH_CPU_MARKER("- Draw Call Generation", 0xFF, 0xFF, 0xFF); PrepareDrawCalls(camnode); PROFILER_POP_CPU_MARKER(); // Shadows { // To avoid wrong culling, use the largest view possible m_scene_manager->setActiveCamera(m_suncam); if (!m_mipviz && !m_wireframe && UserConfigParams::m_dynamic_lights && UserConfigParams::m_shadows && !irr_driver->needUBOWorkaround() && hasShadow) { PROFILER_PUSH_CPU_MARKER("- Shadow", 0x30, 0x6F, 0x90); renderShadows(); PROFILER_POP_CPU_MARKER(); if (UserConfigParams::m_gi) { PROFILER_PUSH_CPU_MARKER("- RSM", 0xFF, 0x0, 0xFF); renderRSM(); PROFILER_POP_CPU_MARKER(); } } m_scene_manager->setActiveCamera(camnode); } PROFILER_PUSH_CPU_MARKER("- Solid Pass 1", 0xFF, 0x00, 0x00); glDepthMask(GL_TRUE); glDepthFunc(GL_LEQUAL); glEnable(GL_DEPTH_TEST); glDisable(GL_BLEND); glEnable(GL_CULL_FACE); if (UserConfigParams::m_dynamic_lights || forceRTT) { m_rtts->getFBO(FBO_NORMAL_AND_DEPTHS).Bind(); glClearColor(0., 0., 0., 0.); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); renderSolidFirstPass(); } PROFILER_POP_CPU_MARKER(); // Lights { PROFILER_PUSH_CPU_MARKER("- Light", 0x00, 0xFF, 0x00); if (UserConfigParams::m_dynamic_lights) renderLights(pointlightcount, hasShadow); PROFILER_POP_CPU_MARKER(); } // Handle SSAO { PROFILER_PUSH_CPU_MARKER("- SSAO", 0xFF, 0xFF, 0x00); ScopedGPUTimer Timer(getGPUTimer(Q_SSAO)); if (UserConfigParams::m_ssao) renderSSAO(); PROFILER_POP_CPU_MARKER(); } PROFILER_PUSH_CPU_MARKER("- Solid Pass 2", 0x00, 0x00, 0xFF); if (UserConfigParams::m_dynamic_lights || forceRTT) { m_rtts->getFBO(FBO_COLORS).Bind(); SColor clearColor(0, 150, 150, 150); if (World::getWorld() != NULL) clearColor = World::getWorld()->getClearColor(); glClearColor(clearColor.getRed() / 255.f, clearColor.getGreen() / 255.f, clearColor.getBlue() / 255.f, clearColor.getAlpha() / 255.f); glClear(GL_COLOR_BUFFER_BIT); glDepthMask(GL_FALSE); } renderSolidSecondPass(); PROFILER_POP_CPU_MARKER(); if (getNormals()) { m_rtts->getFBO(FBO_NORMAL_AND_DEPTHS).Bind(); renderNormalsVisualisation(); m_rtts->getFBO(FBO_COLORS).Bind(); } if (UserConfigParams::m_dynamic_lights && World::getWorld() != NULL && World::getWorld()->isFogEnabled()) { PROFILER_PUSH_CPU_MARKER("- Fog", 0xFF, 0x00, 0x00); m_post_processing->renderFog(); PROFILER_POP_CPU_MARKER(); } PROFILER_PUSH_CPU_MARKER("- Skybox", 0xFF, 0x00, 0xFF); renderSkybox(camnode); PROFILER_POP_CPU_MARKER(); if (getRH()) { m_rtts->getFBO(FBO_COLORS).Bind(); m_post_processing->renderRHDebug(m_rtts->getRH().getRTT()[0], m_rtts->getRH().getRTT()[1], m_rtts->getRH().getRTT()[2], rh_matrix, rh_extend); } if (getGI()) { m_rtts->getFBO(FBO_COLORS).Bind(); m_post_processing->renderGI(rh_matrix, rh_extend, m_rtts->getRH().getRTT()[0], m_rtts->getRH().getRTT()[1], m_rtts->getRH().getRTT()[2]); } PROFILER_PUSH_CPU_MARKER("- Glow", 0xFF, 0xFF, 0x00); // Render anything glowing. if (!m_mipviz && !m_wireframe && UserConfigParams::m_glow) { irr_driver->setPhase(GLOW_PASS); renderGlow(glows); } // end glow PROFILER_POP_CPU_MARKER(); PROFILER_PUSH_CPU_MARKER("- Lensflare/godray", 0x00, 0xFF, 0xFF); computeSunVisibility(); PROFILER_POP_CPU_MARKER(); // Render transparent { PROFILER_PUSH_CPU_MARKER("- Transparent Pass", 0xFF, 0x00, 0x00); ScopedGPUTimer Timer(getGPUTimer(Q_TRANSPARENT)); renderTransparent(); PROFILER_POP_CPU_MARKER(); } m_sync = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0); // Render particles { PROFILER_PUSH_CPU_MARKER("- Particles", 0xFF, 0xFF, 0x00); ScopedGPUTimer Timer(getGPUTimer(Q_PARTICLES)); renderParticles(); PROFILER_POP_CPU_MARKER(); } if (!UserConfigParams::m_dynamic_lights && !forceRTT) { glDisable(GL_FRAMEBUFFER_SRGB); glDisable(GL_DEPTH_TEST); glDepthMask(GL_FALSE); return; } // Ensure that no object will be drawn after that by using invalid pass irr_driver->setPhase(PASS_COUNT); }
void ofBufferObject::unbindRange(GLenum target,GLuint index) const{ glBindBufferBase(target,index,0); }
void DrawableManager::initRenderTypes() { /* * precalls */ auto doubleBufferPreCall = [](gl::Program & prog, const DrawableType & drawType, const core::Camera & cam){ prog.use(); #ifdef LEGACY_MODE const auto modelIndex = glGetUniformBlockIndex(static_cast<GLuint>(prog), "ModelMatrixBuffer"); glUniformBlockBinding(static_cast<GLuint>(prog), modelIndex, k_modelBufferBinding); glBindBufferBase(GL_UNIFORM_BUFFER, k_modelBufferBinding, drawType.modelBuffer); const auto colorIndex = glGetUniformBlockIndex(static_cast<GLuint>(prog), "ColorBuffer"); glUniformBlockBinding(static_cast<GLuint>(prog), colorIndex, k_colorBufferBinding); glBindBufferBase(GL_UNIFORM_BUFFER, k_colorBufferBinding, drawType.colorBuffer); #else glBindBufferBase(GL_SHADER_STORAGE_BUFFER, k_modelBufferBinding, drawType.modelBuffer); glBindBufferBase(GL_SHADER_STORAGE_BUFFER, k_colorBufferBinding, drawType.colorBuffer); #endif prog["ViewProj"] = cam.getProjMatrix() * cam.getViewMatrix(); prog["View"] = cam.getViewMatrix(); prog["lightDir"] = glm::vec3(1.f, 2.f, -3.f); drawType.vao.bind(); }; auto tripleBufferPreCall = [](gl::Program & prog, const DrawableType & drawType, const core::Camera & cam){ prog.use(); #ifdef LEGACY_MODE const auto modelIndex = glGetUniformBlockIndex(static_cast<GLuint>(prog), "ModelMatrixBuffer"); glUniformBlockBinding(static_cast<GLuint>(prog), modelIndex, k_modelBufferBinding); glBindBufferBase(GL_UNIFORM_BUFFER, k_modelBufferBinding, drawType.modelBuffer); const auto colorIndex = glGetUniformBlockIndex(static_cast<GLuint>(prog), "ColorBuffer"); glUniformBlockBinding(static_cast<GLuint>(prog), colorIndex, k_colorBufferBinding); glBindBufferBase(GL_UNIFORM_BUFFER, k_colorBufferBinding, drawType.colorBuffer); const auto miscIndex = glGetUniformBlockIndex(static_cast<GLuint>(prog), "MiscBuffer"); glUniformBlockBinding(static_cast<GLuint>(prog), miscIndex, k_miscBufferBinding); glBindBufferBase(GL_UNIFORM_BUFFER, k_miscBufferBinding, drawType.miscBuffer); #else glBindBufferBase(GL_SHADER_STORAGE_BUFFER, k_modelBufferBinding, drawType.modelBuffer); glBindBufferBase(GL_SHADER_STORAGE_BUFFER, k_colorBufferBinding, drawType.colorBuffer); glBindBufferBase(GL_SHADER_STORAGE_BUFFER, k_miscBufferBinding, drawType.miscBuffer); #endif prog["ViewProj"] = cam.getProjMatrix() * cam.getViewMatrix(); prog["View"] = cam.getViewMatrix(); prog["lightDir"] = glm::vec3(1.f, 2.f, -3.f); drawType.vao.bind(); }; auto singleBufferPreCall = [](gl::Program & prog, const DrawableType & drawType, const core::Camera & cam){ prog.use(); #ifdef LEGACY_MODE const auto modelIndex = glGetUniformBlockIndex(static_cast<GLuint>(prog), "ModelMatrixBuffer"); glUniformBlockBinding(static_cast<GLuint>(prog), modelIndex, k_modelBufferBinding); glBindBufferBase(GL_UNIFORM_BUFFER, k_modelBufferBinding, drawType.modelBuffer); #else glBindBufferBase(GL_SHADER_STORAGE_BUFFER, k_modelBufferBinding, drawType.modelBuffer); #endif prog["col"] = drawType.col; prog["ViewProj"] = cam.getProjMatrix() * cam.getViewMatrix(); prog["View"] = cam.getViewMatrix(); prog["lightDir"] = glm::vec3(1.f, 2.f, -3.f); drawType.vao.bind(); }; /* * UNICOLORED QUAD */ const std::vector<GLubyte> quadIdx = { 3, 2, 0, 0, 1, 3 }; auto renderType = RenderTypeName::QUAD; #ifdef LEGACY_MODE gl::Shader quadVert(GL_VERTEX_SHADER); quadVert.addSourceFromString("#version 330 core\n"); quadVert.addSourceFromString("const int NUM_MATRICES = " + std::to_string(m_maxNumObjects) + ";\n"); quadVert.addSourceFromFile("shader/geometries/quad_legacy.vert"); if (!quadVert.compileSource()) { LOG_ERROR("could not compile vertex shader!"); } gl::Shader frag("shader/lighting/direct_lighting_legacy.frag"); m_renderTypes[renderType].prog.attachShader(quadVert); m_renderTypes[renderType].prog.attachShader(frag); m_renderTypes[renderType].ibo.bind(GL_ARRAY_BUFFER); m_renderTypes[renderType].ibo.createMutableStorage(static_cast<unsigned int>(quadIdx.size() * sizeof(GLubyte)), GL_STATIC_DRAW, quadIdx.data()); m_renderTypes[renderType].ibo.unbind(); #else gl::Shader quadVert("shader/geometries/quad.vert", "quad_instance_vert"); gl::Shader frag("shader/lighting/direct_lighting.frag"); m_renderTypes[renderType].prog.attachShader(quadVert); m_renderTypes[renderType].prog.attachShader(frag); m_renderTypes[renderType].ibo.createImmutableStorage(static_cast<unsigned int>(quadIdx.size() * sizeof(GLubyte)), 0, quadIdx.data()); #endif // drawCall m_renderTypes[renderType].drawCall = [](const GLsizei size){ glDrawElementsInstanced(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, 0, size); }; // preCall m_renderTypes[renderType].preCall = singleBufferPreCall; /* * MULTICOLORED QUAD */ renderType = RenderTypeName::MULTICOLOR_QUAD; #ifdef LEGACY_MODE gl::Shader multicolorQuadVert(GL_VERTEX_SHADER); multicolorQuadVert.addSourceFromString("#version 330 core\n"); multicolorQuadVert.addSourceFromString("const int NUM_MATRICES = " + std::to_string(m_maxNumObjects) + ";\n"); multicolorQuadVert.addSourceFromFile("shader/geometries/multicolor_quad_legacy.vert"); if (!multicolorQuadVert.compileSource()) { LOG_ERROR("could not compile vertex shader!"); } m_renderTypes[renderType].prog.attachShader(multicolorQuadVert); m_renderTypes[renderType].prog.attachShader(frag); m_renderTypes[renderType].ibo.bind(GL_ARRAY_BUFFER); m_renderTypes[renderType].ibo.createMutableStorage( static_cast<unsigned int>(quadIdx.size() * sizeof(GLubyte)), GL_STATIC_DRAW, quadIdx.data()); m_renderTypes[renderType].ibo.unbind(); #else gl::Shader multicolorQuadVert("shader/geometries/multicolor_quad.vert", "multicolor_quad_vert"); m_renderTypes[renderType].prog.attachShader(multicolorQuadVert); m_renderTypes[renderType].prog.attachShader(frag); m_renderTypes[renderType].ibo.createImmutableStorage(static_cast<unsigned int>(quadIdx.size() * sizeof(GLubyte)), 0, quadIdx.data()); #endif // drawCall m_renderTypes[renderType].drawCall = [](const GLsizei size){ glDrawElementsInstanced(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, 0, size); }; // preCall m_renderTypes[renderType].preCall = doubleBufferPreCall; /* * UNICOLORED CUBE */ const std::vector<GLushort> cubeIdx = { 19, 18, 16, 16, 17, 19, 7, 3, 1, 1, 5, 7, 22, 23, 21, 21, 20, 22, 2, 6, 4, 4, 0, 2, 9, 8, 12, 12, 13, 9, 14, 15, 11, 11, 10, 14 }; renderType = RenderTypeName::CUBE; #ifdef LEGACY_MODE gl::Shader cubeVert(GL_VERTEX_SHADER); cubeVert.addSourceFromString("#version 330 core\n"); cubeVert.addSourceFromString("const int NUM_MATRICES = " + std::to_string(m_maxNumObjects) + ";\n"); cubeVert.addSourceFromFile("shader/geometries/cube_legacy.vert"); if (!cubeVert.compileSource()) { LOG_ERROR("could not compile vertex shader!"); } m_renderTypes[renderType].prog.attachShader(cubeVert); m_renderTypes[renderType].prog.attachShader(frag); m_renderTypes[renderType].ibo.bind(GL_ARRAY_BUFFER); m_renderTypes[renderType].ibo.createMutableStorage( static_cast<unsigned int>(cubeIdx.size() * sizeof(GLushort)), GL_STATIC_DRAW, cubeIdx.data()); m_renderTypes[renderType].ibo.unbind(); #else gl::Shader cubeVert("shader/geometries/cube.vert", "cube_vert"); m_renderTypes[renderType].prog.attachShader(cubeVert); m_renderTypes[renderType].prog.attachShader(frag); m_renderTypes[renderType].ibo.createImmutableStorage(static_cast<unsigned int>(cubeIdx.size() * sizeof(GLushort)), 0, cubeIdx.data()); #endif // drawCall m_renderTypes[renderType].drawCall = [](const GLsizei size){ glDrawElementsInstanced(GL_TRIANGLES, 36, GL_UNSIGNED_SHORT, 0, size); }; // preCall m_renderTypes[renderType].preCall = singleBufferPreCall; /* * MULTICOLORED CUBE */ renderType = RenderTypeName::MULTICOLOR_CUBE; #ifdef LEGACY_MODE gl::Shader multicolorCubeVert(GL_VERTEX_SHADER); multicolorCubeVert.addSourceFromString("#version 330 core\n"); multicolorCubeVert.addSourceFromString("const int NUM_MATRICES = " + std::to_string(m_maxNumObjects) + ";\n"); multicolorCubeVert.addSourceFromFile("shader/geometries/multicolor_cube_legacy.vert"); if (!multicolorCubeVert.compileSource()) { LOG_ERROR("could not compile vertex shader!"); } m_renderTypes[renderType].prog.attachShader(multicolorCubeVert); m_renderTypes[renderType].prog.attachShader(frag); m_renderTypes[renderType].ibo.bind(GL_ARRAY_BUFFER); m_renderTypes[renderType].ibo.createMutableStorage( static_cast<unsigned int>(cubeIdx.size() * sizeof(GLushort)), GL_STATIC_DRAW, cubeIdx.data()); m_renderTypes[renderType].ibo.unbind(); #else gl::Shader multicolorCubeVert("shader/geometries/multicolor_cube.vert", "multicolor_cube_vert"); m_renderTypes[renderType].prog.attachShader(multicolorCubeVert); m_renderTypes[renderType].prog.attachShader(frag); m_renderTypes[renderType].ibo.createImmutableStorage(static_cast<unsigned int>(cubeIdx.size() * sizeof(GLushort)), 0, cubeIdx.data()); #endif // drawCall m_renderTypes[renderType].drawCall = [](const GLsizei size){ glDrawElementsInstanced(GL_TRIANGLES, 36, GL_UNSIGNED_SHORT, 0, size); }; // preCall m_renderTypes[renderType].preCall = doubleBufferPreCall; /* * FAN */ std::vector<GLushort> fanIdx; constexpr auto segments = 100u; fanIdx.reserve(segments + 2); for (auto i = 0u; i < segments + 2; ++i) { fanIdx.emplace_back(i); } renderType = RenderTypeName::FAN; #ifdef LEGACY_MODE gl::Shader fanVert(GL_VERTEX_SHADER); fanVert.addSourceFromString("#version 330 core\n"); fanVert.addSourceFromString("const int NUM_MATRICES = " + std::to_string(m_maxNumObjects) + ";\n"); fanVert.addSourceFromFile("shader/geometries/fan_legacy.vert"); if (!fanVert.compileSource()) { LOG_ERROR("could not compile vertex shader!"); } m_renderTypes[renderType].prog.attachShader(fanVert); m_renderTypes[renderType].prog.attachShader(frag); m_renderTypes[renderType].ibo.bind(GL_ARRAY_BUFFER); m_renderTypes[renderType].ibo.createMutableStorage( static_cast<unsigned int>(fanIdx.size() * sizeof(GLushort)), GL_STATIC_DRAW, fanIdx.data()); m_renderTypes[renderType].ibo.unbind(); #else gl::Shader fanVert("shader/geometries/fan.vert", "fan_vert"); m_renderTypes[renderType].prog.attachShader(fanVert); m_renderTypes[renderType].prog.attachShader(frag); m_renderTypes[renderType].ibo.createImmutableStorage(static_cast<unsigned int>(fanIdx.size() * sizeof(GLushort)), 0, fanIdx.data()); #endif // drawCall m_renderTypes[renderType].drawCall = [](const GLsizei size){ glDrawElementsInstanced(GL_TRIANGLE_FAN, segments + 2, GL_UNSIGNED_SHORT, 0, size); }; // preCall m_renderTypes[renderType].preCall = tripleBufferPreCall; /* * ANNULUS */ std::vector<GLushort> annulusIdx; annulusIdx.reserve(2 * segments + 2); for (auto i = 0u; i < 2 * segments + 2; ++i) { annulusIdx.emplace_back(i); } renderType = RenderTypeName::ANNULUS; #ifdef LEGACY_MODE gl::Shader annulusVert(GL_VERTEX_SHADER); annulusVert.addSourceFromString("#version 330 core\n"); annulusVert.addSourceFromString("const int NUM_MATRICES = " + std::to_string(m_maxNumObjects) + ";\n"); annulusVert.addSourceFromFile("shader/geometries/circlesegment_legacy.vert"); if (!annulusVert.compileSource()) { LOG_ERROR("could not compile vertex shader!"); } m_renderTypes[renderType].prog.attachShader(annulusVert); m_renderTypes[renderType].prog.attachShader(frag); m_renderTypes[renderType].ibo.bind(GL_ARRAY_BUFFER); m_renderTypes[renderType].ibo.createMutableStorage( static_cast<unsigned int>(annulusIdx.size() * sizeof(GLushort)), GL_STATIC_DRAW, annulusIdx.data()); m_renderTypes[renderType].ibo.unbind(); #else gl::Shader annulusVert("shader/geometries/circlesegment.vert", "circlesegment_vert"); m_renderTypes[renderType].prog.attachShader(annulusVert); m_renderTypes[renderType].prog.attachShader(frag); m_renderTypes[renderType].ibo.createImmutableStorage(static_cast<unsigned int>(annulusIdx.size() * sizeof(GLushort)), 0, annulusIdx.data()); #endif // drawCall m_renderTypes[renderType].drawCall = [](const GLsizei size){ glDrawElementsInstanced(GL_TRIANGLE_STRIP, 2 * segments + 2, GL_UNSIGNED_SHORT, 0, size); }; // preCall m_renderTypes[renderType].preCall = tripleBufferPreCall; /* * TRAPEZOID */ renderType = RenderTypeName::TRAPEZOID; #ifdef LEGACY_MODE gl::Shader trapezoidVert(GL_VERTEX_SHADER); trapezoidVert.addSourceFromString("#version 330 core\n"); trapezoidVert.addSourceFromString("const int NUM_MATRICES = " + std::to_string(m_maxNumObjects) + ";\n"); trapezoidVert.addSourceFromFile("shader/geometries/trapezoid_legacy.vert"); if (!trapezoidVert.compileSource()) { LOG_ERROR("could not compile vertex shader!"); } m_renderTypes[renderType].prog.attachShader(trapezoidVert); m_renderTypes[renderType].prog.attachShader(frag); m_renderTypes[renderType].ibo.bind(GL_ARRAY_BUFFER); m_renderTypes[renderType].ibo.createMutableStorage( static_cast<unsigned int>(quadIdx.size() * sizeof(GLubyte)), GL_STATIC_DRAW, quadIdx.data()); m_renderTypes[renderType].ibo.unbind(); #else gl::Shader trapezoidVert("shader/geometries/trapezoid.vert", "trapezoid_vert"); m_renderTypes[renderType].prog.attachShader(trapezoidVert); m_renderTypes[renderType].prog.attachShader(frag); m_renderTypes[renderType].ibo.createImmutableStorage(static_cast<unsigned int>(quadIdx.size() * sizeof(GLubyte)), 0, quadIdx.data()); #endif // drawCall m_renderTypes[renderType].drawCall = [](const GLsizei size){ glDrawElementsInstanced(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, 0, size); }; // preCall m_renderTypes[renderType].preCall = tripleBufferPreCall; }
void ofBufferObject::unbindBase(GLenum target,GLuint index) const{ glBindBufferBase(target,index,0); if(data){ data->isBound = false; } }
void GLSLShader::renderTF() { float positionData[] = { -0.8f, -0.8f, 0.0f, 0.8f, -0.8f, 0.0f, 0.0f, 0.8f, 0.0f }; // GLuint buffer; // glGenBuffers(1, &buffer); // glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, buffer); // GLuint id; // int bufferSize = 9 * sizeof(float); // glGenTransformFeedbacks(1, &id); // glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, bufferSize, NULL, GL_DYNAMIC_COPY); // glBindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buffer, 0, bufferSize); // const char* vars[] = { "in_Vertex_Position" }; // glTransformFeedbackVaryings(programHandle, 1, vars, GL_INTERLEAVED_ATTRIBS ); // std::vector<Eigen::Vector4f> vdata; // vdata.push_back(Eigen::Vector4f(-1, -1, 0, 1)); // vdata.push_back(Eigen::Vector4f(1, -1, 0, 1)); // vdata.push_back(Eigen::Vector4f(0, 1, 0, 1)); // createVertexAttribute(0, "in_Vertex_Position", vdata); // link(); // glBeginTransformFeedback( GL_TRIANGLES ); // glBindVertexArray(vaoHandle); // glDrawArrays(GL_TRIANGLES, 0, 3); // std::vector<Eigen::Vector4f> feedbackData; // glEndTransformFeedback(); // glFlush(); // // glGetBufferSubData( GL_TRANSFORM_FEEDBACK_BUFFER, 0, bufferSize, buffer ); // glInvalidateBufferData( buffer ); // glDeleteTransformFeedbacks( 1, &id ); //std::cout << "Feedback data:" << std::endl << std::endl << feedbackData << std::endl; //UPDATE // glEnable(GL_RASTERIZER_DISCARD); // glBindBuffer(GL_ARRAY_BUFFER, m_particleBuffer[m_currVB]); // glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, m_transformFeedback[m_currTFB]); // glEnableVertexAttribArray(0); // glVertexAttribPointer(1,3,GL_FLOAT,GL_FALSE, size ,(const GLvoid*)4); // position // glBeginTransformFeedback(GL_POINTS); // if (m_isFirst) { // glDrawArrays(GL_POINTS, 0, 1); // m_isFirst = false; // } // else { // glDrawTransformFeedback(GL_POINTS, m_transformFeedback[m_currVB]); // } // glEndTransformFeedback(); // glDisableVertexAttribArray(0); // //RENDER // glDisable(GL_RASTERIZER_DISCARD); // glBindBuffer(GL_ARRAY_BUFFER, m_particleBuffer[m_currTFB]); // glEnableVertexAttribArray(0); // glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, size, (const GLvoid*)4); // position // glDrawTransformFeedback(GL_POINTS, m_transformFeedback[m_currTFB]); // glDisableVertexAttribArray(0); // m_currVB = m_currTFB; // m_currTFB = (m_currTFB + 1) & 0x1; // glBindBuffer(GL_ARRAY_BUFFER, m_transformFeedback[0]); //// glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 0, 0); // glEnableVertexAttribArray(1); // glDisableVertexAttribArray(0); static float c = 0.0; glDisableVertexAttribArray(1); // glBindBuffer(GL_ARRAY_BUFFER, 0); glEnable(GL_RASTERIZER_DISCARD); glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_transformFeedback[0]); GLuint location = glGetUniformLocation(programHandle, "UseTF"); glUniform1f(location,c); glBindVertexArray(vaoHandle); glBeginTransformFeedback(GL_POINTS); glDrawArrays(GL_POINTS, 0, 3); glEndTransformFeedback(); glDisable(GL_RASTERIZER_DISCARD); glEnableVertexAttribArray(1); glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0); location = glGetUniformLocation(programHandle, "UseTF"); glUniform1f(location, 0.0); glDrawArrays(GL_TRIANGLES, 0, 3); c += 0.01; if (c > 1.0) c = 0.0; }
//***************************************************************************** // Update //***************************************************************************** void ParticleSystem::Update() { float fDeltaTime = 0.0f; int hProg = GetShaderProgram(PARTICLE_UPDATE_PROGRAM); m_timer.Stop(); fDeltaTime = m_timer.Time(); glUseProgram(hProg); // Toggle the update buffer index m_nUpdateBuffer = !m_nUpdateBuffer; // Bind the correct buffers glBindBuffer(GL_ARRAY_BUFFER, m_arVBOs[m_nUpdateBuffer]); glBindBuffer ( GL_TRANSFORM_FEEDBACK_BUFFER, m_arVBOs[!m_nUpdateBuffer]); glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_arVBOs[!m_nUpdateBuffer]); // Assign vertex attributes glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, PARTICLE_DATA_SIZE, 0); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, PARTICLE_DATA_SIZE, (void*) 12); glVertexAttribPointer(2, 4, GL_FLOAT, GL_FALSE, PARTICLE_DATA_SIZE, (void*) 24); glVertexAttribPointer(3, 1, GL_FLOAT, GL_FALSE, PARTICLE_DATA_SIZE, (void*) 40); glVertexAttribPointer(4, 1, GL_FLOAT, GL_FALSE, PARTICLE_DATA_SIZE, (void*) 44); glEnableVertexAttribArray(0); glEnableVertexAttribArray(1); glEnableVertexAttribArray(2); glEnableVertexAttribArray(3); glEnableVertexAttribArray(4); // Set Uniforms glUniform1f(s_hMinLifetime, m_fMinLifetime); glUniform1f(s_hMaxLifetime, m_fMaxLifetime); glUniform4fv(s_hMinColor, 1, m_arMinColor); glUniform4fv(s_hMaxColor, 1, m_arMaxColor); glUniform3fv(s_hMinVelocity, 1, m_arMinVelocity); glUniform3fv(s_hMaxVelocity, 1, m_arMaxVelocity); glUniform1f(s_hMinSize, m_fMinSize); glUniform1f(s_hMaxSize, m_fMaxSize); glUniform3fv(s_hGravity, 1, m_arGravity); glUniform1i(s_hSeed, rand()); glUniform1f(s_hDeltaTime, fDeltaTime); glUniform1i(s_hGenerate, m_nGenerate); glUniform3fv(s_hOrigin, 1, m_arOrigin); glUniform3fv(s_hSpawnVariance, 1, m_arSpawnVariance); // Since this shader is only being used for transform feedback, // we don't want anything to be drawn to the framebuffer. // To disable drawing, enable GL_RASTERIZE_DISCARD glEnable(GL_RASTERIZER_DISCARD); // Update particles with transform feedback glBeginTransformFeedback(GL_POINTS); glDrawArrays(GL_POINTS, 0, m_nParticleCount); glEndTransformFeedback(); // Since the rendering relies on the particle update being finished, // and the gpu does its processing asynchronously, we must wait until // the gpu processing is done by using a sync object. glFinish should // work too, but might not be as effectient. m_pSync = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0); glDisable(GL_RASTERIZER_DISCARD); glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, 0); glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0); glBindBuffer(GL_ARRAY_BUFFER, 0); m_timer.Start(); }