Remove support for legacy OpenGL features

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

diff --git a/source/vertexarray.cpp b/source/vertexarray.cpp
index e8fa36a030bf5991a89bf4ed8f79944543ced413..9947ac1108a59ef5b5a9a72d9caaa7987ba11782 100644 (file)
--- a/source/vertexarray.cpp
+++ b/source/vertexarray.cpp
@@ -18,13 +18,10 @@ VertexArray::VertexArray(const VertexFormat &f)
 
 VertexArray::~VertexArray()
 {
 
 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)


@@ -88,6 +85,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);
 }


@@ -103,11 +101,6 @@ 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
 {
        if(format.empty())
 void VertexArray::apply() const
 {
        if(format.empty())


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

+       static Require _req(ARB_vertex_shader);
+

        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


@@ -124,25 +119,18 @@ void VertexArray::apply() const
        if(!set_current(this) && !dirty)
                return;
 
        if(!set_current(this) && !dirty)
                return;
 

-       Buffer *vbuf = get_buffer();
-       if(vbuf)
-       {
-               vbuf->bind_to(ARRAY_BUFFER);
-               if(dirty)
-                       update_buffer();
-       }
+       const Buffer *vbuf = get_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);
        apply_arrays(&arrays, (old ? &old->arrays : 0), base, stride_bytes);
 
        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);

 }
 
 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)
 {

-       unsigned active_tex = 0;

        unsigned n_arrays = arrays ? arrays->size() : 0;
        if(old_arrays)
                n_arrays = max<unsigned>(n_arrays, old_arrays->size());
        unsigned n_arrays = arrays ? arrays->size() : 0;
        if(old_arrays)
                n_arrays = max<unsigned>(n_arrays, old_arrays->size());


@@ -156,69 +144,30 @@ 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(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)
-               {
-                       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;
-               }
-               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);
+void VertexArray::unbind()
+{
+       const VertexArray *old = current();
+       if(set_current(0))
+               apply_arrays(0, &old->arrays, 0, 0);

 }
 
 
 }
 
 


@@ -231,6 +180,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));