Some changes

assets/SSAA_4X.frag

@@ -0,0 +1,19 @@
+precision mediump float;
+
+uniform sampler2D Texture;
+uniform vec2 samplesOffset[4];
+
+varying vec2 texCoord;
+
+void main() 
+{
+	vec3 color = vec3(0, 0, 0);
+	for (int i = 0; i < 4; ++i)
+	{
+		color += texture2D(Texture, texCoord + samplesOffset[i]).rgb;
+	}
+	color /= 4;
+
+	//gl_FragColor = vec4(texture2D(Texture, texCoord ), 1.0);
+	gl_FragColor = vec4(color, 1.0);
+}

assets/SSAA_4X.vertex

@@ -0,0 +1,11 @@
+attribute vec3 vPosition;
+attribute vec2 vTexCoord;
+varying vec2 texCoord;
+
+uniform mat4 ProjectionMatrix;
+
+void main() 
+{
+	gl_Position = ProjectionMatrix * vec4(vPosition.xyz, 1.0);
+	texCoord = vTexCoord;
+}

assets/brickshader_fragment.txt

@@ -0,0 +1,15 @@
+precision mediump float;
+uniform sampler2D Texture;
+uniform float Transparency;
+uniform vec4 BrickColor;
+varying vec2 texCoord;
+
+void main() 
+{
+	vec4 color = BrickColor * texture2D(Texture,texCoord).rgba;
+
+	gl_FragColor = vec4(color.rgb, color.a * Transparency);
+	
+	
+	
+}

assets/brickshader_vertex.txt

@@ -0,0 +1,12 @@
+attribute vec3 vPosition;
+attribute vec2 vTexCoord;
+varying vec2 texCoord;
+
+uniform mat4 ProjectionMatrix;
+
+void main() 
+{
+	//480x320
+	gl_Position = ProjectionMatrix * vec4(vPosition.xyz, 1.0);
+	texCoord = vTexCoord;
+}

assets/color_fragment.txt

@@ -0,0 +1,7 @@
+precision mediump float;
+varying vec4 color;
+
+void main() 
+{
+	gl_FragColor = color;
+}

assets/color_vertex.txt

@@ -0,0 +1,11 @@
+attribute vec3 vPosition;
+attribute vec4 vColor;
+varying vec4 color;
+
+uniform mat4 ProjectionMatrix;
+
+void main() 
+{
+	gl_Position = ProjectionMatrix * vec4(vPosition.xyz, 1.0);
+	color = vColor;
+}

assets/emoji/emojis.json

@@ -1,249 +0,0 @@
-{
-	"transform version": "V1",
-	
-	"models": [
-	{
-		"type": "EmojiModel",
-		"name": "Smile"
-	}],
-  
-  "renderParams": [
-    {
-      "vertexShader": "./assets/shaders/vertex/orthoVertexShader.txt",
-      "fragmentShader": "./assets/shaders/fragment/orthoFragmentShader.txt",
-      "alphaTest": "true",
-      "blend": "true",
-      "TAG": "smile & tongue 0"
-    }
-  ],
-	
-	"initialModules": [0, 1, 2, 3, 4],
-
-  "modules": [
-    {
-      "iconPath": "./assets/fx/emoji/Asset 3@20x.png",
-      "suits": [
-        {
-          "renderParamsID": 0,
-          "emojiTexture": "./assets/fx/emoji/Asset 3@20x.png"
-        }
-      ]
-    },
-    {
-      "iconPath": "./assets/fx/emoji/Asset 24@20x.png",
-      "suits": [
-        {
-          "renderParamsID": 0,
-          "emojiTexture": "./assets/fx/emoji/Asset 24@20x.png"
-        }
-      ]
-    },
-    {
-      "iconPath": "./assets/fx/emoji/Asset 13@20x.png",
-      "suits": [
-        {
-          "renderParamsID": 0,
-          "emojiTexture": "./assets/fx/emoji/Asset 13@20x.png"
-        }
-      ]
-    },
-    {
-      "iconPath": "./assets/fx/emoji/Asset 23@20x.png",
-      "suits": [
-        {
-          "renderParamsID": 0,
-          "emojiTexture": "./assets/fx/emoji/Asset 23@20x.png"
-        }
-      ]
-    },
-    {
-      "iconPath": "./assets/fx/emoji/Asset 19@20x.png",
-      "suits": [
-        {
-          "renderParamsID": 0,
-          "emojiTexture": "./assets/fx/emoji/Asset 19@20x.png"
-        }
-      ]
-    },
-    {
-      "iconPath": "./assets/fx/emoji/Asset 20@20x.png",
-      "suits": [
-        {
-          "renderParamsID": 0,
-          "emojiTexture": "./assets/fx/emoji/Asset 20@20x.png"
-        }
-      ]
-    },
-    {
-      "iconPath": "./assets/fx/emoji/Asset 17@20x.png",
-      "suits": [
-        {
-          "renderParamsID": 0,
-          "emojiTexture": "./assets/fx/emoji/Asset 17@20x.png"
-        }
-      ]
-    },
-    {
-      "iconPath": "./assets/fx/emoji/Asset 18@20x.png",
-      "suits": [
-        {
-          "renderParamsID": 0,
-          "emojiTexture": "./assets/fx/emoji/Asset 18@20x.png"
-        }
-      ]
-    },
-    {
-      "iconPath": "./assets/fx/emoji/Asset 15@20x.png",
-      "suits": [
-        {
-          "renderParamsID": 0,
-          "emojiTexture": "./assets/fx/emoji/Asset 15@20x.png"
-        }
-      ]
-    },
-    {
-      "iconPath": "./assets/fx/emoji/Asset 16@20x.png",
-      "suits": [
-        {
-          "renderParamsID": 0,
-          "emojiTexture": "./assets/fx/emoji/Asset 16@20x.png"
-        }
-      ]
-    },
-    {
-      "iconPath": "./assets/fx/emoji/Asset 21@20x.png",
-      "suits": [
-        {
-          "renderParamsID": 0,
-          "emojiTexture": "./assets/fx/emoji/Asset 21@20x.png"
-        }
-      ]
-    },
-    {
-      "iconPath": "./assets/fx/emoji/Asset 4@20x.png",
-      "suits": [
-        {
-          "renderParamsID": 0,
-          "emojiTexture": "./assets/fx/emoji/Asset 4@20x.png"
-        }
-      ]
-    },
-    {
-      "iconPath": "./assets/fx/emoji/Asset 22@20x.png",
-      "suits": [
-        {
-          "renderParamsID": 0,
-          "emojiTexture": "./assets/fx/emoji/Asset 22@20x.png"
-        }
-      ]
-    },
-    {
-      "iconPath": "./assets/fx/emoji/Asset 14@20x.png",
-      "suits": [
-        {
-          "renderParamsID": 0,
-          "emojiTexture": "./assets/fx/emoji/Asset 14@20x.png"
-        }
-      ]
-    },
-    {
-      "iconPath": "./assets/fx/emoji/Asset 11@20x.png",
-      "suits": [
-        {
-          "renderParamsID": 0,
-          "emojiTexture": "./assets/fx/emoji/Asset 11@20x.png"
-        }
-      ]
-    },
-    {
-      "iconPath": "./assets/fx/emoji/Asset 25@20x.png",
-      "suits": [
-        {
-          "renderParamsID": 0,
-          "emojiTexture": "./assets/fx/emoji/Asset 25@20x.png"
-        }
-      ]
-    },
-    {
-      "iconPath": "./assets/fx/emoji/Asset 26@20x.png",
-      "suits": [
-        {
-          "renderParamsID": 0,
-          "emojiTexture": "./assets/fx/emoji/Asset 26@20x.png"
-        }
-      ]
-    },
-    {
-      "iconPath": "./assets/fx/emoji/Asset 27@20x.png",
-      "suits": [
-        {
-          "renderParamsID": 0,
-          "emojiTexture": "./assets/fx/emoji/Asset 27@20x.png"
-        }
-      ]
-    },
-    {
-      "iconPath": "./assets/fx/emoji/Asset 28@20x.png",
-      "suits": [
-        {
-          "renderParamsID": 0,
-          "emojiTexture": "./assets/fx/emoji/Asset 28@20x.png"
-        }
-      ]
-    },
-    {
-      "iconPath": "./assets/fx/emoji/Asset 5@20x.png",
-      "suits": [
-        {
-          "renderParamsID": 0,
-          "emojiTexture": "./assets/fx/emoji/Asset 5@20x.png"
-        }
-      ]
-    },
-    {
-      "iconPath": "./assets/fx/emoji/Asset 6@20x.png",
-      "suits": [
-        {
-          "renderParamsID": 0,
-          "emojiTexture": "./assets/fx/emoji/Asset 6@20x.png"
-        }
-      ]
-    },
-    {
-      "iconPath": "./assets/fx/emoji/Asset 7@20x.png",
-      "suits": [
-        {
-          "renderParamsID": 0,
-          "emojiTexture": "./assets/fx/emoji/Asset 7@20x.png"
-        }
-      ]
-    },
-    {
-      "iconPath": "./assets/fx/emoji/Asset 8@20x.png",
-      "suits": [
-        {
-          "renderParamsID": 0,
-          "emojiTexture": "./assets/fx/emoji/Asset 8@20x.png"
-        }
-      ]
-    },
-    {
-      "iconPath": "./assets/fx/emoji/Asset 9@20x.png",
-      "suits": [
-        {
-          "renderParamsID": 0,
-          "emojiTexture": "./assets/fx/emoji/Asset 9@20x.png"
-        }
-      ]
-    },
-    {
-      "iconPath": "./assets/fx/emoji/Asset 10@20x.png",
-      "suits": [
-        {
-          "renderParamsID": 0,
-          "emojiTexture": "./assets/fx/emoji/Asset 10@20x.png"
-        }
-      ]
-    }
-  ]
-}

