void Mesh::Init() { m_vbo = Renderer::instance->GenerateBufferID(); GL_CHECK_ERROR(); Renderer::instance->BindAndBufferVBOData(m_vbo, m_verts.data(), m_verts.size()); GL_CHECK_ERROR(); m_ibo = Renderer::instance->RenderBufferCreate(m_indices.data(), m_indices.size(), sizeof(unsigned int), GL_STATIC_DRAW); GL_CHECK_ERROR(); }
void SimpleGLScene::initShaders() { shader.link("test/shaders/helix.vert", "test/shaders/helix.frag"); GL_CHECK_ERROR(); blur.link("test/shaders/postprocess.vert", "test/shaders/kawase.frag"); GL_CHECK_ERROR(); postprocess.link("test/shaders/postprocess.vert", "test/shaders/gamma.frag"); GL_CHECK_ERROR(); framebuffer.create(); GL_CHECK_ERROR(); }
std::string shaderInfoLog(GLuint shader) { GLint length; glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &length); GL_CHECK_ERROR(); if (length == 0) return ""; std::unique_ptr<char[]> log(new char[length + 1]); glGetShaderInfoLog(shader, length, 0, reinterpret_cast<GLchar*>(log.get())); GL_CHECK_ERROR(); return log.get(); }
std::string programInfoLog(GLuint program) { GLint length; glGetProgramiv(program, GL_INFO_LOG_LENGTH, &length); GL_CHECK_ERROR(); if (length == 0) return ""; std::unique_ptr<char[]> log(new char[length + 1]); glGetProgramInfoLog(program, length, 0, reinterpret_cast<char*>(log.get())); GL_CHECK_ERROR(); return log.get(); }
Buffer::Buffer() : mPADI(nullptr) { glGenBuffers(1, &mVBO); GL_CHECK_ERROR(); }
void Program::link() { glLinkProgram(program); GL_CHECK_ERROR(); if (programLinkStatus(program) == false) throw error("error linking program: " + programInfoLog(program)); }
bool programValidateStatus(GLuint program) { GLint b; glGetProgramiv(program, GL_VALIDATE_STATUS, &b); GL_CHECK_ERROR(); return b == GL_TRUE; }
bool programLinkStatus(GLuint program) { GLint b; glGetProgramiv(program, GL_LINK_STATUS, &b); GL_CHECK_ERROR(); return b == GL_TRUE; }
//----------------------------------------------------------------------------------- void TheGame::RenderCoolStuff() const { Matrix4x4 view = Renderer::instance->GetView(); Matrix4x4 proj = Renderer::instance->GetProjection(); Matrix4x4 translation; Matrix4x4 rotation; Matrix4x4 model; m_currentMaterial->m_shaderProgram->SetVec3Uniform("gCameraPosition", m_camera->m_position); Matrix4x4::MatrixMakeTranslation(&translation, Vector3(0.0f, sin((float)GetCurrentTimeSeconds()) * spinFactor, 3.0f)); Matrix4x4::MatrixMakeRotationAroundY(&rotation, (float)GetCurrentTimeSeconds() * spinFactor); Matrix4x4::MatrixMultiply(&model, &rotation, &translation); if ((g_loadedMotion || g_loadedMotions) && g_loadedSkeleton) { int NUM_BONES = 200; for (unsigned int i = 0; i < g_loadedSkeleton->m_jointArray.size(); ++i) { Matrix4x4 world = g_loadedSkeleton->GetWorldBoneToModelOutOfLocal(i); //g_loadedSkeleton->m_jointArray.at(i).m_boneToModelSpace; Matrix4x4 inverseWorld = g_loadedSkeleton->m_jointArray.at(i).m_modelToBoneSpace; //g_loadedSkeleton->GetWorldModelToBoneOutOfLocal(i); Matrix4x4 mat = Matrix4x4::IDENTITY; Matrix4x4::MatrixMultiply(&mat, &inverseWorld, &world); m_testMaterial->SetMatrix4x4Uniform(Stringf("gBoneMatrices[%i]", i).c_str(), mat, NUM_BONES); } } m_currentMaterial->SetMatrices(model, view, proj); GL_CHECK_ERROR(); loadedMesh->m_material = m_currentMaterial; loadedMesh->Render(); }
std::ostream& writeTexture(std::ostream& file, const GL::Texture2D& tex) { glBindTexture(GL_TEXTURE_2D, tex); GLint levels = 1; GLint format; glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_INTERNAL_FORMAT, &format); GLint width; glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &width); GLint height; glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &height); if (format == GL_RGBA16F || format == GL_RGBA32F) { std::unique_ptr<float[]> buffer(new float[width * height * 3]); glGetTexImage(GL_TEXTURE_2D, 0, GL_RGB, GL_FLOAT, buffer.get()); writeImageRGB(file, width, height, buffer.get()); } else if (format == GL_R16F || GL_R32F) { std::unique_ptr<float[]> buffer(new float[width * height]); glGetTexImage(GL_TEXTURE_2D, 0, GL_RED, GL_FLOAT, buffer.get()); writeImageR(file, width, height, buffer.get()); } GL_CHECK_ERROR(); return file; }
bool shaderCompileStatus(GLuint shader) { GLint b; glGetShaderiv(shader, GL_COMPILE_STATUS, &b); GL_CHECK_ERROR(); return b == GL_TRUE; }
//----------------------------------------------------------------------------------- void Renderer::DrawVertexArray(const Vertex_PCT* vertexes, int numVertexes, DrawMode drawMode /*= DrawMode::QUADS*/) { if (numVertexes == 0) { return; } MeshBuilder builder; builder.Begin(); for (int i = 0; i < numVertexes; ++i) { builder.SetColor(vertexes[i].color); builder.SetUV(vertexes[i].texCoords); builder.SetTBN(Vector3::ZERO, Vector3::ZERO, Vector3::ZERO); builder.AddVertex(vertexes[i].pos); builder.AddIndex(i); } builder.End(); Mesh* mesh = new Mesh(); builder.CopyToMesh(mesh, &Vertex_PCUTB::Copy, sizeof(Vertex_PCUTB), &Vertex_PCUTB::BindMeshToVAO); mesh->m_drawMode = drawMode; MeshRenderer* thingToRender = new MeshRenderer(mesh, m_defaultMaterial); m_defaultMaterial->SetMatrices(Matrix4x4::IDENTITY, m_viewStack.GetTop(), m_projStack.GetTop()); GL_CHECK_ERROR(); thingToRender->Render(); delete mesh; }
//----------------------------------------------------------------------------------- //Is really only used for debug purposes void Renderer::FrameBufferCopyToBack(Framebuffer* fbo) { if (fbo == nullptr) { return; } GLuint fboHandle = fbo->m_fboHandle; glBindFramebuffer(GL_READ_FRAMEBUFFER, fboHandle); glBindFramebuffer(GL_DRAW_FRAMEBUFFER, NULL); uint32_t readWidth = fbo->m_pixelWidth; uint32_t readHeight = fbo->m_pixelHeight; #pragma TODO("Make aspect not hard-coded!!!") uint32_t drawWidth = 1600; uint32_t drawHeight = 900; glBlitFramebuffer(0, 0, //Lower left corner pixel readWidth, readHeight, //Top right corner pixel 0, 0, //lower left pixel of the read buffer drawWidth, drawHeight, //top right pixel of read buffer GL_COLOR_BUFFER_BIT, GL_NEAREST); GL_CHECK_ERROR(); }
bool Shader::LinkProgram() { if (this->program == 0) { LogError("Trying to link uninitialized program - skipping"); return false; } glLinkProgram(this->program); GLint linked; glGetProgramiv(this->program, GL_LINK_STATUS, &linked); if (!linked) { GLint infoLength; glGetProgramiv(this->program, GL_INFO_LOG_LENGTH, &infoLength); if (infoLength > 0) { char *infoBuf = new char[infoLength]; glGetProgramInfoLog(this->program, infoLength, NULL, infoBuf); LogError("Shader link info: %s", infoBuf); delete[] infoBuf; } return false; } GL_CHECK_ERROR(); return true; }
Shader::~Shader() { if (this->vertexShader) { if (this->program) { glDetachShader(this->program, this->vertexShader); } glDeleteShader(this->vertexShader); this->vertexShader = 0; } if (this->fragmentShader) { if (this->program) { glDetachShader(this->program, this->fragmentShader); } glDeleteShader(this->fragmentShader); this->fragmentShader = 0; } if (this->program) { LogSpam("Shader program destroyed: %d", this->program); glDeleteProgram(this->program); this->program = 0; } GL_CHECK_ERROR(); }
bool Shader::ValidateProgram() { if (this->program == 0) { LogError("Trying to validate uninitialized program - skipping."); return false; } glValidateProgram(this->program); GLint valid; glGetProgramiv(this->program, GL_VALIDATE_STATUS, &valid); if (!valid) { GLint logLength; glGetProgramiv(this->program, GL_INFO_LOG_LENGTH, &logLength); if (logLength > 0) { char *infoBuf = new char[logLength]; glGetProgramInfoLog(this->program, logLength, NULL, infoBuf); LogError("Shader validation info: %s", infoBuf); delete[] infoBuf; } return false; } GL_CHECK_ERROR(); return true; }
//----------------------------------------------------------------------------------- void Renderer::DrawText2D(const Vector2& position, const std::string& asciiText, float scale, const RGBA& tint /*= RGBA::WHITE*/, bool drawShadow /*= false*/, const BitmapFont* font /*= nullptr*/, const Vector2& right /*= Vector3::UNIT_X*/, const Vector2& up /*= Vector3::UNIT_Z*/) { //To be used when I expand this method to 3D text UNUSED(up); UNUSED(right); if (asciiText.empty()) { return; } if (font == nullptr) { font = m_defaultFont; } int stringLength = asciiText.size(); Vector2 cursorPosition = position + (Vector2::UNIT_Y * (float)font->m_maxHeight * scale); const Glyph* previousGlyph = nullptr; MeshBuilder builder; builder.Begin(); for (int i = 0; i < stringLength; i++) { unsigned char currentCharacter = asciiText[i]; const Glyph* glyph = font->GetGlyph(currentCharacter); float glyphWidth = static_cast<float>(glyph->width) * scale; float glyphHeight = static_cast<float>(glyph->height) * scale; if (previousGlyph) { const Vector2 kerning = font->GetKerning(*previousGlyph, *glyph); cursorPosition += (kerning * scale); } Vector2 offset = Vector2(glyph->xOffset * scale, -glyph->yOffset * scale); Vector2 topRight = cursorPosition + offset + Vector2(glyphWidth, 0.0f); Vector2 bottomLeft = cursorPosition + offset - Vector2(0.0f, glyphHeight); AABB2 quadBounds = AABB2(bottomLeft, topRight); AABB2 glyphBounds = font->GetTexCoordsForGlyph(*glyph); if (drawShadow) { float shadowWidthOffset = glyphWidth / 10.0f; float shadowHeightOffset = glyphHeight / -10.0f; Vector2 shadowOffset = Vector2(shadowWidthOffset, shadowHeightOffset); AABB2 shadowBounds = AABB2(bottomLeft + shadowOffset, topRight + shadowOffset); builder.AddTexturedAABB(shadowBounds, glyphBounds.mins, glyphBounds.maxs, RGBA::BLACK); } builder.AddTexturedAABB(quadBounds, glyphBounds.mins, glyphBounds.maxs, tint); cursorPosition.x += glyph->xAdvance * scale; previousGlyph = glyph; } builder.End(); Mesh* mesh = new Mesh(); builder.CopyToMesh(mesh, &Vertex_PCUTB::Copy, sizeof(Vertex_PCUTB), &Vertex_PCUTB::BindMeshToVAO); mesh->m_drawMode = DrawMode::TRIANGLES; MeshRenderer* thingToRender = new MeshRenderer(mesh, font->GetMaterial()); m_defaultMaterial->SetMatrices(Matrix4x4::IDENTITY, m_viewStack.GetTop(), m_projStack.GetTop()); GL_CHECK_ERROR(); thingToRender->Render(); delete mesh; delete thingToRender; }
void FullscreenQuad::draw() const { glBindVertexArray(vao); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); GL_CHECK_ERROR(); }
Skydome::Skydome() : vs(Framework::preprocessShaderSource(::vs, "skydome.vs").c_str()), fs(Framework::preprocessShaderSource(::fs, "skydome.fs").c_str()) { static const float3 box_vertices[] = { float3(-1.0f,-1.0f,-1.0f), float3(-1.0f,-1.0f, 1.0f), float3( 1.0f,-1.0f, 1.0f), float3( 1.0f,-1.0f,-1.0f), float3(-1.0f, 1.0f,-1.0f), float3(-1.0f, 1.0f, 1.0f), float3( 1.0f, 1.0f, 1.0f), float3( 1.0f, 1.0f,-1.0f) }; static const std::uint16_t box_indices[] = { 0, 4, 1, 4, 5, 1, 1, 5, 2, 5, 6, 2, 2, 6, 3, 6, 7, 3, 3, 7, 0, 7, 4, 0, 0, 1, 3, 1, 2, 3, 7, 6, 4, 4, 6, 5 }; prog.attachShader(vs); prog.attachShader(fs); prog.link(); glBindVertexArray(vao); glBindBuffer(GL_ARRAY_BUFFER, vertices); glBufferData(GL_ARRAY_BUFFER, sizeof(box_vertices), box_vertices, GL_STATIC_DRAW); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indices); glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(box_indices), box_indices, GL_STATIC_DRAW); glBindVertexArray(0); glSamplerParameteri(envmap_sampler, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glSamplerParameteri(envmap_sampler, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glSamplerParameteri(envmap_sampler, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT); glSamplerParameteri(envmap_sampler, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT); glUseProgram(prog); GLuint em = glGetUniformLocation(prog, "envmap"); glUniform1i(em, 0); GLuint camera_uniform_block = glGetUniformBlockIndex(prog, "CameraParameters"); glUniformBlockBinding(prog, camera_uniform_block, 0); GL_CHECK_ERROR(); }
/*! void Matrices(Shaderobject shader, String uniform_variable)\n Function to pass 4x4 matrices as uniform array to a vertexshader */ void Item_armature::Matrices(QObject* _shader, QString var){ if (glwrapper_shader* shader = dynamic_cast<glwrapper_shader*>(_shader)){ float* space = new float[max_bone_id * 16 + 16]; for (QTreeWidgetItemIterator it(this);*it;it++){ if (Item_bone* bone = dynamic_cast<Item_bone*>(*it)){ float xx = bone->quat[0] * bone->quat[0]; float xy = bone->quat[0] * bone->quat[1]; float xz = bone->quat[0] * bone->quat[2]; float xw = bone->quat[0] * bone->quat[3]; float yy = bone->quat[1] * bone->quat[1]; float yz = bone->quat[1] * bone->quat[2]; float yw = bone->quat[1] * bone->quat[3]; float zz = bone->quat[2] * bone->quat[2]; float zw = bone->quat[2] * bone->quat[3]; //Matrix in OpenGL order!!! int ofs = bone->id * 16; space[ofs + 0] = 1.0 - 2.0 * (yy + zz); space[ofs + 1] = 2.0 * (xy + zw); space[ofs + 2] = 2.0 * (xz - yw); space[ofs + 3] = 0.0; space[ofs + 4] = 2.0 * (xy - zw); space[ofs + 5] = 1.0 - 2.0 * (xx + zz); space[ofs + 6] = 2.0 * (yz + xw); space[ofs + 7] = 0.0; space[ofs + 8] = 2.0 * (xz + yw); space[ofs + 9] = 2.0 * (yz - xw); space[ofs + 10] = 1.0 - 2.0 * (xx + yy); space[ofs + 11] = 0; float x = bone->initJoint[0]; float y = bone->initJoint[1]; float z = bone->initJoint[2]; space[ofs + 12] = bone->joint[0] - (space[ofs+0] * x + space[ofs+4] * y + space[ofs+8] * z); space[ofs + 13] = bone->joint[1] - (space[ofs+1] * x + space[ofs+5] * y + space[ofs+9] * z); space[ofs + 14] = bone->joint[2] - (space[ofs+2] * x + space[ofs+6] * y + space[ofs+10]* z); space[ofs + 15] = 1.0; } } shader->Bind(); int loc = glGetUniformLocationARB(shader->getShaderHandle(),var.toLatin1().constData()); glUniformMatrix4fvARB(loc, max_bone_id + 1,GL_FALSE, space); GL_CHECK_ERROR(); delete[] space; } else{ qDebug() << "Item_armature::Joints parameter is not a shader object"; } }
void SimpleGLScene::initBuffers() { int strip_x = 2, strip_y = 512; std::vector<float> stripData(2 * strip_x * strip_y), quadData(2 * 2 * 2), lineData = { 0, 1, 0, 2, 0, 3 }, gridData(64 * 64 * 2); initMeshArray(stripData, strip_x, strip_y); initMeshArray(quadData, 2, 2); initMeshArray(gridData, 64, 64); stripBuffer.allocate(stripData, 2); quadBuffer.allocate(quadData, 2); vao.create(); GL_CHECK_ERROR(); }
FullscreenQuad::FullscreenQuad() : vs(Framework::preprocessShaderSource(::vs, "fullscreen_quad.vs").c_str()) { glBindVertexArray(vao); glBindBuffer(GL_ARRAY_BUFFER, vb); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 8, 0); glBindVertexArray(0); GL_CHECK_ERROR(); }
void CopyShader::draw(GLuint src) const { glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, src); glBindSampler(0, sampler); glUseProgram(prog); quad.draw(); GL_CHECK_ERROR(); }
void Skydome::draw(GLuint envmap) const { glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, envmap); glBindSampler(0, envmap_sampler); glUseProgram(prog); glBindVertexArray(vao); glDrawElements(GL_TRIANGLES, 36, GL_UNSIGNED_SHORT, 0); GL_CHECK_ERROR(); }
bool SpriteShader::PrepareToRender() { glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, this->glTexture); glUseProgram(this->program); glUniformMatrix4fv(this->uniforms[DEFAULT_SHADER_UNIFORM_MVP], 1, GL_FALSE, this->mvpMatrix.data()); glUniform1i(this->uniforms[DEFAULT_SHADER_UNIFORM_TEXTURE], 0); GL_CHECK_ERROR(); return true; }
//----------------------------------------------------------------------------------- void Renderer::DrawText2D ( const Vector2& startBottomLeft , const std::string& asciiText , float cellWidth , float cellHeight , const RGBA& tint /*= RGBA::WHITE*/ , bool drawShadow /*= false*/ , const BitmapFont* font /*= nullptr*/) { const float SHADOW_WIDTH_OFFSET = cellWidth / 10.0f; const float SHADOW_HEIGHT_OFFSET = cellHeight / -10.0f; const Vector2 SHADOW_OFFSET = Vector2(SHADOW_WIDTH_OFFSET, SHADOW_HEIGHT_OFFSET); if (asciiText.empty()) { return; } MeshBuilder builder; builder.Begin(); if (font == nullptr) { font = m_defaultFont; } int stringLength = asciiText.size(); Vector2 currentPosition = startBottomLeft; for (int i = 0; i < stringLength; i++) { unsigned char currentCharacter = asciiText[i]; Vector2 topRight = currentPosition + Vector2(cellWidth, cellHeight); AABB2 quadBounds = AABB2(currentPosition, topRight); AABB2 glyphBounds = font->GetTexCoordsForGlyph(currentCharacter); if (drawShadow) { AABB2 shadowBounds = AABB2(currentPosition + SHADOW_OFFSET, topRight + SHADOW_OFFSET); builder.AddTexturedAABB(shadowBounds, glyphBounds.mins, glyphBounds.maxs, RGBA::BLACK); } builder.AddTexturedAABB(quadBounds, glyphBounds.mins, glyphBounds.maxs, tint); currentPosition.x += cellWidth; } builder.End(); Mesh* mesh = new Mesh(); builder.CopyToMesh(mesh, &Vertex_PCUTB::Copy, sizeof(Vertex_PCUTB), &Vertex_PCUTB::BindMeshToVAO); mesh->m_drawMode = DrawMode::TRIANGLES; MeshRenderer* thingToRender = new MeshRenderer(mesh, font->GetMaterial()); m_defaultMaterial->SetMatrices(Matrix4x4::IDENTITY, m_viewStack.GetTop(), m_projStack.GetTop()); GL_CHECK_ERROR(); thingToRender->Render(); delete mesh; delete thingToRender; }
//----------------------------------------------------------------------------------- void Renderer::DrawVertexArray(const Vertex_PCT* vertexes, int numVertexes, DrawMode drawMode /*= QUADS*/, Texture* texture /*= nullptr*/) { // if (!texture) // { // texture = m_defaultTexture; // } // BindTexture(*texture); // glEnableClientState(GL_VERTEX_ARRAY); // glEnableClientState(GL_COLOR_ARRAY); // glEnableClientState(GL_TEXTURE_COORD_ARRAY); // // glVertexPointer(3, GL_FLOAT, sizeof(Vertex_PCT), &vertexes[0].pos); // glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(Vertex_PCT), &vertexes[0].color); // glTexCoordPointer(2, GL_FLOAT, sizeof(Vertex_PCT), &vertexes[0].texCoords); // // glDrawArrays(GetDrawMode(drawMode), 0, numVertexes); // // glDisableClientState(GL_VERTEX_ARRAY); // glDisableClientState(GL_COLOR_ARRAY); // glDisableClientState(GL_TEXTURE_COORD_ARRAY); // UnbindTexture(); if (numVertexes == 0) { return; } MeshBuilder builder; builder.Begin(); for (int i = 0; i < numVertexes; ++i) { builder.SetColor(vertexes[i].color); builder.SetUV(vertexes[i].texCoords); builder.SetTBN(Vector3::ZERO, Vector3::ZERO, Vector3::ZERO); builder.AddVertex(vertexes[i].pos); builder.AddIndex(i); } builder.End(); Mesh* mesh = new Mesh(); builder.CopyToMesh(mesh, &Vertex_PCUTB::Copy); mesh->m_drawMode = drawMode; MeshRenderer thingToRender = MeshRenderer(mesh, m_defaultMaterial); m_defaultMaterial->SetMatrices(Matrix4x4::IDENTITY, m_viewStack.GetTop(), m_projStack.GetTop()); GL_CHECK_ERROR(); thingToRender.Render(); delete mesh; }
void SimpleGLScene::resize(int width, int height) { sceneWidth = width, sceneHeight = height; glViewport(0, 0, width, height); projection = mat_perspective(60, width / (double) height, 1.0, 200.0); renderedColorTexture.allocate(width, height); renderedColorTexture.setParameter(GL_TEXTURE_MIN_FILTER, GL_LINEAR); renderedColorTexture.setParameter(GL_TEXTURE_MAG_FILTER, GL_LINEAR); renderedColorTexture.setParameter(GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); renderedColorTexture.setParameter(GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); renderedDepthTexture.allocate(width, height); renderedDepthTexture.setParameter(GL_TEXTURE_MIN_FILTER, GL_LINEAR); renderedDepthTexture.setParameter(GL_TEXTURE_MAG_FILTER, GL_LINEAR); renderedDepthTexture.setParameter(GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); renderedDepthTexture.setParameter(GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); framebuffer.attach( GL_COLOR_ATTACHMENT0, renderedColorTexture, GL_DEPTH_ATTACHMENT, renderedDepthTexture); GL_CHECK_ERROR(); }
CopyShader::CopyShader(FullscreenQuad& quad) : quad(quad), fs(Framework::preprocessShaderSource(::fs, "copy.fs").c_str()) { quad.attach(prog); prog.attachShader(fs); prog.link(); glSamplerParameteri(sampler, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glSamplerParameteri(sampler, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glSamplerParameteri(sampler, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT); glSamplerParameteri(sampler, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT); glUseProgram(prog); GLuint tex = glGetUniformLocation(prog, "src"); glUniform1i(tex, 0); GL_CHECK_ERROR(); }
void Buffer::resetBufferData(PackedArrayDataInterface* ArrayData, GLenum BufferType, GLenum Usage) { mPADI = ArrayData; /*@ Unsupported glNamedBufferData( mVBO, ArrayData->getByteSize(), ArrayData->getData(), Usage ); */ glBindBuffer(BufferType, mVBO); glBufferData( BufferType, ArrayData->getByteSize(), ArrayData->getData(), Usage); glBindBuffer(BufferType, 0); GL_CHECK_ERROR(); }