Working on examples

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

@@ -10,9 +10,9 @@ varying vec3 ts_light_pos;
 varying vec3 ts_view_pos;
 varying vec3 ts_frag_pos;
 
-const float num_layers = 16.0;
+const float num_layers = 8.0;
 
-const float depth_scale = 0.01;
+const float depth_scale = 0.002;
 
 
 

assets/phong_fragment.txt

@@ -0,0 +1,50 @@
+precision mediump float;
+uniform sampler2D Texture;
+uniform float Transparency;
+
+
+varying vec3 position;
+varying vec3 normal;
+varying vec2 texCoord;
+
+uniform vec3 lightPos;
+uniform vec3 cameraPos;
+uniform vec3 ambientLight;
+uniform vec3 diffuseLight;
+uniform vec3 specularLight;
+uniform float specularPower;
+
+void phongModel( vec3 norm, out vec3 ambAndDiff, out vec3 spec ) 
+{
+    vec3 lightDirection =  normalize(vec3(lightPos));
+	vec3 cameraDirection =  normalize(vec3(cameraPos) - position);
+    vec3 lightReflection = reflect( -lightDirection, norm );
+
+    float sDotN = max( dot(lightDirection,norm), 0.0 );
+	
+    vec3 diffuse = diffuseLight * sDotN;
+    ambAndDiff = ambientLight + diffuse;
+	
+    spec = vec3(0.0);
+    if(sDotN > 0.0)
+    {
+        spec = specularLight * pow(max( dot(lightReflection, cameraDirection), 0.0 ), specularPower);
+		// spec is NAN, if dot == 0 && specularPower <= 0
+    }
+}
+
+void main()
+{
+    vec3 ambAndDiff, spec;
+	vec3 norm = normalize(normal);	
+	
+	phongModel(norm, ambAndDiff, spec);
+
+    vec4 textureColor = texture2D(Texture, texCoord).rgba;
+	
+	textureColor.r = textureColor.r * ambAndDiff.r + spec.r;
+	textureColor.g = textureColor.g * ambAndDiff.g + spec.g;
+	textureColor.b = textureColor.b * ambAndDiff.b + spec.b;
+	
+	gl_FragColor = textureColor;
+}

assets/phong_vertex.txt

@@ -0,0 +1,25 @@
+attribute vec3 vPosition;
+attribute vec3 vNormal;
+attribute vec2 vTexCoord;
+varying vec3 position;
+varying vec3 normal;
+varying vec2 texCoord;
+
+
+uniform mat4 ProjectionMatrix1;
+uniform mat4 ModelViewMatrix;
+
+void main() 
+{
+
+	mat4 mvp = ProjectionMatrix1 * ModelViewMatrix;
+ 
+	vec4 tnorm = ModelViewMatrix * vec4(vNormal,0.0);
+	normal = normalize(vec3(tnorm));
+	 
+	position = vec3( ModelViewMatrix * vec4(vPosition,1.0) );
+	gl_Position = mvp * vec4(vPosition,1.0);
+	
+	
+	texCoord = vTexCoord;
+}

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;
-}

assets/smaa/blend_fragment.txt

