void populateCanvasFromLoad(MaskDAGXML xmldat)
{
cleanCanvas();
newCanvas();
for (int i = 0; i < xmldat.mNodes.Count; i++)
{
Type t = xmldat.mNodes[i].GetType();
MaskDAGGraphNode val = null;
try
{
System.Reflection.ConstructorInfo ci = t.GetConstructor(new Type[] { typeof(GraphCanvas) });
val = ((MaskDAGGraphNode)ci.Invoke(new object[] { this }));
}
catch (Exception e)
{
e.ToString();
return;
}
val.load(xmldat.mNodes[i]);
addCanvasNode(val);
}
//load our connections now
for (int i = 0; i < xmldat.mConnections.Count; i++)
{
CanvasNode start = findConnectionNode(xmldat.mConnections[i].mOwnerDeviceID, xmldat.mConnections[i].mConnectionName);
CanvasNode end = findConnectionNode(xmldat.mConnections[i].mNeighborDeviceID, xmldat.mConnections[i].mNeighborConnectionName);
if (start == null || end == null) continue;
addConnection(start, end);
}
}
public ConnectionPoint(ParamType paramType, string Descriptor, MaskDAGGraphNode ownerMaskDAGGraphNode, GraphCanvas owningCanvas)
{
mDepthLayer = 1;
mOwnerMaskDAGGraphNode = ownerMaskDAGGraphNode;
mParamType = paramType;
ID = Descriptor;
}
public override bool load(MaskDAGGraphNode fromNode)
{
Device_DistanceTransform dc = fromNode as Device_DistanceTransform;
mGUID = dc.mGUID;
draggedByMouse(Location, dc.Location);
return(true);
}
public OutputConnectionPoint(ParamType valueType, string Descriptor, MaskDAGGraphNode ownerMaskDAGGraphNode, GraphCanvas owningCanvas)
: base(valueType, Descriptor, ownerMaskDAGGraphNode, owningCanvas)
{
Location = new Point(2, 2);
mSize = new Size(10, 10);
mBorderSize = 1;
mColorBottom = Color.LightGray;
mColorTop = Color.Gray;
}
public override bool load(MaskDAGGraphNode fromNode)
{
Device_Chooser dc = fromNode as Device_Chooser;
mGUID = dc.mGUID;
draggedByMouse(Location, dc.Location);
InputChoice = dc.InputChoice;
return(true);
}
public ConstraintConnectionPoint(ParamType valueType, string Descriptor, MaskDAGGraphNode ownerMaskDAGGraphNode, GraphCanvas owningCanvas)
: base(valueType, Descriptor, ownerMaskDAGGraphNode, owningCanvas)
{
Location = new Point(2, 2);
mSize = new Size(10, 10);
mBorderSize = 1;
mColorBottom = Color.Purple;
mColorTop = Color.White;
}
public override bool load(MaskDAGGraphNode fromNode)
{
Device_Gradient dc = fromNode as Device_Gradient;
mGUID = dc.mGUID;
draggedByMouse(Location, dc.Location);
Direction = dc.Direction;
return(true);
}
public override bool load(MaskDAGGraphNode fromNode)
{
Device_MaskFromList dc = fromNode as Device_MaskFromList;
mGUID = dc.mGUID;
draggedByMouse(Location, dc.Location);
SelectedMaskName = dc.SelectedMaskName;
return(true);
}
public override bool load(MaskDAGGraphNode fromNode)
{
Device_RandomInt dc = fromNode as Device_RandomInt;
mGUID = dc.mGUID;
draggedByMouse(Location, dc.Location);
OutputScalar = dc.OutputScalar;
return(true);
}
public override bool load(MaskDAGGraphNode fromNode)
{
Device_Contract dc = fromNode as Device_Contract;
mGUID = dc.mGUID;
draggedByMouse(Location, dc.Location);
NumPixels = dc.NumPixels;
return(true);
}
public override bool load(MaskDAGGraphNode fromNode)
{
Device_GaussianBlur dc = fromNode as Device_GaussianBlur;
mGUID = dc.mGUID;
draggedByMouse(Location, dc.Location);
Radius = dc.Radius;
return(true);
}
public override bool load(MaskDAGGraphNode fromNode)
{
Device_Smooth dc = fromNode as Device_Smooth;
mGUID = dc.mGUID;
draggedByMouse(Location, dc.Location);
SmoothPower = dc.SmoothPower;
return(true);
}
public override bool load(MaskDAGGraphNode fromNode)
{
Device_Combiner dc = fromNode as Device_Combiner;
mGUID = dc.mGUID;
draggedByMouse(Location, dc.Location);
Method = dc.Method;
return(true);
}
public override bool load(MaskDAGGraphNode fromNode)
{
Device_BiasGain dc = fromNode as Device_BiasGain;
mGUID = dc.mGUID;
draggedByMouse(Location, dc.Location);
Bias = dc.Bias;
Gain = dc.Gain;
return(true);
}
public override bool load(MaskDAGGraphNode fromNode)
{
Device_Constant dc = fromNode as Device_Constant;
mGUID = dc.mGUID;
draggedByMouse(Location, dc.Location);
Value = dc.Value;
return(true);
}
public override bool load(MaskDAGGraphNode fromNode)
{
Device_Flipper dc = fromNode as Device_Flipper;
mGUID = dc.mGUID;
draggedByMouse(Location, dc.Location);
FlipVertical = dc.FlipVertical;
FlipHorizontal = dc.FlipHorizontal;
return(true);
}
public override bool load(MaskDAGGraphNode fromNode)
{
Device_Clamp dc = fromNode as Device_Clamp;
mGUID = dc.mGUID;
draggedByMouse(Location, dc.Location);
ClampType = dc.ClampType;
MinHeight = dc.MinHeight;
MaxHeight = dc.MaxHeight;
return(true);
}
public override bool load(MaskDAGGraphNode fromNode)
{
Device_SelectGradient dc = fromNode as Device_SelectGradient;
mGUID = dc.mGUID;
draggedByMouse(Location, dc.Location);
FalloffAmt = dc.FalloffAmt;
MaxSlope = dc.MaxSlope;
MinSlope = dc.MinSlope;
return(true);
}
public override bool load(MaskDAGGraphNode fromNode)
{
Device_Terrace dc = fromNode as Device_Terrace;
mGUID = dc.mGUID;
draggedByMouse(Location, dc.Location);
TerraceShape = dc.TerraceShape;
NumTerraces = dc.NumTerraces;
Method = dc.Method;
return(true);
}
public override bool load(MaskDAGGraphNode fromNode)
{
Device_RadialGradient dc = fromNode as Device_RadialGradient;
mGUID = dc.mGUID;
draggedByMouse(Location, dc.Location);
Radius = dc.Radius;
Intensity = dc.Intensity;
HotSpot = dc.HotSpot;
return(true);
}
public override bool load(MaskDAGGraphNode fromNode)
{
Device_Distort dc = fromNode as Device_Distort;
mGUID = dc.mGUID;
draggedByMouse(Location, dc.Location);
Frequency = dc.Frequency;
Power = dc.Power;
Roughness = dc.Roughness;
RandomSeed = dc.RandomSeed;
return(true);
}
public override bool load(MaskDAGGraphNode fromNode)
{
Device_HydraulicErosion dc = fromNode as Device_HydraulicErosion;
mGUID = dc.mGUID;
draggedByMouse(Location, dc.Location);
MultiscaleEnable = dc.MultiscaleEnable;
SedimentCarryAmt = dc.SedimentCarryAmt;
SoilHardness = dc.SoilHardness;
Amount = dc.Amount;
return(true);
}
public override void onDoubleClick(Point mousePoint, MouseEventArgs mouseEvent)
{
CanvasNode selectedNode = intersectNodeMouseLoc(mouseEvent.Location);
if (selectedNode != null)
{
MaskDAGGraphNode gn = selectedNode as MaskDAGGraphNode;
if (gn == null)
return;
if (mouseEvent.Button == MouseButtons.Left)
{
gn.displayPropertiesDlg();
}
}
}
public override bool load(MaskDAGGraphNode fromNode)
{
Device_VoronoiNoise dc = fromNode as Device_VoronoiNoise;
mGUID = dc.mGUID;
draggedByMouse(Location, dc.Location);
Frequency = dc.Frequency;
SeedParam = dc.SeedParam;
Displacement = dc.Displacement;
EnableDistance = dc.EnableDistance;
return(true);
}
public override bool load(MaskDAGGraphNode fromNode)
{
Device_RidgedNoise dc = fromNode as Device_RidgedNoise;
mGUID = dc.mGUID;
draggedByMouse(Location, dc.Location);
Frequency = dc.Frequency;
Lacunarity = dc.Lacunarity;
OctaveParam = dc.OctaveParam;
SeedParam = dc.SeedParam;
return(true);
}
public override bool load(MaskDAGGraphNode fromNode)
{
Device_Curves dc = fromNode as Device_Curves;
mGUID = dc.mGUID;
draggedByMouse(Location, dc.Location);
ControlPointsValues.Clear();
ControlPointsKeys.Clear();
ControlPointsValues.AddRange(dc.ControlPointsValues);
ControlPointsKeys.AddRange(dc.ControlPointsKeys);
return(true);
}
public void generatePreview(CanvasNode cn)
{
OutputGenerationParams ogp = new OutputGenerationParams();
ogp.Width = 128;
ogp.Height = 128;
MaskDAGGraphNode gn = (MaskDAGGraphNode)cn;
MaskParam mp = new MaskParam();
InputConnectionPoint icp = new InputConnectionPoint(mp,true,"Preview",gn,this);
gn.computeOutput(icp,ogp);
if (onUpdateCallback != null)
{
DAGMask m = mp.Value;
onUpdateCallback(ref m);
}
}
//general functions
MaskDAGXML prepCanvasForSave()
{
MaskDAGXML xmldat = new MaskDAGXML();
for (int i = 0; i < mNodes.Count; i++)
if (mNodes[i].mDepthLayer == 0)
xmldat.mNodes.Add(mNodes[i] as MaskDAGGraphNode);
//generate connection records
for (int i = 0; i < mNodes.Count; i++)
{
MaskDAGGraphNode dnode = (mNodes[i] as MaskDAGGraphNode);
if (dnode != null)
xmldat.mConnections.AddRange(dnode.generateConnectionLists());
}
return xmldat;
}
public virtual bool load(MaskDAGGraphNode fromNode)
{
mGUID = fromNode.mGUID;
draggedByMouse(Location, fromNode.Location);
return(false);
}
public bool gatherInputAndParameters(OutputGenerationParams parms)
{
//walk all of our local params
//find the associated connection point
//copy the data from the connection point to our local point
Type type = GetType();// Get object type
System.Reflection.PropertyInfo[] pi = type.GetProperties();
for (int i = 0; i < pi.Length; i++)
{
System.Reflection.PropertyInfo prop = pi[i];
object[] custAttrib = prop.GetCustomAttributes(false);
if (custAttrib == null)
{
continue;
}
Type ptt = prop.PropertyType;
for (int k = 0; k < custAttrib.Length; k++)
{
if (custAttrib[k] is ConnectionType)
{
ConnectionType ct = custAttrib[k] as ConnectionType;
if (ct.ConnType == "Param")
{
for (int j = 0; j < mParamConnections.Count; j++)
{
if (mParamConnections[j].Neighbors.Count == 0)
{
continue;
}
if (mParamConnections[j].ID == ct.Description)
{
ConnectionPoint CP = mParamConnections[j].Neighbors[0] as ConnectionPoint;
MaskDAGGraphNode GN = CP.OwnerNode as MaskDAGGraphNode;
if (!GN.computeOutput(mParamConnections[j], parms))
{
return(false);
}
if (ptt == typeof(float))
{
prop.SetValue(this, ((FloatParam)mParamConnections[j].ParamType).Value, null);
}
else if (ptt == typeof(int))
{
prop.SetValue(this, ((IntParam)mParamConnections[j].ParamType).Value, null);
}
else if (ptt == typeof(bool))
{
prop.SetValue(this, ((BoolParam)mParamConnections[j].ParamType).Value, null);
}
else if (ptt == typeof(DAGMask))
{
prop.SetValue(this, ((MaskParam)mParamConnections[j].ParamType).Value, null);
}
}
}
}
else if (ct.ConnType == "Input")
{
for (int j = 0; j < mInputConnections.Count; j++)
{
if (mInputConnections[j].ID == ct.Description)
{
ConnectionPoint CP = mInputConnections[j].Neighbors[0] as ConnectionPoint;
MaskDAGGraphNode GN = CP.OwnerNode as MaskDAGGraphNode;
if (!GN.computeOutput(mInputConnections[j], parms))
{
return(false);
}
if (ptt == typeof(float))
{
prop.SetValue(this, ((FloatParam)mInputConnections[j].ParamType).Value, null);
}
else if (ptt == typeof(int))
{
prop.SetValue(this, ((IntParam)mInputConnections[j].ParamType).Value, null);
}
else if (ptt == typeof(bool))
{
prop.SetValue(this, ((BoolParam)mInputConnections[j].ParamType).Value, null);
}
else if (ptt == typeof(DAGMask))
{
prop.SetValue(this, ((MaskParam)mInputConnections[j].ParamType).Value, null);
}
}
}
}
else if (ct.ConnType == "Constraint")
{
for (int j = 0; j < mConstraintConnections.Count; j++)
{
if (mConstraintConnections[j].Neighbors.Count == 0)
{
if (ptt == typeof(float))
{
prop.SetValue(this, 0, null);
}
else if (ptt == typeof(int))
{
prop.SetValue(this, 0, null);
}
else if (ptt == typeof(bool))
{
prop.SetValue(this, false, null);
}
else if (ptt == typeof(DAGMask))
{
prop.SetValue(this, null, null);
}
}
else if (mConstraintConnections[j].ID == ct.Description)
{
ConnectionPoint CP = mConstraintConnections[j].Neighbors[0] as ConnectionPoint;
MaskDAGGraphNode GN = CP.OwnerNode as MaskDAGGraphNode;
if (!GN.computeOutput(mConstraintConnections[j], parms))
{
return(false);
}
if (ptt == typeof(float))
{
prop.SetValue(this, ((FloatParam)mConstraintConnections[j].ParamType).Value, null);
}
else if (ptt == typeof(int))
{
prop.SetValue(this, ((IntParam)mConstraintConnections[j].ParamType).Value, null);
}
else if (ptt == typeof(bool))
{
prop.SetValue(this, ((BoolParam)mConstraintConnections[j].ParamType).Value, null);
}
else if (ptt == typeof(DAGMask))
{
prop.SetValue(this, ((MaskParam)mConstraintConnections[j].ParamType).Value, null);
}
}
}
}
break;
}
}
}
return(true);
}