assets/lines.json

@@ -0,0 +1,7 @@
+{
+    "lines": [
+        {"start": [-500, -500], "end": [500, -500], "color": [0.3, 0.3, 0.0]},
+        {"start": [500, -500], "end": [500, 500], "color": [0.0, 0.3, 0.15]},
+        {"start": [500, 500], "end": [-500, -500], "color": [0.25, 0, 0.4]}
+    ]
+}

assets/parallax_fragment.txt

@@ -0,0 +1,68 @@
+precision mediump float;
+uniform sampler2D Texture;
+uniform sampler2D NormalMap;
+uniform sampler2D HeightMap;
+
+precision highp float;
+
+varying vec2 frag_uv;
+varying vec3 ts_light_pos;
+varying vec3 ts_view_pos;
+varying vec3 ts_frag_pos;
+
+const float num_layers = 16.0;
+
+const float depth_scale = 0.01;
+
+
+
+vec2 parallax_uv(vec2 uv, vec3 view_dir)
+{
+ 
+        float layer_depth = 1.0 / num_layers;
+        float cur_layer_depth = 0.0;
+        vec2 delta_uv = view_dir.xy * depth_scale / (view_dir.z * num_layers);
+        vec2 cur_uv = uv;
+
+        float depth_from_tex = texture2D(HeightMap, cur_uv).r;
+
+        for (int i = 0; i < 32; i++) {
+            cur_layer_depth += layer_depth;
+            cur_uv -= delta_uv;
+            depth_from_tex = texture2D(HeightMap, cur_uv).r;
+            if (depth_from_tex < cur_layer_depth) {
+                break;
+            }
+        }
+
+
+            // Parallax occlusion mapping
+            vec2 prev_uv = cur_uv + delta_uv;
+            float next = depth_from_tex - cur_layer_depth;
+            float prev = texture2D(HeightMap, prev_uv).r - cur_layer_depth
+                         + layer_depth;
+            float weight = next / (next - prev);
+            return mix(cur_uv, prev_uv, weight);
+        
+    
+}
+
+void main(void)
+{
+    vec3 light_dir = normalize(ts_light_pos - ts_frag_pos);
+    vec3 view_dir = normalize(ts_view_pos - ts_frag_pos);
+
+    // Only perturb the texture coordinates if a parallax technique is selected
+    vec2 uv = parallax_uv(frag_uv, view_dir);
+	//vec2 uv = frag_uv;
+
+    vec3 albedo = texture2D(Texture, uv).rgb;
+
+    vec3 ambient = 0.3 * albedo;
+
+    // Normal mapping
+    vec3 norm = normalize(texture2D(NormalMap, uv).rgb * 2.0 - 1.0);
+    float diffuse = max(dot(light_dir, norm), 0.0);
+    gl_FragColor = vec4(diffuse * albedo + ambient, 1.0);
+    
+}

assets/parallax_vertex.txt

@@ -0,0 +1,60 @@
+attribute vec3 vPosition;
+attribute vec2 vTexCoord;
+
+uniform	vec3 eye;
+
+uniform mat4 ModelViewMatrix;
+uniform mat3 NormalMatrix;
+uniform mat4 ProjectionMatrix1;
+uniform mat3 ModelViewMatrix3x3;
+
+varying vec2 frag_uv;
+varying vec3 ts_light_pos; // Tangent space values
+varying vec3 ts_view_pos;  //
+varying vec3 ts_frag_pos;  //
+
+
+mat3 transpose(in mat3 inMatrix)
+{
+    vec3 i0 = inMatrix[0];
+    vec3 i1 = inMatrix[1];
+    vec3 i2 = inMatrix[2];
+
+    mat3 outMatrix = mat3(
+        vec3(i0.x, i1.x, i2.x),
+        vec3(i0.y, i1.y, i2.y),
+        vec3(i0.z, i1.z, i2.z)
+    );
+
+    return outMatrix;
+}
+
+
+void main() 
+{
+	vec3 vert_norm = vec3(0, 1, 0);
+	vec3 vert_tang = vec3(1, 0, 0);
+	vec3 vert_bitang = vec3(0, 0, 1);
+	
+	mat4 mvp = ProjectionMatrix1 * ModelViewMatrix;
+	
+	gl_Position = mvp * vec4(vPosition.xyz, 1.0);
+	
+	ts_frag_pos = vec3(ModelViewMatrix * vec4(vPosition.xyz, 1.0));
+	
+	vec3 t = normalize((NormalMatrix) * vert_tang);
+    vec3 b = normalize((NormalMatrix) * vert_bitang);
+    vec3 n = normalize((NormalMatrix) * vert_norm);
+    mat3 tbn = transpose(mat3(t, b, n));
+	
+	
+    ts_light_pos = tbn * vec3(1,2,0);
+
+    //ts_view_pos = tbn * eye;
+	ts_view_pos = tbn * vec3(0,0,0);
+    ts_frag_pos = tbn * ts_frag_pos;
+
+	
+	frag_uv = vTexCoord;
+	
+}

assets/simple_shading.fragment

@@ -0,0 +1,18 @@
+precision mediump float;
+
+uniform sampler2D Texture;
+uniform float Transparency;
+uniform vec4 LightDirection;
+
+varying vec2 texCoord;
+varying vec3 fragNormal;
+varying vec3 fragColor;
+
+void main() {
+	vec4 color = vec4((fragColor.rgb * texture2D(Texture, texCoord).rgb), 1.0);
+
+	float intensity = clamp(dot(normalize(LightDirection.xyz), -normalize(fragNormal)), 0, 1);
+	
+	gl_FragColor = vec4(color.rgb * intensity + vec3(0.2, 0.2, 0.2), color.a * Transparency);
+	//gl_FragColor = vec4((fragNormal.rgb + vec3(1.0, 1.0, 1.0))*0.5, 1.0);
+}

assets/simple_shading.vertex

