working on glow

examples/Demo/data/pp_blit_fs.glsl

@@ -0,0 +1,11 @@
+/* BlurFragmentShader.glsl */
+precision mediump float;
+ 
+uniform sampler2D s_texture;
+ 
+varying vec2 v_texCoord;
+ 
+void main()
+{
+    gl_FragColor = texture2D(s_texture, v_texCoord);
+}

examples/Demo/data/pp_blit_vs.glsl

@@ -0,0 +1,16 @@
+/* VBlurVertexShader.glsl */
+attribute vec3 position;
+attribute vec4 color;
+attribute vec2 uv;
+ 
+uniform mediump float step;
+
+varying vec2 v_texCoord;
+varying vec4 v_color;
+ 
+void main()
+{
+    gl_Position = vec4(position.xyz, 1.0);
+    v_texCoord = uv;
+    v_color = color;
+}

examples/Demo/data/pp_hblur_vs.glsl

@@ -1,26 +1,32 @@
-/* HBlurVertexShader.glsl */
-attribute vec4 a_position;
-attribute vec2 a_texCoord;
+/* VBlurVertexShader.glsl */
+attribute vec3 position;
+attribute vec4 color;
+attribute vec2 uv;
  
+uniform mediump float step;
+
 varying vec2 v_texCoord;
 varying vec2 v_blurTexCoords[14];
  
 void main()
 {
-    gl_Position = a_position;
-    v_texCoord = a_texCoord;
-    v_blurTexCoords[ 0] = v_texCoord + vec2(-0.028, 0.0);
-    v_blurTexCoords[ 1] = v_texCoord + vec2(-0.024, 0.0);
-    v_blurTexCoords[ 2] = v_texCoord + vec2(-0.020, 0.0);
-    v_blurTexCoords[ 3] = v_texCoord + vec2(-0.016, 0.0);
-    v_blurTexCoords[ 4] = v_texCoord + vec2(-0.012, 0.0);
-    v_blurTexCoords[ 5] = v_texCoord + vec2(-0.008, 0.0);
-    v_blurTexCoords[ 6] = v_texCoord + vec2(-0.004, 0.0);
-    v_blurTexCoords[ 7] = v_texCoord + vec2( 0.004, 0.0);
-    v_blurTexCoords[ 8] = v_texCoord + vec2( 0.008, 0.0);
-    v_blurTexCoords[ 9] = v_texCoord + vec2( 0.012, 0.0);
-    v_blurTexCoords[10] = v_texCoord + vec2( 0.016, 0.0);
-    v_blurTexCoords[11] = v_texCoord + vec2( 0.020, 0.0);
-    v_blurTexCoords[12] = v_texCoord + vec2( 0.024, 0.0);
-    v_blurTexCoords[13] = v_texCoord + vec2( 0.028, 0.0);
+    gl_Position = vec4(position.xy, 0, 1.0);
+    float z = step;
+
+
+    v_texCoord = uv;
+    v_blurTexCoords[ 0] = v_texCoord + vec2(-z * 7, 0.0);
+    v_blurTexCoords[ 1] = v_texCoord + vec2(-z * 6, 0.0);
+    v_blurTexCoords[ 2] = v_texCoord + vec2(-z * 5, 0.0);
+    v_blurTexCoords[ 3] = v_texCoord + vec2(-z * 4, 0.0);
+    v_blurTexCoords[ 4] = v_texCoord + vec2(-z * 3, 0.0);
+    v_blurTexCoords[ 5] = v_texCoord + vec2(-z * 2, 0.0);
+    v_blurTexCoords[ 6] = v_texCoord + vec2(-z    , 0.0);
+    v_blurTexCoords[ 7] = v_texCoord + vec2( z    , 0.0);
+    v_blurTexCoords[ 8] = v_texCoord + vec2( z * 2, 0.0);
+    v_blurTexCoords[ 9] = v_texCoord + vec2( z * 3, 0.0);
+    v_blurTexCoords[10] = v_texCoord + vec2( z * 4, 0.0);
+    v_blurTexCoords[11] = v_texCoord + vec2( z * 5, 0.0);
+    v_blurTexCoords[12] = v_texCoord + vec2( z * 6, 0.0);
+    v_blurTexCoords[13] = v_texCoord + vec2( z * 7, 0.0);
 }

