Avoid some brain damage from Windows headers

[libs/gl.git] / source / vertexarray.cpp

diff --git a/source/vertexarray.cpp b/source/vertexarray.cpp
index 996871c4094ecc659566cd460175392c6b69600a..0ebd4f0fef4e9855a650b53280ddfbac1ffbcd99 100644 (file)
--- a/source/vertexarray.cpp
+++ b/source/vertexarray.cpp
@@ -1,5 +1,6 @@
 #include <msp/gl/extensions/arb_multitexture.h>
 #include <msp/gl/extensions/arb_vertex_shader.h>
 #include <msp/gl/extensions/arb_multitexture.h>
 #include <msp/gl/extensions/arb_vertex_shader.h>

+#include <msp/gl/extensions/msp_legacy_features.h>

 #include "buffer.h"
 #include "error.h"
 #include "gl.h"
 #include "buffer.h"
 #include "error.h"
 #include "gl.h"


@@ -11,21 +12,19 @@ using namespace std;
 namespace Msp {
 namespace GL {
 
 namespace Msp {
 namespace GL {
 

-VertexArray::VertexArray(const VertexFormat &f):
-       dirty(false)
+bool VertexArray::legacy_used = false;
+
+VertexArray::VertexArray(const VertexFormat &f)

 {
        reset(f);
 }
 
 VertexArray::~VertexArray()
 {
 {
        reset(f);
 }
 
 VertexArray::~VertexArray()
 {

+       /* Unbind accesses the current VertexArray, so a call from ~Bindable would
+       try to access destroyed data. */

        if(current()==this)
        if(current()==this)

-       {
-               /* We must deactivate arrays here, or apply() would try to access deleted
-               data on the next invocation. */
-               set_current(0);
-               apply_arrays(0, &arrays, 0, 0);
-       }
+               unbind();

 }
 
 void VertexArray::reset(const VertexFormat &f)
 }
 
 void VertexArray::reset(const VertexFormat &f)


@@ -33,6 +32,7 @@ void VertexArray::reset(const VertexFormat &f)
        clear();
        format = f;
        stride = get_stride(format);
        clear();
        format = f;
        stride = get_stride(format);

+       legacy = false;

 
        arrays.clear();
 
 
        arrays.clear();
 


@@ -47,6 +47,9 @@ void VertexArray::reset(const VertexFormat &f)
                arr.component = *c;
                arr.offset = offs;
 
                arr.component = *c;
                arr.offset = offs;
 

+               if(*c<ATTRIB1)
+                       legacy = true;
+

                offs += get_component_size(*c);
        }
 }
                offs += get_component_size(*c);
        }
 }


@@ -89,6 +92,7 @@ void VertexArray::reserve(unsigned n)
 float *VertexArray::append()
 {
        data.insert(data.end(), stride, 0.0f);
 float *VertexArray::append()
 {
        data.insert(data.end(), stride, 0.0f);

+       update_offset();

        dirty = true;
        return &*(data.end()-stride);
 }
        dirty = true;
        return &*(data.end()-stride);
 }


@@ -104,12 +108,7 @@ unsigned VertexArray::get_data_size() const
        return data.size()*sizeof(float);
 }
 
        return data.size()*sizeof(float);
 }
 

