expvintl
978 lines
36 KiB
HLSL
978 lines
36 KiB
HLSL
#ifndef PRAGMA_DCL
|
|
#pragma dcl position
|
|
#define PRAGMA_DCL
|
|
#endif
|
|
|
|
#define GLASS_LIGHTING (1)
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// GPUPTFX_RENDER.FX - gpu particle rendering shader
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// INCLUDES
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#include "../common.fxh"
|
|
#include "../Lighting/lighting_common.fxh"
|
|
|
|
#include "ptfx_common.fxh"
|
|
#include "ptxgpu_common.fxh"
|
|
#include "../../../rage/base/src/shaderlib/rage_diffuse_sampler.fxh"
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// VARIABLES
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
BeginDX10Sampler(sampler2D, Texture2D<float4>, BackBufferTexture, BackBufferSampler, BackBufferTexture)
|
|
ContinueSampler(sampler2D,BackBufferTexture,BackBufferSampler,BackBufferTexture)
|
|
MinFilter = LINEAR;
|
|
MagFilter = LINEAR;
|
|
MipFilter = NONE;
|
|
AddressU = CLAMP; // MIRROR
|
|
AddressV = CLAMP; // MIRROR
|
|
EndSampler;
|
|
|
|
BeginDX10Sampler(sampler2D, Texture2D<float4>, DistortionTexture, DistortionSampler, DistortionTexture)
|
|
ContinueSampler(sampler2D,DistortionTexture,DistortionSampler,DistortionTexture)
|
|
MinFilter = LINEAR;
|
|
MagFilter = LINEAR;
|
|
MipFilter = NONE;
|
|
AddressU = CLAMP; // MIRROR
|
|
AddressV = CLAMP; // MIRROR
|
|
EndSampler;
|
|
|
|
BeginConstantBufferDX10( ptxgpu_render_locals )
|
|
|
|
float gLightIntensityMult : LightIntensityMult
|
|
< string UIName = "Light Intensity Multiplier : Controls the intensity of the directional and ambient contribution";
|
|
float UIMin = 0.0;
|
|
float UIMax = 2.0;
|
|
float UIStep = 0.01;
|
|
> = 0.8f;
|
|
|
|
float4 gTextureRowsColsStartEnd : TextureRowsColsStartEnd;
|
|
float4 gTextureAnimRateScaleOverLifeStart2End2 : TextureAnimRateScaleOverLifeStart2End2;
|
|
float4 gSizeMinRange : SizeMinRange;
|
|
float4 gColour : Colour;
|
|
float2 gFadeInOut : FadeInOut;
|
|
float2 gRotSpeedMinRange : RotSpeedMinRange;
|
|
float3 gDirectionalZOffsetMinRange : DirectionalZOffsetMinRange;
|
|
float2 gFadeNearFar : FadeNearFar;
|
|
float3 gFadeZBaseLoHi : FadeZBaseLoHi;
|
|
float3 gDirectionalVelocityAdd : DirectionalVelocityAdd;
|
|
float gEdgeSoftness : EdgeSoftness;
|
|
float gMaxLife : MaxLife;
|
|
float3 gRefParticlePos : RefParticlePos;
|
|
float gParticleColorPercentage : ParticleColorPercentage;
|
|
float gBackgroundDistortionVisibilityPercentage : BackgroundDistortionVisibilityPercentage;
|
|
float gBackgroundDistortionAlphaBooster : BackgroundDistortionAlphaBooster;
|
|
float gBackgroundDistortionAmount : BackgroundDistortionAmount;
|
|
float gDirectionalLightShadowAmount : DirectionalLightShadowAmount < int nostrip = 1; > = 1.0f;
|
|
float gLocalLightsMultiplier : LocalLightsMultiplier;
|
|
float4 gCamAngleLimits : CamAngleLimits = float4(PTXGPU_CAMANGLE_FORWARD_MIN, PTXGPU_CAMANGLE_FORWARD_INV_RANGE, PTXGPU_CAMANGLE_UP_MIN, PTXGPU_CAMANGLE_UP_INV_RANGE);
|
|
|
|
EndConstantBufferDX10( ptxgpu_render_locals )
|
|
|
|
#define gCamAngleForwardMin (gCamAngleLimits.x)
|
|
#define gCamAngleForwardInvRange (gCamAngleLimits.y)
|
|
#define gCamAngleUpMin (gCamAngleLimits.z)
|
|
#define gCamAngleUpInvRange (gCamAngleLimits.w)
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// STRUCTURES
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
struct ptxgpuDropInfo
|
|
{
|
|
float4 pos;
|
|
float4 worldPos;
|
|
float2 texCoord;
|
|
float3 dirUp;
|
|
float3 dirSide;
|
|
};
|
|
|
|
struct ptxgpuVertexOutC
|
|
{
|
|
float3 texCoordPrevA : TEXCOORD0;
|
|
float2 texCoordCurrA : TEXCOORD1;
|
|
float3 texCoordPrevB : TEXCOORD2;
|
|
float2 texCoordCurrB : TEXCOORD3;
|
|
NOINTERPOLATION float4 color : TEXCOORD4;
|
|
float4 lightColor_DepthW : TEXCOORD5;
|
|
NOINTERPOLATION float2 texABBlendValues : TEXCOORD6;
|
|
DECLARE_POSITION_CLIPPLANES( pos )
|
|
};
|
|
|
|
struct ptxgpuPixelInC
|
|
{
|
|
float3 texCoordPrevA : TEXCOORD0;
|
|
float2 texCoordCurrA : TEXCOORD1;
|
|
float3 texCoordPrevB : TEXCOORD2;
|
|
float2 texCoordCurrB : TEXCOORD3;
|
|
NOINTERPOLATION float4 color : TEXCOORD4;
|
|
float4 lightColor_DepthW : TEXCOORD5;
|
|
NOINTERPOLATION float2 texABBlendValues : TEXCOORD6;
|
|
DECLARE_POSITION_CLIPPLANES_PSIN( pos )
|
|
};
|
|
|
|
#define posDepthW lightColor_DepthW.w
|
|
#define lightColor lightColor_DepthW.xyz
|
|
|
|
#if APPLY_DOF_TO_GPU_PARTICLES
|
|
#define gpuParticleOutput OutHalf4Color_DOF
|
|
#else
|
|
#define gpuParticleOutput half4
|
|
#endif //APPLY_DOF_TO_GPU_PARTICLES
|
|
|
|
#define DOF_GPU_PARTICLE_ALPHA_LIMIT (0.15)
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// HELPER FUNCTIONS
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
float CalculateShadowAmount(float3 centerPos, float3 vertexPos, float3 dirUp, float3 dirSide, float effectShadowAmount)
|
|
{
|
|
#if (RSG_PC && __LOW_QUALITY)
|
|
return 1.0f;
|
|
#else
|
|
const int NUM_SAMPLES = 10;
|
|
|
|
const float2 poisson10[NUM_SAMPLES] =
|
|
{
|
|
float2(0.02027519f, -0.7867655f),
|
|
float2(-0.7015828f, -0.4747616f),
|
|
float2(0.544736f, -0.06281875f),
|
|
float2(-0.1233655f, -0.1290102f),
|
|
float2(0.7202142f, -0.5998743f),
|
|
float2(0.5887699f, 0.8062456f),
|
|
float2(-0.5588413f, 0.3316797f),
|
|
float2(-0.3311834f, 0.8879117f),
|
|
float2(0.05035595f, 0.4865102f),
|
|
float2(0.9244029f, 0.3605934f)
|
|
};
|
|
|
|
|
|
float3 midPt = (centerPos + vertexPos) * 0.5f;
|
|
float radius = length(centerPos - vertexPos) * 0.5f;
|
|
float shadowAmount = 0.0f;
|
|
|
|
//Can't do an unroll here because PS4 compiler can't handle it and ends up
|
|
//making GPU particles flicker a lot
|
|
for(int i=0; i<NUM_SAMPLES; i++)
|
|
{
|
|
float3 samplePos = midPt + radius * ( dirSide * poisson10[i].x + dirUp * poisson10[i].y );
|
|
shadowAmount += CalcCascadeShadowsFastNoFade(gViewInverse[3].xyz, samplePos, float3(0,0,1), float2(0,0));
|
|
}
|
|
shadowAmount *= (1.0f/NUM_SAMPLES);
|
|
return lerp(1.0, shadowAmount, effectShadowAmount);
|
|
#endif
|
|
|
|
}
|
|
// ptxgpuDropCreate ///////////////////////////////
|
|
|
|
float3x3 rotationAboutAxis(float3 axis, float rads)
|
|
{
|
|
// construct a quaternion
|
|
float s;
|
|
float w;
|
|
sincos(rads, s, w);
|
|
float x = axis.x*s;
|
|
float y = axis.y*s;
|
|
float z = axis.z*s;
|
|
|
|
// convert to a matrix
|
|
float x2 = x + x;
|
|
float y2 = y + y;
|
|
float z2 = z + z;
|
|
float xx = x * x2;
|
|
float yy = y * y2;
|
|
float zz = z * z2;
|
|
float xy = x * y2;
|
|
float yz = y * z2;
|
|
float xz = z * x2;
|
|
float wx = w * x2;
|
|
float wy = w * y2;
|
|
float wz = w * z2;
|
|
|
|
float3x3 rotMat;
|
|
rotMat[0][0] = 1.0f-(yy+zz);
|
|
rotMat[1][0] = xy-wz;
|
|
rotMat[2][0] = xz+wy;
|
|
rotMat[0][1] = xy+wz;
|
|
rotMat[1][1] = 1.0f-(xx+zz);
|
|
rotMat[2][1] = yz-wx;
|
|
rotMat[0][2] = xz-wy;
|
|
rotMat[1][2] = yz+wx;
|
|
rotMat[2][2] = 1.0f-(xx+yy);
|
|
|
|
return rotMat;
|
|
}
|
|
|
|
|
|
ptxgpuDropInfo ptxgpuDropCreate(float2 uvs, float4 ptxPosition, float4 ptxVelocity, float drawDirectional, float curLife, float sizeX, float sizeY, float rotSpeed, float zOffset)
|
|
{
|
|
ptxgpuDropInfo OUT = (ptxgpuDropInfo)0;
|
|
|
|
OUT.texCoord = uvs;
|
|
|
|
ptxPosition.z += sizeY*zOffset;
|
|
|
|
uvs.xy = uvs.xy-0.5f;
|
|
float3 dirSide, dirUp, offset;
|
|
if (drawDirectional>0.0f)
|
|
{
|
|
float3 velocity = float3(ptxVelocity.xyz);
|
|
velocity += gDirectionalVelocityAdd.xyz;
|
|
float3 ptxToCam = gViewInverse[3].xyz-ptxPosition.xyz;
|
|
dirUp = normalize(velocity);
|
|
dirSide = normalize(cross(dirUp, ptxToCam));
|
|
offset = (uvs.x*sizeX)*dirSide + ((0.7f-(uvs.y+0.5f))*sizeY)*-dirUp;
|
|
}
|
|
else
|
|
{
|
|
// Find a rotation matrix around the cameras forward direction
|
|
float currRot = rotSpeed * curLife;
|
|
float3x3 rotMat = rotationAboutAxis(gViewInverse[2].xyz, currRot);
|
|
|
|
//Let's orient the particle with the world Up axis
|
|
float3 vViewAxis = normalize(gViewInverse[3] - ptxPosition);
|
|
dirUp = float3(0,0,1);
|
|
if(dot(vViewAxis, dirUp) < 0.999995f)
|
|
{
|
|
dirSide = cross(dirUp, vViewAxis);
|
|
dirSide = normalize(dirSide);
|
|
|
|
dirUp = cross(dirSide, vViewAxis);
|
|
dirUp = normalize(dirUp);
|
|
}
|
|
else
|
|
{
|
|
dirSide = float3(1,0,0);
|
|
dirUp = float3(0,1,0);
|
|
}
|
|
|
|
//applying rotations to the dirUp and dirSide
|
|
dirUp = mul(dirUp, rotMat);
|
|
dirSide = mul(dirSide, rotMat);
|
|
|
|
// Calculate the final offset
|
|
offset = (uvs.x*sizeX)* dirSide + (uvs.y * sizeY) * dirUp;
|
|
}
|
|
|
|
// Transform position to the clipping space
|
|
float4 pos = float4(ptxPosition.xyz, 1.0f);
|
|
pos.xyz += offset.xyz;
|
|
|
|
OUT.pos = (float4)mul(pos, gWorldViewProj);
|
|
OUT.worldPos = (float4)mul(pos, gWorld);
|
|
|
|
OUT.dirUp = dirUp;
|
|
OUT.dirSide = dirSide;
|
|
|
|
return OUT;
|
|
}
|
|
|
|
float4 ptxgpuGetDiffuseColour(sampler2D texSampler, ptxgpuPixelInC IN, bool bAnimateTexture, bool bApplyABBlend, bool bPerform4ChannelBlend)
|
|
{
|
|
float4 texCol = tex2D(texSampler, IN.texCoordCurrA);
|
|
if(bAnimateTexture)
|
|
{
|
|
float4 texColPrevA = tex2D(texSampler, IN.texCoordPrevA);
|
|
texCol = lerp(texColPrevA, texCol, IN.texCoordPrevA.z);
|
|
}
|
|
|
|
if(bApplyABBlend)
|
|
{
|
|
float4 texColB = tex2D(texSampler, IN.texCoordCurrB);
|
|
if(bAnimateTexture)
|
|
{
|
|
float4 texColPrevB = tex2D(texSampler, IN.texCoordPrevB);
|
|
texColB = lerp(texColPrevB, texColB, IN.texCoordPrevB.z);
|
|
}
|
|
if(bPerform4ChannelBlend)
|
|
{
|
|
texCol = texCol * IN.texABBlendValues.x + texColB * IN.texABBlendValues.y;
|
|
|
|
}
|
|
else
|
|
{
|
|
texCol = float4(texCol.rgb, texCol.a * IN.texABBlendValues.x) + float4(texColB.rgb, texColB.a * IN.texABBlendValues.y);
|
|
|
|
}
|
|
}
|
|
|
|
return texCol;
|
|
}
|
|
|
|
#if __SHADERMODEL>=40
|
|
float3 ptxgpuApplyBackgroundDistortion(ptxgpuPixelInC IN, bool bAnimateTexture, bool bApplyAABBBlend)
|
|
{
|
|
float3 outColor;
|
|
|
|
#if __PS3 || __WIN32PC || RSG_ORBIS
|
|
float2 screenPos = IN.pos.xy * gInvScreenSize.xy;
|
|
#else
|
|
float2 screenPos = IN.pos.xy * gInvScreenSize.xy + gInvScreenSize.zw;
|
|
#endif // __PS3
|
|
float2 offsetSamplePos = float2(0.0f, 0.0f);
|
|
//Sample the distorion texture and offset screen space pos based on sample * distortion amount
|
|
[branch]
|
|
if(gBackgroundDistortionAmount > 0.0f)
|
|
{
|
|
float depthFactor = 1.0 - (IN.pos.z * IN.pos.z);
|
|
float4 distortionNormal = ptxgpuGetDiffuseColour(DistortionSampler, IN, bAnimateTexture, bApplyAABBBlend, true);
|
|
distortionNormal.xy = distortionNormal.xy * 2.0f - 1.0f;
|
|
distortionNormal.xy = lerp(float2(0.0f,0.0f), distortionNormal.xy, distortionNormal.z);
|
|
offsetSamplePos = (distortionNormal.xy * gInvScreenSize.xy) * (depthFactor * gBackgroundDistortionAmount);
|
|
}
|
|
|
|
const float3 backGroundColor = tex2D(BackBufferSampler, screenPos.xy + offsetSamplePos).rgb;
|
|
outColor = (backGroundColor * gBackgroundDistortionVisibilityPercentage);
|
|
return outColor;
|
|
|
|
}
|
|
#endif
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// VERTEX SHADER
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
ptxgpuVertexOutC VS_ptxgpuRenderDrop_Common(ptxgpuVertexIn IN, bool bAnimateTexture, bool bApplyABBlend, bool bApplyBackgroundDistortion)
|
|
{
|
|
// get the particle state
|
|
float4 pos4;
|
|
float4 vel4;
|
|
float2 texCoords;
|
|
ptxgpuGetParticleState(IN, texCoords, pos4, vel4);
|
|
|
|
// Transform local position to world position
|
|
pos4.xyz += gRefParticlePos;
|
|
|
|
// Position W contains the collision state in the sign and the current particle life value
|
|
float curLife = abs(pos4.w);
|
|
|
|
// unpack the current and max life
|
|
float seed;
|
|
float initLife;
|
|
UnPackVelW(vel4.w, gMaxLife, initLife, seed);
|
|
|
|
// get a random value (use the texture id for the moment - this could need fiddled with a bit more)
|
|
float randomTexId = seed;
|
|
float randomSize = frac(seed*10.0f);
|
|
float randomRot = frac(seed*100.0f);
|
|
|
|
float rotSpeed = gRotSpeedMinRange.x + gRotSpeedMinRange.y * randomRot;
|
|
|
|
// check if the particle has collided with the ground yet
|
|
ptxgpuDropInfo ptxInfo;
|
|
|
|
// particle has not collided - therefore it is visible
|
|
float2 sizeXY = gSizeMinRange.xy + gSizeMinRange.zw * randomSize;
|
|
|
|
// random height offset for particle
|
|
float zOffset = gDirectionalZOffsetMinRange.y + gDirectionalZOffsetMinRange.z * frac(seed*1000.0f);
|
|
ptxInfo = ptxgpuDropCreate(texCoords, pos4, vel4, gDirectionalZOffsetMinRange.x, curLife, sizeXY.x, sizeXY.y, rotSpeed, zOffset);
|
|
|
|
ptxgpuVertexOutC OUT;
|
|
OUT.texCoordCurrA = ptxInfo.texCoord;
|
|
OUT.texCoordPrevA.xy = ptxInfo.texCoord;
|
|
OUT.texCoordPrevA.z = 0.0f;
|
|
OUT.texCoordCurrB = ptxInfo.texCoord;
|
|
OUT.texCoordPrevB.xy = ptxInfo.texCoord;
|
|
OUT.texCoordPrevB.z = 0.0f;
|
|
OUT.pos = ptxInfo.pos;
|
|
OUT.posDepthW = OUT.pos.w;
|
|
OUT.texABBlendValues = float2(0.0f,0.0f);
|
|
|
|
// calculate the animated texture id (depending on whether we're scaling over life ratio or curr life)
|
|
float curLifeIncreasing = initLife - curLife;
|
|
float animTexId = lerp(curLifeIncreasing*gTextureAnimRateScaleOverLifeStart2End2.x,
|
|
(curLifeIncreasing/initLife)*gTextureAnimRateScaleOverLifeStart2End2.x,
|
|
gTextureAnimRateScaleOverLifeStart2End2.y);
|
|
|
|
// use the animated texture id if the anim rate is non-zero
|
|
randomTexId = fselect_gt(gTextureAnimRateScaleOverLifeStart2End2.x, 0.0f, frac(animTexId), randomTexId);
|
|
|
|
// set the colour of the falling drop
|
|
OUT.color = gColour; // gColor converted to linear space on the CPU
|
|
|
|
// turn the random texture id (0.0 -> 0.999) into a texture id into the texture page
|
|
float texIdA = gTextureRowsColsStartEnd.z + (randomTexId*0.999f*(1+gTextureRowsColsStartEnd.w-gTextureRowsColsStartEnd.z));
|
|
float texIdCurrA = floor(texIdA);
|
|
|
|
// calculate the texture page info
|
|
float4 TextureRowsColsCurrA = float4(fmod(texIdCurrA, gTextureRowsColsStartEnd.y), // xIndex = id % cols
|
|
floor(texIdCurrA / gTextureRowsColsStartEnd.y), // yIndex = id / cols
|
|
1.0f/gTextureRowsColsStartEnd.y, // xStep = 1 / cols
|
|
1.0f/gTextureRowsColsStartEnd.x); // yStep = 1 / rows
|
|
|
|
// convert the global uv space into that of the texture page at the required texture id
|
|
OUT.texCoordCurrA.xy = (TextureRowsColsCurrA.xy+OUT.texCoordCurrA.xy) * TextureRowsColsCurrA.zw;
|
|
|
|
if(bAnimateTexture)
|
|
{
|
|
// turn the random texture id (0.0 -> 0.999) into a texture id into the texture page
|
|
float texIdPrevA = fselect_lt(texIdCurrA-1, gTextureRowsColsStartEnd.z, texIdCurrA, texIdCurrA-1);
|
|
|
|
// calculate the texture page info
|
|
float4 TextureRowsColsPrevA = float4(fmod(texIdPrevA, gTextureRowsColsStartEnd.y), // xIndex = id % cols
|
|
floor(texIdPrevA / gTextureRowsColsStartEnd.y), // yIndex = id / cols
|
|
1.0f/gTextureRowsColsStartEnd.y, // xStep = 1 / cols
|
|
1.0f/gTextureRowsColsStartEnd.x); // yStep = 1 / rows
|
|
|
|
// convert the global uv space into that of the texture page at the required texture id
|
|
OUT.texCoordPrevA.xy = (TextureRowsColsPrevA.xy+OUT.texCoordPrevA.xy) * TextureRowsColsPrevA.zw;
|
|
OUT.texCoordPrevA.z = fselect_gt(gTextureAnimRateScaleOverLifeStart2End2.x, 0.0f, frac(texIdA), 1.0f);
|
|
}
|
|
|
|
if(bApplyABBlend)
|
|
{
|
|
// turn the random texture id (0.0 -> 0.999) into a texture id into the texture page
|
|
float texIdB = gTextureAnimRateScaleOverLifeStart2End2.z + (randomTexId*0.999f*(1+gTextureAnimRateScaleOverLifeStart2End2.w-gTextureAnimRateScaleOverLifeStart2End2.z));
|
|
float texIdCurrB = floor(texIdB);
|
|
// calculate the texture page info
|
|
float4 TextureRowsColsCurrB = float4(fmod(texIdCurrB, gTextureRowsColsStartEnd.y), // xIndex = id % cols
|
|
floor(texIdCurrB / gTextureRowsColsStartEnd.y), // yIndex = id / cols
|
|
1.0f/gTextureRowsColsStartEnd.y, // xStep = 1 / cols
|
|
1.0f/gTextureRowsColsStartEnd.x); // yStep = 1 / rows
|
|
|
|
// convert the global uv space into that of the texture page at the required texture id
|
|
OUT.texCoordCurrB.xy = (TextureRowsColsCurrB.xy+OUT.texCoordCurrB.xy) * TextureRowsColsCurrB.zw;
|
|
|
|
if(bAnimateTexture)
|
|
{
|
|
// turn the random texture id (0.0 -> 0.999) into a texture id into the texture page
|
|
float texIdPrevB = fselect_lt(texIdCurrB-1, gTextureAnimRateScaleOverLifeStart2End2.z, texIdCurrB, texIdCurrB-1);
|
|
// calculate the texture page info
|
|
float4 TextureRowsColsPrevB = float4(fmod(texIdPrevB, gTextureRowsColsStartEnd.y), // xIndex = id % cols
|
|
floor(texIdPrevB / gTextureRowsColsStartEnd.y), // yIndex = id / cols
|
|
1.0f/gTextureRowsColsStartEnd.y, // xStep = 1 / cols
|
|
1.0f/gTextureRowsColsStartEnd.x); // yStep = 1 / rows
|
|
|
|
// convert the global uv space into that of the texture page at the required texture id
|
|
OUT.texCoordPrevB.xy = (TextureRowsColsPrevB.xy+OUT.texCoordPrevB.xy) * TextureRowsColsPrevB.zw;
|
|
OUT.texCoordPrevB.z = fselect_gt(gTextureAnimRateScaleOverLifeStart2End2.x, 0.0f, frac(texIdB), 1.0f);
|
|
|
|
}
|
|
|
|
//Lets calculate how much of A and B we require based on the view vector
|
|
float3 eyeDir = normalize(pos4.xyz - gViewInverse[3].xyz);
|
|
float cosCamAngle = abs(eyeDir.z);
|
|
|
|
float forwardAngleFade = saturate((1.0f - cosCamAngle - gCamAngleForwardMin)*gCamAngleForwardInvRange);
|
|
float upAngleFade = saturate((cosCamAngle - gCamAngleUpMin)*gCamAngleUpInvRange);
|
|
OUT.texABBlendValues = float2(forwardAngleFade,upAngleFade);
|
|
|
|
}
|
|
|
|
// fade all particles as they get far from the camera
|
|
float fadeFar = 1.0f - (length(gViewInverse[3].xy - pos4.xy) * gFadeNearFar.y);
|
|
float fadeFarMult = saturate(fadeFar * fadeFar * fadeFar);
|
|
OUT.color.a *= fadeFarMult;
|
|
|
|
// fade all particles as they get near the camera
|
|
float fadeNear = length(gViewInverse[3].xy - pos4.xy) * gFadeNearFar.x;
|
|
float fadeNearMult = saturate(fadeNear * fadeNear * fadeNear);
|
|
OUT.color.a *= fadeNearMult;
|
|
|
|
// fade all particles relative to the base z
|
|
float baseZLoMult = saturate((pos4.z-gFadeZBaseLoHi.x)*abs(gFadeZBaseLoHi.y));
|
|
OUT.color.a *= baseZLoMult;
|
|
|
|
float baseZHiMult = saturate((pos4.z-gFadeZBaseLoHi.x)*abs(gFadeZBaseLoHi.z));
|
|
OUT.color.a *= 1.0f-baseZHiMult;
|
|
|
|
// fade the particle in and out over it's life
|
|
float dropFadeIn = saturate((initLife - curLife) * gFadeInOut.x);
|
|
float dropFadeOut = saturate(curLife * gFadeInOut.y);
|
|
OUT.color.a *= dropFadeIn * dropFadeOut;
|
|
|
|
// Take the exponent bias into account
|
|
OUT.color.a *= gInvColorExpBias;
|
|
|
|
LocalLightResult lightingRes = CalculateLightingForward(
|
|
4,
|
|
true, //diffuse
|
|
float3(1.0, 1.0, 1.0), // material.diffuseColor.rgb,
|
|
pos4.xyz, //surface.position
|
|
normalize(gViewInverse[3].xyz - pos4.xyz) // surface.normal
|
|
#if GLASS_LIGHTING
|
|
, OUT.color.w
|
|
#endif // GLASS_LIGHTING
|
|
);
|
|
|
|
float3 dirIntensity = gDirectionalColour.rgb;
|
|
float3 ambIntensity = naturalAmbient(1.0f);
|
|
[branch]
|
|
if(gDirectionalLightShadowAmount>0.0f)
|
|
{
|
|
dirIntensity *= CalculateShadowAmount(pos4.xyz, ptxInfo.worldPos.xyz, ptxInfo.dirUp.xyz, ptxInfo.dirSide.xyz, gDirectionalLightShadowAmount);
|
|
}
|
|
OUT.lightColor.rgb = (dirIntensity + ambIntensity) * gLightIntensityMult + (lightingRes.diffuseLightContribution * gLocalLightsMultiplier);
|
|
|
|
//This is to boost alpha if using the background to contribute to the color (otherwise it just isn't noticeable on the rain)
|
|
if(bApplyBackgroundDistortion)
|
|
{
|
|
OUT.color.a *= gBackgroundDistortionAlphaBooster;
|
|
}
|
|
|
|
// Zero out particles that have colided or that are fully transparent in order to cull them
|
|
#if __PS3
|
|
// PS3 culls dead drop particles on the SPU (ground particles don't die)
|
|
float isDead = OUT.color.a <= 0.01;
|
|
#else
|
|
// dead if the alpha is too low or the particle is flagged as dead
|
|
float isDead = OUT.color.a <= 0.001f || pos4.w<0.0f;
|
|
#endif // !__PS3
|
|
|
|
#if __SHADERMODEL >= 40
|
|
// isDead is set to one when we want to clip and zero otherwise
|
|
OUT.pos_ClipDistance0 = 1.0f - (2.0f * isDead);
|
|
#else
|
|
OUT.pos.xyz *= 1.0 - isDead;
|
|
|
|
#endif //__SHADERMODEL >= 40
|
|
|
|
return OUT;
|
|
}
|
|
|
|
|
|
ptxgpuVertexOutC VS_ptxgpuRenderDrop_NoAnimate_NoABBlend_NoBackgroundDistortion(ptxgpuVertexIn IN)
|
|
{
|
|
return VS_ptxgpuRenderDrop_Common(IN, false, false, false);
|
|
}
|
|
|
|
ptxgpuVertexOutC VS_ptxgpuRenderDrop_Animate_NoABBlend_NoBackgroundDistortion(ptxgpuVertexIn IN)
|
|
{
|
|
return VS_ptxgpuRenderDrop_Common(IN, true, false, false);
|
|
}
|
|
|
|
ptxgpuVertexOutC VS_ptxgpuRenderDrop_NoAnimate_ABBlend_NoBackgroundDistortion(ptxgpuVertexIn IN)
|
|
{
|
|
return VS_ptxgpuRenderDrop_Common(IN, false, true, false);
|
|
}
|
|
|
|
ptxgpuVertexOutC VS_ptxgpuRenderDrop_Animate_ABBlend_NoBackgroundDistortion(ptxgpuVertexIn IN)
|
|
{
|
|
return VS_ptxgpuRenderDrop_Common(IN, true, true, false);
|
|
}
|
|
|
|
ptxgpuVertexOutC VS_ptxgpuRenderDrop_NoAnimate_NoABBlend_BackgroundDistortion(ptxgpuVertexIn IN)
|
|
{
|
|
return VS_ptxgpuRenderDrop_Common(IN, false, false, true);
|
|
}
|
|
|
|
ptxgpuVertexOutC VS_ptxgpuRenderDrop_Animate_NoABBlend_BackgroundDistortion(ptxgpuVertexIn IN)
|
|
{
|
|
return VS_ptxgpuRenderDrop_Common(IN, true, false, true);
|
|
}
|
|
|
|
ptxgpuVertexOutC VS_ptxgpuRenderDrop_NoAnimate_ABBlend_BackgroundDistortion(ptxgpuVertexIn IN)
|
|
{
|
|
return VS_ptxgpuRenderDrop_Common(IN, false, true, true);
|
|
}
|
|
|
|
ptxgpuVertexOutC VS_ptxgpuRenderDrop_Animate_ABBlend_BackgroundDistortion(ptxgpuVertexIn IN)
|
|
{
|
|
return VS_ptxgpuRenderDrop_Common(IN, true, true, true);
|
|
}
|
|
|
|
|
|
#if __SHADERMODEL >= 40
|
|
|
|
ptxgpuVertexOutC VS_ptxgpuRenderDrop_NoAnimate_NoABBlend_NoBackgroundDistortion_LookUp(ptxgpuLookUpVertexIn IN, uint InstanceID : SV_InstanceID)
|
|
{
|
|
ptxgpuVertexIn Vertex = Create_ptxgpuVertexIn(IN, InstanceID);
|
|
return VS_ptxgpuRenderDrop_NoAnimate_NoABBlend_NoBackgroundDistortion(Vertex);
|
|
}
|
|
|
|
ptxgpuVertexOutC VS_ptxgpuRenderDrop_Animate_NoABBlend_NoBackgroundDistortion_LookUp(ptxgpuLookUpVertexIn IN, uint InstanceID : SV_InstanceID)
|
|
{
|
|
ptxgpuVertexIn Vertex = Create_ptxgpuVertexIn(IN, InstanceID);
|
|
return VS_ptxgpuRenderDrop_Animate_NoABBlend_NoBackgroundDistortion(Vertex);
|
|
}
|
|
|
|
ptxgpuVertexOutC VS_ptxgpuRenderDrop_NoAnimate_ABBlend_NoBackgroundDistortion_LookUp(ptxgpuLookUpVertexIn IN, uint InstanceID : SV_InstanceID)
|
|
{
|
|
ptxgpuVertexIn Vertex = Create_ptxgpuVertexIn(IN, InstanceID);
|
|
return VS_ptxgpuRenderDrop_NoAnimate_ABBlend_NoBackgroundDistortion(Vertex);
|
|
}
|
|
|
|
ptxgpuVertexOutC VS_ptxgpuRenderDrop_Animate_ABBlend_NoBackgroundDistortion_LookUp(ptxgpuLookUpVertexIn IN, uint InstanceID : SV_InstanceID)
|
|
{
|
|
ptxgpuVertexIn Vertex = Create_ptxgpuVertexIn(IN, InstanceID);
|
|
return VS_ptxgpuRenderDrop_Animate_ABBlend_NoBackgroundDistortion(Vertex);
|
|
}
|
|
|
|
ptxgpuVertexOutC VS_ptxgpuRenderDrop_NoAnimate_NoABBlend_BackgroundDistortion_LookUp(ptxgpuLookUpVertexIn IN, uint InstanceID : SV_InstanceID)
|
|
{
|
|
ptxgpuVertexIn Vertex = Create_ptxgpuVertexIn(IN, InstanceID);
|
|
return VS_ptxgpuRenderDrop_NoAnimate_NoABBlend_BackgroundDistortion(Vertex);
|
|
}
|
|
|
|
ptxgpuVertexOutC VS_ptxgpuRenderDrop_Animate_NoABBlend_BackgroundDistortion_LookUp(ptxgpuLookUpVertexIn IN, uint InstanceID : SV_InstanceID)
|
|
{
|
|
ptxgpuVertexIn Vertex = Create_ptxgpuVertexIn(IN, InstanceID);
|
|
return VS_ptxgpuRenderDrop_Animate_NoABBlend_BackgroundDistortion(Vertex);
|
|
}
|
|
|
|
ptxgpuVertexOutC VS_ptxgpuRenderDrop_NoAnimate_ABBlend_BackgroundDistortion_LookUp(ptxgpuLookUpVertexIn IN, uint InstanceID : SV_InstanceID)
|
|
{
|
|
ptxgpuVertexIn Vertex = Create_ptxgpuVertexIn(IN, InstanceID);
|
|
return VS_ptxgpuRenderDrop_NoAnimate_ABBlend_BackgroundDistortion(Vertex);
|
|
}
|
|
|
|
ptxgpuVertexOutC VS_ptxgpuRenderDrop_Animate_ABBlend_BackgroundDistortion_LookUp(ptxgpuLookUpVertexIn IN, uint InstanceID : SV_InstanceID)
|
|
{
|
|
ptxgpuVertexIn Vertex = Create_ptxgpuVertexIn(IN, InstanceID);
|
|
return VS_ptxgpuRenderDrop_Animate_ABBlend_BackgroundDistortion(Vertex);
|
|
}
|
|
|
|
#endif //__WIN32PC && __SHADERMODEL >= 40
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// PIXEL SHADER
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
gpuParticleOutput PS_ptxgpuRender_Common(ptxgpuPixelInC IN, bool bAnimateTexture, bool bApplyABBlend, bool bApplyBackgroundDistortion)
|
|
{
|
|
float4 color = IN.color;
|
|
color.rgb *= IN.lightColor;
|
|
|
|
// We only care about the alpha value
|
|
#if __SHADERMODEL >= 40
|
|
|
|
float4 rainColor = color.rgba;
|
|
|
|
float4 particleTexture = ptxgpuGetDiffuseColour(DiffuseSampler, IN, bAnimateTexture, bApplyABBlend, false);
|
|
|
|
color.a = saturate(rainColor.a * particleTexture.a);
|
|
color.rgb = (rainColor.rgb * gParticleColorPercentage);
|
|
|
|
// If we need background distortion...
|
|
if(bApplyBackgroundDistortion)
|
|
{
|
|
color.rgb += ptxgpuApplyBackgroundDistortion(IN, bAnimateTexture, bApplyABBlend);
|
|
}
|
|
|
|
#else // __SHADERMODEL >= 40
|
|
|
|
float colAlphaMult = ptxgpuGetDiffuseColour(DiffuseSampler, IN, bAnimateTexture, bApplyABBlend, false).a;
|
|
color.a *= colAlphaMult;
|
|
|
|
#endif // __SHADERMODEL >= 40
|
|
|
|
half4 packedCol = PackHdr(color);
|
|
|
|
gpuParticleOutput OUT;
|
|
#if APPLY_DOF_TO_GPU_PARTICLES
|
|
// calculate the final pixel colour
|
|
OUT.col0 = packedCol;
|
|
float dofOutput = color.a > DOF_GPU_PARTICLE_ALPHA_LIMIT ? 1.0 : 0.0;
|
|
float dofDepth = IN.posDepthW;
|
|
#if SUPPORT_INVERTED_PROJECTION
|
|
dofDepth = 1.0 - dofDepth;
|
|
#endif
|
|
OUT.dof.depth = dofDepth * dofOutput; //z/w
|
|
OUT.dof.alpha = dofOutput;
|
|
#else
|
|
OUT = packedCol;
|
|
#endif
|
|
|
|
return OUT;
|
|
}
|
|
|
|
gpuParticleOutput PS_ptxgpuRender_NoAnimate_NoABBlend_NoBackgroundDistortion(ptxgpuPixelInC IN) : COLOR
|
|
{
|
|
return PS_ptxgpuRender_Common(IN, false, false, false);
|
|
}
|
|
|
|
gpuParticleOutput PS_ptxgpuRender_Animate_NoABBlend_NoBackgroundDistortion(ptxgpuPixelInC IN) : COLOR
|
|
{
|
|
return PS_ptxgpuRender_Common(IN, true, false, false);
|
|
}
|
|
|
|
gpuParticleOutput PS_ptxgpuRender_NoAnimate_ABBlend_NoBackgroundDistortion(ptxgpuPixelInC IN) : COLOR
|
|
{
|
|
return PS_ptxgpuRender_Common(IN, false, true, false);
|
|
}
|
|
|
|
gpuParticleOutput PS_ptxgpuRender_Animate_ABBlend_NoBackgroundDistortion(ptxgpuPixelInC IN) : COLOR
|
|
{
|
|
return PS_ptxgpuRender_Common(IN, true, true, false);
|
|
}
|
|
|
|
gpuParticleOutput PS_ptxgpuRender_NoAnimate_NoABBlend_BackgroundDistortion(ptxgpuPixelInC IN) : COLOR
|
|
{
|
|
return PS_ptxgpuRender_Common(IN, false, false, true);
|
|
}
|
|
|
|
gpuParticleOutput PS_ptxgpuRender_Animate_NoABBlend_BackgroundDistortion(ptxgpuPixelInC IN) : COLOR
|
|
{
|
|
return PS_ptxgpuRender_Common(IN, true, false, true);
|
|
}
|
|
|
|
gpuParticleOutput PS_ptxgpuRender_NoAnimate_ABBlend_BackgroundDistortion(ptxgpuPixelInC IN) : COLOR
|
|
{
|
|
return PS_ptxgpuRender_Common(IN, false, true, true);
|
|
}
|
|
|
|
gpuParticleOutput PS_ptxgpuRender_Animate_ABBlend_BackgroundDistortion(ptxgpuPixelInC IN) : COLOR
|
|
{
|
|
return PS_ptxgpuRender_Common(IN, true, true, true);
|
|
}
|
|
|
|
half4 PS_ptxgpuRenderSoftCommon(ptxgpuPixelInC IN, bool bAnimateTexture, bool bApplyABBlend, bool bApplyBackgroundDistortion)
|
|
{
|
|
float4 color = IN.color;
|
|
color.rgb *= IN.lightColor;
|
|
|
|
// We only care about the alpha value
|
|
float colAlphaMult = ptxgpuGetDiffuseColour(DiffuseSampler, IN, bAnimateTexture, bApplyABBlend, false).a;
|
|
color.a *= colAlphaMult;
|
|
|
|
#if __SHADERMODEL>=40
|
|
// If we need background distortion...
|
|
if(bApplyBackgroundDistortion)
|
|
{
|
|
color.rgb += ptxgpuApplyBackgroundDistortion(IN, bAnimateTexture, bApplyABBlend);
|
|
}
|
|
#endif
|
|
// Get the pixels GBuffer depth
|
|
|
|
#if __LOW_QUALITY
|
|
float sampledDepth = 1.0f;
|
|
#else
|
|
float sampledDepth;
|
|
ptfxGetDepthValue(IN.pos.xy, sampledDepth);
|
|
#endif // __LOW_QUALITY
|
|
|
|
// Do the soft edge calculation
|
|
float depthDiff = (sampledDepth - IN.posDepthW);
|
|
depthDiff*=depthDiff;
|
|
float softFade = saturate( depthDiff * gEdgeSoftness );
|
|
color.a *= softFade;
|
|
|
|
// calculate the final pixel colour
|
|
return PackHdr(color);
|
|
}
|
|
|
|
|
|
half4 PS_ptxgpuRenderSoft_NoAnimate_NoABBlend_NoBackgroundDistortion(ptxgpuPixelInC IN) : COLOR
|
|
{
|
|
return PS_ptxgpuRenderSoftCommon(IN, false, false, false);
|
|
}
|
|
half4 PS_ptxgpuRenderSoft_Animate_NoABBlend_NoBackgroundDistortion(ptxgpuPixelInC IN) : COLOR
|
|
{
|
|
return PS_ptxgpuRenderSoftCommon(IN, true, false, false);
|
|
}
|
|
half4 PS_ptxgpuRenderSoft_NoAnimate_ABBlend_NoBackgroundDistortion(ptxgpuPixelInC IN) : COLOR
|
|
{
|
|
return PS_ptxgpuRenderSoftCommon(IN, false, true, false);
|
|
}
|
|
half4 PS_ptxgpuRenderSoft_Animate_ABBlend_NoBackgroundDistortion(ptxgpuPixelInC IN) : COLOR
|
|
{
|
|
return PS_ptxgpuRenderSoftCommon(IN, true, true, false);
|
|
}
|
|
|
|
half4 PS_ptxgpuRenderSoft_NoAnimate_NoABBlend_BackgroundDistortion(ptxgpuPixelInC IN) : COLOR
|
|
{
|
|
return PS_ptxgpuRenderSoftCommon(IN, false, false, true);
|
|
}
|
|
half4 PS_ptxgpuRenderSoft_Animate_NoABBlend_BackgroundDistortion(ptxgpuPixelInC IN) : COLOR
|
|
{
|
|
return PS_ptxgpuRenderSoftCommon(IN, true, false, true);
|
|
}
|
|
half4 PS_ptxgpuRenderSoft_NoAnimate_ABBlend_BackgroundDistortion(ptxgpuPixelInC IN) : COLOR
|
|
{
|
|
return PS_ptxgpuRenderSoftCommon(IN, false, true, true);
|
|
}
|
|
half4 PS_ptxgpuRenderSoft_Animate_ABBlend_BackgroundDistortion(ptxgpuPixelInC IN) : COLOR
|
|
{
|
|
return PS_ptxgpuRenderSoftCommon(IN, true, true, true);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// TECHNIQUES
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
technique draw
|
|
{
|
|
pass p_NoAnim_NoABBlend_NoBackgroundDistortion
|
|
{
|
|
CullMode = None;
|
|
#if __SHADERMODEL >= 40
|
|
VertexShader = compile VERTEXSHADER VS_ptxgpuRenderDrop_NoAnimate_NoABBlend_NoBackgroundDistortion_LookUp();
|
|
#else
|
|
VertexShader = compile VERTEXSHADER VS_ptxgpuRenderDrop_NoAnimate_NoABBlend_NoBackgroundDistortion();
|
|
#endif
|
|
PixelShader = compile PIXELSHADER PS_ptxgpuRender_NoAnimate_NoABBlend_NoBackgroundDistortion() CGC_FLAGS(CGC_DEFAULTFLAGS);
|
|
}
|
|
|
|
pass p_Anim_NoABBlend_NoBackgroundDistortion
|
|
{
|
|
CullMode = None;
|
|
#if __SHADERMODEL >= 40
|
|
VertexShader = compile VERTEXSHADER VS_ptxgpuRenderDrop_Animate_NoABBlend_NoBackgroundDistortion_LookUp();
|
|
#else
|
|
VertexShader = compile VERTEXSHADER VS_ptxgpuRenderDrop_Animate_NoABBlend_NoBackgroundDistortion();
|
|
#endif
|
|
PixelShader = compile PIXELSHADER PS_ptxgpuRender_Animate_NoABBlend_NoBackgroundDistortion() CGC_FLAGS(CGC_DEFAULTFLAGS);
|
|
}
|
|
|
|
pass p_NoAnim_ABBlend_NoBackgroundDistortion
|
|
{
|
|
CullMode = None;
|
|
#if __SHADERMODEL >= 40
|
|
VertexShader = compile VERTEXSHADER VS_ptxgpuRenderDrop_NoAnimate_ABBlend_NoBackgroundDistortion_LookUp();
|
|
#else
|
|
VertexShader = compile VERTEXSHADER VS_ptxgpuRenderDrop_NoAnimate_ABBlend_NoBackgroundDistortion();
|
|
#endif
|
|
PixelShader = compile PIXELSHADER PS_ptxgpuRender_NoAnimate_ABBlend_NoBackgroundDistortion() CGC_FLAGS(CGC_DEFAULTFLAGS);
|
|
}
|
|
|
|
pass p_Anim_ABBlend_NoBackgroundDistortion
|
|
{
|
|
CullMode = None;
|
|
#if __SHADERMODEL >= 40
|
|
VertexShader = compile VERTEXSHADER VS_ptxgpuRenderDrop_Animate_ABBlend_NoBackgroundDistortion_LookUp();
|
|
#else
|
|
VertexShader = compile VERTEXSHADER VS_ptxgpuRenderDrop_Animate_ABBlend_NoBackgroundDistortion();
|
|
#endif
|
|
PixelShader = compile PIXELSHADER PS_ptxgpuRender_Animate_ABBlend_NoBackgroundDistortion() CGC_FLAGS(CGC_DEFAULTFLAGS);
|
|
}
|
|
|
|
|
|
|
|
|
|
pass p_NoAnim_NoABBlend_BackgroundDistortion
|
|
{
|
|
CullMode = None;
|
|
#if __SHADERMODEL >= 40
|
|
VertexShader = compile VERTEXSHADER VS_ptxgpuRenderDrop_NoAnimate_NoABBlend_BackgroundDistortion_LookUp();
|
|
#else
|
|
VertexShader = compile VERTEXSHADER VS_ptxgpuRenderDrop_NoAnimate_NoABBlend_BackgroundDistortion();
|
|
#endif
|
|
PixelShader = compile PIXELSHADER PS_ptxgpuRender_NoAnimate_NoABBlend_BackgroundDistortion() CGC_FLAGS(CGC_DEFAULTFLAGS);
|
|
}
|
|
|
|
pass p_Anim_NoABBlend_BackgroundDistortion
|
|
{
|
|
CullMode = None;
|
|
#if __SHADERMODEL >= 40
|
|
VertexShader = compile VERTEXSHADER VS_ptxgpuRenderDrop_Animate_NoABBlend_BackgroundDistortion_LookUp();
|
|
#else
|
|
VertexShader = compile VERTEXSHADER VS_ptxgpuRenderDrop_Animate_NoABBlend_BackgroundDistortion();
|
|
#endif
|
|
PixelShader = compile PIXELSHADER PS_ptxgpuRender_Animate_NoABBlend_BackgroundDistortion() CGC_FLAGS(CGC_DEFAULTFLAGS);
|
|
}
|
|
|
|
pass p_NoAnim_ABBlend_BackgroundDistortion
|
|
{
|
|
CullMode = None;
|
|
#if __SHADERMODEL >= 40
|
|
VertexShader = compile VERTEXSHADER VS_ptxgpuRenderDrop_NoAnimate_ABBlend_BackgroundDistortion_LookUp();
|
|
#else
|
|
VertexShader = compile VERTEXSHADER VS_ptxgpuRenderDrop_NoAnimate_ABBlend_BackgroundDistortion();
|
|
#endif
|
|
PixelShader = compile PIXELSHADER PS_ptxgpuRender_NoAnimate_ABBlend_BackgroundDistortion() CGC_FLAGS(CGC_DEFAULTFLAGS);
|
|
}
|
|
|
|
pass p_Anim_ABBlend_BackgroundDistortion
|
|
{
|
|
CullMode = None;
|
|
#if __SHADERMODEL >= 40
|
|
VertexShader = compile VERTEXSHADER VS_ptxgpuRenderDrop_Animate_ABBlend_BackgroundDistortion_LookUp();
|
|
#else
|
|
VertexShader = compile VERTEXSHADER VS_ptxgpuRenderDrop_Animate_ABBlend_BackgroundDistortion();
|
|
#endif
|
|
PixelShader = compile PIXELSHADER PS_ptxgpuRender_Animate_ABBlend_BackgroundDistortion() CGC_FLAGS(CGC_DEFAULTFLAGS);
|
|
}
|
|
}
|
|
|
|
technique draw_soft
|
|
{
|
|
pass p_NoAnim_NoBlend_NoBackgroundDistortion
|
|
{
|
|
CullMode = None;
|
|
#if __SHADERMODEL >= 40
|
|
VertexShader = compile VERTEXSHADER VS_ptxgpuRenderDrop_NoAnimate_NoABBlend_NoBackgroundDistortion_LookUp();
|
|
#else
|
|
VertexShader = compile VERTEXSHADER VS_ptxgpuRenderDrop_NoAnimate_NoABBlend_NoBackgroundDistortion();
|
|
#endif
|
|
PixelShader = compile PIXELSHADER PS_ptxgpuRenderSoft_NoAnimate_NoABBlend_NoBackgroundDistortion() CGC_FLAGS(CGC_DEFAULTFLAGS);
|
|
}
|
|
pass p_Anim_NoBlend_NoBackgroundDistortion
|
|
{
|
|
CullMode = None;
|
|
#if __SHADERMODEL >= 40
|
|
VertexShader = compile VERTEXSHADER VS_ptxgpuRenderDrop_Animate_NoABBlend_NoBackgroundDistortion_LookUp();
|
|
#else
|
|
VertexShader = compile VERTEXSHADER VS_ptxgpuRenderDrop_Animate_NoABBlend_NoBackgroundDistortion();
|
|
#endif
|
|
PixelShader = compile PIXELSHADER PS_ptxgpuRenderSoft_Animate_NoABBlend_NoBackgroundDistortion() CGC_FLAGS(CGC_DEFAULTFLAGS);
|
|
}
|
|
pass p_NoAnim_Blend_NoBackgroundDistortion
|
|
{
|
|
CullMode = None;
|
|
#if __SHADERMODEL >= 40
|
|
VertexShader = compile VERTEXSHADER VS_ptxgpuRenderDrop_NoAnimate_ABBlend_NoBackgroundDistortion_LookUp();
|
|
#else
|
|
VertexShader = compile VERTEXSHADER VS_ptxgpuRenderDrop_NoAnimate_ABBlend_NoBackgroundDistortion();
|
|
#endif
|
|
PixelShader = compile PIXELSHADER PS_ptxgpuRenderSoft_NoAnimate_ABBlend_NoBackgroundDistortion() CGC_FLAGS(CGC_DEFAULTFLAGS);
|
|
}
|
|
pass p_Anim_Blend_NoBackgroundDistortion
|
|
{
|
|
CullMode = None;
|
|
#if __SHADERMODEL >= 40
|
|
VertexShader = compile VERTEXSHADER VS_ptxgpuRenderDrop_Animate_ABBlend_NoBackgroundDistortion_LookUp();
|
|
#else
|
|
VertexShader = compile VERTEXSHADER VS_ptxgpuRenderDrop_Animate_ABBlend_NoBackgroundDistortion();
|
|
#endif
|
|
PixelShader = compile PIXELSHADER PS_ptxgpuRenderSoft_Animate_ABBlend_NoBackgroundDistortion() CGC_FLAGS(CGC_DEFAULTFLAGS);
|
|
}
|
|
pass p_NoAnim_NoBlend_BackgroundDistortion
|
|
{
|
|
CullMode = None;
|
|
#if __SHADERMODEL >= 40
|
|
VertexShader = compile VERTEXSHADER VS_ptxgpuRenderDrop_NoAnimate_NoABBlend_BackgroundDistortion_LookUp();
|
|
#else
|
|
VertexShader = compile VERTEXSHADER VS_ptxgpuRenderDrop_NoAnimate_NoABBlend_BackgroundDistortion();
|
|
#endif
|
|
PixelShader = compile PIXELSHADER PS_ptxgpuRenderSoft_NoAnimate_NoABBlend_BackgroundDistortion() CGC_FLAGS(CGC_DEFAULTFLAGS);
|
|
}
|
|
pass p_Anim_NoBlend_BackgroundDistortion
|
|
{
|
|
CullMode = None;
|
|
#if __SHADERMODEL >= 40
|
|
VertexShader = compile VERTEXSHADER VS_ptxgpuRenderDrop_Animate_NoABBlend_NoBackgroundDistortion_LookUp();
|
|
#else
|
|
VertexShader = compile VERTEXSHADER VS_ptxgpuRenderDrop_Animate_NoABBlend_NoBackgroundDistortion();
|
|
#endif
|
|
PixelShader = compile PIXELSHADER PS_ptxgpuRenderSoft_Animate_NoABBlend_BackgroundDistortion() CGC_FLAGS(CGC_DEFAULTFLAGS);
|
|
}
|
|
pass p_NoAnim_Blend_BackgroundDistortion
|
|
{
|
|
CullMode = None;
|
|
#if __SHADERMODEL >= 40
|
|
VertexShader = compile VERTEXSHADER VS_ptxgpuRenderDrop_NoAnimate_ABBlend_NoBackgroundDistortion_LookUp();
|
|
#else
|
|
VertexShader = compile VERTEXSHADER VS_ptxgpuRenderDrop_NoAnimate_ABBlend_NoBackgroundDistortion();
|
|
#endif
|
|
PixelShader = compile PIXELSHADER PS_ptxgpuRenderSoft_NoAnimate_ABBlend_BackgroundDistortion() CGC_FLAGS(CGC_DEFAULTFLAGS);
|
|
}
|
|
pass p_Anim_Blend_BackgroundDistortion
|
|
{
|
|
CullMode = None;
|
|
#if __SHADERMODEL >= 40
|
|
VertexShader = compile VERTEXSHADER VS_ptxgpuRenderDrop_Animate_ABBlend_NoBackgroundDistortion_LookUp();
|
|
#else
|
|
VertexShader = compile VERTEXSHADER VS_ptxgpuRenderDrop_Animate_ABBlend_NoBackgroundDistortion();
|
|
#endif
|
|
PixelShader = compile PIXELSHADER PS_ptxgpuRenderSoft_Animate_ABBlend_BackgroundDistortion() CGC_FLAGS(CGC_DEFAULTFLAGS);
|
|
}
|
|
}
|