public ColorMapActor(double layerAltitude, BindingsSource bs, ObservableCollection<VisualizationDataSource> dataSources, Host host)
: base(bs)
{
LinearPalette palette = new LinearPalette(swm.Colors.Blue, swm.Colors.Green, swm.Colors.Red);
palette.IncreaseBrightness = false;
this.palette = palette;
meshLayers = new List<MeshLayer>();
layerHelper = new LayerHelper(layerAltitude);
this.host = host;
dataSources.CollectionChanged += new System.Collections.Specialized.NotifyCollectionChangedEventHandler(dataSources_CollectionChanged);
}
private void legend1_LayerDoubleClick(int Handle)
{
LayerHelper.ShowLayerProperties(Handle);
}
public bool isGrounded()
{
RaycastHit2D hit = Physics2D.Raycast(transform.position, -Vector2.up, rayLength, 1 << LayerHelper.getLayer(LayerHelper.Layer.GROUND));
if (hit.collider != null)
{
return(true);
}
return(false);
}
public virtual bool a_air()
{
if (attackUpdate == 0 && !blocked)
{
prim_air = true;
attackUpdate = attackUpdateCooldown;
Vector2 dir = new Vector2(animator.gameObject.transform.rotation.y == 0 ? 1 : -1, 0);
RaycastHit2D[] hit = Physics2D.RaycastAll(transform.position, dir, attackRange, 1 << LayerHelper.getLayer(LayerHelper.Layer.HITABLE));
for (int i = 0; i < hit.Length; i++)
{
GameObject gameObject = hit[i].collider.gameObject;
if (gameObject.transform.parent.gameObject != this.gameObject && gameObject.transform.parent.name.StartsWith("Player"))
{
gameObject.transform.GetComponentInParent <HealthManager>().applyDamageFixedY(this.transform.position + new Vector3(0, -0.5f, 0), 2, 20);
gameObject.transform.GetComponentInParent <HealthManager>().stun(0.5f);
}
}
return(true);
}
return(false);
}
private Dictionary <int, ILayer> ReadMapLayers(bool onlySelectedFeatures, bool onlyCurrentExtent, bool highlightedLayerOnly)
{
List <ILayer> layers = null;
if (highlightedLayerOnly)
{
if (this.MxDocument.SelectedLayer != null)
{
layers = new List <ILayer>();
if (!this.MxDocument.SelectedLayer.Is3D())
{
layers.Add(this.MxDocument.SelectedLayer);
}
}
else
{
layers = this.MxDocument.SelectedItem.ToLayerList();
}
}
else
{
layers = LayerHelper.GetLayerList(this.MxDocument.FocusMap);
}
Dictionary <int, ILayer> exportLayers = new Dictionary <int, ILayer>();
IEnvelope extent = null;
if (onlyCurrentExtent)
{
extent = this.MxDocument.ActiveView.Extent;
}
int i = 0;
foreach (ILayer layer in layers)
{
if (layer is IFeatureLayer &&
!layer.Is3D())
{
IFeatureLayer featureLayer = (IFeatureLayer)layer;
IFeatureSelection featureSelection = (IFeatureSelection)featureLayer;
bool hasSelectedFeatures = (featureSelection.SelectionSet.Count > 0);
bool visibleInCurrentExtent = false;
bool selectedVisibleInCurrentExtent = false;
if (extent != null)
{
ISpatialFilter filter = new SpatialFilterClass();
filter.Geometry = extent;
filter.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
visibleInCurrentExtent = featureLayer.FeatureClass.FeatureCount(filter) > 0;
ICursor cursor;
featureSelection.SelectionSet.Search(filter, true, out cursor);
int c = 0;
while (cursor.NextRow() != null)
{
c++;
break;
}
selectedVisibleInCurrentExtent = (c > 0);
}
if (onlySelectedFeatures & onlyCurrentExtent)
{
if (selectedVisibleInCurrentExtent)
{
exportLayers.Add(++i, layer);
}
}
else if (onlySelectedFeatures & !onlyCurrentExtent)
{
if (hasSelectedFeatures)
{
exportLayers.Add(++i, layer);
}
}
else if (!onlySelectedFeatures & onlyCurrentExtent)
{
if (visibleInCurrentExtent)
{
exportLayers.Add(++i, layer);
}
}
else
{
exportLayers.Add(++i, layer);
}
}
}
return(exportLayers);
}
public void OnSliceButtonClick()
{
if (state == LayerBankState.empty)
{
return;
}
if (state == LayerBankState.drawSlices)
{
ToggleSliceMeshComponent(false);
ToggleMainMeshComponents(true);
state = LayerBankState.drawMainMesh;
return;
}
if (state == LayerBankState.drawMainMesh)
{
hats = new List <Mesh>();
state = LayerBankState.drawSlices;
ToggleMainMeshComponents(false);
ToggleSliceMeshComponent(true);
var zmin = layers[0][0].z;
var zmax = layers[layers.Count - 1][0].z;
int slicesNum;
if (!int.TryParse(slicesCount.text, out slicesNum))
{
slicesNum = 5;
}
List <Vector3> points;
if (Drag_n_drop.lastHitPlane != null)
{
points = Drag_n_drop.lastHitPlane;
}
else
{
points = new List <Vector3>()
{
new Vector3(0, 0, zmin), new Vector3(1, 0, zmin), new Vector3(0, 1, zmin)
};
}
var centr = LayerHelper.CalcCenterPoint(meshFilter.mesh);
var plane = new Plane(points[0], points[1], points[2]);
if (Vector3.Magnitude(plane.normal + (centr - points[0])) < Vector3.Magnitude(centr - points[0]))
{
var temp = points[0];
points[0] = points[1];
points[1] = temp;
}
plane = new Plane(points[0], points[1], points[2]);
float size = 0;
foreach (var i in meshFilter.mesh.vertices)
{
size = Mathf.Max(size, plane.GetDistanceToPoint(i));
}
slices = MeshSlicer.SliceInPeaces(slicesNum, meshFilter.mesh, size, points, out hats);
lastSliceVector = plane.normal.normalized;
hats.Add(upperBound.mesh);
hats.Insert(0, downBound.mesh);
SetSlice(0);
//StartCoroutine(DrawSlices(slices, hats));
}
}
public void EnableProtector(TEAM spawningTeam)
{
gameObject.layer = LayerHelper.GetAttackBoxLayer(spawningTeam);
}
/// <summary>
/// 加载地图
/// </summary>
/// <param name="MWSFilePath"></param>
private void LoadMap(String MWSFilePath)
{
t.Stop();
SelectedFeature = null;
mapControl1.Map.Layers.Clear();
String MapPath = MWSFilePath;
MapWorkSpaceLoader mwsLoader = new MapWorkSpaceLoader(MapPath);
mapControl1.Map.Load(mwsLoader);
foreach (IMapLayer imapLayer in mapControl1.Map.Layers)
{
if (!imapLayer.Alias.Equals("JKINFO"))
{
try
{
LayerHelper.SetSelectable(imapLayer, false);
}
catch
{ }
}
else
{
LayerHelper.SetEditable(imapLayer, false);
}
}
_TempMWSFilePath = MWSFilePath;
//从mdb文件中更新数据到tab表中
t.Interval = 30000;
t.Tick += new EventHandler(t_Tick);
//t.Enabled = true;
t.Start();
//SearchInfo si = MapInfo.Data.SearchInfoFactory.SearchWhere("NDH IS NOT NULL");
////si.QueryDefinition.Columns = new string[] { "NDH" }; //null
//if (ifs == null)
//{
// ifs = MapInfo.Engine.Session.Current.Catalog.Search(MapInfo.Engine.Session.Current.Catalog.GetTable("JKINFO"), si);
//}
//else
//{
// lock (ifs)
// {
// ifs = MapInfo.Engine.Session.Current.Catalog.Search(MapInfo.Engine.Session.Current.Catalog.GetTable("JKINFO"), si);
// }
//}
//try
//{
// if (tRewNew.ThreadState != ThreadState.Running)
// {
// tRewNew.Start();
// }
//}
//catch
//{
//}
}
void TypeSearch_E()
{
this.richTextBox1.Clear();
var layers = MMaker.Core.AppStatic.d_Layers
.Where(x => (new List <string>()
{
"상수관로", "급수관로"
})
.Contains(x.Key.KorName())).Select(x => x.Value);
var tree = LayerHelper.spatialIndex(layers.ToArray());
foreach (var layer in layers)
{
foreach (var feature in layer.Features)
{
var features = tree.Query(feature.Geometry.EnvelopeInternal);
var line = feature.Geometry as ILineString;
foreach (var item in features)
{
if (feature.Equals(item))
{
continue;
}
//if (!feature.Geometry.Crosses(item.Geometry)) continue;
//var g = feature.Geometry.Difference(item.Geometry);
//var p = g?.InteriorPoint;
var line2 = item.Geometry as ILineString;
//교차점 확인
var p = Helper.GeometryHelper.CrossedPoint(feature.Geometry, item.Geometry);
if (p == null)
{
continue;
}
//정상적인 작도
if (Helper.GeometryHelper.IsEqualLocation(line.StartPoint, p))
{
continue;
}
if (Helper.GeometryHelper.IsEqualLocation(line.EndPoint, p))
{
continue;
}
//최소범위 정의
//상월 , 하월 검토
//선 분할 검토
//var p1 = NetTopologySuite.Operation.Distance.DistanceOp.Distance(item.Geometry, p); ;
//if (true)
//{
//}
var v = new NetTopologySuite.Algorithm.Distance.PointPairDistance();
NetTopologySuite.Algorithm.Distance.DistanceToPoint.ComputeDistance(line2, p.Coordinate, v);
//var pp = item.Geometry.Intersection(p);
;
//객체 속성
//관리번호 중복 검토
//연장 속성 업데이트
//if (item.Geometry.Touches(line.StartPoint)) continue;
//if (item.Geometry.Touches(line.EndPoint)) continue;
//var f1 = DistanceOp.IsWithinDistance(item.Geometry, line.StartPoint, 0);
//var f2 = DistanceOp.IsWithinDistance(item.Geometry, line.EndPoint, 0);
//var p1 = DistanceOp.NearestPoints(item.Geometry, line.StartPoint);
//var n1_1 = new NetTopologySuite.Geometries.Point(p1.Min());
//var n1_2 = new NetTopologySuite.Geometries.Point(p1.Max());
//var d1_1 = DistanceOp.Distance(n1_1, line.StartPoint);
//var d1_2 = DistanceOp.Distance(n1_2, line.StartPoint);
//var p2 = DistanceOp.NearestPoints(item.Geometry, line.EndPoint);
//var n2_1 = new NetTopologySuite.Geometries.Point(p2.Min());
//var n2_2 = new NetTopologySuite.Geometries.Point(p2.Max());
//var d2_1 = DistanceOp.Distance(n2_1, line.EndPoint);
//var d2_2 = DistanceOp.Distance(n2_2, line.EndPoint);
//var f1 = DistanceOp.IsWithinDistance(line.StartPoint, item.Geometry, 0);
//var f2 = DistanceOp.IsWithinDistance(line.EndPoint, item.Geometry, 0);
//var p1 = DistanceOp.NearestPoints(line.StartPoint, item.Geometry );
//var n1_1 = new NetTopologySuite.Geometries.Point(p1.Min());
//var n1_2 = new NetTopologySuite.Geometries.Point(p1.Max());
//var d1_1 = DistanceOp.Distance(line.StartPoint, n1_1 );
//var d1_2 = DistanceOp.Distance(line.StartPoint, n1_2 );
//var p2 = DistanceOp.NearestPoints(line.EndPoint, item.Geometry);
//var n2_1 = new NetTopologySuite.Geometries.Point(p2.Min());
//var n2_2 = new NetTopologySuite.Geometries.Point(p2.Max());
//var d2_1 = DistanceOp.Distance(line.EndPoint, n2_1);
//var d2_2 = DistanceOp.Distance(line.EndPoint, n2_2);
////var c = Math.Min(d1, d2);
//var flag = feature.Geometry.Overlaps(item.Geometry);
var str = string.Format("{0} : {1} : {2} : {3} : {4} : {5}\n", layer.Name, feature.DataRow["OFID"], item.ParentFeatureSet.Name, item.DataRow["OFID"], p.X, p.Y);
//var str = string.Format("{0} : {1} : {2} : {3} : {4} : {5} : {6} : {7} : {8} : {9}\n", layer.Name, feature.DataRow["OFID"], item.ParentFeatureSet.Name, item.DataRow["OFID"], d1, d2, c, f1, f2, flag);
richTextBox1.AppendText(str);
}
}
}
}
public static StorableMesh BuildMeshFromLayers(List <List <Vector3> > layers)
{
#region Layers Preparations
{
#region Generate Additional Points
int maxInd = 0;
for (int i = 0; i < layers.Count; i++)
{
if (layers[maxInd].Count < layers[i].Count)
{
maxInd = i;
}
}
#endregion
#region rotatingLayers
var startPos = layers[0][0];
for (int i = 1; i < layers.Count; i++)
{
float minDst = float.MaxValue;
int minInd = 0;
for (int j = 0; j < layers[i].Count; j++)
{
minDst = minDst > LayerHelper.DistanceAsVec2(layers[i][j], startPos) ? LayerHelper.DistanceAsVec2(layers[i][j], startPos) : minDst;
minInd = minDst > LayerHelper.DistanceAsVec2(layers[i][j], startPos) ? j : minInd;
}
if (minInd > 0)
{
List <Vector3> newList = layers[i].GetRange(minInd, layers[i].Count - minInd);
newList.AddRange(layers[i].GetRange(0, minInd + 1));
}
}
#endregion
}
#endregion
List <Vector3> vertices = new List <Vector3>();
Vector3 averagePoint = Vector3.zero;
int count = 0;
foreach (var i in layers)
{
foreach (var j in i)
{
averagePoint += j;
count++;
}
}
averagePoint = averagePoint / count;
for (int i = 0; i < layers.Count; i++)
{
for (int j = 0; j < layers[i].Count; j++)
{
layers[i][j] -= averagePoint;
}
}
List <int> triangles = new List <int>();
List <Vector3> bigList = new List <Vector3>();
List <List <int> > nums = new List <List <int> >();
List <Vector3> verts = new List <Vector3>();
for (int i = 0; i < layers.Count; i++)
{
List <int> layerInd = new List <int>();
for (int j = 0; j < layers[i].Count; j++)
{
layerInd.Add(verts.Count);
verts.Add(layers[i][j]);
}
nums.Add(layerInd);
}
List <int> Tr = new List <int>();
for (int i = 0; i < layers.Count - 1; i++)
{
int u = 0;
int d = 0;
while (d < layers[i].Count - 1 ||
u < layers[i + 1].Count - 1)
{
float magUp = float.MaxValue;
float magDown = float.MaxValue;
if (d < layers[i].Count - 1)
{
magUp = Vector3.Magnitude(layers[i + 1][u] - layers[i][d + 1]);
}
if (u < layers[i + 1].Count - 1)
{
magDown = Vector3.Magnitude(layers[i][d] - layers[i + 1][u + 1]);
}
if (magUp < magDown && d < layers[i].Count - 1)
{
Tr.AddRange(LayerHelper.CreateTriangle(nums[i + 1][u], nums[i][d], nums[i][d + 1]));
d++;
}
else
{
Tr.AddRange(LayerHelper.CreateTriangle(nums[i][d], nums[i + 1][u + 1], nums[i + 1][u]));
u++;
}
}
Tr.AddRange(LayerHelper.CreateTriangle(nums[i][0], nums[i + 1][0], nums[i][nums[i].Count - 1]));
Tr.AddRange(LayerHelper.CreateTriangle(nums[i + 1][nums[i + 1].Count - 1], nums[i + 1][0], nums[i][nums[i].Count - 1]));
}
#region hats for main mesh
var cp = LayerHelper.CalcCenterPoint(layers[0].ToArray());
verts.Add(cp);
for (int i = 0; i < nums[0].Count - 1; i++)
{
Tr.Add(verts.Count - 1);
Tr.Add(nums[0][i]);
Tr.Add(nums[0][i + 1]);
}
Tr.Add(verts.Count - 1);
Tr.Add(nums[0][nums[0].Count - 1]);
Tr.Add(nums[0][0]);
cp = LayerHelper.CalcCenterPoint(layers[layers.Count - 1].ToArray());
verts.Add(cp);
for (int i = 0; i < nums[nums.Count - 1].Count - 1; i++)
{
Tr.Add(verts.Count - 1);
Tr.Add(nums[nums.Count - 1][i]);
Tr.Add(nums[nums.Count - 1][i + 1]);
}
Tr.Add(verts.Count - 1);
Tr.Add(nums[nums.Count - 1][nums[nums.Count - 1].Count - 1]);
Tr.Add(nums[nums.Count - 1][0]);
#endregion
return(new StorableMesh(verts, Tr, null));
//meshFilter.mesh.SetVertices(verts);
//meshFilter.mesh.SetTriangles(Tr, 0);
//meshFilter.mesh.RecalculateNormals();
//meshFilter.GetComponent<MeshCollider>().sharedMesh = meshFilter.mesh;
//for (int i = 0; i < verts.Count; i++)
//{
// var go = Instantiate(spherePrefab, dragSpheresParent);
// go.OnPositionChange += OnSpherePositionChange;
// go.transform.localPosition = verts[i];
// sphereToVertex.Add(go, new Dictionary<MeshFilter, int>() { { meshFilter, i } });
// if (i < layers[0].Count)
// sphereToVertex[go].Add(downBound, i);
// if (i >= verts.Count - layers[layers.Count - 1].Count)
// sphereToVertex[go].Add(upperBound, i - verts.Count + layers[layers.Count - 1].Count);
//}
//ToggleMainMeshComponents(true);
//state = LayerBankState.drawMainMesh;
}
public void CreateNBuffers(DepthPeeler peeler)
{
// NOTE: we are only considering the first 4 depth layers packed into 1 image
// - create the level 0 N-buffer from the original packedDepthTexture
// - copy it at 1/4 resolution (using mip-mapping??)
// - create the rest of N-buffer level from the previous levels
// - for each level i in [1; LevelCount]:
// - attach level i-1 as the source texture
// - attach level i as the render target
// - render a quad
// Different shaders are used for the first level and the rest of levels.
// Since we are creating single set of N-buffers for four depth images
// in parallel in the first level we must find the extrema even within
// the vector components.
//for (int i = 0; i < LayerCount; i++)
//{
// GL.BindTexture(TextureTarget.Texture2D, nBuffersTextures[i]);
// GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear);
//}
GL.PushAttrib(AttribMask.ViewportBit);
GL.Viewport(0, 0, nbuffersWidth, nbuffersHeight);
GL.Ext.BindFramebuffer(FramebufferTarget.FramebufferExt, fboHandle);
GL.DepthFunc(DepthFunction.Always);
// the first level is taken directly from the original packed depth texture (without offsets)
GL.UseProgram(level0shaderProgram);
GL.ActiveTexture(TextureUnit.Texture0);
GL.BindTexture(TextureTarget.Texture2DArray, peeler.PackedDepthTextures);
GL.Uniform1(GL.GetUniformLocation(level0shaderProgram, "packedDepthTexture"), 0);
GL.Uniform1(GL.GetUniformLocation(level0shaderProgram, "layer"), 0);
GL.Ext.FramebufferTextureLayer(
FramebufferTarget.FramebufferExt, FramebufferAttachment.ColorAttachment0Ext,
nBuffersTextureArray, 0, 0); // layer 0
LayerHelper.DrawQuad();
// -- DEBUG --
//GL.UseProgram(0);
//GL.ActiveTexture(TextureUnit.Texture0);
//GL.BindTexture(TextureTarget.Texture2D, prevMinTexture);
//// copy the source texture from the frame buffer to the destination texture
//GL.CopyTexSubImage2D(TextureTarget.Texture2D, 0, 0, 0, 0, 0, nbuffersWidth, nbuffersHeight);
//GL.UseProgram(shaderProgram);
////GL.Ext.BindFramebuffer(FramebufferTarget.FramebufferExt, 0);
//Vector3 offset = new Vector3(1.0f / nbuffersWidth, 1.0f / nbuffersHeight, 0);
//GL.Uniform1(GL.GetUniformLocation(shaderProgram, "prevLevelMinTexture"), 0);
//GL.Uniform1(GL.GetUniformLocation(shaderProgram, "prevLevelMaxTexture"), 1);
//GL.Uniform1(GL.GetUniformLocation(shaderProgram, "prevLevel"), 0);
//GL.Uniform3(GL.GetUniformLocation(shaderProgram, "offset"), offset);
//GL.ActiveTexture(TextureUnit.Texture1);
//GL.BindTexture(TextureTarget.Texture2DArray, nBuffersTextureArray);
//GL.ActiveTexture(TextureUnit.Texture0);
//GL.BindTexture(TextureTarget.Texture2D, prevMinTexture);
//GL.Ext.FramebufferTextureLayer(
// FramebufferTarget.FramebufferExt, FramebufferAttachment.ColorAttachment0Ext,
// nBuffersTextureArray, 0, 1);
//LayerHelper.DrawQuad();
// -- DEBUG --
// the following levels are constructed from the previous ones (with offsets)
GL.UseProgram(shaderProgram);
// (x, y, 0)
// (1,1,0) converted from [width; height] to [0.0; 1.0]^2 texture coordinates
Vector3 offset = new Vector3(1.0f / nbuffersWidth, 1.0f / nbuffersHeight, 0);
GL.Uniform1(GL.GetUniformLocation(shaderProgram, "prevLevelTexture"), 0);
GL.ActiveTexture(TextureUnit.Texture0);
GL.BindTexture(TextureTarget.Texture2DArray, nBuffersTextureArray);
GL.TexParameter(TextureTarget.Texture2DArray, TextureParameterName.TextureBorderColor, new float[] { 1, 0, 0, 0 });
for (int i = 1; i < LayerCount; i++)
{
GL.Uniform3(GL.GetUniformLocation(shaderProgram, "offset"), offset);
GL.Uniform1(GL.GetUniformLocation(shaderProgram, "prevLevel"), i - 1);
GL.Ext.FramebufferTextureLayer(
FramebufferTarget.FramebufferExt, FramebufferAttachment.ColorAttachment0Ext,
nBuffersTextureArray, 0, i);
LayerHelper.DrawQuad();
offset *= 2.0f;
}
GL.TexParameter(TextureTarget.Texture2DArray, TextureParameterName.TextureBorderColor, new float[] { 0, 1, 0, 0 });
GL.DepthFunc(DepthFunction.Less);
GL.UseProgram(0);
GL.ActiveTexture(TextureUnit.Texture1);
GL.BindTexture(TextureTarget.Texture2D, 0);
GL.ActiveTexture(TextureUnit.Texture0);
GL.BindTexture(TextureTarget.Texture2D, 0);
GL.Ext.BindFramebuffer(FramebufferTarget.FramebufferExt, 0);
GL.PopAttrib(); // ViewportBit
//for (int i = 0; i < LayerCount; i++)
//{
// GL.BindTexture(TextureTarget.Texture2D, nBuffersTextures[i]);
// GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.LinearMipmapLinear);
// GL.Ext.GenerateMipmap(GenerateMipmapTarget.Texture2D);
//}
//GL.BindTexture(TextureTarget.Texture2D, 0);
}
/// <override></override>
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
{
if (destinationType == null)
{
throw new ArgumentNullException("destinationType");
}
if (value is string || value == null)
{
if (destinationType == typeof(int))
{
return(ConvertToLayerId(context, (string)value));
}
else if (destinationType == typeof(LayerIds))
{
return(ConvertToLayerIds(context, (string)value));
}
else
{
throw new NotSupportedException();
}
}
else if (value is int)
{
if (destinationType == typeof(LayerIds))
{
return(Layer.ConvertToLayerIds((int)value));
}
else if (destinationType == typeof(string))
{
return(ConvertToLayerName(context, (int)value));
}
else
{
throw new NotSupportedException();
}
}
else if (value is LayerIds)
{
if (destinationType == typeof(int))
{
return(Layer.ConvertToLayerId((LayerIds)value));
}
else if (destinationType == typeof(string))
{
string result = String.Empty;
foreach (int id in LayerHelper.GetAllLayerIds((LayerIds)value))
{
result += string.Format("{0}{1}",
String.IsNullOrEmpty(result) ? String.Empty : ListSeparatorChar + " ",
ConvertToLayerName(context, id)
);
}
return(result);
}
else
{
throw new NotSupportedException();
}
}
else
{
throw new NotSupportedException();
}
}
private void AddBuildings()
{
var allRooms = new Dictionary <Room, Point>();
var needRooms = CityBlockIds.Length * 3;
foreach (var blockId in CityBlockIds)
{
var rooms = LayerHelper.GenerateRooms(World.Rnd, BaseMapBlock.Rect.Inflate(-2, -2).Offset(2, 2), new Point[0], blockId).OrderByDescending(_room => _room.RoomRectangle.Size);
foreach (var room in rooms)
{
allRooms.Add(room, blockId);
//if (allRooms.Count >= needRooms)
//{
// break;
//}
}
}
var availableBuildings = Util.GetAllTypesOf <Building>().Select(_type => (Building)Activator.CreateInstance(_type, this)).ToArray();
var availableRoles = Util.GetAllTypesOf <AbstractCitizenRole>().Select(_type => (AbstractCitizenRole)Activator.CreateInstance(_type)).ToArray();
var buildings = new List <Building>();
var surface = Layer as Surface;
if (surface == null)
{
throw new NotImplementedException();
}
foreach (var abuilding in availableBuildings)
{
for (var i = 0; i < abuilding.MinCountInCity; i++)
{
var building = (Building)Activator.CreateInstance(abuilding.GetType(), this);
var role = availableRoles.FirstOrDefault(_role => _role.BuildingType == building.BuildingType);
if (role != null)
{
var citizen = new Citizen(Layer, World.Rnd, surface.GetNextCitizenName(new[] { ESex.MALE, ESex.FEMALE, }.RandomItem(World.Rnd)));
var citizenRole = (AbstractCitizenRole)Activator.CreateInstance(role.GetType());
citizenRole.SetBuilding(citizen, building);
citizen.AddRole(citizenRole);
m_citizens.Add(citizen);
}
buildings.Add(building);
}
}
while (buildings.Count < allRooms.Count)
{
foreach (var abuilding in availableBuildings)
{
var count = buildings.Count(_building => _building.GetType() == abuilding.GetType());
if (count >= abuilding.MaxCountInCity)
{
continue;
}
var building = (Building)Activator.CreateInstance(abuilding.GetType(), this);
var role = availableRoles.FirstOrDefault(_role => _role.BuildingType == building.BuildingType);
if (role != null)
{
Citizen citizen = null;
if (building.BuildingType == EBuilding.HOUSE)
{
citizen = m_citizens.FirstOrDefault(_citizen => _citizen.Roles.OfType <AbstractCitizenRole>().All(_role => _role.BuildingType != EBuilding.HOUSE));
}
if (citizen == null)
{
citizen = new Citizen(Layer, World.Rnd, surface.GetNextCitizenName(new[] { ESex.MALE, ESex.FEMALE, }.RandomItem(World.Rnd)));
m_citizens.Add(citizen);
}
var citizenRole = (AbstractCitizenRole)Activator.CreateInstance(role.GetType());
citizenRole.SetBuilding(citizen, building);
citizen.AddRole(citizenRole);
}
buildings.Add(building);
}
}
buildings = buildings.OrderBy(_building => World.Rnd.Next()).ToList();
foreach (var building in buildings)
{
var pair = allRooms.First(_pair => building.IsFit(_pair.Key));
allRooms.Remove(pair.Key);
building.SetRoom(pair.Key);
m_buildings.Add(building);
}
}
public static void GetLayerCount_ThrowsOnNullGraph() => LayerHelper.GetLayerCount(null);
public static Task Render(IElement element, IFrameContext context, RendererDirect2D render)
{
using (TransformHelper.Create(render, element, context))
using (LayerHelper.Create(render, element, context))
{
var x = 0f;
var y = 0f;
IBrush brush = null;
IBrush sbrush = null;
var fillOpacity = -1f;
D2D1.Brush fillBrush = null;
D2D1.Brush strokeBrush = null;
var strokeOpacity = -1f;
foreach (var span in GetSpans(element, context))
{
if (span.X.HasValue)
{
x = span.X.Value;
}
if (span.Y.HasValue)
{
y = span.Y.Value;
}
var c = span.Items.Count;
var layouts = new List <DW.TextLayout>(c);
var w = 0f;
for (var i = 0; i < c; i++)
{
var ti = span.Items[i];
var l = render.CreateTextLayout(ti.Font, ti.Text, 9999999);
layouts.Add(l);
w += ti.Dx + l.Metrics.WidthIncludingTrailingWhitespace;
}
x -= span.TextAnchor == TextAnchor.Middle
? w / 2
: span.TextAnchor == TextAnchor.End
? w
: 0;
for (var i = 0; i < c; i++)
{
var ti = span.Items[i];
var l = layouts[i];
if (brush != ti.Fill.Brush || !MathEx.NearEqual(fillOpacity, ti.Fill.Opacity))
{
fillBrush = render.CreateBrush(element, context, ti.Fill.Brush, ti.Fill.Opacity);
brush = ti.Fill.Brush;
fillOpacity = ti.Fill.Opacity;
}
if (sbrush != ti.Stroke.Brush || !MathEx.NearEqual(strokeOpacity, ti.Stroke.Opacity))
{
strokeBrush = render.CreateBrush(element, context, ti.Stroke.Brush, ti.Stroke.Opacity);
sbrush = ti.Stroke.Brush;
fillOpacity = ti.Fill.Opacity;
}
x += ti.Dx;
y += ti.Dy;
if (fillBrush != null)
{
if (ti.Stroke.Brush != null)
{
l.Draw(new CustomColorRenderer(render.Target, fillBrush, strokeBrush, ti.Stroke.Width), x,
y - CalcBaselineOffset(l, ti.DominantBaseline));
}
else
{
render.Target.DrawTextLayout(
new DXM.RawVector2(x, y - CalcBaselineOffset(l, ti.DominantBaseline)),
l,
fillBrush,
D2D1.DrawTextOptions.EnableColorFont
);
}
}
x += l.Metrics.WidthIncludingTrailingWhitespace;
l.Dispose();
}
}
return(Task.CompletedTask);
}
}
private void mapControl1_MouseClick(object sender, MouseEventArgs e)
{
if (e.Button == MouseButtons.Right)
{
pNodePoint = e.Location;
if (String.IsNullOrEmpty(_TempMWSFilePath))
{
//地图未打开 右键菜单不激活！
return;
}
if (String.IsNullOrEmpty(AdminPassword))
{
InputPassWDForm frmIPWDF = new InputPassWDForm();
if (frmIPWDF.ShowDialog() == DialogResult.OK)
{
String ConfigPassword = String.Empty;
try
{
ConfigPassword = System.Configuration.ConfigurationManager.AppSettings["AdminPassWord"].ToString();
}
catch
{
}
if (String.IsNullOrEmpty(ConfigPassword))
{
MessageBox.Show("密码配置错误！");
return;
}
if (!MD5Help.MD5Encrypt(frmIPWDF.PassWord).Equals(ConfigPassword))
{
MessageBox.Show("密码错误！");
return;
}
else
{
AdminPassword = ConfigPassword;
foreach (IMapLayer imapLayer in mapControl1.Map.Layers)
{
if (imapLayer.Alias.Equals("JKINFO"))
{
LayerHelper.SetEditable(imapLayer, true);
LayerHelper.SetInsertable(imapLayer, true);
LayerHelper.SetSelectable(imapLayer, true);
}
else
{
LayerHelper.SetEditable(imapLayer, false);
LayerHelper.SetInsertable(imapLayer, false);
LayerHelper.SetSelectable(imapLayer, false);
}
}
MessageBox.Show("登陆成功！");
}
}
else
{
return;
}
}
//mapControl1.ContextMenuStrip = EditContextMenu;
//MessageBox.Show("登陆成功！");
EditContextMenu.Show(e.Location);
}
else
{
//SelectedFeature = null;
}
}
protected override void DrawSingleFrame(int iteration, Scene scene, Navigation navigation)
{
Debug.Assert(DepthPeeler != null);
Camera camera = navigation.Camera;
ComputeSensorTransform(camera);
GL.ClearColor(0f, 0f, 0f, 1f);
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
// bind color and depth textures
GL.ActiveTexture(TextureUnit.Texture0);
int lensSampleTex = IncrementalModeEnabled
? incrementalLensSampleTexture
: previewLensSampleTexture;
GL.BindTexture(TextureTarget.Texture3D, lensSampleTex);
//GL.ActiveTexture(TextureUnit.Texture1);
//GL.BindTexture(TextureTarget.Texture1D, pixelSampleTexture);
GL.ActiveTexture(TextureUnit.Texture2);
GL.BindTexture(TextureTarget.Texture2DArray, DepthPeeler.PackedDepthTextures);
GL.ActiveTexture(TextureUnit.Texture3);
GL.BindTexture(TextureTarget.Texture2DArray, DepthPeeler.ColorTextures);
GL.ActiveTexture(TextureUnit.Texture4);
GL.BindTexture(TextureTarget.Texture2DArray, NBuffers.NBuffersTextures);
// enable IBRT shader
GL.UseProgram(shaderProgram);
// set shader parameters (textures, lens model, ...)
GL.Uniform1(GL.GetUniformLocation(shaderProgram, "lensSamplesTexture"), 0);
//GL.Uniform1(GL.GetUniformLocation(shaderProgram, "pixelSamplesTexture"), 1);
GL.Uniform1(GL.GetUniformLocation(shaderProgram, "packedDepthTexture"), 2);
GL.Uniform1(GL.GetUniformLocation(shaderProgram, "colorTexture"), 3);
GL.Uniform1(GL.GetUniformLocation(shaderProgram, "nBuffersTexture"), 4);
GL.Uniform2(GL.GetUniformLocation(shaderProgram, "nBuffersSize"), NBuffers.Size);
GL.Uniform2(GL.GetUniformLocation(shaderProgram, "sensorSize"), camera.SensorSize);
//GL.Uniform1(GL.GetUniformLocation(shaderProgram, "sensorZ"), camera.SensorZ);
GL.Uniform3(GL.GetUniformLocation(shaderProgram, "sensorShift"), camera.SensorShift3);
GL.Uniform1(GL.GetUniformLocation(shaderProgram, "near"), camera.Near);
GL.Uniform1(GL.GetUniformLocation(shaderProgram, "far"), camera.Far);
GL.Uniform1(GL.GetUniformLocation(shaderProgram, "lensFocalLength"), camera.Lens.FocalLength);
GL.Uniform1(GL.GetUniformLocation(shaderProgram, "lensApertureRadius"), camera.Lens.ApertureRadius);
//Matrix4 perspective = camera.Perspective;
//GL.UniformMatrix4(GL.GetUniformLocation(shaderProgram, "perspective"), false, ref perspective);
GL.Uniform4(GL.GetUniformLocation(shaderProgram, "frustumBounds"), camera.FrustumBounds);
// jittering
GL.Uniform2(GL.GetUniformLocation(shaderProgram, "screenSize"), new Vector2(Width, Height));
GL.Uniform2(GL.GetUniformLocation(shaderProgram, "screenSizeInv"), new Vector2(1.0f / Width, 1.0f / Height));
GL.Uniform1(GL.GetUniformLocation(shaderProgram, "sampleCount"), (IncrementalModeEnabled ? SampleCount : PreviewSampleCount));
GL.Uniform1(GL.GetUniformLocation(shaderProgram, "sampleCountInv"), 1.0f / (IncrementalModeEnabled ? SampleCount : PreviewSampleCount));
GL.Uniform1(GL.GetUniformLocation(shaderProgram, "sampleIndexOffset"), IncrementalModeEnabled ? SampleCount * iteration : 0);
GL.Uniform1(GL.GetUniformLocation(shaderProgram, "totalSampleCount"), IncrementalModeEnabled ? MaxTotalSampleCount : PreviewSampleCount);
//GL.Uniform1(GL.GetUniformLocation(shaderProgram, "sampleCount"), SampleCount);
//GL.Uniform1(GL.GetUniformLocation(shaderProgram, "sampleCountInv"), 1.0f / SampleCount);
//GL.Uniform1(GL.GetUniformLocation(shaderProgram, "sampleIndexOffset"), SampleCount * iteration);
//GL.Uniform1(GL.GetUniformLocation(shaderProgram, "totalSampleCount"), TotalSampleCount);
GL.Uniform2(GL.GetUniformLocation(shaderProgram, "cameraShift"), camera.LensShift);
GL.UniformMatrix3(GL.GetUniformLocation(shaderProgram, "sensorTransform"), 1, false, sensorTransform3x3);
// draw the quad
LayerHelper.DrawQuad();
// disable shader
GL.UseProgram(0);
// unbind textures
GL.ActiveTexture(TextureUnit.Texture4);
GL.BindTexture(TextureTarget.Texture2D, 0);
GL.ActiveTexture(TextureUnit.Texture3);
GL.BindTexture(TextureTarget.Texture2D, 0);
GL.ActiveTexture(TextureUnit.Texture2);
GL.BindTexture(TextureTarget.Texture2D, 0);
GL.ActiveTexture(TextureUnit.Texture1);
GL.BindTexture(TextureTarget.Texture2D, 0);
GL.ActiveTexture(TextureUnit.Texture0);
GL.BindTexture(TextureTarget.Texture2D, 0);
}
public bool isNearWall(float Width, float rotation)
{
if (rotation == 1)
{
RaycastHit2D hit = Physics2D.Raycast(transform.position, Vector2.left, rayLengthExtended, LayerHelper.getLayers(new LayerHelper.Layer[] { LayerHelper.Layer.GROUND, LayerHelper.Layer.GOUND_NO_COLLISION }));
if (hit.collider != null)
{
return(true);
}
pushBack = Math.Abs(pushBack);
}
else if (rotation == 0)
{
RaycastHit2D hit = Physics2D.Raycast(transform.position, Vector2.right, rayLengthExtended, LayerHelper.getLayers(new LayerHelper.Layer[] { LayerHelper.Layer.GROUND, LayerHelper.Layer.GOUND_NO_COLLISION }));
if (hit.collider != null)
{
return(true);
}
pushBack = -Math.Abs(pushBack);
}
return(false);
}
/// <summary>
/// Sets the damagable layers.
/// </summary>
public void SetDamagableLayers()
{
_damagableLayers = LayerHelper.GetDamagableLayers(gameObject.layer);
}
void OnCollision(Collider2D _collider)
{
if (!activated)
{
return;
}
if (decaying)
{
return;
}
if (LayerHelper.Exist(collisionIgnores, _collider))
{
return;
}
if (m_Ricochet && !m_Ricochet.ShouldCollide(_collider))
{
return;
}
if (m_Ricochet)
{
if (!m_Ricochet.OnCollision(_collider))
{
StartDecay();
}
}
else
{
StartDecay();
}
if (LayerHelper.Exist(collisionTargets, _collider))
{
var _damageDetector = _collider.GetComponentInChildren <DamageDetector>();
if (!isHitOwner &&
(_damageDetector.GetInstanceID() == ownerDetecterID))
{
return;
}
if (_damageDetector != null &&
_damageDetector.enabled)
{
attackData.velocity = rigidbody2D.velocity;
_damageDetector.Damage(attackData);
}
if (postHit != null)
{
postHit(this, _collider);
}
// todo: server를 통해서 이루어져야합니다.
if (effectHitPrf)
{
var _effectHit = GameObject.Instantiate(effectHitPrf, transform.position, transform.rotation) as GameObject;
_effectHit.transform.Translate(effectHitOffset);
}
}
else if (LayerHelper.Exist(collisionTargets, _collider.gameObject))
{
if (postBumped != null)
{
postBumped(this, _collider);
}
}
if (postCollide != null)
{
postCollide(this, _collider);
}
}
public void SetLayerHelper(LayerHelper layerHelper)
{
this.layerHelper = layerHelper;
layerHelper.BaseLayersChanged += LayerHelperBaseLayersChanged;
layerHelper.LayersChanged += LayerHelperLayersChanged;
}
// Update is called once per frame
void Update()
{
Bounds bounds = coll2D.bounds;
Vector3 extents = bounds.extents;
RaycastHit2D[] hit2Ds = Tool.RaycastAll2D(bounds.center, -myTrans.up, extents.y, extents.x, 2, LayerHelper.GetLayerMask(standLayerNames, true));
bool checkStand = Tool.IsCheck(hit2Ds);
if (!checkStand)
{
if (uncheckStandStartTime < 0)
{
uncheckStandStartTime = Time.time;
}
float deltaTime = Time.time - uncheckStandStartTime;
myTrans.position += (Vector3)(gravity * deltaTime * deltaTime * .5f);
}
else
{
Vector2 point = AveragePoint(hit2Ds);
Vector3 position = myTrans.position;
float x = position.x;
float y = point.y + extents.y - (bounds.center.y - position.y);
float z = position.z;
Vector3 newPosition = Vector3.right * x + Vector3.up * y + Vector3.forward * z;
myTrans.position = newPosition;
uncheckStandStartTime = -1;
}
}
private void OnAnimationEvent(Spine.AnimationState state, int trackIndex, Spine.Event e)
{
AudioSource audioSource = null;
string name = e.Data.Name;
switch (name)
{
case "refereePig_fall":
audioSource = WPFMonoBehaviour.gameData.commonAudioCollection.refereePigFall;
goto IL_282;
case "refereePig_flag":
audioSource = WPFMonoBehaviour.gameData.commonAudioCollection.refereePigFlag;
goto IL_282;
case "refereePig_impact":
audioSource = WPFMonoBehaviour.gameData.commonAudioCollection.refereePigImpact;
goto IL_282;
case "refereePig_whistle":
audioSource = WPFMonoBehaviour.gameData.commonAudioCollection.refereePigWhistle;
goto IL_282;
case "safe_drop":
audioSource = WPFMonoBehaviour.gameData.commonAudioCollection.safeDrop;
goto IL_282;
case "you_win_pillow_appear":
audioSource = WPFMonoBehaviour.gameData.commonAudioCollection.youWinPillowAppear;
goto IL_282;
case "refereePig_fall_impact":
audioSource = WPFMonoBehaviour.gameData.commonAudioCollection.refereePigFallImpact;
goto IL_282;
case "Anticipation":
audioSource = WPFMonoBehaviour.gameData.commonAudioCollection.scoreAnticipation[0];
goto IL_282;
case "win_trumpet":
{
AudioSource[] winTrumpet = WPFMonoBehaviour.gameData.commonAudioCollection.winTrumpet;
audioSource = winTrumpet[UnityEngine.Random.Range(0, winTrumpet.Length)];
goto IL_282;
}
case "confetti1":
{
GameObject gameObject = UnityEngine.Object.Instantiate <GameObject>(this.confettiParticlesPrefab);
LayerHelper.SetSortingLayer(gameObject, "Popup", true);
LayerHelper.SetLayer(gameObject, base.gameObject.layer, true);
gameObject.transform.position = WPFMonoBehaviour.hudCamera.ViewportToWorldPoint(new Vector3(0.333333343f, 0f));
goto IL_282;
}
case "confetti2":
{
GameObject gameObject2 = UnityEngine.Object.Instantiate <GameObject>(this.confettiParticlesPrefab);
LayerHelper.SetSortingLayer(gameObject2, "Popup", true);
LayerHelper.SetLayer(gameObject2, base.gameObject.layer, true);
gameObject2.transform.position = WPFMonoBehaviour.hudCamera.ViewportToWorldPoint(new Vector3(0.6666667f, 0f));
goto IL_282;
}
}
audioSource = null;
IL_282:
if (audioSource != null)
{
Singleton <AudioManager> .Instance.Spawn2dOneShotEffect(audioSource);
}
}
public override void Update()
{
base.Update();
Bounds bounds = coll.bounds;
Vector3 extents = bounds.extents;
Vector3 right = rootTrans.right;
RaycastHit2D[] hit2Ds = Tool.RaycastAll2D(bounds.center, right, extents.x, extents.y, 5, LayerHelper.GetLayerMask(layerSize, true));
if (!Tool.IsCheck(hit2Ds))
{
Vector3 newPosition = rootTrans.position;
newPosition += rootTrans.right * sprintingSpeed * Time.deltaTime;
if (!Tool.IsOutOfCameraX(newPosition.x, -coll.bounds.extents.x))
{
rootTrans.position = newPosition;
}
}
}
public void SetLayers_ThrowsOnNull() => LayerHelper.SetLayers(null);
public virtual void down()
{
RaycastHit2D hit = Physics2D.Raycast(transform.position, -Vector2.up, rayLength, 1 << LayerHelper.getLayer(LayerHelper.Layer.GOUND_NO_COLLISION));
if (hit.collider != null)
{
OneWayPlatform oneWayPlatForm = hit.collider.gameObject.GetComponent <OneWayPlatform>();
oneWayPlatForm.unblock(this.name, 0.1f);
}
}
public void SetLayers_DoesNotThrowOnEmptyList() => LayerHelper.SetLayers(new List <Node>());
public bool isNearGround()
{
RaycastHit2D hit = Physics2D.Raycast(transform.position, -Vector2.up, rayLengthExtended, LayerHelper.getLayers(new LayerHelper.Layer[] { LayerHelper.Layer.GROUND, LayerHelper.Layer.GOUND_NO_COLLISION }));
if (hit.collider != null)
{
return(true);
}
return(false);
}
private void CleanupOnFailure()
{
Destroy(effectGroup);
LayerHelper.SetLayer(target, previousLayer);
}
