refactoring TweenAlphaFade

preparing for TweenGlow

examples/Demo/data/pp_hblur_vs.glsl

@@ -0,0 +1,26 @@
+/* HBlurVertexShader.glsl */
+attribute vec4 a_position;
+attribute vec2 a_texCoord;
+ 
+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);
+}

examples/Demo/data/pp_rast_fs.glsl

@@ -0,0 +1,27 @@
+/* BlurFragmentShader.glsl */
+precision mediump float;
+ 
+uniform sampler2D s_texture;
+ 
+varying vec2 v_texCoord;
+varying vec2 v_blurTexCoords[14];
+ 
+void main()
+{
+    gl_FragColor = vec4(0.0);
+    gl_FragColor += texture2D(s_texture, v_blurTexCoords[ 0])*0.0044299121055113265;
+    gl_FragColor += texture2D(s_texture, v_blurTexCoords[ 1])*0.00895781211794;
+    gl_FragColor += texture2D(s_texture, v_blurTexCoords[ 2])*0.0215963866053;
+    gl_FragColor += texture2D(s_texture, v_blurTexCoords[ 3])*0.0443683338718;
+    gl_FragColor += texture2D(s_texture, v_blurTexCoords[ 4])*0.0776744219933;
+    gl_FragColor += texture2D(s_texture, v_blurTexCoords[ 5])*0.115876621105;
+    gl_FragColor += texture2D(s_texture, v_blurTexCoords[ 6])*0.147308056121;
+    gl_FragColor += texture2D(s_texture, v_texCoord         )*0.159576912161;
+    gl_FragColor += texture2D(s_texture, v_blurTexCoords[ 7])*0.147308056121;
+    gl_FragColor += texture2D(s_texture, v_blurTexCoords[ 8])*0.115876621105;
+    gl_FragColor += texture2D(s_texture, v_blurTexCoords[ 9])*0.0776744219933;
+    gl_FragColor += texture2D(s_texture, v_blurTexCoords[10])*0.0443683338718;
+    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;
+}

examples/Demo/data/pp_vblur_vs.glsl

@@ -0,0 +1,26 @@
+/* VBlurVertexShader.glsl */
+attribute vec4 a_position;
+attribute vec2 a_texCoord;
+ 
+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);
+}

examples/Demo/src/TestTweenAlphaFade.h

@@ -14,26 +14,27 @@ public:
         sprite->setResAnim(resources.getResAnim("t2p"));
         sprite->attachTo(content);
 
-        sprite->setPosition(200.8f, 150);
+        sprite->setPosition(getStage()->getSize() / 2);
         sprite->addEventListener(TouchEvent::CLICK,
                                  CLOSURE(this, &TestTweenAlphaFade::onClick));
 
         spSprite anim = new Sprite;
-        //anim->attachTo(sprite);
-        //anim->setScale(1.0f / 1.5f);
+        anim->attachTo(sprite);
+        anim->addTween(Actor::TweenScale(3), 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);
         _test = sprite;
     }
 
     void onClick(Event*)
     {
-        _test->addTween(TweenAlphaFade(false, 0), 5500, 1, true);
+        _test->addTween(TweenAlphaFade(false), 5500, 1, true);
     }
 
     void clicked(string id)

oxygine/src/Clock.cpp

@@ -24,7 +24,7 @@ namespace oxygine
     Clock::Clock():
         _counter(0), _destTime(0), _srcTime(0),
         _multiplier(1.0f), _fixedStep(0),
-        _lastUpdateTime(-1)
+        _lastUpdateTime(-1), _lastDT(0)
     {
     }
 
@@ -43,6 +43,16 @@ namespace oxygine
         return (int)_fixedStep;
     }
 
+    int Clock::getLastDT() const
+    {
+        return _lastDT;
+    }
+
+    timeMS  Clock::getLastUpdateTime() const
+    {
+        return _lastUpdateTime;
+    }
+
     void Clock::setMultiplier(float m)
     {
         _multiplier = m;
@@ -94,6 +104,7 @@ namespace oxygine
         _destTime += dt;
 
         _lastUpdateTime = time;
+        _lastDT = dt;
 
         //if (_fixedStep > 0)
         //  printf("ticks: %d\n", int((_destTime - _srcTime)/_fixedStep));

oxygine/src/Clock.h

@@ -17,6 +17,8 @@ namespace oxygine
         timeMS  getTime() const;
         int     getPauseCounter() const;
         int     getFixedStep() const;
+        int     getLastDT() const;
+        timeMS  getLastUpdateTime() const;
         float   getMultiplier() const;
 
         void    setFixedStep(float stepMS);
@@ -39,6 +41,7 @@ namespace oxygine
         float   _multiplier;
         float   _fixedStep;
 
+        int    _lastDT;
         timeMS _lastUpdateTime;
     };
 }

