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 "buffer.h"
#include "glassert.h"
#include <cstdio> #include <cstdio>
#define BUFFER_OFFSET(i) ((char *)NULL + (i)) #define BUFFER_OFFSET(i) ((char *)NULL + (i))
@ -31,8 +31,8 @@ Buffer<T>::BufferEditor::BufferEditor(Buffer *b)
if(b->isDynamic()) if(b->isDynamic())
{ {
GLenum m_typeEnum = getGLEnum(b->getType()); GLenum m_typeEnum = getGLEnum(b->getType());
glAssert(glBindBuffer(m_typeEnum, b->getId())); glBindBuffer(m_typeEnum, b->getId());
glAssert(ptr = (T*)glMapBuffer(m_typeEnum, GL_WRITE_ONLY)); ptr = (T*)glMapBuffer(m_typeEnum, GL_WRITE_ONLY);
} }
else else
{ {
@ -45,7 +45,7 @@ template <typename T>
Buffer<T>::BufferEditor::~BufferEditor() Buffer<T>::BufferEditor::~BufferEditor()
{ {
glUnmapBuffer(m_typeEnum); glUnmapBuffer(m_typeEnum);
glAssert(glBindBuffer(m_typeEnum, 0)); glBindBuffer(m_typeEnum, 0);
} }
template <typename T> template <typename T>
@ -56,10 +56,10 @@ Buffer<T>::Buffer(const std::vector<T> &data, BufferType type, bool isDynamic) :
// TODO : allow stream draw // TODO : allow stream draw
GLenum draw_type = isDynamic ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW; GLenum draw_type = isDynamic ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW;
GLenum typeEnum = getGLEnum(m_type); GLenum typeEnum = getGLEnum(m_type);
glAssert(glGenBuffers(1, m_id)); glGenBuffers(1, m_id);
glAssert(glBindBuffer(typeEnum, m_id)); glBindBuffer(typeEnum, m_id);
glAssert(glBufferData(typeEnum, data.size() * sizeof(T), data.data(), draw_type)); glBufferData(typeEnum, data.size() * sizeof(T), data.data(), draw_type);
glAssert(glBindBuffer(typeEnum, 0)); glBindBuffer(typeEnum, 0);
} }
template <typename T> template <typename T>
@ -67,12 +67,12 @@ void Buffer<T>::setVertexAttrib(int location, int nbComponents, int offset, int
{ {
if(m_type == VBO) if(m_type == VBO)
{ {
glAssert(glBindBuffer(GL_ARRAY_BUFFER, m_id)); glBindBuffer(GL_ARRAY_BUFFER, m_id);
glAssert(glEnableVertexAttribArray(location)); glEnableVertexAttribArray(location);
if(instanceDivisor) if(instanceDivisor)
glAssert(glVertexAttribDivisor(location, instanceDivisor)); glVertexAttribDivisor(location, instanceDivisor);
glAssert(glVertexAttribPointer(location, nbComponents, GL_FLOAT, GL_FALSE, sizeof(T), BUFFER_OFFSET(offset))); glVertexAttribPointer(location, nbComponents, GL_FLOAT, GL_FALSE, sizeof(T), BUFFER_OFFSET(offset));
glAssert(glBindBuffer(GL_ARRAY_BUFFER, 0)); glBindBuffer(GL_ARRAY_BUFFER, 0);
} }
else else
fprintf(stderr, "WTF\n"); fprintf(stderr, "WTF\n");
@ -81,5 +81,5 @@ void Buffer<T>::setVertexAttrib(int location, int nbComponents, int offset, int
template <typename T> template <typename T>
Buffer<T>::~Buffer() 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 "mesh.h"
#include "sparrowrenderer.h" #include "sparrowrenderer.h"
#include "scene.h" #include "scene.h"
#include "glassert.h"
#include "material.h" #include "material.h"
#include <glm/ext.hpp> #include <glm/ext.hpp>
void CrappyModule::renderGL(Camera* myCamera, Scene* scene) void CrappyModule::renderGL(Camera* myCamera, Scene* scene)
{ {
glAssert(glEnable(GL_LIGHTING)); glEnable(GL_LIGHTING);
glAssert(glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity(); glLoadIdentity();
glAssert(glEnable(GL_LIGHT0)); glEnable(GL_LIGHT0);
glAssert(glLightfv(GL_LIGHT0, GL_AMBIENT, glm::value_ptr(glm::vec4(glm::vec3(0.1f), 1)))); 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)))); 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)))); 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)))); glLightfv(GL_LIGHT0, GL_SPECULAR, glm::value_ptr(glm::vec4(0, 0, 0, 1)));
int i=1; int i=1;
for(SceneIterator<Light*>* lightIt = scene->getLights(); for(SceneIterator<Light*>* lightIt = scene->getLights();
lightIt->isValid(); lightIt->next()) lightIt->isValid(); lightIt->next())
{ {
Light* l = lightIt->getItem(); Light* l = lightIt->getItem();
glAssert(glEnable(GL_LIGHT0 + i)); glEnable(GL_LIGHT0 + i);
glAssert(glLightfv(GL_LIGHT0 + i, GL_AMBIENT, glm::value_ptr(glm::vec4(glm::vec3(0), 1)))); glLightfv(GL_LIGHT0 + i, GL_AMBIENT, glm::value_ptr(glm::vec4(glm::vec3(0), 1)));
if(l->isDirectionnal()){ 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{ }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)))); 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_SPECULAR, glm::value_ptr(glm::vec4(l->getColor(), 1)));
++i; ++i;
} }
@ -43,7 +43,7 @@ void CrappyModule::renderGL(Camera* myCamera, Scene* scene)
glMatrixMode(GL_PROJECTION); glMatrixMode(GL_PROJECTION);
glLoadMatrixf(glm::value_ptr(myCamera->getProjectionMatrix())); glLoadMatrixf(glm::value_ptr(myCamera->getProjectionMatrix()));
glMatrixMode(GL_MODELVIEW); glMatrixMode(GL_MODELVIEW);
if(node->mesh->hasInstances()) if(!node->mesh->instances_offsets.empty())
{ {
for(const glm::vec3 &pos : node->mesh->instances_offsets) 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) 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 "deferredmodule.h"
#include "glassert.h"
#include "texture.h" #include "texture.h"
GBuffer::GBuffer(int width, int height) : FrameBuffer() GBuffer::GBuffer(int width, int height) : FrameBuffer()

28
src/forwardmodule.cpp
View File

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

16
src/framebuffer.cpp
View File

@ -1,6 +1,6 @@
#include "framebuffer.h" #include "framebuffer.h"
#include "texture.h" #include "texture.h"
#include "glassert.h"
#include <iostream> #include <iostream>
const FrameBuffer* FrameBuffer::screen = new FrameBuffer(0); const FrameBuffer* FrameBuffer::screen = new FrameBuffer(0);
@ -8,13 +8,13 @@ const FrameBuffer* FrameBuffer::screen = new FrameBuffer(0);
FrameBuffer::FrameBuffer() : FrameBuffer::FrameBuffer() :
allocated(true) allocated(true)
{ {
glAssert(glGenFramebuffers(1, &fbo)); glGenFramebuffers(1, &fbo);
} }
FrameBuffer::~FrameBuffer() FrameBuffer::~FrameBuffer()
{ {
if(allocated) if(allocated)
glAssert(glDeleteFramebuffers(1, &fbo)); glDeleteFramebuffers(1, &fbo);
} }
void FrameBuffer::addTexture(Texture* tex, GLenum attachment) void FrameBuffer::addTexture(Texture* tex, GLenum attachment)
@ -30,7 +30,7 @@ void FrameBuffer::addTexture(Texture* tex, GLenum attachment)
} }
else 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 if(attachment != GL_DEPTH_ATTACHMENT) // TODO stencil attachment must be tested too
attachments.push_back(attachment); attachments.push_back(attachment);
} }
@ -43,10 +43,10 @@ void FrameBuffer::initColorAttachments()
if(fbo != 0 && attachments.size() != 0) if(fbo != 0 && attachments.size() != 0)
{ {
bindFBO(); bindFBO();
glAssert(glDrawBuffers(attachments.size(), attachments.data())); glDrawBuffers(attachments.size(), attachments.data());
} }
else else
glAssert(glDrawBuffer(GL_NONE)); glDrawBuffer(GL_NONE);
check(); check();
} }
@ -59,13 +59,13 @@ void FrameBuffer::deleteTextures()
void FrameBuffer::bindFBO(GLenum target) const void FrameBuffer::bindFBO(GLenum target) const
{ {
glAssert(glBindFramebuffer(target, fbo)); glBindFramebuffer(target, fbo);
} }
bool FrameBuffer::check() bool FrameBuffer::check()
{ {
GLenum err; GLenum err;
glAssert(err = glCheckFramebufferStatus(GL_FRAMEBUFFER)); err = glCheckFramebufferStatus(GL_FRAMEBUFFER);
if (err != GL_FRAMEBUFFER_COMPLETE) { if (err != GL_FRAMEBUFFER_COMPLETE) {
std::cerr << "FBO not complete (error = " << err << ") : "; std::cerr << "FBO not complete (error = " << err << ") : ";
switch (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 "shadersource.h"
#include "phongmaterial.h" #include "phongmaterial.h"
#include "mesh.h" #include "mesh.h"
#include "glassert.h"
#include <glm/ext.hpp> #include <glm/ext.hpp>
const char* Light::flagStr[] = { const char* Light::flagStr[] = {
@ -97,14 +97,14 @@ void Light::initShadowMap(int resWidth, int resHeight, glm::vec3 dim)
void Light::generateShadowMap(Scene* scene) void Light::generateShadowMap(Scene* scene)
{ {
glAssert(glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)); glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glAssert(glViewport(0, 0, shadowMapWidth, shadowMapHeight)); glViewport(0, 0, shadowMapWidth, shadowMapHeight);
shadowMap->bindFBO(); shadowMap->bindFBO();
glAssert(glClearDepth(1.0)); glClearDepth(1.0);
glAssert(glClear(GL_DEPTH_BUFFER_BIT)); glClear(GL_DEPTH_BUFFER_BIT);
glAssert(glEnable(GL_DEPTH_TEST)); glEnable(GL_DEPTH_TEST);
glAssert(glDepthFunc(GL_LESS)); glDepthFunc(GL_LESS);
glAssert(glCullFace(GL_FRONT)); glCullFace(GL_FRONT);
for(SceneIterator<GeometryNode*>* geometryIt = scene->getGeometry(); for(SceneIterator<GeometryNode*>* geometryIt = scene->getGeometry();
geometryIt->isValid(); geometryIt->next()) geometryIt->isValid(); geometryIt->next())
{ {
@ -131,7 +131,7 @@ void Light::generateShadowMap(Scene* scene)
} }
} }
} }
glAssert(glCullFace(GL_BACK)); glCullFace(GL_BACK);
} }
Texture* Light::getShadowMap() Texture* Light::getShadowMap()

50
src/mesh.cpp
View File

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

14
src/phongmaterial.cpp
View File

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

22
src/pipeline.cpp
View File

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

52
src/posteffectmodule.cpp
View File

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

102
src/shader.cpp
View File

@ -1,96 +1,96 @@
#include "glew.h" #include "glew.h"
#include "shader.h" #include "shader.h"
#include <iostream> #include <iostream>
#include "glassert.h"
#include <glm/ext.hpp> #include <glm/ext.hpp>
Shader::Shader(const std::string &vertexSource, const std::string &fragmentSource) Shader::Shader(const std::string &vertexSource, const std::string &fragmentSource)
{ {
program = glAssert(glCreateProgram()); program = glCreateProgram();
GLuint vertexShaderId = createShader(vertexSource, GL_VERTEX_SHADER); GLuint vertexShaderId = createShader(vertexSource, GL_VERTEX_SHADER);
GLuint fragmentShaderId = createShader(fragmentSource, GL_FRAGMENT_SHADER); GLuint fragmentShaderId = createShader(fragmentSource, GL_FRAGMENT_SHADER);
glAssert(glAttachShader(program, vertexShaderId)); glAttachShader(program, vertexShaderId);
glAssert(glAttachShader(program, fragmentShaderId)); glAttachShader(program, fragmentShaderId);
glAssert(glBindAttribLocation(program, 0, "inPosition")); glBindAttribLocation(program, 0, "inPosition");
glAssert(glBindAttribLocation(program, 1, "inNormal")); glBindAttribLocation(program, 1, "inNormal");
glAssert(glBindAttribLocation(program, 2, "inTexCoord")); glBindAttribLocation(program, 2, "inTexCoord");
glAssert(glBindAttribLocation(program, 3, "inTangent")); glBindAttribLocation(program, 3, "inTangent");
glAssert(glBindAttribLocation(program, 4, "inBinormal")); glBindAttribLocation(program, 4, "inBinormal");
glAssert(glLinkProgram(program)); glLinkProgram(program);
// check errors // check errors
GLint linked; GLint linked;
glAssert(glGetProgramiv(program, GL_LINK_STATUS, &linked)); glGetProgramiv(program, GL_LINK_STATUS, &linked);
if (!linked) { if (!linked) {
std::cerr << "Program not linked" << std::endl; std::cerr << "Program not linked" << std::endl;
printProgramInfoLog(program); printProgramInfoLog(program);
program = 0; program = 0;
} }
glAssert(glDetachShader(program, vertexShaderId)); glDetachShader(program, vertexShaderId);
glAssert(glDetachShader(program, fragmentShaderId)); glDetachShader(program, fragmentShaderId);
glAssert(glDeleteShader(vertexShaderId)); glDeleteShader(vertexShaderId);
glAssert(glDeleteShader(fragmentShaderId)); glDeleteShader(fragmentShaderId);
} }
Shader::Shader(const std::string &vertexSource, const std::string &geometrySource, const std::string &fragmentSource) 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 vertexShaderId = createShader(vertexSource, GL_VERTEX_SHADER);
GLuint geometryShaderId = createShader(geometrySource, GL_GEOMETRY_SHADER); GLuint geometryShaderId = createShader(geometrySource, GL_GEOMETRY_SHADER);
GLuint fragmentShaderId = createShader(fragmentSource, GL_FRAGMENT_SHADER); GLuint fragmentShaderId = createShader(fragmentSource, GL_FRAGMENT_SHADER);
glAssert(glAttachShader(program, vertexShaderId)); glAttachShader(program, vertexShaderId);
glAssert(glAttachShader(program, geometryShaderId)); glAttachShader(program, geometryShaderId);
glAssert(glAttachShader(program, fragmentShaderId)); glAttachShader(program, fragmentShaderId);
glAssert(glBindAttribLocation(program, 0, "inPosition")); glBindAttribLocation(program, 0, "inPosition");
glAssert(glBindAttribLocation(program, 1, "inNormal")); glBindAttribLocation(program, 1, "inNormal");
glAssert(glBindAttribLocation(program, 2, "inTexCoord")); glBindAttribLocation(program, 2, "inTexCoord");
glAssert(glLinkProgram(program)); glLinkProgram(program);
// check errors // check errors
GLint linked; GLint linked;
glAssert(glGetProgramiv(program, GL_LINK_STATUS, &linked)); glGetProgramiv(program, GL_LINK_STATUS, &linked);
if (!linked) { if (!linked) {
std::cerr << "Program not linked" << std::endl; std::cerr << "Program not linked" << std::endl;
printProgramInfoLog(program); printProgramInfoLog(program);
program = 0; program = 0;
} }
glAssert(glDetachShader(program, vertexShaderId)); glDetachShader(program, vertexShaderId);
glAssert(glDetachShader(program, geometryShaderId)); glDetachShader(program, geometryShaderId);
glAssert(glDetachShader(program, fragmentShaderId)); glDetachShader(program, fragmentShaderId);
glAssert(glDeleteShader(vertexShaderId)); glDeleteShader(vertexShaderId);
glAssert(glDeleteShader(geometryShaderId)); glDeleteShader(geometryShaderId);
glAssert(glDeleteShader(fragmentShaderId)); glDeleteShader(fragmentShaderId);
} }
Shader::~Shader() Shader::~Shader()
{ {
bool ok; bool ok;
glAssert(ok = glIsProgram(program)) ok = glIsProgram(program);
if(ok) if(ok)
glAssert(glDeleteProgram(program)); glDeleteProgram(program);
} }
GLuint Shader::createShader(const std::string &source, GLenum shaderType) 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(); 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 // check errors
GLint compiled; GLint compiled;
glAssert(glGetShaderiv(shaderId, GL_COMPILE_STATUS, &compiled)); glGetShaderiv(shaderId, GL_COMPILE_STATUS, &compiled);
if (!compiled) { if (!compiled) {
std::string type_str; std::string type_str;
switch(shaderType) switch(shaderType)
@ -119,10 +119,10 @@ void Shader::printShaderInfoLog(GLuint shaderId)
int infoLogLen = 0; int infoLogLen = 0;
int charsWritten = 0; int charsWritten = 0;
GLchar *infoLog; GLchar *infoLog;
glAssert(glGetShaderiv(shaderId, GL_INFO_LOG_LENGTH, &infoLogLen)); glGetShaderiv(shaderId, GL_INFO_LOG_LENGTH, &infoLogLen);
if (infoLogLen > 0) { if (infoLogLen > 0) {
infoLog = new GLchar[infoLogLen]; infoLog = new GLchar[infoLogLen];
glAssert(glGetShaderInfoLog(shaderId, infoLogLen, &charsWritten, infoLog)); glGetShaderInfoLog(shaderId, infoLogLen, &charsWritten, infoLog);
std::cerr << "InfoLog:" << std::endl << infoLog << std::endl; std::cerr << "InfoLog:" << std::endl << infoLog << std::endl;
delete [] infoLog; delete [] infoLog;
} }
@ -133,10 +133,10 @@ void Shader::printProgramInfoLog(GLuint programId)
int infoLogLen = 0; int infoLogLen = 0;
int charsWritten = 0; int charsWritten = 0;
GLchar *infoLog; GLchar *infoLog;
glAssert(glGetProgramiv(programId, GL_INFO_LOG_LENGTH, &infoLogLen)); glGetProgramiv(programId, GL_INFO_LOG_LENGTH, &infoLogLen);
if (infoLogLen > 0) { if (infoLogLen > 0) {
infoLog = new GLchar[infoLogLen]; infoLog = new GLchar[infoLogLen];
glAssert(glGetProgramInfoLog(programId, infoLogLen, &charsWritten, infoLog)); glGetProgramInfoLog(programId, infoLogLen, &charsWritten, infoLog);
std::cerr << "InfoLog:" << std::endl << infoLog << std::endl; std::cerr << "InfoLog:" << std::endl << infoLog << std::endl;
delete [] infoLog; delete [] infoLog;
} }
@ -144,56 +144,56 @@ void Shader::printProgramInfoLog(GLuint programId)
GLuint Shader::getLocation(std::string attribName) GLuint Shader::getLocation(std::string attribName)
{ {
glAssert(GLuint loc = glGetUniformLocation(program, attribName.c_str())); GLuint loc = glGetUniformLocation(program, attribName.c_str());
return loc; return loc;
} }
void Shader::bind() void Shader::bind()
{ {
glAssert(glUseProgram(program)); glUseProgram(program);
} }
void Shader::unbind() void Shader::unbind()
{ {
glAssert(glUseProgram(0)); glUseProgram(0);
} }
void Shader::bindFloat(GLuint location, float val) void Shader::bindFloat(GLuint location, float val)
{ {
glAssert(glUniform1f(location, val)); glUniform1f(location, val);
} }
void Shader::bindMat3(GLuint location, glm::mat3 mat) 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) 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) 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) 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) 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) void Shader::bindUnsignedInteger(GLuint location, GLuint unsigned_integer)
{ {
glAssert(glUniform1ui(location, unsigned_integer)); glUniform1ui(location, unsigned_integer);
} }
void Shader::bindInteger(GLuint location, GLint 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 "texture.h"
#include "camera.h" #include "camera.h"
#include "framebuffer.h" #include "framebuffer.h"
#include "glassert.h"
#include "sparrowrenderer.h" #include "sparrowrenderer.h"
#define BUFFER_OFFSET(i) ((char *)NULL + (i)) #define BUFFER_OFFSET(i) ((char *)NULL + (i))
@ -15,13 +15,13 @@ SkyboxModule::SkyboxModule(Texture* myCubeMap)
{ {
cubeMap = myCubeMap; cubeMap = myCubeMap;
glAssert(glGenVertexArrays(1, &vao)); glGenVertexArrays(1, &vao);
glAssert(glBindVertexArray(vao)); glBindVertexArray(vao);
glAssert(glGenBuffers(2, vbos)); glGenBuffers(2, vbos);
glAssert(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbos[0])); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbos[0]);
glAssert(glBufferData(GL_ELEMENT_ARRAY_BUFFER, 36 * sizeof(GLubyte), skyboxIndices, GL_STATIC_DRAW)); glBufferData(GL_ELEMENT_ARRAY_BUFFER, 36 * sizeof(GLubyte), skyboxIndices, GL_STATIC_DRAW);
glAssert(glBindBuffer(GL_ARRAY_BUFFER, vbos[1])); glBindBuffer(GL_ARRAY_BUFFER, vbos[1]);
glAssert(glBufferData(GL_ARRAY_BUFFER, 24 * sizeof(GLfloat), skyboxVertices, GL_STATIC_DRAW)); glBufferData(GL_ARRAY_BUFFER, 24 * sizeof(GLfloat), skyboxVertices, GL_STATIC_DRAW);
if(SparrowRenderer::isModernOpenGLAvailable()) if(SparrowRenderer::isModernOpenGLAvailable())
{ {
@ -30,31 +30,31 @@ SkyboxModule::SkyboxModule(Texture* myCubeMap)
mvpLocation = shader->getLocation("MVP"); mvpLocation = shader->getLocation("MVP");
} }
glAssert(glBindVertexArray(0)); glBindVertexArray(0);
} }
SkyboxModule::~SkyboxModule() SkyboxModule::~SkyboxModule()
{ {
if(SparrowRenderer::isModernOpenGLAvailable()) if(SparrowRenderer::isModernOpenGLAvailable())
{ {
glAssert(glDeleteVertexArrays(1, &vao)); glDeleteVertexArrays(1, &vao);
glAssert(glDeleteBuffers(2, vbos)); glDeleteBuffers(2, vbos);
} }
} }
void SkyboxModule::renderGL(Camera* myCamera, Scene* scene) 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 viewMatrix = glm::mat4(glm::mat3(myCamera->getViewMatrix()));
glm::mat4 projectionMatrix = myCamera->getProjectionMatrix(); glm::mat4 projectionMatrix = myCamera->getProjectionMatrix();
glAssert(glDisable(GL_CULL_FACE)); glDisable(GL_CULL_FACE);
glAssert(glDepthMask(GL_FALSE)); glDepthMask(GL_FALSE);
if(!SparrowRenderer::isModernOpenGLAvailable()) if(!SparrowRenderer::isModernOpenGLAvailable())
{ {
glAssert(glMatrixMode(GL_MODELVIEW)); glMatrixMode(GL_MODELVIEW);
glAssert(glLoadMatrixf(glm::value_ptr(viewMatrix))); glLoadMatrixf(glm::value_ptr(viewMatrix));
glAssert(glMatrixMode(GL_PROJECTION)); glMatrixMode(GL_PROJECTION);
glAssert(glLoadMatrixf(glm::value_ptr(projectionMatrix))); glLoadMatrixf(glm::value_ptr(projectionMatrix));
} }
else else
{ {
@ -63,38 +63,38 @@ void SkyboxModule::renderGL(Camera* myCamera, Scene* scene)
shader->bindMat4(mvpLocation, projectionMatrix * viewMatrix); shader->bindMat4(mvpLocation, projectionMatrix * viewMatrix);
} }
cubeMap->bind(0); cubeMap->bind(0);
glAssert(glBindVertexArray(vao)); glBindVertexArray(vao);
glAssert(glBindBuffer(GL_ARRAY_BUFFER, vbos[1])); glBindBuffer(GL_ARRAY_BUFFER, vbos[1]);
if(SparrowRenderer::isModernOpenGLAvailable()) if(SparrowRenderer::isModernOpenGLAvailable())
{ {
glAssert(glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3*sizeof(GLfloat), BUFFER_OFFSET(0))); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3*sizeof(GLfloat), BUFFER_OFFSET(0));
glAssert(glEnableVertexAttribArray(0)); glEnableVertexAttribArray(0);
} }
else else
{ {
glAssert(glDisable(GL_LIGHTING)); glDisable(GL_LIGHTING);
glAssert(glEnable(GL_TEXTURE_CUBE_MAP)); glEnable(GL_TEXTURE_CUBE_MAP);
glAssert(glEnableClientState(GL_VERTEX_ARRAY)); glEnableClientState(GL_VERTEX_ARRAY);
glAssert(glVertexPointer(3, GL_FLOAT, 0, BUFFER_OFFSET(0))); glVertexPointer(3, GL_FLOAT, 0, BUFFER_OFFSET(0));
glAssert(glEnableClientState(GL_TEXTURE_COORD_ARRAY)); glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glAssert(glTexCoordPointer(3, GL_FLOAT, 0, BUFFER_OFFSET(0))); glTexCoordPointer(3, GL_FLOAT, 0, BUFFER_OFFSET(0));
} }
glAssert(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbos[0])); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbos[0]);
glAssert(glDrawElements(GL_TRIANGLES, 36, GL_UNSIGNED_BYTE, NULL)); glDrawElements(GL_TRIANGLES, 36, GL_UNSIGNED_BYTE, NULL);
glAssert(glBindVertexArray(0)); glBindVertexArray(0);
if(!SparrowRenderer::isModernOpenGLAvailable()) if(!SparrowRenderer::isModernOpenGLAvailable())
{ {
glAssert(glEnable(GL_LIGHTING)); glEnable(GL_LIGHTING);
glAssert(glDisable(GL_TEXTURE_CUBE_MAP)); glDisable(GL_TEXTURE_CUBE_MAP);
glAssert(glDisableClientState(GL_VERTEX_ARRAY)); glDisableClientState(GL_VERTEX_ARRAY);
glAssert(glDisableClientState(GL_TEXTURE_COORD_ARRAY)); glDisableClientState(GL_TEXTURE_COORD_ARRAY);
} }
glAssert(glEnable(GL_CULL_FACE)); glEnable(GL_CULL_FACE);
glAssert(glDepthMask(GL_TRUE)); glDepthMask(GL_TRUE);
} }
void SkyboxModule::setRenderTarget(const FrameBuffer* target) void SkyboxModule::setRenderTarget(const FrameBuffer* target)

