rexy712/our_dick
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Switch to true modern opengl (DSA)

Browse Source
This commit is contained in:
rexy712 2020-10-01 05:01:30 -07:00
parent c45875c108
commit b2c8b0b3b5
10 changed files with 215 additions and 562 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
include/graphics/fbo.hpp
View File

@ -30,8 +30,6 @@ namespace gfx{
{
private:
GLuint m_buffer;
frame_buffer_accessor m_draw;
frame_buffer_accessor m_read;
public:
fbo();
@ -50,12 +48,6 @@ namespace gfx{
bool bind()const;
bool bind(gl_frame_buffer_manager& b)const;
bool bind_lock(gl_frame_buffer_manager& b)const;
void bind_unlock(gl_frame_buffer_manager& b)const;
void unbind()const;
gl_frame_buffer_manager* get_bound_buffer()const;
GLenum get_bound_id()const;
};
}

2
include/graphics/texture.hpp
View File

@ -101,7 +101,7 @@ namespace gfx{
//bind to GL_TEXTURE_2D
void bind()const;
//bind to given texture unit and load into given program uniform location
void use(GLuint tunit, GLint uloc)const;
void bind_unit(GLuint tunit)const;
};
}

66
include/graphics/vao.hpp
View File

@ -21,6 +21,7 @@
#include "gl_include.hpp"
#include "math/math.hpp"
#include "vbo.hpp"
namespace gfx{
using namespace math;
@ -45,6 +46,9 @@ namespace gfx{
GLuint raw()const;
void bind_buffer(const vbo& buffer, GLuint index, GLuint offset, GLuint stride);
void bind_element_buffer(const vbo& buffer);
//Get access to a generic vertex attribute within this vao
vertex_attribute get_attribute(int index);
@ -72,60 +76,22 @@ namespace gfx{
constexpr vertex_attribute& operator=(vertex_attribute&&) = default;
//enable use as an array attribute (most likely what is desired)
void enable_array_mode();
void enable();
//disable use as an array attribute. used for static data in attributes during rendering
void disable_array_mode();
void disable();
void associate_with(GLuint buffer_binding);
//setters for use in array mode. Same arguments as glVertexAttribPointer but these take arguments
//as object counts rather than bytes. a valid vbo must be bound to buffers::array_buffer before these are called.
void set_float_pointer(GLint size, GLsizei stride, GLsizei offset);
void set_double_pointer(GLint size, GLsizei stride, GLsizei offset);
void set_byte_pointer(GLint size, GLsizei stride, GLsizei offset);
void set_ubyte_pointer(GLint size, GLsizei stride, GLsizei offset);
void set_short_pointer(GLint size, GLsizei stride, GLsizei offset);
void set_ushort_pointer(GLint size, GLsizei stride, GLsizei offset);
void set_int_pointer(GLint size, GLsizei stride, GLsizei offset);
void set_uint_pointer(GLint size, GLsizei stride, GLsizei offset);
//setters for use in non array mode
void set(GLfloat);
void set(GLshort);
void set(GLdouble);
void set(GLint);
void set(GLuint);
void set(GLfloat, GLfloat);
void set(GLshort, GLshort);
void set(GLdouble, GLdouble);
void set(GLint, GLint);
void set(GLuint, GLuint);
void set(GLfloat, GLfloat, GLfloat);
void set(GLshort, GLshort, GLshort);
void set(GLdouble, GLdouble, GLdouble);
void set(GLint, GLint, GLint);
void set(GLuint, GLuint, GLuint);
void set(GLfloat, GLfloat, GLfloat, GLfloat);
void set(GLshort, GLshort, GLshort, GLshort);
void set(GLdouble, GLdouble, GLdouble, GLdouble);
void set(GLint, GLint, GLint, GLint);
void set(GLuint, GLuint, GLuint, GLuint);
void set(const vec2<GLfloat>&);
void set(const vec2<GLshort>&);
void set(const vec2<GLdouble>&);
void set(const vec2<GLint>&);
void set(const vec2<GLuint>&);
void set(const vec3<GLfloat>&);
void set(const vec3<GLshort>&);
void set(const vec3<GLdouble>&);
void set(const vec3<GLint>&);
void set(const vec3<GLuint>&);
void set(const vec4<GLfloat>&);
void set(const vec4<GLshort>&);
void set(const vec4<GLdouble>&);
void set(const vec4<GLint>&);
void set(const vec4<GLuint>&);
void set(const vec4<GLbyte>&);
void set(const vec4<GLubyte>&);
void set(const vec4<GLushort>&);
void set_float_array(GLint size, GLsizei offset);
void set_double_array(GLint size, GLsizei offset);
void set_byte_array(GLint size, GLsizei offset);
void set_ubyte_array(GLint size, GLsizei offset);
void set_short_array(GLint size, GLsizei offset);
void set_ushort_array(GLint size, GLsizei offset);
void set_int_array(GLint size, GLsizei offset);
void set_uint_array(GLint size, GLsizei offset);
};
}

40
include/graphics/vbo.hpp
View File

@ -21,8 +21,6 @@
#include "gl_include.hpp"
#include "gl_buffers.hpp"
#include "scoped_buffer_bind.hpp"
#include <cstdlib> //size_t, ptrdiff_t
#include <utility> //exchange, swap
@ -56,7 +54,6 @@ namespace gfx{
private:
GLuint m_buffer; //handle to vbo
size_t m_buffer_size; //amount of buffer currently in use
buffer_accessor m_bi; //interface with gl_buffer stuff
public:
//create a buffer with given capacity with predicted usage case 't'
@ -70,12 +67,6 @@ namespace gfx{
//attempt binding to given gl_buffer_manager. returns true on success
bool bind(gl_buffer_manager& b)const;
//attempt binding to given gl_buffer_manager and locking that buffer. returns true on success
bool bind_lock(gl_buffer_manager& b)const;
//unlock associated gl_buffer_manager but don't unbind
void bind_unlock()const;
//unbind and unlock associated gl_buffer_manager
void unbind()const;
//add data to the end of this buffer (starts loading at data+get_size())
bool buffer(const void* data, size_t datasize);
//change capacity of buffer
@ -84,7 +75,7 @@ namespace gfx{
GLuint raw()const;
//glMapBuffer to given target with map style 'm'
scoped_vbo_map<void> map(gl_buffer_manager& target, maptype m)const;
scoped_vbo_map<void> map(maptype m)const;
//emties the buffer. does not clear contents, just sets size to 0.
void clear();
@ -92,9 +83,6 @@ namespace gfx{
size_t get_cap()const;
usage get_usage()const;
//check the currently bound buffer target
gl_buffer_manager* get_bound_buffer()const;
GLenum get_bound_id()const;
private:
static bool copy_buffer(vbo& dest, const vbo& src);
};
@ -114,12 +102,11 @@ namespace gfx{
private:
pointer m_data = nullptr; //pointer to the mapped region
scoped_buffer_bind<buffer_accessor> m_bind;
GLuint m_buffer;
public:
//create a mapping for 'v' on 'targ' with map style 'm'
explicit scoped_vbo_map(const buffer_accessor& ba, gl_buffer_manager& bm, GLuint bid, vbo::maptype m);
explicit scoped_vbo_map(GLuint bid, vbo::maptype m);
scoped_vbo_map(const scoped_vbo_map&) = delete;
scoped_vbo_map(scoped_vbo_map&&);
~scoped_vbo_map();
@ -161,10 +148,10 @@ namespace gfx{
private:
pointer m_data = nullptr;
scoped_buffer_bind<buffer_accessor> m_bind;
GLuint m_buffer;
public:
explicit scoped_vbo_map(const buffer_accessor& ba, gl_buffer_manager& bm, GLuint bid, vbo::maptype m);
explicit scoped_vbo_map(GLuint bid, vbo::maptype m);
scoped_vbo_map(const scoped_vbo_map&) = delete;
scoped_vbo_map(scoped_vbo_map&&);
~scoped_vbo_map();
@ -184,37 +171,36 @@ namespace gfx{
};
template<typename T>
scoped_vbo_map<T>::scoped_vbo_map(const buffer_accessor& ba, gl_buffer_manager& bm, GLuint bid, vbo::maptype m):
m_bind(ba, bm, bid)
scoped_vbo_map<T>::scoped_vbo_map(GLuint bid, vbo::maptype m):
m_buffer(bid)
{
if(!m_bind.valid())
return;
m_data = reinterpret_cast<pointer>(glMapBuffer(m_bind.get_bound_id(), static_cast<GLenum>(m)));
m_data = reinterpret_cast<pointer>(glMapNamedBuffer(m_buffer, static_cast<GLenum>(m)));
}
template<typename T>
scoped_vbo_map<T>::scoped_vbo_map(scoped_vbo_map&& m):
m_data(std::exchange(m.m_data, nullptr)),
m_bind(std::move(m.m_bind)){}
m_buffer(std::exchange(m.m_buffer, 0)){}
template<typename T>
scoped_vbo_map<T>::~scoped_vbo_map(){
if(m_data){
glUnmapBuffer(m_bind.get_bound_id());
glUnmapNamedBuffer(m_buffer);
}
}
template<typename T>
scoped_vbo_map<T>& scoped_vbo_map<T>::operator=(scoped_vbo_map&& m){
std::swap(m_data, m.m_data);
m_bind = std::move(m.m_bind);
std::swap(m_buffer, m.m_buffer);
return *this;
}
template<typename T>
auto scoped_vbo_map<T>::length()const -> size_type{
GLint64 retval;
glGetBufferParameteri64v(m_bind.get_bound_id(), GL_BUFFER_MAP_LENGTH, &retval);
glGetNamedBufferParameteri64v(m_buffer, GL_BUFFER_MAP_LENGTH, &retval);
return retval;
}
template<typename T>
auto scoped_vbo_map<T>::release() -> pointer{
m_buffer = 0;
return std::exchange(m_data, nullptr);
}
template<typename T>

67
src/graphics/fbo.cpp
View File

@ -23,14 +23,10 @@
namespace gfx{
fbo::fbo(){
glGenFramebuffers(1, &m_buffer);
m_draw.set_buffer_id(m_buffer);
m_read.set_buffer_id(m_buffer);
glCreateFramebuffers(1, &m_buffer);
}
fbo::fbo(fbo&& f):
m_buffer(std::exchange(f.m_buffer, 0)),
m_draw(std::move(f.m_draw)),
m_read(std::move(f.m_read)){}
m_buffer(std::exchange(f.m_buffer, 0)){}
fbo::~fbo(){
if(m_buffer)
glDeleteFramebuffers(1, &m_buffer);
@ -46,72 +42,25 @@ namespace gfx{
}
bool fbo::detach(GLenum point){
scoped_buffer_bind draw_bind(m_draw, buffer::fb_draw);
if(!draw_bind.valid())
return false;
glFramebufferRenderbuffer(m_draw.get_bound_id(), point, GL_RENDERBUFFER, 0);
glNamedFramebufferRenderbuffer(m_buffer, point, GL_RENDERBUFFER, 0);
return true;
}
bool fbo::attach(const texture& tex, GLenum point){
scoped_buffer_bind draw_bind(m_draw, buffer::fb_draw);
if(!draw_bind.valid())
return false;
tex.bind();
glFramebufferTexture2D(m_draw.get_bound_id(), point, GL_TEXTURE_2D, tex.raw(), 0);
glNamedFramebufferTexture(m_buffer, point, tex.raw(), 0);
return true;
}
bool fbo::attach(const rbo& r, GLenum point){
scoped_buffer_bind draw_bind(m_draw, buffer::fb_draw);
if(!draw_bind.valid())
return false;
r.bind();
glFramebufferRenderbuffer(m_draw.get_bound_id(), point, GL_RENDERBUFFER, r.raw());
glNamedFramebufferRenderbuffer(m_buffer, point, GL_RENDERBUFFER, r.raw());
return true;
}
bool fbo::bind()const{
return (bind(buffer::fb_draw) && bind(buffer::fb_read));
glBindFramebuffer(GL_FRAMEBUFFER, m_buffer);
return true;
}
bool fbo::bind(gl_frame_buffer_manager& b)const{
if(GL_DRAW_FRAMEBUFFER == b.get_buffer_id()){
if(!m_draw.bind(b))
return false;
}else{
if(!m_read.bind(b))
return false;
}
glBindFramebuffer(b.get_buffer_id(), m_buffer);
return true;
}
bool fbo::bind_lock(gl_frame_buffer_manager& b)const{
if(GL_DRAW_FRAMEBUFFER == b.get_buffer_id()){
if(!m_draw.bind_lock(b))
return false;
}else{
if(!m_read.bind_lock(b))
return false;
}
return true;
}
void fbo::bind_unlock(gl_frame_buffer_manager& b)const{
if(GL_DRAW_FRAMEBUFFER == b.get_buffer_id()){
m_draw.unlock();
}else{
m_read.unlock();
}
}
void fbo::unbind()const{
m_draw.unbind();
m_read.unbind();
}
GLenum fbo::get_bound_id()const{
if(m_read.get_bound_buffer() && m_draw.get_bound_buffer())
return GL_FRAMEBUFFER;
if(m_read.get_bound_buffer())
return m_read.get_bound_id();
if(m_draw.get_bound_buffer())
return m_draw.get_bound_id();
return 0;
}
}

199
src/graphics/shader_program.cpp
View File

@ -425,20 +425,16 @@ namespace gfx{
set_uniform(get_uniform_loc(name), f1, f2, f3, f4);
}
void shader_program::set_uniform(GLuint loc, GLfloat f){
use();
glUniform1f(loc, f);
glProgramUniform1f(m_shader_id, loc, f);
}
void shader_program::set_uniform(GLuint loc, GLfloat f1, GLfloat f2){
use();
glUniform2f(loc, f1, f2);
glProgramUniform2f(m_shader_id, loc, f1, f2);
}
void shader_program::set_uniform(GLuint loc, GLfloat f1, GLfloat f2, GLfloat f3){
use();
glUniform3f(loc, f1, f2, f3);
glProgramUniform3f(m_shader_id, loc, f1, f2, f3);
}
void shader_program::set_uniform(GLuint loc, GLfloat f1, GLfloat f2, GLfloat f3, GLfloat f4){
use();
glUniform4f(loc, f1, f2, f3, f4);
glProgramUniform4f(m_shader_id, loc, f1, f2, f3, f4);
}
void shader_program::set_uniform(const char* name, GLint i){
@ -454,20 +450,16 @@ namespace gfx{
set_uniform(get_uniform_loc(name), i1, i2, i3, i4);
}
void shader_program::set_uniform(GLuint loc, GLint i){
use();
glUniform1i(loc, i);
glProgramUniform1i(m_shader_id, loc, i);
}
void shader_program::set_uniform(GLuint loc, GLint i1, GLint i2){
use();
glUniform2i(loc, i1, i2);
glProgramUniform2i(m_shader_id, loc, i1, i2);
}
void shader_program::set_uniform(GLuint loc, GLint i1, GLint i2, GLint i3){
use();
glUniform3i(loc, i1, i2, i3);
glProgramUniform3i(m_shader_id, loc, i1, i2, i3);
}
void shader_program::set_uniform(GLuint loc, GLint i1, GLint i2, GLint i3, GLint i4){
use();
glUniform4i(loc, i1, i2, i3, i4);
glProgramUniform4i(m_shader_id, loc, i1, i2, i3, i4);
}
void shader_program::set_uniform(const char* name, GLuint i){
@ -483,28 +475,24 @@ namespace gfx{
set_uniform(get_uniform_loc(name), i1, i2, i3, i4);
}
void shader_program::set_uniform(GLuint loc, GLuint i){
use();
glUniform1ui(loc, i);
glProgramUniform1ui(m_shader_id, loc, i);
}
void shader_program::set_uniform(GLuint loc, GLuint i1, GLuint i2){
use();
glUniform2ui(loc, i1, i2);
glProgramUniform2ui(m_shader_id, loc, i1, i2);
}
void shader_program::set_uniform(GLuint loc, GLuint i1, GLuint i2, GLuint i3){
use();
glUniform3ui(loc, i1, i2, i3);
glProgramUniform3ui(m_shader_id, loc, i1, i2, i3);
}
void shader_program::set_uniform(GLuint loc, GLuint i1, GLuint i2, GLuint i3, GLuint i4){
use();
glUniform4ui(loc, i1, i2, i3, i4);
glProgramUniform4ui(m_shader_id, loc, i1, i2, i3, i4);
}
void shader_program::set_uniform(const char* name, const texture& t, GLuint tex_unit){
set_uniform(get_uniform_loc(name), t, tex_unit);
}
void shader_program::set_uniform(GLuint loc, const texture& t, GLuint tex_unit){
use();
t.use(tex_unit, loc);
t.bind_unit(tex_unit);
glProgramUniform1i(m_shader_id, loc, tex_unit);
}
void shader_program::set_uniform(const char* name, const vec2<GLfloat>& v){
@ -517,41 +505,36 @@ namespace gfx{
set_uniform(get_uniform_loc(name), v);
}
void shader_program::set_uniform(GLuint loc, const vec2<GLfloat>& v){
use();
glUniform2fv(loc, 1, v);
glProgramUniform2fv(m_shader_id, loc, 1, v);
}
void shader_program::set_uniform(GLuint loc, const vec3<GLfloat>& v){
use();
glUniform3fv(loc, 1, v);
glProgramUniform3fv(m_shader_id, loc, 1, v);
}
void shader_program::set_uniform(GLuint loc, const vec4<GLfloat>& v){
use();
glUniform4fv(loc, 1, v);
glProgramUniform4fv(m_shader_id, loc, 1, v);
}
void shader_program::set_uniform(const char* name, GLsizei count, const vec2<GLfloat>* v_arr){
set_uniform(get_uniform_loc(name), count, v_arr);
}
void shader_program::set_uniform(GLuint loc, GLsizei count, const vec2<GLfloat>* v_arr){
use();
if constexpr(sizeof(v_arr[0]) == sizeof(GLfloat[2])){
glUniform2fv(loc, count, reinterpret_cast<const GLfloat*>(v_arr));
glProgramUniform2fv(m_shader_id, loc, count, reinterpret_cast<const GLfloat*>(v_arr));
}else{
std::unique_ptr<GLfloat[]> arr(new GLfloat[count * 2]);
for(GLsizei i = 0; i < count; ++i){
arr[i] = v_arr[i].get(0);
arr[i + 1] = v_arr[i].get(1);
}
glUniform2fv(loc, count, arr.get());
glProgramUniform2fv(m_shader_id, loc, count, arr.get());
}
}
void shader_program::set_uniform(const char* name, GLsizei count, const vec3<GLfloat>* v_arr){
set_uniform(get_uniform_loc(name), count, v_arr);
}
void shader_program::set_uniform(GLuint loc, GLsizei count, const vec3<GLfloat>* v_arr){
use();
if constexpr(sizeof(v_arr[0]) == sizeof(GLfloat[3])){
glUniform3fv(loc, count, reinterpret_cast<const GLfloat*>(v_arr));
glProgramUniform3fv(m_shader_id, loc, count, reinterpret_cast<const GLfloat*>(v_arr));
}else{
std::unique_ptr<GLfloat[]> arr(new GLfloat[count * 3]);
for(GLsizei i = 0; i < count; ++i){
@ -559,16 +542,15 @@ namespace gfx{
arr[i + 1] = v_arr[i].get(1);
arr[i + 2] = v_arr[i].get(2);
}
glUniform3fv(loc, count, arr.get());
glProgramUniform3fv(m_shader_id, loc, count, arr.get());
}
}
void shader_program::set_uniform(const char* name, GLsizei count, const vec4<GLfloat>* v_arr){
set_uniform(get_uniform_loc(name), count, v_arr);
}
void shader_program::set_uniform(GLuint loc, GLsizei count, const vec4<GLfloat>* v_arr){
use();
if constexpr(sizeof(v_arr[0]) == sizeof(GLfloat[4])){
glUniform4fv(loc, count, reinterpret_cast<const GLfloat*>(v_arr));
glProgramUniform4fv(m_shader_id, loc, count, reinterpret_cast<const GLfloat*>(v_arr));
}else{
std::unique_ptr<GLfloat[]> arr(new GLfloat[count * 4]);
for(GLsizei i = 0; i < count; ++i){
@ -577,7 +559,7 @@ namespace gfx{
arr[i + 2] = v_arr[i].get(2);
arr[i + 3] = v_arr[i].get(3);
}
glUniform4fv(loc, count, arr.get());
glProgramUniform4fv(m_shader_id, loc, count, arr.get());
}
}
@ -594,20 +576,16 @@ namespace gfx{
set_uniform_4(get_uniform_loc(name), count, v_arr);
}
void shader_program::set_uniform_1(GLuint loc, GLsizei count, const GLfloat* v_arr){
use();
glUniform1fv(loc, count, v_arr);
glProgramUniform1fv(m_shader_id, loc, count, v_arr);
}
void shader_program::set_uniform_2(GLuint loc, GLsizei count, const GLfloat* v_arr){
use();
glUniform2fv(loc, count, v_arr);
glProgramUniform2fv(m_shader_id, loc, count, v_arr);
}
void shader_program::set_uniform_3(GLuint loc, GLsizei count, const GLfloat* v_arr){
use();
glUniform3fv(loc, count, v_arr);
glProgramUniform3fv(m_shader_id, loc, count, v_arr);
}
void shader_program::set_uniform_4(GLuint loc, GLsizei count, const GLfloat* v_arr){
use();
glUniform4fv(loc, count, v_arr);
glProgramUniform4fv(m_shader_id, loc, count, v_arr);
}
void shader_program::set_uniform(const char* name, const vec2<GLint>& v){
@ -620,41 +598,36 @@ namespace gfx{
set_uniform(get_uniform_loc(name), v);
}
void shader_program::set_uniform(GLuint loc, const vec2<GLint>& v){
use();
glUniform2iv(loc, 1, v);
glProgramUniform2iv(m_shader_id, loc, 1, v);
}
void shader_program::set_uniform(GLuint loc, const vec3<GLint>& v){
use();
glUniform3iv(loc, 1, v);
glProgramUniform3iv(m_shader_id, loc, 1, v);
}
void shader_program::set_uniform(GLuint loc, const vec4<GLint>& v){
use();
glUniform4iv(loc, 1, v);
glProgramUniform4iv(m_shader_id, loc, 1, v);
}
void shader_program::set_uniform(const char* name, GLsizei count, const vec2<GLint>* v_arr){
set_uniform(get_uniform_loc(name), count, v_arr);
}
void shader_program::set_uniform(GLuint loc, GLsizei count, const vec2<GLint>* v_arr){
use();
if constexpr(sizeof(v_arr[0]) == sizeof(GLint[2])){
glUniform2iv(loc, count, reinterpret_cast<const GLint*>(v_arr));
glProgramUniform2iv(m_shader_id, loc, count, reinterpret_cast<const GLint*>(v_arr));
}else{
std::unique_ptr<GLint[]> arr(new GLint[count * 2]);
for(GLsizei i = 0; i < count; ++i){
arr[i] = v_arr[i].get(0);
arr[i + 1] = v_arr[i].get(1);
}
glUniform2iv(loc, count, arr.get());
glProgramUniform2iv(m_shader_id, loc, count, arr.get());
}
}
void shader_program::set_uniform(const char* name, GLsizei count, const vec3<GLint>* v_arr){
set_uniform(get_uniform_loc(name), count, v_arr);
}
void shader_program::set_uniform(GLuint loc, GLsizei count, const vec3<GLint>* v_arr){
use();
if constexpr(sizeof(v_arr[0]) == sizeof(GLint[3])){
glUniform3iv(loc, count, reinterpret_cast<const GLint*>(v_arr));
glProgramUniform3iv(m_shader_id, loc, count, reinterpret_cast<const GLint*>(v_arr));
}else{
std::unique_ptr<GLint[]> arr(new GLint[count * 3]);
for(GLsizei i = 0; i < count; ++i){
@ -662,16 +635,15 @@ namespace gfx{
arr[i + 1] = v_arr[i].get(1);
arr[i + 2] = v_arr[i].get(2);
}
glUniform3iv(loc, count, arr.get());
glProgramUniform3iv(m_shader_id, loc, count, arr.get());
}
}
void shader_program::set_uniform(const char* name, GLsizei count, const vec4<GLint>* v_arr){
set_uniform(get_uniform_loc(name), count, v_arr);
}
void shader_program::set_uniform(GLuint loc, GLsizei count, const vec4<GLint>* v_arr){
use();
if constexpr(sizeof(v_arr[0]) == sizeof(GLint[4])){
glUniform4iv(loc, count, reinterpret_cast<const GLint*>(v_arr));
glProgramUniform4iv(m_shader_id, loc, count, reinterpret_cast<const GLint*>(v_arr));
}else{
std::unique_ptr<GLint[]> arr(new GLint[count * 4]);
for(GLsizei i = 0; i < count; ++i){
@ -680,7 +652,7 @@ namespace gfx{
arr[i + 2] = v_arr[i].get(2);
arr[i + 3] = v_arr[i].get(3);
}
glUniform4iv(loc, count, arr.get());
glProgramUniform4iv(m_shader_id, loc, count, arr.get());
}
}
@ -697,20 +669,16 @@ namespace gfx{
set_uniform_4(get_uniform_loc(name), count, v_arr);
}
void shader_program::set_uniform_1(GLuint loc, GLsizei count, const GLint* v_arr){
use();
glUniform1iv(loc, count, v_arr);
glProgramUniform1iv(m_shader_id, loc, count, v_arr);
}
void shader_program::set_uniform_2(GLuint loc, GLsizei count, const GLint* v_arr){
use();
glUniform2iv(loc, count, v_arr);
glProgramUniform2iv(m_shader_id, loc, count, v_arr);
}
void shader_program::set_uniform_3(GLuint loc, GLsizei count, const GLint* v_arr){
use();
glUniform3iv(loc, count, v_arr);
glProgramUniform3iv(m_shader_id, loc, count, v_arr);
}
void shader_program::set_uniform_4(GLuint loc, GLsizei count, const GLint* v_arr){
use();
glUniform4iv(loc, count, v_arr);
glProgramUniform4iv(m_shader_id, loc, count, v_arr);
}
void shader_program::set_uniform(const char* name, const vec2<GLuint>& v){
@ -723,41 +691,36 @@ namespace gfx{
set_uniform(get_uniform_loc(name), v);
}
void shader_program::set_uniform(GLuint loc, const vec2<GLuint>& v){
use();
glUniform2uiv(loc, 1, v);
glProgramUniform2uiv(m_shader_id, loc, 1, v);
}
void shader_program::set_uniform(GLuint loc, const vec3<GLuint>& v){
use();
glUniform3uiv(loc, 1, v);
glProgramUniform3uiv(m_shader_id, loc, 1, v);
}
void shader_program::set_uniform(GLuint loc, const vec4<GLuint>& v){
use();
glUniform4uiv(loc, 1, v);
glProgramUniform4uiv(m_shader_id, loc, 1, v);
}
void shader_program::set_uniform(const char* name, GLsizei count, const vec2<GLuint>* v_arr){
set_uniform(get_uniform_loc(name), count, v_arr);
}
void shader_program::set_uniform(GLuint loc, GLsizei count, const vec2<GLuint>* v_arr){
use();
if constexpr(sizeof(v_arr[0]) == sizeof(GLuint[2])){
glUniform2uiv(loc, count, reinterpret_cast<const GLuint*>(v_arr));
glProgramUniform2uiv(m_shader_id, loc, count, reinterpret_cast<const GLuint*>(v_arr));
}else{
std::unique_ptr<GLuint[]> arr(new GLuint[count * 2]);
for(GLsizei i = 0; i < count; ++i){
arr[i] = v_arr[i].get(0);
arr[i + 1] = v_arr[i].get(1);
}
glUniform2uiv(loc, count, arr.get());
glProgramUniform2uiv(m_shader_id, loc, count, arr.get());
}
}
void shader_program::set_uniform(const char* name, GLsizei count, const vec3<GLuint>* v_arr){
set_uniform(get_uniform_loc(name), count, v_arr);
}
void shader_program::set_uniform(GLuint loc, GLsizei count, const vec3<GLuint>* v_arr){
use();
if constexpr(sizeof(v_arr[0]) == sizeof(GLuint[3])){
glUniform3uiv(loc, count, reinterpret_cast<const GLuint*>(v_arr));
glProgramUniform3uiv(m_shader_id, loc, count, reinterpret_cast<const GLuint*>(v_arr));
}else{
std::unique_ptr<GLuint[]> arr(new GLuint[count * 3]);
for(GLsizei i = 0; i < count; ++i){
@ -765,16 +728,15 @@ namespace gfx{
arr[i + 1] = v_arr[i].get(1);
arr[i + 2] = v_arr[i].get(2);
}
glUniform3uiv(loc, count, arr.get());
glProgramUniform3uiv(m_shader_id, loc, count, arr.get());
}
}
void shader_program::set_uniform(const char* name, GLsizei count, const vec4<GLuint>* v_arr){
set_uniform(get_uniform_loc(name), count, v_arr);
}
void shader_program::set_uniform(GLuint loc, GLsizei count, const vec4<GLuint>* v_arr){
use();
if constexpr(sizeof(v_arr[0]) == sizeof(GLuint[4])){
glUniform4uiv(loc, count, reinterpret_cast<const GLuint*>(v_arr));
glProgramUniform4uiv(m_shader_id, loc, count, reinterpret_cast<const GLuint*>(v_arr));
}else{
std::unique_ptr<GLuint[]> arr(new GLuint[count * 4]);
for(GLsizei i = 0; i < count; ++i){
@ -783,7 +745,7 @@ namespace gfx{
arr[i + 2] = v_arr[i].get(2);
arr[i + 3] = v_arr[i].get(3);
}
glUniform4uiv(loc, count, arr.get());
glProgramUniform4uiv(m_shader_id, loc, count, arr.get());
}
}
@ -800,20 +762,16 @@ namespace gfx{
set_uniform_4(get_uniform_loc(name), count, v_arr);
}
void shader_program::set_uniform_1(GLuint loc, GLsizei count, const GLuint* v_arr){
use();
glUniform1uiv(loc, count, v_arr);
glProgramUniform1uiv(m_shader_id, loc, count, v_arr);
}
void shader_program::set_uniform_2(GLuint loc, GLsizei count, const GLuint* v_arr){
use();
glUniform2uiv(loc, count, v_arr);
glProgramUniform2uiv(m_shader_id, loc, count, v_arr);
}
void shader_program::set_uniform_3(GLuint loc, GLsizei count, const GLuint* v_arr){
use();
glUniform3uiv(loc, count, v_arr);
glProgramUniform3uiv(m_shader_id, loc, count, v_arr);
}
void shader_program::set_uniform_4(GLuint loc, GLsizei count, const GLuint* v_arr){
use();
glUniform4uiv(loc, count, v_arr);
glProgramUniform4uiv(m_shader_id, loc, count, v_arr);
}
void shader_program::set_uniform(const char* name, const mat2<GLfloat>& m){
@ -826,25 +784,21 @@ namespace gfx{
set_uniform(get_uniform_loc(name), m);
}
void shader_program::set_uniform(GLuint loc, const mat2<GLfloat>& m){
use();
glUniformMatrix2fv(loc, 1, GL_FALSE, m);
glProgramUniformMatrix2fv(m_shader_id, loc, 1, GL_FALSE, m);
}
void shader_program::set_uniform(GLuint loc, const mat3<GLfloat>& m){
use();
glUniformMatrix3fv(loc, 1, GL_FALSE, m);
glProgramUniformMatrix3fv(m_shader_id, loc, 1, GL_FALSE, m);
}
void shader_program::set_uniform(GLuint loc, const mat4<GLfloat>& m){
use();
glUniformMatrix4fv(loc, 1, GL_FALSE, m);
glProgramUniformMatrix4fv(m_shader_id, loc, 1, GL_FALSE, m);
}
void shader_program::set_uniform(const char* name, GLsizei count, const mat2<GLfloat>* m_arr){
set_uniform(get_uniform_loc(name), count, m_arr);
}
void shader_program::set_uniform(GLuint loc, GLsizei count, const mat2<GLfloat>* m_arr){
use();
if constexpr(sizeof(m_arr[0]) == sizeof(GLfloat[4])){
glUniformMatrix2fv(loc, count, GL_FALSE, reinterpret_cast<const GLfloat*>(m_arr));
glProgramUniformMatrix2fv(m_shader_id, loc, count, GL_FALSE, reinterpret_cast<const GLfloat*>(m_arr));
}else{
std::unique_ptr<GLfloat[]> arr(new GLfloat[count * 4]);
for(GLsizei i = 0; i < count; ++i){
@ -853,16 +807,15 @@ namespace gfx{
arr[i + 2] = m_arr[i].get(2);
arr[i + 3] = m_arr[i].get(3);
}
glUniformMatrix2fv(loc, count, GL_FALSE, arr.get());
glProgramUniformMatrix2fv(m_shader_id, loc, count, GL_FALSE, arr.get());
}
}
void shader_program::set_uniform(const char* name, GLsizei count, const mat3<GLfloat>* m_arr){
set_uniform(get_uniform_loc(name), count, m_arr);
}
void shader_program::set_uniform(GLuint loc, GLsizei count, const mat3<GLfloat>* m_arr){
use();
if constexpr(sizeof(m_arr[0]) == sizeof(GLfloat[9])){
glUniformMatrix3fv(loc, count, GL_FALSE, reinterpret_cast<const GLfloat*>(m_arr));
glProgramUniformMatrix3fv(m_shader_id, loc, count, GL_FALSE, reinterpret_cast<const GLfloat*>(m_arr));
}else{
std::unique_ptr<GLfloat[]> arr(new GLfloat[count * 9]);
for(GLsizei i = 0; i < count; ++i){
@ -876,16 +829,15 @@ namespace gfx{
arr[i + 7] = m_arr[i].get(7);
arr[i + 8] = m_arr[i].get(8);
}
glUniformMatrix3fv(loc, count, GL_FALSE, arr.get());
glProgramUniformMatrix3fv(m_shader_id, loc, count, GL_FALSE, arr.get());
}
}
void shader_program::set_uniform(const char* name, GLsizei count, const mat4<GLfloat>* m_arr){
set_uniform(get_uniform_loc(name), count, m_arr);
}
void shader_program::set_uniform(GLuint loc, GLsizei count, const mat4<GLfloat>* m_arr){
use();
if constexpr(sizeof(m_arr[0]) == sizeof(GLfloat[16])){
glUniformMatrix4fv(loc, count, GL_FALSE, reinterpret_cast<const GLfloat*>(m_arr));
glProgramUniformMatrix4fv(m_shader_id, loc, count, GL_FALSE, reinterpret_cast<const GLfloat*>(m_arr));
}else{
std::unique_ptr<GLfloat[]> arr(new GLfloat[count * 16]);
for(GLsizei i = 0; i < count; ++i){
@ -906,7 +858,7 @@ namespace gfx{
arr[i + 14] = m_arr[i].get(14);
arr[i + 15] = m_arr[i].get(15);
}
glUniformMatrix4fv(loc, count, GL_FALSE, arr.get());
glProgramUniformMatrix4fv(m_shader_id, loc, count, GL_FALSE, arr.get());
}
}
@ -938,39 +890,30 @@ namespace gfx{
set_uniform_mat4x3(get_uniform_loc(name), count, m_arr);
}
void shader_program::set_uniform_mat2(GLuint loc, GLsizei count, const GLfloat* m_arr){
use();
glUniformMatrix2fv(loc, count, GL_FALSE, m_arr);
glProgramUniformMatrix2fv(m_shader_id, loc, count, GL_FALSE, m_arr);
}
void shader_program::set_uniform_mat3(GLuint loc, GLsizei count, const GLfloat* m_arr){
use();
glUniformMatrix3fv(loc, count, GL_FALSE, m_arr);
glProgramUniformMatrix3fv(m_shader_id, loc, count, GL_FALSE, m_arr);
}
void shader_program::set_uniform_mat4(GLuint loc, GLsizei count, const GLfloat* m_arr){
use();
glUniformMatrix4fv(loc, count, GL_FALSE, m_arr);
glProgramUniformMatrix4fv(m_shader_id, loc, count, GL_FALSE, m_arr);
}
void shader_program::set_uniform_mat2x3(GLuint loc, GLsizei count, const GLfloat* m_arr){
use();
glUniformMatrix2x3fv(loc, count, GL_FALSE, m_arr);
glProgramUniformMatrix2x3fv(m_shader_id, loc, count, GL_FALSE, m_arr);
}
void shader_program::set_uniform_mat3x2(GLuint loc, GLsizei count, const GLfloat* m_arr){
use();
glUniformMatrix3x2fv(loc, count, GL_FALSE, m_arr);
glProgramUniformMatrix3x2fv(m_shader_id, loc, count, GL_FALSE, m_arr);
}
void shader_program::set_uniform_mat2x4(GLuint loc, GLsizei count, const GLfloat* m_arr){
use();
glUniformMatrix2x4fv(loc, count, GL_FALSE, m_arr);
glProgramUniformMatrix2x4fv(m_shader_id, loc, count, GL_FALSE, m_arr);
}
void shader_program::set_uniform_mat4x2(GLuint loc, GLsizei count, const GLfloat* m_arr){
use();
glUniformMatrix4x2fv(loc, count, GL_FALSE, m_arr);
glProgramUniformMatrix4x2fv(m_shader_id, loc, count, GL_FALSE, m_arr);
}
void shader_program::set_uniform_mat3x4(GLuint loc, GLsizei count, const GLfloat* m_arr){
use();
glUniformMatrix3x4fv(loc, count, GL_FALSE, m_arr);
glProgramUniformMatrix3x4fv(m_shader_id, loc, count, GL_FALSE, m_arr);
}
void shader_program::set_uniform_mat4x3(GLuint loc, GLsizei count, const GLfloat* m_arr){
use();
glUniformMatrix4x3fv(loc, count, GL_FALSE, m_arr);
glProgramUniformMatrix4x3fv(m_shader_id, loc, count, GL_FALSE, m_arr);
}
}

76
src/graphics/texture.cpp
View File

@ -23,12 +23,12 @@
namespace gfx{
texture::texture(){
glGenTextures(1, &m_tex_id);
glCreateTextures(GL_TEXTURE_2D, 1, &m_tex_id);
}
texture::texture(GLenum format, GLsizei w, GLsizei h, GLenum type):
m_width(w), m_height(h)
{
glGenTextures(1, &m_tex_id);
glCreateTextures(GL_TEXTURE_2D, 1, &m_tex_id);
resize(format, w, h, type);
}
texture::texture(const image& i):
@ -55,33 +55,49 @@ namespace gfx{
return false;
if(!m_tex_id)
glGenTextures(1, &m_tex_id);
glCreateTextures(GL_TEXTURE_2D, 1, &m_tex_id);
m_width = i.get_width();
m_height = i.get_height();
bind();
switch(i.get_channels()){
case 1:
glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, m_width, m_height, 0, GL_RED, GL_UNSIGNED_BYTE, i.data());
glTextureStorage2D(m_tex_id, 1, GL_R8, m_width, m_height);
glTextureSubImage2D(m_tex_id, 0, 0, 0, m_width, m_height, GL_RED, GL_UNSIGNED_BYTE, i.data());
break;
case 2:
glTexImage2D(GL_TEXTURE_2D, 0, GL_RG, m_width, m_height, 0, GL_RG, GL_UNSIGNED_BYTE, i.data());
glTextureStorage2D(m_tex_id, 1, GL_RG8, m_width, m_height);
glTextureSubImage2D(m_tex_id, 0, 0, 0, m_width, m_height, GL_RG, GL_UNSIGNED_BYTE, i.data());
break;
case 3:
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, m_width, m_height, 0, GL_RGB, GL_UNSIGNED_BYTE, i.data());
glTextureStorage2D(m_tex_id, 1, GL_RGB8, m_width, m_height);
glTextureSubImage2D(m_tex_id, 0, 0, 0, m_width, m_height, GL_RGB, GL_UNSIGNED_BYTE, i.data());
break;
case 4:
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_width, m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, i.data());
glTextureStorage2D(m_tex_id, 1, GL_RGBA8, m_width, m_height);
glTextureSubImage2D(m_tex_id, 0, 0, 0, m_width, m_height, GL_RGBA, GL_UNSIGNED_BYTE, i.data());
break;
default:
return false;
}
glGenerateMipmap(GL_TEXTURE_2D);
glGenerateTextureMipmap(m_tex_id);
return true;
}
void texture::resize(GLenum format, GLsizei w, GLsizei h, GLenum type){
bind();
glTexImage2D(GL_TEXTURE_2D, 0, format, w, h, 0, format, type, NULL);
glGenerateMipmap(GL_TEXTURE_2D);
switch(format){
case GL_RED:
glTextureStorage2D(m_tex_id, 1, GL_R8, w, h);
break;
case GL_RG:
glTextureStorage2D(m_tex_id, 1, GL_RG8, w, h);
break;
case GL_RGB:
glTextureStorage2D(m_tex_id, 1, GL_RGB8, w, h);
break;
case GL_RGBA:
glTextureStorage2D(m_tex_id, 1, GL_RGBA8, w, h);
break;
};
glTextureSubImage2D(m_tex_id, 0, 0, 0, w, h, format, type, NULL);
glGenerateTextureMipmap(m_tex_id);
}
void texture::set_width(int w){
@ -96,41 +112,33 @@ namespace gfx{
}
void texture::set_wrap_mode(wrap w){
bind();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, static_cast<GLint>(w));
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, static_cast<GLint>(w));
glTextureParameteri(m_tex_id, GL_TEXTURE_WRAP_S, static_cast<GLint>(w));
glTextureParameteri(m_tex_id, GL_TEXTURE_WRAP_T, static_cast<GLint>(w));
}
void texture::set_wrap_mode(wrap w, wrap h){
bind();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, static_cast<GLint>(w));
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, static_cast<GLint>(h));
glTextureParameteri(m_tex_id, GL_TEXTURE_WRAP_S, static_cast<GLint>(w));
glTextureParameteri(m_tex_id, GL_TEXTURE_WRAP_T, static_cast<GLint>(h));
}
void texture::set_wrap_x(wrap w){
bind();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, static_cast<GLint>(w));
glTexParameteri(m_tex_id, GL_TEXTURE_WRAP_S, static_cast<GLint>(w));
}
void texture::set_wrap_y(wrap h){
bind();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, static_cast<GLint>(h));
glTextureParameteri(m_tex_id, GL_TEXTURE_WRAP_T, static_cast<GLint>(h));
}
void texture::set_border_color(GLfloat r, GLfloat g, GLfloat b, GLfloat a){
GLfloat arr[4] = {r, g, b, a};
bind();
glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, arr);
glTextureParameterfv(m_tex_id, GL_TEXTURE_BORDER_COLOR, arr);
}
void texture::set_filter(minfilter min, magfilter mag){
bind();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, static_cast<GLint>(min));
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, static_cast<GLint>(mag));
glTextureParameteri(m_tex_id, GL_TEXTURE_MIN_FILTER, static_cast<GLint>(min));
glTextureParameteri(m_tex_id, GL_TEXTURE_MAG_FILTER, static_cast<GLint>(mag));
}
void texture::set_mag_filter(magfilter m){
bind();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, static_cast<GLint>(m));
glTextureParameteri(m_tex_id, GL_TEXTURE_MAG_FILTER, static_cast<GLint>(m));
}
void texture::set_min_filter(minfilter m){
bind();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, static_cast<GLint>(m));
glTextureParameteri(m_tex_id, GL_TEXTURE_MIN_FILTER, static_cast<GLint>(m));
}
int texture::get_width()const{
@ -147,10 +155,8 @@ namespace gfx{
void texture::bind()const{
glBindTexture(GL_TEXTURE_2D, m_tex_id);
}
void texture::use(GLuint tunit, GLint uloc)const{
glActiveTexture(GL_TEXTURE0 + tunit);
bind();
glUniform1i(uloc, tunit);
void texture::bind_unit(GLuint tunit)const{
glBindTextureUnit(tunit, m_tex_id);
}

212
src/graphics/vao.cpp
View File

@ -21,202 +21,44 @@
namespace gfx{
void vertex_attribute::enable_array_mode(){
glBindVertexArray(m_vao);
glEnableVertexAttribArray(m_index);
void vertex_attribute::enable(){
glEnableVertexArrayAttrib(m_vao, m_index);
}
void vertex_attribute::disable_array_mode(){
glBindVertexArray(m_vao);
glEnableVertexAttribArray(m_index);
void vertex_attribute::disable(){
glDisableVertexArrayAttrib(m_vao, m_index);
}
void vertex_attribute::set_float_pointer(GLint size, GLsizei stride, GLsizei offset){
glBindVertexArray(m_vao);
glVertexAttribPointer(m_index, size, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * stride, (void*)(sizeof(GLfloat) * offset));
void vertex_attribute::associate_with(GLuint buffer_binding){
glVertexArrayAttribBinding(m_vao, m_index, buffer_binding);
}
void vertex_attribute::set_double_pointer(GLint size, GLsizei stride, GLsizei offset){
glBindVertexArray(m_vao);
glVertexAttribPointer(m_index, size, GL_DOUBLE, GL_FALSE, sizeof(GLdouble) * stride, (void*)(sizeof(GLdouble) * offset));
void vertex_attribute::set_float_array(GLint size, GLsizei offset){
glVertexArrayAttribFormat(m_vao, m_index, size, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * offset);
}
void vertex_attribute::set_byte_pointer(GLint size, GLsizei stride, GLsizei offset){
glBindVertexArray(m_vao);
glVertexAttribPointer(m_index, size, GL_BYTE, GL_FALSE, sizeof(GLbyte) * stride, (void*)(sizeof(GLbyte) * offset));
void vertex_attribute::set_double_array(GLint size, GLsizei offset){
glVertexArrayAttribFormat(m_vao, m_index, size, GL_DOUBLE, GL_FALSE, sizeof(GLdouble) * offset);
}
void vertex_attribute::set_ubyte_pointer(GLint size, GLsizei stride, GLsizei offset){
glBindVertexArray(m_vao);
glVertexAttribPointer(m_index, size, GL_UNSIGNED_BYTE, GL_FALSE, sizeof(GLubyte) * stride, (void*)(sizeof(GLubyte) * offset));
void vertex_attribute::set_byte_array(GLint size, GLsizei offset){
glVertexArrayAttribFormat(m_vao, m_index, size, GL_BYTE, GL_FALSE, sizeof(GLbyte) * offset);
}
void vertex_attribute::set_short_pointer(GLint size, GLsizei stride, GLsizei offset){
glBindVertexArray(m_vao);
glVertexAttribPointer(m_index, size, GL_SHORT, GL_FALSE, sizeof(GLshort) * stride, (void*)(sizeof(GLshort) * offset));
void vertex_attribute::set_ubyte_array(GLint size, GLsizei offset){
glVertexArrayAttribFormat(m_vao, m_index, size, GL_UNSIGNED_BYTE, GL_FALSE, sizeof(GLubyte) * offset);
}
void vertex_attribute::set_ushort_pointer(GLint size, GLsizei stride, GLsizei offset){
glBindVertexArray(m_vao);
glVertexAttribPointer(m_index, size, GL_UNSIGNED_SHORT, GL_FALSE, sizeof(GLushort) * stride, (void*)(sizeof(GLushort) * offset));
void vertex_attribute::set_short_array(GLint size, GLsizei offset){
glVertexArrayAttribFormat(m_vao, m_index, size, GL_SHORT, GL_FALSE, sizeof(GLshort) * offset);
}
void vertex_attribute::set_int_pointer(GLint size, GLsizei stride, GLsizei offset){
glBindVertexArray(m_vao);
glVertexAttribPointer(m_index, size, GL_INT, GL_FALSE, sizeof(GLint) * stride, (void*)(sizeof(GLint) * offset));
void vertex_attribute::set_ushort_array(GLint size, GLsizei offset){
glVertexArrayAttribFormat(m_vao, m_index, size, GL_UNSIGNED_SHORT, GL_FALSE, sizeof(GLushort) * offset);
}
void vertex_attribute::set_uint_pointer(GLint size, GLsizei stride, GLsizei offset){
glBindVertexArray(m_vao);
glVertexAttribPointer(m_index, size, GL_UNSIGNED_INT, GL_FALSE, sizeof(GLuint) * stride, (void*)(sizeof(GLuint) * offset));
void vertex_attribute::set_int_array(GLint size, GLsizei offset){
glVertexArrayAttribFormat(m_vao, m_index, size, GL_INT, GL_FALSE, sizeof(GLint) * offset);
}
void vertex_attribute::set(GLfloat x){
glBindVertexArray(m_vao);
glVertexAttrib1f(m_index, x);
}
void vertex_attribute::set(GLshort x){
glBindVertexArray(m_vao);
glVertexAttrib1s(m_index, x);
}
void vertex_attribute::set(GLdouble x){
glBindVertexArray(m_vao);
glVertexAttrib1d(m_index, x);
}
void vertex_attribute::set(GLint x){
glBindVertexArray(m_vao);
glVertexAttribI1i(m_index, x);
}
void vertex_attribute::set(GLuint x){
glBindVertexArray(m_vao);
glVertexAttribI1ui(m_index, x);
}
void vertex_attribute::set(GLfloat x, GLfloat y){
glBindVertexArray(m_vao);
glVertexAttrib2f(m_index, x, y);
}
void vertex_attribute::set(GLshort x, GLshort y){
glBindVertexArray(m_vao);
glVertexAttrib2s(m_index, x, y);
}
void vertex_attribute::set(GLdouble x, GLdouble y){
glBindVertexArray(m_vao);
glVertexAttrib2d(m_index, x, y);
}
void vertex_attribute::set(GLint x, GLint y){
glBindVertexArray(m_vao);
glVertexAttribI2i(m_index, x, y);
}
void vertex_attribute::set(GLuint x, GLuint y){
glBindVertexArray(m_vao);
glVertexAttribI2ui(m_index, x, y);
}
void vertex_attribute::set(GLfloat x, GLfloat y, GLfloat z){
glBindVertexArray(m_vao);
glVertexAttrib3f(m_index, x, y, z);
}
void vertex_attribute::set(GLshort x, GLshort y, GLshort z){
glBindVertexArray(m_vao);
glVertexAttrib3s(m_index, x, y, z);
}
void vertex_attribute::set(GLdouble x, GLdouble y, GLdouble z){
glBindVertexArray(m_vao);
glVertexAttrib3d(m_index, x, y, z);
}
void vertex_attribute::set(GLint x, GLint y, GLint z){
glBindVertexArray(m_vao);
glVertexAttribI3i(m_index, x, y, z);
}
void vertex_attribute::set(GLuint x, GLuint y, GLuint z){
glBindVertexArray(m_vao);
glVertexAttribI3ui(m_index, x, y, z);
}
void vertex_attribute::set(GLfloat x, GLfloat y, GLfloat z, GLfloat w){
glBindVertexArray(m_vao);
glVertexAttrib4f(m_index, x, y, z, w);
}
void vertex_attribute::set(GLshort x, GLshort y, GLshort z, GLshort w){
glBindVertexArray(m_vao);
glVertexAttrib4s(m_index, x, y, z, w);
}
void vertex_attribute::set(GLdouble x, GLdouble y, GLdouble z, GLdouble w){
glBindVertexArray(m_vao);
glVertexAttrib4d(m_index, x, y, z, w);
}
void vertex_attribute::set(GLint x, GLint y, GLint z, GLint w){
glBindVertexArray(m_vao);
glVertexAttribI4i(m_index, x, y, z, w);
}
void vertex_attribute::set(GLuint x, GLuint y, GLuint z, GLuint w){
glBindVertexArray(m_vao);
glVertexAttribI4ui(m_index, x, y, z, w);
}
void vertex_attribute::set(const vec2<GLfloat>& v){
glBindVertexArray(m_vao);
glVertexAttrib2fv(m_index, v);
}
void vertex_attribute::set(const vec2<GLshort>& v){
glBindVertexArray(m_vao);
glVertexAttrib2sv(m_index, v);
}
void vertex_attribute::set(const vec2<GLdouble>& v){
glBindVertexArray(m_vao);
glVertexAttrib2dv(m_index, v);
}
void vertex_attribute::set(const vec2<GLint>& v){
glBindVertexArray(m_vao);
glVertexAttribI2iv(m_index, v);
}
void vertex_attribute::set(const vec2<GLuint>& v){
glBindVertexArray(m_vao);
glVertexAttribI2uiv(m_index, v);
}
void vertex_attribute::set(const vec3<GLfloat>& v){
glBindVertexArray(m_vao);
glVertexAttrib3fv(m_index, v);
}
void vertex_attribute::set(const vec3<GLshort>& v){
glBindVertexArray(m_vao);
glVertexAttrib3sv(m_index, v);
}
void vertex_attribute::set(const vec3<GLdouble>& v){
glBindVertexArray(m_vao);
glVertexAttrib3dv(m_index, v);
}
void vertex_attribute::set(const vec3<GLint>& v){
glBindVertexArray(m_vao);
glVertexAttribI3iv(m_index, v);
}
void vertex_attribute::set(const vec3<GLuint>& v){
glBindVertexArray(m_vao);
glVertexAttribI3uiv(m_index, v);
}
void vertex_attribute::set(const vec4<GLfloat>& v){
glBindVertexArray(m_vao);
glVertexAttrib4fv(m_index, v);
}
void vertex_attribute::set(const vec4<GLshort>& v){
glBindVertexArray(m_vao);
glVertexAttrib4sv(m_index, v);
}
void vertex_attribute::set(const vec4<GLdouble>& v){
glBindVertexArray(m_vao);
glVertexAttrib4dv(m_index, v);
}
void vertex_attribute::set(const vec4<GLint>& v){
glBindVertexArray(m_vao);
glVertexAttrib4iv(m_index, v);
}
void vertex_attribute::set(const vec4<GLuint>& v){
glBindVertexArray(m_vao);
glVertexAttrib4uiv(m_index, v);
}
void vertex_attribute::set(const vec4<GLbyte>& v){
glBindVertexArray(m_vao);
glVertexAttrib4bv(m_index, v);
}
void vertex_attribute::set(const vec4<GLubyte>& v){
glBindVertexArray(m_vao);
glVertexAttrib4ubv(m_index, v);
}
void vertex_attribute::set(const vec4<GLushort>& v){
glBindVertexArray(m_vao);
glVertexAttrib4usv(m_index, v);
void vertex_attribute::set_uint_array(GLint size, GLsizei offset){
glVertexArrayAttribFormat(m_vao, m_index, size, GL_UNSIGNED_INT, GL_FALSE, sizeof(GLuint) * offset);
}
vao::vao(){
glGenVertexArrays(1, &m_buffer);
glCreateVertexArrays(1, &m_buffer);
}
vao::vao(vao&& v):
m_buffer(std::exchange(v.m_buffer, 0)){}
@ -232,6 +74,12 @@ namespace gfx{
return m_buffer;
}
void vao::bind_buffer(const vbo& buffer, GLuint bind_point, GLuint offset, GLuint stride){
glVertexArrayVertexBuffer(m_buffer, bind_point, buffer.raw(), offset, stride);
}
void vao::bind_element_buffer(const vbo& buffer){
glVertexArrayElementBuffer(m_buffer, buffer.raw());
}
vertex_attribute vao::get_attribute(int index){
return vertex_attribute(m_buffer, index);
}

82
src/graphics/vbo.cpp
View File

@ -18,7 +18,6 @@
#include "graphics/vbo.hpp"
#include "util/minmax.hpp"
#include "graphics/scoped_buffer_bind.hpp"
#include <utility> //exchange, swap, move
@ -27,28 +26,21 @@ namespace gfx{
vbo::vbo(size_t size, usage t):
m_buffer_size(0)
{
glGenBuffers(1, &m_buffer);
m_bi.set_buffer_id(m_buffer);
bind(buffer::copy_write);
glBufferData(m_bi.get_bound_id(), size, NULL, static_cast<GLenum>(t));
glCreateBuffers(1, &m_buffer);
glNamedBufferData(m_buffer, size, NULL, static_cast<GLenum>(t));
}
vbo::vbo(const vbo& v):
m_buffer_size(v.m_buffer_size)
{
glGenBuffers(1, &m_buffer);
m_bi.set_buffer_id(m_buffer);
scoped_buffer_bind copy_bind(m_bi, buffer::copy_read);
if(!copy_bind.valid())
return;
scoped_vbo_map<void> data = v.map(buffer::copy_read, maptype::READ);
glCreateBuffers(1, &m_buffer);
scoped_vbo_map<void> data = v.map(maptype::READ);
if(!data)
return;
glBufferData(m_bi.get_bound_id(), v.get_size(), data, static_cast<GLenum>(v.get_usage()));
glNamedBufferData(m_buffer, v.get_size(), data, static_cast<GLenum>(v.get_usage()));
}
vbo::vbo(vbo&& v):
m_buffer(std::exchange(v.m_buffer, 0)),
m_buffer_size(v.m_buffer_size),
m_bi(std::move(v.m_bi)){}
m_buffer_size(v.m_buffer_size){}
vbo::~vbo(){
if(m_buffer)
glDeleteBuffers(1, &m_buffer);
@ -59,45 +51,20 @@ namespace gfx{
}
vbo& vbo::operator=(vbo&& v){
std::swap(m_buffer, v.m_buffer);
m_bi = std::move(v.m_bi);
m_buffer_size = v.m_buffer_size;
return *this;
}
bool vbo::bind(gl_buffer_manager& buf)const{
if(get_bound_id() == buf.get_buffer_id())
return true;
if(!m_bi.bind(buf))
return false;
glBindBuffer(buf.get_buffer_id(), m_buffer);
return true;
}
bool vbo::bind_lock(gl_buffer_manager& buf)const{
if(!m_bi.bind_lock(buf))
return false;
return true;
}
void vbo::bind_unlock()const{
m_bi.unlock();
}
void vbo::unbind()const{
m_bi.unbind();
}
gl_buffer_manager* vbo::get_bound_buffer()const{
return m_bi.get_bound_buffer();
}
GLenum vbo::get_bound_id()const{
return m_bi.get_bound_id();
}
bool vbo::buffer(const void* data, size_t datasize){
if(datasize + m_buffer_size > get_cap()){
if(!resize(util::max(datasize + m_buffer_size, get_cap() * 2)))
return false;
}
scoped_buffer_bind copy_bind(m_bi, buffer::copy_write);
if(!copy_bind.valid())
return false;
glBufferSubData(get_bound_id(), get_size(), datasize, data);
glNamedBufferSubData(m_buffer, get_size(), datasize, data);
m_buffer_size += datasize;
return true;
}
@ -111,8 +78,8 @@ namespace gfx{
GLuint vbo::raw()const{
return m_buffer;
}
scoped_vbo_map<void> vbo::map(gl_buffer_manager& target, maptype m)const{
return scoped_vbo_map<void>(m_bi, target, m_buffer, m);
scoped_vbo_map<void> vbo::map(maptype m)const{
return scoped_vbo_map<void>(m_buffer, m);
}
void vbo::clear(){
@ -122,57 +89,50 @@ namespace gfx{
return m_buffer_size;
}
size_t vbo::get_cap()const{
scoped_buffer_bind copy_bind(m_bi, buffer::copy_read);
GLint retval;
glGetBufferParameteriv(get_bound_id(), GL_BUFFER_SIZE, &retval);
glGetNamedBufferParameteriv(m_buffer, GL_BUFFER_SIZE, &retval);
return retval;
}
auto vbo::get_usage()const -> usage{
scoped_buffer_bind copy_bind(m_bi, buffer::copy_read);
GLint retval;
glGetBufferParameteriv(get_bound_id(), GL_BUFFER_USAGE, &retval);
glGetNamedBufferParameteriv(m_buffer, GL_BUFFER_USAGE, &retval);
return static_cast<usage>(retval);
}
bool vbo::copy_buffer(vbo& dest, const vbo& src){
scoped_buffer_bind copy_bind(dest.m_bi, buffer::copy_write);
if(!copy_bind.valid())
return false;
size_t bytes = util::min(dest.get_cap(), src.get_size());
scoped_vbo_map<void> data(src.m_bi, buffer::copy_read, src.m_buffer, maptype::READ);
scoped_vbo_map<void> data(src.m_buffer, maptype::READ);
if(!data.valid())
return false;
return dest.buffer(data, bytes);
}
scoped_vbo_map<void>::scoped_vbo_map(const buffer_accessor& ba, gl_buffer_manager& bm, GLuint bid, vbo::maptype m):
m_bind(ba, bm, bid)
scoped_vbo_map<void>::scoped_vbo_map(GLuint bid, vbo::maptype m):
m_buffer(bid)
{
if(!m_bind.valid())
return;
m_data = reinterpret_cast<pointer>(glMapBuffer(m_bind.get_bound_id(), static_cast<GLenum>(m)));
m_data = reinterpret_cast<pointer>(glMapNamedBuffer(m_buffer, static_cast<GLenum>(m)));
}
scoped_vbo_map<void>::scoped_vbo_map(scoped_vbo_map&& m):
m_data(std::exchange(m.m_data, nullptr)),
m_bind(std::move(m.m_bind)){}
m_buffer(std::exchange(m.m_buffer, 0)){}
scoped_vbo_map<void>::~scoped_vbo_map(){
if(m_data){
glUnmapBuffer(m_bind.get_bound_id());
glUnmapNamedBuffer(m_buffer);
}
}
scoped_vbo_map<void>& scoped_vbo_map<void>::operator=(scoped_vbo_map&& m){
std::swap(m_data, m.m_data);
m_bind = std::move(m.m_bind);
std::swap(m_buffer, m.m_buffer);
return *this;
}
auto scoped_vbo_map<void>::length()const -> size_type{
GLint64 retval;
glGetBufferParameteri64v(m_bind.get_bound_id(), GL_BUFFER_MAP_LENGTH, &retval);
glGetNamedBufferParameteri64v(m_buffer, GL_BUFFER_MAP_LENGTH, &retval);
return retval;
}
auto scoped_vbo_map<void>::release() -> pointer{
m_buffer = 0;
return std::exchange(m_data, nullptr);
}
scoped_vbo_map<void>::operator pointer(){

25
src/main.cpp
View File

@ -320,11 +320,11 @@ int main(){
}
//tell gl how to interpret the data in the vbo
normal_vao.bind();
normal_vbo.bind(gfx::buffer::array);
normal_vao.bind_buffer(normal_vbo, 0, 0, sizeof(GLfloat) * 3);
auto attrib = normal_vao.get_attribute(0);
attrib.set_float_pointer(3, 3, 0);
attrib.enable_array_mode();
attrib.set_float_array(3, 0);
attrib.associate_with(0);
attrib.enable();
constexpr GLfloat square_coords[] = {
-1, 1, 0, 1,
@ -341,14 +341,16 @@ int main(){
screen_vbo.buffer(square_coords, sizeof(square_coords));
screen_vao.bind();
screen_vbo.bind(gfx::buffer::array);
screen_vao.bind_buffer(screen_vbo, 0, 0, sizeof(GLfloat) * 4);
attrib = screen_vao.get_attribute(0);
attrib.set_float_pointer(2, 4, 0);
attrib.enable_array_mode();
attrib.set_float_array(2, 0);
attrib.associate_with(0);
attrib.enable();
attrib = screen_vao.get_attribute(1);
attrib.set_float_pointer(2, 4, 2);
attrib.enable_array_mode();
attrib.set_float_array(2, 2);
attrib.associate_with(0);
attrib.enable();
while(!manager.should_close()){
//render using program 'prog' with data from 'vao'
@ -358,7 +360,8 @@ int main(){
normal_shader.use();
normal_vao.bind();
glDrawArrays(GL_POINTS, 0, 9);
fbo.unbind();
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glDisable(GL_DEPTH_TEST);
screen_shader.use();
screen_shader.set_uniform("fbtexture", tex, 0);