diff --git a/assets/HeightMap.png b/assets/HeightMap.png index cfbf2f4..e17c0da 100755 Binary files a/assets/HeightMap.png and b/assets/HeightMap.png differ diff --git a/assets/HeightMap_old.png b/assets/HeightMap_old.png new file mode 100755 index 0000000..27e5bbc Binary files /dev/null and b/assets/HeightMap_old.png differ diff --git a/assets/NormalMap.png b/assets/NormalMap.png index 9e16781..8484d63 100755 Binary files a/assets/NormalMap.png and b/assets/NormalMap.png differ diff --git a/assets/parallax_fragment.txt b/assets/parallax_fragment.txt index e2219f1..c70da7c 100755 --- a/assets/parallax_fragment.txt +++ b/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; diff --git a/assets/phong_fragment.txt b/assets/phong_fragment.txt new file mode 100755 index 0000000..b33d152 --- /dev/null +++ b/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; +} \ No newline at end of file diff --git a/assets/phong_vertex.txt b/assets/phong_vertex.txt new file mode 100755 index 0000000..2a66045 --- /dev/null +++ b/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; +} \ No newline at end of file diff --git a/assets/smaa/blend_fragment.txt b/assets/smaa/blend_fragment.txt new file mode 100755 index 0000000..b832128 --- /dev/null +++ b/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)); + +} \ No newline at end of file diff --git a/assets/smaa/blend_vertex.txt b/assets/smaa/blend_vertex.txt new file mode 100755 index 0000000..7746603 --- /dev/null +++ b/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); +} diff --git a/assets/smaa/edge_fragment.txt b/assets/smaa/edge_fragment.txt new file mode 100755 index 0000000..3d2de9a --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/assets/smaa/edge_vertex.txt b/assets/smaa/edge_vertex.txt new file mode 100755 index 0000000..f7edf16 --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/assets/smaa/neighborhood_fragment.txt b/assets/smaa/neighborhood_fragment.txt new file mode 100755 index 0000000..32470b0 --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/assets/smaa/neighborhood_vertex.txt b/assets/smaa/neighborhood_vertex.txt new file mode 100755 index 0000000..7df526e --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/assets/smaa/smaa_area.raw b/assets/smaa/smaa_area.raw new file mode 100755 index 0000000..f5e8575 Binary files /dev/null and b/assets/smaa/smaa_area.raw differ diff --git a/assets/smaa/smaa_search.raw b/assets/smaa/smaa_search.raw new file mode 100755 index 0000000..714baa9 Binary files /dev/null and b/assets/smaa/smaa_search.raw differ diff --git a/game/main_code.cpp b/game/main_code.cpp index 4aa3370..c5cf95c 100644 --- a/game/main_code.cpp +++ b/game/main_code.cpp @@ -47,6 +47,7 @@ Matrix3f quatToMatrix(Vector4f q) { } + void TMyApplication::InnerInit() { @@ -75,8 +76,13 @@ 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("PhongShader", "phong_vertex.txt", "phong_fragment.txt"); + + + Renderer->PushShader("DefaultShader"); + ResourceManager->TexList.AddTexture("console_bkg.bmp"); ResourceManager->TexList.AddTexture("background.jpg"); @@ -84,11 +90,14 @@ void TMyApplication::InnerInit() ResourceManager->TexList.AddTexture("NormalMap.png"); ResourceManager->TexList.AddTexture("linesAll.png"); - ResourceManager->FrameManager.AddFrameRenderBuffer("LevelBuffer", 512, 512); - Vector2f const bottomLeft(-1000, -1000); - float const W = 2000; - float const H = 2000; + Vector2f const bottomLeft(-500, -500); + float const W = 1000; + float const H = 1000; + + Vector2f const backgroundBottomLeft(-1000, -1000); + float const backgroundW = 2000; + float const backgroundH = 2000; { //resolution of background image @@ -96,13 +105,13 @@ void TMyApplication::InnerInit() float const imageH = 512; - background.second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].emplace_back(Vector3f(bottomLeft[0], 0, bottomLeft[1])); - background.second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].emplace_back(Vector3f(bottomLeft[0], 0, bottomLeft[1] + H)); - background.second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].emplace_back(Vector3f(bottomLeft[0] + W, 0, bottomLeft[1] + H)); + 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(bottomLeft[0] + W, 0, bottomLeft[0] + H)); - background.second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].emplace_back(Vector3f(bottomLeft[0] + W, 0, bottomLeft[0])); - background.second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].emplace_back(Vector3f(bottomLeft[0], 0, bottomLeft[0])); + 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 = W / imageW; float const th = H / imageH; @@ -134,32 +143,59 @@ void TMyApplication::InnerInit() float const step = 12; float const thick = 10; - auto f = [this, texW, texH, thick, W, H] (const Vector3f &p1, const Vector3f &p2) { + 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; - fabricRender.second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(p1); - fabricRender.second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(p2); - fabricRender.second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(p3); - - fabricRender.second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(p3); - fabricRender.second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(p4); - fabricRender.second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(p1); + float extraHeight = std::min(20.f, -(t - 1)*t*100.f); - auto texThick = thick / texW; - auto m = (p1[0] + p2[0]) / 2 / texW; - auto y = H / texH; + - fabricRender.second.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].push_back(Vector2f(m, 0)); - fabricRender.second.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].push_back(Vector2f(m, y)); - fabricRender.second.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].push_back(Vector2f(m + texThick, y)); - - fabricRender.second.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].push_back(Vector2f(m + texThick, y)); - fabricRender.second.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].push_back(Vector2f(m + texThick, 0)); - fabricRender.second.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].push_back(Vector2f(m, 0)); + 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)); + } + + + + }; @@ -168,19 +204,25 @@ void TMyApplication::InnerInit() while (p1[0] < bottomLeft[0] + W) { + float t = (p1(0) - bottomLeft(0)) / W; + auto p2 = p1 - Vector3f(0, 0, W); - f(p1, p2); + f(p1, p2, t); auto p3 = p1 + step * stepDirection; - f(p3, p2); + f(p3, p2, t); p1 = p3; } } - background.first.ShaderName ="ParallaxShader"; + //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 @@ -195,6 +237,32 @@ void TMyApplication::InnerInit() background.second.RefreshBuffer(); fabricRender.second.RefreshBuffer(); + + + + + 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(); + + Renderer->SetOrthoProjection(); + + Renderer->SetFullScreenViewport(); + + Inited = true; } @@ -262,6 +330,12 @@ void TMyApplication::OnMouseWheel(short int delta) } void TMyApplication::InnerDraw() +{ + + DrawScene(); +} + +void TMyApplication::DrawScene() { Renderer->SetPerspectiveProjection(pi / 6, 10.f, 10000.f); @@ -291,7 +365,7 @@ void TMyApplication::InnerDraw() 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); @@ -312,23 +386,29 @@ void TMyApplication::InnerDraw() { 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()); - Renderer->DrawTriangleList(fabricRender.second); + Renderer->DrawTriangleList(fabricRender.second); } Renderer->PopMatrix(); CheckGlError(""); - + } diff --git a/game/main_code.h b/game/main_code.h index fd197e6..794f7af 100644 --- a/game/main_code.h +++ b/game/main_code.h @@ -35,6 +35,7 @@ protected: public: TRenderPair fabricRender; TRenderPair background; + TRenderPair rect; bool Loaded; @@ -46,6 +47,9 @@ public: virtual void InnerDraw(); + + void DrawScene(); + virtual void InnerUpdate(size_t dt); bool IsLoaded();