oxygine/src/TweenAlphaFade.cpp

@@ -0,0 +1,23 @@
+#include "TweenAlphaFade.h"
+#include "core/file.h"
+
+namespace oxygine
+{
+    ShaderProgram* TweenGlow::shaderBlurV = 0;
+    ShaderProgram* TweenGlow::shaderBlurH = 0;
+
+
+    void TweenGlow::render2texture()
+    {
+        if (!shaderBlurH)
+        {
+            file::buffer vs_h;
+            file::buffer vs_v;
+            file::buffer fs;
+            file::read("pp_hblur_vs.glsl", vs_h);
+            file::read("pp_vblur_vs.glsl", vs_v);
+            file::read("pp_rast_vs.glsl", fs);
+
+        }
+    }
+}

oxygine/src/TweenAlphaFade.h

@@ -3,12 +3,13 @@
 #include "Tween.h"
 #include "STDMaterial.h"
 #include "core/NativeTexture.h"
-
+#include "Actor.h"
+#include "core/oxygine.h"
+#include "RenderState.h"
 
 namespace oxygine
 {
-
-    class TweenAlphaFade: public Material
+    class TweenPostProcess: public Material
     {
     public:
         typedef Actor type;
@@ -16,8 +17,7 @@ namespace oxygine
         Actor* _actor;
         Material* _prev;
         spNativeTexture _rt;
-        unsigned char _a;
-        bool _fadeIn;
+
         Rect _screen;
         enum options
         {
@@ -27,9 +27,9 @@ namespace oxygine
 
         int _options;
 
-        TweenAlphaFade(bool fadeIn, int opt = opt_singleR2T) : _actor(0), _prev(0), _fadeIn(fadeIn), _options(opt) {}
+        TweenPostProcess(int opt) : _actor(0), _prev(0), _options(opt) {}
 
-        ~TweenAlphaFade()
+        ~TweenPostProcess()
         {
             if (_actor)
                 _actor->setMaterial(0);
@@ -39,10 +39,18 @@ namespace oxygine
         }
 
 
-        Rect getScreenRect(Actor& actor)
+        Rect getScreenRect(const Actor& actor) const
         {
-            RectF screen = actor.computeBounds(actor.computeGlobalTransform());
-            screen.size += Vector2(1, 1);
+            Rect screen;
+
+            Rect display(Point(0, 0), core::getDisplaySize());
+
+            if (_options & opt_fullscreen)
+                return display;
+
+            screen = actor.computeBounds(actor.computeGlobalTransform()).cast<Rect>();
+            screen.size += Point(1, 1);
+            screen.clip(display);
 
             return screen.cast<Rect>();
         }
@@ -71,10 +79,10 @@ namespace oxygine
             _actor = 0;
         }
 
-        void render2texture()
+        bool begin()
         {
             if (!STDRenderer::isReady())
-                return;
+                return false;
 
             Material::setCurrent(0);
             IVideoDriver* driver = IVideoDriver::instance;
@@ -83,46 +91,40 @@ namespace oxygine
             Rect display(Point(0, 0), core::getDisplaySize());
 
             Actor& actor = *_actor;
-            Rect screen;
-
-            if (_options & opt_fullscreen)
-            {
-                //driver->getViewport(screen);
-                screen.pos = Point(0, 0);
-                screen.size = core::getDisplaySize();
-            }
-            else
-            {
-                screen = getScreenRect(actor);
-                screen.clip(display);
-            }
-
-            _screen = screen;
+            _screen = getScreenRect(actor);
 
             if (!_rt)
             {
                 _rt = IVideoDriver::instance->createTexture();
-                _rt->init(screen.getWidth(), screen.getHeight(), TF_R8G8B8A8, true);
-                _rt->reg(CLOSURE(this, &TweenAlphaFade::restore), 0);
+                _rt->init(_screen.getWidth(), _screen.getHeight(), TF_R8G8B8A8, true);
+                _rt->reg(CLOSURE(this, &TweenPostProcess::restore), 0);
             }
 
-            if (_rt->getWidth() < screen.getWidth() || _rt->getHeight() < screen.getHeight())
+            if (_rt->getWidth() < _screen.getWidth() || _rt->getHeight() < _screen.getHeight())
             {
-                _rt->init(screen.getWidth(), screen.getHeight(), TF_R8G8B8A8, true);
-                _rt->reg(CLOSURE(this, &TweenAlphaFade::restore), 0);
+                _rt->init(_screen.getWidth(), _screen.getHeight(), TF_R8G8B8A8, true);
+                _rt->reg(CLOSURE(this, &TweenPostProcess::restore), 0);
             }
+            return true;
+        }
 
+        virtual void render2texture()
+        {
+            if (!begin())
+                return;
+
+            IVideoDriver* driver = IVideoDriver::instance;
             driver->setRenderTarget(_rt);
 
-            Rect vp = screen;
+            Rect vp = _screen;
             vp.pos = Point(0, 0);
             driver->setViewport(vp);
             driver->clear(0);
 
 
             RenderState rs;
-            Material* mat = STDMaterial::instance;
-            STDRenderer* renderer = STDMaterial::instance->getRenderer();
+            STDMaterial* mat = STDMaterial::instance;
+            STDRenderer* renderer = mat->getRenderer();
             rs.material = mat;
 
             RectF clip = vp.cast<RectF>();
@@ -131,19 +133,16 @@ namespace oxygine
             renderer->initCoordinateSystem(vp.getWidth(), vp.getHeight(), true);
 
             rs.transform = _actor->getParent()->computeGlobalTransform();
-            if (_options & opt_fullscreen)
-            {
-                mat->render(&actor, rs);
-            }
-            else
+            if (!(_options & opt_fullscreen))
             {
                 AffineTransform offset;
                 offset.identity();
-                offset.translate(-screen.pos);
+                offset.translate(-_screen.pos);
                 rs.transform = rs.transform * offset;
-                mat->render(&actor, rs);
             }
 
+            mat->Material::render(_actor, rs);
+
             mat->finish();
             driver->setRenderTarget(0);
         }
@@ -152,30 +151,38 @@ namespace oxygine
         {
             if (!(_options & opt_singleR2T))
                 render2texture();
-            _a = lerp(_fadeIn ? 0 : 255, _fadeIn ? 255 : 0, p);
         }
 
         void apply(Material* prev)
         {
 
         }
+    };
+
+    class TweenAlphaFade : public TweenPostProcess
+    {
+    public:
+        unsigned char _a;
+        bool _fadeIn;
+
+        TweenAlphaFade(bool fadeIn, int opt = 0) : TweenPostProcess(opt), _fadeIn(fadeIn), _a(0) {}
+
+        void update(Actor& actor, float p, const UpdateState& us)
+        {
+            TweenPostProcess::update(actor, p, us);
+            _a = lerp(_fadeIn ? 0 : 255, _fadeIn ? 255 : 0, p);
+        }
 
         void render(Actor* actor, const RenderState& rs)
         {
             STDMaterial* mat = STDMaterial::instance;
             STDRenderer* renderer = mat->getRenderer();
-            Rect sr = _screen;//getScreenRect(*actor);
-            if (_options & opt_fullscreen)
-            {
-                sr.pos = Point(0, 0);
-                sr.size = core::getDisplaySize();
-            }
+
             RectF src(0, 0,
-                      sr.getWidth()  / (float)_rt->getWidth(),
-                      sr.getHeight() / (float)_rt->getHeight());
-            RectF dest = sr.cast<RectF>();
+                      _screen.getWidth() / (float)_rt->getWidth(),
+                      _screen.getHeight() / (float)_rt->getHeight());
+            RectF dest = _screen.cast<RectF>();
 
-            //renderer->drawBatch();
             renderer->setBlendMode(blend_premultiplied_alpha);
             AffineTransform tr;
             tr.identity();
@@ -186,4 +193,13 @@ namespace oxygine
             renderer->drawBatch();
         }
     };
+
+    class TweenGlow : public TweenAlphaFade
+    {
+    public:
+        static ShaderProgram* shaderBlurV;
+        static ShaderProgram* shaderBlurH;
+
+        void render2texture() OVERRIDE;
+    };
 }