Fixed magic-stars matchDeathTime value, fixed sparkler-looped spawn, updated hints

assets/SSAA_4X.frag

@@ -1,19 +0,0 @@
-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/brickshader_fragment.txt

@@ -1,15 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

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

assets/config.json

@@ -0,0 +1,3 @@
+{
+	"effect": "effects/confetti.json"
+}

assets/effects/O-func.json

@@ -0,0 +1,102 @@
+{
+	"name": "Sparkler - бенгальский огонь",
+	
+	"emitters":
+	[
+	{
+		"name": "Spark",
+	
+		"maxParticles": 300,
+		"preloading": 100,
+		
+		"texturePath": "textures/spark.png",
+		"textureSize": [ 10, 10 ],
+		
+		"hasInertion": "false",
+		"gravity": [0, 0, 0],
+		
+		"spawnRange_system": "PARTICLE_EFFECT",
+		
+		"spawnTotal":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeline":
+			[
+			{
+				"t": 0,
+				"value": 0
+			},
+			{
+				"t": 1,
+				"value": 5
+			}
+			]
+		},
+		
+		"spawnRange":
+		{
+			"value": [ 0, 0, 0, 0 ]
+		},
+		
+		"lifeTime":
+		{
+			"value": 2
+		},
+		
+		"coords_system": "PARTICLE_BIRTH",
+		"coords_axis_system": "PARTICLE_BIRTH",
+		"rotation_system": "PARTICLE_EFFECT",
+		
+		"coords":
+		{
+			"interpolation": "CUBIC_SPLINE",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": [ 100, 0, 0]
+			},
+			{
+				"t": 0.1,
+				"value": [ 95, 30, 0]
+			},
+			{
+				"t": 0.5,
+				"value": [ 0, 100, 0]
+			},
+			{
+				"t": 1.0,
+				"value": [ -100, 0, 0]
+			},
+			{
+				"t": 1.5,
+				"value": [ 0, -100, 0]
+			},
+			{
+				"t": 1.9,
+				"value": [ 95, -30, 0]
+			},
+			{
+				"t": 2.000,
+				"value": [ 100, 0, 0]
+			}
+			]
+		},
+		
+		"rotation":
+		{
+			"value": [ 0, 0, 0 ]
+		},
+		
+		"scale":
+		{
+			"value": 1
+		},
+		
+		"color":
+		{
+			"value": [ 1, 1, 0, 1 ]
+		}
+	}
+	]
+}

assets/effects/S-func.json

@@ -0,0 +1,94 @@
+{
+	"name": "Sparkler - бенгальский огонь",
+	
+	"emitters":
+	[
+	{
+		"name": "Spark",
+	
+		"maxParticles": 300,
+		"preloading": 100,
+		
+		"texturePath": "textures/spark.png",
+		"textureSize": [ 10, 10 ],
+		
+		"hasInertion": "false",
+		"gravity": [0, 0, 0],
+		
+		"spawnRange_system": "PARTICLE_EFFECT",
+		
+		"spawnTotal":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeline":
+			[
+			{
+				"t": 0,
+				"value": 0
+			},
+			{
+				"t": 1,
+				"value": 5
+			}
+			]
+		},
+		
+		"spawnRange":
+		{
+			"value": [ 0, 0, 0, 0 ]
+		},
+		
+		"lifeTime":
+		{
+			"value": 2
+		},
+		
+		"coords_system": "PARTICLE_EFFECT",
+		"coords_axis_system": "PARTICLE_BIRTH",
+		"rotation_system": "PARTICLE_EFFECT",
+		
+		"coords":
+		{
+			"interpolation": "CUBIC_SPLINE",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": [ 0, 0, 0]
+			},
+			{
+				"t": 0.5,
+				"value": [ 50, 20, 0]
+			},
+			{
+				"t": 1.0,
+				"value": [ 100, 100, 0]
+			},
+			{
+				"t": 1.5,
+				"value": [ 150, 180, 0]
+			},
+			{
+				"t": 2.000,
+				"value": [ 200, 200, 0]
+			}
+			]
+		},
+		
+		"rotation":
+		{
+			"value": [ 0, 0, 0 ]
+		},
+		
+		"scale":
+		{
+			"value": 1
+		},
+		
+		"color":
+		{
+			"value": [ 1, 1, 0, 1 ]
+		}
+	}
+	]
+}

assets/effects/chaotic.json

@@ -0,0 +1,116 @@
+{
+	"emitters":
+	[
+	{
+		"maxParticles": 300,
+		"preloading": 100,
+		
+		"texturePath": "textures/spark.png",
+		"textureSize": [ 10, 10 ],
+		
+		"hasInertion": "false",
+		"gravity": [0, 0, 0],
+		
+		"spawnRange_system": "PARTICLE_EFFECT",
+		
+		"spawnTotal":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeline":
+			[
+			{
+				"t": 0,
+				"value": 0
+			},
+			{
+				"t": 1,
+				"value": 5
+			}
+			]
+		},
+		
+		"spawnRange":
+		{
+			"value": [ 0, 0, 0, 360 ]
+		},
+		
+		"lifeTime":
+		{
+			"value": 3
+		},
+		
+		"coords_system": "PARTICLE_EFFECT",
+		"offset_axis_system": "PARTICLE_EFFECT",
+		"coords_axis_system": "PARTICLE_BIRTH",
+		"rotation_system": "PARTICLE_EFFECT",
+		
+		"coords":
+		{
+			"interpolation": "CUBIC_SPLINE",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": [ 0, 0, 0]
+			},
+			{
+				"t": 3.000,
+				"value": [ 500, 0, 0]
+			}
+			]
+		},
+		
+		"offset":
+		{
+			"interpolation": "CUBIC_SPLINE",
+			"timelineType": "LOOPED",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": [ 10, 0, 0]
+			},
+			{
+				"t": 0.025,
+				"value": [ 9.5, 3, 0]
+			},
+			{
+				"t": 0.125,
+				"value": [ 0, 10, 0]
+			},
+			{
+				"t": 0.25,
+				"value": [ -10, 0, 0]
+			},
+			{
+				"t": 0.375,
+				"value": [ 0, -10, 0]
+			},
+			{
+				"t": 0.475,
+				"value": [ 9.5, -3, 0]
+			},
+			{
+				"t": 0.5,
+				"value": [ 10, 0, 0]
+			}
+			]
+		},
+		
+		"rotation":
+		{
+			"value": [ 0, 0, 0 ]
+		},
+		
+		"scale":
+		{
+			"value": 1
+		},
+		
+		"color":
+		{
+			"value": [ 1, 1, 0, 1 ]
+		}
+	}
+	]
+}

assets/effects/confetti.json