examples/Demo/data/pp_rast_fs.glsl

@@ -24,4 +24,5 @@ void main()
     gl_FragColor += texture2D(s_texture, v_blurTexCoords[11])*0.0215963866053;
     gl_FragColor += texture2D(s_texture, v_blurTexCoords[12])*0.00895781211794;
     gl_FragColor += texture2D(s_texture, v_blurTexCoords[13])*0.0044299121055113265;
+    gl_FragColor = vec4(1,1,1,1) * gl_FragColor.a;
 }

examples/Demo/data/pp_vblur_vs.glsl

@@ -1,26 +1,31 @@
 /* VBlurVertexShader.glsl */
-attribute vec4 a_position;
-attribute vec2 a_texCoord;
+attribute vec3 position;
+attribute vec4 color;
+attribute vec2 uv;
  
+uniform mediump float step;
+
 varying vec2 v_texCoord;
 varying vec2 v_blurTexCoords[14];
  
 void main()
 {
-    gl_Position = a_position;
-    v_texCoord = a_texCoord;
-    v_blurTexCoords[ 0] = v_texCoord + vec2(0.0, -0.028);
-    v_blurTexCoords[ 1] = v_texCoord + vec2(0.0, -0.024);
-    v_blurTexCoords[ 2] = v_texCoord + vec2(0.0, -0.020);
-    v_blurTexCoords[ 3] = v_texCoord + vec2(0.0, -0.016);
-    v_blurTexCoords[ 4] = v_texCoord + vec2(0.0, -0.012);
-    v_blurTexCoords[ 5] = v_texCoord + vec2(0.0, -0.008);
-    v_blurTexCoords[ 6] = v_texCoord + vec2(0.0, -0.004);
-    v_blurTexCoords[ 7] = v_texCoord + vec2(0.0,  0.004);
-    v_blurTexCoords[ 8] = v_texCoord + vec2(0.0,  0.008);
-    v_blurTexCoords[ 9] = v_texCoord + vec2(0.0,  0.012);
-    v_blurTexCoords[10] = v_texCoord + vec2(0.0,  0.016);
-    v_blurTexCoords[11] = v_texCoord + vec2(0.0,  0.020);
-    v_blurTexCoords[12] = v_texCoord + vec2(0.0,  0.024);
-    v_blurTexCoords[13] = v_texCoord + vec2(0.0,  0.028);
+    gl_Position = vec4(position.xy, 0, 1.0);
+    float z = step;
+
+    v_texCoord = uv;
+    v_blurTexCoords[ 0] = v_texCoord + vec2(0.0, -z * 7);
+    v_blurTexCoords[ 1] = v_texCoord + vec2(0.0, -z * 6);
+    v_blurTexCoords[ 2] = v_texCoord + vec2(0.0, -z * 5);
+    v_blurTexCoords[ 3] = v_texCoord + vec2(0.0, -z * 4);
+    v_blurTexCoords[ 4] = v_texCoord + vec2(0.0, -z * 3);
+    v_blurTexCoords[ 5] = v_texCoord + vec2(0.0, -z * 2);
+    v_blurTexCoords[ 6] = v_texCoord + vec2(0.0, -z);
+    v_blurTexCoords[ 7] = v_texCoord + vec2(0.0,  z    );
+    v_blurTexCoords[ 8] = v_texCoord + vec2(0.0,  z * 2);
+    v_blurTexCoords[ 9] = v_texCoord + vec2(0.0,  z * 3);
+    v_blurTexCoords[10] = v_texCoord + vec2(0.0,  z * 4);
+    v_blurTexCoords[11] = v_texCoord + vec2(0.0,  z * 5);
+    v_blurTexCoords[12] = v_texCoord + vec2(0.0,  z * 6);
+    v_blurTexCoords[13] = v_texCoord + vec2(0.0,  z * 7);
 }

