EpicSparrow/SparrowRenderer
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

glAssert is now integrated to glew

Browse Source
This commit is contained in:
Anselme 2016-03-30 11:09:48 +02:00
parent d07541e8ea
commit cd3a1d12c0
18 changed files with 2645 additions and 2650 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
src/buffer.cpp
View File

@ -1,5 +1,5 @@
#include "buffer.h"
#include "glassert.h"
#include <cstdio>
#define BUFFER_OFFSET(i) ((char *)NULL + (i))
@ -31,8 +31,8 @@ Buffer<T>::BufferEditor::BufferEditor(Buffer *b)
if(b->isDynamic())
{
GLenum m_typeEnum = getGLEnum(b->getType());
glAssert(glBindBuffer(m_typeEnum, b->getId()));
glAssert(ptr = (T*)glMapBuffer(m_typeEnum, GL_WRITE_ONLY));
glBindBuffer(m_typeEnum, b->getId());
ptr = (T*)glMapBuffer(m_typeEnum, GL_WRITE_ONLY);
}
else
{
@ -45,7 +45,7 @@ template <typename T>
Buffer<T>::BufferEditor::~BufferEditor()
{
glUnmapBuffer(m_typeEnum);
glAssert(glBindBuffer(m_typeEnum, 0));
glBindBuffer(m_typeEnum, 0);
}
template <typename T>
@ -56,10 +56,10 @@ Buffer<T>::Buffer(const std::vector<T> &data, BufferType type, bool isDynamic) :
// TODO : allow stream draw
GLenum draw_type = isDynamic ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW;
GLenum typeEnum = getGLEnum(m_type);
glAssert(glGenBuffers(1, m_id));
glAssert(glBindBuffer(typeEnum, m_id));
glAssert(glBufferData(typeEnum, data.size() * sizeof(T), data.data(), draw_type));
glAssert(glBindBuffer(typeEnum, 0));
glGenBuffers(1, m_id);
glBindBuffer(typeEnum, m_id);
glBufferData(typeEnum, data.size() * sizeof(T), data.data(), draw_type);
glBindBuffer(typeEnum, 0);
}
template <typename T>
@ -67,12 +67,12 @@ void Buffer<T>::setVertexAttrib(int location, int nbComponents, int offset, int
{
if(m_type == VBO)
{
glAssert(glBindBuffer(GL_ARRAY_BUFFER, m_id));
glAssert(glEnableVertexAttribArray(location));
glBindBuffer(GL_ARRAY_BUFFER, m_id);
glEnableVertexAttribArray(location);
if(instanceDivisor)
glAssert(glVertexAttribDivisor(location, instanceDivisor));
glAssert(glVertexAttribPointer(location, nbComponents, GL_FLOAT, GL_FALSE, sizeof(T), BUFFER_OFFSET(offset)));
glAssert(glBindBuffer(GL_ARRAY_BUFFER, 0));
glVertexAttribDivisor(location, instanceDivisor);
glVertexAttribPointer(location, nbComponents, GL_FLOAT, GL_FALSE, sizeof(T), BUFFER_OFFSET(offset));
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
else
fprintf(stderr, "WTF\n");
@ -81,5 +81,5 @@ void Buffer<T>::setVertexAttrib(int location, int nbComponents, int offset, int
template <typename T>
Buffer<T>::~Buffer()
{
glAssert(glDeleteBuffers(1, m_id));
glDeleteBuffers(1, m_id);
}

34
src/crappymodule.cpp
View File

@ -4,35 +4,35 @@
#include "mesh.h"
#include "sparrowrenderer.h"
#include "scene.h"
#include "glassert.h"
#include "material.h"
#include <glm/ext.hpp>
void CrappyModule::renderGL(Camera* myCamera, Scene* scene)
{
glAssert(glEnable(GL_LIGHTING));
glAssert(glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT));
glEnable(GL_LIGHTING);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glAssert(glEnable(GL_LIGHT0));
glAssert(glLightfv(GL_LIGHT0, GL_AMBIENT, glm::value_ptr(glm::vec4(glm::vec3(0.1f), 1))));
glAssert(glLightfv(GL_LIGHT0, GL_POSITION, glm::value_ptr(glm::vec4(0))));
glAssert(glLightfv(GL_LIGHT0, GL_DIFFUSE, glm::value_ptr(glm::vec4(0, 0, 0, 1))));
glAssert(glLightfv(GL_LIGHT0, GL_SPECULAR, glm::value_ptr(glm::vec4(0, 0, 0, 1))));
glEnable(GL_LIGHT0);
glLightfv(GL_LIGHT0, GL_AMBIENT, glm::value_ptr(glm::vec4(glm::vec3(0.1f), 1)));
glLightfv(GL_LIGHT0, GL_POSITION, glm::value_ptr(glm::vec4(0)));
glLightfv(GL_LIGHT0, GL_DIFFUSE, glm::value_ptr(glm::vec4(0, 0, 0, 1)));
glLightfv(GL_LIGHT0, GL_SPECULAR, glm::value_ptr(glm::vec4(0, 0, 0, 1)));
int i=1;
for(SceneIterator<Light*>* lightIt = scene->getLights();
lightIt->isValid(); lightIt->next())
{
Light* l = lightIt->getItem();
glAssert(glEnable(GL_LIGHT0 + i));
glAssert(glLightfv(GL_LIGHT0 + i, GL_AMBIENT, glm::value_ptr(glm::vec4(glm::vec3(0), 1))));
glEnable(GL_LIGHT0 + i);
glLightfv(GL_LIGHT0 + i, GL_AMBIENT, glm::value_ptr(glm::vec4(glm::vec3(0), 1)));
if(l->isDirectionnal()){
glAssert(glLightfv(GL_LIGHT0 + i, GL_POSITION, glm::value_ptr(glm::vec4(-l->getDir(), 0))));
glLightfv(GL_LIGHT0 + i, GL_POSITION, glm::value_ptr(glm::vec4(-l->getDir(), 0)));
}else{
glAssert(glLightfv(GL_LIGHT0 + i, GL_POSITION, glm::value_ptr(glm::vec4(l->getPos(), 1))));
glLightfv(GL_LIGHT0 + i, GL_POSITION, glm::value_ptr(glm::vec4(l->getPos(), 1)));
}
glAssert(glLightfv(GL_LIGHT0 + i, GL_DIFFUSE, glm::value_ptr(glm::vec4(l->getColor(), 1))));
glAssert(glLightfv(GL_LIGHT0 + i, GL_SPECULAR, glm::value_ptr(glm::vec4(l->getColor(), 1))));
glLightfv(GL_LIGHT0 + i, GL_DIFFUSE, glm::value_ptr(glm::vec4(l->getColor(), 1)));
glLightfv(GL_LIGHT0 + i, GL_SPECULAR, glm::value_ptr(glm::vec4(l->getColor(), 1)));
++i;
}
@ -43,7 +43,7 @@ void CrappyModule::renderGL(Camera* myCamera, Scene* scene)
glMatrixMode(GL_PROJECTION);
glLoadMatrixf(glm::value_ptr(myCamera->getProjectionMatrix()));
glMatrixMode(GL_MODELVIEW);
if(node->mesh->hasInstances())
if(!node->mesh->instances_offsets.empty())
{
for(const glm::vec3 &pos : node->mesh->instances_offsets)
{
@ -61,7 +61,7 @@ void CrappyModule::renderGL(Camera* myCamera, Scene* scene)
}
}
glAssert(glDisable(GL_LIGHTING));
glDisable(GL_LIGHTING);
for(int j=0; j<i; ++j)
glAssert(glDisable(GL_LIGHTING));
glDisable(GL_LIGHTING);
}

2
src/deferredmodule.cpp
View File

@ -1,5 +1,5 @@
#include "deferredmodule.h"
#include "glassert.h"
#include "texture.h"
GBuffer::GBuffer(int width, int height) : FrameBuffer()

28
src/forwardmodule.cpp
View File

@ -3,7 +3,7 @@
#include "mesh.h"
#include "shader.h"
#include "light.h"
#include "glassert.h"
#include "texture.h"
#include <glm/ext.hpp>
@ -13,35 +13,35 @@ void ForwardModule::renderGL(Camera* myCamera, Scene* scene)
renderTarget->bindFBO();
if(clearBeforeDrawing)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glAssert(glViewport(0, 0, width, height));
glViewport(0, 0, width, height);
// render ambient lighting
glAssert(glEnable(GL_DEPTH_TEST));
glAssert(glDepthFunc(GL_LESS));
glAssert(glDisable(GL_BLEND));
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
glDisable(GL_BLEND);
lightPass(myCamera, scene, NULL);
// render directionnal lighting and point lighting
glAssert(glDepthFunc(GL_LEQUAL));
glAssert(glEnable(GL_BLEND));
glAssert(glBlendFunc(GL_ONE, GL_ONE));
glAssert(glDepthMask(GL_FALSE));
glDepthFunc(GL_LEQUAL);
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE);
glDepthMask(GL_FALSE);
for(SceneIterator<Light*>* lightIt = scene->getLights(); lightIt->isValid(); lightIt->next())
lightPass(myCamera, scene, lightIt->getItem());
glAssert(glDisable(GL_BLEND));
glAssert(glDepthFunc(GL_LESS));
glAssert(glDepthMask(GL_TRUE));
glDisable(GL_BLEND);
glDepthFunc(GL_LESS);
glDepthMask(GL_TRUE);
}
void ForwardModule::lightPass(Camera* myCamera, Scene* scene, Light* light)
{
if(isWireframe){
glAssert(glPolygonMode(GL_FRONT_AND_BACK, GL_LINE));
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
}else{
glAssert(glPolygonMode(GL_FRONT_AND_BACK, GL_FILL));
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}
// loop over all types of geometry
for(std::size_t i=0; i<geometryFlagList.size(); ++i)

16
src/framebuffer.cpp
View File

@ -1,6 +1,6 @@
#include "framebuffer.h"
#include "texture.h"
#include "glassert.h"
#include <iostream>
const FrameBuffer* FrameBuffer::screen = new FrameBuffer(0);
@ -8,13 +8,13 @@ const FrameBuffer* FrameBuffer::screen = new FrameBuffer(0);
FrameBuffer::FrameBuffer() :
allocated(true)
{
glAssert(glGenFramebuffers(1, &fbo));
glGenFramebuffers(1, &fbo);
}
FrameBuffer::~FrameBuffer()
{
if(allocated)
glAssert(glDeleteFramebuffers(1, &fbo));
glDeleteFramebuffers(1, &fbo);
}
void FrameBuffer::addTexture(Texture* tex, GLenum attachment)
@ -30,7 +30,7 @@ void FrameBuffer::addTexture(Texture* tex, GLenum attachment)
}
else
{
glAssert(glFramebufferTexture2D(GL_FRAMEBUFFER, attachment, tex->getTarget(), tex->getId(), 0));
glFramebufferTexture2D(GL_FRAMEBUFFER, attachment, tex->getTarget(), tex->getId(), 0);
if(attachment != GL_DEPTH_ATTACHMENT) // TODO stencil attachment must be tested too
attachments.push_back(attachment);
}
@ -43,10 +43,10 @@ void FrameBuffer::initColorAttachments()
if(fbo != 0 && attachments.size() != 0)
{
bindFBO();
glAssert(glDrawBuffers(attachments.size(), attachments.data()));
glDrawBuffers(attachments.size(), attachments.data());
}
else
glAssert(glDrawBuffer(GL_NONE));
glDrawBuffer(GL_NONE);
check();
}
@ -59,13 +59,13 @@ void FrameBuffer::deleteTextures()
void FrameBuffer::bindFBO(GLenum target) const
{
glAssert(glBindFramebuffer(target, fbo));
glBindFramebuffer(target, fbo);
}
bool FrameBuffer::check()
{
GLenum err;
glAssert(err = glCheckFramebufferStatus(GL_FRAMEBUFFER));
err = glCheckFramebufferStatus(GL_FRAMEBUFFER);
if (err != GL_FRAMEBUFFER_COMPLETE) {
std::cerr << "FBO not complete (error = " << err << ") : ";
switch (err) {

26
src/glassert.h
View File

@ -1,26 +0,0 @@
#ifndef GLASSERT
#define GLASSERT
/**
* OpenGL error management class.
*/
#include <cstdio>
#include <cassert>
#ifdef RENDER_DEBUG
#define STR(x) #x
#define glAssert(code) \
code; \
{\
GLuint err = glGetError(); \
if(err != GL_NO_ERROR){ \
fprintf(stderr, "OpenGL Error (%s : %d, %s) : %s (%d)\n", __FILE__, __LINE__, STR(code), gluErrorString(err), err);\
} \
}
#else
#define glAssert(code) code;
#endif
#endif // GLASSERT

4765
src/glew.h
View File

File diff suppressed because it is too large Load Diff

18
src/light.cpp
View File

@ -6,7 +6,7 @@
#include "shadersource.h"
#include "phongmaterial.h"
#include "mesh.h"
#include "glassert.h"
#include <glm/ext.hpp>
const char* Light::flagStr[] = {
@ -97,14 +97,14 @@ void Light::initShadowMap(int resWidth, int resHeight, glm::vec3 dim)
void Light::generateShadowMap(Scene* scene)
{
glAssert(glPolygonMode(GL_FRONT_AND_BACK, GL_FILL));
glAssert(glViewport(0, 0, shadowMapWidth, shadowMapHeight));
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glViewport(0, 0, shadowMapWidth, shadowMapHeight);
shadowMap->bindFBO();
glAssert(glClearDepth(1.0));
glAssert(glClear(GL_DEPTH_BUFFER_BIT));
glAssert(glEnable(GL_DEPTH_TEST));
glAssert(glDepthFunc(GL_LESS));
glAssert(glCullFace(GL_FRONT));
glClearDepth(1.0);
glClear(GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
glCullFace(GL_FRONT);
for(SceneIterator<GeometryNode*>* geometryIt = scene->getGeometry();
geometryIt->isValid(); geometryIt->next())
{
@ -131,7 +131,7 @@ void Light::generateShadowMap(Scene* scene)
}
}
}
glAssert(glCullFace(GL_BACK));
glCullFace(GL_BACK);
}
Texture* Light::getShadowMap()

50
src/mesh.cpp
View File

@ -1,7 +1,7 @@
#include "mesh.h"
#include <glm/ext.hpp>
#include <set>
#include "glassert.h"
#include "sparrowrenderer.h"
#include "material.h"
#include "buffer.h"
@ -48,8 +48,8 @@ void Mesh::initGL()
destroyGL();
// create VAO
glAssert(glGenVertexArrays(1, &vao));
glAssert(glBindVertexArray(vao));
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
Buffer *b;
@ -111,57 +111,57 @@ void Mesh::initGL()
}
// unbind vao
glAssert(glBindVertexArray(0));
glBindVertexArray(0);
}
void Mesh::draw(Shader* shader, bool drawNormals, bool drawTexCoord, bool drawTangents)
{
if(isDoubleSided)
{
glAssert(glDisable(GL_CULL_FACE));
glDisable(GL_CULL_FACE);
}
bool crappy = (shader == NULL);
material->bindAttributes(shader);
glAssert(glBindVertexArray(vao));
glBindVertexArray(vao);
if(crappy)
{
glAssert(glBindBuffer(GL_ARRAY_BUFFER, vbo[POSITION_BUFFER]));
glAssert(glEnableClientState(GL_VERTEX_ARRAY));
glAssert(glVertexPointer(3, GL_FLOAT, 0, BUFFER_OFFSET(0))); // TODO : check 2D positions
glBindBuffer(GL_ARRAY_BUFFER, vbo[POSITION_BUFFER]);
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, 0, BUFFER_OFFSET(0)); // TODO : check 2D positions
if(!texCoords.empty() && drawTexCoord)
{
glAssert(glBindBuffer(GL_ARRAY_BUFFER, vbo[TEXCOORD_BUFFER]));
glAssert(glEnableClientState(GL_TEXTURE_COORD_ARRAY));
glAssert(glTexCoordPointer(2, GL_FLOAT, 0, BUFFER_OFFSET(0)));
glBindBuffer(GL_ARRAY_BUFFER, vbo[TEXCOORD_BUFFER]);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, 0, BUFFER_OFFSET(0));
}
if(!normals.empty() && drawNormals)
{
glAssert(glBindBuffer(GL_ARRAY_BUFFER, vbo[NORMAL_BUFFER]));
glAssert(glEnableClientState(GL_NORMAL_ARRAY));
glAssert(glNormalPointer(GL_FLOAT, 0, BUFFER_OFFSET(0)));
glBindBuffer(GL_ARRAY_BUFFER, vbo[NORMAL_BUFFER]);
glEnableClientState(GL_NORMAL_ARRAY);
glNormalPointer(GL_FLOAT, 0, BUFFER_OFFSET(0));
}
glAssert(glBindBuffer(GL_ARRAY_BUFFER, 0));
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
glAssert(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, getEBO()));
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, getEBO());
if(!instances_offsets.empty() && !crappy)
glAssert(glDrawElementsInstanced(primitive_type, indices.size(), GL_UNSIGNED_INT, NULL, instances_offsets.size()));
glDrawElementsInstanced(primitive_type, indices.size(), GL_UNSIGNED_INT, NULL, instances_offsets.size());
else
glAssert(glDrawElements(primitive_type, indices.size(), GL_UNSIGNED_INT, NULL));
glDrawElements(primitive_type, indices.size(), GL_UNSIGNED_INT, NULL);
if(crappy)
{
glAssert(glDisableClientState(GL_VERTEX_ARRAY));
glDisableClientState(GL_VERTEX_ARRAY);
if(!normals.empty() && drawNormals)
glAssert(glDisableClientState(GL_NORMAL_ARRAY));
glDisableClientState(GL_NORMAL_ARRAY);
if(!texCoords.empty() && drawTexCoord)
glAssert(glDisableClientState(GL_TEXTURE_COORD_ARRAY));
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
glAssert(glBindVertexArray(0));
glBindVertexArray(0);
if(isDoubleSided)
{
glAssert(glEnable(GL_CULL_FACE));
glEnable(GL_CULL_FACE);
}
}
@ -169,7 +169,7 @@ void Mesh::destroyGL()
{
if(vao != 0)
{
glAssert(glDeleteVertexArrays(1, &vao));
glDeleteVertexArrays(1, &vao);
vao = 0;
}
for(Buffer *b : buffers)

14
src/phongmaterial.cpp
View File

@ -1,7 +1,7 @@
#include "phongmaterial.h"
#include "texture.h"
#include "sparrowrenderer.h"
#include "glassert.h"
#include "shader.h"
#include "mesh.h"
#include <glm/ext.hpp>
@ -52,16 +52,16 @@ void PhongMaterial::bindAttributes(Shader* myShader)
else
{
// Crappy rendering code
glAssert(glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, glm::value_ptr(glm::vec4(ambient, 1))));
glAssert(glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, glm::value_ptr(glm::vec4(diffuse, 1))));
glAssert(glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, glm::value_ptr(glm::vec4(specular, 1))));
glAssert(glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, shininess));
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, glm::value_ptr(glm::vec4(ambient, 1)));
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, glm::value_ptr(glm::vec4(diffuse, 1)));
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, glm::value_ptr(glm::vec4(specular, 1)));
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, shininess);
if(diffuse_texture != NULL)
diffuse_texture->bind(0);
else
{
glAssert(glActiveTexture(0));
glAssert(glBindTexture(GL_TEXTURE_2D, 0));
glActiveTexture(0);
glBindTexture(GL_TEXTURE_2D, 0);
}
}
}

