NBGraphics restructure
This commit is contained in:
NaifBanana
@@ -0,0 +1,320 @@
|
||||
#pragma once
|
||||
#ifndef _NB_BUFFER
|
||||
#define _NB_BUFFER
|
||||
|
||||
#include "GLLoad.hpp"
|
||||
|
||||
#include <exception>
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include "NBCore/Errors.hpp"
|
||||
|
||||
namespace nb {
|
||||
|
||||
typedef std::vector<unsigned char> RawVec;
|
||||
|
||||
static uint8_t GLSLTypeSize(GLenum type) {
|
||||
switch(type) {
|
||||
case GL_SHORT:
|
||||
case GL_UNSIGNED_SHORT:
|
||||
case GL_HALF_FLOAT:
|
||||
return 2;
|
||||
break;
|
||||
case GL_INT:
|
||||
case GL_UNSIGNED_INT:
|
||||
case GL_FLOAT:
|
||||
return 4;
|
||||
break;
|
||||
case GL_DOUBLE:
|
||||
return 8;
|
||||
break;
|
||||
default:
|
||||
return 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
struct VertexAttributePointer {
|
||||
GLuint buffer = 0;
|
||||
int32_t offset = 0;
|
||||
GLsizei stride = -1;
|
||||
GLuint divisor = 0;
|
||||
};
|
||||
|
||||
struct VertexAttribute {
|
||||
GLint GLSLSize;
|
||||
GLenum GLSLType;
|
||||
GLboolean GLSLNormalization;
|
||||
VertexAttributePointer ptr;
|
||||
};
|
||||
|
||||
static bool isIndexInVertexAttribute(int i, const VertexAttribute& va) {
|
||||
if ((i -= va.ptr.offset) < 0) { return false; }
|
||||
return (i%va.ptr.stride) < GLSLTypeSize(va.GLSLType) * va.GLSLSize;
|
||||
}
|
||||
|
||||
typedef std::vector<VertexAttribute> VertexAttributeList;
|
||||
|
||||
template<typename T>
|
||||
RawVec vectorToRaw(const std::vector<T>& vec) {
|
||||
unsigned int num_bytes = vec.size() * sizeof(T);
|
||||
RawVec ret(num_bytes);
|
||||
memcpy(ret.data(), vec.data(), num_bytes);
|
||||
return ret;
|
||||
}
|
||||
|
||||
template<typename T, typename S>
|
||||
RawVec concatVectorsToRaw(const std::vector<T>& vec1, const std::vector<S>& vec2) {
|
||||
RawVec vec1_raw = vectorToRaw<T>(vec1);
|
||||
RawVec vec2_raw = vectorToRaw<S>(vec2);
|
||||
unsigned int vec1_raw_size = vec1_raw.size();
|
||||
unsigned int vec2_raw_size = vec2_raw.size();
|
||||
RawVec ret(vec1_raw_size + vec2_raw_size);
|
||||
memcpy(ret.data(), vec1_raw.data(), vec1_raw_size);
|
||||
memcpy(ret.data() + vec1_raw_size, vec2_raw.data(), vec2_raw_size);
|
||||
return ret;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
std::vector<T> rawToVector(const RawVec& vec) {
|
||||
if (vec.size() % sizeof(T) != 0) {
|
||||
throw std::runtime_error("Data size does not align to std::vector<" + std::string(typeid(T).name()) + ">.");
|
||||
}
|
||||
unsigned int num_elmts = vec.size() / sizeof(T);
|
||||
std::vector<T> ret(num_elmts);
|
||||
memcpy(ret.data(), vec.data(), vec.size());
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
class BufferError : public std::runtime_error {
|
||||
public:
|
||||
const bool error;
|
||||
BufferError(const std::string& msg, const std::string& file="", int line=-1)
|
||||
: std::runtime_error(NB::formatDebugString(msg, file, line)), error(true) {}
|
||||
BufferError(bool isError=true) : std::runtime_error(""), error(isError) {}
|
||||
};
|
||||
|
||||
|
||||
template <typename ObjectType>
|
||||
class OpenGLObject {
|
||||
public:
|
||||
~OpenGLObject() { remove(); }
|
||||
|
||||
virtual void bind() const = 0;
|
||||
virtual void unbind() const = 0;
|
||||
virtual bool isInitialized() const = 0;
|
||||
GLuint id() const { return _id; }
|
||||
|
||||
protected:
|
||||
OpenGLObject() = default;
|
||||
OpenGLObject(const OpenGLObject& rhs) = delete;
|
||||
OpenGLObject& operator=(const OpenGLObject& rhs) = delete;
|
||||
|
||||
virtual void remove() const = 0;
|
||||
|
||||
GLuint _id;
|
||||
};
|
||||
|
||||
template <typename BufferType>
|
||||
class Buffer : OpenGLObject<Buffer<BufferType>> {
|
||||
public:
|
||||
using Base = OpenGLObject<Buffer>;
|
||||
using Base::Base;
|
||||
using BufferType::BufferType;
|
||||
using BufferType::GLTarget;
|
||||
|
||||
void bind() const { glBindBuffer(GLTarget, _id); }
|
||||
void unbind() const { glBindBuffer(GLTarget, 0); }
|
||||
|
||||
protected:
|
||||
using Base::_id;
|
||||
|
||||
};
|
||||
|
||||
/*
|
||||
class Buffer : public OpenGLObject {
|
||||
public:
|
||||
Buffer(
|
||||
GLenum buffer_type,
|
||||
GLenum usage=GL_STATIC_DRAW
|
||||
) : _type(buffer_type), _usage(usage) {
|
||||
glGenBuffers(1, &_id);
|
||||
}
|
||||
Buffer(
|
||||
const RawVec& init_data,
|
||||
GLenum buffer_type,
|
||||
GLenum usage=GL_STATIC_DRAW
|
||||
) : _type{buffer_type}, _usage{usage} { data(init_data); }
|
||||
Buffer(
|
||||
unsigned int size,
|
||||
GLenum buffer_type,
|
||||
GLenum usage=GL_STATIC_DRAW
|
||||
) : Buffer(RawVec(size), buffer_type, usage) {}
|
||||
|
||||
Buffer(Buffer&& rhs) { *this = std::move(rhs); }
|
||||
Buffer& operator=(Buffer&& rhs) {
|
||||
remove();
|
||||
_usage = rhs._usage;
|
||||
_id = rhs._id;
|
||||
rhs._id = 0;
|
||||
return *this;
|
||||
}
|
||||
|
||||
GLenum usage() const { return _usage; }
|
||||
unsigned int id() const { return _id; }
|
||||
GLuint size() const { return _size; }
|
||||
bool isInitialized() const override { return _id && glIsBuffer(_id) && bool(_size); }
|
||||
RawVec data() const {
|
||||
RawVec ret(_size);
|
||||
bind();
|
||||
glGetBufferSubData(_type, 0, _size, ret.data());
|
||||
return ret;
|
||||
}
|
||||
void bind() const override { glBindBuffer(_type, _id); }
|
||||
void unbind() const override { glBindBuffer(_type, 0); }
|
||||
|
||||
GLenum usage(GLenum usage) {
|
||||
_usage=usage;
|
||||
data(data());
|
||||
return _usage;
|
||||
}
|
||||
void data(const RawVec& set_data) {
|
||||
if (!glfwGetCurrentContext()) {
|
||||
THROW_BUFFER_ERROR("No OpenGL context.");
|
||||
}
|
||||
bind();
|
||||
glBufferData(_type, set_data.size(), set_data.data(), _usage);
|
||||
_size = set_data.size();
|
||||
}
|
||||
void data(const RawVec& newData, unsigned int offset) {
|
||||
if (newData.size()+offset > _size) {
|
||||
THROW_BUFFER_ERROR("Attempting to overflow buffer of capacity " + std::to_string(_size) + ".");
|
||||
}
|
||||
bind();
|
||||
glBufferSubData(_type, offset, newData.size(), newData.data());
|
||||
}
|
||||
void data(void* src, unsigned int offset, unsigned int size) {
|
||||
if (size+offset > _size) {
|
||||
THROW_BUFFER_ERROR("Attempting to overflow buffer of capacity " + std::to_string(_size) + ".");
|
||||
}
|
||||
bind();
|
||||
glBufferSubData(_type, offset, size, src);
|
||||
}
|
||||
|
||||
protected:
|
||||
virtual void remove() const override {
|
||||
unbind();
|
||||
if (_id) { glDeleteBuffers(1, &_id); }
|
||||
}
|
||||
|
||||
using OpenGLObject::_id;
|
||||
GLenum _type;
|
||||
GLenum _usage;
|
||||
unsigned int _size = 0;
|
||||
};
|
||||
|
||||
|
||||
class Texture : public OpenGLObject {
|
||||
public:
|
||||
Texture(GLenum tar=GL_TEXTURE_2D) : _target(tar) { glGenTextures(1, &_id); }
|
||||
|
||||
Texture(Texture&& rhs) { *this=std::move(rhs); }
|
||||
Texture& operator=(Texture&& rhs) {
|
||||
_target = rhs._target;
|
||||
_id = rhs._id;
|
||||
rhs._id = 0;
|
||||
return *this;
|
||||
}
|
||||
|
||||
void bind() const override { glBindTexture(_target, _id); }
|
||||
void unbind() const override { glBindTexture(_target, 0); }
|
||||
bool isInitialized() const override { return _id && glIsTexture(_id); }
|
||||
|
||||
protected:
|
||||
using OpenGLObject::_id;
|
||||
GLenum _target;
|
||||
};
|
||||
|
||||
class Framebuffer : public OpenGLObject {
|
||||
public:
|
||||
|
||||
Framebuffer(GLenum tar=GL_FRAMEBUFFER) : _target(tar) { glGenFramebuffers(1, &_id); }
|
||||
|
||||
Framebuffer(Framebuffer&& rhs) { *this=std::move(rhs); }
|
||||
Framebuffer& operator=(Framebuffer&& rhs) {
|
||||
remove();
|
||||
_target = rhs._target;
|
||||
_id = rhs._id;
|
||||
rhs._id = 0;
|
||||
return *this;
|
||||
}
|
||||
|
||||
void bind() const override { glBindFramebuffer(_target, _id); }
|
||||
void unbind() const override { glBindFramebuffer(_target, 0); }
|
||||
bool isInitialized() const override { return _id && glIsFramebuffer(_id); }
|
||||
GLenum status() const {
|
||||
bind();
|
||||
return glCheckFramebufferStatus(_target);
|
||||
}
|
||||
|
||||
|
||||
protected:
|
||||
virtual void remove() const override {
|
||||
unbind();
|
||||
if (_id) { glDeleteFramebuffers(1, &_id); }
|
||||
}
|
||||
using OpenGLObject::_id;
|
||||
GLenum _target;
|
||||
};
|
||||
|
||||
class Renderbuffer : public OpenGLObject {
|
||||
public:
|
||||
Renderbuffer(unsigned int x, unsigned int y, GLenum format=GL_RGBA32F, unsigned int multi=0) : Renderbuffer() {
|
||||
storage(x, y, format, multi);
|
||||
}
|
||||
Renderbuffer() { glGenRenderbuffers(1, &_id); }
|
||||
|
||||
|
||||
Renderbuffer(Renderbuffer&& rhs) { *this = std::move(rhs); }
|
||||
Renderbuffer& operator=(Renderbuffer&& rhs) {
|
||||
_format = rhs._format;
|
||||
_id = rhs._id;
|
||||
rhs._id = 0;
|
||||
return *this;
|
||||
}
|
||||
|
||||
virtual void bind() const override { glBindRenderbuffer(GL_RENDERBUFFER, _id); }
|
||||
virtual void unbind() const override { glBindRenderbuffer(GL_RENDERBUFFER, _id); }
|
||||
virtual bool isInitialized() const override { return _id && glIsRenderbuffer(_id); }
|
||||
|
||||
void storage(unsigned int x, unsigned int y, GLenum format=GL_RGBA32F, unsigned int multi=0) {
|
||||
_sizex = x;
|
||||
_sizey = y;
|
||||
_format = format;
|
||||
_multisample = multi;
|
||||
bind();
|
||||
glRenderbufferStorageMultisample(GL_RENDERBUFFER, _multisample, _format, _sizex, _sizey);
|
||||
}
|
||||
|
||||
|
||||
protected:
|
||||
virtual void remove() const override {
|
||||
unbind();
|
||||
if (_id) { glDeleteRenderbuffers(1, &_id); }
|
||||
}
|
||||
|
||||
using OpenGLObject::_id;
|
||||
GLenum _format;
|
||||
unsigned int _sizex{0};
|
||||
unsigned int _sizey{0};
|
||||
unsigned int _multisample{0};
|
||||
|
||||
};
|
||||
|
||||
*/
|
||||
|
||||
} // namespace NB
|
||||
#endif // _NB_BUFFER
|
||||
@@ -0,0 +1,18 @@
|
||||
include_directories(./.)
|
||||
include_directories(./..)
|
||||
|
||||
find_package(OpenGL)
|
||||
add_subdirectory(${GLFW_PATH} ${GLFW_PATH}/build)
|
||||
|
||||
include_directories(${GLFW_PATH}/include ${GLAD_PATH}/include)
|
||||
|
||||
set(GLFW_BUILD_DOCS OFF CACHE BOOL "" FORCE)
|
||||
set(GLFW_BUILD_TESTS OFF CACHE BOOL "" FORCE)
|
||||
set(GLFW_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
|
||||
|
||||
add_library(NBGraphics
|
||||
./src/Window.cpp
|
||||
./src/Buffers.cpp
|
||||
${GLAD_PATH}/src/glad.c
|
||||
)
|
||||
target_link_libraries(NBGraphics glfw3)
|
||||
@@ -0,0 +1,151 @@
|
||||
#pragma once
|
||||
#ifndef _NB_CAMERA
|
||||
#define _NB_CAMERA
|
||||
|
||||
#include <GLLoad.h>
|
||||
#include <glm/glm.hpp>
|
||||
#include <glm/gtc/matrix_inverse.hpp>
|
||||
#include <glm/gtc/matrix_transform.hpp>
|
||||
#include <glm/gtc/type_ptr.hpp>
|
||||
|
||||
namespace NB {
|
||||
|
||||
class Camera {
|
||||
public:
|
||||
typedef glm::vec3 Vec3;
|
||||
typedef glm::mat4 Mat4;
|
||||
|
||||
enum CameraTypeEnum : unsigned char {
|
||||
None,
|
||||
Orthographic,
|
||||
Perspective
|
||||
};
|
||||
|
||||
const CameraTypeEnum CameraType = CameraTypeEnum::None;
|
||||
|
||||
static Vec3 normCross(const Vec3&, const Vec3&);
|
||||
static Vec3 transformVec(const Mat4&, const Vec3&);
|
||||
|
||||
Camera(
|
||||
const Vec3& pos=Vec3(0.0f, 0.0f, -1.0f),
|
||||
const Vec3& tar=Vec3(0.0f, 0.0f, 0.0f),
|
||||
const Vec3& up =Vec3(0.0f, 1.0f, 0.0f)
|
||||
);
|
||||
|
||||
|
||||
Vec3 getPos() const;
|
||||
Vec3 getTarget() const;
|
||||
Vec3 getDirection() const;
|
||||
Vec3 getWorldUp() const;
|
||||
Vec3 getUp() const;
|
||||
Vec3 getRight() const;
|
||||
Mat4 getViewMatrix() const;
|
||||
Mat4 getProjectionMatrix() const;
|
||||
Mat4 getFlattenedMatrices() const;
|
||||
bool isUpLocked() const;
|
||||
|
||||
void setProjection(const Mat4&);
|
||||
void setPos(const Vec3&);
|
||||
void setTarget(const Vec3&);
|
||||
void setDirection(const Vec3&);
|
||||
void setWorldUp(const Vec3&);
|
||||
void lockToWorldUp(bool lock);
|
||||
void resetUp();
|
||||
void addPos(const Vec3&);
|
||||
void panPos(const Vec3&);
|
||||
void panPosRelative(const Vec3&);
|
||||
void addTarget(const Vec3&);
|
||||
void roll(float);
|
||||
void pitch(float);
|
||||
void yaw(float);
|
||||
|
||||
protected:
|
||||
Vec3 _pos;
|
||||
Vec3 _tar;
|
||||
Vec3 _dir;
|
||||
Vec3 _world_up;
|
||||
Vec3 _up;
|
||||
Vec3 _right;
|
||||
Mat4 _view;
|
||||
Mat4 _proj;
|
||||
bool _lock_world_up = true;
|
||||
|
||||
void _calcLook();
|
||||
|
||||
};
|
||||
|
||||
class OrthographicCamera : public Camera {
|
||||
public:
|
||||
const CameraTypeEnum CameraType = CameraTypeEnum::Orthographic;
|
||||
|
||||
OrthographicCamera(
|
||||
const Vec3& pos=Vec3(0.0f, 0.0f, -1.0f),
|
||||
const Vec3& tar=Vec3(0.0f, 0.0f, 0.0f),
|
||||
const Vec3& up =Vec3(0.0f, 1.0f, 0.0f),
|
||||
float left = -1.0f,
|
||||
float right = 1.0f,
|
||||
float bottom = -1.0f,
|
||||
float top = 1.0f,
|
||||
float near = 0.001f,
|
||||
float far = 1.0f
|
||||
);
|
||||
|
||||
float getLeftPlane() const;
|
||||
float getRightPlane() const;
|
||||
float getBottomPlane() const;
|
||||
float getTopPlane() const;
|
||||
float getNearPlane() const;
|
||||
float getFarPlane() const;
|
||||
|
||||
void setLeftPlane(float);
|
||||
void setRightPlane(float);
|
||||
void setBottomPlane(float);
|
||||
void setTopPlane(float);
|
||||
void setNearPlane(float);
|
||||
void setFarPlane(float);
|
||||
void setOrthographicProjection(float left=-1.0, float right=1.0, float bottom=-1.0, float top=1.0, float near=.001, float far=1.0);
|
||||
void setViewingVolume(float width, float height, float depth);
|
||||
|
||||
protected:
|
||||
float _leftPlane, _rightPlane, _topPlane, _bottomPlane, _nearPlane, _farPlane;
|
||||
|
||||
void _calcView();
|
||||
using Camera::setProjection;
|
||||
|
||||
};
|
||||
|
||||
class PerspectiveCamera : public Camera {
|
||||
public:
|
||||
const CameraTypeEnum CameraType = CameraTypeEnum::Perspective;
|
||||
|
||||
PerspectiveCamera(
|
||||
const Vec3& pos=Vec3(0.0f, 0.0f, -1.0f),
|
||||
const Vec3& tar=Vec3(0.0f, 0.0f, 0.0f),
|
||||
const Vec3& up =Vec3(0.0f, 1.0f, 0.0f),
|
||||
float fov = 45.0f,
|
||||
float aspectRatio = 1.0f,
|
||||
float near = 0.001f,
|
||||
float far = 1.0f
|
||||
);
|
||||
|
||||
float getFOV() const;
|
||||
float getAspectRatio() const;
|
||||
float getNearPlane() const;
|
||||
float getFarPlane() const;
|
||||
|
||||
void setFOV(float);
|
||||
void setAspectRatio(float);
|
||||
void setNearPlane(float);
|
||||
void setFarPlane(float);
|
||||
void setPerspectiveProjection(float fov=45, float aspectRatio=1.0f, float near=0.001f, float far=1.0f);
|
||||
|
||||
protected:
|
||||
float _fov, _ratio, _nearPlane, _farPlane;
|
||||
|
||||
void _calcView();
|
||||
using Camera::setProjection;
|
||||
|
||||
};
|
||||
|
||||
}
|
||||
#endif // _NB_CAMERA
|
||||
@@ -0,0 +1,84 @@
|
||||
#pragma once
|
||||
#ifndef _NB_DRAW
|
||||
#define _NB_DRAW
|
||||
|
||||
#include <GLLoad.h>
|
||||
|
||||
#include <exception>
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include "Buffers.h"
|
||||
#include "Shader.h"
|
||||
#include "VAOManager.hpp"
|
||||
|
||||
#define THROW_DRAW_ERROR(msg) throw DrawError(msg, __FILE__, __LINE__);
|
||||
|
||||
namespace NB{
|
||||
|
||||
class DrawError : public std::runtime_error {
|
||||
public:
|
||||
DrawError(const std::string&, const std::string& file="", int line=-1);
|
||||
};
|
||||
|
||||
uint8_t VerticesFromPrimitives(GLenum, unsigned int num_prims=1);
|
||||
|
||||
uint8_t PrimitivesFromVertices(GLenum, unsigned int);
|
||||
|
||||
void copyVertexAttribute(const VertexAttribute&, VertexAttribute&);
|
||||
|
||||
class DrawBuffer {
|
||||
public:
|
||||
typedef std::shared_ptr<Buffer> BufferManagerPointer;
|
||||
DrawBuffer(VertexAttributeList, GLenum prim_type=GL_TRIANGLES);
|
||||
//DrawBuffer(std::initializer_list<VertexAttribute>, std::initializer_list<VertexAttributePointer>);
|
||||
|
||||
unsigned int vertSize() const;
|
||||
const std::shared_ptr<ShaderProgram> shader() const;
|
||||
unsigned int elementBufferID() const;
|
||||
unsigned int vertexBufferID() const;
|
||||
virtual void draw() const;
|
||||
RawVec vertAttrData(unsigned int);
|
||||
|
||||
VertexAttributeList changeVertLayout(unsigned int, VertexAttributePointer);
|
||||
RawVec vertAttrData(unsigned int, const RawVec&);
|
||||
virtual void elementData(const std::vector<unsigned int>&);
|
||||
virtual void elementData(unsigned int);
|
||||
virtual void elementData(const std::vector<unsigned int>&, unsigned int offset);
|
||||
virtual void vertexData(const RawVec&);
|
||||
virtual void vertexData(unsigned int num_verts);
|
||||
virtual void vertexData(const RawVec&, unsigned int offset);
|
||||
|
||||
BufferManagerPointer _vert_data;
|
||||
BufferManagerPointer _elmt_data;
|
||||
VAOManager _VAO;
|
||||
const GLenum _gl_primitive_type=0;
|
||||
virtual VertexAttributeList defaultVAO(VertexAttributeList);
|
||||
|
||||
unsigned int _num_verts, _num_prims;
|
||||
protected:
|
||||
};
|
||||
|
||||
class DrawInstanceBuffer : public DrawBuffer {
|
||||
public:
|
||||
DrawInstanceBuffer(VertexAttributeList, VertexAttributeList, GLenum primt_type=GL_TRIANGLES);
|
||||
|
||||
unsigned int instSize() const;
|
||||
unsigned int instanceBufferID() const;
|
||||
virtual void draw() const override;
|
||||
|
||||
VertexAttributeList changeInstanceLayout(unsigned int, VertexAttributePointer);
|
||||
virtual void instanceData(const RawVec&);
|
||||
virtual void instanceData(unsigned int);
|
||||
virtual void instanceData(const RawVec&, unsigned int offset);
|
||||
|
||||
BufferManagerPointer _inst_data;
|
||||
virtual VertexAttributeList defaultVAO(VertexAttributeList);
|
||||
unsigned int _num_inst;
|
||||
|
||||
protected:
|
||||
};
|
||||
|
||||
}
|
||||
#endif
|
||||
@@ -0,0 +1,35 @@
|
||||
#pragma once
|
||||
#ifndef _NB_OPENGL_LOADER
|
||||
#define _NB_OPENGL_LOADER
|
||||
|
||||
#include <glad/glad.h>
|
||||
#include <GLFW/glfw3.h>
|
||||
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
|
||||
namespace NB {
|
||||
|
||||
static unsigned int __NB_GL_DEBUG_ERROR_CODE__;
|
||||
|
||||
static std::string formatDebugString(const std::string& msg, const std::string& file="", int line=-1) {
|
||||
std::string ret = "";
|
||||
if (file != "") {
|
||||
ret += "In file " + file;
|
||||
if (line >= 0) {
|
||||
ret += " at line " + std::to_string(line);
|
||||
}
|
||||
ret += ":\n\t";
|
||||
}
|
||||
return ret + msg;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#define NB_GL_DEBUG_THROW(cmd, when) while(NB::__NB_GL_DEBUG_ERROR_CODE__=glGetError()){\
|
||||
std::cout << "[GL ERROR]: " << NB::__NB_GL_DEBUG_ERROR_CODE__;\
|
||||
std::cout << " " << when << " " << cmd << "\n";\
|
||||
}
|
||||
#define NB_GL_DEBUG(cmd) NB_GL_DEBUG_THROW(#cmd, "before"); cmd; NB_GL_DEBUG_THROW(#cmd, "after");
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,75 @@
|
||||
#pragma once
|
||||
#ifndef _NB_VAO_MANAGER
|
||||
#define _NB_VAO_MANAGER
|
||||
|
||||
#include <GLLoad.h>
|
||||
|
||||
#include <exception>
|
||||
#include <memory>
|
||||
#include <vector>
|
||||
|
||||
#include "Buffers.h"
|
||||
|
||||
#define THROW_VAO_ERROR(msg) throw VAOError(msg, __FILE__, __LINE__);
|
||||
|
||||
namespace NB {
|
||||
|
||||
class VAOError : public std::runtime_error {
|
||||
public:
|
||||
const bool error;
|
||||
VAOError(const std::string& msg, const std::string& file="", int line=-1)
|
||||
: std::runtime_error(NB::formatDebugString(msg, file, line)), error(true) {}
|
||||
VAOError(bool isError=true) : std::runtime_error(""), error(isError) {}
|
||||
};
|
||||
|
||||
class VAOManager : public OpenGLObject {
|
||||
public:
|
||||
typedef std::shared_ptr<Buffer> BufferManagerPointer;
|
||||
//typedef BufferManager BufferManagerPointer;
|
||||
|
||||
VAOManager();
|
||||
VAOManager(
|
||||
std::vector<BufferManagerPointer>,
|
||||
BufferManagerPointer elmt_buf = nullptr,
|
||||
const VertexAttributeList& vert_attrs = {}
|
||||
);
|
||||
VAOManager(
|
||||
BufferManagerPointer vert_bufs,
|
||||
BufferManagerPointer elmt_buf = nullptr,
|
||||
const VertexAttributeList& vert_attrs = {}
|
||||
) : VAOManager(std::vector<BufferManagerPointer>(1, vert_bufs), elmt_buf, vert_attrs) {}
|
||||
|
||||
VAOManager(VAOManager&& rhs);
|
||||
VAOManager& operator=(VAOManager&& rhs);
|
||||
|
||||
VertexAttributeList getLayout() const;
|
||||
GLuint id() const;
|
||||
unsigned int vertSize(GLuint) const;
|
||||
std::vector<BufferManagerPointer> getVertexBuffers() const;
|
||||
bool isInitialized() const override;
|
||||
RawVec attributeData(unsigned int);
|
||||
|
||||
RawVec attributeData(unsigned int, const RawVec&);
|
||||
void bind() const;
|
||||
void unbind() const;
|
||||
void addVBO(BufferManagerPointer);
|
||||
void changeEBO(BufferManagerPointer);
|
||||
VertexAttributeList addVertexAttributes(const VertexAttributeList&);
|
||||
VertexAttributeList addVertexAttributes(VertexAttribute);
|
||||
VertexAttributeList generate();
|
||||
VertexAttributeList generate(VertexAttributeList);
|
||||
VertexAttributeList changeLayout(unsigned int, VertexAttributePointer);
|
||||
|
||||
VAOError checkValid(const VertexAttributeList&);
|
||||
|
||||
private:
|
||||
void remove() const override;
|
||||
|
||||
using OpenGLObject::_id;
|
||||
std::map<GLuint, BufferManagerPointer> _vert_buffers;
|
||||
BufferManagerPointer _elmt_buffer = nullptr;
|
||||
VertexAttributeList _vert_attrs;
|
||||
};
|
||||
|
||||
} // namespace NB
|
||||
#endif // _NB_VAO_MANAGER
|
||||
@@ -0,0 +1,69 @@
|
||||
#pragma once
|
||||
#ifndef _NB_WINDOW
|
||||
#define _NB_WINDOW
|
||||
|
||||
#include "GLLoad.hpp"
|
||||
|
||||
#include <atomic>
|
||||
#include <array>
|
||||
#include <iostream>
|
||||
#include <map>
|
||||
#include <stdexcept>
|
||||
#include <string>
|
||||
|
||||
namespace NB {
|
||||
|
||||
class GLError : public std::runtime_error {
|
||||
public:
|
||||
GLError(const std::string&);
|
||||
};
|
||||
|
||||
class WindowError : public std::runtime_error {
|
||||
public:
|
||||
WindowError(const std::string&);
|
||||
};
|
||||
|
||||
class Window {
|
||||
public:
|
||||
static bool StrictInitialization;
|
||||
|
||||
static int getGLFWHint(int);
|
||||
static int setGLFWHint(int, int);
|
||||
static Window* getCurrent();
|
||||
|
||||
Window(const std::array<uint16_t, 2>, const char*, GLFWmonitor* initMonitor=NULL, GLFWwindow* initWindow=NULL);
|
||||
Window(const uint16_t, const uint16_t, const char*, GLFWmonitor* initMonitor=NULL, GLFWwindow* initWindow=NULL);
|
||||
~Window();
|
||||
|
||||
int getWindowHint(int) const;
|
||||
GLFWwindow* getWindow() const;
|
||||
std::array<uint16_t, 2> getSize() const;
|
||||
float getAspectRatio() const;
|
||||
std::string getName() const;
|
||||
|
||||
int init();
|
||||
int setWindowHint(int, int);
|
||||
void setCurrent();
|
||||
void resize(const std::array<uint16_t, 2>);
|
||||
void resize(const uint16_t x, const uint16_t y);
|
||||
|
||||
protected:
|
||||
static std::map<GLFWwindow*, Window*> WindowContexts;
|
||||
static std::map<int, int> GLFWHints;
|
||||
static Window* _current;
|
||||
static bool _glfw_init;
|
||||
static bool checkKillGLFW();
|
||||
|
||||
std::map<int, int> windowHints;
|
||||
std::array<uint16_t, 2> windowSize;
|
||||
float _aspect_ratio;
|
||||
std::string windowName;
|
||||
GLFWwindow* window;
|
||||
GLFWmonitor* monitor;
|
||||
GLFWwindow* shareWindow;
|
||||
bool _init = false;
|
||||
int gladResponse = -1;
|
||||
};
|
||||
|
||||
};
|
||||
#endif
|
||||
@@ -0,0 +1,193 @@
|
||||
#pragma once
|
||||
#ifndef _NB_SHADER
|
||||
#define _NB_SHADER
|
||||
|
||||
#include <GLLoad.h>
|
||||
|
||||
#include <cctype>
|
||||
#include <cstring>
|
||||
#include <exception>
|
||||
#include <fstream>
|
||||
#include <iostream>
|
||||
#include <map>
|
||||
#include <regex>
|
||||
#include <sstream>
|
||||
#include <string>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
#include <glm/glm.hpp>
|
||||
#include <glm/gtc/matrix_transform.hpp>
|
||||
#include <glm/gtc/type_ptr.hpp>
|
||||
|
||||
// #define _PREPROC_FUNC_PARAMS_ (const ShaderPreprocessor&, ShaderUnit&, unsigned int, const std::string&, std::vector<uint8_t>&)
|
||||
|
||||
namespace NB {
|
||||
|
||||
class ShaderPreprocessorError : public std::runtime_error {
|
||||
public:
|
||||
enum Codes : unsigned char {
|
||||
NONE,
|
||||
FILE_NOT_FOUND,
|
||||
BUILTIN_NOT_FOUND,
|
||||
CUSTOM,
|
||||
UNDEFINED
|
||||
};
|
||||
|
||||
const Codes code;
|
||||
|
||||
ShaderPreprocessorError(const std::string&, const std::string& file="", int line=-1);
|
||||
ShaderPreprocessorError(Codes, const std::string& arg="", const std::string& file="", int line=-1);
|
||||
|
||||
protected:
|
||||
static std::string errorCodeParser(Codes, const std::string& arg="");
|
||||
};
|
||||
|
||||
class ShaderError : public std::runtime_error {
|
||||
public:
|
||||
ShaderError(const std::string&, const char* shad=nullptr, const std::string& file="", int line=-1);
|
||||
|
||||
protected:
|
||||
std::string formatString(const std::string&, const char* shad=nullptr, const std::string& file="", int line=-1);
|
||||
};
|
||||
|
||||
struct File {
|
||||
// typedef std::tuple<std::string, std::string, std::string> FilePath;
|
||||
struct FilePath {
|
||||
std::string dir;
|
||||
std::string basename;
|
||||
std::string ext;
|
||||
};
|
||||
FilePath path;
|
||||
std::stringstream src;
|
||||
std::map<unsigned int, std::shared_ptr<File>> include_map;
|
||||
|
||||
File() {}
|
||||
File(const File& rhs) { *this = rhs; }
|
||||
|
||||
File& operator=(const File& rhs) {
|
||||
path = rhs.path;
|
||||
src.str("");
|
||||
src << rhs.src.rdbuf();
|
||||
include_map = rhs.include_map;
|
||||
return *this;
|
||||
}
|
||||
};
|
||||
|
||||
// File::FilePath get_file_path(std::string);
|
||||
|
||||
class ShaderPreprocessor;
|
||||
|
||||
enum OpenGLProfiles {
|
||||
Core,
|
||||
Compatibility,
|
||||
ES
|
||||
};
|
||||
|
||||
struct ShaderUnit {
|
||||
GLenum type = 0x0;
|
||||
File file;
|
||||
std::string preprocSource;
|
||||
std::map<std::string, std::string> defines;
|
||||
short vMajor=0, vMinor=0;
|
||||
OpenGLProfiles profile = Core;
|
||||
};
|
||||
|
||||
class ShaderPreprocessor;
|
||||
|
||||
class ShaderProgram {
|
||||
friend ShaderPreprocessor;
|
||||
public:
|
||||
ShaderProgram() {}
|
||||
ShaderProgram(const ShaderProgram& rhs) = delete;
|
||||
ShaderProgram(ShaderProgram&& rhs);
|
||||
|
||||
~ShaderProgram();
|
||||
|
||||
ShaderProgram& operator=(const ShaderProgram& rhs) = delete;
|
||||
ShaderProgram& operator=(ShaderProgram&& rhs);
|
||||
|
||||
std::vector<ShaderUnit> getShaders() const;
|
||||
ShaderUnit getShaders(unsigned int) const;
|
||||
void use() const;
|
||||
unsigned int id() const;
|
||||
|
||||
void setBool(const std::string& name, bool value) const;
|
||||
void setInt(const std::string& name, int value) const;
|
||||
void setUnsigned(const std::string& name, int value) const;
|
||||
void setFloat(const std::string& name, float value) const;
|
||||
void setMat4(const std::string& name, glm::mat4& value) const;
|
||||
|
||||
static ShaderProgram CreateShaderProgram(std::vector<ShaderUnit>&);
|
||||
|
||||
private:
|
||||
ShaderProgram(std::vector<ShaderUnit>& shaders) : _shader_units(shaders){}
|
||||
|
||||
std::vector<ShaderUnit> _shader_units;
|
||||
unsigned int _id;
|
||||
};
|
||||
|
||||
class ShaderPreprocessor {
|
||||
public:
|
||||
typedef ShaderPreprocessorError::Codes Codes;
|
||||
|
||||
enum TokenType {
|
||||
TK,
|
||||
DR,
|
||||
WS,
|
||||
NL,
|
||||
LC,
|
||||
BC
|
||||
};
|
||||
static std::string TokenName(const TokenType&);
|
||||
|
||||
std::map<std::string, GLenum> AcceptedExtensions = {
|
||||
{".frag", GL_FRAGMENT_SHADER},
|
||||
{".fs", GL_FRAGMENT_SHADER},
|
||||
{".vert", GL_VERTEX_SHADER},
|
||||
{".vs", GL_VERTEX_SHADER},
|
||||
{".tess", 0x0},
|
||||
{".geom", GL_GEOMETRY_SHADER},
|
||||
{".comp", 0x0},
|
||||
{".shad", 0x0},
|
||||
{".glsl", 0x0}
|
||||
};
|
||||
std::map<std::string, OpenGLProfiles> AcceptedProfiles {
|
||||
{"core", Core},
|
||||
{"compatibility", Compatibility},
|
||||
{"es", ES}
|
||||
};
|
||||
std::vector<std::string> Directories;
|
||||
std::map<std::string, std::string> BuiltIns;
|
||||
|
||||
ShaderPreprocessor();
|
||||
|
||||
|
||||
File load(const std::string, bool builtin_first=false) const;
|
||||
ShaderUnit& preprocess(const std::string&, ShaderUnit&) const;
|
||||
ShaderUnit preprocess(File, GLenum shader_type=0x0) const;
|
||||
ShaderUnit preprocess(const std::string&, GLenum shader_type=0x0) const;
|
||||
ShaderProgram ReloadFromFile(const ShaderProgram& rhs) const;
|
||||
ShaderProgram CreateShaderProgram(std::vector<std::string>) const;
|
||||
|
||||
private:
|
||||
typedef std::pair<TokenType, std::string> Token;
|
||||
typedef std::vector<std::string> StringVec;
|
||||
|
||||
inline bool directive_dispatch(ShaderUnit&, const std::string&) const;
|
||||
inline std::vector<Token> tokenize(const std::string&) const;
|
||||
|
||||
inline bool preprocessor_include(ShaderUnit&, const StringVec&, const std::string&) const;
|
||||
inline bool preprocessor_version(ShaderUnit&, const StringVec&, const std::string&) const;
|
||||
inline bool preprocessor_define(ShaderUnit&, const StringVec&, const std::string&) const;
|
||||
// inline bool preprocessor_uniform(ShaderUnit&, const std::string&, const std::string&) const;
|
||||
|
||||
File loadFromBase(const std::string, const std::string base="") const;
|
||||
File loadFromDirectories(const std::string) const;
|
||||
File loadFromBuiltIn(const std::string) const;
|
||||
File load_BuiltInFirst(const std::string) const;
|
||||
File load_FilesFirst(const std::string) const;
|
||||
};
|
||||
|
||||
}
|
||||
#endif
|
||||
@@ -0,0 +1,5 @@
|
||||
#include "Buffers.hpp"
|
||||
|
||||
namespace nb {
|
||||
|
||||
}
|
||||
@@ -0,0 +1,272 @@
|
||||
#include "Camera.h"
|
||||
namespace NB {
|
||||
|
||||
// Camera class
|
||||
Camera::Camera(const Vec3& pos, const Vec3& tar, const Vec3& up) {
|
||||
_pos = pos;
|
||||
_tar = tar;
|
||||
_world_up = glm::normalize(up);
|
||||
_dir = glm::normalize(_tar-_pos);
|
||||
_right = normCross(_dir, _world_up);
|
||||
_up = normCross(_right, _dir);
|
||||
_proj = glm::ortho(-1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 1.0f);
|
||||
_calcLook();
|
||||
}
|
||||
|
||||
void Camera::_calcLook() {
|
||||
_view = glm::lookAt(_pos, _tar, (_lock_world_up)?_world_up:_up);
|
||||
}
|
||||
|
||||
glm::vec3 Camera::normCross(const Vec3& a, const Vec3& b) {
|
||||
return glm::normalize(glm::cross(a, b));
|
||||
}
|
||||
|
||||
glm::vec3 Camera::transformVec(const Mat4& mat, const Vec3& vec) {
|
||||
return Vec3(mat * glm::vec4(vec, 1.0f));
|
||||
}
|
||||
|
||||
glm::vec3 Camera::getPos() const { return _pos; }
|
||||
|
||||
glm::vec3 Camera::getTarget() const { return _tar; }
|
||||
|
||||
glm::vec3 Camera::getDirection() const { return _dir; }
|
||||
|
||||
glm::vec3 Camera::getWorldUp() const { return _world_up; }
|
||||
|
||||
glm::vec3 Camera::getUp() const { return _up; }
|
||||
|
||||
glm::vec3 Camera::getRight() const { return _right; }
|
||||
|
||||
glm::mat4 Camera::getViewMatrix() const { return _view; }
|
||||
|
||||
glm::mat4 Camera::getProjectionMatrix() const { return _proj; }
|
||||
|
||||
glm::mat4 Camera::getFlattenedMatrices() const { return _proj * _view; }
|
||||
|
||||
bool Camera::isUpLocked() const { return _lock_world_up; }
|
||||
|
||||
void Camera::setProjection(const Mat4& proj) {
|
||||
_proj = proj;
|
||||
}
|
||||
|
||||
void Camera::setPos(const Vec3& pos) {
|
||||
_pos = pos;
|
||||
_calcLook();
|
||||
}
|
||||
|
||||
void Camera::setTarget(const Vec3& tar) {
|
||||
_tar = tar;
|
||||
_dir = glm::normalize(_tar-_pos);
|
||||
_right = normCross(_dir, _world_up);
|
||||
_up = normCross(_right, _dir);
|
||||
_calcLook();
|
||||
}
|
||||
|
||||
void Camera::setDirection(const Vec3& dir) {
|
||||
setTarget(glm::normalize(dir)+_pos);
|
||||
}
|
||||
|
||||
void Camera::setWorldUp(const Vec3& up) {
|
||||
_world_up = up;
|
||||
_right = normCross(_dir, _up);
|
||||
_up = normCross(_right, _dir);
|
||||
_calcLook();
|
||||
}
|
||||
|
||||
void Camera::lockToWorldUp(bool lock) {
|
||||
if (!_lock_world_up && lock) {
|
||||
resetUp();
|
||||
}
|
||||
_lock_world_up = lock;
|
||||
}
|
||||
|
||||
void Camera::resetUp() {
|
||||
_right = normCross(_dir, _world_up);
|
||||
_up = normCross(_right, _dir);
|
||||
_calcLook();
|
||||
}
|
||||
|
||||
void Camera::addPos(const Vec3& add) {
|
||||
_pos += add;
|
||||
_dir = glm::normalize(_tar-_pos);
|
||||
if (_lock_world_up) {
|
||||
_right = normCross(_dir, _world_up);
|
||||
} else {
|
||||
_right = normCross(_dir, _up);
|
||||
_up = normCross(_right, _dir);
|
||||
}
|
||||
_calcLook();
|
||||
}
|
||||
|
||||
void Camera::panPos(const Vec3& add) {
|
||||
_tar += add;
|
||||
addPos(add);
|
||||
}
|
||||
|
||||
void Camera::panPosRelative(const Vec3& add) {
|
||||
panPos(add.x*_right + add.y*((_lock_world_up)?_world_up:_up) + add.z*_dir);
|
||||
}
|
||||
|
||||
void Camera::addTarget(const Vec3& add) {
|
||||
_tar += add;
|
||||
_dir = glm::normalize(_tar-_pos);
|
||||
_right = normCross(_dir, _world_up);
|
||||
_up = normCross(_right, _dir);
|
||||
_calcLook();
|
||||
}
|
||||
|
||||
void Camera::roll(float ang) {
|
||||
if (!_lock_world_up) {
|
||||
Mat4 rot_mat = glm::rotate(Mat4(1.0f), ang, _dir);
|
||||
_right = transformVec(rot_mat, _right);
|
||||
_up = transformVec(rot_mat, _up);
|
||||
_calcLook();
|
||||
}
|
||||
}
|
||||
|
||||
void Camera::pitch(float ang) {
|
||||
Mat4 rot_mat = glm::rotate(Mat4(1.0f), ang, _right);
|
||||
_dir = transformVec(rot_mat, _dir);
|
||||
_up = transformVec(rot_mat, _up);
|
||||
_tar = _pos + _dir;
|
||||
_calcLook();
|
||||
}
|
||||
|
||||
void Camera::yaw(float ang) {
|
||||
Mat4 rot_mat = glm::rotate(Mat4(1.0f), ang, ((_lock_world_up)?_world_up:_up));
|
||||
_dir = transformVec(rot_mat, _dir);
|
||||
_right = transformVec(rot_mat, _right);
|
||||
_up = normCross(_right, _dir);
|
||||
_tar = _pos + _dir;
|
||||
_calcLook();
|
||||
}
|
||||
|
||||
// OrthographicCamera class
|
||||
OrthographicCamera::OrthographicCamera(
|
||||
const Vec3& pos,
|
||||
const Vec3& tar,
|
||||
const Vec3& up,
|
||||
float left,
|
||||
float right,
|
||||
float bottom,
|
||||
float top,
|
||||
float near,
|
||||
float far
|
||||
) : Camera(pos, tar, up), _leftPlane(left), _rightPlane(right), _bottomPlane(bottom), _topPlane(top), _nearPlane(near), _farPlane(far) {
|
||||
_calcView();
|
||||
}
|
||||
|
||||
void OrthographicCamera::_calcView() {
|
||||
setProjection(glm::ortho(_leftPlane, _rightPlane, _bottomPlane, _topPlane, _nearPlane, _farPlane));
|
||||
}
|
||||
|
||||
float OrthographicCamera::getLeftPlane() const { return _leftPlane; }
|
||||
|
||||
float OrthographicCamera::getRightPlane() const { return _rightPlane; }
|
||||
|
||||
float OrthographicCamera::getBottomPlane() const { return _bottomPlane; }
|
||||
|
||||
float OrthographicCamera::getTopPlane() const { return _topPlane; }
|
||||
|
||||
float OrthographicCamera::getNearPlane() const { return _nearPlane; }
|
||||
|
||||
float OrthographicCamera::getFarPlane() const { return _farPlane; }
|
||||
|
||||
void OrthographicCamera::setLeftPlane(float left) {
|
||||
_leftPlane = left;
|
||||
_calcView();
|
||||
}
|
||||
|
||||
void OrthographicCamera::setRightPlane(float right) {
|
||||
_rightPlane = right;
|
||||
_calcView();
|
||||
}
|
||||
|
||||
void OrthographicCamera::setBottomPlane(float bottom) {
|
||||
_bottomPlane = bottom;
|
||||
_calcView();
|
||||
}
|
||||
|
||||
void OrthographicCamera::setTopPlane(float top) {
|
||||
_topPlane = top;
|
||||
_calcView();
|
||||
}
|
||||
|
||||
void OrthographicCamera::setNearPlane(float near) {
|
||||
_nearPlane = near;
|
||||
_calcView();
|
||||
}
|
||||
|
||||
void OrthographicCamera::setFarPlane(float far) {
|
||||
_farPlane = far;
|
||||
_calcView();
|
||||
}
|
||||
|
||||
void OrthographicCamera::setOrthographicProjection(float left, float right, float bottom, float top, float near, float far) {
|
||||
_leftPlane = left;
|
||||
_rightPlane = right;
|
||||
_bottomPlane = bottom;
|
||||
_topPlane = top;
|
||||
_nearPlane = near;
|
||||
_farPlane = far;
|
||||
_calcView();
|
||||
}
|
||||
|
||||
void OrthographicCamera::setViewingVolume(float width, float height, float depth) {
|
||||
setOrthographicProjection(width/-2.0, width/2.0, height/-2.0, height/2.0, 0.01, depth);
|
||||
}
|
||||
|
||||
// PerspectiveCamera class
|
||||
PerspectiveCamera::PerspectiveCamera(
|
||||
const Vec3& pos,
|
||||
const Vec3& tar,
|
||||
const Vec3& up ,
|
||||
float fov,
|
||||
float aspectRatio,
|
||||
float near,
|
||||
float far
|
||||
) : Camera(pos, tar, up), _fov(fov), _ratio(aspectRatio), _nearPlane(near), _farPlane(far) {
|
||||
_calcView();
|
||||
}
|
||||
|
||||
void PerspectiveCamera::_calcView() {
|
||||
setProjection(glm::perspective(glm::radians(_fov), _ratio, _nearPlane, _farPlane));
|
||||
}
|
||||
|
||||
float PerspectiveCamera::getFOV() const { return _fov; }
|
||||
|
||||
float PerspectiveCamera::getAspectRatio() const { return _ratio; }
|
||||
|
||||
float PerspectiveCamera::getNearPlane() const { return _nearPlane; }
|
||||
|
||||
float PerspectiveCamera::getFarPlane() const { return _farPlane; }
|
||||
|
||||
void PerspectiveCamera::setFOV(float fov) {
|
||||
_fov = fov;
|
||||
_calcView();
|
||||
}
|
||||
|
||||
void PerspectiveCamera::setAspectRatio(float aspectRatio) {
|
||||
_ratio = aspectRatio;
|
||||
_calcView();
|
||||
}
|
||||
|
||||
void PerspectiveCamera::setNearPlane(float near) {
|
||||
_nearPlane = near;
|
||||
_calcView();
|
||||
}
|
||||
|
||||
void PerspectiveCamera::setFarPlane(float far) {
|
||||
_farPlane = far;
|
||||
_calcView();
|
||||
}
|
||||
|
||||
void PerspectiveCamera::setPerspectiveProjection(float fov, float aspectRatio, float near, float far) {
|
||||
_fov = fov;
|
||||
_ratio = aspectRatio;
|
||||
_nearPlane = near;
|
||||
_farPlane = far;
|
||||
_calcView();
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,307 @@
|
||||
#include "Draw.h"
|
||||
|
||||
namespace NB{
|
||||
|
||||
DrawError::DrawError(
|
||||
const std::string& msg,
|
||||
const std::string& file,
|
||||
int line) : std::runtime_error(NB::formatDebugString(msg, file, line)) {}
|
||||
|
||||
uint8_t VerticesFromPrimitives(GLenum type, unsigned int num_prims) {
|
||||
switch(type) {
|
||||
case GL_POINTS:
|
||||
return num_prims;
|
||||
case GL_LINES:
|
||||
return num_prims*2;
|
||||
break;
|
||||
case GL_LINE_STRIP:
|
||||
return num_prims+1;
|
||||
break;
|
||||
case GL_LINE_LOOP:
|
||||
return num_prims;
|
||||
break;
|
||||
case GL_TRIANGLES:
|
||||
return num_prims*3;
|
||||
break;
|
||||
case GL_TRIANGLE_STRIP:
|
||||
case GL_TRIANGLE_FAN:
|
||||
return num_prims+2;
|
||||
break;
|
||||
case GL_QUADS:
|
||||
return 4*num_prims;
|
||||
break;
|
||||
case GL_QUAD_STRIP:
|
||||
return 2*num_prims+2;
|
||||
break;
|
||||
default:
|
||||
return num_prims;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
uint8_t PrimitivesFromVertices(GLenum type, unsigned int num_verts) {
|
||||
switch(type) {
|
||||
case GL_POINTS:
|
||||
return num_verts;
|
||||
case GL_LINES:
|
||||
return num_verts/2;
|
||||
break;
|
||||
case GL_LINE_STRIP:
|
||||
return num_verts-1;
|
||||
break;
|
||||
case GL_LINE_LOOP:
|
||||
return num_verts;
|
||||
break;
|
||||
case GL_TRIANGLES:
|
||||
return num_verts/3;
|
||||
break;
|
||||
case GL_TRIANGLE_STRIP:
|
||||
case GL_TRIANGLE_FAN:
|
||||
return num_verts-2;
|
||||
break;
|
||||
case GL_QUADS:
|
||||
return num_verts/4;
|
||||
break;
|
||||
case GL_QUAD_STRIP:
|
||||
return num_verts/2 - 1;
|
||||
break;
|
||||
default:
|
||||
return num_verts;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// DrawBuffer class
|
||||
DrawBuffer::DrawBuffer(VertexAttributeList vas, GLenum prim_type)
|
||||
: _gl_primitive_type(prim_type), _VAO() {
|
||||
_vert_data = std::make_shared<Buffer>(GL_ARRAY_BUFFER);
|
||||
_elmt_data = std::make_shared<Buffer>(GL_ELEMENT_ARRAY_BUFFER);
|
||||
_VAO.addVBO(_vert_data);
|
||||
_VAO.changeEBO(_elmt_data);
|
||||
try {
|
||||
throw _VAO.checkValid(vas);
|
||||
} catch (VAOError vaoe) {
|
||||
if (vaoe.error) {
|
||||
_VAO.addVertexAttributes(DrawBuffer::defaultVAO(vas));
|
||||
} else {
|
||||
_VAO.addVertexAttributes(vas);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
VertexAttributeList DrawBuffer::defaultVAO(VertexAttributeList vert_attrs) {
|
||||
GLuint vert_id = _vert_data->id();
|
||||
unsigned int vert_size = 0;
|
||||
for (const VertexAttribute& va : vert_attrs) {
|
||||
vert_size += va.GLSLSize * GLSLTypeSize(va.GLSLType);
|
||||
}
|
||||
unsigned int curr_byte = 0;
|
||||
for (VertexAttribute& va : vert_attrs) {
|
||||
va.ptr.buffer = vert_id;
|
||||
va.ptr.stride = vert_size;
|
||||
va.ptr.offset = curr_byte;
|
||||
va.ptr.divisor = 0;
|
||||
curr_byte += va.GLSLSize * GLSLTypeSize(va.GLSLType);
|
||||
}
|
||||
return vert_attrs;
|
||||
}
|
||||
|
||||
VertexAttributeList DrawBuffer::changeVertLayout(unsigned int i, VertexAttributePointer vap) {
|
||||
GLuint vert_id = _vert_data->id();
|
||||
vap.buffer = (vap.buffer) ? vap.buffer : vert_id;
|
||||
VertexAttributeList vas = _VAO.getLayout();
|
||||
unsigned int idx = 0;
|
||||
for (const VertexAttribute& va : vas) {
|
||||
if (va.ptr.buffer == vert_id) {
|
||||
if (idx == i) {
|
||||
return _VAO.changeLayout(i, vap);
|
||||
}
|
||||
idx++;
|
||||
}
|
||||
}
|
||||
THROW_DRAW_ERROR("Could not find vertex attribute with index " + std::to_string(i));
|
||||
}
|
||||
|
||||
unsigned int DrawBuffer::vertSize() const { return _VAO.vertSize(_vert_data->id()); }
|
||||
|
||||
void DrawBuffer::draw() const {
|
||||
_VAO.bind();
|
||||
glDrawElements(_gl_primitive_type, _elmt_data->size() / GLSLTypeSize(GL_INT), GL_UNSIGNED_INT, 0);
|
||||
_VAO.unbind();
|
||||
}
|
||||
|
||||
unsigned int DrawBuffer::elementBufferID() const { return _elmt_data->id(); }
|
||||
|
||||
unsigned int DrawBuffer::vertexBufferID() const { return _vert_data->id(); }
|
||||
|
||||
RawVec DrawBuffer::vertAttrData(unsigned int i) {
|
||||
if (!_vert_data->isInitialized()) {
|
||||
throw DrawError("Vertex buffer is not initialized.");
|
||||
}
|
||||
return _VAO.attributeData(i);
|
||||
}
|
||||
|
||||
RawVec DrawBuffer::vertAttrData(unsigned int i, const RawVec& newdata) {
|
||||
if (!(_vert_data->isInitialized())) {
|
||||
VertexAttribute va = _VAO.getLayout()[i];
|
||||
vertexData(newdata.size() / (va.GLSLSize*GLSLTypeSize(va.GLSLType)));
|
||||
std::cout << "From DrawBuffer::vertAttrData(int, RawVec) - vert buf size: " << _vert_data->size() << "\n";
|
||||
}
|
||||
return _VAO.attributeData(i, newdata);
|
||||
}
|
||||
|
||||
void DrawBuffer::elementData(unsigned int num_prims) {
|
||||
elementData(std::vector<unsigned int>(VerticesFromPrimitives(_gl_primitive_type, num_prims)));
|
||||
}
|
||||
|
||||
void DrawBuffer::elementData(const std::vector<unsigned int>& elements) {
|
||||
_num_prims = PrimitivesFromVertices(_gl_primitive_type, elements.size());
|
||||
_elmt_data->data(vectorToRaw(elements));
|
||||
}
|
||||
|
||||
void DrawBuffer::elementData(const std::vector<unsigned int>& elements, unsigned int offset) {
|
||||
_VAO.bind();
|
||||
if (!_elmt_data->isInitialized()) {
|
||||
std::vector<unsigned int> init_elmts(elements);
|
||||
init_elmts.insert(init_elmts.cbegin(), offset, 0);
|
||||
elementData(init_elmts, 0);
|
||||
} else {
|
||||
_elmt_data->data(vectorToRaw(elements), offset);
|
||||
}
|
||||
_VAO.unbind();
|
||||
}
|
||||
|
||||
void DrawBuffer::vertexData(unsigned int num_verts) {
|
||||
vertexData(RawVec(num_verts * vertSize()));
|
||||
}
|
||||
|
||||
void DrawBuffer::vertexData(const RawVec& vert_data) {
|
||||
// Check for uninitialized Vertex Pointers. If so, will fallback to default VAO setup.
|
||||
// Otherwise, set VAO to provided Vertex Atributes.
|
||||
int vert_size = vertSize();
|
||||
if (vert_data.size() % vert_size != 0) {
|
||||
THROW_DRAW_ERROR("Initializing data does not match vertex size of " + std::to_string(vert_size) + ".");
|
||||
}
|
||||
_num_verts = vert_data.size() / vert_size;
|
||||
// TODO: Make it not static draw all the time
|
||||
|
||||
_VAO.bind();
|
||||
_vert_data->data(vert_data);
|
||||
_VAO.unbind();
|
||||
}
|
||||
|
||||
void DrawBuffer::vertexData(const RawVec& data, unsigned int offset) {
|
||||
_VAO.bind();
|
||||
if (!_vert_data->isInitialized()) {
|
||||
RawVec load_data(offset);
|
||||
load_data.insert(load_data.end(), data.begin(), data.end());
|
||||
vertexData(load_data, 0);
|
||||
} else {
|
||||
try{
|
||||
_vert_data->data(data, offset);
|
||||
} catch(BufferError& e) {
|
||||
THROW_DRAW_ERROR("NB::BufferError in loadVBO:\n\t" + std::string(e.what()));
|
||||
}
|
||||
}
|
||||
_VAO.unbind();
|
||||
}
|
||||
|
||||
// DrawInstanceBufferClass
|
||||
DrawInstanceBuffer::DrawInstanceBuffer(
|
||||
VertexAttributeList vert_vas,
|
||||
VertexAttributeList inst_vas,
|
||||
GLenum prim_type
|
||||
): DrawBuffer(vert_vas, prim_type) {
|
||||
_inst_data = std::make_shared<Buffer>(GL_ARRAY_BUFFER);
|
||||
_VAO.addVBO(_inst_data);
|
||||
try {
|
||||
throw _VAO.checkValid(inst_vas);
|
||||
} catch (VAOError vaoe) {
|
||||
if (vaoe.error) {
|
||||
_VAO.addVertexAttributes(defaultVAO(inst_vas));
|
||||
} else {
|
||||
_VAO.addVertexAttributes(inst_vas);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
unsigned int DrawInstanceBuffer::instSize() const { return _VAO.vertSize(_inst_data->id()); }
|
||||
|
||||
unsigned int DrawInstanceBuffer::instanceBufferID() const { return _inst_data->id(); }
|
||||
|
||||
void DrawInstanceBuffer::instanceData(unsigned int num_inst) {
|
||||
instanceData(RawVec(instSize() * num_inst));
|
||||
}
|
||||
|
||||
void DrawInstanceBuffer::instanceData(const RawVec& inst_data) {
|
||||
int inst_size = instSize();
|
||||
if (inst_data.size() % inst_size != 0) {
|
||||
THROW_DRAW_ERROR("Initializing data does not match instance size of " + std::to_string(inst_size) + ".");
|
||||
}
|
||||
_num_inst = inst_data.size() / inst_size;
|
||||
|
||||
_VAO.bind();
|
||||
_inst_data->data(inst_data);
|
||||
_VAO.unbind();
|
||||
}
|
||||
|
||||
void DrawInstanceBuffer::instanceData(const RawVec& data, unsigned int offset) {
|
||||
_VAO.bind();
|
||||
if (!_inst_data->isInitialized()) {
|
||||
RawVec load_data(offset);
|
||||
load_data.insert(load_data.end(), data.begin(), data.end());
|
||||
instanceData(load_data, 0);
|
||||
} else {
|
||||
try{
|
||||
_inst_data->data(data, offset);
|
||||
} catch(BufferError& e) {
|
||||
THROW_DRAW_ERROR("NB::BufferError in loadIBO:\n\t" + std::string(e.what()));
|
||||
}
|
||||
}
|
||||
_VAO.unbind();
|
||||
}
|
||||
|
||||
VertexAttributeList DrawInstanceBuffer::defaultVAO(VertexAttributeList inst_attrs) {
|
||||
GLuint inst_id = _inst_data->id();
|
||||
unsigned int vert_size = 0;
|
||||
for (const VertexAttribute& va : inst_attrs) {
|
||||
vert_size += va.GLSLSize * GLSLTypeSize(va.GLSLType);
|
||||
}
|
||||
unsigned int curr_byte = 0;
|
||||
for (VertexAttribute& va : inst_attrs) {
|
||||
va.ptr.buffer = inst_id;
|
||||
va.ptr.stride = vert_size;
|
||||
va.ptr.offset = curr_byte;
|
||||
va.ptr.divisor = 1;
|
||||
curr_byte += va.GLSLSize * GLSLTypeSize(va.GLSLType);
|
||||
}
|
||||
return inst_attrs;
|
||||
}
|
||||
|
||||
VertexAttributeList DrawInstanceBuffer::changeInstanceLayout(unsigned int i, VertexAttributePointer vap) {
|
||||
GLuint inst_id = _inst_data->id();
|
||||
vap.buffer = (vap.buffer) ? vap.buffer : inst_id;
|
||||
VertexAttributeList vas = _VAO.getLayout();
|
||||
unsigned int vas_size = vas.size();
|
||||
unsigned int inst_idx = 0;
|
||||
unsigned int idx = 0;
|
||||
for (const VertexAttribute& va : vas) {
|
||||
if (va.ptr.buffer == inst_id) {
|
||||
if (inst_idx == i) {
|
||||
return _VAO.changeLayout(idx, vap);
|
||||
}
|
||||
inst_idx++;
|
||||
}
|
||||
idx++;
|
||||
}
|
||||
THROW_DRAW_ERROR("Could not find instance attribute with index " + std::to_string(i));
|
||||
}
|
||||
|
||||
void DrawInstanceBuffer::draw() const {
|
||||
_VAO.bind();
|
||||
glDrawElementsInstanced(_gl_primitive_type, _elmt_data->size() / GLSLTypeSize(GL_UNSIGNED_INT), GL_UNSIGNED_INT, (void*)_elmt_data->id(), _num_inst);
|
||||
_VAO.unbind();
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,225 @@
|
||||
#include "VAOManager.hpp"
|
||||
|
||||
namespace NB {
|
||||
|
||||
using BufferManagerPointer = std::shared_ptr<Buffer>;
|
||||
|
||||
VAOManager::VAOManager() { glGenVertexArrays(1, &_id); }
|
||||
|
||||
VAOManager::VAOManager(
|
||||
std::vector<BufferManagerPointer> vert_bufs,
|
||||
BufferManagerPointer elmt_buf,
|
||||
const VertexAttributeList& vert_attrs
|
||||
) : VAOManager() {
|
||||
_elmt_buffer = elmt_buf;
|
||||
for (BufferManagerPointer vb : vert_bufs) {
|
||||
_vert_buffers[vb->id()] = vb;
|
||||
}
|
||||
if (vert_attrs.size()!=0) {
|
||||
generate(vert_attrs);
|
||||
}
|
||||
}
|
||||
|
||||
VAOManager::VAOManager(VAOManager&& rhs) { *this = std::move(rhs); }
|
||||
|
||||
VAOManager& VAOManager::operator=(VAOManager&& rhs) {
|
||||
remove();
|
||||
_vert_buffers = rhs._vert_buffers;
|
||||
_elmt_buffer = rhs._elmt_buffer;
|
||||
_vert_attrs = rhs._vert_attrs;
|
||||
return *this;
|
||||
}
|
||||
|
||||
VertexAttributeList VAOManager::getLayout() const { return _vert_attrs; }
|
||||
|
||||
GLuint VAOManager::id() const { return _id; }
|
||||
|
||||
bool VAOManager::isInitialized() const {
|
||||
return _id && glIsVertexArray(_id);
|
||||
}
|
||||
|
||||
void VAOManager::remove() const {
|
||||
bind();
|
||||
for (int i{0}; i < _vert_attrs.size(); ++i) {
|
||||
glDisableVertexAttribArray(i);
|
||||
}
|
||||
unbind();
|
||||
glDisableVertexAttribArray(_id);
|
||||
}
|
||||
|
||||
unsigned int VAOManager::vertSize(GLuint id) const {
|
||||
unsigned int size = 0;
|
||||
for (const VertexAttribute& va : _vert_attrs) {
|
||||
if (va.ptr.buffer == id) {
|
||||
size += va.GLSLSize * GLSLTypeSize(va.GLSLType);
|
||||
}
|
||||
}
|
||||
return size;
|
||||
}
|
||||
|
||||
std::vector<BufferManagerPointer> VAOManager::getVertexBuffers() const {
|
||||
std::vector<BufferManagerPointer> ret;
|
||||
for (const auto& i : _vert_buffers) {
|
||||
ret.emplace_back(i.second);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
RawVec VAOManager::attributeData(unsigned int i) {
|
||||
if (i <= _vert_attrs.size()) {
|
||||
throw std::out_of_range("No vertex attribute exists for specified index");
|
||||
}
|
||||
VertexAttribute attr = _vert_attrs[i];
|
||||
BufferManagerPointer buffer = _vert_buffers[attr.ptr.buffer];
|
||||
RawVec data = buffer->data();
|
||||
unsigned int attr_size = attr.GLSLSize*GLSLTypeSize(attr.GLSLType);
|
||||
RawVec ret((buffer->size()-attr.ptr.offset-attr_size)*attr_size/attr.ptr.stride);
|
||||
int data_size = data.size();
|
||||
for (int i{0}; i < data_size; ++i) {
|
||||
if (isIndexInVertexAttribute(i, attr)) {
|
||||
ret[i] = data[i];
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
RawVec VAOManager::attributeData(unsigned int i, const RawVec& new_data) {
|
||||
if (i >= _vert_attrs.size()) {
|
||||
throw std::out_of_range("No vertex attribute exists for specified index.");
|
||||
}
|
||||
VertexAttribute attr = _vert_attrs[i];
|
||||
BufferManagerPointer buffer = _vert_buffers[attr.ptr.buffer];
|
||||
unsigned int attr_size = attr.GLSLSize*GLSLTypeSize(attr.GLSLType);
|
||||
unsigned int offset = attr.ptr.offset;
|
||||
unsigned int num_verts = buffer->size() / vertSize(buffer->id());
|
||||
if (num_verts*attr_size != new_data.size()) {
|
||||
// WHY HERE????
|
||||
THROW_VAO_ERROR(
|
||||
"Input data size of " + std::to_string(new_data.size())
|
||||
+ " does not match data size for requested vertex attribute of total size " + std::to_string(num_verts*attr_size)
|
||||
+ "."
|
||||
);
|
||||
}
|
||||
uint64_t pos = uint64_t(new_data.data());
|
||||
for (int i{0}; i<num_verts; i++) {
|
||||
buffer->data((void*)(pos+i*attr_size), offset+i*attr.ptr.stride, attr_size);
|
||||
}
|
||||
return RawVec(new_data);
|
||||
}
|
||||
|
||||
void VAOManager::bind() const {
|
||||
glBindVertexArray(_id);
|
||||
if (_elmt_buffer) { _elmt_buffer->bind(); }
|
||||
}
|
||||
|
||||
void VAOManager::unbind() const {
|
||||
glBindVertexArray(0);
|
||||
if (_elmt_buffer) { _elmt_buffer->unbind(); }
|
||||
}
|
||||
|
||||
void VAOManager::addVBO(BufferManagerPointer vert_buf) {
|
||||
GLuint vert_id = vert_buf->id();
|
||||
if (_vert_buffers.find(vert_id) == _vert_buffers.end()) {
|
||||
_vert_buffers[vert_buf->id()] = vert_buf;
|
||||
} else {
|
||||
THROW_VAO_ERROR("Attempting to add identical VBO id of " + std::to_string(vert_id) + ".");
|
||||
}
|
||||
}
|
||||
|
||||
void VAOManager::changeEBO(BufferManagerPointer ebo) {
|
||||
_elmt_buffer = ebo;
|
||||
}
|
||||
|
||||
VertexAttributeList VAOManager::addVertexAttributes(const VertexAttributeList& vert_attrs) {
|
||||
VertexAttributeList curr_vas = _vert_attrs;
|
||||
curr_vas.insert(curr_vas.end(), vert_attrs.begin(), vert_attrs.end());
|
||||
try {
|
||||
throw checkValid(curr_vas);
|
||||
} catch (VAOError vaoe) {
|
||||
if (vaoe.error) {
|
||||
THROW_VAO_ERROR(vaoe.what());
|
||||
}
|
||||
}
|
||||
_vert_attrs = curr_vas;
|
||||
generate();
|
||||
return _vert_attrs;
|
||||
}
|
||||
|
||||
VertexAttributeList VAOManager::addVertexAttributes(VertexAttribute vert_attr) {
|
||||
return addVertexAttributes({vert_attr});
|
||||
}
|
||||
|
||||
VertexAttributeList VAOManager::generate() {
|
||||
bind();
|
||||
unsigned int num_attrs = _vert_attrs.size();
|
||||
VertexAttribute* va;
|
||||
for (int i = 0; i < num_attrs; ++i) {
|
||||
va = &(_vert_attrs[i]);
|
||||
_vert_buffers[va->ptr.buffer]->bind();
|
||||
glVertexAttribPointer(
|
||||
i,
|
||||
va->GLSLSize,
|
||||
va->GLSLType,
|
||||
va->GLSLNormalization,
|
||||
va->ptr.stride,
|
||||
(void*)va->ptr.offset
|
||||
);
|
||||
glVertexAttribDivisor(i, va->ptr.divisor);
|
||||
glEnableVertexAttribArray(i);
|
||||
}
|
||||
if (_elmt_buffer != nullptr) {
|
||||
_elmt_buffer->bind();
|
||||
}
|
||||
unbind();
|
||||
return _vert_attrs;
|
||||
}
|
||||
|
||||
VertexAttributeList VAOManager::generate(VertexAttributeList vert_attrs) {
|
||||
try {
|
||||
throw checkValid(vert_attrs);
|
||||
} catch (VAOError vaoe) {
|
||||
if (vaoe.error) {
|
||||
THROW_VAO_ERROR(vaoe.what());
|
||||
}
|
||||
}
|
||||
_vert_attrs.swap(vert_attrs);
|
||||
return generate();
|
||||
}
|
||||
|
||||
VertexAttributeList VAOManager::changeLayout(unsigned int i, VertexAttributePointer vap) {
|
||||
_vert_attrs[i].ptr = vap;
|
||||
bind();
|
||||
const VertexAttribute* va = &(_vert_attrs[i]);
|
||||
glDisableVertexAttribArray(i);
|
||||
_vert_buffers[va->ptr.buffer]->bind();
|
||||
glVertexAttribPointer(
|
||||
_id,
|
||||
va->GLSLSize,
|
||||
va->GLSLType,
|
||||
va->GLSLNormalization,
|
||||
va->ptr.stride,
|
||||
(void*)va->ptr.offset
|
||||
);
|
||||
glVertexAttribDivisor(i, va->ptr.divisor);
|
||||
glEnableVertexAttribArray(i);
|
||||
unbind();
|
||||
return _vert_attrs;
|
||||
}
|
||||
|
||||
VAOError VAOManager::checkValid(const VertexAttributeList& vert_attrs) {
|
||||
GLuint va_id;
|
||||
unsigned int num_attrs = vert_attrs.size();
|
||||
for (int i = 0; i < num_attrs; ++i) {
|
||||
va_id = vert_attrs[i].ptr.buffer;
|
||||
if (_vert_buffers.find(va_id) == _vert_buffers.cend()) {
|
||||
return VAOError("Attempting to point to unknown VBO of id " + std::to_string(va_id) +
|
||||
" at Vertex Attribute " + std::to_string(i) + ".");
|
||||
}
|
||||
if (vert_attrs[i].ptr.stride<0) {
|
||||
return VAOError("Invalid stride value at Vertex Attribute " + std::to_string(i) + ".");
|
||||
}
|
||||
}
|
||||
return VAOError(false);
|
||||
}
|
||||
|
||||
} // namespace NB
|
||||
@@ -0,0 +1,170 @@
|
||||
#include "Window.hpp"
|
||||
namespace NB {
|
||||
|
||||
std::map<GLFWwindow*, Window*> Window::WindowContexts = {};
|
||||
std::map<int, int> Window::GLFWHints = {};
|
||||
bool Window::StrictInitialization = true;
|
||||
bool Window::_glfw_init = false;
|
||||
Window* Window::_current = nullptr;
|
||||
static std::map<int, int> defailt_window_hints = {
|
||||
{GLFW_CONTEXT_VERSION_MAJOR, 3},
|
||||
{GLFW_CONTEXT_VERSION_MINOR, 1},
|
||||
{GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE}
|
||||
#ifdef _NB_GL_DEBUG_ON
|
||||
, {GLFW_OPENGL_DEBUG_CONTEXT, GL_TRUE}
|
||||
#endif
|
||||
};
|
||||
|
||||
GLError::GLError(const std::string& msg) : std::runtime_error(msg) {}
|
||||
|
||||
WindowError::WindowError(const std::string &msg) : std::runtime_error(msg) {}
|
||||
|
||||
int Window::getGLFWHint(int hint_key) {
|
||||
if (GLFWHints.find(hint_key) == GLFWHints.end()) {
|
||||
return 0;
|
||||
} else {
|
||||
return GLFWHints.at(hint_key);
|
||||
}
|
||||
}
|
||||
|
||||
int Window::setGLFWHint(int hint_key, int hint_val) {
|
||||
if (Window::_glfw_init) {
|
||||
throw GLError("Cannot set GLFW hint after window is initialized.");
|
||||
} else {
|
||||
GLFWHints[hint_key] = hint_val;
|
||||
}
|
||||
return GLFWHints[hint_key];
|
||||
}
|
||||
|
||||
Window* Window::getCurrent() {
|
||||
return _current;
|
||||
}
|
||||
|
||||
bool Window::checkKillGLFW() {
|
||||
if(Window::WindowContexts.size() == 0 && _glfw_init) {
|
||||
glfwTerminate();
|
||||
Window::_glfw_init = false;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
Window::Window(const uint16_t x, const uint16_t y, const char* initName, GLFWmonitor* initMonitor, GLFWwindow* initWindow) {
|
||||
if (!Window::_glfw_init) {
|
||||
for (const auto& hint : Window::GLFWHints) {
|
||||
glfwInitHint(hint.first, hint.second);
|
||||
}
|
||||
int glfwResponse = glfwInit();
|
||||
if (glfwResponse) {
|
||||
Window::_glfw_init = true;
|
||||
} else {
|
||||
if (Window::StrictInitialization) {
|
||||
throw GLError("Failed to load GLFW with glfwInit()="+std::to_string(glfwResponse)+".");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
windowSize = {x, y};
|
||||
_aspect_ratio = float(x)/float(y);
|
||||
windowName = std::string(initName);
|
||||
monitor = initMonitor;
|
||||
shareWindow = initWindow;
|
||||
|
||||
for (const auto& hint: defailt_window_hints) {
|
||||
windowHints[hint.first] = hint.second;
|
||||
}
|
||||
}
|
||||
|
||||
Window::Window(const std::array<uint16_t, 2> initSize, const char* initName, GLFWmonitor* initMonitor, GLFWwindow* initWindow) :
|
||||
Window(initSize[0], initSize[1], initName, initMonitor, initWindow){}
|
||||
|
||||
Window::~Window() {
|
||||
glfwSetWindowShouldClose(window, true);
|
||||
glfwDestroyWindow(window);
|
||||
Window::WindowContexts.erase(window);
|
||||
if (Window::WindowContexts.size()==0) {
|
||||
glfwTerminate();
|
||||
}
|
||||
}
|
||||
|
||||
void Window::setCurrent() {
|
||||
_current = this;
|
||||
glfwMakeContextCurrent(window);
|
||||
}
|
||||
|
||||
int Window::getWindowHint(int hint_key) const {
|
||||
if (windowHints.find(hint_key) == windowHints.end()) {
|
||||
return 0;
|
||||
} else {
|
||||
return windowHints.at(hint_key);
|
||||
}
|
||||
}
|
||||
|
||||
int Window::setWindowHint(int hint_key, int hint_val) {
|
||||
if (_init) {
|
||||
throw WindowError("Cannot set window hint after window is initialized.");
|
||||
} else {
|
||||
windowHints[hint_key] = hint_val;
|
||||
}
|
||||
return windowHints[hint_key];
|
||||
}
|
||||
|
||||
int Window::init() {
|
||||
if (!_glfw_init) {
|
||||
throw GLError("GLFW has not been initialized.");
|
||||
}
|
||||
for (const auto& hint : windowHints) {
|
||||
glfwWindowHint(hint.first, hint.second);
|
||||
}
|
||||
|
||||
window = glfwCreateWindow(windowSize[0], windowSize[1], windowName.c_str(), monitor, shareWindow);
|
||||
if (window == NULL) {
|
||||
Window::WindowContexts.erase(window);
|
||||
if (Window::WindowContexts.size()==0 && Window::_glfw_init) { glfwTerminate(); }
|
||||
if (Window::StrictInitialization) {
|
||||
throw WindowError("Could not create window in glfwCreateWindow().");
|
||||
}
|
||||
}
|
||||
glfwMakeContextCurrent(window);
|
||||
Window::WindowContexts[window] = this;
|
||||
|
||||
gladResponse = gladLoadGLLoader((GLADloadproc)glfwGetProcAddress);
|
||||
if (!gladResponse) {
|
||||
Window::checkKillGLFW();
|
||||
if (Window::StrictInitialization) {
|
||||
throw GLError("Failed to load GLAD with \
|
||||
gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)="+\
|
||||
std::to_string(gladResponse)+"."
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
_init = true;
|
||||
glViewport(0, 0, windowSize[0], windowSize[1]);
|
||||
return gladResponse;
|
||||
}
|
||||
|
||||
GLFWwindow* Window::getWindow() const {
|
||||
return window;
|
||||
}
|
||||
|
||||
float Window::getAspectRatio() const { return _aspect_ratio; }
|
||||
|
||||
std::array<uint16_t, 2> Window::getSize() const {
|
||||
return windowSize;
|
||||
}
|
||||
|
||||
std::string Window::getName() const {
|
||||
return windowName;
|
||||
}
|
||||
|
||||
void Window::resize(const std::array<uint16_t, 2> newSize) {
|
||||
windowSize = newSize;
|
||||
_aspect_ratio = float(newSize[0]) / float(newSize[1]);
|
||||
glViewport(0, 0, windowSize[0], windowSize[1]);
|
||||
glfwSetWindowSize(window, windowSize[0], windowSize[1]);
|
||||
}
|
||||
|
||||
void Window::resize(const uint16_t x, const uint16_t y) { resize({x, y}); }
|
||||
|
||||
};
|
||||
@@ -0,0 +1,742 @@
|
||||
#include "Shader.h"
|
||||
|
||||
// #define _PREPROC_FUNC_PARAM_NAMES_ (const ShaderPreprocessor& proc, ShaderUnit& shad, unsigned int linenum, const std::string& line, std::vector<uint8_t>& params)
|
||||
|
||||
namespace NB{
|
||||
|
||||
File::FilePath get_file_path(std::string name) {
|
||||
const std::vector<char> allowed_special_chars = {
|
||||
'.', '!', '#', '$', '%', '&', '\'', '(', ')', '+', ',', '-', ';', '=', '@', '[', ']', '^', '_', '`', '~'
|
||||
};
|
||||
std::vector<std::string> path = {""};
|
||||
for (const char c : name) {
|
||||
if (c == '/' || c == '\\') {
|
||||
path.push_back("");
|
||||
} else if (std::isalnum(c)) {
|
||||
path.back() += c;
|
||||
} else {
|
||||
bool spec_char_found = false;
|
||||
for (const char sc : allowed_special_chars) {
|
||||
if (c == sc) {
|
||||
path.back() += c;
|
||||
spec_char_found = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!spec_char_found) {
|
||||
throw std::runtime_error("'" + name + "' is not valid filepath.");
|
||||
}
|
||||
}
|
||||
}
|
||||
File::FilePath ret;
|
||||
for (const auto& tk : path) {
|
||||
if (tk == path.back()) {
|
||||
size_t period = tk.find(".");
|
||||
if (period == std::string::npos) {
|
||||
ret.basename = tk;
|
||||
ret.ext = "";
|
||||
} else {
|
||||
ret.basename = tk.substr(0, period);
|
||||
ret.ext = tk.substr(period);
|
||||
}
|
||||
} else {
|
||||
ret.dir += tk + "/";
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
// ShaderPreprocessorError class
|
||||
ShaderPreprocessorError::ShaderPreprocessorError(
|
||||
const std::string& msg,
|
||||
const std::string& file,
|
||||
int line
|
||||
) : code(Codes::UNDEFINED), std::runtime_error(formatDebugString(msg, file, line)) {}
|
||||
|
||||
ShaderPreprocessorError::ShaderPreprocessorError(
|
||||
Codes err_code,
|
||||
const std::string& arg,
|
||||
const std::string& file,
|
||||
int line
|
||||
) : code(err_code), std::runtime_error(formatDebugString(errorCodeParser(err_code, arg), file, line)) {}
|
||||
|
||||
std::string ShaderPreprocessorError::errorCodeParser(Codes err_code, const std::string& arg) {
|
||||
switch(err_code) {
|
||||
case Codes::FILE_NOT_FOUND:
|
||||
return "File '" + arg + "' not found.";
|
||||
case Codes::BUILTIN_NOT_FOUND:
|
||||
return "Built-in '" + arg + "' not found.";
|
||||
case Codes::CUSTOM:
|
||||
case Codes::UNDEFINED:
|
||||
return arg;
|
||||
case Codes::NONE:
|
||||
default:
|
||||
return "";
|
||||
}
|
||||
}
|
||||
|
||||
// ShaderError class
|
||||
ShaderError::ShaderError(
|
||||
const std::string& msg,
|
||||
const char* shad,
|
||||
const std::string& file,
|
||||
int line
|
||||
) : std::runtime_error(formatString(msg, shad, file, line)) {}
|
||||
|
||||
std::string ShaderError::formatString(
|
||||
const std::string& msg,
|
||||
const char* shad,
|
||||
const std::string& file,
|
||||
int line
|
||||
) {
|
||||
std::stringstream ret;
|
||||
if (file != "") {
|
||||
ret << "In file " << file;
|
||||
if (line >= 0) {
|
||||
ret << " at line " << line;
|
||||
}
|
||||
ret << ":\n\t";
|
||||
}
|
||||
ret << msg;
|
||||
if (shad != nullptr) {
|
||||
ret << " with shader error: " << shad;
|
||||
}
|
||||
return ret.str();
|
||||
}
|
||||
|
||||
// ShaderPreprocessor class
|
||||
std::string ShaderPreprocessor::TokenName(const ShaderPreprocessor::TokenType& x) {
|
||||
switch(x) {
|
||||
case TK:
|
||||
return "Token";
|
||||
break;
|
||||
case DR:
|
||||
return "Directive";
|
||||
break;
|
||||
case WS:
|
||||
return "Whitespace";
|
||||
break;
|
||||
case NL:
|
||||
return "NewLine";
|
||||
break;
|
||||
case LC:
|
||||
return "LineComment";
|
||||
break;
|
||||
case BC:
|
||||
return "BlockComment";
|
||||
break;
|
||||
default:
|
||||
return "Unrecognized";
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
ShaderPreprocessor::ShaderPreprocessor() {}
|
||||
|
||||
File ShaderPreprocessor::loadFromBase(const std::string path, const std::string base) const {
|
||||
File ret;
|
||||
std::ifstream filestream;
|
||||
filestream.open(base + path);
|
||||
if (filestream.is_open()) {
|
||||
ret.path = get_file_path(base + path);
|
||||
ret.src << filestream.rdbuf();
|
||||
return ret;
|
||||
}
|
||||
filestream.close();
|
||||
std::string ext;
|
||||
for (const auto& kv : AcceptedExtensions) {
|
||||
ext = kv.first;
|
||||
filestream.open(base + path + ext);
|
||||
if (filestream.is_open()) {
|
||||
ret.path = get_file_path(base + path + ext);
|
||||
ret.src << filestream.rdbuf();
|
||||
return ret;
|
||||
}
|
||||
filestream.close();
|
||||
}
|
||||
throw ShaderPreprocessorError(Codes::FILE_NOT_FOUND, base + path);
|
||||
}
|
||||
|
||||
File ShaderPreprocessor::loadFromDirectories(const std::string name) const {
|
||||
File ret;
|
||||
std::ifstream fstream;
|
||||
for (const std::string& path : Directories) {
|
||||
fstream.open(path + name);
|
||||
if (fstream.is_open()) {
|
||||
ret.path = get_file_path(path + name);
|
||||
ret.src << fstream.rdbuf();
|
||||
return ret;
|
||||
}
|
||||
fstream.close();
|
||||
}
|
||||
throw ShaderPreprocessorError(Codes::FILE_NOT_FOUND, name);
|
||||
}
|
||||
|
||||
File ShaderPreprocessor::load(const std::string path, bool builtin_first) const {
|
||||
if(builtin_first) {
|
||||
return load_BuiltInFirst(path);
|
||||
}
|
||||
return load_FilesFirst(path);
|
||||
}
|
||||
|
||||
File ShaderPreprocessor::loadFromBuiltIn(const std::string name) const {
|
||||
File ret;
|
||||
//std::stringstream ret;
|
||||
decltype(BuiltIns)::const_iterator builtin_it = BuiltIns.find(name);
|
||||
if (builtin_it != BuiltIns.end()) {
|
||||
ret.path = File::FilePath{"builtin:", name, ""};
|
||||
ret.src << builtin_it->second;
|
||||
return ret;
|
||||
}
|
||||
throw ShaderPreprocessorError(Codes::BUILTIN_NOT_FOUND, name);
|
||||
}
|
||||
|
||||
File ShaderPreprocessor::load_FilesFirst(const std::string path) const {
|
||||
try {
|
||||
return loadFromBase(path);
|
||||
} catch (ShaderPreprocessorError e) {
|
||||
if (e.code == Codes::FILE_NOT_FOUND) {
|
||||
try {
|
||||
return loadFromDirectories(path);
|
||||
} catch (ShaderPreprocessorError f) {
|
||||
if (f.code == Codes::FILE_NOT_FOUND) {
|
||||
try {
|
||||
return loadFromBuiltIn(path);
|
||||
} catch(ShaderPreprocessorError g) {
|
||||
if (g.code == Codes::BUILTIN_NOT_FOUND) {
|
||||
throw ShaderPreprocessorError(Codes::FILE_NOT_FOUND, path);
|
||||
} else { throw g; }
|
||||
}
|
||||
} else { throw f; }
|
||||
}
|
||||
} else { throw e; }
|
||||
}
|
||||
}
|
||||
|
||||
File ShaderPreprocessor::load_BuiltInFirst(const std::string path) const {
|
||||
try {
|
||||
return loadFromBuiltIn(path);
|
||||
} catch (ShaderPreprocessorError f) {
|
||||
if (f.code == Codes::BUILTIN_NOT_FOUND) {
|
||||
try {
|
||||
return loadFromDirectories(path);
|
||||
} catch (ShaderPreprocessorError e) {
|
||||
if (e.code == Codes::FILE_NOT_FOUND) {
|
||||
return loadFromBase(path);
|
||||
} else {
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
throw f;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
std::vector<ShaderPreprocessor::Token> ShaderPreprocessor::tokenize(const std::string& code) const {
|
||||
enum State {
|
||||
FSlash,
|
||||
WhiteSpace,
|
||||
LineComment,
|
||||
BlockComment,
|
||||
BlockCommentEndStar,
|
||||
Directive,
|
||||
Token
|
||||
};
|
||||
|
||||
std::vector<ShaderPreprocessor::Token> tks;
|
||||
|
||||
std::string token = "";
|
||||
State state = WhiteSpace;
|
||||
for(char c : code) {
|
||||
if (c==13) {
|
||||
continue;
|
||||
}
|
||||
switch(state) {
|
||||
case WhiteSpace:
|
||||
if (c=='/') {
|
||||
if (token != "") { tks.push_back({WS, token}); }
|
||||
token = c;
|
||||
state = FSlash;
|
||||
} else if (c=='#') {
|
||||
if (token != "") { tks.push_back({WS, token}); }
|
||||
token = c;
|
||||
state = Directive;
|
||||
} else if (c=='\n') {
|
||||
if (token != "") { tks.push_back({WS, token}); }
|
||||
tks.push_back({NL, "\n"});
|
||||
token = "";
|
||||
state = WhiteSpace;
|
||||
} else if (std::isblank(c)) {
|
||||
token += c;
|
||||
} else {
|
||||
if (token != "") { tks.push_back({WS, token}); }
|
||||
token = c;
|
||||
state = Token;
|
||||
}
|
||||
break;
|
||||
case FSlash:
|
||||
if (c=='/') {
|
||||
token += c;
|
||||
state = LineComment;
|
||||
} else if (c=='*') {
|
||||
token += c;
|
||||
state = BlockComment;
|
||||
} else if (c=='\n') {
|
||||
tks.push_back({TK, token});
|
||||
tks.push_back({NL, "\n"});
|
||||
token = "";
|
||||
state = WhiteSpace;
|
||||
} else if (std::isblank(c)) {
|
||||
tks.push_back({TK, token});
|
||||
token = c;
|
||||
}else {
|
||||
token += c;
|
||||
state = Token;
|
||||
}
|
||||
break;
|
||||
case LineComment:
|
||||
if (c=='\n') {
|
||||
tks.push_back({LC, token});
|
||||
tks.push_back({NL, "\n"});
|
||||
token = "";
|
||||
state = WhiteSpace;
|
||||
} else {
|
||||
token += c;
|
||||
}
|
||||
break;
|
||||
case BlockComment:
|
||||
token += c;
|
||||
if (c=='*') {
|
||||
state = BlockCommentEndStar;
|
||||
}
|
||||
break;
|
||||
case BlockCommentEndStar:
|
||||
token += c;
|
||||
if (c=='/') {
|
||||
tks.push_back({BC, token});
|
||||
token = "";
|
||||
state = WhiteSpace;
|
||||
} else {
|
||||
state = BlockComment;
|
||||
}
|
||||
break;
|
||||
case Directive:
|
||||
if (c=='\n') {
|
||||
tks.push_back({DR, token});
|
||||
tks.push_back({NL, "\n"});
|
||||
token = "";
|
||||
state = WhiteSpace;
|
||||
} else if (c=='/') {
|
||||
tks.push_back({DR, token});
|
||||
token = c;
|
||||
state = FSlash;
|
||||
} else {
|
||||
token += c;
|
||||
}
|
||||
break;
|
||||
case Token:
|
||||
if (c=='\n') {
|
||||
tks.push_back({TK, token});
|
||||
tks.push_back({NL, "\n"});
|
||||
token = "";
|
||||
state = WhiteSpace;
|
||||
} else if (std::isblank(c)) {
|
||||
tks.push_back({TK, token});
|
||||
token = c;
|
||||
state = WhiteSpace;
|
||||
} else if (c=='/') {
|
||||
tks.push_back({TK, token});
|
||||
token = c;
|
||||
state = FSlash;
|
||||
}else {
|
||||
token += c;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
switch(state) {
|
||||
case WhiteSpace:
|
||||
if (token != "") { tks.push_back({WS, token}); }
|
||||
case FSlash:
|
||||
tks.push_back({TK, token});
|
||||
break;
|
||||
case LineComment:
|
||||
tks.push_back({LC, token});
|
||||
break;
|
||||
case BlockComment:
|
||||
case BlockCommentEndStar:
|
||||
tks.push_back({BC, token});
|
||||
break;
|
||||
case Directive:
|
||||
tks.push_back({DR, token});
|
||||
break;
|
||||
case Token:
|
||||
tks.push_back({TK, token});
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
return tks;
|
||||
}
|
||||
|
||||
ShaderUnit& ShaderPreprocessor::preprocess(const std::string& code, ShaderUnit& shad) const {
|
||||
typedef ShaderPreprocessor::Token Token;
|
||||
std::vector<Token> tks = tokenize(code);
|
||||
|
||||
for (int i{0}; i < tks.size(); ++i) {
|
||||
switch(tks[i].first) {
|
||||
case DR:
|
||||
directive_dispatch(shad, tks[i].second);
|
||||
break;
|
||||
case TK:
|
||||
case NL:
|
||||
case LC:
|
||||
case BC:
|
||||
case WS:
|
||||
default:
|
||||
shad.preprocSource += tks[i].second;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (shad.vMajor == 0 && shad.vMinor == 0) {
|
||||
shad.vMajor = 1;
|
||||
shad.vMinor = 10;
|
||||
}
|
||||
return shad;
|
||||
}
|
||||
|
||||
ShaderUnit ShaderPreprocessor::preprocess(File file, GLenum shader_type) const {
|
||||
ShaderUnit ret;
|
||||
ret.file = file;
|
||||
if (shader_type) {
|
||||
ret.type = shader_type;
|
||||
} else {
|
||||
decltype(AcceptedExtensions.begin()) find_type = AcceptedExtensions.find(file.path.ext);
|
||||
if (find_type != AcceptedExtensions.end()) {
|
||||
ret.type = find_type->second;
|
||||
}
|
||||
}
|
||||
preprocess(file.src.str(), ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
ShaderUnit ShaderPreprocessor::preprocess(const std::string& code, GLenum shader_type) const {
|
||||
File local;
|
||||
local.path = File::FilePath{"live:", "live", ".shad"};
|
||||
return preprocess(local, shader_type);
|
||||
}
|
||||
|
||||
ShaderProgram ShaderPreprocessor::CreateShaderProgram(std::vector<std::string> shads) const {
|
||||
std::vector<ShaderUnit> _shader_units;
|
||||
for (const auto& name : shads) {
|
||||
_shader_units.push_back(preprocess(load(name)));
|
||||
}
|
||||
return ShaderProgram::CreateShaderProgram(_shader_units);
|
||||
}
|
||||
|
||||
ShaderProgram ShaderPreprocessor::ReloadFromFile(const ShaderProgram& rhs) const {
|
||||
std::vector<std::string> shader_names;
|
||||
shader_names.reserve(rhs._shader_units.size());
|
||||
std::string filename;
|
||||
for (const ShaderUnit& shad : rhs._shader_units) {
|
||||
filename = shad.file.path.dir + shad.file.path.basename + shad.file.path.ext;
|
||||
shader_names.emplace_back(filename);
|
||||
}
|
||||
return CreateShaderProgram(shader_names);
|
||||
}
|
||||
|
||||
bool ShaderPreprocessor::directive_dispatch(ShaderUnit& shad, const std::string& line) const {
|
||||
StringVec dir_tks = {""};
|
||||
for (char c : line) {
|
||||
if (std::isblank(c)) {
|
||||
if (dir_tks.back() != "") {
|
||||
dir_tks.push_back("");
|
||||
}
|
||||
} else {
|
||||
dir_tks.back() += c;
|
||||
}
|
||||
}
|
||||
if (!dir_tks.size()) { return false; }
|
||||
|
||||
if (dir_tks[0][0] != '#') { return false; }
|
||||
|
||||
if (dir_tks[0] == "#define") {
|
||||
return preprocessor_define(shad, dir_tks, line);
|
||||
} else if (dir_tks[0] == "#version") {
|
||||
return preprocessor_version(shad, dir_tks, line);
|
||||
} else if (dir_tks[0] == "#include") {
|
||||
return preprocessor_include(shad, dir_tks, line);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
typedef std::vector<std::string> StringVec;
|
||||
|
||||
bool ShaderPreprocessor::preprocessor_include(
|
||||
ShaderUnit& shad,
|
||||
const StringVec& tokens,
|
||||
const std::string& line
|
||||
) const
|
||||
{
|
||||
try {
|
||||
if (tokens[0] != "#include") { return false; }
|
||||
} catch (std::out_of_range e) {
|
||||
return false;
|
||||
}
|
||||
std::string path = "";
|
||||
for (const auto& tk : tokens) {
|
||||
if (tk != tokens.front()) {
|
||||
path += tk;
|
||||
}
|
||||
}
|
||||
// Add file-inclusion base +
|
||||
// Do path cleanup +
|
||||
// Restructure preprocessing data flow
|
||||
std::string filename = path.substr(1, path.size()-2);
|
||||
try {
|
||||
if (path[0] == '"' && path.back() == '"') {
|
||||
preprocess(load(filename).src.str(), shad);
|
||||
return true;
|
||||
} else if (path[0] == '<' && path.back() == '>') {
|
||||
preprocess(load(filename, true).src.str(), shad);
|
||||
return true;
|
||||
}
|
||||
} catch (ShaderPreprocessorError e) {
|
||||
if (e.code == Codes::FILE_NOT_FOUND) {
|
||||
std::cout << "COULD NOT FIND " << filename << ".\n";
|
||||
} else {
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool ShaderPreprocessor::preprocessor_define(ShaderUnit& shad, const StringVec& tokens, const std::string& line) const {
|
||||
shad.preprocSource += line;
|
||||
try {
|
||||
if (tokens[0] != "#define") { return false; }
|
||||
try {
|
||||
shad.defines[tokens[1]] = tokens[2];
|
||||
} catch (std::length_error& f) {
|
||||
shad.defines[tokens[1]] = "";
|
||||
}
|
||||
return true;
|
||||
} catch (std::out_of_range& e) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
bool ShaderPreprocessor::preprocessor_version(ShaderUnit& shad, const StringVec& tokens, const std::string& line) const {
|
||||
shad.preprocSource += line;
|
||||
std::cout << "Shader version: ";
|
||||
try {
|
||||
if (tokens[0] != "#version") { return false; }
|
||||
if (tokens[1].size() == 3) {
|
||||
short vMajor = tokens[1][0]-'0';
|
||||
short vMinorA = tokens[1][1]-'0';
|
||||
short vMinorB = tokens[1][2]-'0';
|
||||
if (vMajor > 10 || vMinorA > 10 || vMinorB > 10) {
|
||||
return false;
|
||||
}
|
||||
shad.vMajor = vMajor;
|
||||
shad.vMinor = vMinorA*10 + vMinorB;
|
||||
shad.profile = AcceptedProfiles.at(tokens[2]);
|
||||
std::cout << shad.vMajor << "." << shad.vMinor << "\n";
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
} catch (std::out_of_range& e) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* bool ShaderPreprocessor::preprocessor_uniform(
|
||||
ShaderUnit& shad,
|
||||
const std::string& type,
|
||||
const std::string& name
|
||||
) const {
|
||||
std::string type_str = "";
|
||||
unsigned int type_str_len = 0;
|
||||
for (const char& c : type) {
|
||||
if (type_str_len) {
|
||||
if (std::isdigit(c)) {
|
||||
type_str += c;
|
||||
continue;
|
||||
} else if (c=='[') {
|
||||
type_str += '_';
|
||||
}else if (c == ']' || std::isblank(c)){
|
||||
continue;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
} else {
|
||||
if (std::isalnum(c)) {
|
||||
type_str += c;
|
||||
continue;
|
||||
} else if (c == '[') {
|
||||
type_str_len = type_str.length();
|
||||
type_str += '_';
|
||||
continue;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
std::string name_str = "";
|
||||
unsigned int name_str_len = 0;
|
||||
for (const char& c : name) {
|
||||
if (c == ';') {
|
||||
break;
|
||||
}
|
||||
if (name_str_len) {
|
||||
if (std::isdigit(c)) {
|
||||
type_str.insert(type_str_len, 1, c);
|
||||
type_str_len++;
|
||||
continue;
|
||||
} else if (c=='[') {
|
||||
type_str.insert(type_str_len, "_");
|
||||
type_str_len++;
|
||||
continue;
|
||||
}else if (c == ']' || std::isblank(c)){
|
||||
continue;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
} else {
|
||||
if (std::isalnum(c)) {
|
||||
name_str += c;
|
||||
continue;
|
||||
} else if ( c == '[') {
|
||||
name_str_len = name_str.length();
|
||||
type_str.insert(type_str_len, "_");
|
||||
type_str_len++;
|
||||
continue;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
shad.uniforms.push_back(UniformHandle{
|
||||
name_str,
|
||||
type_str,
|
||||
0x0,
|
||||
0x0
|
||||
});
|
||||
return true;
|
||||
} */
|
||||
|
||||
|
||||
// ShaderProgram
|
||||
|
||||
ShaderProgram::ShaderProgram(ShaderProgram&& rhs) {
|
||||
_shader_units = rhs._shader_units;
|
||||
_id = rhs._id;
|
||||
rhs._id = 0;
|
||||
}
|
||||
|
||||
ShaderProgram::~ShaderProgram() {
|
||||
glDeleteProgram(_id);
|
||||
}
|
||||
|
||||
ShaderProgram& ShaderProgram::operator=(ShaderProgram&& rhs) {
|
||||
_shader_units = rhs._shader_units;
|
||||
_id = rhs._id;
|
||||
rhs._id = 0;
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
ShaderProgram ShaderProgram::CreateShaderProgram(std::vector<ShaderUnit>& shaders) {
|
||||
int success;
|
||||
ShaderProgram ret(shaders);
|
||||
char infoLog[512];
|
||||
unsigned int shad_id;
|
||||
std::vector<unsigned int> shad_ids;
|
||||
shad_ids.reserve(shaders.size());
|
||||
for (auto& shad : ret._shader_units) {
|
||||
const char* source = shad.preprocSource.data();
|
||||
shad_id = glCreateShader(shad.type);
|
||||
shad_ids.emplace_back(shad_id);
|
||||
glShaderSource(shad_id, 1, &source, NULL);
|
||||
glCompileShader(shad_id);
|
||||
glGetShaderiv(shad_id, GL_COMPILE_STATUS, &success);
|
||||
if (!success) {
|
||||
glGetShaderInfoLog(shad_id, 512, NULL, infoLog);
|
||||
File::FilePath& fp = shad.file.path;
|
||||
std::string filename = fp.dir + fp.basename + fp.ext;
|
||||
// std::cout << "Could not compile '" + filename + "': " << infoLog << "\n";
|
||||
// return *ret;
|
||||
throw ShaderError("Could not compile '" + filename + "'.", infoLog);
|
||||
}
|
||||
}
|
||||
|
||||
ret._id = glCreateProgram();
|
||||
for(auto& id : shad_ids) {
|
||||
glAttachShader(ret._id, id);
|
||||
}
|
||||
glLinkProgram(ret._id);
|
||||
glGetProgramiv(ret._id, GL_LINK_STATUS, &success);
|
||||
if (!success) {
|
||||
glGetProgramInfoLog(ret._id, 512, NULL, infoLog);
|
||||
throw ShaderError("Could not link shader program.", infoLog);
|
||||
}
|
||||
for (auto& id : shad_ids) {
|
||||
glDeleteShader(id);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
unsigned int ShaderProgram::id() const { return _id; }
|
||||
|
||||
void ShaderProgram::use() const {
|
||||
glUseProgram(_id);
|
||||
}
|
||||
|
||||
std::vector<ShaderUnit> ShaderProgram::getShaders() const {
|
||||
return _shader_units;
|
||||
}
|
||||
|
||||
ShaderUnit ShaderProgram::getShaders(unsigned int idx) const {
|
||||
return _shader_units[idx];
|
||||
}
|
||||
|
||||
void ShaderProgram::setBool(const std::string& name, bool value) const {
|
||||
glUniform1i(glGetUniformLocation(_id, name.c_str()), (int)value);
|
||||
}
|
||||
|
||||
void ShaderProgram::setInt(const std::string& name, int value) const {
|
||||
glUniform1i(glGetUniformLocation(_id, name.c_str()), (int)value);
|
||||
}
|
||||
|
||||
void ShaderProgram::setFloat(const std::string& name, float value) const {
|
||||
glUniform1f(glGetUniformLocation(_id, name.c_str()), (int)value);
|
||||
}
|
||||
|
||||
void ShaderProgram::setMat4(const std::string& name, glm::mat4& value) const {
|
||||
glUniformMatrix4fv(glGetUniformLocation(_id, name.c_str()), 1, GL_FALSE, glm::value_ptr(value));
|
||||
}
|
||||
|
||||
/* // Shader class
|
||||
Shader::Shader() { _id = 0x0; }
|
||||
|
||||
Shader::Shader(const Shader& cpy_shader) { _id = cpy_shader._id; }
|
||||
|
||||
Shader& Shader::operator=(const Shader& cpy_shader) { _id = cpy_shader._id; return *this; }
|
||||
|
||||
void Shader::use() const{
|
||||
glUseProgram(_id);
|
||||
}
|
||||
|
||||
*/
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user