spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

HLSL-Quelltext

//////////////////////////////////////////////////////////////////
//POM Shader

//////////////////////////////////////////////////////////////////
//Includes
#include"Constants.fx"
#include"Sampler.fx"
#include"Textures.fx"
#include"Lighting.fx"


//////////////////////////////////////////////////////////////////
//Layout
struct VSInput
{
    uint IID                    : SV_InstanceID;  //ID der Model-Instanz
    float3 vPosition            : POSITION0;      //Vertexposition im ModelSpace
    float3 vNormal              : NORMAL0;        //Vertexnormale im ModelSpace
    float3 vTangent             : TANGENT0;       //Vertextangente im ModelSpace
    float2 vTextureCoord        : TEXCOORD0;      //Vertex-Texturkoordinaten
};

struct PSInput
{
    uint IID                    : INSTANCEID;     //ID der Model-Instanz
    float4 vPosition            : SV_Position;    //Fertig transformierte Pixelposition
    float3 vWorldPosition       : POSITION0;      //Position des Pixels im WorldSpace
    float3 vViewDir             : VIEWDIR0;       //Normalisierter Vektor von Kamera in Richtung des Pixels im WorldSpace
    float3 vNormal              : NORMAL0;        //Normale des Pixels im WorldSpace
    float3 vTangent             : TANGENT0;       //Tangente des Pixels im WorldSpace
    float3 vBinormal            : BINORMAL0;      //Binormale des Pixels im WorldSpace
    float2 vTextureCoord        : TEXCOORD0;      //Texturkoordinaten des Pixels

    //#
    float2 vParallaxOffsetTS    : PAROFFSETTS0;   //Parallaxe im TangentSpace
    float3 vViewDirTS           : VIEWDIRTS0;     //Normalisierter Vektor von Kamera in Richtung des Pixels im TangentSpace
    float3 vNormalTS            : NORMALTS0;      //Normale des Pixels im TangentSpace
    //#
};

struct PSOutput
{
    float4 Color                : SV_Target0;     //Fertig berechnete Farbe des Pixels
};

//VertexShader
PSInput VertexShaderProc(VSInput In)
{
    PSInput Out;
    
    Out.IID= In.IID;
    
    float4 vWorldPosition= mul(float4(In.vPosition, 1.0), Instance[In.IID].mWorld);
    Out.vPosition= mul(vWorldPosition, mViewProjection);
    
    Out.vWorldPosition= vWorldPosition.xyz;
    Out.vViewDir= normalize(Out.vWorldPosition - vCameraPosition);
    float3 vNormal= mul(In.vNormal, (float3x3)Instance[In.IID].mWorld);
    Out.vNormal= vNormal;
    
    Out.vTangent= mul(In.vTangent, (float3x3)Instance[In.IID].mWorld);
    Out.vBinormal= cross(Out.vNormal, Out.vTangent);
    
    Out.vTextureCoord= In.vTextureCoord;

    //#
    row_major float3x3 mTBN= {Out.vTangent, Out.vBinormal, Out.vNormal};
    Out.vViewDirTS= mul(mTBN, -Out.vViewDir);
    Out.vNormalTS= mul(mTBN, Out.vNormal);

    float fParallaxLimit= length(Out.vViewDirTS.xy) / Out.vViewDirTS.z;
    const float fHeightMapScale= 0.2;
    fParallaxLimit*= fHeightMapScale;

    Out.vParallaxOffsetTS= normalize(-Out.vViewDirTS.xy) * fParallaxLimit;
    //#
    
    return(Out);
}

//PixelShader
PSOutput PixelShaderProc(PSInput In)
{
    PSOutput Out;

    //#
    //Parallax Occlusion Mapping
    //Samples berechnen
    const uint nMinSamples= 16;
    const uint nMaxSamples= 128;
    uint nNumPOMSamples = (uint)lerp(nMinSamples, nMaxSamples, normalize(In.vViewDirTS).z);

    //Steps berechnen und Offset
    float fStepSize    = 1.0 / (float)nNumPOMSamples;
    float2 vOffsetStep = fStepSize * In.vParallaxOffsetTS;
    float2 vCurrOffset = float2(0, 0);
    float2 vLastOffset = float2(0, 0);
    float2 vFinalOffset= float2(0, 0);

    float4 vCurrSample;
    float4 vLastSample;
    float stepHeight = 1.0;
    float Ua= 0.0F;

    //Anstieg vorberechnen
    float2 dx= ddx(In.vTextureCoord);
    float2 dy= ddy(In.vTextureCoord);

    //Sampeln, um den Durchstoßpunkt zu finden
    for(uint nCurrSample= 0; nCurrSample < nNumPOMSamples; nCurrSample++)
    {
        vCurrSample = TexNormalHeight.SampleGrad( TextureSamplerWrap, In.vTextureCoord + vCurrOffset, dx, dy );
        if ( vCurrSample.a > stepHeight )
        {
            //Gefunden!
            //Noch schnell den Schnittpunkt der 2 Geraden (HöheAlt-HöheNeu) x (StepAlt-StepNeu) finden
            // HöheNeu    StepAlt
            //         \/
            // StepNeu /\ HöheAlt
            //Damit sieht das glatter aus.
            Ua= (vLastSample.a - (stepHeight+fStepSize)) / ( fStepSize + (vCurrSample.a - vLastSample.a));
            vFinalOffset = vLastOffset - Ua * vOffsetStep ;

            vCurrSample = TexNormalHeight.SampleGrad( TextureSamplerWrap, In.vTextureCoord + vFinalOffset, dx, dy );
            nCurrSample = nNumPOMSamples;
        }
        else
        {
            //Beim nächsten mal klappta bestimmt!
            stepHeight -= fStepSize;
            vLastOffset = vCurrOffset;
            vCurrOffset += vOffsetStep;
            vLastSample = vCurrSample;
        }
    }

    In.vTextureCoord+= vFinalOffset;
    //#
    
    //NormalMapping
    row_major float3x3 mTBN= {In.vTangent, In.vBinormal, In.vNormal};
    float3 vNormal= normalize(mul(TexNormalHeight.Sample(TextureSamplerWrap, In.vTextureCoord).rgb * 2.0 - 1.0, mTBN));
    
    //Illumination
    float3 DiffuseLight= float3(0, 0, 0);
    float3 SpecularLight= float3(0, 0, 0);
    LightSource Light;
    uint LightIndex;

    //Light #0 (Directional)
    LightIndex= Instance[In.IID].aLightIndices[0].LID;
    if(LightIndex != 0xFFFFFFFF)
    {
        Light= aLights[LightIndex];
        DiffuseLight+= DirectionalLightDiffuse(Light, vNormal);
        SpecularLight+= DirectionalLightSpecular(Light, vNormal, MatSpecularColorPower.a, In.vViewDir);
    }
    //Color-Sources
    float4 ColorAlpha= MatColorAlpha;
    float4 SpecularColorPower= MatSpecularColorPower;
    float4 EmissiveAmbient= MatEmissiveAmbient;
    float4 MirrorColorSaturation= MatMirrorColorSaturation;
    
    ColorAlpha*= TexColorAlpha.Sample(TextureSamplerWrap, In.vTextureCoord);
    
    Out.Color= float4(0, 0, 0, 1);
    Out.Color.rgb+= AmbientLight.rgb * EmissiveAmbient.a * ColorAlpha.rgb;
    Out.Color.rgb+= DiffuseLight * ColorAlpha.rgb;
    Out.Color.rgb+= SpecularLight * SpecularColorPower.rgb;

    return(Out);
}