// Sets up this effect and selects a technique to render with.
protected override string _SetupEffect(SceneRenderState srs, MaterialInstanceData materialData)
{
// For now, we'll accept whatever SimpleMaterial would use.
base._SetupEffect(srs, materialData);
return "Technique1";
}
/// <summary>
/// Updates all the reflections based on their priority.
/// </summary>
/// <param name="srs">The current scene render state.</param>
public void Update(SceneRenderState srs)
{
if (_reflectionList.Count == 0)
return;
#if DEBUG
Profiler.Instance.StartBlock(_updateProfileBlock);
#endif
_frameCounter++;
// is this an odd or even numbered frame?
evenFrame = _frameCounter % 2 == 0;
// always update priority 0
updated = _Update(0, srs);
// on even frames, update priority 2
if (evenFrame)
updated = _Update(2, srs);
// on odd frames or if no 2s were updated, update priority 1
if (!evenFrame || !updated)
updated = _Update(1, srs);
// not sure why we need to clear depth, but if we don't, messed up things happen
srs.Gfx.Device.Clear(ClearOptions.DepthBuffer, Color.White, 1.0f, 0);
#if DEBUG
Profiler.Instance.EndBlock(_updateProfileBlock);
#endif
}
protected override void _SetupGlobalParameters(SceneRenderState srs, MaterialInstanceData materialData)
{
Assert.Fatal(_texture != null, "PostProcessMaterial._SetupGlobalParameters - Texture has not been set!");
base._SetupGlobalParameters(srs, materialData);
_baseTextureParameter.SetValue(_texture);
}
public override void Render(int frame, int matFrame, Material[] materialList, SceneRenderState srs)
{
Vector3 cameraCenter = srs.CameraPosition;
DrawPrimitive.Set(_vb.Instance, _ib.Instance, _verts.Length, 0, GFXVertexFormat.VertexSize, GFXVertexFormat.GetVertexDeclaration(srs.Gfx.Device));
int nextCluster = _startCluster;
do
{
// Render the cluster...
for (int i = _clusters[nextCluster].StartPrimitive; i < _clusters[nextCluster].EndPrimitive; i++)
{
DrawPrimitive.SetMaterial(_primitives[i].MaterialIndex & DrawPrimitive.MaterialMask, materialList, ref _bounds, srs);
DrawPrimitive.Render(_primitives[i].MaterialIndex & DrawPrimitive.TypeMask, _primitives[i].Start, _primitives[i].NumElements);
}
// determine Next cluster...
if (_clusters[nextCluster].FrontCluster != _clusters[nextCluster].BackCluster)
{
float dot = _clusters[nextCluster].Normal.X * cameraCenter.X +
_clusters[nextCluster].Normal.Y * cameraCenter.Y +
_clusters[nextCluster].Normal.Z * cameraCenter.Z;
// this is opposite of TGE (i.e., -dot rather than dot).
nextCluster = (-dot > _clusters[nextCluster].K) ? _clusters[nextCluster].FrontCluster : _clusters[nextCluster].BackCluster;
}
else
{
nextCluster = _clusters[nextCluster].FrontCluster;
}
} while (nextCluster >= 0);
DrawPrimitive.Clear();
}
protected override string _SetupEffect(SceneRenderState srs, MaterialInstanceData materialData)
{
if (_blendAmount < 1.0f)
{
srs.Gfx.Device.RenderState.AlphaBlendEnable = true;
srs.Gfx.Device.RenderState.SourceBlend = Blend.SourceAlpha;
srs.Gfx.Device.RenderState.DestinationBlend = Blend.InverseSourceAlpha;
}
return "CopyTechnique";
}
protected override void _SetupObjectParameters(RenderInstance renderInstance, SceneRenderState srs)
{
base._SetupObjectParameters(renderInstance, srs);
EffectManager.SetParameter(_worldViewProjectionParameter, renderInstance.ObjectTransform * srs.View * srs.Projection);
EffectManager.SetParameter(_opacityParameter, renderInstance.Opacity);
ITextureMaterial material = renderInstance.Material as ITextureMaterial;
if (material != null && !material.Texture.IsNull)
EffectManager.SetParameter(_baseTextureParameter, material.Texture.Instance);
}
public override void RenderTranslucentPass(SceneRenderState srs)
{
#if DEBUG
Profiler.Instance.StartBlock(_renderProfileBlock);
#endif
base.RenderOpaquePass(srs);
base.RenderTranslucentPass(srs);
#if DEBUG
Profiler.Instance.EndBlock(_renderProfileBlock);
#endif
}
public override void Sort(SceneRenderState srs)
{
#if DEBUG
Profiler.Instance.StartBlock(_sortProfileBlock);
#endif
if (srs.SceneGraph is T2DSceneGraph)
_elementList.Sort(_2DComparer);
#if DEBUG
Profiler.Instance.EndBlock(_sortProfileBlock);
#endif
}
protected override void _SetupObjectParameters(RenderInstance renderInstance, SceneRenderState srs)
{
base._SetupObjectParameters(renderInstance, srs);
BasicEffect basicEffect = _effect.Instance as BasicEffect;
if (basicEffect != null)
basicEffect.World = renderInstance.ObjectTransform;
else
{
EffectParameter worldParam = _effect.Instance.Parameters["World"];
worldParam.SetValue(srs.World.Top);
}
}
public override void RenderTranslucentPass(SceneRenderState srs)
{
// Make sure we have something to render.
if (_elementList.Count == 0 ||
srs.IsReflectPass ||
GFXDevice.Instance.ShaderProfile < ShaderProfile.PS_1_4)
return;
// Get the current render target which contains the state
// of the scene rendered so far.
RenderTarget2D sceneTarget = GFXDevice.Instance.Device.GetRenderTarget(0) as RenderTarget2D;
if (sceneTarget == null)
return;
#if DEBUG
Profiler.Instance.StartBlock(_renderProfileBlock);
#endif
// So here we're making a copy of the current state of the
// active scene render target for use in the refraction effect.
// Prepare the copy material if we don't have one.
if (_copyMaterial == null)
{
_copyMaterial = new SimpleMaterial();
_copyMaterial.IsCopyPass = true;
}
// Copy the content of the current scene render target to
// the refraction texture.
GFXDevice.Instance.Device.SetRenderTarget(0, null);
_refractionTexture = sceneTarget.GetTexture();
// Now set back the scene render target.
//
// At this point the act of switching render targets has
// forced the content to be lost. To fix that we do a
// copy to get the original content back.
//
_copyMaterial.SetTexture(_refractionTexture);
TorqueEngineComponent.Instance.ReapplyMainRenderTarget();
SceneRenderer.RenderManager.RenderQuad(_copyMaterial, Vector2.Zero, new Vector2(sceneTarget.Width, sceneTarget.Height));
// Now render all the refraction meshes.
base.RenderOpaquePass(srs);
#if DEBUG
Profiler.Instance.EndBlock(_renderProfileBlock);
#endif
}
protected override void _SetupGlobalParameters(SceneRenderState srs, MaterialInstanceData materialData)
{
base._SetupGlobalParameters(srs, materialData);
BasicEffect basicEffect = _effect.Instance as BasicEffect;
if (basicEffect != null)
{
basicEffect.EnableDefaultLighting();
basicEffect.View = srs.View;
basicEffect.Projection = srs.Projection;
}
else
{
EffectParameter viewParam = _effect.Instance.Parameters["View"];
viewParam.SetValue(srs.View);
EffectParameter projectionParam = _effect.Instance.Parameters["Projection"];
projectionParam.SetValue(srs.Projection);
}
}
public override void RenderOpaquePass(SceneRenderState srs)
{
if (_elementList.Count == 0 || srs.IsReflectPass)
return;
T2DSceneGraph sceneGraph = srs.SceneGraph as T2DSceneGraph;
Assert.Fatal(sceneGraph != null, "T2DRenderManager.RenderOpaquePass - 2D elements should not be added to a 3D scenegraph!");
// always use alpha blending
srs.Gfx.Device.RenderState.AlphaBlendEnable = true;
// if the depth buffer isn't being used, disable it
if (!sceneGraph.UseDepthBuffer)
srs.Gfx.Device.RenderState.DepthBufferEnable = false;
// The depth buffer is enabled, but not in a z pass, so we need alpha testing to keep transparent
// parts of textures out of the z buffer.
else if (!sceneGraph.DoZPass)
{
srs.Gfx.Device.RenderState.AlphaTestEnable = true;
srs.Gfx.Device.RenderState.ReferenceAlpha = 255;
}
// render objects as normal
_RenderDiffuse(srs, srs.Gfx.Device);
// in case a 3D object was the last thing rendered
if (_rendering3D)
_Cleanup3DState(srs, srs.Gfx.Device);
// cleanup render states
if (!sceneGraph.UseDepthBuffer)
srs.Gfx.Device.RenderState.DepthBufferEnable = true;
else if (!sceneGraph.DoZPass)
srs.Gfx.Device.RenderState.AlphaTestEnable = false;
srs.Gfx.Device.RenderState.AlphaBlendEnable = false;
}
protected override string _SetupEffect(SceneRenderState srs, MaterialInstanceData materialData)
{
srs.Gfx.Device.RenderState.DestinationBlend = Blend.InverseSourceAlpha;
srs.Gfx.Device.RenderState.SourceBlend = Blend.SourceAlpha;
return base._SetupEffect(srs, materialData);
}
public override void RenderOpaquePass(SceneRenderState srs)
{
}
protected override void _RenderGroup(List<RenderInstance> renderInstances, RenderMaterial material, MaterialInstanceData materialData, SceneRenderState srs, GraphicsDevice d3d)
{
(material as IRefractionMaterial).SetTexture(_refractionTexture);
base._RenderGroup(renderInstances, material, materialData, srs, d3d);
}
public override void RenderZPass(SceneRenderState srs)
{
}
void _RenderMesh(ref ObjectInstance obj, int objectDetail, Material[] materialList, SceneRenderState srs)
{
if (obj.Visibility > 0.01f)
{
mesh = _GetMesh(ref obj.Object, objectDetail);
if (mesh != null)
{
srs.World.Push();
if (obj.Object.NodeIndex >= 0)
srs.World.MultiplyMatrixLocal(_nodeTransforms[obj.Object.NodeIndex]);
mesh.Render(obj.Frame, obj.MaterialFrame, materialList, srs);
srs.World.Pop();
}
}
}
/// <summary>
/// Select a detail level given the specified scene render state.
/// </summary>
/// <param name="srs">The scene render state to base detail level selection on.</param>
/// <returns>The detail level to use.</returns>
public int SelectCurrentDetail(SceneRenderState srs)
{
if (_shape.DetailLevelCount == 1)
{
_currentDetailLevel = 0;
return 0;
}
Matrix world = srs.World.Top;
Vector3 p;
Vector3.Transform(ref _shape.Center, ref world, out p);
p -= srs.CameraPosition;
float dist = p.LengthSquared(); ;
x = world.Left;
y = world.Forward;
z = world.Up;
float scale = x.LengthSquared();
scale += y.LengthSquared();
scale += z.LengthSquared();
scale *= 0.3334f;
dist /= scale;
dist = (float)Math.Sqrt(dist);
float pixelRadius = srs.Gfx.ProjectRadius(dist, _shape.Radius);
return SelectCurrentDetail(pixelRadius);
}
/// <summary>
/// Renders the shape.
/// </summary>
/// <param name="dl">The detail level to render at.</param>
/// <param name="intraDL">Unused</param>
/// <param name="objectScale">Unused</param>
/// <param name="srs">The current render state of the scene.</param>
/// <param name="hidden">Bitmask of the mesh indices that should not be rendered.</param>
public void Render(int dl, float intraDL, Vector3 objectScale, SceneRenderState srs, int hidden)
{
// if dl==-1, nothing to do
if (dl == -1)
return;
Assert.Fatal(dl >= 0 && dl < _shape.DetailLevelCount, "ShapeInstance.render - Invalid detail level.");
ss = _shape.Details[dl].SubShapeNumber;
od = _shape.Details[dl].ObjectDetailNumber;
if (ss < 0)
return;
// Set up static data
_SetStatics(dl, intraDL, objectScale);
_shape.CreateVBIB(srs.Gfx.Device);
// Set up animating ifl materials
for (int i = 0; i < _iflMaterialInstances.Length; i++)
_materialList[_iflMaterialInstances[i].IflMaterial.MaterialSlot] = _materialList[_iflMaterialInstances[i].IflMaterial.FirstFrame + _iflMaterialInstances[i].Frame];
// run through the meshes
start = !_renderNonTranslucent ? _shape.SubShapeFirstTranslucentObject[ss] : _shape.SubShapeFirstObject[ss];
end = !_renderTranslucent ? _shape.SubShapeFirstTranslucentObject[ss] : _shape.SubShapeFirstObject[ss] + _shape.SubShapeObjectCount[ss];
for (int i = start; i < end; i++)
{
if ((1 << i & hidden) > 0)
continue;
_RenderMesh(ref _meshObjects[i], od, _materialList, srs);
}
_ClearStatics();
}
protected void _InitDynamic(int size, CubemapCamera camera)
{
if (!_cubeTexture.IsNull)
return;
_camera = camera;
_sceneRenderState = new SceneRenderState();
_renderTarget = ResourceManager.Instance.CreateRenderTargetCube(size);
// resolve faces of cube texture for the xbox
for (int i = 0; i < 6; ++i)
{
GFXDevice.Instance.Device.SetRenderTarget(0, _renderTarget.Instance, (CubeMapFace)i);
}
// reset render target
TorqueEngineComponent.Instance.ReapplyMainRenderTarget();
_cubeTexture = ResourceManager.Instance.CreateTextureCube(_renderTarget);
}
protected override void _SetupGlobalParameters(SceneRenderState srs, MaterialInstanceData materialData)
{
base._SetupGlobalParameters(srs, materialData);
if (!_texture.IsNull)
EffectManager.SetParameter(_baseTextureParameter, CurrentVideoFrameTexture.Instance);
}
protected override string _SetupEffect(SceneRenderState srs, MaterialInstanceData materialData)
{
if (!_textureMissing && (_texture.IsNull || _texture.IsInvalid) && !string.IsNullOrEmpty(_textureFilename))
{
_texture = ResourceManager.Instance.LoadTexture(_textureFilename);
if (_texture.IsNull)
_textureMissing = true;
}
if (_isCopyPass)
return "CopyTechnique";
if (!_texture.IsNull)
{
if (_isColorBlended)
return "ColorTextureBlendTechnique";
return "TexturedTechnique";
}
return "ColoredTechnique";
}
protected override void _SetupGlobalParameters(SceneRenderState srs, MaterialInstanceData materialData)
{
base._SetupGlobalParameters(srs, materialData);
EffectManager.SetParameter(_opacityParameter, _blendAmount);
EffectManager.SetParameter(_worldViewProjectionParameter, Matrix.Identity);
}
public override void Render(SceneRenderState srs)
{
GraphicsDevice d3d = srs.Gfx.Device;
Assert.Fatal(d3d != null, "doh");
if (_vertices == null)
return;
if (_vb.IsNull)
_CreateVB();
if (_refillVB)
_FillVB();
if (_polyDirty)
_UpdateCollisionPoly();
Vector3 ScaleVector = new Vector3(0.5f * Size.X, 0.5f * Size.Y, 1);
// scale, translate, rotate
Matrix ScaleMatrix = Matrix.CreateScale(ScaleVector);
Matrix TranslationMatrix = Matrix.CreateTranslation(new Vector3(Position.X, Position.Y, LayerDepth));
Matrix RotationMatrix = Matrix.CreateRotationZ(MathHelper.ToRadians(Rotation));
Matrix objToWorld = ScaleMatrix * RotationMatrix * TranslationMatrix;
int numVerts = _vertices.Length + 1;
srs.World.Push();
srs.World.MultiplyMatrixLocal(objToWorld);
RenderInstance ri = SceneRenderer.RenderManager.AllocateInstance();
ri.Type = RenderInstance.RenderInstanceType.Mesh2D;
ri.ObjectTransform = srs.World.Top;
ri.VertexBuffer = _vb.Instance;
ri.PrimitiveType = PrimitiveType.LineStrip;
ri.VertexSize = GFXVertexFormat.VertexSize;
ri.VertexDeclaration = GFXVertexFormat.GetVertexDeclaration(d3d);
ri.VertexCount = numVerts;
ri.BaseVertex = 0;
ri.PrimitiveCount = numVerts - 1;
ri.Opacity = VisibilityLevel;
ri.UTextureAddressMode = TextureAddressMode.Clamp;
ri.VTextureAddressMode = TextureAddressMode.Clamp;
ri.Material = _material;
SceneRenderer.RenderManager.AddInstance(ri);
srs.World.Pop();
base.Render(srs);
}
protected override void _SetupGlobalParameters(SceneRenderState srs, MaterialInstanceData materialData)
{
base._SetupGlobalParameters(srs, materialData);
if (_texture.Instance != null && _texture.Instance.IsDisposed)
_texture.Invalidate();
if (!_texture.IsNull)
EffectManager.SetParameter(_baseTextureParameter, Texture.Instance);
}
protected override void _SetupGlobalParameters(SceneRenderState srs, MaterialInstanceData materialData)
{
base._SetupGlobalParameters(srs, materialData);
EffectManager.SetParameter(_fogColorParameter, _fogColor);
EffectManager.SetParameter(_fogNearDistanceParameter, _fogNearDistance);
EffectManager.SetParameter(_fogFarDistanceParameter, _fogFarDistance);
EffectManager.SetParameter(_camPosParameter, srs.CameraPosition);
}
protected override string _SetupEffect(SceneRenderState srs, MaterialInstanceData materialData)
{
if ((_texture.IsNull || _texture.IsInvalid) && !string.IsNullOrEmpty(VideoFilename))
_texture = ResourceManager.Instance.CreateResource<Texture2D>(_videoPlayer.GetTexture());
if (_isCopyPass)
return "CopyTechnique";
if (!_texture.IsNull)
{
if (_isColorBlended)
return "ColorTextureBlendTechnique";
return "TexturedTechnique";
}
return "ColoredTechnique";
}
protected override void _SetupObjectParameters(RenderInstance renderInstance, SceneRenderState srs)
{
base._SetupObjectParameters(renderInstance, srs);
EffectManager.SetParameter(_worldMatrixParameter, renderInstance.ObjectTransform);
EffectManager.SetParameter(_worldViewProjectionParameter, renderInstance.ObjectTransform * srs.View * srs.Projection);
}
protected override void _SetupObjectParameters(RenderInstance renderInstance, SceneRenderState srs)
{
base._SetupObjectParameters(renderInstance, srs);
EffectManager.SetParameter(_worldViewProjectionParameter, renderInstance.ObjectTransform * srs.View * srs.Projection);
if (IsTranslucent)
EffectManager.SetParameter(_opacityParameter, renderInstance.Opacity * _opacity);
}
public override void Render(SceneRenderState srs)
{
#if DEBUG
Profiler.Instance.StartBlock("T2DParticleEffect.Render");
#endif
// Any effect-data?
if (CurrentEffectData == null)
{
// No, so finish here.
#if DEBUG
Profiler.Instance.EndBlock("T2DParticleEffect.Render");
#endif
return;
}
// Any particle allocations?
if (_currentParticleAllocations == 0)
{
// No, so finish here.
#if DEBUG
Profiler.Instance.EndBlock("T2DParticleEffect.Render");
#endif
return;
}
// Update Render Batch.
_UpdateRenderBatch();
// Fetch Graphics Device.
GraphicsDevice d3d = srs.Gfx.Device;
// Sanity!
Assert.Fatal(d3d != null, "Could not acquire graphics device!");
// MM: This'll do for now!
_tangent = new Vector4(MatrixUtil.MatrixGetRow(0, ref srs._camTrans), 1.0f);
_normal = new Vector4(MatrixUtil.MatrixGetRow(2, ref srs._camTrans), 0.0f);
// Calculate Vertex Count.
int vertexCount = _currentParticleAllocations * 4;
// Create Scratch Vertex Array.
GFXVertexFormat.PCTTBN[] _vertexScratch = TorqueUtil.GetScratchArray<GFXVertexFormat.PCTTBN>(vertexCount);
// Sanity!
Assert.Fatal(_vertexScratch != null, "Invalid vertex scratch!");
int vertexOffset = 0;
// Enumerate Emitters.
foreach (T2DParticleEmitter emitter in _emitterList)
{
// Is emitter showing and has some particles allocated?
if (!emitter.CurrentEmitterData.Hidden && emitter.Allocated > 0)
{
_textureCoords = emitter.CurrentEmitterData.TextureCoords;
// Create Render Instance.
RenderInstance ri = SceneRenderer.RenderManager.AllocateInstance();
ri.Type = RenderInstance.RenderInstanceType.Mesh2D;
// Sanity!
Assert.Fatal(_vertexScratch != null, "Invalid vertex scratch!");
// Populate Render Instance.
ri.ObjectTransform = emitter.ParticleRenderTransform;
ri.VertexBuffer = _vertexBuffer.Instance;
ri.IndexBuffer = _indexBuffer.Instance;
ri.BaseVertex = vertexOffset;
ri.StartIndex = 0;
ri.PrimitiveType = PrimitiveType.TriangleList;
ri.PrimitiveCount = emitter.Allocated * 2;
ri.VertexCount = emitter.Allocated * 4;
ri.VertexSize = GFXVertexFormat.VertexSize;
ri.VertexDeclaration = GFXVertexFormat.GetVertexDeclaration(GFXDevice.Instance.Device);
ri.Opacity = VisibilityLevel;
ri.UTextureAddressMode = TextureAddressMode.Clamp;
ri.VTextureAddressMode = TextureAddressMode.Clamp;
ri.Material = emitter.CurrentEmitterData.Material;
// Render Emitter.
emitter.RenderEmitter(_vertexScratch,
ref vertexOffset,
_textureCoords,
ref _normal,
ref _tangent);
// Add Render Instance to Render Manager.
SceneRenderer.RenderManager.AddInstance(ri);
}
}
// Sanity!
Assert.Fatal(vertexOffset <= vertexCount, "Vertex Count Mismatch rendering effect!");
// NOTE:- It's important to note that the vertex offsets may not realize the vertex
// counts as emitters can be hidden and therefore won't contribute to the offset
// into the vertex buffers.
//
// JMQ: except that if you pass a zero vertexOffset into the SetData function, it
// will throw an exception. Added a check for that.
//
if (vertexCount != 0 && vertexOffset > 0)
{
GFXDevice.Instance.Device.Vertices[0].SetSource(null, 0, 0);
#if XBOX
_vertexBuffer.Instance.SetData<GFXVertexFormat.PCTTBN>(_vertexScratch, 0, vertexOffset);
#else
_vertexBuffer.Instance.SetData<GFXVertexFormat.PCTTBN>(_vertexScratch, 0, vertexOffset, SetDataOptions.Discard);
#endif
}
_vertexScratch = null;
// Base Render.
base.Render(srs);
#if DEBUG
Profiler.Instance.EndBlock("T2DParticleEffect.Render");
#endif
}