@@ -0,0 +1,861 @@
+{
+	"emitters":
+	[
+	{
+		"maxParticles": 10000,
+		"preloading": 1000,
+		
+		"texturePath": "textures/star-white.png",
+		"textureSize": [ 5, 5 ],
+		
+		"gravity": [ 0, -100, 0 ],
+		
+		"spawnRange_system": "PARTICLE_EFFECT",
+		
+		"spawnTotal":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": 0
+			},
+			{
+				"t": 1.000,
+				"value": 15
+			}
+			]
+		},
+		
+		"spawnRange":
+		{
+			"value": [ 0, 0, 360, 0]
+		},
+		
+		"lifeTime":
+		{
+			"min": 10,
+			"max": 10
+		},
+		
+		"coords_system": "PARTICLE_BIRTH",
+		"coords_axis_system": "PARTICLE_BIRTH",
+		"offset_axis_system": "PARTICLE_BIRTH",
+		"rotation_system": "PARTICLE_ITSELF",
+		
+		"coords":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": [ 0, 0, 0 ]
+			},
+			{
+				"t": 1.000,
+				"min": [ 100, 0, 0 ],
+				"max": [ 200, 0, 0 ]
+			}
+			]
+		},
+		
+		"offset":
+		{
+			"interpolation": "CUBIC_SPLINE",
+			"timelineType": "LOOPED",
+			"timeOffset":
+			{
+				"min": 0,
+				"max": 1
+			},
+			"timeline":
+			[
+			{
+				"t": 0.00,
+				"value": [ 10, 0, 0]
+			},
+			{
+				"t": 0.05,
+				"value": [ 9.5, 3, 0]
+			},
+			{
+				"t": 0.25,
+				"value": [ 0, 10, 0]
+			},
+			{
+				"t": 0.5,
+				"value": [ -10, 0, 0]
+			},
+			{
+				"t": 0.75,
+				"value": [ 0, -10, 0]
+			},
+			{
+				"t": 0.95,
+				"value": [ 9.5, -3, 0]
+			},
+			{
+				"t": 1.0,
+				"value": [ 10, 0, 0]
+			}
+			]
+		},
+		
+		"rotation":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeOffset":
+			{
+				"min": 0,
+				"max": 1
+			},
+			"timelineType": "LOOPED",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": [ 0, 45, 0 ]
+			},
+			{
+				"t": 1.000,
+				"value": [ 360, 45, 0 ]
+			}
+			]
+		},
+		
+		"scale":
+		{
+			"interpolation": "DISCRETE",
+			"timeline":
+			[
+			{
+				"min": 1,
+				"max": 2
+			}
+			]
+		},
+		
+		"color":
+		{
+			"value": [ 0, 1, 0, 1 ]
+		}
+	},
+	{
+		"name": "Magic Star",
+	
+		"maxParticles": 10000,
+		"preloading": 1000,
+		
+		"texturePath": "textures/rect-white.png",
+		"textureSize": [ 5, 5 ],
+		
+		"gravity": [ 0, -100, 0 ],
+		
+		"spawnRange_system": "PARTICLE_EFFECT",
+		
+		"spawnTotal":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": 0
+			},
+			{
+				"t": 1.000,
+				"value": 15
+			}
+			]
+		},
+		
+		"spawnRange":
+		{
+			"value": [ 0, 0, 360, 0]
+		},
+		
+		"lifeTime":
+		{
+			"min": 10,
+			"max": 10
+		},
+		
+		"coords_system": "PARTICLE_BIRTH",
+		"coords_axis_system": "PARTICLE_BIRTH",
+		"offset_axis_system": "PARTICLE_BIRTH",
+		"rotation_system": "PARTICLE_EFFECT",
+		
+		"coords":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": [ 0, 0, 0 ]
+			},
+			{
+				"t": 1.000,
+				"min": [ 100, 0, 0 ],
+				"max": [ 200, 0, 0 ]
+			}
+			]
+		},
+		
+		"offset":
+		{
+			"interpolation": "CUBIC_SPLINE",
+			"timelineType": "LOOPED",
+			"timeOffset":
+			{
+				"min": 0,
+				"max": 1
+			},
+			"timeline":
+			[
+			{
+				"t": 0.00,
+				"value": [ 10, 0, 0]
+			},
+			{
+				"t": 0.05,
+				"value": [ 9.5, 3, 0]
+			},
+			{
+				"t": 0.25,
+				"value": [ 0, 10, 0]
+			},
+			{
+				"t": 0.5,
+				"value": [ -10, 0, 0]
+			},
+			{
+				"t": 0.75,
+				"value": [ 0, -10, 0]
+			},
+			{
+				"t": 0.95,
+				"value": [ 9.5, -3, 0]
+			},
+			{
+				"t": 1.0,
+				"value": [ 10, 0, 0]
+			}
+			]
+		},
+		
+		"rotation":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeOffset":
+			{
+				"min": 0,
+				"max": 1
+			},
+			"timelineType": "LOOPED",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": [ 0, 45, 0 ]
+			},
+			{
+				"t": 1.000,
+				"value": [ 360, 45, 0 ]
+			}
+			]
+		},
+		
+		"scale":
+		{
+			"interpolation": "DISCRETE",
+			"timeline":
+			[
+			{
+				"min": 1,
+				"max": 2
+			}
+			]
+		},
+		
+		"color":
+		{
+			"value": [ 1, 0, 0, 1 ]
+		}
+	},
+	{
+		"name": "Magic Star",
+	
+		"maxParticles": 10000,
+		"preloading": 1000,
+		
+		"texturePath": "textures/circle-white.png",
+		"textureSize": [ 5, 5 ],
+		
+		"gravity": [ 0, -100, 0 ],
+		
+		"spawnRange_system": "PARTICLE_EFFECT",
+		
+		"spawnTotal":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": 0
+			},
+			{
+				"t": 1.000,
+				"value": 15
+			}
+			]
+		},
+		
+		"spawnRange":
+		{
+			"value": [ 0, 0, 360, 0]
+		},
+		
+		"lifeTime":
+		{
+			"min": 10,
+			"max": 10
+		},
+		
+		"coords_system": "PARTICLE_BIRTH",
+		"coords_axis_system": "PARTICLE_BIRTH",
+		"offset_axis_system": "PARTICLE_BIRTH",
+		"rotation_system": "PARTICLE_EFFECT",
+		
+		"coords":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": [ 0, 0, 0 ]
+			},
+			{
+				"t": 1.000,
+				"min": [ 100, 0, 0 ],
+				"max": [ 200, 0, 0 ]
+			}
+			]
+		},
+		
+		"offset":
+		{
+			"interpolation": "CUBIC_SPLINE",
+			"timelineType": "LOOPED",
+			"timeOffset":
+			{
+				"min": 0,
+				"max": 1
+			},
+			"timeline":
+			[
+			{
+				"t": 0.00,
+				"value": [ 10, 0, 0]
+			},
+			{
+				"t": 0.05,
+				"value": [ 9.5, 3, 0]
+			},
+			{
+				"t": 0.25,
+				"value": [ 0, 10, 0]
+			},
+			{
+				"t": 0.5,
+				"value": [ -10, 0, 0]
+			},
+			{
+				"t": 0.75,
+				"value": [ 0, -10, 0]
+			},
+			{
+				"t": 0.95,
+				"value": [ 9.5, -3, 0]
+			},
+			{
+				"t": 1.0,
+				"value": [ 10, 0, 0]
+			}
+			]
+		},
+		
+		"rotation":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeOffset":
+			{
+				"min": 0,
+				"max": 1
+			},
+			"timelineType": "LOOPED",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": [ 0, 45, 0 ]
+			},
+			{
+				"t": 1.000,
+				"value": [ 360, 45, 0 ]
+			}
+			]
+		},
+		
+		"scale":
+		{
+			"interpolation": "DISCRETE",
+			"timeline":
+			[
+			{
+				"min": 1,
+				"max": 2
+			}
+			]
+		},
+		
+		"color":
+		{
+			"value": [ 0, 0, 1, 1 ]
+		}
+	},
+	{
+		"name": "Magic Star",
+	
+		"maxParticles": 10000,
+		"preloading": 1000,
+		
+		"texturePath": "textures/star-white.png",
+		"textureSize": [ 5, 5 ],
+		
+		"gravity": [ 0, -100, 0 ],
+		
+		"spawnRange_system": "PARTICLE_EFFECT",
+		
+		"spawnTotal":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": 0
+			},
+			{
+				"t": 1.000,
+				"value": 15
+			}
+			]
+		},
+		
+		"spawnRange":
+		{
+			"value": [ 0, 0, 360, 0]
+		},
+		
+		"lifeTime":
+		{
+			"min": 10,
+			"max": 10
+		},
+		
+		"coords_system": "PARTICLE_BIRTH",
+		"coords_axis_system": "PARTICLE_BIRTH",
+		"offset_axis_system": "PARTICLE_BIRTH",
+		"rotation_system": "PARTICLE_EFFECT",
+		
+		"coords":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": [ 0, 0, 0 ]
+			},
+			{
+				"t": 1.000,
+				"min": [ 100, 0, 0 ],
+				"max": [ 200, 0, 0 ]
+			}
+			]
+		},
+		
+		"offset":
+		{
+			"interpolation": "CUBIC_SPLINE",
+			"timelineType": "LOOPED",
+			"timeOffset":
+			{
+				"min": 0,
+				"max": 1
+			},
+			"timeline":
+			[
+			{
+				"t": 0.00,
+				"value": [ 10, 0, 0]
+			},
+			{
+				"t": 0.05,
+				"value": [ 9.5, 3, 0]
+			},
+			{
+				"t": 0.25,
+				"value": [ 0, 10, 0]
+			},
+			{
+				"t": 0.5,
+				"value": [ -10, 0, 0]
+			},
+			{
+				"t": 0.75,
+				"value": [ 0, -10, 0]
+			},
+			{
+				"t": 0.95,
+				"value": [ 9.5, -3, 0]
+			},
+			{
+				"t": 1.0,
+				"value": [ 10, 0, 0]
+			}
+			]
+		},
+		
+		"rotation":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeOffset":
+			{
+				"min": 0,
+				"max": 1
+			},
+			"timelineType": "LOOPED",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": [ 0, 45, 0 ]
+			},
+			{
+				"t": 1.000,
+				"value": [ 360, 45, 0 ]
+			}
+			]
+		},
+		
+		"scale":
+		{
+			"interpolation": "DISCRETE",
+			"timeline":
+			[
+			{
+				"min": 1,
+				"max": 2
+			}
+			]
+		},
+		
+		"color":
+		{
+			"value": [ 1, 1, 0, 1 ]
+		}
+	},
+	{
+		"name": "Magic Star",
+	
+		"maxParticles": 10000,
+		"preloading": 1000,
+		
+		"texturePath": "textures/rect-white.png",
+		"textureSize": [ 5, 5 ],
+		
+		"gravity": [ 0, -100, 0 ],
+		
+		"spawnRange_system": "PARTICLE_EFFECT",
+		
+		"spawnTotal":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": 0
+			},
+			{
+				"t": 1.000,
+				"value": 15
+			}
+			]
+		},
+		
+		"spawnRange":
+		{
+			"value": [ 0, 0, 360, 0]
+		},
+		
+		"lifeTime":
+		{
+			"min": 10,
+			"max": 10
+		},
+		
+		"coords_system": "PARTICLE_BIRTH",
+		"coords_axis_system": "PARTICLE_BIRTH",
+		"offset_axis_system": "PARTICLE_BIRTH",
+		"rotation_system": "PARTICLE_EFFECT",
+		
+		"coords":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": [ 0, 0, 0 ]
+			},
+			{
+				"t": 1.000,
+				"min": [ 100, 0, 0 ],
+				"max": [ 200, 0, 0 ]
+			}
+			]
+		},
+		
+		"offset":
+		{
+			"interpolation": "CUBIC_SPLINE",
+			"timelineType": "LOOPED",
+			"timeOffset":
+			{
+				"min": 0,
+				"max": 1
+			},
+			"timeline":
+			[
+			{
+				"t": 0.00,
+				"value": [ 10, 0, 0]
+			},
+			{
+				"t": 0.05,
+				"value": [ 9.5, 3, 0]
+			},
+			{
+				"t": 0.25,
+				"value": [ 0, 10, 0]
+			},
+			{
+				"t": 0.5,
+				"value": [ -10, 0, 0]
+			},
+			{
+				"t": 0.75,
+				"value": [ 0, -10, 0]
+			},
+			{
+				"t": 0.95,
+				"value": [ 9.5, -3, 0]
+			},
+			{
+				"t": 1.0,
+				"value": [ 10, 0, 0]
+			}
+			]
+		},
+		
+		"rotation":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeOffset":
+			{
+				"min": 0,
+				"max": 1
+			},
+			"timelineType": "LOOPED",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": [ 0, 45, 0 ]
+			},
+			{
+				"t": 1.000,
+				"value": [ 360, 45, 0 ]
+			}
+			]
+		},
+		
+		"scale":
+		{
+			"interpolation": "DISCRETE",
+			"timeline":
+			[
+			{
+				"min": 1,
+				"max": 2
+			}
+			]
+		},
+		
+		"color":
+		{
+			"value": [ 0, 1, 1, 1 ]
+		}
+	},
+	{
+		"name": "Magic Star",
+	
+		"maxParticles": 10000,
+		"preloading": 1000,
+		
+		"texturePath": "textures/circle-white.png",
+		"textureSize": [ 5, 5 ],
+		
+		"gravity": [ 0, -100, 0 ],
+		
+		"spawnRange_system": "PARTICLE_EFFECT",
+		
+		"spawnTotal":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": 0
+			},
+			{
+				"t": 1.000,
+				"value": 15
+			}
+			]
+		},
+		
+		"spawnRange":
+		{
+			"value": [ 0, 0, 360, 0]
+		},
+		
+		"lifeTime":
+		{
+			"min": 10,
+			"max": 10
+		},
+		
+		"coords_system": "PARTICLE_BIRTH",
+		"coords_axis_system": "PARTICLE_BIRTH",
+		"offset_axis_system": "PARTICLE_BIRTH",
+		"rotation_system": "PARTICLE_EFFECT",
+		
+		"coords":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": [ 0, 0, 0 ]
+			},
+			{
+				"t": 1.000,
+				"min": [ 100, 0, 0 ],
+				"max": [ 200, 0, 0 ]
+			}
+			]
+		},
+		
+		"offset":
+		{
+			"interpolation": "CUBIC_SPLINE",
+			"timelineType": "LOOPED",
+			"timeOffset":
+			{
+				"min": 0,
+				"max": 1
+			},
+			"timeline":
+			[
+			{
+				"t": 0.00,
+				"value": [ 10, 0, 0]
+			},
+			{
+				"t": 0.05,
+				"value": [ 9.5, 3, 0]
+			},
+			{
+				"t": 0.25,
+				"value": [ 0, 10, 0]
+			},
+			{
+				"t": 0.5,
+				"value": [ -10, 0, 0]
+			},
+			{
+				"t": 0.75,
+				"value": [ 0, -10, 0]
+			},
+			{
+				"t": 0.95,
+				"value": [ 9.5, -3, 0]
+			},
+			{
+				"t": 1.0,
+				"value": [ 10, 0, 0]
+			}
+			]
+		},
+		
+		"rotation":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeOffset":
+			{
+				"min": 0,
+				"max": 1
+			},
+			"timelineType": "LOOPED",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": [ 0, 45, 0 ]
+			},
+			{
+				"t": 1.000,
+				"value": [ 360, 45, 0 ]
+			}
+			]
+		},
+		
+		"scale":
+		{
+			"interpolation": "DISCRETE",
+			"timeline":
+			[
+			{
+				"min": 1,
+				"max": 2
+			}
+			]
+		},
+		
+		"color":
+		{
+			"value": [ 1, 0, 1, 1 ]
+		}
+	}
+	]
+}

assets/effects/magic-stars.json

