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();
}
