More shader stuff. Shader has world position through vertex shader and blockpos.
Dissolve from firstpos to secondpos with some randomness. Blue pulse with diagonal highlights.
This commit is contained in:
Christian Knaapen
@@ -250,7 +250,7 @@ public class RenderHelper implements IWorldEventListener {
|
||||
|
||||
if (sideHit != null) {
|
||||
BlockRendererDispatcher dispatcher = Minecraft.getMinecraft().getBlockRendererDispatcher();
|
||||
float percentile = ClientProxy.ticksInGame / 100f % 1f;
|
||||
float percentile = ClientProxy.ticksInGame / 50f % 1f;
|
||||
//TODO test
|
||||
percentile = 1f;
|
||||
|
||||
@@ -438,7 +438,7 @@ public class RenderHelper implements IWorldEventListener {
|
||||
|
||||
//image
|
||||
OpenGlHelper.setActiveTexture(ARBMultitexture.GL_TEXTURE0_ARB);
|
||||
GL11.glBindTexture(GL11.GL_TEXTURE_2D, mc.renderEngine.getTexture(TextureMap.LOCATION_BLOCKS_TEXTURE/*new ResourceLocation(EffortlessBuilding.MODID, "textures/shader_color.png")*/).getGlTextureId());
|
||||
GL11.glBindTexture(GL11.GL_TEXTURE_2D, mc.renderEngine.getTexture(TextureMap.LOCATION_BLOCKS_TEXTURE).getGlTextureId());
|
||||
ARBShaderObjects.glUniform1iARB(imageUniform, 0);
|
||||
|
||||
OpenGlHelper.setActiveTexture(ARBMultitexture.GL_TEXTURE0_ARB + secondaryTextureUnit);
|
||||
|
||||
@@ -41,9 +41,6 @@ public final class ShaderHelper {
|
||||
private static final String VERT_EXTENSION = ".vert";
|
||||
private static final String FRAG_EXTENSION = ".frag";
|
||||
|
||||
// public static final FloatBuffer projection = GLAllocation.createDirectFloatBuffer(16);
|
||||
// public static final FloatBuffer modelview = GLAllocation.createDirectFloatBuffer(16);
|
||||
|
||||
public static int rawColor;
|
||||
public static int dissolve;
|
||||
|
||||
@@ -52,7 +49,7 @@ public final class ShaderHelper {
|
||||
return;
|
||||
|
||||
rawColor = createProgram("/assets/effortlessbuilding/shaders/raw_color", FRAG);
|
||||
dissolve = createProgram("/assets/effortlessbuilding/shaders/dissolve", FRAG);
|
||||
dissolve = createProgram("/assets/effortlessbuilding/shaders/dissolve", VERT + FRAG);
|
||||
}
|
||||
|
||||
public static void useShader(int shader, Consumer<Integer> callback) {
|
||||
@@ -65,17 +62,6 @@ public final class ShaderHelper {
|
||||
int time = ARBShaderObjects.glGetUniformLocationARB(shader, "time");
|
||||
ARBShaderObjects.glUniform1iARB(time, ClientProxy.ticksInGame);
|
||||
|
||||
// GlStateManager.getFloat(GL11.GL_PROJECTION_MATRIX, projection);
|
||||
// GlStateManager.getFloat(GL11.GL_MODELVIEW_MATRIX, modelview);
|
||||
|
||||
// int inverse_view_proj = ARBShaderObjects.glGetUniformLocationARB(shader, "inverse_view_proj");
|
||||
int screen_width = ARBShaderObjects.glGetUniformLocationARB(shader, "screen_width");
|
||||
int screen_height = ARBShaderObjects.glGetUniformLocationARB(shader, "screen_height");
|
||||
|
||||
// ARBShaderObjects.glUniformMatrix4ARB(inverse_view_proj, true, modelview);
|
||||
ARBShaderObjects.glUniform1fARB(screen_width, Minecraft.getMinecraft().displayWidth);
|
||||
ARBShaderObjects.glUniform1fARB(screen_height, Minecraft.getMinecraft().displayHeight);
|
||||
|
||||
if(callback != null)
|
||||
callback.accept(shader);
|
||||
}
|
||||
|
||||
@@ -1,12 +1,5 @@
|
||||
#version 120
|
||||
|
||||
uniform mat4 gl_ProjectionMatrix;
|
||||
uniform mat4 gl_ModelViewMatrix;
|
||||
|
||||
//uniform mat4 inverse_view_proj;
|
||||
uniform float screen_width;
|
||||
uniform float screen_height;
|
||||
|
||||
uniform int time; // Passed in, see ShaderHelper.java
|
||||
|
||||
uniform float percentile; // Passed in via Callback
|
||||
@@ -18,149 +11,97 @@ uniform sampler2D image;
|
||||
uniform sampler2D mask;
|
||||
|
||||
varying vec4 position;
|
||||
|
||||
// Simplex 3D Noise
|
||||
// by Ian McEwan, Ashima Arts
|
||||
//
|
||||
vec4 permute(vec4 x) {return mod(((x*34.0)+1.0)*x, 289.0);}
|
||||
vec4 taylorInvSqrt(vec4 r) {return 1.79284291400159 - 0.85373472095314 * r;}
|
||||
|
||||
float snoise(vec3 v){
|
||||
const vec2 C = vec2(1.0/6.0, 1.0/3.0) ;
|
||||
const vec4 D = vec4(0.0, 0.5, 1.0, 2.0);
|
||||
|
||||
// First corner
|
||||
vec3 i = floor(v + dot(v, C.yyy) );
|
||||
vec3 x0 = v - i + dot(i, C.xxx) ;
|
||||
|
||||
// Other corners
|
||||
vec3 g = step(x0.yzx, x0.xyz);
|
||||
vec3 l = 1.0 - g;
|
||||
vec3 i1 = min( g.xyz, l.zxy );
|
||||
vec3 i2 = max( g.xyz, l.zxy );
|
||||
|
||||
// x0 = x0 - 0. + 0.0 * C
|
||||
vec3 x1 = x0 - i1 + 1.0 * C.xxx;
|
||||
vec3 x2 = x0 - i2 + 2.0 * C.xxx;
|
||||
vec3 x3 = x0 - 1. + 3.0 * C.xxx;
|
||||
|
||||
// Permutations
|
||||
i = mod(i, 289.0 );
|
||||
vec4 p = permute( permute( permute(
|
||||
i.z + vec4(0.0, i1.z, i2.z, 1.0 ))
|
||||
+ i.y + vec4(0.0, i1.y, i2.y, 1.0 ))
|
||||
+ i.x + vec4(0.0, i1.x, i2.x, 1.0 ));
|
||||
|
||||
// Gradients
|
||||
// ( N*N points uniformly over a square, mapped onto an octahedron.)
|
||||
float n_ = 1.0/7.0; // N=7
|
||||
vec3 ns = n_ * D.wyz - D.xzx;
|
||||
|
||||
vec4 j = p - 49.0 * floor(p * ns.z *ns.z); // mod(p,N*N)
|
||||
|
||||
vec4 x_ = floor(j * ns.z);
|
||||
vec4 y_ = floor(j - 7.0 * x_ ); // mod(j,N)
|
||||
|
||||
vec4 x = x_ *ns.x + ns.yyyy;
|
||||
vec4 y = y_ *ns.x + ns.yyyy;
|
||||
vec4 h = 1.0 - abs(x) - abs(y);
|
||||
|
||||
vec4 b0 = vec4( x.xy, y.xy );
|
||||
vec4 b1 = vec4( x.zw, y.zw );
|
||||
|
||||
vec4 s0 = floor(b0)*2.0 + 1.0;
|
||||
vec4 s1 = floor(b1)*2.0 + 1.0;
|
||||
vec4 sh = -step(h, vec4(0.0));
|
||||
|
||||
vec4 a0 = b0.xzyw + s0.xzyw*sh.xxyy ;
|
||||
vec4 a1 = b1.xzyw + s1.xzyw*sh.zzww ;
|
||||
|
||||
vec3 p0 = vec3(a0.xy,h.x);
|
||||
vec3 p1 = vec3(a0.zw,h.y);
|
||||
vec3 p2 = vec3(a1.xy,h.z);
|
||||
vec3 p3 = vec3(a1.zw,h.w);
|
||||
|
||||
//Normalise gradients
|
||||
vec4 norm = taylorInvSqrt(vec4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3)));
|
||||
p0 *= norm.x;
|
||||
p1 *= norm.y;
|
||||
p2 *= norm.z;
|
||||
p3 *= norm.w;
|
||||
|
||||
// Mix final noise value
|
||||
vec4 m = max(0.6 - vec4(dot(x0,x0), dot(x1,x1), dot(x2,x2), dot(x3,x3)), 0.0);
|
||||
m = m * m;
|
||||
return 42.0 * dot( m*m, vec4( dot(p0,x0), dot(p1,x1),
|
||||
dot(p2,x2), dot(p3,x3) ) );
|
||||
}
|
||||
|
||||
vec3 getWorldPosition() {
|
||||
// Convert screen coordinates to normalized device coordinates (NDC)
|
||||
vec4 ndc = vec4(
|
||||
(gl_FragCoord.x / screen_width - 0.5) * 2.0,
|
||||
(gl_FragCoord.y / screen_height - 0.5) * 2.0,
|
||||
(gl_FragCoord.z - 0.5) * 2.0,
|
||||
1.0);
|
||||
|
||||
// Convert NDC throuch inverse clip coordinates to view coordinates
|
||||
vec4 clip = transpose(gl_ModelViewMatrix) * ndc;
|
||||
vec3 vertex = (clip / clip.w).xyz;
|
||||
return vertex;
|
||||
}
|
||||
varying vec3 normal;
|
||||
|
||||
void main() {
|
||||
|
||||
vec3 worldpos = getWorldPosition();
|
||||
|
||||
float noise = worldpos.x / 300.0;//snoise(worldpos);
|
||||
|
||||
vec3 worldpos = blockpos + position.xyz;
|
||||
vec2 texcoord = vec2(gl_TexCoord[0]);
|
||||
vec4 color = texture2D(image, texcoord);
|
||||
vec4 texcolor = texture2D(image, texcoord);
|
||||
vec4 color = texcolor;
|
||||
vec3 firstposc = firstpos + 0.51; //center in block
|
||||
vec3 secondposc = secondpos + 0.5;
|
||||
|
||||
vec3 relBlockPos = mod(blockpos, 32.0) / 32.0;
|
||||
vec2 maskcoord = texcoord + vec2(relBlockPos.x + relBlockPos.y, relBlockPos.z + relBlockPos.y);
|
||||
//find place in between first and second pos
|
||||
float firstToSecond = length(secondposc - firstposc);
|
||||
float place = 0.0;
|
||||
if (firstToSecond > 0.5) {
|
||||
float placeFromFirst = length(worldpos - firstposc) / firstToSecond;
|
||||
float placeFromSecond = length(worldpos - secondposc) / firstToSecond;
|
||||
place = (placeFromFirst + (1.0 - placeFromSecond)) / 2.0;
|
||||
} else {
|
||||
//only one block
|
||||
}
|
||||
|
||||
//find 2d texture coordinate for noise texture based on world position
|
||||
vec2 maskcoord = vec2(worldpos.y, worldpos.z);
|
||||
if (abs(normal.y) > 0.5)
|
||||
maskcoord = vec2(worldpos.x, worldpos.z);
|
||||
if (abs(normal.z) > 0.5)
|
||||
maskcoord = vec2(worldpos.x, worldpos.y);
|
||||
|
||||
maskcoord /= 20.0;
|
||||
vec4 maskColor = texture2D(mask, maskcoord);
|
||||
float maskgs = maskColor.r;
|
||||
maskgs = noise;
|
||||
|
||||
float r = color.r * gl_Color.r;
|
||||
float g = color.g * gl_Color.g;
|
||||
float b = color.b * gl_Color.b;
|
||||
float a = color.a; // Ignore gl_Color.a as we don't want to make use of that for the dissolve effect
|
||||
//color.rgb *= gl_Color.rgb;
|
||||
|
||||
r = noise;
|
||||
g = noise;
|
||||
b = noise;
|
||||
//desaturate
|
||||
color.rgb *= vec3(0.8);
|
||||
|
||||
// r -= 0.1;
|
||||
// g += 0.0;
|
||||
// b += 0.1;
|
||||
//add blueish hue
|
||||
color.rgb += vec3(-0.2, 0.0, 0.3);
|
||||
|
||||
//add pulsing blue
|
||||
float pulse = (sin(time / 5.0) + 1.0) / 2.0;
|
||||
color.rgb += (1.0 - color.rgb) * vec3(-0.5, 0.2, 0.6) * pulse;
|
||||
|
||||
//add diagonal highlights
|
||||
float diagTime = mod(time / 40.0, 1.4) - 0.2;
|
||||
float diag = smoothstep(diagTime - 0.2, diagTime, place) - smoothstep(diagTime, diagTime + 0.2, place);
|
||||
color.rgb += (1.0 - color.rgb) * diag * vec3(0.0, 0.2, 0.4);
|
||||
|
||||
float diagTime2 = mod(time / 70.0, 1.4) - 0.2;
|
||||
float diag2 = smoothstep(diagTime2 - 0.2, diagTime2, place) - smoothstep(diagTime2, diagTime2 + 0.2, place);
|
||||
color.rgb += (1.0 - color.rgb) * diag2 * vec3(0.0, 0.4, 0.8);
|
||||
|
||||
//add shading
|
||||
// vec3 p1;
|
||||
// //if (firstpos.x < secondpos.x)
|
||||
//
|
||||
// float pulse = (sin(time / 5.0) + 1.0) / 2.0;
|
||||
// vec3 wmf = worldpos - firstposc;
|
||||
// vec3 wms = worldpos - (secondposc + vec3(0.0, 1.0, 1.0));
|
||||
// float distToEdge1 = min(length(wmf.xy), length(wmf.xz));
|
||||
// float distToEdge2 = min(length(wmf.yz), length(wms.xy));
|
||||
// float distToEdge3 = min(length(wms.xz), length(wms.yz));
|
||||
// float distToEdge = min(min(distToEdge1, distToEdge2), distToEdge3);
|
||||
// color.rgb += vec3(0.5 - smoothstep(0, 0.5, distToEdge)) * 0.5;
|
||||
|
||||
|
||||
// pulse = 1.0;//pulse / 2.0 + 0.5;
|
||||
// vec4 pulseColor = texture2D(mask, maskcoord + time / 700.0);
|
||||
// vec4 pulseColor2 = texture2D(mask, vec2(maskcoord.x + time / 600.0, maskcoord.y - time / 600.0));
|
||||
// float pulseGreyScale = pulseColor.r + pulseColor2.r / 2.0;
|
||||
//
|
||||
// r -= r * pulseColor.r * pulse * 0.2;
|
||||
// g += (1.0 - g) * pulseColor.r * pulse * 0.2;
|
||||
// b += (1.0 - b) * pulseColor.r * pulse * 0.8;
|
||||
// color.r -= color.r * pulseColor.r * pulse * 0.2;
|
||||
// color.g += (1.0 - color.g) * pulseColor.r * pulse * 0.2;
|
||||
// color.b += (1.0 - color.b) * pulseColor.r * pulse * 0.8;
|
||||
//
|
||||
// r -= r * pulseColor2.r * pulse * 0.4;
|
||||
// g += (1.0 - g) * pulseColor2.r * pulse * 0.2;
|
||||
// b += (1.0 - b) * pulseColor2.r * pulse;
|
||||
|
||||
// color.r -= color.r * pulseColor2.r * pulse * 0.4;
|
||||
// color.g += (1.0 - color.g) * pulseColor2.r * pulse * 0.2;
|
||||
// color.b += (1.0 - color.b) * pulseColor2.r * pulse;
|
||||
|
||||
if(highlight == 1) {
|
||||
r += 0.0;
|
||||
g += 0.1;
|
||||
b -= 0.2;
|
||||
color.r += 0.0;
|
||||
color.g += 0.1;
|
||||
color.b -= 0.2;
|
||||
}
|
||||
|
||||
r = max(0, min(1, r));
|
||||
g = max(0, min(1, g));
|
||||
b = max(0, min(1, b));
|
||||
color.r = max(0, min(1, color.r));
|
||||
color.g = max(0, min(1, color.g));
|
||||
color.b = max(0, min(1, color.b));
|
||||
|
||||
if(maskgs <= percentile)
|
||||
gl_FragColor = vec4(r, g, b, a);
|
||||
else gl_FragColor = vec4(r, g, b, 0);
|
||||
if (maskgs * 0.3 + place * 0.7 <= percentile)
|
||||
gl_FragColor = color;
|
||||
else gl_FragColor = vec4(texcolor.rgb, 0.0);
|
||||
}
|
||||
@@ -7,14 +7,15 @@ uniform int highlight;
|
||||
uniform vec3 blockpos;
|
||||
uniform vec3 firstpos;
|
||||
uniform vec3 secondpos;
|
||||
uniform sampler2D image;
|
||||
uniform sampler2D mask;
|
||||
|
||||
varying vec4 position;
|
||||
varying vec3 normal;
|
||||
|
||||
void main() {
|
||||
gl_Position = ftransform();//gl_ProjectionMatrix * gl_ModelViewMatrix * gl_Vertex;
|
||||
gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0 + 0.01;
|
||||
gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0;
|
||||
|
||||
position = gl_Vertex;
|
||||
normal = gl_Normal;
|
||||
}
|
||||
Reference in New Issue
Block a user