@@ -0,0 +1,422 @@
+#version 410 compatibility
+#define SMAA_PIXEL_SIZE vec2(1.0 / 512.0, 1.0 / 512.0)
+
+
+#define SMAA_THRESHOLD 0.05
+#define SMAA_MAX_SEARCH_STEPS 32
+#define SMAA_MAX_SEARCH_STEPS_DIAG 16
+#define SMAA_CORNER_ROUNDING 25
+
+
+#ifndef SMAA_DEPTH_THRESHOLD
+#define SMAA_DEPTH_THRESHOLD (0.1 * SMAA_THRESHOLD)
+#endif
+
+
+#ifndef SMAA_REPROJECTION
+#define SMAA_REPROJECTION 0
+#endif
+
+#define SMAA_REPROJECTION_WEIGHT_SCALE 30.0
+
+
+#ifndef SMAA_AREATEX_MAX_DISTANCE
+#define SMAA_AREATEX_MAX_DISTANCE 16
+#endif
+#ifndef SMAA_AREATEX_MAX_DISTANCE_DIAG
+#define SMAA_AREATEX_MAX_DISTANCE_DIAG 20
+#endif
+#define SMAA_AREATEX_PIXEL_SIZE (1.0 / vec2(160.0, 560.0))
+#define SMAA_AREATEX_SUBTEX_SIZE (1.0 / 7.0)
+
+
+/* --- Define section is over ---- */
+
+
+
+
+//-----------------------------------------------------------------------------
+// Diagonal Search Functions
+
+/**
+ * These functions allows to perform diagonal pattern searches.
+ */
+float SMAASearchDiag1(sampler2D edgesTex, vec2 texcoord, vec2 dir, float c) {
+    texcoord += dir * SMAA_PIXEL_SIZE;
+    vec2 e = vec2(0.0, 0.0);
+    float i;
+    for (i = 0.0; i < float(SMAA_MAX_SEARCH_STEPS_DIAG); i++) {
+        e.rg = textureLod(edgesTex, texcoord, 0.0).rg;
+        
+		//SMAA_FLATTEN
+		if (dot(e, vec2(1.0, 1.0)) < 1.9) break;
+        
+		texcoord += dir * SMAA_PIXEL_SIZE;
+    }
+    return i + float(e.g > 0.9) * c;
+}
+
+float SMAASearchDiag2(sampler2D edgesTex, vec2 texcoord, vec2 dir, float c) {
+    texcoord += dir * SMAA_PIXEL_SIZE;
+    vec2 e = vec2(0.0, 0.0);
+    float i;
+    for (i = 0.0; i < float(SMAA_MAX_SEARCH_STEPS_DIAG); i++) {
+        e.g = textureLod(edgesTex, texcoord, 0.0).g;
+        e.r = textureLodOffset(edgesTex, texcoord, 0.0, ivec2(1, 0)).r;
+        
+		//SMAA_FLATTEN
+		if (dot(e, vec2(1.0, 1.0)) < 1.9) break;
+        
+		texcoord += dir * SMAA_PIXEL_SIZE;
+    }
+    return i + float(e.g > 0.9) * c;
+}
+
+/** 
+ * Similar to SMAAArea, this calculates the area corresponding to a certain
+ * diagonal distance and crossing edges 'e'.
+ */
+vec2 SMAAAreaDiag(sampler2D areaTex, vec2 dist, vec2 e, float offset) {
+    vec2 texcoord = float(SMAA_AREATEX_MAX_DISTANCE_DIAG) * e + dist;
+
+    // We do a scale and bias for mapping to texel space:
+    texcoord = SMAA_AREATEX_PIXEL_SIZE * texcoord + (0.5 * SMAA_AREATEX_PIXEL_SIZE);
+
+    // Diagonal areas are on the second half of the texture:
+    texcoord.x += 0.5;
+
+    // Move to proper place, according to the subpixel offset:
+    texcoord.y += SMAA_AREATEX_SUBTEX_SIZE * offset;
+
+
+    return textureLod(areaTex, texcoord, 0.0).rg;
+}
+
+/**
+ * This searches for diagonal patterns and returns the corresponding weights.
+ */
+vec2 SMAACalculateDiagWeights(sampler2D edgesTex, sampler2D areaTex, vec2 texcoord, vec2 e, ivec4 subsampleIndices) {
+    vec2 weights = vec2(0.0, 0.0);
+
+    vec2 d;
+    d.x = e.r > 0.0? SMAASearchDiag1(edgesTex, texcoord, vec2(-1.0,  1.0), 1.0) : 0.0;
+    d.y = SMAASearchDiag1(edgesTex, texcoord, vec2(1.0, -1.0), 0.0);
+
+    //SMAA_BRANCH
+    if (d.r + d.g > 2.0) { // d.r + d.g + 1 > 3
+        vec4 coords = fma(vec4(-d.r, d.r, d.g, -d.g), SMAA_PIXEL_SIZE.xyxy, texcoord.xyxy);
+
+        vec4 c;
+        c.x = textureLodOffset(edgesTex, coords.xy, 0.0, ivec2(-1,  0)).g;
+        c.y = textureLodOffset(edgesTex, coords.xy, 0.0, ivec2( 0,  0)).r;
+        c.z = textureLodOffset(edgesTex, coords.zw, 0.0, ivec2( 1,  0)).g;
+        c.w = textureLodOffset(edgesTex, coords.zw, 0.0, ivec2( 1, -1)).r;
+        vec2 e = 2.0 * c.xz + c.yw;
+        float t = float(SMAA_MAX_SEARCH_STEPS_DIAG) - 1.0;
+        e *= step(d.rg, vec2(t, t));
+
+        weights += SMAAAreaDiag(areaTex, d, e, float(subsampleIndices.z));
+    }
+
+    d.x = SMAASearchDiag2(edgesTex, texcoord, vec2(-1.0, -1.0), 0.0);
+    float right = textureLodOffset(edgesTex, texcoord, 0.0, ivec2(1, 0)).r;
+    d.y = right > 0.0? SMAASearchDiag2(edgesTex, texcoord, vec2(1.0, 1.0), 1.0) : 0.0;
+
+    //SMAA_BRANCH
+    if (d.r + d.g > 2.0) { // d.r + d.g + 1 > 3
+        vec4 coords = fma(vec4(-d.r, -d.r, d.g, d.g), SMAA_PIXEL_SIZE.xyxy, texcoord.xyxy);
+
+        vec4 c;
+        c.x  = textureLodOffset(edgesTex, coords.xy, 0.0, ivec2(-1,  0)).g;
+        c.y  = textureLodOffset(edgesTex, coords.xy, 0.0, ivec2( 0, -1)).r;
+        c.zw = textureLodOffset(edgesTex, coords.zw, 0.0, ivec2( 1,  0)).gr;
+        vec2 e = 2.0 * c.xz + c.yw;
+        float t = float(SMAA_MAX_SEARCH_STEPS_DIAG) - 1.0;
+        e *= step(d.rg, vec2(t, t));
+
+        weights += SMAAAreaDiag(areaTex, d, e, float(subsampleIndices.w)).gr;
+    }
+
+    return weights;
+}
+
+
+//-----------------------------------------------------------------------------
+// Horizontal/Vertical Search Functions
+
+/**
+ * This allows to determine how much length should we add in the last step
+ * of the searches. It takes the bilinearly interpolated edge (see 
+ * @PSEUDO_GATHER4), and adds 0, 1 or 2, depending on which edges and
+ * crossing edges are active.
+ */
+float SMAASearchLength(sampler2D searchTex, vec2 e, float bias, float scale) {
+    // Not required if searchTex accesses are set to point:
+    // vec2 SEARCH_TEX_PIXEL_SIZE = 1.0 / vec2(66.0, 33.0);
+    // e = vec2(bias, 0.0) + 0.5 * SEARCH_TEX_PIXEL_SIZE + 
+    //     e * vec2(scale, 1.0) * vec2(64.0, 32.0) * SEARCH_TEX_PIXEL_SIZE;
+    e.r = bias + e.r * scale;
+	e.g = -e.g;
+    return 255.0 * textureLod(searchTex, e, 0.0).r;
+}
+
+/**
+ * Horizontal/vertical search functions for the 2nd pass.
+ */
+float SMAASearchXLeft(sampler2D edgesTex, sampler2D searchTex, vec2 texcoord, float end) {
+    /**
+     * @PSEUDO_GATHER4
+     * This texcoord has been offset by (-0.25, -0.125) in the vertex shader to
+     * sample between edge, thus fetching four edges in a row.
+     * Sampling with different offsets in each direction allows to disambiguate
+     * which edges are active from the four fetched ones.
+     */
+    vec2 e = vec2(0.0, 1.0);
+    while (texcoord.x > end && 
+           e.g > 0.8281 && // Is there some edge not activated?
+           e.r == 0.0) { // Or is there a crossing edge that breaks the line?
+        e = textureLod(edgesTex, texcoord, 0.0).rg;
+        texcoord -= vec2(2.0, 0.0) * SMAA_PIXEL_SIZE;
+    }
+
+    // We correct the previous (-0.25, -0.125) offset we applied:
+    texcoord.x += 0.25 * SMAA_PIXEL_SIZE.x;
+
+    // The searches are bias by 1, so adjust the coords accordingly:
+    texcoord.x += SMAA_PIXEL_SIZE.x;
+
+    // Disambiguate the length added by the last step:
+    texcoord.x += 2.0 * SMAA_PIXEL_SIZE.x; // Undo last step
+    texcoord.x -= SMAA_PIXEL_SIZE.x * SMAASearchLength(searchTex, e, 0.0, 0.5);
+
+    return texcoord.x;
+}
+
+float SMAASearchXRight(sampler2D edgesTex, sampler2D searchTex, vec2 texcoord, float end) {
+    vec2 e = vec2(0.0, 1.0);
+    while (texcoord.x < end && 
+           e.g > 0.8281 && // Is there some edge not activated?
+           e.r == 0.0) { // Or is there a crossing edge that breaks the line?
+        e = textureLod(edgesTex, texcoord, 0.0).rg;
+        texcoord += vec2(2.0, 0.0) * SMAA_PIXEL_SIZE;
+    }
+
+    texcoord.x -= 0.25 * SMAA_PIXEL_SIZE.x;
+    texcoord.x -= SMAA_PIXEL_SIZE.x;
+    texcoord.x -= 2.0 * SMAA_PIXEL_SIZE.x;
+    texcoord.x += SMAA_PIXEL_SIZE.x * SMAASearchLength(searchTex, e, 0.5, 0.5);
+    return texcoord.x;
+}
+
+float SMAASearchYUp(sampler2D edgesTex, sampler2D searchTex, vec2 texcoord, float end) {
+    vec2 e = vec2(1.0, 0.0);
+    while (texcoord.y > end && 
+           e.r > 0.8281 && // Is there some edge not activated?
+           e.g == 0.0) { // Or is there a crossing edge that breaks the line?
+        e = textureLod(edgesTex, texcoord, 0.0).rg;
+        texcoord -= vec2(0.0, 2.0) * SMAA_PIXEL_SIZE;
+    }
+
+    texcoord.y += 0.25 * SMAA_PIXEL_SIZE.y;
+    texcoord.y += SMAA_PIXEL_SIZE.y;
+    texcoord.y += 2.0 * SMAA_PIXEL_SIZE.y;
+    texcoord.y -= SMAA_PIXEL_SIZE.y * SMAASearchLength(searchTex, e.gr, 0.0, 0.5);
+    return texcoord.y;
+}
+
+float SMAASearchYDown(sampler2D edgesTex, sampler2D searchTex, vec2 texcoord, float end) {
+    vec2 e = vec2(1.0, 0.0);
+    while (texcoord.y < end && 
+           e.r > 0.8281 && // Is there some edge not activated?
+           e.g == 0.0) { // Or is there a crossing edge that breaks the line?
+        e = textureLod(edgesTex, texcoord, 0.0).rg;
+        texcoord += vec2(0.0, 2.0) * SMAA_PIXEL_SIZE;
+    }
+    
+    texcoord.y -= 0.25 * SMAA_PIXEL_SIZE.y;
+    texcoord.y -= SMAA_PIXEL_SIZE.y;
+    texcoord.y -= 2.0 * SMAA_PIXEL_SIZE.y;
+    texcoord.y += SMAA_PIXEL_SIZE.y * SMAASearchLength(searchTex, e.gr, 0.5, 0.5);
+    return texcoord.y;
+}
+
+/** 
+ * Ok, we have the distance and both crossing edges. So, what are the areas
+ * at each side of current edge?
+ */
+vec2 SMAAArea(sampler2D areaTex, vec2 dist, float e1, float e2, float offset) {
+    // Rounding prevents precision errors of bilinear filtering:
+    vec2 texcoord = float(SMAA_AREATEX_MAX_DISTANCE) * round(4.0 * vec2(e1, e2)) + dist;
+    
+    // We do a scale and bias for mapping to texel space:
+    texcoord = SMAA_AREATEX_PIXEL_SIZE * texcoord + (0.5 * SMAA_AREATEX_PIXEL_SIZE);
+
+    // Move to proper place, according to the subpixel offset:
+    texcoord.y += SMAA_AREATEX_SUBTEX_SIZE * offset;
+
+
+    return textureLod(areaTex, texcoord, 0.0).rg;
+
+}
+
+//-----------------------------------------------------------------------------
+// Corner Detection Functions
+
+void SMAADetectHorizontalCornerPattern(sampler2D edgesTex, inout vec2 weights, vec2 texcoord, vec2 d) {
+    #if SMAA_CORNER_ROUNDING < 100 || SMAA_FORCE_CORNER_DETECTION == 1
+    vec4 coords = fma(vec4(d.x, 0.0, d.y, 0.0),
+                            SMAA_PIXEL_SIZE.xyxy, texcoord.xyxy);
+    vec2 e;
+    e.r = textureLodOffset(edgesTex, coords.xy, 0.0, ivec2(0.0,  1.0)).r;
+    bool left = abs(d.x) < abs(d.y);
+    e.g = textureLodOffset(edgesTex, coords.xy, 0.0, ivec2(0.0, -2.0)).r;
+    if (left) weights *= clamp(float(SMAA_CORNER_ROUNDING) / 100.0 + 1.0 - e, 0.0, 1.0);
+
+    e.r = textureLodOffset(edgesTex, coords.zw, 0.0, ivec2(1.0,  1.0)).r;
+    e.g = textureLodOffset(edgesTex, coords.zw, 0.0, ivec2(1.0, -2.0)).r;
+    if (!left) weights *= clamp(float(SMAA_CORNER_ROUNDING) / 100.0 + 1.0 - e, 0.0, 1.0);
+    #endif
+}
+
+void SMAADetectVerticalCornerPattern(sampler2D edgesTex, inout vec2 weights, vec2 texcoord, vec2 d) {
+    #if SMAA_CORNER_ROUNDING < 100 || SMAA_FORCE_CORNER_DETECTION == 1
+    vec4 coords = fma(vec4(0.0, d.x, 0.0, d.y),
+                            SMAA_PIXEL_SIZE.xyxy, texcoord.xyxy);
+    vec2 e;
+    e.r = textureLodOffset(edgesTex, coords.xy, 0.0, ivec2( 1.0, 0.0)).g;
+    bool left = abs(d.x) < abs(d.y);
+    e.g = textureLodOffset(edgesTex, coords.xy, 0.0, ivec2(-2.0, 0.0)).g;
+    if (left) weights *= clamp(float(SMAA_CORNER_ROUNDING) / 100.0 + 1.0 - e, 0.0, 1.0);
+
+    e.r = textureLodOffset(edgesTex, coords.zw, 0.0, ivec2( 1.0, 1.0)).g;
+    e.g = textureLodOffset(edgesTex, coords.zw, 0.0, ivec2(-2.0, 1.0)).g;
+    if (!left) weights *= clamp(float(SMAA_CORNER_ROUNDING) / 100.0 + 1.0 - e, 0.0, 1.0);
+    #endif
+}
+
+//-----------------------------------------------------------------------------
+// Blending Weight Calculation Pixel Shader (Second Pass)
+
+vec4 SMAABlendingWeightCalculationPS(vec2 texcoord,
+                                       vec2 pixcoord,
+                                       vec4 offset[3],
+                                       sampler2D edgesTex, 
+                                       sampler2D areaTex, 
+                                       sampler2D searchTex,
+                                       ivec4 subsampleIndices) { // Just pass zero for SMAA 1x, see @SUBSAMPLE_INDICES.
+    vec4 weights = vec4(0.0, 0.0, 0.0, 0.0);
+
+    vec2 e = texture(edgesTex, texcoord).rg;
+
+    //SMAA_BRANCH
+    if (e.g > 0.0) { // Edge at north
+        #if SMAA_MAX_SEARCH_STEPS_DIAG > 0 || SMAA_FORCE_DIAGONAL_DETECTION == 1
+        // Diagonals have both north and west edges, so searching for them in
+        // one of the boundaries is enough.
+        weights.rg = SMAACalculateDiagWeights(edgesTex, areaTex, texcoord, e, subsampleIndices);
+
+        // We give priority to diagonals, so if we find a diagonal we skip 
+        // horizontal/vertical processing.
+        //SMAA_BRANCH
+        if (dot(weights.rg, vec2(1.0, 1.0)) == 0.0) {
+        #endif
+
+        vec2 d;
+
+        // Find the distance to the left:
+        vec2 coords;
+        coords.x = SMAASearchXLeft(edgesTex, searchTex, offset[0].xy, offset[2].x);
+        coords.y = offset[1].y; // offset[1].y = texcoord.y - 0.25 * SMAA_PIXEL_SIZE.y (@CROSSING_OFFSET)
+        d.x = coords.x;
+
+        // Now fetch the left crossing edges, two at a time using bilinear
+        // filtering. Sampling at -0.25 (see @CROSSING_OFFSET) enables to
+        // discern what value each edge has:
+        float e1 = textureLod(edgesTex, coords, 0.0).r;
+
+        // Find the distance to the right:
+        coords.x = SMAASearchXRight(edgesTex, searchTex, offset[0].zw, offset[2].y);
+        d.y = coords.x;
+
+        // We want the distances to be in pixel units (doing this here allow to
+        // better interleave arithmetic and memory accesses):
+        d = d / SMAA_PIXEL_SIZE.x - pixcoord.x;
+
+        // SMAAArea below needs a sqrt, as the areas texture is compressed 
+        // quadratically:
+        vec2 sqrt_d = sqrt(abs(d));
+
+        // Fetch the right crossing edges:
+        float e2 = textureLodOffset(edgesTex, coords, 0.0, ivec2(1, 0)).r;
+
+        // Ok, we know how this pattern looks like, now it is time for getting
+        // the actual area:
+        weights.rg = SMAAArea(areaTex, sqrt_d, e1, e2, float(subsampleIndices.y));
+
+        // Fix corners:
+        SMAADetectHorizontalCornerPattern(edgesTex, weights.rg, texcoord, d);
+
+        #if SMAA_MAX_SEARCH_STEPS_DIAG > 0 || SMAA_FORCE_DIAGONAL_DETECTION == 1
+        } else
+            e.r = 0.0; // Skip vertical processing.
+        #endif
+    }
+
+    //SMAA_BRANCH
+    if (e.r > 0.0) { // Edge at west
+        vec2 d;
+
+        // Find the distance to the top:
+        vec2 coords;
+        coords.y = SMAASearchYUp(edgesTex, searchTex, offset[1].xy, offset[2].z);
+        coords.x = offset[0].x; // offset[1].x = texcoord.x - 0.25 * SMAA_PIXEL_SIZE.x;
+        d.x = coords.y;
+
+        // Fetch the top crossing edges:
+        float e1 = textureLod(edgesTex, coords, 0.0).g;
+
+        // Find the distance to the bottom:
+        coords.y = SMAASearchYDown(edgesTex, searchTex, offset[1].zw, offset[2].w);
+        d.y = coords.y;
+
+        // We want the distances to be in pixel units:
+        d = d / SMAA_PIXEL_SIZE.y - pixcoord.y;
+
+        // SMAAArea below needs a sqrt, as the areas texture is compressed 
+        // quadratically:
+        vec2 sqrt_d = sqrt(abs(d));
+
+        // Fetch the bottom crossing edges:
+        float e2 = textureLodOffset(edgesTex, coords, 0.0, ivec2(0, 1)).g;
+
+        // Get the area for this direction:
+        weights.ba = SMAAArea(areaTex, sqrt_d, e1, e2, float(subsampleIndices.x));
+
+        // Fix corners:
+        SMAADetectVerticalCornerPattern(edgesTex, weights.ba, texcoord, d);
+		
+		//return vec4(weights.ba, 0.0, 1.0);
+    }
+
+    return weights;
+	
+	
+}
+
+
+
+/* ------------- Header is over -------------- */
+
+
+uniform sampler2D edge_tex;
+uniform sampler2D area_tex;
+uniform sampler2D search_tex;
+in vec2 texcoord;
+in vec2 pixcoord;
+in vec4 offset[3];
+in vec4 dummy2;
+void main()
+{
+  gl_FragColor = SMAABlendingWeightCalculationPS(texcoord, pixcoord, offset, edge_tex, area_tex, search_tex, ivec4(0));
+
+}

