// render the scene.
public void Render()
{
bool skipRender =
SurfaceId == 0 ||
GameEngine.IsInError ||
Width == 0 ||
Height == 0 ||
DesignView.Context == null;
if (skipRender)
{
return;
}
m_clk.Start();
GameEngine.SetObjectProperty(swapChainId, SurfaceId, BkgColorPropId, DesignView.BackColor);
GameEngine.SetRenderState(RenderState);
GameEngine.Begin(SurfaceId, Camera.ViewMatrix, Camera.ProjectionMatrix);
IGame game = DesignView.Context.As <IGame>();
GridRenderer gridRender = game.Grid.Cast <GridRenderer>();
gridRender.Render(Camera);
bool renderSelected = RenderState.DisplayBound == DisplayFlagModes.Selection ||
RenderState.DisplayCaption == DisplayFlagModes.Selection ||
RenderState.DisplayPivot == DisplayFlagModes.Selection;
if (renderSelected)
{
// for testing draw bounds for selected objects
var selection = DesignView.Context.As <ISelectionContext>().Selection;
IEnumerable <DomNode> rootDomNodes = DomNode.GetRoots(selection.AsIEnumerable <DomNode>());
RenderProperties(rootDomNodes,
RenderState.DisplayCaption == DisplayFlagModes.Selection,
RenderState.DisplayBound == DisplayFlagModes.Selection,
RenderState.DisplayPivot == DisplayFlagModes.Selection);
}
RenderProperties(Items,
RenderState.DisplayCaption == DisplayFlagModes.Always,
RenderState.DisplayBound == DisplayFlagModes.Always,
RenderState.DisplayPivot == DisplayFlagModes.Always);
GameEngine.RenderGame();
if (DesignView.Manipulator != null)
{
DesignView.Manipulator.Render(this);
}
string str = string.Format("View Type: {0} time-per-frame: {1:0.00} ms", ViewType, m_clk.Milliseconds);
GameEngine.DrawText2D(str, Util3D.CaptionFont, 1, 1, Color.White);
RenderSystemAxis();
GameEngine.End();
}
void m_selectionContext_SelectionChanged(object sender, EventArgs e)
{
var domNodes = m_selectionContext.Selection.AsIEnumerable <DomNode>();
var roots = DomNode.GetRoots(domNodes);
var sel = GameEngine.GlobalSelection;
sel.Clear();
foreach (var node in roots)
{
if (node.Is <ITransformableGroup>())
{
foreach (var adapter in node.Subtree.AsIEnumerable <NativeObjectAdapter>())
{
sel.Add(adapter.DocumentId, adapter.InstanceId);
}
}
else
{
var adapter = node.As <NativeObjectAdapter>();
if (adapter != null)
{
sel.Add(adapter.DocumentId, adapter.InstanceId);
}
}
}
using (var placements = GameEngine.GetEditorSceneManager().GetPlacementsEditor())
sel.DoFixup(placements);
InvalidateViews();
}
public object Copy(Selection <object> selection)
{
IEnumerable <DomNode> rootDomNodes = DomNode.GetRoots(Selection.AsIEnumerable <DomNode>());
object[] copies = DomNode.Copy(rootDomNodes).ToArray <object>();
return(new DataObject(copies));
}
public override void OnBeginDrag()
{
var selection = DesignView.Context.As <ISelectionContext>().Selection;
var transactionContext = DesignView.Context.As <ITransactionContext>();
NodeList.Clear();
m_isUniformScaling = false;
IEnumerable <DomNode> rootDomNodes = DomNode.GetRoots(selection.AsIEnumerable <DomNode>());
foreach (DomNode node in rootDomNodes)
{
ITransformable transNode = node.As <ITransformable>();
if (transNode == null || (transNode.TransformationType & TransformationTypes.Scale) == 0)
{
continue;
}
IVisible vn = node.As <IVisible>();
if (!vn.Visible)
{
continue;
}
ILockable lockable = node.As <ILockable>();
if (lockable.IsLocked)
{
continue;
}
// force uniform scaling if any node requires it
if ((transNode.TransformationType & TransformationTypes.UniformScale) == TransformationTypes.UniformScale)
{
m_isUniformScaling = true;
}
NodeList.Add(transNode);
IManipulatorNotify notifier = transNode.As <IManipulatorNotify>();
if (notifier != null)
{
notifier.OnBeginDrag();
}
}
m_originalValues = new Vec3F[NodeList.Count];
int k = 0;
foreach (ITransformable node in NodeList)
{
m_originalValues[k++] = node.Scale;
}
if (NodeList.Count > 0)
{
transactionContext.Begin("Scale".Localize());
}
}
private void RenderExtras(GUILayer.SimpleRenderingContext context, DesignView designView)
{
bool renderSelected = RenderState.DisplayBound == DisplayFlagModes.Selection ||
RenderState.DisplayCaption == DisplayFlagModes.Selection ||
RenderState.DisplayPivot == DisplayFlagModes.Selection;
if (renderSelected)
{
var selection = DesignView.Context.As <ISelectionContext>().Selection;
IEnumerable <DomNode> rootDomNodes = DomNode.GetRoots(selection.AsIEnumerable <DomNode>());
RenderProperties(context, rootDomNodes,
RenderState.DisplayCaption == DisplayFlagModes.Selection,
RenderState.DisplayBound == DisplayFlagModes.Selection,
RenderState.DisplayPivot == DisplayFlagModes.Selection);
}
if (RenderState.GridMode == RenderState.GridModes.Enabled)
{
var game = designView.Context.As <IGame>();
GridRenderer gridRender = game.Grid.Cast <GridRenderer>();
gridRender.Render(context, Camera);
}
RenderProperties(context, Items,
RenderState.DisplayCaption == DisplayFlagModes.Always,
RenderState.DisplayBound == DisplayFlagModes.Always,
RenderState.DisplayPivot == DisplayFlagModes.Always);
GameEngine.DrawText2D(m_pendingCaption, Util3D.CaptionFont, 1, 1, Color.White);
}
public override void OnBeginDrag()
{
if (m_hitRegion == HitRegion.None)
{
return;
}
var selectionCntx = DesignView.Context.As <ISelectionContext>();
var selection = selectionCntx.Selection;
var transactionContext = DesignView.Context.As <ITransactionContext>();
NodeList.Clear();
IEnumerable <DomNode> rootDomNodes = DomNode.GetRoots(selection.AsIEnumerable <DomNode>());
foreach (DomNode domNode in rootDomNodes)
{
ITransformable node = domNode.As <ITransformable>();
if (node == null || (node.TransformationType & TransformationTypes.Rotation) == 0)
{
continue;
}
IVisible vn = node.As <IVisible>();
if (!vn.Visible)
{
continue;
}
ILockable lockable = node.As <ILockable>();
if (lockable.IsLocked)
{
continue;
}
NodeList.Add(node);
IManipulatorNotify notifier = node.As <IManipulatorNotify>();
if (notifier != null)
{
notifier.OnBeginDrag();
}
}
m_rotations = new Matrix4F[NodeList.Count];
for (int k = 0; k < NodeList.Count; k++)
{
ITransformable node = NodeList[k];
Matrix4F m = new Matrix4F(node.Transform);
m.Translation = new Vec3F(0, 0, 0);
m.Normalize(m);
m_rotations[k] = m;
}
if (NodeList.Count > 0)
{
transactionContext.Begin("Rotate".Localize());
}
}
/// <summary>
/// Copies the selection. Returns a data object representing the copied items.</summary>
/// <returns>Data object representing the copied items; e.g., a
/// System.Windows.Forms.IDataObject object</returns>
public object Copy()
{
IEnumerable <UIObject> uiObjects = Selection.AsIEnumerable <UIObject>();
IEnumerable <DomNode> rootNodes = DomNode.GetRoots(Adapters.AsIEnumerable <DomNode>(uiObjects));
List <object> copies = new List <object>(DomNode.Copy(rootNodes));
return(new DataObject(copies.ToArray()));
}
public void Delete()
{
IEnumerable <DomNode> selectedDomNodes = GetSelection <DomNode>();
foreach (DomNode domNode in DomNode.GetRoots(selectedDomNodes))
{
domNode.RemoveFromParent();
}
}
public void Delete()
{
IEnumerable <DomNode> rootDomNodes = DomNode.GetRoots(Selection.AsIEnumerable <DomNode>());
foreach (DomNode domNode in rootDomNodes)
{
domNode.RemoveFromParent();
}
}
void m_selectionContext_SelectionChanged(object sender, EventArgs e)
{
IEnumerable <DomNode> domNodes = m_selectionContext.Selection.AsIEnumerable <DomNode>();
IEnumerable <DomNode> roots = DomNode.GetRoots(domNodes);
IEnumerable <NativeObjectAdapter> nativeObjects = roots.AsIEnumerable <NativeObjectAdapter>();
GameEngine.SetSelection(nativeObjects);
InvalidateViews();
}
/// <summary>
/// Copies selected items from the statechart</summary>
/// <returns>DataObject containing an enumeration of selected items</returns>
public object Copy()
{
List <DomNode> domNodes = new List <DomNode>();
// form state "closure" for determining which transitions to copy
HashSet <StateBase> allStates = new HashSet <StateBase>();
// for all selected root states and sub-states
IEnumerable <DomNode> rootNodes = DomNode.GetRoots(Selection.AsIEnumerable <DomNode>());
IEnumerable <StateBase> rootStates = Adapters.AsIEnumerable <StateBase>(rootNodes);
foreach (StateBase stateBase in rootStates)
{
domNodes.Add(stateBase.DomNode);
allStates.Add(stateBase);
State state = stateBase.As <State>();
if (state != null)
{
foreach (StateBase subState in state.SubStates)
{
allStates.Add(subState);
}
}
}
// get selected transitions between selected states
bool itemsIncludeTransitions = false;
foreach (Transition transition in Selection.AsIEnumerable <Transition>())
{
domNodes.Add(transition.DomNode);
itemsIncludeTransitions = true;
}
// if there were none, then try to add any transitions between selected states or sub-states
if (!itemsIncludeTransitions)
{
foreach (Transition transition in m_transitions)
{
if (allStates.Contains(transition.FromState) &&
allStates.Contains(transition.ToState))
{
domNodes.Add(transition.DomNode);
}
}
}
foreach (Annotation annotation in Selection.AsIEnumerable <Annotation>())
{
domNodes.Add(annotation.DomNode);
}
DomNode[] copies = DomNode.Copy(domNodes);
return(new DataObject(Enumerable.ToArray <object>(copies)));
}
/// <summary>
/// Copies the selection. Returns a data object representing the copied items.</summary>
/// <returns>Data object representing the copied items; e.g., a
/// System.Windows.Forms.IDataObject object</returns>
public object Copy()
{
IEnumerable <UIObject> uiObjects = Selection.AsIEnumerable <UIObject>();
IEnumerable <Curve> curves = Selection.AsIEnumerable <Curve>();
IEnumerable <DomNode> rootNodes = DomNode.GetRoots(uiObjects.AsIEnumerable <DomNode>());
IEnumerable <DomNode> rootNodes2 = DomNode.GetRoots(curves.AsIEnumerable <DomNode>());
List <object> copies = new List <object>(DomNode.Copy(rootNodes));
copies.AddRange(rootNodes2);
return(new DataObject(copies.ToArray()));
}
public bool CanCopy()
{
IEnumerable <DomNode> rootDomNodes = DomNode.GetRoots(Selection.AsIEnumerable <DomNode>());
foreach (DomNode domNode in rootDomNodes)
{
if (domNode.Is <IGame>() || domNode.Is <GameReference>() ||
domNode.Is <IResource>())
{
return(false);
}
}
return(Selection.Count > 0);
}
/// <summary>
/// Deletes selected items</summary>
public void Delete()
{
IEnumerable <DomNode> rootNodes = DomNode.GetRoots(Selection.AsIEnumerable <DomNode>());
foreach (DomNode node in rootNodes)
{
if (node.Parent != null)
{
node.RemoveFromParent();
}
}
Selection.Clear();
}
public bool CanDelete()
{
IEnumerable <DomNode> rootDomNodes = DomNode.GetRoots(Selection.AsIEnumerable <DomNode>());
foreach (DomNode domNode in rootDomNodes)
{
if (domNode.Parent != null)
{
return(true);
}
}
return(false);
}
public bool CanDelete()
{
IEnumerable <DomNode> rootDomNodes = DomNode.GetRoots(Selection.AsIEnumerable <DomNode>());
foreach (DomNode domNode in rootDomNodes)
{
if (domNode.Is <IGame>() ||
domNode.Is <GameReference>() ||
domNode.Parent == null ||
(domNode.Parent.Is <IGame>() && domNode.Is <IGameObjectFolder>()) ||
IsLocked(domNode))
{
return(false);
}
}
return(Selection.Count > 0);
}
public void TestGetRoots()
{
DomNodeType type = new DomNodeType("type");
ChildInfo childInfo = new ChildInfo("child", type);
type.Define(childInfo);
DomNode child = new DomNode(type);
DomNode parent = new DomNode(type);
DomNode grandparent = new DomNode(type);
parent.SetChild(childInfo, child);
grandparent.SetChild(childInfo, parent);
DomNode child2 = new DomNode(type);
Utilities.TestSequenceEqual(DomNode.GetRoots(new DomNode[] { grandparent, child, child2 }), grandparent, child2);
}
void m_selectionContext_SelectionChanged(object sender, EventArgs e)
{
IEnumerable <DomNode> domNodes = m_selectionContext.Selection.AsIEnumerable <DomNode>();
IEnumerable <DomNode> roots = DomNode.GetRoots(domNodes);
IEnumerable <NativeObjectAdapter> nativeObjects = roots.AsIEnumerable <NativeObjectAdapter>();
var sel = GameEngine.GlobalSelection;
sel.Clear();
foreach (var adapter in nativeObjects)
{
sel.Add(adapter.DocumentId, adapter.InstanceId);
}
using (var placements = GameEngine.GetEditorSceneManager().GetPlacementsEditor())
sel.DoFixup(placements);
InvalidateViews();
}
public void Frame(IEnumerable <object> items)
{
IEnumerable <DomNode> rootDomNodes = DomNode.GetRoots(items.AsIEnumerable <DomNode>());
AABB bound = new AABB();
foreach (var item in items)
{
IBoundable boundable = null;
DomNode domItem = item.As <DomNode>();
if (domItem != null)
{
foreach (var node in domItem.Lineage)
{
boundable = node.As <IBoundable>();
if (boundable != null)
{
break;
}
}
}
else
{
Slot slot = item.As <Slot>();
boundable = slot.Owner.As <IBoundable>();
}
IVisible vn = boundable.As <IVisible>();
if (boundable != null && (vn == null || vn.Visible))
{
bound.Extend(boundable.BoundingBox);
}
}
if (!bound.IsEmpty)
{
Sphere3F sphere = bound.ToSphere();
sphere.Radius *= 3.0f;
IDesignView designView = Globals.MEFContainer.GetExportedValue <IDesignView>();
Util.ZoomOnSphere(designView.ActiveView.Camera, sphere);
}
}
public void Delete()
{
if (!CanDelete())
{
return;
}
IEnumerable <DomNode> rootDomNodes = DomNode.GetRoots(Selection.AsIEnumerable <DomNode>());
foreach (DomNode domNode in rootDomNodes)
{
if (domNode.Is <IGame>() ||
domNode.Is <GameReference>() ||
domNode.Parent == null ||
(domNode.Parent.Is <IGame>() && domNode.Is <IGameObjectFolder>()))
{
continue;
}
domNode.RemoveFromParent();
}
UpdateGameObjectReferences();
}
public override void OnBeginDrag()
{
if (m_hitRegion == HitRegion.None)
{
return;
}
m_cancelDrag = false;
Clear(); // cached values.
var selectionContext = DesignView.Context.As <ISelectionContext>();
var selection = selectionContext.Selection;
var transactionContext = DesignView.Context.As <ITransactionContext>();
IEnumerable <DomNode> rootDomNodes = DomNode.GetRoots(selection.AsIEnumerable <DomNode>());
m_duplicating = Control.ModifierKeys == m_duplicateKey;
if (m_duplicating)
{
List <DomNode> originals = new List <DomNode>();
foreach (DomNode node in rootDomNodes)
{
ITransformable transformable = node.As <ITransformable>();
if (!CanManipulate(transformable))
{
continue;
}
originals.Add(node);
}
if (originals.Count > 0)
{
DomNode[] copies = DomNode.Copy(originals);
transactionContext.Begin("Copy And Move".Localize());
List <object> newSelection = new List <object>();
// re-parent copy
for (int i = 0; i < copies.Length; i++)
{
DomNode copy = copies[i];
DomNode original = originals[i];
ChildInfo chInfo = original.ChildInfo;
if (chInfo.IsList)
{
original.Parent.GetChildList(chInfo).Add(copy);
}
else
{
original.Parent.SetChild(chInfo, copy);
}
newSelection.Add(Util.AdaptDomPath(copy));
copy.InitializeExtensions();
}
selectionContext.SetRange(newSelection);
NodeList.AddRange(copies.AsIEnumerable <ITransformable>());
}
}
else
{
foreach (DomNode node in rootDomNodes)
{
ITransformable transformable = node.As <ITransformable>();
if (!CanManipulate(transformable))
{
continue;
}
NodeList.Add(transformable);
}
if (NodeList.Count > 0)
{
transactionContext.Begin("Move".Localize());
}
}
m_originalValues = new Vec3F[NodeList.Count];
m_originalRotations = new Vec3F[NodeList.Count];
for (int k = 0; k < NodeList.Count; k++)
{
ITransformable node = NodeList[k];
IManipulatorNotify notifier = node.As <IManipulatorNotify>();
if (notifier != null)
{
notifier.OnBeginDrag();
}
m_originalValues[k] = node.Translation;
m_originalRotations[k] = node.Rotation;
}
}
/// <summary>
/// Inserts the specified child into the specified parent</summary>
/// <param name="parent">Parent to insert into</param>
/// <param name="child">Child to be inserted</param>
/// <remarks>This method is used by copy-paste and drag-drop from various sources.
/// When making any changes to this method, please test the following:
/// - Copy/Paste, Cut/Paste
/// - Drag-drop from {Palette|ResourceLister} to {ProjectLister|DesignView}
/// Pay special attention to:
/// - (GameObjects with) GameObjectReferences
/// - (GameObjects with) ResourceReferences incl. Locators
/// - GameObjectGroups (and hierarchies thereof)
/// - GameObjectFolders (and hierarchies thereof)
/// - Pasting the same objects more than once</remarks>
public void Insert(object parent, object child)
{
if (!CanInsert(parent, child))
{
return;
}
var hierarchical = parent.AsAll <IHierarchical>();
// Extract node list from IDataObject
IEnumerable <object> items = Util.ConvertData(child, true);
DomNode parentRoot = null;
DomNode parentNode = parent.As <DomNode>();
if (parentNode != null)
{
parentRoot = parentNode.GetRoot();
}
List <DomNode> copyList = new List <DomNode>();
List <object> objectlist = new List <object>();
foreach (object item in items)
{
if (item.Is <IGameObject>() || item.Is <IGameObjectFolder>())
{
DomNode childNode = item.As <DomNode>();
DomNode childRoot = childNode.GetRoot();
if ((parentRoot != null && childRoot.Is <IGame>() && parentRoot != childRoot))
{
childNode.RemoveFromParent();
copyList.Add(childNode);
continue;
}
}
objectlist.Add(item);
}
if (copyList.Count > 0)
{
IEnumerable <DomNode> copies = DomNode.Copy(copyList);
// remvoe lock
foreach (DomNode copy in copies)
{
this.SetLocked(copy, false);
}
objectlist.AddRange(copies);
}
foreach (object obj in objectlist)
{
DomNode node = obj.As <DomNode>();
if (node != null)
{
node.InitializeExtensions();
}
}
List <DomNode> insertedNodes = new List <DomNode>();
foreach (object obj in objectlist)
{
object insertedObj = null;
bool inserted = false;
foreach (var h in hierarchical)
{
if (h.AddChild(obj))
{
inserted = true;
break;
}
}
if (inserted)
{
insertedObj = obj;
}
else
{
IResource res = obj as IResource;
var gob = m_resourceConverterService.Convert(res);
foreach (var h in hierarchical)
{
if (h.AddChild(gob))
{
inserted = true;
break;
}
}
if (inserted)
{
insertedObj = gob;
}
}
DomNode insertNode = Adapters.As <DomNode>(insertedObj);
if (insertNode != null)
{
insertedNodes.Add(insertNode);
}
}
IEnumerable <DomNode> rootDomNodes = DomNode.GetRoots(insertedNodes);
List <object> newSelection = new List <object>();
foreach (DomNode rootNode in rootDomNodes)
{
AdaptablePath <object> path = Util.AdaptDomPath(rootNode);
if (path.First.Is <IGame>() && (rootNode.Is <IGameObject>() || rootNode.Is <IGameObjectFolder>()))
{
newSelection.Add(path);
}
}
if (newSelection.Count > 0)
{
if (InTransaction)
{
m_savedSelection = new List <object>(MasterContext.Selection);
}
MasterContext.SetRange(newSelection);
}
}
public override void OnBeginDrag()
{
if (m_hitRegion == HitRegion.None)
{
return;
}
var selection = DesignView.Context.As <ISelectionContext>().Selection;
var transactionContext = DesignView.Context.As <ITransactionContext>();
NodeList.Clear();
m_isUniformScaling = false;
IEnumerable <DomNode> rootDomNodes = DomNode.GetRoots(selection.AsIEnumerable <DomNode>());
foreach (DomNode node in rootDomNodes)
{
ITransformable transNode = node.As <ITransformable>();
if (transNode == null || (transNode.TransformationType & TransformationTypes.Scale) == 0)
{
continue;
}
IVisible vn = node.As <IVisible>();
if (!vn.Visible)
{
continue;
}
ILockable lockable = node.As <ILockable>();
if (lockable.IsLocked)
{
continue;
}
// force uniform scaling if any node requires it
if ((transNode.TransformationType & TransformationTypes.UniformScale) == TransformationTypes.UniformScale)
{
m_isUniformScaling = true;
}
NodeList.Add(transNode);
IManipulatorNotify notifier = transNode.As <IManipulatorNotify>();
if (notifier != null)
{
notifier.OnBeginDrag();
}
}
// to compute offset use bounding box in local space.
Vec3F offset = Vec3F.ZeroVector;// 0.5f; // use bounding box in local space
switch (m_hitRegion)
{
case HitRegion.XAxis:
case HitRegion.YAxis:
case HitRegion.ZAxis:
offset = new Vec3F(-1, -1, -1);
break;
case HitRegion.NegXAxis:
case HitRegion.NegYAxis:
case HitRegion.NegZAxis:
offset = new Vec3F(1, 1, 1);
break;
default:
break;
}
m_originalScales = new Vec3F[NodeList.Count];
m_originalTranslations = new Vec3F[NodeList.Count];
m_pivotOffset = new Vec3F[NodeList.Count];
int k = 0;
foreach (ITransformable node in NodeList)
{
IBoundable boundable = node.As <IBoundable>();
Vec3F pivot = Vec3F.Mul(boundable.LocalBoundingBox.Radius, offset);
m_pivotOffset[k] = pivot;
m_originalScales[k] = node.Scale;
Matrix4F mtrx = TransformUtils.CalcTransform(
Vec3F.ZeroVector,
node.Rotation,
node.Scale,
pivot
);
m_originalTranslations[k] = node.Translation - mtrx.Translation;
k++;
}
if (NodeList.Count > 0)
{
transactionContext.Begin("Extend".Localize());
}
}
public ManipulatorActiveOperation(
string name, ISelectionContext selectionContext,
FilterDelegate filter,
bool duplicate)
{
TransactionContextList = new List <ITransactionContext>();
NodeList = new List <ITransformable>();
IsDuplicating = duplicate;
var selection = selectionContext.Selection;
IEnumerable <DomNode> rootDomNodes = DomNode.GetRoots(selection.AsIEnumerable <DomNode>());
SetupTransactionContexts(rootDomNodes);
if (duplicate)
{
List <DomNode> originals = new List <DomNode>();
foreach (DomNode node in rootDomNodes)
{
ITransformable transformable = node.As <ITransformable>();
if (!CanManipulate(transformable, filter))
{
continue;
}
originals.Add(node);
}
if (originals.Count > 0)
{
DomNode[] copies = DomNode.Copy(originals);
foreach (var t in TransactionContextList)
{
t.Begin(("Copy And" + name).Localize());
}
List <object> newSelection = new List <object>();
// re-parent copy
for (int i = 0; i < copies.Length; i++)
{
DomNode copy = copies[i];
DomNode original = originals[i];
ChildInfo chInfo = original.ChildInfo;
if (chInfo.IsList)
{
original.Parent.GetChildList(chInfo).Add(copy);
}
else
{
original.Parent.SetChild(chInfo, copy);
}
newSelection.Add(Util.AdaptDomPath(copy));
copy.InitializeExtensions();
}
selectionContext.SetRange(newSelection);
NodeList.AddRange(copies.AsIEnumerable <ITransformable>());
}
}
else
{
foreach (DomNode node in rootDomNodes)
{
ITransformable transformable = node.As <ITransformable>();
if (!CanManipulate(transformable, filter))
{
continue;
}
NodeList.Add(transformable);
}
if (NodeList.Count > 0)
{
foreach (var t in TransactionContextList)
{
t.Begin(name.Localize());
}
}
}
for (int k = 0; k < NodeList.Count; k++)
{
IManipulatorNotify notifier = NodeList[k].As <IManipulatorNotify>();
if (notifier != null)
{
notifier.OnBeginDrag();
}
}
}
// render the scene.
public override void Render()
{
bool skipRender =
SurfaceId == 0 ||
GameEngine.IsInError ||
Width == 0 ||
Height == 0 ||
DesignView.Context == null;
if (skipRender)
{
return;
}
m_clk.Start();
GameEngine.SetObjectProperty(swapChainId, SurfaceId, BkgColorPropId, DesignView.BackColor);
GameEngine.SetRenderState(RenderState);
GameEngine.Begin(SurfaceId, Camera.ViewMatrix, Camera.ProjectionMatrix);
IGame game = DesignView.Context.As <IGame>();
GridRenderer gridRender = game.Grid.Cast <GridRenderer>();
gridRender.Render(Camera);
GameEngine.RenderGame();
bool renderSelected = RenderState.DisplayBound == DisplayFlagModes.Selection ||
RenderState.DisplayCaption == DisplayFlagModes.Selection ||
RenderState.DisplayPivot == DisplayFlagModes.Selection;
if (renderSelected)
{
var selection = DesignView.Context.As <ISelectionContext>().Selection;
IEnumerable <DomNode> rootDomNodes = DomNode.GetRoots(selection.AsIEnumerable <DomNode>());
RenderProperties(rootDomNodes,
RenderState.DisplayCaption == DisplayFlagModes.Selection,
RenderState.DisplayBound == DisplayFlagModes.Selection,
RenderState.DisplayPivot == DisplayFlagModes.Selection);
}
RenderProperties(Items,
RenderState.DisplayCaption == DisplayFlagModes.Always,
RenderState.DisplayBound == DisplayFlagModes.Always,
RenderState.DisplayPivot == DisplayFlagModes.Always);
GameEngine.SetRendererFlag(BasicRendererFlags.Foreground | BasicRendererFlags.Lit);
if (DesignView.Manipulator != null)
{
DesignView.Manipulator.Render(this);
}
string str = string.Format("View Type: {0} time per frame-render call: {1:0.00} ms", ViewType, m_clk.Milliseconds);
GameEngine.DrawText2D(str, Util3D.CaptionFont, 1, 1, Color.White);
GameEngine.End();
if (IsPicking)
{// todo: use Directx to draw marque.
using (Graphics g = CreateGraphics())
{
Rectangle rect = MakeRect(FirstMousePoint, CurrentMousePoint);
if (rect.Width > 0 && rect.Height > 0)
{
g.DrawRectangle(s_marqueePen, rect);
}
}
}
}
