public override void Init(EffectParameter _p)
{
base.Init(_p);
numbericType = EffectNumbericType.Percentage;
type = EffectType.Ice;
coverType = EffectCoverType.Cover;
}
internal EffectConstantBuffer(string name, int size, EffectParameterDescription[] paramDescription)
: base(size)
{
_device = GraphicManager.Device;
Name = name;
Size = size;
_hashCode = GetHashCode(name, size, paramDescription);
if (paramDescription != null)
{
Parameters = new Dictionary<string, EffectParameter>(paramDescription.Length);
for (int i = 0; i < paramDescription.Length; i++)
{
EffectParameter parameter = new EffectParameter(paramDescription[i], this);
Parameters.Add(parameter.Name, parameter);
}
}
Clear();
_nativeBuffer = Buffer.NewConstantBuffer(size);
IsDirty = true;
}
/// <summary>
/// Lazily recomputes the world inverse transpose matrix and
/// eye position based on the current effect parameter settings.
/// </summary>
internal static EffectDirtyFlags SetLightingMatrices(EffectDirtyFlags dirtyFlags, ref Matrix world, ref Matrix view,
EffectParameter worldParam, EffectParameter worldInverseTransposeParam, EffectParameter eyePositionParam)
{
// Set the world and world inverse transpose matrices.
if ((dirtyFlags & EffectDirtyFlags.World) != 0)
{
Matrix worldTranspose;
Matrix worldInverseTranspose;
Matrix.Invert(ref world, out worldTranspose);
Matrix.Transpose(ref worldTranspose, out worldInverseTranspose);
worldParam.SetValue(world);
worldInverseTransposeParam.SetValue(worldInverseTranspose);
dirtyFlags &= ~EffectDirtyFlags.World;
}
// Set the eye position.
if ((dirtyFlags & EffectDirtyFlags.EyePosition) != 0)
{
Matrix viewInverse;
Matrix.Invert(ref view, out viewInverse);
eyePositionParam.SetValue(viewInverse.TranslationVector);
dirtyFlags &= ~EffectDirtyFlags.EyePosition;
}
return dirtyFlags;
}
public ParticleSystem(GraphicsDevice device, ContentManager content)
{
this.device = device;
// Create vertex buffer used to spawn new particles
this.particleStart = Buffer.Vertex.New<ParticleVertex>(device, MAX_NEW);
// Create vertex buffers to use for updating and drawing the particles alternatively
var vbFlags = BufferFlags.VertexBuffer | BufferFlags.StreamOutput;
this.particleDrawFrom = Buffer.New<ParticleVertex>(device, MAX_PARTICLES, vbFlags);
this.particleStreamTo = Buffer.New<ParticleVertex>(device, MAX_PARTICLES, vbFlags);
this.layout = VertexInputLayout.FromBuffer(0, this.particleStreamTo);
this.effect = content.Load<Effect>("ParticleEffect");
this.texture = content.Load<Texture2D>("Dot");
this.viewParameter = effect.Parameters["_view"];
this.projParameter = effect.Parameters["_proj"];
this.lookAtMatrixParameter = effect.Parameters["_lookAtMatrix"];
this.elapsedSecondsParameter = effect.Parameters["_elapsedSeconds"];
this.camDirParameter = effect.Parameters["_camDir"];
this.gravityParameter = effect.Parameters["_gravity"];
this.textureParameter = effect.Parameters["_texture"];
this.samplerParameter = effect.Parameters["_sampler"];
this.updatePass = effect.Techniques["UpdateTeq"].Passes[0];
this.renderPass = effect.Techniques["RenderTeq"].Passes[0];
}
protected override void Initialize()
{
base.Initialize();
_pixelShaderConstantBuffer = ConstantBuffers["SamplingConstants"];
_encodeConstantsParameter = _pixelShaderConstantBuffer.Parameters["EncodeConstants"];
}
internal EffectAnnotation(EffectParameter parameter)
{
this.ParameterClass = parameter.ParameterClass;
this.ParameterType = parameter.ParameterType;
this.Name = parameter.Name;
this.RowCount = parameter.RowCount;
this.ColumnCount = parameter.ColumnCount;
this.Semantic = parameter.Semantic;
}
/// <summary>
/// Initializes a new instance of the <see cref="PrimitiveQuad" /> class.
/// </summary>
/// <param name="graphicsDevice">The graphics device.</param>
public PrimitiveQuad(GraphicsDevice graphicsDevice)
{
GraphicsDevice = graphicsDevice;
quadEffect = ToDispose(new Effect(GraphicsDevice, effectBytecode));
quadPass = quadEffect.CurrentTechnique.Passes[0];
matrixParameter = quadEffect.Parameters["MatrixTransform"];
Transform = Matrix.Identity;
sharedData = GraphicsDevice.GetOrCreateSharedData(SharedDataType.PerDevice, "Toolkit::PrimitiveQuad::VertexBuffer", () => new SharedData(GraphicsDevice));
}
protected override void Initialize()
{
base.Initialize();
_vertexShaderConstantBuffer = ConstantBuffers["VertexShaderConstants"];
_viewMatrixParameter = _vertexShaderConstantBuffer.Parameters["ViewMatrix"];
_projectionMatrixParameter = _vertexShaderConstantBuffer.Parameters["ProjectionMatrix"];
_modelMatrixParameter = _vertexShaderConstantBuffer.Parameters["ModelMatrix"];
_scaleFactorParameter = _vertexShaderConstantBuffer.Parameters["scaleFactor"];
}
public Effect(EffectData effectData)
{
Name = effectData.Name;
CBufferLinks = new List<CBufferLink>();
ConstantBuffers = new Dictionary<string, EffectConstantBuffer>();
Parameters = new Dictionary<string, EffectParameter>();
foreach (CBufferLinkData cb in effectData.CBuffers)
{
EffectConstantBuffer cBuffer = MaterialManager.ConstantBuffers[cb.CBuffer];
ConstantBuffers.Add(cb.CBuffer, cBuffer);
CBufferLinks.Add(new CBufferLink() { CBuffer = cBuffer, Slot = cb.Slot });
foreach (EffectParameter parameter in cBuffer.Parameters.Values)
{
Parameters.Add(parameter.Name, parameter);
}
}
Techniques = new Dictionary<string, EffectTechnique>();
foreach (TechniqueData td in effectData.Techniques)
{
TechniqueTags tags = new TechniqueTags(td.Tags);
EffectTechnique technique = new EffectTechnique(td.Name, tags,this);
Techniques.Add(td.Name, technique);
SetCurrentTechnique(td.Name);
technique.Passes = new List<EffectPass>();
foreach (PassData pd in td.Passes)
{
EffectPass pass = new EffectPass(pd.Rasterizer, pd.Blend, pd.DepthStencil,
pd.Shader, pd.VertexShaderEntryPoint, pd.PixelShaderEntryPoint, tags, this);
technique.Passes.Add(pass);
}
}
WorldMatrix = Parameters["world"];
ViewMatrix = Parameters["view"];
ProjectionMatrix = Parameters["projection"];
WolrdInverseTrasposeMatrix = Parameters["worldInverseTraspose"];
EyePos = Parameters["eyePos"];
}
protected override void Initialize()
{
base.Initialize();
_constantBuffer = ConstantBuffers["CB0"];
_scaleParameter = _constantBuffer.Parameters["scale"];
_offsetParameter = _constantBuffer.Parameters["offset"];
_textureParameter = Parameters["tex"];
Parameters["sam"].SetResource(GetSampler());
}
protected override void Initialize()
{
base.Initialize();
_colorTextureParameter = Parameters["ColorTexture"];
_colorResidencyParameter = Parameters["ColorResidency"];
_normalTextureParameter = Parameters["NormalTexture"];
_normalResidencyParameter = Parameters["NormalResidency"];
Parameters["Trilinear"].SetResource(GraphicsDevice.SamplerStates.AnisotropicWrap);
Parameters["MaxFilter"].SetResource(GraphicsDevice.SamplerStates.LinearWrap);
_pixelShaderConstantBuffer = ConstantBuffers["PixelShaderConstants"];
_sunPositionParameter = _pixelShaderConstantBuffer.Parameters["SunPosition"];
}
public DirectionalLight(
EffectParameter directionParameter,
EffectParameter diffuseColorParameter,
EffectParameter specularColorParameter,
DirectionalLight cloneSource
)
{
this.diffuseColorParameter = diffuseColorParameter;
this.directionParameter = directionParameter;
this.specularColorParameter = specularColorParameter;
if (cloneSource != null)
{
DiffuseColor = cloneSource.DiffuseColor;
Direction = cloneSource.Direction;
SpecularColor = cloneSource.SpecularColor;
Enabled = cloneSource.Enabled;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="PrimitiveQuad" /> class.
/// </summary>
/// <param name="graphicsDevice">The graphics device.</param>
public PrimitiveQuad(GraphicsDevice graphicsDevice)
{
GraphicsDevice = graphicsDevice;
quadEffect = ToDispose(new Effect(GraphicsDevice, effectBytecode));
quadPass = quadEffect.CurrentTechnique.Passes[0];
matrixParameter = quadEffect.Parameters["MatrixTransform"];
textureCopyPass = quadEffect.CurrentTechnique.Passes[1];
textureParameter = quadEffect.Parameters["Texture"];
textureSamplerParameter = quadEffect.Parameters["TextureSampler"];
// Default LinearClamp
textureSamplerParameter.SetResource(GraphicsDevice.SamplerStates.LinearClamp);
Transform = Matrix.Identity;
sharedData = GraphicsDevice.GetOrCreateSharedData(SharedDataType.PerDevice, "Toolkit::PrimitiveQuad::VertexBuffer", () => new SharedData(GraphicsDevice));
}
/// <summary>
/// Lazily recomputes the world+view+projection matrix and
/// fog vector based on the current effect parameter settings.
/// </summary>
internal static EffectDirtyFlags SetWorldViewProjAndFog(EffectDirtyFlags dirtyFlags,
ref Matrix world, ref Matrix view, ref Matrix projection, ref Matrix worldView,
bool fogEnabled, float fogStart, float fogEnd,
EffectParameter worldViewProjParam, EffectParameter fogVectorParam)
{
// Recompute the world+view+projection matrix?
if ((dirtyFlags & EffectDirtyFlags.WorldViewProj) != 0)
{
Matrix worldViewProj;
Matrix.Multiply(ref world, ref view, out worldView);
Matrix.Multiply(ref worldView, ref projection, out worldViewProj);
worldViewProjParam.SetValue(worldViewProj);
dirtyFlags &= ~EffectDirtyFlags.WorldViewProj;
}
if (fogEnabled)
{
// Recompute the fog vector?
if ((dirtyFlags & (EffectDirtyFlags.Fog | EffectDirtyFlags.FogEnable)) != 0)
{
SetFogVector(ref worldView, fogStart, fogEnd, fogVectorParam);
dirtyFlags &= ~(EffectDirtyFlags.Fog | EffectDirtyFlags.FogEnable);
}
}
else
{
// When fog is disabled, make sure the fog vector is reset to zero.
if ((dirtyFlags & EffectDirtyFlags.FogEnable) != 0)
{
fogVectorParam.SetValue(Vector4.Zero);
dirtyFlags &= ~EffectDirtyFlags.FogEnable;
}
}
return dirtyFlags;
}
private void ApplyFrustumCorners(EffectParameter frustumCorners, Vector2 topLeftVertex, Vector2 bottomRightVertex)
{
float dx = _currentFrustumCorners[1].X - _currentFrustumCorners[0].X;
float dy = _currentFrustumCorners[0].Y - _currentFrustumCorners[2].Y;
_localFrustumCorners[0] = _currentFrustumCorners[2];
_localFrustumCorners[0].X += dx * (topLeftVertex.X * 0.5f + 0.5f);
_localFrustumCorners[0].Y += dy * (bottomRightVertex.Y * 0.5f + 0.5f);
_localFrustumCorners[1] = _currentFrustumCorners[2];
_localFrustumCorners[1].X += dx * (bottomRightVertex.X * 0.5f + 0.5f);
_localFrustumCorners[1].Y += dy * (bottomRightVertex.Y * 0.5f + 0.5f);
_localFrustumCorners[2] = _currentFrustumCorners[2];
_localFrustumCorners[2].X += dx * (topLeftVertex.X * 0.5f + 0.5f);
_localFrustumCorners[2].Y += dy * (topLeftVertex.Y * 0.5f + 0.5f);
_localFrustumCorners[3] = _currentFrustumCorners[2];
_localFrustumCorners[3].X += dx * (bottomRightVertex.X * 0.5f + 0.5f);
_localFrustumCorners[3].Y += dy * (topLeftVertex.Y * 0.5f + 0.5f);
frustumCorners.SetValue(_localFrustumCorners);
}
public GaussianBlur(Game game, int screenWidth, int screenHeight)
{
if (m_renderHolder != null && !m_renderHolder.IsDisposed)
{
m_renderHolder.Dispose();
}
if (m_renderHolder2 != null && !m_renderHolder2.IsDisposed)
{
m_renderHolder2.Dispose();
}
if (LevelEV.SAVE_FRAMES)
{
m_renderHolder = new RenderTarget2D(game.GraphicsDevice, screenWidth / 2, screenHeight / 2);
m_renderHolder2 = new RenderTarget2D(game.GraphicsDevice, screenWidth / 2, screenHeight / 2);
}
else
{
m_renderHolder = new RenderTarget2D(game.GraphicsDevice, screenWidth, screenHeight);
m_renderHolder2 = new RenderTarget2D(game.GraphicsDevice, screenWidth, screenHeight);
}
effect = game.Content.Load <Effect>("Shaders\\GaussianBlurMask");
m_offsetParameters = effect.Parameters["offsets"];
}
public void LoadContent(Game game, string diffuseTexture, Color starColor, Color haloColor)
{
starDiffuse = game.Content.Load <Texture2D>(@"textures\" + diffuseTexture);
haloDiffuse = game.Content.Load <Texture2D>(@"textures\glow");
spriteCenter = new Vector2(haloDiffuse.Width / 2, haloDiffuse.Height / 2);
starEffect = game.Content.Load <Effect>(@"shaders\suneffect");
starWorldMatrix = starEffect.Parameters["World"];
starViewMatrix = starEffect.Parameters["View"];
starProjectionMatrix = starEffect.Parameters["Projection"];
starDiffuseTexture = starEffect.Parameters["DiffuseTexture"];
starColorData = starEffect.Parameters["StarColor"];
halo = new SpriteBatch(game.GraphicsDevice);
this.starColor = new Vector4((float)starColor.R / 255.0f, (float)starColor.G / 255.0f, (float)starColor.B / 255.0f, 1.0f);
this.haloColor = haloColor;
star.LoadContent(game);
}
public RTSFXEntity(Effect _fx)
{
if (_fx == null)
{
throw new ArgumentNullException("A Null Effect Was Used");
}
// Set The Effect To The First Technique
fx = _fx;
fx.CurrentTechnique = fx.Techniques[0];
// Get The Passes
fxPassBuilding = fx.CurrentTechnique.Passes[PASS_KEY_BUILDING];
fxPassUnit = fx.CurrentTechnique.Passes[PASS_KEY_UNIT];
// Get The Parameters
fxpWorld = fx.Parameters[PARAM_KEY_WORLD];
fxpVP = fx.Parameters[PARAM_KEY_VP];
fxpColP = fx.Parameters[PARAM_KEY_COLOR_PRIMARY];
fxpColS = fx.Parameters[PARAM_KEY_COLOR_SECONDARY];
fxpColT = fx.Parameters[PARAM_KEY_COLOR_TERTIARY];
fxpTexelSize = fx.Parameters[PARAM_KEY_TEXEL_SIZE];
}
private IArmor Finger()
{
IArmor armor = CreateArmor(AvalableItemPosition.Finger, 17, new Gold());
armor.ExamineDescription = "The gem is made of a red stone with white veins that look like a swirl frozen in time.";
armor.LookDescription = "The ring is made of a thick gold band with a red stone in the center.";
armor.ShortDescription = "Gold Ring.";
armor.SentenceDescription = "ring";
armor.KeyWords.Add("red");
armor.KeyWords.Add("stone");
armor.KeyWords.Add("gold");
armor.KeyWords.Add("ring");
IEnchantment enchantment = new HeartbeatBigTickEnchantment();
enchantment.Effect = new RecoverStamina();
IEffectParameter effectParameter = new EffectParameter();
effectParameter.Dice = new Dice(1, 1);
enchantment.Parameter = effectParameter;
return(armor);
}
public Property <Matrix[]> GetMatrixArrayParameter(string name)
{
IProperty result = null;
if (!this.properties.TryGetValue(name, out result))
{
Property <Matrix[]> property = new Property <Matrix[]>();
this.Add(new SetBinding <Matrix[]>(property, delegate(Matrix[] value)
{
if (this.effect != null)
{
EffectParameter param = this.effect.Parameters[name];
if (param != null)
{
param.SetValue(value);
}
}
}));
this.properties[name] = property;
result = property;
}
return((Property <Matrix[]>)result);
}
public override void OnCreateDevice()
{
effect = SpacewarGame.ContentManager.Load <Effect>(SpacewarGame.Settings.MediaPath + @"shaders\ship");
worldParam = effect.Parameters["world"];
inverseWorldParam = effect.Parameters["inverseWorld"];
worldViewProjectionParam = effect.Parameters["worldViewProjection"];
viewPositionParam = effect.Parameters["viewPosition"];
skinTextureParam = effect.Parameters["SkinTexture"];
normalTextureParam = effect.Parameters["NormalMapTexture"];
reflectionTextureParam = effect.Parameters["ReflectionTexture"];
ambientParam = effect.Parameters["Ambient"];
directionalDirectionParam = effect.Parameters["DirectionalDirection"];
directionalColorParam = effect.Parameters["DirectionalColor"];
pointPositionParam = effect.Parameters["PointPosition"];
pointColorParam = effect.Parameters["PointColor"];
pointFactorParam = effect.Parameters["PointFactor"];
materialParam = effect.Parameters["Material"];
blackTexture = SpacewarGame.ContentManager.Load <Texture2D>(SpacewarGame.Settings.MediaPath + @"Textures\Black");
SetupEffect();
}
//--------------------------------------------------------------
#region Creation & Cleanup
//--------------------------------------------------------------
/// <summary>
/// Initializes a new instance of the <see cref="BloomFilter"/> class.
/// </summary>
/// <param name="graphicsService">The graphics service.</param>
/// <exception cref="ArgumentNullException">
/// <paramref name="graphicsService"/> is <see langword="null"/>.
/// </exception>
public BloomFilter(IGraphicsService graphicsService)
: base(graphicsService)
{
_effect = GraphicsService.Content.Load <Effect>("DigitalRune/PostProcessing/BloomFilter");
_viewportSizeParameter = _effect.Parameters["ViewportSize"];
_bloomThresholdParameter = _effect.Parameters["BloomThreshold"];
_bloomIntensityParameter = _effect.Parameters["BloomIntensity"];
_bloomSaturationParameter = _effect.Parameters["BloomSaturation"];
_sceneTextureParameter = _effect.Parameters["SceneTexture"];
_bloomTextureParameter = _effect.Parameters["BloomTexture"];
_brightnessPass = _effect.CurrentTechnique.Passes["Brightness"];
_combinePass = _effect.CurrentTechnique.Passes["Combine"];
_blur = new Blur(graphicsService);
_blur.InitializeGaussianBlur(7, 7.0f / 3.0f, true);
_downsampleFilter = PostProcessHelper.GetDownsampleFilter(graphicsService);
Threshold = 0.7f;
Intensity = 1.5f;
Saturation = 0.5f;
DownsampleFactor = 4;
}
public WaterReflectionEffect(Effect effect)
: base(effect)
{
this.CurrentTechnique = this.Techniques["WaterReflectionTechnique"];
this.timeParam = this.Parameters["_time"];
this.sparkleIntensityParam = this.Parameters["_sparkleIntensity"];
this.sparkleColorParam = this.Parameters["_sparkleColor"];
this.screenSpaceVerticalOffsetParam = this.Parameters["_screenSpaceVerticalOffset"];
this.perspectiveCorrectionIntensityParam = this.Parameters["_perspectiveCorrectionIntensity"];
this.firstDisplacementSpeedParam = this.Parameters["_firstDisplacementSpeed"];
this.secondDisplacementSpeedParam = this.Parameters["_secondDisplacementSpeed"];
this.secondDisplacementScaleParam = this.Parameters["_secondDisplacementScale"];
this.SparkleIntensity = 0.015f;
this.SparkleColor = Color.White;
this.PerspectiveCorrectionIntensity = 0.3f;
this.FirstDisplacementSpeed = 0.06f;
this.SecondDisplacementSpeed = 0.02f;
this.SecondDisplacementScale = 3f;
this.ReflectionIntensity = 0.85f;
this.NormalMagnitude = 0.03f;
}
public Property <RenderTarget2D> GetRenderTarget2DParameter(string name)
{
IProperty result = null;
if (!this.properties.TryGetValue(name, out result))
{
Property <RenderTarget2D> property = new Property <RenderTarget2D>();
this.Add(new SetBinding <RenderTarget2D>(property, delegate(RenderTarget2D value)
{
if (this.effect != null)
{
EffectParameter param = this.effect.Parameters[name];
if (param != null && (value == null || !value.IsDisposed))
{
param.SetValue(value);
}
}
}));
this.properties[name] = property;
result = property;
}
return((Property <RenderTarget2D>)result);
}
public void SetupOceanShaderParameters()
{
worldOceanParameter = oceanEffect.Parameters["World"];
viewOceanParameter = oceanEffect.Parameters["View"];
projectionOceanParameter = oceanEffect.Parameters["Projection"];
ambientColorOceanParameter = oceanEffect.Parameters["AmbientColor"];
ambientIntensityOceanParameter = oceanEffect.Parameters["AmbientIntensity"];
diffuseColorOceanParameter = oceanEffect.Parameters["DiffuseColor"];
diffuseIntensityOceanParameter = oceanEffect.Parameters["DiffuseIntensity"];
lightDirectionOceanParameter = oceanEffect.Parameters["LightDirection"];
eyePosOceanParameter = oceanEffect.Parameters["EyePosition"];
specularColorOceanParameter = oceanEffect.Parameters["SpecularColor"];
colorMapTextureOceanParameter = oceanEffect.Parameters["ColorMap"];
normalMapTextureOceanParameter = oceanEffect.Parameters["NormalMap"];
totalTimeOceanParameter = oceanEffect.Parameters["TotalTime"];
rippleSpeedParameter = oceanEffect.Parameters["rippleSpeed"];
rippleHeightParameter = oceanEffect.Parameters["rippleHeight"];
}
/// <inheritdoc/>
public EffectParameterBinding GetBinding(Effect effect, EffectParameter parameter, IDictionary <string, object> opaqueData)
{
if (effect is AlphaTestEffect ||
effect is BasicEffect ||
effect is DualTextureEffect ||
effect is EnvironmentMapEffect ||
effect is SkinnedEffect)
{
// The ShaderIndex parameter is set by effect technique bindings.
var description = effect.GetParameterDescriptions()[parameter];
if (description.Semantic == "XnaShaderIndex")
{
return(new NullParameterBinding <int>(effect, parameter));
}
if (description.Semantic == "XnaFogVector")
{
return(new FogVectorParameterBinding(effect, parameter));
}
}
return(null);
}
private void ParameterListBox_OnSelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (ParameterListBox.SelectedIndex == -1)
{
return;
}
if (_selectedParam != null)
{
_selectedParam.Json = AddonTextEditor.Text;
_selectedParam.Lang = LangTextEditor.Text;
_params[_selectedParam.Key] = _selectedParam;
AddonManager.CurrentAddon.Effect.Parameters = _params;
AddonManager.SaveCurrentAddon();
}
var selectedKey = ((KeyValuePair <string, EffectParameter>)ParameterListBox.SelectedItem).Key;
_selectedParam = _params[selectedKey];
AddonTextEditor.Text = _selectedParam.Json;
LangTextEditor.Text = _selectedParam.Lang;
}
public GaussianBlurEffect() : base(Core.GraphicsDevice, EffectResource.GaussianBlurBytes)
{
_blurWeightsParam = Parameters["_sampleWeights"];
_blurOffsetsParam = Parameters["_sampleOffsets"];
// Look up how many samples our gaussian blur effect supports.
_sampleCount = _blurWeightsParam.Elements.Count;
// Create temporary arrays for computing our filter settings.
_sampleWeights = new float[_sampleCount];
_verticalSampleOffsets = new Vector2[_sampleCount];
_horizontalSampleOffsets = new Vector2[_sampleCount];
// The first sample always has a zero offset.
_verticalSampleOffsets[0] = Vector2.Zero;
_horizontalSampleOffsets[0] = Vector2.Zero;
// we can calculate the sample weights just once since they are always the same for horizontal or vertical blur
CalculateSampleWeights();
SetBlurEffectParameters(_horizontalBlurDelta, 0, _horizontalSampleOffsets);
PrepareForHorizontalBlur();
}
protected override void GetParameters()
{
//Binding the effect parameters in to Effect File;
// Geometry
world = effect.Parameters["world"];
viewProj = effect.Parameters["viewProjection"];
worldForNormal = effect.Parameters["worldForNormal"];
cameraPosition = effect.Parameters["cameraPosition"];
// Material
emissiveColor = effect.Parameters["emissiveColor"];
diffuseColor = effect.Parameters["diffuseColor"];
specularColor = effect.Parameters["specularColor"];
specularPower = effect.Parameters["specularPower"];
toonTexture = effect.Parameters["toonTexture"];
textureEnabled = effect.Parameters["TextureEnabled"];
// Lights
light = effect.Parameters["light"];
ambientLightColor = effect.Parameters["ambientLightColor"];
numberOfLights = effect.Parameters["numberOfLights"];
}
//--------------------------------------------------------------
#region Properties & Events
//--------------------------------------------------------------
#endregion
//--------------------------------------------------------------
#region Creation & Cleanup
//--------------------------------------------------------------
/// <summary>
/// Initializes a new instance of the <see cref="FogRenderer"/> class.
/// </summary>
/// <param name="graphicsService">The graphics service.</param>
/// <exception cref="ArgumentNullException">
/// <paramref name="graphicsService"/> is <see langword="null"/>.
/// </exception>
public FogRenderer(IGraphicsService graphicsService)
{
if (graphicsService == null)
{
throw new ArgumentNullException("graphicsService");
}
Order = 3;
_effect = graphicsService.Content.Load <Effect>("DigitalRune/Deferred/Fog");
_parameterViewportSize = _effect.Parameters["ViewportSize"];
_parameterFrustumCorners = _effect.Parameters["FrustumCorners"];
_parameterFogParameters = _effect.Parameters["FogParameters"];
_parameterColor0 = _effect.Parameters["Color0"];
_parameterColor1 = _effect.Parameters["Color1"];
_parameterHeights = _effect.Parameters["Heights"];
_parameterLightDirection = _effect.Parameters["LightDirection"];
_parameterScatteringSymmetry = _effect.Parameters["ScatteringSymmetry"];
_parameterGBuffer0 = _effect.Parameters["GBuffer0"];
_passFog = _effect.Techniques[0].Passes["Fog"];
_passFogWithHeightFalloff = _effect.Techniques[0].Passes["FogWithHeightFalloff"];
_passFogWithPhase = _effect.Techniques[0].Passes["FogWithPhase"];
_passFogWithHeightFalloffWithPhase = _effect.Techniques[0].Passes["FogWithHeightFalloffWithPhase"];
}
private static MaterialParameterSetter CreateSetter(EffectParameter parameter)
{
if (string.IsNullOrEmpty(parameter.Semantic))
{
return(null);
}
var parameterType = new ParameterType()
{
Type = parameter.ParameterType, Rows = parameter.RowCount, Columns = parameter.ColumnCount
};
Type type;
if (!ParameterTypeMappings.TryGetValue(parameterType, out type))
{
#if WINDOWS
Trace.TraceWarning("An automatic setter could not be created for the Material parameter \"{0}\", with semantic \"{1}\".", parameter.Name, parameter.Semantic);
#endif
}
var typeName = type.Name;
if (parameter.Elements.Count > 0)
{
typeName += "[]";
}
Type setterType;
if (SetterTypeMappings.TryGetValue(typeName, out setterType))
{
return(Activator.CreateInstance(setterType, parameter) as MaterialParameterSetter);
}
else
{
return(null);
}
}
EffectParameter paramPixelSize; // pixel size
/// <summary>
/// Create a new blur manager
/// </summary>
public BlurManager(GraphicsDevice graphicsDevice, Effect effect, int sizex, int sizey)
{
if (graphicsDevice == null)
{
throw new ArgumentNullException("graphicsDevice");
}
if (effect == null)
{
throw new ArgumentNullException("effect");
}
gd = graphicsDevice;
blurEffect = effect; // save effect
sizeX = sizey; // save horizontal buffer size
sizeY = sizex; // save verical buffer size
// get effect parameters
paramWorldViewProjection = blurEffect.Parameters["g_WorldViewProj"];
paramColorMap = blurEffect.Parameters["g_ColorMap"];
paramColor = blurEffect.Parameters["g_Color"];
paramPixelSize = blurEffect.Parameters["g_PixelSize"];
pixelSize = new Vector2(1.0f / sizeX, 1.0f / sizeY);
viewProjection = Matrix.CreateOrthographicOffCenter(0.0f, sizeX, 0.0f, sizeY, -1.0f, 1.0f);
// create vertex buffer
vertexBuffer = new VertexBuffer(gd, typeof(VertexPositionTexture),
6, BufferUsage.WriteOnly);
// create vertex declaration
vertexDeclaration =
new VertexDeclaration(VertexPositionTexture.VertexDeclaration.GetVertexElements());
// create vertex data
SetVertexData();
}
/// <summary>
/// Helper for loading and initializing the particle effect.
/// </summary>
void LoadParticleEffect()
{
Effect effect = content.Load <Effect>("ParticleEffect");
// If we have several particle systems, the content manager will return
// a single shared effect instance to them all. But we want to preconfigure
// the effect with parameters that are specific to this particular
// particle system. By cloning the effect, we prevent one particle system
// from stomping over the parameter settings of another.
particleEffect = effect.Clone();
EffectParameterCollection parameters = particleEffect.Parameters;
// Look up shortcuts for parameters that change every frame.
effectViewParameter = parameters["View"];
effectProjectionParameter = parameters["Projection"];
effectViewportScaleParameter = parameters["ViewportScale"];
effectTimeParameter = parameters["CurrentTime"];
// Set the values of parameters that do not change.
parameters["Duration"].SetValue((float)settings.Duration.TotalSeconds);
parameters["DurationRandomness"].SetValue(settings.DurationRandomness);
parameters["Gravity"].SetValue(settings.Gravity);
parameters["EndVelocity"].SetValue(settings.EndVelocity);
parameters["MinColor"].SetValue(settings.MinColor.ToVector4());
parameters["MaxColor"].SetValue(settings.MaxColor.ToVector4());
parameters["RotateSpeed"].SetValue(new Vector2(settings.MinRotateSpeed, settings.MaxRotateSpeed));
parameters["StartSize"].SetValue(new Vector2(settings.MinStartSize, settings.MaxStartSize));
parameters["EndSize"].SetValue(new Vector2(settings.MinEndSize, settings.MaxEndSize));
// Load the particle texture, and set it onto the effect.
Texture2D texture = content.Load <Texture2D>(settings.TextureName);
parameters["Texture"].SetValue(texture);
}
private async void AddFloatParameter_OnClick(object sender, RoutedEventArgs e)
{
var id = await WindowManager.ShowInputDialog("New Float Effect Parameter", "float parameter id", "float-id");
if (string.IsNullOrWhiteSpace(id))
{
return;
}
if (_params.ContainsKey(id))
{
NotificationManager.PublishErrorNotification("failed to add parameter, parameter id already exists");
return;
}
var param = new EffectParameter {
Key = id.Replace(" ", "-")
};
param.Json = $@"{{
""id"":""{id}"",
""type"": ""float"",
""initial-value"":0,
""uniform"": ""{param.Uniform}""
}}";
param.Lang = $@"""{id}"": {{
""name"": ""{param.Uniform}"",
""desc"": ""{param.Uniform}""
}}";
param.VariableDeclaration = $"uniform lowp float {param.Uniform};";
_params.Add(id, param);
ParameterListBox.Items.Refresh();
ParameterListBox.SelectedIndex = _params.Count - 1;
AddonManager.CurrentAddon.Effect.Parameters = _params;
}
public WindowsSceneEffect(ContentManager content)
{
_basicEffect = content.Load <Effect>(ResourceNames.Effects.BasicEffect);
PostProcessingEffect = content.Load <Effect>(ResourceNames.Effects.PostProcessing);
_shadowCasterTechnique = _basicEffect.Techniques["ShadowCaster"];
_shadowCasterTransparentTechnique = _basicEffect.Techniques["ShadowCasterTransparent"];
ShadowMapDebugEffect = content.Load <Effect>(ResourceNames.Effects.DebugShadowMap);
_effectsByLightingFlags = new Dictionary <int, EffectTechnique>()
{
{ LightTechniqueFlag.Lit | LightTechniqueFlag.ReceiveShadows, _basicEffect.Techniques["LitNoTextureShadowReceiver"] },
{ LightTechniqueFlag.Lit | LightTechniqueFlag.ReceiveShadows | LightTechniqueFlag.SoftShadows, _basicEffect.Techniques["LitNoTextureShadowReceiverPCF"] },
{ LightTechniqueFlag.Lit | LightTechniqueFlag.UseTexture, _basicEffect.Techniques["Lit"] },
{ LightTechniqueFlag.Lit | LightTechniqueFlag.UseTexture | LightTechniqueFlag.ReceiveShadows, _basicEffect.Techniques["LitShadowReceiver"] },
{ LightTechniqueFlag.Lit | LightTechniqueFlag.UseTexture | LightTechniqueFlag.ReceiveShadows | LightTechniqueFlag.SoftShadows, _basicEffect.Techniques["LitShadowReceiverPCF"] },
{ 0, _basicEffect.Techniques["UnlitNoTexture"] },
{ LightTechniqueFlag.UseTexture, _basicEffect.Techniques["Unlit"] },
{ LightTechniqueFlag.UseTexture | LightTechniqueFlag.LinearTextureSampling, _basicEffect.Techniques["UnlitLinearSampled"] },
};
_lightViewProjection = _basicEffect.Parameters["LightViewProjection"];
_world = _basicEffect.Parameters["World"];
_worldLight = _basicEffect.Parameters["WorldLight"];
_view = _basicEffect.Parameters["View"];
_projection = _basicEffect.Parameters["Projection"];
_lightDirection = _basicEffect.Parameters["LightDirection"];
_shadowMap = _basicEffect.Parameters["ShadowMap"];
_diffuseTexture = _basicEffect.Parameters["DiffuseTexture"];
_texcoordOffset = _basicEffect.Parameters["TexcoordOffset"];
_texcoordScale = _basicEffect.Parameters["TexcoordScale"];
_ambientLight = _basicEffect.Parameters["AmbientLight"];
_ambientIntensity = _basicEffect.Parameters["AmbientIntensity"];
_diffuseIntensity = _basicEffect.Parameters["DiffuseIntensity"];
_shadowScale = _basicEffect.Parameters["ShadowScale"];
_materialColor = _basicEffect.Parameters["MaterialColor"];
}
/// <summary>
/// Draws several copies of a piece of geometry without using any
/// special GPU instancing techniques at all. This just does a
/// regular loop and issues several draw calls one after another.
/// </summary>
void DrawModelNoInstancing(Model model, Matrix[] modelBones,
Matrix[] instances, Matrix view, Matrix projection)
{
foreach (ModelMesh mesh in model.Meshes)
{
foreach (ModelMeshPart meshPart in mesh.MeshParts)
{
GraphicsDevice.SetVertexBuffer(meshPart.VertexBuffer, meshPart.VertexOffset);
GraphicsDevice.Indices = meshPart.IndexBuffer;
// Set up the rendering effect.
Effect effect = meshPart.Effect;
effect.CurrentTechnique = effect.Techniques["NoInstancing"];
effect.Parameters["View"].SetValue(view);
effect.Parameters["Projection"].SetValue(projection);
EffectParameter transformParameter = effect.Parameters["World"];
// Draw a single instance copy each time around this loop.
for (int i = 0; i < instances.Length; i++)
{
transformParameter.SetValue(modelBones[mesh.ParentBone.Index] * instances[i]);
foreach (EffectPass pass in effect.CurrentTechnique.Passes)
{
pass.Apply();
GraphicsDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0,
meshPart.NumVertices, meshPart.StartIndex,
meshPart.PrimitiveCount);
}
}
}
}
}
private void ExtractParameters()
{
_worldParameter = _effect.Parameters["World"];
_viewParameter = _effect.Parameters["View"];
_projectionParameter = _effect.Parameters["Projection"];
_worldViewParameter = _effect.Parameters["WorldView"];
_worldViewProjectionParameter = _effect.Parameters["WorldViewProjection"];
_textureMatrixParameter = _effect.Parameters["TextureMatrix"];
_lightViewProjParameter = _effect.Parameters["LightViewProj"];
_farClipParameter = _effect.Parameters["FarClip"];
_lightBufferPixelSizeParameter = _effect.Parameters["LightBufferPixelSize"];
_bonesParameter = _effect.Parameters["Bones"];
_normalBufferParameter = _effect.Parameters["NormalBuffer"];
_lightBufferParameter = _effect.Parameters["LightBuffer"];
_lightSpecularBufferParameter = _effect.Parameters["LightSpecularBuffer"];
_depthBufferParameter = _effect.Parameters["DepthBuffer"];
_colorBufferParameter = _effect.Parameters["ColorBuffer"];
_ambientParameter = _effect.Parameters["AmbientColor"];
_ambientCubemapParameter = _effect.Parameters["AmbientCubeMap"];
_totalTimeParameter = _effect.Parameters["TotalTime"];
_diffuseParameter = _effect.Parameters["DiffuseMap"];
if (_diffuseParameter == null)
{
_diffuseParameter = _effect.Parameters["Diffuse"];
}
if (_textureMatrixParameter != null)
{
_textureMatrixParameter.SetValue(Matrix.Identity);
}
}
public LensFlareRenderer(IGraphicsService graphicsService)
{
if (graphicsService == null)
throw new ArgumentNullException("graphicsService");
Order = 4;
var graphicsDevice = graphicsService.GraphicsDevice;
_basicEffect = new BasicEffect(graphicsDevice)
{
FogEnabled = false,
LightingEnabled = false,
TextureEnabled = false,
VertexColorEnabled = true,
};
_queryGeometry = new VertexPositionColor[4];
_spriteBatch = graphicsService.GetSpriteBatch();
if (graphicsDevice.GraphicsProfile == GraphicsProfile.HiDef)
{
// Use custom effect with sRGB reads in pixel shader.
try
{
_effect = graphicsService.Content.Load<Effect>("DigitalRune/SpriteEffect");
_transformParameter = _effect.Parameters["Transform"];
_techniqueLinear = _effect.Techniques["Sprite"];
_techniqueGamma = _effect.Techniques["SpriteWithGamma"];
}
catch (ContentLoadException)
{
// If we cannot load the HiDef effect, fall back to Reach. This happens in the Linux
// build when it runs in Windows.
_effect = null;
}
}
}
/// <summary>
/// Example 1.3
/// This function obtains EffectParameter objects from the Effect objects.
/// The EffectParameters are handles to the values in the shaders and are
/// effectively how your C# code and your shader code communicate.
/// </summary>
private void GetEffectParameters()
{
//These parameters are used by both vertexLightingEffect and
//noLightingEffect, so we must take care to look up the correct ones.
if (enableAdvancedEffect)
{
worldParameter = vertexLightingEffect.Parameters["world"];
viewParameter = vertexLightingEffect.Parameters["view"];
projectionParameter = vertexLightingEffect.Parameters["projection"];
}
else
{
worldParameter = noLightingEffect.Parameters["world"];
viewParameter = noLightingEffect.Parameters["view"];
projectionParameter = noLightingEffect.Parameters["projection"];
}
//These effect parameters are only used by vertexLightingEffect
//to indicate the lights' colors and direction
lightColorParameter = vertexLightingEffect.Parameters["lightColor"];
lightDirectionParameter = vertexLightingEffect.Parameters["lightDirection"];
ambientColorParameter = vertexLightingEffect.Parameters["ambientColor"];
}
public WaterReflectionEffect() : base()
{
CurrentTechnique = Techniques["WaterReflectionTechnique"];
_timeParam = Parameters["_time"];
_sparkleIntensityParam = Parameters["_sparkleIntensity"];
_sparkleColorParam = Parameters["_sparkleColor"];
_screenSpaceVerticalOffsetParam = Parameters["_screenSpaceVerticalOffset"];
_perspectiveCorrectionIntensityParam = Parameters["_perspectiveCorrectionIntensity"];
_firstDisplacementSpeedParam = Parameters["_firstDisplacementSpeed"];
_secondDisplacementSpeedParam = Parameters["_secondDisplacementSpeed"];
_secondDisplacementScaleParam = Parameters["_secondDisplacementScale"];
_sparkleIntensityParam.SetValue(_sparkleIntensity);
_sparkleColorParam.SetValue(Vector3.One);
_perspectiveCorrectionIntensityParam.SetValue(_perspectiveCorrectionIntensity);
FirstDisplacementSpeed = _firstDisplacementSpeed;
SecondDisplacementSpeed = _secondDisplacementSpeed;
_secondDisplacementScaleParam.SetValue(_secondDisplacementScale);
// override some defaults from the ReflectionEffect
ReflectionIntensity = _reflectionIntensity;
NormalMagnitude = _normalMagnitude;
}
protected override void PrepareParams()
{
base.PrepareParams();
//fixed parameters
pProjection = Parameters["Projection"];
pTileSize = Parameters["TileSize"];
//change between rendering light passes
pRoomTarget = Parameters["RoomTarget"];
pRoomUVRescale = Parameters["RoomUVRescale"];
pRoomUVOff = Parameters["RoomUVOff"];
pLightPosition = Parameters["LightPosition"];
pLightColor = Parameters["LightColor"];
pLightSize = Parameters["LightSize"];
pLightPower = Parameters["LightPower"];
pLightIntensity = Parameters["LightIntensity"];
pTargetRoom = Parameters["TargetRoom"];
pBlurMax = Parameters["BlurMax"];
pBlurMin = Parameters["BlurMin"];
pMapLayout = Parameters["MapLayout"];
pUVBase = Parameters["UVBase"];
pLightDirection = Parameters["LightDirection"];
pLightHeight = Parameters["LightHeight"];
pShadowPowers = Parameters["ShadowPowers"];
pSSAASize = Parameters["SSAASize"];
pIsOutdoors = Parameters["IsOutdoors"];
proomMap = Parameters["roomMap"];
pshadowMap = Parameters["shadowMap"];
pfloorShadowMap = Parameters["floorShadowMap"];
}
public override void Initialize()
{
base.Initialize();
part = GameContainer.Content.Load <Model>("Content\\Models\\Player_Part");
tail = GameContainer.Content.Load <Model>("Content\\Models\\Player_Tail");
tailTransforms = new Matrix[tail.Bones.Count];
tail.CopyAbsoluteBoneTransformsTo(tailTransforms);
velvety = GameContainer.Content.Load <Effect>("Content\\Effects\\Velvety");
fxWorldInvertedTranspose = velvety.Parameters["WorldITXf"];
fxWvp = velvety.Parameters["WvpXf"];
fxWorld = velvety.Parameters["WorldXf"];
fxViewInverted = velvety.Parameters["ViewIXf"];
fxSubColor = velvety.Parameters["SubColor"];
fxDiffColor = velvety.Parameters["DiffColor"];
fxSpecColor = velvety.Parameters["SpecColor"];
for (int i = 0; i < part.Meshes.Count; i++)
{
for (int j = 0; j < part.Meshes[i].MeshParts.Count; j++)
{
part.Meshes[i].MeshParts[j].Effect = velvety;
}
}
for (int i = 0; i < tail.Meshes.Count; i++)
{
for (int j = 0; j < tail.Meshes[i].MeshParts.Count; j++)
{
tail.Meshes[i].MeshParts[j].Effect = velvety;
}
}
}
/// <summary>
/// Get parameters, override to support more
/// </summary>
protected virtual void GetParameters()
{
worldViewProj = effect.Parameters["worldViewProj"];
viewProj = effect.Parameters["viewProj"];
world = effect.Parameters["world"];
viewInverse = effect.Parameters["viewInverse"];
projection = effect.Parameters["projection"];
lightDir = effect.Parameters["lightDir"];
ambientColor = effect.Parameters["ambientColor"];
diffuseColor = effect.Parameters["diffuseColor"];
specularColor = effect.Parameters["specularColor"];
specularPower = effect.Parameters["specularPower"];
alphaFactor = effect.Parameters["alphaFactor"];
// Default alpha factor to 1.0f for hotels and stuff
AlphaFactor = 1.0f;
scale = effect.Parameters["scale"];
diffuseTexture = effect.Parameters["diffuseTexture"];
normalTexture = effect.Parameters["normalTexture"];
heightTexture = effect.Parameters["heightTexture"];
reflectionCubeTexture = effect.Parameters["reflectionCubeTexture"];
detailTexture = effect.Parameters["detailTexture"];
parallaxAmount = effect.Parameters["parallaxAmount"];
carHueColorChange = effect.Parameters["carHueColorChange"];
}
public VisionEffect(Effect effect, SamplerState samplerState = null)
{
GraphicsDevice = effect.GraphicsDevice;
Effect = effect;
Name = effect.Name;
_epTextureSampler = effect.Parameters["TextureSampler"];
if(_epTextureSampler!=null)
Sampler = samplerState ?? GraphicsDevice.SamplerStates.LinearWrap;
_epWorld = effect.Parameters["World"];
_epWorldInverseTranspose = effect.Parameters["WorldInverseTranspose"];
_epView = effect.Parameters["View"];
_epProjection = effect.Parameters["Projection"];
_epCameraPosition = effect.Parameters["CameraPosition"];
_epClipPlane = effect.Parameters["ClipPlane"];
_epSunlightDirection = effect.Parameters["SunlightDirection"];
_epTexture = effect.Parameters["Texture"];
_epDiffuseColor = effect.Parameters["DiffuseColor"];
_epDoShadowMapping = effect.Parameters["DoShadowMapping"];
_epShadowMap = effect.Parameters["ShadowMap"];
_epShadowViewProjection = effect.Parameters["ShadowViewProjection"];
_epShadowFarPlane = effect.Parameters["ShadowFarPlane"];
_epShadowMult = effect.Parameters["ShadowMult"];
_techStandard = effect.Techniques["TechStandard"];
_techClipPlane = effect.Techniques["TechClipPlane"];
_techDepthMap = effect.Techniques["TechDepthMap"];
//Debug.Assert( _epView != null );
//Debug.Assert(_techDepthMap != null);
if ( _epSunlightDirection != null)
_epSunlightDirection.SetValue(VisionContent.SunlightDirection);
}
public int effectDispel(SkillParameter skillParameter, EffectParameter effectParameter)
{
UnitCtl curUnit = War.scene.GetUnitForUID(effectParameter.curBuildUid);
if (curUnit == null)
{
return(-1);
}
if (effectParameter.effect.animPathStart != "temp")
{
GameObject effectPrefab = WarRes.GetPrefab(effectParameter.effect.animPathStart.ToLower());
GameObject effectAnim = GameObject.Instantiate <GameObject>(effectPrefab);
effectAnim.transform.position = curUnit.transform.position;
}
if (effectParameter.unitCtlList.Count <= 1)
{
Debug.Log("==============unitctllist count < 1");
return(-1);
}
War.skillWarManager.StartCoroutine(effectDispelEnd(skillParameter, effectParameter));
return(0);
}
protected override void Initialize()
{
textureParam = Parameters["Texture"];
samplerParam = Parameters["TextureSampler"];
diffuseColorParam = Parameters["DiffuseColor"];
emissiveColorParam = Parameters["EmissiveColor"];
specularColorParam = Parameters["SpecularColor"];
specularPowerParam = Parameters["SpecularPower"];
eyePositionParam = Parameters["EyePosition"];
fogColorParam = Parameters["FogColor"];
fogVectorParam = Parameters["FogVector"];
worldParam = Parameters["World"];
worldInverseTransposeParam = Parameters["WorldInverseTranspose"];
worldViewProjParam = Parameters["WorldViewProj"];
light0 = new DirectionalLight(Parameters["DirLight0Direction"],
Parameters["DirLight0DiffuseColor"],
Parameters["DirLight0SpecularColor"], null);
light1 = new DirectionalLight(Parameters["DirLight1Direction"],
Parameters["DirLight1DiffuseColor"],
Parameters["DirLight1SpecularColor"], null);
light2 = new DirectionalLight(Parameters["DirLight2Direction"],
Parameters["DirLight2DiffuseColor"],
Parameters["DirLight2SpecularColor"], null);
samplerParam.SetResource(GraphicsDevice.SamplerStates.Default);
}
protected override void Initialize()
{
base.Initialize();
if (this.Parameters.Contains("blockSampler"))
this.Parameters["blockSampler"].SetResource(this.GraphicsDevice.SamplerStates.LinearClamp);
m_perObConstBuf = this.ConstantBuffers["PerObjectBuffer"];
m_objectWorldMatrixParam = m_perObConstBuf.Parameters["g_chunkOffset"];
CreateGameColorBuffer();
}
/// <summary>
/// Looks up shortcut references to our effect parameters.
/// </summary>
void CacheEffectParameters()
{
matrixParam = Parameters["MatrixTransform"];
}
public ConstantBufferLink(EffectConstantBuffer constantBuffer, EffectParameter parameter)
{
ConstantBuffer = constantBuffer;
Parameter = parameter;
ResourceIndex = 0;
}
/// <summary>
/// Looks up shortcut references to our effect parameters.
/// </summary>
void CacheEffectParameters()
{
textureParam = Parameters["Texture"];
diffuseColorParam = Parameters["DiffuseColor"];
alphaTestParam = Parameters["AlphaTest"];
fogColorParam = Parameters["FogColor"];
fogVectorParam = Parameters["FogVector"];
worldViewProjParam = Parameters["WorldViewProj"];
shaderIndexParam = Parameters["ShaderIndex"];
}
protected override void Initialize()
{
textureParam = Parameters["Texture"];
diffuseColorParam = Parameters["DiffuseColor"];
alphaTestParam = Parameters["AlphaTest"];
fogColorParam = Parameters["FogColor"];
fogVectorParam = Parameters["FogVector"];
worldViewProjParam = Parameters["WorldViewProj"];
}
/// <summary>
/// Looks up shortcut references to our effect parameters.
/// </summary>
void CacheEffectParameters(EnvironmentMapEffect cloneSource)
{
textureParam = Parameters["Texture"];
environmentMapParam = Parameters["EnvironmentMap"];
environmentMapAmountParam = Parameters["EnvironmentMapAmount"];
environmentMapSpecularParam = Parameters["EnvironmentMapSpecular"];
fresnelFactorParam = Parameters["FresnelFactor"];
diffuseColorParam = Parameters["DiffuseColor"];
emissiveColorParam = Parameters["EmissiveColor"];
eyePositionParam = Parameters["EyePosition"];
fogColorParam = Parameters["FogColor"];
fogVectorParam = Parameters["FogVector"];
worldParam = Parameters["World"];
worldInverseTransposeParam = Parameters["WorldInverseTranspose"];
worldViewProjParam = Parameters["WorldViewProj"];
light0 = new DirectionalLight(Parameters["DirLight0Direction"],
Parameters["DirLight0DiffuseColor"],
null,
(cloneSource != null) ? cloneSource.light0 : null);
light1 = new DirectionalLight(Parameters["DirLight1Direction"],
Parameters["DirLight1DiffuseColor"],
null,
(cloneSource != null) ? cloneSource.light1 : null);
light2 = new DirectionalLight(Parameters["DirLight2Direction"],
Parameters["DirLight2DiffuseColor"],
null,
(cloneSource != null) ? cloneSource.light2 : null);
}
/// <summary>
/// Looks up shortcut references to our effect parameters.
/// </summary>
void CacheEffectParameters(BasicEffect cloneSource)
{
textureParam = Parameters["Texture"];
diffuseColorParam = Parameters["DiffuseColor"];
emissiveColorParam = Parameters["EmissiveColor"];
specularColorParam = Parameters["SpecularColor"];
specularPowerParam = Parameters["SpecularPower"];
eyePositionParam = Parameters["EyePosition"];
fogColorParam = Parameters["FogColor"];
fogVectorParam = Parameters["FogVector"];
worldParam = Parameters["World"];
worldInverseTransposeParam = Parameters["WorldInverseTranspose"];
worldViewProjParam = Parameters["WorldViewProj"];
shaderIndexParam = Parameters["ShaderIndex"];
light0 = new DirectionalLight(Parameters["DirLight0Direction"],
Parameters["DirLight0DiffuseColor"],
Parameters["DirLight0SpecularColor"],
(cloneSource != null) ? cloneSource.light0 : null);
light1 = new DirectionalLight(Parameters["DirLight1Direction"],
Parameters["DirLight1DiffuseColor"],
Parameters["DirLight1SpecularColor"],
(cloneSource != null) ? cloneSource.light1 : null);
light2 = new DirectionalLight(Parameters["DirLight2Direction"],
Parameters["DirLight2DiffuseColor"],
Parameters["DirLight2SpecularColor"],
(cloneSource != null) ? cloneSource.light2 : null);
}
public ParameterBinding(EffectParameter parameter, int slot)
{
Parameter = parameter;
Slot = slot;
}
///// <summary>
///// Creates a new DualTextureEffect by cloning parameter settings from an existing instance.
///// </summary>
//protected DualTextureEffect(DualTextureEffect cloneSource)
// : base(cloneSource)
//{
// CacheEffectParameters();
// fogEnabled = cloneSource.fogEnabled;
// vertexColorEnabled = cloneSource.vertexColorEnabled;
// world = cloneSource.world;
// view = cloneSource.view;
// projection = cloneSource.projection;
// diffuseColor = cloneSource.diffuseColor;
// alpha = cloneSource.alpha;
// fogStart = cloneSource.fogStart;
// fogEnd = cloneSource.fogEnd;
//}
///// <summary>
///// Creates a clone of the current DualTextureEffect instance.
///// </summary>
//public override Effect Clone()
//{
// return new DualTextureEffect(this);
//}
/// <summary>
/// Looks up shortcut references to our effect parameters.
/// </summary>
void CacheEffectParameters()
{
textureParam = Parameters["Texture"];
texture2Param = Parameters["Texture2"];
diffuseColorParam = Parameters["DiffuseColor"];
fogColorParam = Parameters["FogColor"];
fogVectorParam = Parameters["FogVector"];
worldViewProjParam = Parameters["WorldViewProj"];
}
protected override void Initialize()
{
textureParam = Parameters["Texture"];
diffuseColorParam = Parameters["DiffuseColor"];
emissiveColorParam = Parameters["EmissiveColor"];
specularColorParam = Parameters["SpecularColor"];
specularPowerParam = Parameters["SpecularPower"];
eyePositionParam = Parameters["EyePosition"];
fogColorParam = Parameters["FogColor"];
fogVectorParam = Parameters["FogVector"];
worldParam = Parameters["World"];
worldInverseTransposeParam = Parameters["WorldInverseTranspose"];
worldViewProjParam = Parameters["WorldViewProj"];
bonesParam = Parameters["Bones"];
light0 = new DirectionalLight(Parameters["DirLight0Direction"],
Parameters["DirLight0DiffuseColor"],
Parameters["DirLight0SpecularColor"],
null);
light1 = new DirectionalLight(Parameters["DirLight1Direction"],
Parameters["DirLight1DiffuseColor"],
Parameters["DirLight1SpecularColor"],
null);
light2 = new DirectionalLight(Parameters["DirLight2Direction"],
Parameters["DirLight2DiffuseColor"],
Parameters["DirLight2SpecularColor"],
null);
}
private void buildFx(InitInfo initInfo)
{
var p = Effect.Effect.Parameters;
p["MirrorSampler"].SetResource(Effect.GraphicsDevice.SamplerStates.PointMirror);
_mhWorldInv = p["WorldInv"];
_mhCameraPosition = p["CameraPosition"];
_mhWaveBumpMapOffset0 = p["WaveNMapOffset0"];
_mhWaveBumpMapOffset1 = p["WaveNMapOffset1"];
_mhWaveDispMapOffset0 = p["WaveDMapOffset0"];
_mhWaveDispMapOffset1 = p["WaveDMapOffset1"];
_reflectedView = p["ReflectedView"];
_reflectedMap = p["ReflectedMap"];
p["BumpMap0"].SetResource(initInfo.waveMap0);
p["BumpMap1"].SetResource(initInfo.waveMap1);
p["WaveDispMap0"].SetResource(initInfo.dmap0);
p["WaveDispMap1"].SetResource(initInfo.dmap1);
p["ScaleHeights"].SetValue(initInfo.scaleHeights);
p["GridStepSizeL"].SetValue(new Vector2(initInfo.dx, initInfo.dz));
p["WaveHeight"].SetValue(0.3f * 2);
}
/// <summary>
/// Sets a vector which can be dotted with the object space vertex position to compute fog amount.
/// </summary>
static void SetFogVector(ref Matrix worldView, float fogStart, float fogEnd, EffectParameter fogVectorParam)
{
if (fogStart == fogEnd)
{
// Degenerate case: force everything to 100% fogged if start and end are the same.
fogVectorParam.SetValue(new Vector4(0, 0, 0, 1));
}
else
{
// We want to transform vertex positions into view space, take the resulting
// Z value, then scale and offset according to the fog start/end distances.
// Because we only care about the Z component, the shader can do all this
// with a single dot product, using only the Z row of the world+view matrix.
float scale = 1f / (fogStart - fogEnd);
var fogVector = new Vector4(worldView.M13 * scale, worldView.M23 * scale, worldView.M33 * scale, (worldView.M43 + fogStart) * scale);
fogVectorParam.SetValue(fogVector);
}
}
/// <summary>
/// Initializes the stage block.
/// </summary>
/// <param name="stageBlock">The stage block.</param>
/// <param name="logger">The logger.</param>
private void InitStageBlock(StageBlock stageBlock, Logger logger)
{
// If null shader, then skip init
if (stageBlock.Index < 0)
{
return;
}
stageBlock.Shader = Effect.Pool.GetOrCompileShader(stageBlock.Type, stageBlock.Index);
var shaderRaw = Effect.Pool.EffectData.Shaders[stageBlock.Index];
// Cache the input signature
if (shaderRaw.Type == EffectShaderType.Vertex)
{
inputSignatureManager = graphicsDevice.GetOrCreateInputSignatureManager(shaderRaw.InputSignature.Bytecode, shaderRaw.InputSignature.Hashcode);
}
for (int i = 0; i < shaderRaw.ConstantBuffers.Count; i++)
{
var constantBufferRaw = shaderRaw.ConstantBuffers[i];
// Constant buffers with a null size are skipped
if (constantBufferRaw.Size == 0)
continue;
var constantBuffer = Effect.GetOrCreateConstantBuffer(Effect.GraphicsDevice, constantBufferRaw);
// IF constant buffer is null, it means that there is a conflict
if (constantBuffer == null)
{
logger.Error("Constant buffer [{0}] cannot have multiple size or different content declaration inside the same effect pool", constantBufferRaw.Name);
continue;
}
// Test if this constant buffer is not already part of the effect
if (Effect.ConstantBuffers[constantBufferRaw.Name] == null)
{
// Add the declared constant buffer to the effect shader.
Effect.ConstantBuffers.Add(constantBuffer);
// Declare all parameter from constant buffer at the effect level.
foreach (var parameter in constantBuffer.Parameters)
{
var previousParameter = Effect.Parameters[parameter.Name];
if (previousParameter == null)
{
// Add an effect parameter linked to the approriate constant buffer at the effect level.
Effect.Parameters.Add(new EffectParameter((EffectData.ValueTypeParameter) parameter.ParameterDescription, constantBuffer));
}
else if (parameter.ParameterDescription != previousParameter.ParameterDescription || parameter.buffer != previousParameter.buffer)
{
// If registered parameters is different
logger.Error("Parameter [{0}] defined in Constant buffer [{0}] is already defined by another constant buffer with the definition [{2}]", parameter, constantBuffer.Name, previousParameter);
}
}
}
}
var constantBufferLinks = new List<ConstantBufferLink>();
// Declare all resource parameters at the effect level.
foreach (var parameterRaw in shaderRaw.ResourceParameters)
{
EffectParameter parameter;
var previousParameter = Effect.Parameters[parameterRaw.Name];
// Skip enmpty constant buffers.
if (parameterRaw.Type == EffectParameterType.ConstantBuffer && Effect.ConstantBuffers[parameterRaw.Name] == null)
{
continue;
}
int resourceIndex = Effect.ResourceLinker.Count;
if (previousParameter == null)
{
parameter = new EffectParameter(parameterRaw, EffectResourceTypeHelper.ConvertFromParameterType(parameterRaw.Type), Effect.ResourceLinker.Count, Effect.ResourceLinker);
Effect.Parameters.Add(parameter);
Effect.ResourceLinker.Count += parameterRaw.Count;
}
else
{
resourceIndex = ((EffectData.ResourceParameter) previousParameter.ParameterDescription).Slot;
if (CompareResourceParameter(parameterRaw, (EffectData.ResourceParameter) previousParameter.ParameterDescription))
{
// If registered parameters is different
logger.Error("Resource Parameter [{0}] is already defined with a different definition [{1}]", parameterRaw, previousParameter.ParameterDescription);
}
parameter = previousParameter;
}
// For constant buffers, we need to store explicit link
if (parameter.ResourceType == EffectResourceType.ConstantBuffer)
{
constantBufferLinks.Add(new ConstantBufferLink(Effect.ConstantBuffers[parameter.Name], parameter));
}
if (stageBlock.Parameters == null)
{
stageBlock.Parameters = new List<EffectParameter>();
}
stageBlock.Parameters.Add(parameter);
}
stageBlock.ConstantBufferLinks = constantBufferLinks.ToArray();
}
/// <summary>
/// Sets the diffuse/emissive/alpha material color parameters.
/// </summary>
internal static void SetMaterialColor(bool lightingEnabled, float alpha,
ref Vector4 diffuseColor, ref Vector3 emissiveColor, ref Vector3 ambientLightColor,
EffectParameter diffuseColorParam, EffectParameter emissiveColorParam)
{
// Desired lighting model:
//
// ((AmbientLightColor + sum(diffuse directional light)) * DiffuseColor) + EmissiveColor
//
// When lighting is disabled, ambient and directional lights are ignored, leaving:
//
// DiffuseColor + EmissiveColor
//
// For the lighting disabled case, we can save one shader instruction by precomputing
// diffuse+emissive on the CPU, after which the shader can use DiffuseColor directly,
// ignoring its emissive parameter.
//
// When lighting is enabled, we can merge the ambient and emissive settings. If we
// set our emissive parameter to emissive+(ambient*diffuse), the shader no longer
// needs to bother adding the ambient contribution, simplifying its computation to:
//
// (sum(diffuse directional light) * DiffuseColor) + EmissiveColor
//
// For further optimization goodness, we merge material alpha with the diffuse
// color parameter, and premultiply all color values by this alpha.
if (lightingEnabled)
{
var diffuse = new Vector4(diffuseColor.X * alpha, diffuseColor.Y * alpha, diffuseColor.Z * alpha, alpha);
var emissive = new Vector3(
(emissiveColor.X + ambientLightColor.X * diffuseColor.X) * alpha,
(emissiveColor.Y + ambientLightColor.Y * diffuseColor.Y) * alpha,
(emissiveColor.Z + ambientLightColor.Z * diffuseColor.Z) * alpha
);
diffuseColorParam.SetValue(diffuse);
emissiveColorParam.SetValue(emissive);
}
else
{
var diffuse = new Vector4((diffuseColor.X + emissiveColor.X) * alpha, (diffuseColor.Y + emissiveColor.Y) * alpha, (diffuseColor.Z + emissiveColor.Z) * alpha, alpha);
diffuseColorParam.SetValue(diffuse);
}
}
