IEnumerator PostEffectTimer(PostEffect postEffect)
{
PostEffect.PostEffectType postEffectType = postEffect.type;
switch (postEffectType)
{
case PostEffect.PostEffectType.BURN:
{
for (int i = 0; i < 3; ++i)
{
Color oldColor = spriteRenderer.color;
postEffect.PerformEffect();
yield return(new WaitForSeconds(0.3f));
spriteRenderer.color = oldColor;
yield return(new WaitForSeconds(0.8f));
}
break;
}
case PostEffect.PostEffectType.FREEZE:
{
postEffect.PerformEffect();
yield return(new WaitForSeconds(2f));
}
break;
default:
break;
}
postEffect.RevertEffect();
}
public void CastCameraEffect(string camEffectName, params object[] args)
{
switch (camEffectName)
{
case "DeathEffect":
postEffect = new DeathEffect();
break;
case "BeHitEffect":
postEffect = new BeHitEffect();
break;
case "MotionBlurEffect":
postEffect = new MotionBlurEffect();
break;
default:
break;
}
if (postEffect != null)
{
if (!PosteffectsDic.ContainsKey(camEffectName))
{
PosteffectsDic.Add(camEffectName, postEffect);
}
PosteffectsDic[camEffectName].CastCameraEffect(args);
}
}
public override void preProcess()
{
PostEffect combinePass = findObjectByInternalName("combinePass", true);
if (combinePass[".texture[3]"] != mColorCorrectionFileName) // sGlobal["$HDRPostFX::colorCorrectionRamp"])
{
combinePass.setTexture(3, mColorCorrectionFileName); // sGlobal["$HDRPostFX::colorCorrectionRamp"]);
}
}
/// <description>
/// ( PostEffect, [bool clear = false] )
/// </description>
public static void Open(PostEffect pfx, bool clear = false)
{
InternalUnsafeMethods.Open__Args _args = new InternalUnsafeMethods.Open__Args()
{
pfx = pfx.ObjectPtr,
clear = clear,
};
InternalUnsafeMethods.Open()(_args);
}
void Start()
{
player = transform.parent.GetComponentInChildren <PlayerController>();
cam = transform.parent.GetComponentInChildren <Camera>();
pe = cam.GetComponent <PostEffect>();
syncPlayer = GetComponentInParent <PlayerSync>();
cape = transform.parent.GetComponentInChildren <Cloth>();
nvs = GameObject.FindObjectOfType <NetworkVariables>();
localhost = GameObject.FindObjectOfType <LocalConnections>();
}
public override void setShaderConsts()
{
setShaderConst("$brightScalar", sGlobal["$LightRayPostFX::brightScalar"]);
PostEffect pfx = findObjectByInternalName("final", true);
pfx.setShaderConst("$numSamples", sGlobal["$LightRayPostFX::numSamples"]);
pfx.setShaderConst("$density", sGlobal["$LightRayPostFX::density"]);
pfx.setShaderConst("$weight", sGlobal["$LightRayPostFX::weight"]);
pfx.setShaderConst("$decay", sGlobal["$LightRayPostFX::decay"]);
pfx.setShaderConst("$exposure", sGlobal["$LightRayPostFX::exposure"]);
}
public static string LoadShader(PostEffect effect)
{
switch (effect)
{
case PostEffect.Bit4:
return("Hidden/Aubergine/4Bit");
default:
return(string.Format("Hidden/Aubergine/{0}", effect));
}
}
public override bool onEnabled()
{
PostEffect HDRPostFX = "HDRPostFX";
if (!HDRPostFX.isEnabledX())
{
HDRPostFX.enable();
}
HDRPostFX["skip"] = true.AsString();
return(true);
}
public PostEffectProxy CreatePostEffectProxy(Camera cam)
{
PostEffect postEffect = cam.GetComponent <PostEffect>();
if (postEffect == null)
{
postEffect = cam.gameObject.AddComponent <PostEffect>();
}
return(cam.GetComponent <PostEffectProxy>());
}
public void SetPlay()
{
Debug.Log("Set play");
currentState = GameState.GAMEPLAY;
volume.profile = baseProfile;
canvasPauseMenu.SetActive(false);
Time.timeScale = 1.0f;
if (pixelShader.isOn)
{
PostEffect post = cam.gameObject.GetComponent <PostEffect>();
post.enabled = true;
}
}
public override void setShaderConsts()
{
if (this["autoFocusEnabled"].AsBool())
{
autoFocus();
}
float fd = this["focalDist"].AsFloat() / fGlobal["$Param::FarDist"];
double range = Util.mLerp(this["minRange"].AsFloat(), this["maxRange"].AsFloat(), fd) /
fGlobal["$Param::FarDist"] * .5;
// We work in "depth" space rather than real-world units for the
// rest of this method...
// Given the focal distance and the range around it we want in focus
// we can determine the near-end-distance and far-start-distance
double ned = Util.getMax(fd - (float)range, (float)0.0);
double fsd = Util.getMin(fd + (float)range, (float)1.0);
// near slope
float nsl = this["nearSlope"].AsFloat();
// Given slope of near blur equation and the near end dist and amount (x2,y2)
// solve for the y-intercept
// y = mx + b
// so...
// y - mx = b
float b = (float)0.0 - nsl * (float)ned;
string eqNear = nsl.AsString() + " " + b.AsString() + " 0.0";
// Do the same for the far blur equation...
float fsl = this["farSlope"].AsFloat();
b = (float)0.0 - fsl * (float)fsd;
string eqFar = fsl.AsString() + " " + b.AsString() + " " + "1.0";
PostEffect DOFFinalPFX = "DOFFinalPFX";
this.setShaderConst("$dofEqWorld", eqNear);
DOFFinalPFX.setShaderConst("$dofEqFar", eqFar);
this.setShaderConst("$maxWorldCoC", this["nearBlurMax"]);
DOFFinalPFX.setShaderConst("$maxFarCoC", this["farBlurMax"]);
DOFFinalPFX.setShaderConst("$dofLerpScale", this["lerpScale"]);
DOFFinalPFX.setShaderConst("$dofLerpBias", this["lerpBias"]);
}
public override void setShaderConsts()
{
setShaderConst("$brightPassThreshold", sGlobal["$HDRPostFX::brightPassThreshold"]);
setShaderConst("$g_fMiddleGray", sGlobal["$HDRPostFX::keyValue"]);
PostEffect bloomh = findObjectByInternalName("bloomH", true);
bloomh.setShaderConst("$gaussMultiplier", sGlobal["$HDRPostFX::gaussMultiplier"]);
bloomh.setShaderConst("$gaussMean", sGlobal["$HDRPostFX::gaussMean"]);
bloomh.setShaderConst("$gaussStdDev", sGlobal["$HDRPostFX::gaussStdDev"]);
PostEffect bloomV = findObjectByInternalName("bloomV", true);
bloomV.setShaderConst("$gaussMultiplier", sGlobal["$HDRPostFX::gaussMultiplier"]);
bloomV.setShaderConst("$gaussMean", sGlobal["$HDRPostFX::gaussMean"]);
bloomV.setShaderConst("$gaussStdDev", sGlobal["$HDRPostFX::gaussStdDev"]);
double minLuminace = dGlobal["$HDRPostFX::minLuminace"];
if (minLuminace <= 0.0)
{
minLuminace = 0.00001;
}
((PostEffect)findObjectByInternalName("adaptLum", true)).setShaderConst("$g_fMinLuminace",
minLuminace.AsString());
((PostEffect)findObjectByInternalName("finalLum", true)).setShaderConst("$adaptRate",
sGlobal["$HDRPostFX::adaptRate"]);
PostEffect combinePass = findObjectByInternalName("combinePass", true);
combinePass.setShaderConst("$g_fEnableToneMapping", sGlobal["$HDRPostFX::enableToneMapping"]);
combinePass.setShaderConst("$g_fMiddleGray", sGlobal["$HDRPostFX::keyValue"]);
combinePass.setShaderConst("$g_fBloomScale", sGlobal["$HDRPostFX::enableBloom"]);
combinePass.setShaderConst("$g_fEnableBlueShift", sGlobal["$HDRPostFX::enableBlueShift"]);
combinePass.setShaderConst("$g_fBlueShiftColor", sGlobal["$HDRPostFX::blueShiftColor"]);
float clampedGamma = Util.mClamp(fGlobal["$pref::Video::Gamma"], (float)0.001, (float)2.2);
combinePass.setShaderConst("$g_fOneOverGamma", (1 / clampedGamma).AsString());
float whiteCutoff = fGlobal["$HDRPostFX::whiteCutoff"] * fGlobal["$HDRPostFX::whiteCutoff"] *
fGlobal["$HDRPostFX::whiteCutoff"] * fGlobal["$HDRPostFX::whiteCutoff"];
combinePass.setShaderConst("$g_fWhiteCutoff", whiteCutoff.AsString());
}
// Start is called before the first frame update
void Start()
{
postEffect = Camera.main.GetComponent <PostEffect>();
monsterSound = gameObject.GetComponent <AudioSource>();
GameObject body = gameObject.transform.Find("body_mesh").gameObject;
charRenderer = body.GetComponent <Renderer>();
spotlight = spotlightObject.GetComponent <Light>();
pointlight = spotlightObject.transform.GetChild(0).gameObject.GetComponent <Light>();
blushAmount = 0.0f;
tearAmount = 0.0f;
lerpAmount = 0.0f;
hopAmount = Mathf.PI / 2.0f;
blinkVal = 0;
postEffect.PostMat.SetFloat("_BlinkAmount", 0f);
}
void Start()
{
center = new Vector3(-0.7f, 0f, -3.95f);
Civilians = new Civilian[CivilianCount];
for (int i = 0; i < CivilianCount; i++)
{
StartCoroutine("OffsetCivilianEntry", i);
Civilians[i].status = 1.0f;
}
tintCount = Tints.Length;
animator = Char.GetComponent <Animator>();
postEffect = Camera.main.GetComponent <PostEffect>();
HealthHeart.SetActive(true);
healthRenderer = HealthHeart.GetComponent <MeshRenderer>();
healthPoints = 200f;
StartCoroutine("FadeInHeart");
}
public override void setShaderConsts()
{
setShaderConst("$texSize1", "0");
setShaderConst("$overallStrength", sGlobal["$SSAOPostFx::overallStrength"]);
//thisobj.setShaderConst("$",);
setShaderConst("$sRadius", sGlobal["$SSAOPostFx::sRadius"]);
setShaderConst("$sStrength", sGlobal["$SSAOPostFx::sStrength"]);
setShaderConst("$sDepthMin", sGlobal["$SSAOPostFx::sDepthMin"]);
setShaderConst("$sDepthMax", sGlobal["$SSAOPostFx::sDepthMax"]);
setShaderConst("$sDepthPow", sGlobal["$SSAOPostFx::sDepthPow"]);
setShaderConst("$sNormalTol", sGlobal["$SSAOPostFx::sNormalTol"]);
setShaderConst("$sNormalPow", sGlobal["$SSAOPostFx::sNormalPow"]);
setShaderConst("$lRadius", sGlobal["$SSAOPostFx::lRadius"]);
setShaderConst("$lStrength", sGlobal["$SSAOPostFx::lStrength"]);
setShaderConst("$lDepthMin", sGlobal["$SSAOPostFx::lDepthMin"]);
setShaderConst("$lDepthMax", sGlobal["$SSAOPostFx::lDepthMax"]);
setShaderConst("$lDepthPow", sGlobal["$SSAOPostFx::lDepthPow"]);
setShaderConst("$lNormalTol", sGlobal["$SSAOPostFx::lNormalTol"]);
setShaderConst("$lNormalPow", sGlobal["$SSAOPostFx::lNormalPow"]);
PostEffect blur = findObjectByInternalName("blurY", false);
blur.setShaderConst("$blurDepthTol", sGlobal["$SSAOPostFx::blurDepthTol"]);
blur.setShaderConst("$blurNormalTol", sGlobal["$SSAOPostFx::blurNormalTol"]);
blur = findObjectByInternalName("blurX", false);
blur.setShaderConst("$blurDepthTol", sGlobal["$SSAOPostFx::blurDepthTol"]);
blur.setShaderConst("$blurNormalTol", sGlobal["$SSAOPostFx::blurNormalTol"]);
blur = findObjectByInternalName("blurY2", false);
blur.setShaderConst("$blurDepthTol", sGlobal["$SSAOPostFx::blurDepthTol"]);
blur.setShaderConst("$blurNormalTol", sGlobal["$SSAOPostFx::blurNormalTol"]);
blur = findObjectByInternalName("blurX2", false);
blur.setShaderConst("$blurDepthTol", sGlobal["$SSAOPostFx::blurDepthTol"]);
blur.setShaderConst("$blurNormalTol", sGlobal["$SSAOPostFx::blurNormalTol"]);
}
public void quit()
{
GuiEditorGui GuiEditorGui = "GuiEditorGui";
GuiEditorGui.GuiEditor GuiEditor = "GuiEditor";
SimSet GuiGroup = "GuiGroup";
GuiCanvas Canvas = "Canvas";
PostEffect MLAAFx = "MLAAFx";
this.close();
GuiGroup.add(GuiEditorGui);
// we must not delete a window while in its event handler, or we foul the event dispatch mechanism
this.schedule("10", "delete");
Canvas.setContent(GuiEditor["lastContent"]);
bGlobal["$InGuiEditor"] = false;
//Temp fix to disable MLAA when in GUI editor
if (MLAAFx.isObject() && bGlobal["$MLAAFxGuiEditorTemp"])
{
MLAAFx.isEnabled = true;
bGlobal["$MLAAFxGuiEditorTemp"] = false;
}
}
public void ResolveShadows(ShadowCasterMap shadowCasterMap, LightSource resultLight, PostEffect postEffect)
{
this.ResolveShadows(shadowCasterMap, resultLight, postEffect, 1f);
}
public void AddPostEffect(PostEffect newPostEffect)
{
StartCoroutine(PostEffectTimer(newPostEffect));
}
public override void onDisabled()
{
PostEffect HDRPostFX = "HDRPostFX";
HDRPostFX["skip"] = false.AsString();
}
// Start is called before the first frame update
void Start()
{
startTime = Time.fixedTime;
postEffect = Camera.main.GetComponent <PostEffect>();
blinkVal = 0;
}
public void ResolveShadows(ShadowCasterMap shadowCasterMap, LightSource resultLight, RenderTarget2D printRT, PostEffect postEffect, Camera gameCamera)
{
this.ResolveShadows(shadowCasterMap, resultLight, printRT, postEffect, 1f, gameCamera);
}
public void ResolveShadows(ShadowCasterMap shadowCasterMap, LightSource resultLight, RenderTarget2D printRT, PostEffect postEffect, float distanceMod, Camera gameCamera)
{
BlendState backupBlendState = graphicsDevice.BlendState;
graphicsDevice.BlendState = BlendState.Opaque;
this.ExecuteTechniqueDistortAndComputeDistance(shadowCasterMap, resultLight, shadowMapDistorted, "DistortAndComputeDistances", gameCamera);
// Horizontal reduction
this.ApplyHorizontalReduction(shadowMapDistorted, this.shadowMapDigested);
this.distanceMod = distanceMod;
switch (postEffect)
{
case PostEffect.LinearAttenuation:
{
this.ExecuteTechniqueDrawShadows(printRT, "DrawShadowsLinearAttenuation", this.shadowMapDigested);
}
break;
case PostEffect.LinearAttenuation_BlurLow:
{
this.ExecuteTechniqueDrawShadows(shadowsRT, "DrawShadowsNoAttenuationPreBlur", this.shadowMapDigested);
this.ExecuteTechniqueBlurH(shadowsRT, processedShadowsRT, "BlurHorizontallyLow");
this.ExecuteTechniqueBlurV(processedShadowsRT, printRT, "BlurVerticallyLowLinearAttenuation");
}
break;
case PostEffect.LinearAttenuation_BlurMid:
{
this.ExecuteTechniqueDrawShadows(shadowsRT, "DrawShadowsNoAttenuationPreBlur", this.shadowMapDigested);
this.ExecuteTechniqueBlurH(shadowsRT, processedShadowsRT, "BlurHorizontallyMid");
this.ExecuteTechniqueBlurV(processedShadowsRT, printRT, "BlurVerticallyMidLinearAttenuation");
}
break;
case PostEffect.LinearAttenuation_BlurHigh:
{
this.ExecuteTechniqueDrawShadows(shadowsRT, "DrawShadowsNoAttenuationPreBlur", this.shadowMapDigested);
this.ExecuteTechniqueBlurH(shadowsRT, processedShadowsRT, "BlurHorizontallyHigh");
this.ExecuteTechniqueBlurV(processedShadowsRT, printRT, "BlurVerticallyHighLinearAttenuation");
}
break;
case PostEffect.CurveAttenuation:
{
this.ExecuteTechniqueDrawShadows(printRT, "DrawShadowsCurveAttenuation", this.shadowMapDigested);
}
break;
case PostEffect.CurveAttenuation_BlurLow:
{
this.ExecuteTechniqueDrawShadows(shadowsRT, "DrawShadowsNoAttenuationPreBlur", this.shadowMapDigested);
this.ExecuteTechniqueBlurH(shadowsRT, processedShadowsRT, "BlurHorizontallyLow");
this.ExecuteTechniqueBlurV(processedShadowsRT, printRT, "BlurVerticallyLowCurveAttenuation");
}
break;
case PostEffect.CurveAttenuation_BlurMid:
{
this.ExecuteTechniqueDrawShadows(shadowsRT, "DrawShadowsNoAttenuationPreBlur", this.shadowMapDigested);
this.ExecuteTechniqueBlurH(shadowsRT, processedShadowsRT, "BlurHorizontallyMid");
this.ExecuteTechniqueBlurV(processedShadowsRT, printRT, "BlurVerticallyMidCurveAttenuation");
}
break;
case PostEffect.CurveAttenuation_BlurHigh:
{
this.ExecuteTechniqueDrawShadows(shadowsRT, "DrawShadowsNoAttenuationPreBlur", this.shadowMapDigested);
this.ExecuteTechniqueBlurH(shadowsRT, processedShadowsRT, "BlurHorizontallyHigh");
this.ExecuteTechniqueBlurV(processedShadowsRT, printRT, "BlurVerticallyHighCurveAttenuation");
}
break;
case PostEffect.Only_BlurLow:
{
this.ExecuteTechniqueDrawShadows(shadowsRT, "DrawShadowsNoAttenuationPreBlur", this.shadowMapDigested);
this.ExecuteTechniqueBlurH(shadowsRT, processedShadowsRT, "BlurHorizontallyLow");
this.ExecuteTechniqueBlurV(processedShadowsRT, printRT, "BlurVerticallyLowNoAttenuation");
}
break;
case PostEffect.Only_BlurMid:
{
this.ExecuteTechniqueDrawShadows(shadowsRT, "DrawShadowsNoAttenuationPreBlur", this.shadowMapDigested);
this.ExecuteTechniqueBlurH(shadowsRT, processedShadowsRT, "BlurHorizontallyMid");
this.ExecuteTechniqueBlurV(processedShadowsRT, printRT, "BlurVerticallyMidNoAttenuation");
}
break;
case PostEffect.Only_BlurHigh:
{
this.ExecuteTechniqueDrawShadows(shadowsRT, "DrawShadowsNoAttenuationPreBlur", this.shadowMapDigested);
this.ExecuteTechniqueBlurH(shadowsRT, processedShadowsRT, "BlurHorizontallyHigh");
this.ExecuteTechniqueBlurV(processedShadowsRT, printRT, "BlurVerticallyHighNoAttenuation");
}
break;
default: //NOFX
{
this.ExecuteTechniqueDrawShadows(printRT, "DrawShadowsNoAttenuation", this.shadowMapDigested);
}
break;
}
graphicsDevice.BlendState = backupBlendState;
}
public void ResolveShadows(ShadowCasterMap shadowCasterMap, LightSource resultLight, RenderTarget2D printRT, PostEffect postEffect, float distanceMod, Vector2 newPosition, Camera gameCamera)
{
resultLight.Position = newPosition;
this.ResolveShadows(shadowCasterMap, resultLight, printRT, postEffect, distanceMod, gameCamera);
}
public void ResolveShadows(ShadowCasterMap shadowCasterMap, LightSource resultLight, PostEffect postEffect, Vector2 newPosition, int radius)
{
resultLight.Position = newPosition;
this.ResolveShadows(shadowCasterMap, resultLight, postEffect, 1f, radius);
}
// OnStateEnter is called when a transition starts and the state machine starts to evaluate this state
override public void OnStateEnter(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
{
postEffect = Camera.main.GetComponent <PostEffect>();
}
public void ResolveShadows(ShadowCasterMap shadowCasterMap, LightSource resultLight, PostEffect postEffect, float distanceMod)
{
BlendState backupBlendState = graphicsDevice.BlendState;
graphicsDevice.BlendState = BlendState.Opaque;
this.ExecuteTechniqueDistortAndComputeDistance(shadowCasterMap, resultLight, shadowMapDistorted, "DistortAndComputeDistances");
// Horizontal reduction
this.ApplyHorizontalReduction(shadowMapDistorted, this.shadowMapDigested);
this.distanceMod = distanceMod;
switch (postEffect)
{
case PostEffect.LinearAttenuation:
{
this.ExecuteTechniqueDrawShadows(resultLight.PrintedLight, "DrawShadowsLinearAttenuation", this.shadowMapDigested);
}
break;
case PostEffect.LinearAttenuation_BlurLow:
{
this.ExecuteTechniqueDrawShadows(shadowsRT, "DrawShadowsNoAttenuationPreBlur", this.shadowMapDigested);
this.ExecuteTechniqueBlurH(shadowsRT, processedShadowsRT, "BlurHorizontallyLow");
this.ExecuteTechniqueBlurV(processedShadowsRT, resultLight.PrintedLight, "BlurVerticallyLowLinearAttenuation");
}
break;
case PostEffect.LinearAttenuation_BlurMid:
{
this.ExecuteTechniqueDrawShadows(shadowsRT, "DrawShadowsNoAttenuationPreBlur", this.shadowMapDigested);
this.ExecuteTechniqueBlurH(shadowsRT, processedShadowsRT, "BlurHorizontallyMid");
this.ExecuteTechniqueBlurV(processedShadowsRT, resultLight.PrintedLight, "BlurVerticallyMidLinearAttenuation");
}
break;
case PostEffect.LinearAttenuation_BlurHigh:
{
this.ExecuteTechniqueDrawShadows(shadowsRT, "DrawShadowsNoAttenuationPreBlur", this.shadowMapDigested);
this.ExecuteTechniqueBlurH(shadowsRT, processedShadowsRT, "BlurHorizontallyHigh");
this.ExecuteTechniqueBlurV(processedShadowsRT, resultLight.PrintedLight, "BlurVerticallyHighLinearAttenuation");
}
break;
case PostEffect.CurveAttenuation:
{
this.ExecuteTechniqueDrawShadows(resultLight.PrintedLight, "DrawShadowsCurveAttenuation", this.shadowMapDigested);
}
break;
case PostEffect.CurveAttenuation_BlurLow:
{
this.ExecuteTechniqueDrawShadows(shadowsRT, "DrawShadowsNoAttenuationPreBlur", this.shadowMapDigested);
this.ExecuteTechniqueBlurH(shadowsRT, processedShadowsRT, "BlurHorizontallyLow");
this.ExecuteTechniqueBlurV(processedShadowsRT, resultLight.PrintedLight, "BlurVerticallyLowCurveAttenuation");
}
break;
case PostEffect.CurveAttenuation_BlurMid:
{
this.ExecuteTechniqueDrawShadows(shadowsRT, "DrawShadowsNoAttenuationPreBlur", this.shadowMapDigested);
this.ExecuteTechniqueBlurH(shadowsRT, processedShadowsRT, "BlurHorizontallyMid");
this.ExecuteTechniqueBlurV(processedShadowsRT, resultLight.PrintedLight, "BlurVerticallyMidCurveAttenuation");
}
break;
case PostEffect.CurveAttenuation_BlurHigh:
{
this.ExecuteTechniqueDrawShadows(shadowsRT, "DrawShadowsNoAttenuationPreBlur", this.shadowMapDigested);
this.ExecuteTechniqueBlurH(shadowsRT, processedShadowsRT, "BlurHorizontallyHigh");
this.ExecuteTechniqueBlurV(processedShadowsRT, resultLight.PrintedLight, "BlurVerticallyHighCurveAttenuation");
}
break;
case PostEffect.Only_BlurLow:
{
this.ExecuteTechniqueDrawShadows(shadowsRT, "DrawShadowsNoAttenuationPreBlur", this.shadowMapDigested);
this.ExecuteTechniqueBlurH(shadowsRT, processedShadowsRT, "BlurHorizontallyLow");
this.ExecuteTechniqueBlurV(processedShadowsRT, resultLight.PrintedLight, "BlurVerticallyLowNoAttenuation");
}
break;
case PostEffect.Only_BlurMid:
{
this.ExecuteTechniqueDrawShadows(shadowsRT, "DrawShadowsNoAttenuationPreBlur", this.shadowMapDigested);
this.ExecuteTechniqueBlurH(shadowsRT, processedShadowsRT, "BlurHorizontallyMid");
this.ExecuteTechniqueBlurV(processedShadowsRT, resultLight.PrintedLight, "BlurVerticallyMidNoAttenuation");
}
break;
case PostEffect.Only_BlurHigh:
{
this.ExecuteTechniqueDrawShadows(shadowsRT, "DrawShadowsNoAttenuationPreBlur", this.shadowMapDigested);
this.ExecuteTechniqueBlurH(shadowsRT, processedShadowsRT, "BlurHorizontallyHigh");
this.ExecuteTechniqueBlurV(processedShadowsRT, resultLight.PrintedLight, "BlurVerticallyHighNoAttenuation");
}
break;
default: //NOFX
{
this.ExecuteTechniqueDrawShadows(resultLight.PrintedLight, "DrawShadowsNoAttenuation", this.shadowMapDigested);
}
break;
}
graphicsDevice.BlendState = backupBlendState;
}
public void ResolveShadows(ShadowCasterMap shadowCasterMap, LightSource resultLight, PostEffect postEffect, float distanceMod, Vector2 newPosition)
{
resultLight.Position = newPosition;
this.ResolveShadows(shadowCasterMap, resultLight, postEffect, distanceMod);
}