// Retrace portals between corners and register if type of polygon changes
public static int RetracePortals(NavMeshQuery query, int startIndex, int endIndex, NativeSlice <PolygonId> path, int n, Vector3 termPos, ref NativeList <NavMeshLocation> straightPath, int maxStraightPath)
{
#if DEBUG_CROWDSYSTEM_ASSERTS
Assert.IsTrue(n < maxStraightPath);
Assert.IsTrue(startIndex <= endIndex);
#endif
for (var k = startIndex; k < endIndex - 1; ++k)
{
var type1 = query.GetPolygonType(path[k]);
var type2 = query.GetPolygonType(path[k + 1]);
if (type1 != type2)
{
Vector3 l, r;
var status = query.GetPortalPoints(path[k], path[k + 1], out l, out r);
#if DEBUG_CROWDSYSTEM_ASSERTS
Assert.IsTrue(status); // Expect path elements k, k+1 to be verified
#endif
float3 cpa1, cpa2;
GeometryUtils.SegmentSegmentCPA(out cpa1, out cpa2, l, r, straightPath[n - 1].position, termPos);
straightPath.Add(query.CreateLocation(cpa1, path[k + 1]));
// straightPathFlags[n] = (type2 == NavMeshPolyTypes.OffMeshConnection) ? StraightPathFlags.OffMeshConnection : 0;
if (++n == maxStraightPath)
{
// Debug.Log($"1： {n} {maxStraightPath} {startIndex} {endIndex} {straightPath.Length}");
return(maxStraightPath);
}
}
}
// Debug.Log($"2：{n} {maxStraightPath} {startIndex} {endIndex} {straightPath.Length}");
// if (n < straightPath.Length)
// {
straightPath.Add(query.CreateLocation(termPos, path[endIndex]));
// straightPathFlags[n] = query.GetPolygonType(path[endIndex]) == NavMeshPolyTypes.OffMeshConnection ? StraightPathFlags.OffMeshConnection : 0;
return(++n);
// }
// else
// {
// // Debug.LogWarning($"寻路出现错误 {termPos}");
// // 拐角的时候可能多一个，然后就错误，暂时这样改
// straightPath[n - 1] = query.CreateLocation(termPos, path[endIndex]);
// straightPathFlags[n - 1] = query.GetPolygonType(path[endIndex]) == NavMeshPolyTypes.OffMeshConnection ? StraightPathFlags.OffMeshConnection : 0;
// // for (var i = 0; i < straightPath.Length; i++)
// // {
// // Debug.Log(straightPath[i].position);
// // }
// }
// // if (n > straightPath.Length - 1) // Fix for IndexOutOfRangeException with one point on straightPath[n]
// // {
// // return n;
// // }
// // straightPath[n] = query.CreateLocation(termPos, path[endIndex]);
// // straightPathFlags[n] = query.GetPolygonType(path[endIndex]) == NavMeshPolyTypes.OffMeshConnection ? StraightPathFlags.OffMeshConnection : 0;
// // return ++n;
// return n;
}
void CalculateClosestLandmark(ILandmarkController landmark)
{
var settings = landmark.settings as ClosestLandmarkSettings;
if (settings == null)
{
return;
}
if (worldVertices == null || settings.target == null)
{
return;
}
if (m_WorldVerts.Count < 3)
{
return;
}
Vector3 edgeVertA;
Vector3 edgeVertB;
switch (landmark.output)
{
case LandmarkOutputPoint landmarkPoint:
{
var targetPolygon = settings.target as LandmarkOutputPolygon;
if (targetPolygon && targetPolygon.worldVertices.Count > 0)
{
Vector3 closestOnThis, closestOnOther;
GeometryUtils.ClosestPolygonApproach(m_WorldVerts, targetPolygon.worldVertices, out closestOnThis, out closestOnOther);
landmarkPoint.position = closestOnThis;
}
else
{
var targetPosition = settings.target.transform.position;
var planeNormal = Vector3.Cross(m_WorldVerts[0] - m_WorldVerts[1], m_WorldVerts[2] - m_WorldVerts[1]).normalized;
var pointOnInfinitePlane = GeometryUtils.ProjectPointOnPlane(planeNormal, m_WorldVerts[1], targetPosition);
if (GeometryUtils.PointInPolygon3D(pointOnInfinitePlane, m_WorldVerts))
{
landmarkPoint.position = pointOnInfinitePlane;
}
else
{
GeometryUtils.FindClosestEdge(m_WorldVerts, targetPosition, out edgeVertA, out edgeVertB);
landmarkPoint.position = GeometryUtils.ClosestPointOnLineSegment(targetPosition, edgeVertA, edgeVertB);
}
}
}
break;
case LandmarkOutputEdge landmarkEdge:
{
var targetPosition = settings.target.transform.position;
GeometryUtils.FindClosestEdge(m_WorldVerts, targetPosition, out edgeVertA, out edgeVertB);
landmarkEdge.startPoint = edgeVertA;
landmarkEdge.endPoint = edgeVertB;
}
break;
case LandmarkOutputPose landmarkPose:
{
var targetPolygon = settings.target as LandmarkOutputPolygon;
Vector3 closestOnThis, closestOnOther;
if (targetPolygon && targetPolygon.worldVertices.Count > 0)
{
GeometryUtils.ClosestPolygonApproach(m_WorldVerts, targetPolygon.worldVertices, out closestOnThis, out closestOnOther);
}
else
{
closestOnOther = settings.target.transform.position;
var planeNormal = Vector3.Cross(m_WorldVerts[0] - m_WorldVerts[1], m_WorldVerts[2] - m_WorldVerts[1]).normalized;
var pointOnInfinitePlane = GeometryUtils.ProjectPointOnPlane(planeNormal, m_WorldVerts[1], closestOnOther);
if (GeometryUtils.PointInPolygon3D(pointOnInfinitePlane, m_WorldVerts))
{
closestOnThis = pointOnInfinitePlane;
}
else
{
GeometryUtils.FindClosestEdge(m_WorldVerts, closestOnOther, out edgeVertA, out edgeVertB);
closestOnThis = GeometryUtils.ClosestPointOnLineSegment(closestOnOther, edgeVertA, edgeVertB);
}
}
// Make sure look direction is flattened along the plane
var lookDirection = closestOnOther - closestOnThis;
lookDirection = Vector3.Cross(Vector3.Cross(lookDirection, transform.up), transform.up);
landmarkPose.currentPose = new Pose {
position = closestOnThis, rotation = Quaternion.LookRotation(lookDirection)
};
}
break;
}
}
private IEnumerable <IPath> GetConnectLineCandidates(
[NotNull] IPoint forUnpairedSourcePoint,
[NotNull] IPath reshapePath,
[NotNull] IList <IGeometry> geometriesToReshape,
IPointCollection sketchOriginalIntersectionPoints)
{
var touchingPaths = new List <IPath>();
if (_sourceIntersectionLines != null)
{
foreach (IPath intersectionPath in
GeometryUtils.GetPaths(_sourceIntersectionLines))
{
if (
GeometryUtils.AreEqualInXY(intersectionPath.FromPoint,
forUnpairedSourcePoint) ||
GeometryUtils.AreEqualInXY(intersectionPath.ToPoint, forUnpairedSourcePoint)
)
{
touchingPaths.Add(intersectionPath);
}
}
}
var connectLineCandidates = new List <IPath>();
foreach (IPath sharedBoundary in touchingPaths)
{
if (IntersectsOtherSourceTargetConnection(sharedBoundary,
sketchOriginalIntersectionPoints,
SourceTargetPairs))
{
continue;
}
IList <IGeometry> sharedBoundaryPolys;
if (PathRunsAlongSeveralPolygons(sharedBoundary, geometriesToReshape,
forUnpairedSourcePoint,
out sharedBoundaryPolys))
{
IGeometry sharedBoundaryPoly = sharedBoundaryPolys[0];
double xyTolerance = GeometryUtils.GetXyTolerance(sharedBoundaryPoly);
var curveToReshape =
(ICurve)
GeometryUtils.GetHitGeometryPart(forUnpairedSourcePoint, sharedBoundaryPoly,
xyTolerance);
Assert.NotNull(curveToReshape);
IPoint targetConnectPoint;
IPath connectLineCandidate = GetSharedBoundaryProlongation(
curveToReshape, sharedBoundary, forUnpairedSourcePoint, reshapePath,
xyTolerance,
out targetConnectPoint);
// Only change those polygons that have not already been reshaped using the sketch.
if (connectLineCandidate != null &&
AllPolygonsAreDisjoint(sharedBoundaryPolys, targetConnectPoint) &&
!CrossesOtherGeometry(connectLineCandidate, geometriesToReshape))
{
connectLineCandidates.Add(connectLineCandidate);
}
}
}
return(connectLineCandidates);
}
override protected void CreateResources()
{
// RgbaFloat lightColor = RgbaFloat.Orange;
RgbaFloat lightColor = RgbaFloat.Blue;
//RgbaFloat lightColor = RgbaFloat.LightGrey;
var spotLightPos = new Vector4(0.0f, 5.0f, 7.0f, 1.0f);
var lightLookAt = spotLightPos - Light.DEFAULT_POSITION;
var lightCam = new OrthographicCamera(35, 35, Light.DEFAULT_POSITION, lightLookAt);
var spotLightCam = new OrthographicCamera(RenderResoultion.Horizontal, RenderResoultion.Vertical, spotLightPos, Light.DEFAULT_LOOKAT);
// RgbaFloat lightColor = new RgbaFloat(1.0f,0.36f,0.0f,0.2f);
_sceneRuntimeState.Light = new Light(lightCam, lightColor, 0.1f);
_sceneRuntimeState.Camera = Camera;
_sceneRuntimeState.SpotLight
= new Light(
spotLightCam,
RgbaFloat.DarkRed,
1.0f,
0.02f,
new Vector4(Math.Cos(17.5f.ToRadians()).ToFloat(), Math.Cos(12.5f.ToRadians()).ToFloat(), 0.0f, 1.0f));
// Sun //TODO: Make this VertexPositionNormalColor
_sun = new Model <VertexPositionNormal, RealtimeMaterial>(String.Empty, GeometryFactory.GenerateSphereNormal(100, 100, 1), new RealtimeMaterial());
var sunMeshZero = _sun.GetMesh(0);
var sunMaterialZero = _sun.GetMaterial(0);
// _sun.meshes[0].TryGetMaterial().ambient = new Vector4(0.0f,0.0f,0.0f,0.0f);
sunMaterialZero.ambient = lightColor.ToVector4();
Vector4 lightPos = _sceneRuntimeState.Light.LightPos;
Vector3 newTranslation = new Vector3(lightPos.X, lightPos.Y, lightPos.Z);
_sun.SetNewWorldTranslation(ref newTranslation, true);
//TODO: This geometry will cause problems for shadow mapping. Has to be ignored in the shadowmap generation process.
var sunRuntimeState = new ModelRuntimeDescriptor <VertexPositionNormal>(_sun, "Phong", "PhongNoShadow", VertexRuntimeTypes.VertexPositionNormal, PrimitiveTopology.TriangleList, new RenderDescription(RenderFlags.NORMAL), new InstancingRenderDescription(RenderFlags.NONE, InstancingDataFlags.EMPTY));
sunRuntimeState.CallVertexLayoutGeneration += ResourceGenerator.GenerateVertexLayoutForPN;
_modelPNDescriptorList.Add(sunRuntimeState);
var spotlight = new Model <VertexPositionNormal, RealtimeMaterial>(String.Empty, GeometryFactory.GenerateSphereNormal(100, 100, 1), new RealtimeMaterial());
var spotlightMeshZero = spotlight.GetMesh(0);
var spotlightMaterialZero = spotlight.GetMaterial(0);
//TODO: @Bug: Seems to be an issue with ambient selecting the wrong color
spotlightMaterialZero.ambient = _sceneRuntimeState.SpotLight.Color_DontMutate;
// spotlight.meshes[0].TryGetMaterial().ambient = new Vector4(1.0f,1.0f,1.0f,1.0f);
// _sun.meshes[0].TryGetMaterial().ambient = lightColor.ToVector4();
Vector4 lightPosSpot = _sceneRuntimeState.SpotLight.LightPos;
Vector3 newTranslationSpot = new Vector3(lightPosSpot.X, lightPosSpot.Y, lightPosSpot.Z);
spotlight.SetNewWorldTranslation(ref newTranslationSpot, true);
var spotLightRuntimeState = new ModelRuntimeDescriptor <VertexPositionNormal>(spotlight, "Phong", "PhongNoShadow", VertexRuntimeTypes.VertexPositionNormal, PrimitiveTopology.TriangleList, new RenderDescription(RenderFlags.NORMAL | RenderFlags.SHADOW_MAP), new InstancingRenderDescription(RenderFlags.NONE, InstancingDataFlags.EMPTY));
spotLightRuntimeState.CallVertexLayoutGeneration += ResourceGenerator.GenerateVertexLayoutForPN;
_modelPNDescriptorList.Add(spotLightRuntimeState);
// Colored Quad
// var offsets = new Vector3[] {new Vector3(-1.0f,0.0f,0f),new Vector3(1.0f,0.0f,0.0f)};
// // var offsets = new Vector3[] {new Vector3(0.0f,0.0f,0.0f)};
// var instancingData = new InstancingData {Positions = offsets};
// var floor = new Model<VertexPositionColor>(String.Empty,GeometryFactory.GenerateColorQuad(RgbaFloat.Red,RgbaFloat.Yellow,RgbaFloat.Green,RgbaFloat.LightGrey));
// var floorRuntimeState = new ModelRuntimeDescriptor<VertexPositionColor>(floor,"OffsetColor","Color",VertexTypes.VertexPositionColor,PrimitiveTopology.TriangleStrip);
// floorRuntimeState.TotalInstanceCount = offsets.Length.ToUnsigned();
// floorRuntimeState.CallVertexLayoutGeneration+=ResourceGenerator.GenerateVertexLayoutForPC;
// floorRuntimeState.CallVertexInstanceLayoutGeneration+=ResourceGenerator.GenerateVertexInstanceLayoutForPC;
// _modelPCDescriptorList.Add(floorRuntimeState);
//Quad Textured
// var offsets = new Vector3[] {new Vector3(-1.0f,0.0f,0f),new Vector3(1.0f,0.0f,0.0f)};
// // var offsets = new Vector3[] {new Vector3(0.0f,0.0f,0.0f)};
// var instancingData = new InstancingData {Positions = offsets};
// var floor = new Model<VertexPositionTexture>("paving",GeometryFactory.GenerateTexturedQuad());
// floor.meshes[0].TryGetMaterial().textureDiffuse="pavingColor.jpg";
// var floorRuntimeState = new ModelRuntimeDescriptor<VertexPositionTexture>(floor,"PositionOffsetTexture","Texture",VertexTypes.VertexPositionTexture,PrimitiveTopology.TriangleStrip);
// floorRuntimeState.TotalInstanceCount = offsets.Length.ToUnsigned();
// floorRuntimeState.CallVertexLayoutGeneration+=ResourceGenerator.GenerateVertexLayoutForPT;
// floorRuntimeState.CallVertexInstanceLayoutGeneration+=ResourceGenerator.GenerateVertexInstanceLayoutForPositionOffset;
// floorRuntimeState.CallTextureResourceLayoutGeneration+=ResourceGenerator.GenerateTextureResourceLayoutForDiffuseMapping;
// floorRuntimeState.CallTextureResourceSetGeneration+=ResourceGenerator.GenerateTextureResourceSetForDiffuseMapping;
// floorRuntimeState.CallSamplerGeneration+=ResourceGenerator.GenerateLinearSampler;
// _modelPTDescriptorList.Add(floorRuntimeState);
// floor
// var offsets = new Vector3[] {new Vector3(-1.0f,0.0f,0f),new Vector3(1.0f,0.0f,0.0f)};
// var offsets = new Vector3[] {new Vector3(0.0f,0.0f,0.0f)};
var offsets = GeometryUtils.CreateTilingList_XZ(-20, 20, -10, 10, 0, GeometryFactory.QUAD_WIDTH, GeometryFactory.QUAD_HEIGHT);
// var offsets = GeometryUtils.CreateTilingList_XZ(-1,1,0,0,0,GeometryFactory.QUAD_WIDTH,GeometryFactory.QUAD_HEIGHT);
var instancingData = new InstanceData {
Flag = InstancingDataFlags.POSITION, Positions = offsets
};
var floor = new Model <VertexPositionNormalTextureTangentBitangent, RealtimeMaterial>("paving/", GeometryFactory.GenerateQuadPNTTB_XZ(), new RealtimeMaterial());
var floorMeshZero = floor.GetMesh(0);
var flootMaterialZero = floor.GetMaterial(0);
flootMaterialZero.textureDiffuse = "pavingColor.jpg";
flootMaterialZero.textureNormal = "pavingNorm.jpg";
flootMaterialZero.ambient = new Vector4(0.3f, 0.3f, 0.3f, 1.0f);
var floorTranslation = new Vector3(0.0f, -2.0f, 0.0f);
floor.SetNewWorldTranslation(ref floorTranslation, true);
var floorRuntimeState = new ModelRuntimeDescriptor <VertexPositionNormalTextureTangentBitangent>(floor, "PositionOffsetPhongBitangentTexture", "PhongBitangentTexture", VertexRuntimeTypes.VertexPositionNormalTextureTangentBitangent, PrimitiveTopology.TriangleStrip, new RenderDescription(RenderFlags.NORMAL | RenderFlags.SHADOW_MAP), new InstancingRenderDescription(RenderFlags.SHADOW_MAP, InstancingDataFlags.POSITION));
floorRuntimeState.TotalInstanceCount = offsets.Length.ToUnsigned();
//TODO: Test ViewMatrix Instancing
// Matrix4x4 test = Camera.ViewMatrix;
// Matrix4x4 test2 = Camera.ViewMatrix;
// test.Translation = new Vector3(0,1,-10);
// test2.Translation = new Vector3(0,0,-10);
// var viewMatrices = new Matrix4x4[] {test2, test};
// var viewInstancingData = new InstancingData{
// Types = InstancingTypes.ViewMatricies,
// ViewMatrices = viewMatrices
// };
// var floorRuntimeState = new ModelRuntimeDescriptor<VertexPositionNormalTextureTangentBitangent>(floor, "ViewMatInstancePhongBitangentTexture", "PhongBitangentTexture", VertexRuntimeTypes.VertexPositionNormalTextureTangentBitangent, PrimitiveTopology.TriangleStrip, RenderFlags.NORMAL | RenderFlags.SHADOW_MAP);
//floorRuntimeState.TotalInstanceCount = viewMatrices.Length.ToUnsigned();
floorRuntimeState.CallVertexLayoutGeneration += ResourceGenerator.GenerateVertexLayoutForPNTTB;
floorRuntimeState.AddVertexInstanceDelegate(InstancingDataFlags.POSITION, ResourceGenerator.GenerateVertexInstanceLayoutForPositionOffset);
floorRuntimeState.AddPreEffectsVertexInstanceDelegate(RenderFlags.SHADOW_MAP, ResourceGenerator.GenerateVertexLayoutForPNTTB);
//floorRuntimeState.CallVertexInstanceLayoutGeneration+=ResourceGenerator.GenerateVertexInstanceLayoutForViewMatrixOffset; //viewMatInstance
floorRuntimeState.CallTextureResourceLayoutGeneration += ResourceGenerator.GenerateTextureResourceLayoutForNormalMapping;
floorRuntimeState.CallTextureResourceSetGeneration += ResourceGenerator.GenerateTextureResourceSetForNormalMapping;
floorRuntimeState.CallSamplerGeneration += ResourceGenerator.GenerateTriLinearSampler;
_modelPNTTBDescriptorList.Add(floorRuntimeState);
InstanceData[] instancingDataPN = { InstanceData.NO_DATA };
InstanceData[] instancingDataPNTTB = { instancingData };
foreach (var modelDescriptor in _modelPNDescriptorList)
{
FillRuntimeDescriptor(modelDescriptor, _sceneRuntimeState, instancingDataPN);
PNRuntimeGeometry.AddModel(modelDescriptor);
}
// foreach(var modelDescriptor in _modelPTDescriptorList){
// FillRuntimeDescriptor(modelDescriptor,_sceneRuntimeState,InstancingData.NO_DATA);
// }
foreach (var modelDescriptor in _modelPNTTBDescriptorList)
{
FillRuntimeDescriptor(modelDescriptor, _sceneRuntimeState, instancingDataPNTTB);
PNTTBRuntimeGeometry.AddModel(modelDescriptor);
}
}
public DensityVolumeList PrepareVisibleDensityVolumeList(HDCamera hdCamera, CommandBuffer cmd, float time)
{
DensityVolumeList densityVolumes = new DensityVolumeList();
if (!hdCamera.frameSettings.IsEnabled(FrameSettingsField.Volumetrics))
{
return(densityVolumes);
}
var visualEnvironment = VolumeManager.instance.stack.GetComponent <VisualEnvironment>();
if (visualEnvironment.fogType.value != FogType.Volumetric)
{
return(densityVolumes);
}
using (new ProfilingSample(cmd, "Prepare Visible Density Volume List"))
{
Vector3 camPosition = hdCamera.camera.transform.position;
Vector3 camOffset = Vector3.zero;// World-origin-relative
if (ShaderConfig.s_CameraRelativeRendering != 0)
{
camOffset = camPosition; // Camera-relative
}
m_VisibleVolumeBounds.Clear();
m_VisibleVolumeData.Clear();
// Collect all visible finite volume data, and upload it to the GPU.
DensityVolume[] volumes = DensityVolumeManager.manager.PrepareDensityVolumeData(cmd, hdCamera.camera, time);
for (int i = 0; i < Math.Min(volumes.Length, k_MaxVisibleVolumeCount); i++)
{
DensityVolume volume = volumes[i];
// TODO: cache these?
var obb = new OrientedBBox(Matrix4x4.TRS(volume.transform.position, volume.transform.rotation, volume.parameters.size));
// Handle camera-relative rendering.
obb.center -= camOffset;
// Frustum cull on the CPU for now. TODO: do it on the GPU.
// TODO: account for custom near and far planes of the V-Buffer's frustum.
// It's typically much shorter (along the Z axis) than the camera's frustum.
// XRTODO: fix combined frustum culling
if (GeometryUtils.Overlap(obb, hdCamera.frustum, 6, 8) || hdCamera.camera.stereoEnabled)
{
// TODO: cache these?
var data = volume.parameters.ConvertToEngineData();
m_VisibleVolumeBounds.Add(obb);
m_VisibleVolumeData.Add(data);
}
}
s_VisibleVolumeBoundsBuffer.SetData(m_VisibleVolumeBounds);
s_VisibleVolumeDataBuffer.SetData(m_VisibleVolumeData);
// Fill the struct with pointers in order to share the data with the light loop.
densityVolumes.bounds = m_VisibleVolumeBounds;
densityVolumes.density = m_VisibleVolumeData;
return(densityVolumes);
}
}
public void TestCalcTriangleArea8_ThrowsException()
{
double area = GeometryUtils.CalcTriangleArea(18.24, 100, 31.0057);
}
public SubcurveFilter PrepareFilter(
[NotNull] IList <IPolyline> preprocessedSourceLines,
[NotNull] IList <IGeometry> targetGeometries,
bool useMinimalTolerance,
[NotNull] ReshapeCurveFilterOptions filterOptions)
{
_useMinimalTolerance = useMinimalTolerance;
_filterOptions = filterOptions;
ReleaseFilterObjects();
if (filterOptions.OnlyInVisibleExtent)
{
Assert.NotNull(_extentProvider);
_currentlyVisibleExtents = new List <IEnvelope>();
// add the lens window extents
_currentlyVisibleExtents.AddRange(
_extentProvider.GetVisibleLensWindowExtents());
// plus the main map window
_currentlyVisibleExtents.Add(_extentProvider.GetCurrentExtent());
}
if (filterOptions.ExcludeOutsideTolerance)
{
// NOTE: Buffer lines / outlines -> otherwise we miss lines for individual reshapes
// and clip on extent (pre-process) before buffering to improve performance
var sourceOutline =
(IPolyline)GeometryUtils.UnionGeometries(preprocessedSourceLines);
const int logInfoPointCountThreshold = 10000;
var bufferNotifications = new NotificationCollection();
if (AdjustUtils.TryBuffer(sourceOutline,
filterOptions.ExcludeTolerance,
logInfoPointCountThreshold,
"Calculating reshape line tolerance buffer...",
bufferNotifications,
out _mustBeWithinSourceBuffer))
{
ExclusionOutsideSourceBufferLine =
GeometryFactory.CreatePolyline(
Assert.NotNull(_mustBeWithinSourceBuffer));
}
else
{
_msg.WarnFormat(
"Unable to calculate reshape line tolerance buffer: {0}",
bufferNotifications.Concatenate(". "));
}
Marshal.ReleaseComObject(sourceOutline);
}
if (filterOptions.ExcludeResultingInOverlaps)
{
_targetUnionPoly = ReshapeUtils.CreateUnionPolygon(
targetGeometries, _useMinimalTolerance);
}
return(this);
}
public void TestCalcDistance1()
{
double distance = GeometryUtils.CalcDistance(0, 0, 1, 1);
Assert.AreEqual(Math.Sqrt(2), distance);
}
public void TestCalcDistance2()
{
double distance = GeometryUtils.CalcDistance(1, 1, 5, 4);
Assert.AreEqual(5, distance);
}
private IMultiPatch ReadMultipatch(BinaryReader reader,
Ordinates expectedOrdinates,
bool groupPartsByPointIDs = false)
{
IMultiPatch result = new MultiPatchClass();
if (groupPartsByPointIDs)
{
GeometryUtils.MakePointIDAware(result);
}
int polyhedraCount = checked ((int)reader.ReadUInt32());
for (int i = 0; i < polyhedraCount; i++)
{
WkbGeometryType geometryType;
Ordinates ordinates;
ReadWkbType(reader, false,
out geometryType, out ordinates);
Assert.AreEqual(WkbGeometryType.PolyhedralSurface, geometryType,
"Unexpected geometry type");
Assert.AreEqual(expectedOrdinates, ordinates,
"Unexpected ordinates dimension");
int polygonCount = checked ((int)reader.ReadUInt32());
for (int p = 0; p < polygonCount; p++)
{
ReadWkbType(reader, false,
out geometryType, out expectedOrdinates);
Assert.AreEqual(WkbGeometryType.Polygon, geometryType,
"Unexpected geometry type");
var rings = ReadSingleExteriorRingPolygon(reader, ordinates, false).ToList();
if (rings.Count == 0)
{
continue;
}
if (groupPartsByPointIDs)
{
AssignPointIds(rings, i);
}
var outerRingType = rings.Count > 1
? esriMultiPatchRingType.esriMultiPatchOuterRing
: p == 0 || groupPartsByPointIDs
? esriMultiPatchRingType.esriMultiPatchFirstRing
: esriMultiPatchRingType.esriMultiPatchRing;
IRing outerRing = rings[0];
GeometryFactory.AddRingToMultiPatch(outerRing, result, outerRingType);
if (rings.Count > 1)
{
for (int r = 1; r < rings.Count; r++)
{
IRing innerRing = rings[r];
GeometryFactory.AddRingToMultiPatch(
innerRing, result, esriMultiPatchRingType.esriMultiPatchInnerRing);
}
}
}
}
return(result);
}
private void ProcessFeature([NotNull] Feature feature)
{
var shape = feature.GetShape();
var point = Assert.NotNull(shape as MapPoint, "Input shape is not MapPoint");
IDictionary <Feature, double> distanceByFeature =
GetNearFeatures(point, _referenceDatasets, _searchDistance);
if (distanceByFeature.Count == 0)
{
_msg.DebugFormat(
"Marker feature {0}: No reference feature found within search distance of {1}",
ProcessingUtils.Format(feature), _searchDistance);
return;
}
var nearest = distanceByFeature.OrderBy(f => f.Value).First();
var referenceFeature = Assert.NotNull(nearest.Key, "Oops, bug");
var distance = nearest.Value; // may be zero
var referenceShape = referenceFeature.GetShape();
var referenceCurve = Assert.NotNull(referenceShape as Multipart,
"Reference shape is not Multipart");
double distanceAlongCurve = GeometryUtils.GetDistanceAlongCurve(referenceCurve, point);
double normalLength = Math.Max(_inputDataset.XYTolerance, distance);
var normalPoly = GeometryEngine.Instance.QueryNormal(
referenceCurve, SegmentExtension.NoExtension, distanceAlongCurve,
AsRatioOrLength.AsLength, normalLength);
var normal = (LineSegment)normalPoly.Parts[0][0]; // TODO safety guards
double tangentLength = Math.Max(_inputDataset.XYTolerance, distance);
var tangentPoly = GeometryEngine.Instance.QueryTangent(
referenceCurve, SegmentExtension.NoExtension, distanceAlongCurve,
AsRatioOrLength.AsLength, tangentLength);
var tangent = (LineSegment)tangentPoly.Parts[0][0]; // TODO safety guards
// ILine.Angle is the angle between line and positive x axis,
// but the Angle property of a representation marker has its
// zero point at North: add 90° to ILine.Angle to fix:
double normalOffset = MathUtils.ToDegrees(normal.Angle) - 90;
double normalAngle = ProcessingUtils.ToPositiveDegrees(normalOffset);
double tangentOffset = MathUtils.ToDegrees(tangent.Angle) - 90;
double tangentAngle = ProcessingUtils.ToPositiveDegrees(tangentOffset);
_markerFieldSetter.ForgetAll()
.DefineFields(feature, InputQualifier)
.DefineFields(referenceFeature, ReferenceQualifier)
.DefineValue("normalAngle", normalAngle)
.DefineValue("tangentAngle", tangentAngle)
.DefineValue("distance", distance)
.Execute(feature);
feature.Store();
FeaturesAligned += 1;
_msg.DebugFormat(
"Marker feature {0}: aligned to {1} (normalAngle: {2}, tangentAngle: {3}, distance: {4})",
ProcessingUtils.Format(feature), ProcessingUtils.Format(referenceFeature),
normalAngle, tangentAngle, distance);
// TODO need some mechanism to ensure disposal (required by Pro SDK documentation); see also OneNote
foreach (var pair in distanceByFeature)
{
pair.Key.Dispose();
}
}
protected override void AdaptMZAware(IGeometry geometry)
{
GeometryUtils.MakeMAware(geometry);
}
private Geometry GetNearestSearchReference([NotNull] Geometry reference)
{
const int maxPointCount = 10000;
// todo daro: old implementation
//bool useCentroid = !GeometryUtils.IsGeometryValid(reference);
bool useCentroid = true;
if (!useCentroid && GeometryUtils.GetPointCount(reference) > maxPointCount)
{
_msg.Debug("Too many points on reference geometry for searching, using center of envelope");
useCentroid = true;
}
if (useCentroid)
{
MapPoint centroid = null;
try
{
// todo daro: old implementation
//var area = reference.Extent as IArea;
//if (area != null && ! area.Centroid.IsEmpty)
//{
// centroid = area.Centroid;
//}
if (!reference.IsEmpty)
{
centroid = GeometryEngine.Instance.Centroid(reference);
}
}
catch (Exception e)
{
_msg.Debug("Error trying to get centroid of geometry", e);
// todo daro: old implementation
//_msg.Debug(GeometryUtils.ToString(reference));
}
if (centroid == null)
{
return(null);
}
reference = centroid;
}
// todo daro: old implementation
//else
//{
// if (reference is IMultiPatch)
// {
// reference = ((IMultiPatch)reference).XYFootprint;
// }
//}
// todo daro: old implementation
//reference = GetInWorkListSpatialReference(reference);
return(reference);
}
private double ExecuteGJKAlgorithm(
VertexProperties[] vertexShape1,
VertexProperties[] vertexShape2,
ref CollisionPoint cp,
ref List <SupportTriangle> triangles,
ref Vector3d centroid,
ref bool isIntersection)
{
double minDistance = double.MaxValue;
int minTriangleIndex = -1;
var result = new CollisionPointOutput();
var oldDirection = new Vector3d();
var simplex = new Simplex();
//Primo punto del simplex
simplex.Support.Add(GetFarthestPoint(vertexShape1, vertexShape2, vertexShape2.Length / 2));
//Secondo punto del simplex
Vector3d direction = Vector3d.Normalize(simplex.Support[0].s * -1.0);
if (!simplex.AddSupport(Helper.GetMinkowskiFarthestPoint(vertexShape1, vertexShape2, direction)))
{
return(-1.0);
}
//Terzo punto del simplex
direction = Vector3d.Normalize(GetDirectionOnSimplex2(simplex));
if (!simplex.AddSupport(Helper.GetMinkowskiFarthestPoint(vertexShape1, vertexShape2, direction)))
{
return(-1.0);
}
//Quarto punto del simplex
direction = Vector3d.Normalize(GeometryUtils.CalculateTriangleNormal(
simplex.Support[0].s,
simplex.Support[1].s,
simplex.Support[2].s));
if (!simplex.AddSupport(Helper.GetMinkowskiFarthestPoint(vertexShape1, vertexShape2, direction)))
{
simplex.AddSupport(Helper.GetMinkowskiFarthestPoint(vertexShape1, vertexShape2, -1.0 * direction));
}
//Costruisco il poliedro
centroid = Helper.SetStartTriangle(
ref triangles,
simplex.Support.ToArray());
//Verifico che l'origine sia contenuta nel poliedro
if (Helper.IsInConvexPoly(origin, triangles))
{
isIntersection = true;
return(-1.0);
}
Vector3d triangleDistance = GetMinDistance(ref triangles, origin, ref minTriangleIndex);
result.SetDist(triangleDistance);
result.SetNormal(Vector3d.Normalize(triangleDistance));
Helper.GetVertexFromMinkowsky(triangles[minTriangleIndex], vertexShape1, vertexShape2, ref result);
minDistance = triangleDistance.Length();
for (int i = 0; i < MaxIterations; i++)
{
direction = -1.0 * triangleDistance.Normalize();
if (Vector3d.Length(direction) < constTolerance)
{
direction = origin - centroid;
}
if (direction == oldDirection)
{
break;
}
oldDirection = direction;
if (!simplex.AddSupport(Helper.GetMinkowskiFarthestPoint(vertexShape1, vertexShape2, direction)))
{
for (int j = 0; j < triangles.Count; j++)
{
direction = triangles[j].Normal;
if (!simplex.AddSupport(Helper.GetMinkowskiFarthestPoint(vertexShape1, vertexShape2, direction)))
{
if (simplex.AddSupport(Helper.GetMinkowskiFarthestPoint(vertexShape1, vertexShape2, -1.0 * direction)))
{
break;
}
continue;
}
break;
}
}
triangles = Helper.AddPointToConvexPolygon(triangles, simplex.Support[simplex.Support.Count - 1], centroid);
//Verifico che l'origine sia contenuta nel poliedro
if (Helper.IsInConvexPoly(origin, triangles))
{
isIntersection = true;
return(-1.0);
}
triangleDistance = GetMinDistance(ref triangles, origin, ref minTriangleIndex);
double mod = triangleDistance.Length();
if (mod < minDistance)
{
result.SetDist(triangleDistance);
result.SetNormal(triangles[minTriangleIndex].Normal);
Helper.GetVertexFromMinkowsky(triangles[minTriangleIndex], vertexShape1, vertexShape2, ref result);
minDistance = mod;
}
}
cp = new CollisionPoint(result.A, result.B);
return(minDistance);
}
public void TestCalcTriangleArea4_ThrowsException()
{
double area = GeometryUtils.CalcTriangleArea(10, 30, 0);
}
public void TestCalcDistance3()
{
double distance = GeometryUtils.CalcDistance(12.8, 9.73, 12.8, 9.73);
Assert.AreEqual(0, distance);
}
public void TestCalcTriangleArea7_ThrowsException()
{
double area = GeometryUtils.CalcTriangleArea(5, 12, -13);
}
public void TestIsLineHorizontal1_ThrowsException()
{
bool horizontal = GeometryUtils.IsLineHorizontal(12.8, 9.73, 12.8, 9.73);
}
public void TestCalcTriangleArea9()
{
double area = GeometryUtils.CalcTriangleArea(60, 91, 109);
Assert.AreEqual(2730, area);
}
public void TestCalcTriangleArea1()
{
double area = GeometryUtils.CalcTriangleArea(3, 4, 5);
Assert.AreEqual(6, area);
}
public static CalculateOverlapsResponse CalculateOverlaps(
[NotNull] CalculateOverlapsRequest request,
[CanBeNull] ITrackCancel trackCancel)
{
var watch = Stopwatch.StartNew();
IList <IFeature> sourceFeatures =
ProtobufConversionUtils.FromGdbObjectMsgList(
request.SourceFeatures, request.ClassDefinitions);
IList <IFeature> targetFeatures =
ProtobufConversionUtils.FromGdbObjectMsgList(
request.TargetFeatures, request.ClassDefinitions);
_msg.DebugStopTiming(watch, "Unpacked feature lists from request params");
Overlaps selectableOverlaps = RemoveOverlapsUtils.GetSelectableOverlaps(
sourceFeatures, targetFeatures, trackCancel);
watch = Stopwatch.StartNew();
var result = new CalculateOverlapsResponse();
foreach (var overlapByGdbRef
in selectableOverlaps.OverlapsBySourceRef)
{
var gdbObjRefMsg = ProtobufGdbUtils.ToGdbObjRefMsg(overlapByGdbRef.Key);
var overlap = overlapByGdbRef.Value;
var overlapsMsg = new OverlapMsg()
{
OriginalFeatureRef = gdbObjRefMsg
};
foreach (IGeometry geometry in overlap)
{
// TODO: At some point the SR-XY tol/res should be transferred separately (via class-lookup?)
var shapeFormat = ShapeMsg.FormatOneofCase.EsriShape;
var srFormat = SpatialReferenceMsg.FormatOneofCase.SpatialReferenceEsriXml;
overlapsMsg.Overlaps.Add(
ProtobufGeometryUtils.ToShapeMsg(
geometry, shapeFormat, srFormat));
if (_msg.IsVerboseDebugEnabled)
{
_msg.VerboseDebug(
$"Calculated overlap: {GeometryUtils.ToString(geometry)}");
}
}
result.Overlaps.Add(overlapsMsg);
}
foreach (var notification in selectableOverlaps.Notifications)
{
result.Notifications.Add(notification.Message);
}
_msg.DebugStopTiming(watch, "Packed overlaps into response");
return(result);
}
public void TestIsLineHorizontal2()
{
bool horizontal = GeometryUtils.IsLineHorizontal(12.8, 9.73, -12.8, 9.73);
Assert.AreEqual(true, horizontal);
}
/// <inheritdoc />
public override void GetGripPoints(
Entity entity, GripDataCollection grips, double curViewUnitSize, int gripSize, Vector3d curViewDir, GetGripPointsFlags bitFlags)
{
try
{
if (IsApplicable(entity))
{
// Удаляю все ручки - это удалит ручку вставки блока
grips.Clear();
var section = EntityReaderService.Instance.GetFromEntity <Section>(entity);
if (section != null)
{
// insertion (start) grip
var vertexGrip = new SectionVertexGrip(section, 0)
{
GripPoint = section.InsertionPoint
};
grips.Add(vertexGrip);
// middle points
for (var index = 0; index < section.MiddlePoints.Count; index++)
{
vertexGrip = new SectionVertexGrip(section, index + 1)
{
GripPoint = section.MiddlePoints[index]
};
grips.Add(vertexGrip);
var removeVertexGrip = new SectionRemoveVertexGrip(section, index + 1)
{
GripPoint = section.MiddlePoints[index] - (Vector3d.YAxis * 20 * curViewUnitSize)
};
grips.Add(removeVertexGrip);
}
// end point
vertexGrip = new SectionVertexGrip(section, section.MiddlePoints.Count + 1)
{
GripPoint = section.EndPoint
};
grips.Add(vertexGrip);
#region AddVertex grips
// add vertex grips
for (var i = 0; i < section.MiddlePoints.Count; i++)
{
if (i == 0)
{
var addVertexGrip = new SectionAddVertexGrip(
section,
section.InsertionPoint, section.MiddlePoints[i])
{
GripPoint = GeometryUtils.GetMiddlePoint3d(section.InsertionPoint, section.MiddlePoints[i])
};
grips.Add(addVertexGrip);
}
else
{
var addVertexGrip = new SectionAddVertexGrip(
section,
section.MiddlePoints[i - 1], section.MiddlePoints[i])
{
GripPoint = GeometryUtils.GetMiddlePoint3d(section.MiddlePoints[i - 1], section.MiddlePoints[i])
};
grips.Add(addVertexGrip);
}
// last segment
if (i == section.MiddlePoints.Count - 1)
{
var addVertexGrip = new SectionAddVertexGrip(
section,
section.MiddlePoints[i], section.EndPoint)
{
GripPoint = GeometryUtils.GetMiddlePoint3d(section.MiddlePoints[i], section.EndPoint)
};
grips.Add(addVertexGrip);
}
}
if (!section.MiddlePoints.Any())
{
var addVertexGrip = new SectionAddVertexGrip(section, section.InsertionPoint, section.EndPoint)
{
GripPoint = GeometryUtils.GetMiddlePoint3d(section.InsertionPoint, section.EndPoint)
};
grips.Add(addVertexGrip);
}
#endregion
#region Reverse Grips
var reverseGrip = new SectionReverseGrip(section)
{
GripPoint = section.EntityDirection == EntityDirection.LeftToRight
? section.TopShelfEndPoint - (Vector3d.XAxis * 20 * curViewUnitSize)
: section.TopShelfEndPoint + (Vector3d.XAxis * 20 * curViewUnitSize)
};
grips.Add(reverseGrip);
reverseGrip = new SectionReverseGrip(section)
{
GripPoint = section.EntityDirection == EntityDirection.LeftToRight
? section.BottomShelfEndPoint - (Vector3d.XAxis * 20 * curViewUnitSize)
: section.BottomShelfEndPoint + (Vector3d.XAxis * 20 * curViewUnitSize)
};
grips.Add(reverseGrip);
#endregion
#region Text grips
if (section.TopDesignationPoint != Point3d.Origin && section.HasTextValue())
{
var textGrip = new SectionTextGrip(section)
{
GripPoint = section.TopDesignationPoint,
Name = TextGripName.TopText
};
grips.Add(textGrip);
}
if (section.BottomDesignationPoint != Point3d.Origin && section.HasTextValue())
{
var textGrip = new SectionTextGrip(section)
{
GripPoint = section.BottomDesignationPoint,
Name = TextGripName.BottomText
};
grips.Add(textGrip);
}
#endregion
}
}
}
catch (Exception exception)
{
if (exception.ErrorStatus != ErrorStatus.NotAllowedForThisProxy)
{
ExceptionBox.Show(exception);
}
}
}
public void TestIsLineVertical1_ThrowsException()
{
bool vertical = GeometryUtils.IsLineVertical(12.8, 9.73, 12.8, 9.73);
}
public void MouseMove(Vector p)
{
CurrentPos = p;
if (Moving)
{
AdjustForGrid(p);
if (_lockingLines)
{
p = GeometryUtils.OrthogonalProjection(_lockCenter,
GeometryUtils.DistanceFromLine(_lockCenter, _lockNext, p) <
GeometryUtils.DistanceFromLine(_lockCenter, _lockPrev, p)
? _lockNext
: _lockPrev, p);
}
Vector delta = p - _moveStartPosition;
if (delta.Length > 0)
{
_anythingMoved = true;
}
Vector.MarkDefault = VectorMark.Selected;
foreach (Polygon x in Lev.Polygons)
{
bool anythingMoved = false;
for (int i = 0; i < x.Vertices.Count; i++)
{
if (x.Vertices[i].Mark != VectorMark.Selected)
{
continue;
}
x.Vertices[i] += delta;
anythingMoved = true;
}
if (anythingMoved)
{
x.UpdateDecomposition();
}
}
foreach (LevObject x in Lev.Objects.Where(x => x.Position.Mark == VectorMark.Selected))
{
x.Position += delta;
}
foreach (Picture z in Lev.Pictures.Where(z => z.Position.Mark == VectorMark.Selected))
{
z.Position += delta;
}
Vector.MarkDefault = VectorMark.None;
_moveStartPosition = p;
}
else if (FreeSelecting)
{
_mouseTrip += (p - _lastMousePosition).Length;
_lastMousePosition = p;
double step = 0.02 * ZoomCtrl.ZoomLevel;
if (_mouseTrip > step)
{
while (!(_mouseTrip < step))
{
_mouseTrip -= step;
}
_selectionPoly.Add(p);
}
}
else if (!Busy)
{
ResetHighlight();
int nearestVertex = GetNearestVertexIndex(p);
int nearestObject = GetNearestObjectIndex(p);
int nearestTextureIndex = GetNearestPictureIndex(p);
if (nearestVertex == -1)
{
ChangeCursorToHand();
NearestPolygon.Mark = PolygonMark.Highlight;
LevEditor.HighlightLabel.Text = NearestPolygon.IsGrass ? "Grass" : "Ground";
LevEditor.HighlightLabel.Text += " polygon, " + NearestPolygon.Count + " vertices";
}
else if (nearestVertex >= 0)
{
ChangeCursorToHand();
Vector b = NearestPolygon.Vertices[nearestVertex];
if (b.Mark == VectorMark.None)
{
b.Mark = VectorMark.Highlight;
}
LevEditor.HighlightLabel.Text = NearestPolygon.IsGrass ? "Grass" : "Ground";
LevEditor.HighlightLabel.Text += " polygon, vertex " + (nearestVertex + 1) + " of " +
NearestPolygon.Count + " vertices";
}
else if (nearestObject >= 0)
{
ChangeCursorToHand();
if (Lev.Objects[nearestObject].Position.Mark == VectorMark.None)
{
Lev.Objects[nearestObject].Position.Mark = VectorMark.Highlight;
}
ShowObjectInfo(nearestObject);
}
else if (nearestTextureIndex >= 0)
{
ChangeCursorToHand();
if (Lev.Pictures[nearestTextureIndex].Position.Mark == VectorMark.None)
{
Lev.Pictures[nearestTextureIndex].Position.Mark = VectorMark.Highlight;
}
ShowTextureInfo(nearestTextureIndex);
}
else
{
ChangeToDefaultCursorIfHand();
LevEditor.HighlightLabel.Text = "";
}
}
}
public void TestIsLineVertical2()
{
bool vertical = GeometryUtils.IsLineVertical(12.8, -9.73, 12.8, 9.73);
Assert.AreEqual(true, vertical);
}
private int CheckIntersection([NotNull] IPoint intersectionPoint,
[NotNull] IFeature feature1, int tableIndex1,
[NotNull] IFeature feature2, int tableIndex2)
{
double feature1Z = intersectionPoint.Z;
if (double.IsNaN(feature1Z))
{
return(NoError);
}
double feature2Z = GeometryUtils.GetZValueFromGeometry(
feature2.Shape, intersectionPoint,
GeometryUtils.GetXyTolerance(feature2));
if (double.IsNaN(feature2Z))
{
return(NoError);
}
double dz = Math.Abs(feature1Z - feature2Z);
double minimumZDifference =
feature1Z >= feature2Z
? GetMinimumZDifference(feature1, tableIndex1,
feature2, tableIndex2)
: GetMinimumZDifference(feature2, tableIndex2,
feature1, tableIndex1);
double maximumZDifference =
feature1Z >= feature2Z
? GetMaximumZDifference(feature1, tableIndex1,
feature2, tableIndex2)
: GetMaximumZDifference(feature2, tableIndex2,
feature1, tableIndex1);
int errorCount = 0;
if (minimumZDifference > 0 && dz < minimumZDifference)
{
// a z difference smaller than the minimum is always an error
errorCount += ReportIssue(
$"Z distance is {dz:N2}. Minimum allowed distance is {minimumZDifference}",
intersectionPoint,
Codes[Code.ZDifferenceAtLineIntersection_SmallerThanLimit],
TestUtils.GetShapeFieldName(feature1),
dz, feature1, feature2);
}
if (maximumZDifference > 0 && dz > maximumZDifference)
{
// a z difference larger than the maximum is always an error
errorCount += ReportIssue(
$"Z distance is {dz:N2}. Maximum allowed distance is {maximumZDifference}",
intersectionPoint,
Codes[Code.ZDifferenceAtLineIntersection_LargerThanLimit],
TestUtils.GetShapeFieldName(feature1),
dz, feature1, feature2);
}
return(errorCount +
(feature1Z >= feature2Z
? CheckConstraint(feature1, tableIndex1,
feature2, tableIndex2,
intersectionPoint, dz)
: CheckConstraint(feature2, tableIndex2,
feature1, tableIndex1,
intersectionPoint, dz)));
}
public void TestCalcTriangleArea2_ThrowsException()
{
double area = GeometryUtils.CalcTriangleArea(0, 40, 50);
}
private void selectGameObjects(Rect selectionRect)
{
// Is Deselection Mode?
if (SimulationGame.KeyboardState.IsKeyDown(Keys.LeftAlt) || SimulationGame.KeyboardState.IsKeyDown(Keys.RightAlt))
{
if (SimulationGame.Player.InteriorID == Interior.Outside)
{
// Check collision with interactive && contained objects
Point chunkTopLeft = GeometryUtils.GetChunkPosition(selectionRect.Left, selectionRect.Top, WorldGrid.WorldChunkPixelSize.X, WorldGrid.WorldChunkPixelSize.Y);
Point chunkBottomRight = GeometryUtils.GetChunkPosition(selectionRect.Right, selectionRect.Bottom, WorldGrid.WorldChunkPixelSize.X, WorldGrid.WorldChunkPixelSize.Y);
for (int chunkX = chunkTopLeft.X - 1; chunkX <= chunkBottomRight.X + 1; chunkX++)
{
for (int chunkY = chunkTopLeft.Y - 1; chunkY <= chunkBottomRight.Y + 1; chunkY++)
{
WorldGridChunk worldGridChunk = SimulationGame.World.GetFromChunkPoint(chunkX, chunkY);
addSelectedObjectsFromWorldPart(selectionRect, worldGridChunk, true);
}
}
}
else
{
addSelectedObjectsFromWorldPart(selectionRect, SimulationGame.World.InteriorManager.Get(SimulationGame.Player.InteriorID), true);
}
if (SelectedGameObjects.Count > 0)
{
gameObjectSelection?.Invoke(SelectedGameObjects);
}
}
else
{
if (SimulationGame.KeyboardState.IsKeyDown(Keys.LeftShift) == false && SimulationGame.KeyboardState.IsKeyDown(Keys.RightShift) == false)
{
SelectedBlockPosition = Point.Zero;
SelectedBlockType = null;
SelectedWorldLink = null;
SelectedGameObjects.Clear();
}
if (SimulationGame.Player.InteriorID == Interior.Outside)
{
// Check collision with interactive && contained objects
Point chunkTopLeft = GeometryUtils.GetChunkPosition(selectionRect.Left, selectionRect.Top, WorldGrid.WorldChunkPixelSize.X, WorldGrid.WorldChunkPixelSize.Y);
Point chunkBottomRight = GeometryUtils.GetChunkPosition(selectionRect.Right, selectionRect.Bottom, WorldGrid.WorldChunkPixelSize.X, WorldGrid.WorldChunkPixelSize.Y);
for (int chunkX = chunkTopLeft.X - 1; chunkX <= chunkBottomRight.X + 1; chunkX++)
{
for (int chunkY = chunkTopLeft.Y - 1; chunkY <= chunkBottomRight.Y + 1; chunkY++)
{
WorldGridChunk worldGridChunk = SimulationGame.World.GetFromChunkPoint(chunkX, chunkY);
addSelectedObjectsFromWorldPart(selectionRect, worldGridChunk);
}
}
}
else
{
addSelectedObjectsFromWorldPart(selectionRect, SimulationGame.World.InteriorManager.Get(SimulationGame.Player.InteriorID));
}
if (SelectedGameObjects.Count == 0)
{
WorldPart worldPart = (SimulationGame.Player.InteriorID == Interior.Outside) ? SimulationGame.World.GetFromRealPoint((int)selectionRect.X, (int)selectionRect.Y) : (WorldPart)SimulationGame.World.InteriorManager.Get(SimulationGame.Player.InteriorID);
if (worldPart.WorldLinks != null)
{
foreach (var worldLinkItem in worldPart.WorldLinks)
{
Rect renderPosition = new Rect(worldLinkItem.Value.FromBlock.X * WorldGrid.BlockSize.X, worldLinkItem.Value.FromBlock.Y * WorldGrid.BlockSize.Y, WorldGrid.BlockSize.X, WorldGrid.BlockSize.Y);
if (renderPosition.Contains(selectionRect.GetPosition()))
{
SelectedWorldLink = worldLinkItem.Value;
worldLinkSelection?.Invoke(SelectedWorldLink);
return;
}
}
}
// We get the block
SelectedBlockPosition = GeometryUtils.GetBlockFromReal((int)SimulationGame.RealWorldMousePosition.X, (int)SimulationGame.RealWorldMousePosition.Y);
SelectedBlockType = BlockType.lookup[SimulationGame.World.GetBlockType(SelectedBlockPosition.X, SelectedBlockPosition.Y, SimulationGame.Player.InteriorID)];
blockSelection?.Invoke(SelectedBlockType);
}
else
{
gameObjectSelection?.Invoke(SelectedGameObjects);
}
}
}
private static void RunTest(Stream stream, double minimumMeasure)
{
var geoms = GeometryUtils.ReadWKTFile(stream);
Assert.IsTrue(Tester.Test(geoms, minimumMeasure));
}