@@ -0,0 +1,274 @@
+{
+	"emitters":
+	[
+	{
+		"preloading": 20,
+		
+		"texturePath": "textures/magic-star.png",
+		"textureSize": [ 22.625, 12.5 ],
+		
+		"hasInertion": "false",
+		"gravity": [0, 0, 0],
+		
+		"spawnRange_system": "PARTICLE_EFFECT",
+		
+		"spawnTotal":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeline":
+			[
+			{
+				"t": 0,
+				"value": 0
+			},
+			{
+				"t": 1,
+				"value": 2
+			}
+			]
+		},
+		
+		"spawnRange":
+		{
+			"value": [ 0, 30, 0, 45 ]
+		},
+		
+		"lifeTime":
+		{
+			"min": 1.5,
+			"max": 3
+		},
+		
+		"coords_system": "PARTICLE_BIRTH",
+		"coords_axis_system": "PARTICLE_BIRTH",
+		"rotation_system": "PARTICLE_BIRTH",
+		
+		"coords":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": [ 0, 0, 0 ]
+			},
+			{
+				"t": 1.000,
+				"min": [ 300, 0, 0 ],
+				"max": [ 300, 0, 0 ]
+			}
+			]
+		},
+		
+		"rotation":
+		{
+			"value": [ 0, 0, 0 ]
+		},
+		
+		"scale":
+		{
+			"interpolation": "DISCRETE",
+			"timeline":
+			[
+			{
+				"value": 1
+			}
+			]
+		},
+		
+		"color":
+		{
+			"value": [ 1, 1, 1, 1 ]
+		},
+		
+		"emitters":
+		[
+		{
+			"name": "Spark",
+		
+			"maxParticles": 110,
+			"preloading": 110,
+			
+			"texturePath": "textures/spark-white.png",
+			"textureSize": [ 10, 10 ],
+			
+			"gravity": [0, -100, 0],
+			
+			"spawnRange_system": "PARTICLE_BIRTH",
+			
+			"spawnTotal":
+			{
+				"interpolation": "LINEAR_SPLINE",
+				"matchDeathTime": "true",
+				"timeline":
+				[
+				{
+					"t": 0.000,
+					"value": 0
+				},
+				{
+					"t": 1,
+					"value": 50
+				}
+				]
+			},
+			
+			"spawnRange":
+			{
+				"value": [ 0, 0, 0, 360 ]
+			},
+			
+			"lifeTime":
+			{
+				"min": 1,
+				"max": 2
+			},
+			
+			"coords_system": "PARTICLE_BIRTH",
+			"coords_axis_system": "PARTICLE_BIRTH",
+			"rotation_system": "PARTICLE_BIRTH",
+			
+			"coords":
+			{
+				"interpolation": "LINEAR_SPLINE",
+				"timeline":
+				[
+				{
+					"t": 0.000,
+					"value": [ 0, 0, 0 ]
+				},
+				{
+					"t": 1.000,
+					"min": [ 0, 0, 0 ],
+					"max": [ 50, 0, 0 ]
+				}
+				]
+			},
+			
+			"rotation":
+			{
+				"value": [ 0, 0, 0 ]
+			},
+			
+			"scale":
+			{
+				"value": 1
+			},
+			
+			"color":
+			{
+				"interpolation": "LINEAR_SPLINE",
+				"timeline":
+				[
+				{
+					"t": 0.000,
+					"value": [ 0, 1, 1, 1 ]
+				},
+				{
+					"t": 1.000,
+					"value": [ 0, 0, 1, 1 ]
+				},
+				{
+					"t": 1.200,
+					"value": [ 0, 0, 1, 0 ]
+				}
+				]
+			}
+		},
+		{
+			"name": "Spark",
+		
+			"maxParticles": 300,
+			"preloading": 300,
+			
+			"texturePath": "textures/spark-white.png",
+			"textureSize": [ 10, 10 ],
+			
+			"hasInertion": "true",
+			"gravity": [0, -100, 0],
+			
+			"spawnRange_system": "PARTICLE_BIRTH",
+			
+			"spawnTotal":
+			{
+				"interpolation": "DISCRETE",
+				"matchDeathTime": "true",
+				"timeline":
+				[
+				{
+					"t": 0.000,
+					"value": 0
+				},
+				{
+					"t": 2.000,
+					"value": 300
+				}
+				]
+			},
+			
+			"spawnRange":
+			{
+				"value": [ 0, 0, 0, 360 ]
+			},
+			
+			"lifeTime":
+			{
+				"min": 1,
+				"max": 2
+			},
+			
+			"coords_system": "PARTICLE_BIRTH",
+			"coords_axis_system": "PARTICLE_BIRTH",
+			"rotation_system": "PARTICLE_BIRTH",
+			
+			"coords":
+			{
+				"interpolation": "LINEAR_SPLINE",
+				"timeline":
+				[
+				{
+					"t": 0.000,
+					"value": [ 0, 0, 0 ]
+				},
+				{
+					"t": 1.000,
+					"min": [ 25, 0, 0 ],
+					"max": [ 300, 0, 0 ]
+				}
+				]
+			},
+			
+			"rotation":
+			{
+				"value": [ 0, 0, 0 ]
+			},
+			
+			"scale":
+			{
+				"value": 1
+			},
+			
+			"color":
+			{
+				"interpolation": "LINEAR_SPLINE",
+				"timeline":
+				[
+				{
+					"t": 0.000,
+					"value": [ 1, 1, 0, 1 ]
+				},
+				{
+					"t": 1.000,
+					"value": [ 1, 0, 0, 1 ]
+				},
+				{
+					"t": 1.200,
+					"value": [ 1, 0, 0, 0 ]
+				}
+				]
+			}
+		}
+		]
+	}
+	]
+}

assets/effects/sine-comets.json

@@ -0,0 +1,110 @@
+{
+	"name": "Sparkler - бенгальский огонь",
+	
+	"emitters":
+	[
+	{
+		"name": "Spark",
+	
+		"maxParticles": 300,
+		"preloading": 100,
+		
+		"texturePath": "textures/comet.png",
+		"textureSize": [ 20, 7.12 ],
+		
+		"hasInertion": "false",
+		"gravity": [0, 0, 0],
+		
+		"spawnRange_system": "PARTICLE_EFFECT",
+		
+		"spawnTotal":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeline":
+			[
+			{
+				"t": 0,
+				"value": 0
+			},
+			{
+				"t": 1,
+				"value": 3
+			}
+			]
+		},
+		
+		"spawnRange":
+		{
+			"value": [ 0, 0, 0, 0 ]
+		},
+		
+		"lifeTime":
+		{
+			"value": 6
+		},
+		
+		"coords_system": "PARTICLE_EFFECT",
+		"coords_axis_system": "PARTICLE_BIRTH",
+		"rotation_system": "PARTICLE_ITSELF",
+		
+		"coords":
+		{
+			"interpolation": "CUBIC_SPLINE",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": [ 50, 0, 0 ]
+			},
+			{
+				"t": 0.001,
+				"value": [ 50, 0, 0 ]
+			},
+			{
+				"t": 1.000,
+				"value": [ 100, 100, 0 ]
+			},
+			{
+				"t": 2.000,
+				"value": [ 200, -100, 0 ]
+			},
+			{
+				"t": 3.000,
+				"value": [ 300, 100, 0 ]
+			},
+			{
+				"t": 4.000,
+				"value": [ 400, -100, 0 ]
+			},
+			{
+				"t": 5.000,
+				"value": [ 500, 100, 0 ]
+			},
+			{
+				"t": 5.999,
+				"value": [ 600, -100, 0 ]
+			},
+			{
+				"t": 6.000,
+				"value": [ 600, -100, 0 ]
+			}
+			]
+		},
+		
+		"rotation":
+		{
+			"value": [ 0, 0, 0 ]
+		},
+		
+		"scale":
+		{
+			"value": 1
+		},
+		
+		"color":
+		{
+			"value": [ 1, 1, 1, 1 ]
+		}
+	}
+	]
+}

assets/effects/sine-sparks.json

@@ -0,0 +1,110 @@
+{
+	"name": "Sparkler - бенгальский огонь",
+	
+	"emitters":
+	[
+	{
+		"name": "Spark",
+	
+		"maxParticles": 300,
+		"preloading": 100,
+		
+		"texturePath": "textures/spark.png",
+		"textureSize": [ 10, 10 ],
+		
+		"hasInertion": "false",
+		"gravity": [0, 0, 0],
+		
+		"spawnRange_system": "PARTICLE_EFFECT",
+		
+		"spawnTotal":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeline":
+			[
+			{
+				"t": 0,
+				"value": 0
+			},
+			{
+				"t": 1,
+				"value": 20
+			}
+			]
+		},
+		
+		"spawnRange":
+		{
+			"value": [ 0, 0, 0, 0 ]
+		},
+		
+		"lifeTime":
+		{
+			"value": 6
+		},
+		
+		"coords_system": "PARTICLE_EFFECT",
+		"coords_axis_system": "PARTICLE_BIRTH",
+		"rotation_system": "PARTICLE_EFFECT",
+		
+		"coords":
+		{
+			"interpolation": "CUBIC_SPLINE",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": [ 50, 0, 0 ]
+			},
+			{
+				"t": 0.001,
+				"value": [ 50, 0, 0 ]
+			},
+			{
+				"t": 1.000,
+				"value": [ 100, 100, 0 ]
+			},
+			{
+				"t": 2.000,
+				"value": [ 200, -100, 0 ]
+			},
+			{
+				"t": 3.000,
+				"value": [ 300, 100, 0 ]
+			},
+			{
+				"t": 4.000,
+				"value": [ 400, -100, 0 ]
+			},
+			{
+				"t": 5.000,
+				"value": [ 500, 100, 0 ]
+			},
+			{
+				"t": 5.999,
+				"value": [ 600, -100, 0 ]
+			},
+			{
+				"t": 6.000,
+				"value": [ 600, -100, 0 ]
+			}
+			]
+		},
+		
+		"rotation":
+		{
+			"value": [ 0, 0, 0 ]
+		},
+		
+		"scale":
+		{
+			"value": 1
+		},
+		
+		"color":
+		{
+			"value": [ 1, 1, 0, 1 ]
+		}
+	}
+	]
+}

assets/effects/sparkler-looped.json

@@ -0,0 +1,93 @@
+{
+	"name": "Simple Sparkler",
+	
+	"emitters":
+	[
+	{
+		"name": "Spark",
+	
+		"maxParticles": 2000,
+		"preloading": 2000,
+		
+		"texturePath": "textures/spark-white.png",
+		"textureSize": [ 10, 10 ],
+		
+		"hasInertion": "false",
+		"gravity": [0, 0, 0],
+		
+		"spawnRange_system": "PARTICLE_EFFECT",
+		
+		"spawnTotal":
+		{
+			"interpolation": "CUBIC_SPLINE",
+			"timelineType": "LOOPED",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": 0
+			},
+			{
+				"t": 0.001,
+				"value": 0
+			},
+			{
+				"t": 9.999,
+				"value": 10000
+			},
+			{
+				"t": 10.000,
+				"value": 10000
+			}
+			]
+		},
+		
+		"spawnRange":
+		{
+			"value": [ 0, 0, 0, 360 ]
+		},
+		
+		"lifeTime":
+		{
+			"min": 0.1,
+			"max": 1
+		},
+		
+		"coords_system": "PARTICLE_BIRTH",
+		"coords_axis_system": "PARTICLE_BIRTH",
+		"rotation_system": "PARTICLE_EFFECT",
+		
+		"coords":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": [ 0, 0, 0 ]
+			},
+			{
+				"t": 1,
+				"min": [ 300, 0, 0 ],
+				"max": [ 600, 0, 0 ]
+			}
+			]
+		},
+		
+		"rotation":
+		{
+			"value": [ 0, 0, 0 ]
+		},
+		
+		"scale":
+		{
+			"value": 1
+		},
+		
+		"color":
+		{
+			"value": [ 1, 1, 0, 1 ]
+		}
+	}
+	]
+}

