void HandleSamplerStatePropertyField(PropertySheet propertySheet, SamplerStateShaderProperty samplerStateShaderProperty)
{
var enumPropertyDrawer = new EnumPropertyDrawer();
propertySheet.Add(enumPropertyDrawer.CreateGUI(
newValue =>
{
this._preChangeValueCallback("Change property value");
TextureSamplerState state = samplerStateShaderProperty.value;
state.filter = (TextureSamplerState.FilterMode)newValue;
samplerStateShaderProperty.value = state;
this._postChangeValueCallback(false, ModificationScope.Graph);
this.inspectorUpdateDelegate();
},
samplerStateShaderProperty.value.filter,
"Filter",
TextureSamplerState.FilterMode.Linear,
out var filterVisualElement));
propertySheet.Add(enumPropertyDrawer.CreateGUI(
newValue =>
{
this._preChangeValueCallback("Change property value");
TextureSamplerState state = samplerStateShaderProperty.value;
state.wrap = (TextureSamplerState.WrapMode)newValue;
samplerStateShaderProperty.value = state;
this._postChangeValueCallback(false, ModificationScope.Graph);
this.inspectorUpdateDelegate();
},
samplerStateShaderProperty.value.wrap,
"Wrap",
TextureSamplerState.WrapMode.Repeat,
out var wrapVisualElement));
}
private void ResetSampler(GraphicsDevice device, int index, bool PS)
{
SamplerState ss;
TextureSamplerState tss = PS ? TextureSamplerState.BilinearFiltering : TextureSamplerState.PointFiltering;
try
{
if (PS)
{
ss = device.SamplerStates[index];
device.Textures[index] = null;
}
else
{
ss = device.VertexSamplerStates[index];
device.VertexTextures[index] = null;
}
//reset everything
ss.AddressU = tss.AddressU;
ss.AddressV = tss.AddressV;
ss.AddressW = tss.AddressW;
ss.MagFilter = tss.MagFilter;
ss.MinFilter = tss.MinFilter;
ss.MipFilter = tss.MipFilter;
ss.MaxAnisotropy = tss.MaxAnisotropy;
ss.MaxMipLevel = tss.MaxMipmapLevel;
}
catch
{
//ignore...
}
}
void BuildSamplerStatePropertyField(SamplerStateShaderProperty property)
{
var filterField = new EnumField(property.value.filter);
filterField.RegisterValueChangedCallback(evt =>
{
graph.owner.RegisterCompleteObjectUndo("Change Property Value");
TextureSamplerState state = property.value;
state.filter = (TextureSamplerState.FilterMode)evt.newValue;
property.value = state;
Rebuild();
DirtyNodes(ModificationScope.Graph);
});
AddRow("Filter", filterField);
var wrapField = new EnumField(property.value.wrap);
wrapField.RegisterValueChangedCallback(evt =>
{
graph.owner.RegisterCompleteObjectUndo("Change Property Value");
TextureSamplerState state = property.value;
state.wrap = (TextureSamplerState.WrapMode)evt.newValue;
property.value = state;
Rebuild();
DirtyNodes(ModificationScope.Graph);
});
AddRow("Wrap", wrapField);
}
static TexturedElement()
{
bilinearFilter = TextureSamplerState.BilinearFiltering;
bilinearFilter.AddressUV = TextureAddressMode.Clamp;
pointFilter = TextureSamplerState.PointFiltering;
pointFilter.AddressUV = TextureAddressMode.Clamp;
}
static TexturedElement()
{
_bilinearFilter = TextureSamplerState.BilinearFiltering;
_bilinearFilter.AddressUV = TextureAddress.Clamp;
_pointFilter = TextureSamplerState.PointFiltering;
_pointFilter.AddressUV = TextureAddress.Clamp;
}
static TexturedElement()
{
_bilinearFilter = TextureSamplerState.BilinearFiltering;
_bilinearFilter.AddressUV = TextureAddress.Clamp;
_pointFilter = TextureSamplerState.PointFiltering;
_pointFilter.AddressUV = TextureAddress.Clamp;
}
/// <summary>
/// Initializes a new instance of the <see cref="GorgonRenderable"/> class.
/// </summary>
/// <param name="gorgon2D">Gorgon 2D interface.</param>
/// <param name="name">The name.</param>
/// <exception cref="System.ArgumentNullException">Thrown when the <paramref name="name"/> parameter is NULL (Nothing in VB.Net).
/// <para>-or-</para>
/// <para>Thrown when the <paramref name="gorgon2D"/> parameter is NULL.</para>
/// </exception>
/// <exception cref="System.ArgumentException">Thrown when the <paramref name="name"/> parameter is an empty string.</exception>
protected GorgonRenderable(Gorgon2D gorgon2D, string name)
: base(name)
{
GorgonDebug.AssertNull(gorgon2D, "gorgon2D");
Gorgon2D = gorgon2D;
CullingMode = CullingMode.Back;
AlphaTestValues = GorgonRangeF.Empty;
DepthStencil = new DepthStencilStates();
Blending = new BlendState();
TextureSampler = new TextureSamplerState();
BaseVertexCount = 0;
}
public BlackboardFieldPropertyView(BlackboardField blackboardField, GraphData graph, AbstractShaderProperty property)
{
styleSheets.Add(Resources.Load <StyleSheet>("Styles/ShaderGraphBlackboard"));
m_BlackboardField = blackboardField;
m_Graph = graph;
m_Property = property;
if (!m_Graph.isSubGraph)
{
if (property.isExposable)
{
m_ExposedToogle = new Toggle();
m_ExposedToogle.OnToggleChanged(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change Exposed Toggle");
if (m_OnExposedToggle != null)
{
m_OnExposedToggle();
}
property.generatePropertyBlock = evt.newValue;
if (property.generatePropertyBlock)
{
m_BlackboardField.icon = BlackboardProvider.exposedIcon;
}
else
{
m_BlackboardField.icon = null;
}
DirtyNodes(ModificationScope.Graph);
});
m_ExposedToogle.value = property.generatePropertyBlock;
AddRow("Exposed", m_ExposedToogle);
}
if (property.isExposable)
{
m_ReferenceNameField = new TextField(512, false, false, ' ');
m_ReferenceNameField.styleSheets.Add(Resources.Load <StyleSheet>("Styles/PropertyNameReferenceField"));
AddRow("Reference", m_ReferenceNameField);
m_ReferenceNameField.value = property.referenceName;
m_ReferenceNameField.isDelayed = true;
m_ReferenceNameField.RegisterValueChangedCallback(newName =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change Reference Name");
if (m_ReferenceNameField.value != m_Property.referenceName)
{
string newReferenceName = m_Graph.SanitizePropertyReferenceName(newName.newValue, property.guid);
property.overrideReferenceName = newReferenceName;
}
m_ReferenceNameField.value = property.referenceName;
if (string.IsNullOrEmpty(property.overrideReferenceName))
{
m_ReferenceNameField.RemoveFromClassList("modified");
}
else
{
m_ReferenceNameField.AddToClassList("modified");
}
DirtyNodes(ModificationScope.Graph);
UpdateReferenceNameResetMenu();
});
if (!string.IsNullOrEmpty(property.overrideReferenceName))
{
m_ReferenceNameField.AddToClassList("modified");
}
}
}
// Key Undo callbacks for input fields
EventCallback <KeyDownEvent> keyDownCallback = new EventCallback <KeyDownEvent>(evt =>
{
// Record Undo for input field edit
if (m_UndoGroup == -1)
{
m_UndoGroup = Undo.GetCurrentGroup();
m_Graph.owner.RegisterCompleteObjectUndo("Change property value");
}
// Handle scaping input field edit
if (evt.keyCode == KeyCode.Escape && m_UndoGroup > -1)
{
Undo.RevertAllDownToGroup(m_UndoGroup);
m_UndoGroup = -1;
evt.StopPropagation();
}
// Dont record Undo again until input field is unfocused
m_UndoGroup++;
this.MarkDirtyRepaint();
});
EventCallback <FocusOutEvent> focusOutCallback = new EventCallback <FocusOutEvent>(evt =>
{
// Reset UndoGroup when done editing input field
m_UndoGroup = -1;
});
if (property is Vector1ShaderProperty)
{
var floatProperty = (Vector1ShaderProperty)property;
BuildVector1PropertyView(floatProperty);
}
else if (property is Vector2ShaderProperty)
{
var vectorProperty = (Vector2ShaderProperty)property;
var field = new Vector2Field {
value = vectorProperty.value
};
field.Q("unity-x-input").Q("unity-text-input").RegisterCallback <KeyDownEvent>(keyDownCallback);
field.Q("unity-x-input").Q("unity-text-input").RegisterCallback <FocusOutEvent>(focusOutCallback);
field.Q("unity-y-input").Q("unity-text-input").RegisterCallback <KeyDownEvent>(keyDownCallback);
field.Q("unity-y-input").Q("unity-text-input").RegisterCallback <FocusOutEvent>(focusOutCallback);
// Called after KeyDownEvent
field.RegisterValueChangedCallback(evt =>
{
// Only true when setting value via FieldMouseDragger
// Undo recorded once per dragger release
if (m_UndoGroup == -1)
{
m_Graph.owner.RegisterCompleteObjectUndo("Change property value");
}
vectorProperty.value = evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is Vector3ShaderProperty)
{
var vectorProperty = (Vector3ShaderProperty)property;
var field = new Vector3Field {
value = vectorProperty.value
};
field.Q("unity-x-input").Q("unity-text-input").RegisterCallback <KeyDownEvent>(keyDownCallback);
field.Q("unity-x-input").Q("unity-text-input").RegisterCallback <FocusOutEvent>(focusOutCallback);
field.Q("unity-y-input").Q("unity-text-input").RegisterCallback <KeyDownEvent>(keyDownCallback);
field.Q("unity-y-input").Q("unity-text-input").RegisterCallback <FocusOutEvent>(focusOutCallback);
field.Q("unity-z-input").Q("unity-text-input").RegisterCallback <KeyDownEvent>(keyDownCallback);
field.Q("unity-z-input").Q("unity-text-input").RegisterCallback <FocusOutEvent>(focusOutCallback);
// Called after KeyDownEvent
field.RegisterValueChangedCallback(evt =>
{
// Only true when setting value via FieldMouseDragger
// Undo recorded once per dragger release
if (m_UndoGroup == -1)
{
m_Graph.owner.RegisterCompleteObjectUndo("Change property value");
}
vectorProperty.value = evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is Vector4ShaderProperty)
{
var vectorProperty = (Vector4ShaderProperty)property;
var field = new Vector4Field {
value = vectorProperty.value
};
field.Q("unity-x-input").Q("unity-text-input").RegisterCallback <KeyDownEvent>(keyDownCallback);
field.Q("unity-x-input").Q("unity-text-input").RegisterCallback <FocusOutEvent>(focusOutCallback);
field.Q("unity-y-input").Q("unity-text-input").RegisterCallback <KeyDownEvent>(keyDownCallback);
field.Q("unity-y-input").Q("unity-text-input").RegisterCallback <FocusOutEvent>(focusOutCallback);
field.Q("unity-z-input").Q("unity-text-input").RegisterCallback <KeyDownEvent>(keyDownCallback);
field.Q("unity-z-input").Q("unity-text-input").RegisterCallback <FocusOutEvent>(focusOutCallback);
field.Q("unity-w-input").Q("unity-text-input").RegisterCallback <KeyDownEvent>(keyDownCallback);
field.Q("unity-w-input").Q("unity-text-input").RegisterCallback <FocusOutEvent>(focusOutCallback);
// Called after KeyDownEvent
field.RegisterValueChangedCallback(evt =>
{
// Only true when setting value via FieldMouseDragger
// Undo recorded once per dragger release
if (m_UndoGroup == -1)
{
m_Graph.owner.RegisterCompleteObjectUndo("Change property value");
}
vectorProperty.value = evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is ColorShaderProperty)
{
var colorProperty = (ColorShaderProperty)property;
var colorField = new ColorField {
value = property.defaultValue, showEyeDropper = false, hdr = colorProperty.colorMode == ColorMode.HDR
};
colorField.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change property value");
colorProperty.value = evt.newValue;
DirtyNodes();
});
AddRow("Default", colorField);
if (!m_Graph.isSubGraph)
{
var colorModeField = new EnumField((Enum)colorProperty.colorMode);
colorModeField.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change Color Mode");
if (colorProperty.colorMode == (ColorMode)evt.newValue)
{
return;
}
colorProperty.colorMode = (ColorMode)evt.newValue;
colorField.hdr = colorProperty.colorMode == ColorMode.HDR;
colorField.MarkDirtyRepaint();
DirtyNodes();
});
AddRow("Mode", colorModeField);
}
}
else if (property is TextureShaderProperty)
{
var textureProperty = (TextureShaderProperty)property;
var field = new ObjectField {
value = textureProperty.value.texture, objectType = typeof(Texture)
};
field.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change property value");
textureProperty.value.texture = (Texture)evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
if (!m_Graph.isSubGraph)
{
var defaultModeField = new EnumField((Enum)textureProperty.defaultType);
defaultModeField.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change Texture Mode");
if (textureProperty.defaultType == (TextureShaderProperty.DefaultType)evt.newValue)
{
return;
}
textureProperty.defaultType = (TextureShaderProperty.DefaultType)evt.newValue;
DirtyNodes(ModificationScope.Graph);
});
void ToggleDefaultModeFieldEnabled()
{
defaultModeField.SetEnabled(!defaultModeField.enabledSelf);
}
m_OnExposedToggle += ToggleDefaultModeFieldEnabled;
AddRow("Mode", defaultModeField);
}
}
else if (property is Texture2DArrayShaderProperty)
{
var textureProperty = (Texture2DArrayShaderProperty)property;
var field = new ObjectField {
value = textureProperty.value.textureArray, objectType = typeof(Texture2DArray)
};
field.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change property value");
textureProperty.value.textureArray = (Texture2DArray)evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is Texture3DShaderProperty)
{
var textureProperty = (Texture3DShaderProperty)property;
var field = new ObjectField {
value = textureProperty.value.texture, objectType = typeof(Texture3D)
};
field.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change property value");
textureProperty.value.texture = (Texture3D)evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is CubemapShaderProperty)
{
var cubemapProperty = (CubemapShaderProperty)property;
var field = new ObjectField {
value = cubemapProperty.value.cubemap, objectType = typeof(Cubemap)
};
field.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change property value");
cubemapProperty.value.cubemap = (Cubemap)evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is BooleanShaderProperty)
{
var booleanProperty = (BooleanShaderProperty)property;
EventCallback <ChangeEvent <bool> > onBooleanChanged = evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change property value");
booleanProperty.value = evt.newValue;
DirtyNodes();
};
var field = new Toggle();
field.OnToggleChanged(onBooleanChanged);
field.value = booleanProperty.value;
AddRow("Default", field);
}
else if (property is Matrix2ShaderProperty)
{
var matrix2Property = (Matrix2ShaderProperty)property;
var row0Field = new Vector2Field {
value = matrix2Property.value.GetRow(0)
};
row0Field.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change Property Value");
Vector2 row1 = matrix2Property.value.GetRow(1);
matrix2Property.value = new Matrix4x4()
{
m00 = evt.newValue.x,
m01 = evt.newValue.y,
m02 = 0,
m03 = 0,
m10 = row1.x,
m11 = row1.y,
m12 = 0,
m13 = 0,
m20 = 0,
m21 = 0,
m22 = 0,
m23 = 0,
m30 = 0,
m31 = 0,
m32 = 0,
m33 = 0,
};
DirtyNodes();
});
AddRow("Default", row0Field);
var row1Field = new Vector2Field {
value = matrix2Property.value.GetRow(1)
};
row1Field.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change Property Value");
Vector2 row0 = matrix2Property.value.GetRow(0);
matrix2Property.value = new Matrix4x4()
{
m00 = row0.x,
m01 = row0.y,
m02 = 0,
m03 = 0,
m10 = evt.newValue.x,
m11 = evt.newValue.y,
m12 = 0,
m13 = 0,
m20 = 0,
m21 = 0,
m22 = 0,
m23 = 0,
m30 = 0,
m31 = 0,
m32 = 0,
m33 = 0,
};
DirtyNodes();
});
AddRow("", row1Field);
}
else if (property is Matrix3ShaderProperty)
{
var matrix3Property = (Matrix3ShaderProperty)property;
var row0Field = new Vector3Field {
value = matrix3Property.value.GetRow(0)
};
row0Field.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change Property Value");
Vector3 row1 = matrix3Property.value.GetRow(1);
Vector3 row2 = matrix3Property.value.GetRow(2);
matrix3Property.value = new Matrix4x4()
{
m00 = evt.newValue.x,
m01 = evt.newValue.y,
m02 = evt.newValue.z,
m03 = 0,
m10 = row1.x,
m11 = row1.y,
m12 = row1.z,
m13 = 0,
m20 = row2.x,
m21 = row2.y,
m22 = row2.z,
m23 = 0,
m30 = 0,
m31 = 0,
m32 = 0,
m33 = 0,
};
DirtyNodes();
});
AddRow("Default", row0Field);
var row1Field = new Vector3Field {
value = matrix3Property.value.GetRow(1)
};
row1Field.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change Property Value");
Vector3 row0 = matrix3Property.value.GetRow(0);
Vector3 row2 = matrix3Property.value.GetRow(2);
matrix3Property.value = new Matrix4x4()
{
m00 = row0.x,
m01 = row0.y,
m02 = row0.z,
m03 = 0,
m10 = evt.newValue.x,
m11 = evt.newValue.y,
m12 = evt.newValue.z,
m13 = 0,
m20 = row2.x,
m21 = row2.y,
m22 = row2.z,
m23 = 0,
m30 = 0,
m31 = 0,
m32 = 0,
m33 = 0,
};
DirtyNodes();
});
AddRow("", row1Field);
var row2Field = new Vector3Field {
value = matrix3Property.value.GetRow(2)
};
row2Field.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change Property Value");
Vector3 row0 = matrix3Property.value.GetRow(0);
Vector3 row1 = matrix3Property.value.GetRow(1);
matrix3Property.value = new Matrix4x4()
{
m00 = row0.x,
m01 = row0.y,
m02 = row0.z,
m03 = 0,
m10 = row1.x,
m11 = row1.y,
m12 = row1.z,
m13 = 0,
m20 = evt.newValue.x,
m21 = evt.newValue.y,
m22 = evt.newValue.z,
m23 = 0,
m30 = 0,
m31 = 0,
m32 = 0,
m33 = 0,
};
DirtyNodes();
});
AddRow("", row2Field);
}
else if (property is Matrix4ShaderProperty)
{
var matrix4Property = (Matrix4ShaderProperty)property;
var row0Field = new Vector4Field {
value = matrix4Property.value.GetRow(0)
};
row0Field.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change Property Value");
Vector4 row1 = matrix4Property.value.GetRow(1);
Vector4 row2 = matrix4Property.value.GetRow(2);
Vector4 row3 = matrix4Property.value.GetRow(3);
matrix4Property.value = new Matrix4x4()
{
m00 = evt.newValue.x,
m01 = evt.newValue.y,
m02 = evt.newValue.z,
m03 = evt.newValue.w,
m10 = row1.x,
m11 = row1.y,
m12 = row1.z,
m13 = row1.w,
m20 = row2.x,
m21 = row2.y,
m22 = row2.z,
m23 = row2.w,
m30 = row3.x,
m31 = row3.y,
m32 = row3.z,
m33 = row3.w,
};
DirtyNodes();
});
AddRow("Default", row0Field);
var row1Field = new Vector4Field {
value = matrix4Property.value.GetRow(1)
};
row1Field.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change Property Value");
Vector4 row0 = matrix4Property.value.GetRow(0);
Vector4 row2 = matrix4Property.value.GetRow(2);
Vector4 row3 = matrix4Property.value.GetRow(3);
matrix4Property.value = new Matrix4x4()
{
m00 = row0.x,
m01 = row0.y,
m02 = row0.z,
m03 = row0.w,
m10 = evt.newValue.x,
m11 = evt.newValue.y,
m12 = evt.newValue.z,
m13 = evt.newValue.w,
m20 = row2.x,
m21 = row2.y,
m22 = row2.z,
m23 = row2.w,
m30 = row3.x,
m31 = row3.y,
m32 = row3.z,
m33 = row3.w,
};
DirtyNodes();
});
AddRow("", row1Field);
var row2Field = new Vector4Field {
value = matrix4Property.value.GetRow(2)
};
row2Field.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change Property Value");
Vector4 row0 = matrix4Property.value.GetRow(0);
Vector4 row1 = matrix4Property.value.GetRow(1);
Vector4 row3 = matrix4Property.value.GetRow(3);
matrix4Property.value = new Matrix4x4()
{
m00 = row0.x,
m01 = row0.y,
m02 = row0.z,
m03 = row0.w,
m10 = row1.x,
m11 = row1.y,
m12 = row1.z,
m13 = row1.w,
m20 = evt.newValue.x,
m21 = evt.newValue.y,
m22 = evt.newValue.z,
m23 = evt.newValue.w,
m30 = row3.x,
m31 = row3.y,
m32 = row3.z,
m33 = row3.w,
};
DirtyNodes();
});
AddRow("", row2Field);
var row3Field = new Vector4Field {
value = matrix4Property.value.GetRow(3)
};
row3Field.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change Property Value");
Vector4 row0 = matrix4Property.value.GetRow(0);
Vector4 row1 = matrix4Property.value.GetRow(1);
Vector4 row2 = matrix4Property.value.GetRow(2);
matrix4Property.value = new Matrix4x4()
{
m00 = row0.x,
m01 = row0.y,
m02 = row0.z,
m03 = row0.w,
m10 = row1.x,
m11 = row1.y,
m12 = row1.z,
m13 = row1.w,
m20 = row2.x,
m21 = row2.y,
m22 = row2.z,
m23 = row2.w,
m30 = evt.newValue.x,
m31 = evt.newValue.y,
m32 = evt.newValue.z,
m33 = evt.newValue.w,
};
DirtyNodes();
});
AddRow("", row3Field);
}
else if (property is SamplerStateShaderProperty)
{
var samplerStateProperty = (SamplerStateShaderProperty)property;
var filterField = new EnumField(samplerStateProperty.value.filter);
filterField.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change Property Value");
TextureSamplerState state = samplerStateProperty.value;
state.filter = (TextureSamplerState.FilterMode)evt.newValue;
samplerStateProperty.value = state;
DirtyNodes(ModificationScope.Graph);
});
AddRow("Filter", filterField);
var wrapField = new EnumField(samplerStateProperty.value.wrap);
wrapField.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change Property Value");
TextureSamplerState state = samplerStateProperty.value;
state.wrap = (TextureSamplerState.WrapMode)evt.newValue;
samplerStateProperty.value = state;
DirtyNodes(ModificationScope.Graph);
});
AddRow("Wrap", wrapField);
}
else if (property is GradientShaderProperty)
{
var gradientProperty = (GradientShaderProperty)property;
var field = new GradientField {
value = gradientProperty.value
};
field.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change Property Value");
gradientProperty.value = evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
var precisionField = new EnumField((Enum)property.precision);
precisionField.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change Precision");
if (property.precision == (Precision)evt.newValue)
{
return;
}
property.precision = (Precision)evt.newValue;
m_Graph.ValidateGraph();
precisionField.MarkDirtyRepaint();
DirtyNodes();
});
AddRow("Precision", precisionField);
AddToClassList("sgblackboardFieldPropertyView");
UpdateReferenceNameResetMenu();
}
static TexturedElement()
{
bilinearFilter = TextureSamplerState.BilinearFiltering;
bilinearFilter.AddressUV = TextureAddressMode.Clamp;
pointFilter = TextureSamplerState.PointFiltering;
pointFilter.AddressUV = TextureAddressMode.Clamp;
}
private TextureSamplerState GetState(GraphicsDevice device, int index, bool PS, List <Texture> textures, out int textureIndex)
{
TextureSamplerState tss = new TextureSamplerState();
textureIndex = -1;
try
{
SamplerState ss = null;
tss = TextureSamplerState.BilinearFiltering;
if (!PS)
{
tss = TextureSamplerState.PointFiltering;
}
Texture texture = null;
if (PS)
{
ss = device.SamplerStates[index];
texture = device.Textures[index];
}
else
{
ss = device.VertexSamplerStates[index];
texture = device.VertexTextures[index];
}
tss.AddressU = ss.AddressU;
tss.AddressV = ss.AddressV;
tss.AddressW = ss.AddressW;
//special case, force texture cubes to always be clamped. (xbox helper)
if (texture is TextureCube)
{
tss.AddressU = TextureAddressMode.Clamp;
tss.AddressV = TextureAddressMode.Clamp;
tss.AddressW = TextureAddressMode.Clamp;
}
tss.MagFilter = ss.MagFilter;
tss.MinFilter = ss.MinFilter;
tss.MipFilter = ss.MipFilter;
tss.MaxAnisotropy = ss.MaxAnisotropy;
tss.MaxMipmapLevel = ss.MaxMipLevel;
for (int i = 0; i < textures.Count; i++)
{
if (texture == textures[i] &&
texture != null && textures[i] != null)
{
textureIndex = i;
}
}
}
catch
{
//hmph...
}
return(tss);
}
private void ExtractEffectDefaults(Effect effect, List <Register> textures, SourceShader source, Platform platform)
{
//nasty-ness ensues!
GraphicsDevice device = Graphics.GraphicsDevice;
int maxVsConst = device.GraphicsDeviceCapabilities.MaxVertexShaderConstants;
int maxPsConst = 32;
int maxPsTextures = 16;
int maxVsTextures = 4;
bool setPsBooleanConstants = device.GraphicsDeviceCapabilities.PixelShaderVersion.Major == 3;
bool[] shaderBooleanConstants = new bool[16];
List <Texture> allTextures = new List <Texture>();
foreach (EffectTechnique technique in effect.Techniques)
{
//Thanks to Darren Grant (again :)
//annotate a Technique with 'BaseTypes' and the generates class will inherit from those types
string[] baseTypes = new string[0];
foreach (EffectAnnotation annotation in technique.Annotations)
{
if (annotation.Name.Equals("BaseTypes", StringComparison.InvariantCulture) ||
annotation.Name.Equals("BaseType", StringComparison.InvariantCulture))
{
baseTypes = annotation.GetValueString().Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
for (int i = 0; i < baseTypes.Length; i++)
{
baseTypes[i] = baseTypes[i].Trim();
}
}
}
Vector4[] psConstants = new Vector4[maxPsConst]; // pixel
Vector4[] vsConstants = new Vector4[maxVsConst]; // not-pixel
TextureSamplerState[] psSamplers = new TextureSamplerState[maxPsTextures];
TextureSamplerState[] vsSamplers = new TextureSamplerState[maxVsTextures];
int[] psTexturesIndex = new int[maxPsTextures];
int[] vsTexturesIndex = new int[maxVsTextures];
bool[] psBooleanConstants = new bool[16];
bool[] vsBooleanConstants = new bool[16];
allTextures.Clear();
Dictionary <string, Vector4[]> techniqueSingleValues = new Dictionary <string, Vector4[]>();
try
{
device.SetPixelShaderConstant(0, psConstants);
device.SetVertexShaderConstant(0, vsConstants);
device.SetVertexShaderConstant(0, shaderBooleanConstants);
if (setPsBooleanConstants)
{
device.SetPixelShaderConstant(0, shaderBooleanConstants);
}
for (int i = 0; i < maxPsTextures; i++)
{
ResetSampler(device, i, true);
}
for (int i = 0; i < maxVsTextures; i++)
{
ResetSampler(device, i, false);
}
//assign the technique textures
foreach (Register texReg in textures)
{
Type type = Common.GetTextureType(texReg.Type);
Texture tex = Graphics.BeginGetTempTexture(type);
effect.Parameters[texReg.Name].SetValue(tex);
allTextures.Add(tex);
}
//bind the effect technique
effect.CurrentTechnique = technique;
effect.Begin();
if (technique.Passes.Count > 0)
{
EffectPass pass = technique.Passes[0];
pass.Begin();
pass.End();
}
effect.End();
foreach (var param in effect.Parameters)
{
try
{
if (param.ParameterType == EffectParameterType.Single ||
param.ParameterType == EffectParameterType.Int32)
{
Vector4[] values = param.GetValueVector4Array(param.RowCount);
techniqueSingleValues.Add(param.Name, values);
}
}
catch
{
}
}
//all done. Now read back what has changed. :D
psConstants = device.GetPixelShaderVector4ArrayConstant(0, maxPsConst);
vsConstants = device.GetVertexShaderVector4ArrayConstant(0, maxVsConst);
for (int i = 0; i < maxPsTextures; i++)
{
psSamplers[i] = GetState(device, i, true, allTextures, out psTexturesIndex[i]);
}
for (int i = 0; i < maxVsTextures; i++)
{
vsSamplers[i] = GetState(device, i, false, allTextures, out vsTexturesIndex[i]);
}
for (int i = 0; i < allTextures.Count; i++)
{
Graphics.EndGetTempTexture(allTextures[i]);
}
allTextures.Clear();
vsBooleanConstants = device.GetVertexShaderBooleanConstant(0, 16);
psBooleanConstants = device.GetPixelShaderBooleanConstant(0, 16);
}
catch
{
//something went wrong... Eg, binding a SM 3.0 shader on SM 2.0 hardware device
//Need to be running the Reference device
throw new CompileException("Unable to compile shader: The DirectX Reference Device may be missing (Is the DirectX SDK Installed?)");
}
TechniqueExtraData defaults = new TechniqueExtraData();
defaults.PixelSamplerStates = psSamplers;
defaults.PixelShaderConstants = psConstants;
defaults.VertexSamplerStates = vsSamplers;
defaults.VertexShaderConstants = vsConstants;
defaults.PixelSamplerTextureIndex = psTexturesIndex;
defaults.VertexSamplerTextureIndex = vsTexturesIndex;
defaults.TechniqueTextures = textures.ToArray();
defaults.ClassBaseTypes = baseTypes;
defaults.PixelShaderBooleanConstants = psBooleanConstants;
defaults.VertexShaderBooleanConstants = vsBooleanConstants;
defaults.DefaultSingleValues = techniqueSingleValues;
if (this.techniqueDefaults.ContainsKey(technique.Name) == false)
{
this.techniqueDefaults.Add(technique.Name, defaults);
}
}
}
bool IShader.SetSamplerState(Xen.Graphics.ShaderSystem.ShaderSystemBase state, int name_uid, TextureSamplerState sampler)
{
throw new NotImplementedException();
}
private TextureSamplerState GetState(GraphicsDevice device, Native.DeviceInterop io, int index, bool PS, List<Texture> textures, out int textureIndex)
{
TextureSamplerState tss = new TextureSamplerState();
textureIndex = -1;
try
{
Texture texture = null;
if (PS)
{
texture = device.Textures[index];
var state = io.GetSamplerState(index, false);
tss = TextureSamplerState.BilinearFiltering;
tss.AddressU = Translate(state.U);
tss.AddressV = Translate(state.V);
tss.AddressW = Translate(state.W);
tss.Filter = Translate(state.Min, state.Mag, state.Mip);
tss.MaxAnisotropy = (int)state.MaxAni;
}
else
{
texture = device.VertexTextures[index];
var state = io.GetSamplerState(index, true);
tss = TextureSamplerState.PointFiltering;
tss.AddressU = Translate(state.U);
tss.AddressV = Translate(state.V);
tss.AddressW = Translate(state.W);
}
//special case, force texture cubes to always be clamped. (xbox helper)
if (texture is TextureCube)
{
tss.AddressU = TextureAddressMode.Clamp;
tss.AddressV = TextureAddressMode.Clamp;
tss.AddressW = TextureAddressMode.Clamp;
}
for (int i = 0; i < textures.Count; i++)
{
if (texture == textures[i] &&
texture != null && textures[i] != null)
{
textureIndex = i;
}
}
}
catch
{
//hmph...
}
return tss;
}
private void ExtractEffectDefaults(Effect effect, List<Register> textures, SourceShader source, Platform platform)
{
//nasty-ness ensues!
GraphicsDevice device = Graphics.GraphicsDevice;
int maxVsConst = 256;
int maxPsConst = 32;
int maxPsTextures = 16;
int maxVsTextures = 4;
bool[] shaderBooleanConstants = new bool[16];
List<Texture> allTextures = new List<Texture>();
foreach (EffectTechnique technique in effect.Techniques)
{
//Thanks to Darren Grant (again :)
//annotate a Technique with 'BaseTypes' and the generates class will inherit from those types
string[] baseTypes = new string[0];
foreach (EffectAnnotation annotation in technique.Annotations)
{
if (annotation.Name.Equals("BaseTypes", StringComparison.InvariantCulture) ||
annotation.Name.Equals("BaseType", StringComparison.InvariantCulture))
{
baseTypes = annotation.GetValueString().Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
for (int i = 0; i < baseTypes.Length; i++)
baseTypes[i] = baseTypes[i].Trim();
}
}
float[] psConstants = new float[maxPsConst * 4]; // pixel
float[] vsConstants = new float[maxVsConst * 4]; // not-pixel
TextureSamplerState[] psSamplers = new TextureSamplerState[maxPsTextures];
TextureSamplerState[] vsSamplers = new TextureSamplerState[maxVsTextures];
int[] psTexturesIndex = new int[maxPsTextures];
int[] vsTexturesIndex = new int[maxVsTextures];
int[] psBooleanConstants = new int[16];
int[] vsBooleanConstants = new int[16];
allTextures.Clear();
Dictionary<string, Vector4[]> techniqueSingleValues = new Dictionary<string, Vector4[]>();
//get the device
object devicePtr = device.GetType().GetField("pComPtr", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance).GetValue(device);
var deviceInterop = new Xen.Graphics.ShaderSystem.Native.DeviceInterop((System.Reflection.Pointer)devicePtr);
try
{
//I'm sure XNA won't mind...
deviceInterop.ZeroShaderConstants();
for (int i = 0; i < maxPsTextures; i++)
{
deviceInterop.SetTextureFilters(i, false);
ResetSampler(device, i, true);
}
for (int i = 0; i < maxVsTextures; i++)
{
deviceInterop.SetTextureFilters(i, true);
ResetSampler(device, i, false);
}
//assign the technique textures
foreach (Register texReg in textures)
{
Type type = Common.GetTextureType(texReg.Type);
Texture tex = Graphics.BeginGetTempTexture(type);
effect.Parameters[texReg.Name].SetValue(tex);
allTextures.Add(tex);
}
//bind the effect technique
effect.CurrentTechnique = technique;
if (technique.Passes.Count > 0)
{
EffectPass pass = technique.Passes[0];
pass.Apply();
}
foreach (var param in effect.Parameters)
{
try
{
if (param.ParameterType == EffectParameterType.Single ||
param.ParameterType == EffectParameterType.Int32)
{
Vector4[] values = param.GetValueVector4Array(param.RowCount);
techniqueSingleValues.Add(param.Name, values);
}
}
catch
{
}
}
//all done. Now read back what has changed. :D
deviceInterop.GetShaderConstantsPS(psConstants);
deviceInterop.GetShaderConstantsVS(vsConstants);
//psConstants = device.GetPixelShaderVector4ArrayConstant(0, maxPsConst);
//vsConstants = device.GetVertexShaderVector4ArrayConstant(0, maxVsConst);
for (int i = 0; i < maxPsTextures; i++)
psSamplers[i] = GetState(device, deviceInterop, i, true, allTextures, out psTexturesIndex[i]);
for (int i = 0; i < maxVsTextures; i++)
vsSamplers[i] = GetState(device, deviceInterop, i, false, allTextures, out vsTexturesIndex[i]);
for (int i = 0; i < allTextures.Count; i++)
Graphics.EndGetTempTexture(allTextures[i]);
allTextures.Clear();
deviceInterop.GetShaderConstantsPS(psBooleanConstants);
deviceInterop.GetShaderConstantsVS(vsBooleanConstants);
//vsBooleanConstants = device.GetVertexShaderBooleanConstant(0, 16);
//psBooleanConstants = device.GetPixelShaderBooleanConstant(0, 16);
}
catch
{
//something went wrong... Eg, binding a SM 3.0 shader on SM 2.0 hardware device
throw new CompileException("An unexpected error occured while compiling shader: The DirectX device may not be XNA 'HiDef' capable");
}
TechniqueExtraData defaults = new TechniqueExtraData();
defaults.PixelSamplerStates = psSamplers;
defaults.PixelShaderConstants = Convert(psConstants);
defaults.VertexSamplerStates = vsSamplers;
defaults.VertexShaderConstants = Convert(vsConstants);
defaults.PixelSamplerTextureIndex = psTexturesIndex;
defaults.VertexSamplerTextureIndex = vsTexturesIndex;
defaults.TechniqueTextures = textures.ToArray();
defaults.ClassBaseTypes = baseTypes;
defaults.PixelShaderBooleanConstants = Convert(psBooleanConstants);
defaults.VertexShaderBooleanConstants = Convert(vsBooleanConstants);
defaults.DefaultSingleValues = techniqueSingleValues;
if (this.techniqueDefaults.ContainsKey(technique.Name) == false)
this.techniqueDefaults.Add(technique.Name, defaults);
}
}
bool IShader.SetSamplerState(Xen.Graphics.ShaderSystem.IShaderSystem state, int name_uid, TextureSamplerState sampler)
{
throw new NotImplementedException();
}
public void Bind(Xen.Graphics.ShaderSystem.IShaderSystem state)
{
bool tc, ic;
int deviceID = state.Begin(this, 4, 0, out tc, out ic);
if (device != deviceID)
{
if (vs != null)
{
vs.Dispose();
}
if (ps != null)
{
ps.Dispose();
}
device = deviceID;
//internally, the code is smart enough to not duplicate creating the pixel shader
state.CreateShaders(out vs, out ps, vsb, psb, 0, 0, 0, 0);
}
float randX = (float)(random.NextDouble());
float randY = (float)(random.NextDouble());
this.psConstants[4].Z = randX;
this.psConstants[4].W = randY;
//random texture is limited in size, so randomly offset by a tiny amount
randX = (float)((random.NextDouble() * 2 - 1) / 256.0);
randY = (float)((random.NextDouble() * 2 - 1) / 256.0);
this.psConstants[5].X = randX;
this.psConstants[5].Y = randY;
state.SetShaders(this.vs, this.ps);
TextureSamplerState point = TextureSamplerState.PointFiltering;
state.SetPixelShaderSampler(0, randTexture, point);
if (positionSize != null)
{
state.SetPixelShaderSampler(1, positionSize, point);
}
if (velocityRotation != null)
{
state.SetPixelShaderSampler(2, velocityRotation, point);
}
if (this.colourSamplerIndex != -1)
{
state.SetPixelShaderSampler(this.colourSamplerIndex, colourValues, point);
}
if (this.userSamplerIndex != -1)
{
state.SetPixelShaderSampler(this.userSamplerIndex, userValues, point);
}
if (this.lifeSamplerIndex != -1)
{
state.SetPixelShaderSampler(this.lifeSamplerIndex, lifeTexture, point);
}
state.SetWorldViewProjectionMatrix(this.vreg.Matrix4Transpose(0), ref this.world);
const float randTextureSize = (float)RandomValueTexture.Resolution;
const float invRandTextureSize = 1.0f / randTextureSize;
if (enabledMoveVS || enabledAddVS)
{
for (int i = 0; i < 4; i++) //copy the WVP matrix
{
this.vsMoveConstants[i] = this.vreg.array[i];
}
vsMoveConstants[6] = new Vector4(randTextureSize, invRandTextureSize, 0, 0);
state.SetShaderConstants(this.vsMoveConstants, psConstants);
}
else
{
state.SetWindowSizeVector2(this.vreg.Vector2(4), ref this.viewsize);
this.vreg.array[6] = new Vector4(randTextureSize, invRandTextureSize, 0, 0);
state.SetShaderConstants(this.vreg.array, psConstants);
}
}
