Jump to content

Refraction shader help

Recommended Posts

Is there a way to get rid of this doubling up of the gun and hands in the refraction shader? I'm wracking my brain here. Here's my fragment shader:

#version 400
#define BFN_ENABLED 1

uniform sampler2D texture0;//diffuse map
uniform sampler2D texture1;//light map
uniform sampler2D texture2;//specular map
uniform samplerCube texture5;//cube map
uniform sampler2DMS texture9;
uniform sampler2D texture10;//screen color
uniform samplerCube texture15;//BFN map
uniform vec4 materialcolorspecular;
//uniform vec4 lighting_ambient;
//uniform vec4 ambientlight;
uniform int decalmode;
uniform float materialroughness;
uniform vec2 buffersize;
uniform bool isbackbuffer;

//Camera uniforms
uniform mat4 cameramatrix;
uniform mat4 projectioncameramatrix;
uniform vec2 camerarange;
uniform float camerazoom;
uniform mat4 camerainversematrix;
uniform mat3 cameranormalmatrix;
uniform vec3 cameraposition;

//My uniforms
#define BUMPINESS 0.01

in vec2 ex_texcoords0;
in vec4 ex_color;
in float ex_selectionstate;
in vec3 ex_VertexCameraPosition;
in vec4 ex_vertexposition;
in vec3 ex_normal;
in vec3 ex_tangent;
in vec3 ex_binormal;
in float clipdistance0;

out vec4 fragData0;
out vec4 fragData1;
out vec4 fragData2;
out vec4 fragData3;

float DepthToZPosition(in float depth) {
    return camerarange.x / (camerarange.y - depth * (camerarange.y - camerarange.x)) * camerarange.y;

void main(void)
    //Clip plane discard
    if (clipdistance0>0.0) discard;
    vec4 outcolor = ex_color;
    vec4 color_specular = materialcolorspecular;
    //Normal map
    vec3 normal = ex_normal;
    normal = texture(texture1,ex_texcoords0).xyz * 2.0 - 1.0;
    float ao = normal.z;
    normal = ex_tangent*normal.x + ex_binormal*normal.y + ex_normal*normal.z;
    vec2 texcoord = (gl_FragCoord.xy / buffersize);
    if (isbackbuffer) texcoord.y = 1.0f - texcoord.y;
    vec3 texAdjust = vec3(texcoord.x,texcoord.y,1.0);
    //vec3 texAdjust = (vec3(texcoord.x*1.2,texcoord.y,1.5)+0.2
    texAdjust = normalize(texAdjust);
    vec4 screencolor = textureProj(texture10,texAdjust + normal.xyz*BUMPINESS);
    outcolor = screencolor * 0.75;

    fragData0 = outcolor;
    //Best-fit normals
    fragData1 = texture(texture15,normalize(vec3(normal.x,-normal.y,normal.z)));
    fragData1.a = fragData0.a;
    //Low-res normals
    fragData1 = vec4(normalize(normal)*0.5+0.5,fragData0.a);
    float specular = color_specular.r * 0.299 + color_specular.g * 0.587 + color_specular.b * 0.114;
    int materialflags=1;
    if (ex_selectionstate>0.0) materialflags += 2;
    if (decalmode==1) materialflags += 4;//brush
    if (decalmode==2) materialflags += 8;//model
    if (decalmode==4) materialflags += 16;//terrain
    if (materialroughness>=0.5)
        materialflags += 32;
        if (materialroughness>=0.75) materialflags += 64;
        if (materialroughness>=0.25) materialflags += 64;
    fragData1.a = materialflags/255.0;
    fragData2 = vec4(0.0,0.0,0.0,specular);
    fragData3 = vec4(ex_VertexCameraPosition,1.0f);



Share this post

Link to post

The refraction shader should be reading the depth and only blending with pixels that fall below the transparent surface's depth value, not pixels that fall in front.

Coincidentally, I am about to start on a global refraction effect in the new Vulkan renderer.

  • Like 2

Share this post

Link to post

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.

Reply to this topic...

×   Pasted as rich text.   Paste as plain text instead

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.

  • Create New...