assets/effects/sparkler.json

@@ -0,0 +1,85 @@
+{
+	"name": "Simple Sparkler",
+	
+	"emitters":
+	[
+	{
+		"name": "Spark",
+	
+		"maxParticles": 1100,
+		"preloading": 1100,
+		
+		"texturePath": "textures/spark-white.png",
+		"textureSize": [ 10, 10 ],
+		
+		"hasInertion": "false",
+		"gravity": [0, 0, 0],
+		
+		"spawnRange_system": "PARTICLE_EFFECT",
+		
+		"spawnTotal":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timelineType": "CONTINUED",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": 0
+			},
+			{
+				"t": 1.000,
+				"value": 1000
+			}
+			]
+		},
+		
+		"spawnRange":
+		{
+			"value": [ 0, 0, 0, 360 ]
+		},
+		
+		"lifeTime":
+		{
+			"min": 0.1,
+			"max": 1
+		},
+		
+		"coords_system": "PARTICLE_BIRTH",
+		"coords_axis_system": "PARTICLE_BIRTH",
+		"rotation_system": "PARTICLE_EFFECT",
+		
+		"coords":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": [ 0, 0, 0 ]
+			},
+			{
+				"t": 1,
+				"min": [ 300, 0, 0 ],
+				"max": [ 600, 0, 0 ]
+			}
+			]
+		},
+		
+		"rotation":
+		{
+			"value": [ 0, 0, 0 ]
+		},
+		
+		"scale":
+		{
+			"value": 1
+		},
+		
+		"color":
+		{
+			"value": [ 1, 1, 0, 1 ]
+		}
+	}
+	]
+}

assets/effects/test.json

@@ -0,0 +1,646 @@
+{
+	"emitters":
+	[
+	{
+		"maxParticles": 10000,
+		"preloading": 1000,
+		
+		"texturePath": "textures/star-white.png",
+		"textureSize": [ 5, 5 ],
+		
+		"gravity": [ 0, -100, 0 ],
+		
+		"spawnRange_system": "PARTICLE_EFFECT",
+		
+		"spawnTotal":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": 0
+			},
+			{
+				"t": 1.000,
+				"value": 5
+			}
+			]
+		},
+		
+		"spawnRange":
+		{
+			"value": [ 0, 0, 360, 180 ]
+		},
+		
+		"lifeTime":
+		{
+			"min": 10,
+			"max": 10
+		},
+		
+		"coords_system": "PARTICLE_BIRTH",
+		"coords_axis_system": "PARTICLE_BIRTH",
+		"offset_axis_system": "PARTICLE_ITSELF",
+		"rotation_system": "PARTICLE_ITSELF",
+		
+		"coords":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": [ 0, 0, 0 ]
+			},
+			{
+				"t": 1.000,
+				"min": [ 150, 0, 0 ],
+				"max": [ 300, 0, 0 ]
+			}
+			]
+		},
+		
+		"offset":
+		{
+			"interpolation": "CUBIC_SPLINE",
+			"timelineType": "LOOPED",
+			"timeline":
+			[
+			{
+				"t": 0.00,
+				"value": [ 10, 0, 0]
+			},
+			{
+				"t": 0.05,
+				"value": [ 9.5, 3, 0]
+			},
+			{
+				"t": 0.25,
+				"value": [ 0, 10, 0]
+			},
+			{
+				"t": 0.5,
+				"value": [ -10, 0, 0]
+			},
+			{
+				"t": 0.75,
+				"value": [ 0, -10, 0]
+			},
+			{
+				"t": 0.95,
+				"value": [ 9.5, -3, 0]
+			},
+			{
+				"t": 1.0,
+				"value": [ 10, 0, 0]
+			}
+			]
+		},
+		
+		"rotation":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeOffset":
+			{
+				"min": 0,
+				"max": 1
+			},
+			"timelineType": "LOOPED",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": [ 0, 45, 0 ]
+			},
+			{
+				"t": 1.000,
+				"value": [ 360, 45, 0 ]
+			}
+			]
+		},
+		
+		"scale":
+		{
+			"interpolation": "DISCRETE",
+			"timeline":
+			[
+			{
+				"min": 1,
+				"max": 2
+			}
+			]
+		},
+		
+		"color":
+		{
+			"value": [ 0, 1, 0, 1 ]
+		}
+	},
+	{
+		"name": "Magic Star",
+	
+		"maxParticles": 10000,
+		"preloading": 1000,
+		
+		"texturePath": "textures/rect-white.png",
+		"textureSize": [ 5, 5 ],
+		
+		"gravity": [ 0, -100, 0 ],
+		
+		"spawnRange_system": "PARTICLE_EFFECT",
+		
+		"spawnTotal":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": 0
+			},
+			{
+				"t": 1.000,
+				"value": 5
+			}
+			]
+		},
+		
+		"spawnRange":
+		{
+			"value": [ 0, 0, 360, 180 ]
+		},
+		
+		"lifeTime":
+		{
+			"min": 10,
+			"max": 10
+		},
+		
+		"coords_system": "PARTICLE_BIRTH",
+		"coords_axis_system": "PARTICLE_BIRTH",
+		"offset_axis_system": "PARTICLE_ITSELF",
+		"rotation_system": "PARTICLE_ITSELF",
+		
+		"coords":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": [ 0, 0, 0 ]
+			},
+			{
+				"t": 1.000,
+				"min": [ 150, 0, 0 ],
+				"max": [ 300, 0, 0 ]
+			}
+			]
+		},
+		
+		"rotation":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeOffset":
+			{
+				"min": 0,
+				"max": 1
+			},
+			"timelineType": "LOOPED",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": [ 0, 45, 0 ]
+			},
+			{
+				"t": 1.000,
+				"value": [ 360, 45, 0 ]
+			}
+			]
+		},
+		
+		"scale":
+		{
+			"interpolation": "DISCRETE",
+			"timeline":
+			[
+			{
+				"min": 1,
+				"max": 2
+			}
+			]
+		},
+		
+		"color":
+		{
+			"value": [ 1, 0, 0, 1 ]
+		}
+	},
+	{
+		"name": "Magic Star",
+	
+		"maxParticles": 10000,
+		"preloading": 1000,
+		
+		"texturePath": "textures/circle-white.png",
+		"textureSize": [ 5, 5 ],
+		
+		"gravity": [ 0, -100, 0 ],
+		
+		"spawnRange_system": "PARTICLE_EFFECT",
+		
+		"spawnTotal":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": 0
+			},
+			{
+				"t": 1.000,
+				"value": 5
+			}
+			]
+		},
+		
+		"spawnRange":
+		{
+			"value": [ 0, 0, 360, 180 ]
+		},
+		
+		"lifeTime":
+		{
+			"min": 10,
+			"max": 10
+		},
+		
+		"coords_system": "PARTICLE_BIRTH",
+		"coords_axis_system": "PARTICLE_BIRTH",
+		"offset_axis_system": "PARTICLE_ITSELF",
+		"rotation_system": "PARTICLE_ITSELF",
+		
+		"coords":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": [ 0, 0, 0 ]
+			},
+			{
+				"t": 1.000,
+				"min": [ 150, 0, 0 ],
+				"max": [ 300, 0, 0 ]
+			}
+			]
+		},
+		
+		"rotation":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeOffset":
+			{
+				"min": 0,
+				"max": 1
+			},
+			"timelineType": "LOOPED",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": [ 0, 45, 0 ]
+			},
+			{
+				"t": 1.000,
+				"value": [ 360, 45, 0 ]
+			}
+			]
+		},
+		
+		"scale":
+		{
+			"interpolation": "DISCRETE",
+			"timeline":
+			[
+			{
+				"min": 1,
+				"max": 2
+			}
+			]
+		},
+		
+		"color":
+		{
+			"value": [ 0, 0, 1, 1 ]
+		}
+	},
+	{
+		"name": "Magic Star",
+	
+		"maxParticles": 10000,
+		"preloading": 1000,
+		
+		"texturePath": "textures/star-white.png",
+		"textureSize": [ 5, 5 ],
+		
+		"gravity": [ 0, -100, 0 ],
+		
+		"spawnRange_system": "PARTICLE_EFFECT",
+		
+		"spawnTotal":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": 0
+			},
+			{
+				"t": 1.000,
+				"value": 5
+			}
+			]
+		},
+		
+		"spawnRange":
+		{
+			"value": [ 0, 0, 360, 180 ]
+		},
+		
+		"lifeTime":
+		{
+			"min": 10,
+			"max": 10
+		},
+		
+		"coords_system": "PARTICLE_BIRTH",
+		"coords_axis_system": "PARTICLE_BIRTH",
+		"offset_axis_system": "PARTICLE_ITSELF",
+		"rotation_system": "PARTICLE_ITSELF",
+		
+		"coords":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": [ 0, 0, 0 ]
+			},
+			{
+				"t": 1.000,
+				"min": [ 150, 0, 0 ],
+				"max": [ 300, 0, 0 ]
+			}
+			]
+		},
+		
+		"rotation":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeOffset":
+			{
+				"min": 0,
+				"max": 1
+			},
+			"timelineType": "LOOPED",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": [ 0, 45, 0 ]
+			},
+			{
+				"t": 1.000,
+				"value": [ 360, 45, 0 ]
+			}
+			]
+		},
+		
+		"scale":
+		{
+			"interpolation": "DISCRETE",
+			"timeline":
+			[
+			{
+				"min": 1,
+				"max": 2
+			}
+			]
+		},
+		
+		"color":
+		{
+			"value": [ 1, 1, 0, 1 ]
+		}
+	},
+	{
+		"name": "Magic Star",
+	
+		"maxParticles": 10000,
+		"preloading": 1000,
+		
+		"texturePath": "textures/rect-white.png",
+		"textureSize": [ 5, 5 ],
+		
+		"gravity": [ 0, -100, 0 ],
+		
+		"spawnRange_system": "PARTICLE_EFFECT",
+		
+		"spawnTotal":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": 0
+			},
+			{
+				"t": 1.000,
+				"value": 5
+			}
+			]
+		},
+		
+		"spawnRange":
+		{
+			"value": [ 0, 0, 360, 180 ]
+		},
+		
+		"lifeTime":
+		{
+			"min": 10,
+			"max": 10
+		},
+		
+		"coords_system": "PARTICLE_BIRTH",
+		"coords_axis_system": "PARTICLE_BIRTH",
+		"offset_axis_system": "PARTICLE_ITSELF",
+		"rotation_system": "PARTICLE_ITSELF",
+		
+		"coords":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": [ 0, 0, 0 ]
+			},
+			{
+				"t": 1.000,
+				"min": [ 150, 0, 0 ],
+				"max": [ 300, 0, 0 ]
+			}
+			]
+		},
+		
+		"rotation":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeOffset":
+			{
+				"min": 0,
+				"max": 1
+			},
+			"timelineType": "LOOPED",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": [ 0, 45, 0 ]
+			},
+			{
+				"t": 1.000,
+				"value": [ 360, 45, 0 ]
+			}
+			]
+		},
+		
+		"scale":
+		{
+			"interpolation": "DISCRETE",
+			"timeline":
+			[
+			{
+				"min": 1,
+				"max": 2
+			}
+			]
+		},
+		
+		"color":
+		{
+			"value": [ 0, 1, 1, 1 ]
+		}
+	},
+	{
+		"name": "Magic Star",
+	
+		"maxParticles": 10000,
+		"preloading": 1000,
+		
+		"texturePath": "textures/circle-white.png",
+		"textureSize": [ 5, 5 ],
+		
+		"gravity": [ 0, -100, 0 ],
+		
+		"spawnRange_system": "PARTICLE_EFFECT",
+		
+		"spawnTotal":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": 0
+			},
+			{
+				"t": 1.000,
+				"value": 5
+			}
+			]
+		},
+		
+		"spawnRange":
+		{
+			"value": [ 0, 0, 360, 180 ]
+		},
+		
+		"lifeTime":
+		{
+			"min": 10,
+			"max": 10
+		},
+		
+		"coords_system": "PARTICLE_BIRTH",
+		"coords_axis_system": "PARTICLE_BIRTH",
+		"offset_axis_system": "PARTICLE_ITSELF",
+		"rotation_system": "PARTICLE_ITSELF",
+		
+		"coords":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": [ 0, 0, 0 ]
+			},
+			{
+				"t": 1.000,
+				"min": [ 150, 0, 0 ],
+				"max": [ 300, 0, 0 ]
+			}
+			]
+		},
+		
+		"rotation":
+		{
+			"interpolation": "LINEAR_SPLINE",
+			"timeOffset":
+			{
+				"min": 0,
+				"max": 1
+			},
+			"timelineType": "LOOPED",
+			"timeline":
+			[
+			{
+				"t": 0.000,
+				"value": [ 0, 45, 0 ]
+			},
+			{
+				"t": 1.000,
+				"value": [ 360, 45, 0 ]
+			}
+			]
+		},
+		
+		"scale":
+		{
+			"interpolation": "DISCRETE",
+			"timeline":
+			[
+			{
+				"min": 1,
+				"max": 2
+			}
+			]
+		},
+		
+		"color":
+		{
+			"value": [ 1, 0, 1, 1 ]
+		}
+	}
+	]
+}

