/// <summary>
/// Render
/// </summary>
/// <param name="setMat">Set matrix</param>
/// <param name="techniqueName">Technique name</param>
/// <param name="renderDelegate">Render delegate</param>
public void RenderCollada(string techniqueName,
RenderDelegate renderDelegate)
{
/*will become important later in the book.
* // Can we do the requested technique?
* // For graphic cards not supporting ps2.0, fall back to ps1.1
* if (BaseGame.CanUsePS20 == false &&
* techniqueName.EndsWith("20"))
* // Use same technique without the 20 ending!
* techniqueName = techniqueName.Substring(0, techniqueName.Length - 2);
*/
// Start shader
effect.CurrentTechnique = effect.Techniques[techniqueName];
effect.Begin(SaveStateMode.None);
// Render all passes (usually just one)
//foreach (EffectPass pass in effect.CurrentTechnique.Passes)
for (int num = 0; num < effect.CurrentTechnique.Passes.Count; num++)
{
EffectPass pass = effect.CurrentTechnique.Passes[num];
pass.Begin();
renderDelegate();
pass.End();
} // foreach (pass)
// End shader
effect.End();
} // Render(passName, renderDelegate)
} // Update()
#endregion
#region Render
/*unused, always specify a technique name
* /// <summary>
* /// Render
* /// </summary>
* /// <param name="renderDelegate">Render delegate</param>
* public void Render(BaseGame.RenderDelegate renderDelegate)
* {
* SetParameters();
*
* //not supported or bug, no multiple techniques possible yet:
* //effect.Technique = "SpecularPerPixel";
*
* // Start shader
* effect.Begin(EffectStateOptions.Default);
* foreach (EffectPass pass in effect.CurrentTechnique.Passes)
* {
* // Render each pass
* pass.Begin();
* renderDelegate();
* pass.End();
* } // foreach (pass)
*
* // End shader
* effect.End();
* } // Render(renderDelegate)
*/
/*unused, always specify a technique name
* /// <summary>
* /// Render
* /// </summary>
* /// <param name="setMat">Set matrix</param>
* /// <param name="renderDelegate">Render delegate</param>
* public void Render(Material setMat,
* BaseGame.RenderDelegate renderDelegate)
* {
* SetParameters(setMat);
*
* //not supported or bug, no multiple techniques possible yet:
* //effect.Technique = "SpecularPerPixel";
*
* // Start shader
* effect.Begin(EffectStateOptions.Default);
* foreach (EffectPass pass in effect.CurrentTechnique.Passes)
* {
* // Render each pass
* pass.Begin();
* renderDelegate();
* pass.End();
* } // foreach (pass)
*
* // End shader
* effect.End();
* } // Render(setMat, renderDelegate)
*/
/// <summary>
/// Render
/// </summary>
/// <param name="setMat">Set matrix</param>
/// <param name="passName">Pass name</param>
/// <param name="renderDelegate">Render delegate</param>
public void Render(Material setMat,
string techniqueName,
BaseGame.RenderDelegate renderDelegate)
{
SetParameters(setMat);
// Can we do the requested technique?
// For graphic cards not supporting ps2.0, fall back to ps1.1
if (BaseGame.CanUsePS20 == false &&
techniqueName.EndsWith("20"))
{
// Use same technique without the 20 ending!
techniqueName = techniqueName.Substring(0, techniqueName.Length - 2);
}
// Start shader
effect.CurrentTechnique = effect.Techniques[techniqueName];
effect.Begin(SaveStateMode.None);
// Render all passes (usually just one)
//foreach (EffectPass pass in effect.CurrentTechnique.Passes)
for (int num = 0; num < effect.CurrentTechnique.Passes.Count; num++)
{
EffectPass pass = effect.CurrentTechnique.Passes[num];
pass.Begin();
renderDelegate();
pass.End();
} // foreach (pass)
// End shader
effect.End();
} // Render(setMat, passName, renderDelegate)
private void Render()
{
if (this.vertexCount > 0)
{
if (this.declaration == null || this.declaration.IsDisposed)
{
this.declaration = new VertexDeclaration(device, VertexPositionTexture.VertexElements);
}
device.VertexDeclaration = this.declaration;
Effect effect = this.Effect;
// set the only parameter this effect takes.
effect.Parameters["viewProjection"].SetValue(this.View * this.Projection);
EffectTechnique technique = effect.CurrentTechnique;
effect.Begin();
EffectPassCollection passes = technique.Passes;
for (int i = 0; i < passes.Count; i++)
{
EffectPass pass = passes[i];
pass.Begin();
device.DrawUserIndexedPrimitives <VertexPositionTexture>(
PrimitiveType.TriangleList, this.vertices, 0, this.vertexCount,
this.indices, 0, this.indexCount / 3);
pass.End();
}
effect.End();
this.vertexCount = 0;
this.indexCount = 0;
}
}
} // end of TopLevelPalette Update()
public void Render()
{
if (Active)
{
GraphicsDevice device = BokuGame.bokuGame.GraphicsDevice;
device.VertexDeclaration = decl;
// Render all passes.
effect.Parameters["FrameTexture"].SetValue(frameTexture);
effect.Parameters["ScreenTexture"].SetValue(screenTexture);
effect.Parameters["IconTexture"].SetValue(iconTexture);
effect.Parameters["Alpha"].SetValue(Alpha);
effect.CurrentTechnique = effect.Techniques["Normal"];
effect.Parameters["NumIcons"].SetValue((float)numIcons);
for (int i = 0; i < numIcons; i++)
{
effect.Parameters["Color" + i.ToString()].SetValue(color[i]);
}
effect.Begin();
for (int i = 0; i < effect.CurrentTechnique.Passes.Count; i++)
{
EffectPass pass = effect.CurrentTechnique.Passes[i];
pass.Begin();
device.DrawUserPrimitives(PrimitiveType.TriangleStrip, vertices, 0, 6);
pass.End();
}
effect.End();
} // end if Active
} // end of TopLevelPalette Render()
} // end of RenderObj Init()
public override void Render(Camera camera)
{
Matrix viewMatrix = camera.ViewMatrix;
Matrix projMatrix = camera.ProjectionMatrix;
Matrix worldViewProjMatrix = shared.worldMatrix * viewMatrix * projMatrix;
effect.Parameters["WorldViewProjMatrix"].SetValue(worldViewProjMatrix);
effect.Parameters["WorldMatrix"].SetValue(shared.worldMatrix);
effect.Parameters["LightTexture"].SetValue(texture);
effect.Parameters["Color"].SetValue(diffuse);
effect.Parameters["TextureOffset"].SetValue(shared.TextureOffset);
device.VertexDeclaration = decl;
device.Vertices[0].SetSource(vbuf, 0, stride);
device.Indices = ibuf;
// Render all passes.
effect.CurrentTechnique = effect.Techniques["AdditiveTexturedColorPass"];
effect.Begin();
for (int i = 0; i < effect.CurrentTechnique.Passes.Count; i++)
{
EffectPass pass = effect.CurrentTechnique.Passes[i];
pass.Begin();
device.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, numVertices, 0, numTriangles);
pass.End();
}
effect.End();
} // end of RenderObj Render()
public void Render()
{
//game.GraphicsDevice.RenderState.FillMode = FillMode.WireFrame;
game.GraphicsDevice.RenderState.CullMode = CullMode.None;
effect.World = World;
effect.View = game.Camera.View;
effect.Projection = game.Camera.Projection;
effect.Begin(SaveStateMode.None);
// Render all passes (usually just one)
//foreach (EffectPass pass in effect.CurrentTechnique.Passes)
for (int num = 0; num < effect.CurrentTechnique.Passes.Count; num++)
{
EffectPass pass = effect.CurrentTechnique.Passes[num];
pass.Begin();
renderPrimitives();
pass.End();
} // foreach (pass)
// End shader
effect.End();
}
} // Add(addMesh)
#endregion
#region Render
/// <summary>
/// Render all meshes that use this technique sorted by the materials.
/// This method is only called if we got any meshes to render,
/// which is determinated if NumberOfRenderMeshes is greater 0.
/// </summary>
/// <param name="effect">Effect</param>
public void Render(Effect effect)
{
// Start effect for this technique
effect.CurrentTechnique = technique;
effect.Begin(SaveStateMode.None);
// Render all pass (we always just have one)
//obs: foreach (EffectPass pass in effect.CurrentTechnique.Passes)
{
EffectPass pass = effect.CurrentTechnique.Passes[0];
pass.Begin();
// Render all meshes sorted by all materials.
//obs: foreach (MeshesPerMaterial list in meshesPerMaterials)
for (int listNum = 0; listNum < meshesPerMaterials.Count; listNum++)
{
MeshesPerMaterial list = meshesPerMaterials[listNum];
if (list.NumberOfRenderMatrices > 0)
{
list.Render();
}
} // for (listNum)
pass.End();
} // foreach (pass)
// End shader
effect.End();
} // Render(effect)
/// <summary>
/// Render all meshes that use this technique sorted by the materials.
/// This method is only called if we got any meshes to render,
/// which is determinated if NumberOfRenderMeshes is greater 0.
/// </summary>
/// <param name="effect">Effect</param>
public void Render(Effect effect)
{
// Start effect for this technique
effect.CurrentTechnique = technique;
try
{
effect.Begin(SaveStateMode.None);
// Render all pass (we always just have one)
EffectPass pass = effect.CurrentTechnique.Passes[0];
pass.Begin();
// Render all meshes sorted by all materials.
for (int listNum = 0; listNum < meshesPerMaterials.Count; listNum++)
{
MeshesPerMaterial list = meshesPerMaterials[listNum];
if (list.NumberOfRenderMatrices > 0)
{
list.Render();
}
}
pass.End();
}
finally
{
// End shader
effect.End();
}
}
/// <summary>
/// Draw a list of Lines.
/// </summary>
public void Draw(List <RoundLine> roundLines, float lineRadius, Color lineColor /*, Matrix viewProjMatrix*/,
float time, string techniqueName)
{
device.VertexDeclaration = vdecl;
device.Vertices[0].SetSource(vb, 0, bytesPerVertex);
device.Indices = ib;
viewProjMatrixParameter.SetValue(mProjection);
timeParameter.SetValue(time);
lineColorParameter.SetValue(lineColor.ToVector4());
lineRadiusParameter.SetValue(lineRadius);
blurThresholdParameter.SetValue(BlurThreshold);
if (techniqueName == null)
{
effect.CurrentTechnique = effect.Techniques[0];
}
else
{
effect.CurrentTechnique = effect.Techniques[techniqueName];
}
effect.Begin();
EffectPass pass = effect.CurrentTechnique.Passes[0];
pass.Begin();
int iData = 0;
int numInstancesThisDraw = 0;
foreach (RoundLine roundLine in roundLines)
{
translationData[iData++] = roundLine.P0.X;
translationData[iData++] = roundLine.P0.Y;
translationData[iData++] = roundLine.Rho;
translationData[iData++] = roundLine.Theta;
numInstancesThisDraw++;
if (numInstancesThisDraw == numInstances)
{
instanceDataParameter.SetValue(translationData);
effect.CommitChanges();
device.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, numVertices, 0, numPrimitivesPerInstance * numInstancesThisDraw);
NumLinesDrawn += numInstancesThisDraw;
numInstancesThisDraw = 0;
iData = 0;
}
}
if (numInstancesThisDraw > 0)
{
instanceDataParameter.SetValue(translationData);
effect.CommitChanges();
device.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, numVertices, 0, numPrimitivesPerInstance * numInstancesThisDraw);
NumLinesDrawn += numInstancesThisDraw;
}
pass.End();
effect.End();
}
public void DrawPrimitives(RenderPrimitivesDelegate renderPrimitives)
{
Shader.effect.Begin(SaveStateMode.None);
EffectPass pass = Shader.effect.CurrentTechnique.Passes[0];
pass.Begin();
renderPrimitives();
pass.End();
Shader.effect.End();
}
public override void Draw()
{
fx.Begin();
for (int i = 0; i < fx.CurrentTechnique.Passes.Count; i++)
{
EffectPass pass = fx.CurrentTechnique.Passes[i];
pass.Begin();
device.VertexDeclaration = vertexDeclaration;
device.DrawUserIndexedPrimitives <VertexPositionColor>
(PrimitiveType.TriangleList, vertices, 0, 4, indices, 0, 2);
pass.End();
}
fx.End();
}
void FinishDrawing(PrimitiveType drawtype, Int32 count)
{
m_effect.Begin();
for (Int32 i = 0; i != m_effect.CurrentTechnique.Passes.Count; ++i)
{
EffectPass pass = m_effect.CurrentTechnique.Passes[i];
pass.Begin();
Device.DrawUserPrimitives <Vertex>(drawtype, m_drawbuffer, 0, count);
pass.End();
}
m_effect.End();
m_effect.GraphicsDevice.Textures[0] = null;
m_effect.GraphicsDevice.Textures[1] = null;
}
public static void RenderSphere(BoundingSphere sphere, Color color, ref Matrix view, ref Matrix projection)
{
//this null check is here in case we never ran the InitializeBuffers method of this class
//if this is the case the device will be null
if (device == null)
{
return;
}
device.VertexDeclaration = vertexDeclaration;
device.Vertices[0].SetSource(sphereBuffer, 0, VertexPositionColor.SizeInBytes);
effect.View = view;
effect.Projection = projection;
Matrix scale = Matrix.CreateScale(sphere.Radius);
Matrix translation = Matrix.CreateTranslation(sphere.Center);
effect.Begin(SaveStateMode.SaveState);
for (int i = 0; i < effect.CurrentTechnique.Passes.Count; i++)
{
EffectPass pass = effect.CurrentTechnique.Passes[i];
pass.Begin();
effect.DiffuseColor = color.ToVector3();//Vector3.UnitY;
effect.World = scale * translation;
effect.CommitChanges();
device.DrawPrimitives(PrimitiveType.LineStrip, 0, numberOfSphereVerts - 1);
effect.DiffuseColor = color.ToVector3(); //Vector3.UnitZ;
effect.World = scale * Matrix.CreateRotationX(MathHelper.PiOver2) * translation;
effect.CommitChanges();
device.DrawPrimitives(PrimitiveType.LineStrip, 0, numberOfSphereVerts - 1);
effect.DiffuseColor = color.ToVector3(); //Vector3.UnitX;
effect.World = scale * Matrix.CreateRotationZ(MathHelper.PiOver2) * translation;
effect.CommitChanges();
device.DrawPrimitives(PrimitiveType.LineStrip, 0, numberOfSphereVerts - 1);
pass.End();
}
effect.End();
}
public override void Draw(GameTime gameTime)
{
//GraphicsDevice.Clear(Color.Black);
GraphicsDevice.SetRenderTarget(0, target1);
//GraphicsDevice.SetRenderTarget(0, null);
GraphicsDevice.Clear(Color.Black);
// Draw on the target1
base.Draw(gameTime);
// Draw post-screen fx
#region Effects render
for (int i = 0; i < blur.CurrentTechnique.Passes.Count; i++)
{
if (i == 0)
{
GraphicsDevice.SetRenderTarget(0, target2);
}
else
{
GraphicsDevice.SetRenderTarget(0, null);
}
game.spriteBatch.Begin(SpriteBlendMode.AlphaBlend, SpriteSortMode.Immediate, SaveStateMode.None);
blur.Begin();
EffectPass pass = blur.CurrentTechnique.Passes[i];
pass.Begin();
Texture2D tex = (i == 0) ? target1.GetTexture() : target2.GetTexture();
game.spriteBatch.Draw(tex, new Vector2(0, 0), Color.White);
pass.End();
blur.End();
//if (i == 1)
// game.spriteBatch.Draw(target1.GetTexture(), new Vector2(0, 0), Color.White);
game.spriteBatch.End();
}
#endregion
}
private void PostRender()
{
//graphics.GraphicsDevice.ResolveRenderTarget(0);
texturedRenderedTo = renderTarget.GetTexture();
graphics.GraphicsDevice.SetRenderTarget(0, null);
graphics.GraphicsDevice.Clear(ClearOptions.Target | ClearOptions.DepthBuffer, Color.Black, 1.0f, 0);
postEffect.Begin();
camSpeed = Math.Abs(Editor.camera.speed);
if (camSpeed != 0f)
{
if (effectSpeed < camSpeed * 0.003f)
{
effectSpeed = camSpeed * 0.003f;
}
}
else
{
if (effectSpeed > 0.0003f)
{
effectSpeed *= 0.92f;
}
else
{
effectSpeed = 0f;
}
}
postEffect.Parameters["speed"].SetValue(effectSpeed);
spriteBatch.Begin(postBlendMode, SpriteSortMode.Immediate, SaveStateMode.SaveState);
EffectPass pass = postEffect.CurrentTechnique.Passes[0];
pass.Begin();
spriteBatch.Draw(texturedRenderedTo, new Vector2(0, 0), null, Color.White, 0, new Vector2(0, 0), 1.0f, SpriteEffects.None, 1);
pass.End();
spriteBatch.End();
postEffect.End();
}
//* ────＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿_*
//* methods ───────────────────────────────-*
//* -----------------------------------------------------------------------*
/// <summary>1フレーム分の描画処理を実行します。</summary>
///
/// <param name="entity">この状態を適用されているオブジェクト。</param>
/// <param name="privateMembers">
/// オブジェクトと状態クラスのみがアクセス可能なフィールド。
/// </param>
/// <param name="gameTime">前フレームが開始してからの経過時間。</param>
public override void draw(CEntity entity, CCursor privateMembers, GameTime gameTime)
{
Matrix world = privateMembers.world;
effect.Parameters["World"].SetValue(world);
effect.Begin();
EffectPassCollection passes = effect.CurrentTechnique.Passes;
for (int i = passes.Count; --i >= 0;)
{
EffectPass pass = passes[i];
pass.Begin();
device.DrawUserPrimitives <VertexPositionNormalTexture>(
PrimitiveType.TriangleStrip, vertex, 0, 2);
pass.End();
}
effect.End();
}
public void RenderSinglePass(Effect effect, params string[] textureParams)
{
if (!isVisible)
{
return;
}
for (int i = 0; i < textureParams.Length; i++)
{
effect.Parameters[textureParams[i]].SetValue(textures[i]);
}
effect.Begin();
EffectPass pass = effect.CurrentTechnique.Passes[0];
pass.Begin();
Render();
pass.End();
effect.End();
}
/// <summary>
/// Flushes all queued areas to be drawn.
/// </summary>
public void Flush()
{
if (this.Areas.Count > 0)
{
Matrix world;
Matrix worldViewProjection;
this.Effect.CurrentTechnique = this.Effect.Techniques[0];
this.Effect.Begin();
EffectPass pass = this.Effect.CurrentTechnique.Passes[0];
this.GraphicsDevice.VertexDeclaration = this.VertexDeclaration;
this.GraphicsDevice.Vertices[0].SetSource(this.VertexBuffer, 0, this.BytesPerVertices);
this.GraphicsDevice.Indices = this.IndexBuffer;
pass.Begin();
for (int index = 0; index < this.Areas.Count; index++)
{
if (this.Areas[index] != null)
{
world = this.Areas[index].World;
worldViewProjection = world * this.Camera.AreaView * this.Camera.AreaProjection;
this.Effect.Parameters["worldViewProj"].SetValue(worldViewProjection);
this.Effect.Parameters["color"].SetValue(this.Areas[index].Color.ToVector4());
this.Effect.Parameters["blurThreshold"].SetValue(0.95f);
this.Effect.CommitChanges();
this.GraphicsDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, this.VerticesNumber, 0, this.PrimitivesNumber);
}
}
pass.End();
this.Effect.End();
this.Areas.Clear();
}
}
/// <summary>
/// This method is meant for usage with one shader per meshpart, all parameters preset and using shared parameters.
/// Technique should have just one pass.
/// </summary>
/// <param name="primitive"></param>
/// <param name="state"></param>
public void RenderPrimitiveSinglePass(IRenderPrimitives primitives, SaveStateMode state)
{
Shader.effect.Begin(state);
// Render all passes (usually just one)
//for ( int num = 0; num < Shader.effect.CurrentTechnique.Passes.Count; num++ )
//{
//EffectPass pass = Shader.effect.CurrentTechnique.Passes[ num ];
EffectPass pass = Shader.effect.CurrentTechnique.Passes[0];
pass.Begin();
primitives.RenderPrimitives();
pass.End();
//}
// End shader
Shader.effect.End();
}
/// <summary>
/// Render using this shader.
/// </summary>
/// <param name="setMat">Set matrix</param>
/// <param name="techniqueName">Technique name</param>
/// <param name="renderDelegate">Render delegate</param>
public void RenderMultipass(RenderDelegate renderDelegate)
{
//SetCameraParameters( game.Camera );
// Start shader
//effect.CurrentTechnique = effect.Techniques[ techniqueName ];
effect.Begin(SaveStateMode.None);
// Render all passes (usually just one)
//foreach (EffectPass pass in effect.CurrentTechnique.Passes)
for (int num = 0; num < effect.CurrentTechnique.Passes.Count; num++)
{
EffectPass pass = effect.CurrentTechnique.Passes[num];
pass.Begin();
renderDelegate();
pass.End();
} // foreach (pass)
// End shader
effect.End();
} // Render(passName, renderDelegate)
// do the device and effect magic to render a given chunk of geometry
private void DrawChunk(ref XCamera Camera, ref Matrix world, Chunk ch)
{
// configure the device and actually draw
X.GraphicsDevice.Indices = ch.Mesh.IndexBuffer;
X.GraphicsDevice.VertexDeclaration = ch.Part.VertexDeclaration;
X.GraphicsDevice.Vertices[0].SetSource(ch.Mesh.VertexBuffer, ch.Part.StreamOffset, ch.Part.VertexStride);
// note: calculating the world matrix overrides the previous value, hence the use
// of the saved copy of the world transform
Matrix chworld;
Matrix.Multiply(ref matrices_[ch.Mesh.ParentBone.Index], ref world, out chworld);
//ch.Fx.Setup();
ch.SAS.Projection = Camera.Projection;
ch.SAS.World = chworld;
ch.SAS.View = Camera.View;
ch.SAS.ComputeViewAndProjection();
ch.SAS.ComputeModel();
ch.SAS.BindEnvironment();
for (int k = 0; k < ch.Fx.Parameters.Count; k++)
{
ch.SAS.SetEffectParameterValue(ch.Fx.Parameters[k]);
}
ch.Fx.Begin(SaveStateMode.SaveState); // be lazy and save state
EffectTechnique et = ch.Fx.CurrentTechnique;
// most my effects are single-pass, but at least transparency is multi-pass
for (int i = 0, n = et.Passes.Count; i != n; ++i)
{
EffectPass ep = et.Passes[i];
ep.Begin();
X.GraphicsDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, ch.Part.BaseVertex,
0, ch.Part.NumVertices, ch.Part.StartIndex, ch.Part.PrimitiveCount);
ep.End();
}
ch.Fx.End();
}
public void Draw()
{
if (UIReady == false)
{
PrepareRenderer();
}
if (UITexture != null && !UITexture.IsDisposed && !UIRectangle.IsEmpty)
{
if (this.isBloom == false)
{
UISpriteBatch.Draw(UITexture, UIPosition, UIRectangle, new Color(Color.White, UIAlpha), UIRotation,
new Vector2(0, 0), 1.0f, SpriteEffects.None, 0.0f);
}
else
{
UISpriteBatch.End();
UIBloom.Parameters["mag"].SetValue(this.UIBPara);
UIBloom.Parameters["alpha"].SetValue(UIAlpha);
UIBloom.Parameters["hirange"].SetValue(this.UIHiRange);
UIBloom.Begin();
UISpriteBatch.Begin(SpriteBlendMode.AlphaBlend, SpriteSortMode.Immediate,
SaveStateMode.SaveState);
EffectPass pass = UIBloom.CurrentTechnique.Passes[0];
pass.Begin();
UISpriteBatch.Draw(UITexture, UIPosition, UIRectangle, new Color(Color.White, UIAlpha), UIRotation,
new Vector2(0, 0), 1.0f, SpriteEffects.None, 0.0f);
pass.End();
UISpriteBatch.End();
UIBloom.End();
UISpriteBatch.Begin();
}
}
}
/// <summary>
/// Render
/// </summary>
/// <param name="setMat">Set matrix</param>
/// <param name="passName">Pass name</param>
/// <param name="renderDelegate">Render delegate</param>
public void Render(Material setMat,
string techniqueName,
BaseGame.RenderHandler renderCode)
{
if (techniqueName == null)
{
throw new ArgumentNullException("techniqueName");
}
if (renderCode == null)
{
throw new ArgumentNullException("renderCode");
}
SetParameters(setMat);
// Start shader
effect.CurrentTechnique = effect.Techniques[techniqueName];
try
{
effect.Begin(SaveStateMode.None);
// Render all passes (usually just one)
//foreach (EffectPass pass in effect.CurrentTechnique.Passes)
for (int num = 0; num < effect.CurrentTechnique.Passes.Count; num++)
{
EffectPass pass = effect.CurrentTechnique.Passes[num];
pass.Begin();
renderCode();
pass.End();
}
}
finally
{
// End shader
effect.End();
}
}
// do the device and effect magic to render a given chunk of geometry
private void DrawChunk(DrawDetails dd, Chunk ch)
{
// configure the device and actually draw
dd.dev.Indices = ch.Mesh.IndexBuffer;
dd.dev.VertexDeclaration = ch.Part.VertexDeclaration;
dd.dev.Vertices[0].SetSource(ch.Mesh.VertexBuffer, ch.Part.StreamOffset, ch.Part.VertexStride);
// note: calculating the world matrix overrides the previous value, hence the use
// of the saved copy of the world transform
Matrix.Multiply(ref matrices_[ch.Mesh.ParentBone.Index], ref world_, out dd.world);
ch.Fx.Setup(dd);
ch.Fx.FX.Begin(); // be lazy and save state
EffectTechnique et = ch.Fx.FX.CurrentTechnique;
// most my effects are single-pass, but at least transparency is multi-pass
for (int i = 0, n = et.Passes.Count; i != n; ++i)
{
EffectPass ep = et.Passes[i];
ep.Begin();
dd.dev.DrawIndexedPrimitives(PrimitiveType.TriangleList, ch.Part.BaseVertex,
0, ch.Part.NumVertices, ch.Part.StartIndex, ch.Part.PrimitiveCount);
ep.End();
}
ch.Fx.FX.End();
}
public static void RenderBox(Vector3 pos, Matrix orient, Vector3 sideLengths, Color color, ref Matrix view, ref Matrix projection)
{
//this null check is here in case we never ran the InitializeBuffers method of this class
//if this is the case the device will be null
if (device == null)
{
return;
}
device.VertexDeclaration = vertexDeclaration;
device.Vertices[0].SetSource(boxBuffer, 0, VertexPositionColor.SizeInBytes);
effect.View = view;
effect.Projection = projection;
Matrix scale = Matrix.CreateScale(sideLengths);
Matrix translation = Matrix.CreateTranslation(pos);
effect.Begin(SaveStateMode.SaveState);
for (int i = 0; i < effect.CurrentTechnique.Passes.Count; i++)
{
EffectPass pass = effect.CurrentTechnique.Passes[i];
pass.Begin();
effect.DiffuseColor = color.ToVector3();
effect.World = scale * translation * orient;
effect.CommitChanges();
device.DrawPrimitives(PrimitiveType.LineStrip, 0, numberOfBoxVerts - 1);
pass.End();
}
effect.End();
}
internal static void BloomEnd()
{
try
{
GameBase.graphics.GraphicsDevice.ResolveRenderTarget(0);
GameBase.graphics.GraphicsDevice.SetRenderTarget(0, null);
GameBase.graphics.GraphicsDevice.Clear(Color.Black);
Texture2D tex = rTarg.GetTexture();
GameBase.spriteBatch.Begin(SpriteBlendMode.AlphaBlend, SpriteSortMode.Immediate,
SaveStateMode.None);
GameBase.spriteBatch.GraphicsDevice.RenderState.SeparateAlphaBlendEnabled = true;
GameBase.spriteBatch.GraphicsDevice.RenderState.AlphaSourceBlend = Blend.One;
GameBase.spriteBatch.GraphicsDevice.RenderState.AlphaDestinationBlend = Blend.InverseSourceAlpha;
GameBase.spriteBatch.Draw(tex,
new Rectangle(0, 0, GameBase.WindowWidth,
GameBase.WindowHeight + GameBase.WindowVOffset),
new Rectangle(0, 0, GameBase.WindowWidth,
GameBase.WindowHeight + GameBase.WindowVOffset), Color.White);
GameBase.spriteBatch.End();
bloomatic.Parameters["mag"].SetValue(0.004f);
bloomatic.Parameters["alpha"].SetValue(0.15f);
bloomatic.Parameters["hirange"].SetValue(false);
bloomatic.Parameters["redtint"].SetValue(0);
bloomatic.Begin();
GameBase.spriteBatch.Begin(SpriteBlendMode.AlphaBlend, SpriteSortMode.Immediate,
SaveStateMode.None);
EffectPass pass = bloomatic.CurrentTechnique.Passes[0];
pass.Begin();
GameBase.spriteBatch.Draw(tex,
new Rectangle(0, 0, GameBase.WindowWidth,
GameBase.WindowHeight + GameBase.WindowVOffset),
new Rectangle(0, 0, GameBase.WindowWidth,
GameBase.WindowHeight + GameBase.WindowVOffset), Color.White);
pass.End();
GameBase.spriteBatch.End();
if (ExtraPass)
{
bloomatic.Parameters["mag"].SetValue(Magnitude);
bloomatic.Parameters["alpha"].SetValue(Alpha);
bloomatic.Parameters["redtint"].SetValue(RedTint);
bloomatic.Parameters["hirange"].SetValue(HiRange);
GameBase.spriteBatch.Begin(Additive ? SpriteBlendMode.Additive : SpriteBlendMode.AlphaBlend,
SpriteSortMode.Immediate,
SaveStateMode.None);
pass.Begin();
GameBase.spriteBatch.Draw(tex,
new Rectangle(0, 0, GameBase.WindowWidth,
GameBase.WindowHeight + GameBase.WindowVOffset),
new Rectangle(0, 0, GameBase.WindowWidth,
GameBase.WindowHeight + GameBase.WindowVOffset), Colour);
pass.End();
GameBase.spriteBatch.End();
}
bloomatic.End();
}
catch
{
ConfigManager.sBloom = false;
GameBase.ShowMessage("No shader support - disabling bloom effects.");
}
}
/// <summary>
/// Show shadows with help of our blur map shader
/// </summary>
public void ShowShadows()
{
// Only apply post screen blur if texture is valid and effect are valid
if (blurMapTexture == null ||
Valid == false ||
// If the shadow scene map is not yet filled, there is no point
// continuing here ...
blurMapTexture.XnaTexture == null)
{
return;
}
// Don't use or write to the z buffer
BaseGame.Device.RenderState.DepthBufferEnable = false;
BaseGame.Device.RenderState.DepthBufferWriteEnable = false;
// Make sure we clamp everything to 0-1
BaseGame.Device.SamplerStates[0].AddressU = TextureAddressMode.Clamp;
BaseGame.Device.SamplerStates[0].AddressV = TextureAddressMode.Clamp;
// Restore back buffer as render target
//not required: BaseGame.ResetRenderTarget(false);
if (blurMap != null)
{
blurMap.SetValue(blurMapTexture.XnaTexture);
}
effect.CurrentTechnique = effect.Techniques["ScreenAdvancedBlur20"];
// We must have exactly 2 passes!
if (effect.CurrentTechnique.Passes.Count != 2)
{
throw new InvalidOperationException(
"This shader should have exactly 2 passes!");
}
// Render second pass
try
{
effect.Begin(SaveStateMode.None);
// Use ZeroSourceBlend alpha mode for the final result
BaseGame.Device.RenderState.AlphaBlendEnable = true;
BaseGame.Device.RenderState.AlphaBlendOperation = BlendFunction.Add;
BaseGame.Device.RenderState.SourceBlend = Blend.Zero;
BaseGame.Device.RenderState.DestinationBlend = Blend.SourceColor;
EffectPass effectPass = effect.CurrentTechnique.Passes[1];
effectPass.Begin();
VBScreenHelper.Render();
effectPass.End();
}
finally
{
effect.End();
}
// Restore z buffer state
BaseGame.Device.RenderState.DepthBufferEnable = true;
BaseGame.Device.RenderState.DepthBufferWriteEnable = true;
// Set u/v addressing back to wrap
BaseGame.Device.SamplerStates[0].AddressU = TextureAddressMode.Wrap;
BaseGame.Device.SamplerStates[0].AddressV = TextureAddressMode.Wrap;
// Restore normal alpha blending
//BaseGame.Device.RenderState.BlendFunction = BlendFunction.Add;
BaseGame.SetCurrentAlphaMode(BaseGame.AlphaMode.Default);
}
/// <summary>
/// Show shadows with help of our blur map shader
/// </summary>
public void RenderShadows()
{
// Only apply post screen blur if texture is valid and effect are valid
if (sceneMapTexture == null ||
Valid == false ||
// If the shadow scene map is not yet filled, there is no point
// continuing here ...
sceneMapTexture.XnaTexture == null)
{
return;
}
// Don't use or write to the z buffer
BaseGame.Device.RenderState.DepthBufferEnable = false;
BaseGame.Device.RenderState.DepthBufferWriteEnable = false;
// Disable alpha for the first pass
BaseGame.Device.RenderState.AlphaBlendEnable = false;
if (windowSize != null)
{
windowSize.SetValue(
new float[] { sceneMapTexture.Width, sceneMapTexture.Height });
}
if (sceneMap != null)
{
sceneMap.SetValue(sceneMapTexture.XnaTexture);
}
effect.CurrentTechnique = effect.Techniques["ScreenAdvancedBlur20"];
// We must have exactly 2 passes!
if (effect.CurrentTechnique.Passes.Count != 2)
{
throw new InvalidOperationException(
"This shader should have exactly 2 passes!");
}
// Just start pass 0
try
{
effect.Begin(SaveStateMode.None);
blurMapTexture.SetRenderTarget();
EffectPass effectPass = effect.CurrentTechnique.Passes[0];
effectPass.Begin();
VBScreenHelper.Render();
effectPass.End();
}
finally
{
effect.End();
}
blurMapTexture.Resolve();
BaseGame.ResetRenderTarget(false);
// Restore z buffer state
BaseGame.Device.RenderState.DepthBufferEnable = true;
BaseGame.Device.RenderState.DepthBufferWriteEnable = true;
// Set u/v addressing back to wrap
BaseGame.Device.SamplerStates[0].AddressU = TextureAddressMode.Wrap;
BaseGame.Device.SamplerStates[0].AddressV = TextureAddressMode.Wrap;
// Restore normal alpha blending
//BaseGame.Device.RenderState.BlendFunction = BlendFunction.Add;
BaseGame.SetCurrentAlphaMode(BaseGame.AlphaMode.Default);
}
/// <summary>
/// the mesh is drawn by using the vertexData.
/// When the userPrimitive member is set to true,
/// it is drawn without using the vertex buffer and the index buffer.
/// </summary>
/// <param name="renderTracer"></param>
protected override void OnDraw(RenderTracer renderTracer)
{
GraphicsDevice device = renderTracer.Device;
RenderState renderState = device.RenderState;
basicEffect.Texture = this.textureResource;
basicEffect.World = this.TransformedMatrix;
basicEffect.View = renderTracer.View;
basicEffect.Projection = renderTracer.Projection;
basicEffect.LightingEnabled = false;
device.VertexDeclaration = vertexDeclaration;
device.SamplerStates[0].AddressU = TextureAddressMode.Wrap;
device.SamplerStates[0].AddressV = TextureAddressMode.Wrap;
device.SamplerStates[0].MinFilter = TextureFilter.Linear;
device.SamplerStates[0].MagFilter = TextureFilter.Linear;
device.SamplerStates[0].MipFilter = TextureFilter.Point;
renderState.AlphaTestEnable = alphaTestEnable;
renderState.AlphaBlendEnable = alphaBlendEnable;
renderState.AlphaFunction = alphaFunction;
renderState.SourceBlend = sourceBlend;
renderState.DestinationBlend = destinationBlend;
renderState.BlendFunction = blendFunction;
renderState.ReferenceAlpha = referenceAlpha;
renderState.DepthBufferEnable = depthBufferEnable;
renderState.DepthBufferWriteEnable = depthBufferWriteEnable;
renderState.DepthBufferFunction = depthBufferFunction;
renderState.CullMode = cullMode;
basicEffect.Begin();
for (int i = 0; i < basicEffect.CurrentTechnique.Passes.Count; i++)
{
EffectPass pass = basicEffect.CurrentTechnique.Passes[i];
pass.Begin();
if (userPrimitive)
{
// Use index?
if (indexData != null)
{
// only use vertex and index data
device.DrawUserIndexedPrimitives <VertexPositionColorTexture>(
PrimitiveType.TriangleList,
vertexData,
0,
vertexData.Length,
indexData,
0,
this.primitiveCount);
}
else
{
device.DrawUserPrimitives <VertexPositionColorTexture>(
PrimitiveType.TriangleList,
vertexData,
0,
this.primitiveCount);
}
}
else
{
// Use vertex buffer
device.Vertices[0].SetSource(vertexBuffer,
0,
VertexPositionColorTexture.SizeInBytes);
// Use index?
if (indexBuffer != null)
{
// Use index buffer
device.Indices = indexBuffer;
device.DrawIndexedPrimitives(PrimitiveType.TriangleList,
0,
0,
updateVertexCount,
0,
this.primitiveCount);
}
else
{
device.DrawPrimitives(PrimitiveType.TriangleList,
0,
this.primitiveCount);
}
}
pass.End();
}
basicEffect.End();
device.RenderState.DepthBufferWriteEnable = true;
}
/// <summary>
/// Draws the current frame
/// </summary>
/// <param name="gameTime">The game time</param>
public override void Draw(GameTime gameTime)
{
try
{
int index = 0;
// Update all the effects with the palette and world and draw the meshes
for (int i = 0; i < numMeshes; i++)
{
ModelMesh mesh = model.Meshes[i];
// The starting index for the modelEffects array
int effectStartIndex = index;
if (matrixPaletteParams[index] != null)
{
foreach (Effect effect in mesh.Effects)
{
worldParams[index].SetValue(
world);
matrixPaletteParams[index].SetValue(palette[i]);
index++;
}
}
else
{
foreach (Effect effect in mesh.Effects)
{
worldParams[index].SetValue(pose[mesh.ParentBone.Index] * world);
index++;
}
}
int numParts = mesh.MeshParts.Count;
GraphicsDevice device = mesh.VertexBuffer.GraphicsDevice;
device.Indices = mesh.IndexBuffer;
for (int j = 0; j < numParts; j++)
{
ModelMeshPart currentPart = mesh.MeshParts[j];
if (currentPart.NumVertices == 0 || currentPart.PrimitiveCount == 0)
{
continue;
}
Effect currentEffect = modelEffects[effectStartIndex + j];
device.VertexDeclaration = currentPart.VertexDeclaration;
device.Vertices[0].SetSource(mesh.VertexBuffer, currentPart.StreamOffset,
currentPart.VertexStride);
currentEffect.Begin();
EffectPassCollection passes = currentEffect.CurrentTechnique.Passes;
int numPasses = passes.Count;
for (int k = 0; k < numPasses; k++)
{
EffectPass pass = passes[k];
pass.Begin();
device.DrawIndexedPrimitives(PrimitiveType.TriangleList, currentPart.BaseVertex,
0, currentPart.NumVertices, currentPart.StartIndex, currentPart.PrimitiveCount);
pass.End();
}
currentEffect.End();
}
}
}
catch (NullReferenceException)
{
throw new InvalidOperationException("The effects on the model for a " +
"ModelAnimator were changed without calling ModelAnimator.InitializeEffectParams().");
}
catch (InvalidCastException)
{
throw new InvalidCastException("ModelAnimator has thrown an InvalidCastException. This is " +
"likely because the model uses too many bones for the matrix palette. The default palette size "
+ "is 56 for windows and 40 for Xbox.");
}
}
