// Add layer
private void addNewLayer(MaterialLayer newLayer)
{
Debug.Assert(selectedLayer != null);
LayerNode selectedNode = layersTreeView.SelectedNode as LayerNode;
if (selectedLayer.type == "root" || selectedLayer.type == "group")
{
// Insert into group
_controller.addTerrainLayer(selectedLayer as MaterialGroupLayer, newLayer, selectedNode.Nodes.Count);
}
else
{
// Create new layer
LayerNode parent = selectedNode.Parent as LayerNode;
// Add new layer to parent
_controller.addTerrainLayer(parent.layer as MaterialGroupLayer, newLayer, selectedNode.Index + 1);
}
// Refresh tree
populateTreeView(selectedMaterial.rootLayer);
// Select layer
selectLayer(newLayer);
// Refocus on tree
layersTreeView.Focus();
// Set changes made
_controller.setChangesMade(true);
}
public void LoadFrom(string filename)
{
this.filename = filename;
PrismMap map = PrismFile.LoadMapFrom(filename);
textureSetList.Clear();
rootLayer.Nodes.Clear();
Dictionary <PrismTexture.Tile, TextureSet.Tile> tileList = new Dictionary <PrismTexture.Tile, TextureSet.Tile>();
foreach (PrismTexture t in map.Textures)
{
TextureSet set = new TextureSet(t.Name, t.Bitmap);
foreach (PrismTexture.Tile tile in t.Tiles)
{
TextureSet.Tile newTile = new TextureSet.Tile(tile.Name, set, tile.UV);
tileList.Add(tile, newTile);
set.AddTile(newTile);
}
CreateTextureSet(set);
}
rootLayer = new LayerNode(map.RootLayerNode, tileList, this);
}
// Select layer
public void selectLayer(MaterialLayer layer)
{
Debug.Assert(layersTreeView.Nodes[0] is LayerNode);
LayerNode targetNode = recursiveGetNode(layersTreeView.Nodes[0] as LayerNode, layer);
layersTreeView.SelectedNode = targetNode;
}
protected override void DoUndo()
{
if (LayerNode != null)
{
Map.EditorLayer layer = LayerNode.Tag as Map.EditorLayer;
LayerNode.Remove();
layer.Remove();
}
}
// Checkbox validation
private void layersTreeView_BeforeCheck(object sender, TreeViewCancelEventArgs e)
{
// Prevent root node from being unchecked
Debug.Assert(e.Node is LayerNode);
LayerNode node = e.Node as LayerNode;
if (node.layer.type == "root")
{
e.Cancel = true;
}
}
private void CustomTreeView_AfterCheck(object sender, TreeViewEventArgs e)
{
if (e.Node is LayerNode)
{
LayerNode n = e.Node as LayerNode;
if (e.Node.Checked != n.Layer.Enabled)
{
OnRequestLayerEnabledChange(new LayerEnabledChangeEventArgs(n.Layer, e.Node.Checked));
}
}
}
public TreeLayerNode(LayerFormAdv form, LayerNode node)
: base(node.Name)
{
this.form = form;
this.layerNode = node;
foreach (LayerNode n in node.Nodes)
{
TreeLayerNode newNode = new TreeLayerNode(form, n);
newNode.Parent = this;
}
}
// Add layer button clicked
private void addLayerButton_Click(object sender, EventArgs e)
{
Debug.Assert(layersTreeView.SelectedNode is LayerNode);
SelectMaterialLayerType newLayerForm = new SelectMaterialLayerType();
if (newLayerForm.ShowDialog() == DialogResult.OK)
{
LayerNode node = layersTreeView.SelectedNode as LayerNode;
MaterialLayer newLayer = EditorMaterialLayer.create(newLayerForm.getSelectedType());
addNewLayer(newLayer);
}
}
private void TextBox_TextChanged(object sender, TextChangedEventArgs e)
{
LayerNode selectedNode = (LayerNode)listBox1.SelectedItem;
if (selectedNode == null)
{
return;
}
selectedNode.Values[_selectedKey] = textBox.Text;
listBox2.ItemsSource = null;
listBox2.ItemsSource = selectedNode.Values;
}
// recursiveBuildNode
private LayerNode recursiveBuildNode(MaterialLayer layer)
{
LayerNode node = new LayerNode(layer, layer.enabled);
if (layer.type == "root" || layer.type == "group")
{
MaterialGroupLayer groupLayer = layer as MaterialGroupLayer;
foreach (MaterialLayer childLayer in groupLayer.layers)
{
node.Nodes.Add(recursiveBuildNode(childLayer));
}
}
return(node);
}
// populate tree view
public void populateTreeView(MaterialGroupLayer rootLayer)
{
SuspendLayout();
// Clear existing nodes
layersTreeView.Nodes.Clear();
// Build nodes
LayerNode rootNode = recursiveBuildNode(rootLayer);
// Set tree view to root node
layersTreeView.Nodes.Add(rootNode);
// Expand all
layersTreeView.ExpandAll();
ResumeLayout();
}
// Move layer down
private void downButton_Click(object sender, EventArgs e)
{
Debug.Assert(layersTreeView.SelectedNode is LayerNode);
LayerNode node = layersTreeView.SelectedNode as LayerNode;
// Move layer down
MaterialGroupLayer parent = (node.Parent as LayerNode).layer as MaterialGroupLayer;
_controller.moveTerrainLayerDown(parent, node.layer);
// Refresh tree view
populateTreeView(selectedMaterial.rootLayer);
// Select repositioned layer
selectLayer(node.layer);
// Set changes made
_controller.setChangesMade(true);
}
public SerialLayer([NotNull] LayerNode node, string DType)
{
ThrowIf.Variable.IsNull(node, nameof(node));
ClassName = node.Base.LayerName;
Config = new Dictionary <string, object>();
Config.Add("dtype", DType);
foreach (var value in node.Base.Parameters)
{
var paramKey = value.Name;
var paramValue = node.Values[paramKey];
switch (value.Type.ToUpperInvariant())
{
case "string":
Config.Add(paramKey, paramValue);
break;
case "float":
Config.Add(paramKey,
Convert.ToSingle(paramValue, System.Globalization.CultureInfo.InvariantCulture));
break;
case "int":
Config.Add(paramKey,
Convert.ToInt32(paramValue, System.Globalization.CultureInfo.InvariantCulture));
break;
case "tuple":
ThrowIf.Variable.IsNull(paramValue, nameof(paramValue));
var strings = paramValue.Split(',');
var ints = new int[strings.Length];
for (var i = 0; i < strings.Length; ++i)
{
ints[i] = Convert.ToInt32(strings[i],
System.Globalization.CultureInfo.InvariantCulture);
}
Config.Add(paramKey, ints);
break;
}
}
}
// Remove layer button clicked
private void removeLayerButton_Click(object sender, EventArgs e)
{
Debug.Assert(layersTreeView.SelectedNode is LayerNode);
LayerNode node = layersTreeView.SelectedNode as LayerNode;
Debug.Assert(node.layer.type != "root");
// Display a warning that child nodes will be destroyed
bool doRemove = false;
if (node.layer.type == "group")
{
doRemove = MessageBox.Show("Are you sure you want to remove this node and all its child nodes?", "Remove Nodes", MessageBoxButtons.YesNo) == DialogResult.Yes;
}
else
{
doRemove = true;
}
if (doRemove)
{
// Remove layer
MaterialGroupLayer parent = (node.Parent as LayerNode).layer as MaterialGroupLayer;
_controller.removeTerrainLayer(parent, node.layer);
// Refresh tree view
populateTreeView(selectedMaterial.rootLayer);
// Select different layer
if (parent.layers.Count > 0)
{
selectLayer(parent.layers[parent.layers.Count - 1]);
}
else
{
selectLayer(parent);
}
// Set changes made
_controller.setChangesMade(true);
}
}
// Node check changed
private void layersTreeView_AfterCheck(object sender, TreeViewEventArgs e)
{
Debug.Assert(e.Node is LayerNode);
LayerNode node = e.Node as LayerNode;
Debug.Assert(node.layer.type != "root");
// Set layer's enabled status
node.layer.enabled = node.Checked;
// Recursively update child nodes' enabled status
// (nodes only, not layers -- the renderer stops at the first disabled layer anyway, so it's effectively the same behavior as disabling the layers)
foreach (TreeNode childNode in e.Node.Nodes)
{
recursiveEnableNode(childNode, node.Checked);
}
// Set changes made
_controller.setChangesMade(true);
}
// Selected node changed
private void layersTreeView_AfterSelect(object sender, TreeViewEventArgs e)
{
Debug.Assert(e.Node is LayerNode);
LayerNode node = e.Node as LayerNode;
// Remove button's status
removeLayerButton.Enabled = node.layer.type != "root";
// Add button's status
addLayerButton.Enabled = true;
// Copy/paste button's status
layerCopyButton.Enabled = true;
layerPasteButton.Enabled = _controller.copiedMaterialLayer != null;
// Up/down buttons' status
if (node.layer.type == "root")
{
upButton.Enabled = false;
downButton.Enabled = false;
}
else
{
upButton.Enabled = e.Node.Index > 0;
if (e.Node.Parent == null)
{
downButton.Enabled = false;
}
else
{
downButton.Enabled = e.Node.Index < e.Node.Parent.Nodes.Count - 1;
}
}
// Set layer's property grid
layerProperties.SelectedObject = node.layer;
}
public LayerNode(LayerNode copy)
: this(copy.name + " (copy)", copy.editor)
{
foreach (LayerNode n in copy.Nodes)
{
LayerNode copyNode;
if (n is Layer)
{
copyNode = new Layer(n as Layer);
}
else if (n is LayerFolder)
{
copyNode = new LayerFolder(n as LayerFolder);
}
else
{
copyNode = new LayerNode(n);
}
copyNode.SetParent(this, -1);
}
}
// recursiveGetNode
private LayerNode recursiveGetNode(LayerNode startNode, MaterialLayer layer)
{
// Check this node's layer
if (startNode.layer == layer)
{
return(startNode);
}
if (startNode.layer.type == "root" || startNode.layer.type == "group")
{
// Spawn more searches, checking results
foreach (TreeNode node in startNode.Nodes)
{
LayerNode result = recursiveGetNode(node as LayerNode, layer);
if (result != null && result.layer == layer)
{
return(result);
}
}
}
return(null);
}
public Editor(EditorForm form)
{
CurrentEditor = this;
this.form = form;
editorCamera = new Camera();
editorCamera.Use();
mouse = new MouseWatch();
mouse.Perspective = editorCamera;
keyboard = new KeyboardWatch();
manipulators = new Manipulator[] { new Manipulator(this), new ManipulatorTranslate(this), new ManipulatorRotate(this), new ManipulatorScale(this), new VertexPen(this) };
gridModel = new Model();
gridModel.PrimitiveType = PrimitiveType.Lines;
List <Vector3> gridVertices = new List <Vector3>();
for (int i = -50; i <= 50; i++)
{
gridVertices.Add(new Vector3(-50f, i, 0));
gridVertices.Add(new Vector3(50f, i, 0));
gridVertices.Add(new Vector3(i, -50f, 0));
gridVertices.Add(new Vector3(i, 50f, 0));
}
gridModel.VertexPosition = gridVertices.ToArray();
cameraControl = new CameraControl(this);
selectionBox = new SelectionBox(this);
meshCreator = new MeshCreator(this);
rootLayer = new LayerNode("root", this);
}
// recursiveBuildNode
private LayerNode recursiveBuildNode(MaterialLayer layer)
{
LayerNode node = new LayerNode(layer, layer.enabled);
if (layer.type == "root" || layer.type == "group")
{
MaterialGroupLayer groupLayer = layer as MaterialGroupLayer;
foreach (MaterialLayer childLayer in groupLayer.layers)
node.Nodes.Add(recursiveBuildNode(childLayer));
}
return node;
}
// recursiveGetNode
private LayerNode recursiveGetNode(LayerNode startNode, MaterialLayer layer)
{
// Check this node's layer
if (startNode.layer == layer)
return startNode;
if (startNode.layer.type == "root" || startNode.layer.type == "group")
{
// Spawn more searches, checking results
foreach (TreeNode node in startNode.Nodes)
{
LayerNode result = recursiveGetNode(node as LayerNode, layer);
if (result != null && result.layer == layer)
return result;
}
}
return null;
}
void LoadLayer(int idx)
{
/*AsyncOperation async = Application.LoadLevelAdditiveAsync(idx);
for(int i=0;i<9;i++)
{
GameObject obj = GameObject.Find("Brick(Clone)");
bricks.Add(obj);
Destroy(obj);
}
assignBrick();*/
LayerNode layerNode = new LayerNode();
layerNode.level = currentLevel;
layerNode.last = currentLayer;
if(currentLayer == null)
{
currentLayer = layerNode;
}
else
{
currentLayer.next = layerNode;
currentLayer = layerNode;
}
if(currentLayer.LoadScene(idx))
{
StartCoroutine(WaitAndInit(0.1f));
currentLevel++;
}
}
void DeleteLayer(LayerNode l)
{
if(l!=null)
{
for(int i=0;i<l.bricks.Count;i++)
{
Destroy((GameObject)l.bricks[i]);
}
l = null;
}
}
void OnGUI()
{
if(GUI.Button(new Rect(50,90,80,20), "Layer")) {
LoadLayer(kk);
kk++;
}
if(GUI.Button(new Rect(50,120,80,20), "qq")) {
currentLayer = null;
/*for(int i=0;i<9;i++)
{
Destroy((GameObject)currentLayer.bricks[i]);
}*/
}
}
public void SetParent(LayerNode node, int index)
{
Parent = node;
Index = index;
}
private static List <Layer> ParseLayers(MapDetails Map, List <TextureDetails> Textures)
{
var Result = new List <Layer>();
foreach (XmlNode LayerNode in Map.MapElement.SelectNodes("layer"))
{
var DataNode = LayerNode.SelectNodes("data").Item(0);
string CompressionFormat = DataNode.Attributes["compression"].Value;
string EncodingFormat = DataNode.Attributes["encoding"].Value;
if (!CompressionFormat.Equals("gzip", StringComparison.InvariantCultureIgnoreCase) || !EncodingFormat.Equals("base64", StringComparison.InvariantCultureIgnoreCase))
{
throw new FormatException("Currently the Tmx loader can only handled base-64 zlib tiles.");
}
string Base64Data = DataNode.InnerXml.Trim();
byte[] CompressedData = Convert.FromBase64String(Base64Data);
byte[] UncompressedData = new byte[1024]; // NOTE: This must be a multiple of 4.
Tile[,] Tiles = new Tile[Map.MapNumTilesWide, Map.MapNumTilesHigh];
int MapIndex = 0;
using (var GZipStream = new GZipStream(new MemoryStream(CompressedData), CompressionMode.Decompress, false)) {
while (true)
{
int BytesRead = GZipStream.Read(UncompressedData, 0, UncompressedData.Length);
if (BytesRead == 0)
{
break;
}
using (BinaryReader Reader = new BinaryReader(new MemoryStream(UncompressedData))) {
for (int i = 0; i < BytesRead; i += 4)
{
int GID = Reader.ReadInt32();
int MapX = MapIndex % Map.MapNumTilesWide;
int MapY = MapIndex / Map.MapNumTilesWide;
MapIndex++;
if (GID == 0)
{
continue;
}
var Texture = Textures.Last(c => c.StartGID <= GID);
int TextureX = (GID - Texture.StartGID) % Texture.NumTilesWide;
int TextureY = (GID - Texture.StartGID) / Texture.NumTilesWide;
Rectangle SourceRect = new Rectangle(TextureX * Texture.TileWidth, TextureY * Texture.TileHeight, Texture.TileWidth, Texture.TileHeight);
Rectangle Location = new Rectangle(MapX * Map.MapTileWidth, MapY * Map.MapTileHeight, Map.MapTileWidth, Map.MapTileHeight);
Tile Tile = new Tile(Texture.Texture, SourceRect, Location, new Vector2(MapX, MapY));
Tiles[MapX, MapY] = Tile;
}
}
}
}
bool IsSolid = true;
foreach (XmlNode PropertiesNode in LayerNode.SelectNodes("properties"))
{
foreach (XmlNode Property in PropertiesNode.SelectNodes("property"))
{
string Name = Property.Attributes["name"].Value;
string Value = Property.Attributes["value"].Value;
if (Name.Equals("Solid", StringComparison.InvariantCultureIgnoreCase))
{
IsSolid = bool.Parse(Value);
}
}
}
Layer Layer = new Layer(new Vector2(Map.MapTileWidth, Map.MapTileHeight), Tiles);
Layer.IsSolid = IsSolid;
Result.Add(Layer);
}
return(Result);
}
public SerialLayer([NotNull] LayerNode node, string DType, string BSize) : this(node, DType)
{
Config.Add("batch_input_shape", $"null, {BSize}");
}
