} // end of UIGridModularMenu RefreshTexture() public void Render(Camera camera) { try { ShaderGlobals.SetValues(effect); ShaderGlobals.SetCamera(effect, camera); effect.CurrentTechnique = effect.Techniques["NormalMappedWithEnv"]; effect.Parameters["DiffuseTexture"].SetValue(diffuse); effect.Parameters["WorldMatrix"].SetValue(worldMatrix); effect.Parameters["WorldViewProjMatrix"].SetValue(worldMatrix * camera.ViewProjectionMatrix); effect.Parameters["Alpha"].SetValue(1.0f); effect.Parameters["DiffuseColor"].SetValue(new Vector4(1, 1, 1, 1)); effect.Parameters["SpecularColor"].SetValue(specularColor); effect.Parameters["SpecularPower"].SetValue(specularPower); effect.Parameters["NormalMap"].SetValue(normalMap); geometry.Render(effect); } catch { // This Try/Catch is here since the first frame back from a device reset // the call to diffuse fails saying that the rendertarget is // still set on the device. As far as I can tell it's not but I still // can't win the argument. } } // end of UIGridModularMenu Render()
} // end of UIGridTextListElement SetValue() public override void LoadContent(bool immediate) { // Init the effect. if (effect == null) { effect = BokuGame.Load <Effect>(BokuGame.Settings.MediaPath + @"Shaders\UI2D"); ShaderGlobals.RegisterEffect("UI2D", effect); } // Load the check textures. if (checkbox == null) { checkbox = BokuGame.Load <Texture2D>(BokuGame.Settings.MediaPath + @"Textures\UI2D\WhiteCheckBox"); } if (checkmark == null) { checkmark = BokuGame.Load <Texture2D>(BokuGame.Settings.MediaPath + @"Textures\UI2D\WhiteCheck"); } // Load the normal map texture. if (normalMapName != null) { normalMap = BokuGame.Load <Texture2D>(BokuGame.Settings.MediaPath + @"Textures\UI2D\" + normalMapName); } }
public void LoadContent(bool immediate) { contentLoaded = true; // Init the effect. if (effect == null) { effect = BokuGame.Load <Effect>(BokuGame.Settings.MediaPath + @"Shaders\UI2D"); ShaderGlobals.RegisterEffect("UI2D", effect); } // Load the textures. if (whiteTop == null) { whiteTop = BokuGame.Load <Texture2D>(BokuGame.Settings.MediaPath + @"Textures\GridElements\WhiteTop"); } if (whiteHighlight == null) { whiteHighlight = BokuGame.Load <Texture2D>(BokuGame.Settings.MediaPath + @"Textures\GridElements\WhiteHighlight"); } if (blackHighlight == null) { blackHighlight = BokuGame.Load <Texture2D>(BokuGame.Settings.MediaPath + @"Textures\GridElements\BlackHighlight"); } if (greenBar == null) { greenBar = BokuGame.Load <Texture2D>(BokuGame.Settings.MediaPath + @"Textures\GridElements\GreenBar"); } // Load the normal map texture. if (normalMapName != null) { normalMap = BokuGame.Load <Texture2D>(BokuGame.Settings.MediaPath + @"Textures\UI2D\" + normalMapName); } }
} // end of UIGridPictureListElement RefreshTexture() public override void LoadContent(bool immediate) { // Init the effect. if (effect == null) { effect = BokuGame.Load <Effect>(BokuGame.Settings.MediaPath + @"Shaders\UI2D"); ShaderGlobals.RegisterEffect("UI2D", effect); } // Load the normal map texture. if (normalMapName != null) { normalMap = BokuGame.Load <Texture2D>(BokuGame.Settings.MediaPath + @"Textures\UI2D\" + normalMapName); } // Load the arrow textures. if (leftArrow == null) { leftArrow = BokuGame.Load <Texture2D>(BokuGame.Settings.MediaPath + @"Textures\UI2D\WhiteLeftArrow"); } if (rightArrow == null) { rightArrow = BokuGame.Load <Texture2D>(BokuGame.Settings.MediaPath + @"Textures\UI2D\WhiteRightArrow"); } }
public static void Load(GraphicsDevice device) { if (effect == null) { effect = BokuGame.Load <Effect>(BokuGame.Settings.MediaPath + @"Shaders\Ripple"); ShaderGlobals.RegisterEffect("Ripple", effect); effectCache.Load(effect); } if (texture == null) { texture = BokuGame.Load <Texture2D>(BokuGame.Settings.MediaPath + @"Textures\BullsEye1"); } if (verts == null) { verts = new DynamicVertexBuffer(device, typeof(Vertex), kMaxVerts, BufferUsage.WriteOnly); } if (indices == null) { indices = new IndexBuffer(device, typeof(Int16), kMaxIndices, BufferUsage.WriteOnly); Int16[] localIdx = new Int16[kMaxIndices]; for (int i = 0; i < kMaxTiles; ++i) { localIdx[i * 6 + 0] = (short)(i * 4 + 0); localIdx[i * 6 + 1] = (short)(i * 4 + 1); localIdx[i * 6 + 2] = (short)(i * 4 + 2); localIdx[i * 6 + 3] = (short)(i * 4 + 2); localIdx[i * 6 + 4] = (short)(i * 4 + 1); localIdx[i * 6 + 5] = (short)(i * 4 + 3); } indices.SetData <Int16>(localIdx); } }
} // end of UIGrid2DDualTextureElement Render() public override void LoadContent(bool immediate) { // Init the effect. if (effect == null) { effect = BokuGame.Load <Effect>(BokuGame.Settings.MediaPath + @"Shaders\UI2D"); ShaderGlobals.RegisterEffect("UI2D", effect); } // Load the diffuse texture. if (foreTextureName != null) { foreTexture = Boku.Programming.CardSpace.Cards.CardFaceTexture(foreTextureName); } // Load the overlay texture. if (backSelectedTexture == null) { backSelectedTexture = BokuGame.Load <Texture2D>(BokuGame.Settings.MediaPath + @"Textures\HelpCard\GreenSquare"); } if (backUnselectedTexture == null) { backUnselectedTexture = BokuGame.Load <Texture2D>(BokuGame.Settings.MediaPath + @"Textures\HelpCard\GreySquare"); } } // end of UIGrid2DDualTextureElement LoadContent()
/// <summary> /// Render all ghost effects /// </summary> /// <param name="camera"></param> private void RenderGhosts(Camera camera) { if (ghostList.Count > 0) { if (ghostList.Count > 1) { ghostList.Sort(_CompareGhostByDist); } RenderEffect was = renderEffects; renderEffects = RenderEffect.GhostPass; for (int i = 0; i < ghostList.Count; ++i) { float opacity = ghostList[i].Opacity; float glow = ghostList[i].Glow; ShaderGlobals.FixExplicitBloom(glow); ShaderGlobals.FixBloomColor(new Vector4(opacity, opacity, opacity, 1.0f)); ghostList[i].Actor.RenderObject.Render(camera); } ShaderGlobals.ReleaseExplicitBloom(); ShaderGlobals.ReleaseBloomColor(); renderEffects = was; } }
/// <summary> /// Load up anything that doesn't require a device. /// </summary> /// <param name="immediate"></param> public static void LoadContent(bool immediate) { if (effect == null) { effect = BokuGame.Load <Effect>(BokuGame.Settings.MediaPath + @"Shaders\ShowBudget"); ShaderGlobals.RegisterEffect("ShowBudget", effect); effectCache.Load(effect, ""); budgetTechnique = effect.Techniques["ShowBudget"]; glowTechnique = effect.Techniques["BorderGlow"]; } if (background == null) { background = BokuGame.Load <Texture2D>(BokuGame.Settings.MediaPath + @"Textures\BudgetBackground"); } if (mask == null) { mask = BokuGame.Load <Texture2D>(BokuGame.Settings.MediaPath + @"Textures\BudgetMask"); } if (glow == null) { glow = BokuGame.Load <Texture2D>(BokuGame.Settings.MediaPath + @"Textures\BudgetGlow"); } }
} // end of UIGrid2DLEDArray Render() public override void LoadContent(bool immediate) { // Init the effect. if (effect == null) { effect = BokuGame.Load <Effect>(BokuGame.Settings.MediaPath + @"Shaders\UI2D"); ShaderGlobals.RegisterEffect("UI2D", effect); } // Load the normal map texture. if (normalMapName != null) { normalMap = BokuGame.Load <Texture2D>(BokuGame.Settings.MediaPath + @"Textures\UI2D\" + normalMapName); } // Load the diffuse texture. if (diffuseTextureName != null) { diffuse = BokuGame.Load <Texture2D>(BokuGame.Settings.MediaPath + @"Textures\" + diffuseTextureName); } if (white == null) { white = BokuGame.Load <Texture2D>(BokuGame.Settings.MediaPath + @"Textures\White"); } } // end of UIGrid2DLEDArray LoadContent()
/// <summary> /// Sets up all the common stuff needed for rendering. This includes /// setting the technique and any parameters that don't change from /// one batch to the next. /// </summary> public override void PreRender(Camera camera) { if (InGame.inGame.renderEffects == InGame.RenderEffect.Normal) { if (numActiveBleeps > 0) { GraphicsDevice device = BokuGame.bokuGame.GraphicsDevice; effect.CurrentTechnique = effect.Techniques[@"BleepPass"]; // Set up common rendering values. effect.Parameters["CurrentTime"].SetValue((float)Time.GameTimeTotalSeconds); // Set up world matrix. Matrix worldMatrix = Matrix.Identity; Matrix worldViewProjMatrix = worldMatrix * camera.ViewProjectionMatrix; effect.Parameters["DiffuseTexture"].SetValue(texture); effect.Parameters["EyeLocation"].SetValue(new Vector4(camera.ActualFrom, 1.0f)); effect.Parameters["CameraUp"].SetValue(new Vector4(camera.ViewUp, 1.0f)); effect.Parameters["WorldMatrix"].SetValue(worldMatrix); effect.Parameters["WorldViewProjMatrix"].SetValue(worldViewProjMatrix); float radius = 0.2f; float minPix = 3.0f; float maxPix = 6.0f; Vector4 pixelLimit = ShaderGlobals.MakeParticleSizeLimit(radius, minPix, maxPix); effect.Parameters["ParticleRadius"].SetValue(pixelLimit); device.Indices = ibuf; device.SetVertexBuffer(vbuf); } } }
} // end of UIGrid2DTextureElement Render() public override void LoadContent(bool immediate) { // Init the effect. if (effect == null) { effect = BokuGame.Load <Effect>(BokuGame.Settings.MediaPath + @"Shaders\UI2D"); ShaderGlobals.RegisterEffect("UI2D", effect); } // Load the normal map texture. if (normalMapName != null) { normalMap = BokuGame.Load <Texture2D>(BokuGame.Settings.MediaPath + @"Textures\UI2D\" + normalMapName); } // Load the diffuse texture. if (diffuseTextureName != null) { if (CardSpace) { diffuse = Boku.Programming.CardSpace.Cards.CardFaceTexture(diffuseTextureName); } else { diffuse = BokuGame.Load <Texture2D>(BokuGame.Settings.MediaPath + @"Textures\" + diffuseTextureName); } } // Load the overlay texture. if (overlayTextureName != null) { overlayTexture = BokuGame.Load <Texture2D>(BokuGame.Settings.MediaPath + @"Textures\" + overlayTextureName); } } // end of UIGrid2DTextureElement LoadContent()
/// <summary> /// Set all lights' parameters to effect. /// Note this completely clobbers any transitional effects. /// </summary> /// <param name="effect"></param> public void SetToEffect(Effect effect) { if (LightList != null) { for (int i = 0; i < LightList.Length; ++i) { Light light = LightList[i]; Vector3 color = light.Color; float maxChan = Math.Max(color.X, Math.Max(color.Y, color.Z)); lightColors[i] = light.Color; lightDir[i] = new Vector4(light.Direction, maxChan); string dirParam = "LightDirection" + i.ToString(); if (effect.Parameters[dirParam] != null) { effect.Parameters[dirParam].SetValue(new Vector4(light.Direction, maxChan)); } string colorParam = "LightColor" + i.ToString(); if (effect.Parameters[colorParam] != null) { effect.Parameters[colorParam].SetValue(light.Color); } } lightWrap = Wrap; Parameter(EffectParams.Wrap).SetValue(ShaderGlobals.MakeWrapVec(Wrap)); } }
} // end of UIGridModularButtonElement Render() public override void LoadContent(bool immediate) { // Init the effect. if (effect == null) { effect = BokuGame.Load <Effect>(BokuGame.Settings.MediaPath + @"Shaders\UI2D"); ShaderGlobals.RegisterEffect("UI2D", effect); } // Load the normal map texture. if (normalMapName != null) { normalMap = BokuGame.Load <Texture2D>(BokuGame.Settings.MediaPath + @"Textures\UI2D\" + normalMapName); } // Load the check textures. if (checkboxWhite == null) { checkboxWhite = BokuGame.Load <Texture2D>(BokuGame.Settings.MediaPath + @"Textures\GridElements\CheckboxWhite"); } if (blackSquare == null) { blackSquare = BokuGame.Load <Texture2D>(BokuGame.Settings.MediaPath + @"Textures\GridElements\BlackSquare"); } } // end of UIGridModularButtonElement LoadContent()
public override void LoadContent(bool immediate) { // Init the effect. if (effect == null) { effect = BokuGame.Load <Effect>(BokuGame.Settings.MediaPath + @"Shaders\UI2D"); ShaderGlobals.RegisterEffect("UI2D", effect); } // Load the normal map texture. if (normalMapName != null) { normalMap = BokuGame.Load <Texture2D>(BokuGame.Settings.MediaPath + @"Textures\UI2D\" + normalMapName); } // Load the textures. if (sliderWhite == null) { sliderWhite = BokuGame.Load <Texture2D>(BokuGame.Settings.MediaPath + @"Textures\GridElements\SliderWhite"); } if (sliderBlack == null) { sliderBlack = BokuGame.Load <Texture2D>(BokuGame.Settings.MediaPath + @"Textures\GridElements\SliderBlack"); } if (sliderBeadEnd == null) { sliderBeadEnd = BokuGame.Load <Texture2D>(BokuGame.Settings.MediaPath + @"Textures\GridElements\SliderBeadEnd"); } if (sliderBeadMiddle == null) { sliderBeadMiddle = BokuGame.Load <Texture2D>(BokuGame.Settings.MediaPath + @"Textures\GridElements\SliderBeadMiddle"); } } // end of UIGridBaseModularSliderElement LoadContent()
public void ExecuteRow( Vector2 screenUV, Vector2 objUV, int cols, float screenUVdx, float objUVdx, Color[] backbuffer, int backbufferOffset, ref Texture texture, ref ShaderGlobals globals) { int texY = Shaders.SampleTextureY(texture, objUV); float darkXfac = -0.5f + globals.CosTime1000 * 0.1f; screenUV.x += darkXfac; float darkY = screenUV.y - 0.5f + globals.CosTime600 * 0.1f; float darkY2 = darkY * darkY; float darkFac = 1.0f - 4.0f * darkY2; uint ditherOffset = (uint)(backbufferOffset + (int)globals.Time); for (int x = 0; x < cols; ++x, screenUV.x += screenUVdx, objUV.x += objUVdx, backbufferOffset++, ++ditherOffset) { Color result = new Color(0xFF000000); float darkX = screenUV.x; float dark = darkFac - 4f * darkX * darkX; if (dark > 0.0f) { result = Shaders.SampleTextureX(texture, texY, objUV); uint darkI = (uint)(dark * 255.0f); result.Scale(darkI); result = Shaders.Dither(result, ditherOffset); } backbuffer[backbufferOffset] = result; } }
/// <summary> /// Set our envmap as current, render, then restore. /// </summary> public override void Render(Camera camera, ref Matrix rootToWorld, List <List <PartInfo> > listPartsReplacement) { ShaderGlobals.PushEnvMap(RoverGreeter.EnvMap); base.Render(camera, ref rootToWorld, listPartsReplacement); ShaderGlobals.PopEnvMap(); }
internal static void LoadContent(bool immediate) { if (effect == null) { effect = BokuGame.Load <Effect>(BokuGame.Settings.MediaPath + @"Shaders\ScoreEffect"); ShaderGlobals.RegisterEffect("ScoreEffect", effect); } }
} // end of UtilsVertex public static void Init(GraphicsDevice device) { // Init the effect. effect = BokuGame.Load <Effect>(BokuGame.Settings.MediaPath + @"Shaders\Utils"); ShaderGlobals.RegisterEffect("Utils", effect); ramps = BokuGame.Load <Texture2D>(BokuGame.Settings.MediaPath + @"Textures\Ramps"); white = BokuGame.Load <Texture2D>(BokuGame.Settings.MediaPath + @"Textures\White"); } // end of Utils Init()
public void LoadContent(bool immediate) { // Init the effect. Doesn't really matter which one, just // has to be one that uses the same shared parameters. if (effect == null) { effect = BokuGame.Load <Effect>(BokuGame.Settings.MediaPath + @"Shaders\Standard"); ShaderGlobals.RegisterEffect("Standard", effect); } } // end of UIShim RenderObj LoadContent()
public void Render() { /// render entire pie if (Active) { ShaderGlobals.SetValues(effect); ShaderGlobals.SetCamera(effect, camera); RenderDisk(rootDisk); } }
} // end of SkyBox Render() public override void LoadContent(bool immediate) { // Init the effect. if (effect == null) { effect = BokuGame.Load <Effect>(BokuGame.Settings.MediaPath + @"Shaders\SkyBox"); ShaderGlobals.RegisterEffect("SkyBox", effect); } base.LoadContent(immediate); } // end of SkyBox LoadContent()
private static void Postfix(ShaderGlobals __instance, int band, float power) { if (ReactiveLights.Count == 0) { return; } else if (band == 1) { Update(power); } }
public static void Render(Camera camera) { Parameter(EffectParams.WorldMatrix).SetValue(Matrix.Identity); Parameter(EffectParams.WorldViewProjMatrix).SetValue(camera.ViewProjectionMatrix); Parameter(EffectParams.CrossTexture).SetValue(CrossTexture); effect.CurrentTechnique = Technique(InGame.inGame.renderEffects); Impact.RenderActive(camera, effect, effectCache); ShaderGlobals.ReleaseExplicitBloom(); }
public void SetupWaterEffect(Water.Definition def, float baseHeight) { /// Give the water a shot at setting up body specific parameters. Parameter(EffectParams.Color).SetValue(def.Color); Parameter(EffectParams.BaseHeight).SetValue(baseHeight); Parameter(EffectParams.WaveHeight).SetValue(Terrain.WaveHeight); Parameter(EffectParams.Fresnel).SetValue(def.Fresnel); Parameter(EffectParams.Shininess).SetValue(def.Shininess); Parameter(EffectParams.Emissive).SetValue(def.Emissive); Parameter(EffectParams.TextureTile).SetValue(def.TextureTiling); ShaderGlobals.FixExplicitBloom(def.ExplicitBloom); }
/// <summary> /// Load up resource needed for rendering, all shared statics. /// </summary> /// <param name="immediate"></param> public static void LoadContent(bool immediate) { if (bump == null) { bump = BokuGame.Load <Texture2D>(BokuGame.Settings.MediaPath + @"Textures\DistortionWake"); } if (effect == null) { effect = BokuGame.Load <Effect>(BokuGame.Settings.MediaPath + @"Shaders\Standard"); ShaderGlobals.RegisterEffect("Standard", effect); effectCache.Load(effect, ""); } }
} // end of SharedSmokeEmitter Update() /// <summary> /// Sets up all the common stuff needed for rendering. This includes /// setting the technique and any parameters that don't change from /// one batch to the next. /// </summary> public override void PreRender(Camera camera) { GraphicsDevice device = BokuGame.bokuGame.GraphicsDevice; if (InGame.inGame.renderEffects == InGame.RenderEffect.DistortionPass) { ShaderGlobals.FixExplicitBloom(0.004f); effect.CurrentTechnique = effect.Techniques[@"DistortionPass"]; } else { // Turn off bloom. ShaderGlobals.FixExplicitBloom(0.0f); effect.CurrentTechnique = effect.Techniques[TechniqueName]; } // Set up common rendering values. effect.Parameters["CurrentTime"].SetValue((float)Time.GameTimeTotalSeconds); // Set up world matrix. Matrix worldMatrix = Matrix.Identity; Matrix worldViewProjMatrix = worldMatrix * camera.ViewProjectionMatrix; Vector4 diffuseColor = ShaderGlobals.ParticleTint(false); effect.Parameters["DiffuseColor"].SetValue(diffuseColor); effect.Parameters["DiffuseTexture"].SetValue(texture); effect.Parameters["EyeLocation"].SetValue(new Vector4(camera.ActualFrom, 1.0f)); effect.Parameters["CameraUp"].SetValue(new Vector4(camera.ViewUp, 1.0f)); effect.Parameters["WorldMatrix"].SetValue(worldMatrix); effect.Parameters["WorldViewProjMatrix"].SetValue(worldViewProjMatrix); effect.Parameters["ParticleRadius"].SetValue( ShaderGlobals.MakeParticleSizeLimit(1.0f, 0.0f, 200.0f)); // Cloned from DistortFilter. Another casualty of the removal of gloabl shader values. Vector4 filterScroll = new Vector4(0.0f, 0.0f, 0.0f, 0.0f); Vector4 filterScale = new Vector4(0.5f, 0.5f, 0.5f, 0.5f); float filterStrength = 0.2f; effect.Parameters["BumpScroll"].SetValue(filterScroll); effect.Parameters["BumpScale"].SetValue(filterScale); effect.Parameters["BumpStrength"].SetValue(filterStrength); effect.Parameters["DepthTexture"].SetValue(InGame.inGame.EffectsRenderTarget); //effect.Parameters["Bump"].SetValue(DistortFilter.BumpTexture); effect.Parameters["Bump"].SetValue(DistortionManager.Bump); effect.Parameters["DOF_FarPlane"].SetValue(100.0f); device.Indices = ibuf; } // end of SharedSmokeEmitter PreRender()
/// <summary> /// This Init function also doubles as an update function /// in case the position or size of the billboard changes. /// </summary> public void InitDeviceResources(GraphicsDevice device) { // Init the vertex buffer. if (vbuf == null) { vbuf = new VertexBuffer(device, typeof(Vertex), 4, BufferUsage.WriteOnly); // Create local vertices. Vertex[] localVerts = new Vertex[4]; { localVerts[0] = new Vertex(new Vector3(-size.X / 2.0f, size.Y / 2.0f, 0.0f), new Vector2(0, 0)); localVerts[1] = new Vertex(new Vector3(size.X / 2.0f, size.Y / 2.0f, 0.0f), new Vector2(1, 0)); localVerts[2] = new Vertex(new Vector3(size.X / 2.0f, -size.Y / 2.0f, 0.0f), new Vector2(1, 1)); localVerts[3] = new Vertex(new Vector3(-size.X / 2.0f, -size.Y / 2.0f, 0.0f), new Vector2(0, 1)); } // Copy to vertex buffer. vbuf.SetData <Vertex>(localVerts); } // Init the effect. if (effect == null) { effect = BokuGame.Load <Effect>(BokuGame.Settings.MediaPath + @"Shaders\Billboard"); ShaderGlobals.RegisterEffect("Billboard", effect); effectCache.Load(effect); technique = premultipliedAlpha ? effect.Techniques["PremultipliedAlphaColorPass"] : effect.Techniques["NormalAlphaColorPass"]; } // Load the texture. if (textureFilename != null) { // First try and load it as a programming tile. texture = CardSpace.Cards.CardFaceTexture(textureFilename); // If that didn't work, treat it as an asset name. if (texture == null) { texture = BokuGame.Load <Texture2D>(BokuGame.Settings.MediaPath + textureFilename); } } if (texture != null && size == Vector2.Zero) { UiCamera c = new UiCamera(); size.X = texture.Width / c.Dpi; // 96 DPI size.Y = texture.Height / c.Dpi; } } // end of InitDeviceResources()
public static void Load() { if (effect == null) { effect = BokuGame.Load <Effect>(BokuGame.Settings.MediaPath + @"Shaders\Shield"); ShaderGlobals.RegisterEffect("Shield", effect); effectCache.Load(effect, ""); } if (crossTexture == null) { crossTexture = BokuGame.Load <Texture2D>(BokuGame.Settings.MediaPath + @"Textures\Ring"); } }
public static void DrawFatLine(Camera camera, List <Vector3> pts, Vector4 color, ref Matrix localToWorld) { if (pts.Count > 0) { Matrix viewMatrix = camera.ViewMatrix; Matrix projMatrix = camera.ProjectionMatrix; Matrix worldViewProjMatrix = localToWorld * viewMatrix * projMatrix; effect.Parameters["WorldViewProjMatrix"].SetValue(worldViewProjMatrix); effect.Parameters["WorldMatrix"].SetValue(localToWorld); int numSegs = pts.Count / 2; int numTris = numSegs * 2; SetupRunwayPos(pts, color); effect.CurrentTechnique = effect.Techniques["RunwayAlphaBack"]; effect.Parameters["RunCount"].SetValue(5.0f); effect.Parameters["RunPhase"].SetValue(0.0f); effect.Parameters["RunEndColor"].SetValue(Vector4.UnitW); effect.Parameters["Ramps"].SetValue(white); Vector2 runSkinny = new Vector2( 1.0f / camera.Resolution.X, 1.0f / camera.Resolution.Y) * 1.0f; effect.Parameters["RunWidth"].SetValue(runSkinny); ShaderGlobals.FixExplicitBloom(0.0f); DrawPrimRunwayVerts(numTris); effect.CurrentTechnique = effect.Techniques["RunwayAlpha"]; effect.Parameters["RunCount"].SetValue(1.666f); effect.Parameters["RunPhase"].SetValue(0.0f); effect.Parameters["RunEndColor"].SetValue(color); effect.Parameters["Ramps"].SetValue(white); Vector2 runWidth = new Vector2( 1.0f / camera.Resolution.X, 1.0f / camera.Resolution.Y) * 4.0f; effect.Parameters["RunWidth"].SetValue(runWidth); DrawPrimRunwayVerts(numTris); ShaderGlobals.ReleaseExplicitBloom(); } }
} // end of Compass Render() public void LoadContent(bool immediate) { // Init the effect. if (effect == null) { effect = BokuGame.Load <Effect>(BokuGame.Settings.MediaPath + @"Shaders\Billboard"); ShaderGlobals.RegisterEffect("Billboard", effect); } // Load the texture. if (texture == null) { texture = BokuGame.Load <Texture2D>(BokuGame.Settings.MediaPath + @"Textures\Compass"); } } // end of Compass LoadContent()