void _restore()
{
var layer = this._currentLayer;
D.assert(layer.states.Count > 0);
if (layer.states.Count > 1)
{
ObjectPool <State> .release(layer.states[layer.states.Count - 1]);
layer.states.RemoveAt(layer.states.Count - 1);
layer.currentState = layer.states[layer.states.Count - 1];
layer.clipStack.restore();
return;
}
this._layers.RemoveAt(this._layers.Count - 1);
var currentLayer = this._currentLayer = this._layers[this._layers.Count - 1];
var state = currentLayer.currentState;
var mesh = ImageMeshGenerator.imageMesh(state.matrix, uiRectHelper.one, layer.layerBounds);
if (!this._applyClip(mesh.bounds))
{
ObjectPool <uiMeshMesh> .release(mesh);
return;
}
var renderDraw = CanvasShader.texRT(currentLayer, layer.layerPaint.Value, mesh, layer);
currentLayer.draws.Add(renderDraw);
}
public void saveLayer(Rect bounds, Paint paint)
{
D.assert(bounds != null);
D.assert(bounds.width > 0);
D.assert(bounds.height > 0);
D.assert(paint != null);
this._saveCount++;
var state = this._getState();
var textureWidth = Mathf.CeilToInt(
(float)bounds.width * state.scale * this._devicePixelRatio);
textureWidth = Mathf.Max(textureWidth, 1);
var textureHeight = Mathf.CeilToInt(
(float)bounds.height * state.scale * this._devicePixelRatio);
textureHeight = Mathf.Max(textureHeight, 1);
var parentLayer = this._getLayer();
var layer = new RenderLayer {
rtID = Shader.PropertyToID("_rtID_" + this._layers.Count + "_" + parentLayer.layers.Count),
width = textureWidth,
height = textureHeight,
layerBounds = bounds,
layerPaint = paint,
};
parentLayer.layers.Add(layer);
this._layers.Add(layer);
}
public void DrawRectangle(Rectangle rectangle, int strokeWidth, Color color, RenderLayer layer)
{
spriteBatch.Draw(rectangleTexture, new Rectangle(rectangle.Left, rectangle.Top, rectangle.Width, strokeWidth), null, color, 0f, Vector2.Zero, SpriteEffects.None, GetLayerDepth(layer));
spriteBatch.Draw(rectangleTexture, new Rectangle(rectangle.Left, rectangle.Bottom, rectangle.Width + strokeWidth, strokeWidth), null, color, 0f, Vector2.Zero, SpriteEffects.None, GetLayerDepth(layer));
spriteBatch.Draw(rectangleTexture, new Rectangle(rectangle.Left, rectangle.Top, strokeWidth, rectangle.Height), null, color, 0f, Vector2.Zero, SpriteEffects.None, GetLayerDepth(layer));
spriteBatch.Draw(rectangleTexture, new Rectangle(rectangle.Right, rectangle.Top, strokeWidth, rectangle.Height), null, color, 0f, Vector2.Zero, SpriteEffects.None, GetLayerDepth(layer));
}
void _clearLayer(RenderLayer layer)
{
foreach (var cmdObj in layer.draws)
{
switch (cmdObj)
{
case CmdDraw cmd:
if (cmd.meshObjCreated)
{
this._meshPool.returnMesh(cmd.meshObj);
cmd.meshObj = null;
cmd.meshObjCreated = false;
}
break;
}
cmdObj.release();
}
layer.draws.Clear();
foreach (var subLayer in layer.layers)
{
this._clearLayer(subLayer);
ObjectPool <RenderLayer> .release(subLayer);
}
layer.layers.Clear();
}
void _clearLayer(RenderLayer layer)
{
for (var index = 0; index < layer.draws.Count; index++)
{
var cmdObj = layer.draws[index];
switch (cmdObj)
{
case RenderDraw cmd:
if (cmd.meshObjCreated)
{
this._meshPool.returnMesh(cmd.meshObj);
cmd.meshObj = null;
cmd.meshObjCreated = false;
}
break;
}
}
layer.draws.Clear();
foreach (var subLayer in layer.layers)
{
this._clearLayer(subLayer);
}
layer.layers.Clear();
}
public void Draw(Texture2D texture, Vector2 position, RenderLayer layer)
{
if (texture != null)
{
spriteBatch.Draw(texture, position, null, Color.White, 0f, Vector2.Zero, 1f, SpriteEffects.None, GetLayerDepth(layer));
}
}
internal void render(RenderList list, RenderObject obj, ref Transform parent, byte drawLayers = 255)
{
Transform trs = Local * parent;
uint pos;
if (this.forceBillboard)
{
list.Camera.MakeBillboard(ref trs);
}
if (0 != (drawLayers & ChildrenDrawLayerMask))
{
GeoNode node;
for (pos = NumImmediate, node = FirstChild; 0 != pos; node = node.Sibling, --pos)
{
if (0 != (drawLayers & node.DrawLayerMask))
{
node.render(list, obj, ref trs, drawLayers);
}
}
}
if (0 != (drawLayers & SelfDrawLayerMask))
{
OpenTK.Vector4 viewProj = list.Camera.ViewProj * new OpenTK.Vector4(trs.translation, 1f);
GeoModel model;
for (pos = ModelCount, model = FirstModel; 0 != pos; model = model.Next, --pos)
{
if (0 != (drawLayers & model.DrawLayerMask))
{
RenderLayer.Insert(list, obj, model, ref trs, ref viewProj, (byte)(drawLayers & model.DrawLayerMask));
}
}
}
}
void Awake()
{
if (renderLayer == null)
{
renderLayer = GetComponent <RenderLayer>();
}
}
public void flush(uiPicture picture)
{
this._reset();
this._resetRenderTextureId();
this._drawUIPicture(picture, false);
D.assert(this._layers.Count == 1);
D.assert(this._layers[0].states.Count == 1);
var layer = this._currentLayer;
using (var cmdBuf = new CommandBuffer()) {
cmdBuf.name = "CommandBufferCanvas";
this._lastRtID = -1;
this._drawLayer(layer, cmdBuf);
// this is necessary for webgl2. not sure why... just to be safe to disable the scissor.
cmdBuf.DisableScissorRect();
Graphics.ExecuteCommandBuffer(cmdBuf);
}
D.assert(this._layers.Count == 0 || (this._layers.Count == 1 && this._layers[0] == this._currentLayer));
if (this._currentLayer != null)
{
this._clearLayer(this._currentLayer);
ObjectPool <RenderLayer> .release(this._currentLayer);
this._currentLayer = null;
this._lastScissor = null;
this._layers.Clear();
}
}
/// <summary>
/// modelのパターン(x,y)をbufferに描画する
/// </summary>
/// <param name="model">レイヤーモデル</param>
/// <param name="buffer">描画対象バッファ</param>
/// <param name="xPos">水平位置</param>
/// <param name="yPos">垂直位置</param>
public static void Draw(CharaChipRenderData model, ImageBuffer buffer, int xPos, int yPos)
{
if ((xPos < 0) || (xPos > 2) || (yPos < 0) || (yPos > 3))
{
return;
}
buffer.Clear();
if ((model == null) || (model.LayerCount == 0))
{
return;
}
for (int i = model.LayerCount - 1; i >= 0; i--)
{
RenderLayer layer = model.GetLayer(i);
if (layer.Image == null)
{
continue;
}
// レイヤーを描画する。
DrawLayer(buffer, xPos, yPos, layer);
}
}
public override void Render(ModelShader shader, RenderLayer layer)
{
foreach (Instance inst in myInstances)
{
inst.Render(shader);
}
}
/// <summary>
/// Drawing pictures for every frame.
/// </summary>
/// <param name="sb"></param>
/// <param name="dtime"></param>
public void Render(Microsoft.Xna.Framework.Graphics.SpriteBatch spriteBatch, RenderLayer layer)
{
if (isStarted)
{
if (layer == RenderLayer.Early)
{
DrawBackground(spriteBatch);
}
else if (layer == RenderLayer.Normal)
{
foreach (Renderable render in Renderable.AllRenderable)
{
render.Render(spriteBatch);
}
DrawSelection(spriteBatch);
}
else
{
DrawHealthBars(spriteBatch);
DrawControlPointBars(spriteBatch);
DrawScore(spriteBatch);
if (paused)
DrawPauseScreen(spriteBatch);
if (gameOver)
{
DrawGameOver(spriteBatch);
}
}
}
else
StartScreen(spriteBatch);
}
protected override void OnAwake()
{
base.OnAwake();
renderLayer = GetComponent <RenderLayer>();
anchor = GetComponent <UnitAnchor>();
buildChangeManager = GetComponent <BBuildChangeManager>();
}
//Accessors
//Methods
public override void Render(RenderLayer layer)
{
foreach (MenuItem entry in items)
{
entry.Render(layer);
}
}
public void Draw(Texture2D texture, Rectangle destinationRectangle, Color color, RenderLayer layer)
{
if (texture != null)
{
spriteBatch.Draw(texture, destinationRectangle, null, color, 0f, Vector2.Zero, SpriteEffects.None, GetLayerDepth(layer));
}
}
RenderLayer _createMaskLayer(RenderLayer parentLayer, Rect maskBounds, Action <Paint> drawCallback, Paint paint)
{
var textureWidth = Mathf.CeilToInt((float)maskBounds.width * this._devicePixelRatio);
textureWidth = Mathf.Max(1, textureWidth);
var textureHeight = Mathf.CeilToInt((float)maskBounds.height * this._devicePixelRatio);
textureHeight = Mathf.Max(1, textureHeight);
var maskLayer = new RenderLayer {
rtID = Shader.PropertyToID("_rtID_" + this._layers.Count + "_" + parentLayer.layers.Count),
width = textureWidth,
height = textureHeight,
layerBounds = maskBounds,
};
parentLayer.layers.Add(maskLayer);
this._layers.Add(maskLayer);
var parentState = parentLayer.states.Last();
var maskState = maskLayer.states.Last();
maskState.matrix = parentState.matrix;
drawCallback(Paint.shapeOnly(paint));
var removed = this._layers.removeLast();
D.assert(removed == maskLayer);
return(maskLayer);
}
public override void RenderContent(RenderLayer renderContext, SpriteBatch spriteBatch)
{
Dictionary <string, Texture2D> brushClassOverlays = _form._brushClassOverlays;
DynamicTileBrush brush = _form._brush;
if (!brushClassOverlays.ContainsKey(brush.BrushClass.ClassName))
{
System.Drawing.Bitmap overlayBitmap = null;
if (brush.BrushClass.ClassName == "Basic")
{
overlayBitmap = Properties.Resources.DynBrushBasic;
}
else if (brush.BrushClass.ClassName == "Extended")
{
overlayBitmap = Properties.Resources.DynBrushExtended;
}
else
{
return;
}
TextureResource overlayResource = TextureResourceBitmapExt.CreateTextureResource(overlayBitmap);
brushClassOverlays.Add(brush.BrushClass.ClassName, overlayResource.CreateTexture(spriteBatch.GraphicsDevice));
}
Texture2D overlay = brushClassOverlays[brush.BrushClass.ClassName];
int width = (int)(overlay.Width * renderContext.LevelGeometry.ZoomFactor * (brush.TileWidth / 16.0));
int height = (int)(overlay.Height * renderContext.LevelGeometry.ZoomFactor * (brush.TileHeight / 16.0));
Microsoft.Xna.Framework.Rectangle dstRect = new Microsoft.Xna.Framework.Rectangle(0, 0, width, height);
spriteBatch.Draw(overlay, dstRect, new Microsoft.Xna.Framework.Color(1f, 1f, 1f, .5f));
}
public void ToItem(AGSSerializationContext context, IObject obj)
{
obj.ResetScale(InitialWidth, InitialHeight);
var image = Image.ToItem(context);
if (image != null)
{
obj.Image = image;
obj.Scale = new PointF(ScaleX, ScaleY);
}
obj.Location = new AGSLocation(Location.Item1, Location.Item2, Location.Item3);
obj.Pivot = new PointF(Pivot.Item1, Pivot.Item2);
obj.Angle = Angle;
obj.Tint = Color.FromHexa(Tint);
obj.IsPixelPerfect = IsPixelPerfect;
AnimationComponent.ToItem(context, obj);
obj.RenderLayer = RenderLayer.ToItem(context);
obj.Properties.CopyFrom(Properties.ToItem(context));
obj.Enabled = Enabled;
obj.DisplayName = DisplayName;
obj.IgnoreViewport = IgnoreViewport;
obj.IgnoreScalingArea = IgnoreScalingArea;
obj.Visible = Visible;
if (Parent != null)
{
var parent = Parent.ToItem(context);
obj.TreeNode.SetParent(parent.TreeNode);
}
}
public static CmdLayer create(RenderLayer layer)
{
CmdLayer newCmd = ObjectPool <CmdLayer> .alloc();
newCmd.layer = layer;
return(newCmd);
}
public override void Render(RenderLayer layer)
{
if (layer == RenderLayer.MENU)
{
menuPanel.Render(layer);
}
}
public override void Render(RenderLayer layer)
{
if (Camera.IsInsideCamera(this.Position, AllSprites["Explosion"].Pos.w, AllSprites["Explosion"].Pos.h))
{
Coordinate drawPosition = Camera.ConvertMapToScreenCoordinate(this.Position);
AllSprites["Explosion"].RotateAndRender(drawPosition, 0, AllSprites["Explosion"].Pos.w / 2, AllSprites["Explosion"].Pos.h / 2);
}
}
protected BaseRenderObject()
{
Transform = new Transform();
Debug = false;
RenderLayer = RenderLayer.None;
ZLevel = 1;
ParentTransform = null;
}
public Tile(string texture, Vector2 position, float rotation, Vector2 scale, RenderLayer layer, float depth)
{
this.Texture = texture;
this.Position = position;
this.Rotation = rotation;
this.Scale = scale;
this.RenderLayer = layer;
this.Depth = depth;
}
public static RenderLayer AddRenderLayer(RenderLayer layer)
{
if (MainWindow != null)
{
MainWindow.Layers.Add(layer);
}
return(layer);
}
RenderLayer _createBlurLayer(RenderLayer maskLayer, float sigmaX, float sigmaY, RenderLayer parentLayer)
{
sigmaX = BlurUtils.adjustSigma(sigmaX, out var scaleFactorX, out var radiusX);
sigmaY = BlurUtils.adjustSigma(sigmaY, out var scaleFactorY, out var radiusY);
var textureWidth = Mathf.CeilToInt((float)maskLayer.width / scaleFactorX);
if (textureWidth < 1)
{
textureWidth = 1;
}
var textureHeight = Mathf.CeilToInt((float)maskLayer.height / scaleFactorY);
if (textureHeight < 1)
{
textureHeight = 1;
}
var blurXLayer = RenderLayer.create(
rtID: Shader.PropertyToID(this._getNewRenderTextureKey()),
width: textureWidth,
height: textureHeight,
layerBounds: maskLayer.layerBounds,
filterMode: FilterMode.Bilinear,
noMSAA: true
);
parentLayer.addLayer(blurXLayer);
var blurYLayer = RenderLayer.create(
rtID: Shader.PropertyToID(this._getNewRenderTextureKey()),
width: textureWidth,
height: textureHeight,
layerBounds: maskLayer.layerBounds,
filterMode: FilterMode.Bilinear,
noMSAA: true
);
parentLayer.addLayer(blurYLayer);
var blurMesh = ImageMeshGenerator.imageMesh(null, uiRectHelper.one, maskLayer.layerBounds);
var kernelX = BlurUtils.get1DGaussianKernel(sigmaX, radiusX);
var kernelY = BlurUtils.get1DGaussianKernel(sigmaY, radiusY);
blurXLayer.draws.Add(CanvasShader.maskFilter(
blurXLayer, blurMesh, maskLayer,
radiusX, new Vector2(1f / textureWidth, 0), kernelX));
blurYLayer.draws.Add(CanvasShader.maskFilter(
blurYLayer, blurMesh.duplicate(), blurXLayer,
radiusY, new Vector2(0, -1f / textureHeight), kernelY));
return(blurYLayer);
}
//Accessors
//Methods
public override void Render(RenderLayer layer)
{
clock.Render(layer);
if (timeUp)
{
title.RenderAtPosition(title.Pos.x, title.Pos.y);
score1.RenderAtPosition(score1.Pos.x, score1.Pos.y);
score2.RenderAtPosition(score2.Pos.x, score2.Pos.y);
}
}
public TextureComponent(string textureFilename, RenderLayer layer)
{
ResourceManager rm = ResourceManager.GetInstance();
TextureFilename = textureFilename;
Layer = layer;
Texture = rm.GetResource <Texture2D>(textureFilename);
Offset = new Point(Texture.Width / 2, Texture.Height / 2);
}
private void buttonOK_Click(object sender, EventArgs e)
{
//有效性验证
m_dataInfo = inputAndOutput.GetDataInfo();
string filePath = m_dataInfo.GetOutputFilePath();
string fileName = m_dataInfo.GetOutputFileName();
#region 参数有效性验证
if (m_dataInfo.IsValid() == false)
{
return;
}
if (textBoxEps.Text == "")
{
MessageBox.Show("区域半径输入错误！");
return;
}
if (textBoxMinPts.Text == "")
{
MessageBox.Show("最小点数输入错误！");
return;
}
if (File.Exists(filePath + "\\" + fileName))
{
MessageBox.Show(fileName + "文件已存在，请重新输入！");
return;
}
#endregion
//参数获取
m_dEps = m_dataInfo.UnitsConvertToMeters(float.Parse(textBoxEps.Text), m_mapControl.MapUnits);
m_nMinPts = int.Parse(textBoxMinPts.Text);
//计算得到聚类结果
m_DBSCANCluster = new DBSCAN(m_dataInfo, m_dEps, m_nMinPts);
m_Clusters = m_DBSCANCluster.GetClusters();
//保存到shp
SaveShapefile shapefile = new SaveShapefile(m_dataInfo, m_Clusters);
shapefile.CreatePolygonShapefile();
shapefile.CreatePointsShapefile();
IFeatureLayer pointLayer = shapefile.GetPointFeatureLayer();
IFeatureLayer polygonLayer = shapefile.GetPolygonFeatureLayer();
//渲染显示
RenderLayer layerRenderer = new RenderLayer();
layerRenderer.DefinePointUniqueValueRenderer(pointLayer as IGeoFeatureLayer, "index");
layerRenderer.DefinePolygonUniqueValueRenderer(polygonLayer as IGeoFeatureLayer, "index");
m_mapControl.AddLayer(polygonLayer as ILayer);
m_mapControl.AddLayer(pointLayer as ILayer);
this.m_mapControl.Refresh();
this.Close();
}
public GUIComponent(GUIType type, string textureName, Point screenPosition, RenderLayer layer)
{
ResourceManager rm = ResourceManager.GetInstance();
Type = type;
TexturePath = textureName;
ScreenPosition = screenPosition;
Layer = layer;
IsActive = true;
Texture = rm.GetResource <Texture2D>(textureName);
}
public MenuButtonComponent(MenuButtonType type, ButtonAction buttonAction, string normalTexturePath, string highlightTexturePath, Vector2 position, RenderLayer layer)
{
IsActive = false;
Ishighlighted = false;
Type = type;
Use = buttonAction;
NormalTexturePath = normalTexturePath;
HighlightTexturePath = highlightTexturePath;
Position = position;
Layer = layer;
}
public SpriteComponent(Sprite sprite, String renderLayer)
{
m_sprite = sprite;
m_attachedToOwner = true;
m_visible = true;
if (Engine.Renderer.RenderLayers.ContainsKey(renderLayer))
{
m_layer = Engine.Renderer.RenderLayers[renderLayer];
}
}
void _tryAddScissor(RenderLayer layer, uiRect?scissor)
{
if (uiRectHelper.equals(scissor, this._lastScissor))
{
return;
}
layer.draws.Add(CmdScissor.create(
deviceScissor: scissor
));
this._lastScissor = scissor;
}
public override void Render( ModelShader shader, RenderLayer layer )
{
float rx, rz;
for ( int x = 0; x < myGridWidth; ++x ) for ( int z = 0; z < myGridDepth; ++z )
{
ExteriorBlock blk = myInstGrid[ x, z ];
rx = blk.CenterPos.X - shader.Camera.Position.X;
rz = blk.CenterPos.Y - shader.Camera.Position.Z;
if ( ( rx * rx + rz * rz ) < shader.Camera.ViewDistance2 + blk.Radius2 )
blk.Render( shader, layer );
}
}
public override void Render( ModelShader shader, RenderLayer layer )
{
foreach ( Instance inst in myInstances )
inst.Render( shader );
}
public abstract void Render( ModelShader shader, RenderLayer layer );
private float getDepthScale(RenderLayer l)
{
switch (l)
{
case RenderLayer.Background:
return .6f;
default:
return 1;
}
}
/// <summary>
/// Run render on the currently active game screen
/// </summary>
/// <param name="sb">The spritebatch used for drawing</param>
/// <param name="dtime">The time passed since last frame</param>
public void Render(Microsoft.Xna.Framework.Graphics.SpriteBatch sb, RenderLayer layer)
{
activeScreen.Render(sb, layer);
}
