/// <summary> /// update grid, if there is change in From or To Vectors /// </summary> public virtual void UpdateGrid() { gridPayload = GenerateVerticies(gridOrigin, From, To, CellSize); GenerateCells(gridPayload); ColliderConfiguration(gridPayload, gridOrigin); gridRenderer.UpdateGridRenderer(gridPayload); }
private GridVerticiesPayload gridPayloadMaker() { GridVerticiesPayload g = new GridVerticiesPayload(); g.xDimension = xDimension; g.yDimension = yDimension; g.zDimension = zDimension; g.origin = gridOrigin; g.CellSize = CellSize; g.xStart = xStart; g.xEnd = xEnd; g.yStart = yStart; g.yEnd = yEnd; g.zStart = zStart; g.zEnd = zEnd; g.gridCellsPositions = gridCellPositions; return(g); }
/// <summary> /// /// </summary> /// <param name="gridPayload"></param> /// <param name="i"></param> private void RenderGridTiles(GridVerticiesPayload gridPayload, Interactable i) { // use a circular render texture, that //Ray cameraRay = Camera.main.ScreenPointToRay(new Vector3(Camera.main.pixelWidth / 2, Camera.main.pixelHeight / 2, 0)); //RaycastHit hit; //if (Physics.Raycast(cameraRay, out hit, 100f) & hit.collider.GetComponent<Floor>()) //{ // Vector3 floorPos = hit.collider.GetComponent<Floor>().transform.position; // circle.SetActive(true); // circle.transform.position = new Vector3(hit.point.x, floorPos.y, hit.point.z); // // You need a way to map the grid shaders w/ // // relative to the mouse movement //} //else //{ // circle.SetActive(false); //} //for (int x = 0; x < g.xDimension; x++) //{ // for (int z = 0; z < g.zDimension; z++) // { // } //} }
public void ConfigureGrid() { calculateGridLengths(); calculateGridDimensions(); setUpGridVertices(); setGridLengthsAbsValue(); generateGridVerticies(); generateGridCellPositions(); g = gridPayloadMaker(); }
// initialize grid on Start at Beginning of RunTime. private void initalizeGrid() { // for non AR //gridOrigin = transform.position; gridPayload = GenerateVerticies(gridOrigin, from, to, CellSize); gridRenderer.UpdateGridRenderer(gridPayload); ColliderConfiguration(gridPayload, gridOrigin); //GenerateCells(gridPayload); // for AR }
private void ColliderConfiguration(GridVerticiesPayload g, Vector3 colliderOrigin) { collider = GetComponent <BoxCollider>(); // take into account that the scale units (i.e. a cube scale of 20 means a collider width of 1 will mean // the actual dimensions will be 20. Vector3 scale = transform.localScale; Debug.Log(scale); // collider.size = new Vector3((g.xDimension * CellSize)/scale.x, g.yDimension*CellSize, (g.zDimension * CellSize)/scale.z); collider.center = colliderOrigin; }
public void UpdateGridRenderer(GridVerticiesPayload v) { xStart = v.xStart; xEnd = v.xEnd; yStart = v.yStart; yEnd = v.yEnd; zStart = v.zStart; zEnd = v.zEnd; xDimension = v.xDimension; yDimension = v.yDimension; zDimension = v.zDimension; }
/// <summary> /// Add cells that are within the Camera boundaries. /// </summary> private void GenerateCells(GridVerticiesPayload g) { for (int x = 0; x < g.xDimension - 1; x++) { for (int y = 0; y < g.yDimension - 1; y++) { for (int z = 0; y < g.zDimension - 1; z++) { float shiftedX = x - g.origin.x + g.CellSize / 2; float shiftedY = y - g.origin.y + g.CellSize / 2; float shiftedZ = z - g.origin.z + g.CellSize / 2; Vector3 cellPos = new Vector3(shiftedX, shiftedY, shiftedZ); //cells[i] = new Cell(cellPos, g.CellSize); } } } }
// inspiration https://www.youtube.com/watch?v=QBO1m-AFntQ #region Private rendering / cell calculation methods /// <summary> /// Generate vertices for the vertex array; /// </summary> /// <param name="gridOrigin"></param> private GridVerticiesPayload GenerateVerticies(Vector3 gridOrigin, Vector3 from, Vector3 to, float cellSize) { GridVerticiesPayload g = new GridVerticiesPayload(); // check type sensitivity here for (int i = 0; i < 3; i++) { from[i] = Mathf.Clamp(from[i], -Mathf.Infinity, 0); to[i] = Mathf.Clamp(to[i], 0, Mathf.Infinity); } // private variables -> call this the // changeGridLengths(); int xStartLength = Mathf.FloorToInt(from.x - gridOrigin.x); int yStartLength = Mathf.FloorToInt(from.y - gridOrigin.y); int zStartLength = Mathf.FloorToInt(from.z - gridOrigin.z); int xEndLength = Mathf.FloorToInt(to.x - gridOrigin.x); int yEndLength = Mathf.FloorToInt(to.y - gridOrigin.y); int zEndLength = Mathf.FloorToInt(to.z - gridOrigin.z); g.xDimension = Mathf.Abs(xEndLength - xStartLength); g.yDimension = Mathf.Abs(yEndLength - yStartLength); g.zDimension = Mathf.Abs(zEndLength - zStartLength); //Debug.Log("Grid Origin: " + gridOrigin); //Debug.Log(xStartLength + " , " + yStartLength + " , " + zStartLength); //Debug.Log(xEndLength + " , " + yEndLength + " , " + zEndLength); //Debug.Log(g.xDimension + " , " + g.yDimension + " , " + g.zDimension); g.origin = gridOrigin; g.CellSize = cellSize; // x axis end g.xStart = new Vector3[g.xDimension, g.zDimension]; g.xEnd = new Vector3[g.xDimension, g.zDimension]; // y axis end g.yStart = new Vector3[g.yDimension, g.zDimension]; g.yEnd = new Vector3[g.yDimension, g.zDimension]; // z axis end g.zStart = new Vector3[g.xDimension, g.yDimension]; g.zEnd = new Vector3[g.xDimension, g.yDimension]; // for math purposes, convert to abs value xStartLength = Mathf.Abs(xStartLength); yStartLength = Mathf.Abs(yStartLength); zStartLength = Mathf.Abs(zStartLength); xEndLength = Mathf.Abs(xEndLength); yEndLength = Mathf.Abs(yEndLength); zEndLength = Mathf.Abs(zEndLength); // x lines for (int x = 0; x < g.xDimension; x++) { for (int z = 0; z < g.zDimension; z++) { g.xStart[x, z] = new Vector3(g.CellSize * (x - xStartLength + gridOrigin.x), g.CellSize * (-yStartLength + gridOrigin.y), g.CellSize * (z - zStartLength + gridOrigin.z)); g.xEnd[x, z] = new Vector3(g.CellSize * (x - xStartLength + gridOrigin.x), g.CellSize * (yEndLength + gridOrigin.y), g.CellSize * (z - zStartLength + gridOrigin.z)); } } // y lines for (int y = 0; y < g.yDimension; y++) { for (int z = 0; z < g.zDimension; z++) { g.yStart[y, z] = new Vector3(g.CellSize * (-xStartLength + gridOrigin.x), g.CellSize * (y - yStartLength + gridOrigin.y), g.CellSize * (z - zStartLength + gridOrigin.z)); g.yEnd[y, z] = new Vector3(g.CellSize * (xEndLength + gridOrigin.x), g.CellSize * (y - yStartLength + gridOrigin.y), g.CellSize * (z - zStartLength + gridOrigin.z)); } } // z lines for (int x = 0; x < g.xDimension; x++) { for (int y = 0; y < g.yDimension; y++) { g.zStart[x, y] = new Vector3(g.CellSize * (x - xStartLength + gridOrigin.x), g.CellSize * (y - yStartLength + gridOrigin.y), g.CellSize * (-zStartLength + gridOrigin.z)); g.zEnd[x, y] = new Vector3(g.CellSize * (x - xStartLength + gridOrigin.x), g.CellSize * (y - yStartLength + gridOrigin.y), g.CellSize * (zEndLength + gridOrigin.z)); } } return(g); }
// place this method in the Projector GameObject public void shiftGraph(GridVerticiesPayload g, Vector3 cameraShift) { #region notes // how to shift using the gridVerticiesPayload? // what type of problem am I solving // refactoring // the problem I'm having is -> // I hate individually changing each individual variable because // it requires me to remember each variable. // I prefer calling methods which manipulate multiple variables at once, rather than // try to do it at every step // it adds extra cognitive load to the process, by repeating the steps needed t // what are the pros and cons of each use case. #endregion #region steps // I am interested in refactoring the gridPayload because // I feel that there will be multiple use cases I haven't accounted for // that I want to prepare for. // think about single responsibility problem // question -> should this be triggered by an event listener? // i.e. everytime there is a Time.deltaTime change, send an event to the delegate // so that this grid can make that change // step 0) -> From the public interface, have a // public method that allows for the shifting of the graph // i.e. g.shiftGraph(cameraShift); // step 1 -> in ShiftGraph, access the existing from and to // public variables, shift the opposite direction of movement, // and // step 2 -> change the start lengths and end lengths, // based on the SHIFT of the to and from variables. Internally // call g.changeGridLengths() method // step 4) recalculate the unitDimensions, using the private method // g.changeDimensions() // step 5) g.setGridDimensions() // this will parse through all the // grid private variables & set up grid dimensions. // step 6) g.generateGridVerticies() this will autopopulate the grid dimensions // with vertice coordinates // step 7) call the gridRenderer to rerender the // this means that we need access to the // to and from variables #endregion }