assets/smaa/blend_vertex.txt

@@ -0,0 +1,74 @@
+#version 410 compatibility
+#define SMAA_PIXEL_SIZE vec2(1.0 / 512.0, 1.0 / 512.0)
+
+#define SMAA_THRESHOLD 0.05
+#define SMAA_MAX_SEARCH_STEPS 32
+#define SMAA_MAX_SEARCH_STEPS_DIAG 16
+#define SMAA_CORNER_ROUNDING 25
+
+
+#ifndef SMAA_DEPTH_THRESHOLD
+#define SMAA_DEPTH_THRESHOLD (0.1 * SMAA_THRESHOLD)
+#endif
+
+
+#ifndef SMAA_REPROJECTION
+#define SMAA_REPROJECTION 0
+#endif
+
+#define SMAA_REPROJECTION_WEIGHT_SCALE 30.0
+
+
+#ifndef SMAA_AREATEX_MAX_DISTANCE
+#define SMAA_AREATEX_MAX_DISTANCE 16
+#endif
+#ifndef SMAA_AREATEX_MAX_DISTANCE_DIAG
+#define SMAA_AREATEX_MAX_DISTANCE_DIAG 20
+#endif
+#define SMAA_AREATEX_PIXEL_SIZE (1.0 / vec2(160.0, 560.0))
+#define SMAA_AREATEX_SUBTEX_SIZE (1.0 / 7.0)
+
+
+/* --- Define section is over ---- */
+
+/**
+ * Blend Weight Calculation Vertex Shader
+ */
+void SMAABlendingWeightCalculationVS(vec4 position,
+                                     out vec4 svPosition,
+                                     inout vec2 texcoord,
+                                     out vec2 pixcoord,
+                                     out vec4 offset[3]) {
+    svPosition = position;
+
+    pixcoord = texcoord / SMAA_PIXEL_SIZE;
+
+    // We will use these offsets for the searches later on (see @PSEUDO_GATHER4):
+    offset[0] = texcoord.xyxy + SMAA_PIXEL_SIZE.xyxy * vec4(-0.25, -0.125,  1.25, -0.125);
+    offset[1] = texcoord.xyxy + SMAA_PIXEL_SIZE.xyxy * vec4(-0.125, -0.25, -0.125,  1.25);
+
+    // And these for the searches, they indicate the ends of the loops:
+    offset[2] = vec4(offset[0].xz, offset[1].yw) + 
+                vec4(-2.0, 2.0, -2.0, 2.0) *
+                SMAA_PIXEL_SIZE.xxyy * float(SMAA_MAX_SEARCH_STEPS);
+}
+
+/* ------------- Header is over -------------- */
+
+out vec2 texcoord;
+out vec2 pixcoord;
+out vec4 offset[3];
+out vec4 dummy2;
+
+attribute vec3 vPosition;
+attribute vec2 vTexCoord;
+uniform mat4 ProjectionMatrix;
+
+
+void main()
+{
+  texcoord = vTexCoord;
+  vec4 dummy1 = vec4(0);
+  SMAABlendingWeightCalculationVS(dummy1, dummy2, texcoord, pixcoord, offset);
+  gl_Position = ProjectionMatrix * vec4(vPosition.xyz, 1.0);
+}

