public override void SetEntityVars(DeviceContext context, ref RenderableInst rend)
{
VSEntityVars.Vars.CamRel = new Vector4(rend.CamRel, 0.0f);
VSEntityVars.Vars.Orientation = rend.Orientation;
VSEntityVars.Vars.Scale = rend.Scale;
VSEntityVars.Update(context);
VSEntityVars.SetVSCBuffer(context, 2);
}
public override void SetEntityVars(DeviceContext context, ref RenderableInst rend)
{
VSEntityVars.Vars.CamRel = new Vector4(rend.CamRel, 0.0f);
VSEntityVars.Vars.Orientation = rend.Orientation;
VSEntityVars.Vars.Scale = rend.Scale;
VSEntityVars.Vars.HasSkeleton = rend.Renderable.HasSkeleton ? 1u : 0;
VSEntityVars.Vars.HasTransforms = rend.Renderable.HasTransforms ? 1u : 0;
VSEntityVars.Vars.TintPaletteIndex = rend.TintPaletteIndex;
VSEntityVars.Vars.IsInstanced = 0;
VSEntityVars.Update(context);
VSEntityVars.SetVSCBuffer(context, 2);
}
public void RenderLights(DeviceContext context, Camera camera, Shadowmap globalShadows, ShaderGlobalLights globalLights)
{
//first full-screen directional light pass, for sun/moon
//discard pixels where scene depth is 0, since nothing was rendered there
//blend mode: overwrite
var ps = (MSAASampleCount > 1) ? DirLightMSPS : DirLightPS;
context.VertexShader.Set(DirLightVS);
context.PixelShader.Set(ps);
LightVSVars.Vars.ViewProj = Matrix.Identity;
LightVSVars.Vars.CameraPos = Vector4.Zero;
LightVSVars.Vars.LightType = 0;
LightVSVars.Vars.IsLOD = 0;
LightVSVars.Vars.Pad0 = 0;
LightVSVars.Vars.Pad1 = 0;
LightVSVars.Update(context);
LightVSVars.SetVSCBuffer(context, 0);
LightPSVars.Vars.GlobalLights = globalLights.Params;
LightPSVars.Vars.ViewProjInv = Matrix.Transpose(camera.ViewProjInvMatrix);
LightPSVars.Vars.CameraPos = Vector4.Zero;
LightPSVars.Vars.EnableShadows = (globalShadows != null) ? 1u : 0u;
LightPSVars.Vars.RenderMode = 0;
LightPSVars.Vars.RenderModeIndex = 1;
LightPSVars.Vars.RenderSamplerCoord = 0;
LightPSVars.Vars.LightType = 0;
LightPSVars.Vars.IsLOD = 0;
LightPSVars.Vars.SampleCount = (uint)MSAASampleCount;
LightPSVars.Vars.SampleMult = 1.0f / MSAASampleCount;
LightPSVars.Update(context);
LightPSVars.SetPSCBuffer(context, 0);
context.PixelShader.SetShaderResources(0, GBuffers.DepthSRV);
context.PixelShader.SetShaderResources(2, GBuffers.SRVs);
if (globalShadows != null)
{
globalShadows.SetFinalRenderResources(context);
}
context.InputAssembler.InputLayout = LightQuadLayout;
LightQuad.Draw(context);
context.VertexShader.Set(null);
context.PixelShader.Set(null);
context.PixelShader.SetShaderResources(0, null, null, null);
context.PixelShader.SetSamplers(0, null, null);
}
private void FinalPass(DeviceContext context)
{
context.Rasterizer.SetViewport(Viewport);
context.VertexShader.Set(FinalPassVS);
context.PixelShader.Set(FinalPassPS);
var srv = SceneColourSRV;
context.PixelShader.SetShaderResources(0, srv, LumBlendResult.SRV, EnableBloom ? Bloom.SRV : null);
if (CS_FULL_PIXEL_REDUCTION)
{
FinalPSVars.Vars.invPixelCount = new Vector4(1.0f / (Width * Height));
}
else
{
FinalPSVars.Vars.invPixelCount = new Vector4(1.0f / (81 * 81));
}
FinalPSVars.Update(context);
FinalPSVars.SetPSCBuffer(context, 0);
context.PixelShader.SetSamplers(0, SampleStatePoint, SampleStateLinear);
context.InputAssembler.InputLayout = FinalPassLayout;
FinalPassQuad.Draw(context);
context.VertexShader.Set(null);
context.PixelShader.Set(null);
context.PixelShader.SetShaderResources(0, null, null, null);
context.PixelShader.SetSamplers(0, null, null);
}
public void SetSceneVars(DeviceContext context, Matrix shadowviewproj)
{
VSSceneVars.Vars.ViewProj = Matrix.Transpose(shadowviewproj);
VSSceneVars.Vars.WindVector = WindVector;
VSSceneVars.Update(context);
VSSceneVars.SetVSCBuffer(context, 0);
}
public void SetSphereVars(DeviceContext context, Vector3 center, float radius)
{
VSSphereVars.Vars.Center = center;
VSSphereVars.Vars.Radius = radius;
VSSphereVars.Update(context);
VSSphereVars.SetVSCBuffer(context, 1);
}
public void SSAAPass(DeviceContext context)
{
//do antialiasing from SceneColour
context.VertexShader.Set(FinalVS);
context.PixelShader.Set(SSAAPS);
context.PixelShader.SetShaderResources(0, SceneColour.SRV);
context.PixelShader.SetSamplers(0, SampleStatePoint);
SSAAPSVars.Vars.SampleCount = (uint)SSAASampleCount;
SSAAPSVars.Vars.SampleMult = 1.0f / (SSAASampleCount * SSAASampleCount);
SSAAPSVars.Vars.TexelSizeX = 1.0f / Width;
SSAAPSVars.Vars.TexelSizeY = 1.0f / Height;
SSAAPSVars.Update(context);
SSAAPSVars.SetPSCBuffer(context, 0);
context.InputAssembler.InputLayout = LightQuadLayout;
LightQuad.Draw(context);
context.VertexShader.Set(null);
context.PixelShader.Set(null);
context.PixelShader.SetShaderResources(0, null, null, null);
context.PixelShader.SetSamplers(0, null, null);
}
public override void SetModelVars(DeviceContext context, RenderableModel model)
{
if ((model.Owner.Skeleton?.BoneTransforms != null) && (model.Owner.Skeleton.BoneTransforms.Length > 0))
{
SetBoneMatrices(context, model.Owner.Skeleton.BoneTransforms);
defaultBoneMatricesBound = false;
}
else if (!defaultBoneMatricesBound)
{
SetBoneMatrices(context, defaultBoneMatrices);
defaultBoneMatricesBound = true;
}
if (model.Owner.Cloth?.Vertices != null)
{
SetClothVertices(context, model.Owner.Cloth.Vertices);
}
if (!model.UseTransform)
{
return;
}
VSModelVars.Vars.Transform = Matrix.Transpose(model.Transform);
VSModelVars.Update(context);
VSModelVars.SetVSCBuffer(context, 3);
}
public override void SetSceneVars(DeviceContext context, Camera camera, Shadowmap shadowmap, ShaderGlobalLights lights)
{
VSSceneVars.Vars.ViewProj = Matrix.Transpose(camera.ViewProjMatrix);
VSSceneVars.Vars.ViewInv = Matrix.Transpose(camera.ViewInvMatrix);
VSSceneVars.Vars.CamPos = camera.Position;
VSSceneVars.Update(context);
VSSceneVars.SetVSCBuffer(context, 0);
}
public override void SetSceneVars(DeviceContext context, Camera camera, Shadowmap shadowmap, ShaderGlobalLights lights)
{
VSSceneVars.Vars.ViewProj = Matrix.Transpose(camera.ViewProjMatrix);
VSSceneVars.Vars.CameraPos = new Vector4(camera.Position, 0.0f);
VSSceneVars.Vars.LightColour = new Vector4(1.0f, 1.0f, 1.0f, lights.HdrIntensity * 2.0f);
VSSceneVars.Update(context);
VSSceneVars.SetVSCBuffer(context, 0);
}
public override void SetSceneVars(DeviceContext context, Camera camera, Shadowmap shadowmap, ShaderGlobalLights lights)
{
VSSceneVars.Vars.ViewProj = Matrix.Transpose(camera.ViewProjMatrix);
VSSceneVars.Vars.ViewInv = Matrix.Transpose(camera.ViewInvMatrix);
VSSceneVars.Vars.ScreenScale = new Vector4(0.5f / camera.Width, 0.5f / camera.Height, camera.Width, camera.Height);
VSSceneVars.Update(context);
VSSceneVars.SetVSCBuffer(context, 0);
}
public void SetMarkerVars(DeviceContext context, Vector3 camrel, Vector2 size, Vector2 offset)
{
VSMarkerVars.Vars.CamRel = new Vector4(camrel, 0.0f);
VSMarkerVars.Vars.Size = size;
VSMarkerVars.Vars.Offset = offset;
VSMarkerVars.Update(context);
VSMarkerVars.SetVSCBuffer(context, 1);
}
public override void SetSceneVars(DeviceContext context, Camera camera, Shadowmap shadowmap, ShaderGlobalLights lights)
{
uint rendermode = 0;
uint rendermodeind = 1;
SpecularEnable = lights.SpecularEnabled;
switch (RenderMode)
{
case WorldRenderMode.VertexNormals:
rendermode = 1;
break;
case WorldRenderMode.VertexTangents:
rendermode = 2;
break;
case WorldRenderMode.VertexColour:
rendermode = 3;
rendermodeind = (uint)RenderVertexColourIndex;
break;
case WorldRenderMode.TextureCoord:
rendermode = 4;
rendermodeind = (uint)RenderTextureCoordIndex;
break;
case WorldRenderMode.SingleTexture:
rendermode = 8; //direct mode
break;
}
VSSceneVars.Vars.ViewProj = Matrix.Transpose(camera.ViewProjMatrix);
VSSceneVars.Vars.WindVector = WindVector;
VSSceneVars.Update(context);
VSSceneVars.SetVSCBuffer(context, 0);
PSSceneVars.Vars.GlobalLights = lights.Params;
PSSceneVars.Vars.EnableShadows = (shadowmap != null) ? 1u : 0u;
PSSceneVars.Vars.RenderMode = rendermode;
PSSceneVars.Vars.RenderModeIndex = rendermodeind;
PSSceneVars.Vars.RenderSamplerCoord = (uint)RenderTextureSamplerCoord;
PSSceneVars.Update(context);
PSSceneVars.SetPSCBuffer(context, 0);
if (shadowmap != null)
{
shadowmap.SetFinalRenderResources(context);
}
if (!InstGlobalVars.Flag) //on the first frame, update the instance globals
{
InstGlobalVars.Update(context);
InstGlobalVars.Flag = true;
}
}
public void SetBoxVars(DeviceContext context, Vector3 camrel, Vector3 bbmin, Vector3 bbmax, Quaternion orientation, Vector3 scale)
{
VSBoxVars.Vars.Orientation = orientation;
VSBoxVars.Vars.BBMin = new Vector4(bbmin, 0.0f);
VSBoxVars.Vars.BBRng = new Vector4(bbmax - bbmin, 0.0f);
VSBoxVars.Vars.CamRel = camrel;
VSBoxVars.Vars.Scale = scale;
VSBoxVars.Update(context);
VSBoxVars.SetVSCBuffer(context, 1);
}
public override void SetSceneVars(DeviceContext context, Camera camera, Shadowmap shadowmap, ShaderGlobalLights lights)
{
VSSceneVars.Vars.ViewProj = Matrix.Transpose(camera.ViewProjMatrix);
VSSceneVars.Update(context);
VSSceneVars.SetVSCBuffer(context, 0);
PSSceneVars.Vars.GlobalLights = lights.Params;
PSSceneVars.Update(context);
PSSceneVars.SetPSCBuffer(context, 0);
}
public override void SetModelVars(DeviceContext context, RenderableModel model)
{
if (!model.UseTransform)
{
return;
}
VSModelVars.Vars.Transform = Matrix.Transpose(model.Transform);
VSModelVars.Update(context);
VSModelVars.SetVSCBuffer(context, 3);
}
public void RenderSun(DeviceContext context, Camera camera, Weather weather, ShaderGlobalLights lights)
{
context.VertexShader.Set(sunvs);
context.PixelShader.Set(sunps);
VSSunMoonVars.Vars.ViewProj = Matrix.Transpose(camera.ViewProjMatrix);
VSSunMoonVars.Vars.ViewInv = Matrix.Transpose(camera.ViewInvMatrix);
VSSunMoonVars.Vars.CamRel = new Vector4(lights.CurrentSunDir, 0);
VSSunMoonVars.Vars.Size = new Vector2(weather.CurrentValues.skySunDiscSize * 0.008f);
VSSunMoonVars.Vars.Offset = Vector2.Zero;
VSSunMoonVars.Update(context);
VSSunMoonVars.SetVSCBuffer(context, 0);
PSSunMoonVars.Vars.Colour = new Vector4(weather.CurrentValues.skySunDiscCol * weather.CurrentValues.skySunHdr, 1);
PSSunMoonVars.Update(context);
PSSunMoonVars.SetPSCBuffer(context, 0);
context.InputAssembler.InputLayout = sunlayout;
sundisc.Draw(context);
}
public override void SetSceneVars(DeviceContext context, Camera camera, Shadowmap shadowmap, ShaderGlobalLights lights)
{
CloudsLocalVars.Update(context);
CloudsLocalVars.SetVSCBuffer(context, 0);
CloudsLocalVars.SetPSCBuffer(context, 0);
VSSceneVars.Vars.ViewProj = Matrix.Transpose(camera.ViewProjMatrix);
VSSceneVars.Vars.ViewInv = Matrix.Transpose(camera.ViewInvMatrix);
VSSceneVars.Update(context);
VSSceneVars.SetVSCBuffer(context, 1);
PSSceneVars.Vars.LightDirection = new Vector4(lights.Params.LightDir, 0.0f);
PSSceneVars.Vars.EnableHDR = EnableHDR ? 1u : 0u;
PSSceneVars.Update(context);
PSSceneVars.SetPSCBuffer(context, 1);
}
public void SetFinalRenderResources(DeviceContext context)
{
ShadowVars.Vars.CamScenePos = new Vector4(SceneCamPos, 0.0f); //in shadow scene coords
ShadowVars.Vars.CamSceneView = Matrix.Transpose(SceneCamView);
ShadowVars.Vars.LightView = Matrix.Transpose(LightView);
ShadowVars.Vars.LightDir = new Vector4(LightDirection, 0.0f);
Matrix dxmatTextureScale = Matrix.Scaling(0.5f, -0.5f, 1.0f);
Matrix dxmatTextureTranslation = Matrix.Translation(0.5f, 0.5f, 0.0f);
Matrix dxmatTextureST = Matrix.Multiply(dxmatTextureScale, dxmatTextureTranslation);
for (int i = 0; i < CascadeCount; ++i)
{
ShadowmapCascade cascade = Cascades[i];
Matrix mShadowTexture = Matrix.Multiply(cascade.Ortho, dxmatTextureST);
ShadowVars.Vars.CascadeScales.Set(i, new Vector4(mShadowTexture.M11, mShadowTexture.M22, mShadowTexture.M33, 1.0f));
ShadowVars.Vars.CascadeOffsets.Set(i, new Vector4(mShadowTexture.M41, mShadowTexture.M42, mShadowTexture.M43, 0.0f));
ShadowVars.Vars.CascadeDepths.Set(i, new Vector4(cascade.IntervalFar, 0.0f, 0.0f, 0.0f));
}
ShadowVars.Vars.CascadeCount = CascadeCount;
ShadowVars.Vars.CascadeVisual = 0;
ShadowVars.Vars.PCFLoopStart = (PCFSize) / -2;
ShadowVars.Vars.PCFLoopEnd = (PCFSize) / 2 + 1;
// The border padding values keep the pixel shader from reading the borders during PCF filtering.
float txs = (float)TextureSize;
ShadowVars.Vars.BorderPaddingMax = (txs - 1.0f) / txs;
ShadowVars.Vars.BorderPaddingMin = 1.0f / txs;
ShadowVars.Vars.Bias = PCFOffset;
ShadowVars.Vars.BlurBetweenCascades = BlurBetweenCascades;
ShadowVars.Vars.CascadeCountInv = 1.0f / (float)CascadeCount;
ShadowVars.Vars.TexelSize = 1.0f / txs;
ShadowVars.Vars.TexelSizeX = ShadowVars.Vars.TexelSize / (float)CascadeCount;
ShadowVars.Vars.ShadowMaxDistance = maxShadowDistance;
ShadowVars.Update(context);
SetBuffers(context);
}
public void SetInstanceVars(DeviceContext context, RenderableInstanceBatch batch)
{
var gb = batch.Key;
// sanity check
if (batch.GrassInstanceBuffer == null)
{
return;
}
VSEntityVars.Vars.CamRel = new Vector4(batch.CamRel, 0.0f);
VSEntityVars.Vars.Orientation = Quaternion.Identity;
VSEntityVars.Vars.Scale = Vector3.One;
VSEntityVars.Vars.HasSkeleton = 0;
VSEntityVars.Vars.HasTransforms = 0;
VSEntityVars.Vars.TintPaletteIndex = 0;
VSEntityVars.Vars.IsInstanced = 1;
VSEntityVars.Update(context);
VSEntityVars.SetVSCBuffer(context, 2);
InstGlobalVars.SetVSCBuffer(context, 5);
InstLocalVars.Vars.vecBatchAabbMin = batch.AABBMin;
InstLocalVars.Vars.vecBatchAabbDelta = batch.AABBMax - batch.AABBMin;
InstLocalVars.Vars.vecPlayerPos = new Vector4(batch.Position - batch.CamRel, 1.0f);
InstLocalVars.Vars._vecCollParams = new Vector2(2.0f, -3.0f);//range, offset
InstLocalVars.Vars.fadeAlphaDistUmTimer = new Vector4(0.0f);
InstLocalVars.Vars.uMovementParams = new Vector4(0.0f);
InstLocalVars.Vars._fakedGrassNormal = new Vector4(Vector3.Normalize(-batch.CamRel), 0.0f);
InstLocalVars.Vars.gScaleRange = gb.Batch.ScaleRange;
InstLocalVars.Vars.gWindBendingGlobals = new Vector4(WindVector.X, WindVector.Y, 1.0f, 1.0f);
InstLocalVars.Vars.gWindBendScaleVar = new Vector2(WindVector.Z, WindVector.W);
InstLocalVars.Vars.gAlphaTest = 0.0f;
InstLocalVars.Vars.gAlphaToCoverageScale = 1.0f;
InstLocalVars.Vars.gLodFadeInstRange = new Vector3(gb.Batch.LodInstFadeRange, gb.Batch.LodFadeStartDist, gb.Batch.lodDist);
InstLocalVars.Vars.gUseComputeShaderOutputBuffer = 0;
InstLocalVars.Update(context);
InstLocalVars.SetVSCBuffer(context, 6);
context.VertexShader.SetShaderResource(2, batch.GrassInstanceBuffer.SRV);
}
private void ProcessBloom(DeviceContext context)
{
if (EnableBloom)
{
// Bright pass and horizontal blur
ShaderResourceView view = Primary.SRV;
ShaderResourceView[] aRViews = { view, LumBlendResult.SRV };
//BloomFilterShaderVars cbFilter;
//GetSampleWeights(cbFilter.avSampleWeights, 3.0f, 1.25f);
FilterBPHCSVars.Vars.outputwidth = (uint)(Width / 8);
if (CS_FULL_PIXEL_REDUCTION)
{
FilterBPHCSVars.Vars.finverse = 1.0f / (Width * Height);
}
else
{
FilterBPHCSVars.Vars.finverse = 1.0f / (81 * 81); //(ToneMappingTexSize*ToneMappingTexSize);
}
FilterBPHCSVars.Vars.inputsize0 = (int)Width;
FilterBPHCSVars.Vars.inputsize1 = (int)Height;
FilterBPHCSVars.Update(context);
int x = (int)(Math.Ceiling((float)FilterBPHCSVars.Vars.outputwidth / (128 - 7 * 2)));
int y = (Height / 8);
Compute(context, BloomFilterBPHCS, FilterBPHCSVars.Buffer, Bloom1.UAV, x, y, 1, view, LumBlendResult.SRV);
// Vertical blur
FilterVCSVars.Vars.outputsize0 = (int)(Width / 8);
FilterVCSVars.Vars.outputsize1 = (int)(Height / 8);
FilterVCSVars.Vars.inputsize0 = (int)(Width / 8);
FilterVCSVars.Vars.inputsize1 = (int)(Height / 8);
FilterVCSVars.Update(context);
x = Width / 8;
y = (int)(Math.Ceiling((float)FilterVCSVars.Vars.outputsize1 / (128 - 7 * 2)));
Compute(context, BloomFilterVCS, FilterVCSVars.Buffer, Bloom0.UAV, x, y, 1, Bloom1.SRV, LumBlendResult.SRV);
}
CopyPixels(context, Width / 8, Height / 8, Bloom0.SRV, Bloom.RTV);
}
public override void SetModelVars(DeviceContext context, RenderableModel model)
{
if (model.Owner.BoneTransforms != null)
{
SetBoneMatrices(context, model.Owner.BoneTransforms);
defaultBoneMatricesBound = false;
}
else if (!defaultBoneMatricesBound)
{
SetBoneMatrices(context, defaultBoneMatrices);
defaultBoneMatricesBound = true;
}
if (!model.UseTransform)
{
return;
}
VSModelVars.Vars.Transform = Matrix.Transpose(model.Transform);
VSModelVars.Update(context);
VSModelVars.SetVSCBuffer(context, 2);
}
public override void SetSceneVars(DeviceContext context, Camera camera, Shadowmap shadowmap, ShaderGlobalLights lights)
{
switch (mode)
{
default:
case BoundsShaderMode.Sphere:
VSSphereSceneVars.Vars.ViewProj = Matrix.Transpose(camera.ViewProjMatrix);
VSSphereSceneVars.Vars.ViewInv = Matrix.Transpose(camera.ViewInvMatrix);
VSSphereSceneVars.Vars.SegmentCount = (float)SegmentCount;
VSSphereSceneVars.Vars.VertexCount = (float)VertexCount;
VSSphereSceneVars.Update(context);
VSSphereSceneVars.SetVSCBuffer(context, 0);
break;
case BoundsShaderMode.Box:
VSBoxSceneVars.Vars.ViewProj = Matrix.Transpose(camera.ViewProjMatrix);
VSBoxSceneVars.Update(context);
VSBoxSceneVars.SetVSCBuffer(context, 0);
break;
}
}
public override void SetGeomVars(DeviceContext context, RenderableGeometry geom)
{
RenderableTexture texture = null;
RenderableTexture texture2 = null;
RenderableTexture tintpal = null;
RenderableTexture bumptex = null;
RenderableTexture spectex = null;
RenderableTexture detltex = null;
bool isdistmap = false;
float tntpalind = 0.0f;
if ((geom.RenderableTextures != null) && (geom.RenderableTextures.Length > 0))
{
if (RenderMode == WorldRenderMode.Default)
{
for (int i = 0; i < geom.RenderableTextures.Length; i++)
{
var itex = geom.RenderableTextures[i];
if (geom.HDTextureEnable)
{
var hdtex = geom.RenderableTexturesHD[i];
if ((hdtex != null) && (hdtex.IsLoaded))
{
itex = hdtex;
}
}
var ihash = geom.TextureParamHashes[i];
if (itex == null)
{
continue;
}
if (itex.Key?.NameHash == 1678728908 /*"blank"*/)
{
continue;
}
switch (ihash)
{
case MetaName.DiffuseSampler:
case MetaName.PlateBgSampler:
texture = itex;
break;
case MetaName.BumpSampler:
case MetaName.PlateBgBumpSampler:
bumptex = itex;
break;
case MetaName.SpecSampler:
spectex = itex;
break;
case MetaName.DetailSampler:
detltex = itex;
break;
case MetaName.TintPaletteSampler:
tintpal = itex;
if (tintpal.Key != null)
{
//this is slightly dodgy but VSEntityVars should have the correct value in it...
tntpalind = (VSEntityVars.Vars.TintPaletteIndex + 0.5f) / tintpal.Key.Height;
}
break;
case MetaName.distanceMapSampler:
texture = itex;
isdistmap = true;
break;
case MetaName.DiffuseSampler2:
texture2 = itex;
break;
case MetaName.heightSampler:
case MetaName.EnvironmentSampler:
//case MetaName.SnowSampler0:
//case MetaName.SnowSampler1:
//case MetaName.DiffuseSampler3:
//case MetaName.DirtSampler:
//case MetaName.DirtBumpSampler:
break;
case MetaName.FlowSampler:
case MetaName.FogSampler:
case MetaName.FoamSampler:
if (texture == null)
{
texture = itex;
}
break;
default:
if (texture == null)
{
texture = itex;
}
break;
}
}
}
else if (RenderMode == WorldRenderMode.SingleTexture)
{
for (int i = 0; i < geom.RenderableTextures.Length; i++)
{
var itex = geom.RenderableTextures[i];
var ihash = geom.TextureParamHashes[i];
if (ihash == RenderTextureSampler)
{
texture = itex;
break;
}
}
}
}
bool usediff = ((texture != null) && (texture.ShaderResourceView != null));
bool usediff2 = ((texture2 != null) && (texture2.ShaderResourceView != null));
bool usebump = ((bumptex != null) && (bumptex.ShaderResourceView != null));
bool usespec = ((spectex != null) && (spectex.ShaderResourceView != null));
bool usedetl = ((detltex != null) && (detltex.ShaderResourceView != null));
bool usetint = ((tintpal != null) && (tintpal.ShaderResourceView != null));
uint tintflag = 0;
if (usetint)
{
tintflag = 1;
}
Vector4 textureAlphaMask = Vector4.Zero;
uint decalflag = DecalMode ? 1u : 0u;
uint windflag = geom.EnableWind ? 1u : 0u;
uint emflag = geom.IsEmissive ? 1u : 0u;
uint pstintflag = tintflag;
var shaderName = geom.DrawableGeom.Shader.Name;
var shaderFile = geom.DrawableGeom.Shader.FileName;
switch (shaderFile.Hash)
{
case 2245870123: //trees_normal_diffspec_tnt.sps
case 3334613197: //trees_tnt.sps
case 1229591973: //{trees_normal_spec_tnt.sps}
if (usetint)
{
tintflag = 2; //use 2nd vertex colour channel for tint...
}
break;
case 3880384844: //{decal_spec_only.sps}w
case 600733812: //{decal_amb_only.sps}
case 2842248626: //{spec_decal.sps}
case 2457676400: //{reflect_decal.sps}
case 2706821972: //{mirror_decal.sps}
//if (RenderMode == WorldRenderMode.Default) usediff = false;
break;
case 2655725442: //{decal_dirt.sps}
textureAlphaMask = geom.DirtDecalMask;
decalflag = 2;
break;
}
if (VSEntityVars.Vars.IsInstanced > 0)
{
pstintflag = 1;
switch (shaderFile.Hash)
{
case 916743331: //{grass_batch.sps}
windflag = 1;
break;
case 3833671083: //{normal_spec_batch.sps}
windflag = 0;
break;
default:
break;
}
}
PSGeomVars.Vars.EnableTexture = (usediff ? 1u : 0u) + (usediff2 ? 2u : 0u);
PSGeomVars.Vars.EnableTint = pstintflag;
PSGeomVars.Vars.EnableNormalMap = usebump ? 1u : 0u;
PSGeomVars.Vars.EnableSpecMap = usespec ? 1u : 0u;
PSGeomVars.Vars.EnableDetailMap = usedetl ? 1u : 0u;
PSGeomVars.Vars.IsDecal = decalflag;
PSGeomVars.Vars.IsEmissive = emflag;
PSGeomVars.Vars.IsDistMap = isdistmap ? 1u : 0u;
PSGeomVars.Vars.bumpiness = geom.bumpiness;
PSGeomVars.Vars.AlphaScale = isdistmap ? 1.0f : AlphaScale;
PSGeomVars.Vars.HardAlphaBlend = 0.0f; //todo: cutouts flag!
PSGeomVars.Vars.useTessellation = 0.0f;
PSGeomVars.Vars.detailSettings = geom.detailSettings;
PSGeomVars.Vars.specMapIntMask = geom.specMapIntMask;
PSGeomVars.Vars.specularIntensityMult = SpecularEnable ? geom.specularIntensityMult : 0.0f;
PSGeomVars.Vars.specularFalloffMult = geom.specularFalloffMult;
PSGeomVars.Vars.specularFresnel = geom.specularFresnel;
PSGeomVars.Vars.wetnessMultiplier = geom.wetnessMultiplier;
PSGeomVars.Vars.SpecOnly = geom.SpecOnly ? 1u : 0u;
PSGeomVars.Vars.TextureAlphaMask = textureAlphaMask;
PSGeomVars.Update(context);
PSGeomVars.SetPSCBuffer(context, 2);
VSGeomVars.Vars.EnableTint = tintflag;
VSGeomVars.Vars.TintYVal = tntpalind;
VSGeomVars.Vars.IsDecal = DecalMode ? 1u : 0u;
VSGeomVars.Vars.EnableWind = windflag;
VSGeomVars.Vars.WindOverrideParams = geom.WindOverrideParams;
VSGeomVars.Update(context);
VSGeomVars.SetVSCBuffer(context, 4);
context.VertexShader.SetSampler(0, geom.IsFragment ? texsamplertntyft : texsamplertnt);
context.PixelShader.SetSampler(0, AnisotropicFilter ? texsampleranis : texsampler);
if (usediff)
{
texture.SetPSResource(context, 0);
}
if (usebump)
{
bumptex.SetPSResource(context, 2);
}
if (usespec)
{
spectex.SetPSResource(context, 3);
}
if (usedetl)
{
detltex.SetPSResource(context, 4);
}
if (usediff2)
{
texture2.SetPSResource(context, 5);
}
if (usetint)
{
tintpal.SetVSResource(context, 0);
}
}
public override void SetGeomVars(DeviceContext context, RenderableGeometry geom)
{
RenderableTexture texture = null; // ((geom.Textures != null) && (geom.Textures.Length > 0)) ? geom.Textures[0] : null;
//trees_lod2
//PNCCTTTT: texcoord2 seems to be 0-1 for the billboard, vertex pos is billboard root.
//param for billboard dir... (treeLod2Normal)
//trees_lod
//PNCCT:
if (geom.VertexType != VertexType.PNCCTTTT)
{
}
var shader = geom.DrawableGeom.Shader;
if (shader.Name.Hash == 1874959840)
{
int nparams = 0;
MetaName[] hashes = null;
ShaderParameter[] sparams = null;
if (shader.ParametersList != null)
{
nparams = shader.ParametersList.Hashes.Length;
hashes = shader.ParametersList.Hashes;
sparams = shader.ParametersList.Parameters;
}
for (int i = 0; i < nparams; i++)
{
var h = (ShaderParamNames)shader.ParametersList.Hashes[i];
switch (h)
{
case ShaderParamNames.AlphaTest: VSGeomVars.Vars.AlphaTest = (Vector4)sparams[i].Data; break;
case ShaderParamNames.AlphaScale: VSGeomVars.Vars.AlphaScale = (Vector4)sparams[i].Data; break;
case ShaderParamNames.UseTreeNormals: VSGeomVars.Vars.UseTreeNormals = (Vector4)sparams[i].Data; break;
case ShaderParamNames.treeLod2Normal: VSGeomVars.Vars.treeLod2Normal = (Vector4)sparams[i].Data; break;
case ShaderParamNames.treeLod2Params: VSGeomVars.Vars.treeLod2Params = (Vector4)sparams[i].Data; break;
}
}
}
else
{
VSGeomVars.Vars.AlphaTest = Vector4.Zero;
VSGeomVars.Vars.AlphaScale = Vector4.Zero;
VSGeomVars.Vars.UseTreeNormals = Vector4.Zero;
VSGeomVars.Vars.treeLod2Normal = Vector4.Zero;
VSGeomVars.Vars.treeLod2Params = Vector4.Zero;
}
VSGeomVars.Update(context);
VSGeomVars.SetVSCBuffer(context, 3);
if ((geom.RenderableTextures != null) && (geom.RenderableTextures.Length > 0))
{
for (int i = 0; i < geom.RenderableTextures.Length; i++)
{
var itex = geom.RenderableTextures[i];
var ihash = geom.TextureParamHashes[i];
switch (ihash)
{
case ShaderParamNames.DiffuseSampler:
texture = itex;
break;
}
if (texture != null)
{
break;
}
}
////try get default diffuse texture
//if ((geom.DiffuseSampler >= 0) && (geom.DiffuseSampler < geom.Textures.Length))
//{
// texture = geom.Textures[geom.DiffuseSampler];
//}
//if ((texture == null) && (geom.TextureSampler_layer0 >= 0) && (geom.TextureSampler_layer0 < geom.Textures.Length))
//{
// texture = geom.Textures[geom.TextureSampler_layer0];
//}
//if ((texture == null) && (geom.TextureSampler_layer1 >= 0) && (geom.TextureSampler_layer1 < geom.Textures.Length))
//{
// texture = geom.Textures[geom.TextureSampler_layer1];
//}
//if ((texture == null) && (geom.TextureSampler_layer2 >= 0) && (geom.TextureSampler_layer2 < geom.Textures.Length))
//{
// texture = geom.Textures[geom.TextureSampler_layer2];
//}
//if ((texture == null) && (geom.TextureSampler_layer3 >= 0) && (geom.TextureSampler_layer3 < geom.Textures.Length))
//{
// texture = geom.Textures[geom.TextureSampler_layer3];
//}
//fallback try get first texture...
int index = 0;
while (((texture == null) || (texture.Texture2D == null)) && (index < geom.RenderableTextures.Length))
{
texture = geom.RenderableTextures[index];
index++;
}
}
bool usediff = ((texture != null) && (texture.Texture2D != null) && (texture.ShaderResourceView != null));
PSEntityVars.Vars.EnableTexture = usediff ? 1u : 0u;
PSEntityVars.Update(context);
PSEntityVars.SetPSCBuffer(context, 1);
if (usediff)
{
context.PixelShader.SetSampler(0, texsampler);
//context.PixelShader.SetShaderResource(0, difftex.ShaderResourceView);
texture.SetPSResource(context, 0);
}
}
public override void SetSceneVars(DeviceContext context, Camera camera, Shadowmap shadowmap, ShaderGlobalLights lights)
{
uint rendermode = 0;
uint rendermodeind = 1;
switch (RenderMode)
{
case WorldRenderMode.VertexNormals:
rendermode = 1;
break;
case WorldRenderMode.VertexTangents:
rendermode = 2;
break;
case WorldRenderMode.VertexColour:
rendermode = 3;
rendermodeind = (uint)RenderVertexColourIndex;
break;
case WorldRenderMode.TextureCoord:
rendermode = 4;
rendermodeind = (uint)RenderTextureCoordIndex;
break;
case WorldRenderMode.SingleTexture:
switch (RenderTextureSampler)
{
case MetaName.DiffuseSampler:
rendermode = 5;
break;
case MetaName.BumpSampler:
rendermode = 6;
break;
case MetaName.SpecSampler:
rendermode = 7;
break;
default:
rendermode = 8;
break;
}
break;
}
VSSceneVars.Vars.ViewProj = Matrix.Transpose(camera.ViewProjMatrix);
VSSceneVars.Update(context);
VSSceneVars.SetVSCBuffer(context, 0);
PSSceneVars.Vars.GlobalLights = lights.Params;
PSSceneVars.Vars.EnableShadows = (shadowmap != null) ? 1u : 0u;
PSSceneVars.Vars.RenderMode = rendermode;
PSSceneVars.Vars.RenderModeIndex = rendermodeind;
PSSceneVars.Vars.RenderSamplerCoord = (uint)RenderTextureSamplerCoord;
PSSceneVars.Update(context);
PSSceneVars.SetPSCBuffer(context, 0);
if (shadowmap != null)
{
shadowmap.SetFinalRenderResources(context);
}
}
public void SetColourVars(DeviceContext context, Vector4 colour)
{
PSColourVars.Vars.Colour = colour;
PSColourVars.Update(context);
PSColourVars.SetPSCBuffer(context, 0);
}
public override void SetGeomVars(DeviceContext context, RenderableGeometry geom)
{
RenderableTexture texture0 = null;
RenderableTexture texture1 = null;
RenderableTexture texture2 = null;
RenderableTexture texture3 = null;
RenderableTexture texture4 = null;
RenderableTexture texturemask = null;
RenderableTexture tintpal = null;
RenderableTexture normals0 = null;
RenderableTexture normals1 = null;
RenderableTexture normals2 = null;
RenderableTexture normals3 = null;
RenderableTexture normals4 = null;
float tntpalind = 0.0f;
bool usevc = true;
if ((geom.RenderableTextures != null) && (geom.RenderableTextures.Length > 0))
{
for (int i = 0; i < geom.RenderableTextures.Length; i++)
{
var itex = geom.RenderableTextures[i];
if (geom.HDTextureEnable)
{
var hdtex = geom.RenderableTexturesHD[i];
if ((hdtex != null) && (hdtex.IsLoaded))
{
itex = hdtex;
}
}
var ihash = geom.TextureParamHashes[i];
switch (ihash)
{
case MetaName.DiffuseSampler:
texture0 = itex;
break;
case MetaName.TextureSampler_layer0:
texture1 = itex;
break;
case MetaName.TextureSampler_layer1:
texture2 = itex;
break;
case MetaName.TextureSampler_layer2:
texture3 = itex;
break;
case MetaName.TextureSampler_layer3:
texture4 = itex;
break;
case MetaName.BumpSampler:
normals0 = itex;
break;
case MetaName.BumpSampler_layer0:
normals1 = itex;
break;
case MetaName.BumpSampler_layer1:
normals2 = itex;
break;
case MetaName.BumpSampler_layer2:
normals3 = itex;
break;
case MetaName.BumpSampler_layer3:
normals4 = itex;
break;
case MetaName.lookupSampler:
texturemask = itex;
break;
case MetaName.TintPaletteSampler:
tintpal = itex;
if (tintpal.Key != null)
{
//this is slightly dodgy but vsentvarsdata should have the correct value in it...
tntpalind = (VSEntityVars.Vars.TintPaletteIndex + 0.5f) / tintpal.Key.Height;
}
break;
}
}
//if ((geom.DiffuseSampler >= 0) && (geom.DiffuseSampler < geom.Textures.Length))
//{
// texture0 = geom.Textures[geom.DiffuseSampler];
//}
//if ((geom.TextureSampler_layer0 >= 0) && (geom.TextureSampler_layer0 < geom.Textures.Length))
//{
// texture1 = geom.Textures[geom.TextureSampler_layer0];
//}
//if ((geom.TextureSampler_layer1 >= 0) && (geom.TextureSampler_layer1 < geom.Textures.Length))
//{
// texture2 = geom.Textures[geom.TextureSampler_layer1];
//}
//if ((geom.TextureSampler_layer2 >= 0) && (geom.TextureSampler_layer2 < geom.Textures.Length))
//{
// texture3 = geom.Textures[geom.TextureSampler_layer2];
//}
//if ((geom.TextureSampler_layer3 >= 0) && (geom.TextureSampler_layer3 < geom.Textures.Length))
//{
// texture4 = geom.Textures[geom.TextureSampler_layer3];
//}
//if ((geom.BumpSampler >= 0) && (geom.BumpSampler < geom.Textures.Length))
//{
// normals0 = geom.Textures[geom.BumpSampler];
//}
//if ((geom.BumpSampler_layer0 >= 0) && (geom.BumpSampler_layer0 < geom.Textures.Length))
//{
// normals1 = geom.Textures[geom.BumpSampler_layer0];
//}
//if ((geom.BumpSampler_layer1 >= 0) && (geom.BumpSampler_layer1 < geom.Textures.Length))
//{
// normals2 = geom.Textures[geom.BumpSampler_layer1];
//}
//if ((geom.BumpSampler_layer2 >= 0) && (geom.BumpSampler_layer2 < geom.Textures.Length))
//{
// normals3 = geom.Textures[geom.BumpSampler_layer2];
//}
//if ((geom.BumpSampler_layer3 >= 0) && (geom.BumpSampler_layer3 < geom.Textures.Length))
//{
// normals4 = geom.Textures[geom.BumpSampler_layer3];
//}
//if ((geom.lookupSampler >= 0) && (geom.lookupSampler < geom.Textures.Length))
//{
// texturemask = geom.Textures[geom.lookupSampler];
//}
//if ((geom.TintPaletteSampler >= 0) && (geom.TintPaletteSampler < geom.Textures.Length))
//{
// tintpal = geom.Textures[geom.TintPaletteSampler];
// if (tintpal.Texture != null)
// {
// //this is slightly dodgy but vsentvarsdata should have the correct value in it...
// tntpalind = (vsentvarsdata.TintPaletteIndex + 0.5f) / tintpal.Texture.Height;
// }
//}
}
if (RenderMode == WorldRenderMode.SingleTexture)
{
usevc = false;
switch (RenderTextureSampler)
{
case MetaName.DiffuseSampler:
case MetaName.BumpSampler:
case MetaName.SpecSampler:
break;
default:
for (int i = 0; i < geom.RenderableTextures.Length; i++)
{
var itex = geom.RenderableTextures[i];
var ihash = geom.TextureParamHashes[i];
if (ihash == RenderTextureSampler)
{
texture0 = itex;
break;
}
}
//int directtexind = geom.GetTextureSamplerIndex(RenderTextureSampler);
//if ((directtexind >= 0) && (directtexind < geom.Textures.Length))
//{
// texture0 = geom.Textures[directtexind];
//}
break;
}
}
bool usediff0 = ((texture0 != null) && (texture0.ShaderResourceView != null));
bool usediff1 = ((texture1 != null) && (texture1.ShaderResourceView != null));
bool usediff2 = ((texture2 != null) && (texture2.ShaderResourceView != null));
bool usediff3 = ((texture3 != null) && (texture3.ShaderResourceView != null));
bool usediff4 = ((texture4 != null) && (texture4.ShaderResourceView != null));
bool usemask = ((texturemask != null) && (texturemask.ShaderResourceView != null));
bool usetint = ((tintpal != null) && (tintpal.ShaderResourceView != null));
bool usenm = (((normals0 != null) && (normals0.ShaderResourceView != null)) || ((normals1 != null) && (normals1.ShaderResourceView != null)));
float bumpiness = 1.0f;
if (usenm)
{
bumpiness = geom.bumpiness;
}
PSGeomVars.Vars.EnableTexture0 = usediff0 ? 1u : 0u;
PSGeomVars.Vars.EnableTexture1 = usediff1 ? 1u : 0u;
PSGeomVars.Vars.EnableTexture2 = usediff2 ? 1u : 0u;
PSGeomVars.Vars.EnableTexture3 = usediff3 ? 1u : 0u;
PSGeomVars.Vars.EnableTexture4 = usediff4 ? 1u : 0u;
PSGeomVars.Vars.EnableTextureMask = usemask ? 1u : 0u;
PSGeomVars.Vars.EnableNormalMap = usenm ? 1u : 0u;
PSGeomVars.Vars.ShaderName = geom.DrawableGeom.Shader.Name.Hash;
PSGeomVars.Vars.EnableTint = usetint ? 1u : 0u;
PSGeomVars.Vars.EnableVertexColour = usevc ? 1u : 0u;
PSGeomVars.Vars.bumpiness = bumpiness;//
PSGeomVars.Update(context);
PSGeomVars.SetPSCBuffer(context, 2);
VSGeomVars.Vars.EnableTint = usetint ? 1u : 0u;
VSGeomVars.Vars.TintYVal = tntpalind;
VSGeomVars.Update(context);
VSGeomVars.SetVSCBuffer(context, 4);
context.VertexShader.SetSampler(0, texsamplertnt);
context.PixelShader.SetSampler(0, AnisotropicFilter ? texsampleranis : texsampler);
if (usediff0)
{
texture0.SetPSResource(context, 0);
}
if (usediff1)
{
texture1.SetPSResource(context, 2);
}
if (usediff2)
{
texture2.SetPSResource(context, 3);
}
if (usediff3)
{
texture3.SetPSResource(context, 4);
}
if (usediff4)
{
texture4.SetPSResource(context, 5);
}
if (usemask)
{
texturemask.SetPSResource(context, 6);
}
if (usetint)
{
tintpal.SetVSResource(context, 0);
}
if (normals0 != null)
{
normals0.SetPSResource(context, 7);
}
if (normals1 != null)
{
normals1.SetPSResource(context, 8);
}
if (normals2 != null)
{
normals2.SetPSResource(context, 9);
}
if (normals3 != null)
{
normals3.SetPSResource(context, 10);
}
if (normals4 != null)
{
normals4.SetPSResource(context, 11);
}
}
public void RenderLights(DeviceContext context, Camera camera, List <RenderableLightInst> lights)
{
//instanced rendering of all other lights, using appropriate shapes
//blend mode: additive
var ps = (MSAASampleCount > 1) ? LightMSPS : LightPS;
context.VertexShader.Set(LightVS);
context.PixelShader.Set(ps);
LightVSVars.Vars.ViewProj = Matrix.Transpose(camera.ViewProjMatrix);
LightVSVars.Vars.CameraPos = new Vector4(camera.Position, 0.0f);
LightVSVars.Vars.LightType = 0;
LightVSVars.Vars.IsLOD = 0;
LightVSVars.Vars.Pad0 = 0;
LightVSVars.Vars.Pad1 = 0;
LightVSVars.Update(context);
LightVSVars.SetVSCBuffer(context, 0);
LightPSVars.Vars.ViewProjInv = Matrix.Transpose(camera.ViewProjInvMatrix);
LightPSVars.Vars.CameraPos = new Vector4(camera.Position, 0.0f);
LightPSVars.Vars.EnableShadows = 0;
LightPSVars.Vars.RenderMode = 0;
LightPSVars.Vars.RenderModeIndex = 1;
LightPSVars.Vars.RenderSamplerCoord = 0;
LightPSVars.Vars.LightType = 0;
LightPSVars.Vars.IsLOD = 0;
LightPSVars.Vars.SampleCount = (uint)MSAASampleCount;
LightPSVars.Vars.SampleMult = 1.0f / MSAASampleCount;
LightPSVars.Update(context);
LightPSVars.SetPSCBuffer(context, 0);
context.PixelShader.SetShaderResources(0, GBuffers.DepthSRV);
context.PixelShader.SetShaderResources(2, GBuffers.SRVs);
for (int i = 0; i < lights.Count; i++)
{
var li = lights[i];
var rl = li.Light;
LightInstVars.Vars.InstPosition = li.EntityPosition + li.EntityRotation.Multiply(rl.Position) - camera.Position;
LightInstVars.Vars.InstDirection = li.EntityRotation.Multiply(rl.Direction);
LightInstVars.Vars.InstTangentX = li.EntityRotation.Multiply(rl.TangentX);
LightInstVars.Vars.InstTangentY = li.EntityRotation.Multiply(rl.TangentY);
LightInstVars.Vars.InstCapsuleExtent = li.EntityRotation.Multiply(rl.CapsuleExtent);
LightInstVars.Vars.InstCullingPlaneNormal = li.EntityRotation.Multiply(rl.CullingPlaneNormal);
LightInstVars.Vars.InstColour = rl.Colour;
LightInstVars.Vars.InstIntensity = rl.Intensity;
LightInstVars.Vars.InstFalloff = rl.Falloff;
LightInstVars.Vars.InstFalloffExponent = rl.FalloffExponent;
LightInstVars.Vars.InstConeInnerAngle = rl.ConeInnerAngle;
LightInstVars.Vars.InstConeOuterAngle = rl.ConeOuterAngle;
LightInstVars.Vars.InstType = (uint)rl.Type;
LightInstVars.Vars.InstCullingPlaneOffset = rl.CullingPlaneOffset;
LightInstVars.Update(context);
LightInstVars.SetVSCBuffer(context, 1);
LightInstVars.SetPSCBuffer(context, 2);
switch (rl.Type)
{
case LightType.Point:
LightSphere.Draw(context);
break;
case LightType.Spot:
LightCone.Draw(context);
break;
case LightType.Capsule:
LightCapsule.Draw(context);
break;
default:
break;
}
}
context.VertexShader.Set(null);
context.PixelShader.Set(null);
context.PixelShader.SetShaderResources(0, null, null, null);
context.PixelShader.SetSamplers(0, null, null);
}
public override void SetGeomVars(DeviceContext context, RenderableGeometry geom)
{
RenderableTexture texture = null; // ((geom.Textures != null) && (geom.Textures.Length > 0)) ? geom.Textures[0] : null;
if ((geom.RenderableTextures != null) && (geom.RenderableTextures.Length > 0))
{
if (RenderMode == WorldRenderMode.Default)
{
for (int i = 0; i < geom.RenderableTextures.Length; i++)
{
var itex = geom.RenderableTextures[i];
var ihash = geom.TextureParamHashes[i];
switch (ihash)
{
case ShaderParamNames.DiffuseSampler:
texture = itex;
break;
}
}
////fallback try get first texture... eventaully remove this! (helps with water for now)
//int index = 0;
//while (((texture == null) || (texture.Texture2D == null)) && (index < geom.Textures.Length))
//{
// texture = geom.Textures[index];
// index++;
//}
}
else if (RenderMode == WorldRenderMode.SingleTexture)
{
for (int i = 0; i < geom.RenderableTextures.Length; i++)
{
var itex = geom.RenderableTextures[i];
var ihash = geom.TextureParamHashes[i];
if (ihash == RenderTextureSampler)
{
texture = itex;
break;
}
}
}
}
bool usediff = ((texture != null) && (texture.Texture2D != null) && (texture.ShaderResourceView != null));
PSGeomVars.Vars.EnableTexture = usediff ? 1u : 0u;
PSGeomVars.Vars.EnableTint = 0u;
PSGeomVars.Update(context);
PSGeomVars.SetPSCBuffer(context, 2);
VSGeomVars.Vars.EnableTint = 0u;
VSGeomVars.Vars.TintYVal = 0u;
VSGeomVars.Vars.IsDecal = 0u;
VSGeomVars.Vars.EnableWind = 0u;
VSGeomVars.Vars.WindOverrideParams = Vector4.Zero;
VSGeomVars.Vars.globalAnimUV0 = Vector4.Zero;
VSGeomVars.Vars.globalAnimUV1 = Vector4.Zero;
VSGeomVars.Update(context);
VSGeomVars.SetVSCBuffer(context, 4);
//context.VertexShader.SetSampler(0, texsampler);
context.PixelShader.SetSampler(0, texsampler);
//context.PixelShader.SetSampler(1, texsamplerc);
if (usediff)
{
texture.SetPSResource(context, 0);
//context.PixelShader.SetShaderResource(0, difftex.ShaderResourceView);
}
}
