Community

Question

Hi,

I'd like to write a shader effect, where a transparent wall "glows" locally when a ball comes near it. By "glow" I mean simply make the transparent wall locally opaque. In my current implementation that wall doesn't glow correctly. In a script attached to the wall I pass the ball position to the wall-shader:

renderer.material.SetVector("_BallPos", Vector4(pinball.transform.position.x, 
 pinball.transform.position.y, pinball.transform.position.z, 1));

So far I've written this shader code:

Shader "PinballShaders/BoundaryGlowShader"
{
    Properties 
    {
        _Color ("Main Color", Color) = (0.1, 0.3, 0.7, 0.25)
        _BallPos("Pinball position", Vector) = (0,0,0,1)
        //Max dist indicates the size of the effect when 
        //pinball comes near the wall
        _MaxDist("Maximum distance", Float) = 2.0
        _MainTex ("Base (RGBA)", 2D) = "white" {}
    }
    SubShader 
    {
        //Blend One One 
        Blend SrcAlpha OneMinusSrcAlpha

        Tags {Queue = Transparent}
        Cull Off

        Pass
        {
CGPROGRAM
#pragma vertex vert
#pragma fragment frag

#include "UnityCG.cginc"

uniform float4 _Color;
uniform float4 _BallPos;
uniform float _MaxDist;
uniform sampler2D _MainTex;

struct v2f {
    float4 pos : POSITION;
    float4 color : COLOR0;
    float4 fragPos : COLOR1;
};

v2f vert (appdata_base v)
{
    v2f o;
    o.pos = mul (glstate.matrix.mvp, v.vertex);
    //Store the fragment position relative to eye coordinate system.
    //Is this interpolated between vertex and fragment shader?
    o.fragPos = o.pos;
    o.color = _Color;
    return o;
}

half4 frag (v2f i) : COLOR
{
    float4 outColor = i.color;
    float distance = length(_BallPos - i.fragPos.rgba);
    //the nearer the ball to pixel's 3d coordinate, the more opaque it should be
    outColor.a =  max(1 - distance / _MaxDist, 0.0);

    return outColor;
}
ENDCG

        }
    } 
    FallBack "VertexLit"
}

Any idea what's wrong with my code? Isn't fragPos interpolated across the triangle?

Answer 1

0

Looks like your checking the distance in the pixel shader, after coordinates have already been transformed into eye / screen space.

You need to convert the point into the wall's local co-ordinate system, and then do the distance calculation in the vertext shader instead.

Convert the position of the ball into local space before sending to the shader:

Vector4 localPoint = transform.InverseTransformPoint(pinball.transform.position);
localPoint.Scale(transform.localScale);
localPoint.w = 1;
renderer.material.SetVector("_BallPos", localPoint);

And the shader changes:

v2f vert (appdata_base v)
{
    v2f o;
    // Check distance here.

    float dist = distance(_BallPos, v.vertex);
    float safety = step(0.001 , maxDistance);
    o.color = _Color;
    o.color.a = safety *  (1 - clamp(dist, 0, maxDistance)/maxDistance);
    o.pos = mul (glstate.matrix.mvp, v.vertex);
    //Store the fragment position relative to eye coordinate system.
    //Is this interpolated between vertex and fragment shader?
    o.fragPos = o.pos;
    return o;
}

half4 frag (v2f i) : COLOR
{
    float4 outColor = i.color;
    return outColor;
}

answered Apr 12 '10 at 10:18 PM

Horsman
426 ● 3 ● 6 ● 15

Of course, fragPos is no longer needed and should be removed from the v2f structure.

Apr 13 '10 at 02:23 AM Daniel Brauer

Thanks a lot for your suggestion, which works pretty fine for well tesselated objects. But in my case I have a quite big wall consisting of only two triangles. If I calculate the distance in the vertex shader and the ball hits the wall in the middle, vertices are too far away so the wall doesn't get opaque at the hitpoint. That was the reason why I wanted to compute the distance in the fragment shader. I thought I had to get everything into eye coordinates...?

Apr 13 '10 at 07:20 AM drhenry

BTW: converting the ball position into the local coordinate system of the wall did the trick for me (see Horsman's code above). I made mainly two mistakes in my code: 1) I thought I should pass global coordinates to the shader (thus I had the coordinates of the vertex and the ball in separate coordinates systems) 2) fragPos and ball position must be multiplied by the modelview matrix (not the model view PROJECTION matrix), if you do distance calculation in the fragment shader.

Apr 13 '10 at 08:25 AM drhenry

(comments are locked)

Answer 2

Thanks to Horsman. I changed a bit of his code, so that it works fine even for objects of arbitrary triangulation:

struct v2f {
    float4 pos : POSITION;
    float4 color : COLOR0;
    //position of the wall fragment in eye coordinates
    float4 fragPos : TEXCOORD1;
    //position of the pinball in eye coordinates
    float4 ballPos : TEXCOORD2;
};

v2f vert (appdata_base v)
{
    v2f o;
    o.color = _Color;
    o.pos = mul (glstate.matrix.mvp, v.vertex);

    o.fragPos = mul (glstate.matrix.modelview[0], v.vertex);
    o.ballPos = mul (glstate.matrix.modelview[0], _BallPos);

    return o;
}

half4 frag (v2f i) : COLOR
{
    float4 outColor = i.color;

    // Check distance here.
    float dist = distance(i.ballPos, i.fragPos);
    float safety = step(0.001 , _MaxDist);
    outColor.a = safety *  (1 - clamp(dist, 0, _MaxDist)/_MaxDist);

    return outColor;
}

Performance would be better, if the ball position in eye coordinates would not be computed in the vertex shader (=matrix multiplication for each vertex) but in a Unity script (=only one matrix multiplication).

Community

How to detect in a shader, if two objects are close

Follow this question

Welcome to Unity Answers

Unity Answers tutorial video!

Related Questions