examples/Demo/src/TestTweenGlow.h

@@ -1,6 +1,6 @@
 #pragma once
 #include "test.h"
-#include "TweenGlow.h"
+#include "TweenAlphaFade.h"
 #undef OUT
 
 
@@ -11,36 +11,27 @@ public:
     TestTweenGlow()
     {
         spSprite sprite = new Sprite;
-        //Vector2 pos(0, 0);
-        //sprite->setPosition(pos);
         sprite->setResAnim(resources.getResAnim("t2p"));
         sprite->attachTo(content);
-        //float scale = 1.0f / getStage()->getScaleX();
-        //sprite->setScale(scale);
-        //Vector2 displaySpriteSize = sprite->getSize() * scale;
-        //sprite->setPosition((content->getSize() - displaySpriteSize) / 2.0f);
-        //*/
 
-        sprite->setPosition(100.8f, 100.5f);
-        sprite->setScale(1.5f);
-        sprite->addEventListener(TouchEvent::CLICK,
-                                 CLOSURE(this, &TestTweenGlow::onClick));
+        sprite->setPosition(getStage()->getSize() / 2);
 
-        spSprite child = new Sprite;
-        child->attachTo(sprite);
-        child->setScale(1.0f / 1.5f);
-        child->setResAnim(resources.getResAnim("t2p"));
+        spSprite anim = new Sprite;
+        anim->attachTo(sprite);
+        anim->addTween(Actor::TweenScale(6), 4000, -1, true);
+        anim->setPosition(sprite->getSize() / 2);
+        anim->setAnchor(0.5f, 0.5f);
+        anim->setScale(10);
+        anim->setResAnim(resources.getResAnim("anim"));
+        anim->addTween(TweenAnim(resources.getResAnim("anim")), 1500, -1);
 
+        sprite->addTween(Actor::TweenRotationDegrees(360), 10000, -1);
+        sprite->setAnchor(0.5f, 0.5f);
 
-        sprite->addTween(Actor::TweenX(-130), 10000, -1, true);
+        sprite->addTween(TweenGlow(), 55000, 1, true);
         _test = sprite;
     }
 