assets/smaa/edge_fragment.txt

@@ -0,0 +1,105 @@
+#version 410 compatibility
+
+#define SMAA_THRESHOLD 0.05
+#define SMAA_MAX_SEARCH_STEPS 32
+#define SMAA_MAX_SEARCH_STEPS_DIAG 16
+#define SMAA_CORNER_ROUNDING 25
+
+
+#ifndef SMAA_DEPTH_THRESHOLD
+#define SMAA_DEPTH_THRESHOLD (0.1 * SMAA_THRESHOLD)
+#endif
+
+
+#ifndef SMAA_REPROJECTION
+#define SMAA_REPROJECTION 0
+#endif
+
+#define SMAA_REPROJECTION_WEIGHT_SCALE 30.0
+
+
+#ifndef SMAA_AREATEX_MAX_DISTANCE
+#define SMAA_AREATEX_MAX_DISTANCE 16
+#endif
+#ifndef SMAA_AREATEX_MAX_DISTANCE_DIAG
+#define SMAA_AREATEX_MAX_DISTANCE_DIAG 20
+#endif
+#define SMAA_AREATEX_PIXEL_SIZE (1.0 / vec2(160.0, 560.0))
+#define SMAA_AREATEX_SUBTEX_SIZE (1.0 / 7.0)
+
+
+/* --- Define section is over ---- */
+
+/**
+ * Color Edge Detection
+ *
+ * IMPORTANT NOTICE: color edge detection requires gamma-corrected colors, and
+ * thus 'colorTex' should be a non-sRGB texture.
+ */
+vec4 SMAAColorEdgeDetectionPS(vec2 texcoord,
+                                vec4 offset[3],
+                                sampler2D colorTex
+                                ) {
+    vec2 threshold = vec2(SMAA_THRESHOLD, SMAA_THRESHOLD);
+
+    // Calculate color deltas:
+    vec4 delta;
+    vec3 C = texture(colorTex, texcoord).rgb;
+
+    vec3 Cleft = texture(colorTex, offset[0].xy).rgb;
+    vec3 t = abs(C - Cleft);
+    delta.x = max(max(t.r, t.g), t.b);
+
+    vec3 Ctop  = texture(colorTex, offset[0].zw).rgb;
+    t = abs(C - Ctop);
+    delta.y = max(max(t.r, t.g), t.b);
+
+    // We do the usual threshold:
+    vec2 edges = step(threshold, delta.xy);
+
+    // Then discard if there is no edge:
+    if (dot(edges, vec2(1.0, 1.0)) == 0.0)
+        discard;
+
+    // Calculate right and bottom deltas:
+    vec3 Cright = texture(colorTex, offset[1].xy).rgb;
+    t = abs(C - Cright);
+    delta.z = max(max(t.r, t.g), t.b);
+
+    vec3 Cbottom  = texture(colorTex, offset[1].zw).rgb;
+    t = abs(C - Cbottom);
+    delta.w = max(max(t.r, t.g), t.b);
+
+    // Calculate the maximum delta in the direct neighborhood:
+    float maxDelta = max(max(max(delta.x, delta.y), delta.z), delta.w);
+
+    // Calculate left-left and top-top deltas:
+    vec3 Cleftleft  = texture(colorTex, offset[2].xy).rgb;
+    t = abs(C - Cleftleft);
+    delta.z = max(max(t.r, t.g), t.b);
+
+    vec3 Ctoptop = texture(colorTex, offset[2].zw).rgb;
+    t = abs(C - Ctoptop);
+    delta.w = max(max(t.r, t.g), t.b);
+
+    // Calculate the final maximum delta:
+    maxDelta = max(max(maxDelta, delta.z), delta.w);
+
+    // Local contrast adaptation in action:
+    edges.xy *= step(0.5 * maxDelta, delta.xy);
+
+    return vec4(edges, 0.0, 0.0);
+	
+}
+
+
+/* ------------- Header is over -------------- */
+
+uniform sampler2D albedo_tex;
+in vec2 texcoord;
+in vec4 offset[3];
+in vec4 dummy2;
+void main()
+{
+    gl_FragColor = SMAAColorEdgeDetectionPS(texcoord, offset, albedo_tex);
+}

