static string[] GetMemberNamesFromMethodCall(MethodCall methodCall)
{
List <string> names = new List <string>();
while (methodCall != null)
{
names.Insert(0, methodCall.MethodName);
SelfReference selfRef = methodCall.Target as SelfReference;
InstanceVariable instance = methodCall.Target as InstanceVariable;
LocalVariable localVariable = methodCall.Target as LocalVariable;
methodCall = methodCall.Target as MethodCall;
if (methodCall == null)
{
if (selfRef != null)
{
names.Insert(0, "self");
}
else if (instance != null)
{
names.Insert(0, instance.Name);
}
else if (localVariable != null)
{
names.Insert(0, localVariable.Name);
}
}
}
return(names.ToArray());
}
/// <summary>
/// Creates a description of a parameter used in a shader.
/// </summary>
/// <param name="name">The variable name used in the shader.</param>
/// <param name="type">The identifier of the variable used in the shader.</param>
/// <param name="effect">A reference to the effect instance.</param>
/// <param name="updateMethod">A delegate method that "polls" the updated value.</param>
public InstanceParameter(string name, InstanceVariable type, Effect effect, dynamic variableRef, UpdateInstanceParameter updateMethod)
: base(name, effect)
{
Type = type;
effectVariable = variableRef;
update = updateMethod;
}
public object Deserialize(InstanceVariable instance)
{
string name = instance.Name.Substring(1);
object obj = componentCreator.GetComponent(name);
if (obj != null)
{
return(obj);
}
return(componentCreator.GetInstance(name));
}
private IEnumerable <Instance> Instantiate(string variableName, ISequenceResolver resolver, IEnumerable <string> categories, IDictionary <string, string> traits)
{
foreach (var obj in resolver.Execute())
{
var instanceVariable = new InstanceVariable(obj);
yield return(new Instance(
new Dictionary <string, ITestVariable>()
{
{ variableName, instanceVariable }
},
categories,
traits
));
}
}
void WalkSimpleAssignment(SimpleAssignmentExpression node)
{
AttributeAccess attributeAccess = node.Left as AttributeAccess;
InstanceVariable instance = node.Left as InstanceVariable;
LocalVariable localVariable = node.Left as LocalVariable;
if (attributeAccess != null)
{
RubyControlFieldExpression field = RubyControlFieldExpression.Create(attributeAccess);
object propertyValue = deserializer.Deserialize(node.Right);
if (propertyValue != null)
{
field.SetPropertyValue(componentCreator, propertyValue);
}
else if (IsResource(node.Right))
{
field.SetPropertyValue(componentCreator, GetResource(node.Right as MethodCall));
}
else
{
ThrowCouldNotFindTypeException(node.Right);
}
}
else if (instance != null)
{
string instanceName = RubyControlFieldExpression.GetVariableName(instance.Name);
object propertyValue = deserializer.Deserialize(instanceName, node.Right);
AddComponent(instanceName, propertyValue);
}
else if (localVariable != null)
{
object propertyValue = deserializer.Deserialize(localVariable.Name, node.Right);
if (propertyValue == null)
{
ThrowCouldNotFindTypeException(node.Right);
}
}
}
public static string[] GetMemberNames(InstanceVariable instance)
{
return(new string[] { instance.Name });
}
public void SetInstanceParameter(InstanceVariable instanceVariable)
{
InstanceParameter ip = InstanceParameter.Create(instanceVariable, effect);
SetInstanceParameter(ip);
}
/// <summary>
/// Creates a "default parameter", such as World, View, Projection Matrices,
/// light direction, positionV3, ambient Color and so on.
/// </summary>
/// <param name="type">The type of the parameter to create.</param>
/// <param name="effect">A reference of the effect instance.</param>
/// <returns>An istance of EffectParameter containg all the needed information
/// to correctly set and update this value into the shader.</returns>
public static InstanceParameter Create(InstanceVariable type, Effect effect)
{
string varName = string.Empty;
dynamic eV = null;
UpdateInstanceParameter update = null;
VerboseEvent.InstanceParameterCreation.Log(type.ToString());
switch (type)
{
case InstanceVariable.ObjectWorld:
varName = ParamHandles.Matrices.World;
eV = effect.GetVariableByName(varName).AsMatrix();
update = (fxParam, rObject) => MatrixUpdate(fxParam.EffectVariable, rObject.World);
break;
case InstanceVariable.LightAmbient:
varName = ParamHandles.Color4s.LightAmbient;
eV = effect.GetVariableByName(varName).AsVector();
update =
(fxParam, rObject) =>
Color44Update(fxParam.EffectVariable,
((IColorMaterial)rObject.Material).AmbientColor);
break;
case InstanceVariable.Diffuse:
varName = ParamHandles.Color4s.MaterialDiffuse;
eV = effect.GetVariableByName(varName).AsVector();
update =
(fxParam, rObject) =>
Color44Update(fxParam.EffectVariable,
((IColorMaterial)rObject.Material).DiffuseColor);
break;
case InstanceVariable.Ambient:
varName = ParamHandles.Color4s.MaterialAmbient;
eV = effect.GetVariableByName(varName).AsVector();
update =
(fxParam, rObject) => Color44Update(fxParam.EffectVariable, ((IColorMaterial)rObject.Material).AmbientColor);
break;
case InstanceVariable.Specular:
varName = ParamHandles.Color4s.MaterialSpecular;
eV = effect.GetVariableByName(varName).AsVector();
update =
(fxParam, rObject) =>
Color44Update(fxParam.EffectVariable,
((IColorMaterial)rObject.Material).SpecularColor);
break;
case InstanceVariable.DiffuseMap:
varName = ParamHandles.Textures.DiffuseMap;
eV = effect.GetVariableByName(varName).AsResource();
update=(fxParam, rObject) =>
ResourceUpdate(fxParam.EffectVariable,
((IDiffuseMap)rObject).DiffuseMapResource);
break;
case InstanceVariable.AmbientCoefficient:
varName = ParamHandles.Color4s.MaterialkA;
eV = effect.GetVariableByName(varName).AsScalar();
update = (fxParam, rObject) => FloatUpdate(fxParam.EffectVariable, ((IColorMaterial)rObject.Material).AmbientCoefficient);
break;
case InstanceVariable.DiffuseCoefficient:
varName = ParamHandles.Color4s.MaterialkD;
eV = effect.GetVariableByName(varName).AsScalar();
update = (fxParam, rObject) => FloatUpdate(fxParam.EffectVariable, ((IColorMaterial)rObject.Material).AmbientCoefficient);
break;
case InstanceVariable.MaterialBuffer:
varName = ParamHandles.CBuffers.MaterialBuffer;
eV = effect.GetConstantBufferByName(varName).AsConstantBuffer();
update = (fxParam, rObject) => BufferUpdate(fxParam.EffectVariable, MaterialBuffer.FromMaterial((ShaderMaterial)rObject.Material));
break;
}
return new InstanceParameter(varName, type, effect, eV, update);
}
