public override void OnSelectedTreeNodeChanged(SceneNodeModel newNode) { var nodeType = newNode?.NodeType ?? NodeType.None; var nodeTag = newNode?.Tag; foreach (var pair in FiringPositionGroups) { pair.Value.IsRendering = nodeType == NodeType.AiFiringPositions && pair.Key == nodeTag; } foreach (var pair in AreaGroups) { pair.Value.IsRendering = nodeType == NodeType.AiZoneAreas && pair.Key == nodeTag; } foreach (var pair in StartLocationGroups) { pair.Value.IsRendering = nodeType == NodeType.AiStartingLocations && pair.Key == nodeTag; } foreach (var pair in GroupStartLocationGroups) { pair.Value.IsRendering = nodeType == NodeType.AiGroupStartingLocations && pair.Key == nodeTag; } foreach (var pair in SoloStartLocationGroups) { pair.Value.IsRendering = nodeType == NodeType.AiSoloStartingLocations && pair.Key == nodeTag; } }
public override IEnumerable <ScenarioListItem> GetListItems(SceneNodeModel treeNode) { if (treeNode.NodeType == NodeType.StartProfiles) { var items = new List <ScenarioListItem>(); var section = scenario.Sections[Section.StartProfiles]; var nameOffset = OffsetById(section.Node, FieldId.Name); using (var reader = scenario.CreateReader()) { for (int i = 0; i < section.TagBlock.Count; i++) { var baseAddress = section.TagBlock.Pointer.Address + section.BlockSize * i; reader.Seek(baseAddress + nameOffset, SeekOrigin.Begin); var name = reader.ReadNullTerminatedString(); if (string.IsNullOrEmpty(name)) { name = "<none>"; } items.Add(new ScenarioListItem(name)); } } return(items); } return(Enumerable.Empty <ScenarioListItem>()); }
internal override BlockPropertiesLocator GetPropertiesLocator(SceneNodeModel treeNode, int itemIndex) { XmlNode rootNode; long baseAddress; IMetaUpdateReceiver target; if (treeNode.NodeType == NodeType.Mission) { rootNode = scenario.Sections[Section.Mission].Node; baseAddress = scenario.RootAddress; target = null; } else if (treeNode.NodeType == NodeType.StartProfiles && itemIndex >= 0) { var section = scenario.Sections[Section.StartProfiles]; rootNode = section.Node; baseAddress = section.TagBlock.Pointer.Address + itemIndex * section.BlockSize; target = scenario.Items[itemIndex]; } else { return(null); } return(new BlockPropertiesLocator { RootNode = rootNode, BaseAddress = baseAddress, TargetObject = target }); }
public void ShowProperties(SceneNodeModel node, int itemIndex) { context = new MetaContext(scenario.Xml, scenario.ScenarioTag.CacheFile, scenario.ScenarioTag, scenario.MetadataStream); Visibility = Visibility.Hidden; rootNode = null; altNodes.Clear(); var nodeType = node?.NodeType ?? NodeType.None; var handler = scenario.GetNodeTypeHandler(nodeType); var details = handler?.GetPropertiesLocator(node, itemIndex); if (details == null) { CurrentItem = null; return; } rootNode = details.RootNode; baseAddress = details.BaseAddress; if (details.AdditionalNodes != null) { altNodes.AddRange(details.AdditionalNodes); } CurrentItem = details.TargetObject; Reload(); Visibility = Visibility.Visible; }
public override bool ExecuteObjectOperation(SceneNodeModel treeNode, ObjectOperation operation, int itemIndex) { var blockRef = scenario.Sections[Section.StartProfiles]; var blockEditor = scenario.MetadataStream.GetBlockEditor(blockRef.TagBlock.Pointer.Address); switch (operation) { case ObjectOperation.Add: blockEditor.Add(); break; case ObjectOperation.Remove: if (itemIndex < 0 || itemIndex >= blockRef.TagBlock.Count) { return(false); } blockEditor.Remove(itemIndex); break; case ObjectOperation.Copy: if (itemIndex < 0 || itemIndex >= blockRef.TagBlock.Count) { return(false); } blockEditor.Copy(itemIndex, itemIndex + 1); break; } blockEditor.UpdateBlockReference(blockRef); return(true); }
public override Helix.Element3D GetElement(SceneNodeModel treeNode, int itemIndex) { var nodeTag = treeNode.Tag; if (treeNode.NodeType == NodeType.AiFiringPositions) { return(FiringPositions[nodeTag as AiZone][itemIndex]); } else if (treeNode.NodeType == NodeType.AiZoneAreas) { return(Areas[nodeTag as AiZone][itemIndex]); } else if (treeNode.NodeType == NodeType.AiStartingLocations) { return(StartLocations[nodeTag as AiEncounter][itemIndex]); } else if (treeNode.NodeType == NodeType.AiGroupStartingLocations) { return(GroupStartLocations[nodeTag as AiSquad][itemIndex]); } else if (treeNode.NodeType == NodeType.AiSoloStartingLocations) { return(SoloStartLocations[nodeTag as AiSquad][itemIndex]); } else { return(null); } }
public override Helix.Element3D GetElement(SceneNodeModel treeNode, int itemIndex) { var nodeType = treeNode?.NodeType ?? NodeType.None; var paletteKey = PaletteType.FromNodeType(nodeType); return(PaletteHolders[paletteKey].Elements[itemIndex]); }
public override int GetElementIndex(SceneNodeModel treeNode, Helix.Element3D element) { var nodeTag = treeNode.Tag; if (treeNode.NodeType == NodeType.AiFiringPositions) { return((nodeTag as AiZone).FiringPositions.IndexOf(element.DataContext as AiFiringPosition)); } else if (treeNode.NodeType == NodeType.AiZoneAreas) { return((nodeTag as AiZone).Areas.IndexOf(element.DataContext as AiArea)); } else if (treeNode.NodeType == NodeType.AiStartingLocations) { return((nodeTag as AiEncounter).StartingLocations.IndexOf(element.DataContext as AiStartingLocation)); } else if (treeNode.NodeType == NodeType.AiGroupStartingLocations) { return((nodeTag as AiSquad).GroupStartLocations.IndexOf(element.DataContext as AiStartingLocation)); } else if (treeNode.NodeType == NodeType.AiSoloStartingLocations) { return((nodeTag as AiSquad).SoloStartLocations.IndexOf(element.DataContext as AiStartingLocation)); } else { throw new ArgumentException(); } }
public override bool ExecuteObjectOperation(SceneNodeModel treeNode, ObjectOperation operation, int itemIndex) { var paletteKey = PaletteType.FromNodeType(treeNode.NodeType); var holder = PaletteHolders[paletteKey]; var blockEditor = scenario.MetadataStream.GetBlockEditor(holder.Definition.PlacementBlockRef.TagBlock.Pointer.Address); switch (operation) { case ObjectOperation.Add: blockEditor.Add(); blockEditor.UpdateBlockReference(holder.Definition.PlacementBlockRef); var placement = holder.InsertPlacement(blockEditor.EntryCount - 1, scenario, paletteKey); //setting the palette index causes a refresh which builds an element for the new object //these also need to be set to -1 initially anyway placement.PaletteIndex = placement.NameIndex = -1; break; case ObjectOperation.Remove: if (itemIndex < 0 || itemIndex >= holder.Definition.Placements.Count) { return(false); } ShiftObjectNames(paletteKey, itemIndex, holder.Definition.Placements.Count, true); blockEditor.Remove(itemIndex); blockEditor.UpdateBlockReference(holder.Definition.PlacementBlockRef); holder.RemovePlacement(itemIndex); UpdateBlockIndexes(paletteKey, itemIndex, holder.Definition.Placements.Count); break; case ObjectOperation.Copy: if (itemIndex < 0 || itemIndex >= holder.Definition.Placements.Count) { return(false); } ShiftObjectNames(paletteKey, itemIndex, holder.Definition.Placements.Count, false); var destIndex = itemIndex + 1; blockEditor.Copy(itemIndex, destIndex); blockEditor.UpdateBlockReference(holder.Definition.PlacementBlockRef); placement = holder.InsertPlacement(destIndex, scenario, paletteKey); placement.CopyFrom(holder.Definition.Placements[itemIndex]); UpdateBlockIndexes(paletteKey, itemIndex, holder.Definition.Placements.Count); break; default: return(false); } return(true); }
public override IEnumerable <ScenarioListItem> GetListItems(SceneNodeModel treeNode) { var paletteKey = PaletteType.FromNodeType(treeNode.NodeType); foreach (var placement in scenario.Palettes[paletteKey].Placements) { yield return(new ScenarioListItem(placement)); } }
public override SharpDX.BoundingBox GetObjectBounds(SceneNodeModel treeNode, int itemIndex) { var element = GetElement(treeNode, itemIndex); if (element == null) { return(default(SharpDX.BoundingBox)); } return((element as IMeshNode)?.GetNodeBounds() ?? element.GetTotalBounds()); }
public override bool ExecuteObjectOperation(SceneNodeModel treeNode, ObjectOperation operation, int itemIndex) { var blockRef = scenario.Sections[Section.TriggerVolumes]; var blockEditor = scenario.MetadataStream.GetBlockEditor(blockRef.TagBlock.Pointer.Address); switch (operation) { case ObjectOperation.Add: blockEditor.Add(); var vol = new TriggerVolume(scenario) { //really should be reading these from the stream... ForwardVector = new RealVector3D(1, 0, 0), UpVector = new RealVector3D(0, 0, 1), Size = new RealVector3D(1, 1, 1) }; scenario.TriggerVolumes.Add(vol); AddTriggerVolumeElement(vol); break; case ObjectOperation.Remove: if (itemIndex < 0 || itemIndex >= blockRef.TagBlock.Count) { return(false); } blockEditor.Remove(itemIndex); scenario.TriggerVolumes.RemoveAt(itemIndex); RemoveTriggerVolumeElement(itemIndex); UpdateBlockIndexes(itemIndex, scenario.TriggerVolumes.Count); break; case ObjectOperation.Copy: if (itemIndex < 0 || itemIndex >= blockRef.TagBlock.Count) { return(false); } var destIndex = itemIndex + 1; blockEditor.Copy(itemIndex, destIndex); vol = new TriggerVolume(scenario); scenario.TriggerVolumes.Insert(destIndex, vol); InsertTriggerVolumeElement(vol, destIndex); vol.CopyFrom(scenario.TriggerVolumes[itemIndex]); UpdateBlockIndexes(itemIndex, scenario.TriggerVolumes.Count); break; } blockEditor.UpdateBlockReference(blockRef); return(true); }
public void SetTransparentMaterial() { //grab the existing material _tempMaterial = SceneNodeModel.Material; //temporarily replace it with the transparent one Material material = _application.ResourceCache.GetMaterial("Materials/GreenTransparent.xml"); if (material != null) { material.Name = "greenTransparent"; SceneNodeModel.SetMaterial(material); } }
public void NavigateToObject(SceneNodeModel node, int index) { if (node == null || !isReady) { return; } var handler = scenario.GetNodeTypeHandler(scenario.SelectedNodeType); if (handler != null) { renderer.ZoomToBounds(handler.GetObjectBounds(node, index), 500); } }
public override void OnSelectedTreeNodeChanged(SceneNodeModel newNode) { TriggerVolumeGroup.IsRendering = newNode?.NodeType == NodeType.TriggerVolumes; var editor = scenario.RenderView as DXEditor; if (newNode?.NodeType == NodeType.TriggerVolumes && !editor.TreeViewItems.Contains(sceneNode)) { editor.TreeViewItems.Add(sceneNode); } else if (newNode?.NodeType != NodeType.TriggerVolumes && editor.TreeViewItems.Contains(sceneNode)) { editor.TreeViewItems.Remove(sceneNode); } }
public override void OnSelectedTreeNodeChanged(SceneNodeModel newNode) { var nodeType = newNode?.NodeType ?? NodeType.None; //if the node is not a palette this will disable hit testing on all palettes var paletteKey = PaletteType.FromNodeType(nodeType); foreach (var palette in PaletteHolders.Values) { palette.GroupElement.IsHitTestVisible = palette.Name == paletteKey; } //only render decals when the decal node is selected PaletteHolders[PaletteType.Decal].GroupElement.IsRendering = nodeType == NodeType.Decals; }
public void SelectObject(SceneNodeModel node, int itemIndex) { if (node == null || !isReady) { return; } if (itemIndex < 0) { return; } var handler = scenario.GetNodeTypeHandler(scenario.SelectedNodeType); renderer.SetSelectedElement(handler?.GetElement(node, itemIndex)); }
public Game() { octtreeNode = new SceneNodeOcttree(); blockgNode = new SceneNodeBlockGrid(); ModelLoader.Get().LoadModel("models/xyz.3ds"); xyzModelNode = new SceneNodeModel(ModelLoader.Get().GetModel("models/xyz.3ds")); octtreeNode.AddNode(xyzModelNode); ((SceneNodeOcttree)(octtreeNode)).BuildTree(6); camera = new Camera(); camera.SetPosition(10, 10, 10); camera.SetTarget(0, 0, 0); running = true; }
public override IEnumerable <ScenarioListItem> GetListItems(SceneNodeModel treeNode) { var zoneTag = treeNode.Parent.Tag as AiZone; var encTag = treeNode.Parent.Tag as AiEncounter; var squadTag = treeNode.Parent.Tag as AiSquad; if (treeNode.NodeType == NodeType.AiSquadGroups) { return(scenario.SquadHierarchy.SquadGroups.Select(group => new ScenarioListItem(group))); } else if (treeNode.NodeType == NodeType.AiZones) { return(scenario.SquadHierarchy.Zones.Select(zone => new ScenarioListItem(zone))); } else if (treeNode.NodeType == NodeType.AiZoneAreas) { return(zoneTag.Areas.Select(area => new ScenarioListItem(area))); } else if (treeNode.NodeType == NodeType.AiFiringPositions) { return(zoneTag.FiringPositions.Select(fpos => new ScenarioListItem(fpos))); } else if (treeNode.NodeType == NodeType.AiSquads) { return(zoneTag.Squads.Select(squad => new ScenarioListItem(squad))); } else if (treeNode.NodeType == NodeType.AiEncounters) { return(squadTag.Encounters.Select(enc => new ScenarioListItem(enc))); } else if (treeNode.NodeType == NodeType.AiStartingLocations || treeNode.NodeType == NodeType.AiGroupStartingLocations || treeNode.NodeType == NodeType.AiSoloStartingLocations) { var locations = treeNode.NodeType == NodeType.AiStartingLocations ? encTag.StartingLocations : treeNode.NodeType == NodeType.AiGroupStartingLocations ? squadTag.GroupStartLocations : squadTag.SoloStartLocations; return(locations.Select(loc => new ScenarioListItem(loc))); } else { return(Enumerable.Empty <ScenarioListItem>()); } }
internal override BlockPropertiesLocator GetPropertiesLocator(SceneNodeModel treeNode, int itemIndex) { if (itemIndex < 0) { return(null); } var section = scenario.Sections[Section.StartPositions]; return(new BlockPropertiesLocator { RootNode = section.Node, BaseAddress = section.TagBlock.Pointer.Address + itemIndex * section.BlockSize, TargetObject = scenario.Items[itemIndex] }); }
public override Helix.Element3D GetElement(SceneNodeModel treeNode, int itemIndex) { var prev = TriggerVolumes.FirstOrDefault(t => t.Tag != null); if (prev != null) { prev.DiffuseColor = TriggerVolume.DefaultColour; prev.Tag = null; } var selected = TriggerVolumes[itemIndex]; selected.DiffuseColor = TriggerVolume.SelectedColour; selected.Tag = true; RefreshTriggerVolumes(itemIndex); return(selected); }
public override bool ExecuteObjectOperation(SceneNodeModel treeNode, ObjectOperation operation, int itemIndex) { var blockRef = scenario.Sections[Section.StartPositions]; var blockEditor = scenario.MetadataStream.GetBlockEditor(blockRef.TagBlock.Pointer.Address); switch (operation) { case ObjectOperation.Add: blockEditor.Add(); var pos = new StartPosition(scenario); scenario.StartingPositions.Add(pos); AddStartPositionElement(pos); break; case ObjectOperation.Remove: if (itemIndex < 0 || itemIndex >= blockRef.TagBlock.Count) { return(false); } blockEditor.Remove(itemIndex); scenario.StartingPositions.RemoveAt(itemIndex); RemoveStartPositionElement(itemIndex); break; case ObjectOperation.Copy: if (itemIndex < 0 || itemIndex >= blockRef.TagBlock.Count) { return(false); } var destIndex = itemIndex + 1; blockEditor.Copy(itemIndex, destIndex); pos = new StartPosition(scenario); scenario.StartingPositions.Insert(destIndex, pos); InsertStartPositionElement(pos, destIndex); pos.CopyFrom(scenario.StartingPositions[itemIndex]); break; } blockEditor.UpdateBlockReference(blockRef); return(true); }
public void SelectPalette(SceneNodeModel node) { if (node == null || !isReady) { return; } foreach (var c in scenario.ComponentManagers) { c.OnSelectedTreeNodeChanged(node); } //remove selection highlighter if it is no longer visible var selection = renderer.GetSelectedElement(); if (selection != null && (selection.IsRendering == false || selection.EnumerateAncestors().Any(e => e.IsRendering == false))) { renderer.SetSelectedElement(null); } }
internal override BlockPropertiesLocator GetPropertiesLocator(SceneNodeModel treeNode, int itemIndex) { if (itemIndex < 0) { return(null); } var section = scenario.Sections[Section.TriggerVolumes]; var altNodes = new List <Tuple <XmlNode, long> >(); altNodes.Add(Tuple.Create(scenario.Sections[Section.ObjectNames].Node, scenario.RootAddress)); return(new BlockPropertiesLocator { RootNode = section.Node, BaseAddress = section.TagBlock.Pointer.Address + itemIndex * section.BlockSize, AdditionalNodes = altNodes, TargetObject = scenario.TriggerVolumes[itemIndex] }); }
internal override BlockPropertiesLocator GetPropertiesLocator(SceneNodeModel treeNode, int itemIndex) { var paletteKey = PaletteType.FromNodeType(treeNode.NodeType); if (itemIndex >= 0) { var palette = scenario.Palettes[paletteKey]; var altNodes = new List <Tuple <XmlNode, long> >(); altNodes.Add(Tuple.Create(scenario.Sections[Section.ObjectNames].Node, scenario.RootAddress)); altNodes.Add(Tuple.Create(palette.PaletteNode, scenario.RootAddress)); return(new BlockPropertiesLocator { RootNode = palette.PlacementsNode, BaseAddress = palette.PlacementBlockRef.TagBlock.Pointer.Address + itemIndex * palette.PlacementBlockRef.BlockSize, AdditionalNodes = altNodes, TargetObject = palette.Placements[itemIndex] }); } return(null); }
internal override BlockPropertiesLocator GetPropertiesLocator(SceneNodeModel treeNode, int itemIndex) { XmlNode rootNode; long baseAddress; IMetaUpdateReceiver target; var altNodes = new List <Tuple <XmlNode, long> >(); if (treeNode.NodeType == NodeType.AiSquadGroups && itemIndex >= 0) { var group = scenario.SquadHierarchy.SquadGroups[itemIndex]; rootNode = scenario.SquadHierarchy.AiNodes[AiSection.SquadGroups]; baseAddress = group.BlockStartAddress; altNodes.Add(Tuple.Create(scenario.SquadHierarchy.AiNodes[AiSection.SquadGroups], scenario.RootAddress)); target = group; } else if ((treeNode.NodeType == NodeType.AiZoneItem && treeNode.Tag is AiZone) || (treeNode.NodeType == NodeType.AiZones && itemIndex >= 0)) { var zone = treeNode.NodeType == NodeType.AiZones ? scenario.SquadHierarchy.Zones[itemIndex] : treeNode.Tag as AiZone; rootNode = scenario.SquadHierarchy.AiNodes[AiSection.Zones]; baseAddress = zone.BlockStartAddress; target = zone; } else if (treeNode.NodeType == NodeType.AiFiringPositions && itemIndex >= 0) { var fpos = (treeNode.Parent.Tag as AiZone).FiringPositions[itemIndex]; rootNode = scenario.SquadHierarchy.AiNodes[AiSection.FiringPositions]; baseAddress = fpos.BlockReference.TagBlock.Pointer.Address + fpos.BlockIndex * fpos.BlockReference.BlockSize; altNodes.Add(Tuple.Create(scenario.SquadHierarchy.AiNodes[AiSection.Areas], fpos.Zone.BlockStartAddress)); target = fpos; } else if (treeNode.NodeType == NodeType.AiZoneAreas && itemIndex >= 0) { var area = (treeNode.Parent.Tag as AiZone).Areas[itemIndex]; rootNode = scenario.SquadHierarchy.AiNodes[AiSection.Areas]; baseAddress = area.BlockReference.TagBlock.Pointer.Address + area.BlockIndex * area.BlockReference.BlockSize; target = area; } else if ((treeNode.NodeType == NodeType.AiSquadItem && treeNode.Tag is AiSquad) || (treeNode.NodeType == NodeType.AiSquads && itemIndex >= 0)) { var squad = treeNode.NodeType == NodeType.AiSquads ? (treeNode.Parent.Tag as AiZone).Squads[itemIndex] : treeNode.Tag as AiSquad; rootNode = scenario.SquadHierarchy.AiNodes[AiSection.Squads]; baseAddress = squad.BlockStartAddress; altNodes.Add(Tuple.Create(scenario.SquadHierarchy.AiNodes[AiSection.SquadGroups], scenario.RootAddress)); altNodes.Add(Tuple.Create(scenario.SquadHierarchy.AiNodes[AiSection.Zones], scenario.RootAddress)); target = squad; } else if ((treeNode.NodeType == NodeType.AiEncounterItem && treeNode.Tag is AiEncounter) || (treeNode.NodeType == NodeType.AiEncounters && itemIndex >= 0)) { var enc = treeNode.NodeType == NodeType.AiEncounters ? (treeNode.Parent.Tag as AiSquad).Encounters[itemIndex] : treeNode.Tag as AiEncounter; rootNode = scenario.SquadHierarchy.AiNodes[AiSection.Encounters]; baseAddress = enc.BlockStartAddress; foreach (var palette in scenario.Palettes.Values) { altNodes.Add(Tuple.Create(palette.PaletteNode, scenario.RootAddress)); } target = enc; } else if ((treeNode.NodeType == NodeType.AiStartingLocations || treeNode.NodeType == NodeType.AiGroupStartingLocations || treeNode.NodeType == NodeType.AiSoloStartingLocations) && itemIndex >= 0) { var tag = treeNode.Parent.Tag; var loc = treeNode.NodeType == NodeType.AiStartingLocations ? (tag as AiEncounter).StartingLocations[itemIndex] : treeNode.NodeType == NodeType.AiGroupStartingLocations ? (tag as AiSquad).GroupStartLocations[itemIndex] : (tag as AiSquad).SoloStartLocations[itemIndex]; rootNode = scenario.SquadHierarchy.AiNodes[loc.SectionKey]; baseAddress = loc.BlockReference.TagBlock.Pointer.Address + loc.BlockIndex * loc.BlockReference.BlockSize; foreach (var palette in scenario.Palettes.Values) { altNodes.Add(Tuple.Create(palette.PaletteNode, scenario.RootAddress)); } target = loc; } else { return(null); } return(new BlockPropertiesLocator { RootNode = rootNode, BaseAddress = baseAddress, AdditionalNodes = altNodes, TargetObject = target }); }
public override SharpDX.BoundingBox GetObjectBounds(SceneNodeModel treeNode, int itemIndex) { return(GetElement(treeNode, itemIndex)?.GetTotalBounds() ?? default(SharpDX.BoundingBox)); }
//only called if HandlesNodeType, called to fill the listbox when a tree item is clicked public virtual IEnumerable <ScenarioListItem> GetListItems(SceneNodeModel treeNode) { yield break; }
//only called if HandlesNodeType, called to populate properties list internal virtual BlockPropertiesLocator GetPropertiesLocator(SceneNodeModel treeNode, int itemIndex) { throw new NotImplementedException(); }
//only called if SupportsObjectOperation public virtual bool ExecuteObjectOperation(SceneNodeModel treeNode, ObjectOperation operation, int itemIndex) { throw new NotImplementedException(); }