allemang.d/toddcox-visualize
1
0
Fork 0
mirror of https://github.com/allemangD/toddcox-visualize.git synced 2025-11-10 12:02:47 -05:00
Code Issues Packages Projects Releases Wiki Activity

class names to PascalCase

Browse Source
This commit is contained in:
David
2020-03-10 15:25:37 -04:00
parent d29fc033df
commit 63692ced17
8 changed files with 71 additions and 71 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
vis/include/cgl/buffer.hpp
View File

@@ -6,31 +6,31 @@
namespace cgl { namespace cgl {
template<class T> template<class T>
class buffer { class Buffer {
GLuint id{}; GLuint id{};
public: public:
buffer() { Buffer() {
glCreateBuffers(1, &id); glCreateBuffers(1, &id);
} }
buffer(const T &data, GLenum usage = GL_STATIC_DRAW) Buffer(const T &data, GLenum usage = GL_STATIC_DRAW)
: buffer() { : Buffer() {
put(data, usage); put(data, usage);
} }
buffer(const std::vector<T> &data, GLenum usage = GL_STATIC_DRAW) Buffer(const std::vector<T> &data, GLenum usage = GL_STATIC_DRAW)
: buffer() { : Buffer() {
put(data, usage); put(data, usage);
} }
buffer(buffer &) = delete; Buffer(Buffer &) = delete;
buffer(buffer &&o) noexcept { Buffer(Buffer &&o) noexcept {
id = std::exchange(o.id, 0); id = std::exchange(o.id, 0);
}; };
~buffer() { ~Buffer() {
glDeleteBuffers(1, &id); glDeleteBuffers(1, &id);
id = 0; id = 0;
} }

18
vis/include/cgl/error.hpp
View File

@@ -5,24 +5,24 @@
#include <glad/glad.h> #include <glad/glad.h>
namespace cgl { namespace cgl {
class gl_error : public std::domain_error { class GlError : public std::domain_error {
public: public:
explicit gl_error(const std::string &arg) : domain_error(arg) {} explicit GlError(const std::string &arg) : domain_error(arg) {}
explicit gl_error(const char *string) : domain_error(string) {} explicit GlError(const char *string) : domain_error(string) {}
}; };
class shader_error : public gl_error { class ShaderError : public GlError {
public: public:
explicit shader_error(const std::string &arg) : gl_error(arg) {} explicit ShaderError(const std::string &arg) : GlError(arg) {}
explicit shader_error(const char *string) : gl_error(string) {} explicit ShaderError(const char *string) : GlError(string) {}
}; };
class program_error : public gl_error { class ProgramError : public GlError {
public: public:
explicit program_error(const std::string &arg) : gl_error(arg) {} explicit ProgramError(const std::string &arg) : GlError(arg) {}
explicit program_error(const char *string) : gl_error(string) {} explicit ProgramError(const char *string) : GlError(string) {}
}; };
} }

12
vis/include/cgl/pipeline.hpp
View File

@@ -49,32 +49,32 @@ namespace cgl{
return std::string(buffer); return std::string(buffer);
} }
pipeline &stage(const shaderprogram<GL_VERTEX_SHADER> &pgm) { pipeline &stage(const ShaderProgram<GL_VERTEX_SHADER> &pgm) {
glUseProgramStages(id, GL_VERTEX_SHADER_BIT, pgm); glUseProgramStages(id, GL_VERTEX_SHADER_BIT, pgm);
return *this; return *this;
} }
pipeline &stage(const shaderprogram<GL_TESS_CONTROL_SHADER> &pgm) { pipeline &stage(const ShaderProgram<GL_TESS_CONTROL_SHADER> &pgm) {
glUseProgramStages(id, GL_TESS_CONTROL_SHADER_BIT, pgm); glUseProgramStages(id, GL_TESS_CONTROL_SHADER_BIT, pgm);
return *this; return *this;
} }
pipeline &stage(const shaderprogram<GL_TESS_EVALUATION_SHADER> &pgm) { pipeline &stage(const ShaderProgram<GL_TESS_EVALUATION_SHADER> &pgm) {
glUseProgramStages(id, GL_TESS_EVALUATION_SHADER_BIT, pgm); glUseProgramStages(id, GL_TESS_EVALUATION_SHADER_BIT, pgm);
return *this; return *this;
} }
pipeline &stage(const shaderprogram<GL_GEOMETRY_SHADER> &pgm) { pipeline &stage(const ShaderProgram<GL_GEOMETRY_SHADER> &pgm) {
glUseProgramStages(id, GL_GEOMETRY_SHADER_BIT, pgm); glUseProgramStages(id, GL_GEOMETRY_SHADER_BIT, pgm);
return *this; return *this;
} }
pipeline &stage(const shaderprogram<GL_FRAGMENT_SHADER> &pgm) { pipeline &stage(const ShaderProgram<GL_FRAGMENT_SHADER> &pgm) {
glUseProgramStages(id, GL_FRAGMENT_SHADER_BIT, pgm); glUseProgramStages(id, GL_FRAGMENT_SHADER_BIT, pgm);
return *this; return *this;
} }
pipeline &stage(const shaderprogram<GL_COMPUTE_SHADER> &pgm) { pipeline &stage(const ShaderProgram<GL_COMPUTE_SHADER> &pgm) {
glUseProgramStages(id, GL_COMPUTE_SHADER_BIT, pgm); glUseProgramStages(id, GL_COMPUTE_SHADER_BIT, pgm);
return *this; return *this;
} }

14
vis/include/cgl/program.hpp
View File

@@ -11,22 +11,22 @@
#include <util.hpp> #include <util.hpp>
namespace cgl { namespace cgl {
class program { class Program {
protected: protected:
GLuint id{}; GLuint id{};
public: public:
program() { Program() {
id = glCreateProgram(); id = glCreateProgram();
} }
program(program &) = delete; Program(Program &) = delete;
program(program &&o) noexcept { Program(Program &&o) noexcept {
id = std::exchange(o.id, 0); id = std::exchange(o.id, 0);
}; };
~program() { ~Program() {
glDeleteProgram(id); glDeleteProgram(id);
} }
@@ -48,12 +48,12 @@ namespace cgl {
} }
template<GLenum mode> template<GLenum mode>
void attach(const shader<mode> &sh) { void attach(const Shader<mode> &sh) {
glAttachShader(id, sh); glAttachShader(id, sh);
} }
template<GLenum mode> template<GLenum mode>
void detach(const shader<mode> &sh) { void detach(const Shader<mode> &sh) {
glDetachShader(id, sh); glDetachShader(id, sh);
} }

30
vis/include/cgl/shader.hpp
View File

@@ -11,33 +11,33 @@
namespace cgl { namespace cgl {
template<GLenum mode> template<GLenum mode>
class shader { class Shader {
protected: protected:
GLuint id{}; GLuint id{};
public: public:
shader() { Shader() {
id = glCreateShader(mode); id = glCreateShader(mode);
} }
shader(const std::string &src) : shader() { Shader(const std::string &src) : Shader() {
set_source(src); set_source(src);
if (!compile()) if (!compile())
throw shader_error(get_info_log()); throw ShaderError(get_info_log());
} }
static shader<mode> file(const std::string &name) { static Shader<mode> file(const std::string &name) {
return shader<mode>(utilReadFile(name)); return Shader<mode>(utilReadFile(name));
} }
shader(shader &) = delete; Shader(Shader &) = delete;
shader(shader &&o) noexcept { Shader(Shader &&o) noexcept {
id = std::exchange(o.id, 0); id = std::exchange(o.id, 0);
}; };
~shader() { ~Shader() {
glDeleteShader(id); glDeleteShader(id);
} }
@@ -70,11 +70,11 @@ namespace cgl {
}; };
namespace sh { namespace sh {
using vert = shader<GL_VERTEX_SHADER>; using vert = Shader<GL_VERTEX_SHADER>;
using tcs = shader<GL_TESS_CONTROL_SHADER>; using tcs = Shader<GL_TESS_CONTROL_SHADER>;
using tes = shader<GL_TESS_EVALUATION_SHADER>; using tes = Shader<GL_TESS_EVALUATION_SHADER>;
using geom = shader<GL_GEOMETRY_SHADER>; using geom = Shader<GL_GEOMETRY_SHADER>;
using frag = shader<GL_FRAGMENT_SHADER>; using frag = Shader<GL_FRAGMENT_SHADER>;
using comp = shader<GL_COMPUTE_SHADER>; using comp = Shader<GL_COMPUTE_SHADER>;
} }
} }

26
vis/include/cgl/shaderprogram.hpp
View File

@@ -13,34 +13,34 @@
namespace cgl{ namespace cgl{
template<GLenum mode> template<GLenum mode>
class shaderprogram : public program { class ShaderProgram : public Program {
public: public:
shaderprogram() : program() { ShaderProgram() : Program() {
glProgramParameteri(id, GL_PROGRAM_SEPARABLE, GL_TRUE); glProgramParameteri(id, GL_PROGRAM_SEPARABLE, GL_TRUE);
} }
shaderprogram(const std::string &src) : shaderprogram() { ShaderProgram(const std::string &src) : ShaderProgram() {
shader<mode> sh(src); Shader<mode> sh(src);
attach(sh); attach(sh);
if (!link()) if (!link())
throw shader_error(get_info_log()); throw ShaderError(get_info_log());
detach(sh); detach(sh);
} }
static shaderprogram<mode> file(const std::string &name) { static ShaderProgram<mode> file(const std::string &name) {
return shaderprogram<mode>(utilReadFile(name)); return ShaderProgram<mode>(utilReadFile(name));
} }
}; };
namespace pgm { namespace pgm {
using vert = shaderprogram<GL_VERTEX_SHADER>; using vert = ShaderProgram<GL_VERTEX_SHADER>;
using tcs = shaderprogram<GL_TESS_CONTROL_SHADER>; using tcs = ShaderProgram<GL_TESS_CONTROL_SHADER>;
using tes = shaderprogram<GL_TESS_EVALUATION_SHADER>; using tes = ShaderProgram<GL_TESS_EVALUATION_SHADER>;
using geom = shaderprogram<GL_GEOMETRY_SHADER>; using geom = ShaderProgram<GL_GEOMETRY_SHADER>;
using frag = shaderprogram<GL_FRAGMENT_SHADER>; using frag = ShaderProgram<GL_FRAGMENT_SHADER>;
using comp = shaderprogram<GL_COMPUTE_SHADER>; using comp = ShaderProgram<GL_COMPUTE_SHADER>;
} }
} }

14
vis/include/cgl/vertexarray.hpp
View File

@@ -10,21 +10,21 @@
#include <cgl/buffer.hpp> #include <cgl/buffer.hpp>
namespace cgl { namespace cgl {
class vertexarray { class VertexArray {
GLuint id{}; GLuint id{};
public: public:
vertexarray() { VertexArray() {
glCreateVertexArrays(1, &id); glCreateVertexArrays(1, &id);
} }
vertexarray(vertexarray &) = delete; VertexArray(VertexArray &) = delete;
vertexarray(vertexarray &&o) noexcept { VertexArray(VertexArray &&o) noexcept {
id = std::exchange(o.id, 0); id = std::exchange(o.id, 0);
} }
~vertexarray() { ~VertexArray() {
glDeleteVertexArrays(1, &id); glDeleteVertexArrays(1, &id);
id = 0; id = 0;
} }
@@ -42,7 +42,7 @@ namespace cgl {
template<class T> template<class T>
void pointer( void pointer(
GLuint index, GLuint index,
const buffer<T> &buf, const Buffer<T> &buf,
unsigned size, unsigned size,
GLenum type, GLenum type,
bool normalized = false, bool normalized = false,
@@ -59,7 +59,7 @@ namespace cgl {
template<class T> template<class T>
void ipointer( void ipointer(
GLuint index, GLuint index,
const buffer<T> &buf, const Buffer<T> &buf,
unsigned size, unsigned size,
GLenum type, GLenum type,
unsigned stride = 0 unsigned stride = 0

10
vis/src/main.cpp
View File

@@ -33,9 +33,9 @@ struct Matrices {
template<unsigned N, class V> template<unsigned N, class V>
struct Drawable { struct Drawable {
GLenum mode{}; GLenum mode{};
cgl::vertexarray vao{}; cgl::VertexArray vao{};
cgl::buffer<Primitive<N>> ibo{}; cgl::Buffer<Primitive<N>> ibo{};
cgl::buffer<V> vbo{}; cgl::Buffer<V> vbo{};
Drawable(GLenum mode) : mode(mode), vao(), ibo(), vbo() {} Drawable(GLenum mode) : mode(mode), vao(), ibo(), vbo() {}
@@ -179,10 +179,10 @@ void run(GLFWwindow *window) {
slices.vao.ipointer(0, slices.ibo, 4, GL_UNSIGNED_INT); slices.vao.ipointer(0, slices.ibo, 4, GL_UNSIGNED_INT);
slices.vao.pointer(1, slices.vbo, 3, GL_FLOAT); slices.vao.pointer(1, slices.vbo, 3, GL_FLOAT);
auto vbo = cgl::buffer<glm::vec4>(points(group)); auto vbo = cgl::Buffer<glm::vec4>(points(group));
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, vbo); glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, vbo);
auto ubo = cgl::buffer<Matrices>(); auto ubo = cgl::Buffer<Matrices>();
glBindBufferBase(GL_UNIFORM_BUFFER, 1, ubo); glBindBufferBase(GL_UNIFORM_BUFFER, 1, ubo);
while (!glfwWindowShouldClose(window)) { while (!glfwWindowShouldClose(window)) {