/// <summary>
/// Add a renderable to this group.
/// </summary>
/// <param name="renderable">Renderable to add to the queue.</param>
/// <param name="technique"></param>
public void AddRenderable(IRenderable renderable, Technique technique)
{
// Transparent and depth/colour settings mean depth sorting is required?
// Note: colour write disabled with depth check/write enabled means
// setup depth buffer for other passes use.
if (technique.IsTransparent && (!technique.DepthWrite || !technique.DepthCheck || technique.ColorWriteEnabled))
{
AddTransparentRenderable(technique, renderable);
}
else
{
if (this.splitNoShadowPasses && this._parent.ShadowsEnabled &&
(!technique.Parent.ReceiveShadows || renderable.CastsShadows && this.shadowCastersCannotBeReceivers))
{
// Add solid renderable and add passes to no-shadow group
AddSolidRenderable(technique, renderable, true);
}
else
{
if (this.splitPassesByLightingType && this._parent.ShadowsEnabled)
{
AddSolidRenderableSplitByLightType(technique, renderable);
}
else
{
AddSolidRenderable(technique, renderable, false);
}
}
}
}
/// <summary>
/// Internal method for adding a solid renderable
/// </summary>
/// <param name="technique">Technique to use for this renderable.</param>
/// <param name="renderable">Renderable to add to the queue.</param>
/// <param name="noShadows">True to add to the no shadow group, false otherwise.</param>
protected void AddSolidRenderable(Technique technique, IRenderable renderable, bool noShadows)
{
SortedList passMap = null;
if (noShadows)
{
passMap = this.solidPassesNoShadow;
}
else
{
passMap = this.solidPasses;
}
for (var i = 0; i < technique.PassCount; i++)
{
var pass = technique.GetPass(i);
if (passMap[pass] == null)
{
// add a new list to hold renderables for this pass
passMap.Add(pass, new RenderableList());
}
// add to solid list for this pass
var solidList = (RenderableList)passMap[pass];
solidList.Add(renderable);
}
}
/// <summary>
/// Internal method for adding a transparent renderable.
/// </summary>
/// <param name="technique">Technique to use for this renderable.</param>
/// <param name="renderable">Renderable to add to the queue.</param>
protected void AddTransparentRenderable(Technique technique, IRenderable renderable)
{
for (int i = 0; i < technique.NumPasses; i++)
{
// add to transparent list
transparentPasses.Add(new RenderablePass(renderable, technique.GetPass(i)));
}
}
/// <summary>
/// Clones this Technique.
/// </summary>
/// <param name="parent">Material that will own this technique.</param>
/// <returns></returns>
public Technique Clone(Material parent)
{
Technique newTechnique = new Technique(parent);
CopyTo(newTechnique);
return(newTechnique);
}
/// <summary>
/// Creates a new Technique for this Material.
/// </summary>
/// <remarks>
/// A Technique is a single way of rendering geometry in order to achieve the effect
/// you are intending in a material. There are many reason why you would want more than
/// one - the main one being to handle variable graphics card abilities; you might have
/// one technique which is impressive but only runs on 4th-generation graphics cards,
/// for example. In this case you will want to create at least one fallback Technique.
/// The engine will work out which Techniques a card can support and pick the best one.
/// <p/>
/// If multiple Techniques are available, the order in which they are created is
/// important - the engine will consider lower-indexed Techniques to be preferable
/// to higher-indexed Techniques, ie when asked for the 'best' technique it will
/// return the first one in the technique list which is supported by the hardware.
/// </remarks>
/// <returns></returns>
public Technique CreateTechnique()
{
Technique t = new Technique(this);
techniques.Add(t);
compilationRequired = true;
return(t);
}
public void SetDepthBias(float constantBias, float slopeScaleBias)
{
for (int i = 0; i < techniques.Count; i++)
{
Technique technique = (Technique)techniques[i];
technique.SetDepthBias(constantBias, slopeScaleBias);
}
}
/// <summary>
/// Internal method for adding a transparent renderable.
/// </summary>
/// <param name="technique">Technique to use for this renderable.</param>
/// <param name="renderable">Renderable to add to the queue.</param>
protected void AddTransparentRenderable(Technique technique, IRenderable renderable)
{
for (var i = 0; i < technique.PassCount; i++)
{
// add to transparent list
this.transparentPasses.Add(new RenderablePass(renderable, technique.GetPass(i)));
}
}
/// <summary>
/// Removes the specified Technique from this material.
/// </summary>
/// <param name="t">A reference to the technique to remove</param>
public void RemoveTechnique(Technique t)
{
Debug.Assert(t != null, "t != null");
// remove from the list, and force a rebuild of supported techniques
techniques.Remove(t);
supportedTechniques.Clear();
bestTechniquesByScheme.Clear();
compilationRequired = true;
}
public RSQuadOperation(CompositorInstance instance, uint pass_id, Material mat)
{
this.mat = mat;
this.instance = instance;
this.pass_id = pass_id;
mat.Load();
instance.FireNotifyMaterialSetup(pass_id, mat);
technique = mat.GetTechnique(0);
Debug.Assert(technique != null);
}
public BspGeometry()
{
geometryMat = MaterialManager.Instance.GetByName("Axiom/BspGeometryMaterial");
if (geometryMat == null)
{
geometryMat = (Material) MaterialManager.Instance.Create("Axiom/BspGeometryMaterial");
geometryMat.ReceiveShadows = true;
technique = geometryMat.GetTechnique(0);
}
}
/// <summary>
/// Searches for the named technique.
/// Returns null if technique with name is not found
/// </summary>
public Technique GetTechnique(string name)
{
for (int i = 0; i < techniques.Count; i++)
{
Technique t = (Technique)techniques[i];
if (t.Name == name)
{
return(t);
}
}
return(null);
}
public BspGeometry()
{
this.geometryMat = (Material)MaterialManager.Instance.GetByName( "Axiom/BspGeometryMaterial" );
if ( this.geometryMat == null )
{
this.geometryMat =
(Material)
MaterialManager.Instance.Create( "Axiom/BspGeometryMaterial", ResourceGroupManager.Instance.WorldResourceGroupName );
this.geometryMat.ReceiveShadows = true;
this.technique = this.geometryMat.GetTechnique( 0 );
}
}
/// <summary>
/// Applies texture names to Texture Unit State with matching texture name aliases.
/// All techniques, passes, and Texture Unit States within the material are checked.
/// If matching texture aliases are found then true is returned.
/// </summary>
/// <param name="aliasList">A map container of texture alias, texture name pairs.</param>
/// <param name="apply">Set to true to apply the texture aliases else just test to see if texture alias matches are found.</param>
/// <returns>True if matching texture aliases were found in the material.</returns>
public bool ApplyTextureAliases(Dictionary <string, string> aliasList, bool apply)
{
bool testResult = false;
// iterate through all techniques and apply texture aliases
for (int i = 0; i < techniques.Count; i++)
{
Technique technique = (Technique)techniques[i];
if (technique.ApplyTextureAliases(aliasList, apply))
{
testResult = true;
}
}
return(testResult);
}
/// <summary>
/// Insert a supported technique into the local
/// collections, if it's not already present. */
/// </summary>
protected void InsertSupportedTechnique(Technique t)
{
supportedTechniques.Add(t);
// get scheme
int schemeIndex = t.SchemeIndex;
Dictionary <int, Technique> lodTechniques;
if (!bestTechniquesByScheme.TryGetValue(schemeIndex, out lodTechniques))
{
lodTechniques = new Dictionary <int, Technique>();
bestTechniquesByScheme[schemeIndex] = lodTechniques;
}
if (!lodTechniques.ContainsKey(t.LodIndex))
{
lodTechniques[t.LodIndex] = t;
}
}
/// <summary>
/// 'Compiles' this Material.
/// </summary>
/// <remarks>
/// Compiling a material involves determining which Techniques are supported on the
/// card on which the engine is currently running, and for fixed-function Passes within those
/// Techniques, splitting the passes down where they contain more TextureUnitState
/// instances than the curren card has texture units.
/// <p/>
/// This process is automatically done when the Material is loaded, but may be
/// repeated if you make some procedural changes.
/// <p/>
/// This method should be safe for use on threads other than the main render thread.
/// </remarks>
/// <param name="autoManageTextureUnits">
/// If true, when a fixed function pass has too many TextureUnitState
/// entries than the card has texture units, the Pass in question will be split into
/// more than one Pass in order to emulate the Pass. If you set this to false and
/// this situation arises, an Exception will be thrown.
/// </param>
public void Compile(bool autoManageTextureUnits)
{
// clear current list of supported techniques
supportedTechniques.Clear();
bestTechniquesByScheme.Clear();
unsupportedReasons = "";
string compileMessages = "";
// compile each technique, adding supported ones to the list of supported techniques
for (int i = 0; i < techniques.Count; i++)
{
Technique t = (Technique)techniques[i];
// compile the technique, splitting texture passes if required
compileMessages = t.Compile(autoManageTextureUnits);
// if supported, add it to the list
if (t.IsSupported)
{
InsertSupportedTechnique(t);
}
else
{
string s = "Material " + name + " Technique " + i;
if (t.Name != "")
{
s += " (" + t.Name + ")";
}
s += " is not supported. " + compileMessages;
LogManager.Instance.Write(s);
unsupportedReasons = compileMessages;
}
}
// TODO: Order best techniques
compilationRequired = false;
// Did we find any?
if (supportedTechniques.Count == 0)
{
LogManager.Instance.Write("Warning: Material '{0}' has no supportable Techniques on this hardware. Will be rendered blank. Explanation: {1}",
name, compileMessages);
}
}
/// <summary>
/// Add a renderable to this group.
/// </summary>
/// <param name="renderable">Renderable to add to the queue.</param>
public void AddRenderable(IRenderable renderable)
{
Technique t = null;
// Check material & technique supplied (the former since the default implementation
// of Technique is based on it for backwards compatibility
if (renderable.Material == null || renderable.Technique == null)
{
// use default if not found
t = MaterialManager.Instance.GetByName("BaseWhite").GetTechnique(0);
}
else
{
t = renderable.Technique;
}
// Transparent and depth settings mean depth sorting is required?
if (t.IsTransparent && !(t.DepthWrite && t.DepthCheck))
{
AddTransparentRenderable(t, renderable);
}
else
{
if (splitNoShadowPasses &&
(!t.Parent.ReceiveShadows ||
renderable.CastsShadows && shadowCastersCannotBeReceivers))
{
// Add solid renderable and add passes to no-shadow group
AddSolidRenderable(t, renderable, true);
}
else
{
if (splitPassesByLightingType)
{
AddSolidRenderableSplitByLightType(t, renderable);
}
else
{
AddSolidRenderable(t, renderable, false);
}
}
}
}
/// <summary>
/// Copies the details of this material into another, preserving the target's handle and name
/// (unlike operator=) but copying everything else.
/// </summary>
/// <param name="target">Material which will receive this material's settings.</param>
public void CopyTo(Material target, bool copyUniqueInfo)
{
if (copyUniqueInfo)
{
target.name = name;
target.handle = handle;
target.isLoaded = isLoaded;
target.isManual = isManual;
}
// copy basic data
target.size = size;
target.lastAccessed = lastAccessed;
target.receiveShadows = receiveShadows;
target.transparencyCastsShadows = transparencyCastsShadows;
target.RemoveAllTechniques();
// clone a copy of all the techniques
for (int i = 0; i < techniques.Count; i++)
{
Technique technique = (Technique)techniques[i];
Technique newTechnique = target.CreateTechnique();
technique.CopyTo(newTechnique);
// only add this technique to supported techniques if its...well....supported :-)
if (newTechnique.IsSupported)
{
target.InsertSupportedTechnique(newTechnique);
}
}
// clear LOD distances
target.lodDistances.Clear();
// copy LOD distances
for (int i = 0; i < lodDistances.Count; i++)
{
target.lodDistances.Add(lodDistances[i]);
}
target.compilationRequired = compilationRequired;
}
/// <summary>
/// Copy the details of this Technique to another.
/// </summary>
/// <param name="target"></param>
public void CopyTo(Technique target)
{
target.name = name;
target.isSupported = isSupported;
target.lodIndex = lodIndex;
target.schemeIndex = schemeIndex;
target.RemoveAllPasses();
// clone each pass and add that to the new technique
for (int i = 0; i < passes.Count; i++)
{
Pass pass = (Pass)passes[i];
Pass newPass = pass.Clone(target, pass.Index);
target.passes.Add(newPass);
}
// Compile for categorised illumination on demand
target.ClearIlluminationPasses();
target.illuminationPassesCompilationPhase = IlluminationPassesState.NotCompiled;
}
/// <summary>
/// </summary>
public void AddRenderable(IRenderable item, Technique technique, ushort priority)
{
RenderPriorityGroup group = null;
// see if there is a current queue group for this group id
if (!PriorityGroups.ContainsKey(priority))
{
// create a new queue group for this group id
group = new RenderPriorityGroup(this, this.splitPassesByLightingType, this.splitNoShadowPasses,
this.splitPassesByLightingType);
// add the new group to cached render group
PriorityGroups.Add(priority, group);
}
else
{
// retreive the existing queue group
group = PriorityGroups[priority];
}
// add the renderable to the appropriate group
group.AddRenderable(item, technique);
}
/// <summary>
/// Internal method for adding a solid renderable ot the group based on lighting stage.
/// </summary>
/// <param name="technique">Technique to use for this renderable.</param>
/// <param name="renderable">Renderable to add to the queue.</param>
protected void AddSolidRenderableSplitByLightType(Technique technique, IRenderable renderable)
{
// Divide the passes into the 3 categories
for (var i = 0; i < technique.IlluminationPassCount; i++)
{
// Insert into solid list
var illpass = technique.GetIlluminationPass(i);
SortedList passMap = null;
switch (illpass.Stage)
{
case IlluminationStage.Ambient:
passMap = this.solidPasses;
break;
case IlluminationStage.PerLight:
passMap = this.solidPassesDiffuseSpecular;
break;
case IlluminationStage.Decal:
passMap = this.solidPassesDecal;
break;
}
var solidList = (RenderableList)passMap[illpass.Pass];
if (solidList == null)
{
// add a new list to hold renderables for this pass
solidList = new RenderableList();
passMap.Add(illpass.Pass, solidList);
}
solidList.Add(renderable);
}
}
/// <summary>
/// </summary>
public void AddRenderable( IRenderable item, Technique technique, ushort priority )
{
RenderPriorityGroup group = null;
// see if there is a current queue group for this group id
if ( !PriorityGroups.ContainsKey( priority ) )
{
// create a new queue group for this group id
group = new RenderPriorityGroup( this, this.splitPassesByLightingType, this.splitNoShadowPasses,
this.splitPassesByLightingType );
// add the new group to cached render group
PriorityGroups.Add( priority, group );
}
else
{
// retreive the existing queue group
group = PriorityGroups[ priority ];
}
// add the renderable to the appropriate group
group.AddRenderable( item, technique );
}
/// <summary>
/// Internal method for adding a solid renderable
/// </summary>
/// <param name="technique">Technique to use for this renderable.</param>
/// <param name="renderable">Renderable to add to the queue.</param>
/// <param name="noShadows">True to add to the no shadow group, false otherwise.</param>
protected void AddSolidRenderable(Technique technique, IRenderable renderable, bool noShadows)
{
SortedList passMap = null;
if(noShadows)
{
passMap = solidPassesNoShadow;
}
else
{
passMap = solidPasses;
}
for(int i = 0; i < technique.NumPasses; i++)
{
Pass pass = technique.GetPass(i);
if(passMap[pass] == null)
{
// add a new list to hold renderables for this pass
passMap.Add(pass, new RenderableList());
}
// add to solid list for this pass
RenderableList solidList = (RenderableList)passMap[pass];
solidList.Add(renderable);
}
}
/// <summary>
/// Insert a supported technique into the local
/// collections, if it's not already present. */
/// </summary>
protected void InsertSupportedTechnique(Technique t)
{
supportedTechniques.Add(t);
// get scheme
int schemeIndex = t.SchemeIndex;
Dictionary<int, Technique> lodTechniques;
if (!bestTechniquesByScheme.TryGetValue(schemeIndex, out lodTechniques)) {
lodTechniques = new Dictionary<int, Technique>();
bestTechniquesByScheme[schemeIndex] = lodTechniques;
}
if (!lodTechniques.ContainsKey(t.LodIndex))
lodTechniques[t.LodIndex] = t;
}
/// <summary>
/// Clones this Technique.
/// </summary>
/// <param name="parent">Material that will own this technique.</param>
/// <returns></returns>
public Technique Clone( Material parent )
{
Technique newTechnique = new Technique( parent );
CopyTo( newTechnique );
return newTechnique;
}
/// <summary>
/// Copy the details of this Technique to another.
/// </summary>
/// <param name="target"></param>
public void CopyTo( Technique target )
{
target._isSupported = _isSupported;
target.SchemeIndex = SchemeIndex;
target._lodIndex = _lodIndex;
target.RemoveAllPasses();
// clone each pass and add that to the new technique
for ( int i = 0; i < _passes.Count; i++ )
{
Pass pass = _passes[ i ];
Pass newPass = pass.Clone( target, pass.Index );
target._passes.Add( newPass );
}
// Compile for categorized illumination on demand
ClearIlluminationPasses();
_illuminationPassesCompilationPhase = IlluminationPassesCompilationPhase.NotCompiled;
}
/// <summary>
/// Internal method for adding a transparent renderable.
/// </summary>
/// <param name="technique">Technique to use for this renderable.</param>
/// <param name="renderable">Renderable to add to the queue.</param>
protected void AddTransparentRenderable(Technique technique, IRenderable renderable)
{
for(int i = 0; i < technique.NumPasses; i++)
{
// add to transparent list
transparentPasses.Add(new RenderablePass(renderable, technique.GetPass(i)));
}
}
/// <summary>
/// Default constructor.
/// </summary>
/// <param name="parent">Technique that owns this Pass.</param>
/// <param name="index">Index of this pass.</param>
public XnaPass( Technique parent, int index )
: base( parent, index )
{
}
/// <summary>
/// Copy the details of this Technique to another.
/// </summary>
/// <param name="target"></param>
public void CopyTo(Technique target)
{
target.name = name;
target.isSupported = isSupported;
target.lodIndex = lodIndex;
target.schemeIndex = schemeIndex;
target.RemoveAllPasses();
// clone each pass and add that to the new technique
for(int i = 0; i < passes.Count; i++) {
Pass pass = (Pass)passes[i];
Pass newPass = pass.Clone(target, pass.Index);
target.passes.Add(newPass);
}
// Compile for categorised illumination on demand
target.ClearIlluminationPasses();
target.illuminationPassesCompilationPhase = IlluminationPassesState.NotCompiled;
}
/// <summary>
/// Removes the specified Technique from this material.
/// </summary>
/// <param name="t">A reference to the technique to remove</param>
public void RemoveTechnique(Technique t)
{
Debug.Assert(t != null, "t != null");
// remove from the list, and force a rebuild of supported techniques
techniques.Remove(t);
supportedTechniques.Clear();
bestTechniquesByScheme.Clear();
compilationRequired = true;
}
/// <summary>
/// Removes the specified Technique from this material.
/// </summary>
/// <param name="t">A reference to the technique to remove</param>
/// <ogre name="removeTechnique" />
public void RemoveTechnique( Technique t )
{
Debug.Assert( t != null, "t != null" );
// remove from the list, and force a rebuild of supported techniques
this.techniques.Remove( t );
this.SupportedTechniques.Clear();
this.ClearBestTechniqueList();
this._compilationRequired = true;
}
/// <summary>
/// Default constructor.
/// </summary>
/// <param name="parent">Technique that owns this Pass.</param>
/// <param name="index">Index of this pass.</param>
public Pass( Technique parent, int index )
{
this._parent = parent;
this._index = index;
lock ( passLock )
{
this.passId = nextPassId++;
}
// color defaults
_ambient = ColorEx.White;
_diffuse = ColorEx.White;
_specular = ColorEx.Black;
_emissive = ColorEx.Black;
// by default, don't override the scene's fog settings
_fogOverride = false;
_fogMode = FogMode.None;
_fogColor = ColorEx.White;
_fogStart = 0;
_fogEnd = 1;
_fogDensity = 0.001f;
// default blending (overwrite)
_sourceBlendFactor = SceneBlendFactor.One;
_destinationBlendFactor = SceneBlendFactor.Zero;
// depth buffer settings
_depthCheck = true;
_depthWrite = true;
_colorWriteEnabled = true;
_depthFunction = CompareFunction.LessEqual;
// cull settings
_cullingMode = CullingMode.Clockwise;
_manualCullingMode = ManualCullingMode.Back;
// light settings
_lightingEnabled = true;
_runOnlyForOneLightType = true;
_onlyLightType = LightType.Point;
_shadingMode = Shading.Gouraud;
// Default max lights to the global max
_maxSimultaneousLights = Config.MaxSimultaneousLights;
_name = index.ToString();
IterationCount = 1;
DirtyHash();
}
/// <see cref="Translator.Translate"/>
public override void Translate( ScriptCompiler compiler, AbstractNode node )
{
ObjectAbstractNode obj = (ObjectAbstractNode)node;
// Create the technique from the material
Material material = (Material)obj.Parent.Context;
_technique = material.CreateTechnique();
obj.Context = _technique;
// Get the name of the technique
if ( !string.IsNullOrEmpty( obj.Name ) )
_technique.Name = obj.Name;
// Set the properties for the technique
foreach ( AbstractNode i in obj.Children )
{
if ( i is PropertyAbstractNode )
{
PropertyAbstractNode prop = (PropertyAbstractNode)i;
switch ( (Keywords)prop.Id )
{
#region ID_SCHEME
case Keywords.ID_SCHEME:
if ( prop.Values.Count == 0 )
{
compiler.AddError( CompileErrorCode.StringExpected, prop.File, prop.Line );
}
else if ( prop.Values.Count > 1 )
{
compiler.AddError( CompileErrorCode.FewerParametersExpected, prop.File, prop.Line,
"scheme only supports 1 argument" );
}
else
{
string scheme;
if ( getString( prop.Values[ 0 ], out scheme ) )
_technique.Scheme = scheme;
else
compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line,
"scheme must have 1 string argument" );
}
break;
#endregion ID_SCHEME
#region ID_LOD_INDEX
case Keywords.ID_LOD_INDEX:
if ( prop.Values.Count == 0 )
{
compiler.AddError( CompileErrorCode.StringExpected, prop.File, prop.Line );
}
else if ( prop.Values.Count > 1 )
{
compiler.AddError( CompileErrorCode.FewerParametersExpected, prop.File, prop.Line,
"lod_index only supports 1 argument" );
}
else
{
int val;
if ( getInt( prop.Values[ 0 ], out val ) )
_technique.LodIndex = val;
else
compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line,
"lod_index cannot accept argument \"" + prop.Values[ 0 ].Value + "\"" );
}
break;
#endregion ID_LOD_INDEX
#region ID_SHADOW_CASTER_MATERIAL
case Keywords.ID_SHADOW_CASTER_MATERIAL:
if ( prop.Values.Count == 0 )
{
compiler.AddError( CompileErrorCode.StringExpected, prop.File, prop.Line );
}
else if ( prop.Values.Count > 1 )
{
compiler.AddError( CompileErrorCode.FewerParametersExpected, prop.File, prop.Line,
"shadow_caster_material only accepts 1 argument" );
}
else
{
string matName;
if ( getString( prop.Values[ 0 ], out matName ) )
{
string evtMatName = string.Empty;
ScriptCompilerEvent evt = new ProcessResourceNameScriptCompilerEvent(
ProcessResourceNameScriptCompilerEvent.ResourceType.Material, matName );
compiler._fireEvent( ref evt );
evtMatName = ( (ProcessResourceNameScriptCompilerEvent)evt ).Name;
_technique.ShadowCasterMaterial = (Material)MaterialManager.Instance[ evtMatName ]; // Use the processed name
}
else
compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line,
"shadow_caster_material cannot accept argument \"" + prop.Values[ 0 ].Value + "\"" );
}
break;
#endregion ID_SHADOW_CASTER_MATERIAL
#region ID_SHADOW_RECEIVER_MATERIAL
case Keywords.ID_SHADOW_RECEIVER_MATERIAL:
if ( prop.Values.Count == 0 )
{
compiler.AddError( CompileErrorCode.StringExpected, prop.File, prop.Line );
}
else if ( prop.Values.Count > 1 )
{
compiler.AddError( CompileErrorCode.FewerParametersExpected, prop.File, prop.Line,
"shadow_receiver_material only accepts 1 argument" );
}
else
{
AbstractNode i0 = getNodeAt( prop.Values, 0 );
string matName = string.Empty;
if ( getString( i0, out matName ) )
{
string evtName = string.Empty;
ScriptCompilerEvent evt = new ProcessResourceNameScriptCompilerEvent(
ProcessResourceNameScriptCompilerEvent.ResourceType.Material, matName );
compiler._fireEvent( ref evt );
evtName = ( (ProcessResourceNameScriptCompilerEvent)evt ).Name;
_technique.ShadowReceiverMaterial = (Material)MaterialManager.Instance[ evtName ];
}
else
compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line,
"shadow_receiver_material_name cannot accept argument \"" + i0.Value + "\"" );
}
break;
#endregion ID_SHADOW_RECEIVER_MATERIAL
#region ID_GPU_VENDOR_RULE
case Keywords.ID_GPU_VENDOR_RULE:
if ( prop.Values.Count < 2 )
{
compiler.AddError( CompileErrorCode.StringExpected, prop.File, prop.Line,
"gpu_vendor_rule must have 2 arguments" );
}
else if ( prop.Values.Count > 2 )
{
compiler.AddError( CompileErrorCode.FewerParametersExpected, prop.File, prop.Line,
"gpu_vendor_rule must have 2 arguments" );
}
else
{
AbstractNode i0 = getNodeAt( prop.Values, 0 );
AbstractNode i1 = getNodeAt( prop.Values, 1 );
Technique.GPUVendorRule rule = new Technique.GPUVendorRule();
if ( i0 is AtomAbstractNode )
{
AtomAbstractNode atom0 = (AtomAbstractNode)i0;
Keywords atom0Id = (Keywords)atom0.Id;
if ( atom0Id == Keywords.ID_INCLUDE )
{
rule.Include = true;
}
else if ( atom0Id == Keywords.ID_EXCLUDE )
{
rule.Include = false;
}
else
{
compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line,
"gpu_vendor_rule cannot accept \"" + i0.Value + "\" as first argument" );
}
string vendor = string.Empty;
if ( !getString( i1, out vendor ) )
{
compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line,
"gpu_vendor_rule cannot accept \"" + i1.Value + "\" as second argument" );
}
rule.Vendor = RenderSystemCapabilities.VendorFromString( vendor );
if ( rule.Vendor != GPUVendor.Unknown )
{
_technique.AddGPUVenderRule( rule );
}
}
else
{
compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line,
"gpu_vendor_rule cannot accept \"" + i0.Value + "\" as first argument" );
}
}
break;
#endregion ID_GPU_VENDOR_RULE
#region ID_GPU_DEVICE_RULE
case Keywords.ID_GPU_DEVICE_RULE:
if ( prop.Values.Count < 2 )
{
compiler.AddError( CompileErrorCode.StringExpected, prop.File, prop.Line,
"gpu_device_rule must have at least 2 arguments" );
}
else if ( prop.Values.Count > 3 )
{
compiler.AddError( CompileErrorCode.FewerParametersExpected, prop.File, prop.Line,
"gpu_device_rule must have at most 3 arguments" );
}
else
{
AbstractNode i0 = getNodeAt( prop.Values, 0 );
AbstractNode i1 = getNodeAt( prop.Values, 1 );
Technique.GPUDeviceNameRule rule = new Technique.GPUDeviceNameRule();
if ( i0 is AtomAbstractNode )
{
AtomAbstractNode atom0 = (AtomAbstractNode)i0;
Keywords atom0Id = (Keywords)atom0.Id;
if ( atom0Id == Keywords.ID_INCLUDE )
{
rule.Include = true;
}
else if ( atom0Id == Keywords.ID_EXCLUDE )
{
rule.Include = false;
}
else
{
compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line,
"gpu_device_rule cannot accept \"" + i0.Value + "\" as first argument" );
}
if ( !getString( i1, out rule.DevicePattern ) )
{
compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line,
"gpu_device_rule cannot accept \"" + i1.Value + "\" as second argument" );
}
if ( prop.Values.Count == 3 )
{
AbstractNode i2 = getNodeAt( prop.Values, 2 );
if ( !getBoolean( i2, out rule.CaseSensitive ) )
{
compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line,
"gpu_device_rule third argument must be \"true\", \"false\", \"yes\", \"no\", \"on\", or \"off\"" );
}
}
_technique.AddGPUDeviceNameRule( rule );
}
else
{
compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line,
"gpu_device_rule cannot accept \"" + i0.Value + "\" as first argument" );
}
}
break;
#endregion ID_GPU_DEVICE_RULE
default:
compiler.AddError( CompileErrorCode.UnexpectedToken, prop.File, prop.Line, "token \"" + prop.Name + "\" is not recognized" );
break;
} //end of switch statement
} // end of if ( i is PropertyAbstractNode )
else if ( i is ObjectAbstractNode )
{
_processNode( compiler, i );
}
}
}
/// <summary>
/// Creates a new Technique for this Material.
/// </summary>
/// <remarks>
/// A Technique is a single way of rendering geometry in order to achieve the effect
/// you are intending in a material. There are many reason why you would want more than
/// one - the main one being to handle variable graphics card abilities; you might have
/// one technique which is impressive but only runs on 4th-generation graphics cards,
/// for example. In this case you will want to create at least one fallback Technique.
/// The engine will work out which Techniques a card can support and pick the best one.
/// <p/>
/// If multiple Techniques are available, the order in which they are created is
/// important - the engine will consider lower-indexed Techniques to be preferable
/// to higher-indexed Techniques, ie when asked for the 'best' technique it will
/// return the first one in the technique list which is supported by the hardware.
/// </remarks>
/// <returns></returns>
public Technique CreateTechnique()
{
Technique t = new Technique(this);
techniques.Add(t);
compilationRequired = true;
return t;
}
public RSQuadOperation(CompositorInstance instance, uint pass_id, Material mat)
{
this.mat = mat;
this.instance = instance;
this.pass_id = pass_id;
mat.Load();
instance.FireNotifyMaterialSetup(pass_id, mat);
technique = mat.GetTechnique(0);
Debug.Assert(technique != null);
}
/// <summary>
/// Add children to the render queue
/// </summary>
/// <param name="queue"> </param>
/// <param name="group"> </param>
/// <param name="camSquaredDistance"> </param>
public void AddRenderables( RenderQueue queue, RenderQueueGroupID group, float camSquaredDistance )
{
// Determine the current material technique
mTechnique = mMaterial.GetBestTechnique( mMaterial.GetLodIndex( camSquaredDistance ) );
foreach ( GeometryBucket iter in mGeometryBucketList )
{
queue.AddRenderable( iter, group );
}
}
public void AddRenderables( RenderQueue queue, RenderQueueGroupID group, Real lodValue )
{
// Get batch instance
#warning OGRE-1.6 BatchInstance Implementation
//BatchInstance batchInstance = Parent.Parent;
// Get material lod strategy
var materialLodStrategy = Material.LodStrategy;
// If material strategy doesn't match, recompute lod value with correct strategy
#warning OGRE-1.6 BatchInstance Implementation needed
//if ( materialLodStrategy != batchInstance.LodStrategy )
// lodValue = materialLodStrategy.GetValue( batchInstance, batchInstance.Camera );
// determine the current material technique
this.technique = this.material.GetBestTechnique( this.material.GetLodIndex( lodValue ) );
foreach ( var gbucket in this.geometryBucketList )
{
queue.AddRenderable( gbucket, RenderQueue.DEFAULT_PRIORITY, group );
}
}
public TechniqueTranslator()
: base()
{
_technique = null;
}
/// <summary>
/// Internal method for adding a solid renderable ot the group based on lighting stage.
/// </summary>
/// <param name="technique">Technique to use for this renderable.</param>
/// <param name="renderable">Renderable to add to the queue.</param>
protected void AddSolidRenderableSplitByLightType(Technique technique, IRenderable renderable)
{
// Divide the passes into the 3 categories
for (int i = 0; i < technique.IlluminationPassCount; i++)
{
// Insert into solid list
IlluminationPass illpass = technique.GetIlluminationPass(i);
SortedList passMap = null;
switch(illpass.Stage)
{
case IlluminationStage.Ambient:
passMap = solidPasses;
break;
case IlluminationStage.PerLight:
passMap = solidPassesDiffuseSpecular;
break;
case IlluminationStage.Decal:
passMap = solidPassesDecal;
break;
}
RenderableList solidList = (RenderableList)passMap[illpass.Pass];
if(solidList == null)
{
// add a new list to hold renderables for this pass
solidList = new RenderableList();
passMap.Add(illpass.Pass, solidList);
}
solidList.Add(renderable);
}
}
public void AddRenderables(RenderQueue queue, RenderQueueGroupID group, float camDistanceSquared)
{
if (material != null) {
// determine the current material technique
technique = material.GetBestTechnique(material.GetLodIndexSquaredDepth(camDistanceSquared));
foreach (GeometryBucket gbucket in geometryBucketList)
queue.AddRenderable(gbucket, RenderQueue.DEFAULT_PRIORITY, group);
}
}
/// <summary>
/// Default constructor.
/// </summary>
/// <param name="parent">Technique that owns this Pass.</param>
/// <param name="index">Index of this pass.</param>
public Pass(Technique parent, int index)
{
this.parent = parent;
this.index = index;
lock (passLock) {
this.passId = nextPassId++;
}
// color defaults
ambient = ColorEx.White;
diffuse = ColorEx.White;
specular = ColorEx.Black;
emissive = ColorEx.Black;
// by default, don't override the scene's fog settings
fogOverride = false;
fogMode = FogMode.None;
fogColor = ColorEx.White;
fogStart = 0;
fogEnd = 1;
fogDensity = 0.001f;
// default blending (overwrite)
sourceBlendFactor = SceneBlendFactor.One;
destBlendFactor = SceneBlendFactor.Zero;
// depth buffer settings
depthCheck = true;
depthWrite = true;
colorWrite = true;
alphaRejectFunction = CompareFunction.AlwaysPass;
alphaRejectValue = 0;
depthFunc = CompareFunction.LessEqual;
depthBiasConstant = 0f;
depthBiasSlopeScale = 0f;
// cull settings
cullMode = CullingMode.Clockwise;
manualCullMode = ManualCullingMode.Back;
// light settings
lightingEnabled = true;
runOnlyForOneLightType = true;
lightsPerIteration = 1;
runOncePerLight = false;
onlyLightType = LightType.Point;
shadeOptions = Shading.Gouraud;
// Default max lights to the global max
maxLights = Config.MaxSimultaneousLights;
// Starting light index
startLight = 0;
// Default to solid
sceneDetail = SceneDetailLevel.Solid;
// Iteration count of 1
passIterationCount = 1;
// pointSize, etc.
pointSize = 1.0f;
pointMinSize = 0f;
pointMaxSize = 0f;
pointSpritesEnabled = false;
pointAttenuationEnabled = false;
pointAttenuationConstant = 1.0f;
pointAttenuationLinear = 0f;
pointAttenuationQuadratic = 0f;
contentTypeLookupBuilt = false;
name = index.ToString();
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;
}
private void InsertSupportedTechnique( Technique technique )
{
this.SupportedTechniques.Add( technique );
// get scheme
ushort schemeIndex = technique.SchemeIndex;
Dictionary<int, Technique> lodTechniques;
if ( !this.bestTechniquesByScheme.ContainsKey( schemeIndex ) )
{
lodTechniques = new Dictionary<int, Technique>();
this.bestTechniquesByScheme.Add( schemeIndex, lodTechniques );
}
else
{
lodTechniques = this.bestTechniquesByScheme[ schemeIndex ];
}
// Insert won't replace if supported technique for this scheme/lod is
// already there, which is what we want
if ( !lodTechniques.ContainsKey( technique.LodIndex ) )
{
lodTechniques.Add( technique.LodIndex, technique );
}
}