-    void onClick(Event*)
-    {
-        _test->addTween(TweenAlphaFade(false), 5500, 1, true);
-    }
-
     void clicked(string id)
     {
         //   _test->addTween(TweenFade(), 1500);

examples/Demo/src/TestUserShader2.h

@@ -41,8 +41,7 @@ public:
 
         //link into 1 shader program
         unsigned int pr = ShaderProgramGL::createProgram(vs, ps, static_cast<const VertexDeclarationGL*>(IVideoDriver::instance->getVertexDeclaration(vertexPCT2T2::FORMAT)));
-        _lightShader = new ShaderProgramGL();
-        _lightShader->init(pr);
+        _lightShader = new ShaderProgramGL(pr);
 
         //set shader and apply samplers uniforms
         driver->setShaderProgram(_lightShader);

examples/Demo/src/example.cpp

@@ -26,6 +26,7 @@
 #include "TestTouches.h"
 #include "TestColorFont.h"
 #include "TestTweenAlphaFade.h"
+#include "TestTweenGlow.h"
 
 #ifdef __S3E__
 #include "s3eKeyboard.h"
@@ -81,6 +82,7 @@ public:
         addButton("openbrowser", "Open Browser");
         addButton("http", "Http requests");
         addButton("tweenfade", "Tween Alpha Fade");
+        addButton("tweenglow", "Tween Glow");
 
         _color = Color::Red;
         _txtColor = Color::White;
@@ -131,6 +133,7 @@ public:
         if (id == "tweenshine") showTest(new TestTweenShine);
         if (id == "multicolorfont") showTest(new TestColorFont);
         if (id == "tweenfade") showTest(new TestTweenAlphaFade);
+        if (id == "tweenglow") showTest(new TestTweenGlow);
         if (id == "openbrowser")
         {
             core::execute("http://oxygine.org/");

oxygine/src/TweenAlphaFade.cpp

@@ -1,23 +1,171 @@
 #include "TweenAlphaFade.h"
 #include "core/file.h"
+#include "core/gl/ShaderProgramGL.h"
+#include "core/gl/oxgl.h"
+#include "core/gl/VertexDeclarationGL.h"
+#include "core/gl/NativeTextureGLES.h"
 
 namespace oxygine
 {
     ShaderProgram* TweenGlow::shaderBlurV = 0;
     ShaderProgram* TweenGlow::shaderBlurH = 0;
+    ShaderProgram* TweenGlow::shaderBlit = 0;
 
 
     void TweenGlow::render2texture()
     {
+        TweenPostProcess::render2texture();
+        const VertexDeclarationGL* decl = static_cast<const VertexDeclarationGL*>(IVideoDriver::instance->getVertexDeclaration(vertexPCT2::FORMAT));
+
         if (!shaderBlurH)
         {
             file::buffer vs_h;
             file::buffer vs_v;
-            file::buffer fs;
+            file::buffer fs_blur;
             file::read("pp_hblur_vs.glsl", vs_h);
             file::read("pp_vblur_vs.glsl", vs_v);
-            file::read("pp_rast_vs.glsl", fs);
+            file::read("pp_rast_fs.glsl", fs_blur);
+
+            vs_h.push_back(0);
+            vs_v.push_back(0);
+            fs_blur.push_back(0);
+
+
+            unsigned int h = ShaderProgramGL::createShader(GL_VERTEX_SHADER, (const char*)&vs_h.front(), "", "");
+            unsigned int v = ShaderProgramGL::createShader(GL_VERTEX_SHADER, (const char*)&vs_v.front(), "", "");
+            unsigned int ps = ShaderProgramGL::createShader(GL_FRAGMENT_SHADER, (const char*)&fs_blur.front(), "", "");
+
+
+            shaderBlurV = new ShaderProgramGL(ShaderProgramGL::createProgram(v, ps, decl));
+            shaderBlurH = new ShaderProgramGL(ShaderProgramGL::createProgram(h, ps, decl));
+
+
 
+            file::buffer vs_blit;
+            file::buffer fs_blit;
+            file::read("pp_blit_vs.glsl", vs_blit);
+            file::read("pp_blit_fs.glsl", fs_blit);
+
+            vs_blit.push_back(0);
+            fs_blit.push_back(0);
+
+
+            unsigned int vs = ShaderProgramGL::createShader(GL_VERTEX_SHADER, (const char*)&vs_blit.front(), "", "");
+            unsigned int fs = ShaderProgramGL::createShader(GL_FRAGMENT_SHADER, (const char*)&fs_blit.front(), "", "");
+
+            shaderBlit = new ShaderProgramGL(ShaderProgramGL::createProgram(vs, fs, decl));
         }
+
+
+        GLint prevFBO = 0;
+        glGetIntegerv(GL_FRAMEBUFFER_BINDING, &prevFBO);
+
+        Rect vp = _screen;
+        vp.pos = Point(0, 0);
+
+        vertexPCT2 v[4];
+
+
+
+        int w = _screen.size.x;
+        int h = _screen.size.y;
+
+        IVideoDriver* driver = IVideoDriver::instance;
+
+        driver->setState(IVideoDriver::STATE_BLEND, 0);
+
+        oxglBindFramebuffer(GL_FRAMEBUFFER, safeCast<NativeTextureGLES*>(_rt2.get())->getFboID());
+        driver->setViewport(Rect(0, 0, w / 2, h / 2));
+        driver->setShaderProgram(shaderBlit);
+        driver->setUniformInt("s_texture", 0);
+        driver->setTexture(0, _rt);
+
+
+        fillQuadT(v,
+                  RectF(0, 0, w / (float)_rt->getWidth(), h / (float)_rt->getHeight()),
+                  RectF(-1, -1, 2, 2),
+                  AffineTransform::getIdentity(), 0);
+
+
+        driver->draw(IVideoDriver::PT_TRIANGLE_STRIP, decl, v, sizeof(v));
+        driver->setTexture(0, 0);
+        w /= 2;
+        h /= 2;
+
+
+        oxglBindFramebuffer(GL_FRAMEBUFFER, safeCast<NativeTextureGLES*>(_rt.get())->getFboID());
+        driver->setViewport(Rect(0, 0, w / 2, h / 2));
+        driver->setShaderProgram(shaderBlit);
+        driver->setUniformInt("s_texture", 0);
+        driver->setTexture(0, _rt2);
+
+
+        fillQuadT(v,
+                  RectF(0, 0, w / (float)_rt2->getWidth(), h / (float)_rt2->getHeight()),
+                  RectF(-1, -1, 2, 2),
+                  AffineTransform::getIdentity(), 0);
+
+
+        driver->draw(IVideoDriver::PT_TRIANGLE_STRIP, decl, v, sizeof(v));
+        driver->setTexture(0, 0);
+        w /= 2;
+        h /= 2;
+
+
+
+
+        oxglBindFramebuffer(GL_FRAMEBUFFER, safeCast<NativeTextureGLES*>(_rt2.get())->getFboID());
+
+        driver->setViewport(Rect(0, 0, w, h));
+        driver->clear(0);
+        driver->setShaderProgram(shaderBlurH);
+        driver->setUniform("step", 1.0f / _rt->getWidth());
+        driver->setUniformInt("s_texture", 0);
+        driver->setTexture(0, _rt);
+
+
+
+        fillQuadT(v,
+                  RectF(0, 0, w / (float)_rt->getWidth(), h / (float)_rt->getHeight()),
+                  RectF(-1, -1, 2, 2),
+                  AffineTransform::getIdentity(), 0);
+
+
+        driver->draw(IVideoDriver::PT_TRIANGLE_STRIP, decl, v, sizeof(v));
+        driver->setTexture(0, 0);
+
+
+
+        oxglBindFramebuffer(GL_FRAMEBUFFER, safeCast<NativeTextureGLES*>(_rt.get())->getFboID());
+
+
+        driver->setViewport(Rect(0, 0, w, h));
+        driver->clear(Color::Red);
+
+        driver->setShaderProgram(shaderBlurV);
+        driver->setUniform("step", 1.0f / _rt2->getHeight());
+        driver->setUniformInt("s_texture", 0);
+        driver->setTexture(0, _rt2);
+
+        fillQuadT(v,
+                  RectF(0, 0, w / (float)_rt2->getWidth(), h / (float)_rt2->getHeight()),
+                  RectF(-1, -1, 2, 2),
+                  AffineTransform::getIdentity(), 0);
+
+
+        driver->draw(IVideoDriver::PT_TRIANGLE_STRIP, decl, v, sizeof(v));
+        driver->setTexture(0, 0);
+
+
+
+
+        oxglBindFramebuffer(GL_FRAMEBUFFER, prevFBO);
+    }
+
+    void TweenGlow::rtCreated()
+    {
+        TweenPostProcess::rtCreated();
+        _rt2 = IVideoDriver::instance->createTexture();
+        _rt2->init(_rt->getWidth() / 2, _rt->getHeight() / 2, TF_R8G8B8A8, true);
     }
 }

oxygine/src/TweenAlphaFade.h

@@ -50,6 +50,7 @@ namespace oxygine
 
             screen = actor.computeBounds(actor.computeGlobalTransform()).cast<Rect>();
             screen.size += Point(1, 1);
+            screen.expand(Point(18, 18), Point(18, 18));
             screen.clip(display);
 
             return screen.cast<Rect>();
@@ -93,21 +94,31 @@ namespace oxygine
             Actor& actor = *_actor;
             _screen = getScreenRect(actor);
 
+            bool c = false;
             if (!_rt)
             {
                 _rt = IVideoDriver::instance->createTexture();
                 _rt->init(_screen.getWidth(), _screen.getHeight(), TF_R8G8B8A8, true);
-                _rt->reg(CLOSURE(this, &TweenPostProcess::restore), 0);
+                c = true;
             }
 
             if (_rt->getWidth() < _screen.getWidth() || _rt->getHeight() < _screen.getHeight())
             {
                 _rt->init(_screen.getWidth(), _screen.getHeight(), TF_R8G8B8A8, true);
-                _rt->reg(CLOSURE(this, &TweenPostProcess::restore), 0);
+                c = true;
             }
+
+            if (c)
+                rtCreated();
+
             return true;
         }
 
+        virtual void rtCreated()
+        {
+            _rt->reg(CLOSURE(this, &TweenPostProcess::restore), 0);
+        }
+
         virtual void render2texture()
         {
             if (!begin())
@@ -194,12 +205,48 @@ namespace oxygine
         }
     };
 
