public override Vector3 FindNearestFace(Vector3 fromPoint, GridPlane thePlane, bool doDebug = false) { //get a temporary point (world space) Vector3 toPoint = FindNearestBox(fromPoint); //snap to the plane toPoint[(int)thePlane] = FindNearestVertex(fromPoint)[(int)thePlane]; //debugging if (doDebug) { Vector3 debugCube = spacing; debugCube[(int)thePlane] = 0.0f; //store the old matrix and create a new one based on the grid's roation and the point's position Matrix4x4 oldRotationMatrix = Gizmos.matrix; Matrix4x4 newRotationMatrix = Matrix4x4.TRS(toPoint, transform.rotation, Vector3.one); Gizmos.matrix = newRotationMatrix; Gizmos.DrawCube(Vector3.zero, debugCube); //Position zero because the matrix already contains the point Gizmos.matrix = oldRotationMatrix; } return(toPoint); }
public override Vector3 NearestFaceW(Vector3 fromPoint, GridPlane thePlane, bool doDebug = false) { //get a temporary point (world space) //Vector3 toPoint = NearestBoxW(fromPoint); //snap to the plane //toPoint[(int)thePlane] = NearestVertexW(fromPoint)[(int)thePlane]; //debugging if (doDebug) { Vector3 debugCube = spacing; debugCube[(int)thePlane] = 0.0f; //store the old matrix and create a new one based on the grid's roation and the point's position Matrix4x4 oldRotationMatrix = Gizmos.matrix; //Matrix4x4 newRotationMatrix = Matrix4x4.TRS(toPoint, transform.rotation, Vector3.one); Matrix4x4 newRotationMatrix = Matrix4x4.TRS(GridToWorld(NearestFaceG(fromPoint, thePlane) + 0.5f * Vector3.one - 0.5f * units[(int)thePlane]), transform.rotation, Vector3.one); Gizmos.matrix = newRotationMatrix; Gizmos.DrawCube(Vector3.zero, debugCube); //Position zero because the matrix already contains the point Gizmos.matrix = oldRotationMatrix; } //return toPoint; return(GridToWorld(NearestFaceG(fromPoint, thePlane) + 0.5f * Vector3.one - 0.5f * units[(int)thePlane])); }
public EnemySpawner(GridPlane plane) { resources = 0; this.plane = plane; for (int x = 0; x < LEVEL_SIZE.X; ++x) { if (!plane.grid[x, 0].solid) { available.Add(plane.grid[x, 0]); } if (!plane.grid[x, LEVEL_SIZE.Y - 1].solid) { available.Add(plane.grid[x, LEVEL_SIZE.Y - 1]); } } for (int y = 0; y < LEVEL_SIZE.Y; ++y) { if (!plane.grid[0, y].solid) { available.Add(plane.grid[0, y]); } if (!plane.grid[LEVEL_SIZE.X - 1, y].solid) { available.Add(plane.grid[LEVEL_SIZE.X - 1, y]); } } }
void InitializePlanes(GraphicsDevice graphicsDevice, int gridSize, float cellSize, Color color) { int halfGridSize = gridSize / 2; float offset = halfGridSize * cellSize; var upTransform = Matrix.CreateTranslation(new Vector3(0, offset, 0)); Up = GridPlane.CreatePlaneXZ(graphicsDevice, gridSize, gridSize, cellSize, color, upTransform); var downTransform = Matrix.CreateTranslation(new Vector3(0, -offset, 0)); Down = GridPlane.CreatePlaneXZ(graphicsDevice, gridSize, gridSize, cellSize, color, downTransform); var forwardTransform = Matrix.CreateTranslation(new Vector3(0, 0, -offset)); Forward = GridPlane.CreatePlaneXY(graphicsDevice, gridSize, gridSize, cellSize, color, forwardTransform); var backwardTransform = Matrix.CreateTranslation(new Vector3(0, 0, offset)); Backward = GridPlane.CreatePlaneXY(graphicsDevice, gridSize, gridSize, cellSize, color, backwardTransform); var leftTransform = Matrix.CreateTranslation(new Vector3(-offset, 0, 0)); Left = GridPlane.CreatePlaneZY(graphicsDevice, gridSize, gridSize, cellSize, color, leftTransform); var rightTransform = Matrix.CreateTranslation(new Vector3(offset, 0, 0)); Right = GridPlane.CreatePlaneZY(graphicsDevice, gridSize, gridSize, cellSize, color, rightTransform); }
public void CopyFrom(BrushSettings other) { brushRadius = other.brushRadius; brushSpacing = other.brushSpacing; brushOverlapCheckMode = other.brushOverlapCheckMode; brushOverlapDistance = other.brushOverlapDistance; brushOverlapCheckObjects = other.brushOverlapCheckObjects; brushOverlapCheckLayers = other.brushOverlapCheckLayers; surfaceOffset = other.surfaceOffset; orientationTransformMode = other.orientationTransformMode; orientationMode = other.orientationMode; alongBrushStroke = other.alongBrushStroke; rotation = other.rotation; randomizeOrientationX = other.randomizeOrientationX; randomizeOrientationY = other.randomizeOrientationY; randomizeOrientationZ = other.randomizeOrientationZ; scaleTransformMode = other.scaleTransformMode; scaleMode = other.scaleMode; scaleUniformMin = other.scaleUniformMin; scaleUniformMax = other.scaleUniformMax; scalePerAxisMin = other.scalePerAxisMin; scalePerAxisMax = other.scalePerAxisMax; pinFixedRotation = other.pinFixedRotation; pinFixedRotationValue = other.pinFixedRotationValue; pinFixedScale = other.pinFixedScale; pinFixedScaleValue = other.pinFixedScaleValue; placeScale = other.placeScale; placeEulerAngles = other.placeEulerAngles; multibrushEnabled = other.multibrushEnabled; multibrushPaintSelectedSlot = other.multibrushPaintSelectedSlot; multibrushMode = other.multibrushMode; multibrushPattern = other.multibrushPattern; multibrushPatternContinue = other.multibrushPatternContinue; for (int i = 0; i < kNumMultibrushSlots; i++) { multibrushSlots[i] = other.multibrushSlots[i]; } slopeEnabled = other.slopeEnabled; slopeAngleMin = other.slopeAngleMin; slopeAngleMax = other.slopeAngleMax; slopeVector = other.slopeVector; slopeVectorCustom = other.slopeVectorCustom; slopeVectorFlip = other.slopeVectorFlip; gridEnabled = other.gridEnabled; gridOrigin = other.gridOrigin; gridStep = other.gridStep; gridPlane = other.gridPlane; gridNormal = other.gridNormal; gridAngle = other.gridAngle; }
public void ResetGrid() { gridOrigin = new Vector3(0, 0, 0); gridStep = new Vector2(5, 5); gridPlane = GridPlane.XZ; gridNormal = new Vector3(0, 1, 0); gridAngle = 0.0f; }
public static dynamic GetTSObject(GridPlane dynObject) { if (dynObject is null) { return(null); } return(dynObject.teklaObject); }
public override void HandleInput(InputHelper inputHelper) { base.HandleInput(inputHelper); mousePos = inputHelper.MousePosition; plane = GameWorld.FindByType <Camera>()[0].currentPlane; node = plane.NodeAt(mousePos / Camera.scale, false); if (previousNode != node) { if (previousNode != null) { previousNode.selected = false; } previousNode = node; } if (node == null) { return; } else { node.selected = true; } selectedPossible = !node.solid && node.available && inputHelper.MouseInGameWindow; if (inputHelper.MouseLeftButtonPressed() && inputHelper.MouseInGameWindow && selected != null && selectedPossible) { Type t = Type.GetType(selected.itemType); //Get the type of the object object temp = Activator.CreateInstance(t); //Create an instance of that object GameObject obj = temp as GameObject; //Cast it as a GameObject obj.Position = node.Position + new Vector2(NODE_SIZE.X / 2, 0); //Adjust the position to the middle of the GridNode if (selected.itemType.Equals("ResourceTower") && GameWorld.FindByType <ResourceTower>().Count > 2) { selected = null; return; } plane.Add(obj); //Add it to the hierarchy obj.MyParticleControl.AddTowerBuildGlow(obj.Position); //Add particle effect EcResources -= selected.cost; //Subtract its cost from the resources PlaySound(SND_TOWERPLACE); if (!inputHelper.IsKeyDown(Keys.LeftShift) || selected.cost > EcResources) //allow shift-clicking multiple towers { selected = null; //Reset the selected object reference } } //Cancel the current selection with X or right click if (inputHelper.KeyPressed(Keys.X) && selected != null || inputHelper.MouseRightButtonPressed() && selected != null) { selected = null; } }
public GsaGridPlaneSurface() { m_plane = Plane.Unset; m_gridplane = new GridPlane(); m_gp_guid = Guid.NewGuid(); m_gridsrf = new GridSurface(); m_gs_guid = Guid.NewGuid(); m_axis = new Axis(); }
//transforms from quasi axis to real axis. Quasi axis is the relative X, Y and Z n the current grid plane, // all calculations are done in quasi space, so there is only one calculation, and then transformed into real space protected virtual int[] TransformIndices(GridPlane plane){ if(plane == GridPlane.YZ){ return new int[3] {2, 1, (int)gridPlane}; } else if(plane == GridPlane.XZ){ return new int[3] {0, 2, (int)gridPlane}; } else{ return new int[3] {0, 1, (int)gridPlane}; } }
public Camera() : base() { position = -LEVEL_CENTER + GAME_WINDOW_SIZE.toVector() / 2; scale = new Vector2(1f); planes = new List <GridPlane>(); for (int i = 0; i < 1; ++i) { GridPlane p = new GridPlane((Plane)i); p.active = false; Add(p); switch ((Plane)i) { case Plane.Land: Land = p; planes.Add(Land); //Add items to the land plane (p.Add) p.Add(new Base { Position = LEVEL_CENTER }); //p.Add(new ParticleController()); break; } } currentPlane = planes[(int)Plane.Land]; //Reference the current plane to one of the three Console.WriteLine("Current Plane: " + currentPlane.planeType.ToString()); LevelGenerator levelGenerator = new LevelGenerator(); List <int[, ]> list = new List <int[, ]>(); list = levelGenerator.GenerateNewLevel(); for (int x = 0; x < LEVEL_SIZE.X; ++x) { for (int y = 0; y < LEVEL_SIZE.Y; ++y) { int tex = list[0][x, y]; if (tex == 2) //Mountain { tex = Functions.choose(new List <int> { 2, 7, 8 }); } if (tex == 5) { tex = Functions.choose(new List <int> { 5, 9 }); } Land.grid[x, y].texture = tex; } } currentPlane.Add(new EnemySpawner(currentPlane)); // The grid must be finished for (int i = 1; i <= 5; i += 2) { currentPlane.Add(new Clouds(new Vector2(-1500 / i, SCREEN_SIZE.Y + 1800 / i))); } }
//returns XYZ grid coordinates of a face close to a given point public override Vector3 GetFaceCoordinates(Vector3 fromPoint, GridPlane thePlane) { //get the grid coordinates of the face Vector3 face = GetBoxCoordinates(FindNearestFace(fromPoint, thePlane)); // two of the face coordinates are in a box, the other is on the vertex closest to the face face[(int)thePlane] = FindNearestVertex(fromPoint)[(int)thePlane]; return(face); }
//returns XYZ grid coordinates of a face close to a given point public override Vector3 NearestFaceG(Vector3 fromPoint, GridPlane thePlane) { //get the grid coordinates of the face //Vector3 face = NearestBoxG(NearestFaceW(fromPoint, thePlane)); // two of the face coordinates are in a box, the other is on the vertex closest to the face //face[(int)thePlane] = NearestVertexW(fromPoint)[(int)thePlane]; //return face; return(RoundPoint(WorldToGrid(fromPoint) - 0.5f * Vector3.one + 0.5f * units[(int)thePlane])); }
public override Vector3 NearestFaceW(Vector3 fromPoint, GridPlane thePlane, bool doDebug = false) { Vector3 dest = PolarToWorld(NearestFaceP(fromPoint, thePlane)); if (doDebug) { DrawSphere(dest); } return(dest); }
protected Vector3 NearestFaceG(Vector3 world, GridPlane thePlane, HexCoordinateSystem coordianteSystem) { if (coordianteSystem == HexCoordinateSystem.Herring) { return(NearestFaceGHerring(world, thePlane)); } else { return(Vector3.zero); } }
public Vector3 NearestFaceP(Vector3 world, GridPlane thePlane) { Vector3 polar = WorldToPolar(world); polar -= 0.5f * radius * units[idx[0]] + 0.5f * angle * units[idx[1]]; // virtually shift the point half an angle and half a radius down, this will simulate the shifted coordinates polar[idx[1]] = Mathf.Max(0, polar[idx[1]]); // prevent the angle from becoming negative polar = RoundPolarPoint(polar); // round the point polar += 0.5f * radius * units[idx[0]] + 0.5f * angle * units[idx[1]]; //Debug.Log (polar); return(polar); }
public bool InitializeDocument(params object[] args) { if (args.Length == 0 || !(args[0] is GridPlane)) return false; bool isVirgin = null == _doc; _doc = (GridPlane)args[0]; Initialize(true); return true; }
/// <summary>transforms from quasi axis to real axis.</summary> /// <returns>Real indices of quasi-indices.</returns> /// <param name="plane">The plane.</param> /// /// Quasi axis is the relative X, Y and Z n the current grid plane, all calculations are done in quasi space, so there is only one calculation, and then transformed into real space. protected virtual int[] TransformIndices(GridPlane plane) { if (plane == GridPlane.YZ) { return(new int[] { 2, 1, (int)gridPlane }); } if (plane == GridPlane.XZ) { return(new int[] { 0, 2, (int)gridPlane }); } return(new int[] { 0, 1, (int)gridPlane }); }
//diese Funktion sorgt dafür dass unser Block nach der bewegung shön weich landed public void SnapToPosition(GridPlane gridPlane) { movementState = BlockMovementState.Dropping; if (currentAssignedGridPlane != null) { currentAssignedGridPlane.taken = false; } //transform.position = gridPlane.transform.position + new Vector3(0, 0.5f, 0); currentAssignedGridPlane = gridPlane; currentAssignedGridPlane.taken = true; heightCorrector = currentAssignedGridPlane.transform.up; heightCorrector *= transform.localScale.y / 2; }
public bool InitializeDocument(params object[] args) { if (args.Length == 0 || !(args[0] is GridPlane)) { return(false); } bool isVirgin = null == _doc; _doc = (GridPlane)args[0]; Initialize(true); return(true); }
//the cordinates inside the tile protected Vector2 GetTilePointCoordinates(Vector3 world, GridPlane thePlane) { Vector3 local = _transform.GFInverseTransformPointFixed(world); Vector3 tile = GetTileCoordinates(world, thePlane); Vector2 tilePoint = new Vector2(); tilePoint[0] = (local[idx[0]] + 1.0f * radius) - tile[idx[0]] * side; float shift = 1 - Mathf.RoundToInt(Mathf.Abs(tile[idx[0]]) % 2); // 1 for even, 0 for odd tilePoint[1] = (local[idx[1]] + shift * 0.5f * height) - tile[idx[1]] * height; // Debug.Log(tilePoint); return(tilePoint); }
public Vector3 NearestFaceW(Vector3 fromPoint, GridPlane thePlane, bool doDebug = false) { if (doDebug) { Vector3 debugCube = spacing; debugCube [(int)thePlane] = 0.0f; Matrix4x4 oldRotationMatrix = Gizmos.matrix; Matrix4x4 newRotationMatrix = Matrix4x4.TRS(GridToWorld(NearestFaceG(fromPoint, thePlane) + 0.5f * Vector3.one - 0.5f * units [(int)thePlane]), transform.rotation, Vector3.one); Gizmos.matrix = newRotationMatrix; Gizmos.DrawCube(Vector3.zero, debugCube); Gizmos.matrix = oldRotationMatrix; } return(GridToWorld(NearestFaceG(fromPoint, thePlane) + 0.5f * Vector3.one - 0.5f * units [(int)thePlane])); }
public GridRender(Direct3d d3d, Camera camera, GEMSEnvironment enviroment) : base(d3d) { this.enviroment = enviroment; this.gridDisplayed = enviroment.GridDisplayed; this.gridPlane = enviroment.GridPlane; this.gridOffset = enviroment.GidOffset; this.gridSize = enviroment.GridSize.Value; this.camera = camera; enviroment.GridOptionChanged += new GEMSEnvironment.GridOptionChangedEventHandler(OnGridOptionChanged); camera.ViewChanged += new Camera.ViewChangedEventHandler(OnViewChanged); camera.ProjectionChanged += new Camera.ProjectionChangedEventHandler(OnProjectionChanged); isDisplayed = IsDisplay(camera.Look); }
public override Vector3 NearestFaceW(Vector3 fromPoint, GridPlane thePlane, bool doDebug = false) { Vector3 face = NearestFaceG(fromPoint, thePlane); Vector3 toPoint = new Vector3(); toPoint[idx[0]] = face[idx[0]] * side; toPoint[idx[1]] = face[idx[1]] * height + Mathf.Abs(face[idx[0]] % 2) * height / 2.0f; toPoint[idx[2]] = face[idx[2]] * depth; toPoint = _transform.GFTransformPointFixed(toPoint); if (doDebug) { Gizmos.DrawSphere(toPoint, height / 2); } return(toPoint); }
protected Vector3 GetTileCoordinates(Vector3 world, GridPlane thePlane) { //get the world point into local space Vector3 local = _transform.GFInverseTransformPointFixed(world); // Debug.Log(local); Vector3 tile = new Vector3(); //find the coordinates of the tile tile[idx[0]] = Mathf.Floor((local[idx[0]] + 1.0f * radius) / side); float shift = 1 - Mathf.RoundToInt(Mathf.Abs(tile[idx[0]]) % 2); // 1 for even, 0 for odd tile[idx[1]] = Mathf.Floor((local[idx[1]] + (shift * 0.5f * height)) / height); tile[idx[2]] = Mathf.Round(local[idx[2]] / depth); // maybe I stil need the above instead // Debug.Log(tile); return(tile); }
void Awake() { if (developerMode) { GameObject[] gridGO = GameObject.FindGameObjectsWithTag("gridPlane"); GameObject[] blockGO = GameObject.FindGameObjectsWithTag("blockObject"); gridPlanes = new GridPlane[gridGO.Length]; blockObjects = new BlockObject[blockGO.Length]; for (int i = 0; i < gridGO.Length; i++) { gridPlanes[i] = gridGO[i].GetComponent <GridPlane>(); } for (int i = 0; i < blockGO.Length; i++) { blockObjects[i] = blockGO[i].GetComponent <BlockObject>(); } } //suche für jedes BlockObjectk die näheste GridPlane, snappe foreach (BlockObject blockObject in blockObjects) { float nearestDistance = float.PositiveInfinity; GridPlane nearestPlane = null; foreach (GridPlane gridPlane in gridPlanes) { if (gridPlane.taken == false && !gridPlane.empthy) { float currentDistance = Vector3.Distance(gridPlane.transform.position, blockObject.transform.position); if (currentDistance < nearestDistance) { nearestDistance = currentDistance; nearestPlane = gridPlane; } } } //blockObject.transform.position = nearestPlane.transform.position + new Vector3(0,0.5f,0); blockObject.currentAssignedGridPlane = nearestPlane; } }
//_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_- #region helper functions //transforms from quasi axis to real axis. Quasi axis is the relative X, Y and Z n the current grid plane, // all calculations are done in quasi space, so there is only one calculation, and then transformed into real space protected int[] TransformIndices(GridPlane plane) { int[] indices = new int[3]; if (plane == GridPlane.YZ) { indices[0] = 2; indices[1] = 1; indices[2] = (int)gridPlane; } else if (plane == GridPlane.XZ) { indices[0] = 0; indices[1] = 2; indices[2] = (int)gridPlane; } else { indices[0] = 0; indices[1] = 1; indices[2] = (int)gridPlane; } Swap <int>(ref indices[0], ref indices[1], hexSideMode == HexOrientation.FlatSides); return(indices); }
//idea: cover the hex grid with a grid of rectangular tiles, find the position inside the tile and then // the hex that belongs to that point's tile protected Vector3 NearestFaceGHerring(Vector3 world, GridPlane thePlane) { Vector3 tile = GetTileCoordinates(world, thePlane); Vector3 tilePoint = GetTilePointCoordinates(world, thePlane); Vector3 face = new Vector3(); //there are three possible hexagons, find the one we need (left edge belongs to the hex, right one doesn't) face[idx[0]] = tilePoint[0] >= radius *Mathf.Abs(0.5f - tilePoint[1] / height) ? tile[idx[0]] : tile[idx[0]] - 1; int delta = tilePoint[1] > 0.5f * height ? 1 : 0; face[idx[1]] = tilePoint[0] >= radius *Mathf.Abs(0.5f - tilePoint[1] / height) ? tile[idx[1]] : tile[idx[1]] - Mathf.Abs(face[idx[0]] % 2) + delta; face[idx[2]] = tile[idx[2]]; //Debug.Log(face); return(face); }
public static void DrawCell(GridPlane gridPlane, int cellIndex, Color fillup, Color outline) { var cellCenterInWorld = gridPlane.GetCellCenter(cellIndex); var cellHalfSize = gridPlane.CellSize / 2.0f; Vector3[] verts = new Vector3[] { cellCenterInWorld - gridPlane.transform.right * cellHalfSize.x - gridPlane.transform.forward * cellHalfSize.y, cellCenterInWorld - gridPlane.transform.right * cellHalfSize.x + gridPlane.transform.forward * cellHalfSize.y, cellCenterInWorld + gridPlane.transform.right * cellHalfSize.x + gridPlane.transform.forward * cellHalfSize.y, cellCenterInWorld + gridPlane.transform.right * cellHalfSize.x - gridPlane.transform.forward * cellHalfSize.y, }; var rectColor = fillup; rectColor.a = 0.2f; var outlineColor = outline; outlineColor.a = 0.5f; Handles.DrawSolidRectangleWithOutline(verts, rectColor, outlineColor); }
/// <summary>Returns the world position of the nearest face.</summary> /// <returns>World position of the nearest face.</returns> /// <param name="worldPoint">Point in world space.</param> /// <param name="plane">Plane on which the face lies.</param> /// <param name="doDebug">Whether to draw a small debug sphere at the vertex.</param> /// /// Similar to <see cref="NearestVertexW"/>, it returns the world /// coordinates of a face on the grid. Since the face is enclosed by four /// vertices, the returned value is the point in between all four of the /// vertices. You also need to specify on which plane the face lies. If /// <c>doDebug</c> is set a small gizmo face will drawn inside the face. public override Vector3 NearestFaceW(Vector3 worldPoint, GridPlane plane, bool doDebug) { //debugging if (doDebug) { Vector3 debugCube = spacing; debugCube[(int)plane] = 0.0f; //store the old matrix and create a new one based on the grid's roation and the point's position Matrix4x4 oldRotationMatrix = Gizmos.matrix; //Matrix4x4 newRotationMatrix = Matrix4x4.TRS(toPoint, transform.rotation, Vector3.one); Matrix4x4 newRotationMatrix = Matrix4x4.TRS(GridToWorld(NearestFaceG(worldPoint, plane)), transform.rotation, Vector3.one); Gizmos.matrix = newRotationMatrix; Gizmos.DrawCube(Vector3.zero, debugCube); //Position zero because the matrix already contains the point Gizmos.matrix = oldRotationMatrix; } //return toPoint; return(GridToWorld(NearestFaceG(worldPoint, plane))); }
public GsaGridPlaneSurface(Plane plane, bool tryUseExisting = false) { m_plane = plane; m_gridplane = new GridPlane(); if (tryUseExisting) { m_gp_guid = new Guid(); // will create 0000-00000-00000-00000 } else { m_gp_guid = Guid.NewGuid(); // will create random guid } m_gridsrf = new GridSurface { Direction = 0, Elements = "all", ElementType = GridSurface.Element_Type.ONE_DIMENSIONAL, ExpansionType = GridSurfaceExpansionType.UNDEF, SpanType = GridSurface.Span_Type.ONE_WAY }; if (tryUseExisting) { m_gs_guid = new Guid(); // will create 0000-00000-00000-00000 } else { m_gs_guid = Guid.NewGuid(); // will create random guid } m_axis = new Axis(); m_axis.Origin.X = plane.OriginX; m_axis.Origin.Y = plane.OriginY; m_axis.Origin.Z = plane.OriginZ; m_axis.XVector.X = plane.XAxis.X; m_axis.XVector.Y = plane.XAxis.Y; m_axis.XVector.Z = plane.XAxis.Z; m_axis.XYPlane.X = plane.YAxis.X; m_axis.XYPlane.Y = plane.YAxis.Y; m_axis.XYPlane.Z = plane.YAxis.Z; }
public static void DrawGizmos(GridPlane gridPlane, GizmoType gizmoType) { Gizmos.color = Color.black; for (var row = 0; row <= gridPlane.Row; ++row) { Gizmos.DrawLine(gridPlane.RowBeginPosition(row), gridPlane.RowEndPosition(row)); } for (var col = 0; col <= gridPlane.Column; ++col) { Gizmos.DrawLine(gridPlane.ColumnBeginPosition(col), gridPlane.ColumnEndPosition(col)); } Gizmos.color = Color.white; for (var cellIndex = 0; cellIndex != gridPlane.Cells.Length; ++cellIndex) { var cell = gridPlane.Cells[cellIndex]; var cellOrigin = gridPlane.GetCellOrigin(cellIndex) + new Vector3(1, 0, 1) * 0.25f; if (cell != null) { if (cell.UsageFlag.HasFlag(CellUsage.Plant)) { Gizmos.DrawIcon(GetCellItemPosition(cellOrigin, gridPlane.CellSize.x, gridPlane.CellSize.y, Vector3.right, Vector3.forward, 3, 0), GizmosPlant); } if (cell.UsageFlag.HasFlag(CellUsage.Furniture)) { Gizmos.DrawIcon(GetCellItemPosition(cellOrigin, gridPlane.CellSize.x, gridPlane.CellSize.y, Vector3.right, Vector3.forward, 3, 1), GizmosFurniture); } if (cell.UsageFlag.HasFlag(CellUsage.Building)) { Gizmos.DrawIcon(GetCellItemPosition(cellOrigin, gridPlane.CellSize.x, gridPlane.CellSize.y, Vector3.right, Vector3.forward, 3, 2), GizmosBuilding); } } else { Gizmos.DrawIcon(GetCellItemPosition(cellOrigin, gridPlane.CellSize.x, gridPlane.CellSize.y, Vector3.right, Vector3.forward, 3, 0), GizmosPlant); Gizmos.DrawIcon(GetCellItemPosition(cellOrigin, gridPlane.CellSize.x, gridPlane.CellSize.y, Vector3.right, Vector3.forward, 3, 1), GizmosFurniture); Gizmos.DrawIcon(GetCellItemPosition(cellOrigin, gridPlane.CellSize.x, gridPlane.CellSize.y, Vector3.right, Vector3.forward, 3, 2), GizmosBuilding); } } }
/// <summary>Returns the world position of the nearest face.</summary> /// <returns>World position of the nearest face.</returns> /// <param name="worldPoint">Point in world space.</param> /// <param name="plane">Plane on which the face lies.</param> /// <param name="doDebug">Whether to draw a small debug sphere at the vertex.</param> /// /// Similar to <see cref="NearestVertexW"/>, it returns the world /// coordinates of a face on the grid. Since the face is enclosed by four /// vertices, the returned value is the point in between all four of the /// vertices. You also need to specify on which plane the face lies. If /// <c>doDebug</c> is set a small gizmo face will drawn inside the face. public override Vector3 NearestFaceW(Vector3 worldPoint, GridPlane plane, bool doDebug) { //debugging if (doDebug) { Vector3 debugCube = spacing; debugCube[(int)plane] = 0.0f; //store the old matrix and create a new one based on the grid's roation and the point's position Matrix4x4 oldRotationMatrix = Gizmos.matrix; //Matrix4x4 newRotationMatrix = Matrix4x4.TRS(toPoint, transform.rotation, Vector3.one); Matrix4x4 newRotationMatrix = Matrix4x4.TRS(GridToWorld(NearestFaceG(worldPoint, plane)), transform.rotation, Vector3.one); Gizmos.matrix = newRotationMatrix; Gizmos.DrawCube(Vector3.zero, debugCube);//Position zero because the matrix already contains the point Gizmos.matrix = oldRotationMatrix; } //return toPoint; return GridToWorld(NearestFaceG(worldPoint, plane)); }
public override Vector3 FindNearestFace(Vector3 fromPoint, GridPlane thePlane, bool doDebug = false) { //get a temporary point (world space) Vector3 toPoint = FindNearestBox(fromPoint); //snap to the plane toPoint[(int)thePlane] = FindNearestVertex(fromPoint)[(int)thePlane]; //debugging if(doDebug){ Vector3 debugCube = spacing; debugCube[(int)thePlane] = 0.0f; //store the old matrix and create a new one based on the grid's roation and the point's position Matrix4x4 oldRotationMatrix = Gizmos.matrix; Matrix4x4 newRotationMatrix = Matrix4x4.TRS(toPoint, transform.rotation, Vector3.one); Gizmos.matrix = newRotationMatrix; Gizmos.DrawCube(Vector3.zero, debugCube);//Position zero because the matrix already contains the point Gizmos.matrix = oldRotationMatrix; } return toPoint; }
public override Vector3 NearestFaceG(Vector3 worldPoint, GridPlane plane) { return NearestFaceG(worldPoint); }
//returns XYZ grid coordinates of a face close to a given point public override Vector3 GetFaceCoordinates(Vector3 fromPoint, GridPlane thePlane) { //get the grid coordinates of the face Vector3 face = GetBoxCoordinates(FindNearestFace(fromPoint, thePlane)); // two of the face coordinates are in a box, the other is on the vertex closest to the face face[(int)thePlane] = FindNearestVertex(fromPoint)[(int)thePlane]; return face; }
/** * @brief Returns the grid position of the nearest face. * @param world Point in world space. * @param thePlane Plane on which the face lies. * @return Grid coordinates of the nearest face. * * Similar to @c #NearestFaceW, except you get grid coordinates instead of world coordinates. * Since faces lie between vertices two values will always have +0.5 compared to vertex coordinates, while the values that lies on the plane will have a round number. * Example: * @code * var myGrid: GFRectGrid; * var worldPoint: Vector3; * var face = myGrid.NearestFaceG (worldPoint, GFGrid.GridPlane.XY); // something like (2.5, -1.5, 3) * @endcode */ public override Vector3 NearestFaceG(Vector3 fromPoint, GridPlane thePlane){ return RoundPoint(WorldToGrid(fromPoint) - 0.5f * Vector3.one + 0.5f * units[(int)thePlane]) + 0.5f * Vector3.one - 0.5f * units[(int)thePlane]; }
public override Vector3 NearestFaceW(Vector3 worldPoint, GridPlane plane, bool doDebug) { return NearestFaceW(worldPoint, doDebug); }
// similar to the base class, except these ones swap quasi-X and quasi-Y when hexes have flat sides. private int[] TransformIndicesS(GridPlane plane){ int[] indices = TransformIndices (plane); Swap<int>(ref indices[0], ref indices[1], hexSideMode == HexOrientation.FlatSides); return indices; }
public abstract Vector3 GetFaceCoordinates(Vector3 world, GridPlane thePlane);
public abstract Vector3 FindNearestFace(Vector3 fromPoint, GridPlane thePlane, bool doDebug = false);
protected virtual XYPlotLayer SDeserialize(object o, Altaxo.Serialization.Xml.IXmlDeserializationInfo info, object parent) { XYPlotLayer s = (o == null ? new XYPlotLayer() : (XYPlotLayer)o); int count; // Background IBackgroundStyle bgs = (IBackgroundStyle)info.GetValue("Background", s); if (null!=bgs) { if (!s.GridPlanes.Contains(CSPlaneID.Front)) s.GridPlanes.Add(new GridPlane(CSPlaneID.Front)); s.GridPlanes[CSPlaneID.Front].Background = bgs.Brush; } // size, position, rotation and scale s.Location = (XYPlotLayerPositionAndSize)info.GetValue("LocationAndSize", s); s._cachedLayerSize = (SizeF)info.GetValue("CachedSize", typeof(SizeF)); s._cachedLayerPosition = (PointF)info.GetValue("CachedPosition", typeof(PointF)); s._coordinateSystem.UpdateAreaSize(s._cachedLayerSize); // LayerProperties bool clipDataToFrame = info.GetBoolean("ClipDataToFrame"); s._dataClipping = clipDataToFrame ? LayerDataClipping.StrictToCS : LayerDataClipping.None; // axis related s.LinkedScales = (LinkedScaleCollection)info.GetValue("AxisProperties", s); // Styles G2DScaleStyleCollection ssc = (G2DScaleStyleCollection)info.GetValue("AxisStyles", s); GridPlane gplane = new GridPlane(CSPlaneID.Front); gplane.GridStyle[0] = ssc.ScaleStyle(0).GridStyle; gplane.GridStyle[1] = ssc.ScaleStyle(1).GridStyle; s.GridPlanes.Add(gplane); foreach (AxisStyle ax in ssc.AxisStyles) s._axisStyles.Add(ax); // Legends count = info.OpenArray("Legends"); s.Legend = (TextGraphic)info.GetValue("e", s); info.CloseArray(count); // XYPlotLayer specific count = info.OpenArray("LinkedLayers"); s.LinkedLayerLink = (Main.RelDocNodeProxy)info.GetValue("e", s); info.CloseArray(count); s.GraphObjects = (GraphicCollection)info.GetValue("GraphicGlyphs", s); s.PlotItems = (PlotItemCollection)info.GetValue("Plots", s); return s; }
/// <summary>Returns the grid position of the nearest face.</summary> /// <returns>Grid position of the nearest face.</returns> /// <param name="worldPoint">Point in world space.</param> /// <param name="plane">Plane on which the face lies.</param> /// /// Similar to <see cref="NearestFaceW"/>, except you get grid coordinates /// instead of world coordinates. Since faces lie between vertices two /// values will always have +0.5 compared to vertex coordinates, while the /// values that lies on the plane will have a round number. /// <example> /// Example: /// <code> /// GFRectGrid myGrid; /// Vector3 worldPoint; /// Vector3 face = myGrid.NearestFaceG(worldPoint, GFGrid.GridPlane.XY); // something like (2.5, -1.5, 3) /// </code> /// </example> public override Vector3 NearestFaceG(Vector3 worldPoint, GridPlane plane) { return RoundPoint(WorldToGrid(worldPoint) - 0.5f * Vector3.one + 0.5f * Units[(int)plane]) + 0.5f * Vector3.one - 0.5f * Units[(int)plane]; }
public GridPlaneController(GridPlane doc) { InitializeDocument(doc); }
protected virtual XYPlotLayer SDeserialize(object o, Altaxo.Serialization.Xml.IXmlDeserializationInfo info, object parent) { XYPlotLayer s = (o == null ? new XYPlotLayer(info) : (XYPlotLayer)o); int count; // Background IBackgroundStyle bgs = (IBackgroundStyle)info.GetValue("Background", s); if (null != bgs) { if (!s.GridPlanes.Contains(CSPlaneID.Front)) s.GridPlanes.Add(new GridPlane(CSPlaneID.Front)); s.GridPlanes[CSPlaneID.Front].Background = bgs.Brush; } // size, position, rotation and scale var location = (XYPlotLayerPositionAndSize_V0)info.GetValue("LocationAndSize", s); s._cachedLayerSize = (SizeF)info.GetValue("CachedSize", s); s._cachedLayerPosition = (PointF)info.GetValue("CachedPosition", s); s._coordinateSystem.UpdateAreaSize(s._cachedLayerSize); s.Location = location.ConvertToCurrentLocationVersion(s._cachedLayerSize, s._cachedLayerPosition); // LayerProperties bool clipDataToFrame = info.GetBoolean("ClipDataToFrame"); s._dataClipping = clipDataToFrame ? LayerDataClipping.StrictToCS : LayerDataClipping.None; // axis related var linkedScales = (Altaxo.Graph.Scales.Deprecated.LinkedScaleCollection)info.GetValue("AxisProperties", s); s.SetupOldAxes(linkedScales); // Styles G2DScaleStyleCollection ssc = (G2DScaleStyleCollection)info.GetValue("AxisStyles", s); GridPlane gplane = new GridPlane(CSPlaneID.Front); gplane.GridStyle[0] = ssc.ScaleStyle(0).GridStyle; gplane.GridStyle[1] = ssc.ScaleStyle(1).GridStyle; s.GridPlanes.Add(gplane); foreach (AxisStyle ax in ssc.AxisStyles) s._axisStyles.Add(ax); // Legends count = info.OpenArray("Legends"); var legend = (TextGraphic)info.GetValue("e", s); info.CloseArray(count); // XYPlotLayer specific count = info.OpenArray("LinkedLayers"); var linkedLayer = (Main.RelDocNodeProxy)info.GetValue("e", s); info.CloseArray(count); ProvideLinkedScalesWithLinkedLayerIndex(s, linkedLayer, info); s.GraphObjects.AddRange((IEnumerable<IGraphicBase>)info.GetValue("GraphicGlyphs", s)); if (null != legend) { var legend1 = new LegendText(legend); s.GraphObjects.Add(legend1); } s.PlotItems = (PlotItemCollection)info.GetValue("Plots", s); return s; }