public ResizeHandles(Layer layer)
{
for (int i = 0; i < mHandles.Length; i++)
{
mHandles[i] = new LineCircle();
mHandles[i].Radius = RadiusAtNoZoom;
ShapeManager.Self.Add(mHandles[i], layer);
}
mXLine1 = new Line(null);
mXLine2 = new Line(null);
mXLine1.Name = "Resize Handle X Line 1";
mXLine2.Name = "Resize Handle X Line 2";
ShapeManager.Self.Add(mXLine1, layer);
ShapeManager.Self.Add(mXLine2, layer);
mOriginLine = new Line(null);
mOriginLine.Name = "Resize Handle Offset Line";
ShapeManager.Self.Add(mOriginLine, layer);
Visible = true;
UpdateToProperties();
}
public void Add(SolidRectangle solidRectangle, Layer layer = null)
{
if (layer == null)
{
layer = Renderer.LayersWritable[0];
}
mSolidRectangles.Add(solidRectangle);
layer.Add(solidRectangle);
}
public void Add(Text text, Layer layer)
{
if (layer == null)
{
layer = Renderer.LayersWritable[0];
}
mTexts.Add(text);
#if !TEST
layer.Add(text);
#endif
}
public void Add(LineRectangle lineRectangle, Layer layer)
{
if (layer == null)
{
layer = Renderer.LayersWritable[0];
}
mRectangles.Add(lineRectangle);
layer.Add(lineRectangle);
}
public void Add(Sprite sprite, Layer layer = null)
{
mSprites.Add(sprite);
#if !TEST
if (layer == null)
{
layer = Renderer.LayersWritable[0];
}
layer.Add(sprite);
#endif
}
public void BeginSpriteBatch(RenderStateVariables renderStates, Layer layer, BeginType beginType, Camera camera)
{
Matrix matrix = GetZoomAndMatrix(layer, camera);
SamplerState samplerState = GetSamplerState(renderStates);
bool isFullscreen = renderStates.ClipRectangle == null;
RasterizerState rasterizerState;
if (isFullscreen)
{
rasterizerState = scissorTestDisabled;
}
else
{
rasterizerState = scissorTestEnabled;
}
Rectangle scissorRectangle = new Rectangle();
if (rasterizerState.ScissorTestEnable)
{
scissorRectangle = renderStates.ClipRectangle.Value;
}
DepthStencilState depthStencilState = DepthStencilState.DepthRead;
if (beginType == BeginType.Begin)
{
mSpriteBatch.ReplaceRenderStates(SpriteSortMode.Immediate, renderStates.BlendState,
samplerState,
depthStencilState,
rasterizerState,
null, matrix,
scissorRectangle);
}
else
{
mSpriteBatch.PushRenderStates(SpriteSortMode.Immediate, renderStates.BlendState,
samplerState,
depthStencilState,
rasterizerState,
null, matrix,
scissorRectangle);
}
}
private void CreateLayer()
{
mLayer = Renderer.AddLayer();
mLayer.LayerCameraSettings = new LayerCameraSettings();
mLayer.LayerCameraSettings.IsInScreenSpace = true;
mLayer.Name = "Ruler Layer";
}
public void Draw(Layer layer)
{
Renderer.Draw(this, layer);
}
private RasterizerState GetRasterizerState(RenderStateVariables renderStates, Layer layer)
{
bool isFullscreen = layer.ScissorIpso == null;
if (isFullscreen)
{
return scissorTestDisabled;
}
else
{
return scissorTestEnabled;
}
}
private void BeginSpriteBatch(RenderStateVariables renderStates, Layer layer, BeginType beginType)
{
Matrix matrix = GetZoomAndMatrix(layer);
SamplerState samplerState = GetSamplerState(renderStates);
RasterizerState rasterizerState = GetRasterizerState(renderStates, layer);
Rectangle scissorRectangle = new Rectangle();
if(rasterizerState.ScissorTestEnable)
{
scissorRectangle = layer.GetScissorRectangleFor(mCamera);
}
DepthStencilState depthStencilState = DepthStencilState.DepthRead;
if (beginType == BeginType.Begin)
{
mSpriteBatch.Begin(SpriteSortMode.Immediate, renderStates.BlendState,
samplerState,
depthStencilState,
rasterizerState,
null, matrix,
scissorRectangle);
}
else
{
mSpriteBatch.Push(SpriteSortMode.Immediate, renderStates.BlendState,
samplerState,
depthStencilState,
rasterizerState,
null, matrix,
scissorRectangle);
}
mDrawCallsPerFrame++;
}
private void Render(IEnumerable<IRenderableIpso> whatToRender, SystemManagers managers, Layer layer)
{
foreach(var renderable in whatToRender)
{
var oldClip = mRenderStateVariables.ClipRectangle;
AdjustRenderStates(mRenderStateVariables, layer, renderable);
bool didClipChange = oldClip != mRenderStateVariables.ClipRectangle;
renderable.Render(spriteRenderer, managers);
if (RenderUsingHierarchy)
{
Render(renderable.Children, managers, layer);
}
if(didClipChange)
{
mRenderStateVariables.ClipRectangle = oldClip;
spriteRenderer.BeginSpriteBatch(mRenderStateVariables, layer, BeginType.Begin, mCamera);
}
}
}
private void AddChildren(SystemManagers managers, Layer layer)
{
// In a simple situation we'd just loop through the
// ContainedElements and add them to the manager. However,
// this means that the container will dictate the Layer that
// its children reside on. This is not what we want if we have
// two children, one of which is attached to the other, and the parent
// instance clips its children. Therefore, we should make sure that we're
// only adding direct children and letting instances handle their own children
if (this.ElementSave != null && this.ElementSave is ScreenSave)
{
//Recursively add children to the managers
foreach (var child in this.mWhatThisContains)
{
// July 27, 2014
// Is this an unnecessary check?
// if (child is GraphicalUiElement)
{
// December 1, 2014
// I think that when we
// add a screen we should
// add all of the children of
// the screen. There's nothing
// "above" that.
if (child.Parent == null || child.Parent == this)
{
(child as GraphicalUiElement).AddToManagers(managers, layer);
}
else
{
child.mManagers = this.mManagers;
child.CustomAddToManagers();
child.CustomAddChildren();
}
}
}
}
else if (this.Children != null)
{
foreach (var child in this.Children)
{
if (child is GraphicalUiElement)
{
var childGue = child as GraphicalUiElement;
if (child.Parent == null || child.Parent == this)
{
childGue.AddToManagers(managers, layer);
}
else
{
childGue.mManagers = this.mManagers;
childGue.CustomAddToManagers();
childGue.CustomAddChildren();
}
}
}
// If a Component contains a child and that child is parented to the screen bounds then we should still add it
foreach (var child in this.mWhatThisContains)
{
var childGue = child as GraphicalUiElement;
// We'll check if this child has a parent, and if that parent isn't part of this component. If not, then
// we'll add it
if (child.Parent != null && this.mWhatThisContains.Contains(child.Parent) == false)
{
childGue.AddToManagers(managers, layer);
}
else
{
childGue.mManagers = this.mManagers;
childGue.CustomAddToManagers();
childGue.CustomAddChildren();
}
}
}
}
public void Add(NineSlice nineSlice, Layer layer = null)
{
mNineSlices.Add(nineSlice);
#if !TEST
if (layer == null)
{
layer = Renderer.LayersWritable[0];
}
layer.Add(nineSlice);
#endif
}
public Layer AddLayer()
{
Layer layer = new Layer();
mLayers.Add(layer);
return layer;
}
public void AddLayer(SortableLayer sortableLayer, Layer masterLayer)
{
if (masterLayer == null)
{
masterLayer = LayersWritable[0];
}
masterLayer.Add(sortableLayer);
}
private void CreateLayer()
{
mLayer = mManagers.Renderer.AddLayer();
mLayer.LayerCameraSettings = new LayerCameraSettings();
mLayer.LayerCameraSettings.IsInScreenSpace = true;
}
public void MoveToLayer(Layer layer)
{
var layerToRemoveFrom = mLayer;
if (mLayer == null && mManagers != null)
{
layerToRemoveFrom = mManagers.Renderer.Layers[0];
}
var layerToAddTo = layer;
if (layerToAddTo == null)
{
layerToAddTo = mManagers.Renderer.Layers[0];
}
//if (mSortableLayer != null)
//{
// // all renderables are part of the mSortableLayer, so we
// // just move the mSortableLayer and everything comes along with it:
// mManagers.Renderer.RemoveLayer(mSortableLayer);
// mManagers.Renderer.AddLayer(mSortableLayer, layer);
//}
//else
{
// This may be a Screen
if (mContainedObjectAsIpso != null)
{
if(layerToRemoveFrom != null)
{
layerToRemoveFrom.Remove(mContainedObjectAsIpso);
}
layerToAddTo.Add(mContainedObjectAsIpso);
}
// We don't want to move the children to a layer, because the children
// are drawn hierarchically
//foreach (var contained in this.mWhatThisContains)
//{
// contained.MoveToLayer(layer);
//}
}
}
private void AddContainedRenderableToManagers(SystemManagers managers, Layer layer)
{
// This may be a Screen
if (mContainedObjectAsIpso != null)
{
if (mContainedObjectAsIpso is Sprite)
{
managers.SpriteManager.Add(mContainedObjectAsIpso as Sprite, layer);
}
else if (mContainedObjectAsIpso is NineSlice)
{
managers.SpriteManager.Add(mContainedObjectAsIpso as NineSlice, layer);
}
else if (mContainedObjectAsIpso is LineRectangle)
{
managers.ShapeManager.Add(mContainedObjectAsIpso as LineRectangle, layer);
}
else if (mContainedObjectAsIpso is SolidRectangle)
{
managers.ShapeManager.Add(mContainedObjectAsIpso as SolidRectangle, layer);
}
else if (mContainedObjectAsIpso is Text)
{
managers.TextManager.Add(mContainedObjectAsIpso as Text, layer);
}
else if (mContainedObjectAsIpso is LineCircle)
{
managers.ShapeManager.Add(mContainedObjectAsIpso as LineCircle, layer);
}
else
{
throw new NotImplementedException();
}
}
}
public GraphicalOutline(Layer uiLayer)
{
SelectionBorder = 0;
mUiLayer = uiLayer;
}
public void Add(LineCircle lineCircle, Layer layer)
{
mCircles.Add(lineCircle);
if (layer == null)
{
layer = Renderer.LayersWritable[0];
}
layer.Add(lineCircle);
}
private Matrix GetZoomAndMatrix(Layer layer, Camera camera)
{
Matrix matrix;
if (layer.LayerCameraSettings != null)
{
if (layer.LayerCameraSettings.IsInScreenSpace)
{
float zoom = 1;
if (layer.LayerCameraSettings.Zoom.HasValue)
{
zoom = layer.LayerCameraSettings.Zoom.Value;
}
matrix = Matrix.CreateScale(zoom);
CurrentZoom = zoom;
}
else
{
float zoom = camera.Zoom;
if (layer.LayerCameraSettings.Zoom.HasValue)
{
zoom = layer.LayerCameraSettings.Zoom.Value;
}
matrix = Camera.GetTransformationMatirx(camera.X, camera.Y, zoom, camera.ClientWidth, camera.ClientHeight);
CurrentZoom = zoom;
}
}
else
{
matrix = camera.GetTransformationMatrix();
CurrentZoom = camera.Zoom;
}
return matrix;
}
private void AdjustRenderStates(RenderStateVariables renderState, Layer layer, IRenderableIpso renderable)
{
BlendState renderBlendState = renderable.BlendState;
bool wrap = renderable.Wrap;
bool shouldResetStates = false;
if (renderBlendState == null)
{
renderBlendState = BlendState.NonPremultiplied;
}
if (renderState.BlendState != renderBlendState)
{
renderState.BlendState = renderable.BlendState;
shouldResetStates = true;
}
if (renderState.Wrap != wrap)
{
renderState.Wrap = wrap;
shouldResetStates = true;
}
if (renderable.ClipsChildren)
{
Rectangle clipRectangle = GetScissorRectangleFor(Camera, renderable);
if (renderState.ClipRectangle == null || clipRectangle != renderState.ClipRectangle.Value)
{
//todo: Don't just overwrite it, constrain this rect to the existing one, if it's not null:
var adjustedRectangle = clipRectangle;
if (renderState.ClipRectangle != null)
{
adjustedRectangle = ConstrainRectangle(clipRectangle, renderState.ClipRectangle.Value);
}
renderState.ClipRectangle = adjustedRectangle;
shouldResetStates = true;
}
}
if (shouldResetStates)
{
spriteRenderer.BeginSpriteBatch(renderState, layer, BeginType.Begin, mCamera);
}
}
public void Draw(SystemManagers managers, Layer layer)
{
// So that 2 controls don't render at the same time.
lock (LockObject)
{
mCamera.UpdateClient();
var oldSampler = GraphicsDevice.SamplerStates[0];
mRenderStateVariables.BlendState = BlendState.NonPremultiplied;
mRenderStateVariables.Wrap = false;
RenderLayer(managers, layer);
if (oldSampler != null)
{
GraphicsDevice.SamplerStates[0] = oldSampler;
}
}
}
public virtual void AddToManagers(SystemManagers managers, Layer layer)
{
#if DEBUG
if (managers == null)
{
throw new ArgumentNullException("managers cannot be null");
}
#endif
// If mManagers isn't null, it's already been added
if (mManagers == null)
{
mLayer = layer;
mManagers = managers;
AddContainedRenderableToManagers(managers, layer);
// Custom should be called before children have their Custom called
CustomAddToManagers();
// that means this is a screen, so the children need to be added directly to managers
if (this.mContainedObjectAsIpso == null)
{
AddChildren(managers, layer);
}
else
{
CustomAddChildren();
}
}
}
public void Add(Line line, Layer layer = null)
{
if(layer == null)
{
layer = Renderer.LayersWritable[0];
}
mLines.Add(line);
layer.Add(line);
}
public void RemoveLayer(Layer layer)
{
mLayers.Remove(layer);
}
internal void RenderLayer(SystemManagers managers, Layer layer)
{
// If the Layer's clip region has no width or height, then let's
// skip over rendering it, otherwise XNA crashes:
var clipRegion = layer.GetScissorRectangleFor(managers.Renderer.Camera);
if(clipRegion.Width != 0 && clipRegion.Height != 0)
{
BeginSpriteBatch(mRenderStateVariables, layer, BeginType.Push);
layer.SortRenderables();
foreach (IRenderable renderable in layer.RenderablesWriteable)
{
AdjustRenderStates(mRenderStateVariables, layer, renderable);
renderable.Render(mSpriteBatch.SpriteBatch, managers);
}
mSpriteBatch.Pop();
}
}
private void AdjustRenderStates(RenderStateVariables renderState, Layer layer, IRenderable renderable)
{
BlendState renderBlendState = renderable.BlendState;
bool wrap = renderable.Wrap;
bool shouldResetStates = false;
if (renderBlendState == null)
{
renderBlendState = BlendState.NonPremultiplied;
}
if (renderState.BlendState != renderBlendState)
{
renderState.BlendState = renderable.BlendState;
shouldResetStates = true;
}
if (renderState.Wrap != wrap)
{
renderState.Wrap = wrap;
shouldResetStates = true;
}
if (shouldResetStates)
{
BeginSpriteBatch(renderState, layer, BeginType.Begin);
}
}
public void Add(LineGrid lineGrid, Layer layer = null)
{
if (layer == null)
{
layer = Renderer.LayersWritable[0];
}
mGrids.Add(lineGrid);
layer.Add(lineGrid);
}
internal void RenderLayer(SystemManagers managers, Layer layer, bool prerender = true)
{
//////////////////Early Out////////////////////////////////
if (layer.Renderables.Count == 0)
{
return;
}
///////////////End Early Out///////////////////////////////
if (prerender)
{
PreRender(layer.Renderables);
}
spriteRenderer.BeginSpriteBatch(mRenderStateVariables, layer, BeginType.Push, mCamera);
layer.SortRenderables();
Render(layer.Renderables, managers, layer);
spriteRenderer.EndSpriteBatch();
}