-    class TweenGlow : public TweenAlphaFade
+    class TweenGlow : public TweenPostProcess
     {
     public:
         static ShaderProgram* shaderBlurV;
         static ShaderProgram* shaderBlurH;
+        static ShaderProgram* shaderBlit;
+
+        spNativeTexture _rt2;
+
+        TweenGlow(): TweenPostProcess(0) {}
 
         void render2texture() OVERRIDE;
+        void rtCreated() OVERRIDE;
+
+
+        void render(Actor* actor, const RenderState& rs)
+        {
+            STDMaterial* mat = STDMaterial::instance;
+            STDRenderer* renderer = mat->getRenderer();
+
+            RectF src(0, 0,
+                      _screen.getWidth() / (float)_rt->getWidth() / 4,
+                      _screen.getHeight() / (float)_rt->getHeight() / 4);
+            RectF dest = _screen.cast<RectF>();
+
+            renderer->setBlendMode(blend_premultiplied_alpha);
+            AffineTransform tr;
+            tr.identity();
+            //tr.scale(Vector2(4, 4));
+            renderer->setTransform(tr);
+            renderer->beginElementRendering(true);
+            Color color = Color(Color::White).premultiplied();
+            renderer->drawElement(_rt, color.rgba(), src, dest);
+            renderer->drawBatch();
+
+
+            RenderState r = rs;
+            r.material = mat;
+            actor->setMaterial(_prev);
+            actor->render(r);
+            actor->setMaterial(this);
+
+        }
     };
 }