@@ -0,0 +1,17 @@
+attribute vec3 vPosition;
+attribute vec3 Normal;
+attribute vec2 vTexCoord;
+attribute vec3 vColor;
+
+uniform mat4 ProjectionMatrix;
+
+varying vec2 texCoord;
+varying vec3 fragNormal;
+varying vec3 fragColor;
+
+void main() {
+	gl_Position = ProjectionMatrix * vec4(vPosition.xyz, 1.0);
+	texCoord = vTexCoord;
+	fragNormal = Normal;
+	fragColor = vColor;
+}

assets/simple_shading_no_tex.fragment

@@ -0,0 +1,16 @@
+precision mediump float;
+
+
+uniform float Transparency;
+uniform vec4 LightDirection;
+
+varying vec3 fragNormal;
+varying vec3 fragColor;
+
+void main() {
+	vec4 color = vec4(fragColor.rgb, 1.0);
+
+	float intensity = clamp(dot(normalize(LightDirection.xyz), -normalize(fragNormal)), 0, 1);
+	
+	gl_FragColor = vec4(color.rgb * intensity + vec3(0.2, 0.2, 0.2), color.a * Transparency);
+}

assets/simple_shading_no_tex.vertex

@@ -0,0 +1,14 @@
+attribute vec3 vPosition;
+attribute vec3 Normal;
+attribute vec3 vColor;
+
+uniform mat4 ProjectionMatrix;
+
+varying vec3 fragNormal;
+varying vec3 fragColor;
+
+void main() {
+	gl_Position = ProjectionMatrix * vec4(vPosition.xyz, 1.0);
+	fragNormal = Normal;
+	fragColor = vColor;
+}

game/creditscode.cpp

@@ -0,0 +1,83 @@
+#include "creditscode.h"
+#include "include/Engine.h"
+
+#include "main_code.h"
+
+const int TGameCredits::CONST_STATE_APPEARING = 0;
+const int TGameCredits::CONST_STATE_APPEARED = 1;
+const int TGameCredits::CONST_STATE_DISAPPEARING = 2;
+const int TGameCredits::CONST_STATE_DISAPPEARED = 3;
+
+const float TGameCredits::CONST_APPEAR_TIME = 150.f;
+
+TGameCredits::TGameCredits()
+    : TGameAreaAncestor()
+    , StateTimer(0)
+    , State(CONST_STATE_DISAPPEARED)
+{
+}
+
+void TGameCredits::Draw()
+{
+	//*SE::Console << "TGameCredits::Draw";
+    float transparency = StateTimer/CONST_APPEAR_TIME;
+
+    
+    RenderUniform1f("Transparency", transparency);
+    
+	glBindTexture(GL_TEXTURE_2D,ResourceManager->TexList["main_menu_bkg_left"]);
+	Renderer->DrawRect(Vector2f(0, 0.f), Vector2f(480.f, 320.f));
+	
+	const Vector2f creditsPos(140.f, 130.f);
+	
+	const Vector2f creditsHalfSize(128.f, 128.f);
+	
+	glBindTexture(GL_TEXTURE_2D,ResourceManager->TexList[CONST_CREDITS_TEXTURE]);
+	Renderer->DrawRect(creditsPos-creditsHalfSize, creditsPos+creditsHalfSize);
+	
+	glBindTexture(GL_TEXTURE_2D,ResourceManager->TexList[CONST_LOGO_SMALL_TEXTURE]);
+	Renderer->DrawRect(Vector2f(240.f-128.f+15.f, 320.f-64.f), Vector2f(240.f+128.f+15.f, 320.f));
+    
+    CheckGlError("Draw TGameCredits");
+}
+
+void TGameCredits::Update(size_t dt)
+{
+    if (State == CONST_STATE_APPEARING)
+	{
+		*SE::Console << "TGameCredits::Update - CONST_STATE_APPEARING";
+        StateTimer += dt;
+        if (StateTimer >= CONST_APPEAR_TIME)
+        {
+            StateTimer = CONST_APPEAR_TIME;
+            State = CONST_STATE_APPEARED;
+        }
+    }
+    else if (State == CONST_STATE_DISAPPEARING)
+	{
+        StateTimer -= dt;
+        if (StateTimer <= 0.f)
+        {
+            StateTimer = 0.f;
+            State = CONST_STATE_DISAPPEARED;
+        }
+    }
+}
+
+void TGameCredits::OnTapDown(Vector2f p)
+{
+	*SE::Console << "TGameCredits::OnTapDown";
+    Application->GoFromCreditsToMenu();
+}
+
+void TGameCredits::StartAppear()
+{
+	*SE::Console << "TGameCredits::StartAppear";
+    State = CONST_STATE_APPEARING;
+}
+
+void TGameCredits::StartDisappear()
+{
+	*SE::Console << "TGameCredits::StartDisappear";
+    State = CONST_STATE_DISAPPEARING;
+}

game/creditscode.h

@@ -0,0 +1,34 @@
+#ifndef CREDITSCODE_H_INCLUDED
+#define CREDITSCODE_H_INCLUDED
+
+#include "game_area_interface.h"
+
+using namespace SE;
+
+
+class TGameCredits : public TGameAreaAncestor
+{
+    static const int CONST_STATE_APPEARING;
+    static const int CONST_STATE_APPEARED;
+    static const int CONST_STATE_DISAPPEARING;
+    static const int CONST_STATE_DISAPPEARED;
+    static const float CONST_APPEAR_TIME;
+
+
+    int State;
+    float StateTimer;
+
+public:
+    
+    TGameCredits();
+    
+    virtual void Draw();
+    virtual void Update(size_t dt);
+    virtual void OnTapDown(Vector2f p);
+    
+    void StartAppear();
+    void StartDisappear();
+};
+
+
+#endif

game/game_area_interface.h

@@ -0,0 +1,25 @@
+#ifndef GAME_AREA_INTERFACE_H_INCLUDED
+#define GAME_AREA_INTERFACE_H_INCLUDED
+
+#include "include/Engine.h"
+
+using namespace SE;
+
+
+class TGameAreaAncestor
+{
+public:
+    virtual void Draw() { }
+    virtual void Update(size_t) { }
+    virtual void OnTapUp(Vector2f) { }
+    virtual void OnTapUpAfterMove(Vector2f) { }
+    
+    virtual void OnTapDown(Vector2f) { }
+    virtual void OnFling(Vector2f) { }
+	virtual void OnScroll(Vector2f) { }
+	
+	virtual ~TGameAreaAncestor() { } //By default destructor is not virtual
+};
+
+
+#endif

game/gamecode.h