2
src/sparrowrenderer.cpp
View File

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

44
src/texture.cpp
View File

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

12
src/textureblur.cpp
View File

@ -3,7 +3,7 @@
#include "shader.h" #include "shader.h"
#include "shadersource.h" #include "shadersource.h"
#include "texture.h" #include "texture.h"
#include "glassert.h"
TextureBlur::TextureBlur(FrameBuffer* input, int downsampling, int textureId) : TextureBlur::TextureBlur(FrameBuffer* input, int downsampling, int textureId) :
m_input(input), m_input(input),
@ -67,13 +67,13 @@ void TextureBlur::blur()
FrameBuffer* dst = fbos + (i + 1); FrameBuffer* dst = fbos + (i + 1);
src->bindFBO(GL_READ_FRAMEBUFFER); src->bindFBO(GL_READ_FRAMEBUFFER);
dst->bindFBO(GL_DRAW_FRAMEBUFFER); dst->bindFBO(GL_DRAW_FRAMEBUFFER);
glAssert(glBlitFramebuffer(0, 0, glBlitFramebuffer(0, 0,
src->getTexture(0)->getWidth(), src->getTexture(0)->getWidth(),
src->getTexture(0)->getHeight(), src->getTexture(0)->getHeight(),
0, 0, 0, 0,
dst->getTexture(0)->getWidth(), dst->getTexture(0)->getWidth(),
dst->getTexture(0)->getHeight(), dst->getTexture(0)->getHeight(),
GL_COLOR_BUFFER_BIT, GL_LINEAR)); GL_COLOR_BUFFER_BIT, GL_LINEAR);
} }
// blurring // blurring
@ -82,7 +82,7 @@ void TextureBlur::blur()
FrameBuffer* ping = fbos + i; FrameBuffer* ping = fbos + i;
FrameBuffer* pong = ping + (m_downsampling + 1); FrameBuffer* pong = ping + (m_downsampling + 1);
Texture* tex = ping->getTexture(0); Texture* tex = ping->getTexture(0);
glAssert(glViewport(0, 0, tex->getWidth(), tex->getHeight())); glViewport(0, 0, tex->getWidth(), tex->getHeight());
// ping (horizontal blur) // ping (horizontal blur)
horizontal->bind(); horizontal->bind();
@ -92,7 +92,7 @@ void TextureBlur::blur()
horizontal->bindInteger(uniformLocations[H_SAMPLER], 0); horizontal->bindInteger(uniformLocations[H_SAMPLER], 0);
horizontal->bindInteger(uniformLocations[H_WIDTH], tex->getWidth()); horizontal->bindInteger(uniformLocations[H_WIDTH], tex->getWidth());
horizontal->bindInteger(uniformLocations[H_HEIGHT], tex->getHeight()); horizontal->bindInteger(uniformLocations[H_HEIGHT], tex->getHeight());
glAssert(glDrawArrays(GL_TRIANGLES, 0, 3)); glDrawArrays(GL_TRIANGLES, 0, 3);
// pong (vertical blur) // pong (vertical blur)
vertical->bind(); vertical->bind();
@ -102,7 +102,7 @@ void TextureBlur::blur()
vertical->bindInteger(uniformLocations[V_SAMPLER], 0); vertical->bindInteger(uniformLocations[V_SAMPLER], 0);
vertical->bindInteger(uniformLocations[V_WIDTH], tex->getWidth()); vertical->bindInteger(uniformLocations[V_WIDTH], tex->getWidth());
vertical->bindInteger(uniformLocations[V_HEIGHT], tex->getHeight()); 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 "textureredux.h"
#include "texture.h" #include "texture.h"
#include "glassert.h"
#include "shader.h" #include "shader.h"
#include <glm/ext.hpp> #include <glm/ext.hpp>
@ -57,10 +57,10 @@ glm::vec3 TextureRedux::redux()
if(tempHeight < 1) if(tempHeight < 1)
tempHeight = 1; tempHeight = 1;
glViewport(0, 0, tempWidth, tempHeight); glViewport(0, 0, tempWidth, tempHeight);
glAssert(glDrawArrays(GL_TRIANGLES, 0, 3)); glDrawArrays(GL_TRIANGLES, 0, 3);
inverted = !inverted; inverted = !inverted;
} }
glm::vec3 minMaxMean; 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; return minMaxMean;
} }