22
src/pipeline.cpp
View File

@ -5,7 +5,7 @@
#include "sparrowrenderer.h"
#include "scene.h"
#include "camera.h"
#include "glassert.h"
Pipeline::~Pipeline()
{
@ -15,9 +15,9 @@ Pipeline::~Pipeline()
SimplePipeline::SimplePipeline(ShaderSource *forwardSource)
{
glAssert(glEnable(GL_DEPTH_TEST));
glAssert(glEnable(GL_CULL_FACE));
glAssert(glEnable(GL_TEXTURE_2D));
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glEnable(GL_TEXTURE_2D);
m_isCrappy = forwardSource != NULL && SparrowRenderer::isModernOpenGLAvailable();
if(!m_isCrappy)
@ -33,12 +33,12 @@ SimplePipeline::SimplePipeline(ShaderSource *forwardSource)
void SimplePipeline::renderGL(Scene *scene)
{
glAssert(glClearColor(m_clearColor.r, m_clearColor.g, m_clearColor.b, 1));
glAssert(glClearDepth(1.0));
glAssert(glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT));
glClearColor(m_clearColor.r, m_clearColor.g, m_clearColor.b, 1);
glClearDepth(1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
for(Module *m : modules)
{
glAssert(glFinish());
glFinish();
m->renderGL(m_camera, scene);
}
}
@ -62,9 +62,9 @@ void SimplePipeline::refreshScene(Scene *scene)
StandardPipeline::StandardPipeline(const Settings &mySettings, const SourcePack &mySourcePack)
{
glAssert(glEnable(GL_DEPTH_TEST));
glAssert(glEnable(GL_CULL_FACE));
glAssert(glEnable(GL_TEXTURE_2D));
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glEnable(GL_TEXTURE_2D);
// TODO
}

52
src/posteffectmodule.cpp
View File

@ -1,6 +1,6 @@
#include "posteffectmodule.h"
#include "framebuffer.h"
#include "glassert.h"
#include "texture.h"
#include "shader.h"
#include "textureblur.h"
@ -26,21 +26,21 @@ PostEffectModule::PostEffectModule(int width, int height) :
shaders[i] = NULL;
// set up vao
glAssert(glGenVertexArrays(1, &vao));
glAssert(glBindVertexArray(vao));
glAssert(glGenBuffers(1, &vbo));
glAssert(glBindBuffer(GL_ARRAY_BUFFER, vbo));
glAssert(glBufferData(GL_ARRAY_BUFFER, 3 * 2 * sizeof(GLfloat), vertices, GL_STATIC_DRAW));
glAssert(glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat)*2, NULL));
glAssert(glEnableVertexAttribArray(0));
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, 3 * 2 * sizeof(GLfloat), vertices, GL_STATIC_DRAW);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat)*2, NULL);
glEnableVertexAttribArray(0);
resize(width, height);
}
PostEffectModule::~PostEffectModule()
{
glAssert(glDeleteVertexArrays(1, &vao));
glAssert(glDeleteBuffers(1, &vbo));
glDeleteVertexArrays(1, &vao);
glDeleteBuffers(1, &vbo);
for(int i=0; i<NB_FBO; ++i)
frameBuffers[i].deleteTextures();
delete[](frameBuffers);
@ -120,11 +120,11 @@ void PostEffectModule::renderGL(Camera* myCamera, Scene* scene)
{
if(shaders[0] != NULL)
{
glAssert(glPolygonMode(GL_FRONT_AND_BACK, GL_FILL));
glAssert(glDisable(GL_BLEND));
glAssert(glDisable(GL_DEPTH_TEST));
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glDisable(GL_BLEND);
glDisable(GL_DEPTH_TEST);
glAssert(glBindVertexArray(vao));
glBindVertexArray(vao);
// thresholding the luminance to isolate high luminance pixels for bloom
luminanceStep();
@ -135,18 +135,18 @@ void PostEffectModule::renderGL(Camera* myCamera, Scene* scene)
// compute average luminance and apply tonemapping
hdrStep();
glAssert(glEnable(GL_DEPTH_TEST));
glEnable(GL_DEPTH_TEST);
}
frameBuffers[INPUT_FBO].bindFBO();
glAssert(glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT));
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
void PostEffectModule::luminanceStep()
{
glAssert(glViewport(0, 0, width, height));
glViewport(0, 0, width, height);
frameBuffers[LUMINANCE_FBO].bindFBO();
glAssert(glClear(GL_COLOR_BUFFER_BIT));
glClear(GL_COLOR_BUFFER_BIT);
shaders[LUMINANCE_SHADER]->bind();
@ -155,17 +155,17 @@ void PostEffectModule::luminanceStep()
shaders[LUMINANCE_SHADER]->bindFloat(shaders[LUMINANCE_SHADER]->getLocation("threshold"), bloom_threshold);
glAssert(glDrawArrays(GL_TRIANGLES, 0, 3));
glDrawArrays(GL_TRIANGLES, 0, 3);
}
void PostEffectModule::bloomStep()
{
blur->blur();
glAssert(glViewport(0, 0, width, height));
glViewport(0, 0, width, height);
frameBuffers[BLOOM_FBO].bindFBO();
glAssert(glClear(GL_COLOR_BUFFER_BIT));
glClear(GL_COLOR_BUFFER_BIT);
shaders[BLOOM_SHADER]->bind();
shaders[BLOOM_SHADER]->bindInteger(shaders[BLOOM_SHADER]->getLocation("colorSampler"), 0);
@ -182,7 +182,7 @@ void PostEffectModule::bloomStep()
shaders[BLOOM_SHADER]->bindInteger(shaders[BLOOM_SHADER]->getLocation("width"), width);
shaders[BLOOM_SHADER]->bindInteger(shaders[BLOOM_SHADER]->getLocation("height"), height);
glAssert(glDrawArrays(GL_TRIANGLES, 0, 3));
glDrawArrays(GL_TRIANGLES, 0, 3);
}
void PostEffectModule::hdrStep()
@ -190,10 +190,10 @@ void PostEffectModule::hdrStep()
glm::vec3 minMaxMean = redux->redux();
float gamma = 2.2f;
glAssert(glViewport(0, 0, width, height));
glViewport(0, 0, width, height);
outputFBO->bindFBO();
glAssert(glClear(GL_COLOR_BUFFER_BIT));
glClear(GL_COLOR_BUFFER_BIT);
shaders[HDR_SHADER]->bind();
shaders[HDR_SHADER]->bindInteger(shaders[HDR_SHADER]->getLocation("colorSampler"), 0);
@ -201,7 +201,7 @@ void PostEffectModule::hdrStep()
shaders[HDR_SHADER]->bindVec3(shaders[HDR_SHADER]->getLocation("minMaxMean"), minMaxMean);
shaders[HDR_SHADER]->bindFloat(shaders[HDR_SHADER]->getLocation("gamma"), gamma);
glAssert(glDrawArrays(GL_TRIANGLES, 0, 3));
glDrawArrays(GL_TRIANGLES, 0, 3);
}
void PostEffectModule::setShaders(const std::string &luminanceFragSource,
@ -229,7 +229,7 @@ glm::vec3 PostEffectModule::getObjectInfo(int x, int y)
{
frameBuffers[INPUT_FBO].getTexture(1)->bind(0);
glm::vec3 *val = new glm::vec3[width*height];
glAssert(glGetTexImage(GL_TEXTURE_RECTANGLE, 0, GL_RGB, GL_FLOAT, val));
glGetTexImage(GL_TEXTURE_RECTANGLE, 0, GL_RGB, GL_FLOAT, val);
glm::vec3 ret = val[x + (height-y)*width];
ret.z -= 1; // clearColor compensation
delete[] val;

102
src/shader.cpp
View File

@ -1,96 +1,96 @@
#include "glew.h"
#include "shader.h"
#include <iostream>
#include "glassert.h"
#include <glm/ext.hpp>
Shader::Shader(const std::string &vertexSource, const std::string &fragmentSource)
{
program = glAssert(glCreateProgram());
program = glCreateProgram();
GLuint vertexShaderId = createShader(vertexSource, GL_VERTEX_SHADER);
GLuint fragmentShaderId = createShader(fragmentSource, GL_FRAGMENT_SHADER);
glAssert(glAttachShader(program, vertexShaderId));
glAssert(glAttachShader(program, fragmentShaderId));
glAttachShader(program, vertexShaderId);
glAttachShader(program, fragmentShaderId);
glAssert(glBindAttribLocation(program, 0, "inPosition"));
glAssert(glBindAttribLocation(program, 1, "inNormal"));
glAssert(glBindAttribLocation(program, 2, "inTexCoord"));
glAssert(glBindAttribLocation(program, 3, "inTangent"));
glAssert(glBindAttribLocation(program, 4, "inBinormal"));
glBindAttribLocation(program, 0, "inPosition");
glBindAttribLocation(program, 1, "inNormal");
glBindAttribLocation(program, 2, "inTexCoord");
glBindAttribLocation(program, 3, "inTangent");
glBindAttribLocation(program, 4, "inBinormal");
glAssert(glLinkProgram(program));
glLinkProgram(program);
// check errors
GLint linked;
glAssert(glGetProgramiv(program, GL_LINK_STATUS, &linked));
glGetProgramiv(program, GL_LINK_STATUS, &linked);
if (!linked) {
std::cerr << "Program not linked" << std::endl;
printProgramInfoLog(program);
program = 0;
}
glAssert(glDetachShader(program, vertexShaderId));
glAssert(glDetachShader(program, fragmentShaderId));
glAssert(glDeleteShader(vertexShaderId));
glAssert(glDeleteShader(fragmentShaderId));
glDetachShader(program, vertexShaderId);
glDetachShader(program, fragmentShaderId);
glDeleteShader(vertexShaderId);
glDeleteShader(fragmentShaderId);
}
Shader::Shader(const std::string &vertexSource, const std::string &geometrySource, const std::string &fragmentSource)
{
program = glAssert(glCreateProgram());
program = glCreateProgram();
GLuint vertexShaderId = createShader(vertexSource, GL_VERTEX_SHADER);
GLuint geometryShaderId = createShader(geometrySource, GL_GEOMETRY_SHADER);
GLuint fragmentShaderId = createShader(fragmentSource, GL_FRAGMENT_SHADER);
glAssert(glAttachShader(program, vertexShaderId));
glAssert(glAttachShader(program, geometryShaderId));
glAssert(glAttachShader(program, fragmentShaderId));
glAttachShader(program, vertexShaderId);
glAttachShader(program, geometryShaderId);
glAttachShader(program, fragmentShaderId);
glAssert(glBindAttribLocation(program, 0, "inPosition"));
glAssert(glBindAttribLocation(program, 1, "inNormal"));
glAssert(glBindAttribLocation(program, 2, "inTexCoord"));
glBindAttribLocation(program, 0, "inPosition");
glBindAttribLocation(program, 1, "inNormal");
glBindAttribLocation(program, 2, "inTexCoord");
glAssert(glLinkProgram(program));
glLinkProgram(program);
// check errors
GLint linked;
glAssert(glGetProgramiv(program, GL_LINK_STATUS, &linked));
glGetProgramiv(program, GL_LINK_STATUS, &linked);
if (!linked) {
std::cerr << "Program not linked" << std::endl;
printProgramInfoLog(program);
program = 0;
}
glAssert(glDetachShader(program, vertexShaderId));
glAssert(glDetachShader(program, geometryShaderId));
glAssert(glDetachShader(program, fragmentShaderId));
glAssert(glDeleteShader(vertexShaderId));
glAssert(glDeleteShader(geometryShaderId));
glAssert(glDeleteShader(fragmentShaderId));
glDetachShader(program, vertexShaderId);
glDetachShader(program, geometryShaderId);
glDetachShader(program, fragmentShaderId);
glDeleteShader(vertexShaderId);
glDeleteShader(geometryShaderId);
glDeleteShader(fragmentShaderId);
}
Shader::~Shader()
{
bool ok;
glAssert(ok = glIsProgram(program))
ok = glIsProgram(program);
if(ok)
glAssert(glDeleteProgram(program));
glDeleteProgram(program);
}
GLuint Shader::createShader(const std::string &source, GLenum shaderType)
{
glAssert(GLuint shaderId = glCreateShader(shaderType));
GLuint shaderId = glCreateShader(shaderType);
const GLchar *data = (const GLchar *)source.c_str();
glAssert(glShaderSource(shaderId, 1, &data, NULL));
glShaderSource(shaderId, 1, &data, NULL);
glAssert(glCompileShader(shaderId));
glCompileShader(shaderId);
// check errors
GLint compiled;
glAssert(glGetShaderiv(shaderId, GL_COMPILE_STATUS, &compiled));
glGetShaderiv(shaderId, GL_COMPILE_STATUS, &compiled);
if (!compiled) {
std::string type_str;
switch(shaderType)
@ -119,10 +119,10 @@ void Shader::printShaderInfoLog(GLuint shaderId)
int infoLogLen = 0;
int charsWritten = 0;
GLchar *infoLog;
glAssert(glGetShaderiv(shaderId, GL_INFO_LOG_LENGTH, &infoLogLen));
glGetShaderiv(shaderId, GL_INFO_LOG_LENGTH, &infoLogLen);
if (infoLogLen > 0) {
infoLog = new GLchar[infoLogLen];
glAssert(glGetShaderInfoLog(shaderId, infoLogLen, &charsWritten, infoLog));
glGetShaderInfoLog(shaderId, infoLogLen, &charsWritten, infoLog);
std::cerr << "InfoLog:" << std::endl << infoLog << std::endl;
delete [] infoLog;
}
@ -133,10 +133,10 @@ void Shader::printProgramInfoLog(GLuint programId)
int infoLogLen = 0;
int charsWritten = 0;
GLchar *infoLog;
glAssert(glGetProgramiv(programId, GL_INFO_LOG_LENGTH, &infoLogLen));
glGetProgramiv(programId, GL_INFO_LOG_LENGTH, &infoLogLen);
if (infoLogLen > 0) {
infoLog = new GLchar[infoLogLen];
glAssert(glGetProgramInfoLog(programId, infoLogLen, &charsWritten, infoLog));
glGetProgramInfoLog(programId, infoLogLen, &charsWritten, infoLog);
std::cerr << "InfoLog:" << std::endl << infoLog << std::endl;
delete [] infoLog;
}
@ -144,56 +144,56 @@ void Shader::printProgramInfoLog(GLuint programId)
GLuint Shader::getLocation(std::string attribName)
{
glAssert(GLuint loc = glGetUniformLocation(program, attribName.c_str()));
GLuint loc = glGetUniformLocation(program, attribName.c_str());
return loc;
}
void Shader::bind()
{
glAssert(glUseProgram(program));
glUseProgram(program);
}
void Shader::unbind()
{
glAssert(glUseProgram(0));
glUseProgram(0);
}
void Shader::bindFloat(GLuint location, float val)
{
glAssert(glUniform1f(location, val));
glUniform1f(location, val);
}
void Shader::bindMat3(GLuint location, glm::mat3 mat)
{
glAssert(glUniformMatrix3fv(location, 1, GL_FALSE, glm::value_ptr(mat)));
glUniformMatrix3fv(location, 1, GL_FALSE, glm::value_ptr(mat));
}
void Shader::bindMat4(GLuint location, glm::mat4 mat)
{
glAssert(glUniformMatrix4fv(location, 1, GL_FALSE, glm::value_ptr(mat)));
glUniformMatrix4fv(location, 1, GL_FALSE, glm::value_ptr(mat));
}
void Shader::bindVec3(GLuint location, glm::vec3 vec)
{
glAssert(glUniform3fv(location, 1, glm::value_ptr(vec)));
glUniform3fv(location, 1, glm::value_ptr(vec));
}
void Shader::bindVec4(GLuint location, glm::vec4 vec)
{
glAssert(glUniform4fv(location, 1, glm::value_ptr(vec)));
glUniform4fv(location, 1, glm::value_ptr(vec));
}
void Shader::bindVec3Array(GLuint location, glm::vec3* vec, int nb_elements)
{
glAssert(glUniform3fv(location, nb_elements, (GLfloat*)vec));
glUniform3fv(location, nb_elements, (GLfloat*)vec);
}
void Shader::bindUnsignedInteger(GLuint location, GLuint unsigned_integer)
{
glAssert(glUniform1ui(location, unsigned_integer));
glUniform1ui(location, unsigned_integer);
}
void Shader::bindInteger(GLuint location, GLint integer)
{
glAssert(glUniform1i(location, integer));
glUniform1i(location, integer);
}

74
src/skyboxmodule.cpp
View File

@ -6,7 +6,7 @@
#include "texture.h"
#include "camera.h"
#include "framebuffer.h"
#include "glassert.h"
#include "sparrowrenderer.h"
#define BUFFER_OFFSET(i) ((char *)NULL + (i))
@ -15,13 +15,13 @@ SkyboxModule::SkyboxModule(Texture* myCubeMap)
{
cubeMap = myCubeMap;
glAssert(glGenVertexArrays(1, &vao));
glAssert(glBindVertexArray(vao));
glAssert(glGenBuffers(2, vbos));
glAssert(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbos[0]));
glAssert(glBufferData(GL_ELEMENT_ARRAY_BUFFER, 36 * sizeof(GLubyte), skyboxIndices, GL_STATIC_DRAW));
glAssert(glBindBuffer(GL_ARRAY_BUFFER, vbos[1]));
glAssert(glBufferData(GL_ARRAY_BUFFER, 24 * sizeof(GLfloat), skyboxVertices, GL_STATIC_DRAW));
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
glGenBuffers(2, vbos);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbos[0]);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, 36 * sizeof(GLubyte), skyboxIndices, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, vbos[1]);
glBufferData(GL_ARRAY_BUFFER, 24 * sizeof(GLfloat), skyboxVertices, GL_STATIC_DRAW);
if(SparrowRenderer::isModernOpenGLAvailable())
{
@ -30,31 +30,31 @@ SkyboxModule::SkyboxModule(Texture* myCubeMap)
mvpLocation = shader->getLocation("MVP");
}
glAssert(glBindVertexArray(0));
glBindVertexArray(0);
}
SkyboxModule::~SkyboxModule()
{
if(SparrowRenderer::isModernOpenGLAvailable())
{
glAssert(glDeleteVertexArrays(1, &vao));
glAssert(glDeleteBuffers(2, vbos));
glDeleteVertexArrays(1, &vao);
glDeleteBuffers(2, vbos);
}
}
void SkyboxModule::renderGL(Camera* myCamera, Scene* scene)
{
glAssert(glViewport(0, 0, width, height));
glViewport(0, 0, width, height);
glm::mat4 viewMatrix = glm::mat4(glm::mat3(myCamera->getViewMatrix()));
glm::mat4 projectionMatrix = myCamera->getProjectionMatrix();
glAssert(glDisable(GL_CULL_FACE));
glAssert(glDepthMask(GL_FALSE));
glDisable(GL_CULL_FACE);
glDepthMask(GL_FALSE);
if(!SparrowRenderer::isModernOpenGLAvailable())
{
glAssert(glMatrixMode(GL_MODELVIEW));
glAssert(glLoadMatrixf(glm::value_ptr(viewMatrix)));
glAssert(glMatrixMode(GL_PROJECTION));
glAssert(glLoadMatrixf(glm::value_ptr(projectionMatrix)));
glMatrixMode(GL_MODELVIEW);
glLoadMatrixf(glm::value_ptr(viewMatrix));
glMatrixMode(GL_PROJECTION);
glLoadMatrixf(glm::value_ptr(projectionMatrix));
}
else
{
@ -63,38 +63,38 @@ void SkyboxModule::renderGL(Camera* myCamera, Scene* scene)
shader->bindMat4(mvpLocation, projectionMatrix * viewMatrix);
}
cubeMap->bind(0);
glAssert(glBindVertexArray(vao));
glBindVertexArray(vao);
glAssert(glBindBuffer(GL_ARRAY_BUFFER, vbos[1]));
glBindBuffer(GL_ARRAY_BUFFER, vbos[1]);
if(SparrowRenderer::isModernOpenGLAvailable())
{
glAssert(glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3*sizeof(GLfloat), BUFFER_OFFSET(0)));
glAssert(glEnableVertexAttribArray(0));
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3*sizeof(GLfloat), BUFFER_OFFSET(0));
glEnableVertexAttribArray(0);
}
else
{
glAssert(glDisable(GL_LIGHTING));
glAssert(glEnable(GL_TEXTURE_CUBE_MAP));
glDisable(GL_LIGHTING);
glEnable(GL_TEXTURE_CUBE_MAP);
glAssert(glEnableClientState(GL_VERTEX_ARRAY));
glAssert(glVertexPointer(3, GL_FLOAT, 0, BUFFER_OFFSET(0)));
glAssert(glEnableClientState(GL_TEXTURE_COORD_ARRAY));
glAssert(glTexCoordPointer(3, GL_FLOAT, 0, BUFFER_OFFSET(0)));
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, 0, BUFFER_OFFSET(0));
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(3, GL_FLOAT, 0, BUFFER_OFFSET(0));
}
glAssert(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbos[0]));
glAssert(glDrawElements(GL_TRIANGLES, 36, GL_UNSIGNED_BYTE, NULL));
glAssert(glBindVertexArray(0));
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbos[0]);
glDrawElements(GL_TRIANGLES, 36, GL_UNSIGNED_BYTE, NULL);
glBindVertexArray(0);
if(!SparrowRenderer::isModernOpenGLAvailable())
{
glAssert(glEnable(GL_LIGHTING));
glAssert(glDisable(GL_TEXTURE_CUBE_MAP));
glAssert(glDisableClientState(GL_VERTEX_ARRAY));
glAssert(glDisableClientState(GL_TEXTURE_COORD_ARRAY));
glEnable(GL_LIGHTING);
glDisable(GL_TEXTURE_CUBE_MAP);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
glAssert(glEnable(GL_CULL_FACE));
glAssert(glDepthMask(GL_TRUE));
glEnable(GL_CULL_FACE);
glDepthMask(GL_TRUE);
}
void SkyboxModule::setRenderTarget(const FrameBuffer* target)