assets/smaa/edge_vertex.txt

@@ -0,0 +1,67 @@
+#version 410 compatibility
+#define SMAA_PIXEL_SIZE vec2(1.0/512.0, 1.0/512.0)
+
+#define SMAA_THRESHOLD 0.05
+#define SMAA_MAX_SEARCH_STEPS 32
+#define SMAA_MAX_SEARCH_STEPS_DIAG 16
+#define SMAA_CORNER_ROUNDING 25
+
+
+#ifndef SMAA_DEPTH_THRESHOLD
+#define SMAA_DEPTH_THRESHOLD (0.1 * SMAA_THRESHOLD)
+#endif
+
+
+#ifndef SMAA_REPROJECTION
+#define SMAA_REPROJECTION 0
+#endif
+
+#define SMAA_REPROJECTION_WEIGHT_SCALE 30.0
+
+
+#ifndef SMAA_AREATEX_MAX_DISTANCE
+#define SMAA_AREATEX_MAX_DISTANCE 16
+#endif
+#ifndef SMAA_AREATEX_MAX_DISTANCE_DIAG
+#define SMAA_AREATEX_MAX_DISTANCE_DIAG 20
+#endif
+#define SMAA_AREATEX_PIXEL_SIZE (1.0 / vec2(160.0, 560.0))
+#define SMAA_AREATEX_SUBTEX_SIZE (1.0 / 7.0)
+
+
+/* --- Define section is over ---- */
+
+/**
+ * Edge Detection Vertex Shader
+ */
+void SMAAEdgeDetectionVS(vec4 position,
+                         out vec4 svPosition,
+                         inout vec2 texcoord,
+                         out vec4 offset[3]) {
+    svPosition = position;
+
+    offset[0] = texcoord.xyxy + SMAA_PIXEL_SIZE.xyxy * vec4(-1.0, 0.0, 0.0, -1.0);
+    offset[1] = texcoord.xyxy + SMAA_PIXEL_SIZE.xyxy * vec4( 1.0, 0.0, 0.0,  1.0);
+    offset[2] = texcoord.xyxy + SMAA_PIXEL_SIZE.xyxy * vec4(-2.0, 0.0, 0.0, -2.0);
+}
+
+/* ------------- Header is over -------------- */
+
+out vec2 texcoord;
+out vec4 offset[3];
+out vec4 dummy2;
+
+
+
+attribute vec3 vPosition;
+attribute vec2 vTexCoord;
+uniform mat4 ProjectionMatrix;
+
+
+void main()
+{
+  texcoord = vTexCoord;
+  vec4 dummy1 = vec4(0);
+  SMAAEdgeDetectionVS(dummy1, dummy2, texcoord, offset);
+  gl_Position = ProjectionMatrix * vec4(vPosition.xyz, 1.0);
+}

