Remove support for legacy OpenGL features

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

diff --git a/source/vertexarray.cpp b/source/vertexarray.cpp
index 867aee7b189b71f348950741e4f2ccda6ae18921..9947ac1108a59ef5b5a9a72d9caaa7987ba11782 100644 (file)
--- a/source/vertexarray.cpp
+++ b/source/vertexarray.cpp
@@ -101,7 +101,7 @@ unsigned VertexArray::get_data_size() const
        return data.size()*sizeof(float);
 }
 
        return data.size()*sizeof(float);
 }
 

-void VertexArray::bind() const
+void VertexArray::apply() const

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


@@ -109,6 +109,8 @@ void VertexArray::bind() 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


@@ -117,7 +119,7 @@ void VertexArray::bind() const
        if(!set_current(this) && !dirty)
                return;
 
        if(!set_current(this) && !dirty)
                return;
 

-       Buffer *vbuf = get_buffer();
+       const Buffer *vbuf = get_buffer();

        Bind _bind_vbuf(vbuf, ARRAY_BUFFER);
        if(vbuf && dirty)
                update_buffer();
        Bind _bind_vbuf(vbuf, ARRAY_BUFFER);
        if(vbuf && dirty)
                update_buffer();


@@ -129,7 +131,6 @@ void VertexArray::bind() const
 
 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());


@@ -143,69 +144,23 @@ 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()
 }
 
 void VertexArray::unbind()


@@ -225,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));