aboutsummaryrefslogtreecommitdiff
path: root/client
diff options
context:
space:
mode:
Diffstat (limited to 'client')
-rw-r--r--client/shaders/minimap_shader/opengl_fragment.glsl32
-rw-r--r--client/shaders/minimap_shader/opengl_vertex.glsl11
-rw-r--r--client/shaders/nodes_shader/opengl_fragment.glsl144
-rw-r--r--client/shaders/nodes_shader/opengl_vertex.glsl83
-rw-r--r--client/shaders/water_surface_shader/opengl_fragment.glsl62
-rw-r--r--client/shaders/water_surface_shader/opengl_vertex.glsl17
-rw-r--r--client/shaders/wielded_shader/opengl_fragment.glsl114
-rw-r--r--client/shaders/wielded_shader/opengl_vertex.glsl35
8 files changed, 380 insertions, 118 deletions
diff --git a/client/shaders/minimap_shader/opengl_fragment.glsl b/client/shaders/minimap_shader/opengl_fragment.glsl
new file mode 100644
index 000000000..fa4f9cb1a
--- /dev/null
+++ b/client/shaders/minimap_shader/opengl_fragment.glsl
@@ -0,0 +1,32 @@
+uniform sampler2D baseTexture;
+uniform sampler2D normalTexture;
+uniform vec3 yawVec;
+
+void main (void)
+{
+ vec2 uv = gl_TexCoord[0].st;
+
+ //texture sampling rate
+ const float step = 1.0 / 256.0;
+ float tl = texture2D(normalTexture, vec2(uv.x - step, uv.y + step)).r;
+ float t = texture2D(normalTexture, vec2(uv.x - step, uv.y - step)).r;
+ float tr = texture2D(normalTexture, vec2(uv.x + step, uv.y + step)).r;
+ float r = texture2D(normalTexture, vec2(uv.x + step, uv.y)).r;
+ float br = texture2D(normalTexture, vec2(uv.x + step, uv.y - step)).r;
+ float b = texture2D(normalTexture, vec2(uv.x, uv.y - step)).r;
+ float bl = texture2D(normalTexture, vec2(uv.x - step, uv.y - step)).r;
+ float l = texture2D(normalTexture, vec2(uv.x - step, uv.y)).r;
+ float dX = (tr + 2.0 * r + br) - (tl + 2.0 * l + bl);
+ float dY = (bl + 2.0 * b + br) - (tl + 2.0 * t + tr);
+ vec4 bump = vec4 (normalize(vec3 (dX, dY, 0.1)),1.0);
+ float height = 2.0 * texture2D(normalTexture, vec2(uv.x, uv.y)).r - 1.0;
+ vec4 base = texture2D(baseTexture, uv).rgba;
+ vec3 L = normalize(vec3(0.0, 0.75, 1.0));
+ float specular = pow(clamp(dot(reflect(L, bump.xyz), yawVec), 0.0, 1.0), 1.0);
+ float diffuse = dot(yawVec, bump.xyz);
+
+ vec3 color = (1.1 * diffuse + 0.05 * height + 0.5 * specular) * base.rgb;
+ vec4 col = vec4(color.rgb, base.a);
+ col *= gl_Color;
+ gl_FragColor = vec4(col.rgb, base.a);
+}
diff --git a/client/shaders/minimap_shader/opengl_vertex.glsl b/client/shaders/minimap_shader/opengl_vertex.glsl
new file mode 100644
index 000000000..06df5a3cf
--- /dev/null
+++ b/client/shaders/minimap_shader/opengl_vertex.glsl
@@ -0,0 +1,11 @@
+uniform mat4 mWorldViewProj;
+uniform mat4 mInvWorld;
+uniform mat4 mTransWorld;
+uniform mat4 mWorld;
+
+void main(void)
+{
+ gl_TexCoord[0] = gl_MultiTexCoord0;
+ gl_Position = mWorldViewProj * gl_Vertex;
+ gl_FrontColor = gl_BackColor = gl_Color;
+}
diff --git a/client/shaders/nodes_shader/opengl_fragment.glsl b/client/shaders/nodes_shader/opengl_fragment.glsl
index 6dc96eb48..424d32177 100644
--- a/client/shaders/nodes_shader/opengl_fragment.glsl
+++ b/client/shaders/nodes_shader/opengl_fragment.glsl
@@ -1,6 +1,6 @@
uniform sampler2D baseTexture;
uniform sampler2D normalTexture;
-uniform sampler2D useNormalmap;
+uniform sampler2D textureFlags;
uniform vec4 skyBgColor;
uniform float fogDistance;
@@ -8,91 +8,137 @@ uniform vec3 eyePosition;
varying vec3 vPosition;
varying vec3 worldPosition;
+varying float area_enable_parallax;
varying vec3 eyeVec;
varying vec3 tsEyeVec;
varying vec3 lightVec;
varying vec3 tsLightVec;
-bool normalTexturePresent = false;
+bool normalTexturePresent = false;
const float e = 2.718281828459;
const float BS = 10.0;
-
-float intensity (vec3 color){
+
+void get_texture_flags()
+{
+ vec4 flags = texture2D(textureFlags, vec2(0.0, 0.0));
+ if (flags.r > 0.5) {
+ normalTexturePresent = true;
+ }
+}
+
+float intensity(vec3 color)
+{
return (color.r + color.g + color.b) / 3.0;
}
-float get_rgb_height (vec2 uv){
- return intensity(texture2D(baseTexture,uv).rgb);
+float get_rgb_height(vec2 uv)
+{
+ return intensity(texture2D(baseTexture, uv).rgb);
}
-vec4 get_normal_map(vec2 uv){
+vec4 get_normal_map(vec2 uv)
+{
vec4 bump = texture2D(normalTexture, uv).rgba;
- bump.xyz = normalize(bump.xyz * 2.0 -1.0);
- bump.y = -bump.y;
+ bump.xyz = normalize(bump.xyz * 2.0 - 1.0);
return bump;
}
-void main (void)
+float find_intersection(vec2 dp, vec2 ds)
+{
+ const float depth_step = 1.0 / 24.0;
+ float depth = 1.0;
+ for (int i = 0 ; i < 24 ; i++) {
+ float h = texture2D(normalTexture, dp + ds * depth).a;
+ if (h >= depth)
+ break;
+ depth -= depth_step;
+ }
+ return depth;
+}
+
+float find_intersectionRGB(vec2 dp, vec2 ds)
+{
+ const float depth_step = 1.0 / 24.0;
+ float depth = 1.0;
+ for (int i = 0 ; i < 24 ; i++) {
+ float h = get_rgb_height(dp + ds * depth);
+ if (h >= depth)
+ break;
+ depth -= depth_step;
+ }
+ return depth;
+}
+
+void main(void)
{
vec3 color;
vec4 bump;
vec2 uv = gl_TexCoord[0].st;
bool use_normalmap = false;
-
-#ifdef USE_NORMALMAPS
- if (texture2D(useNormalmap,vec2(1.0,1.0)).r > 0.0){
- normalTexturePresent = true;
- }
-#endif
+ get_texture_flags();
#ifdef ENABLE_PARALLAX_OCCLUSION
- if (normalTexturePresent){
- vec3 tsEye = normalize(tsEyeVec);
- float height = PARALLAX_OCCLUSION_SCALE * texture2D(normalTexture, uv).a - PARALLAX_OCCLUSION_BIAS;
- uv = uv + texture2D(normalTexture, uv).z * height * vec2(tsEye.x,-tsEye.y);
+ vec2 eyeRay = vec2 (tsEyeVec.x, -tsEyeVec.y);
+ const float scale = PARALLAX_OCCLUSION_SCALE / PARALLAX_OCCLUSION_ITERATIONS;
+ const float bias = PARALLAX_OCCLUSION_BIAS / PARALLAX_OCCLUSION_ITERATIONS;
+
+#if PARALLAX_OCCLUSION_MODE == 0
+ // Parallax occlusion with slope information
+ if (normalTexturePresent && area_enable_parallax > 0.0) {
+ for (int i = 0; i < PARALLAX_OCCLUSION_ITERATIONS; i++) {
+ vec4 normal = texture2D(normalTexture, uv.xy);
+ float h = normal.a * scale - bias;
+ uv += h * normal.z * eyeRay;
+ }
+#endif
+
+#if PARALLAX_OCCLUSION_MODE == 1
+ // Relief mapping
+ if (normalTexturePresent && area_enable_parallax > 0.0) {
+ vec2 ds = eyeRay * PARALLAX_OCCLUSION_SCALE;
+ float dist = find_intersection(uv, ds);
+ uv += dist * ds;
+#endif
+ } else if (GENERATE_NORMALMAPS == 1 && area_enable_parallax > 0.0) {
+ vec2 ds = eyeRay * PARALLAX_OCCLUSION_SCALE;
+ float dist = find_intersectionRGB(uv, ds);
+ uv += dist * ds;
}
#endif
-#ifdef USE_NORMALMAPS
- if (normalTexturePresent){
+#if USE_NORMALMAPS == 1
+ if (normalTexturePresent) {
bump = get_normal_map(uv);
use_normalmap = true;
- }
+ }
#endif
-
-#ifdef GENERATE_NORMALMAPS
- if (use_normalmap == false){
- float tl = get_rgb_height (vec2(uv.x-SAMPLE_STEP,uv.y+SAMPLE_STEP));
- float t = get_rgb_height (vec2(uv.x-SAMPLE_STEP,uv.y-SAMPLE_STEP));
- float tr = get_rgb_height (vec2(uv.x+SAMPLE_STEP,uv.y+SAMPLE_STEP));
- float r = get_rgb_height (vec2(uv.x+SAMPLE_STEP,uv.y));
- float br = get_rgb_height (vec2(uv.x+SAMPLE_STEP,uv.y-SAMPLE_STEP));
- float b = get_rgb_height (vec2(uv.x,uv.y-SAMPLE_STEP));
- float bl = get_rgb_height (vec2(uv.x-SAMPLE_STEP,uv.y-SAMPLE_STEP));
- float l = get_rgb_height (vec2(uv.x-SAMPLE_STEP,uv.y));
+
+ if (GENERATE_NORMALMAPS == 1 && normalTexturePresent == false) {
+ float tl = get_rgb_height(vec2(uv.x - SAMPLE_STEP, uv.y + SAMPLE_STEP));
+ float t = get_rgb_height(vec2(uv.x - SAMPLE_STEP, uv.y - SAMPLE_STEP));
+ float tr = get_rgb_height(vec2(uv.x + SAMPLE_STEP, uv.y + SAMPLE_STEP));
+ float r = get_rgb_height(vec2(uv.x + SAMPLE_STEP, uv.y));
+ float br = get_rgb_height(vec2(uv.x + SAMPLE_STEP, uv.y - SAMPLE_STEP));
+ float b = get_rgb_height(vec2(uv.x, uv.y - SAMPLE_STEP));
+ float bl = get_rgb_height(vec2(uv.x -SAMPLE_STEP, uv.y - SAMPLE_STEP));
+ float l = get_rgb_height(vec2(uv.x - SAMPLE_STEP, uv.y));
float dX = (tr + 2.0 * r + br) - (tl + 2.0 * l + bl);
float dY = (bl + 2.0 * b + br) - (tl + 2.0 * t + tr);
- bump = vec4 (normalize(vec3 (dX, -dY, NORMALMAPS_STRENGTH)),1.0);
+ bump = vec4(normalize(vec3 (dX, dY, NORMALMAPS_STRENGTH)), 1.0);
use_normalmap = true;
}
-#endif
-vec4 base = texture2D(baseTexture, uv).rgba;
-
+ vec4 base = texture2D(baseTexture, uv).rgba;
+
#ifdef ENABLE_BUMPMAPPING
- if (use_normalmap){
+ if (use_normalmap) {
vec3 L = normalize(lightVec);
vec3 E = normalize(eyeVec);
- float specular = pow(clamp(dot(reflect(L, bump.xyz), E), 0.0, 1.0),0.5);
- float diffuse = dot(E,bump.xyz);
- /* Mathematic optimization
- * Original: color = 0.05*base.rgb + diffuse*base.rgb + 0.2*specular*base.rgb;
- * This optimization save 2 multiplications (orig: 4 multiplications + 3 additions
- * end: 2 multiplications + 3 additions)
- */
- color = (0.05 + diffuse + 0.2 * specular) * base.rgb;
+ float specular = pow(clamp(dot(reflect(L, bump.xyz), E), 0.0, 1.0), 1.0);
+ float diffuse = dot(-E,bump.xyz);
+ color = (diffuse + 0.1 * specular) * base.rgb;
} else {
color = base.rgb;
}
@@ -104,7 +150,7 @@ vec4 base = texture2D(baseTexture, uv).rgba;
float alpha = gl_Color.a;
vec4 col = vec4(color.rgb, alpha);
col *= gl_Color;
- if(fogDistance != 0.0){
+ if (fogDistance != 0.0) {
float d = max(0.0, min(vPosition.z / fogDistance * 1.5 - 0.6, 1.0));
alpha = mix(alpha, 0.0, d);
}
@@ -112,7 +158,7 @@ vec4 base = texture2D(baseTexture, uv).rgba;
#else
vec4 col = vec4(color.rgb, base.a);
col *= gl_Color;
- if(fogDistance != 0.0){
+ if (fogDistance != 0.0) {
float d = max(0.0, min(vPosition.z / fogDistance * 1.5 - 0.6, 1.0));
col = mix(col, skyBgColor, d);
}
diff --git a/client/shaders/nodes_shader/opengl_vertex.glsl b/client/shaders/nodes_shader/opengl_vertex.glsl
index 07684f616..53d5c92d0 100644
--- a/client/shaders/nodes_shader/opengl_vertex.glsl
+++ b/client/shaders/nodes_shader/opengl_vertex.glsl
@@ -14,25 +14,40 @@ varying vec3 eyeVec;
varying vec3 lightVec;
varying vec3 tsEyeVec;
varying vec3 tsLightVec;
+varying float area_enable_parallax;
const float e = 2.718281828459;
const float BS = 10.0;
-float smoothCurve( float x ) {
- return x * x *( 3.0 - 2.0 * x );
+float smoothCurve(float x)
+{
+ return x * x * (3.0 - 2.0 * x);
}
-float triangleWave( float x ) {
- return abs( fract( x + 0.5 ) * 2.0 - 1.0 );
+float triangleWave(float x)
+{
+ return abs(fract(x + 0.5) * 2.0 - 1.0);
}
-float smoothTriangleWave( float x ) {
- return smoothCurve( triangleWave( x ) ) * 2.0 - 1.0;
+float smoothTriangleWave(float x)
+{
+ return smoothCurve(triangleWave(x)) * 2.0 - 1.0;
}
void main(void)
{
gl_TexCoord[0] = gl_MultiTexCoord0;
-
-#if (MATERIAL_TYPE == TILE_MATERIAL_LIQUID_TRANSPARENT || MATERIAL_TYPE == TILE_MATERIAL_LIQUID_OPAQUE) && ENABLE_WAVING_WATER
+ //TODO: make offset depending on view angle and parallax uv displacement
+ //thats for textures that doesnt align vertically, like dirt with grass
+ //gl_TexCoord[0].y += 0.008;
+
+ //Allow parallax/relief mapping only for certain kind of nodes
+ //Variable is also used to control area of the effect
+#if (DRAW_TYPE == NDT_NORMAL || DRAW_TYPE == NDT_LIQUID || DRAW_TYPE == NDT_FLOWINGLIQUID)
+ area_enable_parallax = 1.0;
+#else
+ area_enable_parallax = 0.0;
+#endif
+
+#if ((MATERIAL_TYPE == TILE_MATERIAL_LIQUID_TRANSPARENT || MATERIAL_TYPE == TILE_MATERIAL_LIQUID_OPAQUE) && ENABLE_WAVING_WATER)
vec4 pos = gl_Vertex;
pos.y -= 2.0;
@@ -76,43 +91,33 @@ void main(void)
vPosition = gl_Position.xyz;
worldPosition = (mWorld * gl_Vertex).xyz;
+
+ // Don't generate heightmaps when too far from the eye
+ float dist = distance (vec3(0.0, 0.0 ,0.0), vPosition);
+ if (dist > 150.0) {
+ area_enable_parallax = 0.0;
+ }
+
vec3 sunPosition = vec3 (0.0, eyePosition.y * BS + 900.0, 0.0);
vec3 normal, tangent, binormal;
normal = normalize(gl_NormalMatrix * gl_Normal);
- if (gl_Normal.x > 0.5) {
- // 1.0, 0.0, 0.0
- tangent = normalize(gl_NormalMatrix * vec3( 0.0, 0.0, -1.0));
- binormal = normalize(gl_NormalMatrix * vec3( 0.0, -1.0, 0.0));
- } else if (gl_Normal.x < -0.5) {
- // -1.0, 0.0, 0.0
- tangent = normalize(gl_NormalMatrix * vec3( 0.0, 0.0, 1.0));
- binormal = normalize(gl_NormalMatrix * vec3( 0.0, -1.0, 0.0));
- } else if (gl_Normal.y > 0.5) {
- // 0.0, 1.0, 0.0
- tangent = normalize(gl_NormalMatrix * vec3( 1.0, 0.0, 0.0));
- binormal = normalize(gl_NormalMatrix * vec3( 0.0, 0.0, 1.0));
- } else if (gl_Normal.y < -0.5) {
- // 0.0, -1.0, 0.0
- tangent = normalize(gl_NormalMatrix * vec3( 1.0, 0.0, 0.0));
- binormal = normalize(gl_NormalMatrix * vec3( 0.0, 0.0, 1.0));
- } else if (gl_Normal.z > 0.5) {
- // 0.0, 0.0, 1.0
- tangent = normalize(gl_NormalMatrix * vec3( 1.0, 0.0, 0.0));
- binormal = normalize(gl_NormalMatrix * vec3( 0.0, -1.0, 0.0));
- } else if (gl_Normal.z < -0.5) {
- // 0.0, 0.0, -1.0
- tangent = normalize(gl_NormalMatrix * vec3(-1.0, 0.0, 0.0));
- binormal = normalize(gl_NormalMatrix * vec3( 0.0, -1.0, 0.0));
- }
- mat3 tbnMatrix = mat3( tangent.x, binormal.x, normal.x,
- tangent.y, binormal.y, normal.y,
- tangent.z, binormal.z, normal.z);
+ tangent = normalize(gl_NormalMatrix * gl_MultiTexCoord1.xyz);
+ binormal = normalize(gl_NormalMatrix * gl_MultiTexCoord2.xyz);
+
+ vec3 v;
lightVec = sunPosition - worldPosition;
- tsLightVec = lightVec * tbnMatrix;
- eyeVec = (gl_ModelViewMatrix * gl_Vertex).xyz;
- tsEyeVec = eyeVec * tbnMatrix;
+ v.x = dot(lightVec, tangent);
+ v.y = dot(lightVec, binormal);
+ v.z = dot(lightVec, normal);
+ tsLightVec = normalize (v);
+
+ eyeVec = -(gl_ModelViewMatrix * gl_Vertex).xyz;
+ v.x = dot(eyeVec, tangent);
+ v.y = dot(eyeVec, binormal);
+ v.z = dot(eyeVec, normal);
+ tsEyeVec = normalize (v);
vec4 color;
float day = gl_Color.r;
diff --git a/client/shaders/water_surface_shader/opengl_fragment.glsl b/client/shaders/water_surface_shader/opengl_fragment.glsl
index 6dc96eb48..75751e243 100644
--- a/client/shaders/water_surface_shader/opengl_fragment.glsl
+++ b/client/shaders/water_surface_shader/opengl_fragment.glsl
@@ -1,6 +1,6 @@
uniform sampler2D baseTexture;
uniform sampler2D normalTexture;
-uniform sampler2D useNormalmap;
+uniform sampler2D textureFlags;
uniform vec4 skyBgColor;
uniform float fogDistance;
@@ -14,41 +14,59 @@ varying vec3 tsEyeVec;
varying vec3 lightVec;
varying vec3 tsLightVec;
-bool normalTexturePresent = false;
+bool normalTexturePresent = false;
+bool texTileableHorizontal = false;
+bool texTileableVertical = false;
+bool texSeamless = false;
const float e = 2.718281828459;
const float BS = 10.0;
-
-float intensity (vec3 color){
+
+void get_texture_flags()
+{
+ vec4 flags = texture2D(textureFlags, vec2(0.0, 0.0));
+ if (flags.r > 0.5) {
+ normalTexturePresent = true;
+ }
+ if (flags.g > 0.5) {
+ texTileableHorizontal = true;
+ }
+ if (flags.b > 0.5) {
+ texTileableVertical = true;
+ }
+ if (texTileableHorizontal && texTileableVertical) {
+ texSeamless = true;
+ }
+}
+
+float intensity(vec3 color)
+{
return (color.r + color.g + color.b) / 3.0;
}
-float get_rgb_height (vec2 uv){
+float get_rgb_height(vec2 uv)
+{
return intensity(texture2D(baseTexture,uv).rgb);
}
-vec4 get_normal_map(vec2 uv){
+vec4 get_normal_map(vec2 uv)
+{
vec4 bump = texture2D(normalTexture, uv).rgba;
bump.xyz = normalize(bump.xyz * 2.0 -1.0);
bump.y = -bump.y;
return bump;
}
-void main (void)
+void main(void)
{
vec3 color;
vec4 bump;
vec2 uv = gl_TexCoord[0].st;
bool use_normalmap = false;
-
-#ifdef USE_NORMALMAPS
- if (texture2D(useNormalmap,vec2(1.0,1.0)).r > 0.0){
- normalTexturePresent = true;
- }
-#endif
+ get_texture_flags();
#ifdef ENABLE_PARALLAX_OCCLUSION
- if (normalTexturePresent){
+ if (normalTexturePresent) {
vec3 tsEye = normalize(tsEyeVec);
float height = PARALLAX_OCCLUSION_SCALE * texture2D(normalTexture, uv).a - PARALLAX_OCCLUSION_BIAS;
uv = uv + texture2D(normalTexture, uv).z * height * vec2(tsEye.x,-tsEye.y);
@@ -56,14 +74,13 @@ void main (void)
#endif
#ifdef USE_NORMALMAPS
- if (normalTexturePresent){
+ if (normalTexturePresent) {
bump = get_normal_map(uv);
use_normalmap = true;
}
#endif
-
-#ifdef GENERATE_NORMALMAPS
- if (use_normalmap == false){
+
+ if (GENERATE_NORMALMAPS == 1 && use_normalmap == false) {
float tl = get_rgb_height (vec2(uv.x-SAMPLE_STEP,uv.y+SAMPLE_STEP));
float t = get_rgb_height (vec2(uv.x-SAMPLE_STEP,uv.y-SAMPLE_STEP));
float tr = get_rgb_height (vec2(uv.x+SAMPLE_STEP,uv.y+SAMPLE_STEP));
@@ -77,16 +94,15 @@ void main (void)
bump = vec4 (normalize(vec3 (dX, -dY, NORMALMAPS_STRENGTH)),1.0);
use_normalmap = true;
}
-#endif
vec4 base = texture2D(baseTexture, uv).rgba;
-
+
#ifdef ENABLE_BUMPMAPPING
- if (use_normalmap){
+ if (use_normalmap) {
vec3 L = normalize(lightVec);
vec3 E = normalize(eyeVec);
- float specular = pow(clamp(dot(reflect(L, bump.xyz), E), 0.0, 1.0),0.5);
- float diffuse = dot(E,bump.xyz);
+ float specular = pow(clamp(dot(reflect(L, bump.xyz), E), 0.0, 1.0),0.5);
+ float diffuse = dot(E,bump.xyz);
/* Mathematic optimization
* Original: color = 0.05*base.rgb + diffuse*base.rgb + 0.2*specular*base.rgb;
* This optimization save 2 multiplications (orig: 4 multiplications + 3 additions
diff --git a/client/shaders/water_surface_shader/opengl_vertex.glsl b/client/shaders/water_surface_shader/opengl_vertex.glsl
index 6e70bbc36..7ae517d8a 100644
--- a/client/shaders/water_surface_shader/opengl_vertex.glsl
+++ b/client/shaders/water_surface_shader/opengl_vertex.glsl
@@ -18,20 +18,23 @@ varying vec3 tsLightVec;
const float e = 2.718281828459;
const float BS = 10.0;
-float smoothCurve( float x ) {
- return x * x *( 3.0 - 2.0 * x );
+float smoothCurve(float x)
+{
+ return x * x * (3.0 - 2.0 * x);
}
-float triangleWave( float x ) {
- return abs( fract( x + 0.5 ) * 2.0 - 1.0 );
+float triangleWave(float x)
+{
+ return abs(fract( x + 0.5 ) * 2.0 - 1.0);
}
-float smoothTriangleWave( float x ) {
- return smoothCurve( triangleWave( x ) ) * 2.0 - 1.0;
+float smoothTriangleWave(float x)
+{
+ return smoothCurve(triangleWave( x )) * 2.0 - 1.0;
}
void main(void)
{
gl_TexCoord[0] = gl_MultiTexCoord0;
-
+
#if (MATERIAL_TYPE == TILE_MATERIAL_LIQUID_TRANSPARENT || MATERIAL_TYPE == TILE_MATERIAL_LIQUID_OPAQUE) && ENABLE_WAVING_WATER
vec4 pos = gl_Vertex;
pos.y -= 2.0;
diff --git a/client/shaders/wielded_shader/opengl_fragment.glsl b/client/shaders/wielded_shader/opengl_fragment.glsl
new file mode 100644
index 000000000..75dd1b674
--- /dev/null
+++ b/client/shaders/wielded_shader/opengl_fragment.glsl
@@ -0,0 +1,114 @@
+uniform sampler2D baseTexture;
+uniform sampler2D normalTexture;
+uniform sampler2D textureFlags;
+
+uniform vec4 skyBgColor;
+uniform float fogDistance;
+uniform vec3 eyePosition;
+
+varying vec3 vPosition;
+varying vec3 worldPosition;
+
+varying vec3 eyeVec;
+varying vec3 lightVec;
+
+bool normalTexturePresent = false;
+bool texTileableHorizontal = false;
+bool texTileableVertical = false;
+bool texSeamless = false;
+
+const float e = 2.718281828459;
+const float BS = 10.0;
+
+void get_texture_flags()
+{
+ vec4 flags = texture2D(textureFlags, vec2(0.0, 0.0));
+ if (flags.r > 0.5) {
+ normalTexturePresent = true;
+ }
+ if (flags.g > 0.5) {
+ texTileableHorizontal = true;
+ }
+ if (flags.b > 0.5) {
+ texTileableVertical = true;
+ }
+ if (texTileableHorizontal && texTileableVertical) {
+ texSeamless = true;
+ }
+}
+
+float intensity(vec3 color)
+{
+ return (color.r + color.g + color.b) / 3.0;
+}
+
+float get_rgb_height(vec2 uv)
+{
+ if (texSeamless) {
+ return intensity(texture2D(baseTexture, uv).rgb);
+ } else {
+ return intensity(texture2D(baseTexture, clamp(uv, 0.0, 0.999)).rgb);
+ }
+}
+
+vec4 get_normal_map(vec2 uv)
+{
+ vec4 bump = texture2D(normalTexture, uv).rgba;
+ bump.xyz = normalize(bump.xyz * 2.0 - 1.0);
+ return bump;
+}
+
+void main(void)
+{
+ vec3 color;
+ vec4 bump;
+ vec2 uv = gl_TexCoord[0].st;
+ bool use_normalmap = false;
+ get_texture_flags();
+
+#if USE_NORMALMAPS == 1
+ if (normalTexturePresent) {
+ bump = get_normal_map(uv);
+ use_normalmap = true;
+ }
+#endif
+
+ if (GENERATE_NORMALMAPS == 1 && normalTexturePresent == false) {
+ float tl = get_rgb_height(vec2(uv.x - SAMPLE_STEP, uv.y + SAMPLE_STEP));
+ float t = get_rgb_height(vec2(uv.x - SAMPLE_STEP, uv.y - SAMPLE_STEP));
+ float tr = get_rgb_height(vec2(uv.x + SAMPLE_STEP, uv.y + SAMPLE_STEP));
+ float r = get_rgb_height(vec2(uv.x + SAMPLE_STEP, uv.y));
+ float br = get_rgb_height(vec2(uv.x + SAMPLE_STEP, uv.y - SAMPLE_STEP));
+ float b = get_rgb_height(vec2(uv.x, uv.y - SAMPLE_STEP));
+ float bl = get_rgb_height(vec2(uv.x -SAMPLE_STEP, uv.y - SAMPLE_STEP));
+ float l = get_rgb_height(vec2(uv.x - SAMPLE_STEP, uv.y));
+ float dX = (tr + 2.0 * r + br) - (tl + 2.0 * l + bl);
+ float dY = (bl + 2.0 * b + br) - (tl + 2.0 * t + tr);
+ bump = vec4(normalize(vec3 (dX, dY, NORMALMAPS_STRENGTH)), 1.0);
+ use_normalmap = true;
+ }
+
+ vec4 base = texture2D(baseTexture, uv).rgba;
+
+#ifdef ENABLE_BUMPMAPPING
+ if (use_normalmap) {
+ vec3 L = normalize(lightVec);
+ vec3 E = normalize(eyeVec);
+ float specular = pow(clamp(dot(reflect(L, bump.xyz), E), 0.0, 1.0), 1.0);
+ float diffuse = dot(-E,bump.xyz);
+ color = (diffuse + 0.1 * specular) * base.rgb;
+ } else {
+ color = base.rgb;
+ }
+#else
+ color = base.rgb;
+#endif
+
+ vec4 col = vec4(color.rgb, base.a);
+ col *= gl_Color;
+ if (fogDistance != 0.0) {
+ float d = max(0.0, min(vPosition.z / fogDistance * 1.5 - 0.6, 1.0));
+ col = mix(col, skyBgColor, d);
+ }
+ gl_FragColor = vec4(col.rgb, base.a);
+}
diff --git a/client/shaders/wielded_shader/opengl_vertex.glsl b/client/shaders/wielded_shader/opengl_vertex.glsl
new file mode 100644
index 000000000..a2ab9fa5f
--- /dev/null
+++ b/client/shaders/wielded_shader/opengl_vertex.glsl
@@ -0,0 +1,35 @@
+uniform mat4 mWorldViewProj;
+uniform mat4 mInvWorld;
+uniform mat4 mTransWorld;
+uniform mat4 mWorld;
+
+uniform float dayNightRatio;
+uniform vec3 eyePosition;
+uniform float animationTimer;
+
+varying vec3 vPosition;
+varying vec3 worldPosition;
+
+varying vec3 eyeVec;
+varying vec3 lightVec;
+varying vec3 tsEyeVec;
+varying vec3 tsLightVec;
+
+const float e = 2.718281828459;
+const float BS = 10.0;
+
+void main(void)
+{
+ gl_TexCoord[0] = gl_MultiTexCoord0;
+ gl_Position = mWorldViewProj * gl_Vertex;
+
+ vPosition = gl_Position.xyz;
+ worldPosition = (mWorld * gl_Vertex).xyz;
+
+ vec3 sunPosition = vec3 (0.0, eyePosition.y * BS + 900.0, 0.0);
+
+ lightVec = sunPosition - worldPosition;
+ eyeVec = -(gl_ModelViewMatrix * gl_Vertex).xyz;
+
+ gl_FrontColor = gl_BackColor = gl_Color;
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-10 05:57:40 +0000