assets/frameshader_fragment.txt

@@ -1,12 +0,0 @@
-precision mediump float;
-uniform sampler2D Texture;
-uniform float Brightness;
-varying vec2 texCoord;
-
-void main() 
-{
-	vec3 color = texture2D(Texture,texCoord).rgb;
-
-	gl_FragColor = vec4(color * Brightness, 1.0);
-	
-}

assets/frameshader_vertex.txt

@@ -1,12 +0,0 @@
-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/lines.json

@@ -1,7 +0,0 @@
-{
-    "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

@@ -1,68 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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/particle_effect_hint.json

@@ -0,0 +1,42 @@
+
+<EMITTER_DESCRIPTION>
+
+		bool enabled;
+
+		< Emitter Description >
+
+		uint maxParticles;
+		uint preloading;
+
+		std::string texturePath;
+		Vector2f textureSize;
+
+		bool hasInertion;
+		Vector3f gravity;
+
+		RelatedCoordinateSystem spawnRange_system; = { PARTICLE_EFFECT , PARTICLE_EMITTER }
+
+		RandomValueAtTimeline<FloatWrapper, RandomFloat> spawnTotal;
+		RandomValueAtTimeline<Vector4fWrapper, RandomVector4f> spawnRange; // yaw + pitch + delta yaw + delta pitch
+		< / Emitter Description >
+
+		< Particle Description >
+		RandomFloat lifeTime;
+
+		RelatedCoordinateSystem coords_system; = { PARTICLE_EFFECT , PARTICLE_EMITTER , PARTICLE_BIRTH , PARTICLE_ITSELF }
+		RelatedCoordinateSystem offset_axis_system;
+		RelatedCoordinateSystem coords_axis_system;
+		RelatedCoordinateSystem rotation_system;
+
+		RandomValueAtTimeline<Vector3fWrapper, RandomVector3f> coords;
+		RandomValueAtTimeline<Vector3fWrapper, RandomVector3f> offset;
+		RandomValueAtTimeline<Vector3fWrapper, RandomVector3f> rotation; // yaw + pitch + roll
+		RandomValueAtTimeline<FloatWrapper, RandomFloat> scale;
+		RandomValueAtTimeline<Vector4fWrapper, RandomVector4f> color;
+
+		std::vector<std::shared_ptr<EmitterDescription>> emittersTypes;
+		</ Particle Description >
+
+	std::vector<EmitterDescription> emittersTypes;
+
+</EMITTER_DESCRIPTION>

assets/shader1fragment.txt

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

assets/shaders/color-shader.fragment

@@ -0,0 +1,8 @@
+precision mediump float;
+
+uniform vec4 Color;
+
+void main() 
+{
+	gl_FragColor = Color;
+}

assets/shaders/color-shader.vertex

@@ -1,11 +1,8 @@
 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/shaders/particle-shader.fragment

@@ -0,0 +1,11 @@
+precision mediump float;
+
+in vec2 texCoord;
+flat in vec4 color;
+
+uniform sampler2D Texture;
+
+void main() 
+{
+	gl_FragColor = texture2D(Texture,texCoord) * color;
+}

assets/shaders/particle-shader.vertex

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

assets/shaders/texture-shader.fragment

@@ -0,0 +1,10 @@
+precision mediump float;
+
+varying vec2 texCoord;
+
+uniform sampler2D Texture;
+
+void main() 
+{
+	gl_FragColor = texture2D(Texture,texCoord);
+}

assets/shaders/texture-shader.vertex

@@ -1,5 +1,6 @@
 attribute vec3 vPosition;
 attribute vec2 vTexCoord;
+
 varying vec2 texCoord;
 
 uniform mat4 ProjectionMatrix;

assets/simple_shading.fragment

@@ -1,18 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,83 +0,0 @@
-#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

@@ -1,34 +0,0 @@
-#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

@@ -1,25 +0,0 @@
-#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

@@ -1,205 +0,0 @@
-#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

@@ -1,20 +0,0 @@
-#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

@@ -1,15 +0,0 @@
-#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

@@ -7,64 +7,11 @@
 
 #include "include/Engine.h"
 
-#include "main_code.h"
+#include <boost/property_tree/json_parser.hpp>
 
 TMyApplication* Application;
 
 
-std::vector<SE::Vector3f> posArr;
-std::vector<SE::Vector3f> normArr;
-std::vector<SE::Vector3f> colorArr;
-std::vector<SE::Vector2f> texCoordArr;
-
-
-GLuint posBuffer;
-GLuint normBuffer;
-GLuint colorBuffer;
-GLuint texCoordBuffer;
-
-
-size_t posArrIndex = 0;
-size_t normArrIndex = 0;
-size_t colorArrIndex = 0;
-size_t texCoordArrIndex = 0;
-
-
-
-Matrix3f quatToMatrix(Vector4f q) {
-
-	Matrix3f result;
-
-	double sqw = q(3)*q(3);
-	double sqx = q(0)*q(0);
-	double sqy = q(1)*q(1);
-	double sqz = q(2)*q(2);
-
-	// invs (inverse square length) is only required if quaternion is not already normalised
-	double invs = 1 / (sqx + sqy + sqz + sqw);
-
-	result(0,0) = (sqx - sqy - sqz + sqw)*invs; // since sqw + sqx + sqy + sqz =1/invs*invs
-	result(1,1) = (-sqx + sqy - sqz + sqw)*invs;
-	result(2,2) = (-sqx - sqy + sqz + sqw)*invs;
-
-	double tmp1 = q(0)*q(1);
-	double tmp2 = q(2)*q(3);
-	result(1, 0) = 2.0 * (tmp1 + tmp2)*invs;
-	result(0, 1) = 2.0 * (tmp1 - tmp2)*invs;
-
-	tmp1 = q(0)*q(2);
-	tmp2 = q(1)*q(3);
-	result(2,0) = 2.0 * (tmp1 - tmp2)*invs;
-	result(0,2) = 2.0 * (tmp1 + tmp2)*invs;
-	tmp1 = q(1)*q(2);
-	tmp2 = q(0)*q(3);
-	result(2, 1) = 2.0 * (tmp1 + tmp2)*invs;
-	result(1, 2) = 2.0 * (tmp1 - tmp2)*invs;
-
-	return result;
-}
-
-
 void TMyApplication::InnerInit()
 {
 
@@ -72,8 +19,7 @@ void TMyApplication::InnerInit()
     
 #ifdef TARGET_WIN32
 #ifdef NDEBUG
-	ST::PathToResources = "resources/";
-	//ST::PathToResources = "../../../assets/";
+	ST::PathToResources = "../../../assets/";
 #else
 	ST::PathToResources = "../../../assets/";
 #endif
@@ -89,609 +35,81 @@ void TMyApplication::InnerInit()
     }
     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");
-	ResourceManager->ShaderManager.AddShader("ColorShader", "color_vertex.txt", "color_fragment.txt");
-	ResourceManager->ShaderManager.AddShader("SSAA_4X", "SSAA_4X.vertex", "SSAA_4X.frag");
-	ResourceManager->ShaderManager.AddShader("ParallaxShader", "parallax_vertex.txt", "parallax_fragment.txt");
-	//ResourceManager->ShaderManager.AddShader("SimpleShadingNoTex", "simple_shading_no_tex.vertex", "simple_shading_no_tex.fragment");
-	ResourceManager->ShaderManager.AddShader("SimpleShading", "simple_shading.vertex", "simple_shading.fragment");
-	Renderer->PushShader("DefaultShader");
+	ResourceManager->ShaderManager.AddShader("DefaultShader", "shaders/texture-shader.vertex", "shaders/texture-shader.fragment");
+	ResourceManager->ShaderManager.AddShader("ColorShader", "shaders/color-shader.vertex", "shaders/color-shader.fragment");
+	ResourceManager->ShaderManager.AddShader(ParticleEffect::PARTICLE_SHADER, "shaders/particle-shader.vertex", "shaders/particle-shader.fragment");
+	Renderer->PushShader("ColorShader");
 
-	ResourceManager->TexList.AddTexture("console_bkg.bmp");
+	float width = Renderer->GetScreenWidth();
+	float height = Renderer->GetScreenHeight();
 
-	ResourceManager->TexList.AddTexture("background.jpg");
-	ResourceManager->TexList.AddTexture("pimgpsh.jpg");
-	ResourceManager->TexList.AddTexture("HeightMap.png");
-	ResourceManager->TexList.AddTexture("NormalMap.png");
-	ResourceManager->TexList.AddTexture("linesAll.png");
-	ResourceManager->TexList.AddTexture("clean-fabric-texture-4-780x585.jpg");
+	Renderer->SetOrthoProjection();
+	Renderer->PushProjectionMatrix(width, height, -500, 500);
+	//Renderer->SetFullScreenViewport();
 
-	ResourceManager->TexList.AddTexture("free-detailed-tiled-rope-texture-3d-model-low-poly-blend.png");
+	boost::property_tree::ptree JSONsource;
 
-	//
-	/*
-	fabricRender.second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].reserve(90000000);
-	fabricRender.second.Data.Vec3CoordArr[CONST_STRING_NORMAL_ATTRIB].reserve(90000000);
-	fabricRender.second.Data.Vec3CoordArr[CONST_STRING_COLOR_ATTRIB].reserve(90000000);
-	fabricRender.second.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].reserve(90000000);
+	boost::property_tree::json_parser::read_json(ST::PathToResources + "config.json", JSONsource);
 
-	*/
+	std::string effectJSON = JSONsource.get<std::string>("effect");
 
-	posArr.resize(20000000);
-	normArr.resize(20000000);
-	texCoordArr.resize(20000000);
-	colorArr.resize(20000000);
+	boost::property_tree::json_parser::read_json(ST::PathToResources + effectJSON, JSONsource);
 
+	sparkler.parse(JSONsource); // parse JSON
 
+	sparkler.load(); // load textures
 
-	ResourceManager->FrameManager.AddFrameRenderBuffer("LevelBuffer", 512, 512);
-
-	Vector2f const bottomLeft(-500, -500);
-	float const W = 1000;
-	float const H = 1000;
-
-	Vector2f const backgroundBottomLeft(-3000, -3000);
-	float const backgroundW = 6000;
-	float const backgroundH = 6000;
-	
-	{
-		//resolution of background image
-		//float const imageW = 512;
-		//float const imageH = 512;
-
-		float const imageW = 2048;
-		float const imageH = 2048;
-
-
-
-		background.second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].emplace_back(Vector3f(backgroundBottomLeft[0], 0, backgroundBottomLeft[1]));
-		background.second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].emplace_back(Vector3f(backgroundBottomLeft[0], 0, backgroundBottomLeft[1] + backgroundH));
-		background.second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].emplace_back(Vector3f(backgroundBottomLeft[0] + backgroundW, 0, backgroundBottomLeft[1] + backgroundH));
-		
-		background.second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].emplace_back(Vector3f(backgroundBottomLeft[0] + backgroundW, 0, backgroundBottomLeft[0] + backgroundH));
-		background.second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].emplace_back(Vector3f(backgroundBottomLeft[0] + backgroundW, 0, backgroundBottomLeft[0]));
-		background.second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].emplace_back(Vector3f(backgroundBottomLeft[0], 0, backgroundBottomLeft[0]));
-
-		float const tw = backgroundW / imageW;
-		float const th = backgroundH / imageH;
-
-		background.second.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].emplace_back(Vector2f(0, th));
-		background.second.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].emplace_back(Vector2f(0, 0));
-		background.second.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].emplace_back(Vector2f(tw, 0));
-		
-		background.second.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].emplace_back(Vector2f(tw, 0));
-		background.second.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].emplace_back(Vector2f(tw, th));
-		background.second.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].emplace_back(Vector2f(0, th));
-
-		background.second.Data.Vec4CoordArr[CONST_STRING_COLOR_ATTRIB].emplace_back(Vector4f(1, 1, 1, 1));
-		background.second.Data.Vec4CoordArr[CONST_STRING_COLOR_ATTRIB].emplace_back(Vector4f(1, 1, 1, 1));
-		background.second.Data.Vec4CoordArr[CONST_STRING_COLOR_ATTRIB].emplace_back(Vector4f(1, 1, 1, 1));
-
-		background.second.Data.Vec4CoordArr[CONST_STRING_COLOR_ATTRIB].emplace_back(Vector4f(1, 1, 1, 1));
-		background.second.Data.Vec4CoordArr[CONST_STRING_COLOR_ATTRIB].emplace_back(Vector4f(1, 1, 1, 1));
-		background.second.Data.Vec4CoordArr[CONST_STRING_COLOR_ATTRIB].emplace_back(Vector4f(1, 1, 1, 1));
-	
-	}
-
-	auto findPlaneBasis = [] (const Vector3f &normal) {
-		std::vector<Vector3f> result;
-
-		Vector3f e0, e1;
-		if(normal.z() != 0)
-		{
-			e0 = Vector3f(1, 0, -normal.x() / normal.z()).normalized();
-			e1 = Vector3f(0, 1, -normal.y() / normal.z());
-		}
-		else if(normal.y() != 0)
-		{
-			e0 = Vector3f(1, -normal.x() / normal.y(), 0).normalized();
-			e1 = Vector3f(0, -normal.z() / normal.y(), 1);
-		}
-		else
-		{
-			e0 = Vector3f(-normal.y() / normal.x(), 1, 0).normalized();
-			e1 = Vector3f(-normal.z() / normal.x(), 0, 1);
-		}
-
-		e1 = (e1 - (e1.dot(e0) / e0.dot(e0)) * e0).normalized();
-
-		result.push_back(e0);
-		result.push_back(e1);
-
-		return result;
-	};
-
-	{
-		//float const R = 3;
-		float const R = 0;
-		//float const r = 4;
-		//float const r = 16;
-		float const r = 19;
-		//size_t const threadsCount = 3;
-		size_t const threadsCount = 1;
-		size_t const edgesCount = 6;
-		//float const angle = pi / 6;
-		float const angle = 0;
-		Vector3f up(0, 1, 0); up.normalize();
-		
-		//size_t const step = 5;
-		float const step = 20;
-
-		const Vector3f vshift = Vector3f(0.f, 0.002f, 0.f);
-		int vShiftVal = 0;
-		
-		auto g = [&] (Vector3f start, Vector3f end, const Vector3f &color, int x) {
-			Vector3f direction = (end - start).normalized();
-			end = end - (r + R) * direction;
-			float iterationsCount = (end - start).norm() / step;
-			auto e = findPlaneBasis(up);
-
-			std::vector<Vector3f> threadCenters;
-			std::vector<std::vector<Vector4f>> threads;
-			for(auto i = 0; i < threadsCount; i++) {
-				std::vector<Vector4f> edges;
-				Vector3f threadCenter = R * (e[0] * cosf(i * 2 * pi / threadsCount) + e[1] * sinf(i * 2 * pi / threadsCount));
-				threadCenters.push_back(threadCenter);
-
-				for(auto j = 0; j < edgesCount; j++) {
-					auto verticeCenter = threadCenter + r * (e[0] * cosf(j * 2 * pi / edgesCount) + e[1] * sinf(j * 2 * pi / edgesCount));
-					edges.push_back(Vector4f(verticeCenter.x(), verticeCenter.y(), verticeCenter.z(), 1));
-				}
-
-				threads.push_back(edges);
-			}
-
-			auto rotateMatrix1 = (
-				Translation3f((r + R) * direction) *
-				AngleAxis<float>(
-					-pi / 8,
-					direction.cross(up).normalized()
-				) *
-				Translation3f(-(r + R) * direction)
-			).matrix();
-			auto matrix = (
-				Translation3f((r + R) * up) *
-				AngleAxis<float>(
-					angle,
-					direction
-				) *
-				Translation3f(-(r + R) * up) *
-				Translation3f(static_cast<int>(step) * direction)
-			).matrix();
-			auto rotateMatrix2 = (
-				Translation3f(static_cast<int>(step) * direction * iterationsCount) *
-				Translation3f((r + R) * direction) *	
-				AngleAxis<float>(
-					-pi / 8,
-					direction.cross(up).normalized()
-					) *
-				Translation3f(-(r + R) * direction) *
-				Translation3f(-static_cast<int>(step) * direction * iterationsCount)
-			).matrix();
-
-			for(int i = -2; i < static_cast<int>(iterationsCount) + 2; i++) {
-				std::vector<std::vector<Vector4f>> newThreads;
-
-				for(auto j = 0; j < threadsCount; j++) {
-					auto edges = threads[j];
-					std::vector<Vector4f> newEdges;
-
-					for(auto k = 0; k < edgesCount; k++) {
-						if(i < 0) {
-							newEdges.push_back(rotateMatrix1 * edges[k]);
-						} else if(i < iterationsCount) {
-							newEdges.push_back(matrix * edges[k]);
-						} else {
-							newEdges.push_back(rotateMatrix2 * edges[k]);
-						}
-					}
-
-					newThreads.push_back(newEdges);
-
-					auto threadCenter_ = Vector4f(threadCenters[j].x(), threadCenters[j].y(), threadCenters[j].z(), 1);
-					auto threadCenter = threadCenter_.head(3);
-
-					Vector3f newThreadCenter;
-					if (i < 0) {
-						newThreadCenter = (rotateMatrix1 * threadCenter_).head(3);
-					} else if (i < iterationsCount) {
-						newThreadCenter = (matrix * threadCenter_).head(3);
-					} else {
-						newThreadCenter = (rotateMatrix2 * threadCenter_).head(3);
-					}
-
-					threadCenters[j] = newThreadCenter;
-					
-					for(auto k = 0; k < edgesCount; k++) {
-						auto vk = edges[k].head(3);
-						auto vk1 = edges[(k + 1) % edgesCount].head(3);
-						auto nvk = newEdges[k].head(3);
-						auto nvk1 = newEdges[(k + 1) % edgesCount].head(3);
-
-						posArr[posArrIndex] = start + vk + vshift*x;
-						posArrIndex++;
-
-						posArr[posArrIndex] = start + vk1 + vshift * x;
-						posArrIndex++;
-
-						//posArr[posArrIndex] = start + nvk;
-						//posArrIndex++;
-
-						//posArr[posArrIndex] = start + vk1;
-						//posArrIndex++;
-
-						posArr[posArrIndex] = start + nvk1 + vshift * x;
-						posArrIndex++;
-
-						posArr[posArrIndex] = start + nvk + vshift*x;
-						posArrIndex++;
-
-
-						normArr[normArrIndex] = vk - threadCenter;
-						normArrIndex++;
-
-						normArr[normArrIndex] = vk1 - threadCenter;
-						normArrIndex++;
-
-						//normArr[normArrIndex] = nvk - newThreadCenter;
-						//normArrIndex++;
-
-						//normArr[normArrIndex] = vk1 - threadCenter;
-						//normArrIndex++;
-
-						normArr[normArrIndex] = nvk1 - newThreadCenter;
-						normArrIndex++;
-
-						normArr[normArrIndex] = nvk - newThreadCenter;
-						normArrIndex++;
-
-
-
-						
-						texCoordArr[texCoordArrIndex] = Vector2f((float)(k) / (edgesCount), (i + 2) / 4.f);
-						texCoordArrIndex++;
-
-						texCoordArr[texCoordArrIndex] = Vector2f((float)(k+10) / (edgesCount), (i + 2) / 4.f);
-						texCoordArrIndex++;
-
-						//texCoordArr[texCoordArrIndex] = Vector2f(0.1, 0.2);
-						//texCoordArrIndex++;
-
-						//texCoordArr[texCoordArrIndex] = Vector2f(0.2, 0.1);
-						//texCoordArrIndex++;
-
-						texCoordArr[texCoordArrIndex] = Vector2f((float)(k + 10) / (edgesCount), (i + 3) / 4.f);
-						texCoordArrIndex++;
-
-						texCoordArr[texCoordArrIndex] = Vector2f((float)k / (edgesCount), (i + 3) / 4.f);
-						texCoordArrIndex++;
-						
-
-						colorArr[colorArrIndex] = color;
-						colorArrIndex++;
-
-						colorArr[colorArrIndex] = color;
-						colorArrIndex++;
-
-						colorArr[colorArrIndex] = color;
-						colorArrIndex++;
-
-						//colorArr[colorArrIndex] = color;
-						//colorArrIndex++;
-
-						colorArr[colorArrIndex] = color;
-						colorArrIndex++;
-
-						//colorArr[colorArrIndex] = color;
-						//colorArrIndex++;
-
-
-
-
-						/*
-						fabricRender.second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(start + vk);
-						fabricRender.second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(start + vk1);
-						fabricRender.second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(start + nvk);
-						fabricRender.second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(start + vk1);
-						fabricRender.second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(start + nvk1);
-						fabricRender.second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(start + nvk);
-
-						fabricRender.second.Data.Vec3CoordArr[CONST_STRING_NORMAL_ATTRIB].push_back((vk - threadCenter));
-						fabricRender.second.Data.Vec3CoordArr[CONST_STRING_NORMAL_ATTRIB].push_back((vk1 - threadCenter));
-						fabricRender.second.Data.Vec3CoordArr[CONST_STRING_NORMAL_ATTRIB].push_back((nvk - newThreadCenter));
-						fabricRender.second.Data.Vec3CoordArr[CONST_STRING_NORMAL_ATTRIB].push_back((vk1 - threadCenter));
-						fabricRender.second.Data.Vec3CoordArr[CONST_STRING_NORMAL_ATTRIB].push_back((nvk1 - newThreadCenter));
-						fabricRender.second.Data.Vec3CoordArr[CONST_STRING_NORMAL_ATTRIB].push_back((nvk - newThreadCenter));
-
-						fabricRender.second.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].push_back(Vector2f(0.1, 0.1));
-						fabricRender.second.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].push_back(Vector2f(0.2, 0.1));
-						fabricRender.second.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].push_back(Vector2f(0.1, 0.2));
-						fabricRender.second.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].push_back(Vector2f(0.2, 0.1));
-						fabricRender.second.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].push_back(Vector2f(0.2, 0.2));
-						fabricRender.second.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].push_back(Vector2f(0.1, 0.2));
-
-						fabricRender.second.Data.Vec3CoordArr[CONST_STRING_COLOR_ATTRIB].push_back(color);
-						fabricRender.second.Data.Vec3CoordArr[CONST_STRING_COLOR_ATTRIB].push_back(color);
-						fabricRender.second.Data.Vec3CoordArr[CONST_STRING_COLOR_ATTRIB].push_back(color);
-						fabricRender.second.Data.Vec3CoordArr[CONST_STRING_COLOR_ATTRIB].push_back(color);
-						fabricRender.second.Data.Vec3CoordArr[CONST_STRING_COLOR_ATTRIB].push_back(color);
-						fabricRender.second.Data.Vec3CoordArr[CONST_STRING_COLOR_ATTRIB].push_back(color);
-						*/
-					}
-				}
-
-				threads = newThreads;
-			}
-		};
-
-		{
-			namespace pt = boost::property_tree;
-			pt::ptree root;
-			//pt::read_json(ST::PathToResources + "lines.json", root);
-			//pt::read_json(ST::PathToResources + "lines100500.json", root);
-			pt::read_json(ST::PathToResources + "lines100500.json", root);
-
-			int x = 0;
-
-			for(auto line: root.get_child("lines")) {
-				std::vector<int> start;
-				std::vector<int> end;
-				std::vector<float> color;
-
-				for(auto value: line.second.get_child("start")) {
-					start.push_back(value.second.get_value<int>());
-				}
-
-				for (auto value : line.second.get_child("end")) {
-					end.push_back(value.second.get_value<int>());
-				}
-
-				for (auto value : line.second.get_child("color")) {
-					color.push_back(value.second.get_value<float>());
-				}
-
-				g(Vector3f(start[0], 0, start[1]), Vector3f(end[0], 0, end[1]), Vector3f(color[0], color[1], color[2]), x);
-				x++;
-			}
-
-		}
-	}
-
-	background.first.ShaderName ="DefaultShader";
-	fabricRender.first.ShaderName = "SimpleShading";
-	//fabricRender.first.ShaderName = "SimpleShadingNoTex";
-	
-	/*
-	 *	Line below should be in tes-engine/include/ShaderManager/ShaderManager.h
-	 */
-	std::string const CONST_STRING_HEIGHTMAP_UNIFORM = "HeightMap";
-
-	background.first.SamplerMap[CONST_STRING_TEXTURE_UNIFORM] = "pimgpsh.jpg";
-
-	fabricRender.first.SamplerMap[CONST_STRING_NORMALMAP_UNIFORM] = "NormalMap.png";
-	fabricRender.first.SamplerMap[CONST_STRING_HEIGHTMAP_UNIFORM] = "HeightMap.png";
-	//fabricRender.first.SamplerMap[CONST_STRING_TEXTURE_UNIFORM] = "clean-fabric-texture-4-780x585.jpg";
-	fabricRender.first.SamplerMap[CONST_STRING_TEXTURE_UNIFORM] = "free-detailed-tiled-rope-texture-3d-model-low-poly-blend.png";
-	fabricRender.first.Vec4Map[CONST_STRING_LIGHT_DIRECTION_UNIFORM] = Vector4f(0, -1, 0, 0);
-
-	background.second.RefreshBuffer();
-	//fabricRender.second.RefreshBuffer();
-
-
-	fabricRender.second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].clear();
-	fabricRender.second.Data.Vec3CoordArr[CONST_STRING_NORMAL_ATTRIB].clear();
-	fabricRender.second.Data.Vec3CoordArr[CONST_STRING_COLOR_ATTRIB].clear();
-	fabricRender.second.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].clear();
-
-	glGenBuffers(1, &posBuffer);
-
-	glBindBuffer(GL_ARRAY_BUFFER, posBuffer);
-
-	glBufferData(GL_ARRAY_BUFFER, posArr.size() * 12, &posArr[0], GL_STATIC_DRAW);
-
-
-
-	glGenBuffers(1, &normBuffer);
-
-	glBindBuffer(GL_ARRAY_BUFFER, normBuffer);
-
-	glBufferData(GL_ARRAY_BUFFER, normArr.size() * 12, &normArr[0], GL_STATIC_DRAW);
-
-
-
-	glGenBuffers(1, &colorBuffer);
-
-	glBindBuffer(GL_ARRAY_BUFFER, colorBuffer);
-
-	glBufferData(GL_ARRAY_BUFFER, colorArr.size() * 12, &colorArr[0], GL_STATIC_DRAW);
-
-
-
-	glGenBuffers(1, &texCoordBuffer);
-
-	glBindBuffer(GL_ARRAY_BUFFER, texCoordBuffer);
-
-	glBufferData(GL_ARRAY_BUFFER, texCoordArr.size() * 8, &texCoordArr[0], GL_STATIC_DRAW);
-
-
-	glDisable(GL_DEPTH_TEST);
-	
-	Inited = true;
+	sparkler.setCoords({ width / 2, height / 2, 0 });
 }
 
 void TMyApplication::InnerDeinit()
 {
-    Inited = false;
-    Loaded = false;
-    if (Console != NULL)
+}
+
+void TMyApplication::InnerOnMouseDown(TMouseState& mouseState)
+{
+	if (mouseState.LeftButtonPressed)
 	{
-        *Console<<"APP DEINIT\n";
+		sparkler.setCoords({ (float)mouseState.X, Renderer->GetScreenHeight() - (float)mouseState.Y, 0 });
 	}
-
-}
-
-void TMyApplication::InnerOnTapDown(Vector2f p)
-{
-	posArr.clear();
-	normArr.clear();
-	colorArr.clear();
-	
-	//fabricRender.second.Data.Vec2CoordArr.clear();
-	//fabricRender.second.Data.Vec3CoordArr.clear();
-}
-
-void TMyApplication::InnerOnTapUp(Vector2f p)
-{
-
-}
-
-void TMyApplication::InnerOnTapUpAfterMove(Vector2f p)
-{
-
-}
-
-void TMyApplication::InnerOnMove(Vector2f p, Vector2f shift)
-{
-	phi += shift(1)*0.02f;
-
-	if (phi < pi/12)
+	if (mouseState.RightButtonPressed)
 	{
-		phi = pi / 12;
+		if (sparkler.isSpawning())
+		{
+			sparkler.stopSpawn();
 		}
-
-	if (phi > pi / 2)
+		else
 		{
-		phi = pi / 2;
+			sparkler.startSpawn();
+		}
 	}
-
-	alpha -= shift(0)*0.02f;
 }
 