@@ -0,0 +1,205 @@
+#ifndef GAMECODE_H_INCLUDED
+#define GAMECODE_H_INCLUDED
+
+#include "include/Engine.h"
+#include "game_area_interface.h"
+
+#include <list>
+
+using namespace SE;
+
+
+const int CONST_BRICKSTATE_VISIBLE = 3;
+const int CONST_BRICKSTATE_DISAPPEAR = 2;
+const int CONST_BRICKSTATE_INVISIBLE = 1;
+const int CONST_BRICKSTATE_APPEAR = 0;
+
+const float CONST_BRICK_DISAPPEAR_TIME = 200.f;
+const float CONST_BRICK_APPEAR_TIME = 200.f;
+
+const int CONST_BRICKMATRIX_WIDTH = 12;
+const int CONST_BRICKMATRIX_HEIGHT = 13;
+const float CONST_BRICK_WIDTH = 37.5f;
+const float CONST_BRICK_HEIGHT = 0.5f*CONST_BRICK_WIDTH;
+const float CONST_BRICK_SHIFT_X = 15.f;
+const float CONST_BRICK_SHIFT_Y = -16.f;
+
+const float CONST_BONUS_APPEAR_TIME = 400.f;
+const float CONST_BONUS_FALL_SPEED = 100.f;
+const float CONST_BONUS_GOTHROUGH_TIME = 8000.f;
+const float CONST_BONUS_CATCH_DISTANCE_X = 65.f;
+const float CONST_BONUS_CATCH_DISTANCE_Y = 20.f;
+
+const float CONST_BONUS_FLOOR_TIME = 8000.f;
+const float CONST_BONUS_FLOOR_APPEAR_SPEED = 50.f;
+
+const int CONST_BONUS_TYPE_MULTIPLIER = 0;
+const int CONST_BONUS_TYPE_GOTHROUGH = 1;
+const int CONST_BONUS_TYPE_FLOOR = 2;
+
+
+class TBrick
+{
+protected:
+    int InitialLocked;
+    int Locked; //0, 1 or 2
+    int State;
+    float StateTimer;
+    Vector4f Color;
+public:
+    TBrick();
+    void SetVisible(Vector4f color, int locked);
+    void SetInvisible();
+    void TryDrawAppear(int ipos, int jpos);
+    void Update(size_t dt);
+    Vector2f GetPosFrom(int ipos, int jpos);
+    Vector4f GetColor();
+    void Appear(Vector4f color, int locked);
+    void Appear();
+    void Hit();
+    void Disappear();
+    int GetLocked();
+    bool CanReact();
+};
+
+class TBonusFalling
+{
+protected:
+   float Lifetime;
+   Vector2f Pos;
+   std::string TexName;
+   int BonusType; //0 - multiplier,  1 - Go-through, 2 - floor
+public:
+    TBonusFalling(Vector2f pos);
+    Vector2f GetPos();
+    int GetType();
+    void Draw();
+    void Update(size_t dt);           
+};
+
+struct TBall
+{
+    Vector2f Pos;
+    Vector2f Velocity;
+    Vector4f Color;
+    std::list<Vector2f> TalePos;
+    
+    Vector2f BallInBlock;
+    Vector2f PrevBallInBlock;
+    
+    TBall(Vector2f pos, Vector2f velocity, Vector4f color);
+    Vector2f GetPos();
+    Vector2f GetVelocityVector();
+    
+    void Go();
+    
+    void ReflectToLeft();
+    void ReflectToRight();
+    void ReflectToUp();
+    void ReflectToDown();
+    
+    void TryReflectOnReflector(Vector2f refPos);
+   
+    void Update(size_t dt);    
+};
+
+typedef std::pair<Vector4f, std::string> PairColorTexture;
+
+struct TBlockInstansingList
+{
+    //color-texture  ---> and list of triangles for this color
+    std::list<std::pair<PairColorTexture, TTriangleList>> ColorBlockList;
+};
+
+
+struct TBallInstancingList
+{
+    std::map<int, TTriangleList> BallAndGlowList;
+};
+
+class TGameLevel : public TGameAreaAncestor
+{
+protected:
+    std::string BkgTexture;
+    std::string LevelScreenTexture;
+    std::string LevelFileName;
+    
+    Vector2f ReflectorPos;
+    
+    int LevelState;
+    bool PrevLevelStateIsStandby;
+    float StateTimer;
+    
+    TBrick BlockMatrix[CONST_BRICKMATRIX_WIDTH][CONST_BRICKMATRIX_HEIGHT];
+    TBlockInstansingList BlockInstansingList;
+    
+    bool TapInBackBtnArea(const Vector2f& pos);
+    
+    void ReloadBlockInstansingList();
+    void SetFinished();
+    void SetFinishFreeze();
+    
+    void DrawBuffer();
+    void DrawPauseButtons();
+    
+    void DrawBallInstancingList();
+ 
+    bool RenderBufferReady;
+    
+    float OutScale;
+    
+    float OutScaleVelocity;
+    
+    void TryGoToMenu();
+    
+    std::list<TBonusFalling> BonusFallingList;
+    
+    std::list<TBall> BallList;
+    
+    TBallInstancingList BallInstancingList;
+    
+    Vector4f BallColor;
+    
+    void ReloadBallInstancingList();
+    void RefreshBallInstancingList();
+    
+    
+    void UpdateBallList(size_t dt);
+    void MultiplyBalls(Vector2f pos, Vector2f velocity);
+    
+    Vector2f GetBlock(const Vector2f& pos);
+    void InitLevel();
+    
+    float BonusGothroughTimer;
+    float BonusFloorTimer;
+    float BonusFloorPosY;
+    
+    Vector4f ParseColor(const std::string& s);
+    void ReloadLevel();
+    
+public:
+    TGameLevel();
+    ~TGameLevel();
+    
+    void FillWithFile(const std::string& filename);
+    
+    void SetStandBy();
+    void SetLoading(const std::string& bkg, const std::string& levelscreen);
+    bool IsLoaded();
+    
+	virtual void Draw();
+	
+	void SetPause();
+	bool IsPaused();
+	void ReleasePause();
+	
+	virtual void Update(size_t dt);
+	virtual void OnTapDown(Vector2f pos);
+	virtual void OnTapUp(Vector2f pos);
+	virtual void OnFling(Vector2f slideSpeed);
+	virtual void OnScroll(Vector2f shift);
+};
+
+
+
+#endif

game/loadingcode.cpp

@@ -0,0 +1,20 @@
+#include "loadingcode.h"
+#include "include/Engine.h"
+#include "main_code.h"
+
+void TGameLoading::Draw()
+{
+	//*SE::Console << "TGameLoading::Draw";
+	
+	glBindTexture(GL_TEXTURE_2D, ResourceManager->TexList[CONST_LOADING_BACKGROUND_BLACK]);
+	Renderer->DrawRect(Vector2f(0.f, 0.f), Vector2f(Renderer->GetMatrixWidth(), Renderer->GetMatrixHeight()));
+
+    glBindTexture(GL_TEXTURE_2D,ResourceManager->TexList[CONST_LOADING_TEXTURE]);
+	Renderer->DrawRect(Vector2f(240.f - 128.f, 10.f), Vector2f(240.f + 128.f, 10.f + 64.f));
+	
+	glBindTexture(GL_TEXTURE_2D,ResourceManager->TexList[CONST_LOGO_SMALL_TEXTURE]);
+	Renderer->DrawRect(Vector2f(480.f - 256.f+50.f, 320.f - 64.f), Vector2f(480.f+50.f, 320.f));
+    
+    CheckGlError();
+
+}

game/loadingcode.h

@@ -0,0 +1,15 @@
+#ifndef LOADINGCODE_H_INCLUDED
+#define LOADINGCODE_H_INCLUDED
+
+#include "game_area_interface.h"
+
+using namespace SE;
+
+class TGameLoading : public TGameAreaAncestor
+{
+public:
+    virtual void Draw();
+};
+
+
+#endif

game/main_code — копия.cpp

