public override bool PreAddToRenderState( TargetRenderState targetRenderState, Pass srcPass, Pass dstPass )
{
//count the number of texture units we need to process
int validTexUnits = 0;
for ( int i = 0; i < srcPass.TextureUnitStatesCount; i++ )
{
if ( IsProcessingNeeded( srcPass.GetTextureUnitState( i ) ) )
{
validTexUnits++;
}
}
SetTextureUnitCount( validTexUnits );
//Build texture stage sub states
for ( int i = 0; i < srcPass.TextureUnitStatesCount; i++ )
{
TextureUnitState texUnitState = srcPass.GetTextureUnitState( i );
if ( IsProcessingNeeded( texUnitState ) )
{
SetTextureUnit( i, texUnitState );
}
}
return true;
}
UpdateGpuProgramsParams( IRenderable rend, Pass pass, AutoParamDataSource source,
Core.Collections.LightList lightList )
{
if ( this.reflectionPowerChanged )
{
GpuProgramParameters fsParams = pass.FragmentProgramParameters;
this.reflectionPower.SetGpuParameter( this.reflectionPowerValue );
this.reflectionPowerChanged = false;
}
}
public override void UpdateGpuProgramsParams( IRenderable rend, Pass pass, AutoParamDataSource source,
Core.Collections.LightList lightList )
{
if ( this.fogMode == FogMode.None )
{
return;
}
FogMode fMode;
ColorEx newFogColor;
Real newFogStart, newFogEnd, newFogDensity;
if ( this.passOverrideParams )
{
fMode = pass.FogMode;
newFogColor = pass.FogColor;
newFogStart = pass.FogStart;
newFogEnd = pass.FogEnd;
newFogDensity = pass.FogDensity;
}
else
{
var sceneMgr = ShaderGenerator.Instance.ActiveSceneManager;
fMode = sceneMgr.FogMode;
newFogColor = sceneMgr.FogColor;
newFogStart = sceneMgr.FogStart;
newFogEnd = sceneMgr.FogEnd;
newFogDensity = sceneMgr.FogDensity;
}
SetFogProperties( fMode, newFogColor, newFogStart, newFogEnd, newFogDensity );
//Per pixel fog
if ( this.calcMode == CalcMode.PerPixel )
{
this.fogParams.SetGpuParameter( this.fogParamsValue );
}
//per vertex fog
else
{
this.fogParams.SetGpuParameter( this.fogParamsValue );
}
this.fogColor.SetGpuParameter( this.fogColorValue );
}
public override void UpdateGpuProgramsParams( IRenderable rend, Pass pass, AutoParamDataSource source,
Core.Collections.LightList lightList )
{
for ( int i = 0; i < this.textureUnitParamsList.Count; i++ )
{
TextureUnitParams curParams = this.textureUnitParamsList[ i ];
if ( curParams.TextureProjector != null && curParams.TextureViewProjImageMatrix != null )
{
Matrix4 matTexViewProjImage;
matTexViewProjImage = Matrix4.ClipSpace2DToImageSpace*
curParams.TextureProjector.ProjectionMatrixRSDepth*
curParams.TextureProjector.ViewMatrix;
curParams.TextureViewProjImageMatrix.SetGpuParameter( matTexViewProjImage );
}
}
}
public override bool PreAddToRenderState( TargetRenderState targetRenderState, Pass srcPass, Pass dstPass )
{
TextureUnitState textureUnit;
//Create the mask texture unit.
textureUnit = dstPass.CreateTextureUnitState();
textureUnit.SetTextureName( this.maskMapTextureName );
this.maskMapSamplerIndex = dstPass.TextureUnitStatesCount - 1;
//Create the reflection texture unit.
textureUnit = dstPass.CreateTextureUnitState();
if ( this.reflectionMapType == TextureType.TwoD )
{
textureUnit.SetTextureName( this.reflectionMapTextureName );
}
else
{
textureUnit.SetCubicTextureName( this.reflectionMapTextureName, true );
}
this.reflectionMapSamplerIndex = dstPass.TextureUnitStatesCount - 1;
return true;
}
/// <summary>
/// Render something as if it came from the current queue.
/// </summary>
///<param name="pass">Material pass to use for setting up this quad.</param>
///<param name="rend">Renderable to render</param>
///<param name="shadowDerivation">Whether passes should be replaced with shadow caster / receiver passes</param>
public virtual void InjectRenderWithPass( Pass pass, IRenderable rend, bool shadowDerivation )
{
// render something as if it came from the current queue
Pass usedPass = this.SetPass( pass, false, shadowDerivation );
this.RenderSingleObject( rend, usedPass, false );
}
/// <summary>
/// Internal method to validate whether a Pass should be allowed to render.
/// </summary>
/// <remarks>
/// Called just before a pass is about to be used for rendering a group to
/// allow the SceneManager to omit it if required. A return value of false
/// skips this pass.
/// </remarks>
protected virtual bool ValidatePassForRendering( Pass pass )
{
// Bypass if we're doing a texture shadow render and
// this pass is after the first (only 1 pass needed for shadow texture)
if ( !this.suppressShadows && this.currentViewport.ShowShadows &&
( ( this.IsShadowTechniqueModulative
&& this.illuminationStage == IlluminationRenderStage.RenderReceiverPass ) ||
this.illuminationStage == IlluminationRenderStage.RenderToTexture || this.suppressRenderStateChanges ) &&
pass.Index > 0 )
{
return false;
}
return true;
}
protected void RenderSingleObject( IRenderable renderable, Pass pass, bool doLightIteration )
{
this.RenderSingleObject( renderable, pass, doLightIteration, null );
}
/// <summary>
/// If only the first two parameters are supplied
/// </summary>
public virtual Pass SetPass( Pass pass, bool evenIfSuppressed )
{
return this.SetPass( pass, evenIfSuppressed, true );
}
/// <summary>Internal method for setting up the renderstate for a rendering pass.</summary>
/// <param name="pass">The Pass details to set.</param>
/// <param name="evenIfSuppressed">
/// Sets the pass details even if render state
/// changes are suppressed; if you are using this to manually set state
/// when render state changes are suppressed, you should set this to true.
/// </param>
/// <param name="shadowDerivation">
/// If false, disables the derivation of shadow passes from original passes
/// </param>
/// <returns>
/// A Pass object that was used instead of the one passed in, can
/// happen when rendering shadow passes
/// </returns>
public virtual Pass SetPass( Pass pass, bool evenIfSuppressed, bool shadowDerivation )
{
if ( !this.suppressRenderStateChanges || evenIfSuppressed )
{
if ( this.illuminationStage == IlluminationRenderStage.RenderToTexture && shadowDerivation )
{
// Derive a special shadow caster pass from this one
pass = this.DeriveShadowCasterPass( pass );
}
else if ( this.illuminationStage == IlluminationRenderStage.RenderReceiverPass )
{
pass = this.DeriveShadowReceiverPass( pass );
}
//TODO :autoParamDataSource.SetPass( pass );
bool passSurfaceAndLightParams = true;
if ( pass.HasVertexProgram )
{
this.targetRenderSystem.BindGpuProgram( pass.VertexProgram.BindingDelegate );
// bind parameters later since they can be per-object
// does the vertex program want surface and light params passed to rendersystem?
passSurfaceAndLightParams = pass.VertexProgram.PassSurfaceAndLightStates;
}
else
{
// Unbind program?
if ( this.targetRenderSystem.IsGpuProgramBound( GpuProgramType.Vertex ) )
{
this.targetRenderSystem.UnbindGpuProgram( GpuProgramType.Vertex );
}
// Set fixed-function vertex parameters
}
if ( passSurfaceAndLightParams )
{
// Set surface reflectance properties, only valid if lighting is enabled
if ( pass.LightingEnabled )
{
this.targetRenderSystem.SetSurfaceParams( pass.Ambient,
pass.Diffuse,
pass.Specular,
pass.Emissive,
pass.Shininess,
pass.VertexColorTracking );
}
// #if NOT_IN_OGRE
else
{
// even with lighting off, we need ambient set to white
this.targetRenderSystem.SetSurfaceParams( ColorEx.White,
ColorEx.Black,
ColorEx.Black,
ColorEx.Black,
0,
TrackVertexColor.None );
}
// #endif
// Dynamic lighting enabled?
this.targetRenderSystem.LightingEnabled = pass.LightingEnabled;
}
// Using a fragment program?
if ( pass.HasFragmentProgram )
{
this.targetRenderSystem.BindGpuProgram( pass.FragmentProgram.BindingDelegate );
// bind parameters later since they can be per-object
}
else
{
// Unbind program?
if ( this.targetRenderSystem.IsGpuProgramBound( GpuProgramType.Fragment ) )
{
this.targetRenderSystem.UnbindGpuProgram( GpuProgramType.Fragment );
}
}
// Set fixed-function fragment settings
//We need to set fog properties always. In D3D, it applies to shaders prior
//to version vs_3_0 and ps_3_0. And in OGL, it applies to "ARB_fog_XXX" in
//fragment program, and in other ways, they maybe accessed by gpu program via
//"state.fog.XXX".
// New fog params can either be from scene or from material
// jsw - set the fog for both fixed function and fragment programs
ColorEx newFogColor;
FogMode newFogMode;
float newFogDensity, newFogStart, newFogEnd;
// does the pass want to override the fog mode?
if ( pass.FogOverride )
{
// New fog params from material
newFogMode = pass.FogMode;
newFogColor = pass.FogColor;
newFogDensity = pass.FogDensity;
newFogStart = pass.FogStart;
newFogEnd = pass.FogEnd;
}
else
{
// New fog params from scene
newFogMode = this.fogMode;
newFogColor = this.fogColor;
newFogDensity = this.fogDensity;
newFogStart = this.fogStart;
newFogEnd = this.fogEnd;
}
// set fog params
/*
float fogScale = 1f;
if ( newFogMode == FogMode.None )
{
fogScale = 0f;
}
*/
// set fog using the render system
this.targetRenderSystem.SetFog( newFogMode, newFogColor, newFogDensity, newFogStart, newFogEnd );
// Tell params about ORIGINAL fog
// Need to be able to override fixed function fog, but still have
// original fog parameters available to a shader that chooses to use
// TODO: autoParamDataSource.SetFog( fogMode, fogColor, fogDensity, fogStart, fogEnd );
// The rest of the settings are the same no matter whether we use programs or not
// Set scene blending
this.targetRenderSystem.SetSceneBlending( pass.SourceBlendFactor, pass.DestinationBlendFactor );
// TODO : Set point parameters
//targetRenderSystem.SetPointParameters(
// pass.PointSize,
// pass.IsPointAttenuationEnabled,
// pass.PointAttenuationConstant,
// pass.PointAttenuationLinear,
// pass.PointAttenuationQuadratic,
// pass.PointMinSize,
// pass.PointMaxSize
// );
//targetRenderSystem.PointSpritesEnabled = pass.PointSpritesEnabled;
// TODO : Reset the shadow texture index for each pass
//foreach ( TextureUnitState textureUnit in pass.TextureUnitStates )
//{
//}
// set all required texture units for this pass, and disable ones not being used
int numTextureUnits = this.targetRenderSystem.Capabilities.TextureUnitCount;
if ( pass.HasFragmentProgram && pass.FragmentProgram.IsSupported )
{
numTextureUnits = pass.FragmentProgram.SamplerCount;
}
else if ( Config.MaxTextureLayers < this.targetRenderSystem.Capabilities.TextureUnitCount )
{
numTextureUnits = Config.MaxTextureLayers;
}
for ( int i = 0; i < numTextureUnits; i++ )
{
if ( i < pass.TextureUnitStageCount )
{
TextureUnitState texUnit = pass.GetTextureUnitState( i );
targetRenderSystem.SetTextureUnitSettings( i, texUnit );
//this.targetRenderSystem.SetTextureUnit( i, texUnit, !pass.HasFragmentProgram );
}
else
{
// disable this unit
if ( !pass.HasFragmentProgram )
{
this.targetRenderSystem.DisableTextureUnit( i );
}
}
}
// Disable remaining texture units
targetRenderSystem.DisableTextureUnitsFrom(pass.TextureUnitStageCount);
// Depth Settings
this.targetRenderSystem.DepthBufferWriteEnabled = pass.DepthWrite;
this.targetRenderSystem.DepthBufferCheckEnabled = pass.DepthCheck;
this.targetRenderSystem.DepthBufferFunction = pass.DepthFunction;
this.targetRenderSystem.SetDepthBias(pass.DepthBiasConstant);
// Aplha Reject Settings
this.targetRenderSystem.SetAlphaRejectSettings( pass.AlphaRejectFunction, (byte)pass.AlphaRejectValue, pass.IsAlphaToCoverageEnabled );
// Color Write
// right now only using on/off, not per channel
bool colWrite = pass.ColorWriteEnabled;
this.targetRenderSystem.SetColorBufferWriteEnabled( colWrite, colWrite, colWrite, colWrite );
// Culling Mode
this.targetRenderSystem.CullingMode = pass.CullingMode;
// Shading mode
//this.targetRenderSystem.ShadingMode = pass.ShadingMode;
// Polygon Mode
this.targetRenderSystem.PolygonMode = pass.PolygonMode;
// set pass number
this.autoParamDataSource.PassNumber = pass.Index;
}
return pass;
}
/// <summary>
/// Internal method for turning a regular pass into a shadow caster pass.
/// </summary>
/// <remarks>
/// This is only used for texture shadows, basically we're trying to
/// ensure that objects are rendered solid black.
/// This method will usually return the standard solid black pass for
/// all fixed function passes, but will merge in a vertex program
/// and fudge the AutpoParamDataSource to set black lighting for
/// passes with vertex programs.
/// </remarks>
/// <param name="pass"></param>
/// <returns></returns>
protected virtual Pass DeriveShadowCasterPass( Pass pass )
{
if ( this.IsShadowTechniqueTextureBased )
{
Pass retPass;
if ( pass.Parent.ShadowCasterMaterial != null )
{
retPass = pass.Parent.ShadowCasterMaterial.GetBestTechnique().GetPass( 0 );
}
else
{
retPass = ( this.shadowTextureCustomCasterPass != null ? this.shadowTextureCustomCasterPass : this.shadowCasterPlainBlackPass );
}
// Special case alpha-blended passes
if ( ( pass.SourceBlendFactor == SceneBlendFactor.SourceAlpha &&
pass.DestinationBlendFactor == SceneBlendFactor.OneMinusSourceAlpha )
|| pass.AlphaRejectFunction != CompareFunction.AlwaysPass )
{
// Alpha blended passes must retain their transparency
retPass.SetAlphaRejectSettings( pass.AlphaRejectFunction, pass.AlphaRejectValue );
retPass.SetSceneBlending( pass.SourceBlendFactor, pass.DestinationBlendFactor );
retPass.Parent.Parent.TransparencyCastsShadows = true;
// So we allow the texture units, but override the color functions
// Copy texture state, shift up one since 0 is shadow texture
int origPassTUCount = pass.TextureUnitStageCount;
for ( int t = 0; t < origPassTUCount; ++t )
{
TextureUnitState tex;
if ( retPass.TextureUnitStageCount <= t )
{
tex = retPass.CreateTextureUnitState();
}
else
{
tex = retPass.GetTextureUnitState( t );
}
// copy base state
pass.GetTextureUnitState( t ).CopyTo( tex );
// override colour function
tex.SetColorOperationEx( LayerBlendOperationEx.Source1, LayerBlendSource.Manual, LayerBlendSource.Current, this.IsShadowTechniqueAdditive ? ColorEx.Black : shadowColor );
}
// Remove any extras
while ( retPass.TextureUnitStageCount > origPassTUCount )
{
retPass.RemoveTextureUnitState( origPassTUCount );
}
}
else
{
// reset
retPass.SetSceneBlending( SceneBlendType.Replace );
retPass.AlphaRejectFunction = CompareFunction.AlwaysPass;
while ( retPass.TextureUnitStageCount > 0 )
{
retPass.RemoveTextureUnitState( 0 );
}
}
// Propogate culling modes
retPass.CullingMode = pass.CullingMode;
retPass.ManualCullingMode = pass.ManualCullingMode;
// Does incoming pass have a custom shadow caster program?
if ( pass.ShadowCasterVertexProgramName != "" )
{
retPass.SetVertexProgram( pass.ShadowCasterVertexProgramName, false );
GpuProgram prg = retPass.VertexProgram;
// Load this program if not done already
if ( !prg.IsLoaded )
{
prg.Load();
}
// Copy params
retPass.VertexProgramParameters = pass.ShadowCasterVertexProgramParameters;
// Also have to hack the light autoparams, that is done later
}
else
{
// reset vp?
if ( retPass == this.shadowTextureCustomCasterPass )
{
if ( retPass.VertexProgramName != this.shadowTextureCustomCasterVertexProgram )
{
this.shadowTextureCustomCasterPass.SetVertexProgram( this.shadowTextureCustomCasterVertexProgram );
if ( retPass.HasVertexProgram )
{
retPass.VertexProgramParameters = this.shadowTextureCustomCasterVPParams;
}
}
}
else
{
// Standard shadow caster pass, reset to no vp
retPass.SetVertexProgram( "" );
}
}
return retPass;
}
else
{
return pass;
}
}
/// <summary>
/// Copy the details of this pass to the target pass.
/// </summary>
/// <param name="target">Destination pass to copy this pass's attributes to.</param>
public void CopyTo( Pass target )
{
target._name = _name;
target._hashCode = _hashCode;
// surface
target._ambient = _ambient.Clone();
target._diffuse = _diffuse.Clone();
target._specular = _specular.Clone();
target._emissive = _emissive.Clone();
target._shininess = _shininess;
target._tracking = _tracking;
// fog
target._fogOverride = _fogOverride;
target._fogMode = _fogMode;
target._fogColor = _fogColor.Clone();
target._fogStart = _fogStart;
target._fogEnd = _fogEnd;
target._fogDensity = _fogDensity;
// default blending
target._sourceBlendFactor = _sourceBlendFactor;
target._destinationBlendFactor = _destinationBlendFactor;
target._depthCheck = _depthCheck;
target._depthWrite = _depthWrite;
target._alphaRejectFunction = _alphaRejectFunction;
target._alphaRejectValue = _alphaRejectValue;
target._colorWriteEnabled = _colorWriteEnabled;
target._depthFunction = _depthFunction;
target._depthBiasConstant = _depthBiasConstant;
target._depthBiasSlopeScale = _depthBiasSlopeScale;
target._cullingMode = _cullingMode;
target._manualCullingMode = _manualCullingMode;
target._lightingEnabled = _lightingEnabled;
target._maxSimultaneousLights = _maxSimultaneousLights;
target._iteratePerLight = _iteratePerLight;
target._runOnlyForOneLightType = _runOnlyForOneLightType;
target._onlyLightType = _onlyLightType;
target._shadingMode = _shadingMode;
target._polygonMode = _polygonMode;
target.IterationCount = IterationCount;
// vertex program
if ( _vertexProgramUsage != null )
{
target._vertexProgramUsage = _vertexProgramUsage.Clone();
}
else
{
target._vertexProgramUsage = null;
}
// shadow caster vertex program
if ( shadowCasterVertexProgramUsage != null )
{
target.shadowCasterVertexProgramUsage = shadowCasterVertexProgramUsage.Clone();
}
else
{
target.shadowCasterVertexProgramUsage = null;
}
// shadow receiver vertex program
if ( _shadowReceiverVertexProgramUsage != null )
{
target._shadowReceiverVertexProgramUsage = _shadowReceiverVertexProgramUsage.Clone();
}
else
{
target._shadowReceiverVertexProgramUsage = null;
}
// fragment program
if ( _fragmentProgramUsage != null )
{
target._fragmentProgramUsage = _fragmentProgramUsage.Clone();
}
else
{
target._fragmentProgramUsage = null;
}
// shadow caster fragment program
if ( _shadowCasterFragmentProgramUsage != null )
{
target._shadowCasterFragmentProgramUsage = _shadowCasterFragmentProgramUsage.Clone();
}
else
{
target._shadowCasterFragmentProgramUsage = null;
}
// shadow receiver fragment program
if ( _shadowReceiverFragmentProgramUsage != null )
{
target._shadowReceiverFragmentProgramUsage = _shadowReceiverFragmentProgramUsage.Clone();
}
else
{
target._shadowReceiverFragmentProgramUsage = null;
}
// Clear texture units but doesn't notify need recompilation in the case
// we are cloning, The parent material will take care of this.
target.textureUnitStates.Clear();
// Copy texture units
for ( int i = 0; i < textureUnitStates.Count; i++ )
{
TextureUnitState newState = new TextureUnitState( target );
TextureUnitState src = (TextureUnitState)textureUnitStates[ i ];
src.CopyTo( newState );
target.textureUnitStates.Add( newState );
}
target.DirtyHash();
}
/// <summary>
/// Method for cloning a Pass object.
/// </summary>
/// <param name="parent">Parent technique that will own this cloned Pass.</param>
/// <param name="index"></param>
/// <returns></returns>
public Pass Clone( Technique parent, int index )
{
Pass newPass = new Pass( parent, index );
CopyTo( newPass );
// dirty the hash on the new pass
newPass.DirtyHash();
return newPass;
}
public RenderablePass( IRenderable renderable, Pass pass )
{
this.renderable = renderable;
this.pass = pass;
}
protected override void SetupContent()
{
ResourceGroupManager.Instance.InitializeAllResourceGroups();
// setup some basic lighting for our scene
SceneManager.AmbientLight = new ColorEx( 0.5f, 0.5f, 0.5f );
SceneManager.CreateLight( "BezierLight" ).Position = new Vector3( 100, 100, 100 );
// define the control point vertices for our patch
// Patch data
PatchVertex[] patchVertices = new PatchVertex[ 9 ];
patchVertices[ 0 ].X = -500;
patchVertices[ 0 ].Y = 200;
patchVertices[ 0 ].Z = -500;
patchVertices[ 0 ].Nx = -0.5f;
patchVertices[ 0 ].Ny = 0.5f;
patchVertices[ 0 ].Nz = 0;
patchVertices[ 0 ].U = 0;
patchVertices[ 0 ].V = 0;
patchVertices[ 1 ].X = 0;
patchVertices[ 1 ].Y = 500;
patchVertices[ 1 ].Z = -750;
patchVertices[ 1 ].Nx = 0;
patchVertices[ 1 ].Ny = 0.5f;
patchVertices[ 1 ].Nz = 0;
patchVertices[ 1 ].U = 0.5f;
patchVertices[ 1 ].V = 0;
patchVertices[ 2 ].X = 500;
patchVertices[ 2 ].Y = 1000;
patchVertices[ 2 ].Z = -500;
patchVertices[ 2 ].Nx = 0.5f;
patchVertices[ 2 ].Ny = 0.5f;
patchVertices[ 2 ].Nz = 0;
patchVertices[ 2 ].U = 1;
patchVertices[ 2 ].V = 0;
patchVertices[ 3 ].X = -500;
patchVertices[ 3 ].Y = 0;
patchVertices[ 3 ].Z = 0;
patchVertices[ 3 ].Nx = -0.5f;
patchVertices[ 3 ].Ny = 0.5f;
patchVertices[ 3 ].Nz = 0;
patchVertices[ 3 ].U = 0;
patchVertices[ 3 ].V = 0.5f;
patchVertices[ 4 ].X = 0;
patchVertices[ 4 ].Y = 500;
patchVertices[ 4 ].Z = 0;
patchVertices[ 4 ].Nx = 0;
patchVertices[ 4 ].Ny = 0.5f;
patchVertices[ 4 ].Nz = 0;
patchVertices[ 4 ].U = 0.5f;
patchVertices[ 4 ].V = 0.5f;
patchVertices[ 5 ].X = 500;
patchVertices[ 5 ].Y = -50;
patchVertices[ 5 ].Z = 0;
patchVertices[ 5 ].Nx = 0.5f;
patchVertices[ 5 ].Ny = 0.5f;
patchVertices[ 5 ].Nz = 0;
patchVertices[ 5 ].U = 1;
patchVertices[ 5 ].V = 0.5f;
patchVertices[ 6 ].X = -500;
patchVertices[ 6 ].Y = 0;
patchVertices[ 6 ].Z = 500;
patchVertices[ 6 ].Nx = -0.5f;
patchVertices[ 6 ].Ny = 0.5f;
patchVertices[ 6 ].Nz = 0;
patchVertices[ 6 ].U = 0;
patchVertices[ 6 ].V = 1;
patchVertices[ 7 ].X = 0;
patchVertices[ 7 ].Y = 500;
patchVertices[ 7 ].Z = 500;
patchVertices[ 7 ].Nx = 0;
patchVertices[ 7 ].Ny = 0.5f;
patchVertices[ 7 ].Nz = 0;
patchVertices[ 7 ].U = 0.5f;
patchVertices[ 7 ].V = 1;
patchVertices[ 8 ].X = 500;
patchVertices[ 8 ].Y = 200;
patchVertices[ 8 ].Z = 800;
patchVertices[ 8 ].Nx = 0.5f;
patchVertices[ 8 ].Ny = 0.5f;
patchVertices[ 8 ].Nz = 0;
patchVertices[ 8 ].U = 1;
patchVertices[ 8 ].V = 1;
// specify a vertex format declaration for our patch: 3 floats for position, 3 floats for normal, 2 floats for UV
patchDeclaration = HardwareBufferManager.Instance.CreateVertexDeclaration();
patchDeclaration.AddElement( 0, 0, VertexElementType.Float3, VertexElementSemantic.Position );
patchDeclaration.AddElement( 0, 12, VertexElementType.Float3, VertexElementSemantic.Normal );
patchDeclaration.AddElement( 0, 24, VertexElementType.Float2, VertexElementSemantic.TexCoords, 0 );
// create a patch mesh using vertices and declaration
patch = MeshManager.Instance.CreateBezierPatch( "patch", ResourceGroupManager.DefaultResourceGroupName, patchVertices, patchDeclaration, 3, 3, 5, 5, VisibleSide.Both, BufferUsage.StaticWriteOnly, BufferUsage.DynamicWriteOnly, true, true );
// Start patch at 0 detail
patch.Subdivision = 0;
// Create entity based on patch
patchEntity = SceneManager.CreateEntity( "Entity1", "patch" );
Material material = (Material)MaterialManager.Instance.Create( "TextMat", ResourceGroupManager.DefaultResourceGroupName, null );
material.GetTechnique( 0 ).GetPass( 0 ).CreateTextureUnitState( "BumpyMetal.jpg" );
patchEntity.MaterialName = "TextMat";
patchPass = material.GetTechnique( 0 ).GetPass( 0 );
// Attach the entity to the root of the scene
SceneManager.RootSceneNode.AttachObject( patchEntity );
// save the main pass of the material so we can toggle wireframe on it
if ( material != null )
{
patchPass = material.GetTechnique( 0 ).GetPass( 0 );
// use an orbit style camera
CameraManager.setStyle( CameraStyle.Orbit );
CameraManager.SetYawPitchDist( 0, 0, 250 );
TrayManager.ShowCursor();
// create slider to adjust detail and checkbox to toggle wireframe
Slider slider = TrayManager.CreateThickSlider( TrayLocation.TopLeft, "Detail", "Detail", 120, 44, 0, 1, 6 );
CheckBox box = TrayManager.CreateCheckBox( TrayLocation.TopLeft, "Wireframe", "Wireframe", 120 );
slider.SliderMoved += new SliderMovedHandler( slider_SliderMoved );
box.CheckChanged += new CheckChangedHandler( box_CheckChanged );
}
}
private void InitShadowDebugPass()
{
Material matDebug = (Material)MaterialManager.Instance[ SHADOW_VOLUMES_MATERIAL ];
if ( matDebug == null )
{
// Create
matDebug =
(Material)
MaterialManager.Instance.Create( SHADOW_VOLUMES_MATERIAL,
ResourceGroupManager.InternalResourceGroupName );
this.shadowDebugPass = matDebug.GetTechnique( 0 ).GetPass( 0 );
this.shadowDebugPass.SetSceneBlending( SceneBlendType.Add );
this.shadowDebugPass.LightingEnabled = false;
this.shadowDebugPass.DepthWrite = false;
TextureUnitState t = this.shadowDebugPass.CreateTextureUnitState();
t.SetColorOperationEx(
LayerBlendOperationEx.Modulate,
LayerBlendSource.Manual,
LayerBlendSource.Current,
new ColorEx( 0.7f, 0.0f, 0.2f ) );
this.shadowDebugPass.CullingMode = CullingMode.None;
if ( this.targetRenderSystem.Capabilities.HasCapability( Capabilities.VertexPrograms ) )
{
ShadowVolumeExtrudeProgram.Initialize();
// Enable the (infinite) point light extruder for now, just to get some params
this.shadowDebugPass.SetVertexProgram(
ShadowVolumeExtrudeProgram.GetProgramName( ShadowVolumeExtrudeProgram.Programs.PointLight ) );
this.infiniteExtrusionParams = this.shadowDebugPass.VertexProgramParameters;
this.infiniteExtrusionParams.SetAutoConstant( 0, GpuProgramParameters.AutoConstantType.WorldViewProjMatrix );
this.infiniteExtrusionParams.SetAutoConstant( 4, GpuProgramParameters.AutoConstantType.LightPositionObjectSpace );
// Note ignored extra parameter - for compatibility with finite extrusion vertex program
this.infiniteExtrusionParams.SetAutoConstant( 5, GpuProgramParameters.AutoConstantType.ShadowExtrusionDistance );
}
matDebug.Compile();
}
else
{
this.shadowDebugPass = matDebug.GetTechnique( 0 ).GetPass( 0 );
if ( this.targetRenderSystem.Capabilities.HasCapability( Capabilities.VertexPrograms ) )
{
this.infiniteExtrusionParams = this.shadowDebugPass.VertexProgramParameters;
}
}
}
private void InitShadowStencilPass()
{
Material matStencil = (Material)MaterialManager.Instance[ STENCIL_SHADOW_VOLUMES_MATERIAL ];
if ( matStencil == null )
{
// Create
matStencil =
(Material)
MaterialManager.Instance.Create( STENCIL_SHADOW_VOLUMES_MATERIAL,
ResourceGroupManager.InternalResourceGroupName );
this.shadowStencilPass = matStencil.GetTechnique( 0 ).GetPass( 0 );
if ( this.targetRenderSystem.Capabilities.HasCapability( Capabilities.VertexPrograms ) )
{
// Enable the finite point light extruder for now, just to get some params
this.shadowStencilPass.SetVertexProgram(
ShadowVolumeExtrudeProgram.GetProgramName(
ShadowVolumeExtrudeProgram.Programs.PointLightFinite ) );
this.finiteExtrusionParams = this.shadowStencilPass.VertexProgramParameters;
this.finiteExtrusionParams.SetAutoConstant( 0, GpuProgramParameters.AutoConstantType.WorldViewProjMatrix );
this.finiteExtrusionParams.SetAutoConstant( 4, GpuProgramParameters.AutoConstantType.LightPositionObjectSpace );
this.finiteExtrusionParams.SetAutoConstant( 5, GpuProgramParameters.AutoConstantType.ShadowExtrusionDistance );
}
matStencil.Compile();
// Nothing else, we don't use this like a 'real' pass anyway,
// it's more of a placeholder
}
else
{
this.shadowStencilPass = matStencil.GetTechnique( 0 ).GetPass( 0 );
if ( this.targetRenderSystem.Capabilities.HasCapability( Capabilities.VertexPrograms ) )
{
this.finiteExtrusionParams = this.shadowStencilPass.VertexProgramParameters;
}
}
}
/// <summary>
/// Overriden from SceneManager.
/// </summary>
protected override void RenderSingleObject( IRenderable renderable, Pass pass, bool doLightIteration,
LightList manualLightList )
{
if ( renderable is BspGeometry )
{
// Render static level geometry
if ( doLightIteration )
{
// render all geometry without lights first
RenderStaticGeometry();
// render geometry affected by each visible light
foreach ( Light l in lightsAffectingFrustum )
{
RenderTextureLighting( l );
}
}
else
{
if ( manualLightList.Count == 0 )
{
if ( illuminationStage == IlluminationRenderStage.RenderReceiverPass )
{
// texture shadows
RenderTextureShadowOnGeometry();
}
else
{
// ambient stencil pass, render geometry without lights
RenderStaticGeometry();
}
}
else
{
// render only geometry affected by the provided light
foreach ( Light l in manualLightList )
{
RenderTextureLighting( l );
}
}
}
}
else
{
base.RenderSingleObject( renderable, pass, doLightIteration, manualLightList );
}
}
/// <summary>
/// Internal method for turning a regular pass into a shadow receiver pass.
/// </summary>
/// <remarks>
/// This is only used for texture shadows, basically we're trying to
/// ensure that objects are rendered with a projective texture.
/// This method will usually return a standard single-texture pass for
/// all fixed function passes, but will merge in a vertex program
/// for passes with vertex programs.
/// </remarks>
/// <param name="pass"></param>
/// <returns></returns>
protected virtual Pass DeriveShadowReceiverPass( Pass pass )
{
if ( this.IsShadowTechniqueTextureBased )
{
Pass retPass;
if ( pass.Parent.ShadowReceiverMaterial != null )
{
retPass = pass.Parent.ShadowReceiverMaterial.GetBestTechnique().GetPass( 0 );
}
else
{
retPass = ( this.shadowTextureCustomReceiverPass != null ? this.shadowTextureCustomReceiverPass : this.shadowReceiverPass );
}
// Does incoming pass have a custom shadow receiver program?
if ( pass.ShadowReceiverVertexProgramName != "" )
{
retPass.SetVertexProgram( pass.ShadowReceiverVertexProgramName );
GpuProgram prg = retPass.VertexProgram;
// Load this program if not done already
if ( !prg.IsLoaded )
{
prg.Load();
}
// Copy params
retPass.VertexProgramParameters = pass.ShadowReceiverVertexProgramParameters;
// Also have to hack the light autoparams, that is done later
}
else
{
if ( retPass == this.shadowTextureCustomReceiverPass )
{
if ( this.shadowTextureCustomReceiverPass.VertexProgramName != this.shadowTextureCustomReceiverVertexProgram )
{
this.shadowTextureCustomReceiverPass.SetVertexProgram( this.shadowTextureCustomReceiverVertexProgram );
if ( retPass.HasVertexProgram )
{
retPass.VertexProgramParameters = this.shadowTextureCustomReceiverVPParams;
}
}
}
else
{
retPass.SetVertexProgram( "" );
}
}
int keepTUCount;
// If additive, need lighting parameters & standard programs
if ( this.IsShadowTechniqueAdditive )
{
keepTUCount = 1;
retPass.LightingEnabled = true;
retPass.Ambient = pass.Ambient;
retPass.SelfIllumination = pass.SelfIllumination;
retPass.Diffuse = pass.Diffuse;
retPass.Specular = pass.Specular;
retPass.Shininess = pass.Shininess;
retPass.SetRunOncePerLight( pass.IteratePerLight,
pass.RunOnlyOncePerLightType,
pass.OnlyLightType );
// We need to keep alpha rejection settings
retPass.SetAlphaRejectSettings( pass.AlphaRejectFunction, pass.AlphaRejectValue );
// Copy texture state, shift up one since 0 is shadow texture
int origPassTUCount = pass.TextureUnitStageCount;
for ( int t = 0; t < origPassTUCount; ++t )
{
int targetIndex = t + 1;
TextureUnitState tex = ( retPass.TextureUnitStageCount <= targetIndex
?
retPass.CreateTextureUnitState()
:
retPass.GetTextureUnitState( targetIndex ) );
pass.GetTextureUnitState( t ).CopyTo( tex );
// If programmable, have to adjust the texcoord sets too
// D3D insists that texcoordsets match tex unit in programmable mode
if ( retPass.HasVertexProgram )
tex.TextureCoordSet = targetIndex;
}
keepTUCount = origPassTUCount + 1;
}
else
{
// need to keep spotlight fade etc
keepTUCount = retPass.TextureUnitStageCount;
}
// Will also need fragment programs since this is a complex light setup
if ( pass.ShadowReceiverFragmentProgramName != "" )
{
// Have to merge the shadow receiver vertex program in
retPass.SetFragmentProgram( pass.ShadowReceiverFragmentProgramName );
GpuProgram prg = retPass.FragmentProgram;
// Load this program if not done already
if ( !prg.IsLoaded )
{
prg.Load();
}
// Copy params
retPass.FragmentProgramParameters = pass.ShadowReceiverFragmentProgramParameters;
// Did we bind a shadow vertex program?
if ( pass.HasVertexProgram && !retPass.HasVertexProgram )
{
// We didn't bind a receiver-specific program, so bind the original
retPass.SetVertexProgram( pass.VertexProgramName );
prg = retPass.VertexProgram;
// Load this program if required
if ( !prg.IsLoaded )
{
prg.Load();
}
// Copy params
retPass.VertexProgramParameters = pass.VertexProgramParameters;
}
}
else
{
// Reset any merged fragment programs from last time
if ( retPass == this.shadowTextureCustomReceiverPass )
{
// reset fp?
if ( retPass.FragmentProgramName != this.shadowTextureCustomReceiverFragmentProgram )
{
retPass.SetFragmentProgram( this.shadowTextureCustomReceiverFragmentProgram );
if ( retPass.HasFragmentProgram )
{
retPass.FragmentProgramParameters = this.shadowTextureCustomReceiverFPParams;
}
}
}
else
{
// Standard shadow receiver pass, reset to no fp
retPass.SetFragmentProgram( "" );
}
}
// Remove any extra texture units
while ( retPass.TextureUnitStageCount > keepTUCount )
{
retPass.RemoveTextureUnitState( keepTUCount );
}
retPass.Load();
return retPass;
}
else
{
return pass;
}
}
protected void InitTextureLighting()
{
if ( targetRenderSystem.Capabilities.TextureUnitCount < 2 )
{
LogManager.Instance.Write( "--WARNING--At least 2 available texture units are required for BSP dynamic lighting!" );
}
Texture texLight = TextureLight.CreateTexture();
this.textureLightMaterial = (Material)MaterialManager.Instance.GetByName( "Axiom/BspTextureLightMaterial" );
if ( this.textureLightMaterial == null )
{
this.textureLightMaterial =
(Material)
MaterialManager.Instance.Create( "Axiom/BspTextureLightMaterial", ResourceGroupManager.DefaultResourceGroupName );
this.textureLightPass = this.textureLightMaterial.GetTechnique( 0 ).GetPass( 0 );
// the texture light
TextureUnitState tex = this.textureLightPass.CreateTextureUnitState( texLight.Name );
tex.SetColorOperation( LayerBlendOperation.Modulate );
tex.ColorBlendMode.source2 = LayerBlendSource.Diffuse;
tex.SetAlphaOperation( LayerBlendOperationEx.Modulate );
tex.AlphaBlendMode.source2 = LayerBlendSource.Diffuse;
tex.TextureCoordSet = 2;
tex.SetTextureAddressingMode( TextureAddressing.Clamp );
// The geometry texture without lightmap. Use the light texture on this
// pass, the appropriate texture will be rendered at RenderTextureLighting
tex = this.textureLightPass.CreateTextureUnitState( texLight.Name );
tex.SetColorOperation( LayerBlendOperation.Modulate );
tex.SetAlphaOperation( LayerBlendOperationEx.Modulate );
tex.SetTextureAddressingMode( TextureAddressing.Wrap );
this.textureLightPass.SetSceneBlending( SceneBlendType.TransparentAlpha );
this.textureLightMaterial.CullingMode = CullingMode.None;
this.textureLightMaterial.Lighting = false;
}
else
{
this.textureLightPass = this.textureLightMaterial.GetTechnique( 0 ).GetPass( 0 );
}
}
/// <summary>
/// If only the first parameter is supplied
/// </summary>
public virtual Pass SetPass( Pass pass )
{
return this.SetPass( pass, false, true );
}
public void ManualRender( RenderOperation op,
Pass pass,
Viewport vp,
Matrix4 worldMatrix,
Matrix4 viewMatrix,
Matrix4 projMatrix )
{
this.ManualRender( op, pass, vp, worldMatrix, viewMatrix, projMatrix, false );
}
protected virtual void UpdateGpuProgramParameters(Pass pass)
{
if ( pass.IsProgrammable )
{
if (_gpuParamsDirty == 0)
return;
if (_gpuParamsDirty != 0)
pass.UpdateAutoParams(autoParamDataSource, _gpuParamsDirty);
if ( pass.HasVertexProgram )
{
targetRenderSystem.BindGpuProgramParameters( GpuProgramType.Vertex, pass.VertexProgramParameters,
_gpuParamsDirty );
}
if ( pass.HasGeometryProgram )
{
targetRenderSystem.BindGpuProgramParameters( GpuProgramType.Geometry, pass.GeometryProgramParameters,
_gpuParamsDirty );
}
if ( pass.HasFragmentProgram )
{
targetRenderSystem.BindGpuProgramParameters( GpuProgramType.Fragment, pass.FragmentProgramParameters,
_gpuParamsDirty );
}
//_gpuParamsDirty = 0;
}
}
/// <summary>
/// Manual rendering method, for advanced users only.
/// </summary>
/// <remarks>
/// This method allows you to send rendering commands through the pipeline on
/// demand, bypassing any normal world processing. You should only use this if you
/// really know what you're doing; the engine does lots of things for you that you really should
/// let it do. However, there are times where it may be useful to have this manual interface,
/// for example overlaying something on top of the scene.
/// <p/>
/// Because this is an instant rendering method, timing is important. The best
/// time to call it is from a RenderTarget event handler.
/// <p/>
/// Don't call this method a lot, it's designed for rare (1 or 2 times per frame) use.
/// Calling it regularly per frame will cause frame rate drops!
/// </remarks>
/// <param name="op">A RenderOperation object describing the rendering op.</param>
/// <param name="pass">The Pass to use for this render.</param>
/// <param name="vp">Reference to the viewport to render to.</param>
/// <param name="worldMatrix">The transform to apply from object to world space.</param>
/// <param name="viewMatrix">The transform to apply from object to view space.</param>
/// <param name="projMatrix">The transform to apply from view to screen space.</param>
/// <param name="doBeginEndFrame">
/// If true, BeginFrame() and EndFrame() are called, otherwise not.
/// You should leave this as false if you are calling this within the main render loop.
/// </param>
public virtual void ManualRender( RenderOperation op,
Pass pass,
Viewport vp,
Matrix4 worldMatrix,
Matrix4 viewMatrix,
Matrix4 projMatrix,
bool doBeginEndFrame )
{
// configure all necessary parameters
this.targetRenderSystem.Viewport = vp;
this.targetRenderSystem.WorldMatrix = worldMatrix;
this.targetRenderSystem.ViewMatrix = viewMatrix;
this.targetRenderSystem.ProjectionMatrix = projMatrix;
if ( doBeginEndFrame )
{
this.targetRenderSystem.BeginFrame();
}
// set the pass and render the object
this.SetPass( pass );
this.targetRenderSystem.Render( op );
if ( doBeginEndFrame )
{
this.targetRenderSystem.EndFrame();
}
}
/// <summary>
/// Internal utility method for rendering a single object.
/// </summary>
/// <param name="renderable">The renderable to issue to the pipeline.</param>
/// <param name="pass">The pass which is being used.</param>
/// <param name="doLightIteration">If true, this method will issue the renderable to
/// the pipeline possibly multiple times, if the pass indicates it should be
/// done once per light.</param>
/// <param name="manualLightList">Only applicable if 'doLightIteration' is false, this
/// method allows you to pass in a previously determined set of lights
/// which will be used for a single render of this object.</param>
protected virtual void RenderSingleObject( IRenderable renderable,
Pass pass,
bool doLightIteration,
LightList manualLightList )
{
ushort numMatrices = 0;
// grab the current scene detail level
PolygonMode camPolyMode = this.cameraInProgress.PolygonMode;
// get the world matrices and the count
renderable.GetWorldTransforms( this.xform );
numMatrices = renderable.NumWorldTransforms;
// set the world matrices in the render system
if ( numMatrices > 1 )
{
this.targetRenderSystem.SetWorldMatrices( this.xform, numMatrices );
}
else
{
this.targetRenderSystem.WorldMatrix = this.xform[ 0 ];
}
// issue view/projection changes (if any)
this.UseRenderableViewProjection( renderable );
if ( !this.suppressRenderStateChanges )
{
bool passSurfaceAndLightParams = true;
if ( pass.IsProgrammable )
{
// Tell auto params object about the renderable change
this.autoParamDataSource.Renderable = renderable;
pass.UpdateAutoParamsNoLights( this.autoParamDataSource );
if ( pass.HasVertexProgram )
{
passSurfaceAndLightParams = pass.VertexProgram.PassSurfaceAndLightStates;
}
}
// issue texture units that depend on updated view matrix
// reflective env mapping is one case
for ( int i = 0; i < pass.TextureUnitStageCount; i++ )
{
TextureUnitState texUnit = pass.GetTextureUnitState( i );
if ( texUnit.HasViewRelativeTexCoordGen )
{
targetRenderSystem.SetTextureUnitSettings( i, texUnit );
//this.targetRenderSystem.SetTextureUnit( i, texUnit, !pass.HasFragmentProgram );
}
}
// Normalize normals
bool thisNormalize = renderable.NormalizeNormals;
if ( thisNormalize != normalizeNormals )
{
this.targetRenderSystem.NormalizeNormals = thisNormalize;
normalizeNormals = thisNormalize;
}
// Set up the solid / wireframe override
PolygonMode requestedMode = pass.PolygonMode;
if ( renderable.PolygonModeOverrideable == true )
{
// check camera detial only when render detail is overridable
if ( requestedMode > camPolyMode )
{
// only downgrade detail; if cam says wireframe we don't go up to solid
requestedMode = camPolyMode;
}
}
if ( requestedMode != this.lastPolyMode )
{
this.targetRenderSystem.PolygonMode = requestedMode;
this.lastPolyMode = requestedMode;
}
// TODO: Add ClipPlanes to RenderSystem.cs
// This is removed in OGRE 1.6.0... no need to port - J. Price
//targetRenderSystem.ClipPlanes = renderable.ClipPlanes;
// get the renderables render operation
op = renderable.RenderOperation;
// TODO: Add srcRenderable to RenderOperation.cs
//op.srcRenderable = renderable;
if ( doLightIteration )
{
// Here's where we issue the rendering operation to the render system
// Note that we may do this once per light, therefore it's in a loop
// and the light parameters are updated once per traversal through the
// loop
LightList rendLightList = renderable.Lights;
bool iteratePerLight = pass.IteratePerLight;
int numIterations = iteratePerLight ? rendLightList.Count : 1;
LightList lightListToUse = null;
for ( int i = 0; i < numIterations; i++ )
{
// determine light list to use
if ( iteratePerLight )
{
localLightList.Clear();
// check whether we need to filter this one out
if ( pass.RunOnlyOncePerLightType && pass.OnlyLightType != rendLightList[ i ].Type )
{
// skip this one
continue;
}
localLightList.Add( rendLightList[ i ] );
lightListToUse = localLightList;
}
else
{
// use complete light list
lightListToUse = rendLightList;
}
if ( pass.IsProgrammable )
{
// Update any automatic gpu params for lights
// Other bits of information will have to be looked up
this.autoParamDataSource.SetCurrentLightList( lightListToUse );
pass.UpdateAutoParamsLightsOnly( this.autoParamDataSource );
UpdateGpuProgramParameters( pass );
}
// Do we need to update light states?
// Only do this if fixed-function vertex lighting applies
if ( pass.LightingEnabled && passSurfaceAndLightParams )
{
this.targetRenderSystem.UseLights( lightListToUse, pass.MaxSimultaneousLights );
}
this.targetRenderSystem.CurrentPassIterationCount = pass.IterationCount;
// issue the render op
this.targetRenderSystem.Render( op );
} // iterate per light
}
else
{
// do we need to update GPU program parameters?
if ( pass.IsProgrammable )
{
// do we have a manual light list
if ( manualLightList != null )
{
// Update any automatic gpu params for lights
// Other bits of information will have to be looked up
this.autoParamDataSource.SetCurrentLightList( manualLightList );
pass.UpdateAutoParamsLightsOnly( this.autoParamDataSource );
}
UpdateGpuProgramParameters( pass );
}
// Use manual lights if present, and not using vertex programs
if ( manualLightList != null && pass.LightingEnabled && passSurfaceAndLightParams )
{
this.targetRenderSystem.UseLights( manualLightList, pass.MaxSimultaneousLights );
}
this.targetRenderSystem.CurrentPassIterationCount = pass.IterationCount;
// issue the render op
this.targetRenderSystem.Render( op );
}
}
else
{
// suppressRenderStateChanges
// Just render
this.targetRenderSystem.CurrentPassIterationCount = 1;
this.targetRenderSystem.Render( op );
}
// Reset view / projection changes if any
this.ResetViewProjectionMode();
}
private void InitShadowReceiverPass()
{
Material matShadRec = (Material)MaterialManager.Instance[ TEXTURE_SHADOW_RECEIVER_MATERIAL ];
if ( matShadRec == null )
{
matShadRec =
(Material)
MaterialManager.Instance.Create( TEXTURE_SHADOW_RECEIVER_MATERIAL,
ResourceGroupManager.InternalResourceGroupName );
this.shadowReceiverPass = matShadRec.GetTechnique( 0 ).GetPass( 0 );
this.shadowReceiverPass.SetSceneBlending( SceneBlendFactor.DestColor, SceneBlendFactor.Zero );
// Don't set lighting and blending modes here, depends on additive / modulative
TextureUnitState t = this.shadowReceiverPass.CreateTextureUnitState();
t.SetTextureAddressingMode( TextureAddressing.Clamp );
}
else
{
this.shadowReceiverPass = matShadRec.GetTechnique( 0 ).GetPass( 0 );
}
}
/// <summary>
/// Internal method to validate whether a Renderable should be allowed to render.
/// </summary>
/// <remarks>
/// Called just before a pass is about to be used for rendering a Renderable to
/// allow the SceneManager to omit it if required. A return value of false
/// skips it.
/// </remarks>
protected virtual bool ValidateRenderableForRendering( Pass pass, IRenderable renderable )
{
// Skip this renderable if we're doing texture shadows, it casts shadows
// and we're doing the render receivers pass
if ( !this.suppressShadows && this.currentViewport.ShowShadows && this.IsShadowTechniqueTextureBased )
{
if ( this.illuminationStage == IlluminationRenderStage.RenderReceiverPass &&
renderable.CastsShadows && !this.shadowTextureSelfShadow )
{
return false;
}
// Some duplication here with validatePassForRendering, for transparents
if ( ( ( this.IsShadowTechniqueModulative
&& this.illuminationStage == IlluminationRenderStage.RenderReceiverPass )
|| this.illuminationStage == IlluminationRenderStage.RenderToTexture
|| this.suppressRenderStateChanges ) &&
pass.Index > 0 )
{
return false;
}
}
return true;
}
private void InitShadowCasterPass()
{
Material matPlainBlack = (Material)MaterialManager.Instance[ TEXTURE_SHADOW_CASTER_MATERIAL ];
if ( matPlainBlack == null )
{
matPlainBlack =
(Material)
MaterialManager.Instance.Create( TEXTURE_SHADOW_CASTER_MATERIAL,
ResourceGroupManager.InternalResourceGroupName );
this.shadowCasterPlainBlackPass = matPlainBlack.GetTechnique( 0 ).GetPass( 0 );
// Lighting has to be on, because we need shadow coloured objects
// Note that because we can't predict vertex programs, we'll have to
// bind light values to those, and so we bind White to ambient
// reflectance, and we'll set the ambient colour to the shadow colour
this.shadowCasterPlainBlackPass.Ambient = ColorEx.White;
this.shadowCasterPlainBlackPass.Diffuse = ColorEx.Black;
this.shadowCasterPlainBlackPass.SelfIllumination = ColorEx.Black;
this.shadowCasterPlainBlackPass.Specular = ColorEx.Black;
// Override fog
this.shadowCasterPlainBlackPass.SetFog( true, FogMode.None );
// no textures or anything else, we will bind vertex programs
// every so often though
}
else
{
this.shadowCasterPlainBlackPass = matPlainBlack.GetTechnique( 0 ).GetPass( 0 );
}
}
public virtual void InjectRenderWithPass( Pass pass, IRenderable rend )
{
this.InjectRenderWithPass( pass, rend, true );
}
private void InitShadowModulativePass()
{
Material matModStencil = (Material)MaterialManager.Instance[ STENCIL_SHADOW_MODULATIVE_MATERIAL ];
if ( matModStencil == null )
{
// Create
matModStencil =
(Material)
MaterialManager.Instance.Create( STENCIL_SHADOW_MODULATIVE_MATERIAL,
ResourceGroupManager.InternalResourceGroupName );
this.shadowModulativePass = matModStencil.GetTechnique( 0 ).GetPass( 0 );
this.shadowModulativePass.SetSceneBlending( SceneBlendFactor.DestColor, SceneBlendFactor.Zero );
this.shadowModulativePass.LightingEnabled = false;
this.shadowModulativePass.DepthWrite = false;
this.shadowModulativePass.DepthCheck = false;
TextureUnitState t = this.shadowModulativePass.CreateTextureUnitState();
t.SetColorOperationEx(
LayerBlendOperationEx.Modulate,
LayerBlendSource.Manual,
LayerBlendSource.Current,
this.shadowColor );
this.shadowModulativePass.CullingMode = CullingMode.None;
}
else
{
this.shadowModulativePass = matModStencil.GetTechnique( 0 ).GetPass( 0 );
}
}