2
src/sparrowrenderer.cpp
View File

@ -3,7 +3,7 @@
#include <GL/glext.h>
#include <cstdio>
#include "sparrowrenderer.h"
#include "glassert.h"
#include "camera.h"
#include "framebuffer.h"
#include "module.h"

44
src/texture.cpp
View File

@ -1,5 +1,5 @@
#include "texture.h"
#include "glassert.h"
#include "image.h"
Texture::Texture(GLenum format,
@ -15,23 +15,23 @@ Texture::Texture(GLenum format,
m_height(height),
m_dataType(dataType)
{
glAssert(glGenTextures(1, &texId));
glAssert(glBindTexture(m_target, texId));
glGenTextures(1, &texId);
glBindTexture(m_target, texId);
switch(m_target)
{
case GL_TEXTURE_2D :
glAssert(glTexImage2D(m_target, 0, internal_format, width, height, 0, format, dataType, NULL));
glTexImage2D(m_target, 0, internal_format, width, height, 0, format, dataType, NULL);
setWrap(GL_REPEAT);
setFiltering(GL_LINEAR);
break;
case GL_TEXTURE_RECTANGLE :
glAssert(glTexImage2D(m_target, 0, internal_format, width, height, 0, format, dataType, NULL));
glTexImage2D(m_target, 0, internal_format, width, height, 0, format, dataType, NULL);
setWrap(GL_CLAMP_TO_EDGE);
setFiltering(GL_LINEAR);
break;
case GL_TEXTURE_CUBE_MAP :
for(int i=0; i<6; ++i)
glAssert(glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, internal_format, width, height, 0, format, dataType, NULL));
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, internal_format, width, height, 0, format, dataType, NULL);
setWrap(GL_CLAMP_TO_EDGE);
setFiltering(GL_LINEAR);
break;
@ -44,8 +44,8 @@ Texture::Texture(Image* myImage) :
m_height(myImage->height),
m_dataType(GL_UNSIGNED_BYTE)
{
glAssert(glGenTextures(1, &texId));
glAssert(glBindTexture(m_target, texId));
glGenTextures(1, &texId);
glBindTexture(m_target, texId);
initPixels(myImage, GL_TEXTURE_2D);
setWrap(GL_REPEAT);
setFiltering(GL_LINEAR);
@ -57,8 +57,8 @@ Texture::Texture(Image* myCubemapImages[6]) :
m_height(myCubemapImages[0]->height),
m_dataType(GL_UNSIGNED_BYTE)
{
glAssert(glGenTextures(1, &texId));
glAssert(glBindTexture(m_target, texId));
glGenTextures(1, &texId);
glBindTexture(m_target, texId);
for(int i=0; i<6; ++i)
initPixels(myCubemapImages[i], GL_TEXTURE_CUBE_MAP_POSITIVE_X + i);
setWrap(GL_CLAMP_TO_EDGE);
@ -73,19 +73,19 @@ Texture::Texture(Texture* tex, bool halfDim) :
m_height(tex->m_height),
m_dataType(tex->m_dataType)
{
glAssert(glGenTextures(1, &texId));
glAssert(glBindTexture(m_target, texId));
glGenTextures(1, &texId);
glBindTexture(m_target, texId);
if(halfDim)
{
m_width /= 2;
m_height /= 2;
}
glAssert(glTexImage2D(m_target, 0, m_internal_format, m_width, m_height, 0, m_format, m_dataType, NULL));
glTexImage2D(m_target, 0, m_internal_format, m_width, m_height, 0, m_format, m_dataType, NULL);
}
Texture::~Texture()
{
glAssert(glDeleteTextures(1, &texId));
glDeleteTextures(1, &texId);
}
void Texture::initPixels(Image* myImage, GLenum target)
@ -105,25 +105,25 @@ void Texture::initPixels(Image* myImage, GLenum target)
m_internal_format = GL_R8;
break;
}
glAssert(glTexImage2D(target, 0, m_internal_format, m_width, m_height, 0, m_format, m_dataType, myImage->pixels));
glTexImage2D(target, 0, m_internal_format, m_width, m_height, 0, m_format, m_dataType, myImage->pixels);
}
void Texture::setWrap(GLint wrap)
{
glAssert(glTexParameteri(m_target, GL_TEXTURE_WRAP_S, wrap));
glAssert(glTexParameteri(m_target, GL_TEXTURE_WRAP_T, wrap));
glAssert(glTexParameteri(m_target, GL_TEXTURE_WRAP_R, wrap));
glTexParameteri(m_target, GL_TEXTURE_WRAP_S, wrap);
glTexParameteri(m_target, GL_TEXTURE_WRAP_T, wrap);
glTexParameteri(m_target, GL_TEXTURE_WRAP_R, wrap);
}
void Texture::setFiltering(GLint filter)
{
glAssert(glTexParameteri(m_target, GL_TEXTURE_MIN_FILTER, filter));
glAssert(glTexParameteri(m_target, GL_TEXTURE_MAG_FILTER, filter));
glTexParameteri(m_target, GL_TEXTURE_MIN_FILTER, filter);
glTexParameteri(m_target, GL_TEXTURE_MAG_FILTER, filter);
}
void Texture::bind(int slot)
{
glAssert(glActiveTexture(GL_TEXTURE0+slot));
glAssert(glBindTexture(m_target, texId));
glActiveTexture(GL_TEXTURE0+slot);
glBindTexture(m_target, texId);
}

12
src/textureblur.cpp
View File

@ -3,7 +3,7 @@
#include "shader.h"
#include "shadersource.h"
#include "texture.h"
#include "glassert.h"
TextureBlur::TextureBlur(FrameBuffer* input, int downsampling, int textureId) :
m_input(input),
@ -67,13 +67,13 @@ void TextureBlur::blur()
FrameBuffer* dst = fbos + (i + 1);
src->bindFBO(GL_READ_FRAMEBUFFER);
dst->bindFBO(GL_DRAW_FRAMEBUFFER);
glAssert(glBlitFramebuffer(0, 0,
glBlitFramebuffer(0, 0,
src->getTexture(0)->getWidth(),
src->getTexture(0)->getHeight(),
0, 0,
dst->getTexture(0)->getWidth(),
dst->getTexture(0)->getHeight(),
GL_COLOR_BUFFER_BIT, GL_LINEAR));
GL_COLOR_BUFFER_BIT, GL_LINEAR);
}
// blurring
@ -82,7 +82,7 @@ void TextureBlur::blur()
FrameBuffer* ping = fbos + i;
FrameBuffer* pong = ping + (m_downsampling + 1);
Texture* tex = ping->getTexture(0);
glAssert(glViewport(0, 0, tex->getWidth(), tex->getHeight()));
glViewport(0, 0, tex->getWidth(), tex->getHeight());
// ping (horizontal blur)
horizontal->bind();
@ -92,7 +92,7 @@ void TextureBlur::blur()
horizontal->bindInteger(uniformLocations[H_SAMPLER], 0);
horizontal->bindInteger(uniformLocations[H_WIDTH], tex->getWidth());
horizontal->bindInteger(uniformLocations[H_HEIGHT], tex->getHeight());
glAssert(glDrawArrays(GL_TRIANGLES, 0, 3));
glDrawArrays(GL_TRIANGLES, 0, 3);
// pong (vertical blur)
vertical->bind();
@ -102,7 +102,7 @@ void TextureBlur::blur()
vertical->bindInteger(uniformLocations[V_SAMPLER], 0);
vertical->bindInteger(uniformLocations[V_WIDTH], tex->getWidth());
vertical->bindInteger(uniformLocations[V_HEIGHT], tex->getHeight());
glAssert(glDrawArrays(GL_TRIANGLES, 0, 3));
glDrawArrays(GL_TRIANGLES, 0, 3);
}
}

6
src/textureredux.cpp
View File

@ -1,6 +1,6 @@
#include "textureredux.h"
#include "texture.h"
#include "glassert.h"
#include "shader.h"
#include <glm/ext.hpp>
@ -57,10 +57,10 @@ glm::vec3 TextureRedux::redux()
if(tempHeight < 1)
tempHeight = 1;
glViewport(0, 0, tempWidth, tempHeight);
glAssert(glDrawArrays(GL_TRIANGLES, 0, 3));
glDrawArrays(GL_TRIANGLES, 0, 3);
inverted = !inverted;
}
glm::vec3 minMaxMean;
glAssert(glReadPixels(0, 0, 1, 1, GL_RGB, GL_FLOAT, glm::value_ptr(minMaxMean)));
glReadPixels(0, 0, 1, 1, GL_RGB, GL_FLOAT, glm::value_ptr(minMaxMean));
return minMaxMean;
}