@@ -1,592 +0,0 @@
-#include "main_code.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <math.h>
-#include <time.h>
-
-#include "include/Engine.h"
-
-#include "main_code.h"
-
-
-
-
-FaceStruct::FaceStruct()
-{
-}
-
-FaceStruct::FaceStruct(const std::array<cv::Point2f, LANDMARK_POINT_COUNT>& fromPreds)
-{
-	ApplyPreds(fromPreds);
-	
-}
-
-void FaceStruct::CalcFromPreds()
-{
-	float minX = preds[0](0);
-	float maxX = preds[0](0);
-	float minY = preds[0](1);
-	float maxY = preds[0](1);
-	float sumX = preds[0](0);
-	float sumY = preds[0](1);
-
-	for (size_t i = 1; i < LANDMARK_POINT_COUNT; i++)
-	{
-		if (minX > preds[i](0))
-		{
-			minX = preds[i](0);
-		}
-
-		if (minY > preds[i](1))
-		{
-			minY = preds[i](1);
-		}
-
-		if (maxX < preds[i](0))
-		{
-			maxX = preds[i](0);
-		}
-
-		if (maxY < preds[i](1))
-		{
-			maxY = preds[i](1);
-		}
-
-		sumX += preds[i](0);
-		sumY += preds[i](1);
-	}
-
-	float avgX = sumX / static_cast<float>(LANDMARK_POINT_COUNT);
-	float avgY = sumY / static_cast<float>(LANDMARK_POINT_COUNT);
-
-
-
-	center = { avgX, avgY };
-	size = { maxX- minX,maxY - minY };
-
-	//center = { centerXSmoother.responsiveAnalogReadSimple(avgX), centerYSmoother.responsiveAnalogReadSimple(avgY) };
-	//size = { sizeWidthSmoother.responsiveAnalogReadSimple(maxX- minX), sizeHeightSmoother.responsiveAnalogReadSimple(maxY - minY) };
-}
-
-void FaceStruct::ApplyPreds(const std::array<cv::Point2f, LANDMARK_POINT_COUNT>& fromPreds)
-{
-	InnerApplyPreds(fromPreds);
-	CalcFromPreds();
-
-	/*
-	for (size_t i = 0; i < LANDMARK_POINT_COUNT; i++)
-	{
-		preds[i] = preds[i] - center;
-
-	}
-
-
-	historicalPreds.push_back(preds);
-	if (historicalPreds.size() > 4)
-	{
-		historicalPreds.erase(historicalPreds.begin());
-	}
-
-
-	for (size_t i = 0; i < LANDMARK_POINT_COUNT; i++)
-	{
-		preds[i] = { 0.f, 0.f };
-		for (size_t x = 0; x < historicalPreds.size(); x++)
-		{
-			preds[i] += historicalPreds[x][i];
-		}
-
-		preds[i] = preds[i] / static_cast<float>(historicalPreds.size());
-	}
-
-	for (size_t i = 0; i < LANDMARK_POINT_COUNT; i++)
-	{
-		preds[i] = preds[i] + center;
-	}*/
-}
-
-void FaceStruct::InnerApplyPreds(const std::array<cv::Point2f, LANDMARK_POINT_COUNT>& fromPreds)
-{
-	for (size_t i = 0; i < LANDMARK_POINT_COUNT; i++)
-	{
-		preds[i] = { fromPreds[i].x, 720 - fromPreds[i].y};
-		
-	}	
-}
-
-
-
-
-cv::VideoCapture cap;
-
-FaceLandmarkDetector faceLandmarkDetector;
-
-GLuint lastFrameTexture;
-
-
-std::array<FaceLandmarkStruct, MAX_FACE_COUNT> faceLandmarkArr;
-
-cv::Mat frame;
-
-std::vector<cv::Mat> frameArr;
-
-int currentIndex = -1;
-int lastProcessedIndex = 0;
-int lineShift = 0;
-
-int prevPassedIndex = 0;
-
-int indexStep = 0;
-
-std::array<FaceStruct, MAX_FACE_COUNT> faceStruct;
-
-
-const std::string CONST_LOADING_BACKGROUND_BLACK = "loading_background_black";
-
-
-TMyApplication* Application;
-
-
-void TMyApplication::InnerInit()
-{
-
-    Application = this;
-    
-#ifdef TARGET_WIN32
-#ifdef NDEBUG
-	//ST::PathToResources = "resources/";
-	ST::PathToResources = "../../../assets/";
-#else
-	ST::PathToResources = "../../../assets/";
-#endif
-#endif
-    
-#ifdef TARGET_IOS
-    ST::PathToResources = "assets/";
-#endif
-
-    if (Console != NULL)
-    {
-        *Console<<"APP INIT\n";
-    }
-    srand (static_cast<size_t>(time(NULL)));
-
-	ResourceManager->ShaderManager.AddShader("DefaultShader", "shader1vertex.txt", "shader1fragment.txt");
-	ResourceManager->ShaderManager.AddShader("FrameShader", "frameshader_vertex.txt", "frameshader_fragment.txt");
-	Renderer->PushShader("DefaultShader");
-
-	ResourceManager->TexList.AddTexture(CONST_LOADING_BACKGROUND_BLACK + ".png", CONST_LOADING_BACKGROUND_BLACK);
-
-
-	auto texid = ResourceManager->TexList.AddTexture("emoji/Asset 3@20x.png");
-	ResourceManager->TexList.AddTexture("emoji/Asset 4@20x.png");
-	ResourceManager->TexList.AddTexture("emoji/Asset 5@20x.png");
-	ResourceManager->TexList.AddTexture("emoji/Asset 6@20x.png");
-	ResourceManager->TexList.AddTexture("emoji/Asset 7@20x.png");
-	ResourceManager->TexList.AddTexture("emoji/Asset 8@20x.png");
-	ResourceManager->TexList.AddTexture("emoji/Asset 9@20x.png");
-	ResourceManager->TexList.AddTexture("emoji/Asset 10@20x.png");
-	ResourceManager->TexList.AddTexture("emoji/Asset 11@20x.png");
-	ResourceManager->TexList.AddTexture("emoji/Asset 13@20x.png");
-	ResourceManager->TexList.AddTexture("emoji/Asset 14@20x.png");
-	ResourceManager->TexList.AddTexture("emoji/Asset 15@20x.png");
-	ResourceManager->TexList.AddTexture("emoji/Asset 16@20x.png");
-	ResourceManager->TexList.AddTexture("emoji/Asset 17@20x.png");
-	ResourceManager->TexList.AddTexture("emoji/Asset 18@20x.png");
-	ResourceManager->TexList.AddTexture("emoji/Asset 19@20x.png");
-	ResourceManager->TexList.AddTexture("emoji/Asset 20@20x.png");
-	ResourceManager->TexList.AddTexture("emoji/Asset 21@20x.png");
-	ResourceManager->TexList.AddTexture("emoji/Asset 22@20x.png");
-	ResourceManager->TexList.AddTexture("emoji/Asset 23@20x.png");
-	ResourceManager->TexList.AddTexture("emoji/Asset 24@20x.png");
-	ResourceManager->TexList.AddTexture("emoji/Asset 25@20x.png");
-	ResourceManager->TexList.AddTexture("emoji/Asset 26@20x.png");
-	ResourceManager->TexList.AddTexture("emoji/Asset 27@20x.png");
-	ResourceManager->TexList.AddTexture("emoji/Asset 28@20x.png");
-
-
-	ResourceManager->FontManager.AddFont("droid_sans14", "droid_sans14_font_bitmap.png", "droid_sans14_font_charmap.txt");
-	ResourceManager->FontManager.PushFont("droid_sans14");
-
-
-	lastFrameTexture = ResourceManager->TexList.AddEmptyTexture("lastFrameTexture", 1280, 720);
-
-	Renderer->SetOrthoProjection();
-
-	Renderer->SetFullScreenViewport();
-
-
-	for (size_t i = 0; i < MAX_FACE_COUNT; i++)
-	{
-		faceRenderPair[i].first.SamplerMap[CONST_STRING_TEXTURE_UNIFORM] = "Asset "+boost::lexical_cast<std::string>(i+3)+"@20x.png";
-
-		faceRenderPair[i].second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(Vector3f(0, 0, 0));
-		faceRenderPair[i].second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(Vector3f(0, 512, 0));
-		faceRenderPair[i].second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(Vector3f(512, 512, 0));
-		faceRenderPair[i].second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(Vector3f(512, 512, 0));
-		faceRenderPair[i].second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(Vector3f(512, 0, 0));
-		faceRenderPair[i].second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(Vector3f(0, 0, 0));
-
-
-		faceRenderPair[i].second.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].push_back(Vector2f(0, 0));
-		faceRenderPair[i].second.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].push_back(Vector2f(0, 1));
-		faceRenderPair[i].second.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].push_back(Vector2f(1, 1));
-		faceRenderPair[i].second.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].push_back(Vector2f(1, 1));
-		faceRenderPair[i].second.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].push_back(Vector2f(1, 0));
-		faceRenderPair[i].second.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].push_back(Vector2f(0, 0));
-		faceRenderPair[i].second.RefreshBuffer();
-	}
-
-
-	cap = cv::VideoCapture(0);
-	//cap = cv::VideoCapture("video.mp4");
-	//cap = cv::VideoCapture("bp.mp4");
-
-
-	// Check if camera opened successfully
-	if (!cap.isOpened()) {
-		std::cout << "Error opening video stream or file" << std::endl;
-	}
-
-	cap.set(CV_CAP_PROP_FRAME_WIDTH, 1280);
-	cap.set(CV_CAP_PROP_FRAME_HEIGHT, 720);
-
-
-		
-	faceLandmarkDetector.StartTrackProcess();
-
-	Inited = true;
-
-
-
-	
-}
-
-void TMyApplication::InnerDeinit()
-{
-
-	faceLandmarkDetector.StopTrackProcess();
-	cap.release();
-
-    Inited = false;
-    
-    if (Console != NULL)
-    {
-        *Console<<"APP DEINIT\n";
-    }
-
-
-}
-
-void TMyApplication::InnerOnTapDown(Vector2f p)
-{
-
-}
-
-void TMyApplication::InnerOnTapUp(Vector2f p)
-{
-
-}
-
-void TMyApplication::InnerOnTapUpAfterMove(Vector2f p)
-{
-
-}
-
-void TMyApplication::InnerOnMove(Vector2f p, Vector2f shift)
-{
-
-}
-	
-void TMyApplication::OnFling(Vector2f v) 
-{
-}
-
-
-	
-void TMyApplication::InnerDraw()
-{
-	glDisable(GL_DEPTH_TEST);
-
-
-
-	//glBindTexture(GL_TEXTURE_2D, ResourceManager->TexList[CONST_LOADING_BACKGROUND_BLACK]);
-	glBindTexture(GL_TEXTURE_2D, lastFrameTexture);
-	Renderer->DrawRect(Vector2f(0.f, 0.f), Vector2f(Renderer->GetMatrixWidth(), Renderer->GetMatrixHeight()));
-
-
-	/*
-	for (size_t i = 0; i < MAX_FACE_COUNT; i++)
-	{
-		TRenderParamsSetter params(faceRenderPair[i].first);
-		Renderer->DrawTriangleList(faceRenderPair[i].second);
-	}*/
-	
-
-
-
-}
-
-
-void TMyApplication::InnerUpdate(size_t dt)
-{
-	
-	
-	/*cap >> lastFrame;
-
-	if (lastFrame.empty())
-	{
-		return;
-	}
-
-	
-	faceLandmarkTracker.HandleOneFrame(lastFrame, localInputStructArr, localFaceShift, localOutputStructArr);
-
-
-
-	high_resolution_clock::time_point t2 = high_resolution_clock::now();
-
-	auto duration = duration_cast<microseconds>(t2 - FaceLandmarkTracker::lastTimePoint).count();
-
-	FaceLandmarkTracker::lastTimePoint = t2;
-
-	std::stringstream ofs;
-
-	ofs << round(1000000.0 / duration);
-
-
-	for (size_t index = 0; index < CONST_FACE_COUNT; index++)
-	{
-		if (localOutputStructArr[index].valid && localInputStructArr[index].valid)
-		{
-			cv::Rect oldFaceRect = localOutputStructArr[index].face;
-			cv::Rect newFaceRect = localInputStructArr[index].face;
-			cv::Point2f oldCenter(oldFaceRect.x + oldFaceRect.width*0.5f, oldFaceRect.y + oldFaceRect.height*0.5f);
-			cv::Point2f newCenter(newFaceRect.x + newFaceRect.width*0.5f, newFaceRect.y + newFaceRect.height*0.5f);
-
-			localFaceShift[index] = newCenter - oldCenter;
-		}
-		else
-		{
-			localFaceShift[index] = cv::Point2f(0, 0);
-		}
-	}
-
-	for (size_t index = 0; index < CONST_FACE_COUNT; index++)
-	{
-		if (localOutputStructArr[index].valid)
-		{
-
-			
-			faceStruct[index].ApplyPreds(localOutputStructArr[index].preds);
-
-
-			for (size_t i = 0; i < CONST_PREDS_COUNT; i++)
-			{
-				//cv::ellipse(lastFrame, cv::Point2f(faceStruct[index].preds[i](0), 720 - faceStruct[index].preds[i](1)) + localFaceShift[index], cv::Size(2, 2), 0, 0, 360, cv::Scalar(255, 128, 128), 4, 8, 0);
-			}
-
-
-			Vector2f posFrom = faceStruct[index].center - faceStruct[index].size*0.5f* 1.25f;
-			Vector2f posTo = faceStruct[index].center + faceStruct[index].size*0.5f* 1.25f;
-
-			ApplyVertexCoordVec(faceRenderPair[index].second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB], posFrom, posTo, 0);
-
-			faceRenderPair[index].second.RefreshBuffer();
-
-		}
-		else
-		{
-			ApplyVertexCoordVec(faceRenderPair[index].second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB], {0,0}, { 0,0 }, 0);
-
-			faceRenderPair[index].second.RefreshBuffer();
-
-		}
-
-	}
-
-	
-
-	for (size_t index = 0; index < CONST_FACE_COUNT; index++)
-	{
-		if (localInputStructArr[index].valid)
-		{
-			//cv::rectangle(lastFrame, localInputStructArr[index].face, cv::Scalar(255, 0, 255), 4, 8, 0);
-		}
-	}
-	
-	*/
-
-
-
-	cap >> frame; // get a new frame from camera/video or read image
-
-	if (frame.empty())
-	{
-		return;
-	}
-
-	cv::Mat image = frame.clone();
-
-	frameArr.push_back(image);
-
-	while (frameArr.size() > 40)
-	{
-		lineShift++;
-		frameArr.erase(frameArr.begin());
-	}
-
-	currentIndex++;
-
-	faceLandmarkArr = faceLandmarkDetector.GetFaceLandmarks(frame, currentIndex);
-
-
-	bool newProcessedIndexFound = false;
-	int newProcessedIndex;
-
-	for (size_t i = 0; i < faceLandmarkArr.size(); i++)
-	{
-		if (faceLandmarkArr[i].valid)
-		{
-			if (!newProcessedIndexFound)
-			{
-				newProcessedIndexFound = true;
-				newProcessedIndex = faceLandmarkArr[i].frameIndex;
-			}
-			else
-			{
-				if (newProcessedIndex < faceLandmarkArr[i].frameIndex)
-				{
-					newProcessedIndex = faceLandmarkArr[i].frameIndex;
-				}
-			}
-		}
-	}
-
-
-	if (newProcessedIndexFound && newProcessedIndex > lastProcessedIndex)
-	{
-		indexStep = 0;
-
-		lastProcessedIndex = newProcessedIndex;
-		prevPassedIndex = currentIndex;
-
-	}
-	else
-	{
-		if (prevPassedIndex > lastProcessedIndex + indexStep)
-		{
-			indexStep++;
-		}
-	}
-
-	//std::cout << currentIndex << " " << lastProcessedIndex << " stepped:" << lastProcessedIndex + indexStep << " indexStep: " << indexStep << std::endl;
-
-
-	cv::Mat renderImage;
-
-	if (lastProcessedIndex + indexStep - lineShift < 0)
-	{
-		renderImage = frameArr[0];
-	}
-	else if (lastProcessedIndex + indexStep - lineShift >= frameArr.size())
-	{
-		renderImage = frameArr[frameArr.size() - 1];
-	}
-	else
-	{
-		renderImage = frameArr[lastProcessedIndex + indexStep - lineShift];
-	}
-
-	renderImage = renderImage.clone();
-
-
-
-
-	
-	cv::Rect frameRect(cv::Point(), renderImage.size());
-
-	for (size_t i = 0; i < faceLandmarkArr.size(); i++)
-	{
-		if (faceLandmarkArr[i].valid)
-		{
-			cv::rectangle(renderImage, faceLandmarkArr[i].faceRect, cv::Scalar(0, 0, 255), 1, 4, 0);
-
-			for (size_t j = 0; j < faceLandmarkArr[i].landmarkArr.size(); j++)
-			{
-
-				//cv::circle(renderImage, faceLandmarkArr[i].landmarkArr[j], 0.1, cv::Scalar(0, 255, 255), 4, 8, 0);
-
-			}
-
-		}
-	}
-
-	for (size_t index = 0; index < faceLandmarkArr.size(); index++)
-	{
-		if (faceLandmarkArr[index].valid)
-		{
-
-
-			faceStruct[index].ApplyPreds(faceLandmarkArr[index].landmarkArr);
-
-			
-			for (size_t i = 0; i < LANDMARK_POINT_COUNT; i++)
-			{
-				cv::ellipse(renderImage, cv::Point2f(faceStruct[index].preds[i](0), 720 - faceStruct[index].preds[i](1)), cv::Size(2, 2), 0, 0, 360, cv::Scalar(255, 128, 128), 4, 8, 0);
-			}
-
-
-			Vector2f posFrom = faceStruct[index].center - faceStruct[index].size*0.5f* 1.35f;
-			Vector2f posTo = faceStruct[index].center + faceStruct[index].size*0.5f* 1.35f;
-
-			ApplyVertexCoordVec(faceRenderPair[index].second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB], posFrom, posTo, 0);
-
-			faceRenderPair[index].second.RefreshBuffer();
-
-		}
-		else
-		{
-			ApplyVertexCoordVec(faceRenderPair[index].second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB], { 0,0 }, { 0,0 }, 0);
-
-			faceRenderPair[index].second.RefreshBuffer();
-
-		}
-
-	}
-
-
-	glBindTexture(GL_TEXTURE_2D, lastFrameTexture);
-
-	static std::array<char, 1280 * 720 * 3> buffer;
-
-	int step = renderImage.step;
-	int height = renderImage.rows;
-	int width = renderImage.cols;
-	int channels = 3;
-	char * data = (char *)renderImage.data;
-	for (int i = 0; i < height; i++)
-	{
-		int ci = height - i - 1;
-		memcpy(&buffer[i*width*channels], &(data[ci*step]), width*channels);
-	}
-
-
-	glTexImage2D(
-		GL_TEXTURE_2D,
-		0,
-		GL_RGB,
-		1280,
-		720,
-		0,
-		GL_BGR_EXT,
-		GL_UNSIGNED_BYTE,
-		&buffer[0]);
-}
-
-
-bool TMyApplication::IsInited()
-{
-    return Inited;
-}