assets/smaa/neighborhood_fragment.txt

@@ -0,0 +1,102 @@
+#version 410 compatibility
+#define SMAA_PIXEL_SIZE vec2(1.0 / 512.0, 1.0 / 512.0)
+
+#define SMAA_THRESHOLD 0.05
+#define SMAA_MAX_SEARCH_STEPS 32
+#define SMAA_MAX_SEARCH_STEPS_DIAG 16
+#define SMAA_CORNER_ROUNDING 25
+
+
+#ifndef SMAA_DEPTH_THRESHOLD
+#define SMAA_DEPTH_THRESHOLD (0.1 * SMAA_THRESHOLD)
+#endif
+
+
+#ifndef SMAA_REPROJECTION
+#define SMAA_REPROJECTION 0
+#endif
+
+#define SMAA_REPROJECTION_WEIGHT_SCALE 30.0
+
+
+#ifndef SMAA_AREATEX_MAX_DISTANCE
+#define SMAA_AREATEX_MAX_DISTANCE 16
+#endif
+#ifndef SMAA_AREATEX_MAX_DISTANCE_DIAG
+#define SMAA_AREATEX_MAX_DISTANCE_DIAG 20
+#endif
+#define SMAA_AREATEX_PIXEL_SIZE (1.0 / vec2(160.0, 560.0))
+#define SMAA_AREATEX_SUBTEX_SIZE (1.0 / 7.0)
+
+
+/* --- Define section is over ---- */
+
+vec4 SMAANeighborhoodBlendingPS(vec2 texcoord,
+                                  vec4 offset[2],
+                                  sampler2D colorTex,
+                                  sampler2D blendTex) {
+    // Fetch the blending weights for current pixel:
+    vec4 a;
+    a.xz = texture(blendTex, texcoord).xz;
+    a.y = texture(blendTex, offset[1].zw).g;
+    a.w = texture(blendTex, offset[1].xy).a;
+
+    // Is there any blending weight with a value greater than 0.0?
+    //SMAA_BRANCH
+    if (dot(a, vec4(1.0, 1.0, 1.0, 1.0)) < 1e-5)
+        return textureLod(colorTex, texcoord, 0.0);
+    else {
+        vec4 color = vec4(0.0, 0.0, 0.0, 0.0);
+
+        // Up to 4 lines can be crossing a pixel (one through each edge). We
+        // favor blending by choosing the line with the maximum weight for each
+        // direction:
+        vec2 offset;
+        offset.x = a.a > a.b? a.a : -a.b; // left vs. right 
+        offset.y = a.g > a.r? a.g : -a.r; // top vs. bottom
+
+        // Then we go in the direction that has the maximum weight:
+        if (abs(offset.x) > abs(offset.y)) // horizontal vs. vertical
+            offset.y = 0.0;
+        else
+            offset.x = 0.0;
+
+        #if SMAA_REPROJECTION == 1
+        // Fetch the opposite color and lerp by hand:
+        vec4 C = textureLod(colorTex, texcoord, 0.0);
+        texcoord += sign(offset) * SMAA_PIXEL_SIZE;
+        vec4 Cop = textureLod(colorTex, texcoord, 0.0);
+        float s = abs(offset.x) > abs(offset.y)? abs(offset.x) : abs(offset.y);
+
+        // Unpack the velocity values:
+        C.a *= C.a;
+        Cop.a *= Cop.a;
+
+        // Lerp the colors:
+        vec4 Caa = mix(C, Cop, s);
+
+        // Unpack velocity and return the resulting value:
+        Caa.a = sqrt(Caa.a);
+        return Caa;
+        #else
+        // Fetch the opposite color and lerp by hand:
+        vec4 C = textureLod(colorTex, texcoord, 0.0);
+        texcoord += sign(offset) * SMAA_PIXEL_SIZE;
+        vec4 Cop = textureLod(colorTex, texcoord, 0.0);
+        float s = abs(offset.x) > abs(offset.y)? abs(offset.x) : abs(offset.y);
+        return mix(C, Cop, s);
+        #endif
+    }
+}
+
+/* ------------- Header is over -------------- */
+
+uniform sampler2D albedo_tex;
+uniform sampler2D blend_tex;
+in vec2 texcoord;
+in vec4 offset[2];
+in vec4 dummy2;
+void main()
+{
+  gl_FragColor = SMAANeighborhoodBlendingPS(texcoord, offset, albedo_tex, blend_tex);
+}

assets/smaa/neighborhood_vertex.txt

