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();
}