game/main_code.h

@@ -1,107 +1,84 @@
-#ifndef MAIN_CODE_H_INCLUDED
-#define MAIN_CODE_H_INCLUDED
-
-#ifdef TARGET_ANDROID
-#include "android_api.h"
-#endif
-
-#ifdef TARGET_WIN32
-#define NOMINMAX 1
-#include <Windows.h>
-#undef NOMINMAX
-#endif
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <math.h>
-
-#include "boost/shared_ptr.hpp"
-#include "boost/thread/thread.hpp"
-#include "boost/assign.hpp"
-#include "boost/bind.hpp"
-
-#include "include/Engine.h"
-
-#include "boost/signals2.hpp"//Signal must be included after asio
-
-#include "../windows/DoubleHitBalls-win/DoubleHitBalls-win/FaceLandmarkDetector.h"
-#include "../windows/DoubleHitBalls-win/DoubleHitBalls-win/ValueSmoother.h"
-
-
-struct FaceStruct
-{
-	SE::Vector2f center;
-	SE::Vector2f size;
-
-	std::array<SE::Vector2f, LANDMARK_POINT_COUNT> preds;
-
-	std::vector<cv::Point3f> modelPoints;
-	cv::Mat rotationVector;
-	cv::Mat translationVector;
-	cv::Mat rotationMatrix;
-	cv::Mat poseMatrix;
-	cv::Mat eulerAngles;
-
-	std::vector<cv::Point3d> boxModelSrc;
-	std::vector<cv::Point2d> boxModelDst;
-
-	ValueSmoother landmarkSmoothers[2 * LANDMARK_POINT_COUNT];
-	ValueSmoother rotationVectorSmoothers[3];
-	ValueSmoother translationVectorSmoothers[3];
-
-	FaceStruct();
-	FaceStruct(const std::array<cv::Point2f, LANDMARK_POINT_COUNT>& fromPreds, cv::Mat& cameraMatrix, cv::Mat& distortionCoefficients);
-
-	void CalcFromPreds(bool noticeablyChanged, cv::Mat& cameraMatrix, cv::Mat& distortionCoefficients);
-	void ApplyPreds(const std::array<cv::Point2f, LANDMARK_POINT_COUNT>& fromPred, bool noticeablyChanged, cv::Mat& cameraMatrix, cv::Mat& distortionCoefficientss);
-	void InnerApplyPreds(const std::array<cv::Point2f, LANDMARK_POINT_COUNT>& fromPreds);
-};
-
-
-
-using namespace SE;
-
-extern const std::string CONST_LOADING_BACKGROUND_BLACK;
-
-class TMyApplication : public TApplication
-{
-protected:
-
-	bool Inited;
-
-	std::array<TRenderPair, MAX_FACE_COUNT> faceRenderPair;
-
-public:
-
-	TMyApplication() : TApplication(), Inited(false) { }
-
-	virtual void InnerInit();
-
-	virtual void InnerDeinit();
-
-	virtual void InnerDraw();
-
-	virtual void InnerUpdate(size_t dt);
-
-	bool IsInited();
-
-	virtual void InnerOnTapDown(Vector2f p);
-
-	virtual void InnerOnTapUp(Vector2f p);
-
-	virtual void InnerOnTapUpAfterMove(Vector2f p);
-
-	virtual void InnerOnMove(Vector2f p, Vector2f shift);
-
-	virtual void OnFling(Vector2f v);
-
-};
-
-
-extern TMyApplication* Application;
-
-
-
-#endif
-
-
+#ifndef MAIN_CODE_H_INCLUDED
+#define MAIN_CODE_H_INCLUDED
+
+#ifdef TARGET_ANDROID
+#include "android_api.h"
+#endif
+
+#ifdef TARGET_WIN32
+#define NOMINMAX 1
+#include <Windows.h>
+#undef NOMINMAX
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+#include "boost/shared_ptr.hpp"
+#include "boost/thread/thread.hpp"
+#include "boost/assign.hpp"
+#include "boost/bind.hpp"
+
+#include "boost/property_tree/ptree.hpp"
+#include "boost/property_tree/json_parser.hpp"
+
+#include "include/Engine.h"
+
+#include "boost/signals2.hpp"//Signal must be included after asio
+
+using namespace SE;
+
+class TMyApplication : public TApplication
+{
+protected:
+
+	bool Inited;
+
+public:
+	TRenderPair fabricRender;
+	TRenderPair background;
+
+	bool Loaded;
+
+	TMyApplication() : TApplication(), Loaded(false), Inited(false) { }
+
+	virtual void InnerInit();
+
+	virtual void InnerDeinit();
+
+	virtual void InnerDraw();
+
+	virtual void InnerUpdate(size_t dt);
+
+	bool IsLoaded();
+
+	bool IsInited();
+
+
+	virtual void InnerOnTapDown(Vector2f p);
+
+	virtual void InnerOnTapUp(Vector2f p);
+
+	virtual void InnerOnTapUpAfterMove(Vector2f p);
+
+	virtual void InnerOnMove(Vector2f p, Vector2f shift);
+
+	virtual void OnFling(Vector2f v);
+
+	virtual void OnMouseWheel(short int delta);
+
+
+	float distance = 2000;
+
+	float alpha = 0;
+
+	float phi = pi / 6;
+};
+
+
+extern TMyApplication* Application;
+
+
+
+#endif

