/// <summary>
/// Returns a ShaderModelConstantRegister object with the information contained in
/// the given regular expression match.
/// </summary>
private static ShaderModelConstantRegister CreateRegister(TargetFramework targetFramework, Match match)
{
ShaderModelConstantRegister register = null;
// Figure out the .NET type that corresponds to the register type.
var registerTypeInHlsl = match.Groups["registerType"].Value;
var registerType = GetRegisterType(targetFramework, registerTypeInHlsl);
if (registerType != null)
{
// See if the user prefers to specify a different type in a comment.
if (match.Groups["type"].Success)
{
OverrideTypeIfAllowed(targetFramework, match.Groups["type"].Value, ref registerType);
}
// Capitalize the first letter of the variable name. Leave the rest alone.
var registerName = match.Groups["registerName"].Value;
registerName = char.ToUpperInvariant(registerName[0]) + registerName.Substring(1);
// Get the register number and the optional summary comment.
var registerNumber = int.Parse(match.Groups["registerNumber"].Value);
if (typeof(Brush).IsAssignableFrom(registerType) && (registerNumber == 0))
{
return(null); // ignore the implicit input sampler
}
var summary = match.Groups["summary"].Value;
// Get the standard min, max, and default value for the register type.
GetStandardValues(registerType, out object minValue, out object maxValue, out object defaultValue);
// Allow the user to override the defaults with values from their comments.
ConvertValue(match.Groups["minValue"].Value, registerType, ref minValue);
ConvertValue(match.Groups["maxValue"].Value, registerType, ref maxValue);
ConvertValue(match.Groups["defaultValue"].Value, registerType, ref defaultValue);
// And if the user specified an initializer for the register value in HLSL,
// that value overrides any other default value.
if (match.Groups["initializer"].Success)
{
ParseInitializerValue(match.Groups["initializerValue"].Value, registerType, ref defaultValue);
}
// Create a structure to hold the register information.
register = new ShaderModelConstantRegister(
registerName,
registerType,
registerNumber,
summary,
minValue,
maxValue,
defaultValue);
}
return(register);
}
public TexturePicker(ShaderModelConstantRegister register)
{
this.InitializeComponent();
this.register = register;
//// attempt to get the already loaded value
Images.TryGetValue(this.register.RegisterNumber, out ImageBrush result);
this.Value = result;
if (this.Value == null)
{
this.LoadTextureFromSettings();
}
this.SetupTextures();
}
public TexturePicker(ShaderModelConstantRegister register)
{
InitializeComponent();
_register = register;
ImageBrush result;
// attempt to get the already loaded value
_images.TryGetValue(_register.RegisterNumber, out result);
Value = result;
if (Value == null)
{
LoadTextureFromSettings();
}
SetupTextures();
}
/// <summary>
/// Returns a shader model constructed from the information found in the
/// given pixel shader file.
/// </summary>
public static ShaderModel ParseShader(string shaderFileName, string shaderText)
{
// Remove all double-slash comments (but not triple-slash comments).
// This helps us avoid parsing register declarations that are commented out.
shaderText = CommentRegex.Replace(shaderText, String.Empty);
// Find all header comments.
Match headerMatch = HeaderCommentsRegex.Match(shaderText);
// Determine the class name, namespace, description, and target platform.
string defaultClassName = Path.GetFileNameWithoutExtension(shaderFileName);
defaultClassName = Char.ToUpperInvariant(defaultClassName[0]) + defaultClassName.Substring(1) + "Effect";
string className = GetValidId(headerMatch.Groups["class"].Value, defaultClassName, false);
string namespaceName = GetValidId(headerMatch.Groups["namespace"].Value, Settings.Default.GeneratedNamespace, true);
string description = headerMatch.Groups["description"].Success ? headerMatch.Groups["description"].Value : null;
string targetFrameworkName = headerMatch.Groups["target"].Success ? headerMatch.Groups["target"].Value : Settings.Default.TargetFramework;
TargetFramework targetFramework = targetFrameworkName == "Silverlight" ? TargetFramework.Silverlight : TargetFramework.WPF;
// Find all register declarations.
MatchCollection matches = RegisterConstantDeclarationRegex.Matches(shaderText);
// Create a list of shader model constant registers.
List <ShaderModelConstantRegister> registers = new List <ShaderModelConstantRegister>();
foreach (Match match in matches)
{
ShaderModelConstantRegister register = CreateRegister(targetFramework, match);
if (register != null)
{
registers.Add(register);
}
}
// Return a new shader model.
return(new ShaderModel
{
ShaderFileName = shaderFileName,
GeneratedClassName = className,
GeneratedNamespace = namespaceName,
Description = description,
TargetFramework = targetFramework,
Registers = registers
});
}
private static CodeMemberField CreateShaderRegisterDependencyProperty(ShaderModel shaderModel, ShaderModelConstantRegister register)
{
if (typeof(Brush).IsAssignableFrom(register.RegisterType))
{
return(new CodeMemberField
{
Type = new CodeTypeReference("DependencyProperty"),
Name = String.Format("{0}Property", register.RegisterName),
Attributes = MemberAttributes.Public | MemberAttributes.Static,
InitExpression = new CodeMethodInvokeExpression
{
Method = new CodeMethodReferenceExpression
{
TargetObject = new CodeTypeReferenceExpression("ShaderEffect"),
MethodName = "RegisterPixelShaderSamplerProperty"
},
Parameters =
{
new CodePrimitiveExpression(register.RegisterName),
new CodeTypeOfExpression(shaderModel.GeneratedClassName),
new CodePrimitiveExpression(register.RegisterNumber)
}
}
});
}
return(new CodeMemberField
{
Type = new CodeTypeReference("DependencyProperty"),
Name = String.Format("{0}Property", register.RegisterName),
Attributes = MemberAttributes.Public | MemberAttributes.Static,
InitExpression = new CodeMethodInvokeExpression
{
Method = new CodeMethodReferenceExpression
{
TargetObject = new CodeTypeReferenceExpression("DependencyProperty"),
MethodName = "Register"
},
Parameters =
{
new CodePrimitiveExpression(register.RegisterName),
new CodeTypeOfExpression(CreateCodeTypeReference(register.RegisterType)),
new CodeTypeOfExpression(shaderModel.GeneratedClassName),
new CodeObjectCreateExpression
{
// Silverlight doesn't have UIPropertyMetadata.
CreateType = new CodeTypeReference(shaderModel.TargetFramework == TargetFramework.WPF ? "UIPropertyMetadata" : "PropertyMetadata"),
Parameters =
{
CreateDefaultValue(register.DefaultValue),
new CodeMethodInvokeExpression
{
Method = new CodeMethodReferenceExpression(null,"PixelShaderConstantCallback"),
Parameters =
{
new CodePrimitiveExpression(register.RegisterNumber)
}
}
}
}
}
}
});
}
private static CodeMemberField CreateShaderRegisterDependencyProperty(ShaderModel shaderModel, ShaderModelConstantRegister register)
{
if (typeof(Brush).IsAssignableFrom(register.RegisterType))
{
return(new CodeMemberField
{
Comments =
{
new CodeCommentStatement("<summary>The ShaderEffect.RegisterPixelShaderSamplerProperty() method must be used with this field as argument. Note the last parameter of this method: it is an integer and it corresponds to the S0 pixel shader register.</summary>"),
},
Type = new CodeTypeReference("DependencyProperty"),
Name = $"{register.RegisterName}Property",
//// ReSharper disable once BitwiseOperatorOnEnumWithoutFlags
Attributes = MemberAttributes.Public | MemberAttributes.Static,
InitExpression = new CodeMethodInvokeExpression
{
Method = new CodeMethodReferenceExpression
{
TargetObject = new CodeTypeReferenceExpression("ShaderEffect"),
MethodName = "RegisterPixelShaderSamplerProperty"
},
Parameters =
{
new CodePrimitiveExpression(register.RegisterName),
new CodeTypeOfExpression(shaderModel.GeneratedClassName),
new CodePrimitiveExpression(register.RegisterNumber)
}
},
});
}
return(new CodeMemberField
{
Type = new CodeTypeReference("DependencyProperty"),
Name = $"{register.RegisterName}Property",
//// ReSharper disable once BitwiseOperatorOnEnumWithoutFlags
Attributes = MemberAttributes.Public | MemberAttributes.Static,
InitExpression = new CodeMethodInvokeExpression
{
Method = new CodeMethodReferenceExpression
{
TargetObject = new CodeTypeReferenceExpression("DependencyProperty"),
MethodName = "Register"
},
Parameters =
{
new CodePrimitiveExpression(register.RegisterName),
new CodeTypeOfExpression(CreateCodeTypeReference(register.RegisterType)),
new CodeTypeOfExpression(shaderModel.GeneratedClassName),
new CodeObjectCreateExpression
{
// Silverlight doesn't have UIPropertyMetadata.
CreateType = new CodeTypeReference(shaderModel.TargetFramework == TargetFramework.WPF ? "UIPropertyMetadata" : "PropertyMetadata"),
Parameters =
{
CreateDefaultValue(register.RegisterType, register.DefaultValue),
new CodeMethodInvokeExpression
{
Method = new CodeMethodReferenceExpression(null,"PixelShaderConstantCallback"),
Parameters =
{
new CodePrimitiveExpression(register.RegisterNumber)
}
}
}
}
}
}
});
}
private void GenerateShaderInputControl(ShaderModelConstantRegister register)
{
string toolTipText = String.IsNullOrEmpty(register.Description) ? null : register.Description;
TextBlock textBlock = new TextBlock
{
Foreground = Brushes.White,
Margin = new Thickness(5),
Inlines =
{
new Run {
Foreground = (Brush)Application.Current.FindResource("HighlightBrush"), Text = register.RegisterName
},
new Run {
Text = String.Format(" : {0}", register.RegisterType.Name)
},
},
ToolTip = toolTipText
};
inputControlPanel.Children.Add(textBlock);
Control control = null;
if (register.RegisterType == typeof(Brush))
{
control = new TexturePicker(register);
}
else if (register.RegisterType == typeof(double) || register.RegisterType == typeof(float))
{
double minValue = Convert.ToDouble(register.MinValue);
double maxValue = Convert.ToDouble(register.MaxValue);
//double defaultValue = Double.Parse(register.DefaultValue.ToString(), NumberStyles.Any, null);
double defaultValue = Convert.ToDouble(register.DefaultValue);
control = new AdjustableSlider
{
Minimum = Math.Min(minValue, defaultValue),
Maximum = Math.Max(maxValue, defaultValue),
Value = defaultValue
};
}
else if (register.RegisterType == typeof(Point) || register.RegisterType == typeof(Vector) || register.RegisterType == typeof(Size))
{
Point minValue = (Point)RegisterValueConverter.ConvertToUsualType(register.MinValue);
Point maxValue = (Point)RegisterValueConverter.ConvertToUsualType(register.MaxValue);
Point defaultValue = (Point)RegisterValueConverter.ConvertToUsualType(register.DefaultValue);
control = new AdjustableSliderPair
{
Minimum = new Point(Math.Min(minValue.X, defaultValue.X), Math.Min(minValue.Y, defaultValue.Y)),
Maximum = new Point(Math.Max(maxValue.X, defaultValue.X), Math.Max(maxValue.Y, defaultValue.Y)),
Value = defaultValue
};
}
else if (register.RegisterType == typeof(Point3D) || register.RegisterType == typeof(Vector3D))
{
Point3D minValue = (Point3D)RegisterValueConverter.ConvertToUsualType(register.MinValue);
Point3D maxValue = (Point3D)RegisterValueConverter.ConvertToUsualType(register.MaxValue);
Point3D defaultValue = (Point3D)RegisterValueConverter.ConvertToUsualType(register.DefaultValue);
control = new AdjustableSliderTriplet
{
Minimum = new Point3D(Math.Min(minValue.X, defaultValue.X), Math.Min(minValue.Y, defaultValue.Y), Math.Min(minValue.Z, defaultValue.Z)),
Maximum = new Point3D(Math.Max(maxValue.X, defaultValue.X), Math.Max(maxValue.Y, defaultValue.Y), Math.Max(maxValue.Z, defaultValue.Z)),
Value = defaultValue
};
}
else if (register.RegisterType == typeof(Color))
{
Color defaultValue = (Color)register.DefaultValue;
//control = new Telerik.Windows.Controls.RadColorEditor
//{
// HorizontalAlignment = HorizontalAlignment.Left,
// SelectedColor = defaultValue
//};
control = new AdjustableColor
{
HorizontalAlignment = HorizontalAlignment.Left,
Value = defaultValue
};
// ((control) as AdjustableColor).;
//control = new TextBox
//{
// Background = Brushes.LightYellow,
// Width = 150,
// HorizontalAlignment = HorizontalAlignment.Left,
// Text = defaultValue.ToString()
//};
}
else if (register.RegisterType == typeof(Point4D))
{
Point4D minValue = (Point4D)register.MinValue;
Point4D maxValue = (Point4D)register.MaxValue;
Point4D defaultValue = (Point4D)register.DefaultValue;
control = new AdjustableSliderQuadruplet
{
Minimum = new Point4D(Math.Min(minValue.X, defaultValue.X), Math.Min(minValue.Y, defaultValue.Y), Math.Min(minValue.Z, defaultValue.Z), Math.Min(minValue.W, defaultValue.W)),
Maximum = new Point4D(Math.Max(maxValue.X, defaultValue.X), Math.Max(maxValue.Y, defaultValue.Y), Math.Max(maxValue.Z, defaultValue.Z), Math.Max(maxValue.W, defaultValue.W)),
Value = defaultValue
};
}
if (control != null)
{
control.Margin = new Thickness(15, 2, 25, 5);
control.ToolTip = toolTipText;
this.inputControlPanel.Children.Add(control);
register.AffiliatedControl = control;
}
}
