naifb/NBEngine
1
0
Fork 0
Code Issues Pull Requests 2 Actions Packages Projects Releases Wiki Activity

Uhhhhh big big changes

Browse Source
This commit is contained in:
NaifBanana 2026-08-20 08:13:26 -05:00
parent 3e7e6acc3a
commit ac671c3770
20 changed files with 561 additions and 285 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

57
engine/NBGraphics/CMakeLists.txt
View File

@ -1,10 +1,11 @@
cmake_minimum_required(VERSION 3.10)
project(NBGraphics VERSION 0.1)
include(GNUInstallDirs)
include(CMakePackageConfigHelpers)
set(GLAD_PATH ${NBENGINE_ROOT}/../glad/)
set(STBIMAGE_PATH ${NBENGINE_ROOT}/../stbi_image)
get_filename_component(GLAD_PATH ${GLAD_PATH} ABSOLUTE)
get_filename_component(STBIMAGE_PATH ${STBIMAGE_PATH} ABSOLUTE)
set(CMAKE_PREFIX_PATH
"${CMAKE_PREFIX_PATH}"
@ -21,6 +22,10 @@ else()
endif()
set(GLFW_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
if (NB_MONITOR_OPENGL_CALLS)
add_compile_definitions(_NB_MONITOR_OPENGL_CALLS)
endif()
toAbsolutePath(NB_GRAPHICS_SOURCE
./src/Buffers.cpp
./src/FrameBuffers.cpp
@ -53,29 +58,45 @@ add_library(NBGraphics
${GLAD_PATH}/src/glad.c
)
add_library(NBEngine::Graphics ALIAS NBGraphics)
add_dependencies(NBGraphics NBCore)
add_dependencies(NBGraphics glfw)
target_link_libraries(NBGraphics
PUBLIC glfw
PUBLIC NBCore
)
get_target_property(GLFW_INTERFACE_INCLUDES glfw INTERFACE_INCLUDE_DIRECTORIES)
#include_directories(${GLFW_INTERFACE_INCLUDES})
target_include_directories(NBGraphics
PUBLIC "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>"
PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
PUBLIC "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
PUBLIC "${STBIMAGE_PATH}"
PUBLIC "${GLAD_PATH}/include"
)
export(
TARGETS NBGraphics
FILE "${CMAKE_BINARY_DIR}/cmake/NBGraphicsTargets.cmake"
NAMESPACE NBEngine::
)
configure_package_config_file(
"NBGraphicsConfig.cmake.in"
"${CMAKE_BINARY_DIR}/cmake/NBGraphicsConfig.cmake"
INSTALL_DESTINATION ${CMAKE_INSTALL_PREFIX}/cmake
PATH_VARS CMAKE_INSTALL_LIBDIR
)
write_basic_package_version_file(
"${CMAKE_BINARY_DIR}/cmake/NBGraphicsConfigVersion.cmake"
COMPATIBILITY AnyNewerVersion
)
if (NBENGINE_INSTALL)
message("Installing NBGraphics to ${CMAKE_INSTALL_PREFIX}")
include(GNUInstallDirs)
include(CMakePackageConfigHelpers)
install(
TARGETS NBGraphics
TARGETS NBGraphics
EXPORT NBGraphicsTargets
LIBRARY DESTINATION lib
ARCHIVE DESTINATION lib
INCLUDES DESTINATION include
)
install(
DIRECTORY "${PROJECT_SOURCE_DIR}/include/NBGraphics"
DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/include/NBGraphics"
DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
FILES_MATCHING PATTERN "*.h" PATTERN "*.hpp"
)
@ -84,20 +105,10 @@ if (NBENGINE_INSTALL)
DESTINATION ${CMAKE_INSTALL_PREFIX}/cmake
NAMESPACE NBEngine::
)
configure_package_config_file(
"NBGraphicsConfig.cmake.in"
"NBGraphicsConfig.cmake"
INSTALL_DESTINATION ${CMAKE_INSTALL_PREFIX}/cmake
PATH_VARS CMAKE_INSTALL_LIBDIR
)
write_basic_package_version_file(
"${CMAKE_CURRENT_BINARY_DIR}/NBGraphicsConfigVersion.cmake"
COMPATIBILITY AnyNewerVersion
)
install(FILES
"${CMAKE_CURRENT_BINARY_DIR}/NBGraphicsConfig.cmake"
"${CMAKE_CURRENT_BINARY_DIR}/NBGraphicsConfigVersion.cmake"
DESTINATION "${CMAKE_INSTALL_PREFIX}/cmake"
"${CMAKE_BINARY_DIR}/cmake/NBGraphicsConfig.cmake"
"${CMAKE_BINARY_DIR}/cmake/NBGraphicsConfigVersion.cmake"
DESTINATION "${CMAKE_INSTALL_PREFIX}/CMake"
)
endif()

6
engine/NBGraphics/NBGraphicsConfig.cmake.in
View File

@ -1,2 +1,6 @@
@PACKAGE_INIT@
include("${CMAKE_CURRENT_LIST_DIR}/NBGraphicsTargets.cmake")
include("${CMAKE_CURRENT_LIST_DIR}/NBGraphicsTargets.cmake")
include(CMakeFindDependencyMacro)
find_dependency(NBCore REQUIRED)
find_dependency(OpenGL REQUIRED)
find_dependency(glfw3 REQUIRED)

18
engine/NBGraphics/include/NBGraphics/Buffers.hpp
View File

@ -14,7 +14,7 @@
namespace nb {
extern const std::unordered_map<GLenum, std::string> BufferTypes;
extern const ConstantMap <GLenum, std::string> BufferTypes;
template<GLenum N>
struct GLSLEnum;
@ -72,7 +72,7 @@ class Buffer : public OpenGLObject {
Buffer(GLenum target) : Target(target) {}
virtual GLuint declare() override {
if (!_id) {
glGenBuffers(1, &_id);
OPENGL_CALL(glGenBuffers(1, &_id));
}
bind();
return _id;
@ -80,7 +80,7 @@ class Buffer : public OpenGLObject {
virtual void remove() override {
if (_id) {
unbind();
glDeleteBuffers(1, &_id);
OPENGL_CALL(glDeleteBuffers(1, &_id));
_id = 0;
}
}
@ -93,15 +93,17 @@ class Buffer : public OpenGLObject {
virtual void bind() const override {
if (_id) {
glBindBuffer(Target, _id);
OPENGL_CALL(glBindBuffer(Target, _id));
} else {
THROW(OGLError(
OGLError::Codes::INVALID_OBJECT,
"w/ BufferType " + BufferTypes.at(Target)
THROW(OpenGLObjectError(
OpenGLObjectError::Codes::INVALID_OBJECT,
"w/ BufferType " + BufferTypes[Target]
));
}
}
virtual void unbind() const override { glBindBuffer(Target, 0); }
virtual void unbind() const override {
OPENGL_CALL(glBindBuffer(Target, 0));
}
GLenum usage() const;
size_t size() const;
ByteVector data() const;

7
engine/NBGraphics/include/NBGraphics/Draw.hpp
View File

@ -9,13 +9,12 @@
#include <string>
#include <vector>
#include <NBGraphics/Buffers.h>
#include <NBGraphics/Shader.h>
#include <NBGraphics/VAOManager.hpp>
#include <NBGraphics/Buffers.hpp>
#include <NBGraphics/VertexArray.hpp>
#define THROW_DRAW_ERROR(msg) throw DrawError(msg, __FILE__, __LINE__);
namespace NB{
namespace nb{
class DrawError : public std::runtime_error {
public:

78
engine/NBGraphics/include/NBGraphics/FrameBuffers.hpp
View File

@ -29,19 +29,25 @@ class RenderBuffer : public RenderTarget {
protected:
GLuint declare() override {
if (!_id) {
glRenderbufferStorage(
OPENGL_CALL(
glGenRenderbuffers(1, &_id)
);
bind();
OPENGL_CALL(glRenderbufferStorage(
GL_RENDERBUFFER,
format,
width,
height
);
));
return _id;
}
bind();
return _id;
}
void remove() override {
if (_id) {
unbind();
glDeleteRenderbuffers(1, &_id);
OPENGL_CALL(glDeleteRenderbuffers(1, &_id));
_id = 0;
}
}
@ -50,11 +56,14 @@ class RenderBuffer : public RenderTarget {
const unsigned int width;
const unsigned int height;
const GLenum format;
template<typename PixelType>
RenderBuffer(unsigned int width_, unsigned int height_) :
RenderBuffer(
GLenum format_,
unsigned int width_,
unsigned int height_
) :
format(format_),
width(width_),
height(height_),
format(OGLPixelFormat<PixelType>::glFormat),
RenderTarget(GL_RENDERBUFFER)
{ declare(); }
RenderBuffer(RenderBuffer&& rhs) :
@ -66,16 +75,16 @@ class RenderBuffer : public RenderTarget {
RenderBuffer& operator=(RenderBuffer&&) = delete;
void bind() const override {
if (_id) {
glBindRenderbuffer(GL_RENDERBUFFER, _id);
OPENGL_CALL(glBindRenderbuffer(GL_RENDERBUFFER, _id));
} else {
THROW(OGLError(
OGLError::Codes::INVALID_OBJECT,
THROW(OpenGLObjectError(
OpenGLObjectError::Codes::INVALID_OBJECT,
"w/ RenderBuffer"
));
}
}
void unbind() const override {
glBindRenderbuffer(GL_RENDERBUFFER, 0);
OPENGL_CALL(glBindRenderbuffer(GL_RENDERBUFFER, 0));
}
};
@ -85,8 +94,10 @@ class FrameBufferBase : public OpenGLObject {
static bool texTypeIs2D(GLenum texType) {
switch(texType) {
case GL_TEXTURE_2D:
default:
return true;
case GL_TEXTURE_1D:
default:
return false;
break;
}
}
@ -98,6 +109,19 @@ class FrameBufferBase : public OpenGLObject {
GLuint declare() override;
void remove() override;
std::shared_ptr<RenderTarget> detach(GLenum);
void attach(
GLenum attachment,
std::shared_ptr<RenderBuffer> renderbuffer
);
public:
const GLenum Target;
void bind() const override;
void unbind() const override;
GLenum status() const;
bool complete() const;
AttachmentMap getAllBuffers() const;
std::shared_ptr<RenderTarget> getBuffer(GLenum) const;
void attach(
GLenum attachment,
std::shared_ptr<Texture> texture,
@ -109,32 +133,6 @@ class FrameBufferBase : public OpenGLObject {
unsigned int level,
unsigned int layer
);
void attach(
GLenum attachment,
std::shared_ptr<RenderBuffer> renderBuffer
) {
declare();
if (attachment == GL_NONE) {
THROW(FrameBufferError(FrameBufferError::INVALID_VALUE,
"Cannot attach RenderBuffer to `GL_NONE`"
));
}
glFramebufferRenderbuffer(
Target,
attachment,
GL_RENDERBUFFER,
renderBuffer->id()
);
_attachments[attachment] = renderBuffer;
}
public:
const GLenum Target;
void bind() const override;
void unbind() const override;
GLenum status() const;
AttachmentMap getAllBuffers() const;
std::shared_ptr<RenderTarget> getBuffer(GLenum) const;
};
class ReadFrameBuffer;
@ -178,12 +176,6 @@ class WriteFrameBuffer : public virtual FrameBufferBase {
WriteFrameBuffer();
WriteFrameBuffer& operator=(ReadFrameBuffer&&);
WriteFrameBuffer& operator=(WriteFrameBuffer&&);
template<typename... T>
void attach(
GLenum attachment,
std::shared_ptr<Texture> texture,
T... args
) { FrameBufferBase::attach(attachment, texture, args...); }
DrawTexVec getWriteBuffers() const;
std::vector<GLenum> getWriteLocations() const;
DrawTexVec setWriteBuffers(const std::vector<GLenum>& attachments);

4
engine/NBGraphics/include/NBGraphics/GLLoad.hpp
View File

@ -5,4 +5,8 @@
#include <glad/glad.h>
#include <GLFW/glfw3.h>
namespace nb {
} // namespace nb
#endif

114
engine/NBGraphics/include/NBGraphics/Image.hpp
View File

@ -134,40 +134,95 @@ class Image;
template<typename T, typename... Channels>
class Image<Pixel<T, Channels...>> {
private:
Error<> sizeCompare(const Image& rhs) {
const std::string errmsg = "Cannot assign images of different size";
if (width != rhs.width) {
return Error<>(
Error<>::VALUE_ERROR,
errmsg+"[ Width: "+std::to_string(width)+\
" != "+std::to_string(rhs.width)+" ]"
);
}
if (height != rhs.height) {
return Error<>(
Error<>::VALUE_ERROR,
errmsg+"[ Width: "+std::to_string(width)+\
" != "+std::to_string(rhs.width)+" ]"
);
}
return Error<>("NoError");
}
protected:
using Codes = ImageError::Codes;
bool _data_managed;
T* _data;
Image(unsigned int x, unsigned int y)
: width(x), height(y), _data(nullptr) {}
void clear() {
if (_data_managed) {
delete[] _data;
_data_managed = false;
}
_data = nullptr;
}
public:
using PixelType = Pixel<T, Channels...>;
static constexpr size_t NumberChannels = sizeof...(Channels);
const unsigned int width;
const unsigned int height;
Image(unsigned int x, unsigned int y, const T* data)
: Image(x, y) {
size_t data_size = width*height*NumberChannels;
_data = new T[data_size];
std::memcpy(_data, data, data_size*sizeof(T));
static Image&& CreateImageStorage(
unsigned int width,
unsigned int height,
T* data=nullptr
) {
unsigned int data_size = NumberChannels*width*height*sizeof(T);
T* data_ptr = new T[data_size];
auto& ret = Image(width, height, data_ptr);
if (data) {
std::memcpy(data_ptr, data, data_size);
}
ret._data_managed = true;
return std::move(ret);
}
Image(unsigned int x, unsigned int y, T* data=nullptr)
: width(x), height(y), _data(data), _data_managed(false) {}
Image(const Image& cpy)
: Image(cpy.width, cpy.height) {
*this = cpy;
}
Image(const Image&) = delete;
Image& operator=(const Image&) = delete;
Image& operator=(Image&&) = delete;
Image(Image&& mv)
: width(mv.width), height(mv.height), _data(mv._data) {
mv._data = nullptr;
: Image(mv.width, mv.height) {
*this = std::move(mv);
}
Image& operator=(const Image& cpy) {
if (_data_managed) {
THROW(Error<>(Error<>::OVERWRITE_ERROR));
}
const Error<> sizeErr = sizeCompare(cpy);
if (sizeErr.code!=1) { THROW(sizeErr); }
_data = cpy._data;
return this;
}
Image& operator=(Image&& mv) {
if (_data_managed) {
THROW(Error<>(Error<>::OVERWRITE_ERROR));
}
const Error<> sizeErr = sizeCompare(mv);
if (sizeErr.code!=1) { THROW(sizeErr); }
_data = mv._data;
_data_managed = mv._data_managed;
mv._data_managed = false;
return this;
}
~Image() {
if (_data) {
delete[] _data;
}
virtual ~Image() {
clear();
}
const T* data() const { return _data; }
Image&& copy() const {
return Image(width, height, _data);
Image<PixelType>&& copy() const {
return CreateImageStorage(width, height, _data);
}
PixelReference<PixelType> at(unsigned int x, unsigned int y) {
if (!(x<width) || !(y<height)) {
@ -188,29 +243,6 @@ class Image<Pixel<T, Channels...>> {
};
template<typename... T>
class ImageReference;
template<typename T, typename... Channels>
class ImageReference<Pixel<T, Channels...>> : public Image<Pixel<T, Channels...>> {
protected:
using Base = Image<Pixel<T, Channels...>>;
using Base::_data;
public:
using Base::width;
using Base::height;
using Base::copy;
ImageReference(unsigned int x, unsigned int y, T* data)
: Base(x, y) {
_data = data;
}
~ImageReference() noexcept {
Base::_data = nullptr;
}
};
} // namespace nb
#endif // _NB_IMAGE

75
engine/NBGraphics/include/NBGraphics/OGLObjects.hpp
View File

@ -2,14 +2,40 @@
#ifndef _NB_OGL_OBJECTS
#define _NB_OGL_OBJECTS
#include <NBGraphics/GLLoad.hpp>
#include <NBCore/Errors.hpp>
#include <NBGraphics/GLLoad.hpp>
#include <NBCore/Utils.hpp>
namespace nb {
class OGLError : public Error<OGLError> {
using Base = Error<OGLError>;
typedef ConstantMap<GLenum, std::string> GLEnumTableType;
extern const GLEnumTableType GLenumTable;
class OpenGLError : public Error<OpenGLError> {
using Base = Error<OpenGLError>;
public:
using Base::Base;
enum Codes : unsigned int {
NO_ERROR = GL_NO_ERROR,
INVALID_ENUM = GL_INVALID_ENUM,
INVALID_VALUE = GL_INVALID_VALUE,
INVALID_OPERATION = GL_INVALID_OPERATION,
INVALID_FRAMEBUFFER_OPERATION = GL_INVALID_FRAMEBUFFER_OPERATION,
OUT_OF_MEMORY = GL_OUT_OF_MEMORY,
STACK_UNDERFLOW = GL_STACK_UNDERFLOW,
STACK_OVERFLOW = GL_STACK_OVERFLOW
};
static const std::string type;
static const ErrorCodeMap ErrorMessages;
static OpenGLError status();
};
class OpenGLObjectError : public Error<OpenGLObjectError> {
using Base = Error<OpenGLObjectError>;
public:
using Base::Base;
@ -35,7 +61,7 @@ class OpenGLObject {
GLuint id() const { return _id; }
protected:
using Codes = OGLError::Codes;
using Codes = OpenGLObjectError::Codes;
OpenGLObject() = default;
virtual GLuint declare() = 0;
@ -45,4 +71,43 @@ class OpenGLObject {
};
} // namespace nb
#ifndef OPENGL_CALL
#ifdef _NB_MONITOR_OPENGL_CALLS
namespace NB_OPENGL_CALL_MONITORING {
template<typename Fn>
inline auto run_expression(
const std::string& file,
unsigned int line,
Fn fn
) {
auto check_ = [file, line]() {
const auto no_err = nb::OpenGLError::NO_ERROR;
auto stat = nb::OpenGLError::status();
if (stat.code != no_err) {
THROW_W_CODE_LOC(file, line, stat);
}
};
if constexpr(std::is_same_v<std::invoke_result_t<Fn>, void>) {
check_();
fn();
check_();
} else {
check_();
auto ret = fn();
check_();
return ret;
}
}
};
#define OPENGL_CALL(expression) NB_OPENGL_CALL_MONITORING::run_expression(\
__FILE__,\
__LINE__,\
[&]() {return expression;}\
)
#else
#define OPENGL_CALL(x) x
#endif // _NB_MONITOR_OPENGL_CALLS
#endif // OPENGL_CALL
#endif // _NB_OGL_OBJECTS

14
engine/NBGraphics/include/NBGraphics/ProgramPipeline.hpp
View File

@ -78,8 +78,8 @@ class Shader : public OpenGLObject {
for (int i=0; i < num_srcs; ++i) {
src_ptrs[i] = _sources[i].data();
}
glShaderSource(_id, num_srcs, src_ptrs.data(), NULL);
glCompileShader(_id);
OPENGL_CALL(glShaderSource(_id, num_srcs, src_ptrs.data(), NULL));
OPENGL_CALL(glCompileShader(_id));
_success = status(GL_COMPILE_STATUS);
if (!_success) {
WARN(log(), 0x0FE);
@ -88,14 +88,14 @@ class Shader : public OpenGLObject {
virtual GLuint declare() override {
if (!_id) {
_id = _id = glCreateShader(target);
_id = _id = OPENGL_CALL(glCreateShader(target));
}
return _id;
}
virtual void remove() override {
if (_id) {
glDeleteShader(_id);
OPENGL_CALL(glDeleteShader(_id));
}
}
@ -113,7 +113,7 @@ class Program : public OpenGLObject {
operator bool();
~Program() { remove(); }
virtual void bind() const override {
glUseProgram(_id);
OPENGL_CALL(glUseProgram(_id));
}
virtual void unbind() const override { /* TODO: Some warning of some kind perhaps*/ }
GLint status(GLenum) const;
@ -125,13 +125,13 @@ class Program : public OpenGLObject {
GLint _success;
virtual GLuint declare() override {
if (!_id) {
_id = glCreateProgram();
_id = OPENGL_CALL(glCreateProgram());
}
return _id;
}
virtual void remove() override {
if (_id) {
glDeleteProgram(_id);
OPENGL_CALL(glDeleteProgram(_id));
}
}

141
engine/NBGraphics/include/NBGraphics/Textures.hpp
View File

@ -6,6 +6,8 @@
#include <NBGraphics/Image.hpp>
#include <NBGraphics/OGLObjects.hpp>
/*! @file Textures.hpp */
namespace nb {
class TextureBuffer : public virtual Buffer {
@ -14,6 +16,9 @@ class TextureBuffer : public virtual Buffer {
};
/*!
@brief An OpenGL object that may be rendered to within a Framebuffer.
*/
class RenderTarget : public OpenGLObject {
protected:
using Base = OpenGLObject;
@ -23,11 +28,13 @@ class RenderTarget : public OpenGLObject {
: Target(rhs.Target), Base(std::move(rhs)) {}
public:
using Base::Base;
using Base::id;
const GLenum Target;
};
/*!
@brief An OpenGL Target object
*/
class Texture : public RenderTarget {
protected:
using Base = RenderTarget;
@ -35,7 +42,7 @@ class Texture : public RenderTarget {
Texture(GLenum);
virtual GLuint declare() override {
if (!_id) {
glGenTextures(1, &_id);
OPENGL_CALL(glGenTextures(1, &_id));
}
bind();
return _id;
@ -43,57 +50,69 @@ class Texture : public RenderTarget {
virtual void remove() override {
if (_id) {
bind();
glDeleteTextures(0, &_id);
OPENGL_CALL(glDeleteTextures(0, &_id));
}
}
public:
using Base::Base;
using Base::id;
using Base::Target;
virtual void bind() const override {
if (_id) {
glBindTexture(Target, _id);
OPENGL_CALL(glBindTexture(Target, _id));
} else {
THROW(OGLError(
OGLError::Codes::INVALID_OBJECT,
THROW(OpenGLObjectError(
OpenGLObjectError::Codes::INVALID_OBJECT,
"w/ Texture"
));
}
}
virtual void unbind() const override {
glBindTexture(Target, 0);
OPENGL_CALL(glBindTexture(Target, 0));
}
template <typename T>
void parameter(GLenum param_, const T& val_);
void parameter(GLenum param_, const float& val_) {
declare();
OPENGL_CALL(
glTexParameterf(Target, param_, val_)
);
}
void parameter(GLenum param_, const int& val_) {
declare();
glTexParameteri(_id, param_, val_);
}
void parameter(GLenum param_, const std::vector<int>& val_) {
declare();
glTexParameteriv(_id, param_, val_.data());
OPENGL_CALL(
glTexParameteri(Target, param_, val_)
);
}
void parameter(GLenum param_, const std::vector<float>& val_) {
declare();
glTexParameterfv(_id, param_, val_.data());
OPENGL_CALL(
glTexParameterfv(Target, param_, val_.data())
);
}
void parameter(GLenum param_, const std::vector<int>& val_) {
declare();
OPENGL_CALL(
glTexParameteriv(Target, param_, val_.data())
);
}
void parameter(GLenum param_, const std::vector<unsigned int>& val_) {
declare();
glTexParameterIuiv(_id, param_, val_.data());
OPENGL_CALL(
glTexParameterIuiv(Target, param_, val_.data())
);
}
void generateMipmaps() const {
bind();
glGenerateMipmap(Target);
OPENGL_CALL(
glGenerateMipmap(Target)
);
}
};
template<typename T>
class ImageTexture;
template<typename T>
struct OGLPixelFormat;
@ -102,52 +121,110 @@ struct OGLPixelFormat<Pixel<T, Channels...>>;
template<>
struct OGLPixelFormat<Pixel<uint8_t, Red, Green, Blue>> {
static constexpr GLenum glFormat = GL_RGB;
static constexpr GLenum glBase = GL_RGB;
static constexpr GLenum glFormat = GL_RGB8UI;
static constexpr GLenum glData = GL_UNSIGNED_BYTE;
};
template<>
struct OGLPixelFormat<Pixel<uint8_t, Red, Green, Blue, Alpha>> {
static constexpr GLenum glFormat = GL_RGBA;
static constexpr GLenum glBase = GL_RGBA;
static constexpr GLenum glFormat = GL_RGBA8UI;
static constexpr GLenum glData = GL_UNSIGNED_BYTE;
};
template<>
struct OGLPixelFormat<Pixel<float, Red, Green>> {
static constexpr GLenum glBase = GL_RG;
static constexpr GLenum glFormat = GL_RG32F;
static constexpr GLenum glData = GL_FLOAT;
};
template<typename T>
class Texture2D;
template<typename T, typename... Channels>
class ImageTexture<Pixel<T, Channels...>> : public Texture {
class Texture2D<Pixel<T, Channels...>> : public Texture {
protected:
using Texture::Texture;
using PixelType = Pixel<T, Channels...>;
public:
using Texture::generateMipmaps;
ImageTexture() : Texture(GL_TEXTURE_2D) {}
ImageTexture(ImageTexture&& cpy) {
Texture2D() : Texture(GL_TEXTURE_2D) {}
Texture2D(Texture2D&& cpy) {
*this = std::move(cpy);
}
ImageTexture& operator=(ImageTexture&& rhs) {
Texture2D& operator=(Texture2D&& rhs) {
return Texture::operator=(std::move(rhs));
}
void setImage(const Image<PixelType>& img, unsigned int layer) {
void setLayer(const Image<PixelType>& img, unsigned int layer) {
using Format = OGLPixelFormat<PixelType>;
declare();
glTexImage2D(
auto data = img.data();
OPENGL_CALL(glTexImage2D(
Target,
layer,
Format::glFormat,
img.width,
img.height,
0,
Format::glFormat,
Format::glBase,
Format::glData,
img.data()
);
data ? data : nullptr
));
}
void setImage(const Image<PixelType>& img, bool generateMipmap=true) {
setImage(img, (unsigned int)0);
void setTexture(const Image<PixelType>& img, bool generateMipmap=true) {
setLayer(img, 0);
if (generateMipmap) { generateMipmaps(); }
}
};
template<typename T>
class Texture1D;
template<typename T, typename... Channels>
class Texture1D<Pixel<T, Channels...>> : public Texture {
protected:
using Texture::Texture;
using PixelType = Pixel<T, Channels...>;
public:
using Texture::generateMipmaps;
Texture1D() : Texture(GL_TEXTURE_1D) {}
Texture1D(Texture1D&& cpy) {
*this = std::move(cpy);
}
Texture1D& operator=(Texture1D&& rhs) {
return Texture::operator=(std::move(rhs));
}
void setLayer(const Image<PixelType>& tex, unsigned int layer) {
if (tex.height != 1) {
THROW(Error<>(
Error<>::VALUE_ERROR,
"Image must be of height 1"
));
}
using Format = OGLPixelFormat<PixelType>;
declare();
auto data = tex.data();
OPENGL_CALL(glTexImage1D(
Target,
layer,
Format::glFormat,
tex.width,
0,
Format::glBase,
Format::glData,
data ? data : nullptr
));
}
void setTexture(const Image<PixelType>& tex, bool generateMipmap=true) {
setLayer(tex, 0);
if (generateMipmap) { generateMipmaps(); }
}
};
} // namespace nb
#endif // _NB_TEXTURES

14
engine/NBGraphics/include/NBGraphics/VertexArray.hpp
View File

@ -88,15 +88,17 @@ class VAO : public OpenGLObject {
virtual void bind() const override {
if(_id) {
glBindVertexArray(_id);
OPENGL_CALL(glBindVertexArray(_id));
} else {
THROW(OGLError(
OGLError::Codes::INVALID_OBJECT,
THROW(OpenGLObjectError(
OpenGLObjectError::Codes::INVALID_OBJECT,
"w/ VertexArrayObject"
));
}
}
virtual void unbind() const override { glBindVertexArray(0); }
virtual void unbind() const override {
OPENGL_CALL(glBindVertexArray(0));
}
VertexAttributePointerList attributes() const;
VertexAttributePointerList attributes(const VertexAttributePointerList&);
@ -114,13 +116,13 @@ class VAO : public OpenGLObject {
if(_id) {
disable();
bind();
glDeleteVertexArrays(1, &_id);
OPENGL_CALL(glDeleteVertexArrays(1, &_id));
_id = 0;
}
}
virtual GLuint declare() override {
if (!_id) {
glGenVertexArrays(1, &_id);
OPENGL_CALL(glGenVertexArrays(1, &_id));
}
bind();
return _id;

5
engine/NBGraphics/include/NBGraphics/Window.hpp
View File

@ -3,6 +3,7 @@
#define _NB_WINDOW
#include <NBGraphics/GLLoad.hpp>
#include <NBGraphics/OGLObjects.hpp>
#include <array>
#include <map>
@ -13,8 +14,8 @@
namespace nb {
class OpenGLError : public Error<OpenGLError> {
using Base = Error<OpenGLError>;
class GLFWError : public Error<GLFWError> {
using Base = Error<GLFWError>;
public:
using Base::Base;

16
engine/NBGraphics/src/Buffers.cpp
View File

@ -2,7 +2,7 @@
namespace nb {
const std::unordered_map<GLenum, std::string> BufferTypes({
const ConstantMap<GLenum, std::string> BufferTypes({
{GL_ARRAY_BUFFER, "GL_ARRAY_BUFFER"},
{GL_ELEMENT_ARRAY_BUFFER, "GL_ELEMENT_BUFFER"}
});
@ -22,10 +22,10 @@ Buffer::Buffer(Buffer&& rval) : Target(rval.Target) {
Buffer& Buffer::operator=(Buffer&& rhs) {
if (Target != rhs.Target) {
auto targ_name = BufferTypes.at(Target);
THROW(OGLError(
OGLError::Codes::INVALID_OBJECT,
"w/ BufferType "+targ_name+" != BufferType "+BufferTypes.at(rhs.Target)
auto targ_name = BufferTypes[Target];
THROW(OpenGLObjectError(
OpenGLObjectError::Codes::INVALID_OBJECT,
"w/ BufferType "+targ_name+" != BufferType "+BufferTypes[Target]
));
}
OpenGLObject::operator=(std::move(rhs));
@ -44,13 +44,13 @@ size_t Buffer::size() const { return _size; }
ByteVector Buffer::data() const {
bind();
ByteVector ret(_size);
glGetBufferSubData(Target, 0, _size, ret.data());
OPENGL_CALL(glGetBufferSubData(Target, 0, _size, ret.data()));
return ret;
}
void Buffer::data(const void* data_, size_t size_, GLenum usage_) {
declare();
glBufferData(Target, size_, data_, usage_);
OPENGL_CALL(glBufferData(Target, size_, data_, usage_));
_size = size_;
_usage = usage_;
}
@ -65,7 +65,7 @@ void Buffer::subdata(const void* data_, size_t size_, GLintptr offset_) {
if (offset_+size_ <= _size) {
THROW(BufferError(BufferError::Codes::DATA_OVERFLOW));
}
glBufferSubData(Target, offset_, size_, data_);
OPENGL_CALL(glBufferSubData(Target, offset_, size_, data_));
}
void Buffer::subdata(const ByteVector& data_, GLintptr offset_) {

113
engine/NBGraphics/src/FrameBuffers.cpp
View File

@ -11,7 +11,9 @@ const ErrorCodeMap FrameBufferError::ErrorMessages = {
GLuint FrameBufferBase::declare() {
if (!_id) {
glGenFramebuffers(1, &_id);
OPENGL_CALL(
glGenFramebuffers(1, &_id)
);
}
bind();
return _id;
@ -20,7 +22,9 @@ GLuint FrameBufferBase::declare() {
void FrameBufferBase::remove() {
if (_id) {
unbind();
glDeleteFramebuffers(1, &_id);
OPENGL_CALL(
glDeleteFramebuffers(1, &_id)
);
_id=0;
}
}
@ -31,7 +35,9 @@ std::shared_ptr<RenderTarget> FrameBufferBase::detach(GLenum attch_) {
bind();
auto ret = _attachments.at(attch_);
_attachments.erase(attch_);
glFramebufferTexture(Target, attch_, 0, 0);
OPENGL_CALL(
glFramebufferTexture(Target, attch_, 0, 0)
);
return ret;
}
@ -47,13 +53,13 @@ void FrameBufferBase::attach(
"Cannot attach object to `GL_NONE`"
));
}
glFramebufferTextureLayer(
OPENGL_CALL(glFramebufferTextureLayer(
Target,
attachment_,
texture_->id(),
level_,
layer_
);
));
_attachments[attachment_] = texture_;
}
@ -69,43 +75,72 @@ void FrameBufferBase::attach(
));
}
if (texTypeIs2D(texture_->Target)) {
glFramebufferTexture2D(
OPENGL_CALL(glFramebufferTexture2D(
Target,
attachment_,
texture_->Target,
texture_->id(),
level_
);
));
} else {
glFramebufferTexture1D(
OPENGL_CALL(glFramebufferTexture1D(
Target,
attachment_,
texture_->Target,
texture_->id(),
level_
);
));
}
_attachments[attachment_] = texture_;
}
void FrameBufferBase::attach(
GLenum attachment,
std::shared_ptr<RenderBuffer> renderbuffer
) {
declare();
if (attachment == GL_NONE) {
THROW(FrameBufferError(FrameBufferError::INVALID_VALUE,
"Cannot attach RenderBuffer to `GL_NONE`"
));
}
OPENGL_CALL(glFramebufferRenderbuffer(
Target,
attachment,
GL_RENDERBUFFER,
renderbuffer->id()
));
_attachments[attachment] = renderbuffer;
}
void FrameBufferBase::bind() const {
if (_id) {
glBindFramebuffer(Target, _id);
OPENGL_CALL(
glBindFramebuffer(Target, _id)
);
} else {
THROW(OGLError(
OGLError::Codes::INVALID_OBJECT,
THROW(OpenGLObjectError(
OpenGLObjectError::Codes::INVALID_OBJECT,
"w/ FrameBuffer"
));
}
}
void FrameBufferBase::unbind() const {
glBindFramebuffer(Target, 0);
OPENGL_CALL(
glBindFramebuffer(Target, 0)
);
}
GLenum FrameBufferBase::status() const {
bind();
return glCheckFramebufferStatus(Target);
return OPENGL_CALL(
glCheckFramebufferStatus(Target)
);
}
bool FrameBufferBase::complete() const {
return status() == GL_FRAMEBUFFER_COMPLETE;
}
FrameBufferBase::AttachmentMap FrameBufferBase::getAllBuffers() const {
@ -166,7 +201,7 @@ std::shared_ptr<RenderTarget> ReadFrameBuffer::setReadBuffer(GLenum attch_) {
}
}
_location = attch_;
glReadBuffer(_location);
OPENGL_CALL(glReadBuffer(_location));
return getReadBuffer();
}
@ -222,7 +257,9 @@ WriteFrameBuffer::DrawTexVec WriteFrameBuffer::setWriteBuffers(const std::vector
}
}
_locations = attchs_;
glDrawBuffers(_locations.size(), _locations.data());
OPENGL_CALL(
glDrawBuffers(_locations.size(), _locations.data())
);
return getWriteBuffers();
}
@ -230,7 +267,9 @@ std::shared_ptr<Texture> WriteFrameBuffer::setWriteBuffer(GLenum attch_) {
bind();
if (attch_ == GL_NONE) {
std::vector<GLenum> tmp(_locations.size(), GL_NONE);
glDrawBuffers(tmp.size(), tmp.data());
OPENGL_CALL(
glDrawBuffers(tmp.size(), tmp.data())
);
_locations = {};
return nullptr;
}
@ -241,13 +280,17 @@ std::shared_ptr<Texture> WriteFrameBuffer::setWriteBuffer(GLenum attch_) {
fRGBA WriteFrameBuffer::clearColorValue() const {
bind();
float rgba[4];
glGetFloatv(GL_COLOR_CLEAR_VALUE, rgba);
OPENGL_CALL(
glGetFloatv(GL_COLOR_CLEAR_VALUE, rgba)
);
return fRGBA{rgba[0], rgba[1], rgba[2], rgba[3]};
}
fRGBA WriteFrameBuffer::clearColorValue(const fRGBA& color) {
declare();
glClearColor(color.r, color.g, color.b, color.a);
OPENGL_CALL(
glClearColor(color.r, color.g, color.b, color.a)
);
return color;
}
@ -258,32 +301,42 @@ fRGBA WriteFrameBuffer::clearColorValue(float r, float g, float b, float a) {
double WriteFrameBuffer::clearDepthValue() const {
bind();
double ret;
glGetDoublev(GL_DEPTH_CLEAR_VALUE, &ret);
OPENGL_CALL(
glGetDoublev(GL_DEPTH_CLEAR_VALUE, &ret)
);
return ret;
}
double WriteFrameBuffer::clearDepthValue(double d_) {
declare();
glClearDepth(d_);
OPENGL_CALL(
glClearDepth(d_)
);
return d_;
}
GLint WriteFrameBuffer::clearStencilValue() const {
bind();
GLint ret;
glGetIntegerv(GL_STENCIL_CLEAR_VALUE, &ret);
OPENGL_CALL(
glGetIntegerv(GL_STENCIL_CLEAR_VALUE, &ret)
);
return ret;
}
GLint WriteFrameBuffer::clearStencilValue(GLint s_) {
declare();
glClearStencil(s_);
OPENGL_CALL(
glClearStencil(s_)
);
return s_;
}
void WriteFrameBuffer::clear(GLbitfield mask_) const {
bind();
glClear(mask_);
OPENGL_CALL(
glClear(mask_)
);
}
void WriteFrameBuffer::clearDepth() const {
@ -292,7 +345,9 @@ void WriteFrameBuffer::clearDepth() const {
void WriteFrameBuffer::clearDepth(float val_) const {
bind();
glClearBufferfv(GL_DEPTH, 0, &val_);
OPENGL_CALL(
glClearBufferfv(GL_DEPTH, 0, &val_)
);
}
void WriteFrameBuffer::clearStencil() const {
@ -301,7 +356,9 @@ void WriteFrameBuffer::clearStencil() const {
void WriteFrameBuffer::clearStencil(GLint val_) const {
bind();
glClearBufferiv(GL_STENCIL, 0, &val_);
OPENGL_CALL(
glClearBufferiv(GL_STENCIL, 0, &val_)
);
}
void WriteFrameBuffer::clearDepthStencil() const {
@ -310,7 +367,9 @@ void WriteFrameBuffer::clearDepthStencil() const {
void WriteFrameBuffer::clearDepthStencil(float d_, GLint s_) const {
bind();
glClearBufferfi(GL_DEPTH_STENCIL, 0, d_, s_);
OPENGL_CALL(
glClearBufferfi(GL_DEPTH_STENCIL, 0, d_, s_)
);
}
FrameBuffer::FrameBuffer()

54
engine/NBGraphics/src/OGLObjects.cpp
View File

@ -1,23 +1,65 @@
#include <NBGraphics/OGLObjects.hpp>
#ifndef GLENUMSTRPAIR
#define GLENUMSTRPAIR(x) {x, #x}
#endif // GLENUMSTRPAIR
namespace nb {
const std::string OGLError::type = "nb::OGLError";
const ErrorCodeMap OGLError::ErrorMessages = {
{ OGLError::Codes::UNDEFINED, "Error" },
{OGLError::Codes::HANGING_OBJECT, "Attempting to leave a hanging OpenGL object"},
{OGLError::Codes::INVALID_OBJECT, "Attempting operation with invalid object"}
const std::string OpenGLObjectError::type = "nb::OpenGLObjectError";
const ErrorCodeMap OpenGLObjectError::ErrorMessages = {
{ OpenGLObjectError::Codes::UNDEFINED, "Error" },
{OpenGLObjectError::Codes::HANGING_OBJECT, "Attempting to leave a hanging OpenGL object"},
{OpenGLObjectError::Codes::INVALID_OBJECT, "Attempting operation with invalid object"}
};
const std::string OpenGLError::type = "nb::OpenGLError";
const ErrorCodeMap OpenGLError::ErrorMessages = {
GLENUMSTRPAIR(GL_NO_ERROR),
GLENUMSTRPAIR(GL_INVALID_ENUM),
GLENUMSTRPAIR(GL_INVALID_ENUM),
GLENUMSTRPAIR(GL_INVALID_VALUE),
GLENUMSTRPAIR(GL_INVALID_OPERATION),
GLENUMSTRPAIR(GL_INVALID_FRAMEBUFFER_OPERATION),
GLENUMSTRPAIR(GL_OUT_OF_MEMORY),
GLENUMSTRPAIR(GL_STACK_UNDERFLOW),
GLENUMSTRPAIR(GL_STACK_OVERFLOW)
};
OpenGLError OpenGLError::status() {
return OpenGLError(glGetError());
}
OpenGLObject::OpenGLObject(OpenGLObject&& rval) {
*this = std::move(rval);
}
OpenGLObject& OpenGLObject::operator=(OpenGLObject&& rhs) {
if (_id) { THROW(OGLError(Codes::HANGING_OBJECT)); }
if (_id) { THROW(OpenGLObjectError(Codes::HANGING_OBJECT)); }
_id = rhs._id;
rhs._id = 0;
return *this;
}
const GLEnumTableType GLenumTable = {
GLENUMSTRPAIR(GL_DRAW_FRAMEBUFFER),
GLENUMSTRPAIR(GL_FRAMEBUFFER),
GLENUMSTRPAIR(GL_FRAMEBUFFER_COMPLETE),
GLENUMSTRPAIR(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT),
GLENUMSTRPAIR(GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER),
GLENUMSTRPAIR(GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS),
GLENUMSTRPAIR(GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT),
GLENUMSTRPAIR(GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE),
GLENUMSTRPAIR(GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER),
GLENUMSTRPAIR(GL_FRAMEBUFFER_UNDEFINED),
GLENUMSTRPAIR(GL_FRAMEBUFFER_UNSUPPORTED),
GLENUMSTRPAIR(GL_READ_FRAMEBUFFER),
GLENUMSTRPAIR(GL_RG),
GLENUMSTRPAIR(GL_RG32F),
GLENUMSTRPAIR(GL_RGB),
GLENUMSTRPAIR(GL_RGB8UI),
GLENUMSTRPAIR(GL_RGBA8UI),
GLENUMSTRPAIR(GL_RGBA),
};
} // namespace nb

12
engine/NBGraphics/src/ProgramPipeline.cpp
View File

@ -41,14 +41,14 @@ bool Shader::success() const {
GLint Shader::status(GLenum parameter) const {
GLint param = 0;
glGetShaderiv(_id, parameter, &param);
OPENGL_CALL(glGetShaderiv(_id, parameter, &param));
return param;
}
std::string Shader::log() const {
GLint logsize = status(GL_INFO_LOG_LENGTH);
char* log_ = new char[logsize];
glGetShaderInfoLog(_id, logsize, NULL, log_);
OPENGL_CALL(glGetShaderInfoLog(_id, logsize, NULL, log_));
std::string ret(log_, logsize);
delete[] log_;
return ret;
@ -57,9 +57,9 @@ std::string Shader::log() const {
Program::Program(SharedVector<Shader> shaders_) {
declare();
for (auto shad_ptr : shaders_) {
glAttachShader(_id, shad_ptr->id());
OPENGL_CALL(glAttachShader(_id, shad_ptr->id()));
}
glLinkProgram(_id);
OPENGL_CALL(glLinkProgram(_id));
_success = status(GL_LINK_STATUS);
if (!_success) {
WARN(log(), 0x0FE);
@ -70,14 +70,14 @@ Program::operator bool() { return _success; }
GLint Program::status(GLenum parameter) const {
GLint param = 0;
glGetProgramiv(_id, parameter, &param);
OPENGL_CALL(glGetProgramiv(_id, parameter, &param));
return param;
}
std::string Program::log() const {
GLint logsize = status(GL_INFO_LOG_LENGTH);
char* log_ = new char[logsize];
glGetProgramInfoLog(_id, logsize, NULL, log_);
OPENGL_CALL(glGetProgramInfoLog(_id, logsize, NULL, log_));
std::string ret(log_, logsize);
delete[] log_;
return ret;

22
engine/NBGraphics/src/VertexArray.cpp
View File

@ -41,17 +41,17 @@ VertexAttributePointerList VAO::attributes(const VertexAttributePointerList& att
_attrs = attrs_;
bind();
for (auto attr_ptr : attrs_) {
glBindBuffer(GL_ARRAY_BUFFER, attr_ptr.buffer);
OPENGL_CALL(glBindBuffer(GL_ARRAY_BUFFER, attr_ptr.buffer));
GLuint idx = attr_ptr.index;
glVertexAttribPointer(
OPENGL_CALL(glVertexAttribPointer(
idx,
attr_ptr.attribute.GLSLSize,
attr_ptr.attribute.GLSLType,
attr_ptr.attribute.GLSLNormalization,
attr_ptr.attribute.layout.stride,
(void*)attr_ptr.attribute.layout.offset
);
glEnableVertexAttribArray(idx);
));
OPENGL_CALL(glEnableVertexAttribArray(idx));
}
unbind();
return _attrs;
@ -70,7 +70,7 @@ void VAO::enable() const {
if (_id) {
bind();
for(auto attr_ptr : _attrs) {
glEnableVertexAttribArray(attr_ptr.index);
OPENGL_CALL(glEnableVertexAttribArray(attr_ptr.index));
}
unbind();
}
@ -79,7 +79,7 @@ void VAO::enable() const {
void VAO::enable(GLuint idx) const {
if(_id) {
bind();
glEnableVertexAttribArray(attr(idx).index);
OPENGL_CALL(glEnableVertexAttribArray(attr(idx).index));
unbind();
}
}
@ -88,7 +88,7 @@ void VAO::disable() const {
if(_id) {
bind();
for(auto attr_ptr : _attrs) {
glDisableVertexAttribArray(attr_ptr.index);
OPENGL_CALL(glDisableVertexAttribArray(attr_ptr.index));
}
unbind();
}
@ -97,7 +97,7 @@ void VAO::disable() const {
void VAO::disable(GLuint idx) const {
if(_id) {
bind();
glDisableVertexAttribArray(attr(idx).index);
OPENGL_CALL(glDisableVertexAttribArray(attr(idx).index));
unbind();
}
}
@ -120,7 +120,9 @@ VertexGroup& VertexGroup::operator=(VertexGroup&& rhs) {
void VertexGroup::draw() const {
bind();
glDrawElements(primitive, _ebo->size(), _ebo->glslType(), 0);
OPENGL_CALL(
glDrawElements(primitive, _ebo->size(), _ebo->glslType(), 0)
);
}
size_t VertexGroup::addBuffer(const VertexData& vertex_data_) {
@ -177,7 +179,7 @@ VertexDataVec VertexGroup::dropBuffers() {
VertexData VertexGroup::dropBuffer(size_t idx) {
if (idx >= _vertex_data.size()) {
THROW(Error(Error<>::INDEX_ERROR));
THROW(Error(Error<>::OUT_OF_RANGE));
}
VertexDataVec tmp;
VertexData ret;

28
engine/NBGraphics/src/Window.cpp
View File

@ -16,13 +16,13 @@ static std::map<int, int> defailt_window_hints = {
#endif
};
using OpenGLErrorCodes = OpenGLError::Codes;
const std::string OpenGLError::type = "nb::OpenGLError";
const ErrorCodeMap OpenGLError::ErrorMessages = {
{OpenGLErrorCodes::UNDEFINED, "Error"},
{OpenGLErrorCodes::INIT_FAILED, "GLFW initialization failed"},
{OpenGLErrorCodes::GLFW_INTIALIZED, "GLFW has already been initialized"},
{OpenGLErrorCodes::GLAD_FAILED, "GLAD initialization failed"}
using GLFWCodes = GLFWError::Codes;
const std::string GLFWError::type = "nb::GLFWError";
const ErrorCodeMap GLFWError::ErrorMessages = {
{GLFWCodes::UNDEFINED, "Error"},
{GLFWCodes::INIT_FAILED, "GLFW initialization failed"},
{GLFWCodes::GLFW_INTIALIZED, "GLFW has already been initialized"},
{GLFWCodes::GLAD_FAILED, "GLAD initialization failed"}
};
using WindowErrorCodes = WindowError::Codes;
@ -44,7 +44,7 @@ int Window::getGLFWHint(int hint_key) {
int Window::setGLFWHint(int hint_key, int hint_val) {
if (Window::_glfw_init) {
THROW(OpenGLError(OpenGLErrorCodes::GLFW_INTIALIZED));
THROW(GLFWError(GLFWCodes::GLFW_INTIALIZED));
} else {
GLFWHints[hint_key] = hint_val;
}
@ -74,7 +74,7 @@ Window::Window(const uint16_t x, const uint16_t y, const char* initName, GLFWmon
Window::_glfw_init = true;
} else {
if (Window::StrictInitialization) {
THROW(OpenGLError(OpenGLErrorCodes::INIT_FAILED));
THROW(GLFWError(GLFWCodes::INIT_FAILED));
}
}
}
@ -147,12 +147,14 @@ int Window::init() {
if (!gladResponse) {
Window::checkKillGLFW();
if (Window::StrictInitialization) {
THROW(OpenGLError(OpenGLErrorCodes::GLAD_FAILED));
THROW(GLFWError(GLFWCodes::GLAD_FAILED));
}
}
_init = true;
glViewport(0, 0, windowSize[0], windowSize[1]);
OPENGL_CALL(
glViewport(0, 0, windowSize[0], windowSize[1])
);
return gladResponse;
}
@ -173,7 +175,9 @@ std::string Window::getName() const {
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]);
OPENGL_CALL(
glViewport(0, 0, windowSize[0], windowSize[1])
);
glfwSetWindowSize(window, windowSize[0], windowSize[1]);
}

10
engine/NBGraphics/tests/CMakeLists.txt
View File

@ -4,21 +4,29 @@ if (NB_BUILD_TESTS)
enable_testing()
include(GoogleTest)
set(STBIMAGE_PATH ${NBENGINE_ROOT}/../stbi_image)
get_filename_component(STBIMAGE_PATH ${STBIMAGE_PATH} ABSOLUTE)
add_executable(TestWindow
./TestWindow.cpp
)
target_link_libraries(TestWindow
NBGraphics
)
target_include_directories(TestWindow
PRIVATE "${STBIMAGE_PATH}"
)
add_executable(TestImages
./testImages.cpp
)
target_link_libraries(TestImages
NBCore
NBGraphics
GTest::gtest_main
)
target_include_directories(TestImages
PRIVATE "${STBIMAGE_PATH}"
)
gtest_discover_tests(TestImages)

58
engine/NBGraphics/tests/TestWindow.cpp
View File

@ -2,14 +2,16 @@
#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"
#include <NBCore/Errors.hpp>
#include <NBGraphics/Image.hpp>
#include <NBGraphics/ProgramPipeline.hpp>
#include <NBGraphics/VertexArray.hpp>
#include <NBGraphics/Window.hpp>
#include <NBGraphics/Textures.hpp>
int main() {
nb::logger.log("Howdy!");
LOG("Howdy!");
nb::Window window(400, 400, "Hello!");
window.setWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
window.setWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
@ -19,12 +21,12 @@ int main() {
GL_VERTEX_SHADER,
"#version 330 core\n"
"layout (location = 0) in vec2 aPos;\n"
"layout (location = 1) in vec2 tPos;\n"
"out vec2 vPos;\n"
"out vec4 vColor;\n"
"void main()\n"
"{\n"
" gl_Position = vec4(aPos.x, aPos.y, 0.0, 1.0);\n"
" vPos = tPos;\n"
" vec2 tmp = (aPos+vec2(1.0, 1.0))*0.5;\n"
" vColor = vec4(tmp.x, 0, tmp.y, 1.0);\n"
"}\0"
);
@ -33,71 +35,41 @@ int main() {
auto frag = std::make_shared<nb::Shader>(
GL_FRAGMENT_SHADER,
"#version 330 core\n"
"in vec2 vPos;\n"
"in vec4 vColor;\n"
"out vec4 FragColor;\n"
"uniform sampler2D tex;\n"
"void main()\n"
"{\n"
" FragColor = texture(tex, vPos);\n"
" FragColor = vColor;\n"
"}\n\0"
);
LOG(frag->log());
nb::ByteVector data = nb::vectorToBytes<float>({
-0.5, -0.5, 0,0,
-0.5, 0.5, 0,1,
0.5, 0.5, 1,1,
0.5, -0.5, 1,0
-0.5, -0.5,
0, 0.5,
0.5, -0.5
});
nb::Program prog({vert, frag});
prog.bind();
std::vector<uint32_t> indxs = {0, 1, 2, 0, 2, 3};
std::vector<uint32_t> indxs = {0, 1, 2};
nb::VertexGroup tri(data, {
nb::VertexAttribute{
2,
GL_FLOAT,
false,
{0, 16}
{0, 8}
},
nb::VertexAttribute{
2,
GL_FLOAT,
false,
{8, 16}
}
}, indxs);
tri.bind();
int width, height, numChannels;
auto raw_img_data = stbi_load(
"./awesomeface.png",
&width,
&height,
&numChannels,
0
);
LOG(numChannels);
using RGBA = nb::Pixel<uint8_t, nb::Red, nb::Green, nb::Blue, nb::Alpha>;
nb::ImageReference<RGBA> img(width, height, raw_img_data);
auto tex = nb::ImageTexture<RGBA>();
tex.parameter(GL_TEXTURE_MAG_FILTER, GL_LINEAR);
tex.parameter(GL_TEXTURE_MIN_FILTER, GL_LINEAR);
tex.setImage(img);
tex.bind();
tri.bind();
LOG(img.at(256, 256).r);
stbi_image_free(raw_img_data);
LOG(prog.log());
GLFWwindow* window_ptr = window.getWindow();
while(!glfwWindowShouldClose(window_ptr)) {
glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
OPENGL_CALL(glClearColor(0.2f, 0.3f, 0.3f, 1.0f));
OPENGL_CALL(glClear(GL_COLOR_BUFFER_BIT));
tri.draw();
glfwPollEvents();
glfwSwapBuffers(window_ptr);