oxygine/src/core/UberShaderProgram.cpp

@@ -80,10 +80,10 @@ namespace oxygine
 
             int vs = ShaderProgramGL::createShader(GL_VERTEX_SHADER, data, prepend, append);
 
-            ShaderProgramGL* pgl = new ShaderProgramGL;
+
             VideoDriverGLES20* driver = ((VideoDriverGLES20*)IVideoDriver::instance);
             const VertexDeclarationGL* decl = driver->getVertexDeclaration(bformat);
-            pgl->init(ShaderProgramGL::createProgram(vs, fs, decl));
+            ShaderProgramGL* pgl = new ShaderProgramGL(ShaderProgramGL::createProgram(vs, fs, decl));
 
 
             CHECKGL();

oxygine/src/core/gl/ShaderProgramGL.cpp

@@ -8,7 +8,7 @@
 
 namespace oxygine
 {
-    ShaderProgramGL::ShaderProgramGL(): _program(0)
+    ShaderProgramGL::ShaderProgramGL(GLuint p) : _program(p)
     {
 
     }
@@ -20,12 +20,6 @@ namespace oxygine
         CHECKGL();
     }
 
-
-    void ShaderProgramGL::init(GLuint p)
-    {
-        _program = p;
-    }
-
     unsigned int ShaderProgramGL::getID() const
     {
         return _program;

oxygine/src/core/gl/ShaderProgramGL.h

@@ -7,11 +7,9 @@ namespace oxygine
     class ShaderProgramGL: public ShaderProgram
     {
     public:
-        ShaderProgramGL();
+        ShaderProgramGL(GLuint p);
         ~ShaderProgramGL();
 
-        void init(GLuint p);
-
         unsigned int    getID() const;
         int             getUniformLocation(const char* id) const;
 

oxygine/src/core/gl/oxgl.cpp

@@ -53,8 +53,15 @@ extern "C"
     {}
     GLAPI void APIENTRY def_glCompileShader(GLuint shader)
     {}
+
     GLAPI void APIENTRY def_glBindAttribLocation(GLuint program, GLuint index, const GLchar* name)
     {}
+
+    GLAPI GLint APIENTRY def_glGetAttribLocation(GLuint program, const GLchar* name)
+    {
+        return 0;
+    }
+
     GLAPI void APIENTRY def_glLinkProgram(GLuint program)
     {}
     GLAPI void APIENTRY def_glUniform1i(GLint location, GLint v0)
@@ -133,6 +140,7 @@ extern "C"
     PFNGLATTACHSHADERPROC _glAttachShader = 0;
     PFNGLCOMPILESHADERPROC _glCompileShader = 0;
     PFNGLBINDATTRIBLOCATIONPROC _glBindAttribLocation = 0;
+    PFNGLGETATTRIBLOCATIONPROC _glGetAttribLocation = 0;
     PFNGLLINKPROGRAMPROC _glLinkProgram = 0;
     PFNGLUNIFORM1IPROC _glUniform1i = 0;
     PFNGLUNIFORM2FVPROC _glUniform2fv = 0;
@@ -184,6 +192,7 @@ int initGLExtensions(myGetProcAdress func)
     GETFUNC(_glAttachShader, def_glAttachShader, PFNGLATTACHSHADERPROC, "glAttachShader");
     GETFUNC(_glCompileShader, def_glCompileShader, PFNGLCOMPILESHADERPROC, "glCompileShader");
     GETFUNC(_glBindAttribLocation, def_glBindAttribLocation, PFNGLBINDATTRIBLOCATIONPROC, "glBindAttribLocation");
+    GETFUNC(_glGetAttribLocation, def_glGetAttribLocation, PFNGLGETATTRIBLOCATIONPROC, "glGetAttribLocation");
     GETFUNC(_glLinkProgram, def_glLinkProgram, PFNGLLINKPROGRAMPROC, "glLinkProgram");
     GETFUNC(_glUniform1i, def_glUniform1i, PFNGLUNIFORM1IPROC, "glUniform1i");
     GETFUNC(_glUniform2fv, def_glUniform2fv, PFNGLUNIFORM2FVPROC, "glUniform2fv");

oxygine/src/core/gl/oxgl.h

@@ -39,6 +39,7 @@ extern "C"
     extern PFNGLATTACHSHADERPROC _glAttachShader;
     extern PFNGLCOMPILESHADERPROC _glCompileShader;
     extern PFNGLBINDATTRIBLOCATIONPROC _glBindAttribLocation;
+    extern PFNGLGETATTRIBLOCATIONPROC _glGetAttribLocation;
     extern PFNGLLINKPROGRAMPROC _glLinkProgram;
     extern PFNGLUNIFORM1IPROC _glUniform1i;
     extern PFNGLUNIFORM2FVPROC _glUniform2fv;
@@ -135,6 +136,7 @@ extern "C"
 #define oxglAttachShader DECLARE_GLEXT(glAttachShader)
 #define oxglCompileShader DECLARE_GLEXT(glCompileShader)
 #define oxglBindAttribLocation DECLARE_GLEXT(glBindAttribLocation)
+#define oxglGetAttribLocation DECLARE_GLEXT(glGetAttribLocation)
 #define oxglLinkProgram DECLARE_GLEXT(glLinkProgram)
 #define oxglUniform1i DECLARE_GLEXT(glUniform1i)
 #define oxglUniform2fv DECLARE_GLEXT(glUniform2fv)

oxygine/src/core/vertex.h

@@ -77,13 +77,11 @@ namespace oxygine
         return offset;
     }
 
-    struct vertexP2T2
+    struct vertexPT2
     {
-        float x, y;
+        enum { FORMAT = VERTEX_POSITION | VERTEX_NUM_TEXCOORDS(1) | VERTEX_TEXCOORD_SIZE(0, 2) };
+        float x, y, z;
         float u, v;
-
-        Vector2& getPos() {return *((Vector2*)&x);}
-        Vector2& getUV() {return *((Vector2*)&u);}
     };
 
     struct vertexP2C