-void TMyApplication::OnFling(Vector2f v) 
+void TMyApplication::InnerOnMouseMove(TMouseState& mouseState)
 {
-}
-
-void TMyApplication::OnMouseWheel(short int delta)
-{
-	distance += delta;
-
-	/*if (distance > 2500)
+	if (mouseState.LeftButtonPressed)
 	{
-		distance = 2500;
-	}*/
-
-	if (distance < 100)
-	{
-		distance = 100;
+		sparkler.setCoords({ (float)mouseState.X, Renderer->GetScreenHeight() - (float)mouseState.Y, 0 });
 	}
 }
 	
 void TMyApplication::InnerDraw()
 {
+	glDisable(GL_DEPTH_TEST);
 
-	Renderer->SetPerspectiveProjection(pi / 6, 100.f, 40000.f);
-
-	Renderer->SetFullScreenViewport();
-
-	Renderer->PushMatrix();
-
-	Renderer->TranslateMatrix(Vector3f(0, 0, -distance));
-
-	Vector4f quat1 = Vector4f(sin(phi / 2), 0, 0, cos(phi / 2));
-	Vector4f quat2 = Vector4f(0, sin(alpha / 2), 0, cos(alpha / 2));
-
-
-	Renderer->RotateMatrix(quat1);
-
-	Renderer->RotateMatrix(quat2);
-
-	glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
-	glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
-	
-	CheckGlError("");
-
-	auto mat1 = quatToMatrix(quat1);
-
-	auto mat2 = quatToMatrix(quat2);
-
-	Vector3f lightPos = {0.f, 1.f, 1.f};
-
-	Vector3f eye = mat2 * mat1 * Vector3f(0.0f, 0.f, -distance);
-
-	{
-		TRenderParamsSetter params(background.first);
-
-		RenderUniform3fv("eye", eye.data());
-		RenderUniform3fv("lightPos", lightPos.data());
-
-		Matrix3f normMatrix = Renderer->GetModelviewMatrix().inverse().transpose().block<3, 3>(0, 0);
-
-		RenderUniformMatrix3fv("NormalMatrix", false, normMatrix.data());
-		RenderUniformMatrix4fv("ModelViewMatrix", false, Renderer->GetModelviewMatrix().data());
-		RenderUniformMatrix3fv("ModelViewMatrix3x3", false, Renderer->GetModelviewMatrix().block<3, 3>(0, 0).data());
-
-		Renderer->DrawTriangleList(background.second);
-	}
-
-
-
-
-	//glEnable(GL_CULL_FACE);
-
-	
-	{
-		TRenderParamsSetter params(fabricRender.first);
-
-		RenderUniform3fv("eye", eye.data());
-		RenderUniform3fv("lightPos", lightPos.data());
-
-		Matrix3f normMatrix = Renderer->GetModelviewMatrix().inverse().transpose().block<3,3>(0,0);
-		
-		RenderUniformMatrix3fv("NormalMatrix", false, normMatrix.data());
-		RenderUniformMatrix4fv("ModelViewMatrix", false, Renderer->GetModelviewMatrix().data());
-		RenderUniformMatrix3fv("ModelViewMatrix3x3", false, Renderer->GetModelviewMatrix().block<3,3>(0,0).data());
-
-
-		glBindBuffer(GL_ARRAY_BUFFER, posBuffer);
-		VertexAttribPointer3fv(CONST_STRING_POSITION_ATTRIB, 0, NULL);
-
-		glBindBuffer(GL_ARRAY_BUFFER, normBuffer);
-		VertexAttribPointer3fv(CONST_STRING_NORMAL_ATTRIB, 0, NULL);
-
-		glBindBuffer(GL_ARRAY_BUFFER, colorBuffer);
-		VertexAttribPointer3fv(CONST_STRING_COLOR_ATTRIB, 0, NULL);
-
-		glBindBuffer(GL_ARRAY_BUFFER, texCoordBuffer);
-		VertexAttribPointer2fv(CONST_STRING_TEXCOORD_ATTRIB, 0, NULL);
-
-
-		glDrawArrays(GL_QUADS, 0, posArrIndex);
-
-
-		//Renderer->DrawTriangleList(fabricRender.second);		
-	}
-
-
-	Renderer->PopMatrix();
-
-	CheckGlError("");
-	
+	glClearColor(0, 0, 0, 0);
+	glClear(GL_COLOR_BUFFER_BIT);
 
+	sparkler.draw();
 }
 
 
 void TMyApplication::InnerUpdate(size_t dt)
 {
+	if (dt > 50)
+	{
+		dt = 50;
+	}
 
-}
-
-bool TMyApplication::IsLoaded()
-{
-    return Loaded;
-}
-
-bool TMyApplication::IsInited()
-{
-    return Inited;
+	sparkler.update(dt / 1000.f);
 }