@@ -0,0 +1,65 @@
+#version 410 compatibility
+#define SMAA_PIXEL_SIZE vec2(1.0 / 512.0, 1.0 / 512.0)
+
+#define SMAA_THRESHOLD 0.05
+#define SMAA_MAX_SEARCH_STEPS 32
+#define SMAA_MAX_SEARCH_STEPS_DIAG 16
+#define SMAA_CORNER_ROUNDING 25
+
+
+#ifndef SMAA_DEPTH_THRESHOLD
+#define SMAA_DEPTH_THRESHOLD (0.1 * SMAA_THRESHOLD)
+#endif
+
+
+#ifndef SMAA_REPROJECTION
+#define SMAA_REPROJECTION 0
+#endif
+
+#define SMAA_REPROJECTION_WEIGHT_SCALE 30.0
+
+
+#ifndef SMAA_AREATEX_MAX_DISTANCE
+#define SMAA_AREATEX_MAX_DISTANCE 16
+#endif
+#ifndef SMAA_AREATEX_MAX_DISTANCE_DIAG
+#define SMAA_AREATEX_MAX_DISTANCE_DIAG 20
+#endif
+#define SMAA_AREATEX_PIXEL_SIZE (1.0 / vec2(160.0, 560.0))
+#define SMAA_AREATEX_SUBTEX_SIZE (1.0 / 7.0)
+
+
+/* --- Define section is over ---- */
+
+/**
+ * Neighborhood Blending Vertex Shader
+ */
+void SMAANeighborhoodBlendingVS(vec4 position,
+                                out vec4 svPosition,
+                                inout vec2 texcoord,
+                                out vec4 offset[2]) {
+    svPosition = position;
+
+    offset[0] = texcoord.xyxy + SMAA_PIXEL_SIZE.xyxy * vec4(-1.0, 0.0, 0.0, -1.0);
+    offset[1] = texcoord.xyxy + SMAA_PIXEL_SIZE.xyxy * vec4( 1.0, 0.0, 0.0,  1.0);
+}
+
+/* ------------- Header is over -------------- */
+
+
+out vec2 texcoord;
+out vec4 offset[2];
+out vec4 dummy2;
+
+attribute vec3 vPosition;
+attribute vec2 vTexCoord;
+uniform mat4 ProjectionMatrix;
+
+
+void main()
+{
+  texcoord = vTexCoord;
+  vec4 dummy1 = vec4(0);
+  SMAANeighborhoodBlendingVS(dummy1, dummy2, texcoord, offset);
+  gl_Position = ProjectionMatrix * vec4(vPosition.xyz, 1.0);
+}

game/main_code.cpp

@@ -12,24 +12,6 @@
 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) {
 
@@ -65,6 +47,7 @@ Matrix3f quatToMatrix(Vector4f q) {
 }
 
 
+
 void TMyApplication::InnerInit()
 {
 
@@ -73,7 +56,6 @@ void TMyApplication::InnerInit()
 #ifdef TARGET_WIN32
 #ifdef NDEBUG
 	ST::PathToResources = "resources/";
-	//ST::PathToResources = "../../../assets/";
 #else
 	ST::PathToResources = "../../../assets/";
 #endif
@@ -94,55 +76,33 @@ void TMyApplication::InnerInit()
 	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");
+	ResourceManager->ShaderManager.AddShader("PhongShader", "phong_vertex.txt", "phong_fragment.txt");
+
+
+
 	Renderer->PushShader("DefaultShader");
 
+
 	ResourceManager->TexList.AddTexture("console_bkg.bmp");
 
 	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");
 
-	ResourceManager->TexList.AddTexture("free-detailed-tiled-rope-texture-3d-model-low-poly-blend.png");
-
-	//
-	/*
-	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);
-
-	*/
-	
-	posArr.resize(20000000);
-	normArr.resize(20000000);
-	texCoordArr.resize(20000000);
-	colorArr.resize(20000000);
-
-
-
-	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;
+	Vector2f const backgroundBottomLeft(-1000, -1000);
+	float const backgroundW = 2000;
+	float const backgroundH = 2000;
 	
 	{
 		//resolution of background image
-		//float const imageW = 512;
-		//float const imageH = 512;
-
-		float const imageW = 2048;
-		float const imageH = 2048;
-
+		float const imageW = 512;
+		float const imageH = 512;
 
 
 		background.second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].emplace_back(Vector3f(backgroundBottomLeft[0], 0, backgroundBottomLeft[1]));
@@ -153,8 +113,8 @@ void TMyApplication::InnerInit()
 		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;
+		float const tw = W / imageW;
+		float const th = H / 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));
@@ -164,6 +124,7 @@ void TMyApplication::InnerInit()
 		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));
@@ -174,348 +135,134 @@ void TMyApplication::InnerInit()
 	
 	}
 
-	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;
+		//resolution of linesAll.png
+		float const  texW = 900;
+		float const  texH = 900;
 
-		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);
+		float const  step = 12;
+		float const  thick = 10;
 
-			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);
+		auto f = [this, texW, texH, thick, W, H] (const Vector3f &p1, const Vector3f &p2, float t) {
+			auto pv = p2 - p1;
+			Vector3f ortho(pv[2], 0, pv[0]);
+			ortho.normalize();
+			auto p3 = p2 + ortho * thick;
+			auto p4 = p1 + ortho * thick;
 
-				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));
-				}
+			float extraHeight = std::min(20.f, -(t - 1)*t*100.f);
 
-				threads.push_back(edges);
+			
+
+			const size_t segmentCount = 20;
+
+			for (int i = 0; i < segmentCount; i++)
+			{
+				auto pStart = p1 + pv * i/ segmentCount;
+				auto pEnd = p1 + pv * (i+1)/ segmentCount;
+
+				auto pStartShifted = pStart + ortho * thick;
+				auto pEndShifted = pEnd + ortho * thick;
+
+				float innerHeightStart = std::min(20.f, -(i / 20.f) * (i / 20.f - 1.f)*100.f);
+				float innerHeightEnd = std::min(20.f, -((i+1) / 20.f) * ((i+1) / 20.f - 1.f)*100.f);
+
+				Vector3f extraShiftStart = { 0, std::min(innerHeightStart, extraHeight), 0 };
+				Vector3f extraShiftEnd = { 0, std::min(innerHeightEnd, extraHeight), 0 };
+
+
+				fabricRender.second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(pStart + extraShiftStart);
+				fabricRender.second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(pEnd + extraShiftEnd);
+				fabricRender.second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(pEndShifted + extraShiftEnd);
+
+				fabricRender.second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(pEndShifted + extraShiftEnd);
+				fabricRender.second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(pStartShifted + extraShiftStart);
+				fabricRender.second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(pStart + extraShiftStart);
+
+				auto texThick = thick / texW;
+				auto m = (pStart[0] + pEnd[0]) / 2 / texW;
+				auto yStart = (H / texH)*(i / 20.f);
+				auto yEnd = (H / texH)*((i+1) / 20.f);
+
+				fabricRender.second.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].push_back(Vector2f(m, yStart));
+				fabricRender.second.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].push_back(Vector2f(m, yEnd));
+				fabricRender.second.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].push_back(Vector2f(m + texThick, yEnd));
+
+				fabricRender.second.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].push_back(Vector2f(m + texThick, yEnd));
+				fabricRender.second.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].push_back(Vector2f(m + texThick, yStart));
+				fabricRender.second.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].push_back(Vector2f(m, yStart));
 			}
 
