From afd625b06702e7a25e0730601f03955832b64e65 Mon Sep 17 00:00:00 2001 From: Mikko Rasa Date: Mon, 27 Aug 2012 00:37:01 +0300 Subject: [PATCH 01/16] Remove alignment where it doesn't belong --- source/extension.cpp | 2 +- source/meshbuilder.h | 2 +- source/texture2d.h | 2 +- source/vertexarray.h | 18 +++++++++--------- source/vertexarraybuilder.h | 2 +- 5 files changed, 13 insertions(+), 13 deletions(-) diff --git a/source/extension.cpp b/source/extension.cpp index c846c59d..bc43ae8b 100644 --- a/source/extension.cpp +++ b/source/extension.cpp @@ -39,7 +39,7 @@ bool is_supported(const string &ext) } /* XXX Conceptually a bit weird place for this, but I couldn't really come up - with anything better that would still be transparent. */ + with anything better that would still be transparent. */ if(extensions.count("GL_ARB_shader_objects")) init_arb_shader_objects(); if(extensions.count("GL_ARB_vertex_shader")) diff --git a/source/meshbuilder.h b/source/meshbuilder.h index d34da63b..0755eeb2 100644 --- a/source/meshbuilder.h +++ b/source/meshbuilder.h @@ -12,7 +12,7 @@ class Mesh; class MeshBuilder: public PrimitiveBuilder { private: - Mesh &mesh; + Mesh &mesh; Batch *batch; public: diff --git a/source/texture2d.h b/source/texture2d.h index 35346e00..994c4efd 100644 --- a/source/texture2d.h +++ b/source/texture2d.h @@ -66,7 +66,7 @@ private: void image(const Graphics::Image &); public: - unsigned get_width() const { return width; } + unsigned get_width() const { return width; } unsigned get_height() const { return height; } private: diff --git a/source/vertexarray.h b/source/vertexarray.h index 039dfa8b..7e6d04f5 100644 --- a/source/vertexarray.h +++ b/source/vertexarray.h @@ -58,16 +58,16 @@ public: const VertexFormat &get_format() const { return format; } const std::vector &get_data() const { return data; } - void use_vertex_buffer(); - void use_vertex_buffer(Buffer *); - void reserve(unsigned); - unsigned size() const { return data.size()/stride; } - void clear(); - void reset(const VertexFormat &); - void apply() const; - float *append(); + void use_vertex_buffer(); + void use_vertex_buffer(Buffer *); + void reserve(unsigned); + unsigned size() const { return data.size()/stride; } + void clear(); + void reset(const VertexFormat &); + void apply() const; + float *append(); float *modify(unsigned); - const float *operator[](unsigned i) const { return &data[0]+i*stride; } + const float *operator[](unsigned i) const { return &data[0]+i*stride; } private: void set_dirty(); diff --git a/source/vertexarraybuilder.h b/source/vertexarraybuilder.h index b956660f..575a4753 100644 --- a/source/vertexarraybuilder.h +++ b/source/vertexarraybuilder.h @@ -13,7 +13,7 @@ class VertexArray; class VertexArrayBuilder: public VertexBuilder { private: - VertexArray &array; + VertexArray &array; VertexArrayBuilder(const VertexArrayBuilder &); public: -- 2.43.0 From e45ade69a77f7ba91b47bebad604ae29b5705b21 Mon Sep 17 00:00:00 2001 From: Mikko Rasa Date: Mon, 27 Aug 2012 00:38:08 +0300 Subject: [PATCH 02/16] Pass the Renderer to ObjectInstance::get_level_of_detail As I recall, the camera was put in renderer to allow view-dependent rendering without the need to pass data outside the rendering pipeline. This is one of the cases where it is needed. --- source/object.cpp | 2 +- source/objectinstance.h | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/source/object.cpp b/source/object.cpp index f23f6658..06062fc0 100644 --- a/source/object.cpp +++ b/source/object.cpp @@ -96,7 +96,7 @@ void Object::render(Renderer &renderer, const ObjectInstance &inst, const Tag &t renderer.set_texturing(pass->get_texturing()); inst.setup_render(renderer, tag); - unsigned lod = min(inst.get_level_of_detail(), meshes.size()-1); + unsigned lod = min(inst.get_level_of_detail(renderer), meshes.size()-1); meshes[lod]->draw(renderer); inst.finish_render(renderer, tag); } diff --git a/source/objectinstance.h b/source/objectinstance.h index 3dc5da6a..6094517b 100644 --- a/source/objectinstance.h +++ b/source/objectinstance.h @@ -41,7 +41,7 @@ public: anything. */ virtual void finish_render(Renderer &, const Tag &) const { } - virtual unsigned get_level_of_detail() const { return 0; } + virtual unsigned get_level_of_detail(const Renderer &) const { return 0; } }; } // namespace GL -- 2.43.0 From 69bd7cdfb824c9189ef89e112222141c28b163f6 Mon Sep 17 00:00:00 2001 From: Mikko Rasa Date: Mon, 27 Aug 2012 00:46:25 +0300 Subject: [PATCH 03/16] Pull glDrawRangeElements from version_1_2.h --- source/batch.cpp | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/source/batch.cpp b/source/batch.cpp index cdbba871..375c52e9 100644 --- a/source/batch.cpp +++ b/source/batch.cpp @@ -5,6 +5,7 @@ #include "extension.h" #include "nv_primitive_restart.h" #include "vertexarray.h" +#include "version_1_2.h" using namespace std; @@ -24,7 +25,11 @@ Batch::Batch(PrimitiveType t): next_in_ibuf(0), prev_in_ibuf(0), dirty(false) -{ } +{ + /* XXX Should probably provide a fallback to glDrawElements since this class + is pretty much required to render anything. */ + static RequireVersion _ver(1, 2); +} Batch::~Batch() { -- 2.43.0 From 485315ca65cb40f33253008a79b0933997bd74f5 Mon Sep 17 00:00:00 2001 From: Mikko Rasa Date: Mon, 27 Aug 2012 23:15:23 +0300 Subject: [PATCH 04/16] Remove the global drawing functions --- source/vertexarray.cpp | 22 ---------------------- source/vertexarray.h | 17 ----------------- 2 files changed, 39 deletions(-) diff --git a/source/vertexarray.cpp b/source/vertexarray.cpp index 7716c5b2..e5e81204 100644 --- a/source/vertexarray.cpp +++ b/source/vertexarray.cpp @@ -235,27 +235,5 @@ VertexArray::Loader::Loader(VertexArray &a): add("attrib4", static_cast(&Loader::attrib)); } - -void array_element(int i) -{ - glArrayElement(i); -} - -void draw_arrays(PrimitiveType mode, int first, unsigned count) -{ - glDrawArrays(mode, first, count); -} - -void draw_elements(PrimitiveType mode, unsigned count, DataType type, const void *indices) -{ - glDrawElements(mode, count, type, indices); -} - -void draw_range_elements(PrimitiveType mode, unsigned low, unsigned high, unsigned count, DataType type, const void *indices) -{ - static RequireVersion _ver(1, 2); - glDrawRangeElements(mode, low, high, count, type, indices); -} - } // namespace GL } // namespace Msp diff --git a/source/vertexarray.h b/source/vertexarray.h index 7e6d04f5..6be5616e 100644 --- a/source/vertexarray.h +++ b/source/vertexarray.h @@ -73,23 +73,6 @@ private: void set_dirty(); }; -void array_element(int); -void draw_arrays(PrimitiveType, int, unsigned); -void draw_elements(PrimitiveType, unsigned, DataType, const void *); -void draw_range_elements(PrimitiveType, unsigned, unsigned, unsigned, DataType, const void *); - -inline void draw_elements(PrimitiveType mode, unsigned count, const unsigned *indices) -{ draw_elements(mode, count, UNSIGNED_INT, indices); } - -inline void draw_elements(PrimitiveType mode, unsigned count, const unsigned short *indices) -{ draw_elements(mode, count, UNSIGNED_SHORT, indices); } - -inline void draw_range_elements(PrimitiveType mode, unsigned low, unsigned high, unsigned count, const unsigned short *indices) -{ draw_range_elements(mode, low, high, count, UNSIGNED_SHORT, indices); } - -inline void draw_range_elements(PrimitiveType mode, unsigned low, unsigned high, unsigned count, const unsigned *indices) -{ draw_range_elements(mode, low, high, count, UNSIGNED_INT, indices); } - } // namespace GL } // namespace Msp -- 2.43.0 From 6afbace895a7bbcf216ab8e48280ea0303ab5892 Mon Sep 17 00:00:00 2001 From: Mikko Rasa Date: Mon, 27 Aug 2012 23:22:10 +0300 Subject: [PATCH 05/16] Complete rewrite of extension handling Prefer the promoted versions of extensions. This improves compatibility with OpenGL 3.0 and OpenGL ES 2.0. Extension availability is now checked through global identifiers rather than strings. This eliminates the possibility of typos. --- gl.spec.fixes | 50 +++++ scripts/extgen.py | 148 +++++++++++-- source/arb_fragment_shader.cpp | 22 ++ source/arb_fragment_shader.h | 16 ++ source/arb_multitexture.cpp | 125 +++++++++++ source/{version_1_3.h => arb_multitexture.h} | 19 +- source/arb_pixel_buffer_object.cpp | 22 ++ source/arb_pixel_buffer_object.h | 16 ++ source/arb_shader_objects.cpp | 212 ++++++++++++------- source/arb_shader_objects.h | 82 +++---- source/arb_texture_cube_map.cpp | 22 ++ source/arb_texture_cube_map.h | 16 ++ source/arb_uniform_buffer_object.cpp | 40 ++-- source/arb_uniform_buffer_object.h | 15 +- source/arb_vertex_buffer_object.cpp | 69 +++--- source/arb_vertex_buffer_object.h | 25 +-- source/arb_vertex_program.cpp | 137 ------------ source/arb_vertex_program.h | 78 ------- source/arb_vertex_shader.cpp | 158 +++++++++++++- source/arb_vertex_shader.h | 52 ++++- source/batch.cpp | 9 +- source/blend.cpp | 10 +- source/buffer.cpp | 20 +- source/buffer.h | 26 +-- source/ext_blend_minmax.cpp | 26 +++ source/ext_blend_minmax.h | 18 ++ source/ext_blend_subtract.cpp | 22 ++ source/ext_blend_subtract.h | 16 ++ source/ext_draw_range_elements.cpp | 26 +++ source/ext_draw_range_elements.h | 18 ++ source/ext_framebuffer_blit.cpp | 19 +- source/ext_framebuffer_blit.h | 5 +- source/ext_framebuffer_multisample.cpp | 19 +- source/ext_framebuffer_multisample.h | 5 +- source/ext_framebuffer_object.cpp | 99 +++++---- source/ext_framebuffer_object.h | 37 ++-- source/ext_texture3d.cpp | 29 +++ source/ext_texture3d.h | 19 ++ source/extension.cpp | 76 +++---- source/extension.h | 74 ++++--- source/framebuffer.cpp | 35 ++- source/framebuffer.h | 24 +-- source/mesh.cpp | 4 +- source/nv_primitive_restart.cpp | 16 +- source/nv_primitive_restart.h | 5 +- source/program.cpp | 37 ++-- source/programdata.cpp | 4 +- source/renderbuffer.cpp | 17 +- source/sgis_generate_mipmap.cpp | 18 ++ source/sgis_generate_mipmap.h | 16 ++ source/shader.cpp | 21 +- source/texture.cpp | 4 +- source/texture3d.cpp | 5 +- source/texturecube.cpp | 4 +- source/texunit.cpp | 10 +- source/uniform.cpp | 12 +- source/version_1_2.cpp | 89 -------- source/version_1_2.h | 54 ----- source/version_1_3.cpp | 105 --------- source/vertexarray.cpp | 16 +- 60 files changed, 1409 insertions(+), 984 deletions(-) create mode 100644 gl.spec.fixes create mode 100644 source/arb_fragment_shader.cpp create mode 100644 source/arb_fragment_shader.h create mode 100644 source/arb_multitexture.cpp rename source/{version_1_3.h => arb_multitexture.h} (69%) create mode 100644 source/arb_pixel_buffer_object.cpp create mode 100644 source/arb_pixel_buffer_object.h create mode 100644 source/arb_texture_cube_map.cpp create mode 100644 source/arb_texture_cube_map.h delete mode 100644 source/arb_vertex_program.cpp delete mode 100644 source/arb_vertex_program.h create mode 100644 source/ext_blend_minmax.cpp create mode 100644 source/ext_blend_minmax.h create mode 100644 source/ext_blend_subtract.cpp create mode 100644 source/ext_blend_subtract.h create mode 100644 source/ext_draw_range_elements.cpp create mode 100644 source/ext_draw_range_elements.h create mode 100644 source/ext_texture3d.cpp create mode 100644 source/ext_texture3d.h create mode 100644 source/sgis_generate_mipmap.cpp create mode 100644 source/sgis_generate_mipmap.h delete mode 100644 source/version_1_2.cpp delete mode 100644 source/version_1_2.h delete mode 100644 source/version_1_3.cpp diff --git a/gl.spec.fixes b/gl.spec.fixes new file mode 100644 index 00000000..4a3cba1f --- /dev/null +++ b/gl.spec.fixes @@ -0,0 +1,50 @@ +# The gl.spec file does not contain enough information to generate extension +# headers correctly, and is a bit broken at some places. This file attempts to +# rectify these problems. + + +# ARB_shader_objects function names got changed when promoted to core + +DeleteObjectARB(...) + alias DeleteShader + alias DeleteProgram + +GetHandleARB(...) + delete + +GetInfoLogARB(...) + alias GetShaderInfoLog + alias GetProgramInfoLog + +GetObjectParameterfvARB(...) + delete + +GetObjectParameterivARB(...) + alias GetShaderiv + alias GetProgramiv + + +# These are listed for the VERSION_3_0 category + +BindBufferRange(...) + category ARB_uniform_buffer_object + +BindBufferBase(...) + category ARB_uniform_buffer_object + + +# The EXT versions allow user-generated names; core versions don't. Since we +# use GL-generated names, it's safe to alias them. + +BindFramebufferEXT(...) + alias BindFramebuffer + +BindRenderbufferEXT(...) + alias BindRenderbuffer + + +# Ignore this, as it comes from ARB_vertex_program and I'm not sure if it works +# with ARB_shader_objects. + +IsProgramARB(...) + delete diff --git a/scripts/extgen.py b/scripts/extgen.py index f349d525..d6727123 100755 --- a/scripts/extgen.py +++ b/scripts/extgen.py @@ -2,39 +2,122 @@ import sys -ext = sys.argv[1] +if len(sys.argv)<2: + print """Usage: + extgen.py [] [ ...]" + +Reads gl.spec and generates files to use . Any promoted functions +are exposed with their promoted names. If extensions are given, +any promoted functions from those are pulled in as well. can be +given to override the version where was promoted to core.""" + sys.exit(0) -funcs = [] +ext = sys.argv[1] +exttype = ext.split('_')[0] +secondary = sys.argv[2:] +ver = None +if secondary and secondary[0][0].isdigit(): + ver = secondary.pop(0) +bp_ext = None + +class Function: + def __init__(self, name): + self.name = name + self.version = None + self.category = None + self.vectorequiv = None + self.aliases = [] + self.extfunc = None + +funcs = {} cur_func = None -for line in file("gl.spec"): - if line[0]=='#' or line.find(':')>=0: - continue - elif line[0]=='\t' and cur_func: - parts = line.split() - if parts[0]=="category" and parts[1]==ext: - funcs.append(cur_func) - else: - paren = line.find('(') - if paren>0: - cur_func = line[:paren] + +def parse_file(fn): + for line in open(fn): + if line[0]=='#' or line.find(':')>=0: + continue + elif line[0]=='\t': + if cur_func: + parts = line.split() + if parts[0]=="category": + cur_func.category = parts[1] + elif parts[0]=="vectorequiv": + cur_func.vectorequiv = parts[1] + elif parts[0]=="alias": + cur_func.aliases.append(parts[1]) + elif parts[0]=="version": + cur_func.version = parts[1] + elif parts[0]=="delete": + del funcs[cur_func.name] + cur_func = None + else: + paren = line.find('(') + if paren>0: + name = line[:paren] + if name in funcs: + cur_func = funcs[name] + else: + cur_func = Function(name) + funcs[name] = cur_func + +parse_file("gl.spec") +parse_file("gl.spec.fixes") + +for f in funcs.itervalues(): + if f.category==ext or f.category in secondary: + if not f.aliases and f.vectorequiv: + for g in funcs.itervalues(): + if g!=f and g.vectorequiv==f.vectorequiv and f.name.startswith(g.name): + f.aliases.append(g.name) + break + + for a in f.aliases: + if a in funcs: + funcs[a].extfunc = f + +def is_relevant(f): + if f.category==ext and not f.aliases: + return True + if f.extfunc: + e = f.extfunc + if e.category==ext or e.category in secondary: + return True + return False + +funcs = [f for f in funcs.itervalues() if is_relevant(f)] +funcs.sort(key=(lambda f: f.name)) + +for f in funcs: + if f.extfunc: + if not ver: + ver = f.version + if not f.category.startswith("VERSION_"): + bp_ext = f.category + if not f.extfunc and not f.name.endswith(exttype): + bp_ext = f.category + +if ver: + ver = map(int, ver.split('.')) out = file(ext.lower()+".h", "w") out.write("#ifndef MSP_GL_%s_\n"%ext.upper()) out.write("#define MSP_GL_%s_\n"%ext.upper()) out.write(""" +#include "extension.h" #include "gl.h" #include namespace Msp { namespace GL { - """) +if funcs: + out.write("\n") for f in funcs: - out.write("extern PFNGL%sPROC gl%s;\n"%(f.upper(), f)) + out.write("extern PFNGL%sPROC gl%s;\n"%(f.name.upper(), f.name)) -out.write("\nvoid init_%s();\n"%ext.lower()) +out.write("\nextern Extension %s;\n"%ext) out.write(""" } // namespace GL @@ -44,23 +127,42 @@ out.write(""" """) out = file(ext.lower()+".cpp", "w") -out.write("#include \"extension.h\"\n") out.write("#include \"%s.h\"\n"%ext.lower()) out.write(""" namespace Msp { namespace GL { - """) +if funcs: + out.write("\n") for f in funcs: - out.write("PFNGL%sPROC gl%s = 0;\n"%(f.upper(), f)) - -out.write("\nvoid init_%s()\n{\n"%ext.lower()) -for f in funcs: - out.write("\tgl%s = reinterpret_cast(get_proc_address(\"gl%s\"));\n"%(f, f.upper(), f)) + out.write("PFNGL%sPROC gl%s = 0;\n"%(f.name.upper(), f.name)) + +out.write("\nExtension::SupportLevel init_%s()\n{\n"%ext.lower()) +if ver: + out.write("\tif(is_version_at_least(%d, %d)"%tuple(ver)) + if bp_ext: + out.write(" || is_supported(\"GL_%s\")"%bp_ext) + out.write(")\n\t{\n") + for f in funcs: + out.write("\t\tgl%s = reinterpret_cast(get_proc_address(\"gl%s\"));\n"%(f.name, f.name.upper(), f.name)) + out.write("\t\treturn Extension::CORE;\n") + out.write("\t}\n") +if ext!=bp_ext: + out.write("\tif(is_supported(\"GL_%s\"))\n\t{\n"%(ext)) + for f in funcs: + n = f.name + if f.extfunc: + n = f.extfunc.name + out.write("\t\tgl%s = reinterpret_cast(get_proc_address(\"gl%s\"));\n"%(f.name, f.name.upper(), n)) + out.write("\t\treturn Extension::EXTENSION;\n") + out.write("\t}\n") +out.write("\treturn Extension::UNSUPPORTED;\n") out.write("}\n") +out.write("\nExtension %s(\"GL_%s\", init_%s);\n"%(ext, ext, ext.lower())) + out.write(""" } // namespace GL } // namespace Msp diff --git a/source/arb_fragment_shader.cpp b/source/arb_fragment_shader.cpp new file mode 100644 index 00000000..18524dcf --- /dev/null +++ b/source/arb_fragment_shader.cpp @@ -0,0 +1,22 @@ +#include "arb_fragment_shader.h" + +namespace Msp { +namespace GL { + +Extension::SupportLevel init_arb_fragment_shader() +{ + if(is_version_at_least(2, 0)) + { + return Extension::CORE; + } + if(is_supported("GL_ARB_fragment_shader")) + { + return Extension::EXTENSION; + } + return Extension::UNSUPPORTED; +} + +Extension ARB_fragment_shader("GL_ARB_fragment_shader", init_arb_fragment_shader); + +} // namespace GL +} // namespace Msp diff --git a/source/arb_fragment_shader.h b/source/arb_fragment_shader.h new file mode 100644 index 00000000..984f1555 --- /dev/null +++ b/source/arb_fragment_shader.h @@ -0,0 +1,16 @@ +#ifndef MSP_GL_ARB_FRAGMENT_SHADER_ +#define MSP_GL_ARB_FRAGMENT_SHADER_ + +#include "extension.h" +#include "gl.h" +#include + +namespace Msp { +namespace GL { + +extern Extension ARB_fragment_shader; + +} // namespace GL +} // namespace Msp + +#endif diff --git a/source/arb_multitexture.cpp b/source/arb_multitexture.cpp new file mode 100644 index 00000000..391b0455 --- /dev/null +++ b/source/arb_multitexture.cpp @@ -0,0 +1,125 @@ +#include "arb_multitexture.h" + +namespace Msp { +namespace GL { + +PFNGLACTIVETEXTUREPROC glActiveTexture = 0; +PFNGLCLIENTACTIVETEXTUREPROC glClientActiveTexture = 0; +PFNGLMULTITEXCOORD1DPROC glMultiTexCoord1d = 0; +PFNGLMULTITEXCOORD1DVPROC glMultiTexCoord1dv = 0; +PFNGLMULTITEXCOORD1FPROC glMultiTexCoord1f = 0; +PFNGLMULTITEXCOORD1FVPROC glMultiTexCoord1fv = 0; +PFNGLMULTITEXCOORD1IPROC glMultiTexCoord1i = 0; +PFNGLMULTITEXCOORD1IVPROC glMultiTexCoord1iv = 0; +PFNGLMULTITEXCOORD1SPROC glMultiTexCoord1s = 0; +PFNGLMULTITEXCOORD1SVPROC glMultiTexCoord1sv = 0; +PFNGLMULTITEXCOORD2DPROC glMultiTexCoord2d = 0; +PFNGLMULTITEXCOORD2DVPROC glMultiTexCoord2dv = 0; +PFNGLMULTITEXCOORD2FPROC glMultiTexCoord2f = 0; +PFNGLMULTITEXCOORD2FVPROC glMultiTexCoord2fv = 0; +PFNGLMULTITEXCOORD2IPROC glMultiTexCoord2i = 0; +PFNGLMULTITEXCOORD2IVPROC glMultiTexCoord2iv = 0; +PFNGLMULTITEXCOORD2SPROC glMultiTexCoord2s = 0; +PFNGLMULTITEXCOORD2SVPROC glMultiTexCoord2sv = 0; +PFNGLMULTITEXCOORD3DPROC glMultiTexCoord3d = 0; +PFNGLMULTITEXCOORD3DVPROC glMultiTexCoord3dv = 0; +PFNGLMULTITEXCOORD3FPROC glMultiTexCoord3f = 0; +PFNGLMULTITEXCOORD3FVPROC glMultiTexCoord3fv = 0; +PFNGLMULTITEXCOORD3IPROC glMultiTexCoord3i = 0; +PFNGLMULTITEXCOORD3IVPROC glMultiTexCoord3iv = 0; +PFNGLMULTITEXCOORD3SPROC glMultiTexCoord3s = 0; +PFNGLMULTITEXCOORD3SVPROC glMultiTexCoord3sv = 0; +PFNGLMULTITEXCOORD4DPROC glMultiTexCoord4d = 0; +PFNGLMULTITEXCOORD4DVPROC glMultiTexCoord4dv = 0; +PFNGLMULTITEXCOORD4FPROC glMultiTexCoord4f = 0; +PFNGLMULTITEXCOORD4FVPROC glMultiTexCoord4fv = 0; +PFNGLMULTITEXCOORD4IPROC glMultiTexCoord4i = 0; +PFNGLMULTITEXCOORD4IVPROC glMultiTexCoord4iv = 0; +PFNGLMULTITEXCOORD4SPROC glMultiTexCoord4s = 0; +PFNGLMULTITEXCOORD4SVPROC glMultiTexCoord4sv = 0; + +Extension::SupportLevel init_arb_multitexture() +{ + if(is_version_at_least(1, 3)) + { + glActiveTexture = reinterpret_cast(get_proc_address("glActiveTexture")); + glClientActiveTexture = reinterpret_cast(get_proc_address("glClientActiveTexture")); + glMultiTexCoord1d = reinterpret_cast(get_proc_address("glMultiTexCoord1d")); + glMultiTexCoord1dv = reinterpret_cast(get_proc_address("glMultiTexCoord1dv")); + glMultiTexCoord1f = reinterpret_cast(get_proc_address("glMultiTexCoord1f")); + glMultiTexCoord1fv = reinterpret_cast(get_proc_address("glMultiTexCoord1fv")); + glMultiTexCoord1i = reinterpret_cast(get_proc_address("glMultiTexCoord1i")); + glMultiTexCoord1iv = reinterpret_cast(get_proc_address("glMultiTexCoord1iv")); + glMultiTexCoord1s = reinterpret_cast(get_proc_address("glMultiTexCoord1s")); + glMultiTexCoord1sv = reinterpret_cast(get_proc_address("glMultiTexCoord1sv")); + glMultiTexCoord2d = reinterpret_cast(get_proc_address("glMultiTexCoord2d")); + glMultiTexCoord2dv = reinterpret_cast(get_proc_address("glMultiTexCoord2dv")); + glMultiTexCoord2f = reinterpret_cast(get_proc_address("glMultiTexCoord2f")); + glMultiTexCoord2fv = reinterpret_cast(get_proc_address("glMultiTexCoord2fv")); + glMultiTexCoord2i = reinterpret_cast(get_proc_address("glMultiTexCoord2i")); + glMultiTexCoord2iv = reinterpret_cast(get_proc_address("glMultiTexCoord2iv")); + glMultiTexCoord2s = reinterpret_cast(get_proc_address("glMultiTexCoord2s")); + glMultiTexCoord2sv = reinterpret_cast(get_proc_address("glMultiTexCoord2sv")); + glMultiTexCoord3d = reinterpret_cast(get_proc_address("glMultiTexCoord3d")); + glMultiTexCoord3dv = reinterpret_cast(get_proc_address("glMultiTexCoord3dv")); + glMultiTexCoord3f = reinterpret_cast(get_proc_address("glMultiTexCoord3f")); + glMultiTexCoord3fv = reinterpret_cast(get_proc_address("glMultiTexCoord3fv")); + glMultiTexCoord3i = reinterpret_cast(get_proc_address("glMultiTexCoord3i")); + glMultiTexCoord3iv = reinterpret_cast(get_proc_address("glMultiTexCoord3iv")); + glMultiTexCoord3s = reinterpret_cast(get_proc_address("glMultiTexCoord3s")); + glMultiTexCoord3sv = reinterpret_cast(get_proc_address("glMultiTexCoord3sv")); + glMultiTexCoord4d = reinterpret_cast(get_proc_address("glMultiTexCoord4d")); + glMultiTexCoord4dv = reinterpret_cast(get_proc_address("glMultiTexCoord4dv")); + glMultiTexCoord4f = reinterpret_cast(get_proc_address("glMultiTexCoord4f")); + glMultiTexCoord4fv = reinterpret_cast(get_proc_address("glMultiTexCoord4fv")); + glMultiTexCoord4i = reinterpret_cast(get_proc_address("glMultiTexCoord4i")); + glMultiTexCoord4iv = reinterpret_cast(get_proc_address("glMultiTexCoord4iv")); + glMultiTexCoord4s = reinterpret_cast(get_proc_address("glMultiTexCoord4s")); + glMultiTexCoord4sv = reinterpret_cast(get_proc_address("glMultiTexCoord4sv")); + return Extension::CORE; + } + if(is_supported("GL_ARB_multitexture")) + { + glActiveTexture = reinterpret_cast(get_proc_address("glActiveTextureARB")); + glClientActiveTexture = reinterpret_cast(get_proc_address("glClientActiveTextureARB")); + glMultiTexCoord1d = reinterpret_cast(get_proc_address("glMultiTexCoord1dARB")); + glMultiTexCoord1dv = reinterpret_cast(get_proc_address("glMultiTexCoord1dvARB")); + glMultiTexCoord1f = reinterpret_cast(get_proc_address("glMultiTexCoord1fARB")); + glMultiTexCoord1fv = reinterpret_cast(get_proc_address("glMultiTexCoord1fvARB")); + glMultiTexCoord1i = reinterpret_cast(get_proc_address("glMultiTexCoord1iARB")); + glMultiTexCoord1iv = reinterpret_cast(get_proc_address("glMultiTexCoord1ivARB")); + glMultiTexCoord1s = reinterpret_cast(get_proc_address("glMultiTexCoord1sARB")); + glMultiTexCoord1sv = reinterpret_cast(get_proc_address("glMultiTexCoord1svARB")); + glMultiTexCoord2d = reinterpret_cast(get_proc_address("glMultiTexCoord2dARB")); + glMultiTexCoord2dv = reinterpret_cast(get_proc_address("glMultiTexCoord2dvARB")); + glMultiTexCoord2f = reinterpret_cast(get_proc_address("glMultiTexCoord2fARB")); + glMultiTexCoord2fv = reinterpret_cast(get_proc_address("glMultiTexCoord2fvARB")); + glMultiTexCoord2i = reinterpret_cast(get_proc_address("glMultiTexCoord2iARB")); + glMultiTexCoord2iv = reinterpret_cast(get_proc_address("glMultiTexCoord2ivARB")); + glMultiTexCoord2s = reinterpret_cast(get_proc_address("glMultiTexCoord2sARB")); + glMultiTexCoord2sv = reinterpret_cast(get_proc_address("glMultiTexCoord2svARB")); + glMultiTexCoord3d = reinterpret_cast(get_proc_address("glMultiTexCoord3dARB")); + glMultiTexCoord3dv = reinterpret_cast(get_proc_address("glMultiTexCoord3dvARB")); + glMultiTexCoord3f = reinterpret_cast(get_proc_address("glMultiTexCoord3fARB")); + glMultiTexCoord3fv = reinterpret_cast(get_proc_address("glMultiTexCoord3fvARB")); + glMultiTexCoord3i = reinterpret_cast(get_proc_address("glMultiTexCoord3iARB")); + glMultiTexCoord3iv = reinterpret_cast(get_proc_address("glMultiTexCoord3ivARB")); + glMultiTexCoord3s = reinterpret_cast(get_proc_address("glMultiTexCoord3sARB")); + glMultiTexCoord3sv = reinterpret_cast(get_proc_address("glMultiTexCoord3svARB")); + glMultiTexCoord4d = reinterpret_cast(get_proc_address("glMultiTexCoord4dARB")); + glMultiTexCoord4dv = reinterpret_cast(get_proc_address("glMultiTexCoord4dvARB")); + glMultiTexCoord4f = reinterpret_cast(get_proc_address("glMultiTexCoord4fARB")); + glMultiTexCoord4fv = reinterpret_cast(get_proc_address("glMultiTexCoord4fvARB")); + glMultiTexCoord4i = reinterpret_cast(get_proc_address("glMultiTexCoord4iARB")); + glMultiTexCoord4iv = reinterpret_cast(get_proc_address("glMultiTexCoord4ivARB")); + glMultiTexCoord4s = reinterpret_cast(get_proc_address("glMultiTexCoord4sARB")); + glMultiTexCoord4sv = reinterpret_cast(get_proc_address("glMultiTexCoord4svARB")); + return Extension::EXTENSION; + } + return Extension::UNSUPPORTED; +} + +Extension ARB_multitexture("GL_ARB_multitexture", init_arb_multitexture); + +} // namespace GL +} // namespace Msp diff --git a/source/version_1_3.h b/source/arb_multitexture.h similarity index 69% rename from source/version_1_3.h rename to source/arb_multitexture.h index bd0b4eae..4c41f095 100644 --- a/source/version_1_3.h +++ b/source/arb_multitexture.h @@ -1,6 +1,7 @@ -#ifndef MSP_GL_VERSION_1_3_ -#define MSP_GL_VERSION_1_3_ +#ifndef MSP_GL_ARB_MULTITEXTURE_ +#define MSP_GL_ARB_MULTITEXTURE_ +#include "extension.h" #include "gl.h" #include @@ -41,20 +42,8 @@ extern PFNGLMULTITEXCOORD4IPROC glMultiTexCoord4i; extern PFNGLMULTITEXCOORD4IVPROC glMultiTexCoord4iv; extern PFNGLMULTITEXCOORD4SPROC glMultiTexCoord4s; extern PFNGLMULTITEXCOORD4SVPROC glMultiTexCoord4sv; -extern PFNGLLOADTRANSPOSEMATRIXFPROC glLoadTransposeMatrixf; -extern PFNGLLOADTRANSPOSEMATRIXDPROC glLoadTransposeMatrixd; -extern PFNGLMULTTRANSPOSEMATRIXFPROC glMultTransposeMatrixf; -extern PFNGLMULTTRANSPOSEMATRIXDPROC glMultTransposeMatrixd; -extern PFNGLSAMPLECOVERAGEPROC glSampleCoverage; -extern PFNGLCOMPRESSEDTEXIMAGE3DPROC glCompressedTexImage3D; -extern PFNGLCOMPRESSEDTEXIMAGE2DPROC glCompressedTexImage2D; -extern PFNGLCOMPRESSEDTEXIMAGE1DPROC glCompressedTexImage1D; -extern PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glCompressedTexSubImage3D; -extern PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glCompressedTexSubImage2D; -extern PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glCompressedTexSubImage1D; -extern PFNGLGETCOMPRESSEDTEXIMAGEPROC glGetCompressedTexImage; -void init_version_1_3(); +extern Extension ARB_multitexture; } // namespace GL } // namespace Msp diff --git a/source/arb_pixel_buffer_object.cpp b/source/arb_pixel_buffer_object.cpp new file mode 100644 index 00000000..0243f8bd --- /dev/null +++ b/source/arb_pixel_buffer_object.cpp @@ -0,0 +1,22 @@ +#include "arb_pixel_buffer_object.h" + +namespace Msp { +namespace GL { + +Extension::SupportLevel init_arb_pixel_buffer_object() +{ + if(is_version_at_least(2, 1)) + { + return Extension::CORE; + } + if(is_supported("GL_ARB_pixel_buffer_object")) + { + return Extension::EXTENSION; + } + return Extension::UNSUPPORTED; +} + +Extension ARB_pixel_buffer_object("GL_ARB_pixel_buffer_object", init_arb_pixel_buffer_object); + +} // namespace GL +} // namespace Msp diff --git a/source/arb_pixel_buffer_object.h b/source/arb_pixel_buffer_object.h new file mode 100644 index 00000000..e7819821 --- /dev/null +++ b/source/arb_pixel_buffer_object.h @@ -0,0 +1,16 @@ +#ifndef MSP_GL_ARB_PIXEL_BUFFER_OBJECT_ +#define MSP_GL_ARB_PIXEL_BUFFER_OBJECT_ + +#include "extension.h" +#include "gl.h" +#include + +namespace Msp { +namespace GL { + +extern Extension ARB_pixel_buffer_object; + +} // namespace GL +} // namespace Msp + +#endif diff --git a/source/arb_shader_objects.cpp b/source/arb_shader_objects.cpp index 18ea5482..3cb31bc5 100644 --- a/source/arb_shader_objects.cpp +++ b/source/arb_shader_objects.cpp @@ -1,91 +1,143 @@ -#include "extension.h" #include "arb_shader_objects.h" namespace Msp { namespace GL { -PFNGLDELETEOBJECTARBPROC glDeleteObjectARB = 0; -PFNGLGETHANDLEARBPROC glGetHandleARB = 0; -PFNGLDETACHOBJECTARBPROC glDetachObjectARB = 0; -PFNGLCREATESHADEROBJECTARBPROC glCreateShaderObjectARB = 0; -PFNGLSHADERSOURCEARBPROC glShaderSourceARB = 0; -PFNGLCOMPILESHADERARBPROC glCompileShaderARB = 0; -PFNGLCREATEPROGRAMOBJECTARBPROC glCreateProgramObjectARB = 0; -PFNGLATTACHOBJECTARBPROC glAttachObjectARB = 0; -PFNGLLINKPROGRAMARBPROC glLinkProgramARB = 0; -PFNGLUSEPROGRAMOBJECTARBPROC glUseProgramObjectARB = 0; -PFNGLVALIDATEPROGRAMARBPROC glValidateProgramARB = 0; -PFNGLUNIFORM1FARBPROC glUniform1fARB = 0; -PFNGLUNIFORM2FARBPROC glUniform2fARB = 0; -PFNGLUNIFORM3FARBPROC glUniform3fARB = 0; -PFNGLUNIFORM4FARBPROC glUniform4fARB = 0; -PFNGLUNIFORM1IARBPROC glUniform1iARB = 0; -PFNGLUNIFORM2IARBPROC glUniform2iARB = 0; -PFNGLUNIFORM3IARBPROC glUniform3iARB = 0; -PFNGLUNIFORM4IARBPROC glUniform4iARB = 0; -PFNGLUNIFORM1FVARBPROC glUniform1fvARB = 0; -PFNGLUNIFORM2FVARBPROC glUniform2fvARB = 0; -PFNGLUNIFORM3FVARBPROC glUniform3fvARB = 0; -PFNGLUNIFORM4FVARBPROC glUniform4fvARB = 0; -PFNGLUNIFORM1IVARBPROC glUniform1ivARB = 0; -PFNGLUNIFORM2IVARBPROC glUniform2ivARB = 0; -PFNGLUNIFORM3IVARBPROC glUniform3ivARB = 0; -PFNGLUNIFORM4IVARBPROC glUniform4ivARB = 0; -PFNGLUNIFORMMATRIX2FVARBPROC glUniformMatrix2fvARB = 0; -PFNGLUNIFORMMATRIX3FVARBPROC glUniformMatrix3fvARB = 0; -PFNGLUNIFORMMATRIX4FVARBPROC glUniformMatrix4fvARB = 0; -PFNGLGETOBJECTPARAMETERFVARBPROC glGetObjectParameterfvARB = 0; -PFNGLGETOBJECTPARAMETERIVARBPROC glGetObjectParameterivARB = 0; -PFNGLGETINFOLOGARBPROC glGetInfoLogARB = 0; -PFNGLGETATTACHEDOBJECTSARBPROC glGetAttachedObjectsARB = 0; -PFNGLGETUNIFORMLOCATIONARBPROC glGetUniformLocationARB = 0; -PFNGLGETACTIVEUNIFORMARBPROC glGetActiveUniformARB = 0; -PFNGLGETUNIFORMFVARBPROC glGetUniformfvARB = 0; -PFNGLGETUNIFORMIVARBPROC glGetUniformivARB = 0; -PFNGLGETSHADERSOURCEARBPROC glGetShaderSourceARB = 0; +PFNGLATTACHSHADERPROC glAttachShader = 0; +PFNGLCOMPILESHADERPROC glCompileShader = 0; +PFNGLCREATEPROGRAMPROC glCreateProgram = 0; +PFNGLCREATESHADERPROC glCreateShader = 0; +PFNGLDELETEPROGRAMPROC glDeleteProgram = 0; +PFNGLDELETESHADERPROC glDeleteShader = 0; +PFNGLDETACHSHADERPROC glDetachShader = 0; +PFNGLGETACTIVEUNIFORMPROC glGetActiveUniform = 0; +PFNGLGETATTACHEDSHADERSPROC glGetAttachedShaders = 0; +PFNGLGETPROGRAMINFOLOGPROC glGetProgramInfoLog = 0; +PFNGLGETPROGRAMIVPROC glGetProgramiv = 0; +PFNGLGETSHADERINFOLOGPROC glGetShaderInfoLog = 0; +PFNGLGETSHADERSOURCEPROC glGetShaderSource = 0; +PFNGLGETSHADERIVPROC glGetShaderiv = 0; +PFNGLGETUNIFORMLOCATIONPROC glGetUniformLocation = 0; +PFNGLGETUNIFORMFVPROC glGetUniformfv = 0; +PFNGLGETUNIFORMIVPROC glGetUniformiv = 0; +PFNGLLINKPROGRAMPROC glLinkProgram = 0; +PFNGLSHADERSOURCEPROC glShaderSource = 0; +PFNGLUNIFORM1FPROC glUniform1f = 0; +PFNGLUNIFORM1FVPROC glUniform1fv = 0; +PFNGLUNIFORM1IPROC glUniform1i = 0; +PFNGLUNIFORM1IVPROC glUniform1iv = 0; +PFNGLUNIFORM2FPROC glUniform2f = 0; +PFNGLUNIFORM2FVPROC glUniform2fv = 0; +PFNGLUNIFORM2IPROC glUniform2i = 0; +PFNGLUNIFORM2IVPROC glUniform2iv = 0; +PFNGLUNIFORM3FPROC glUniform3f = 0; +PFNGLUNIFORM3FVPROC glUniform3fv = 0; +PFNGLUNIFORM3IPROC glUniform3i = 0; +PFNGLUNIFORM3IVPROC glUniform3iv = 0; +PFNGLUNIFORM4FPROC glUniform4f = 0; +PFNGLUNIFORM4FVPROC glUniform4fv = 0; +PFNGLUNIFORM4IPROC glUniform4i = 0; +PFNGLUNIFORM4IVPROC glUniform4iv = 0; +PFNGLUNIFORMMATRIX2FVPROC glUniformMatrix2fv = 0; +PFNGLUNIFORMMATRIX3FVPROC glUniformMatrix3fv = 0; +PFNGLUNIFORMMATRIX4FVPROC glUniformMatrix4fv = 0; +PFNGLUSEPROGRAMPROC glUseProgram = 0; +PFNGLVALIDATEPROGRAMPROC glValidateProgram = 0; -void init_arb_shader_objects() +Extension::SupportLevel init_arb_shader_objects() { - glDeleteObjectARB = reinterpret_cast(get_proc_address("glDeleteObjectARB")); - glGetHandleARB = reinterpret_cast(get_proc_address("glGetHandleARB")); - glDetachObjectARB = reinterpret_cast(get_proc_address("glDetachObjectARB")); - glCreateShaderObjectARB = reinterpret_cast(get_proc_address("glCreateShaderObjectARB")); - glShaderSourceARB = reinterpret_cast(get_proc_address("glShaderSourceARB")); - glCompileShaderARB = reinterpret_cast(get_proc_address("glCompileShaderARB")); - glCreateProgramObjectARB = reinterpret_cast(get_proc_address("glCreateProgramObjectARB")); - glAttachObjectARB = reinterpret_cast(get_proc_address("glAttachObjectARB")); - glLinkProgramARB = reinterpret_cast(get_proc_address("glLinkProgramARB")); - glUseProgramObjectARB = reinterpret_cast(get_proc_address("glUseProgramObjectARB")); - glValidateProgramARB = reinterpret_cast(get_proc_address("glValidateProgramARB")); - glUniform1fARB = reinterpret_cast(get_proc_address("glUniform1fARB")); - glUniform2fARB = reinterpret_cast(get_proc_address("glUniform2fARB")); - glUniform3fARB = reinterpret_cast(get_proc_address("glUniform3fARB")); - glUniform4fARB = reinterpret_cast(get_proc_address("glUniform4fARB")); - glUniform1iARB = reinterpret_cast(get_proc_address("glUniform1iARB")); - glUniform2iARB = reinterpret_cast(get_proc_address("glUniform2iARB")); - glUniform3iARB = reinterpret_cast(get_proc_address("glUniform3iARB")); - glUniform4iARB = reinterpret_cast(get_proc_address("glUniform4iARB")); - glUniform1fvARB = reinterpret_cast(get_proc_address("glUniform1fvARB")); - glUniform2fvARB = reinterpret_cast(get_proc_address("glUniform2fvARB")); - glUniform3fvARB = reinterpret_cast(get_proc_address("glUniform3fvARB")); - glUniform4fvARB = reinterpret_cast(get_proc_address("glUniform4fvARB")); - glUniform1ivARB = reinterpret_cast(get_proc_address("glUniform1ivARB")); - glUniform2ivARB = reinterpret_cast(get_proc_address("glUniform2ivARB")); - glUniform3ivARB = reinterpret_cast(get_proc_address("glUniform3ivARB")); - glUniform4ivARB = reinterpret_cast(get_proc_address("glUniform4ivARB")); - glUniformMatrix2fvARB = reinterpret_cast(get_proc_address("glUniformMatrix2fvARB")); - glUniformMatrix3fvARB = reinterpret_cast(get_proc_address("glUniformMatrix3fvARB")); - glUniformMatrix4fvARB = reinterpret_cast(get_proc_address("glUniformMatrix4fvARB")); - glGetObjectParameterfvARB = reinterpret_cast(get_proc_address("glGetObjectParameterfvARB")); - glGetObjectParameterivARB = reinterpret_cast(get_proc_address("glGetObjectParameterivARB")); - glGetInfoLogARB = reinterpret_cast(get_proc_address("glGetInfoLogARB")); - glGetAttachedObjectsARB = reinterpret_cast(get_proc_address("glGetAttachedObjectsARB")); - glGetUniformLocationARB = reinterpret_cast(get_proc_address("glGetUniformLocationARB")); - glGetActiveUniformARB = reinterpret_cast(get_proc_address("glGetActiveUniformARB")); - glGetUniformfvARB = reinterpret_cast(get_proc_address("glGetUniformfvARB")); - glGetUniformivARB = reinterpret_cast(get_proc_address("glGetUniformivARB")); - glGetShaderSourceARB = reinterpret_cast(get_proc_address("glGetShaderSourceARB")); + if(is_version_at_least(2, 0)) + { + glAttachShader = reinterpret_cast(get_proc_address("glAttachShader")); + glCompileShader = reinterpret_cast(get_proc_address("glCompileShader")); + glCreateProgram = reinterpret_cast(get_proc_address("glCreateProgram")); + glCreateShader = reinterpret_cast(get_proc_address("glCreateShader")); + glDeleteProgram = reinterpret_cast(get_proc_address("glDeleteProgram")); + glDeleteShader = reinterpret_cast(get_proc_address("glDeleteShader")); + glDetachShader = reinterpret_cast(get_proc_address("glDetachShader")); + glGetActiveUniform = reinterpret_cast(get_proc_address("glGetActiveUniform")); + glGetAttachedShaders = reinterpret_cast(get_proc_address("glGetAttachedShaders")); + glGetProgramInfoLog = reinterpret_cast(get_proc_address("glGetProgramInfoLog")); + glGetProgramiv = reinterpret_cast(get_proc_address("glGetProgramiv")); + glGetShaderInfoLog = reinterpret_cast(get_proc_address("glGetShaderInfoLog")); + glGetShaderSource = reinterpret_cast(get_proc_address("glGetShaderSource")); + glGetShaderiv = reinterpret_cast(get_proc_address("glGetShaderiv")); + glGetUniformLocation = reinterpret_cast(get_proc_address("glGetUniformLocation")); + glGetUniformfv = reinterpret_cast(get_proc_address("glGetUniformfv")); + glGetUniformiv = reinterpret_cast(get_proc_address("glGetUniformiv")); + glLinkProgram = reinterpret_cast(get_proc_address("glLinkProgram")); + glShaderSource = reinterpret_cast(get_proc_address("glShaderSource")); + glUniform1f = reinterpret_cast(get_proc_address("glUniform1f")); + glUniform1fv = reinterpret_cast(get_proc_address("glUniform1fv")); + glUniform1i = reinterpret_cast(get_proc_address("glUniform1i")); + glUniform1iv = reinterpret_cast(get_proc_address("glUniform1iv")); + glUniform2f = reinterpret_cast(get_proc_address("glUniform2f")); + glUniform2fv = reinterpret_cast(get_proc_address("glUniform2fv")); + glUniform2i = reinterpret_cast(get_proc_address("glUniform2i")); + glUniform2iv = reinterpret_cast(get_proc_address("glUniform2iv")); + glUniform3f = reinterpret_cast(get_proc_address("glUniform3f")); + glUniform3fv = reinterpret_cast(get_proc_address("glUniform3fv")); + glUniform3i = reinterpret_cast(get_proc_address("glUniform3i")); + glUniform3iv = reinterpret_cast(get_proc_address("glUniform3iv")); + glUniform4f = reinterpret_cast(get_proc_address("glUniform4f")); + glUniform4fv = reinterpret_cast(get_proc_address("glUniform4fv")); + glUniform4i = reinterpret_cast(get_proc_address("glUniform4i")); + glUniform4iv = reinterpret_cast(get_proc_address("glUniform4iv")); + glUniformMatrix2fv = reinterpret_cast(get_proc_address("glUniformMatrix2fv")); + glUniformMatrix3fv = reinterpret_cast(get_proc_address("glUniformMatrix3fv")); + glUniformMatrix4fv = reinterpret_cast(get_proc_address("glUniformMatrix4fv")); + glUseProgram = reinterpret_cast(get_proc_address("glUseProgram")); + glValidateProgram = reinterpret_cast(get_proc_address("glValidateProgram")); + return Extension::CORE; + } + if(is_supported("GL_ARB_shader_objects")) + { + glAttachShader = reinterpret_cast(get_proc_address("glAttachObjectARB")); + glCompileShader = reinterpret_cast(get_proc_address("glCompileShaderARB")); + glCreateProgram = reinterpret_cast(get_proc_address("glCreateProgramObjectARB")); + glCreateShader = reinterpret_cast(get_proc_address("glCreateShaderObjectARB")); + glDeleteProgram = reinterpret_cast(get_proc_address("glDeleteObjectARB")); + glDeleteShader = reinterpret_cast(get_proc_address("glDeleteObjectARB")); + glDetachShader = reinterpret_cast(get_proc_address("glDetachObjectARB")); + glGetActiveUniform = reinterpret_cast(get_proc_address("glGetActiveUniformARB")); + glGetAttachedShaders = reinterpret_cast(get_proc_address("glGetAttachedObjectsARB")); + glGetProgramInfoLog = reinterpret_cast(get_proc_address("glGetInfoLogARB")); + glGetProgramiv = reinterpret_cast(get_proc_address("glGetObjectParameterivARB")); + glGetShaderInfoLog = reinterpret_cast(get_proc_address("glGetInfoLogARB")); + glGetShaderSource = reinterpret_cast(get_proc_address("glGetShaderSourceARB")); + glGetShaderiv = reinterpret_cast(get_proc_address("glGetObjectParameterivARB")); + glGetUniformLocation = reinterpret_cast(get_proc_address("glGetUniformLocationARB")); + glGetUniformfv = reinterpret_cast(get_proc_address("glGetUniformfvARB")); + glGetUniformiv = reinterpret_cast(get_proc_address("glGetUniformivARB")); + glLinkProgram = reinterpret_cast(get_proc_address("glLinkProgramARB")); + glShaderSource = reinterpret_cast(get_proc_address("glShaderSourceARB")); + glUniform1f = reinterpret_cast(get_proc_address("glUniform1fARB")); + glUniform1fv = reinterpret_cast(get_proc_address("glUniform1fvARB")); + glUniform1i = reinterpret_cast(get_proc_address("glUniform1iARB")); + glUniform1iv = reinterpret_cast(get_proc_address("glUniform1ivARB")); + glUniform2f = reinterpret_cast(get_proc_address("glUniform2fARB")); + glUniform2fv = reinterpret_cast(get_proc_address("glUniform2fvARB")); + glUniform2i = reinterpret_cast(get_proc_address("glUniform2iARB")); + glUniform2iv = reinterpret_cast(get_proc_address("glUniform2ivARB")); + glUniform3f = reinterpret_cast(get_proc_address("glUniform3fARB")); + glUniform3fv = reinterpret_cast(get_proc_address("glUniform3fvARB")); + glUniform3i = reinterpret_cast(get_proc_address("glUniform3iARB")); + glUniform3iv = reinterpret_cast(get_proc_address("glUniform3ivARB")); + glUniform4f = reinterpret_cast(get_proc_address("glUniform4fARB")); + glUniform4fv = reinterpret_cast(get_proc_address("glUniform4fvARB")); + glUniform4i = reinterpret_cast(get_proc_address("glUniform4iARB")); + glUniform4iv = reinterpret_cast(get_proc_address("glUniform4ivARB")); + glUniformMatrix2fv = reinterpret_cast(get_proc_address("glUniformMatrix2fvARB")); + glUniformMatrix3fv = reinterpret_cast(get_proc_address("glUniformMatrix3fvARB")); + glUniformMatrix4fv = reinterpret_cast(get_proc_address("glUniformMatrix4fvARB")); + glUseProgram = reinterpret_cast(get_proc_address("glUseProgramObjectARB")); + glValidateProgram = reinterpret_cast(get_proc_address("glValidateProgramARB")); + return Extension::EXTENSION; + } + return Extension::UNSUPPORTED; } +Extension ARB_shader_objects("GL_ARB_shader_objects", init_arb_shader_objects); + } // namespace GL } // namespace Msp diff --git a/source/arb_shader_objects.h b/source/arb_shader_objects.h index e256d068..6b35cee1 100644 --- a/source/arb_shader_objects.h +++ b/source/arb_shader_objects.h @@ -1,53 +1,55 @@ #ifndef MSP_GL_ARB_SHADER_OBJECTS_ #define MSP_GL_ARB_SHADER_OBJECTS_ +#include "extension.h" #include "gl.h" #include namespace Msp { namespace GL { -extern PFNGLDELETEOBJECTARBPROC glDeleteObjectARB; -extern PFNGLGETHANDLEARBPROC glGetHandleARB; -extern PFNGLDETACHOBJECTARBPROC glDetachObjectARB; -extern PFNGLCREATESHADEROBJECTARBPROC glCreateShaderObjectARB; -extern PFNGLSHADERSOURCEARBPROC glShaderSourceARB; -extern PFNGLCOMPILESHADERARBPROC glCompileShaderARB; -extern PFNGLCREATEPROGRAMOBJECTARBPROC glCreateProgramObjectARB; -extern PFNGLATTACHOBJECTARBPROC glAttachObjectARB; -extern PFNGLLINKPROGRAMARBPROC glLinkProgramARB; -extern PFNGLUSEPROGRAMOBJECTARBPROC glUseProgramObjectARB; -extern PFNGLVALIDATEPROGRAMARBPROC glValidateProgramARB; -extern PFNGLUNIFORM1FARBPROC glUniform1fARB; -extern PFNGLUNIFORM2FARBPROC glUniform2fARB; -extern PFNGLUNIFORM3FARBPROC glUniform3fARB; -extern PFNGLUNIFORM4FARBPROC glUniform4fARB; -extern PFNGLUNIFORM1IARBPROC glUniform1iARB; -extern PFNGLUNIFORM2IARBPROC glUniform2iARB; -extern PFNGLUNIFORM3IARBPROC glUniform3iARB; -extern PFNGLUNIFORM4IARBPROC glUniform4iARB; -extern PFNGLUNIFORM1FVARBPROC glUniform1fvARB; -extern PFNGLUNIFORM2FVARBPROC glUniform2fvARB; -extern PFNGLUNIFORM3FVARBPROC glUniform3fvARB; -extern PFNGLUNIFORM4FVARBPROC glUniform4fvARB; -extern PFNGLUNIFORM1IVARBPROC glUniform1ivARB; -extern PFNGLUNIFORM2IVARBPROC glUniform2ivARB; -extern PFNGLUNIFORM3IVARBPROC glUniform3ivARB; -extern PFNGLUNIFORM4IVARBPROC glUniform4ivARB; -extern PFNGLUNIFORMMATRIX2FVARBPROC glUniformMatrix2fvARB; -extern PFNGLUNIFORMMATRIX3FVARBPROC glUniformMatrix3fvARB; -extern PFNGLUNIFORMMATRIX4FVARBPROC glUniformMatrix4fvARB; -extern PFNGLGETOBJECTPARAMETERFVARBPROC glGetObjectParameterfvARB; -extern PFNGLGETOBJECTPARAMETERIVARBPROC glGetObjectParameterivARB; -extern PFNGLGETINFOLOGARBPROC glGetInfoLogARB; -extern PFNGLGETATTACHEDOBJECTSARBPROC glGetAttachedObjectsARB; -extern PFNGLGETUNIFORMLOCATIONARBPROC glGetUniformLocationARB; -extern PFNGLGETACTIVEUNIFORMARBPROC glGetActiveUniformARB; -extern PFNGLGETUNIFORMFVARBPROC glGetUniformfvARB; -extern PFNGLGETUNIFORMIVARBPROC glGetUniformivARB; -extern PFNGLGETSHADERSOURCEARBPROC glGetShaderSourceARB; +extern PFNGLATTACHSHADERPROC glAttachShader; +extern PFNGLCOMPILESHADERPROC glCompileShader; +extern PFNGLCREATEPROGRAMPROC glCreateProgram; +extern PFNGLCREATESHADERPROC glCreateShader; +extern PFNGLDELETEPROGRAMPROC glDeleteProgram; +extern PFNGLDELETESHADERPROC glDeleteShader; +extern PFNGLDETACHSHADERPROC glDetachShader; +extern PFNGLGETACTIVEUNIFORMPROC glGetActiveUniform; +extern PFNGLGETATTACHEDSHADERSPROC glGetAttachedShaders; +extern PFNGLGETPROGRAMINFOLOGPROC glGetProgramInfoLog; +extern PFNGLGETPROGRAMIVPROC glGetProgramiv; +extern PFNGLGETSHADERINFOLOGPROC glGetShaderInfoLog; +extern PFNGLGETSHADERSOURCEPROC glGetShaderSource; +extern PFNGLGETSHADERIVPROC glGetShaderiv; +extern PFNGLGETUNIFORMLOCATIONPROC glGetUniformLocation; +extern PFNGLGETUNIFORMFVPROC glGetUniformfv; +extern PFNGLGETUNIFORMIVPROC glGetUniformiv; +extern PFNGLLINKPROGRAMPROC glLinkProgram; +extern PFNGLSHADERSOURCEPROC glShaderSource; +extern PFNGLUNIFORM1FPROC glUniform1f; +extern PFNGLUNIFORM1FVPROC glUniform1fv; +extern PFNGLUNIFORM1IPROC glUniform1i; +extern PFNGLUNIFORM1IVPROC glUniform1iv; +extern PFNGLUNIFORM2FPROC glUniform2f; +extern PFNGLUNIFORM2FVPROC glUniform2fv; +extern PFNGLUNIFORM2IPROC glUniform2i; +extern PFNGLUNIFORM2IVPROC glUniform2iv; +extern PFNGLUNIFORM3FPROC glUniform3f; +extern PFNGLUNIFORM3FVPROC glUniform3fv; +extern PFNGLUNIFORM3IPROC glUniform3i; +extern PFNGLUNIFORM3IVPROC glUniform3iv; +extern PFNGLUNIFORM4FPROC glUniform4f; +extern PFNGLUNIFORM4FVPROC glUniform4fv; +extern PFNGLUNIFORM4IPROC glUniform4i; +extern PFNGLUNIFORM4IVPROC glUniform4iv; +extern PFNGLUNIFORMMATRIX2FVPROC glUniformMatrix2fv; +extern PFNGLUNIFORMMATRIX3FVPROC glUniformMatrix3fv; +extern PFNGLUNIFORMMATRIX4FVPROC glUniformMatrix4fv; +extern PFNGLUSEPROGRAMPROC glUseProgram; +extern PFNGLVALIDATEPROGRAMPROC glValidateProgram; -void init_arb_shader_objects(); +extern Extension ARB_shader_objects; } // namespace GL } // namespace Msp diff --git a/source/arb_texture_cube_map.cpp b/source/arb_texture_cube_map.cpp new file mode 100644 index 00000000..b74993a9 --- /dev/null +++ b/source/arb_texture_cube_map.cpp @@ -0,0 +1,22 @@ +#include "arb_texture_cube_map.h" + +namespace Msp { +namespace GL { + +Extension::SupportLevel init_arb_texture_cube_map() +{ + if(is_version_at_least(1, 3)) + { + return Extension::CORE; + } + if(is_supported("GL_ARB_texture_cube_map")) + { + return Extension::EXTENSION; + } + return Extension::UNSUPPORTED; +} + +Extension ARB_texture_cube_map("GL_ARB_texture_cube_map", init_arb_texture_cube_map); + +} // namespace GL +} // namespace Msp diff --git a/source/arb_texture_cube_map.h b/source/arb_texture_cube_map.h new file mode 100644 index 00000000..3cde6e7d --- /dev/null +++ b/source/arb_texture_cube_map.h @@ -0,0 +1,16 @@ +#ifndef MSP_GL_ARB_TEXTURE_CUBE_MAP_ +#define MSP_GL_ARB_TEXTURE_CUBE_MAP_ + +#include "extension.h" +#include "gl.h" +#include + +namespace Msp { +namespace GL { + +extern Extension ARB_texture_cube_map; + +} // namespace GL +} // namespace Msp + +#endif diff --git a/source/arb_uniform_buffer_object.cpp b/source/arb_uniform_buffer_object.cpp index b788e036..9b224ffb 100644 --- a/source/arb_uniform_buffer_object.cpp +++ b/source/arb_uniform_buffer_object.cpp @@ -1,31 +1,37 @@ -#include "extension.h" #include "arb_uniform_buffer_object.h" namespace Msp { namespace GL { -PFNGLGETUNIFORMINDICESPROC glGetUniformIndices = 0; -PFNGLGETACTIVEUNIFORMSIVPROC glGetActiveUniformsiv = 0; +PFNGLBINDBUFFERBASEPROC glBindBufferBase = 0; +PFNGLBINDBUFFERRANGEPROC glBindBufferRange = 0; +PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glGetActiveUniformBlockName = 0; +PFNGLGETACTIVEUNIFORMBLOCKIVPROC glGetActiveUniformBlockiv = 0; PFNGLGETACTIVEUNIFORMNAMEPROC glGetActiveUniformName = 0; +PFNGLGETACTIVEUNIFORMSIVPROC glGetActiveUniformsiv = 0; PFNGLGETUNIFORMBLOCKINDEXPROC glGetUniformBlockIndex = 0; -PFNGLGETACTIVEUNIFORMBLOCKIVPROC glGetActiveUniformBlockiv = 0; -PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glGetActiveUniformBlockName = 0; +PFNGLGETUNIFORMINDICESPROC glGetUniformIndices = 0; PFNGLUNIFORMBLOCKBINDINGPROC glUniformBlockBinding = 0; -PFNGLBINDBUFFERBASEPROC glBindBufferBase = 0; -PFNGLBINDBUFFERRANGEPROC glBindBufferRange = 0; -void init_arb_uniform_buffer_object() +Extension::SupportLevel init_arb_uniform_buffer_object() { - glGetUniformIndices = reinterpret_cast(get_proc_address("glGetUniformIndices")); - glGetActiveUniformsiv = reinterpret_cast(get_proc_address("glGetActiveUniformsiv")); - glGetActiveUniformName = reinterpret_cast(get_proc_address("glGetActiveUniformName")); - glGetUniformBlockIndex = reinterpret_cast(get_proc_address("glGetUniformBlockIndex")); - glGetActiveUniformBlockiv = reinterpret_cast(get_proc_address("glGetActiveUniformBlockiv")); - glGetActiveUniformBlockName = reinterpret_cast(get_proc_address("glGetActiveUniformBlockName")); - glUniformBlockBinding = reinterpret_cast(get_proc_address("glUniformBlockBinding")); - glBindBufferBase = reinterpret_cast(get_proc_address("glBindBufferBase")); - glBindBufferRange = reinterpret_cast(get_proc_address("glBindBufferRange")); + if(is_version_at_least(3, 0) || is_supported("GL_ARB_uniform_buffer_object")) + { + glBindBufferBase = reinterpret_cast(get_proc_address("glBindBufferBase")); + glBindBufferRange = reinterpret_cast(get_proc_address("glBindBufferRange")); + glGetActiveUniformBlockName = reinterpret_cast(get_proc_address("glGetActiveUniformBlockName")); + glGetActiveUniformBlockiv = reinterpret_cast(get_proc_address("glGetActiveUniformBlockiv")); + glGetActiveUniformName = reinterpret_cast(get_proc_address("glGetActiveUniformName")); + glGetActiveUniformsiv = reinterpret_cast(get_proc_address("glGetActiveUniformsiv")); + glGetUniformBlockIndex = reinterpret_cast(get_proc_address("glGetUniformBlockIndex")); + glGetUniformIndices = reinterpret_cast(get_proc_address("glGetUniformIndices")); + glUniformBlockBinding = reinterpret_cast(get_proc_address("glUniformBlockBinding")); + return Extension::CORE; + } + return Extension::UNSUPPORTED; } +Extension ARB_uniform_buffer_object("GL_ARB_uniform_buffer_object", init_arb_uniform_buffer_object); + } // namespace GL } // namespace Msp diff --git a/source/arb_uniform_buffer_object.h b/source/arb_uniform_buffer_object.h index 1b8ced53..5a259252 100644 --- a/source/arb_uniform_buffer_object.h +++ b/source/arb_uniform_buffer_object.h @@ -1,23 +1,24 @@ #ifndef MSP_GL_ARB_UNIFORM_BUFFER_OBJECT_ #define MSP_GL_ARB_UNIFORM_BUFFER_OBJECT_ +#include "extension.h" #include "gl.h" #include namespace Msp { namespace GL { -extern PFNGLGETUNIFORMINDICESPROC glGetUniformIndices; -extern PFNGLGETACTIVEUNIFORMSIVPROC glGetActiveUniformsiv; +extern PFNGLBINDBUFFERBASEPROC glBindBufferBase; +extern PFNGLBINDBUFFERRANGEPROC glBindBufferRange; +extern PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glGetActiveUniformBlockName; +extern PFNGLGETACTIVEUNIFORMBLOCKIVPROC glGetActiveUniformBlockiv; extern PFNGLGETACTIVEUNIFORMNAMEPROC glGetActiveUniformName; +extern PFNGLGETACTIVEUNIFORMSIVPROC glGetActiveUniformsiv; extern PFNGLGETUNIFORMBLOCKINDEXPROC glGetUniformBlockIndex; -extern PFNGLGETACTIVEUNIFORMBLOCKIVPROC glGetActiveUniformBlockiv; -extern PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glGetActiveUniformBlockName; +extern PFNGLGETUNIFORMINDICESPROC glGetUniformIndices; extern PFNGLUNIFORMBLOCKBINDINGPROC glUniformBlockBinding; -extern PFNGLBINDBUFFERBASEPROC glBindBufferBase; -extern PFNGLBINDBUFFERRANGEPROC glBindBufferRange; -void init_arb_uniform_buffer_object(); +extern Extension ARB_uniform_buffer_object; } // namespace GL } // namespace Msp diff --git a/source/arb_vertex_buffer_object.cpp b/source/arb_vertex_buffer_object.cpp index 66ef40e5..cf623c47 100644 --- a/source/arb_vertex_buffer_object.cpp +++ b/source/arb_vertex_buffer_object.cpp @@ -1,35 +1,56 @@ -#include "extension.h" #include "arb_vertex_buffer_object.h" namespace Msp { namespace GL { -PFNGLBINDBUFFERARBPROC glBindBufferARB = 0; -PFNGLDELETEBUFFERSARBPROC glDeleteBuffersARB = 0; -PFNGLGENBUFFERSARBPROC glGenBuffersARB = 0; -PFNGLISBUFFERARBPROC glIsBufferARB = 0; -PFNGLBUFFERDATAARBPROC glBufferDataARB = 0; -PFNGLBUFFERSUBDATAARBPROC glBufferSubDataARB = 0; -PFNGLGETBUFFERSUBDATAARBPROC glGetBufferSubDataARB = 0; -PFNGLMAPBUFFERARBPROC glMapBufferARB = 0; -PFNGLUNMAPBUFFERARBPROC glUnmapBufferARB = 0; -PFNGLGETBUFFERPARAMETERIVARBPROC glGetBufferParameterivARB = 0; -PFNGLGETBUFFERPOINTERVARBPROC glGetBufferPointervARB = 0; +PFNGLBINDBUFFERPROC glBindBuffer = 0; +PFNGLBUFFERDATAPROC glBufferData = 0; +PFNGLBUFFERSUBDATAPROC glBufferSubData = 0; +PFNGLDELETEBUFFERSPROC glDeleteBuffers = 0; +PFNGLGENBUFFERSPROC glGenBuffers = 0; +PFNGLGETBUFFERPARAMETERIVPROC glGetBufferParameteriv = 0; +PFNGLGETBUFFERPOINTERVPROC glGetBufferPointerv = 0; +PFNGLGETBUFFERSUBDATAPROC glGetBufferSubData = 0; +PFNGLISBUFFERPROC glIsBuffer = 0; +PFNGLMAPBUFFERPROC glMapBuffer = 0; +PFNGLUNMAPBUFFERPROC glUnmapBuffer = 0; -void init_arb_vertex_buffer_object() +Extension::SupportLevel init_arb_vertex_buffer_object() { - glBindBufferARB = reinterpret_cast(get_proc_address("glBindBufferARB")); - glDeleteBuffersARB = reinterpret_cast(get_proc_address("glDeleteBuffersARB")); - glGenBuffersARB = reinterpret_cast(get_proc_address("glGenBuffersARB")); - glIsBufferARB = reinterpret_cast(get_proc_address("glIsBufferARB")); - glBufferDataARB = reinterpret_cast(get_proc_address("glBufferDataARB")); - glBufferSubDataARB = reinterpret_cast(get_proc_address("glBufferSubDataARB")); - glGetBufferSubDataARB = reinterpret_cast(get_proc_address("glGetBufferSubDataARB")); - glMapBufferARB = reinterpret_cast(get_proc_address("glMapBufferARB")); - glUnmapBufferARB = reinterpret_cast(get_proc_address("glUnmapBufferARB")); - glGetBufferParameterivARB = reinterpret_cast(get_proc_address("glGetBufferParameterivARB")); - glGetBufferPointervARB = reinterpret_cast(get_proc_address("glGetBufferPointervARB")); + if(is_version_at_least(1, 5)) + { + glBindBuffer = reinterpret_cast(get_proc_address("glBindBuffer")); + glBufferData = reinterpret_cast(get_proc_address("glBufferData")); + glBufferSubData = reinterpret_cast(get_proc_address("glBufferSubData")); + glDeleteBuffers = reinterpret_cast(get_proc_address("glDeleteBuffers")); + glGenBuffers = reinterpret_cast(get_proc_address("glGenBuffers")); + glGetBufferParameteriv = reinterpret_cast(get_proc_address("glGetBufferParameteriv")); + glGetBufferPointerv = reinterpret_cast(get_proc_address("glGetBufferPointerv")); + glGetBufferSubData = reinterpret_cast(get_proc_address("glGetBufferSubData")); + glIsBuffer = reinterpret_cast(get_proc_address("glIsBuffer")); + glMapBuffer = reinterpret_cast(get_proc_address("glMapBuffer")); + glUnmapBuffer = reinterpret_cast(get_proc_address("glUnmapBuffer")); + return Extension::CORE; + } + if(is_supported("GL_ARB_vertex_buffer_object")) + { + glBindBuffer = reinterpret_cast(get_proc_address("glBindBufferARB")); + glBufferData = reinterpret_cast(get_proc_address("glBufferDataARB")); + glBufferSubData = reinterpret_cast(get_proc_address("glBufferSubDataARB")); + glDeleteBuffers = reinterpret_cast(get_proc_address("glDeleteBuffersARB")); + glGenBuffers = reinterpret_cast(get_proc_address("glGenBuffersARB")); + glGetBufferParameteriv = reinterpret_cast(get_proc_address("glGetBufferParameterivARB")); + glGetBufferPointerv = reinterpret_cast(get_proc_address("glGetBufferPointervARB")); + glGetBufferSubData = reinterpret_cast(get_proc_address("glGetBufferSubDataARB")); + glIsBuffer = reinterpret_cast(get_proc_address("glIsBufferARB")); + glMapBuffer = reinterpret_cast(get_proc_address("glMapBufferARB")); + glUnmapBuffer = reinterpret_cast(get_proc_address("glUnmapBufferARB")); + return Extension::EXTENSION; + } + return Extension::UNSUPPORTED; } +Extension ARB_vertex_buffer_object("GL_ARB_vertex_buffer_object", init_arb_vertex_buffer_object); + } // namespace GL } // namespace Msp diff --git a/source/arb_vertex_buffer_object.h b/source/arb_vertex_buffer_object.h index 8d3be978..1154446d 100644 --- a/source/arb_vertex_buffer_object.h +++ b/source/arb_vertex_buffer_object.h @@ -1,25 +1,26 @@ #ifndef MSP_GL_ARB_VERTEX_BUFFER_OBJECT_ #define MSP_GL_ARB_VERTEX_BUFFER_OBJECT_ +#include "extension.h" #include "gl.h" #include namespace Msp { namespace GL { -extern PFNGLBINDBUFFERARBPROC glBindBufferARB; -extern PFNGLDELETEBUFFERSARBPROC glDeleteBuffersARB; -extern PFNGLGENBUFFERSARBPROC glGenBuffersARB; -extern PFNGLISBUFFERARBPROC glIsBufferARB; -extern PFNGLBUFFERDATAARBPROC glBufferDataARB; -extern PFNGLBUFFERSUBDATAARBPROC glBufferSubDataARB; -extern PFNGLGETBUFFERSUBDATAARBPROC glGetBufferSubDataARB; -extern PFNGLMAPBUFFERARBPROC glMapBufferARB; -extern PFNGLUNMAPBUFFERARBPROC glUnmapBufferARB; -extern PFNGLGETBUFFERPARAMETERIVARBPROC glGetBufferParameterivARB; -extern PFNGLGETBUFFERPOINTERVARBPROC glGetBufferPointervARB; +extern PFNGLBINDBUFFERPROC glBindBuffer; +extern PFNGLBUFFERDATAPROC glBufferData; +extern PFNGLBUFFERSUBDATAPROC glBufferSubData; +extern PFNGLDELETEBUFFERSPROC glDeleteBuffers; +extern PFNGLGENBUFFERSPROC glGenBuffers; +extern PFNGLGETBUFFERPARAMETERIVPROC glGetBufferParameteriv; +extern PFNGLGETBUFFERPOINTERVPROC glGetBufferPointerv; +extern PFNGLGETBUFFERSUBDATAPROC glGetBufferSubData; +extern PFNGLISBUFFERPROC glIsBuffer; +extern PFNGLMAPBUFFERPROC glMapBuffer; +extern PFNGLUNMAPBUFFERPROC glUnmapBuffer; -void init_arb_vertex_buffer_object(); +extern Extension ARB_vertex_buffer_object; } // namespace GL } // namespace Msp diff --git a/source/arb_vertex_program.cpp b/source/arb_vertex_program.cpp deleted file mode 100644 index 41adaee6..00000000 --- a/source/arb_vertex_program.cpp +++ /dev/null @@ -1,137 +0,0 @@ -#include "extension.h" -#include "arb_vertex_program.h" - -namespace Msp { -namespace GL { - -PFNGLVERTEXATTRIB1DARBPROC glVertexAttrib1dARB = 0; -PFNGLVERTEXATTRIB1DVARBPROC glVertexAttrib1dvARB = 0; -PFNGLVERTEXATTRIB1FARBPROC glVertexAttrib1fARB = 0; -PFNGLVERTEXATTRIB1FVARBPROC glVertexAttrib1fvARB = 0; -PFNGLVERTEXATTRIB1SARBPROC glVertexAttrib1sARB = 0; -PFNGLVERTEXATTRIB1SVARBPROC glVertexAttrib1svARB = 0; -PFNGLVERTEXATTRIB2DARBPROC glVertexAttrib2dARB = 0; -PFNGLVERTEXATTRIB2DVARBPROC glVertexAttrib2dvARB = 0; -PFNGLVERTEXATTRIB2FARBPROC glVertexAttrib2fARB = 0; -PFNGLVERTEXATTRIB2FVARBPROC glVertexAttrib2fvARB = 0; -PFNGLVERTEXATTRIB2SARBPROC glVertexAttrib2sARB = 0; -PFNGLVERTEXATTRIB2SVARBPROC glVertexAttrib2svARB = 0; -PFNGLVERTEXATTRIB3DARBPROC glVertexAttrib3dARB = 0; -PFNGLVERTEXATTRIB3DVARBPROC glVertexAttrib3dvARB = 0; -PFNGLVERTEXATTRIB3FARBPROC glVertexAttrib3fARB = 0; -PFNGLVERTEXATTRIB3FVARBPROC glVertexAttrib3fvARB = 0; -PFNGLVERTEXATTRIB3SARBPROC glVertexAttrib3sARB = 0; -PFNGLVERTEXATTRIB3SVARBPROC glVertexAttrib3svARB = 0; -PFNGLVERTEXATTRIB4NBVARBPROC glVertexAttrib4NbvARB = 0; -PFNGLVERTEXATTRIB4NIVARBPROC glVertexAttrib4NivARB = 0; -PFNGLVERTEXATTRIB4NSVARBPROC glVertexAttrib4NsvARB = 0; -PFNGLVERTEXATTRIB4NUBARBPROC glVertexAttrib4NubARB = 0; -PFNGLVERTEXATTRIB4NUBVARBPROC glVertexAttrib4NubvARB = 0; -PFNGLVERTEXATTRIB4NUIVARBPROC glVertexAttrib4NuivARB = 0; -PFNGLVERTEXATTRIB4NUSVARBPROC glVertexAttrib4NusvARB = 0; -PFNGLVERTEXATTRIB4BVARBPROC glVertexAttrib4bvARB = 0; -PFNGLVERTEXATTRIB4DARBPROC glVertexAttrib4dARB = 0; -PFNGLVERTEXATTRIB4DVARBPROC glVertexAttrib4dvARB = 0; -PFNGLVERTEXATTRIB4FARBPROC glVertexAttrib4fARB = 0; -PFNGLVERTEXATTRIB4FVARBPROC glVertexAttrib4fvARB = 0; -PFNGLVERTEXATTRIB4IVARBPROC glVertexAttrib4ivARB = 0; -PFNGLVERTEXATTRIB4SARBPROC glVertexAttrib4sARB = 0; -PFNGLVERTEXATTRIB4SVARBPROC glVertexAttrib4svARB = 0; -PFNGLVERTEXATTRIB4UBVARBPROC glVertexAttrib4ubvARB = 0; -PFNGLVERTEXATTRIB4UIVARBPROC glVertexAttrib4uivARB = 0; -PFNGLVERTEXATTRIB4USVARBPROC glVertexAttrib4usvARB = 0; -PFNGLVERTEXATTRIBPOINTERARBPROC glVertexAttribPointerARB = 0; -PFNGLENABLEVERTEXATTRIBARRAYARBPROC glEnableVertexAttribArrayARB = 0; -PFNGLDISABLEVERTEXATTRIBARRAYARBPROC glDisableVertexAttribArrayARB = 0; -PFNGLPROGRAMSTRINGARBPROC glProgramStringARB = 0; -PFNGLBINDPROGRAMARBPROC glBindProgramARB = 0; -PFNGLDELETEPROGRAMSARBPROC glDeleteProgramsARB = 0; -PFNGLGENPROGRAMSARBPROC glGenProgramsARB = 0; -PFNGLPROGRAMENVPARAMETER4DARBPROC glProgramEnvParameter4dARB = 0; -PFNGLPROGRAMENVPARAMETER4DVARBPROC glProgramEnvParameter4dvARB = 0; -PFNGLPROGRAMENVPARAMETER4FARBPROC glProgramEnvParameter4fARB = 0; -PFNGLPROGRAMENVPARAMETER4FVARBPROC glProgramEnvParameter4fvARB = 0; -PFNGLPROGRAMLOCALPARAMETER4DARBPROC glProgramLocalParameter4dARB = 0; -PFNGLPROGRAMLOCALPARAMETER4DVARBPROC glProgramLocalParameter4dvARB = 0; -PFNGLPROGRAMLOCALPARAMETER4FARBPROC glProgramLocalParameter4fARB = 0; -PFNGLPROGRAMLOCALPARAMETER4FVARBPROC glProgramLocalParameter4fvARB = 0; -PFNGLGETPROGRAMENVPARAMETERDVARBPROC glGetProgramEnvParameterdvARB = 0; -PFNGLGETPROGRAMENVPARAMETERFVARBPROC glGetProgramEnvParameterfvARB = 0; -PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC glGetProgramLocalParameterdvARB = 0; -PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC glGetProgramLocalParameterfvARB = 0; -PFNGLGETPROGRAMIVARBPROC glGetProgramivARB = 0; -PFNGLGETPROGRAMSTRINGARBPROC glGetProgramStringARB = 0; -PFNGLGETVERTEXATTRIBDVARBPROC glGetVertexAttribdvARB = 0; -PFNGLGETVERTEXATTRIBFVARBPROC glGetVertexAttribfvARB = 0; -PFNGLGETVERTEXATTRIBIVARBPROC glGetVertexAttribivARB = 0; -PFNGLGETVERTEXATTRIBPOINTERVARBPROC glGetVertexAttribPointervARB = 0; -PFNGLISPROGRAMARBPROC glIsProgramARB = 0; - -void init_arb_vertex_program() -{ - glVertexAttrib1dARB = reinterpret_cast(get_proc_address("glVertexAttrib1dARB")); - glVertexAttrib1dvARB = reinterpret_cast(get_proc_address("glVertexAttrib1dvARB")); - glVertexAttrib1fARB = reinterpret_cast(get_proc_address("glVertexAttrib1fARB")); - glVertexAttrib1fvARB = reinterpret_cast(get_proc_address("glVertexAttrib1fvARB")); - glVertexAttrib1sARB = reinterpret_cast(get_proc_address("glVertexAttrib1sARB")); - glVertexAttrib1svARB = reinterpret_cast(get_proc_address("glVertexAttrib1svARB")); - glVertexAttrib2dARB = reinterpret_cast(get_proc_address("glVertexAttrib2dARB")); - glVertexAttrib2dvARB = reinterpret_cast(get_proc_address("glVertexAttrib2dvARB")); - glVertexAttrib2fARB = reinterpret_cast(get_proc_address("glVertexAttrib2fARB")); - glVertexAttrib2fvARB = reinterpret_cast(get_proc_address("glVertexAttrib2fvARB")); - glVertexAttrib2sARB = reinterpret_cast(get_proc_address("glVertexAttrib2sARB")); - glVertexAttrib2svARB = reinterpret_cast(get_proc_address("glVertexAttrib2svARB")); - glVertexAttrib3dARB = reinterpret_cast(get_proc_address("glVertexAttrib3dARB")); - glVertexAttrib3dvARB = reinterpret_cast(get_proc_address("glVertexAttrib3dvARB")); - glVertexAttrib3fARB = reinterpret_cast(get_proc_address("glVertexAttrib3fARB")); - glVertexAttrib3fvARB = reinterpret_cast(get_proc_address("glVertexAttrib3fvARB")); - glVertexAttrib3sARB = reinterpret_cast(get_proc_address("glVertexAttrib3sARB")); - glVertexAttrib3svARB = reinterpret_cast(get_proc_address("glVertexAttrib3svARB")); - glVertexAttrib4NbvARB = reinterpret_cast(get_proc_address("glVertexAttrib4NbvARB")); - glVertexAttrib4NivARB = reinterpret_cast(get_proc_address("glVertexAttrib4NivARB")); - glVertexAttrib4NsvARB = reinterpret_cast(get_proc_address("glVertexAttrib4NsvARB")); - glVertexAttrib4NubARB = reinterpret_cast(get_proc_address("glVertexAttrib4NubARB")); - glVertexAttrib4NubvARB = reinterpret_cast(get_proc_address("glVertexAttrib4NubvARB")); - glVertexAttrib4NuivARB = reinterpret_cast(get_proc_address("glVertexAttrib4NuivARB")); - glVertexAttrib4NusvARB = reinterpret_cast(get_proc_address("glVertexAttrib4NusvARB")); - glVertexAttrib4bvARB = reinterpret_cast(get_proc_address("glVertexAttrib4bvARB")); - glVertexAttrib4dARB = reinterpret_cast(get_proc_address("glVertexAttrib4dARB")); - glVertexAttrib4dvARB = reinterpret_cast(get_proc_address("glVertexAttrib4dvARB")); - glVertexAttrib4fARB = reinterpret_cast(get_proc_address("glVertexAttrib4fARB")); - glVertexAttrib4fvARB = reinterpret_cast(get_proc_address("glVertexAttrib4fvARB")); - glVertexAttrib4ivARB = reinterpret_cast(get_proc_address("glVertexAttrib4ivARB")); - glVertexAttrib4sARB = reinterpret_cast(get_proc_address("glVertexAttrib4sARB")); - glVertexAttrib4svARB = reinterpret_cast(get_proc_address("glVertexAttrib4svARB")); - glVertexAttrib4ubvARB = reinterpret_cast(get_proc_address("glVertexAttrib4ubvARB")); - glVertexAttrib4uivARB = reinterpret_cast(get_proc_address("glVertexAttrib4uivARB")); - glVertexAttrib4usvARB = reinterpret_cast(get_proc_address("glVertexAttrib4usvARB")); - glVertexAttribPointerARB = reinterpret_cast(get_proc_address("glVertexAttribPointerARB")); - glEnableVertexAttribArrayARB = reinterpret_cast(get_proc_address("glEnableVertexAttribArrayARB")); - glDisableVertexAttribArrayARB = reinterpret_cast(get_proc_address("glDisableVertexAttribArrayARB")); - glProgramStringARB = reinterpret_cast(get_proc_address("glProgramStringARB")); - glBindProgramARB = reinterpret_cast(get_proc_address("glBindProgramARB")); - glDeleteProgramsARB = reinterpret_cast(get_proc_address("glDeleteProgramsARB")); - glGenProgramsARB = reinterpret_cast(get_proc_address("glGenProgramsARB")); - glProgramEnvParameter4dARB = reinterpret_cast(get_proc_address("glProgramEnvParameter4dARB")); - glProgramEnvParameter4dvARB = reinterpret_cast(get_proc_address("glProgramEnvParameter4dvARB")); - glProgramEnvParameter4fARB = reinterpret_cast(get_proc_address("glProgramEnvParameter4fARB")); - glProgramEnvParameter4fvARB = reinterpret_cast(get_proc_address("glProgramEnvParameter4fvARB")); - glProgramLocalParameter4dARB = reinterpret_cast(get_proc_address("glProgramLocalParameter4dARB")); - glProgramLocalParameter4dvARB = reinterpret_cast(get_proc_address("glProgramLocalParameter4dvARB")); - glProgramLocalParameter4fARB = reinterpret_cast(get_proc_address("glProgramLocalParameter4fARB")); - glProgramLocalParameter4fvARB = reinterpret_cast(get_proc_address("glProgramLocalParameter4fvARB")); - glGetProgramEnvParameterdvARB = reinterpret_cast(get_proc_address("glGetProgramEnvParameterdvARB")); - glGetProgramEnvParameterfvARB = reinterpret_cast(get_proc_address("glGetProgramEnvParameterfvARB")); - glGetProgramLocalParameterdvARB = reinterpret_cast(get_proc_address("glGetProgramLocalParameterdvARB")); - glGetProgramLocalParameterfvARB = reinterpret_cast(get_proc_address("glGetProgramLocalParameterfvARB")); - glGetProgramivARB = reinterpret_cast(get_proc_address("glGetProgramivARB")); - glGetProgramStringARB = reinterpret_cast(get_proc_address("glGetProgramStringARB")); - glGetVertexAttribdvARB = reinterpret_cast(get_proc_address("glGetVertexAttribdvARB")); - glGetVertexAttribfvARB = reinterpret_cast(get_proc_address("glGetVertexAttribfvARB")); - glGetVertexAttribivARB = reinterpret_cast(get_proc_address("glGetVertexAttribivARB")); - glGetVertexAttribPointervARB = reinterpret_cast(get_proc_address("glGetVertexAttribPointervARB")); - glIsProgramARB = reinterpret_cast(get_proc_address("glIsProgramARB")); -} - -} // namespace GL -} // namespace Msp diff --git a/source/arb_vertex_program.h b/source/arb_vertex_program.h deleted file mode 100644 index a4c8dd0d..00000000 --- a/source/arb_vertex_program.h +++ /dev/null @@ -1,78 +0,0 @@ -#ifndef MSP_GL_ARB_VERTEX_PROGRAM_ -#define MSP_GL_ARB_VERTEX_PROGRAM_ - -#include "gl.h" -#include - -namespace Msp { -namespace GL { - -extern PFNGLVERTEXATTRIB1DARBPROC glVertexAttrib1dARB; -extern PFNGLVERTEXATTRIB1DVARBPROC glVertexAttrib1dvARB; -extern PFNGLVERTEXATTRIB1FARBPROC glVertexAttrib1fARB; -extern PFNGLVERTEXATTRIB1FVARBPROC glVertexAttrib1fvARB; -extern PFNGLVERTEXATTRIB1SARBPROC glVertexAttrib1sARB; -extern PFNGLVERTEXATTRIB1SVARBPROC glVertexAttrib1svARB; -extern PFNGLVERTEXATTRIB2DARBPROC glVertexAttrib2dARB; -extern PFNGLVERTEXATTRIB2DVARBPROC glVertexAttrib2dvARB; -extern PFNGLVERTEXATTRIB2FARBPROC glVertexAttrib2fARB; -extern PFNGLVERTEXATTRIB2FVARBPROC glVertexAttrib2fvARB; -extern PFNGLVERTEXATTRIB2SARBPROC glVertexAttrib2sARB; -extern PFNGLVERTEXATTRIB2SVARBPROC glVertexAttrib2svARB; -extern PFNGLVERTEXATTRIB3DARBPROC glVertexAttrib3dARB; -extern PFNGLVERTEXATTRIB3DVARBPROC glVertexAttrib3dvARB; -extern PFNGLVERTEXATTRIB3FARBPROC glVertexAttrib3fARB; -extern PFNGLVERTEXATTRIB3FVARBPROC glVertexAttrib3fvARB; -extern PFNGLVERTEXATTRIB3SARBPROC glVertexAttrib3sARB; -extern PFNGLVERTEXATTRIB3SVARBPROC glVertexAttrib3svARB; -extern PFNGLVERTEXATTRIB4NBVARBPROC glVertexAttrib4NbvARB; -extern PFNGLVERTEXATTRIB4NIVARBPROC glVertexAttrib4NivARB; -extern PFNGLVERTEXATTRIB4NSVARBPROC glVertexAttrib4NsvARB; -extern PFNGLVERTEXATTRIB4NUBARBPROC glVertexAttrib4NubARB; -extern PFNGLVERTEXATTRIB4NUBVARBPROC glVertexAttrib4NubvARB; -extern PFNGLVERTEXATTRIB4NUIVARBPROC glVertexAttrib4NuivARB; -extern PFNGLVERTEXATTRIB4NUSVARBPROC glVertexAttrib4NusvARB; -extern PFNGLVERTEXATTRIB4BVARBPROC glVertexAttrib4bvARB; -extern PFNGLVERTEXATTRIB4DARBPROC glVertexAttrib4dARB; -extern PFNGLVERTEXATTRIB4DVARBPROC glVertexAttrib4dvARB; -extern PFNGLVERTEXATTRIB4FARBPROC glVertexAttrib4fARB; -extern PFNGLVERTEXATTRIB4FVARBPROC glVertexAttrib4fvARB; -extern PFNGLVERTEXATTRIB4IVARBPROC glVertexAttrib4ivARB; -extern PFNGLVERTEXATTRIB4SARBPROC glVertexAttrib4sARB; -extern PFNGLVERTEXATTRIB4SVARBPROC glVertexAttrib4svARB; -extern PFNGLVERTEXATTRIB4UBVARBPROC glVertexAttrib4ubvARB; -extern PFNGLVERTEXATTRIB4UIVARBPROC glVertexAttrib4uivARB; -extern PFNGLVERTEXATTRIB4USVARBPROC glVertexAttrib4usvARB; -extern PFNGLVERTEXATTRIBPOINTERARBPROC glVertexAttribPointerARB; -extern PFNGLENABLEVERTEXATTRIBARRAYARBPROC glEnableVertexAttribArrayARB; -extern PFNGLDISABLEVERTEXATTRIBARRAYARBPROC glDisableVertexAttribArrayARB; -extern PFNGLPROGRAMSTRINGARBPROC glProgramStringARB; -extern PFNGLBINDPROGRAMARBPROC glBindProgramARB; -extern PFNGLDELETEPROGRAMSARBPROC glDeleteProgramsARB; -extern PFNGLGENPROGRAMSARBPROC glGenProgramsARB; -extern PFNGLPROGRAMENVPARAMETER4DARBPROC glProgramEnvParameter4dARB; -extern PFNGLPROGRAMENVPARAMETER4DVARBPROC glProgramEnvParameter4dvARB; -extern PFNGLPROGRAMENVPARAMETER4FARBPROC glProgramEnvParameter4fARB; -extern PFNGLPROGRAMENVPARAMETER4FVARBPROC glProgramEnvParameter4fvARB; -extern PFNGLPROGRAMLOCALPARAMETER4DARBPROC glProgramLocalParameter4dARB; -extern PFNGLPROGRAMLOCALPARAMETER4DVARBPROC glProgramLocalParameter4dvARB; -extern PFNGLPROGRAMLOCALPARAMETER4FARBPROC glProgramLocalParameter4fARB; -extern PFNGLPROGRAMLOCALPARAMETER4FVARBPROC glProgramLocalParameter4fvARB; -extern PFNGLGETPROGRAMENVPARAMETERDVARBPROC glGetProgramEnvParameterdvARB; -extern PFNGLGETPROGRAMENVPARAMETERFVARBPROC glGetProgramEnvParameterfvARB; -extern PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC glGetProgramLocalParameterdvARB; -extern PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC glGetProgramLocalParameterfvARB; -extern PFNGLGETPROGRAMIVARBPROC glGetProgramivARB; -extern PFNGLGETPROGRAMSTRINGARBPROC glGetProgramStringARB; -extern PFNGLGETVERTEXATTRIBDVARBPROC glGetVertexAttribdvARB; -extern PFNGLGETVERTEXATTRIBFVARBPROC glGetVertexAttribfvARB; -extern PFNGLGETVERTEXATTRIBIVARBPROC glGetVertexAttribivARB; -extern PFNGLGETVERTEXATTRIBPOINTERVARBPROC glGetVertexAttribPointervARB; -extern PFNGLISPROGRAMARBPROC glIsProgramARB; - -void init_arb_vertex_program(); - -} // namespace GL -} // namespace Msp - -#endif diff --git a/source/arb_vertex_shader.cpp b/source/arb_vertex_shader.cpp index 612c5033..918c1316 100644 --- a/source/arb_vertex_shader.cpp +++ b/source/arb_vertex_shader.cpp @@ -1,19 +1,161 @@ -#include "extension.h" #include "arb_vertex_shader.h" namespace Msp { namespace GL { -PFNGLBINDATTRIBLOCATIONARBPROC glBindAttribLocationARB = 0; -PFNGLGETACTIVEATTRIBARBPROC glGetActiveAttribARB = 0; -PFNGLGETATTRIBLOCATIONARBPROC glGetAttribLocationARB = 0; +PFNGLBINDATTRIBLOCATIONPROC glBindAttribLocation = 0; +PFNGLDISABLEVERTEXATTRIBARRAYPROC glDisableVertexAttribArray = 0; +PFNGLENABLEVERTEXATTRIBARRAYPROC glEnableVertexAttribArray = 0; +PFNGLGETACTIVEATTRIBPROC glGetActiveAttrib = 0; +PFNGLGETATTRIBLOCATIONPROC glGetAttribLocation = 0; +PFNGLGETVERTEXATTRIBPOINTERVPROC glGetVertexAttribPointerv = 0; +PFNGLGETVERTEXATTRIBDVPROC glGetVertexAttribdv = 0; +PFNGLGETVERTEXATTRIBFVPROC glGetVertexAttribfv = 0; +PFNGLGETVERTEXATTRIBIVPROC glGetVertexAttribiv = 0; +PFNGLVERTEXATTRIB1DPROC glVertexAttrib1d = 0; +PFNGLVERTEXATTRIB1DVPROC glVertexAttrib1dv = 0; +PFNGLVERTEXATTRIB1FPROC glVertexAttrib1f = 0; +PFNGLVERTEXATTRIB1FVPROC glVertexAttrib1fv = 0; +PFNGLVERTEXATTRIB1SPROC glVertexAttrib1s = 0; +PFNGLVERTEXATTRIB1SVPROC glVertexAttrib1sv = 0; +PFNGLVERTEXATTRIB2DPROC glVertexAttrib2d = 0; +PFNGLVERTEXATTRIB2DVPROC glVertexAttrib2dv = 0; +PFNGLVERTEXATTRIB2FPROC glVertexAttrib2f = 0; +PFNGLVERTEXATTRIB2FVPROC glVertexAttrib2fv = 0; +PFNGLVERTEXATTRIB2SPROC glVertexAttrib2s = 0; +PFNGLVERTEXATTRIB2SVPROC glVertexAttrib2sv = 0; +PFNGLVERTEXATTRIB3DPROC glVertexAttrib3d = 0; +PFNGLVERTEXATTRIB3DVPROC glVertexAttrib3dv = 0; +PFNGLVERTEXATTRIB3FPROC glVertexAttrib3f = 0; +PFNGLVERTEXATTRIB3FVPROC glVertexAttrib3fv = 0; +PFNGLVERTEXATTRIB3SPROC glVertexAttrib3s = 0; +PFNGLVERTEXATTRIB3SVPROC glVertexAttrib3sv = 0; +PFNGLVERTEXATTRIB4NBVPROC glVertexAttrib4Nbv = 0; +PFNGLVERTEXATTRIB4NIVPROC glVertexAttrib4Niv = 0; +PFNGLVERTEXATTRIB4NSVPROC glVertexAttrib4Nsv = 0; +PFNGLVERTEXATTRIB4NUBPROC glVertexAttrib4Nub = 0; +PFNGLVERTEXATTRIB4NUBVPROC glVertexAttrib4Nubv = 0; +PFNGLVERTEXATTRIB4NUIVPROC glVertexAttrib4Nuiv = 0; +PFNGLVERTEXATTRIB4NUSVPROC glVertexAttrib4Nusv = 0; +PFNGLVERTEXATTRIB4BVPROC glVertexAttrib4bv = 0; +PFNGLVERTEXATTRIB4DPROC glVertexAttrib4d = 0; +PFNGLVERTEXATTRIB4DVPROC glVertexAttrib4dv = 0; +PFNGLVERTEXATTRIB4FPROC glVertexAttrib4f = 0; +PFNGLVERTEXATTRIB4FVPROC glVertexAttrib4fv = 0; +PFNGLVERTEXATTRIB4IVPROC glVertexAttrib4iv = 0; +PFNGLVERTEXATTRIB4SPROC glVertexAttrib4s = 0; +PFNGLVERTEXATTRIB4SVPROC glVertexAttrib4sv = 0; +PFNGLVERTEXATTRIB4UBVPROC glVertexAttrib4ubv = 0; +PFNGLVERTEXATTRIB4UIVPROC glVertexAttrib4uiv = 0; +PFNGLVERTEXATTRIB4USVPROC glVertexAttrib4usv = 0; +PFNGLVERTEXATTRIBPOINTERPROC glVertexAttribPointer = 0; -void init_arb_vertex_shader() +Extension::SupportLevel init_arb_vertex_shader() { - glBindAttribLocationARB = reinterpret_cast(get_proc_address("glBindAttribLocationARB")); - glGetActiveAttribARB = reinterpret_cast(get_proc_address("glGetActiveAttribARB")); - glGetAttribLocationARB = reinterpret_cast(get_proc_address("glGetAttribLocationARB")); + if(is_version_at_least(2, 0)) + { + glBindAttribLocation = reinterpret_cast(get_proc_address("glBindAttribLocation")); + glDisableVertexAttribArray = reinterpret_cast(get_proc_address("glDisableVertexAttribArray")); + glEnableVertexAttribArray = reinterpret_cast(get_proc_address("glEnableVertexAttribArray")); + glGetActiveAttrib = reinterpret_cast(get_proc_address("glGetActiveAttrib")); + glGetAttribLocation = reinterpret_cast(get_proc_address("glGetAttribLocation")); + glGetVertexAttribPointerv = reinterpret_cast(get_proc_address("glGetVertexAttribPointerv")); + glGetVertexAttribdv = reinterpret_cast(get_proc_address("glGetVertexAttribdv")); + glGetVertexAttribfv = reinterpret_cast(get_proc_address("glGetVertexAttribfv")); + glGetVertexAttribiv = reinterpret_cast(get_proc_address("glGetVertexAttribiv")); + glVertexAttrib1d = reinterpret_cast(get_proc_address("glVertexAttrib1d")); + glVertexAttrib1dv = reinterpret_cast(get_proc_address("glVertexAttrib1dv")); + glVertexAttrib1f = reinterpret_cast(get_proc_address("glVertexAttrib1f")); + glVertexAttrib1fv = reinterpret_cast(get_proc_address("glVertexAttrib1fv")); + glVertexAttrib1s = reinterpret_cast(get_proc_address("glVertexAttrib1s")); + glVertexAttrib1sv = reinterpret_cast(get_proc_address("glVertexAttrib1sv")); + glVertexAttrib2d = reinterpret_cast(get_proc_address("glVertexAttrib2d")); + glVertexAttrib2dv = reinterpret_cast(get_proc_address("glVertexAttrib2dv")); + glVertexAttrib2f = reinterpret_cast(get_proc_address("glVertexAttrib2f")); + glVertexAttrib2fv = reinterpret_cast(get_proc_address("glVertexAttrib2fv")); + glVertexAttrib2s = reinterpret_cast(get_proc_address("glVertexAttrib2s")); + glVertexAttrib2sv = reinterpret_cast(get_proc_address("glVertexAttrib2sv")); + glVertexAttrib3d = reinterpret_cast(get_proc_address("glVertexAttrib3d")); + glVertexAttrib3dv = reinterpret_cast(get_proc_address("glVertexAttrib3dv")); + glVertexAttrib3f = reinterpret_cast(get_proc_address("glVertexAttrib3f")); + glVertexAttrib3fv = reinterpret_cast(get_proc_address("glVertexAttrib3fv")); + glVertexAttrib3s = reinterpret_cast(get_proc_address("glVertexAttrib3s")); + glVertexAttrib3sv = reinterpret_cast(get_proc_address("glVertexAttrib3sv")); + glVertexAttrib4Nbv = reinterpret_cast(get_proc_address("glVertexAttrib4Nbv")); + glVertexAttrib4Niv = reinterpret_cast(get_proc_address("glVertexAttrib4Niv")); + glVertexAttrib4Nsv = reinterpret_cast(get_proc_address("glVertexAttrib4Nsv")); + glVertexAttrib4Nub = reinterpret_cast(get_proc_address("glVertexAttrib4Nub")); + glVertexAttrib4Nubv = reinterpret_cast(get_proc_address("glVertexAttrib4Nubv")); + glVertexAttrib4Nuiv = reinterpret_cast(get_proc_address("glVertexAttrib4Nuiv")); + glVertexAttrib4Nusv = reinterpret_cast(get_proc_address("glVertexAttrib4Nusv")); + glVertexAttrib4bv = reinterpret_cast(get_proc_address("glVertexAttrib4bv")); + glVertexAttrib4d = reinterpret_cast(get_proc_address("glVertexAttrib4d")); + glVertexAttrib4dv = reinterpret_cast(get_proc_address("glVertexAttrib4dv")); + glVertexAttrib4f = reinterpret_cast(get_proc_address("glVertexAttrib4f")); + glVertexAttrib4fv = reinterpret_cast(get_proc_address("glVertexAttrib4fv")); + glVertexAttrib4iv = reinterpret_cast(get_proc_address("glVertexAttrib4iv")); + glVertexAttrib4s = reinterpret_cast(get_proc_address("glVertexAttrib4s")); + glVertexAttrib4sv = reinterpret_cast(get_proc_address("glVertexAttrib4sv")); + glVertexAttrib4ubv = reinterpret_cast(get_proc_address("glVertexAttrib4ubv")); + glVertexAttrib4uiv = reinterpret_cast(get_proc_address("glVertexAttrib4uiv")); + glVertexAttrib4usv = reinterpret_cast(get_proc_address("glVertexAttrib4usv")); + glVertexAttribPointer = reinterpret_cast(get_proc_address("glVertexAttribPointer")); + return Extension::CORE; + } + if(is_supported("GL_ARB_vertex_shader")) + { + glBindAttribLocation = reinterpret_cast(get_proc_address("glBindAttribLocationARB")); + glDisableVertexAttribArray = reinterpret_cast(get_proc_address("glDisableVertexAttribArrayARB")); + glEnableVertexAttribArray = reinterpret_cast(get_proc_address("glEnableVertexAttribArrayARB")); + glGetActiveAttrib = reinterpret_cast(get_proc_address("glGetActiveAttribARB")); + glGetAttribLocation = reinterpret_cast(get_proc_address("glGetAttribLocationARB")); + glGetVertexAttribPointerv = reinterpret_cast(get_proc_address("glGetVertexAttribPointervARB")); + glGetVertexAttribdv = reinterpret_cast(get_proc_address("glGetVertexAttribdvARB")); + glGetVertexAttribfv = reinterpret_cast(get_proc_address("glGetVertexAttribfvARB")); + glGetVertexAttribiv = reinterpret_cast(get_proc_address("glGetVertexAttribivARB")); + glVertexAttrib1d = reinterpret_cast(get_proc_address("glVertexAttrib1dARB")); + glVertexAttrib1dv = reinterpret_cast(get_proc_address("glVertexAttrib1dvARB")); + glVertexAttrib1f = reinterpret_cast(get_proc_address("glVertexAttrib1fARB")); + glVertexAttrib1fv = reinterpret_cast(get_proc_address("glVertexAttrib1fvARB")); + glVertexAttrib1s = reinterpret_cast(get_proc_address("glVertexAttrib1sARB")); + glVertexAttrib1sv = reinterpret_cast(get_proc_address("glVertexAttrib1svARB")); + glVertexAttrib2d = reinterpret_cast(get_proc_address("glVertexAttrib2dARB")); + glVertexAttrib2dv = reinterpret_cast(get_proc_address("glVertexAttrib2dvARB")); + glVertexAttrib2f = reinterpret_cast(get_proc_address("glVertexAttrib2fARB")); + glVertexAttrib2fv = reinterpret_cast(get_proc_address("glVertexAttrib2fvARB")); + glVertexAttrib2s = reinterpret_cast(get_proc_address("glVertexAttrib2sARB")); + glVertexAttrib2sv = reinterpret_cast(get_proc_address("glVertexAttrib2svARB")); + glVertexAttrib3d = reinterpret_cast(get_proc_address("glVertexAttrib3dARB")); + glVertexAttrib3dv = reinterpret_cast(get_proc_address("glVertexAttrib3dvARB")); + glVertexAttrib3f = reinterpret_cast(get_proc_address("glVertexAttrib3fARB")); + glVertexAttrib3fv = reinterpret_cast(get_proc_address("glVertexAttrib3fvARB")); + glVertexAttrib3s = reinterpret_cast(get_proc_address("glVertexAttrib3sARB")); + glVertexAttrib3sv = reinterpret_cast(get_proc_address("glVertexAttrib3svARB")); + glVertexAttrib4Nbv = reinterpret_cast(get_proc_address("glVertexAttrib4NbvARB")); + glVertexAttrib4Niv = reinterpret_cast(get_proc_address("glVertexAttrib4NivARB")); + glVertexAttrib4Nsv = reinterpret_cast(get_proc_address("glVertexAttrib4NsvARB")); + glVertexAttrib4Nub = reinterpret_cast(get_proc_address("glVertexAttrib4NubARB")); + glVertexAttrib4Nubv = reinterpret_cast(get_proc_address("glVertexAttrib4NubvARB")); + glVertexAttrib4Nuiv = reinterpret_cast(get_proc_address("glVertexAttrib4NuivARB")); + glVertexAttrib4Nusv = reinterpret_cast(get_proc_address("glVertexAttrib4NusvARB")); + glVertexAttrib4bv = reinterpret_cast(get_proc_address("glVertexAttrib4bvARB")); + glVertexAttrib4d = reinterpret_cast(get_proc_address("glVertexAttrib4dARB")); + glVertexAttrib4dv = reinterpret_cast(get_proc_address("glVertexAttrib4dvARB")); + glVertexAttrib4f = reinterpret_cast(get_proc_address("glVertexAttrib4fARB")); + glVertexAttrib4fv = reinterpret_cast(get_proc_address("glVertexAttrib4fvARB")); + glVertexAttrib4iv = reinterpret_cast(get_proc_address("glVertexAttrib4ivARB")); + glVertexAttrib4s = reinterpret_cast(get_proc_address("glVertexAttrib4sARB")); + glVertexAttrib4sv = reinterpret_cast(get_proc_address("glVertexAttrib4svARB")); + glVertexAttrib4ubv = reinterpret_cast(get_proc_address("glVertexAttrib4ubvARB")); + glVertexAttrib4uiv = reinterpret_cast(get_proc_address("glVertexAttrib4uivARB")); + glVertexAttrib4usv = reinterpret_cast(get_proc_address("glVertexAttrib4usvARB")); + glVertexAttribPointer = reinterpret_cast(get_proc_address("glVertexAttribPointerARB")); + return Extension::EXTENSION; + } + return Extension::UNSUPPORTED; } +Extension ARB_vertex_shader("GL_ARB_vertex_shader", init_arb_vertex_shader); + } // namespace GL } // namespace Msp diff --git a/source/arb_vertex_shader.h b/source/arb_vertex_shader.h index 6dab0c0a..6ded1a09 100644 --- a/source/arb_vertex_shader.h +++ b/source/arb_vertex_shader.h @@ -1,17 +1,61 @@ #ifndef MSP_GL_ARB_VERTEX_SHADER_ #define MSP_GL_ARB_VERTEX_SHADER_ +#include "extension.h" #include "gl.h" #include namespace Msp { namespace GL { -extern PFNGLBINDATTRIBLOCATIONARBPROC glBindAttribLocationARB; -extern PFNGLGETACTIVEATTRIBARBPROC glGetActiveAttribARB; -extern PFNGLGETATTRIBLOCATIONARBPROC glGetAttribLocationARB; +extern PFNGLBINDATTRIBLOCATIONPROC glBindAttribLocation; +extern PFNGLDISABLEVERTEXATTRIBARRAYPROC glDisableVertexAttribArray; +extern PFNGLENABLEVERTEXATTRIBARRAYPROC glEnableVertexAttribArray; +extern PFNGLGETACTIVEATTRIBPROC glGetActiveAttrib; +extern PFNGLGETATTRIBLOCATIONPROC glGetAttribLocation; +extern PFNGLGETVERTEXATTRIBPOINTERVPROC glGetVertexAttribPointerv; +extern PFNGLGETVERTEXATTRIBDVPROC glGetVertexAttribdv; +extern PFNGLGETVERTEXATTRIBFVPROC glGetVertexAttribfv; +extern PFNGLGETVERTEXATTRIBIVPROC glGetVertexAttribiv; +extern PFNGLVERTEXATTRIB1DPROC glVertexAttrib1d; +extern PFNGLVERTEXATTRIB1DVPROC glVertexAttrib1dv; +extern PFNGLVERTEXATTRIB1FPROC glVertexAttrib1f; +extern PFNGLVERTEXATTRIB1FVPROC glVertexAttrib1fv; +extern PFNGLVERTEXATTRIB1SPROC glVertexAttrib1s; +extern PFNGLVERTEXATTRIB1SVPROC glVertexAttrib1sv; +extern PFNGLVERTEXATTRIB2DPROC glVertexAttrib2d; +extern PFNGLVERTEXATTRIB2DVPROC glVertexAttrib2dv; +extern PFNGLVERTEXATTRIB2FPROC glVertexAttrib2f; +extern PFNGLVERTEXATTRIB2FVPROC glVertexAttrib2fv; +extern PFNGLVERTEXATTRIB2SPROC glVertexAttrib2s; +extern PFNGLVERTEXATTRIB2SVPROC glVertexAttrib2sv; +extern PFNGLVERTEXATTRIB3DPROC glVertexAttrib3d; +extern PFNGLVERTEXATTRIB3DVPROC glVertexAttrib3dv; +extern PFNGLVERTEXATTRIB3FPROC glVertexAttrib3f; +extern PFNGLVERTEXATTRIB3FVPROC glVertexAttrib3fv; +extern PFNGLVERTEXATTRIB3SPROC glVertexAttrib3s; +extern PFNGLVERTEXATTRIB3SVPROC glVertexAttrib3sv; +extern PFNGLVERTEXATTRIB4NBVPROC glVertexAttrib4Nbv; +extern PFNGLVERTEXATTRIB4NIVPROC glVertexAttrib4Niv; +extern PFNGLVERTEXATTRIB4NSVPROC glVertexAttrib4Nsv; +extern PFNGLVERTEXATTRIB4NUBPROC glVertexAttrib4Nub; +extern PFNGLVERTEXATTRIB4NUBVPROC glVertexAttrib4Nubv; +extern PFNGLVERTEXATTRIB4NUIVPROC glVertexAttrib4Nuiv; +extern PFNGLVERTEXATTRIB4NUSVPROC glVertexAttrib4Nusv; +extern PFNGLVERTEXATTRIB4BVPROC glVertexAttrib4bv; +extern PFNGLVERTEXATTRIB4DPROC glVertexAttrib4d; +extern PFNGLVERTEXATTRIB4DVPROC glVertexAttrib4dv; +extern PFNGLVERTEXATTRIB4FPROC glVertexAttrib4f; +extern PFNGLVERTEXATTRIB4FVPROC glVertexAttrib4fv; +extern PFNGLVERTEXATTRIB4IVPROC glVertexAttrib4iv; +extern PFNGLVERTEXATTRIB4SPROC glVertexAttrib4s; +extern PFNGLVERTEXATTRIB4SVPROC glVertexAttrib4sv; +extern PFNGLVERTEXATTRIB4UBVPROC glVertexAttrib4ubv; +extern PFNGLVERTEXATTRIB4UIVPROC glVertexAttrib4uiv; +extern PFNGLVERTEXATTRIB4USVPROC glVertexAttrib4usv; +extern PFNGLVERTEXATTRIBPOINTERPROC glVertexAttribPointer; -void init_arb_vertex_shader(); +extern Extension ARB_vertex_shader; } // namespace GL } // namespace Msp diff --git a/source/batch.cpp b/source/batch.cpp index 375c52e9..afb9787b 100644 --- a/source/batch.cpp +++ b/source/batch.cpp @@ -2,10 +2,9 @@ #include "bindable.h" #include "buffer.h" #include "error.h" -#include "extension.h" +#include "ext_draw_range_elements.h" #include "nv_primitive_restart.h" #include "vertexarray.h" -#include "version_1_2.h" using namespace std; @@ -28,7 +27,7 @@ Batch::Batch(PrimitiveType t): { /* XXX Should probably provide a fallback to glDrawElements since this class is pretty much required to render anything. */ - static RequireVersion _ver(1, 2); + static Require _req(EXT_draw_range_elements); } Batch::~Batch() @@ -165,12 +164,12 @@ void Batch::append(const Batch &other) else if(prim_type==POLYGON) throw incompatible_data("Batch::append"); else if(prim_type==TRIANGLE_FAN) - static RequireExtension _ext("GL_NV_primitive_restart"); + static Require _req(NV_primitive_restart); if(other.data.empty()) return; - if(is_supported("GL_NV_primitive_restart")) + if(NV_primitive_restart) { restart = true; if(data_type==UNSIGNED_SHORT) diff --git a/source/blend.cpp b/source/blend.cpp index 03fc0f02..cecd562d 100644 --- a/source/blend.cpp +++ b/source/blend.cpp @@ -1,6 +1,6 @@ #include "blend.h" -#include "extension.h" -#include "version_1_2.h" +#include "ext_blend_minmax.h" +#include "ext_blend_subtract.h" namespace Msp { namespace GL { @@ -22,8 +22,10 @@ Blend::Blend(BlendEquation e, BlendFactor sf, BlendFactor df): src_factor(sf), dst_factor(df) { - if(eq!=ADD) - static RequireVersion _ver(1, 2); + if(eq==MIN || eq==MAX) + static Require _req(EXT_blend_minmax); + else if(eq==SUBTRACT || eq==REVERSE_SUBTRACT) + static Require _req(EXT_blend_subtract); } void Blend::bind() const diff --git a/source/buffer.cpp b/source/buffer.cpp index f3b40da6..84c72716 100644 --- a/source/buffer.cpp +++ b/source/buffer.cpp @@ -1,8 +1,8 @@ #include +#include "arb_pixel_buffer_object.h" #include "arb_uniform_buffer_object.h" #include "arb_vertex_buffer_object.h" #include "buffer.h" -#include "extension.h" #include "misc.h" using namespace std; @@ -19,21 +19,21 @@ Buffer::Buffer(BufferType t): { require_buffer_type(type); - glGenBuffersARB(1, &id); + glGenBuffers(1, &id); } Buffer::~Buffer() { - glDeleteBuffersARB(1, &id); + glDeleteBuffers(1, &id); } void Buffer::require_buffer_type(BufferType type) { - static RequireExtension _req_vbo("GL_ARB_vertex_buffer_object"); + static Require _req_vbo(ARB_vertex_buffer_object); if(type==PIXEL_PACK_BUFFER || type==PIXEL_UNPACK_BUFFER) - static RequireExtension _req_pbo("GL_ARB_pixel_buffer_object"); + static Require _req_pbo(ARB_pixel_buffer_object); else if(type==UNIFORM_BUFFER) - static RequireExtension _req_ubo("GL_ARB_uniform_buffer_object"); + static Require _req_ubo(ARB_uniform_buffer_object); } void Buffer::set_usage(BufferUsage u) @@ -45,7 +45,7 @@ void Buffer::data(unsigned sz, const void *d) { const Buffer *old = current(type); bind(); - glBufferDataARB(type, sz, d, usage); + glBufferData(type, sz, d, usage); size = sz; restore(old, type); } @@ -54,7 +54,7 @@ void Buffer::sub_data(unsigned off, unsigned sz, const void *d) { const Buffer *old = current(type); bind(); - glBufferSubDataARB(type, off, sz, d); + glBufferSubData(type, off, sz, d); restore(old, type); } @@ -68,13 +68,13 @@ void Buffer::bind_to(BufferType t) const if(t!=type) require_buffer_type(t); if(set_current(t, this)) - glBindBufferARB(t, id); + glBindBuffer(t, id); } void Buffer::unbind_from(BufferType type) { if(set_current(type, 0)) - glBindBufferARB(type, 0); + glBindBuffer(type, 0); } const Buffer *&Buffer::binding(BufferType type) diff --git a/source/buffer.h b/source/buffer.h index 206cec8d..25ce4699 100644 --- a/source/buffer.h +++ b/source/buffer.h @@ -9,24 +9,24 @@ namespace GL { enum BufferType { - ARRAY_BUFFER = GL_ARRAY_BUFFER_ARB, - ELEMENT_ARRAY_BUFFER = GL_ELEMENT_ARRAY_BUFFER_ARB, - PIXEL_PACK_BUFFER = GL_PIXEL_PACK_BUFFER_ARB, - PIXEL_UNPACK_BUFFER = GL_PIXEL_UNPACK_BUFFER_ARB, + ARRAY_BUFFER = GL_ARRAY_BUFFER, + ELEMENT_ARRAY_BUFFER = GL_ELEMENT_ARRAY_BUFFER, + PIXEL_PACK_BUFFER = GL_PIXEL_PACK_BUFFER, + PIXEL_UNPACK_BUFFER = GL_PIXEL_UNPACK_BUFFER, UNIFORM_BUFFER = GL_UNIFORM_BUFFER }; enum BufferUsage { - STREAM_DRAW = GL_STREAM_DRAW_ARB, - STREAM_READ = GL_STREAM_READ_ARB, - STREAM_COPY = GL_STREAM_COPY_ARB, - STATIC_DRAW = GL_STATIC_DRAW_ARB, - STATIC_READ = GL_STATIC_READ_ARB, - STATIC_COPY = GL_STATIC_COPY_ARB, - DYNAMIC_DRAW = GL_DYNAMIC_DRAW_ARB, - DYNAMIC_READ = GL_DYNAMIC_READ_ARB, - DYNAMIC_COPY = GL_DYNAMIC_COPY_ARB + STREAM_DRAW = GL_STREAM_DRAW, + STREAM_READ = GL_STREAM_READ, + STREAM_COPY = GL_STREAM_COPY, + STATIC_DRAW = GL_STATIC_DRAW, + STATIC_READ = GL_STATIC_READ, + STATIC_COPY = GL_STATIC_COPY, + DYNAMIC_DRAW = GL_DYNAMIC_DRAW, + DYNAMIC_READ = GL_DYNAMIC_READ, + DYNAMIC_COPY = GL_DYNAMIC_COPY }; class BufferRange; diff --git a/source/ext_blend_minmax.cpp b/source/ext_blend_minmax.cpp new file mode 100644 index 00000000..225a05f8 --- /dev/null +++ b/source/ext_blend_minmax.cpp @@ -0,0 +1,26 @@ +#include "ext_blend_minmax.h" + +namespace Msp { +namespace GL { + +PFNGLBLENDEQUATIONPROC glBlendEquation = 0; + +Extension::SupportLevel init_ext_blend_minmax() +{ + if(is_version_at_least(1, 2)) + { + glBlendEquation = reinterpret_cast(get_proc_address("glBlendEquation")); + return Extension::CORE; + } + if(is_supported("GL_EXT_blend_minmax")) + { + glBlendEquation = reinterpret_cast(get_proc_address("glBlendEquationEXT")); + return Extension::EXTENSION; + } + return Extension::UNSUPPORTED; +} + +Extension EXT_blend_minmax("GL_EXT_blend_minmax", init_ext_blend_minmax); + +} // namespace GL +} // namespace Msp diff --git a/source/ext_blend_minmax.h b/source/ext_blend_minmax.h new file mode 100644 index 00000000..5ca1a58c --- /dev/null +++ b/source/ext_blend_minmax.h @@ -0,0 +1,18 @@ +#ifndef MSP_GL_EXT_BLEND_MINMAX_ +#define MSP_GL_EXT_BLEND_MINMAX_ + +#include "extension.h" +#include "gl.h" +#include + +namespace Msp { +namespace GL { + +extern PFNGLBLENDEQUATIONPROC glBlendEquation; + +extern Extension EXT_blend_minmax; + +} // namespace GL +} // namespace Msp + +#endif diff --git a/source/ext_blend_subtract.cpp b/source/ext_blend_subtract.cpp new file mode 100644 index 00000000..f15f3f50 --- /dev/null +++ b/source/ext_blend_subtract.cpp @@ -0,0 +1,22 @@ +#include "ext_blend_subtract.h" + +namespace Msp { +namespace GL { + +Extension::SupportLevel init_ext_blend_subtract() +{ + if(is_version_at_least(1, 2)) + { + return Extension::CORE; + } + if(is_supported("GL_EXT_blend_subtract")) + { + return Extension::EXTENSION; + } + return Extension::UNSUPPORTED; +} + +Extension EXT_blend_subtract("GL_EXT_blend_subtract", init_ext_blend_subtract); + +} // namespace GL +} // namespace Msp diff --git a/source/ext_blend_subtract.h b/source/ext_blend_subtract.h new file mode 100644 index 00000000..243d5301 --- /dev/null +++ b/source/ext_blend_subtract.h @@ -0,0 +1,16 @@ +#ifndef MSP_GL_EXT_BLEND_SUBTRACT_ +#define MSP_GL_EXT_BLEND_SUBTRACT_ + +#include "extension.h" +#include "gl.h" +#include + +namespace Msp { +namespace GL { + +extern Extension EXT_blend_subtract; + +} // namespace GL +} // namespace Msp + +#endif diff --git a/source/ext_draw_range_elements.cpp b/source/ext_draw_range_elements.cpp new file mode 100644 index 00000000..2bccf00e --- /dev/null +++ b/source/ext_draw_range_elements.cpp @@ -0,0 +1,26 @@ +#include "ext_draw_range_elements.h" + +namespace Msp { +namespace GL { + +PFNGLDRAWRANGEELEMENTSPROC glDrawRangeElements = 0; + +Extension::SupportLevel init_ext_draw_range_elements() +{ + if(is_version_at_least(1, 2)) + { + glDrawRangeElements = reinterpret_cast(get_proc_address("glDrawRangeElements")); + return Extension::CORE; + } + if(is_supported("GL_EXT_draw_range_elements")) + { + glDrawRangeElements = reinterpret_cast(get_proc_address("glDrawRangeElementsEXT")); + return Extension::EXTENSION; + } + return Extension::UNSUPPORTED; +} + +Extension EXT_draw_range_elements("GL_EXT_draw_range_elements", init_ext_draw_range_elements); + +} // namespace GL +} // namespace Msp diff --git a/source/ext_draw_range_elements.h b/source/ext_draw_range_elements.h new file mode 100644 index 00000000..e8aba1da --- /dev/null +++ b/source/ext_draw_range_elements.h @@ -0,0 +1,18 @@ +#ifndef MSP_GL_EXT_DRAW_RANGE_ELEMENTS_ +#define MSP_GL_EXT_DRAW_RANGE_ELEMENTS_ + +#include "extension.h" +#include "gl.h" +#include + +namespace Msp { +namespace GL { + +extern PFNGLDRAWRANGEELEMENTSPROC glDrawRangeElements; + +extern Extension EXT_draw_range_elements; + +} // namespace GL +} // namespace Msp + +#endif diff --git a/source/ext_framebuffer_blit.cpp b/source/ext_framebuffer_blit.cpp index 7519e13c..a198cdd1 100644 --- a/source/ext_framebuffer_blit.cpp +++ b/source/ext_framebuffer_blit.cpp @@ -1,15 +1,26 @@ -#include "extension.h" #include "ext_framebuffer_blit.h" namespace Msp { namespace GL { -PFNGLBLITFRAMEBUFFEREXTPROC glBlitFramebufferEXT = 0; +PFNGLBLITFRAMEBUFFERPROC glBlitFramebuffer = 0; -void init_ext_framebuffer_blit() +Extension::SupportLevel init_ext_framebuffer_blit() { - glBlitFramebufferEXT = reinterpret_cast(get_proc_address("glBlitFramebufferEXT")); + if(is_version_at_least(3, 0) || is_supported("GL_ARB_framebuffer_object")) + { + glBlitFramebuffer = reinterpret_cast(get_proc_address("glBlitFramebuffer")); + return Extension::CORE; + } + if(is_supported("GL_EXT_framebuffer_blit")) + { + glBlitFramebuffer = reinterpret_cast(get_proc_address("glBlitFramebufferEXT")); + return Extension::EXTENSION; + } + return Extension::UNSUPPORTED; } +Extension EXT_framebuffer_blit("GL_EXT_framebuffer_blit", init_ext_framebuffer_blit); + } // namespace GL } // namespace Msp diff --git a/source/ext_framebuffer_blit.h b/source/ext_framebuffer_blit.h index 0b651970..75ca6c6e 100644 --- a/source/ext_framebuffer_blit.h +++ b/source/ext_framebuffer_blit.h @@ -1,15 +1,16 @@ #ifndef MSP_GL_EXT_FRAMEBUFFER_BLIT_ #define MSP_GL_EXT_FRAMEBUFFER_BLIT_ +#include "extension.h" #include "gl.h" #include namespace Msp { namespace GL { -extern PFNGLBLITFRAMEBUFFEREXTPROC glBlitFramebufferEXT; +extern PFNGLBLITFRAMEBUFFERPROC glBlitFramebuffer; -void init_ext_framebuffer_blit(); +extern Extension EXT_framebuffer_blit; } // namespace GL } // namespace Msp diff --git a/source/ext_framebuffer_multisample.cpp b/source/ext_framebuffer_multisample.cpp index a0f3930c..7be2f6d3 100644 --- a/source/ext_framebuffer_multisample.cpp +++ b/source/ext_framebuffer_multisample.cpp @@ -1,15 +1,26 @@ -#include "extension.h" #include "ext_framebuffer_multisample.h" namespace Msp { namespace GL { -PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC glRenderbufferStorageMultisampleEXT = 0; +PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glRenderbufferStorageMultisample = 0; -void init_ext_framebuffer_multisample() +Extension::SupportLevel init_ext_framebuffer_multisample() { - glRenderbufferStorageMultisampleEXT = reinterpret_cast(get_proc_address("glRenderbufferStorageMultisampleEXT")); + if(is_version_at_least(3, 0) || is_supported("GL_ARB_framebuffer_object")) + { + glRenderbufferStorageMultisample = reinterpret_cast(get_proc_address("glRenderbufferStorageMultisample")); + return Extension::CORE; + } + if(is_supported("GL_EXT_framebuffer_multisample")) + { + glRenderbufferStorageMultisample = reinterpret_cast(get_proc_address("glRenderbufferStorageMultisampleEXT")); + return Extension::EXTENSION; + } + return Extension::UNSUPPORTED; } +Extension EXT_framebuffer_multisample("GL_EXT_framebuffer_multisample", init_ext_framebuffer_multisample); + } // namespace GL } // namespace Msp diff --git a/source/ext_framebuffer_multisample.h b/source/ext_framebuffer_multisample.h index 479ef693..980ef9a9 100644 --- a/source/ext_framebuffer_multisample.h +++ b/source/ext_framebuffer_multisample.h @@ -1,15 +1,16 @@ #ifndef MSP_GL_EXT_FRAMEBUFFER_MULTISAMPLE_ #define MSP_GL_EXT_FRAMEBUFFER_MULTISAMPLE_ +#include "extension.h" #include "gl.h" #include namespace Msp { namespace GL { -extern PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC glRenderbufferStorageMultisampleEXT; +extern PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glRenderbufferStorageMultisample; -void init_ext_framebuffer_multisample(); +extern Extension EXT_framebuffer_multisample; } // namespace GL } // namespace Msp diff --git a/source/ext_framebuffer_object.cpp b/source/ext_framebuffer_object.cpp index ab5048d6..e9193e17 100644 --- a/source/ext_framebuffer_object.cpp +++ b/source/ext_framebuffer_object.cpp @@ -1,47 +1,74 @@ -#include "extension.h" #include "ext_framebuffer_object.h" namespace Msp { namespace GL { -PFNGLISRENDERBUFFEREXTPROC glIsRenderbufferEXT = 0; -PFNGLBINDRENDERBUFFEREXTPROC glBindRenderbufferEXT = 0; -PFNGLDELETERENDERBUFFERSEXTPROC glDeleteRenderbuffersEXT = 0; -PFNGLGENRENDERBUFFERSEXTPROC glGenRenderbuffersEXT = 0; -PFNGLRENDERBUFFERSTORAGEEXTPROC glRenderbufferStorageEXT = 0; -PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC glGetRenderbufferParameterivEXT = 0; -PFNGLISFRAMEBUFFEREXTPROC glIsFramebufferEXT = 0; -PFNGLBINDFRAMEBUFFEREXTPROC glBindFramebufferEXT = 0; -PFNGLDELETEFRAMEBUFFERSEXTPROC glDeleteFramebuffersEXT = 0; -PFNGLGENFRAMEBUFFERSEXTPROC glGenFramebuffersEXT = 0; -PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC glCheckFramebufferStatusEXT = 0; -PFNGLFRAMEBUFFERTEXTURE1DEXTPROC glFramebufferTexture1DEXT = 0; -PFNGLFRAMEBUFFERTEXTURE2DEXTPROC glFramebufferTexture2DEXT = 0; -PFNGLFRAMEBUFFERTEXTURE3DEXTPROC glFramebufferTexture3DEXT = 0; -PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC glFramebufferRenderbufferEXT = 0; -PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC glGetFramebufferAttachmentParameterivEXT = 0; -PFNGLGENERATEMIPMAPEXTPROC glGenerateMipmapEXT = 0; +PFNGLBINDFRAMEBUFFERPROC glBindFramebuffer = 0; +PFNGLBINDRENDERBUFFERPROC glBindRenderbuffer = 0; +PFNGLCHECKFRAMEBUFFERSTATUSPROC glCheckFramebufferStatus = 0; +PFNGLDELETEFRAMEBUFFERSPROC glDeleteFramebuffers = 0; +PFNGLDELETERENDERBUFFERSPROC glDeleteRenderbuffers = 0; +PFNGLFRAMEBUFFERRENDERBUFFERPROC glFramebufferRenderbuffer = 0; +PFNGLFRAMEBUFFERTEXTURE1DPROC glFramebufferTexture1D = 0; +PFNGLFRAMEBUFFERTEXTURE2DPROC glFramebufferTexture2D = 0; +PFNGLFRAMEBUFFERTEXTURE3DPROC glFramebufferTexture3D = 0; +PFNGLGENFRAMEBUFFERSPROC glGenFramebuffers = 0; +PFNGLGENRENDERBUFFERSPROC glGenRenderbuffers = 0; +PFNGLGENERATEMIPMAPPROC glGenerateMipmap = 0; +PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glGetFramebufferAttachmentParameteriv = 0; +PFNGLGETRENDERBUFFERPARAMETERIVPROC glGetRenderbufferParameteriv = 0; +PFNGLISFRAMEBUFFERPROC glIsFramebuffer = 0; +PFNGLISRENDERBUFFERPROC glIsRenderbuffer = 0; +PFNGLRENDERBUFFERSTORAGEPROC glRenderbufferStorage = 0; -void init_ext_framebuffer_object() +Extension::SupportLevel init_ext_framebuffer_object() { - glIsRenderbufferEXT = reinterpret_cast(get_proc_address("glIsRenderbufferEXT")); - glBindRenderbufferEXT = reinterpret_cast(get_proc_address("glBindRenderbufferEXT")); - glDeleteRenderbuffersEXT = reinterpret_cast(get_proc_address("glDeleteRenderbuffersEXT")); - glGenRenderbuffersEXT = reinterpret_cast(get_proc_address("glGenRenderbuffersEXT")); - glRenderbufferStorageEXT = reinterpret_cast(get_proc_address("glRenderbufferStorageEXT")); - glGetRenderbufferParameterivEXT = reinterpret_cast(get_proc_address("glGetRenderbufferParameterivEXT")); - glIsFramebufferEXT = reinterpret_cast(get_proc_address("glIsFramebufferEXT")); - glBindFramebufferEXT = reinterpret_cast(get_proc_address("glBindFramebufferEXT")); - glDeleteFramebuffersEXT = reinterpret_cast(get_proc_address("glDeleteFramebuffersEXT")); - glGenFramebuffersEXT = reinterpret_cast(get_proc_address("glGenFramebuffersEXT")); - glCheckFramebufferStatusEXT = reinterpret_cast(get_proc_address("glCheckFramebufferStatusEXT")); - glFramebufferTexture1DEXT = reinterpret_cast(get_proc_address("glFramebufferTexture1DEXT")); - glFramebufferTexture2DEXT = reinterpret_cast(get_proc_address("glFramebufferTexture2DEXT")); - glFramebufferTexture3DEXT = reinterpret_cast(get_proc_address("glFramebufferTexture3DEXT")); - glFramebufferRenderbufferEXT = reinterpret_cast(get_proc_address("glFramebufferRenderbufferEXT")); - glGetFramebufferAttachmentParameterivEXT = reinterpret_cast(get_proc_address("glGetFramebufferAttachmentParameterivEXT")); - glGenerateMipmapEXT = reinterpret_cast(get_proc_address("glGenerateMipmapEXT")); + if(is_version_at_least(3, 0) || is_supported("GL_ARB_framebuffer_object")) + { + glBindFramebuffer = reinterpret_cast(get_proc_address("glBindFramebuffer")); + glBindRenderbuffer = reinterpret_cast(get_proc_address("glBindRenderbuffer")); + glCheckFramebufferStatus = reinterpret_cast(get_proc_address("glCheckFramebufferStatus")); + glDeleteFramebuffers = reinterpret_cast(get_proc_address("glDeleteFramebuffers")); + glDeleteRenderbuffers = reinterpret_cast(get_proc_address("glDeleteRenderbuffers")); + glFramebufferRenderbuffer = reinterpret_cast(get_proc_address("glFramebufferRenderbuffer")); + glFramebufferTexture1D = reinterpret_cast(get_proc_address("glFramebufferTexture1D")); + glFramebufferTexture2D = reinterpret_cast(get_proc_address("glFramebufferTexture2D")); + glFramebufferTexture3D = reinterpret_cast(get_proc_address("glFramebufferTexture3D")); + glGenFramebuffers = reinterpret_cast(get_proc_address("glGenFramebuffers")); + glGenRenderbuffers = reinterpret_cast(get_proc_address("glGenRenderbuffers")); + glGenerateMipmap = reinterpret_cast(get_proc_address("glGenerateMipmap")); + glGetFramebufferAttachmentParameteriv = reinterpret_cast(get_proc_address("glGetFramebufferAttachmentParameteriv")); + glGetRenderbufferParameteriv = reinterpret_cast(get_proc_address("glGetRenderbufferParameteriv")); + glIsFramebuffer = reinterpret_cast(get_proc_address("glIsFramebuffer")); + glIsRenderbuffer = reinterpret_cast(get_proc_address("glIsRenderbuffer")); + glRenderbufferStorage = reinterpret_cast(get_proc_address("glRenderbufferStorage")); + return Extension::CORE; + } + if(is_supported("GL_EXT_framebuffer_object")) + { + glBindFramebuffer = reinterpret_cast(get_proc_address("glBindFramebufferEXT")); + glBindRenderbuffer = reinterpret_cast(get_proc_address("glBindRenderbufferEXT")); + glCheckFramebufferStatus = reinterpret_cast(get_proc_address("glCheckFramebufferStatusEXT")); + glDeleteFramebuffers = reinterpret_cast(get_proc_address("glDeleteFramebuffersEXT")); + glDeleteRenderbuffers = reinterpret_cast(get_proc_address("glDeleteRenderbuffersEXT")); + glFramebufferRenderbuffer = reinterpret_cast(get_proc_address("glFramebufferRenderbufferEXT")); + glFramebufferTexture1D = reinterpret_cast(get_proc_address("glFramebufferTexture1DEXT")); + glFramebufferTexture2D = reinterpret_cast(get_proc_address("glFramebufferTexture2DEXT")); + glFramebufferTexture3D = reinterpret_cast(get_proc_address("glFramebufferTexture3DEXT")); + glGenFramebuffers = reinterpret_cast(get_proc_address("glGenFramebuffersEXT")); + glGenRenderbuffers = reinterpret_cast(get_proc_address("glGenRenderbuffersEXT")); + glGenerateMipmap = reinterpret_cast(get_proc_address("glGenerateMipmapEXT")); + glGetFramebufferAttachmentParameteriv = reinterpret_cast(get_proc_address("glGetFramebufferAttachmentParameterivEXT")); + glGetRenderbufferParameteriv = reinterpret_cast(get_proc_address("glGetRenderbufferParameterivEXT")); + glIsFramebuffer = reinterpret_cast(get_proc_address("glIsFramebufferEXT")); + glIsRenderbuffer = reinterpret_cast(get_proc_address("glIsRenderbufferEXT")); + glRenderbufferStorage = reinterpret_cast(get_proc_address("glRenderbufferStorageEXT")); + return Extension::EXTENSION; + } + return Extension::UNSUPPORTED; } +Extension EXT_framebuffer_object("GL_EXT_framebuffer_object", init_ext_framebuffer_object); + } // namespace GL } // namespace Msp diff --git a/source/ext_framebuffer_object.h b/source/ext_framebuffer_object.h index a92b3056..69bf7466 100644 --- a/source/ext_framebuffer_object.h +++ b/source/ext_framebuffer_object.h @@ -1,31 +1,32 @@ #ifndef MSP_GL_EXT_FRAMEBUFFER_OBJECT_ #define MSP_GL_EXT_FRAMEBUFFER_OBJECT_ +#include "extension.h" #include "gl.h" #include namespace Msp { namespace GL { -extern PFNGLISRENDERBUFFEREXTPROC glIsRenderbufferEXT; -extern PFNGLBINDRENDERBUFFEREXTPROC glBindRenderbufferEXT; -extern PFNGLDELETERENDERBUFFERSEXTPROC glDeleteRenderbuffersEXT; -extern PFNGLGENRENDERBUFFERSEXTPROC glGenRenderbuffersEXT; -extern PFNGLRENDERBUFFERSTORAGEEXTPROC glRenderbufferStorageEXT; -extern PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC glGetRenderbufferParameterivEXT; -extern PFNGLISFRAMEBUFFEREXTPROC glIsFramebufferEXT; -extern PFNGLBINDFRAMEBUFFEREXTPROC glBindFramebufferEXT; -extern PFNGLDELETEFRAMEBUFFERSEXTPROC glDeleteFramebuffersEXT; -extern PFNGLGENFRAMEBUFFERSEXTPROC glGenFramebuffersEXT; -extern PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC glCheckFramebufferStatusEXT; -extern PFNGLFRAMEBUFFERTEXTURE1DEXTPROC glFramebufferTexture1DEXT; -extern PFNGLFRAMEBUFFERTEXTURE2DEXTPROC glFramebufferTexture2DEXT; -extern PFNGLFRAMEBUFFERTEXTURE3DEXTPROC glFramebufferTexture3DEXT; -extern PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC glFramebufferRenderbufferEXT; -extern PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC glGetFramebufferAttachmentParameterivEXT; -extern PFNGLGENERATEMIPMAPEXTPROC glGenerateMipmapEXT; +extern PFNGLBINDFRAMEBUFFERPROC glBindFramebuffer; +extern PFNGLBINDRENDERBUFFERPROC glBindRenderbuffer; +extern PFNGLCHECKFRAMEBUFFERSTATUSPROC glCheckFramebufferStatus; +extern PFNGLDELETEFRAMEBUFFERSPROC glDeleteFramebuffers; +extern PFNGLDELETERENDERBUFFERSPROC glDeleteRenderbuffers; +extern PFNGLFRAMEBUFFERRENDERBUFFERPROC glFramebufferRenderbuffer; +extern PFNGLFRAMEBUFFERTEXTURE1DPROC glFramebufferTexture1D; +extern PFNGLFRAMEBUFFERTEXTURE2DPROC glFramebufferTexture2D; +extern PFNGLFRAMEBUFFERTEXTURE3DPROC glFramebufferTexture3D; +extern PFNGLGENFRAMEBUFFERSPROC glGenFramebuffers; +extern PFNGLGENRENDERBUFFERSPROC glGenRenderbuffers; +extern PFNGLGENERATEMIPMAPPROC glGenerateMipmap; +extern PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glGetFramebufferAttachmentParameteriv; +extern PFNGLGETRENDERBUFFERPARAMETERIVPROC glGetRenderbufferParameteriv; +extern PFNGLISFRAMEBUFFERPROC glIsFramebuffer; +extern PFNGLISRENDERBUFFERPROC glIsRenderbuffer; +extern PFNGLRENDERBUFFERSTORAGEPROC glRenderbufferStorage; -void init_ext_framebuffer_object(); +extern Extension EXT_framebuffer_object; } // namespace GL } // namespace Msp diff --git a/source/ext_texture3d.cpp b/source/ext_texture3d.cpp new file mode 100644 index 00000000..e75044a8 --- /dev/null +++ b/source/ext_texture3d.cpp @@ -0,0 +1,29 @@ +#include "ext_texture3d.h" + +namespace Msp { +namespace GL { + +PFNGLTEXIMAGE3DPROC glTexImage3D = 0; +PFNGLTEXSUBIMAGE3DPROC glTexSubImage3D = 0; + +Extension::SupportLevel init_ext_texture3d() +{ + if(is_version_at_least(1, 2)) + { + glTexImage3D = reinterpret_cast(get_proc_address("glTexImage3D")); + glTexSubImage3D = reinterpret_cast(get_proc_address("glTexSubImage3D")); + return Extension::CORE; + } + if(is_supported("GL_EXT_texture3D")) + { + glTexImage3D = reinterpret_cast(get_proc_address("glTexImage3DEXT")); + glTexSubImage3D = reinterpret_cast(get_proc_address("glTexSubImage3DEXT")); + return Extension::EXTENSION; + } + return Extension::UNSUPPORTED; +} + +Extension EXT_texture3D("GL_EXT_texture3D", init_ext_texture3d); + +} // namespace GL +} // namespace Msp diff --git a/source/ext_texture3d.h b/source/ext_texture3d.h new file mode 100644 index 00000000..2f2d696d --- /dev/null +++ b/source/ext_texture3d.h @@ -0,0 +1,19 @@ +#ifndef MSP_GL_EXT_TEXTURE3D_ +#define MSP_GL_EXT_TEXTURE3D_ + +#include "extension.h" +#include "gl.h" +#include + +namespace Msp { +namespace GL { + +extern PFNGLTEXIMAGE3DPROC glTexImage3D; +extern PFNGLTEXSUBIMAGE3DPROC glTexSubImage3D; + +extern Extension EXT_texture3D; + +} // namespace GL +} // namespace Msp + +#endif diff --git a/source/extension.cpp b/source/extension.cpp index bc43ae8b..6ca4f08c 100644 --- a/source/extension.cpp +++ b/source/extension.cpp @@ -5,26 +5,41 @@ #endif #include #include -#include "arb_shader_objects.h" -#include "arb_uniform_buffer_object.h" -#include "arb_vertex_buffer_object.h" -#include "arb_vertex_program.h" -#include "arb_vertex_shader.h" #include "error.h" -#include "ext_framebuffer_blit.h" -#include "ext_framebuffer_multisample.h" -#include "ext_framebuffer_object.h" #include "extension.h" #include "gl.h" -#include "nv_primitive_restart.h" -#include "version_1_2.h" -#include "version_1_3.h" using namespace std; namespace Msp { namespace GL { +Extension::Extension(const char *n, InitFunc f): + name(n), + init_func(f), + init_done(false), + support(UNSUPPORTED) +{ } + +Extension::operator bool() const +{ + if(!init_done) + { + support = init_func(); + init_done = true; + } + + return support>UNSUPPORTED; +} + + +Require::Require(const Extension &ext) +{ + if(!ext) + throw unsupported_extension(ext.get_name()); +} + + bool is_supported(const string &ext) { static set extensions; @@ -38,39 +53,12 @@ bool is_supported(const string &ext) extensions.insert(exts.begin(), exts.end()); } - /* XXX Conceptually a bit weird place for this, but I couldn't really come up - with anything better that would still be transparent. */ - if(extensions.count("GL_ARB_shader_objects")) - init_arb_shader_objects(); - if(extensions.count("GL_ARB_vertex_shader")) - init_arb_vertex_shader(); - if(extensions.count("GL_ARB_vertex_program")) - init_arb_vertex_program(); - if(extensions.count("GL_EXT_framebuffer_object")) - init_ext_framebuffer_object(); - if(extensions.count("GL_EXT_framebuffer_blit")) - init_ext_framebuffer_blit(); - if(extensions.count("GL_EXT_framebuffer_multisample")) - init_ext_framebuffer_multisample(); - if(extensions.count("GL_ARB_vertex_buffer_object")) - init_arb_vertex_buffer_object(); - if(extensions.count("GL_NV_primitive_restart")) - init_nv_primitive_restart(); - if(extensions.count("GL_ARB_uniform_buffer_object")) - init_arb_uniform_buffer_object(); - init_done = true; } return extensions.count(ext); } -void require_extension(const string &ext) -{ - if(!is_supported(ext)) - throw unsupported_extension(ext); -} - const Version &get_gl_version() { static Version version; @@ -83,12 +71,6 @@ const Version &get_gl_version() version.major = lexical_cast(parts[0]); version.minor = lexical_cast(parts[1]); - unsigned combined = version.major*0x100+version.minor; - if(combined>=0x102) - init_version_1_2(); - if(combined>=0x103) - init_version_1_3(); - init_done = true; } @@ -101,12 +83,6 @@ bool is_version_at_least(unsigned a, unsigned b) return (ver.major>a || (ver.major==a && ver.minor>=b)); } -void require_version(unsigned a, unsigned b) -{ - if(!is_version_at_least(a, b)) - throw unsupported_extension(format("OpenGL %d.%d", a, b)); -} - ExtFunc *get_proc_address(const string &name) { #ifndef WIN32 diff --git a/source/extension.h b/source/extension.h index 4072869c..e6c2aca0 100644 --- a/source/extension.h +++ b/source/extension.h @@ -12,54 +12,52 @@ struct Version unsigned short minor; }; -typedef void ExtFunc(); -/** -Indicates whether an extension is supported. If this returns true, the -functions of that extension are safe to use. -*/ -bool is_supported(const std::string &); +class Extension +{ +public: + enum SupportLevel + { + UNSUPPORTED, + EXTENSION, + CORE + }; -/** -Checks that an extension is supported and throws if it isn't. -*/ -void require_extension(const std::string &); + typedef SupportLevel (*InitFunc)(); -/** -RAII version of require_extension. Useful as a static local variable. -*/ -struct RequireExtension -{ - RequireExtension(const std::string &e) { require_extension(e); } -}; +private: + const char *name; + InitFunc init_func; + mutable bool init_done; + mutable SupportLevel support; -/** -Returns the OpenGL version number, as reported by the implementation. -Functions up to the returned version are safe to use. -*/ -const Version &get_gl_version(); +public: + Extension(const char *, InitFunc); -/** -Indicates whether the OpenGL version is at least a.b. -*/ -bool is_version_at_least(unsigned a, unsigned b); + const char *get_name() const { return name; } + operator bool() const; +}; -/** -Checks that the OpenGL version is at least a.b and throws if it isn't. -*/ -void require_version(unsigned a, unsigned b); -/** -RAII version of require_version. Useful as a static local variable. -*/ -struct RequireVersion +struct Require { - RequireVersion(unsigned a, unsigned b) { require_version(a, b); } + Require(const Extension &); }; -/** -Returns the address of an extension function. Only indended for internal use. -*/ + +typedef void ExtFunc(); + +/** Indicates whether an extension is supported. */ +bool is_supported(const std::string &); + +/** Returns the OpenGL version number, as reported by the implementation. */ +const Version &get_gl_version(); + +/** Indicates whether the OpenGL version is at least a.b. */ +bool is_version_at_least(unsigned a, unsigned b); + +/** Returns the address of an extension function. Only indended for internal +use. */ ExtFunc *get_proc_address(const std::string &); } // namespace GL diff --git a/source/framebuffer.cpp b/source/framebuffer.cpp index c4f714c6..43b0f94b 100644 --- a/source/framebuffer.cpp +++ b/source/framebuffer.cpp @@ -1,5 +1,4 @@ #include "error.h" -#include "extension.h" #include "ext_framebuffer_blit.h" #include "ext_framebuffer_object.h" #include "framebuffer.h" @@ -30,15 +29,15 @@ Framebuffer::Framebuffer(): height(0), dirty(0) { - static RequireExtension _ext("GL_EXT_framebuffer_object"); + static Require _req(EXT_framebuffer_object); - glGenFramebuffersEXT(1, &id); + glGenFramebuffers(1, &id); } Framebuffer::~Framebuffer() { if(id) - glDeleteFramebuffersEXT(1, &id); + glDeleteFramebuffers(1, &id); if(current()==this) unbind(); } @@ -53,20 +52,20 @@ void Framebuffer::update_attachment(unsigned mask) const const Attachment &attch = attachments[i]; if(mask&(1<get_id()); + if(attch.type==GL_RENDERBUFFER) + glFramebufferRenderbuffer(GL_FRAMEBUFFER, attch.attachment, GL_RENDERBUFFER, attch.rbuf->get_id()); else if(attch.type==GL_TEXTURE_2D) { static_cast(attch.tex)->allocate(attch.level); - glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, attch.attachment, attch.type, attch.tex->get_id(), attch.level); + glFramebufferTexture2D(GL_FRAMEBUFFER, attch.attachment, attch.type, attch.tex->get_id(), attch.level); } else if(attch.type==GL_TEXTURE_CUBE_MAP) { static_cast(attch.tex)->allocate(attch.level); - glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, attch.attachment, attch.cube_face, attch.tex->get_id(), attch.level); + glFramebufferTexture2D(GL_FRAMEBUFFER, attch.attachment, attch.cube_face, attch.tex->get_id(), attch.level); } else - glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, attch.attachment, 0, 0); + glFramebufferRenderbuffer(GL_FRAMEBUFFER, attch.attachment, 0, 0); } if(attch.attachment>=COLOR_ATTACHMENT0 && attch.attachment<=COLOR_ATTACHMENT3) @@ -84,7 +83,7 @@ void Framebuffer::check_size() for(vector::iterator i=attachments.begin(); i!=attachments.end(); ++i) if(i->type) { - if(i->type==GL_RENDERBUFFER_EXT) + if(i->type==GL_RENDERBUFFER) { width = i->rbuf->get_width(); height = i->rbuf->get_height(); @@ -162,7 +161,7 @@ void Framebuffer::detach(FramebufferAttachment attch) FramebufferStatus Framebuffer::check_status() const { Bind _bind(this, true); - return static_cast(glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT)); + return static_cast(glCheckFramebufferStatus(GL_FRAMEBUFFER)); } void Framebuffer::clear(BufferBits bits) @@ -173,12 +172,12 @@ void Framebuffer::clear(BufferBits bits) void Framebuffer::blit_from(const Framebuffer &other, int sx0, int sy0, int sx1, int sy1, int dx0, int dy0, int dx1, int dy1, BufferBits bits, bool filter) { - static RequireExtension _ext("GL_EXT_framebuffer_blit"); + static Require _req(EXT_framebuffer_blit); const Framebuffer *old = current(); if(set_current(this)) { - glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, id); + glBindFramebuffer(GL_DRAW_FRAMEBUFFER, id); if(dirty) { update_attachment(dirty); @@ -186,12 +185,12 @@ void Framebuffer::blit_from(const Framebuffer &other, int sx0, int sy0, int sx1, } } if(old!=&other) - glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, other.id); + glBindFramebuffer(GL_READ_FRAMEBUFFER, other.id); - glBlitFramebufferEXT(sx0, sy0, sx1, sy1, dx0, dy0, dx1, dy1, bits, (filter ? GL_LINEAR : GL_NEAREST)); + glBlitFramebuffer(sx0, sy0, sx1, sy1, dx0, dy0, dx1, dy1, bits, (filter ? GL_LINEAR : GL_NEAREST)); set_current(old); - glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, (old ? old->id : 0)); + glBindFramebuffer(GL_FRAMEBUFFER, (old ? old->id : 0)); } void Framebuffer::blit_from(const Framebuffer &other, int sx, int sy, unsigned wd, unsigned ht, int dx, int dy, BufferBits bits) @@ -208,7 +207,7 @@ void Framebuffer::bind() const { if(set_current(this)) { - glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, id); + glBindFramebuffer(GL_FRAMEBUFFER, id); if(dirty) { update_attachment(dirty); @@ -246,7 +245,7 @@ Framebuffer::Attachment::Attachment(FramebufferAttachment a): void Framebuffer::Attachment::set(Renderbuffer &r) { - type = GL_RENDERBUFFER_EXT; + type = GL_RENDERBUFFER; rbuf = &r; level = 0; } diff --git a/source/framebuffer.h b/source/framebuffer.h index 8a97222c..236d29e6 100644 --- a/source/framebuffer.h +++ b/source/framebuffer.h @@ -15,24 +15,24 @@ class Texture2D; enum FramebufferAttachment { - COLOR_ATTACHMENT0 = GL_COLOR_ATTACHMENT0_EXT, - COLOR_ATTACHMENT1 = GL_COLOR_ATTACHMENT1_EXT, - COLOR_ATTACHMENT2 = GL_COLOR_ATTACHMENT2_EXT, - COLOR_ATTACHMENT3 = GL_COLOR_ATTACHMENT3_EXT, - DEPTH_ATTACHMENT = GL_DEPTH_ATTACHMENT_EXT, - STENCIL_ATTACHMENT = GL_STENCIL_ATTACHMENT_EXT + COLOR_ATTACHMENT0 = GL_COLOR_ATTACHMENT0, + COLOR_ATTACHMENT1 = GL_COLOR_ATTACHMENT1, + COLOR_ATTACHMENT2 = GL_COLOR_ATTACHMENT2, + COLOR_ATTACHMENT3 = GL_COLOR_ATTACHMENT3, + DEPTH_ATTACHMENT = GL_DEPTH_ATTACHMENT, + STENCIL_ATTACHMENT = GL_STENCIL_ATTACHMENT }; enum FramebufferStatus { - FRAMEBUFFER_INCOMPLETE_ATTACHMENT = GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT, - FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT, + FRAMEBUFFER_INCOMPLETE_ATTACHMENT = GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT, + FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT, FRAMEBUFFER_INCOMPLETE_DIMENSIONS = GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT, FRAMEBUFFER_INCOMPLETE_FORMATS = GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT, - FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT, - FRAMEBUFFER_INCOMPLETE_READ_BUFFER = GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT, - FRAMEBUFFER_UNSUPPORTED = GL_FRAMEBUFFER_UNSUPPORTED_EXT, - FRAMEBUFFER_COMPLETE = GL_FRAMEBUFFER_COMPLETE_EXT + FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER, + FRAMEBUFFER_INCOMPLETE_READ_BUFFER = GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER, + FRAMEBUFFER_UNSUPPORTED = GL_FRAMEBUFFER_UNSUPPORTED, + FRAMEBUFFER_COMPLETE = GL_FRAMEBUFFER_COMPLETE }; enum BufferBits diff --git a/source/mesh.cpp b/source/mesh.cpp index c5e73ebd..9757df5c 100644 --- a/source/mesh.cpp +++ b/source/mesh.cpp @@ -1,6 +1,6 @@ #include "buffer.h" -#include "extension.h" #include "mesh.h" +#include "nv_primitive_restart.h" #include "renderer.h" using namespace std; @@ -69,7 +69,7 @@ void Mesh::add_batch(const Batch &b) PrimitiveType type = b.get_type(); can_append = (type==batches.back().get_type() && type!=LINE_STRIP && type!=LINE_LOOP && type!=POLYGON && - (type!=TRIANGLE_FAN || is_supported("GL_NV_primitive_restart"))); + (type!=TRIANGLE_FAN || NV_primitive_restart)); } if(defer_ibuf) diff --git a/source/nv_primitive_restart.cpp b/source/nv_primitive_restart.cpp index b685e340..ed5a2664 100644 --- a/source/nv_primitive_restart.cpp +++ b/source/nv_primitive_restart.cpp @@ -1,17 +1,23 @@ -#include "extension.h" #include "nv_primitive_restart.h" namespace Msp { namespace GL { -PFNGLPRIMITIVERESTARTNVPROC glPrimitiveRestartNV = 0; PFNGLPRIMITIVERESTARTINDEXNVPROC glPrimitiveRestartIndexNV = 0; +PFNGLPRIMITIVERESTARTNVPROC glPrimitiveRestartNV = 0; -void init_nv_primitive_restart() +Extension::SupportLevel init_nv_primitive_restart() { - glPrimitiveRestartNV = reinterpret_cast(get_proc_address("glPrimitiveRestartNV")); - glPrimitiveRestartIndexNV = reinterpret_cast(get_proc_address("glPrimitiveRestartIndexNV")); + if(is_supported("GL_NV_primitive_restart")) + { + glPrimitiveRestartIndexNV = reinterpret_cast(get_proc_address("glPrimitiveRestartIndexNV")); + glPrimitiveRestartNV = reinterpret_cast(get_proc_address("glPrimitiveRestartNV")); + return Extension::EXTENSION; + } + return Extension::UNSUPPORTED; } +Extension NV_primitive_restart("GL_NV_primitive_restart", init_nv_primitive_restart); + } // namespace GL } // namespace Msp diff --git a/source/nv_primitive_restart.h b/source/nv_primitive_restart.h index b1ff5e16..87358435 100644 --- a/source/nv_primitive_restart.h +++ b/source/nv_primitive_restart.h @@ -1,16 +1,17 @@ #ifndef MSP_GL_NV_PRIMITIVE_RESTART_ #define MSP_GL_NV_PRIMITIVE_RESTART_ +#include "extension.h" #include "gl.h" #include namespace Msp { namespace GL { -extern PFNGLPRIMITIVERESTARTNVPROC glPrimitiveRestartNV; extern PFNGLPRIMITIVERESTARTINDEXNVPROC glPrimitiveRestartIndexNV; +extern PFNGLPRIMITIVERESTARTNVPROC glPrimitiveRestartNV; -void init_nv_primitive_restart(); +extern Extension NV_primitive_restart; } // namespace GL } // namespace Msp diff --git a/source/program.cpp b/source/program.cpp index d9627519..adbb5c4c 100644 --- a/source/program.cpp +++ b/source/program.cpp @@ -8,7 +8,6 @@ #include "arb_vertex_shader.h" #include "buffer.h" #include "error.h" -#include "extension.h" #include "program.h" #include "shader.h" @@ -133,24 +132,24 @@ Program::Program(const string &vert, const string &frag) void Program::init() { - static RequireExtension _ext("GL_ARB_shader_objects"); + static Require _req(ARB_shader_objects); linked = false; - id = glCreateProgramObjectARB(); + id = glCreateProgram(); } Program::~Program() { for(ShaderList::iterator i=owned_data.begin(); i!=owned_data.end(); ++i) delete *i; - glDeleteObjectARB(id); + glDeleteProgram(id); } void Program::attach_shader(Shader &shader) { if(find(shaders.begin(), shaders.end(), &shader)==shaders.end()) { - glAttachObjectARB(id, shader.get_id()); + glAttachShader(id, shader.get_id()); shaders.push_back(&shader); } } @@ -168,7 +167,7 @@ void Program::detach_shader(Shader &shader) if(i!=shaders.end()) { shaders.erase(i, shaders.end()); - glDetachObjectARB(id, shader.get_id()); + glDetachShader(id, shader.get_id()); } } @@ -220,8 +219,8 @@ string Program::process_standard_source(const char **source, const string &flags void Program::bind_attribute(unsigned index, const string &name) { - static RequireExtension _ext("GL_ARB_vertex_shader"); - glBindAttribLocationARB(id, index, name.c_str()); + static Require _req(ARB_vertex_shader); + glBindAttribLocation(id, index, name.c_str()); } void Program::link() @@ -232,13 +231,13 @@ void Program::link() uniforms.clear(); - glLinkProgramARB(id); + glLinkProgram(id); int value; - glGetObjectParameterivARB(id, GL_OBJECT_LINK_STATUS_ARB, &value); + glGetProgramiv(id, GL_LINK_STATUS, &value); if(!(linked = value)) throw compile_error(get_info_log()); - glGetObjectParameterivARB(id, GL_OBJECT_ACTIVE_UNIFORMS_ARB, &value); + glGetProgramiv(id, GL_ACTIVE_UNIFORMS, &value); unsigned count = value; vector uniforms_by_index(count); for(unsigned i=0; isecond.block) { - i->second.location = glGetUniformLocationARB(id, i->second.name.c_str()); + i->second.location = glGetUniformLocation(id, i->second.name.c_str()); blockless_uniforms.push_back(&i->second); } @@ -354,9 +353,9 @@ bool Program::uniform_location_compare(const UniformInfo *uni1, const UniformInf string Program::get_info_log() const { GLsizei len = 0; - glGetObjectParameterivARB(id, GL_OBJECT_INFO_LOG_LENGTH_ARB, &len); + glGetProgramiv(id, GL_INFO_LOG_LENGTH, &len); char *buf = new char[len+1]; - glGetInfoLogARB(id, len+1, &len, buf); + glGetProgramInfoLog(id, len+1, &len, buf); string log(buf, len); delete[] buf; return log; @@ -405,7 +404,7 @@ void Program::bind() const if(!set_current(this)) return; - glUseProgramObjectARB(id); + glUseProgram(id); } void Program::unbind() @@ -413,7 +412,7 @@ void Program::unbind() if(!set_current(0)) return; - glUseProgramObjectARB(0); + glUseProgram(0); } diff --git a/source/programdata.cpp b/source/programdata.cpp index f3f498f3..ed4b0a29 100644 --- a/source/programdata.cpp +++ b/source/programdata.cpp @@ -1,7 +1,7 @@ +#include "arb_shader_objects.h" #include "buffer.h" #include "color.h" #include "error.h" -#include "extension.h" #include "matrix.h" #include "program.h" #include "programdata.h" @@ -19,7 +19,7 @@ ProgramData::ProgramData(): buffer(0), changes(NO_CHANGES) { - static RequireExtension _ext("GL_ARB_shader_objects"); + static Require _req(ARB_shader_objects); } // Blocks are intentionally left uncopied diff --git a/source/renderbuffer.cpp b/source/renderbuffer.cpp index 240cf84c..c920633e 100644 --- a/source/renderbuffer.cpp +++ b/source/renderbuffer.cpp @@ -1,4 +1,3 @@ -#include "extension.h" #include "ext_framebuffer_multisample.h" #include "ext_framebuffer_object.h" #include "renderbuffer.h" @@ -8,14 +7,14 @@ namespace GL { Renderbuffer::Renderbuffer() { - static RequireExtension _ext("GL_EXT_framebuffer_object"); + static Require _req(EXT_framebuffer_object); - glGenRenderbuffersEXT(1, &id); + glGenRenderbuffers(1, &id); } Renderbuffer::~Renderbuffer() { - glDeleteRenderbuffersEXT(1, &id); + glDeleteRenderbuffers(1, &id); } void Renderbuffer::storage(PixelFormat fmt, unsigned wd, unsigned ht) @@ -23,29 +22,29 @@ void Renderbuffer::storage(PixelFormat fmt, unsigned wd, unsigned ht) Bind _bind(this, true); width = wd; height = ht; - glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, fmt, width, height); + glRenderbufferStorage(GL_RENDERBUFFER, fmt, width, height); } void Renderbuffer::storage_multisample(unsigned samples, PixelFormat fmt, unsigned wd, unsigned ht) { - static RequireExtension _ext("GL_EXT_framebuffer_multisample"); + static Require _req(EXT_framebuffer_multisample); Bind _bind(this, true); width = wd; height = ht; - glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, samples, fmt, width, height); + glRenderbufferStorageMultisample(GL_RENDERBUFFER, samples, fmt, width, height); } void Renderbuffer::bind() const { if(set_current(this)) - glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, id); + glBindRenderbuffer(GL_RENDERBUFFER, id); } void Renderbuffer::unbind() { if(set_current(0)) - glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0); + glBindRenderbuffer(GL_RENDERBUFFER, 0); } } // namespace GL diff --git a/source/sgis_generate_mipmap.cpp b/source/sgis_generate_mipmap.cpp new file mode 100644 index 00000000..50805172 --- /dev/null +++ b/source/sgis_generate_mipmap.cpp @@ -0,0 +1,18 @@ +#include "sgis_generate_mipmap.h" + +namespace Msp { +namespace GL { + +Extension::SupportLevel init_sgis_generate_mipmap() +{ + if(is_supported("GL_SGIS_generate_mipmap")) + { + return Extension::EXTENSION; + } + return Extension::UNSUPPORTED; +} + +Extension SGIS_generate_mipmap("GL_SGIS_generate_mipmap", init_sgis_generate_mipmap); + +} // namespace GL +} // namespace Msp diff --git a/source/sgis_generate_mipmap.h b/source/sgis_generate_mipmap.h new file mode 100644 index 00000000..86d8802b --- /dev/null +++ b/source/sgis_generate_mipmap.h @@ -0,0 +1,16 @@ +#ifndef MSP_GL_SGIS_GENERATE_MIPMAP_ +#define MSP_GL_SGIS_GENERATE_MIPMAP_ + +#include "extension.h" +#include "gl.h" +#include + +namespace Msp { +namespace GL { + +extern Extension SGIS_generate_mipmap; + +} // namespace GL +} // namespace Msp + +#endif diff --git a/source/shader.cpp b/source/shader.cpp index cdb50c96..b0cf5a3e 100644 --- a/source/shader.cpp +++ b/source/shader.cpp @@ -1,6 +1,7 @@ +#include "arb_fragment_shader.h" #include "arb_shader_objects.h" +#include "arb_vertex_shader.h" #include "error.h" -#include "extension.h" #include "shader.h" using namespace std; @@ -26,21 +27,21 @@ void Shader::init(ShaderType t) compiled = false; if(t==FRAGMENT_SHADER) - static RequireExtension _ext("GL_ARB_fragment_shader"); + static Require _req(ARB_fragment_shader); else if(t==VERTEX_SHADER) - static RequireExtension _ext("GL_ARB_vertex_shader"); + static Require _req(ARB_vertex_shader); - id = glCreateShaderObjectARB(t); + id = glCreateShader(t); } Shader::~Shader() { - glDeleteObjectARB(id); + glDeleteShader(id); } void Shader::source(unsigned count, const char **str, const int *len) { - glShaderSourceARB(id, count, str, len); + glShaderSource(id, count, str, len); } void Shader::source(const string &str) @@ -55,9 +56,9 @@ void Shader::source(const char *str, int len) void Shader::compile() { - glCompileShaderARB(id); + glCompileShader(id); int value = 0; - glGetObjectParameterivARB(id, GL_OBJECT_COMPILE_STATUS_ARB, &value); + glGetShaderiv(id, GL_COMPILE_STATUS, &value); if(!(compiled = value)) throw compile_error(get_info_log()); } @@ -65,9 +66,9 @@ void Shader::compile() string Shader::get_info_log() const { GLsizei len = 0; - glGetObjectParameterivARB(id, GL_OBJECT_INFO_LOG_LENGTH_ARB, &len); + glGetShaderiv(id, GL_INFO_LOG_LENGTH, &len); char *buf = new char[len+1]; - glGetInfoLogARB(id, len+1, &len, buf); + glGetShaderInfoLog(id, len+1, &len, buf); string log(buf, len); delete[] buf; return log; diff --git a/source/texture.cpp b/source/texture.cpp index 57b1b78d..c8a1371c 100644 --- a/source/texture.cpp +++ b/source/texture.cpp @@ -1,6 +1,6 @@ #include #include "error.h" -#include "extension.h" +#include "sgis_generate_mipmap.h" #include "texture.h" #include "texunit.h" @@ -126,7 +126,7 @@ void Texture::set_wrap_r(TextureWrap w) void Texture::set_generate_mipmap(bool gm) { if(gm) - static RequireExtension _ext("GL_SGIS_generate_mipmap"); + static Require _req(SGIS_generate_mipmap); gen_mipmap = gm; update_parameter(GENERATE_MIPMAP); } diff --git a/source/texture3d.cpp b/source/texture3d.cpp index 33b25ccc..0ad65f88 100644 --- a/source/texture3d.cpp +++ b/source/texture3d.cpp @@ -2,9 +2,8 @@ #include #include "bindable.h" #include "error.h" -#include "extension.h" +#include "ext_texture3d.h" #include "texture3d.h" -#include "version_1_2.h" using namespace std; @@ -18,7 +17,7 @@ Texture3D::Texture3D(): depth(0), allocated(0) { - static RequireVersion _ver(1, 2); + static Require _req(EXT_texture3D); } void Texture3D::storage(PixelFormat fmt, unsigned wd, unsigned ht, unsigned dp) diff --git a/source/texturecube.cpp b/source/texturecube.cpp index ddb0c1e0..bbe6a6b6 100644 --- a/source/texturecube.cpp +++ b/source/texturecube.cpp @@ -1,6 +1,6 @@ +#include "arb_texture_cube_map.h" #include "bindable.h" #include "error.h" -#include "extension.h" #include "texturecube.h" using namespace std; @@ -23,7 +23,7 @@ TextureCube::TextureCube(): size(0), allocated(0) { - static RequireVersion _ver(1, 3); + static Require _req(ARB_texture_cube_map); } void TextureCube::storage(PixelFormat fmt, unsigned sz) diff --git a/source/texunit.cpp b/source/texunit.cpp index 7eb89a98..b19e7917 100644 --- a/source/texunit.cpp +++ b/source/texunit.cpp @@ -1,8 +1,8 @@ #include -#include "extension.h" +#include "arb_multitexture.h" +#include "arb_vertex_shader.h" #include "gl.h" #include "texunit.h" -#include "version_1_3.h" using namespace std; @@ -54,9 +54,9 @@ unsigned TexUnit::get_n_units() static int count = -1; if(count<0) { - if(is_version_at_least(2, 0) || is_supported("GL_ARB_vertex_shader")) + if(ARB_vertex_shader) glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &count); - else if(is_version_at_least(1, 3)) + else if(ARB_multitexture) glGetIntegerv(GL_MAX_TEXTURE_UNITS, &count); else count = 1; @@ -66,6 +66,8 @@ unsigned TexUnit::get_n_units() TexUnit &TexUnit::activate(unsigned n) { + if(n>0) + static Require _req(ARB_multitexture); if(n>=get_n_units()) throw out_of_range("TexUnit::activate"); diff --git a/source/uniform.cpp b/source/uniform.cpp index ac866cf5..09450a9a 100644 --- a/source/uniform.cpp +++ b/source/uniform.cpp @@ -7,39 +7,39 @@ namespace GL { template<> void UniformScalar::apply(int index, unsigned size, const int *value) { - glUniform1ivARB(index, size, value); + glUniform1iv(index, size, value); } template<> void UniformScalar::apply(int index, unsigned size, const float *value) { - glUniform1fvARB(index, size, value); + glUniform1fv(index, size, value); } template<> void UniformVector::apply(int index, unsigned size, const float *value) { - glUniform2fvARB(index, size, value); + glUniform2fv(index, size, value); } template<> void UniformVector::apply(int index, unsigned size, const float *value) { - glUniform3fvARB(index, size, value); + glUniform3fv(index, size, value); } template<> void UniformVector::apply(int index, unsigned size, const float *value) { - glUniform4fvARB(index, size, value); + glUniform4fv(index, size, value); } template<> void UniformMatrix::apply(int index, unsigned size, const float *value) { - glUniformMatrix4fvARB(index, size, false, value); + glUniformMatrix4fv(index, size, false, value); } } // namespace GL diff --git a/source/version_1_2.cpp b/source/version_1_2.cpp deleted file mode 100644 index 9fed2834..00000000 --- a/source/version_1_2.cpp +++ /dev/null @@ -1,89 +0,0 @@ -#include "extension.h" -#include "version_1_2.h" - -namespace Msp { -namespace GL { - -PFNGLBLENDCOLORPROC glBlendColor = 0; -PFNGLBLENDEQUATIONPROC glBlendEquation = 0; -PFNGLDRAWRANGEELEMENTSPROC glDrawRangeElements = 0; -PFNGLCOLORTABLEPROC glColorTable = 0; -PFNGLCOLORTABLEPARAMETERFVPROC glColorTableParameterfv = 0; -PFNGLCOLORTABLEPARAMETERIVPROC glColorTableParameteriv = 0; -PFNGLCOPYCOLORTABLEPROC glCopyColorTable = 0; -PFNGLGETCOLORTABLEPROC glGetColorTable = 0; -PFNGLGETCOLORTABLEPARAMETERFVPROC glGetColorTableParameterfv = 0; -PFNGLGETCOLORTABLEPARAMETERIVPROC glGetColorTableParameteriv = 0; -PFNGLCOLORSUBTABLEPROC glColorSubTable = 0; -PFNGLCOPYCOLORSUBTABLEPROC glCopyColorSubTable = 0; -PFNGLCONVOLUTIONFILTER1DPROC glConvolutionFilter1D = 0; -PFNGLCONVOLUTIONFILTER2DPROC glConvolutionFilter2D = 0; -PFNGLCONVOLUTIONPARAMETERFPROC glConvolutionParameterf = 0; -PFNGLCONVOLUTIONPARAMETERFVPROC glConvolutionParameterfv = 0; -PFNGLCONVOLUTIONPARAMETERIPROC glConvolutionParameteri = 0; -PFNGLCONVOLUTIONPARAMETERIVPROC glConvolutionParameteriv = 0; -PFNGLCOPYCONVOLUTIONFILTER1DPROC glCopyConvolutionFilter1D = 0; -PFNGLCOPYCONVOLUTIONFILTER2DPROC glCopyConvolutionFilter2D = 0; -PFNGLGETCONVOLUTIONFILTERPROC glGetConvolutionFilter = 0; -PFNGLGETCONVOLUTIONPARAMETERFVPROC glGetConvolutionParameterfv = 0; -PFNGLGETCONVOLUTIONPARAMETERIVPROC glGetConvolutionParameteriv = 0; -PFNGLGETSEPARABLEFILTERPROC glGetSeparableFilter = 0; -PFNGLSEPARABLEFILTER2DPROC glSeparableFilter2D = 0; -PFNGLGETHISTOGRAMPROC glGetHistogram = 0; -PFNGLGETHISTOGRAMPARAMETERFVPROC glGetHistogramParameterfv = 0; -PFNGLGETHISTOGRAMPARAMETERIVPROC glGetHistogramParameteriv = 0; -PFNGLGETMINMAXPROC glGetMinmax = 0; -PFNGLGETMINMAXPARAMETERFVPROC glGetMinmaxParameterfv = 0; -PFNGLGETMINMAXPARAMETERIVPROC glGetMinmaxParameteriv = 0; -PFNGLHISTOGRAMPROC glHistogram = 0; -PFNGLMINMAXPROC glMinmax = 0; -PFNGLRESETHISTOGRAMPROC glResetHistogram = 0; -PFNGLRESETMINMAXPROC glResetMinmax = 0; -PFNGLTEXIMAGE3DPROC glTexImage3D = 0; -PFNGLTEXSUBIMAGE3DPROC glTexSubImage3D = 0; -PFNGLCOPYTEXSUBIMAGE3DPROC glCopyTexSubImage3D = 0; - -void init_version_1_2() -{ - glBlendColor = reinterpret_cast(get_proc_address("glBlendColor")); - glBlendEquation = reinterpret_cast(get_proc_address("glBlendEquation")); - glDrawRangeElements = reinterpret_cast(get_proc_address("glDrawRangeElements")); - glColorTable = reinterpret_cast(get_proc_address("glColorTable")); - glColorTableParameterfv = reinterpret_cast(get_proc_address("glColorTableParameterfv")); - glColorTableParameteriv = reinterpret_cast(get_proc_address("glColorTableParameteriv")); - glCopyColorTable = reinterpret_cast(get_proc_address("glCopyColorTable")); - glGetColorTable = reinterpret_cast(get_proc_address("glGetColorTable")); - glGetColorTableParameterfv = reinterpret_cast(get_proc_address("glGetColorTableParameterfv")); - glGetColorTableParameteriv = reinterpret_cast(get_proc_address("glGetColorTableParameteriv")); - glColorSubTable = reinterpret_cast(get_proc_address("glColorSubTable")); - glCopyColorSubTable = reinterpret_cast(get_proc_address("glCopyColorSubTable")); - glConvolutionFilter1D = reinterpret_cast(get_proc_address("glConvolutionFilter1D")); - glConvolutionFilter2D = reinterpret_cast(get_proc_address("glConvolutionFilter2D")); - glConvolutionParameterf = reinterpret_cast(get_proc_address("glConvolutionParameterf")); - glConvolutionParameterfv = reinterpret_cast(get_proc_address("glConvolutionParameterfv")); - glConvolutionParameteri = reinterpret_cast(get_proc_address("glConvolutionParameteri")); - glConvolutionParameteriv = reinterpret_cast(get_proc_address("glConvolutionParameteriv")); - glCopyConvolutionFilter1D = reinterpret_cast(get_proc_address("glCopyConvolutionFilter1D")); - glCopyConvolutionFilter2D = reinterpret_cast(get_proc_address("glCopyConvolutionFilter2D")); - glGetConvolutionFilter = reinterpret_cast(get_proc_address("glGetConvolutionFilter")); - glGetConvolutionParameterfv = reinterpret_cast(get_proc_address("glGetConvolutionParameterfv")); - glGetConvolutionParameteriv = reinterpret_cast(get_proc_address("glGetConvolutionParameteriv")); - glGetSeparableFilter = reinterpret_cast(get_proc_address("glGetSeparableFilter")); - glSeparableFilter2D = reinterpret_cast(get_proc_address("glSeparableFilter2D")); - glGetHistogram = reinterpret_cast(get_proc_address("glGetHistogram")); - glGetHistogramParameterfv = reinterpret_cast(get_proc_address("glGetHistogramParameterfv")); - glGetHistogramParameteriv = reinterpret_cast(get_proc_address("glGetHistogramParameteriv")); - glGetMinmax = reinterpret_cast(get_proc_address("glGetMinmax")); - glGetMinmaxParameterfv = reinterpret_cast(get_proc_address("glGetMinmaxParameterfv")); - glGetMinmaxParameteriv = reinterpret_cast(get_proc_address("glGetMinmaxParameteriv")); - glHistogram = reinterpret_cast(get_proc_address("glHistogram")); - glMinmax = reinterpret_cast(get_proc_address("glMinmax")); - glResetHistogram = reinterpret_cast(get_proc_address("glResetHistogram")); - glResetMinmax = reinterpret_cast(get_proc_address("glResetMinmax")); - glTexImage3D = reinterpret_cast(get_proc_address("glTexImage3D")); - glTexSubImage3D = reinterpret_cast(get_proc_address("glTexSubImage3D")); - glCopyTexSubImage3D = reinterpret_cast(get_proc_address("glCopyTexSubImage3D")); -} - -} // namespace GL -} // namespace Msp diff --git a/source/version_1_2.h b/source/version_1_2.h deleted file mode 100644 index d10ba532..00000000 --- a/source/version_1_2.h +++ /dev/null @@ -1,54 +0,0 @@ -#ifndef MSP_GL_VERSION_1_2_ -#define MSP_GL_VERSION_1_2_ - -#include "gl.h" -#include - -namespace Msp { -namespace GL { - -extern PFNGLBLENDCOLORPROC glBlendColor; -extern PFNGLBLENDEQUATIONPROC glBlendEquation; -extern PFNGLDRAWRANGEELEMENTSPROC glDrawRangeElements; -extern PFNGLCOLORTABLEPROC glColorTable; -extern PFNGLCOLORTABLEPARAMETERFVPROC glColorTableParameterfv; -extern PFNGLCOLORTABLEPARAMETERIVPROC glColorTableParameteriv; -extern PFNGLCOPYCOLORTABLEPROC glCopyColorTable; -extern PFNGLGETCOLORTABLEPROC glGetColorTable; -extern PFNGLGETCOLORTABLEPARAMETERFVPROC glGetColorTableParameterfv; -extern PFNGLGETCOLORTABLEPARAMETERIVPROC glGetColorTableParameteriv; -extern PFNGLCOLORSUBTABLEPROC glColorSubTable; -extern PFNGLCOPYCOLORSUBTABLEPROC glCopyColorSubTable; -extern PFNGLCONVOLUTIONFILTER1DPROC glConvolutionFilter1D; -extern PFNGLCONVOLUTIONFILTER2DPROC glConvolutionFilter2D; -extern PFNGLCONVOLUTIONPARAMETERFPROC glConvolutionParameterf; -extern PFNGLCONVOLUTIONPARAMETERFVPROC glConvolutionParameterfv; -extern PFNGLCONVOLUTIONPARAMETERIPROC glConvolutionParameteri; -extern PFNGLCONVOLUTIONPARAMETERIVPROC glConvolutionParameteriv; -extern PFNGLCOPYCONVOLUTIONFILTER1DPROC glCopyConvolutionFilter1D; -extern PFNGLCOPYCONVOLUTIONFILTER2DPROC glCopyConvolutionFilter2D; -extern PFNGLGETCONVOLUTIONFILTERPROC glGetConvolutionFilter; -extern PFNGLGETCONVOLUTIONPARAMETERFVPROC glGetConvolutionParameterfv; -extern PFNGLGETCONVOLUTIONPARAMETERIVPROC glGetConvolutionParameteriv; -extern PFNGLGETSEPARABLEFILTERPROC glGetSeparableFilter; -extern PFNGLSEPARABLEFILTER2DPROC glSeparableFilter2D; -extern PFNGLGETHISTOGRAMPROC glGetHistogram; -extern PFNGLGETHISTOGRAMPARAMETERFVPROC glGetHistogramParameterfv; -extern PFNGLGETHISTOGRAMPARAMETERIVPROC glGetHistogramParameteriv; -extern PFNGLGETMINMAXPROC glGetMinmax; -extern PFNGLGETMINMAXPARAMETERFVPROC glGetMinmaxParameterfv; -extern PFNGLGETMINMAXPARAMETERIVPROC glGetMinmaxParameteriv; -extern PFNGLHISTOGRAMPROC glHistogram; -extern PFNGLMINMAXPROC glMinmax; -extern PFNGLRESETHISTOGRAMPROC glResetHistogram; -extern PFNGLRESETMINMAXPROC glResetMinmax; -extern PFNGLTEXIMAGE3DPROC glTexImage3D; -extern PFNGLTEXSUBIMAGE3DPROC glTexSubImage3D; -extern PFNGLCOPYTEXSUBIMAGE3DPROC glCopyTexSubImage3D; - -void init_version_1_2(); - -} // namespace GL -} // namespace Msp - -#endif diff --git a/source/version_1_3.cpp b/source/version_1_3.cpp deleted file mode 100644 index d248a083..00000000 --- a/source/version_1_3.cpp +++ /dev/null @@ -1,105 +0,0 @@ -#include "extension.h" -#include "version_1_3.h" - -namespace Msp { -namespace GL { - -PFNGLACTIVETEXTUREPROC glActiveTexture = 0; -PFNGLCLIENTACTIVETEXTUREPROC glClientActiveTexture = 0; -PFNGLMULTITEXCOORD1DPROC glMultiTexCoord1d = 0; -PFNGLMULTITEXCOORD1DVPROC glMultiTexCoord1dv = 0; -PFNGLMULTITEXCOORD1FPROC glMultiTexCoord1f = 0; -PFNGLMULTITEXCOORD1FVPROC glMultiTexCoord1fv = 0; -PFNGLMULTITEXCOORD1IPROC glMultiTexCoord1i = 0; -PFNGLMULTITEXCOORD1IVPROC glMultiTexCoord1iv = 0; -PFNGLMULTITEXCOORD1SPROC glMultiTexCoord1s = 0; -PFNGLMULTITEXCOORD1SVPROC glMultiTexCoord1sv = 0; -PFNGLMULTITEXCOORD2DPROC glMultiTexCoord2d = 0; -PFNGLMULTITEXCOORD2DVPROC glMultiTexCoord2dv = 0; -PFNGLMULTITEXCOORD2FPROC glMultiTexCoord2f = 0; -PFNGLMULTITEXCOORD2FVPROC glMultiTexCoord2fv = 0; -PFNGLMULTITEXCOORD2IPROC glMultiTexCoord2i = 0; -PFNGLMULTITEXCOORD2IVPROC glMultiTexCoord2iv = 0; -PFNGLMULTITEXCOORD2SPROC glMultiTexCoord2s = 0; -PFNGLMULTITEXCOORD2SVPROC glMultiTexCoord2sv = 0; -PFNGLMULTITEXCOORD3DPROC glMultiTexCoord3d = 0; -PFNGLMULTITEXCOORD3DVPROC glMultiTexCoord3dv = 0; -PFNGLMULTITEXCOORD3FPROC glMultiTexCoord3f = 0; -PFNGLMULTITEXCOORD3FVPROC glMultiTexCoord3fv = 0; -PFNGLMULTITEXCOORD3IPROC glMultiTexCoord3i = 0; -PFNGLMULTITEXCOORD3IVPROC glMultiTexCoord3iv = 0; -PFNGLMULTITEXCOORD3SPROC glMultiTexCoord3s = 0; -PFNGLMULTITEXCOORD3SVPROC glMultiTexCoord3sv = 0; -PFNGLMULTITEXCOORD4DPROC glMultiTexCoord4d = 0; -PFNGLMULTITEXCOORD4DVPROC glMultiTexCoord4dv = 0; -PFNGLMULTITEXCOORD4FPROC glMultiTexCoord4f = 0; -PFNGLMULTITEXCOORD4FVPROC glMultiTexCoord4fv = 0; -PFNGLMULTITEXCOORD4IPROC glMultiTexCoord4i = 0; -PFNGLMULTITEXCOORD4IVPROC glMultiTexCoord4iv = 0; -PFNGLMULTITEXCOORD4SPROC glMultiTexCoord4s = 0; -PFNGLMULTITEXCOORD4SVPROC glMultiTexCoord4sv = 0; -PFNGLLOADTRANSPOSEMATRIXFPROC glLoadTransposeMatrixf = 0; -PFNGLLOADTRANSPOSEMATRIXDPROC glLoadTransposeMatrixd = 0; -PFNGLMULTTRANSPOSEMATRIXFPROC glMultTransposeMatrixf = 0; -PFNGLMULTTRANSPOSEMATRIXDPROC glMultTransposeMatrixd = 0; -PFNGLSAMPLECOVERAGEPROC glSampleCoverage = 0; -PFNGLCOMPRESSEDTEXIMAGE3DPROC glCompressedTexImage3D = 0; -PFNGLCOMPRESSEDTEXIMAGE2DPROC glCompressedTexImage2D = 0; -PFNGLCOMPRESSEDTEXIMAGE1DPROC glCompressedTexImage1D = 0; -PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glCompressedTexSubImage3D = 0; -PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glCompressedTexSubImage2D = 0; -PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glCompressedTexSubImage1D = 0; -PFNGLGETCOMPRESSEDTEXIMAGEPROC glGetCompressedTexImage = 0; - -void init_version_1_3() -{ - glActiveTexture = reinterpret_cast(get_proc_address("glActiveTexture")); - glClientActiveTexture = reinterpret_cast(get_proc_address("glClientActiveTexture")); - glMultiTexCoord1d = reinterpret_cast(get_proc_address("glMultiTexCoord1d")); - glMultiTexCoord1dv = reinterpret_cast(get_proc_address("glMultiTexCoord1dv")); - glMultiTexCoord1f = reinterpret_cast(get_proc_address("glMultiTexCoord1f")); - glMultiTexCoord1fv = reinterpret_cast(get_proc_address("glMultiTexCoord1fv")); - glMultiTexCoord1i = reinterpret_cast(get_proc_address("glMultiTexCoord1i")); - glMultiTexCoord1iv = reinterpret_cast(get_proc_address("glMultiTexCoord1iv")); - glMultiTexCoord1s = reinterpret_cast(get_proc_address("glMultiTexCoord1s")); - glMultiTexCoord1sv = reinterpret_cast(get_proc_address("glMultiTexCoord1sv")); - glMultiTexCoord2d = reinterpret_cast(get_proc_address("glMultiTexCoord2d")); - glMultiTexCoord2dv = reinterpret_cast(get_proc_address("glMultiTexCoord2dv")); - glMultiTexCoord2f = reinterpret_cast(get_proc_address("glMultiTexCoord2f")); - glMultiTexCoord2fv = reinterpret_cast(get_proc_address("glMultiTexCoord2fv")); - glMultiTexCoord2i = reinterpret_cast(get_proc_address("glMultiTexCoord2i")); - glMultiTexCoord2iv = reinterpret_cast(get_proc_address("glMultiTexCoord2iv")); - glMultiTexCoord2s = reinterpret_cast(get_proc_address("glMultiTexCoord2s")); - glMultiTexCoord2sv = reinterpret_cast(get_proc_address("glMultiTexCoord2sv")); - glMultiTexCoord3d = reinterpret_cast(get_proc_address("glMultiTexCoord3d")); - glMultiTexCoord3dv = reinterpret_cast(get_proc_address("glMultiTexCoord3dv")); - glMultiTexCoord3f = reinterpret_cast(get_proc_address("glMultiTexCoord3f")); - glMultiTexCoord3fv = reinterpret_cast(get_proc_address("glMultiTexCoord3fv")); - glMultiTexCoord3i = reinterpret_cast(get_proc_address("glMultiTexCoord3i")); - glMultiTexCoord3iv = reinterpret_cast(get_proc_address("glMultiTexCoord3iv")); - glMultiTexCoord3s = reinterpret_cast(get_proc_address("glMultiTexCoord3s")); - glMultiTexCoord3sv = reinterpret_cast(get_proc_address("glMultiTexCoord3sv")); - glMultiTexCoord4d = reinterpret_cast(get_proc_address("glMultiTexCoord4d")); - glMultiTexCoord4dv = reinterpret_cast(get_proc_address("glMultiTexCoord4dv")); - glMultiTexCoord4f = reinterpret_cast(get_proc_address("glMultiTexCoord4f")); - glMultiTexCoord4fv = reinterpret_cast(get_proc_address("glMultiTexCoord4fv")); - glMultiTexCoord4i = reinterpret_cast(get_proc_address("glMultiTexCoord4i")); - glMultiTexCoord4iv = reinterpret_cast(get_proc_address("glMultiTexCoord4iv")); - glMultiTexCoord4s = reinterpret_cast(get_proc_address("glMultiTexCoord4s")); - glMultiTexCoord4sv = reinterpret_cast(get_proc_address("glMultiTexCoord4sv")); - glLoadTransposeMatrixf = reinterpret_cast(get_proc_address("glLoadTransposeMatrixf")); - glLoadTransposeMatrixd = reinterpret_cast(get_proc_address("glLoadTransposeMatrixd")); - glMultTransposeMatrixf = reinterpret_cast(get_proc_address("glMultTransposeMatrixf")); - glMultTransposeMatrixd = reinterpret_cast(get_proc_address("glMultTransposeMatrixd")); - glSampleCoverage = reinterpret_cast(get_proc_address("glSampleCoverage")); - glCompressedTexImage3D = reinterpret_cast(get_proc_address("glCompressedTexImage3D")); - glCompressedTexImage2D = reinterpret_cast(get_proc_address("glCompressedTexImage2D")); - glCompressedTexImage1D = reinterpret_cast(get_proc_address("glCompressedTexImage1D")); - glCompressedTexSubImage3D = reinterpret_cast(get_proc_address("glCompressedTexSubImage3D")); - glCompressedTexSubImage2D = reinterpret_cast(get_proc_address("glCompressedTexSubImage2D")); - glCompressedTexSubImage1D = reinterpret_cast(get_proc_address("glCompressedTexSubImage1D")); - glGetCompressedTexImage = reinterpret_cast(get_proc_address("glGetCompressedTexImage")); -} - -} // namespace GL -} // namespace Msp diff --git a/source/vertexarray.cpp b/source/vertexarray.cpp index e5e81204..13816a13 100644 --- a/source/vertexarray.cpp +++ b/source/vertexarray.cpp @@ -1,10 +1,8 @@ -#include "arb_vertex_program.h" +#include "arb_multitexture.h" +#include "arb_vertex_shader.h" #include "buffer.h" #include "error.h" -#include "extension.h" #include "gl.h" -#include "version_1_2.h" -#include "version_1_3.h" #include "vertexarray.h" using namespace std; @@ -68,9 +66,9 @@ void VertexArray::reset(const VertexFormat &f) has_gen_attrs = true; } if(has_multitex) - static RequireVersion _ver(1, 3); + static Require _req(ARB_multitexture); if(has_gen_attrs) - static RequireExtension _ext("GL_ARB_vertex_program"); + static Require _req(ARB_vertex_shader); } void VertexArray::apply() const @@ -132,9 +130,9 @@ void VertexArray::apply() const } else { - glVertexAttribPointerARB(t-11, sz, GL_FLOAT, false, bpv, base+offset); + glVertexAttribPointer(t-11, sz, GL_FLOAT, false, bpv, base+offset); if(!en) - glEnableVertexAttribArrayARB(t-11); + glEnableVertexAttribArray(t-11); } break; } @@ -159,7 +157,7 @@ void VertexArray::apply() const active_tex = i-3; } else - glDisableVertexAttribArrayARB(i-11); + glDisableVertexAttribArray(i-11); } enabled_arrays = found; -- 2.43.0 From 41b4cb3002f3551ce1bd6fdf15994ee7bc523788 Mon Sep 17 00:00:00 2001 From: Mikko Rasa Date: Tue, 28 Aug 2012 00:05:08 +0300 Subject: [PATCH 06/16] Check the relevant extensions when using pixel formats --- source/arb_texture_float.cpp | 22 ++++++++++++++++++++++ source/arb_texture_float.h | 16 ++++++++++++++++ source/ext_bgra.cpp | 22 ++++++++++++++++++++++ source/ext_bgra.h | 16 ++++++++++++++++ source/pixelformat.cpp | 25 +++++++++++++++++++++++++ source/pixelformat.h | 2 ++ source/renderbuffer.cpp | 2 ++ source/texture2d.cpp | 1 + source/texture3d.cpp | 1 + source/texturecube.cpp | 1 + 10 files changed, 108 insertions(+) create mode 100644 source/arb_texture_float.cpp create mode 100644 source/arb_texture_float.h create mode 100644 source/ext_bgra.cpp create mode 100644 source/ext_bgra.h diff --git a/source/arb_texture_float.cpp b/source/arb_texture_float.cpp new file mode 100644 index 00000000..9f76b3fd --- /dev/null +++ b/source/arb_texture_float.cpp @@ -0,0 +1,22 @@ +#include "arb_texture_float.h" + +namespace Msp { +namespace GL { + +Extension::SupportLevel init_arb_texture_float() +{ + if(is_version_at_least(3, 0)) + { + return Extension::CORE; + } + if(is_supported("GL_ARB_texture_float")) + { + return Extension::EXTENSION; + } + return Extension::UNSUPPORTED; +} + +Extension ARB_texture_float("GL_ARB_texture_float", init_arb_texture_float); + +} // namespace GL +} // namespace Msp diff --git a/source/arb_texture_float.h b/source/arb_texture_float.h new file mode 100644 index 00000000..9eef6148 --- /dev/null +++ b/source/arb_texture_float.h @@ -0,0 +1,16 @@ +#ifndef MSP_GL_ARB_TEXTURE_FLOAT_ +#define MSP_GL_ARB_TEXTURE_FLOAT_ + +#include "extension.h" +#include "gl.h" +#include + +namespace Msp { +namespace GL { + +extern Extension ARB_texture_float; + +} // namespace GL +} // namespace Msp + +#endif diff --git a/source/ext_bgra.cpp b/source/ext_bgra.cpp new file mode 100644 index 00000000..d104717b --- /dev/null +++ b/source/ext_bgra.cpp @@ -0,0 +1,22 @@ +#include "ext_bgra.h" + +namespace Msp { +namespace GL { + +Extension::SupportLevel init_ext_bgra() +{ + if(is_version_at_least(1, 2)) + { + return Extension::CORE; + } + if(is_supported("GL_EXT_bgra")) + { + return Extension::EXTENSION; + } + return Extension::UNSUPPORTED; +} + +Extension EXT_bgra("GL_EXT_bgra", init_ext_bgra); + +} // namespace GL +} // namespace Msp diff --git a/source/ext_bgra.h b/source/ext_bgra.h new file mode 100644 index 00000000..b4ac19d9 --- /dev/null +++ b/source/ext_bgra.h @@ -0,0 +1,16 @@ +#ifndef MSP_GL_EXT_BGRA_ +#define MSP_GL_EXT_BGRA_ + +#include "extension.h" +#include "gl.h" +#include + +namespace Msp { +namespace GL { + +extern Extension EXT_bgra; + +} // namespace GL +} // namespace Msp + +#endif diff --git a/source/pixelformat.cpp b/source/pixelformat.cpp index 60fdc111..4b3dade1 100644 --- a/source/pixelformat.cpp +++ b/source/pixelformat.cpp @@ -1,4 +1,6 @@ #include +#include "arb_texture_float.h" +#include "ext_bgra.h" #include "pixelformat.h" using namespace std; @@ -73,5 +75,28 @@ PixelFormat get_base_pixelformat(PixelFormat pf) } } +void require_pixelformat(PixelFormat pf) +{ + switch(pf) + { + case RGB16F: + case RGB32F: + case RGBA16F: + case RGBA32F: + case LUMINANCE16F: + case LUMINANCE32F: + case LUMINANCE_ALPHA16F: + case LUMINANCE_ALPHA32F: + { static Require _req(ARB_texture_float); } + break; + case BGR: + case BGRA: + { static Require _req(EXT_bgra); } + break; + default: + break; + } +} + } // namespace GL } // namespace Msp diff --git a/source/pixelformat.h b/source/pixelformat.h index 145e2a38..55115cf7 100644 --- a/source/pixelformat.h +++ b/source/pixelformat.h @@ -44,6 +44,8 @@ PixelFormat pixelformat_from_graphics(Graphics::PixelFormat); PixelFormat get_base_pixelformat(PixelFormat); +void require_pixelformat(PixelFormat); + } // namespace GL } // namespace Msp diff --git a/source/renderbuffer.cpp b/source/renderbuffer.cpp index c920633e..8f0b582a 100644 --- a/source/renderbuffer.cpp +++ b/source/renderbuffer.cpp @@ -19,6 +19,7 @@ Renderbuffer::~Renderbuffer() void Renderbuffer::storage(PixelFormat fmt, unsigned wd, unsigned ht) { + require_pixelformat(fmt); Bind _bind(this, true); width = wd; height = ht; @@ -28,6 +29,7 @@ void Renderbuffer::storage(PixelFormat fmt, unsigned wd, unsigned ht) void Renderbuffer::storage_multisample(unsigned samples, PixelFormat fmt, unsigned wd, unsigned ht) { static Require _req(EXT_framebuffer_multisample); + require_pixelformat(fmt); Bind _bind(this, true); width = wd; diff --git a/source/texture2d.cpp b/source/texture2d.cpp index 8c8ad378..dfd93f57 100644 --- a/source/texture2d.cpp +++ b/source/texture2d.cpp @@ -20,6 +20,7 @@ void Texture2D::storage(PixelFormat fmt, unsigned wd, unsigned ht) throw invalid_operation("Texture2D::storage"); if(wd==0 || ht==0) throw invalid_argument("Texture2D::storage"); + require_pixelformat(fmt); ifmt = fmt; width = wd; diff --git a/source/texture3d.cpp b/source/texture3d.cpp index 0ad65f88..95b96903 100644 --- a/source/texture3d.cpp +++ b/source/texture3d.cpp @@ -26,6 +26,7 @@ void Texture3D::storage(PixelFormat fmt, unsigned wd, unsigned ht, unsigned dp) throw invalid_operation("Texture3D::storage"); if(wd==0 || ht==0 || dp==0) throw invalid_argument("Texture3D::storage"); + require_pixelformat(fmt); width = wd; height = ht; diff --git a/source/texturecube.cpp b/source/texturecube.cpp index bbe6a6b6..a5874a6a 100644 --- a/source/texturecube.cpp +++ b/source/texturecube.cpp @@ -32,6 +32,7 @@ void TextureCube::storage(PixelFormat fmt, unsigned sz) throw invalid_operation("TextureCube::storage"); if(sz==0) throw invalid_argument("TextureCube::storage"); + require_pixelformat(fmt); ifmt = fmt; size = sz; -- 2.43.0 From 0c731643d6363eb4c492e836ffb919cb7c0a3035 Mon Sep 17 00:00:00 2001 From: Mikko Rasa Date: Tue, 28 Aug 2012 10:39:19 +0300 Subject: [PATCH 07/16] Tweak the shader functions in Renderer Since ProgramData is no longer tied to a single Program, we can retain it over program changes. This opens up some new possibilities, in particular for Effects. Also rename set_shader to set_shader_program. --- demos/cubemap.cpp | 2 +- demos/shaders.cpp | 3 ++- source/animatedobject.cpp | 2 +- source/object.cpp | 4 ++-- source/renderer.cpp | 15 +++++---------- source/renderer.h | 12 ++++++++++-- 6 files changed, 21 insertions(+), 17 deletions(-) diff --git a/demos/cubemap.cpp b/demos/cubemap.cpp index 1778fb7f..98d0ba24 100644 --- a/demos/cubemap.cpp +++ b/demos/cubemap.cpp @@ -112,7 +112,7 @@ int main() GL::Bind bind_depth(GL::DepthTest::lequal()); GL::Renderer renderer(0); renderer.set_material(&material); - renderer.set_shader(&shprog, &shdata); + renderer.set_shader_program(&shprog, &shdata); renderer.set_texture(&texture); renderer.matrix_stack() *= GL::Matrix::translation(0, 0, -7); { diff --git a/demos/shaders.cpp b/demos/shaders.cpp index ae5c98fb..27538e4e 100644 --- a/demos/shaders.cpp +++ b/demos/shaders.cpp @@ -112,10 +112,11 @@ int main() GL::Renderer renderer(0); renderer.set_material(&mat); renderer.set_texturing(&texturing); + renderer.add_shader_data(progdata); for(unsigned i=0; i<12; ++i) { GL::MatrixStack::Push push(renderer.matrix_stack()); - renderer.set_shader(programs[i], &progdata); + renderer.set_shader_program(programs[i]); renderer.matrix_stack() *= GL::Matrix::translation(-3.3+(i%4)*2.2, 0, -3.5+(i/4)*3.0); renderer.matrix_stack() *= GL::Matrix::rotation(angle, 0, 0, 1); mesh.draw(renderer); diff --git a/source/animatedobject.cpp b/source/animatedobject.cpp index eec54aa7..63a25112 100644 --- a/source/animatedobject.cpp +++ b/source/animatedobject.cpp @@ -45,7 +45,7 @@ void AnimatedObject::setup_render(Renderer &renderer, const Tag &) const { renderer.matrix_stack() *= matrix; if(shdata) - renderer.add_shader_data(shdata); + renderer.add_shader_data(*shdata); } } // namespace GL diff --git a/source/object.cpp b/source/object.cpp index 06062fc0..964099e5 100644 --- a/source/object.cpp +++ b/source/object.cpp @@ -77,7 +77,7 @@ void Object::render(Renderer &renderer, const Tag &tag) const return; Renderer::Push push(renderer); - renderer.set_shader(pass->get_shader_program(), pass->get_shader_data()); + renderer.set_shader_program(pass->get_shader_program(), pass->get_shader_data()); renderer.set_material(pass->get_material()); renderer.set_texturing(pass->get_texturing()); @@ -91,7 +91,7 @@ void Object::render(Renderer &renderer, const ObjectInstance &inst, const Tag &t return; Renderer::Push push(renderer); - renderer.set_shader(pass->get_shader_program(), pass->get_shader_data()); + renderer.set_shader_program(pass->get_shader_program(), pass->get_shader_data()); renderer.set_material(pass->get_material()); renderer.set_texturing(pass->get_texturing()); diff --git a/source/renderer.cpp b/source/renderer.cpp index ee845e08..c751b0e3 100644 --- a/source/renderer.cpp +++ b/source/renderer.cpp @@ -68,22 +68,17 @@ void Renderer::set_material(const Material *m) state->material = m; } -void Renderer::set_shader(const Program *p, const ProgramData *d) +void Renderer::set_shader_program(const Program *p, const ProgramData *d) { state->shprog = p; - if(d) - state->shdata.assign(1, d); - else - state->shdata.clear(); + if(p && d) + add_shader_data(*d); shdata_changed = true; } -void Renderer::add_shader_data(const ProgramData *d) +void Renderer::add_shader_data(const ProgramData &d) { - if(!state->shprog) - throw invalid_operation("Renderer::add_shader_data"); - - state->shdata.push_back(d); + state->shdata.push_back(&d); shdata_changed = true; } diff --git a/source/renderer.h b/source/renderer.h index dd54ca16..5536702b 100644 --- a/source/renderer.h +++ b/source/renderer.h @@ -85,8 +85,16 @@ public: void set_texture(const Texture *); void set_texturing(const Texturing *); void set_material(const Material *); - void set_shader(const Program *, const ProgramData *); - void add_shader_data(const ProgramData *); + + /** Sets the shader program to use. An initial set of data can be set as + well, with the same semantics as add_shader_data. */ + void set_shader_program(const Program *prog, const ProgramData *data = 0); + + /** Adds another set of data to be use with shader programs. The data is + independent of any shader program changes and remains in effect until the + Renderer state is popped. */ + void add_shader_data(const ProgramData &data); + void set_vertex_array(const VertexArray *); void set_element_buffer(const Buffer *); void set_winding_test(const WindingTest *); -- 2.43.0 From a6c45f5cc50ea2ee2aecf8d4f3b69934e69c8f3f Mon Sep 17 00:00:00 2001 From: Mikko Rasa Date: Tue, 28 Aug 2012 10:50:17 +0300 Subject: [PATCH 08/16] Provide the necessary uniforms from ShadowMap With the recent changes to the Effect and Renderer, it's finally possible to avoid the need to specify the shadow map texture unit everywhere, and get rid of the hardcoded gl_EyePlane* indices. --- source/program.cpp | 3 ++- source/shadowmap.cpp | 9 ++++++++- source/shadowmap.h | 2 ++ 3 files changed, 12 insertions(+), 2 deletions(-) diff --git a/source/program.cpp b/source/program.cpp index adbb5c4c..f1120667 100644 --- a/source/program.cpp +++ b/source/program.cpp @@ -17,6 +17,7 @@ namespace { const char *standard_vertex_src[] = { + "s", "uniform int shadow_unit;\n", "n", "attribute vec3 tangent;\n", "n", "attribute vec3 binormal;\n", "t|n", "varying vec2 v_texcoord;\n", @@ -46,7 +47,7 @@ const char *standard_vertex_src[] = "p|en", "\tv_eye_dir = vec3(dot(eye_tangent, eye_dir), dot(eye_binormal, eye_dir), dot(eye_normal, eye_dir));\n", "p|e!n", "\tv_eye_dir = eye_dir;\n", "t|n", "\tv_texcoord = gl_MultiTexCoord0.xy;\n", - "s", "\tv_shadowcoord = vec3(dot(gl_EyePlaneS[3], eye_pos), dot(gl_EyePlaneT[3], eye_pos), dot(gl_EyePlaneR[3], eye_pos));\n", + "s", "\tv_shadowcoord = vec3(dot(gl_EyePlaneS[shadow_unit], eye_pos), dot(gl_EyePlaneT[shadow_unit], eye_pos), dot(gl_EyePlaneR[shadow_unit], eye_pos));\n", "!lm", "\tv_color = gl_Color;\n", 0, "}", 0, 0 diff --git a/source/shadowmap.cpp b/source/shadowmap.cpp index a9edacfc..95ef8583 100644 --- a/source/shadowmap.cpp +++ b/source/shadowmap.cpp @@ -18,7 +18,6 @@ ShadowMap::ShadowMap(unsigned s, const Renderable &r, const Light &l): Effect(r), size(s), light(l), - unit(3), radius(1) { depth_buf.set_min_filter(LINEAR); @@ -27,6 +26,8 @@ ShadowMap::ShadowMap(unsigned s, const Renderable &r, const Light &l): depth_buf.set_wrap(CLAMP_TO_EDGE); depth_buf.storage(DEPTH_COMPONENT, size, size); fbo.attach(DEPTH_ATTACHMENT, depth_buf, 0); + + set_texture_unit(3); } void ShadowMap::set_target(const Vector3 &t, float r) @@ -38,6 +39,10 @@ void ShadowMap::set_target(const Vector3 &t, float r) void ShadowMap::set_texture_unit(unsigned u) { unit = u; + + int i = unit; + shdata.uniform("shadow", i); + shdata.uniform("shadow_unit", i); } void ShadowMap::render(Renderer &renderer, const Tag &tag) const @@ -119,6 +124,8 @@ void ShadowMap::render(Renderer &renderer, const Tag &tag) const tg_r.bind_to(RCOORD); TexUnit::activate(0); + Renderer::Push _push_rend(renderer); + renderer.add_shader_data(shdata); renderable.render(renderer, tag); Texture::unbind_from(unit); diff --git a/source/shadowmap.h b/source/shadowmap.h index 11407462..af3cf6f7 100644 --- a/source/shadowmap.h +++ b/source/shadowmap.h @@ -3,6 +3,7 @@ #include "effect.h" #include "framebuffer.h" +#include "programdata.h" #include "texture2d.h" #include "vector.h" @@ -28,6 +29,7 @@ private: Texture2D depth_buf; Vector3 target; float radius; + ProgramData shdata; public: ShadowMap(unsigned, const Renderable &, const Light &); -- 2.43.0 From 01d2500733766710f4a11f49216a5b3dcc75a4a3 Mon Sep 17 00:00:00 2001 From: Mikko Rasa Date: Tue, 28 Aug 2012 11:30:30 +0300 Subject: [PATCH 09/16] Fix color equations in the standard shaders The generated shader code assigned a scalar to a vec3 if lighting was enabled without texture or material. An unnecessary multiplication in the alpha equation with texture but no material was removed. Also fix texturing in the shader demo (Mesa does funny things with uniforms). --- demos/shaders.cpp | 1 + source/program.cpp | 8 +++++--- 2 files changed, 6 insertions(+), 3 deletions(-) diff --git a/demos/shaders.cpp b/demos/shaders.cpp index 27538e4e..1b9c6472 100644 --- a/demos/shaders.cpp +++ b/demos/shaders.cpp @@ -83,6 +83,7 @@ int main() } GL::ProgramData progdata; + progdata.uniform("texture", 0); progdata.uniform("normalmap", 1); GL::Lighting lighting; diff --git a/source/program.cpp b/source/program.cpp index f1120667..729018a1 100644 --- a/source/program.cpp +++ b/source/program.cpp @@ -79,9 +79,10 @@ const char *standard_fragment_src[] = "e", "\tvec4 reflection = textureCube(environment, n_normal*(dot(n_normal, v_eye_dir)*2.0)-v_eye_dir);\n", "t", "\tvec4 tex_sample = texture2D(texture, v_texcoord);\n", 0, "\tgl_FragColor.rgb = ", - "!t!l!m", "vec3(1.0)", + "!t!m", "vec3(1.0)", "t", "tex_sample.rgb", "l|mt", "*", + "l!m!t", "*", "!lm", "v_color.rgb", "l", "((l_diffuse", "lm", "*gl_FrontLightProduct[0].diffuse.rgb", @@ -94,10 +95,11 @@ const char *standard_fragment_src[] = "e", "+reflection.rgb*reflectivity", 0, ";\n", 0, "\tgl_FragColor.a = ", - "!m", "1.0", + "!t!m", "1.0", + "t", "tex_sample.a", + "tm", "*", "!lm", "v_color.a", "lm", "gl_FrontMaterial.diffuse.a", - "t", "*tex_sample.a", 0, ";\n", 0, "}\n", 0, 0 -- 2.43.0 From 1b7b75e3aaec35433cce81fc58e58e50e5a3f36e Mon Sep 17 00:00:00 2001 From: Mikko Rasa Date: Tue, 28 Aug 2012 12:10:38 +0300 Subject: [PATCH 10/16] More efficient stack management Vectors are better than lists, since they don't need to allocate new memory for every element. A suitably sized reserve() does away with any initial reallocations in most cases. ProgramData in Renderer can be stored in a semi-independent stack as well, since it can only be removed with a pop. State is now devoid of dynamically allocated memory, making the stack operations even faster. --- source/matrix.cpp | 2 ++ source/matrix.h | 4 ++-- source/renderer.cpp | 15 ++++++++++++--- source/renderer.h | 16 +++++++++++++--- 4 files changed, 29 insertions(+), 8 deletions(-) diff --git a/source/matrix.cpp b/source/matrix.cpp index 549fe8b6..b7f76bc7 100644 --- a/source/matrix.cpp +++ b/source/matrix.cpp @@ -278,12 +278,14 @@ GLenum MatrixStack::current_mode = GL_MODELVIEW; MatrixStack::MatrixStack(GLenum m): mode(m) { + matrices.reserve(mode==GL_MODELVIEW ? 32 : 4); matrices.push_back(Matrix()); } MatrixStack::MatrixStack(): mode(0) { + matrices.reserve(32); matrices.push_back(Matrix()); } diff --git a/source/matrix.h b/source/matrix.h index e32df7e3..5444b8b4 100644 --- a/source/matrix.h +++ b/source/matrix.h @@ -1,7 +1,7 @@ #ifndef MSP_GL_MATRIX_H_ #define MSP_GL_MATRIX_H_ -#include +#include #include "gl.h" #include "vector.h" @@ -81,7 +81,7 @@ public: private: GLenum mode; - std::list matrices; + std::vector matrices; static GLenum current_mode; diff --git a/source/renderer.cpp b/source/renderer.cpp index c751b0e3..94875084 100644 --- a/source/renderer.cpp +++ b/source/renderer.cpp @@ -21,11 +21,14 @@ Renderer::Renderer(const Camera *c): mtx_changed(false), camera(c), state_stack(1), - state(&state_stack.back()), vertex_array(0), vertex_array_changed(false), element_buffer(0) { + state_stack.reserve(16); + shdata_stack.reserve(32); + state = &state_stack.back(); + MatrixStack::modelview().push(); if(camera) { @@ -73,12 +76,16 @@ void Renderer::set_shader_program(const Program *p, const ProgramData *d) state->shprog = p; if(p && d) add_shader_data(*d); + + /* Even if we have no new shdata, the existing ones need to be re-applied + to the new program */ shdata_changed = true; } void Renderer::add_shader_data(const ProgramData &d) { - state->shdata.push_back(&d); + shdata_stack.push_back(&d); + state->shdata_count = shdata_stack.size(); shdata_changed = true; } @@ -112,6 +119,8 @@ void Renderer::pop_state() state_stack.pop_back(); state = &state_stack.back(); + if(shdata_stack.size()>state->shdata_count) + shdata_stack.erase(shdata_stack.begin()+state->shdata_count, shdata_stack.end()); mtx_stack.pop(); mtx_changed = true; shdata_changed = true; @@ -170,7 +179,7 @@ void Renderer::apply_state() state->shprog->bind(); if(shdata_changed) { - for(vector::const_iterator i=state->shdata.begin(); i!=state->shdata.end(); ++i) + for(vector::const_iterator i=shdata_stack.begin(); i!=shdata_stack.end(); ++i) (*i)->apply(); shdata_changed = false; } diff --git a/source/renderer.h b/source/renderer.h index 5536702b..6115a7fe 100644 --- a/source/renderer.h +++ b/source/renderer.h @@ -26,6 +26,11 @@ will often be more efficient. This is especially true for ObjectInstances. The Renderer works by deferring GL state changes until something is actually being drawn. This avoids many unnecessary GL calls if consecutive renderables use the same resources. + +A state stack is provided to help with state scoping. Typically a Renderable +will push the current state on entry, set whatever state it requires, render +itself, and pop the state when it's done. An RAII helper class is provided for +the push/pop operation. */ class Renderer { @@ -47,7 +52,7 @@ private: const Texturing *texturing; const Material *material; const Program *shprog; - std::vector shdata; + unsigned shdata_count; const WindingTest *winding_test; State(); @@ -67,12 +72,13 @@ private: MtxStack mtx_stack; bool mtx_changed; const Camera *camera; - std::list state_stack; + std::vector state_stack; State *state; + std::vector shdata_stack; + bool shdata_changed; const VertexArray *vertex_array; bool vertex_array_changed; const Buffer *element_buffer; - bool shdata_changed; public: Renderer(const Camera *); @@ -99,7 +105,11 @@ public: void set_element_buffer(const Buffer *); void set_winding_test(const WindingTest *); + /** Saves the current state so it can be restored later. */ void push_state(); + + /** Restores a previously saved state. Must be matched with an earlier + push_state call. */ void pop_state(); /** Prepares for temporarily bypassing the Renderer by synchronizing the -- 2.43.0 From 99c9abad967dc2925f8603fd0d202d9b6df092ed Mon Sep 17 00:00:00 2001 From: Mikko Rasa Date: Tue, 28 Aug 2012 13:08:16 +0300 Subject: [PATCH 11/16] Fix an uninitialized variable --- source/renderer.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/source/renderer.cpp b/source/renderer.cpp index 94875084..fd4dc576 100644 --- a/source/renderer.cpp +++ b/source/renderer.cpp @@ -205,6 +205,7 @@ Renderer::State::State(): texturing(0), material(0), shprog(0), + shdata_count(0), winding_test(0) { } -- 2.43.0 From 2e6a73a93eac0a18063ec675a24a8e6eeeb80a0c Mon Sep 17 00:00:00 2001 From: Mikko Rasa Date: Tue, 28 Aug 2012 13:18:41 +0300 Subject: [PATCH 12/16] Route rendering calls through Renderer and add an exclusion system This is necessary for generating environment maps for an object, since the object itself should not be included in the map. The alternative is to create a separate Scene, but that's rather clumsy. --- source/instancescene.cpp | 2 +- source/orderedscene.cpp | 3 ++- source/pipeline.cpp | 2 +- source/renderer.cpp | 17 +++++++++++++++++ source/renderer.h | 19 +++++++++++++++++++ source/shadowmap.cpp | 4 ++-- source/simplescene.cpp | 3 ++- 7 files changed, 44 insertions(+), 6 deletions(-) diff --git a/source/instancescene.cpp b/source/instancescene.cpp index ffbfa558..6ddfa0d2 100644 --- a/source/instancescene.cpp +++ b/source/instancescene.cpp @@ -26,7 +26,7 @@ void InstanceScene::render(Renderer &renderer, const Tag &tag) const { for(InstanceMap::const_iterator i=renderables.begin(); i!=renderables.end(); ++i) for(RenderableSet::const_iterator j=i->second.begin(); j!=i->second.end(); ++j) - (*j)->render(renderer, tag); + renderer.render(**j, tag); } } // namespace GL diff --git a/source/orderedscene.cpp b/source/orderedscene.cpp index 547af77a..40149b34 100644 --- a/source/orderedscene.cpp +++ b/source/orderedscene.cpp @@ -1,5 +1,6 @@ #include #include "orderedscene.h" +#include "renderer.h" namespace Msp { namespace GL { @@ -37,7 +38,7 @@ void OrderedScene::insert_after(const Renderable &after, const Renderable &r) void OrderedScene::render(Renderer &renderer, const Tag &tag) const { for(RenderableList::const_iterator i=renderables.begin(); i!=renderables.end(); ++i) - (*i)->render(renderer, tag); + renderer.render(**i, tag); } } // namespace GL diff --git a/source/pipeline.cpp b/source/pipeline.cpp index bfd7bc67..2dd178f2 100644 --- a/source/pipeline.cpp +++ b/source/pipeline.cpp @@ -128,7 +128,7 @@ void Pipeline::render(Renderer &renderer, const Tag &tag) const for(vector::const_iterator j=renderables.begin(); j!=renderables.end(); ++j) if(j->passes.empty() || j->passes.count(i->get_tag())) - j->renderable->render(renderer, i->get_tag()); + renderer.render(*j->renderable, i->get_tag()); } if(target[0]) diff --git a/source/renderer.cpp b/source/renderer.cpp index fd4dc576..6734edc4 100644 --- a/source/renderer.cpp +++ b/source/renderer.cpp @@ -5,6 +5,7 @@ #include "material.h" #include "program.h" #include "programdata.h" +#include "renderable.h" #include "renderer.h" #include "texture.h" #include "texturing.h" @@ -132,6 +133,22 @@ void Renderer::escape() Buffer::unbind_from(ELEMENT_ARRAY_BUFFER); } +void Renderer::exclude(const Renderable &renderable) +{ + excluded.insert(&renderable); +} + +void Renderer::include(const Renderable &renderable) +{ + excluded.erase(&renderable); +} + +void Renderer::render(const Renderable &renderable, const Tag &tag) +{ + if(!excluded.count(&renderable)) + renderable.render(*this, tag); +} + void Renderer::draw(const Batch &batch) { if(!vertex_array) diff --git a/source/renderer.h b/source/renderer.h index 6115a7fe..91d20674 100644 --- a/source/renderer.h +++ b/source/renderer.h @@ -1,8 +1,10 @@ #ifndef MSP_GL_RENDERER_H_ #define MSP_GL_RENDERER_H_ +#include #include #include "matrix.h" +#include "tag.h" namespace Msp { namespace GL { @@ -13,6 +15,7 @@ class Camera; class Material; class Program; class ProgramData; +class Renderable; class Texture; class Texturing; class VertexArray; @@ -45,6 +48,17 @@ public: ~Push() { renderer.pop_state(); } }; + class Exclude + { + private: + Renderer &renderer; + const Renderable &renderable; + + public: + Exclude(Renderer &r, const Renderable &e): renderer(r), renderable(e) { renderer.exclude(renderable); } + ~Exclude() { renderer.include(renderable); } + }; + private: struct State { @@ -79,6 +93,7 @@ private: const VertexArray *vertex_array; bool vertex_array_changed; const Buffer *element_buffer; + std::set excluded; public: Renderer(const Camera *); @@ -117,6 +132,10 @@ public: Renderer. */ void escape(); + void exclude(const Renderable &); + void include(const Renderable &); + + void render(const Renderable &, const Tag & = Tag()); void draw(const Batch &); private: diff --git a/source/shadowmap.cpp b/source/shadowmap.cpp index 95ef8583..ea4982fe 100644 --- a/source/shadowmap.cpp +++ b/source/shadowmap.cpp @@ -48,7 +48,7 @@ void ShadowMap::set_texture_unit(unsigned u) void ShadowMap::render(Renderer &renderer, const Tag &tag) const { if(!enabled_passes.count(tag)) - return renderable.render(renderer, tag); + return renderer.render(renderable, tag); Vector4 lpos = light.get_position(); if(lpos.w) @@ -126,7 +126,7 @@ void ShadowMap::render(Renderer &renderer, const Tag &tag) const Renderer::Push _push_rend(renderer); renderer.add_shader_data(shdata); - renderable.render(renderer, tag); + renderer.render(renderable, tag); Texture::unbind_from(unit); TexGen::unbind_from(SCOORD); diff --git a/source/simplescene.cpp b/source/simplescene.cpp index e7ffc638..9e0623d8 100644 --- a/source/simplescene.cpp +++ b/source/simplescene.cpp @@ -1,3 +1,4 @@ +#include "renderer.h" #include "simplescene.h" namespace Msp { @@ -16,7 +17,7 @@ void SimpleScene::remove(const Renderable &r) void SimpleScene::render(Renderer &renderer, const Tag &tag) const { for(RenderableSet::const_iterator i=renderables.begin(); i!=renderables.end(); ++i) - (*i)->render(renderer, tag); + renderer.render(**i, tag); } } // namespace GL -- 2.43.0 From 9733137499a84f44c29d06d2551d41a903de1112 Mon Sep 17 00:00:00 2001 From: Mikko Rasa Date: Tue, 28 Aug 2012 13:34:09 +0300 Subject: [PATCH 13/16] Don't expose the shader type enum Instead take an object oriented approach. --- source/ambientocclusion.cpp | 4 ++-- source/bloom.cpp | 4 ++-- source/colorcurve.cpp | 3 +-- source/postprocessor.cpp | 2 +- source/program.cpp | 12 ++++++------ source/shader.cpp | 28 +++++++++++++++++++++++----- source/shader.h | 32 +++++++++++++++++++++----------- 7 files changed, 56 insertions(+), 29 deletions(-) diff --git a/source/ambientocclusion.cpp b/source/ambientocclusion.cpp index e22e0391..de937cf6 100644 --- a/source/ambientocclusion.cpp +++ b/source/ambientocclusion.cpp @@ -69,11 +69,11 @@ AmbientOcclusion::AmbientOcclusion(unsigned w, unsigned h, float depth_ratio): quad(get_fullscreen_quad()) { occlude_shader.attach_shader(get_fullscreen_vertex_shader()); - occlude_shader.attach_shader_owned(new Shader(FRAGMENT_SHADER, occlude_fs)); + occlude_shader.attach_shader_owned(new FragmentShader(occlude_fs)); occlude_shader.link(); combine_shader.attach_shader(get_fullscreen_vertex_shader()); - combine_shader.attach_shader_owned(new Shader(FRAGMENT_SHADER, combine_fs)); + combine_shader.attach_shader_owned(new FragmentShader(combine_fs)); combine_shader.link(); occlusion.storage(GL::RGB, w, h); diff --git a/source/bloom.cpp b/source/bloom.cpp index 8a6ddbcd..b73ea160 100644 --- a/source/bloom.cpp +++ b/source/bloom.cpp @@ -43,11 +43,11 @@ Bloom::Bloom(unsigned w, unsigned h): quad(get_fullscreen_quad()) { blur_shader.attach_shader(get_fullscreen_vertex_shader()); - blur_shader.attach_shader_owned(new Shader(FRAGMENT_SHADER, blur_fs)); + blur_shader.attach_shader_owned(new FragmentShader(blur_fs)); blur_shader.link(); combine_shader.attach_shader(get_fullscreen_vertex_shader()); - combine_shader.attach_shader_owned(new Shader(FRAGMENT_SHADER, combine_fs)); + combine_shader.attach_shader_owned(new FragmentShader(combine_fs)); combine_shader.link(); blur_shdata[0].uniform("delta", 1.0f/w, 0.0f); diff --git a/source/colorcurve.cpp b/source/colorcurve.cpp index 95c82491..d008593e 100644 --- a/source/colorcurve.cpp +++ b/source/colorcurve.cpp @@ -43,8 +43,7 @@ ColorCurve::ColorCurve(): quad(get_fullscreen_quad()) { shprog.attach_shader(get_fullscreen_vertex_shader()); - Shader *fs = new Shader(FRAGMENT_SHADER, fragment_src); - shprog.attach_shader_owned(fs); + shprog.attach_shader_owned(new FragmentShader(fragment_src)); shprog.link(); set_peak(0.2); diff --git a/source/postprocessor.cpp b/source/postprocessor.cpp index add8b1ed..6c9408cb 100644 --- a/source/postprocessor.cpp +++ b/source/postprocessor.cpp @@ -21,7 +21,7 @@ namespace GL { Shader &PostProcessor::get_fullscreen_vertex_shader() { - static Shader shader(VERTEX_SHADER, fullscreen_vs_source); + static VertexShader shader(fullscreen_vs_source); return shader; } diff --git a/source/program.cpp b/source/program.cpp index 729018a1..84b3cdd1 100644 --- a/source/program.cpp +++ b/source/program.cpp @@ -128,8 +128,8 @@ Program::Program(const string &vert, const string &frag) { init(); - attach_shader_owned(new Shader(VERTEX_SHADER, vert)); - attach_shader_owned(new Shader(FRAGMENT_SHADER, frag)); + attach_shader_owned(new VertexShader(vert)); + attach_shader_owned(new FragmentShader(frag)); link(); } @@ -179,8 +179,8 @@ void Program::add_standard_shaders(const StandardFeatures &features) string flags = features.create_flags(); string vertex_src = process_standard_source(standard_vertex_src, flags); string fragment_src = process_standard_source(standard_fragment_src, flags); - attach_shader_owned(new Shader(VERTEX_SHADER, vertex_src)); - attach_shader_owned(new Shader(FRAGMENT_SHADER, fragment_src)); + attach_shader_owned(new VertexShader(vertex_src)); + attach_shader_owned(new FragmentShader(fragment_src)); } string Program::process_standard_source(const char **source, const string &flags) @@ -477,7 +477,7 @@ void Program::Loader::attribute(unsigned i, const string &n) void Program::Loader::fragment_shader(const string &src) { - obj.attach_shader_owned(new Shader(FRAGMENT_SHADER, src)); + obj.attach_shader_owned(new FragmentShader(src)); } void Program::Loader::standard() @@ -489,7 +489,7 @@ void Program::Loader::standard() void Program::Loader::vertex_shader(const string &src) { - obj.attach_shader_owned(new Shader(VERTEX_SHADER, src)); + obj.attach_shader_owned(new VertexShader(src)); } diff --git a/source/shader.cpp b/source/shader.cpp index b0cf5a3e..0da1a6e9 100644 --- a/source/shader.cpp +++ b/source/shader.cpp @@ -9,12 +9,12 @@ using namespace std; namespace Msp { namespace GL { -Shader::Shader(ShaderType t) +Shader::Shader(GLenum t) { init(t); } -Shader::Shader(ShaderType t, const string &src) +Shader::Shader(GLenum t, const string &src) { init(t); @@ -22,13 +22,13 @@ Shader::Shader(ShaderType t, const string &src) compile(); } -void Shader::init(ShaderType t) +void Shader::init(GLenum t) { compiled = false; - if(t==FRAGMENT_SHADER) + if(t==GL_FRAGMENT_SHADER) static Require _req(ARB_fragment_shader); - else if(t==VERTEX_SHADER) + else if(t==GL_VERTEX_SHADER) static Require _req(ARB_vertex_shader); id = glCreateShader(t); @@ -74,5 +74,23 @@ string Shader::get_info_log() const return log; } + +VertexShader::VertexShader(): + Shader(GL_VERTEX_SHADER) +{ } + +VertexShader::VertexShader(const string &src): + Shader(GL_VERTEX_SHADER, src) +{ } + + +FragmentShader::FragmentShader(): + Shader(GL_FRAGMENT_SHADER) +{ } + +FragmentShader::FragmentShader(const string &src): + Shader(GL_FRAGMENT_SHADER, src) +{ } + } // namespace GL } // namespace Msp diff --git a/source/shader.h b/source/shader.h index c1fd6b22..63af9b3a 100644 --- a/source/shader.h +++ b/source/shader.h @@ -7,25 +7,19 @@ namespace Msp { namespace GL { -enum ShaderType -{ - FRAGMENT_SHADER = GL_FRAGMENT_SHADER_ARB, - VERTEX_SHADER = GL_VERTEX_SHADER_ARB -}; - class Shader { private: unsigned id; bool compiled; -public: - Shader(ShaderType t); - Shader(ShaderType t, const std::string &); +protected: + Shader(GLenum t); + Shader(GLenum t, const std::string &); private: - void init(ShaderType); + void init(GLenum); public: - ~Shader(); + virtual ~Shader(); void source(unsigned count, const char **str, const int *len); void source(const std::string &str); @@ -36,6 +30,22 @@ public: std::string get_info_log() const; }; + +class VertexShader: public Shader +{ +public: + VertexShader(); + VertexShader(const std::string &); +}; + + +class FragmentShader: public Shader +{ +public: + FragmentShader(); + FragmentShader(const std::string &); +}; + } // namespace GL } // namespace Msp -- 2.43.0 From 9034e81679eeeaa3d1d5d643d3f924d9edb45a68 Mon Sep 17 00:00:00 2001 From: Mikko Rasa Date: Thu, 30 Aug 2012 00:48:58 +0300 Subject: [PATCH 14/16] Entirely new system for building standard shaders The old one was becoming such a huge mess that I had to spend two minutes doing boolean analysis to figure out the conditions for a multiplication operator. The logic parser was also insufficient for expressing sophisticated relationships between variables. The new one operates with expression, starting from a target variable and pulling in others to compute its value. The logic parser is still there, buts its burden is greatly reduced, as most of the work is done by the dependency resolver. Reflections are missing at the moment, but will be added back soon. They were pretty broken in the old system anyway, with the assumption that the environment map is in eye space. The generated shader code is rather verbose, containing a lot more local variables than are needed. An optimizer will be implemented in the near future. --- demos/cubemap.cpp | 2 +- demos/shaders.cpp | 2 +- source/program.cpp | 200 +-------------- source/program.h | 29 +-- source/programbuilder.cpp | 497 ++++++++++++++++++++++++++++++++++++++ source/programbuilder.h | 108 +++++++++ 6 files changed, 615 insertions(+), 223 deletions(-) create mode 100644 source/programbuilder.cpp create mode 100644 source/programbuilder.h diff --git a/demos/cubemap.cpp b/demos/cubemap.cpp index 98d0ba24..512f519f 100644 --- a/demos/cubemap.cpp +++ b/demos/cubemap.cpp @@ -84,7 +84,7 @@ int main() material.set_specular(GL::Color(1.0)); material.set_shininess(100); - GL::Program::StandardFeatures features; + GL::ProgramBuilder::StandardFeatures features; features.lighting = true; features.specular = true; features.material = true; diff --git a/demos/shaders.cpp b/demos/shaders.cpp index 1b9c6472..73ae1b72 100644 --- a/demos/shaders.cpp +++ b/demos/shaders.cpp @@ -67,7 +67,7 @@ int main() vector programs; for(unsigned i=0; i<12; ++i) { - GL::Program::StandardFeatures feat; + GL::ProgramBuilder::StandardFeatures feat; feat.material = i/4>0; feat.texture = i/4>1; feat.lighting = i%4>0; diff --git a/source/program.cpp b/source/program.cpp index 84b3cdd1..636988d7 100644 --- a/source/program.cpp +++ b/source/program.cpp @@ -13,100 +13,6 @@ using namespace std; -namespace { - -const char *standard_vertex_src[] = -{ - "s", "uniform int shadow_unit;\n", - "n", "attribute vec3 tangent;\n", - "n", "attribute vec3 binormal;\n", - "t|n", "varying vec2 v_texcoord;\n", - "s", "varying vec3 v_shadowcoord;\n", - "!lm", "varying vec4 v_color;\n", - "l!n", "varying vec3 v_normal;\n", - "l", "varying vec3 v_light_dir;\n", - "p|e", "varying vec3 v_eye_dir;\n", - "r", "vec4 transform_vertex(vec4);\n", - "lr", "vec3 transform_normal(vec3);\n", - 0, "void main()\n", - 0, "{\n", - "r", "\tvec4 eye_pos = transform_vertex(gl_Vertex);\n", - "!r", "\tvec4 eye_pos = gl_ModelViewMatrix*gl_Vertex;\n", - 0, "\tgl_Position = gl_ProjectionMatrix*eye_pos;\n", - "lr", "\tvec3 eye_normal = transform_normal(gl_Normal);\n", - "l!r", "\tvec3 eye_normal = gl_NormalMatrix*gl_Normal;\n", - "l!n", "\tv_normal = eye_normal;\n", - "nr", "\tvec3 eye_tangent = transform_normal(tangent);\n", - "n!r", "\tvec3 eye_tangent = gl_NormalMatrix*tangent;\n", - "nr", "\tvec3 eye_binormal = transform_normal(binormal);\n", - "n!r", "\tvec3 eye_binormal = gl_NormalMatrix*binormal;\n", - "l", "\tvec3 eye_light_dir = normalize(gl_LightSource[0].position.xyz-eye_pos.xyz*gl_LightSource[0].position.w);\n", - "n", "\tv_light_dir = vec3(dot(eye_tangent, eye_light_dir), dot(eye_binormal, eye_light_dir), dot(eye_normal, eye_light_dir));\n", - "l!n", "\tv_light_dir = eye_light_dir;\n", - "p|e", "\tvec3 eye_dir = -normalize(eye_pos.xyz);\n", - "p|en", "\tv_eye_dir = vec3(dot(eye_tangent, eye_dir), dot(eye_binormal, eye_dir), dot(eye_normal, eye_dir));\n", - "p|e!n", "\tv_eye_dir = eye_dir;\n", - "t|n", "\tv_texcoord = gl_MultiTexCoord0.xy;\n", - "s", "\tv_shadowcoord = vec3(dot(gl_EyePlaneS[shadow_unit], eye_pos), dot(gl_EyePlaneT[shadow_unit], eye_pos), dot(gl_EyePlaneR[shadow_unit], eye_pos));\n", - "!lm", "\tv_color = gl_Color;\n", - 0, "}", - 0, 0 -}; - -const char *standard_fragment_src[] = -{ - "t", "uniform sampler2D texture;\n", - "n", "uniform sampler2D normalmap;\n", - "s", "uniform sampler2DShadow shadow;\n", - "e", "uniform samplerCube environment;\n", - "e", "uniform float reflectivity;\n", - "t|n", "varying vec2 v_texcoord;\n", - "s", "varying vec3 v_shadowcoord;\n", - "!lm", "varying vec4 v_color;\n", - "l!n", "varying vec3 v_normal;\n", - "l", "varying vec3 v_light_dir;\n", - "p|e", "varying vec3 v_eye_dir;\n", - 0, "void main()\n", - 0, "{\n", - "n", "\tvec3 n_normal = texture2D(normalmap, v_texcoord).xyz*2.0-1.0;\n", - "l!n", "\tvec3 n_normal = normalize(v_normal);\n", - "l", "\tfloat l_diffuse = max(dot(n_normal, normalize(v_light_dir)), 0.0);\n", - "p", "\tvec3 half_dir = normalize(v_eye_dir+v_light_dir);\n", - "p", "\tfloat l_specular = pow(max(dot(half_dir, n_normal), 0.0), gl_FrontMaterial.shininess);\n", - "s", "\tfloat l_shadow = shadow2D(shadow, v_shadowcoord).r;\n", - /* XXX This is incorrect with normal mapping, since the vectors are in TBN - space but environment map is expected to be in eye space */ - "e", "\tvec4 reflection = textureCube(environment, n_normal*(dot(n_normal, v_eye_dir)*2.0)-v_eye_dir);\n", - "t", "\tvec4 tex_sample = texture2D(texture, v_texcoord);\n", - 0, "\tgl_FragColor.rgb = ", - "!t!m", "vec3(1.0)", - "t", "tex_sample.rgb", - "l|mt", "*", - "l!m!t", "*", - "!lm", "v_color.rgb", - "l", "((l_diffuse", - "lm", "*gl_FrontLightProduct[0].diffuse.rgb", - "p", "+l_specular", - "pm", "*gl_FrontLightProduct[0].specular.rgb", - "l", ")", - "s", "*l_shadow", - "lm", "+gl_FrontLightModelProduct.sceneColor.rgb", - "l", ")", - "e", "+reflection.rgb*reflectivity", - 0, ";\n", - 0, "\tgl_FragColor.a = ", - "!t!m", "1.0", - "t", "tex_sample.a", - "tm", "*", - "!lm", "v_color.a", - "lm", "gl_FrontMaterial.diffuse.a", - 0, ";\n", - 0, "}\n", - 0, 0 -}; - -} - namespace Msp { namespace GL { @@ -115,11 +21,12 @@ Program::Program() init(); } -Program::Program(const StandardFeatures &features) +Program::Program(const ProgramBuilder::StandardFeatures &features) { init(); - add_standard_shaders(features); + ProgramBuilder builder(features); + builder.add_shaders(*this); if(!features.transform) link(); } @@ -174,52 +81,6 @@ void Program::detach_shader(Shader &shader) } } -void Program::add_standard_shaders(const StandardFeatures &features) -{ - string flags = features.create_flags(); - string vertex_src = process_standard_source(standard_vertex_src, flags); - string fragment_src = process_standard_source(standard_fragment_src, flags); - attach_shader_owned(new VertexShader(vertex_src)); - attach_shader_owned(new FragmentShader(fragment_src)); -} - -string Program::process_standard_source(const char **source, const string &flags) -{ - string result; - - for(unsigned i=0; source[i+1]; i+=2) - { - if(source[i]) - { - bool cond = true; - char oper = '&'; - for(const char *c=source[i]; *c; ++c) - { - if(*c>='a' && *c<='z') - { - bool found = (flags.find(*c)!=string::npos); - if(oper=='|') - cond = (cond || found); - else if(oper=='!') - cond = (cond && !found); - else if(oper=='&') - cond = (cond && found); - oper = '&'; - } - else - oper = *c; - } - - if(!cond) - continue; - } - - result += source[i+1]; - } - - return result; -} - void Program::bind_attribute(unsigned index, const string &name) { static Require _req(ARB_vertex_shader); @@ -419,43 +280,6 @@ void Program::unbind() } -Program::StandardFeatures::StandardFeatures(): - texture(false), - material(false), - lighting(false), - specular(false), - normalmap(false), - shadow(false), - reflection(false), - transform(false) -{ } - -string Program::StandardFeatures::create_flags() const -{ - string flags; - if(texture) - flags += 't'; - if(material) - flags += 'm'; - if(lighting) - { - flags += 'l'; - if(specular) - flags += 'p'; - if(normalmap) - flags += 'n'; - } - if(shadow) - flags += 's'; - if(reflection) - flags += 'e'; - if(transform) - flags += 'r'; - - return flags; -} - - Program::Loader::Loader(Program &p): DataFile::ObjectLoader(p) { @@ -482,9 +306,10 @@ void Program::Loader::fragment_shader(const string &src) void Program::Loader::standard() { - StandardFeatures feat; + ProgramBuilder::StandardFeatures feat; load_sub(feat); - obj.add_standard_shaders(feat); + ProgramBuilder builder(feat); + builder.add_shaders(obj); } void Program::Loader::vertex_shader(const string &src) @@ -492,18 +317,5 @@ void Program::Loader::vertex_shader(const string &src) obj.attach_shader_owned(new VertexShader(src)); } - -Program::StandardFeatures::Loader::Loader(StandardFeatures &f): - DataFile::ObjectLoader(f) -{ - add("lighting", &StandardFeatures::lighting); - add("material", &StandardFeatures::material); - add("normalmap", &StandardFeatures::normalmap); - add("shadow", &StandardFeatures::shadow); - add("specular", &StandardFeatures::specular); - add("texture", &StandardFeatures::texture); - add("transform", &StandardFeatures::transform); -} - } // namespace GL } // namespace Msp diff --git a/source/program.h b/source/program.h index 21b38c25..8cdfb6de 100644 --- a/source/program.h +++ b/source/program.h @@ -6,6 +6,7 @@ #include #include "bindable.h" #include "gl.h" +#include "programbuilder.h" namespace Msp { namespace GL { @@ -29,28 +30,6 @@ public: void vertex_shader(const std::string &); }; - struct StandardFeatures - { - class Loader: public DataFile::ObjectLoader - { - public: - Loader(StandardFeatures &); - }; - - bool texture; - bool material; - bool lighting; - bool specular; - bool normalmap; - bool shadow; - bool reflection; - bool transform; - - StandardFeatures(); - - std::string create_flags() const; - }; - struct UniformBlockInfo; struct UniformInfo @@ -88,7 +67,7 @@ private: public: Program(); - Program(const StandardFeatures &); + Program(const ProgramBuilder::StandardFeatures &); Program(const std::string &, const std::string &); private: void init(); @@ -98,10 +77,6 @@ public: void attach_shader(Shader &shader); void attach_shader_owned(Shader *shader); void detach_shader(Shader &shader); - void add_standard_shaders(const StandardFeatures &); -private: - static std::string process_standard_source(const char **, const std::string &); -public: const ShaderList &get_shaders() const { return shaders; } void bind_attribute(unsigned, const std::string &); diff --git a/source/programbuilder.cpp b/source/programbuilder.cpp new file mode 100644 index 00000000..46f7c153 --- /dev/null +++ b/source/programbuilder.cpp @@ -0,0 +1,497 @@ +#include +#include +#include "program.h" +#include "programbuilder.h" +#include "shader.h" + +using namespace std; + +namespace Msp { +namespace GL { + +/* +Naming conventions: + n_* Normalized vector + l_* Lighting component + + obj_* Object space + eye_* Eye space + tbn_* Tangent-Binormal-Normal space + shd_* Shadow space + *_dir Direction vector + + zzz_* Wildcard space, resolved by the builder + All wildcard spaces within an expression must match + + xxx_yyy_* Matrix that transforms between yyy to xxx + The vector is on the side of its designated space, result will be + in the other space + *_matrix A matrix (duh) + *_rmatrix A mat4 that works with a row vector + + rgb_* Color with rgb components only + color_* Color with rgba components +*/ + +/* The array are stored in reverse order, so that variables always come after +anything that might need them. */ +const ProgramBuilder::StandardVariable ProgramBuilder::standard_variables[] = +{ + { FRAGMENT, "gl_FragColor", 0, "color_base", "!t" }, + { FRAGMENT, "gl_FragColor", 0, "tex_sample*color_base", "t" }, + { FRAGMENT, "color_base", "vec4", "color_unlit", "!l!s" }, + { FRAGMENT, "color_base", "vec4", "color_unlit*vec4(vec3(l_shadow), 1.0)", "!ls" }, + { FRAGMENT, "color_base", "vec4", "vec4(rgb_light_full, 1.0)", "l!m" }, + { FRAGMENT, "color_base", "vec4", "vec4(rgb_light_full, gl_FrontMaterial.diffuse.a)", "lm" }, + { FRAGMENT, "color_unlit", "vec4", "vec4(1.0)", "!m" }, + { FRAGMENT, "color_unlit", "vec4", "color", "m" }, + { FRAGMENT, "rgb_light_full", "vec3", "rgb_light_shadow+gl_FrontLightModelProduct.sceneColor.rgb", "m" }, + { FRAGMENT, "rgb_light_full", "vec3", "rgb_light_shadow", "!m" }, + { FRAGMENT, "rgb_light_shadow", "vec3", "(rgb_light)*l_shadow", "s" }, + { FRAGMENT, "rgb_light_shadow", "vec3", "rgb_light", "!s" }, + { FRAGMENT, "rgb_light", "vec3", "vec3(l_diffuse)", "!m!p" }, + { FRAGMENT, "rgb_light", "vec3", "vec3(l_diffuse+l_specular)", "!mp" }, + { FRAGMENT, "rgb_light", "vec3", "l_diffuse*gl_FrontLightProduct[0].diffuse.rgb", "m!p" }, + { FRAGMENT, "rgb_light", "vec3", "l_diffuse*gl_FrontLightProduct[0].diffuse.rgb+l_specular*gl_FrontLightProduct[0].specular.rgb", "mp" }, + { FRAGMENT, "l_shadow", "float", "shadow2D(shadow, shd_vertex).r", 0 }, + { FRAGMENT, "l_diffuse", "float", "max(dot(n_zzz_normal, n_zzz_light_dir), 0.0)", 0 }, + { FRAGMENT, "l_specular", "float", "pow(max(dot(n_zzz_half_vec, n_zzz_normal), 0.0), gl_FrontMaterial.shininess)", 0 }, + { FRAGMENT, "n_zzz_half_vec", "vec3", "normalize(zzz_light_dir-zzz_incident_dir)", 0 }, + { FRAGMENT, "n_zzz_light_dir", "vec3", "normalize(zzz_light_dir)", 0 }, + { FRAGMENT, "n_tbn_normal", "vec3", "texture2D(normalmap, texture_coord).xyz*2.0-1.0", "n" }, + { FRAGMENT, "n_eye_normal", "vec3", "normalize(eye_normal)", "!n" }, + { FRAGMENT, "tex_sample", "vec4", "texture2D(texture, texture_coord)", 0 }, + + { VERTEX, "gl_Position", 0, "gl_ProjectionMatrix*eye_vertex", 0 }, + { VERTEX, "shd_vertex", "vec3", "eye_vertex*eye_shd_rmatrix", 0 }, + { VERTEX, "eye_shd_rmatrix", "mat4", "mat4(gl_EyePlaneS[shadow_unit], gl_EyePlaneT[shadow_unit], gl_EyePlaneR[shadow_unit], vec4(0.0, 0.0, 0.0, 1.0))", 0 }, + { VERTEX, "tbn_light_dir", "vec3", "eye_light_dir*eye_tbn_matrix", 0 }, + { VERTEX, "eye_light_dir", "vec3", "normalize(gl_LightSource[0].position.xyz-eye_vertex.xyz*gl_LightSource[0].position.w)", 0 }, + { VERTEX, "tbn_incident_dir", "vec3", "eye_incident_dir*eye_tbn_matrix", 0 }, + { VERTEX, "eye_incident_dir", "vec3", "normalize(eye_vertex.xyz)", 0 }, + { VERTEX, "eye_tbn_matrix", "mat3", "mat3(eye_tangent, eye_binormal, eye_normal)", 0 }, + { VERTEX, "eye_vertex", "vec4", "gl_ModelViewMatrix*gl_Vertex", "!r" }, + { VERTEX, "eye_vertex", "vec4", "transform_vertex(gl_Vertex)", "r" }, + { VERTEX, "eye_normal", "vec3", "gl_NormalMatrix*gl_Normal", "!r" }, + { VERTEX, "eye_normal", "vec3", "transform_normal(gl_Normal)", "r" }, + { VERTEX, "eye_tangent", "vec3", "gl_NormalMatrix*tangent", "!r" }, + { VERTEX, "eye_tangent", "vec3", "transform_normal(tangent)", "r" }, + { VERTEX, "eye_binormal", "vec3", "gl_NormalMatrix*binormal", "!r" }, + { VERTEX, "eye_binormal", "vec3", "transform_normal(binormal)", "r" }, + { VERTEX, "color", "vec4", "gl_Color", 0 }, + { VERTEX, "texture_coord", "vec2", "gl_MultiTexCoord0", 0 }, + + { ATTRIBUTE, "tangent", "vec3", 0, 0 }, + { ATTRIBUTE, "binormal", "vec3", 0, 0 }, + + { UNIFORM, "shadow_unit", "int", 0, 0 }, + { UNIFORM, "texture", "sampler2D", 0, 0 }, + { UNIFORM, "shadow", "sampler2DShadow", 0, 0 }, + { UNIFORM, "normalmap", "sampler2D", 0, 0 }, + + // Terminator entry + { NO_SCOPE, 0, 0, 0, 0 } +}; + +ProgramBuilder::ProgramBuilder(const StandardFeatures &f): + features(f), + feature_flags(features.create_flags()) +{ } + +Program *ProgramBuilder::create_program() const +{ + Program *prog = new Program; + add_shaders(*prog); + return prog; +} + +void ProgramBuilder::add_shaders(Program &prog) const +{ + list variables; + list resolved_vars; + + variables.push_front(ShaderVariable("gl_Position")); + variables.push_front(ShaderVariable("gl_FragColor")); + + for(const StandardVariable *i=standard_variables; i->name; ++i) + { + // Skip over anything that isn't used with the supplied flags + if(i->flags && !evaluate_flags(i->flags)) + continue; + + // See if this variable can satisfy any unresolved variables + ShaderVariable *last_resolved = 0; + for(list::iterator j=variables.begin(); j!=variables.end(); ++j) + { + if(j->variable) + continue; + + if(!name_match(i->name, j->resolved_name.c_str())) + continue; + + if(last_resolved) + { + /* We've already resolved a non-fuzzy variable in this iteration. + If there are multiple variables that can be resolved, they refer + to the same variable. */ + j->resolve(*last_resolved); + continue; + } + + j->resolve(*i); + resolved_vars.push_front(&*j); + if(!j->fuzzy_space) + last_resolved = &*j; + + if(!i->expression) + continue; + + vector identifiers = extract_identifiers(i->expression); + for(vector::const_iterator k=identifiers.begin(); k!=identifiers.end(); ++k) + { + // Use an existing variable if possible, but only if it's not fuzzy + ShaderVariable *var = 0; + for(list::iterator l=variables.begin(); (!var && l!=variables.end()); ++l) + if(!l->fuzzy_space && l->resolved_name==*k) + var = &*l; + + if(!var) + { + variables.push_back(ShaderVariable(*k)); + var = &variables.back(); + } + j->add_reference(*var); + } + } + } + + prog.attach_shader_owned(new VertexShader(create_source(resolved_vars, VERTEX))); + prog.attach_shader_owned(new FragmentShader(create_source(resolved_vars, FRAGMENT))); +} + +string ProgramBuilder::create_source(const list &variables, VariableScope scope) const +{ + string source; + + for(list::const_iterator i=variables.begin(); i!=variables.end(); ++i) + if((*i)->variable->scope==UNIFORM && (*i)->is_referenced_from(scope)) + source += format("uniform %s %s;\n", (*i)->variable->type, (*i)->resolved_name); + + if(scope==VERTEX) + { + for(list::const_iterator i=variables.begin(); i!=variables.end(); ++i) + if((*i)->variable->scope==ATTRIBUTE) + source += format("attribute %s %s;\n", (*i)->variable->type, (*i)->resolved_name); + } + + /* Any variables defined in vertex scope but referenced from fragment scope + should be exported as varyings over the interface. */ + list varyings; + for(list::const_iterator i=variables.begin(); i!=variables.end(); ++i) + if((*i)->variable->scope==VERTEX && (*i)->is_referenced_from(FRAGMENT)) + { + varyings.push_back(*i); + source += format("varying %s v_%s;\n", (*i)->variable->type, (*i)->resolved_name); + } + + if(scope==VERTEX && features.transform) + { + // Add the prototypes here, until I come up with something better + source += "vec4 transform_vertex(vec4);\n"; + source += "vec3 transform_normal(vec3);\n"; + } + + source += "void main()\n{\n"; + + for(list::const_iterator i=variables.begin(); i!=variables.end(); ++i) + if((*i)->variable->scope==scope) + { + source += '\t'; + if((*i)->variable->type) + { + source += (*i)->variable->type; + source += ' '; + } + source += format("%s = %s;\n", (*i)->resolved_name, (*i)->get_expression()); + } + + if(scope==VERTEX) + { + for(list::const_iterator i=varyings.begin(); i!=varyings.end(); ++i) + source += format("\tv_%s = %s;\n", (*i)->resolved_name, (*i)->resolved_name); + } + + source += '}'; + + return source; +} + +bool ProgramBuilder::evaluate_flags(const char *flags) const +{ + if(!flags) + return true; + + bool cond = true; + char oper = '&'; + for(const char *i=flags; *i; ++i) + { + if(*i>='a' && *i<='z') + { + bool found = (feature_flags.find(*i)!=string::npos); + if(oper=='|') + cond = (cond || found); + else if(oper=='!') + cond = (cond && !found); + else if(oper=='&') + cond = (cond && found); + oper = '&'; + } + else + oper = *i; + } + + return cond; +} + +ProgramBuilder::MatchLevel ProgramBuilder::name_match(const char *n1, const char *n2, const char **space) +{ + int i = 0; + int zzz = -1; + int zside = 0; + while(*n1 && *n2) + { + if(*n1==*n2 || *n1=='z' || *n2=='z') + { + if(*n1!=*n2) + { + int side = (*n1=='z' ? 1 : 2); + if(zzz<0) + { + zzz = i; + zside = side; + if(space) + { + if(*n1=='z') + *space = n2; + else + *space = n1; + } + } + else if(i>=zzz+3 || side!=zside) + return NO_MATCH; + } + } + else + return NO_MATCH; + ++n1; + ++n2; + ++i; + } + return (!*n1 && !*n2) ? zzz>=0 ? FUZZY : EXACT : NO_MATCH; +} + +bool ProgramBuilder::parse_identifier(const char *ptr, unsigned &start, unsigned &length) +{ + bool found = false; + bool member = false; + for(const char *i=ptr;; ++i) + { + if(!found) + { + if(!*i) + return false; + if(isalpha(*i) || *i=='_') + { + if(!member) + { + start = i-ptr; + found = true; + } + } + else if(*i=='.') + member = true; + else + member = false; + } + else + { + if(!isalnum(*i) && *i!='_') + { + length = i-(ptr+start); + return true; + } + } + } +} + +vector ProgramBuilder::extract_identifiers(const char *expression) +{ + vector result; + const char *ptr = expression; + unsigned start, length; + while(parse_identifier(ptr, start, length)) + { + result.push_back(string(ptr+start, length)); + ptr += start+length; + } + return result; +} + +string ProgramBuilder::replace_identifiers(const char *expression, const map &replace_map) +{ + string result; + const char *ptr = expression; + unsigned start, length; + while(parse_identifier(ptr, start, length)) + { + result.append(ptr, start); + string identifier(ptr+start, length); + map::const_iterator i = replace_map.find(identifier); + if(i!=replace_map.end()) + result += i->second; + else + result += identifier; + ptr += start+length; + } + result += ptr; + return result; +} + + +ProgramBuilder::StandardFeatures::StandardFeatures(): + texture(false), + material(false), + lighting(false), + specular(false), + normalmap(false), + shadow(false), + reflection(false), + transform(false) +{ } + +string ProgramBuilder::StandardFeatures::create_flags() const +{ + string flags; + if(texture) + flags += 't'; + if(material) + flags += 'm'; + if(lighting) + { + flags += 'l'; + if(specular) + flags += 'p'; + if(normalmap) + flags += 'n'; + } + if(shadow) + flags += 's'; + if(reflection) + flags += 'e'; + if(transform) + flags += 'r'; + + return flags; +} + + +ProgramBuilder::ShaderVariable::ShaderVariable(const std::string &n): + name(n), + variable(0), + resolved_name(n), + fuzzy_space(name.find("zzz")!=string::npos) +{ } + +void ProgramBuilder::ShaderVariable::resolve(const StandardVariable &var) +{ + variable = &var; + const char *space = 0; + if(name_match(var.name, resolved_name.c_str(), &space)==FUZZY) + resolve_space(string(space, 3)); +} + +void ProgramBuilder::ShaderVariable::resolve(ShaderVariable &var) +{ + for(list::iterator i=referenced_by.begin(); i!=referenced_by.end(); ++i) + (*i)->update_reference(*this, var); +} + +void ProgramBuilder::ShaderVariable::resolve_space(const string &space) +{ + if(fuzzy_space) + { + resolved_space = space; + + string::size_type zzz = resolved_name.find("zzz"); + resolved_name.replace(zzz, 3, resolved_space); + fuzzy_space = false; + + // Resolving the space could have affected other variables that use this one + for(list::iterator i=referenced_by.begin(); i!=referenced_by.end(); ++i) + (*i)->resolve_space(space); + } + + for(list::iterator i=referenced_vars.begin(); i!=referenced_vars.end(); ++i) + if((*i)->fuzzy_space) + (*i)->resolve_space(space); +} + +void ProgramBuilder::ShaderVariable::add_reference(ShaderVariable &var) +{ + referenced_vars.push_back(&var); + var.referenced_by.push_back(this); + if(var.fuzzy_space && !resolved_space.empty()) + var.resolve_space(resolved_space); +} + +void ProgramBuilder::ShaderVariable::update_reference(ShaderVariable &from, ShaderVariable &to) +{ + replace(referenced_vars.begin(), referenced_vars.end(), &from, &to); + replace(referenced_by.begin(), referenced_by.end(), &from, &to); + if(from.fuzzy_space && !to.fuzzy_space && !to.resolved_space.empty()) + resolve_space(to.resolved_space); +} + +bool ProgramBuilder::ShaderVariable::is_referenced_from(VariableScope scope) const +{ + for(list::const_iterator i=referenced_by.begin(); i!=referenced_by.end(); ++i) + if((*i)->variable->scope==scope) + return true; + return false; +} + +string ProgramBuilder::ShaderVariable::get_expression() const +{ + map replace_map; + for(list::const_iterator i=referenced_vars.begin(); i!=referenced_vars.end(); ++i) + if((*i)->variable) + { + string var_name = (*i)->resolved_name; + if(variable->scope==FRAGMENT && (*i)->variable->scope==VERTEX) + var_name = "v_"+var_name; + if(var_name!=(*i)->name) + replace_map[(*i)->name] = var_name; + } + + if(replace_map.empty()) + return variable->expression; + else + return replace_identifiers(variable->expression, replace_map); +} + + +ProgramBuilder::StandardFeatures::Loader::Loader(StandardFeatures &f): + DataFile::ObjectLoader(f) +{ + add("lighting", &StandardFeatures::lighting); + add("material", &StandardFeatures::material); + add("normalmap", &StandardFeatures::normalmap); + add("reflection", &StandardFeatures::reflection); + add("shadow", &StandardFeatures::shadow); + add("specular", &StandardFeatures::specular); + add("texture", &StandardFeatures::texture); + add("transform", &StandardFeatures::transform); +} + +} // namespace GL +} // namespace Msp diff --git a/source/programbuilder.h b/source/programbuilder.h new file mode 100644 index 00000000..30f1ef15 --- /dev/null +++ b/source/programbuilder.h @@ -0,0 +1,108 @@ +#ifndef MSP_GL_PROGRAMBUILDER_H_ +#define MSP_GL_PROGRAMBUILDER_H_ + +#include +#include +#include +#include + +namespace Msp { +namespace GL { + +class Program; + +class ProgramBuilder +{ +public: + struct StandardFeatures + { + class Loader: public DataFile::ObjectLoader + { + public: + Loader(StandardFeatures &); + }; + + bool texture; + bool material; + bool lighting; + bool specular; + bool normalmap; + bool shadow; + bool reflection; + bool transform; + + StandardFeatures(); + + std::string create_flags() const; + }; + + enum VariableScope + { + NO_SCOPE, + UNIFORM, + ATTRIBUTE, + VERTEX, + FRAGMENT + }; + +private: + struct StandardVariable + { + VariableScope scope; + const char *name; + const char *type; + const char *expression; + const char *flags; + }; + + struct ShaderVariable + { + std::string name; + const StandardVariable *variable; + std::string resolved_name; + bool fuzzy_space; + std::string resolved_space; + std::list referenced_vars; + std::list referenced_by; + + ShaderVariable(const std::string &); + + void resolve(const StandardVariable &); + void resolve(ShaderVariable &); + void resolve_space(const std::string &); + void add_reference(ShaderVariable &); + void update_reference(ShaderVariable &, ShaderVariable &); + bool is_referenced_from(VariableScope) const; + std::string get_expression() const; + }; + + enum MatchLevel + { + NO_MATCH, + EXACT, + FUZZY + }; + + StandardFeatures features; + std::string feature_flags; + + static const StandardVariable standard_variables[]; + +public: + ProgramBuilder(const StandardFeatures &); + + Program *create_program() const; + void add_shaders(Program &) const; +private: + std::string create_source(const std::list &, VariableScope) const; + bool evaluate_flags(const char *) const; + static MatchLevel name_match(const char *, const char *, const char ** = 0); + static bool parse_identifier(const char *, unsigned &, unsigned &); + static std::vector extract_identifiers(const char *); + static std::string replace_identifiers(const char *, const std::map &); +}; + +} // namespace GL +} // namespace Msp + +#endif -- 2.43.0 From 223e33164d0706d357efc03da1dc31a653f6afcf Mon Sep 17 00:00:00 2001 From: Mikko Rasa Date: Thu, 30 Aug 2012 09:03:39 +0300 Subject: [PATCH 15/16] Improvements for shadow mapping Depth bias is now configurable, and a darkness parameter was added. --- source/programbuilder.cpp | 4 +++- source/shadowmap.cpp | 22 ++++++++++++++++++++-- source/shadowmap.h | 15 ++++++++++++++- 3 files changed, 37 insertions(+), 4 deletions(-) diff --git a/source/programbuilder.cpp b/source/programbuilder.cpp index 46f7c153..1e07c1e5 100644 --- a/source/programbuilder.cpp +++ b/source/programbuilder.cpp @@ -53,7 +53,8 @@ const ProgramBuilder::StandardVariable ProgramBuilder::standard_variables[] = { FRAGMENT, "rgb_light", "vec3", "vec3(l_diffuse+l_specular)", "!mp" }, { FRAGMENT, "rgb_light", "vec3", "l_diffuse*gl_FrontLightProduct[0].diffuse.rgb", "m!p" }, { FRAGMENT, "rgb_light", "vec3", "l_diffuse*gl_FrontLightProduct[0].diffuse.rgb+l_specular*gl_FrontLightProduct[0].specular.rgb", "mp" }, - { FRAGMENT, "l_shadow", "float", "shadow2D(shadow, shd_vertex).r", 0 }, + { FRAGMENT, "l_shadow", "float", "mix(1.0, shadow_sample, shadow_darkness)", 0 }, + { FRAGMENT, "shadow_sample", "float", "shadow2D(shadow, shd_vertex).r", 0 }, { FRAGMENT, "l_diffuse", "float", "max(dot(n_zzz_normal, n_zzz_light_dir), 0.0)", 0 }, { FRAGMENT, "l_specular", "float", "pow(max(dot(n_zzz_half_vec, n_zzz_normal), 0.0), gl_FrontMaterial.shininess)", 0 }, { FRAGMENT, "n_zzz_half_vec", "vec3", "normalize(zzz_light_dir-zzz_incident_dir)", 0 }, @@ -87,6 +88,7 @@ const ProgramBuilder::StandardVariable ProgramBuilder::standard_variables[] = { UNIFORM, "shadow_unit", "int", 0, 0 }, { UNIFORM, "texture", "sampler2D", 0, 0 }, { UNIFORM, "shadow", "sampler2DShadow", 0, 0 }, + { UNIFORM, "shadow_darkness", "float", 0, 0 }, { UNIFORM, "normalmap", "sampler2D", 0, 0 }, // Terminator entry diff --git a/source/shadowmap.cpp b/source/shadowmap.cpp index ea4982fe..b930315f 100644 --- a/source/shadowmap.cpp +++ b/source/shadowmap.cpp @@ -18,7 +18,8 @@ ShadowMap::ShadowMap(unsigned s, const Renderable &r, const Light &l): Effect(r), size(s), light(l), - radius(1) + radius(1), + depth_bias(4) { depth_buf.set_min_filter(LINEAR); depth_buf.set_compare_enabled(true); @@ -27,6 +28,7 @@ ShadowMap::ShadowMap(unsigned s, const Renderable &r, const Light &l): depth_buf.storage(DEPTH_COMPONENT, size, size); fbo.attach(DEPTH_ATTACHMENT, depth_buf, 0); + set_darkness(0.7); set_texture_unit(3); } @@ -36,6 +38,22 @@ void ShadowMap::set_target(const Vector3 &t, float r) radius = r; } +void ShadowMap::set_darkness(float d) +{ + if(d<0.0f || d>1.0f) + throw invalid_argument("ShadowMap::set_darkness"); + + shdata.uniform("shadow_darkness", d); +} + +void ShadowMap::set_depth_bias(float b) +{ + if(b<0.0f) + throw invalid_argument("ShadowMap::set_depth_bias"); + + depth_bias = b; +} + void ShadowMap::set_texture_unit(unsigned u) { unit = u; @@ -118,7 +136,7 @@ void ShadowMap::render(Renderer &renderer, const Tag &tag) const TexGen tg_s, tg_t, tg_r; tg_s.set_plane(Vector4(matrix[0]/diam, matrix[4]/diam, matrix[8]/diam, matrix[12]/diam+0.5f)); tg_t.set_plane(Vector4(matrix[1]/diam, matrix[5]/diam, matrix[9]/diam, matrix[13]/diam+0.5f)); - tg_r.set_plane(Vector4(-matrix[2]/diam, -matrix[6]/diam, -matrix[10]/diam, 0.5f-matrix[14]/diam-4.0f/size)); + tg_r.set_plane(Vector4(-matrix[2]/diam, -matrix[6]/diam, -matrix[10]/diam, 0.5f-matrix[14]/diam-depth_bias/size)); tg_s.bind_to(SCOORD); tg_t.bind_to(TCOORD); tg_r.bind_to(RCOORD); diff --git a/source/shadowmap.h b/source/shadowmap.h index af3cf6f7..986e0d96 100644 --- a/source/shadowmap.h +++ b/source/shadowmap.h @@ -29,6 +29,7 @@ private: Texture2D depth_buf; Vector3 target; float radius; + float depth_bias; ProgramData shdata; public: @@ -39,8 +40,20 @@ public: covered by the ShadowMap. */ void set_target(const Vector3 &, float); + /** Sets the darkness of shadows. Must be in the range between 0.0 and 1.0, + inclusive. Only usable with shaders, and provided through the + shadow_darkness uniform. */ + void set_darkness(float); + + /** Sets a distance beyond objects from which the shadow starts. Expressed + in pixel-sized units. Must be positive; values less than 1.0 are not + recommended. Larger values produce less depth artifacts, but may prevent + thin objects from casting shadows on nearby sufraces. */ + void set_depth_bias(float); + /** Sets the texture unit to bind the shadow map to during the rendering - phase. The default is texture unit 3. */ + phase. Provided to shaders through the shadow and shadow_unit uniforms. + The default is texture unit 3. */ void set_texture_unit(unsigned); virtual void render(Renderer &, const Tag &) const; -- 2.43.0 From b250a711295f5ba00114f11a5b1c855eebe08d26 Mon Sep 17 00:00:00 2001 From: Mikko Rasa Date: Thu, 30 Aug 2012 11:41:15 +0300 Subject: [PATCH 16/16] Exception fixes Use out_of_range only when accessing arrays or array-like things, not for general numeric arguments. Armature::get_link functions now throw key_error since they behave like map access externally. --- source/animation.cpp | 3 ++- source/armature.cpp | 5 +++-- source/bloom.cpp | 4 ++-- source/buffer.cpp | 4 ++-- source/object.cpp | 4 ++-- source/pose.cpp | 2 +- source/texturecube.cpp | 2 +- source/texunit.cpp | 4 ++-- source/vertexformat.cpp | 2 +- 9 files changed, 16 insertions(+), 14 deletions(-) diff --git a/source/animation.cpp b/source/animation.cpp index efb67c97..1aa8242a 100644 --- a/source/animation.cpp +++ b/source/animation.cpp @@ -3,6 +3,7 @@ #include #include "animation.h" #include "armature.h" +#include "error.h" #include "keyframe.h" #include "pose.h" @@ -206,7 +207,7 @@ Matrix Animation::Iterator::get_matrix() const Matrix Animation::Iterator::get_pose_matrix(unsigned link) const { if(!animation.armature) - throw logic_error("Animation::Iterator::get_pose_matrix"); + throw invalid_operation("Animation::Iterator::get_pose_matrix"); if(link>animation.armature->get_max_link_index()) throw out_of_range("Animation::Iterator::get_pose_matrix"); diff --git a/source/armature.cpp b/source/armature.cpp index d7a944ed..887d974a 100644 --- a/source/armature.cpp +++ b/source/armature.cpp @@ -1,3 +1,4 @@ +#include #include "armature.h" using namespace std; @@ -16,7 +17,7 @@ const Armature::Link &Armature::get_link(unsigned index) const for(list::const_iterator i=links.begin(); i!=links.end(); ++i) if(i->get_index()==index) return *i; - throw invalid_argument("Armature::get_link"); + throw key_error(typeid(list)); } const Armature::Link &Armature::get_link(const string &name) const @@ -24,7 +25,7 @@ const Armature::Link &Armature::get_link(const string &name) const for(list::const_iterator i=links.begin(); i!=links.end(); ++i) if(i->get_name()==name) return *i; - throw invalid_argument("Armature::get_link"); + throw key_error(typeid(list)); } unsigned Armature::get_max_link_index() const diff --git a/source/bloom.cpp b/source/bloom.cpp index b73ea160..8fda424d 100644 --- a/source/bloom.cpp +++ b/source/bloom.cpp @@ -72,7 +72,7 @@ Bloom::Bloom(unsigned w, unsigned h): void Bloom::set_radius(float r) { if(r<=0.0f) - throw out_of_range("Bloom::set_radius"); + throw invalid_argument("Bloom::set_radius"); int size = min(static_cast(r*3.0f), 9); blur_shdata_common.uniform("size", size); @@ -91,7 +91,7 @@ void Bloom::set_radius(float r) void Bloom::set_strength(float s) { if(s<0.0f || s>1.0f) - throw out_of_range("Bloom::set_strength"); + throw invalid_argument("Bloom::set_strength"); combine_shdata.uniform("strength", s); } diff --git a/source/buffer.cpp b/source/buffer.cpp index 84c72716..5a0f4762 100644 --- a/source/buffer.cpp +++ b/source/buffer.cpp @@ -151,13 +151,13 @@ const BufferRange *&BufferRange::binding(BufferType type, unsigned index) if(type==UNIFORM_BUFFER) { if(index>=get_n_uniform_buffer_bindings()) - throw out_of_range("Buffer::binding"); + throw out_of_range("BufferRange::binding"); if(bound_uniform.size()<=index) bound_uniform.resize(index+1); return bound_uniform[index]; } else - throw invalid_argument("Buffer::binding"); + throw invalid_argument("BufferRange::binding"); } bool BufferRange::set_current(BufferType type, unsigned index, const BufferRange *buf) diff --git a/source/object.cpp b/source/object.cpp index 964099e5..bd899961 100644 --- a/source/object.cpp +++ b/source/object.cpp @@ -32,7 +32,7 @@ Object::~Object() void Object::set_mesh(unsigned i, const Mesh *m) { if(i>meshes.size()) - throw invalid_argument("Object::set_mesh"); + throw out_of_range("Object::set_mesh"); if(i==meshes.size()) meshes.push_back(m); @@ -144,7 +144,7 @@ void Object::Loader::mesh_inline() void Object::Loader::mesh_inline_lod(unsigned l) { if(l>obj.meshes.size()) - throw invalid_argument("Object::Loader::mesh_inline_lod"); + throw out_of_range("Object::Loader::mesh_inline_lod"); RefPtr msh = new Mesh; load_sub(*msh); diff --git a/source/pose.cpp b/source/pose.cpp index 4d589397..63346b08 100644 --- a/source/pose.cpp +++ b/source/pose.cpp @@ -68,7 +68,7 @@ void Pose::Loader::armature(const string &n) void Pose::Loader::link(const string &n) { if(!obj.armature) - error("Armature must be specified first"); + throw logic_error("Armature must be specified first"); LinkLoader ldr(obj, obj.armature->get_link(n).get_index()); load_sub_with(ldr); } diff --git a/source/texturecube.cpp b/source/texturecube.cpp index a5874a6a..6935e582 100644 --- a/source/texturecube.cpp +++ b/source/texturecube.cpp @@ -54,7 +54,7 @@ void TextureCube::image(TextureCubeFace face, unsigned level, PixelFormat fmt, D unsigned s = get_level_size(level); if(s==0) - throw invalid_argument("TextureCube::image"); + throw out_of_range("TextureCube::image"); Bind _bind(this, true); glTexImage2D(face, level, ifmt, s, s, 0, fmt, type, data); diff --git a/source/texunit.cpp b/source/texunit.cpp index b19e7917..0a5f9bf3 100644 --- a/source/texunit.cpp +++ b/source/texunit.cpp @@ -36,7 +36,7 @@ bool TexUnit::set_texenv(const TexEnv *env) bool TexUnit::set_texgen(unsigned i, const TexGen *gen) { if(i>=4) - throw invalid_argument("TexUnit::set_texgen"); + throw out_of_range("TexUnit::set_texgen"); bool result = (texgen[i]!=gen); texgen[i] = gen; return result; @@ -45,7 +45,7 @@ bool TexUnit::set_texgen(unsigned i, const TexGen *gen) const TexGen *TexUnit::get_texgen(unsigned i) { if(i>=4) - throw invalid_argument("TexUnit::get_texgen"); + throw out_of_range("TexUnit::get_texgen"); return texgen[i]; } diff --git a/source/vertexformat.cpp b/source/vertexformat.cpp index ed2b04b8..e3f8bf97 100644 --- a/source/vertexformat.cpp +++ b/source/vertexformat.cpp @@ -114,7 +114,7 @@ VertexFormat operator,(const VertexFormat &f, unsigned i) VertexFormat r = f; unsigned char *c = r.data+r.data[0]; if((*c0) || (*c=8) || i>=53) - throw out_of_range("VertexFormat::operator,"); + throw invalid_argument("VertexFormat::operator,"); *c += i*4; return r; -- 2.43.0