public GameDebugTree(IGame game, IRenderLayer layer, InspectorPanel inspector)
{
_game = game;
_inspector = inspector;
_addedObjects = new AGSConcurrentHashSet <string>(100, false);
_layer = layer;
}
public ITreeNodeView CreateNode(ITreeStringNode item, IRenderLayer layer)
{
var view = _provider.CreateNode(item, layer);
var node = item as IInspectorTreeNode;
if (node == null)
{
return(view);
}
var layout = view.HorizontalPanel.GetComponent <IStackLayoutComponent>();
layout.AbsoluteSpacing = 10f;
int nodeId = Interlocked.Increment(ref _nextNodeId);
var itemTextId = (item.Text ?? "") + "_" + nodeId;
node.Editor.AddEditorUI("InspectorEditor_" + itemTextId, view, node.Property);
var propertyChanged = node.Property.Object as INotifyPropertyChanged;
if (propertyChanged != null)
{
propertyChanged.PropertyChanged += (sender, e) =>
{
if (e.PropertyName != node.Property.Name)
{
return;
}
node.Property.Refresh();
node.Editor.RefreshUI();
};
}
return(view);
}
public ITreeNodeView CreateNode(ITreeStringNode item, IRenderLayer layer)
{
var buttonWidth = 20f;
var buttonHeight = 60f;
var idle = new ButtonAnimation(new EmptyImage(buttonWidth, buttonHeight));
idle.Tint = Colors.Black;
var hovered = new ButtonAnimation(new EmptyImage(buttonWidth, buttonHeight));
hovered.Tint = Colors.Yellow;
var pushed = new ButtonAnimation(new EmptyImage(buttonWidth, buttonHeight));
pushed.Tint = Colors.DarkSlateBlue;
int nodeId = Interlocked.Increment(ref _nextNodeId);
var itemTextId = (item.Text ?? "") + "_" + nodeId;
var parentPanel = _factory.UI.GetPanel("TreeNodeParentPanel_" + itemTextId, 0f, 0f, 0f, 0f, addToUi: false);
var horizontalPanel = _factory.UI.GetPanel("TreeNodeHorizontalPanel_" + itemTextId, 0f, 0f, 0f, 0f, parentPanel, false);
var expandButton = _factory.UI.GetButton("ExpandButton_" + itemTextId, idle, hovered, pushed, 0f, 0f, horizontalPanel, addToUi: false);
var label = _factory.UI.GetLabel("TreeNodeLabel_" + itemTextId, item.Text, 0f, 0f, buttonWidth, 0f, horizontalPanel,
new AGSTextConfig(paddingTop: 0f, paddingBottom: 0f, autoFit: AutoFit.LabelShouldFitText), addToUi: false);
var verticalPanel = _factory.UI.GetPanel("TreeNodeVerticalPanel_" + itemTextId, 0f, 0f, 0f, 0f, parentPanel, false);
horizontalPanel.RenderLayer = layer;
verticalPanel.RenderLayer = layer;
parentPanel.RenderLayer = layer;
expandButton.RenderLayer = layer;
label.RenderLayer = layer;
expandButton.Z = label.Z - 1;
horizontalPanel.Tint = Colors.Transparent;
parentPanel.Tint = Colors.Transparent;
verticalPanel.Tint = Colors.Transparent;
expandButton.Tint = Colors.Transparent;
expandButton.TextBackgroundVisible = false;
label.Tint = Colors.Transparent;
label.TextBackgroundVisible = false;
label.Enabled = true;
expandButton.IsPixelPerfect = false;
horizontalPanel.AddComponent <IBoundingBoxWithChildrenComponent>();
var layout = horizontalPanel.AddComponent <IStackLayoutComponent>();
layout.RelativeSpacing = 1f;
layout.Direction = LayoutDirection.Horizontal;
layout.StartLayout();
PropertyChangedEventHandler onPropertyChanged = (sender, e) =>
{
if (e.PropertyName != nameof(ITreeStringNode.Text))
{
return;
}
label.Text = item.Text;
};
item.PropertyChanged += onPropertyChanged;
label.OnDisposed(() => item.PropertyChanged -= onPropertyChanged);
var nodeView = new AGSTreeNodeView(label, expandButton, parentPanel, verticalPanel, horizontalPanel);
return(nodeView);
}
private IObject getObject(int?renderLayerZ, float z, float spriteZ, IObject parent)
{
Mock <ISprite> sprite = new Mock <ISprite> ();
sprite.Setup(s => s.Z).Returns(spriteZ);
Mock <ITreeNode <IObject> > tree = new Mock <ITreeNode <IObject> > ();
tree.Setup(t => t.Parent).Returns(parent);
IRenderLayer layer = null;
if (renderLayerZ.HasValue)
{
Mock <IRenderLayer> layerMock = new Mock <IRenderLayer> ();
layerMock.Setup(l => l.Z).Returns(renderLayerZ.Value);
layer = layerMock.Object;
}
Mock <IObject> obj = new Mock <IObject> ();
obj.Setup(o => o.Z).Returns(z);
obj.Setup(o => o.CurrentSprite).Returns(sprite.Object);
obj.Setup(o => o.TreeNode).Returns(tree.Object);
obj.Setup(o => o.RenderLayer).Returns(layer);
obj.Setup(o => o.Properties).Returns(new AGSCustomProperties());
tree.Setup(t => t.Node).Returns(obj.Object);
return(obj.Object);
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
public ParticleEmitter(IRenderLayer <TInfoType> renderLayer, Type particleType, ParticleController <TInfoType> controller, string szAssetName, Vector3 v3Position, int nMaxSprites)
{
m_RenderLayer = renderLayer;
m_Particles = new List <IParticle>(nMaxSprites);
m_freeParticleList = new Queue <IParticle>(nMaxSprites);
SaveSerializationData("MaxSprites", nMaxSprites);
SaveSerializationData("AssetName", szAssetName);
SaveSerializationData("ParticleType", particleType);
ParticleController = controller;
m_bActive = false;
m_bContinuosEmission = false;
m_bAllowGeneration = false;
Position = v3Position;
Enabled = true;
EngineServices.GetSystem <IGameSystems>().Components.Add(this);
for (int nCounter = 0; nCounter < nMaxSprites; ++nCounter)
{
IParticle particle = Activator.CreateInstance(particleType, new object[] { m_RenderLayer, szAssetName, Position, Vector3.Zero, 0, 0, false }) as IParticle;
particle.ParticleDead += DeadParticle_Event;
m_Particles.Add(particle);
m_freeParticleList.Enqueue(particle);
}
}
public GameDebugDisplayList(IGame editor, IGame game, IRenderLayer layer)
{
_game = game;
_editor = editor;
_layer = layer;
game.RenderPipeline.OnBeforeProcessingDisplayList.Subscribe(onBeforeProcessingDisplayList);
}
public Outro(IRenderView renderView, OutroData outroData, Font outroFont, Font outroFontLarge, Action finishAction)
{
this.finishAction = finishAction;
this.outroData = outroData;
this.outroFont = outroFont;
this.outroFontLarge = outroFontLarge;
this.renderView = renderView;
renderLayer = renderView.GetLayer(Layer.OutroGraphics);
picture = renderView.SpriteFactory.Create(160, 128, true, 1) as ILayerSprite;
picture.Layer = renderLayer;
picture.PaletteIndex = paletteOffset = renderView.GraphicProvider.FirstOutroPaletteIndex;
picture.Visible = false;
renderTextFactory = renderView.RenderTextFactory;
textProcessor = renderView.TextProcessor;
fadeArea = renderView.ColoredRectFactory.Create(Global.VirtualScreenWidth, Global.VirtualScreenHeight, Color.Black, 255);
fadeArea.Layer = renderView.GetLayer(Layer.Effects);
fadeArea.X = 0;
fadeArea.Y = 0;
fadeArea.Visible = false;
graphicInfos = outroData.GraphicInfos;
EnsureTextures(renderView, outroData, outroFont, outroFontLarge);
}
public InspectorPanel(AGSEditor editor, IRenderLayer layer, ActionManager actions, string idPrefix = "")
{
_idPrefix = idPrefix;
_editor = editor;
_actions = actions;
_layer = layer;
}
public Matrix4 GetMatrix(IRenderLayer renderLayer)
{
renderLayer = renderLayer ?? _dummyLayer;
var matrixProvider = _viewports.GetOrAdd(renderLayer.Z, _createMatrixFunc);
return(matrixProvider.GetMatrix(this, renderLayer.ParallaxSpeed));
}
public GameDebugView(IGame game)
{
_game = game;
_layer = new AGSRenderLayer(AGSLayers.UI.Z - 1, independentResolution: new Size(1800, 1200));
_inspector = new InspectorPanel(game, _layer);
_debugTree = new GameDebugTree(game, _layer, _inspector);
_displayList = new GameDebugDisplayList(game, _layer);
}
public void Dispose()
{
_canvas = null;
_layer = null;
if (_timer != null)
{
_timer.Dispose();
}
}
public GameDebugTree(AGSEditor editor, IRenderLayer layer, InspectorPanel inspector)
{
_editor = editor;
_inspector = inspector;
_entitiesToNodes = new ConcurrentDictionary <string, ITreeStringNode>();
_addedObjects = new AGSConcurrentHashSet <string>(100, false);
_roomSubscribers = new List <RoomSubscriber>(20);
_layer = layer;
}
public RenderFlag(Flag flag, IRenderLayer renderLayer, ISpriteFactory spriteFactory, DataSource dataSource)
: base(renderLayer, spriteFactory, dataSource)
{
this.flag = flag;
this.spriteFactory = spriteFactory;
Initialize();
InitOffsets(dataSource);
}
public static void UnRegisterLayer(IRenderLayer renderer)
{
for (int i = 0; i < MAX_LAYERS; ++i)
{
if (_layers[i] == renderer)
{
_layers[i] = null;
}
}
}
public static void UnRegisterLayer(IRenderLayer renderer)
{
for (int i = 0; i < MAX_LAYERS; ++i)
{
if (_layers[i] == renderer)
{
_layers[i] = null;
}
}
}
public RenderRoadSegment(Map map, MapPos position, Direction direction,
IRenderLayer renderLayer, ISpriteFactory spriteFactory, DataSource dataSource)
: base(renderLayer, spriteFactory, dataSource)
{
this.map = map;
this.position = position;
this.direction = direction;
Initialize();
}
public RenderMapObject(Map.Object objectType, IRenderLayer renderLayer, ISpriteFactory spriteFactory, DataSource dataSource)
: base(renderLayer, spriteFactory, dataSource)
{
this.objectType = objectType;
this.dataSource = dataSource;
Initialize();
InitOffsets(dataSource);
}
readonly List <SpriteInfo> characterSpritesNew = new List <SpriteInfo>(); // shared by all texts
public TextRenderer(IRenderView renderView)
{
spriteFactory = renderView.SpriteFactory;
layerLegacy = renderView.GetLayer(Layer.Gui);
layerNewFont = renderView.GetLayer(Layer.GuiFont);
// original size is 8x8 pixels
characterSizeLegacy = new Size(8, 8);
// new font uses a different size
characterSizeNew = new Size(Global.UIFontCharacterWidth, Global.UIFontCharacterHeight);
}
public GameDebugView(IGame game, KeyboardBindings keyboardBindings)
{
_game = game;
_keyboardBindings = keyboardBindings;
_layer = new AGSRenderLayer(AGSLayers.UI.Z - 1, independentResolution: new Size(1800, 1200));
_inspector = new InspectorPanel(game, _layer);
_debugTree = new GameDebugTree(game, _layer, _inspector);
_displayList = new GameDebugDisplayList(game, _layer);
_input = game.Input;
keyboardBindings.OnKeyboardShortcutPressed.Subscribe(onShortcutKeyPressed);
}
private void RenderMesh(IRenderLayer layer)
{
if (layer.Indices.Size == 3)
{
meshRenderer.RenderElements(layer.Points.Data, layer.Indices.Data, 3, null);
}
else
{
meshRenderer.RenderEdges(layer.Points.Data, layer.Indices.Data, Context.ColorManager.Line);
}
}
private void RenderFilledMesh(IRenderLayer layer)
{
if (layer.Partition != null)
{
meshRenderer.RenderElements(layer.Points.Data, layer.Indices.Data, 3, layer.Partition.Data);
}
else if (layer.Colors != null)
{
functionRenderer.Render(layer);
}
}
public RenderText(Rect virtualScreen, Dictionary <byte, Position> glyphTextureMapping,
IRenderLayer layer, IText text, TextColor textColor, bool shadow)
: base(text.MaxLineSize * CharacterWidth, text.LineCount * CharacterHeight - (LineHeight - CharacterHeight), virtualScreen)
{
this.glyphTextureMapping = glyphTextureMapping;
bounds = virtualScreen;
Layer = layer;
Text = text;
TextColor = textColor;
Shadow = shadow;
}
private void RenderFilledMesh(IRenderLayer layer)
{
if (layer.Partition != null)
{
meshRenderer.RenderElements(layer.Points.Data, layer.Indices.Data, 3, layer.Partition.Data);
}
else if (layer.Colors != null)
{
functionRenderer.Render(layer);
}
}
private void RenderMesh(IRenderLayer layer)
{
if (layer.Indices.Size == 3)
{
meshRenderer.RenderElements(layer.Points.Data, layer.Indices.Data, 3, null);
}
else
{
meshRenderer.RenderEdges(layer.Points.Data, layer.Indices.Data, Context.ColorManager.Line);
}
}
public Player2D(Game game, IRenderLayer layer, Player player, RenderMap2D map,
ISpriteFactory spriteFactory, Position startPosition,
IMapManager mapManager)
: base(game, layer, TextureAtlasManager.Instance.GetOrCreate(Layer.Characters),
spriteFactory, game.GetPlayerAnimationInfo, map, startPosition,
game.GetPlayerPaletteIndex, game.GetPlayerDrawOffset)
{
this.game = game;
this.player = player;
this.mapManager = mapManager;
}
public GameDebugView(AGSEditor editor, KeyboardBindings keyboardBindings, ActionManager actions, GameToolbar toolbar)
{
_toolbar = toolbar;
_actions = actions;
_editor = editor;
_layer = new AGSRenderLayer(AGSLayers.UI.Z - 1, independentResolution: _resolution);
_inspector = new InspectorPanel(editor, _layer, actions);
Tree = new GameDebugTree(editor, _layer, _inspector);
_displayList = new GameDebugDisplayList(editor.Editor, editor.Game, _layer);
_input = editor.Editor.Input;
keyboardBindings.OnKeyboardShortcutPressed.Subscribe(onShortcutKeyPressed);
}
public void Render(IRenderLayer layer)
{
Create(layer);
var hdc = RenderTarget.GetHdc();
NativeMethods.GradientFill(hdc,
points, (uint)points.Length, elements, (uint)elements.Length,
GradientFillMode.GRADIENT_FILL_TRIANGLE);
RenderTarget.ReleaseHdc(hdc);
}
private void RenderVoronoi(IRenderLayer layer)
{
if (RenderManager.VORONOI_DEBUG)
{
meshRenderer.RenderEdges(layer.Points.Data, layer.Indices.Data, Pens.Purple);
meshRenderer.RenderPoints(layer.Points.Data, layer.Points.Size, 0, layer.Count, Brushes.Red);
}
else
{
meshRenderer.RenderEdges(layer.Points.Data, layer.Indices.Data, Context.ColorManager.VoronoiLine);
}
}
public void AttachToRenderLayer(IRenderLayer renderLayerTiles, IRenderLayer renderLayerWaves)
{
foreach (var triangle in triangles)
{
triangle.Layer = renderLayerTiles;
}
foreach (var wave in waves)
{
wave.Layer = renderLayerWaves;
}
}
public MethodWizard(MethodInfo method, HashSet <string> hideProperties, Dictionary <string, object> overrideDefaults,
Action <IPanel> addUiExternal, AGSEditor editor, Func <Dictionary <string, object>, Task <bool> > validate)
{
_method = method;
_editor = editor;
_validate = validate;
_layer = new AGSRenderLayer(AGSLayers.UI.Z - 1);
_hideProperties = hideProperties;
_overrideDefaults = overrideDefaults;
_addUiExternal = addUiExternal;
_taskCompletionSource = new TaskCompletionSource <Dictionary <string, object> >();
}
public void Render(IRenderLayer layer)
{
Create(layer);
var hdc = RenderTarget.GetHdc();
NativeMethods.GradientFill(hdc,
points, (uint)points.Length, elements, (uint)elements.Length,
GradientFillMode.GRADIENT_FILL_TRIANGLE);
RenderTarget.ReleaseHdc(hdc);
}
public override bool OnMessage(GUIMessage message)
{
switch (message.Message)
{
case GUIMessage.MessageType.GUI_MSG_WINDOW_INIT:
{
_prevLayer = GUILayerManager.GetLayer(GUILayerManager.LayerType.Dialog);
_prevOverlay = GUIGraphicsContext.Overlay;
if (GUIGraphicsContext.VideoRenderer != GUIGraphicsContext.VideoRendererType.madVR)
{
GUIGraphicsContext.Overlay = base.IsOverlayAllowed;
}
GUILayerManager.RegisterLayer(this, GUILayerManager.LayerType.Dialog);
GUIPropertyManager.SetProperty("#currentmoduleid", Convert.ToString(GUIWindowManager.ActiveWindow));
GUIPropertyManager.SetProperty("#currentmodule", GetModuleName());
Log.Debug("DialogWindow: {0} init", this.ToString());
GUIMessage msg = new GUIMessage(GUIMessage.MessageType.GUI_MSG_SETFOCUS, GetID, 0, _defaultControlId, 0, 0,
null);
OnMessage(msg);
OnPageLoad();
return(true);
}
case GUIMessage.MessageType.GUI_MSG_WINDOW_DEINIT:
{
//base.OnMessage(message);
// TODO: Establishes a circular loop
// OnPageDestroy(_parentWindowID);
OnPageDestroy(GetID); // mantis 2996: Dialog windows do not animate when closed
_running = false;
_parentWindowID = 0;
_parentWindow = null;
GUIGraphicsContext.Overlay = _prevOverlay;
Dispose();
DeInitControls();
GUILayerManager.UnRegisterLayer(this);
GUILayerManager.RegisterLayer(_prevLayer, GUILayerManager.LayerType.Dialog);
_prevLayer = null;
return(true);
}
}
return(base.OnMessage(message));
}
public void Remove(ILayerItem item)
{
if (item is ILayerItemGroup)
{
foreach (ILayerItem it in (item as ILayerItemGroup).Items)
{
this.Items.Remove(it);
}
if (item.Tag is IVectorHostLayer)
{
IVectorHostLayer hostLayer = item.Tag as IVectorHostLayer;
IMap map = hostLayer.Map as IMap;
if (map.LayerContainer.Layers != null && map.LayerContainer.Layers.Count() != 0)
{
foreach (CodeCell.AgileMap.Core.ILayer it in map.LayerContainer.Layers)
{
map.LayerContainer.Remove(it);
}
}
Update();
}
}
if (item.Tag is GeoDo.RSS.Core.DrawEngine.IRenderLayer)
{
if (item.Tag is GeoDo.RSS.Core.DrawEngine.IRasterLayer)
{
return;
}
else if (item.Tag is GeoDo.RSS.Core.DrawEngine.IVectorLayer)
{
IRenderLayer layer = item.Tag as IRenderLayer;
_viewer.Canvas.LayerContainer.Layers.Remove(item.Tag as IRenderLayer);
this.Items.Remove(item);
return;
}
}
if (item.Tag is CodeCell.AgileMap.Core.ILayer)
{
foreach (GeoDo.RSS.Core.DrawEngine.ILayer layer in _viewer.Canvas.LayerContainer.Layers)
{
if (layer is IVectorHostLayer)
{
IVectorHostLayer hostLayer = layer as IVectorHostLayer;
IMap map = hostLayer.Map as IMap;
map.LayerContainer.Remove(item.Tag as CodeCell.AgileMap.Core.ILayer);
Update();
}
}
this.Items.Remove(item);
}
RefreshViewer();
}
//-------------------------------------------------------------------------------
//-------------------------------------------------------------------------------
private void Init(IRenderLayer <SpriteInfo> spriteSystem, bool bStartActive)
{
//This could be done externally maybe.
m_system = spriteSystem;
Debug.Assert(m_system != null, "A SpriteSystem hasn't been registered with the services");
#warning There is a bug here because we cant assert that this is a spriteLayer due to the text sprite inheriting from this??!!!!
if (bStartActive)
{
m_system.RegisterSprite(this);
}
m_bIsActive = bStartActive;
}
public override bool OnMessage(GUIMessage message)
{
switch (message.Message)
{
case GUIMessage.MessageType.GUI_MSG_WINDOW_INIT:
{
_prevLayer = GUILayerManager.GetLayer(GUILayerManager.LayerType.Dialog);
_prevOverlay = GUIGraphicsContext.Overlay;
GUIGraphicsContext.Overlay = base.IsOverlayAllowed;
GUILayerManager.RegisterLayer(this, GUILayerManager.LayerType.Dialog);
GUIPropertyManager.SetProperty("#currentmoduleid", Convert.ToString(GUIWindowManager.ActiveWindow));
GUIPropertyManager.SetProperty("#currentmodule", GetModuleName());
Log.Debug("DialogWindow: {0} init", this.ToString());
GUIMessage msg = new GUIMessage(GUIMessage.MessageType.GUI_MSG_SETFOCUS, GetID, 0, _defaultControlId, 0, 0,
null);
OnMessage(msg);
OnPageLoad();
return true;
}
case GUIMessage.MessageType.GUI_MSG_WINDOW_DEINIT:
{
//base.OnMessage(message);
// TODO: Establishes a circular loop
// OnPageDestroy(_parentWindowID);
OnPageDestroy(GetID); // mantis 2996: Dialog windows do not animate when closed
_running = false;
_parentWindowID = 0;
_parentWindow = null;
GUIGraphicsContext.Overlay = _prevOverlay;
Dispose();
DeInitControls();
GUILayerManager.UnRegisterLayer(this);
GUILayerManager.RegisterLayer(_prevLayer, GUILayerManager.LayerType.Dialog);
_prevLayer = null;
return true;
}
}
return base.OnMessage(message);
}
public void AddLayer(IRenderLayer layer)
{
_layers.Add(layer);
}
/// <summary>Remove a Scene from the Renderer.</summary>
/// <returns>True if the Scene was in the Renderer, otherwise false.</returns>
public bool RemoveLayer(IRenderLayer layer)
{
return _layers.Remove(layer);
}
public static void RegisterLayer(IRenderLayer renderer, LayerType zOrder)
{
_layers[(int)zOrder] = renderer;
}
private void RenderPolygon(IRenderLayer layer)
{
meshRenderer.RenderSegments(layer.Points.Data, layer.Indices.Data, Context.ColorManager.Segment);
}
private void RenderPoints(IRenderLayer layer)
{
meshRenderer.RenderPoints(layer.Points.Data, layer.Points.Size, layer.Count);
}
private void Create(IRenderLayer layer)
{
var zoom = Context.Zoom;
var colors = layer.Colors.Data;
int length = colors.Length;
int size = layer.Points.Size;
var data = layer.Points.Data;
if (length != data.Length / size)
{
throw new Exception();
}
this.points = new TriVertex[length];
TriVertex vertex;
Color color;
PointF p = new PointF((float)data[0], (float)data[1]);
zoom.WorldToScreen(ref p);
// Get correction distance
float dx = (p.X - (int)p.X) * 2.0f;
float dy = (p.Y - (int)p.Y) * 2.0f;
// Create vertices.
for (int i = 0; i < length; i++)
{
p.X = (float)data[size * i];
p.Y = (float)data[size * i + 1];
zoom.WorldToScreen(ref p);
color = colors[i];
vertex = new TriVertex();
vertex.x = (int)(p.X + dx);
vertex.y = (int)(p.Y + dy);
vertex.Red = (ushort)(color.R << 8);
vertex.Green = (ushort)(color.G << 8);
vertex.Blue = (ushort)(color.B << 8);
vertex.Alpha = (ushort)(color.A << 8);
this.points[i] = vertex;
}
var triangles = layer.Indices.Data;
length = triangles.Length / 3;
this.elements = new GradientTriangle[length];
GradientTriangle e;
// Create triangles.
for (int i = 0; i < length; i++)
{
e = new GradientTriangle();
e.Vertex1 = (uint)triangles[3 * i];
e.Vertex2 = (uint)triangles[3 * i + 1];
e.Vertex3 = (uint)triangles[3 * i + 2];
this.elements[i] = e;
}
}
private void RenderVoronoi(IRenderLayer layer)
{
if (RenderManager.VORONOI_DEBUG)
{
meshRenderer.RenderEdges(layer.Points.Data, layer.Indices.Data, Pens.Purple);
meshRenderer.RenderPoints(layer.Points.Data, layer.Points.Size, 0, layer.Count, Brushes.Red);
}
else
{
meshRenderer.RenderEdges(layer.Points.Data, layer.Indices.Data, Context.ColorManager.VoronoiLine);
}
}
public void DrawPortalAll(IRenderLayer layer)
{
ICamera2 cam = layer.GetCamera();
if (cam == null)
{
return;
}
PortalView portalView = PortalView.CalculatePortalViews(
layer.GetPortalList().ToArray(),
cam,
PortalRenderEnabled ? PortalRenderMax : 0);
List<PortalView> portalViewList = portalView.GetPortalViewList();
#region Draw portal FOVs to the stencil buffer.
{
GL.ColorMask(false, false, false, false);
GL.DepthMask(false);
GL.Disable(EnableCap.DepthTest);
SetEnable(EnableCap.StencilTest, true);
GL.StencilOp(StencilOp.Replace, StencilOp.Replace, StencilOp.Replace);
for (int i = 1; i < Math.Min(portalViewList.Count, StencilMaxValue); i++)
{
GL.StencilFunc(StencilFunction.Always, i, StencilMask);
Mesh mesh = new Mesh();
for (int j = 0; j < portalViewList[i].Paths.Count; j++)
{
Vector2[] a = ClipperConvert.ToVector2(portalViewList[i].Paths[j]);
ModelFactory.AddPolygon(mesh, a);
}
RenderModel(new Model(mesh), CameraExt.GetViewMatrix(cam));
}
}
#endregion
List<DrawData> drawData = new List<DrawData>();
#region Get models.
{
HashSet<Model> models = new HashSet<Model>();
List<IRenderable> renderList = layer.GetRenderList();
foreach (IRenderable e in renderList)
{
if (!e.Visible)
{
continue;
}
List<Clip.ClipModel> clipModels = Clip.GetClipModels(e, layer.GetPortalList(), PortalClipDepth);
foreach (Clip.ClipModel clip in clipModels)
{
if (clip.ClipLines.Length > 0)
{
Model model = clip.Model.DeepClone();
Matrix4 transform = clip.Entity.GetWorldTransform().GetMatrix() * clip.Transform;
for (int i = 0; i < clip.ClipLines.Length; i++)
{
model.Mesh = MathExt.BisectMesh(model.Mesh, clip.ClipLines[i], transform, Side.Right);
}
models.Add(model);
drawData.Add(new DrawData(-1, model, transform));
}
else
{
models.Add(clip.Model);
drawData.Add(new DrawData(
-1,
clip.Model,
clip.Entity.GetWorldTransform().GetMatrix() * clip.Transform));
}
}
}
var indexList = BufferModels(models.ToArray());
for (int i = 0; i < drawData.Count; i++)
{
DrawData d = drawData[i];
d.Index = indexList[d.Model];
}
}
#endregion
#region Draw the scenes within each portal's FOV.
{
GL.ColorMask(true, true, true, true);
GL.DepthMask(true);
GL.Enable(EnableCap.DepthTest);
GL.StencilOp(StencilOp.Keep, StencilOp.Keep, StencilOp.Keep);
for (int i = 0; i < Math.Min(portalViewList.Count, StencilMaxValue); i++)
{
SetScissor(portalViewList[i], CameraExt.GetViewMatrix(cam));
GL.StencilFunc(StencilFunction.Equal, i, StencilMask);
Draw(drawData.ToArray(), portalViewList[i].ViewMatrix);
}
ResetScissor();
}
#endregion
RenderPortalEdges(portalViewList, cam);
}