-void VertexArray::upload_data() const
-{
-       get_buffer()->sub_data(get_offset(), get_data_size(), &data[0]);
-}
-
-void VertexArray::apply() const
+void VertexArray::apply(bool use_legacy) const

 {
        if(format.empty())
                throw invalid_operation("VertexArray::apply");
 {
        if(format.empty())
                throw invalid_operation("VertexArray::apply");


@@ -117,6 +116,17 @@ void VertexArray::apply() const
        if(Mesh::current())
                throw invalid_operation("VertexArray::apply");
 
        if(Mesh::current())
                throw invalid_operation("VertexArray::apply");
 

+       /* Unbind first if the legacy flag changes.  The logic for supporting it
+       directly in apply_arrays would get too complicated, and this also allows
+       rebinding the same array with different legacy setting. */
+       if(legacy_used!=use_legacy)
+               unbind();
+
+       if(!use_legacy)
+               static Require _req(ARB_vertex_shader);
+       else if(legacy)
+               static Require _req(MSP_legacy_features);
+

        const VertexArray *old = current();
        /* If the array has been modified, apply it even if it was the last one to
        be applied.  This is necessary to get the data updated to vertex buffer, and
        const VertexArray *old = current();
        /* If the array has been modified, apply it even if it was the last one to
        be applied.  This is necessary to get the data updated to vertex buffer, and


@@ -126,22 +136,16 @@ void VertexArray::apply() const
                return;
 
        Buffer *vbuf = get_buffer();
                return;
 
        Buffer *vbuf = get_buffer();

-       if(vbuf)
-       {
-               vbuf->bind_to(ARRAY_BUFFER);
-               if(dirty)
-                       update_buffer();
-       }
+       Bind _bind_vbuf(vbuf, ARRAY_BUFFER);
+       if(vbuf && dirty)
+               update_buffer();

 
        const float *base = (vbuf ? reinterpret_cast<float *>(get_offset()) : &data[0]);
        unsigned stride_bytes = stride*sizeof(float);
 
        const float *base = (vbuf ? reinterpret_cast<float *>(get_offset()) : &data[0]);
        unsigned stride_bytes = stride*sizeof(float);

-       apply_arrays(&arrays, (old ? &old->arrays : 0), base, stride_bytes);
-
-       if(vbuf)
-               Buffer::unbind_from(ARRAY_BUFFER);
+       apply_arrays(&arrays, (old ? &old->arrays : 0), base, stride_bytes, use_legacy);

 }
 
 }
 

-void VertexArray::apply_arrays(const vector<Array> *arrays, const vector<Array> *old_arrays, const float *base, unsigned stride_bytes)
+void VertexArray::apply_arrays(const vector<Array> *arrays, const vector<Array> *old_arrays, const float *base, unsigned stride_bytes, bool use_legacy)

 {
        unsigned active_tex = 0;
        unsigned n_arrays = arrays ? arrays->size() : 0;
 {
        unsigned active_tex = 0;
        unsigned n_arrays = arrays ? arrays->size() : 0;


@@ -157,69 +161,85 @@ void VertexArray::apply_arrays(const vector<Array> *arrays, const vector<Array>
                unsigned char comp = (arr ? arr->component : old_arr->component);
                unsigned sz = get_component_size(comp);
                unsigned t = get_component_type(comp);
                unsigned char comp = (arr ? arr->component : old_arr->component);
                unsigned sz = get_component_size(comp);
                unsigned t = get_component_type(comp);

-               GLenum array_type = 0;
-               if(t==get_component_type(VERTEX3))
-               {
-                       if(arr)
-                               glVertexPointer(sz, GL_FLOAT, stride_bytes, base+arr->offset);
-                       array_type = GL_VERTEX_ARRAY;
-               }
-               else if(t==get_component_type(NORMAL3))
+               if(use_legacy)

                {
                {

-                       if(arr)
-                               glNormalPointer(GL_FLOAT, stride_bytes, base+arr->offset);
-                       array_type = GL_NORMAL_ARRAY;
-               }
-               else if(t==get_component_type(COLOR4_FLOAT))
-               {
-                       if(arr)
+                       GLenum array_type = 0;
+                       if(t==get_component_type(VERTEX3))

                        {
                        {

-                               if(sz==1)
-                                       glColorPointer(4, GL_UNSIGNED_BYTE, stride_bytes, base+arr->offset);
-                               else
-                                       glColorPointer(sz, GL_FLOAT, stride_bytes, base+arr->offset);
+                               if(arr)
+                                       glVertexPointer(sz, GL_FLOAT, stride_bytes, base+arr->offset);
+                               array_type = GL_VERTEX_ARRAY;

                        }
                        }

-                       array_type = GL_COLOR_ARRAY;
-               }
-               else if(comp>=TEXCOORD1 && comp<=TEXCOORD4+12)
-               {
-                       t -= get_component_type(TEXCOORD1);
-                       if(t>0 || active_tex)
+                       else if(t==get_component_type(NORMAL3))
+                       {
+                               if(arr)
+                                       glNormalPointer(GL_FLOAT, stride_bytes, base+arr->offset);
+                               array_type = GL_NORMAL_ARRAY;
+                       }
+                       else if(t==get_component_type(COLOR4_FLOAT))
+                       {
+                               if(arr)
+                               {
+                                       if(sz==1)
+                                               glColorPointer(4, GL_UNSIGNED_BYTE, stride_bytes, base+arr->offset);
+                                       else
+                                               glColorPointer(sz, GL_FLOAT, stride_bytes, base+arr->offset);
+                               }
+                               array_type = GL_COLOR_ARRAY;
+                       }
+                       else if(comp>=TEXCOORD1 && comp<=TEXCOORD4+12)

                        {
                        {

-                               glClientActiveTexture(GL_TEXTURE0+t);
-                               active_tex = t;
+                               t -= get_component_type(TEXCOORD1);
+                               if(t>0 || active_tex)
+                               {
+                                       glClientActiveTexture(GL_TEXTURE0+t);
+                                       active_tex = t;
+                               }
+                               if(arr)
+                                       glTexCoordPointer(sz, GL_FLOAT, stride_bytes, base+arr->offset);
+                               array_type = GL_TEXTURE_COORD_ARRAY;
+                       }
+
+                       if(array_type)
+                       {
+                               // Only change enable state if needed
+                               if(arr && !old_arr)
+                                       glEnableClientState(array_type);
+                               else if(old_arr && !arr)
+                                       glDisableClientState(array_type);
+
+                               continue;

                        }
                        }

-                       if(arr)
-                               glTexCoordPointer(sz, GL_FLOAT, stride_bytes, base+arr->offset);
-                       array_type = GL_TEXTURE_COORD_ARRAY;

                }
                }

-               else
+
+               if(t>=get_component_type(ATTRIB1))
+                       t -= get_component_type(ATTRIB1);
+               if(arr)

                {
                {

-                       if(t>=get_component_type(ATTRIB1))
-                               t -= get_component_type(ATTRIB1);
-                       if(arr)
+                       if(arr->component==COLOR4_UBYTE)
+                               glVertexAttribPointer(t, 4, GL_UNSIGNED_BYTE, true, stride_bytes, base+arr->offset);
+                       else

                                glVertexAttribPointer(t, sz, GL_FLOAT, false, stride_bytes, base+arr->offset);
                }
 
                // Only change enable state if needed
                if(arr && !old_arr)
                                glVertexAttribPointer(t, sz, GL_FLOAT, false, stride_bytes, base+arr->offset);
                }
 
                // Only change enable state if needed
                if(arr && !old_arr)

-               {
-                       if(array_type)
-                               glEnableClientState(array_type);
-                       else
-                               glEnableVertexAttribArray(t);
-               }
+                       glEnableVertexAttribArray(t);

                else if(old_arr && !arr)
                else if(old_arr && !arr)

-               {
-                       if(array_type)
-                               glDisableClientState(array_type);
-                       else
-                               glDisableVertexAttribArray(t);
-               }
+                       glDisableVertexAttribArray(t);

        }
 
        if(active_tex)
                glClientActiveTexture(GL_TEXTURE0);
        }
 
        if(active_tex)
                glClientActiveTexture(GL_TEXTURE0);

+
+       legacy_used = use_legacy;
+}
+
+void VertexArray::unbind()
+{
+       const VertexArray *old = current();
+       if(set_current(0))
+               apply_arrays(0, &old->arrays, 0, 0, legacy_used);

 }
 
 
 }
 
 


@@ -232,6 +252,27 @@ VertexArray::Array::Array():
 VertexArray::Loader::Loader(VertexArray &a):
        VertexArrayBuilder(a)
 {
 VertexArray::Loader::Loader(VertexArray &a):
        VertexArrayBuilder(a)
 {

+       add("vertex", static_cast<void (Loader::*)(float, float)>(&Loader::vertex));
+       add("vertex", static_cast<void (Loader::*)(float, float, float)>(&Loader::vertex));
+       add("vertex", static_cast<void (Loader::*)(float, float, float, float)>(&Loader::vertex));
+       add("normal", static_cast<void (Loader::*)(float, float, float)>(&Loader::normal));
+       add("texcoord", static_cast<void (Loader::*)(float)>(&Loader::texcoord));
+       add("texcoord", static_cast<void (Loader::*)(float, float)>(&Loader::texcoord));
+       add("texcoord", static_cast<void (Loader::*)(float, float, float)>(&Loader::texcoord));
+       add("texcoord", static_cast<void (Loader::*)(float, float, float, float)>(&Loader::texcoord));
+       add("multitexcoord", static_cast<void (Loader::*)(unsigned, float)>(&Loader::multitexcoord));
+       add("multitexcoord", static_cast<void (Loader::*)(unsigned, float, float)>(&Loader::multitexcoord));
+       add("multitexcoord", static_cast<void (Loader::*)(unsigned, float, float, float)>(&Loader::multitexcoord));
+       add("multitexcoord", static_cast<void (Loader::*)(unsigned, float, float, float, float)>(&Loader::multitexcoord));
+       add("color", static_cast<void (Loader::*)(float, float, float)>(&Loader::color));
+       add("color", static_cast<void (Loader::*)(float, float, float, float)>(&Loader::color));
+       add("attrib", static_cast<void (Loader::*)(unsigned, float)>(&Loader::attrib));
+       add("attrib", static_cast<void (Loader::*)(unsigned, float, float)>(&Loader::attrib));
+       add("attrib", static_cast<void (Loader::*)(unsigned, float, float, float)>(&Loader::attrib));
+       add("attrib", static_cast<void (Loader::*)(unsigned, float, float, float, float)>(&Loader::attrib));
+       add("tangent", static_cast<void (Loader::*)(float, float, float)>(&Loader::tangent));
+       add("binormal", static_cast<void (Loader::*)(float, float, float)>(&Loader::binormal));
+

        add("vertex2",   static_cast<void (Loader::*)(float, float)>(&Loader::vertex));
        add("vertex3",   static_cast<void (Loader::*)(float, float, float)>(&Loader::vertex));
        add("vertex4",   static_cast<void (Loader::*)(float, float, float, float)>(&Loader::vertex));
        add("vertex2",   static_cast<void (Loader::*)(float, float)>(&Loader::vertex));
        add("vertex3",   static_cast<void (Loader::*)(float, float, float)>(&Loader::vertex));
        add("vertex4",   static_cast<void (Loader::*)(float, float, float, float)>(&Loader::vertex));