glbuffers.h Example File

graphicsview/boxes/glbuffers.h
/**************************************************************************** ** ** Copyright (C) 2016 The Qt Company Ltd. ** Contact: https://www.qt.io/licensing/ ** ** This file is part of the demonstration applications of the Qt Toolkit. ** ** $QT_BEGIN_LICENSE:BSD$ ** Commercial License Usage ** Licensees holding valid commercial Qt licenses may use this file in ** accordance with the commercial license agreement provided with the ** Software or, alternatively, in accordance with the terms contained in ** a written agreement between you and The Qt Company. For licensing terms ** and conditions see https://www.qt.io/terms-conditions. For further ** information use the contact form at https://www.qt.io/contact-us. ** ** BSD License Usage ** Alternatively, you may use this file under the terms of the BSD license ** as follows: ** ** "Redistribution and use in source and binary forms, with or without ** modification, are permitted provided that the following conditions are ** met: ** * Redistributions of source code must retain the above copyright ** notice, this list of conditions and the following disclaimer. ** * Redistributions in binary form must reproduce the above copyright ** notice, this list of conditions and the following disclaimer in ** the documentation and/or other materials provided with the ** distribution. ** * Neither the name of The Qt Company Ltd nor the names of its ** contributors may be used to endorse or promote products derived ** from this software without specific prior written permission. ** ** ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT ** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE ** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." ** ** $QT_END_LICENSE$ ** ****************************************************************************/
#ifndef GLBUFFERS_H #define GLBUFFERS_H //#include <GL/glew.h> #include "glextensions.h" #include <QtWidgets> #include <QtOpenGL> #define BUFFER_OFFSET(i) ((char*)0 + (i)) #define SIZE_OF_MEMBER(cls, member) sizeof(static_cast<cls *>(0)->member) #define GLBUFFERS_ASSERT_OPENGL(prefix, assertion, returnStatement) \ if (m_failed || !(assertion)) { \ if (!m_failed) qCritical(prefix ": The necessary OpenGL functions are not available."); \ m_failed = true; \ returnStatement; \ } void qgluPerspective(GLdouble fovy, GLdouble aspect, GLdouble zNear, GLdouble zFar); class QMatrix4x4; class GLTexture { public: GLTexture(); virtual ~GLTexture(); virtual void bind() = 0; virtual void unbind() = 0; virtual bool failed() const {return m_failed;} protected: GLuint m_texture; bool m_failed; }; class GLFrameBufferObject { public: friend class GLRenderTargetCube; // friend class GLRenderTarget2D; GLFrameBufferObject(int width, int height); virtual ~GLFrameBufferObject(); bool isComplete(); virtual bool failed() const {return m_failed;} protected: void setAsRenderTarget(bool state = true); GLuint m_fbo; GLuint m_depthBuffer; int m_width, m_height; bool m_failed; }; class GLTexture2D : public GLTexture { public: GLTexture2D(int width, int height); explicit GLTexture2D(const QString& fileName, int width = 0, int height = 0); void load(int width, int height, QRgb *data); void bind() override; void unbind() override; }; class GLTexture3D : public GLTexture { public: GLTexture3D(int width, int height, int depth); // TODO: Implement function below //GLTexture3D(const QString& fileName, int width = 0, int height = 0); void load(int width, int height, int depth, QRgb *data); void bind() override; void unbind() override; }; class GLTextureCube : public GLTexture { public: GLTextureCube(int size); explicit GLTextureCube(const QStringList& fileNames, int size = 0); void load(int size, int face, QRgb *data); void bind() override; void unbind() override; }; // TODO: Define and implement class below //class GLRenderTarget2D : public GLTexture2D class GLRenderTargetCube : public GLTextureCube { public: GLRenderTargetCube(int size); // begin rendering to one of the cube's faces. 0 <= face < 6 void begin(int face); // end rendering void end(); bool failed() const override { return m_failed || m_fbo.failed(); } static void getViewMatrix(QMatrix4x4& mat, int face); static void getProjectionMatrix(QMatrix4x4& mat, float nearZ, float farZ); private: GLFrameBufferObject m_fbo; }; struct VertexDescription { enum { Null = 0, // Terminates a VertexDescription array Position, TexCoord, Normal, Color, }; int field; // Position, TexCoord, Normal, Color int type; // GL_FLOAT, GL_UNSIGNED_BYTE int count; // number of elements int offset; // field's offset into vertex struct int index; // 0 (unused at the moment) }; // Implementation of interleaved buffers. // 'T' is a struct which must include a null-terminated static array // 'VertexDescription* description'. // Example: /* struct Vertex { GLfloat position[3]; GLfloat texCoord[2]; GLfloat normal[3]; GLbyte color[4]; static VertexDescription description[]; }; VertexDescription Vertex::description[] = { {VertexDescription::Position, GL_FLOAT, SIZE_OF_MEMBER(Vertex, position) / sizeof(GLfloat), offsetof(Vertex, position), 0}, {VertexDescription::TexCoord, GL_FLOAT, SIZE_OF_MEMBER(Vertex, texCoord) / sizeof(GLfloat), offsetof(Vertex, texCoord), 0}, {VertexDescription::Normal, GL_FLOAT, SIZE_OF_MEMBER(Vertex, normal) / sizeof(GLfloat), offsetof(Vertex, normal), 0}, {VertexDescription::Color, GL_BYTE, SIZE_OF_MEMBER(Vertex, color) / sizeof(GLbyte), offsetof(Vertex, color), 0}, {VertexDescription::Null, 0, 0, 0, 0}, }; */ template<class T> class GLVertexBuffer { public: GLVertexBuffer(int length, const T *data = 0, int mode = GL_STATIC_DRAW) : m_length(0) , m_mode(mode) , m_buffer(0) , m_failed(false) { GLBUFFERS_ASSERT_OPENGL("GLVertexBuffer::GLVertexBuffer", glGenBuffers && glBindBuffer && glBufferData, return) glGenBuffers(1, &m_buffer); glBindBuffer(GL_ARRAY_BUFFER, m_buffer); glBufferData(GL_ARRAY_BUFFER, (m_length = length) * sizeof(T), data, mode); } ~GLVertexBuffer() { GLBUFFERS_ASSERT_OPENGL("GLVertexBuffer::~GLVertexBuffer", glDeleteBuffers, return) glDeleteBuffers(1, &m_buffer); } void bind() { GLBUFFERS_ASSERT_OPENGL("GLVertexBuffer::bind", glBindBuffer, return) glBindBuffer(GL_ARRAY_BUFFER, m_buffer); for (VertexDescription *desc = T::description; desc->field != VertexDescription::Null; ++desc) { switch (desc->field) { case VertexDescription::Position: glVertexPointer(desc->count, desc->type, sizeof(T), BUFFER_OFFSET(desc->offset)); glEnableClientState(GL_VERTEX_ARRAY); break; case VertexDescription::TexCoord: glTexCoordPointer(desc->count, desc->type, sizeof(T), BUFFER_OFFSET(desc->offset)); glEnableClientState(GL_TEXTURE_COORD_ARRAY); break; case VertexDescription::Normal: glNormalPointer(desc->type, sizeof(T), BUFFER_OFFSET(desc->offset)); glEnableClientState(GL_NORMAL_ARRAY); break; case VertexDescription::Color: glColorPointer(desc->count, desc->type, sizeof(T), BUFFER_OFFSET(desc->offset)); glEnableClientState(GL_COLOR_ARRAY); break; default: break; } } } void unbind() { GLBUFFERS_ASSERT_OPENGL("GLVertexBuffer::unbind", glBindBuffer, return) glBindBuffer(GL_ARRAY_BUFFER, 0); for (VertexDescription *desc = T::description; desc->field != VertexDescription::Null; ++desc) { switch (desc->field) { case VertexDescription::Position: glDisableClientState(GL_VERTEX_ARRAY); break; case VertexDescription::TexCoord: glDisableClientState(GL_TEXTURE_COORD_ARRAY); break; case VertexDescription::Normal: glDisableClientState(GL_NORMAL_ARRAY); break; case VertexDescription::Color: glDisableClientState(GL_COLOR_ARRAY); break; default: break; } } } int length() const {return m_length;} T *lock() { GLBUFFERS_ASSERT_OPENGL("GLVertexBuffer::lock", glBindBuffer && glMapBuffer, return 0) glBindBuffer(GL_ARRAY_BUFFER, m_buffer); //glBufferData(GL_ARRAY_BUFFER, m_length, NULL, m_mode); GLvoid* buffer = glMapBuffer(GL_ARRAY_BUFFER, GL_READ_WRITE); m_failed = (buffer == 0); return reinterpret_cast<T *>(buffer); } void unlock() { GLBUFFERS_ASSERT_OPENGL("GLVertexBuffer::unlock", glBindBuffer && glUnmapBuffer, return) glBindBuffer(GL_ARRAY_BUFFER, m_buffer); glUnmapBuffer(GL_ARRAY_BUFFER); } bool failed() { return m_failed; } private: int m_length, m_mode; GLuint m_buffer; bool m_failed; }; template<class T> class GLIndexBuffer { public: GLIndexBuffer(int length, const T *data = 0, int mode = GL_STATIC_DRAW) : m_length(0) , m_mode(mode) , m_buffer(0) , m_failed(false) { GLBUFFERS_ASSERT_OPENGL("GLIndexBuffer::GLIndexBuffer", glGenBuffers && glBindBuffer && glBufferData, return) glGenBuffers(1, &m_buffer); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_buffer); glBufferData(GL_ELEMENT_ARRAY_BUFFER, (m_length = length) * sizeof(T), data, mode); } ~GLIndexBuffer() { GLBUFFERS_ASSERT_OPENGL("GLIndexBuffer::~GLIndexBuffer", glDeleteBuffers, return) glDeleteBuffers(1, &m_buffer); } void bind() { GLBUFFERS_ASSERT_OPENGL("GLIndexBuffer::bind", glBindBuffer, return) glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_buffer); } void unbind() { GLBUFFERS_ASSERT_OPENGL("GLIndexBuffer::unbind", glBindBuffer, return) glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); } int length() const {return m_length;} T *lock() { GLBUFFERS_ASSERT_OPENGL("GLIndexBuffer::lock", glBindBuffer && glMapBuffer, return 0) glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_buffer); GLvoid* buffer = glMapBuffer(GL_ELEMENT_ARRAY_BUFFER, GL_READ_WRITE); m_failed = (buffer == 0); return reinterpret_cast<T *>(buffer); } void unlock() { GLBUFFERS_ASSERT_OPENGL("GLIndexBuffer::unlock", glBindBuffer && glUnmapBuffer, return) glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_buffer); glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER); } bool failed() { return m_failed; } private: int m_length, m_mode; GLuint m_buffer; bool m_failed; }; #endif