game/menucode.cpp

@@ -0,0 +1,220 @@
+#include "menucode.h"
+#include "main_code.h"
+
+const float CONST_SPEED_NEG_ACCELERATION_K = 0.03f;
+
+const float CONST_MENU_POS_K = 0.25f;
+
+const float CONST_MENU_WINDOW_DISTANCE = 240.f + 40.f;
+
+const float CONST_SHIFT_ON_SIDE = 0.f;
+
+TGameMenu::TGameMenu()
+	: MenuSpeed(0)
+	, MenuPos(0)
+	, HoldToTap(false)
+	, MenuItemCount(1)
+	, SelectedGame(-1)
+{
+}
+
+
+void TGameMenu::Draw()
+{
+//	*SE::Console << "TGameMenu::Draw";
+    CheckGlError("Draw TGameMenu");
+    RenderUniform1i("sel", 0);
+    RenderUniform1f("Transparency", 1.f);
+    float bkgShift = MenuPos*0.1f - 100.f;
+	glBindTexture(GL_TEXTURE_2D, ResourceManager->TexList["main_menu_bkg_left"]);	
+	Renderer->DrawRect(Vector2f(bkgShift,0.f), Vector2f(480.f+bkgShift,320.f));
+	glBindTexture(GL_TEXTURE_2D, ResourceManager->TexList["main_menu_bkg_right"]);
+	Renderer->DrawRect(Vector2f(480.f+bkgShift,0.f), Vector2f(960.f+bkgShift,320.f));
+
+
+	if (SelectedGame == 0)
+	{
+        RenderUniform1i("sel", 1);
+    }
+    else
+    {
+        RenderUniform1i("sel", 0);
+    }
+    
+    for (int i=0; i<MenuItemCount; i++)
+    {
+        glBindTexture(GL_TEXTURE_2D, ResourceManager->TexList["levelshot"+tostr(i+1)]);
+        Renderer->DrawRect(Vector2f(160.f+MenuPos+CONST_MENU_WINDOW_DISTANCE*i,80.f), Vector2f(160.f+240.f+MenuPos+CONST_MENU_WINDOW_DISTANCE*i, 240.f));
+    }
+    
+    if (MenuItemCount == 12)
+    {
+        glBindTexture(GL_TEXTURE_2D, ResourceManager->TexList["game_end"]);
+        Renderer->DrawRect(Vector2f(160.f+MenuPos+CONST_MENU_WINDOW_DISTANCE*12,160.f - 64.f), Vector2f(160.f+256.f+MenuPos+CONST_MENU_WINDOW_DISTANCE*12, 160.f + 64.f));
+    
+    }
+    
+    
+    
+    glBindTexture(GL_TEXTURE_2D, ResourceManager->TexList["select_level"]);
+    Renderer->DrawRect(Vector2f(240.f-128.f, 241.f), Vector2f(240.f+128.f, 305.f));
+    
+	glBindTexture(GL_TEXTURE_2D, ResourceManager->TexList["logo_small"]);
+    Renderer->DrawRect(Vector2f(240.f-128.f+15.f, 0.f), Vector2f(240.f+128.f+15.f, 64.f));
+
+    CheckGlError("Draw TGameMenu 2");
+
+	
+}
+
+void TGameMenu::Update(size_t dt)
+{
+	if (HoldToTap)
+		return;
+	// åñëè êíîïêà íå íàæàòà
+	float k;
+	
+	MenuPos = MenuPos + MenuSpeed*dt/1000.f;
+
+    int menuItemToShowCount;
+    
+    if (MenuItemCount == 12)
+    {
+        menuItemToShowCount = 13;
+    }
+    else
+    {
+        menuItemToShowCount = MenuItemCount;
+    }
+	
+	float acc;
+	
+	if (MenuItemCount == 1)
+	{
+	   k = 3;
+    }
+	else
+	{
+        k = fabs( - MenuPos - ((menuItemToShowCount-1)*CONST_MENU_WINDOW_DISTANCE*0.5f)) / ((MenuItemCount-1)*CONST_MENU_WINDOW_DISTANCE*0.5f);  
+    }
+    
+	acc = -MenuSpeed * CONST_SPEED_NEG_ACCELERATION_K * k;
+	
+    
+	float xleft = (- MenuPos + CONST_SHIFT_ON_SIDE - (menuItemToShowCount-1)*CONST_MENU_WINDOW_DISTANCE);
+	
+	if (xleft < 0)
+	{
+        xleft = 0;
+    }
+    
+    acc += xleft*CONST_MENU_POS_K;
+    
+    float xright = (MenuPos - CONST_SHIFT_ON_SIDE);
+	
+	if (xright < 0)
+	{
+        xright = 0;
+    }
+    
+    acc -= xright*CONST_MENU_POS_K;
+    
+	if ((MenuSpeed + acc*dt) * MenuSpeed < 0) //Check if MenuSpeed changes direction
+	{
+		MenuSpeed = 0;
+	}
+	else
+	{
+		MenuSpeed += acc*dt;
+	}
+    
+    
+}
+
+void TGameMenu::OnTapDown(Vector2f pos)
+{
+	*SE::Console << "TGameMenu::OnTapDown";
+    HoldToTap = true;
+	
+    if (pos(1)<64.f && pos(0)>=265.f-128.f && pos(0)<=265.f+128.f)
+    {
+        Application->GoFromMenuToCredits();
+        return;
+    }
+	
+    Vector2f realPos = pos - Vector2f(MenuPos, 0);
+    
+    if (realPos(1) >= 80.f && realPos(1) <= 240.f)
+    {
+        float x = realPos(0) - 160.f;
+        
+        int p = 0;
+        while (x >280.f)
+        {
+            x -= 280.f;
+            p++;
+        }
+        
+        if (x <= 240.f && x >= 0.f && (p<MenuItemCount))
+        {
+            SelectedGame = p;
+            return;
+        }
+    }
+    
+
+    SelectedGame = -1;
+
+}
+
+void TGameMenu::OnTapUp(Vector2f pos)
+{
+	*SE::Console << "TGameMenu::OnTapUp";
+	HoldToTap = false;
+	
+	if (SelectedGame != -1)
+	{
+        MenuPos = -CONST_MENU_WINDOW_DISTANCE*SelectedGame-40.f;
+        Application->GoFromMenuToGame(SelectedGame);
+        SelectedGame = -1;
+    }
+}
+
+void TGameMenu::OnTapUpAfterMove(Vector2f pos)
+{
+    HoldToTap = false;
+}
+
+
+void TGameMenu::OnFling(Vector2f slideSpeed)
+{
+	*SE::Console << "TGameMenu::OnFling";
+	HoldToTap = false;
+	MenuSpeed = slideSpeed(0);
+}
+
+void TGameMenu::OnScroll(Vector2f shift)
+{
+	MenuPos = MenuPos - shift(0);
+}
+
+void TGameMenu::OpenNextLevel()
+{
+	*SE::Console << "TGameMenu::OpenNextLevel";
+    if (MenuItemCount < 12)
+    {
+        MenuItemCount++;
+    }
+}
+
+int TGameMenu::GetMenuItemCount()
+{
+	*SE::Console << "TGameMenu::GetMenuItemCount";
+    return MenuItemCount;
+}
+
+void TGameMenu::SetMenuItemCount(int menuItemCount)
+{
+	*SE::Console << "TGameMenu::SetMenuItemCount";
+    MenuItemCount = menuItemCount;
+}

game/menucode.h

@@ -0,0 +1,41 @@
+#ifndef MENUCODE_H_INCLUDED
+#define MENUCODE_H_INCLUDED
+
+#include "include/Engine.h"
+#include "game_area_interface.h"
+
+using namespace SE;
+
+
+class TGameMenu : public TGameAreaAncestor
+{
+protected:
+	float MenuSpeed;
+	float MenuPos;
+	
+	bool HoldToTap;
+	
+	int MenuItemCount;
+	
+	int SelectedGame;
+	
+	
+public:
+	TGameMenu();
+	virtual void Draw();
+	virtual void Update(size_t dt);
+	virtual void OnTapDown(Vector2f pos);
+	virtual void OnTapUp(Vector2f pos);
+    virtual void OnTapUpAfterMove(Vector2f pos);
+	virtual void OnFling(Vector2f slideSpeed);
+	virtual void OnScroll(Vector2f shift);
+	
+	void OpenNextLevel();
+	int GetMenuItemCount();
+	void SetMenuItemCount(int menuItemCount);
+
+};
+
+
+
+#endif