-			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);
+		Vector3f const stepDirection(1, 0, 0);
+		Vector3f p1(bottomLeft[0], 0, -bottomLeft[1]);
 
-			int x = 0;
+		while (p1[0] < bottomLeft[0] + W) {
 
-			for(auto line: root.get_child("lines")) {
-				std::vector<int> start;
-				std::vector<int> end;
-				std::vector<float> color;
+			float t = (p1(0) - bottomLeft(0)) / W;
 
-				for(auto value: line.second.get_child("start")) {
-					start.push_back(value.second.get_value<int>());
-				}
+			auto p2 = p1 - Vector3f(0, 0, W);
+			f(p1, p2, t);
 
-				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++;
-			}
+			auto p3 = p1 + step * stepDirection;
+			f(p3, p2, t);
 
+			p1 = p3;
 		}
+
 	}
 
-	background.first.ShaderName ="DefaultShader";
-	fabricRender.first.ShaderName = "SimpleShading";
-	//fabricRender.first.ShaderName = "SimpleShadingNoTex";
+	//background.first.ShaderName ="ParallaxShader";
+	//DefaultShader
+	background.first.ShaderName = "DefaultShader";
+
+	fabricRender.first.ShaderName = "ParallaxShader";
+	//fabricRender.first.ShaderName = "PhongShader";
 	
 	/*
 	 *	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";
+	background.first.SamplerMap[CONST_STRING_TEXTURE_UNIFORM] = "background.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);
+	fabricRender.first.SamplerMap[CONST_STRING_TEXTURE_UNIFORM] = "linesAll.png";
 
 	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);
+	fabricRender.second.RefreshBuffer();
 
 
 
-	glGenBuffers(1, &normBuffer);
 
-	glBindBuffer(GL_ARRAY_BUFFER, normBuffer);
-
-	glBufferData(GL_ARRAY_BUFFER, normArr.size() * 12, &normArr[0], GL_STATIC_DRAW);
+	rect.second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(Vector3f(0, 0, 0));
+	rect.second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(Vector3f(0, 512, 0));
+	rect.second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(Vector3f(512, 512, 0));
+	rect.second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(Vector3f(512, 512, 0));
+	rect.second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(Vector3f(512, 0, 0));
+	rect.second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(Vector3f(0, 0, 0));
+
+	rect.second.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].push_back(Vector2f(0, 0));
+	rect.second.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].push_back(Vector2f(0, 1));
+	rect.second.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].push_back(Vector2f(1, 1));
+	rect.second.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].push_back(Vector2f(1, 1));
+	rect.second.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].push_back(Vector2f(1, 0));
+	rect.second.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].push_back(Vector2f(0, 0));
 
 
+	rect.second.RefreshBuffer();
 
-	glGenBuffers(1, &colorBuffer);
+	Renderer->SetOrthoProjection();
 
-	glBindBuffer(GL_ARRAY_BUFFER, colorBuffer);
-
-	glBufferData(GL_ARRAY_BUFFER, colorArr.size() * 12, &colorArr[0], GL_STATIC_DRAW);
+	Renderer->SetFullScreenViewport();
 
 
-
-	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;
 }
@@ -533,12 +280,7 @@ void TMyApplication::InnerDeinit()
 
 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)
@@ -576,10 +318,10 @@ void TMyApplication::OnMouseWheel(short int delta)
 {
 	distance += delta;
 
-	/*if (distance > 2500)
+	if (distance > 2500)
 	{
 		distance = 2500;
-	}*/
+	}
 
 	if (distance < 100)
 	{
@@ -589,8 +331,14 @@ void TMyApplication::OnMouseWheel(short int delta)
 	
 void TMyApplication::InnerDraw()
 {
+	
+	DrawScene();
+}
 
-	Renderer->SetPerspectiveProjection(pi / 6, 100.f, 40000.f);
+void TMyApplication::DrawScene()
+{
+
+	Renderer->SetPerspectiveProjection(pi / 6, 10.f, 10000.f);
 
 	Renderer->SetFullScreenViewport();
 
@@ -606,16 +354,18 @@ void TMyApplication::InnerDraw()
 
 	Renderer->RotateMatrix(quat2);
 
+
 	glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
 	glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
-	
+	glDisable(GL_DEPTH_TEST);
+
 	CheckGlError("");
 
 	auto mat1 = quatToMatrix(quat1);
 
 	auto mat2 = quatToMatrix(quat2);
 
-	Vector3f lightPos = {0.f, 1.f, 1.f};
+	Vector3f lightPos = { 0.f, -1.f, -1.f };
 
 	Vector3f eye = mat2 * mat1 * Vector3f(0.0f, 0.f, -distance);
 
@@ -633,50 +383,32 @@ void TMyApplication::InnerDraw()
 
 		Renderer->DrawTriangleList(background.second);
 	}
-
-
-
-
-	//glEnable(GL_CULL_FACE);
-
-	
 	{
 		TRenderParamsSetter params(fabricRender.first);
 
+		//RenderUniform3fv("cameraPos", eye.data());
 		RenderUniform3fv("eye", eye.data());
 		RenderUniform3fv("lightPos", lightPos.data());
 
-		Matrix3f normMatrix = Renderer->GetModelviewMatrix().inverse().transpose().block<3,3>(0,0);
-		
+		//RenderUniform3fv("ambientLight", Vector3f(0.0f, 0.0f, 0.0f).data());
+		//RenderUniform3fv("specularLight", Vector3f(0.0f, 0.0f, 0.0f).data());
+		//RenderUniform3fv("ambientLight", Vector3f(0.0f, 0.0f, 0.0f).data());
+		//RenderUniform1f("specularPower", 20.f);
+
+		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());
+		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->DrawTriangleList(fabricRender.second);
 	}
 
 
 	Renderer->PopMatrix();
 
 	CheckGlError("");
-	
+
 
 }
 

game/main_code.h

@@ -20,9 +20,6 @@
 #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
@@ -38,6 +35,7 @@ protected:
 public:
 	TRenderPair fabricRender;
 	TRenderPair background;
+	TRenderPair rect;
 
 	bool Loaded;
 
@@ -49,6 +47,9 @@ public:
 
 	virtual void InnerDraw();
 
+
+	void DrawScene();
+
 	virtual void InnerUpdate(size_t dt);
 
 	bool IsLoaded();

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">
@@ -151,7 +150,7 @@
       <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>
     </ClCompile>
     <Link>
@@ -159,7 +158,7 @@
       <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/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.user

@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.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 = 512;
+	int height = 512;
 
 
 	if (CreateEngine(width, height))