From f65df2127804638c848ff1376e9ffc5f4ed57eb1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Gero=20M=C3=BCller?= Date: Thu, 2 Nov 2017 12:45:15 +1000 Subject: [PATCH] Squashed 'vendor/gl/' content from commit 0235739 git-subtree-dir: vendor/gl git-subtree-split: 02357397e4f0f82afc00a8b59c73332a4c996db1 --- CMakeLists.txt | 15 +++ GlBuffers.h | 178 +++++++++++++++++++++++++ GlDebug.h | 77 +++++++++++ GlFrameBuffer.h | 167 ++++++++++++++++++++++++ GlGeometry.h | 167 ++++++++++++++++++++++++ GlLighting.h | 83 ++++++++++++ GlMethods.h | 306 +++++++++++++++++++++++++++++++++++++++++++ GlQuery.h | 73 +++++++++++ GlShaders.h | 329 +++++++++++++++++++++++++++++++++++++++++++++++ GlStacks.h | 154 ++++++++++++++++++++++ GlTexture.h | 123 ++++++++++++++++++ GlVertexArrays.h | 71 ++++++++++ LICENSE | 202 +++++++++++++++++++++++++++++ README.md | 4 + 14 files changed, 1949 insertions(+) create mode 100644 CMakeLists.txt create mode 100644 GlBuffers.h create mode 100644 GlDebug.h create mode 100644 GlFrameBuffer.h create mode 100644 GlGeometry.h create mode 100644 GlLighting.h create mode 100644 GlMethods.h create mode 100644 GlQuery.h create mode 100644 GlShaders.h create mode 100644 GlStacks.h create mode 100644 GlTexture.h create mode 100644 GlVertexArrays.h create mode 100644 LICENSE create mode 100644 README.md diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..fe7f680 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,15 @@ +project(gl) + +set(HEADER_FILES + GlBuffers.h + GlDebug.h + GlFrameBuffer.h + GlGeometry.h + GlLighting.h + GlMethods.h + GlShaders.h + GlVertexArrays.h +) + +add_library(gl STATIC ${HEADER_FILES}) +set_target_properties(gl PROPERTIES LINKER_LANGUAGE CXX) \ No newline at end of file diff --git a/GlBuffers.h b/GlBuffers.h new file mode 100644 index 0000000..64999c4 --- /dev/null +++ b/GlBuffers.h @@ -0,0 +1,178 @@ +/************************************************************************************ + + Authors : Bradley Austin Davis + Copyright : Copyright Brad Davis. All Rights reserved. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + ************************************************************************************/ + +#pragma once + +#ifndef GL_ZERO +#error "You must include the gl headers before including this file" +#endif + +#include +#include +#include + +namespace gl { + +template +class Buffer { + GLuint buffer; + +public: + + Buffer() : + buffer(0) { + glGenBuffers(1, &buffer); + assert(buffer != 0); + } + + Buffer(Buffer && other) : + buffer(0) { + std::swap(other.buffer, buffer); + } + + template + Buffer(const std::vector & data) : + buffer(0) { + glGenBuffers(1, &buffer); + + bind(); + load(data.size() * sizeof(T), &data[0]); + unbind(); + } + + template + Buffer(T (&array)[SIZE]) : + buffer(0) { + glGenBuffers(1, &buffer); + bind(); + load(SIZE * sizeof(T), array); + unbind(); + } + +// template Buffer(const std::vector & data);0 +// template Buffer(const T (&array)[SIZE]); + + virtual ~Buffer() { + glDeleteBuffers(1, &buffer); + } + + void load(size_t size, const void * data, GLenum usage = GL_STATIC_DRAW) { + glBufferData(BufferType, size, data, usage); + } + + void bind() const { + glBindBuffer(BufferType, buffer); + } + + static void unbind() { + glBindBuffer(BufferType, 0); + } +}; + +typedef Buffer IndexBuffer; +typedef std::shared_ptr IndexBufferPtr; + +typedef Buffer VertexBuffer; +typedef std::shared_ptr VertexBufferPtr; + +class BufferLoader { +public: + virtual ~BufferLoader() { + } + virtual const GLvoid* getData() const = 0; + virtual GLsizeiptr getSize() const = 0; +}; + +template class VectorLoader: public BufferLoader { +public: + typedef std::vector V; + const V & data; + VectorLoader(const V & data) : + data(data) { + } + + const GLvoid* getData() const { + const T * ptr = &(this->data[0]); + return ptr; + } + + GLsizeiptr getSize() const { + return sizeof(T) * data.size(); + } + +}; + +template VectorLoader makeVectorLoader( + const std::vector & vector) { + return VectorLoader(vector); +} + +template class ArrayLoader: public BufferLoader { +public: + const T * data; + + ArrayLoader(const T * data) : + data(data) { + } + + const GLvoid* getData() const { + return (const GLvoid*)data; + } + + GLsizeiptr getSize() const { + return sizeof(T) * SIZE; + } +}; + +template ArrayLoader makeArrayLoader( + T * pointer) { + return ArrayLoader(pointer); +} + +template ArrayLoader makeArrayLoader( + T(&array)[SIZE]) { + return ArrayLoader(array); +} + + + +template +Buffer & operator <<(Buffer & buffer, const BufferLoader & loader) { + buffer.bind(); + buffer.load(loader.getSize(), loader.getData()); + Buffer::unbind(); + GL_CHECK_ERROR; + return buffer; +} + +template +Buffer & operator <<(Buffer & buffer, BufferLoader && loader) { + GL_CHECK_ERROR; + buffer.bind(); + GL_CHECK_ERROR; + buffer.load(loader.getSize(), loader.getData()); + GL_CHECK_ERROR; + Buffer::unbind(); + GL_CHECK_ERROR; + return buffer; +} + + +} // gl + diff --git a/GlDebug.h b/GlDebug.h new file mode 100644 index 0000000..b8b8ba4 --- /dev/null +++ b/GlDebug.h @@ -0,0 +1,77 @@ +/************************************************************************************ + + Authors : Bradley Austin Davis + Copyright : Copyright Brad Davis. All Rights reserved. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + ************************************************************************************/ + +#pragma once + +#ifndef GL_ZERO +#error "You must include the gl headers before including this file" +#endif + +#ifdef WIN32 +#include +#endif + +#include +#include +#include +#include +#include +#include + +#ifdef WIN32 +#pragma warning(disable: 4996) +#define snprintf _snprintf +#endif + +namespace gl { + +class error : public std::runtime_error { +public: + GLenum errorCode; + + error(GLenum errorCode) + : errorCode(errorCode), runtime_error("OpenGL Error") { + } + + static inline void check() { + GLenum errorCode = glGetError(); + if (errorCode != 0) { + throw error(errorCode); + } + } +}; + +class shader_error : public std::runtime_error { +public: + GLuint shader; + shader_error(GLuint shader, const std::string & log) + : shader(shader), runtime_error("OpenGL Shader Error: " + log) { + } + + static inline void check() { + GLenum errorCode = glGetError(); + if (errorCode != 0) { + throw error(errorCode); + } + } +}; + +} + +#define GL_CHECK_ERROR gl::error::check() diff --git a/GlFrameBuffer.h b/GlFrameBuffer.h new file mode 100644 index 0000000..aba6d40 --- /dev/null +++ b/GlFrameBuffer.h @@ -0,0 +1,167 @@ +/************************************************************************************ + + Authors : Bradley Austin Davis + Copyright : Copyright Brad Davis. All Rights reserved. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + ************************************************************************************/ + +#pragma once + +#ifndef GL_ZERO +#error "You must include the gl headers before including this file" +#endif + +#include "GlTexture.h" +#include "GlDebug.h" + +namespace gl { + +struct FrameBuffer { + GLuint frameBuffer; + + FrameBuffer() : frameBuffer(0) { + glGenFramebuffers(1, &frameBuffer); + } + + virtual ~FrameBuffer() { + if (frameBuffer) { + glDeleteFramebuffers(1, &frameBuffer); + GL_CHECK_ERROR; + } + } + + void bind(GLenum target = GL_FRAMEBUFFER) { + glBindFramebuffer(target, frameBuffer); + } + + static void unbind(GLenum target = GL_FRAMEBUFFER) { + glBindFramebuffer(target, 0); + } + + static bool checkStatus(GLenum target = GL_FRAMEBUFFER) { + GLuint status = glCheckFramebufferStatus(target); + switch(status) { + case GL_FRAMEBUFFER_COMPLETE: + return true; + break; + + case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT: + std::cerr << "framebuffer incomplete attachment" << std::endl; + break; + + case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: + std::cerr << "framebuffer missing attachment" << std::endl; + break; + + case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER: + std::cerr << "framebuffer incomplete draw buffer" << std::endl; + break; + + case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER: + std::cerr << "framebuffer incomplete read buffer" << std::endl; + break; + + case GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE: + std::cerr << "framebuffer incomplete multisample" << std::endl; + break; + + case GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS : + std::cerr << "framebuffer incomplete layer targets" << std::endl; + break; + + case GL_FRAMEBUFFER_UNSUPPORTED: + std::cerr << "framebuffer unsupported internal format or image" << std::endl; + break; + + default: + std::cerr << "other framebuffer error" << std::endl; + break; + } + + return false; + } + + template + void attach(int attachPoint, std::shared_ptr > & texture) { + glFramebufferTexture2D(GL_FRAMEBUFFER, attachPoint, TextureType, *texture, 0); + } +}; + +typedef std::shared_ptr FrameBufferPtr; + +template +struct TFrameBufferWrapper { + typedef Texture ColorTexture; + FrameBufferPtr frameBuffer; + typename ColorTexture::Ptr color; + Texture2dDepth::Ptr depth; + glm::ivec2 size; + + void init(const glm::ivec2 & size) { + this->size = size; + GL_CHECK_ERROR; + if (!frameBuffer) { + frameBuffer = FrameBufferPtr(new FrameBuffer()); + } + frameBuffer->bind(); + GL_CHECK_ERROR; + + if (!color) { + color = typename ColorTexture::Ptr(new ColorTexture()); + color->bind(); + color->parameter(GL_TEXTURE_MIN_FILTER, GL_LINEAR); + color->parameter(GL_TEXTURE_MAG_FILTER, GL_LINEAR); + color->parameter(GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER); + color->parameter(GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER); + color->storage2d(size); + Texture2d::unbind(); + } + frameBuffer->attach(GL_COLOR_ATTACHMENT0, color); + GL_CHECK_ERROR; + + if (!depth) { + depth = Texture2dDepth::Ptr(new Texture2dDepth()); + depth->bind(); + depth->storage2d(size); + Texture2dDepth::unbind(); + } + frameBuffer->attach(GL_DEPTH_ATTACHMENT, depth); + GL_CHECK_ERROR; + + + if (!frameBuffer->checkStatus()) { + throw std::runtime_error("Bad framebuffer creation"); + } + GL_CHECK_ERROR; + FrameBuffer::unbind(); + GL_CHECK_ERROR; + } + + void activate() { + frameBuffer->bind(); + viewport(size); + } + + static void deactivate() { + FrameBuffer::unbind(); + } + +}; + +typedef TFrameBufferWrapper<> FrameBufferWrapper; + +} // gl + + diff --git a/GlGeometry.h b/GlGeometry.h new file mode 100644 index 0000000..6024ad9 --- /dev/null +++ b/GlGeometry.h @@ -0,0 +1,167 @@ +/************************************************************************************ + + Authors : Bradley Austin Davis + Copyright : Copyright Brad Davis. All Rights reserved. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + ************************************************************************************/ +#pragma once + +#ifndef GL_ZERO +#error "You must include the gl headers before including this file" +#endif + +#include "GlBuffers.h" +#include "GlVertexArrays.h" + +namespace gl { + +class Geometry; + +typedef std::shared_ptr GeometryPtr; + +class Geometry { +public: + static const int VERTEX_ATTRIBUTE_SIZE = 4; + static const int BYTES_PER_ATTRIBUTE = (sizeof(float) + * VERTEX_ATTRIBUTE_SIZE); + enum Flag { + HAS_NORMAL = 0x01, + HAS_COLOR = 0x02, + HAS_TEXTURE = 0x04, + }; + + VertexBufferPtr vertices; + IndexBufferPtr indices; + VertexArrayPtr vertexArray; + + unsigned int elements; + GLenum elementType; + unsigned int verticesPerElement; + unsigned int flags; + + void bindVertexArray() { + vertexArray->bind(); + } + + static void unbindVertexArray() { + gl::VertexArray::unbind(); + } + + static unsigned int getStride(unsigned int flags) { + int result = VERTEX_ATTRIBUTE_SIZE; + if (flags & Geometry::Flag::HAS_NORMAL) { + result += VERTEX_ATTRIBUTE_SIZE; + } + if (flags & Geometry::Flag::HAS_COLOR) { + result += VERTEX_ATTRIBUTE_SIZE; + } + if (flags & Geometry::Flag::HAS_TEXTURE) { + result += VERTEX_ATTRIBUTE_SIZE; + } + return result * sizeof(float); + } + + unsigned int getStride() { + return getStride(flags); + } + + void draw() { + glDrawElements(elementType, elements * verticesPerElement, + GL_UNSIGNED_INT, (void*) 0); + } + + Geometry( + const std::vector & in_vertices, + const std::vector & in_indices, + unsigned int elements = 0, + unsigned int flags = 0, + GLenum elementType = GL_TRIANGLES, + unsigned int verticesPerElement = 3) + : elements(elements), + elementType(elementType), + flags(flags), + vertexArray(new gl::VertexArray()), + verticesPerElement(verticesPerElement) { + vertices = VertexBufferPtr(new VertexBuffer()); + *vertices << VectorLoader(in_vertices); + indices = IndexBufferPtr(new IndexBuffer()); + *indices << VectorLoader(in_indices); + buildVertexArray(); + } + + Geometry( + const gl::VertexBufferPtr in_vertices, + const gl::IndexBufferPtr in_indices, + unsigned int elements = 0, + unsigned int flags = 0, + GLenum elementType = GL_TRIANGLES, + unsigned int verticesPerElement = 3) + : vertices(in_vertices), + indices(in_indices), + elements(elements), + flags(flags), + vertexArray(new gl::VertexArray()), + elementType(elementType), + verticesPerElement(verticesPerElement) { + buildVertexArray(); + } + + void buildVertexArray() { + vertexArray->bind(); + { + indices->bind(); + vertices->bind(); + GL_CHECK_ERROR; + unsigned int stride = getStride(flags); + GLfloat * offset = 0; + glEnableVertexAttribArray(gl::Attribute::Position); + glVertexAttribPointer(gl::Attribute::Position, 3, GL_FLOAT, GL_FALSE, + stride, offset); + GL_CHECK_ERROR; + + if (flags & HAS_NORMAL) { + offset += VERTEX_ATTRIBUTE_SIZE; + glEnableVertexAttribArray(gl::Attribute::Normal); + glVertexAttribPointer(gl::Attribute::Normal, 3, GL_FLOAT, GL_FALSE, + stride, offset); + GL_CHECK_ERROR; + } + + if (flags & HAS_COLOR) { + offset += VERTEX_ATTRIBUTE_SIZE; + glEnableVertexAttribArray(gl::Attribute::Color); + glVertexAttribPointer(gl::Attribute::Color, 3, GL_FLOAT, GL_FALSE, + stride, offset); + GL_CHECK_ERROR; + } + + if (flags & HAS_TEXTURE) { + offset += VERTEX_ATTRIBUTE_SIZE; + glEnableVertexAttribArray(gl::Attribute::TexCoord0); + glVertexAttribPointer(gl::Attribute::TexCoord0, 2, GL_FLOAT, + GL_FALSE, stride, offset); + GL_CHECK_ERROR; + } + } + VertexArray::unbind(); + IndexBuffer::unbind(); + VertexBuffer::unbind(); + GL_CHECK_ERROR; + } + +}; + +} // gl + diff --git a/GlLighting.h b/GlLighting.h new file mode 100644 index 0000000..71f5a29 --- /dev/null +++ b/GlLighting.h @@ -0,0 +1,83 @@ +/************************************************************************************ + + Authors : Bradley Austin Davis + Copyright : Copyright Brad Davis. All Rights reserved. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + ************************************************************************************/ + +#pragma once + +#ifndef GL_ZERO +#error "You must include the gl headers before including this file" +#endif + +#include "GlShaders.h" +#include +#include + +namespace gl { + +struct Light { + glm::vec4 position; + glm::vec4 color; + + Light(const glm::vec4 & position = glm::vec4(1), const glm::vec4 & color = + glm::vec4(1)) { + this->position = position; + this->color = color; + } +}; + +class Lights { + std::vector lightPositions; + std::vector lightColors; + glm::vec4 ambient; + +public: + // Singleton class + Lights() + : ambient(glm::vec4(0.2, 0.2, 0.2, 1.0)) { + addLight(); + } + + void apply(Program & renderProgram) { + renderProgram.setUniform("Ambient", ambient); + renderProgram.setUniform("LightCount", (GLint)lightPositions.size()); + if (!lightPositions.empty()) { + renderProgram.setUniform4fv("LightPosition[0]", lightPositions); + renderProgram.setUniform4fv("LightColor[0]", lightColors); + } + } + + void apply(ProgramPtr & program) { + apply(*program); + } + + void addLight(const glm::vec4 & position = glm::vec4(1), + const glm::vec4 & color = glm::vec4(1)) { + lightPositions.push_back(position); + lightColors.push_back(color); + } + + void addLight(const Light & light) { + addLight(light.position, light.color); + } + + void setAmbient(const glm::vec4 & ambient) { + this->ambient = ambient; + } +}; + +} // gl diff --git a/GlMethods.h b/GlMethods.h new file mode 100644 index 0000000..ace5d56 --- /dev/null +++ b/GlMethods.h @@ -0,0 +1,306 @@ +/************************************************************************************ + + Authors : Bradley Austin Davis + Copyright : Copyright Brad Davis. All Rights reserved. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + ************************************************************************************/ + +#pragma once +#include + +namespace gl { +namespace Error { +enum { + NONE = GL_NO_ERROR, + INVALID_ENUM = GL_INVALID_ENUM, + INVALID_VALUE = GL_INVALID_VALUE, + INVALID_OPERATION = GL_INVALID_OPERATION, +// STACK_OVERFLOW = GL_STACK_OVERFLOW, +// STACK_UNDERFLOW = GL_STACK_UNDERFLOW, + OUT_OF_MEMORY = GL_OUT_OF_MEMORY, +}; +} + +namespace DrawMode { +enum { + POINTS = GL_POINTS, + LINE_STRIP = GL_LINE_STRIP, + LINE_LOOP = GL_LINE_LOOP, + LINES = GL_LINES, + LINE_STRIP_ADJACENCY = GL_LINE_STRIP_ADJACENCY, + LINES_ADJACENCY = GL_LINES_ADJACENCY, + TRIANGLE_STRIP = GL_TRIANGLE_STRIP, + TRIANGLE_FAN = GL_TRIANGLE_FAN, + TRIANGLES = GL_TRIANGLES, + TRIANGLE_STRIP_ADJACENCY = GL_TRIANGLE_STRIP_ADJACENCY, + TRIANGLES_ADJACENCY = GL_TRIANGLES_ADJACENCY, + PATCHES = GL_PATCHES, +}; +} + +inline void uniform(GLint location, GLfloat a) { + glUniform1f(location, a); +} + +inline void uniform(GLint location, GLint a) { + glUniform1i(location, a); +} + +inline void uniform(GLint location, const glm::vec2 & a) { + glUniform2f(location, a.x, a.y); +} + +inline void uniform(GLint location, const glm::vec4 & a) { + glUniform4f(location, a.x, a.y, a.z, a.w); +} + +inline void uniform(GLint location, const std::vector & a) { + glUniform4fv(location, (GLsizei) a.size(), &(a[0][0])); +} + +inline void uniform(GLint location, const glm::vec3 & a) { + glUniform3f(location, a.x, a.y, a.z); +} + +inline void uniform(GLint location, const glm::mat4 & a) { + glUniformMatrix4fv(location, 1, GL_FALSE, glm::value_ptr(a)); +} + +inline void lineWidth(GLfloat width) { + glLineWidth(width); +} + +inline void clearColor(const glm::vec4 & c) { + glClearColor(c.r, c.g, c.b, c.a); +} + +inline void clearColor(const glm::vec3 & c) { + glClearColor(c.r, c.g, c.b, 1.0); +} + +inline void scissor(const glm::ivec2 & v, const glm::ivec2 & size) { + glScissor(v.x, v.y, size.x, size.y); +} + +inline void viewport( const glm::ivec2 & pos, const glm::ivec2 & size ) { + glViewport(pos.x, pos.y, size.x, size.y); +} + +inline void viewport( const glm::ivec2 & size ) { + viewport(glm::ivec2(), size); +} + +} + +namespace glm { + template + inline float aspect(T const & size) { + return (float) size.x / (float)size.y; + } +} + +// inline void ColorMask( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha ); +// inline void AlphaFunc( GLenum func, GLclampf ref ); +// inline void BlendFunc( GLenum sfactor, GLenum dfactor ); +// inline void LogicOp( GLenum opcode ); +// inline void CullFace( GLenum mode ); +// inline void FrontFace( GLenum mode ); +// inline void PointSize( GLfloat size ); +// inline void LineStipple( GLint factor, GLushort pattern ); +// inline void PolygonMode( GLenum face, GLenum mode ); +// inline void PolygonOffset( GLfloat factor, GLfloat units ); +// inline void PolygonStipple( const GLubyte *mask ); +// inline void GetPolygonStipple( GLubyte *mask ); +// inline void EdgeFlag( GLboolean flag ); +// inline void EdgeFlagv( const GLboolean *flag ); +// inline void ClipPlane( GLenum plane, const GLdouble *equation ); +// inline void GetClipPlane( GLenum plane, GLdouble *equation ); +// inline void DrawBuffer( GLenum mode ); +// inline void ReadBuffer( GLenum mode ); +// inline void Enable( GLenum cap ); +// inline void Disable( GLenum cap ); +// inline bool IsEnabled( GLenum cap ); +// inline void EnableClientState( GLenum cap ); /* 1.1 */ +// inline void DisableClientState( GLenum cap ); /* 1.1 */ +// inline void GetBooleanv( GLenum pname, GLboolean *params ); +// inline void GetDoublev( GLenum pname, GLdouble *params ); +// inline void GetFloatv( GLenum pname, GLfloat *params ); +// inline void GetIntegerv( GLenum pname, GLint *params ); +// inline void PushAttrib( GLbitfield mask ); +// inline void PopAttrib( void ); +// inline void PushClientAttrib( GLbitfield mask ); /* 1.1 */ +// inline void PopClientAttrib( void ); /* 1.1 */ +// inline int32_tRenderMode( GLenum mode ); +// GLAPI GLenum GLAPIENTRY glGetError( void ); +// GLAPI const GLubyte * GLAPIENTRY glGetString( GLenum name ); +// inline void Finish( void ); +// inline void Flush( void ); +// inline void Hint( GLenum target, GLenum mode ); +// inline void ClearDepth( GLclampd depth ); +// inline void DepthFunc( GLenum func ); +// inline void DepthMask( GLboolean flag ); +// inline void DepthRange( GLclampd near_val, GLclampd far_val ); +// inline void ClearAccum( const glm::vec4 & color ); +// inline void VertexPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *ptr ); +// inline void NormalPointer( GLenum type, GLsizei stride, const GLvoid *ptr ); +// inline void ColorPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *ptr ); +// inline void IndexPointer( GLenum type, GLsizei stride, const GLvoid *ptr ); +// inline void TexCoordPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *ptr ); +// inline void EdgeFlagPointer( GLsizei stride, const GLvoid *ptr ); +// inline void GetPointerv( GLenum pname, GLvoid **params ); +// inline void ArrayElement( GLint i ); +// inline void DrawArrays( GLenum mode, GLint first, GLsizei count ); +// inline void DrawElements( GLenum mode, GLsizei count, GLenum type, const GLvoid *indices ); +// inline void InterleavedArrays( GLenum format, GLsizei stride, const GLvoid *pointer ); +// inline void ShadeModel( GLenum mode ); +// inline void PixelZoom( GLfloat xfactor, GLfloat yfactor ); +// inline void PixelStoref( GLenum pname, GLfloat param ); +// inline void PixelStorei( GLenum pname, GLint param ); +// inline void PixelTransferf( GLenum pname, GLfloat param ); +// inline void PixelTransferi( GLenum pname, GLint param ); +// inline void PixelMapfv( GLenum map, GLsizei mapsize, const GLfloat *values ); +// inline void PixelMapuiv( GLenum map, GLsizei mapsize, const GLuint *values ); +// inline void PixelMapusv( GLenum map, GLsizei mapsize, const GLushort *values ); +// inline void GetPixelMapfv( GLenum map, GLfloat *values ); +// inline void GetPixelMapuiv( GLenum map, GLuint *values ); +// inline void GetPixelMapusv( GLenum map, GLushort *values ); +// inline void Bitmap( const glm::ivec2 & size, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap ); +// inline void ReadPixels( const glm::ivec2 & v, const glm::ivec2 & size, GLenum format, GLenum type, GLvoid *pixels ); +// inline void DrawPixels( const glm::ivec2 & size, GLenum format, GLenum type, const GLvoid *pixels ); +// inline void CopyPixels( const glm::ivec2 & v, const glm::ivec2 & size, GLenum type ); +// inline void StencilFunc( GLenum func, GLint ref, GLuint mask ); +// inline void StencilMask( GLuint mask ); +// inline void StencilOp( GLenum fail, GLenum zfail, GLenum zpass ); +// inline void ClearStencil( GLint s ); +// inline void TexGend( GLenum coord, GLenum pname, GLdouble param ); +// inline void TexGenf( GLenum coord, GLenum pname, GLfloat param ); +// inline void TexGeni( GLenum coord, GLenum pname, GLint param ); +// inline void TexGendv( GLenum coord, GLenum pname, const GLdouble *params ); +// inline void TexGenfv( GLenum coord, GLenum pname, const GLfloat *params ); +// inline void TexGeniv( GLenum coord, GLenum pname, const GLint *params ); +// inline void GetTexGendv( GLenum coord, GLenum pname, GLdouble *params ); +// inline void GetTexGenfv( GLenum coord, GLenum pname, GLfloat *params ); +// inline void GetTexGeniv( GLenum coord, GLenum pname, GLint *params ); +// inline void TexEnvf( GLenum target, GLenum pname, GLfloat param ); +// inline void TexEnvi( GLenum target, GLenum pname, GLint param ); +// inline void TexEnvfv( GLenum target, GLenum pname, const GLfloat *params ); +// inline void TexEnviv( GLenum target, GLenum pname, const GLint *params ); +// inline void GetTexEnvfv( GLenum target, GLenum pname, GLfloat *params ); +// inline void GetTexEnviv( GLenum target, GLenum pname, GLint *params ); +// inline void TexParameterf( GLenum target, GLenum pname, GLfloat param ); +// inline void TexParameteri( GLenum target, GLenum pname, GLint param ); +// inline void TexParameterfv( GLenum target, GLenum pname, const GLfloat *params ); +// inline void TexParameteriv( GLenum target, GLenum pname, const GLint *params ); +// inline void GetTexParameterfv( GLenum target, GLenum pname, GLfloat *params); +// inline void GetTexParameteriv( GLenum target, GLenum pname, GLint *params ); +// inline void GetTexLevelParameterfv( GLenum target, GLint level, GLenum pname, GLfloat *params ); +// inline void GetTexLevelParameteriv( GLenum target, GLint level, GLenum pname, GLint *params ); +// inline void TexImage1D( GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels ); +// inline void TexImage2D( GLenum target, GLint level, GLint internalFormat, const glm::ivec2 & size, GLint border, GLenum format, GLenum type, const GLvoid *pixels ); +// inline void GetTexImage( GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels ); +// inline void GenTextures( GLsizei n, GLuint *textures ); +// inline void DeleteTextures( GLsizei n, const GLuint *textures); +// inline void BindTexture( GLenum target, GLuint texture ); +// inline void PrioritizeTextures( GLsizei n, const GLuint *textures, const GLclampf *priorities ); +// inline bool AreTexturesResident( GLsizei n, const GLuint *textures, GLboolean *residences ); +// inline bool IsTexture( GLuint texture ); +// inline void TexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels ); +// inline void TexSubImage2D( GLenum target, GLint level, const glm::ivec2 & offset, const glm::ivec2 & size, GLenum format, GLenum type, const GLvoid *pixels ); +// inline void CopyTexImage1D( GLenum target, GLint level, GLenum internalformat, const glm::ivec2 & v, GLsizei width, GLint border ); +// inline void CopyTexImage2D( GLenum target, GLint level, GLenum internalformat, const glm::ivec2 & v, const glm::ivec2 & size, GLint border ); +// inline void CopyTexSubImage1D( GLenum target, GLint level, GLint xoffset, const glm::ivec2 & v, GLsizei width ); +// inline void CopyTexSubImage2D( GLenum target, GLint level, const glm::ivec2 & offset, const glm::ivec2 & v, const glm::ivec2 & size ); +// inline void Map1d( GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points ); +// inline void Map1f( GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points ); +// inline void Map2d( GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points ); +// inline void Map2f( GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points ); +// inline void GetMapdv( GLenum target, GLenum query, GLdouble *v ); +// inline void GetMapfv( GLenum target, GLenum query, GLfloat *v ); +// inline void GetMapiv( GLenum target, GLenum query, GLint *v ); +// inline void EvalCoord1d( GLdouble u ); +// inline void EvalCoord1f( GLfloat u ); +// inline void EvalCoord2d( GLdouble u, GLdouble v ); +// inline void EvalCoord2f( GLfloat u, GLfloat v ); +// inline void MapGrid1d( GLint un, GLdouble u1, GLdouble u2 ); +// inline void MapGrid1f( GLint un, GLfloat u1, GLfloat u2 ); +// inline void MapGrid2d( GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2 ); +// inline void MapGrid2f( GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2 ); +// inline void EvalPoint1( GLint i ); +// inline void EvalPoint2( GLint i, GLint j ); +// inline void EvalMesh1( GLenum mode, GLint i1, GLint i2 ); +// inline void EvalMesh2( GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 ); +// inline void Fogf( GLenum pname, GLfloat param ); +// inline void Fogi( GLenum pname, GLint param ); +// inline void Fogfv( GLenum pname, const GLfloat *params ); +// inline void Fogiv( GLenum pname, const GLint *params ); +// inline void FeedbackBuffer( GLsizei size, GLenum type, GLfloat *buffer ); +// inline void PassThrough( GLfloat token ); +// inline void SelectBuffer( GLsizei size, GLuint *buffer ); +// inline void InitNames( void ); +// inline void LoadName( GLuint name ); +// inline void PushName( GLuint name ); +// inline void PopName( void ); +// inline void DrawRangeElements( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices ); +// inline void TexImage3D( GLenum target, GLint level, GLint internalFormat, const glm::ivec3 & size, GLint border, GLenum format, GLenum type, const GLvoid *pixels ); +// inline void TexSubImage3D( GLenum target, GLint level, const glm::ivec3 & offset, const glm::ivec3 & size, GLenum format, GLenum type, const GLvoid *pixels); +// inline void CopyTexSubImage3D( GLenum target, GLint level, const glm::ivec3 & offset, GLint x, GLint y, const glm::ivec2 & size ); +// inline void ColorTable( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table ); +// inline void ColorSubTable( GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data ); +// inline void ColorTableParameteriv(GLenum target, GLenum pname, const GLint *params); +// inline void ColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params); +// inline void CopyColorSubTable( GLenum target, GLsizei start, const glm::ivec2 & v, GLsizei width ); +// inline void CopyColorTable( GLenum target, GLenum internalformat, const glm::ivec2 & v, GLsizei width ); +// inline void GetColorTable( GLenum target, GLenum format, GLenum type, GLvoid *table ); +// inline void GetColorTableParameterfv( GLenum target, GLenum pname, GLfloat *params ); +// inline void GetColorTableParameteriv( GLenum target, GLenum pname, GLint *params ); +// inline void BlendEquation( GLenum mode ); +// inline void BlendColor( const glm::vec4 & c ); +// inline void Histogram( GLenum target, GLsizei width, GLenum internalformat, GLboolean sink ); +// inline void ResetHistogram( GLenum target ); +// inline void GetHistogram( GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values ); +// inline void GetHistogramParameterfv( GLenum target, GLenum pname, GLfloat *params ); +// inline void GetHistogramParameteriv( GLenum target, GLenum pname, GLint *params ); +// inline void Minmax( GLenum target, GLenum internalformat, GLboolean sink ); +// inline void ResetMinmax( GLenum target ); +// inline void GetMinmax( GLenum target, GLboolean reset, GLenum format, GLenum types, GLvoid *values ); +// inline void GetMinmaxParameterfv( GLenum target, GLenum pname, GLfloat *params ); +// inline void GetMinmaxParameteriv( GLenum target, GLenum pname, GLint *params ); +// inline void ConvolutionFilter1D( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image ); +// inline void ConvolutionFilter2D( GLenum target, GLenum internalformat, const glm::ivec2 & size, GLenum format, GLenum type, const GLvoid *image ); +// inline void ConvolutionParameterf( GLenum target, GLenum pname, GLfloat params ); +// inline void ConvolutionParameterfv( GLenum target, GLenum pname, const GLfloat *params ); +// inline void ConvolutionParameteri( GLenum target, GLenum pname, GLint params ); +// inline void ConvolutionParameteriv( GLenum target, GLenum pname, const GLint *params ); +// inline void CopyConvolutionFilter1D( GLenum target, GLenum internalformat, const glm::ivec2 & v, GLsizei width ); +// inline void CopyConvolutionFilter2D( GLenum target, GLenum internalformat, const glm::ivec2 & v, const glm::ivec2 & size); +// inline void GetConvolutionFilter( GLenum target, GLenum format, GLenum type, GLvoid *image ); +// inline void GetConvolutionParameterfv( GLenum target, GLenum pname, GLfloat *params ); +// inline void GetConvolutionParameteriv( GLenum target, GLenum pname, GLint *params ); +// inline void SeparableFilter2D( GLenum target, GLenum internalformat, const glm::ivec2 & size, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column ); +// inline void GetSeparableFilter( GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span ); +// inline void ActiveTexture( GLenum texture ); +// inline void ClientActiveTexture( GLenum texture ); +// inline void CompressedTexImage1D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data ); +// inline void CompressedTexImage2D( GLenum target, GLint level, GLenum internalformat, const glm::ivec2 & size, GLint border, GLsizei imageSize, const GLvoid *data ); +// inline void CompressedTexImage3D( GLenum target, GLint level, GLenum internalformat, const glm::ivec3 & size, GLint border, GLsizei imageSize, const GLvoid *data ); +// inline void CompressedTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data ); +// inline void CompressedTexSubImage2D( GLenum target, GLint level, const glm::ivec2 & offset, const glm::ivec2 & size, GLenum format, GLsizei imageSize, const GLvoid *data ); +// inline void CompressedTexSubImage3D( GLenum target, GLint level, const glm::ivec3 & offset, const glm::ivec3 & size, GLenum format, GLsizei imageSize, const GLvoid *data ); +// inline void GetCompressedTexImage( GLenum target, GLint lod, GLvoid *img ); +// inline void LoadTransposeMatrixd( const GLdouble m[16] ); +// inline void LoadTransposeMatrixf( const GLfloat m[16] ); +// inline void MultTransposeMatrixd( const GLdouble m[16] ); +// inline void MultTransposeMatrixf( const GLfloat m[16] ); +// inline void SampleCoverage( GLclampf value, GLboolean invert ); diff --git a/GlQuery.h b/GlQuery.h new file mode 100644 index 0000000..3d10b98 --- /dev/null +++ b/GlQuery.h @@ -0,0 +1,73 @@ +/************************************************************************************ + + Authors : Bradley Austin Davis + Copyright : Copyright Brad Davis. All Rights reserved. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + ************************************************************************************/ + +#pragma once + +namespace gl { +template < + typename GenFunction, + typename DelFunction, + typename BindFunction> +class Object { + GLuint id; + const GenFunction gen; + const DelFunction del; + const BindFunction bind; +public: + Object(GenFunction g, DelFunction del, BindFunction bind) : gen(g), del(del), bind(bind) { + } +}; + +template class Query { + GLuint query; +public: + Query() { + glGenQueries(1, &query); + } + + virtual ~Query() { + glDeleteQueries(1, &query); + query = 0; + } + + void begin() { + glBeginQuery(QueryType, query); + } + + static void end() { + glEndQuery(QueryType); + } + + bool available() { + GLint result; + glGetQueryObjectiv(query, GL_QUERY_RESULT_AVAILABLE, &result); + return result == GL_TRUE; + } + + GLint getReult() { + GLint result = -1; + glGetQueryObjectiv(query, GL_QUERY_RESULT, &result); + return result; + } +}; + +typedef Query TimeQuery; +typedef std::shared_ptr TimeQueryPtr; + +} diff --git a/GlShaders.h b/GlShaders.h new file mode 100644 index 0000000..03e3615 --- /dev/null +++ b/GlShaders.h @@ -0,0 +1,329 @@ +/************************************************************************************ + + Authors : Bradley Austin Davis + Copyright : Copyright Brad Davis. All Rights reserved. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + ************************************************************************************/ + +#pragma once + +#ifndef GL_ZERO +#error "You must include the gl headers before including this file" +#endif + +#include +#include + +#include +#include +#include +#include +#include +#include + +namespace gl { + +struct Var { + std::string name; + GLint size; + GLenum type; + GLuint id; + GLint location; + + // for map usage + Var() + : location(0), type(0), size(0), id(0) { + } + Var(bool uniform, GLuint program, GLuint id) { + this->id = id; + static GLchar MY_BUFFER[8192]; + GLsizei bufSize = 8192; + if (uniform) { + glGetActiveUniform(program, id, bufSize, &bufSize, &size, &type, + MY_BUFFER); + } else { + glGetActiveAttrib(program, id, bufSize, &bufSize, &size, &type, + MY_BUFFER); + } + name = std::string(MY_BUFFER, bufSize); + if (uniform) { + location = glGetUniformLocation(program, name.c_str()); + } else { + location = glGetAttribLocation(program, name.c_str()); + } + } +}; + +class Shader { + friend class Program; + GLenum type; + GLuint shader; + std::string source; + +public: + Shader(GLenum type, const std::string & source) + : type(type), shader(0), source(source) { + + // Create the shader object + GLuint newShader = glCreateShader(type); + if (newShader == 0) { + throw std::runtime_error("Unable to create shader object"); + } + + { + static const char * c_str; + // std::string shaderSrc = Files::read(fileName); + // Load the shader source + glShaderSource(newShader, 1, &(c_str = source.c_str()), NULL); + } + + // Compile the shader + glCompileShader(newShader); + + // Check the compile status + GLint compiled; + glGetShaderiv(newShader, GL_COMPILE_STATUS, &compiled); + if (!compiled) { + std::string log = getLog(newShader); + throw shader_error(shader, log); + } + + if (0 != shader) { + glDeleteShader(shader); + } + shader = newShader; + } + + virtual ~Shader() { + glDeleteShader(shader); + } + + static std::string getLog(GLuint shader) { + std::string log; + GLint infoLen = 0; + glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen); + + if (infoLen > 1) { + char* infoLog = new char[infoLen]; + glGetShaderInfoLog(shader, infoLen, NULL, infoLog); + log = std::string(infoLog); + delete[] infoLog; + } + return log; + } +}; + +typedef std::shared_ptr ShaderPtr; + +namespace Attribute { +enum { + Position = 0, + TexCoord0 = 1, + Normal = 2, + Color = 3, + TexCoord1 = 4, +}; +} + +class Program { + typedef std::map Map; + typedef std::set Set; + + ShaderPtr vs; + ShaderPtr fs; + GLuint program; + Map uniforms; + Map attributes; + Set configuredUniforms; + public: + GLint getUniformLocation(const std::string & name) const { + return uniforms.count(name) ? uniforms.at(name).location : -1; + } + + GLint getAttributeLocation(const std::string & name) const { + return attributes.count(name) ? attributes.at(name).location : -1; + } + +public: + static std::string getLog(GLuint program) { + std::string log; + GLint infoLen = 0; + glGetProgramiv(program, GL_INFO_LOG_LENGTH, &infoLen); + + if (infoLen > 1) { + char* infoLog = new char[infoLen]; + glGetProgramInfoLog(program, infoLen, NULL, infoLog); + log = std::string(infoLog); + delete[] infoLog; + } + return log; + } + +public: + Program(const ShaderPtr & vs, const ShaderPtr & fs) + : vs(vs), fs(fs), program(0) { + if (0 != program) { + glDeleteProgram(program); + program = 0; + } + + // Create the program object + program = glCreateProgram(); + + if (program == 0) + throw std::runtime_error("Failed to allocate gl program"); + + glAttachShader(program, vs->shader); + glAttachShader(program, fs->shader); + + // Bind vPosition to attribute 0 + glBindAttribLocation(program, 0, "vPosition"); + + // Link the newProgram + glLinkProgram(program); + + // Check the link status + GLint linked; + glGetProgramiv(program, GL_LINK_STATUS, &linked); + if (!linked) { + std::string log = getLog(program); + throw std::runtime_error(log); + } + + int numVars; + glGetProgramiv(program, GL_ACTIVE_ATTRIBUTES, &numVars); + for (int i = 0; i < numVars; ++i) { + Var var(false, program, i); + // SAY("Found attribute %s at location %d", var.name.c_str(), var.location); + attributes[var.name] = var; + } + glGetProgramiv(program, GL_ACTIVE_UNIFORMS, &numVars); + for (int i = 0; i < numVars; ++i) { + Var var(true, program, i); + //SAY("Found uniform %s at location %d", var.name.c_str(), var.location); + uniforms[var.name] = var; + } + } + + virtual ~Program() { + glDeleteProgram(program); + } + + void setUniform(const std::string & name, GLfloat a) { + configuredUniforms.insert(name); + GLint location = getUniformLocation(name); + glUniform1f(location, a); + } + + void setUniform(const std::string & name, GLint a) { + configuredUniforms.insert(name); + GLint location = getUniformLocation(name); + glUniform1i(location, a); + } + + void setUniform(const std::string & name, bool a) { + configuredUniforms.insert(name); + GLint location = getUniformLocation(name); + glUniform1i(location, a ? 1 : 0); + } + + void setUniform(const std::string & name, const glm::vec2 & a) { + configuredUniforms.insert(name); + GLint location = getUniformLocation(name); + glUniform2f(location, a.x, a.y); + } + + void setUniform(const std::string & name, const glm::vec3 & a) { + configuredUniforms.insert(name); + GLint location = getUniformLocation(name); + glUniform3f(location, a.x, a.y, a.z); + } + + void setUniform(const std::string & name, const glm::vec4 & a) { + configuredUniforms.insert(name); + GLint location = getUniformLocation(name); + glUniform4f(location, a.x, a.y, a.z, a.w); + } + + void setUniform(const std::string & name, const std::vector & a) { + configuredUniforms.insert(name); + GLint location = getUniformLocation(name); + glUniform4fv(location, (GLsizei) a.size(), &(a[0][0])); + } + + void setUniform(const std::string & name, const glm::mat4 & a) { + configuredUniforms.insert(name); + GLint location = getUniformLocation(name); + glUniformMatrix4fv(location, 1, GL_FALSE, glm::value_ptr(a)); + } + + inline void setUniform1f(const std::string & name, GLfloat a) { + setUniform(name, a); + } + + inline void setUniform1i(const std::string & name, GLint a) { + setUniform(name, a); + } + + inline void setUniform2f(const std::string & name, const glm::vec2 & a) { + setUniform(name, a); + } + + inline void setUniform4f(const std::string & name, const glm::vec4 & a) { + setUniform(name, a); + } + + inline void setUniform3f(const std::string & name, const glm::vec3 & a) { + setUniform(name, a); + } + + inline void setUniform4fv(const std::string & name, const std::vector & a) { + setUniform(name, a); + } + + inline void setUniform4x4f(const std::string & name, const glm::mat4 & a) { + setUniform(name, a); + } + + void checkConfigured() { + Set existingUniforms; + // Option #2 + std::for_each(std::begin(uniforms), std::end(uniforms), + [&] (Map::const_reference element) + { + existingUniforms.insert(element.first); + }); + + std::for_each(std::begin(configuredUniforms), + std::end(configuredUniforms), [&] (Set::const_reference element) + { + existingUniforms.erase(element); + }); + +// assert(existingUniforms.size() == 0); + } + + void use() { + glUseProgram(program); + } + + static void clear() { + glUseProgram(0); + } +}; + +typedef std::shared_ptr ProgramPtr; + +} // gl diff --git a/GlStacks.h b/GlStacks.h new file mode 100644 index 0000000..809ef90 --- /dev/null +++ b/GlStacks.h @@ -0,0 +1,154 @@ +/************************************************************************************ + + Authors : Bradley Austin Davis + Copyright : Copyright Brad Davis. All Rights reserved. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + ************************************************************************************/ + +#pragma once + +#ifndef GL_ZERO +#error "You must include the gl headers before including this file" +#endif + +#include +#include +#include +#include +#include "GlShaders.h" +#include "GlLighting.h" + +namespace gl { + +class MatrixStack : public std::stack { + const std::string uniformName; + public: + MatrixStack(const std::string & uniformName) + : uniformName(uniformName) { + push(glm::mat4()); + } + + MatrixStack & apply(Program & program) { + program.setUniform4x4f(uniformName, top()); + return *this; + } + + MatrixStack & apply(ProgramPtr & program) { + apply(*program); + return *this; + } + + MatrixStack & pop() { + std::stack::pop(); + assert(!empty()); + return *this; + } + + MatrixStack & push() { + emplace(top()); + return *this; + } + + MatrixStack & identity() { + top() = glm::mat4(); + return *this; + } + + MatrixStack & push(const glm::mat4 & mat) { + std::stack::push(mat); + return *this; + } + + MatrixStack & rotate(const glm::mat3 & rotation) { + return postMultiply(glm::mat4(rotation)); + } + + MatrixStack & rotate(const glm::quat & rotation) { + return postMultiply(glm::mat4_cast(rotation)); + } + + MatrixStack & rotate(float theta, const glm::vec3 & axis) { + return postMultiply(glm::rotate(glm::mat4(), theta, axis)); + } + + MatrixStack & translate(float translation) { + return translate(glm::vec3(translation, 0, 0)); + } + + MatrixStack & translate(const glm::vec2 & translation) { + return translate(glm::vec3(translation, 0)); + } + + MatrixStack & translate(const glm::vec3 & translation) { + return postMultiply(glm::translate(glm::mat4(), translation)); + } + + MatrixStack & scale(float factor) { + return scale(glm::vec3(factor)); + } + + MatrixStack & scale(const glm::vec3 & scale) { + return postMultiply(glm::scale(glm::mat4(), scale)); + } + + MatrixStack & transform(const glm::mat4 & xfm) { + return postMultiply(xfm); + } + + MatrixStack & preMultiply(const glm::mat4 & xfm) { + top() = xfm * top(); + return *this; + } + + MatrixStack & postMultiply(const glm::mat4 & xfm) { + top() *= xfm; + return *this; + } + + // Remove the rotation component of a matrix. useful for billboarding + MatrixStack & unrotate() { + glm::quat inverse = glm::inverse(glm::quat_cast(top())); + top() = top() * glm::mat4_cast(inverse); + return *this; + } + + // Remove the translation component of a matrix. useful for skyboxing + MatrixStack & untranslate() { + top()[3] = glm::vec4(0, 0, 0, 1); + return *this; + } + +}; + +class Stacks { +public: + static MatrixStack & projection() { + static MatrixStack projection("Projection"); + return projection; + } + + static MatrixStack & modelview() { + static MatrixStack modelview("ModelView"); + return modelview; + } + + static Lights & lights() { + static Lights lights; + return lights; + } +}; + +} // gl + diff --git a/GlTexture.h b/GlTexture.h new file mode 100644 index 0000000..ba2bcbb --- /dev/null +++ b/GlTexture.h @@ -0,0 +1,123 @@ +/************************************************************************************ + + Authors : Bradley Austin Davis + Copyright : Copyright Brad Davis. All Rights reserved. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + ************************************************************************************/ + +#pragma once + +#ifndef GL_ZERO +#error "You must include the gl headers before including this file" +#endif + +#include +#include + +namespace gl { + +namespace TextureTarget2D { +enum Enum { + TEXTURE_2D = GL_TEXTURE_2D, + PROXY_TEXTURE_2D = GL_PROXY_TEXTURE_2D, + TEXTURE_1D_ARRAY = GL_TEXTURE_1D_ARRAY, + PROXY_TEXTURE_1D_ARRAY = GL_PROXY_TEXTURE_1D_ARRAY, + TEXTURE_RECTANGLE = GL_TEXTURE_RECTANGLE, + PROXY_TEXTURE_RECTANGLE = GL_PROXY_TEXTURE_RECTANGLE, + TEXTURE_CUBE_MAP_POSITIVE_X = GL_TEXTURE_CUBE_MAP_POSITIVE_X, + TEXTURE_CUBE_MAP_NEGATIVE_X = GL_TEXTURE_CUBE_MAP_NEGATIVE_X, + TEXTURE_CUBE_MAP_POSITIVE_Y = GL_TEXTURE_CUBE_MAP_POSITIVE_Y, + TEXTURE_CUBE_MAP_NEGATIVE_Y = GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, + TEXTURE_CUBE_MAP_POSITIVE_Z = GL_TEXTURE_CUBE_MAP_POSITIVE_Z, + TEXTURE_CUBE_MAP_NEGATIVE_Z = GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, + PROXY_TEXTURE_CUBE_MAP = GL_PROXY_TEXTURE_CUBE_MAP +}; +} + +template < +GLenum TextureType = GL_TEXTURE_2D, +GLenum TextureFormat = GL_RGBA8 +> +class Texture { +public: + GLuint texture; + Texture() + : texture(0) { + glGenTextures(1, &texture); + } + ~Texture() { + if (texture) { + glDeleteTextures(1, &texture); + } + } + + void bind() { + glBindTexture(TextureType, texture); + } + + static void unbind() { + glBindTexture(TextureType, 0); + } + + void parameter(GLenum paramName, GLfloat f, GLenum target = TextureType ) { + glTexParameterf(target, paramName, f); + } + + void parameter(GLenum paramName, GLint i, GLenum target = TextureType ) { + glTexParameteri(target, paramName, i); + } + + void image2d(const glm::ivec2 & size, void * data, + GLint level = 0, + GLenum format = GL_RGB, + GLenum type = GL_UNSIGNED_BYTE) { + image2d(TextureType, size, data, level, format, type); + } + + void image2d(GLenum target, const glm::ivec2 & size, void * data, + GLint level = 0, + GLenum format = GL_RGB, + GLenum type = GL_UNSIGNED_BYTE) { + GL_CHECK_ERROR; + glTexImage2D(target, level, TextureFormat, size.x, size.y, 0, format, type, data); + GL_CHECK_ERROR; + } + + void storage2d(const glm::ivec2 & size, GLint levels = 1) { + glTexStorage2D(TextureType, levels, TextureFormat, size.x, size.y); + } + + void generateMipmap() { + glGenerateMipmap(TextureType); + } + + operator GLuint() { + return texture; + } + + typedef std::shared_ptr > Ptr; +}; + +typedef Texture Texture2d; +typedef Texture Texture2dDepth; +typedef Texture Texture2dMs; +typedef Texture Texture3d; +typedef Texture TextureCubeMap; +typedef Texture2d::Ptr Texture2dPtr; +typedef Texture2dDepth::Ptr Texture2dDepthPtr; +typedef TextureCubeMap::Ptr TextureCubeMapPtr; +typedef Texture2dMs::Ptr Texture2dMsPtr; +typedef Texture2d::Ptr TexturePtr; +} // gl diff --git a/GlVertexArrays.h b/GlVertexArrays.h new file mode 100644 index 0000000..de85122 --- /dev/null +++ b/GlVertexArrays.h @@ -0,0 +1,71 @@ +/************************************************************************************ + + Authors : Bradley Austin Davis + Copyright : Copyright Brad Davis. All Rights reserved. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + ************************************************************************************/ + +#pragma once + +#ifndef GL_ZERO +#error "You must include the gl headers before including this file" +#endif + +namespace gl { + +class VertexArray { + GLuint object; + public: + VertexArray() + : object(0) { + } + ~VertexArray() { + if (object) { + glDeleteVertexArrays(1, &object); + } + } + + void bind() { + if (object == 0) { + glGenVertexArrays(1, &object); + } + glBindVertexArray(object); + } + + static void draw(GLuint vertexCount, GLenum type = GL_TRIANGLES, + GLsizeiptr offset = 0, GLenum indexType = GL_UNSIGNED_INT) { + glDrawElements(type, vertexCount, indexType, (GLvoid*) offset); + } + + void bindAndDraw(GLuint vertexCount, GLenum type = GL_TRIANGLES, + GLsizeiptr offset = 0, GLenum indexType = GL_UNSIGNED_INT) { + bind(); + draw(vertexCount, type, offset, indexType); + unbind(); + } + + static void unbind() { + glBindVertexArray(0); + } + + operator GLuint() { + return object; + } +}; + +typedef std::shared_ptr VertexArrayPtr; + +} // gl + diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..e06d208 --- /dev/null +++ b/LICENSE @@ -0,0 +1,202 @@ +Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "{}" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright {yyyy} {name of copyright owner} + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + diff --git a/README.md b/README.md new file mode 100644 index 0000000..77c1b36 --- /dev/null +++ b/README.md @@ -0,0 +1,4 @@ +gl +== + +C++ header only OpenGL wrappers