game/main_code.h

@@ -20,28 +20,29 @@
 #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;
 
+
+extern boost::signals2::signal<void(Vector2f)> OnTapUpSignal;
+extern boost::signals2::signal<void(Vector2f)> OnTapUpAfterMoveSignal;
+
+extern boost::signals2::signal<void(Vector2f)> OnTapDownSignal;
+extern boost::signals2::signal<void(Vector2f)> OnFlingSignal;
+extern boost::signals2::signal<void(Vector2f)> OnScrollSignal;
+
+extern boost::signals2::signal<void()> OnDrawSignal;
+
 class TMyApplication : public TApplication
 {
 protected:
-
-	bool Inited;
+	ParticleEffect sparkler;
 
 public:
-	TRenderPair fabricRender;
-	TRenderPair background;
-
-	bool Loaded;
-
-	TMyApplication() : TApplication(), Loaded(false), Inited(false) { }
+	TMyApplication() : TApplication() { }
 
 	virtual void InnerInit();
 
@@ -51,34 +52,14 @@ public:
 
 	virtual void InnerUpdate(size_t dt);
 
-	bool IsLoaded();
+	virtual void InnerOnMouseDown(TMouseState& mouseState);
 
-	bool IsInited();
+	virtual void InnerOnMouseMove(TMouseState& mouseState);
 
-
-	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

@@ -1,220 +0,0 @@
-#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

@@ -1,41 +0,0 @@
-#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

windows/DoubleHitBalls-win/DoubleHitBalls-win/DoubleHitBalls-win.vcxproj

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Debug|Win32">
       <Configuration>Debug</Configuration>
@@ -22,34 +22,33 @@
     <ProjectGuid>{1CC98EEE-BBCB-4D79-B6D7-8511789172C5}</ProjectGuid>
     <Keyword>Win32Proj</Keyword>
     <RootNamespace>DoubleHitBallswin</RootNamespace>
-    <WindowsTargetPlatformVersion>10.0.16299.0</WindowsTargetPlatformVersion>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
     <CharacterSet>NotSet</CharacterSet>
-    <PlatformToolset>v141</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
     <CharacterSet>NotSet</CharacterSet>
-    <PlatformToolset>v141</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>NotSet</CharacterSet>
-    <PlatformToolset>v141</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>NotSet</CharacterSet>
-    <PlatformToolset>v141</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
   <ImportGroup Label="ExtensionSettings">
@@ -117,7 +116,7 @@
     <Link>
       <SubSystem>Windows</SubSystem>
       <GenerateDebugInformation>true</GenerateDebugInformation>
-      <AdditionalLibraryDirectories>../../../game;../../../../tes-engine;../../../../eigen;../../../../boost_1_63_0/stage/x64/lib;../../../../boost_1_63_0/bin.v2/libs/system/build/msvc-14.0/debug/address-model-64/link-static/threading-multi;../../../../boost_1_63_0/bin.v2/libs/date_time/build/msvc-14.0/debug/address-model-64/link-static/threading-multi/;../../../../boost_1_63_0/bin.v2/libs/regex/build/msvc-14.0/debug/address-model-64/link-static/threading-multi;../../../../boost_1_63_0/bin.v2/libs/thread/build/msvc-14.0/debug/address-model-64/link-static/threading-multi;../../../../boost_1_63_0/bin.v2/libs/chrono/build/msvc-14.0/debug/address-model-64/link-static/threading-multi;../../../../boost_1_63_0/bin.v2/libs/signals/build/msvc-14.0/debug/address-model-64/link-static/threading-multi;../../../../libs/boost-gil-extension;../../../../libs/jpeg-9;../../../../libs/jpeg-9/vc10;../../../../libs/lpng1510;../x64/Debug</AdditionalLibraryDirectories>
+      <AdditionalLibraryDirectories>../../../game;../../../../tes-engine;../../../../eigen;../../../../boost_1_63_0/;../../../../boost_1_63_0/bin.v2/libs/system/build/msvc-14.0/debug/address-model-64/link-static/threading-multi;../../../../boost_1_63_0/bin.v2/libs/date_time/build/msvc-14.0/debug/address-model-64/link-static/threading-multi/;../../../../boost_1_63_0/bin.v2/libs/regex/build/msvc-14.0/debug/address-model-64/link-static/threading-multi;../../../../boost_1_63_0/bin.v2/libs/thread/build/msvc-14.0/debug/address-model-64/link-static/threading-multi;../../../../boost_1_63_0/bin.v2/libs/chrono/build/msvc-14.0/debug/address-model-64/link-static/threading-multi;../../../../boost_1_63_0/bin.v2/libs/filesystem/build/msvc-14.0/debug/address-model-64/link-static/threading-multi;../../../../boost_1_63_0/bin.v2/libs/signals/build/msvc-14.0/debug/address-model-64/link-static/threading-multi;../../../../libs/boost-gil-extension;../../../../libs/jpeg-9;../../../../libs/jpeg-9/vc10;../../../../libs/lpng1510;../x64/Debug</AdditionalLibraryDirectories>
       <AdditionalDependencies>libjpeg.lib;libpng.lib;Engine.lib;opengl32.lib;glu32.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>
@@ -151,15 +150,16 @@
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;TARGET_WIN32;_WIN32_WINNT=0x0501;WIN32_LEAN_AND_MEAN;EIGEN_DONT_ALIGN_STATICALLY;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <AdditionalIncludeDirectories>../../../game;../../../../tes-engine;../../../../eigen;../../../../boost_1_67_0/;../../../../libs/boost-gil-extension;../../../../libs/jpeg-9;../../../../libs/jpeg-9/vc10;../../../../libs/lpng1510</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>../../../game;../../../../tes-engine;../../../../eigen;../../../../boost_1_63_0/;../../../../boost_1_63_0/bin.v2/libs/system/build/msvc-14.0/release/address-model-64/link-static/threading-multi;../../../../boost_1_63_0/bin.v2/libs/date_time/build/msvc-14.0/release/address-model-64/link-static/threading-multi/;../../../../boost_1_63_0/bin.v2/libs/regex/build/msvc-14.0/release/address-model-64/link-static/threading-multi;../../../../boost_1_63_0/bin.v2/libs/thread/build/msvc-14.0/release/address-model-64/link-static/threading-multi;../../../../boost_1_63_0/bin.v2/libs/chrono/build/msvc-14.0/release/address-model-64/link-static/threading-multi;../../../../boost_1_63_0/bin.v2/libs/signals/build/msvc-14.0/release/address-model-64/link-static/threading-multi;../../../../libs/boost-gil-extension;../../../../libs/jpeg-9;../../../../libs/jpeg-9/vc10;../../../../libs/lpng1510</AdditionalIncludeDirectories>
       <DisableSpecificWarnings>4503</DisableSpecificWarnings>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
-      <AdditionalLibraryDirectories>../../../game;../../../../tes-engine;../../../../eigen;../../../../boost_1_67_0/stage/lib;../../../../libs/boost-gil-extension;../../../../libs/jpeg-9;../../../../libs/jpeg-9/vc10;../../../../libs/lpng1510;../x64/Release</AdditionalLibraryDirectories>
+      <AdditionalLibraryDirectories>../../../game;../../../../tes-engine;../../../../eigen;../../../../boost_1_63_0/;../../../../boost_1_63_0/stage/x64/lib;../../../../boost_1_63_0/bin.v2/libs/system/build/msvc-14.0/release/address-model-64/link-static/threading-multi;../../../../boost_1_63_0/bin.v2/libs/date_time/build/msvc-14.0/release/address-model-64/link-static/threading-multi/;../../../../boost_1_63_0/bin.v2/libs/regex/build/msvc-14.0/release/address-model-64/link-static/threading-multi;../../../../boost_1_63_0/bin.v2/libs/thread/build/msvc-14.0/release/address-model-64/link-static/threading-multi;../../../../boost_1_63_0/bin.v2/libs/chrono/build/msvc-14.0/release/address-model-64/link-static/threading-multi;../../../../boost_1_63_0/bin.v2/libs/signals/build/msvc-14.0/release/address-model-64/link-static/threading-multi;../../../../libs/boost-gil-extension;../../../../libs/jpeg-9;../../../../libs/jpeg-9/vc10;../../../../libs/lpng1510;../x64/Release</AdditionalLibraryDirectories>
       <AdditionalDependencies>libjpeg.lib;libpng.lib;Engine.lib;opengl32.lib;glu32.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>

windows/DoubleHitBalls-win/DoubleHitBalls-win/DoubleHitBalls-win.vcxproj.filters

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Файлы исходного кода">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Заголовочные файлы">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+    <Filter Include="Файлы ресурсов">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="main.cpp">
+      <Filter>Файлы исходного кода</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\game\main_code.cpp">
+      <Filter>Файлы исходного кода</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="main.h">
+      <Filter>Заголовочные файлы</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\game\main_code.h">
+      <Filter>Заголовочные файлы</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>

windows/DoubleHitBalls-win/DoubleHitBalls-win/DoubleHitBalls-win.vcxproj.user

@@ -1,4 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup />
 </Project>

windows/DoubleHitBalls-win/DoubleHitBalls-win/main.cpp

@@ -8,8 +8,8 @@ int APIENTRY WinMain(HINSTANCE hCurrentInst, HINSTANCE hPreviousInst,
 	LPSTR lpszCmdLine, int nCmdShow)
 {
 
-	int width = 1024;
-	int height = 1024;
+	int width = 1280;
+	int height = 720;
 
 
 	if (CreateEngine(width, height))