public void GenMap(int xSize, int ySize, int zSize) { cubeMap = new bool[xSize, ySize, zSize]; float min = float.MaxValue; float Max = float.MinValue; //float[,,] floatMap = new float[xSize, ySize, zSize]; for (int x = 0; x < xSize; x++) { for (int y = 0; y < ySize; y++) { for (int z = 0; z < zSize; z++) { float xCoord = (((float)x / xSize) / scale * frequncy) + offset.x; float yCoord = (((float)y / ySize) / scale * frequncy) + offset.y; float zCoord = (((float)z / zSize) / scale * frequncy) + offset.z; float perlinVal = Perlin.Noise(xCoord, yCoord, zCoord); //Debug.Log(perlinVal); if (perlinVal < min) { min = perlinVal; } if (perlinVal > Max) { Max = perlinVal; } cubeMap[x, y, z] = perlinVal > toggleThreshold; } } } //Debug.Log("min: " + min + " Max: " + Max); }
private bool DetectCollisionWithStaticBlocks(bool[,,] block, int blockIndex, Vector2Int position) { Vector2Int blockSize = new Vector2Int(block.GetLength(2), block.GetLength(1)); for (int x = 0; x < blockSize.x; x++) { for (int y = 0; y < blockSize.y; y++) { //checks if part of the blockgrid is outside of the main grid if (position.x + x < 0 || position.x + x >= gridSize.x || position.y + y < 0) { //checks if that part of the blockgrid is actually part of the block if (block[blockIndex, y, x]) { if (position.y + y > 0) { if (grid[position.x + x, position.y + y]) { Debug.Log("Collision"); return(true); } } else { return(true); } } } } } return(false); }
/// <summary> /// 初始化方块组 /// </summary> public void Init() { GroupInfos groupInfos = transform.parent.GetComponent <GroupInfos>(); // 销毁当前方块 foreach (Cube cube in GetComponentsInChildren <Cube>()) { Destroy(cube.gameObject); } // 随机选择一个结构 info = groupInfos.infos[Random.Range(0, groupInfos.infoSize)]; // 构建新方块 for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) { for (int k = 0; k < 3; k++) { if (info[i, j, k]) { GameObject cube = GameObject.Instantiate(Cubepre, transform); // 相对于中心的位置生成方块 cube.transform.localPosition = new Vector3(k - 0.5f - 1, i - 1, j - 0.5f - 1); } } } } }
public Position(int size) { this.size = size; this.range = (int)Math.Sqrt(size); this.numbers = new int[size, size]; this.impossible = new bool[size, size, size]; }
public bool InstantiateGameObjects(bool[,,] status) { gameOjects = new GameObjectModel[field, field, field]; if (status.Length != gameOjects.Length) { return(false); } position = new Vector3(); for (int i = 0; i < field; i++) { position.z = 0; for (int j = 0; j < field; j++) { position.x = 0; for (int k = 0; k < field; k++) { gameOjects[i, j, k] = new GameObjectModel(GameObject.Instantiate(prefab, position, Quaternion.identity)); gameOjects[i, j, k].IsRed = status[i, j, k]; gameOjects[i, j, k].UpdateBollView(GameController.IsSet); //gameOjects[i, j, k].SetIJKToView(i, j, k); to debug position.x += 10; } position.z -= 10; } position.y -= 10; } return(true); }
protected bool TryGrowZ(CuboidWithMaterial cub, bool[,,] voxels, bool[,,] voxelVisited, byte[,,] voxelMaterial) { if (cub.Z2 > 15) { return(false); } for (int x = cub.X1; x < cub.X2; x++) { for (int y = cub.Y1; y < cub.Y2; y++) { if (!voxels[x, y, cub.Z2] || voxelVisited[x, y, cub.Z2] || voxelMaterial[x, y, cub.Z2] != cub.Material) { return(false); } } } for (int x = cub.X1; x < cub.X2; x++) { for (int y = cub.Y1; y < cub.Y2; y++) { voxelVisited[x, y, cub.Z2] = true; } } cub.Z2++; return(true); }
protected bool TrySnowGrowZ(CuboidWithMaterial cub, bool[,,] voxels, bool[,] voxelVisited) { if (cub.Z2 > 15) { return(false); } for (int x = cub.X1; x < cub.X2; x++) { // Stop if // "Floor" is gone, already visited, or there's a voxel above if (!voxels[x, cub.Y1, cub.Z2] || voxelVisited[x, cub.Z2] || (cub.Y2 < 15 && voxels[x, cub.Y2, cub.Z2])) { return(false); } } for (int x = cub.X1; x < cub.X2; x++) { voxelVisited[x, cub.Z2] = true; } cub.Z2++; return(true); }
protected bool TryGrowX(CuboidWithMaterial cub, bool[,,] voxels, bool[,,] voxelVisited, byte[,,] voxelMaterial) { if (cub.X2 > 15) { return(false); } for (int y = cub.Y1; y < cub.Y2; y++) { for (int z = cub.Z1; z < cub.Z2; z++) { if (!voxels[cub.X2, y, z] || voxelVisited[cub.X2, y, z] || voxelMaterial[cub.X2, y, z] != cub.Material) { return(false); } } } for (int y = cub.Y1; y < cub.Y2; y++) { for (int z = cub.Z1; z < cub.Z2; z++) { voxelVisited[cub.X2, y, z] = true; } } cub.X2++; return(true); }
protected bool TryGrowY(CuboidWithMaterial cub, bool[,,] voxels, bool[,,] voxelVisited, byte[,,] voxelMaterial) { if (cub.Y2 > 15) { return(false); } for (int x = cub.X1; x < cub.X2; x++) { for (int z = cub.Z1; z < cub.Z2; z++) { if (!voxels[x, cub.Y2, z] || voxelVisited[x, cub.Y2, z] || voxelMaterial[x, cub.Y2, z] != cub.Material) { return(false); } } } for (int x = cub.X1; x < cub.X2; x++) { for (int z = cub.Z1; z < cub.Z2; z++) { voxelVisited[x, cub.Y2, z] = true; } } cub.Y2++; return(true); }
protected void convertToVoxels(out bool[,,] voxels, out byte[,,] materials) { voxels = new bool[16, 16, 16]; materials = new byte[16, 16, 16]; CuboidWithMaterial cwm = tmpCuboid; for (int i = 0; i < VoxelCuboids.Count; i++) { FromUint(VoxelCuboids[i], cwm); for (int dx = cwm.X1; dx < cwm.X2; dx++) { for (int dy = cwm.Y1; dy < cwm.Y2; dy++) { for (int dz = cwm.Z1; dz < cwm.Z2; dz++) { voxels[dx, dy, dz] = true; materials[dx, dy, dz] = cwm.Material; } } } } }
void Start() { blockStates = new bool[200, 200, 200]; blockObjects = new GameObject[200, 200, 200]; textureManager = GameObject.Find("Game Logic").GetComponent <TextureManager> (); }
private void LoadLevel() { if (GameObjectsTable != null) { ClearGameObjectsTable(); } CurrentLevel = LH.GetLevel(); GameSize = CurrentLevel.GameSize; MovesToComplete = CurrentLevel.MovesToComplete; // calculate width and beggining if (!spread) { CellGap = 0; } else { CellGap = (realWidth - (CellGap * (GameSize - 1) * 2)) / (GameSize * 2) / 1.5f; } CalculateWidthAndBeggining(); GameRoutine = null; // initiate other level utilities GameTable = new bool[GameSize, GameSize, GameSize]; NextGameTable = new bool[GameSize, GameSize, GameSize]; GameObjectsTable = new GameObject[GameSize, GameSize, GameSize]; TimeAlive = new int[GameSize, GameSize, GameSize]; // copy level table into game table AssignTableValues(); }
public int size; //A size parameter so size is recorded on a per maze basis public Maze(int mazeSize) { size = mazeSize; adjacencyList = new bool[mazeSize, mazeSize, 2]; //Initialize all cells as connected for (int i = 0; i < mazeSize; i++) { for (int j = 0; j < mazeSize; j++) { adjacencyList[i, j, 0] = true; adjacencyList[i, j, 1] = true; } } //Remove connections to invalid cells for (int i = 0; i < mazeSize; i++) { adjacencyList[i, mazeSize - 1, 1] = false; } for (int j = 0; j < mazeSize; j++) { adjacencyList[mazeSize - 1, j, 0] = false; } }
void RegenMeshAndSelectionBoxes() { int layer = NextNotMatchingRecipeLayer(); if (workitemRenderer != null) { if (layer != 16) { workitemRenderer.RegenMesh(workItemStack, Voxels, SelectedRecipe, layer); } } List <Cuboidf> boxes = new List <Cuboidf>(); bool[,,] recipeVoxels = SelectedRecipe?.Voxels; for (int x = 0; x < 16; x++) { for (int y = 0; y < 16; y++) { for (int z = 0; z < 16; z++) { if (y == 0 || Voxels[x, y, z] || (recipeVoxels != null && y == layer && recipeVoxels[x, y, z])) { // Console.WriteLine("box {0} is voxel at {1},{2}", boxes.Count, x, z); boxes.Add(new Cuboidf(x / 16f, y / 16f, z / 16f, x / 16f + 1 / 16f, y / 16f + 1 / 16f, z / 16f + 1 / 16f)); } } } } selectionBoxes = boxes.ToArray(); }
private void debugArray(bool[,,] a) { string dString = ""; int x = pieceSize.x; int y = pieceSize.y; int z = pieceSize.z; for (int u = 0; u < x; u++) { for (int v = 0; v < y; v++) { for (int w = 0; w < z; w++) { if (a[u, v, w] == true) { dString += "1 "; } else { dString += "0 "; } } } } }
public void CheckIfFinished(IPlayer byPlayer) { if (MatchesRecipe() && api.World is IServerWorldAccessor) { workItemStack = null; Voxels = new bool[16, 16, 16]; AvailableVoxels = 0; ItemStack outstack = SelectedRecipe.Output.ResolvedItemstack.Clone(); selectedRecipeNumber = -1; if (outstack.StackSize == 1 && outstack.Class == EnumItemClass.Block) { api.World.BlockAccessor.SetBlock(outstack.Block.BlockId, pos); return; } while (outstack.StackSize > 0) { ItemStack dropStack = outstack.Clone(); dropStack.StackSize = Math.Min(outstack.StackSize, outstack.Collectible.MaxStackSize); outstack.StackSize -= dropStack.StackSize; if (byPlayer.InventoryManager.TryGiveItemstack(dropStack)) { api.World.PlaySoundAt(new AssetLocation("sounds/player/collect"), byPlayer); } else { api.World.SpawnItemEntity(dropStack, pos.ToVec3d().Add(0.5, 0.5, 0.5)); } } api.World.BlockAccessor.SetBlock(0, pos); } }
private bool DetectCollision(bool[,,] block, int blockIndex, Vector2Int position) { Vector2Int blockSize = new Vector2Int(block.GetLength(2), block.GetLength(1)); for (int y = 0; y < blockSize.y; y++) { for (int x = 0; x < blockSize.x; x++) { if (position.x + x < 0 || position.x + x >= columns || position.y + y < 0) { //Debug.Log("blockindex: " + blockIndex + " x: " + x + " y: " + y); if (block[blockIndex, y, x]) { return(true); } } else { if (block[blockIndex, y, x] && grid[position.y + y, position.x + x]) { return(true); } } } } return(false); }
public Life3D(int fieldWidth, int fieldHeight, int fieldDepth, Color cellColor) { if (fieldWidth < 1) { throw new ArgumentOutOfRangeException("fieldWidth", "fieldWidth must be >= 1."); } if (fieldHeight < 1) { throw new ArgumentOutOfRangeException("fieldHeight", "fieldHeight must be >= 1."); } if (fieldDepth < 1) { throw new ArgumentOutOfRangeException("fieldDepth", "fieldDepth must be >= 1."); } FieldWidth = fieldWidth; FieldHeight = fieldHeight; FieldDepth = fieldDepth; CellSize = new Vector3( 2f / FieldWidth, 2f / FieldHeight, 2f / FieldDepth); field = new bool[fieldWidth, fieldHeight, fieldDepth]; this.cellColor = cellColor; }
static bool[,,] unmarkThisQuarter(bool[,,] markedQuarters) { RegistryKey gameKey = Registry.CurrentUser.CreateSubKey("żabka\\startup", true); DateTime dateTime = DateTime.Now; int val0 = ((int)dateTime.DayOfWeek - 1) % 7; if (val0 == -1) { val0 = 6; } int val1 = dateTime.Hour; int val2 = dateTime.Minute / 15; markedQuarters[val0, val1, val2] = false; string sAllMarkedQuarters = ""; for (int x = 0; x < 7; x++) { for (int y = 0; y < 24; y++) { for (int z = 0; z < 4; z++) { if (markedQuarters[x, y, z]) { sAllMarkedQuarters += x.ToString() + "," + y.ToString() + "," + z.ToString() + " "; } } } } gameKey.SetValue("markedQuarters", sAllMarkedQuarters); gameKey.Close(); return(markedQuarters); }
private bool[,,] ProcessChanges3D(bool[,,] changes, bool[,,] configuration) { var xLength = configuration.GetLength(0); var yLength = configuration.GetLength(1); var zLength = configuration.GetLength(2); for (int x = 0; x < xLength; x++) { for (int y = 0; y < yLength; y++) { for (int z = 0; z < zLength; z++) { if (changes[x, y, z] == true) { if (configuration[x, y, z] == true) { configuration[x, y, z] = false; } else { configuration[x, y, z] = true; } } } } } return(configuration); }
public void BuildGrid(Vector3 res, bool buildObsMap) { // lock (workweLock) { scaledRes = new Vector3(); scaledRes.x = bounds.x / res.x; scaledRes.z = bounds.z / res.z; scaledRes.y = bounds.y / res.y; triDPos = new Vector3[(int)res.x, (int)res.y, (int)res.z]; obstacleMap = new bool[(int)res.x, (int)res.y, (int)res.z]; for (int i = 0; i < res.y; i++) { for (int j = 0; j < res.z; j++) { for (int k = 0; k < res.x; k++) { triDPos[k, i, j] = start + new Vector3(scaledRes.x * k, scaledRes.y * i, scaledRes.z * j); } } } //if (buildObsMap) //{ // BuildObstacleMap(); //} } // StartCoroutine(CheckGrid()); }
// Use this for initialization void Start() { cubeScale = Vector3.one * 0.9f * pointGap; numPointsCenter = new Vector3(numPointsX, numPointsY, numPointsZ); numPointsCenter = numPointsCenter / 2.0f; voxels = new bool[numPointsX, numPointsY, numPointsZ]; int i, j, k; minPointRadius = Mathf.Min(numPointsCenter.x, numPointsCenter.y); minPointRadius = Mathf.Min(minPointRadius, numPointsCenter.y); for (i = 0; i < numPointsX; i++) { for (j = 0; j < numPointsY; j++) { for (k = 0; k < numPointsZ; k++) { //if (Random.Range(0, 10) < 6) { // voxels[i, j, k] = true; //} voxels[i, j, k] = (new Vector3(i, j, k) - numPointsCenter).magnitude <= minPointRadius; } } } }
public void Set_MaxY(int maxY) { Arr = new bool[A, Arr.GetLength(1), One_Min(maxY)]; All_Change(); // to avoid illogical remnants at edges, old array cannot be trusted to be relevant Calc_Population(); }
private void IterateRules(int iGen) { var nextGen = new bool[_finalDimXY, _finalDimXY, _finalDimWZ]; // Only live cubes are from CycleCount - iGen to CycleCount + _dimInput + iGen in x and y directions and // from CycleCount - iGen to CycleCount + iGen in the Z direction. for (var iRow = CycleCount - iGen; iRow < CycleCount + _dimInput + iGen; iRow++) { for (var iCol = CycleCount - iGen; iCol < CycleCount + _dimInput + iGen; iCol++) { for (var iPlane = CycleCount - iGen; iPlane <= CycleCount + iGen; iPlane++) { var count = CountNeighbors(iRow, iCol, iPlane); bool newVal; var oldVal = _universe3[iRow, iCol, iPlane]; if (oldVal) { newVal = (count == 2 || count == 3); } else { newVal = count == 3; } nextGen[iRow, iCol, iPlane] = newVal; } } } _universe3 = nextGen; }
void Start() { levelMatrix = new bool[100, 100, 100]; levelMatrix[50, 50, 50] = true; GenerateLevel(MainRooms, Corridors, SideRooms, StartRoom, MinTilesBeforeExit, MaxTilesBeforeExit, MaxTilesTotal); }
static void Check(string[,] matrix, bool[, ,] used, int row, int col) { // Checking all directions for (int direction = 0; direction < directions.GetLength(0); direction++) { // Skip if current direction is checked if (used[row, col, direction]) { continue; } int currentSum = 0; int currentRow = row; int currentCol = col; // Building current sequence while (IsTraversable(matrix, currentRow, currentCol) && matrix[row, col] == matrix[currentRow, currentCol]) { currentSum++; used[currentRow, currentCol, direction] = true; currentRow += directions[direction, 0]; currentCol += directions[direction, 1]; } // Saving current best sequence if (currentSum > maxSum) { maxSum = currentSum; maxValue = matrix[row, col]; } } }
// returns the number of rows completed after placing a shape public int chackRowsComplete(bool [,,] grid) { int maxCount = 0; int counter = 0; for (int i = 0; i < Grid.DEPTH; i++) { for (int j = 0; j < Grid.HEIGHT; j++) { for (int k = 0; k < Grid.WIDTH; k++) { if (grid [k, i, j]) { counter++; } } } if (counter > maxCount) { maxCount = counter; } counter = 0; } return(maxCount); }
public DiscreteModel(InputModel inputModel, int patternSize, Coord3D outputSize, bool overlapping = true, bool periodic = true, bool addNeighbours = false, bool probabilisticModel = true) { mapOfChanges = new bool[outputSize.X, outputSize.Y, outputSize.Z]; neighboursMap = new Dictionary <int, Dictionary <Coord3D, List <int> > >(); this.periodic = periodic; this.probabilisticModel = probabilisticModel; this.patternSize = patternSize; numGen = 0; this.outputSize = outputSize; if (overlapping) { InitOverlappingModel(inputModel, patternSize, periodic); FindNeighbours(); } else { InitSimpleModel(inputModel, patternSize, false); InitNeighboursMap(periodic); if (addNeighbours) { DetectNeighbours(); } } InitOutputMatrix(outputSize); States = new Stack <List <int> [, , ]>(); ChosenPoints = new List <Coord3D>(); TotalRollbacks = 0; Debug.Log($"Model size: {new Vector3(inputModel.Size.X, inputModel.Size.Y, inputModel.Size.Z)}"); Debug.Log("Model Ready!"); }
public void CalculateMedialAxis(ref Voxel[,,] grid, ref float[,,] disField, out bool[,,] result) { int l = grid.GetLength(0); int m = grid.GetLength(1); int n = grid.GetLength(2); result = new bool[l, m, n]; bool isEle; float sqrtDis; for (int i = 0; i < l; ++i) { for (int j = 0; j < m; ++j) { for (int k = 0; k < n; ++k) { isEle = true; for (int x = i != 0 ? -1 : 0; x < (i != (l - 1) ? 2 : 1); ++x) { for (int y = j != 0 ? -1 : 0; y < (j != (m - 1) ? 2 : 1); ++y) { for (int z = k != 0 ? -1 : 0; z < (k != (n - 1) ? 2 : 1); ++z) { sqrtDis = (float)Math.Sqrt(disField[i, j, k]) + (float)Math.Sqrt(x * x + y * y + z * z); isEle = (sqrtDis > Math.Sqrt(disField[i + x, j + y, k + z]) || (x == 0 && y == 0 && z == 0)) ? isEle : false; //isEle = disField[i, j, k] >= disField[i + x, j + y, k + z] ? isEle : false; } } } result[i, j, k] = isEle && grid[i, j, k].set; } } } }
protected override void GenerateTiles(ref bool[,,] _tiles) { // iterate the chldren for (var i = 0; i < transform.childCount; i++) { // grab the local position/scale var pos = transform.GetChild(i).localPosition; var sca = transform.GetChild(i).localScale / TileSize; // fix to the grid var x = Mathf.RoundToInt(pos.x / TileSize); var y = Mathf.RoundToInt(pos.y / TileSize); var z = Mathf.RoundToInt(pos.z / TileSize); // iterate the size of the transform for (var ix = x; ix < x + Mathf.RoundToInt(sca.x); ix++) { for (var iy = y; iy < y + Mathf.RoundToInt(sca.y); iy++) { for (var iz = z; iz < z + Mathf.RoundToInt(sca.z); iz++) { // validate if (ix < 0 || ix >= MAX_TILES_X || iy < 0 | iy >= MAX_TILES_Y || iz < 0 || iz >= MAX_TILES_Z) { continue; } // add the tile _tiles[ix, iy, iz] = true; } } } } }
public MazeGen(int mazeSizeX, int mazeSizeY, int mazeSizeZ, int seed, int cellSize, int smooth) { try { myMaze = new Maze(); myMaze.GenerateMaze(mazeSizeX, mazeSizeY, mazeSizeZ, seed, smooth); Voxels = myMaze.GetMaze(mazeSizeX * 2, mazeSizeY * 2, cellSize); } catch (Exception e) { // log } }
/// <summary> /// This function initiates the recalculation of the sun light level. /// </summary> public void RecalcSunlight() { in_sunlight = updateSunMap(); //update the Sun map addSunlight(in_sunlight, sun_light);//apply it to the arrays prev_sun_light = sun_light; //store the previous light level sun_level_changed = false; }
void Stop() { m_environment.TerrainOrInteriorChanged -= OnTerrainOrInteriorChanged; m_visibilityArray = null; }
/// <summary> /// Creates a 3D world /// </summary> public World(int width, int height, int depth) { worldBlocked = new Boolean[width, height, depth]; }
public void Draw(Vector3 position, float radius, byte color) { if (myChanges == null) { myChanges = RequestBools(); changeCount = 0; } for (int x = 0; x < data.GetLength(0); x++) { for (int y = 0; y < data.GetLength(1); y++) { for (int z = 0; z < data.GetLength(2); z++) { if (Vector3.Distance(position, transform.localPosition + new Vector3(x, y, z)) < radius) { data[x, y, z] = color; if (!myChanges[x, y, z]) { myChanges[x, y, z] = true; changeCount++; } } } } } }
public void LoadChunk(BinaryReader reader) { byte current = 0; byte count = 0; for (int x = 0; x < data.GetLength(0); x++) { for (int y = 0; y < data.GetLength(1); y++) { for (int z = 0; z < data.GetLength(2); z++) { if (count == 0) { count = reader.ReadByte(); current = reader.ReadByte(); if (current >= MarchingCubes.Builder.colorMap.Length) { Debug.LogError("Malformed data from server: " + current, this); current = 0; //var ms = (MemoryStream)reader.BaseStream; //ms.Position = ms.Length; return; } if (count == 0) { Debug.LogError("Count is zero at: " + x + "," + y + "," + z); } } count--; if (current == 0) { continue; } if (data[x, y, z] == 0 || myChanges == null || !myChanges[x, y, z]) { data[x, y, z] = current; } if (myChanges != null && myChanges[x, y, z] && data[x, y, z] == current) { myChanges[x, y, z] = false; changeCount--; } } } } if (myChanges != null && changeCount <= 0) { boolPool.Push(myChanges); myChanges = null; } }
public void ResetShadows() { light = null; lightheight = null; lightheight = new InfiniteHeightCache(); chunklighted = null; UpdateHeightCache(); loaded = true; light = new InfiniteMapCache(); chunklighted = new bool[map.MapSizeX / chunksize, map.MapSizeY / chunksize, map.MapSizeZ / chunksize]; }
public bool[,,] Analyze(IProgressListener progress) { int width = Model.Width; int height = Model.Height; int depth = Model.Depth; exterior = new bool[width, height, depth]; queue = new Queue<IntVector3>(); var model = this.Model; // Start the scan from the boundary for (int x = 0; x < width; ++x) { for (int y = 0; y < height; ++y) { Traverse(x, y, 0); Traverse(x, y, depth - 1); } } for (int x = 0; x < width; ++x) { for (int z = 0; z < depth; ++z) { Traverse(x, 0, z); Traverse(x, height - 1, z); } } for (int y = 0; y < height; ++y) { for (int z = 0; z < depth; ++z) { Traverse(0, y, z); Traverse(width - 1, y, z); } } int numProcessed = 0; while (queue.Count > 0) { var p = queue.Dequeue(); if (p.X > 0) { Traverse(p.X - 1, p.Y, p.Z); } if (p.X < width - 1) { Traverse(p.X + 1, p.Y, p.Z); } if (p.Y > 0) { Traverse(p.X, p.Y - 1, p.Z); } if (p.Y < height - 1) { Traverse(p.X, p.Y + 1, p.Z); } if (p.Z > 0) { Traverse(p.X, p.Y, p.Z - 1); } if (p.Z < depth - 1) { Traverse(p.X, p.Y, p.Z + 1); } ++numProcessed; // this might move the progress bar in a funny way but // we can't do better since we don't know how many exterior voxels are there yet progress?.Report((double)numProcessed / (numProcessed + queue.Count)); } var ret = exterior; exterior = null; return ret; }
void generate(Vector3 voxel) { int cubes = 0; float vx = voxel.x; float vy = voxel.y; float vz = voxel.z; grid = fillGrid (voxel); string targetName = "voxel " + vx + "," + vy + "," + vz; GameObject target = GameObject.Find (targetName); if (target) { target.transform.Find ("geometry").gameObject.SetActive (true); print ("Reactivating voxel " + voxelName(voxel)); return; } print ("instantiating new voxel " + voxelName (voxel)); GameObject node = new GameObject (targetName); node.transform.parent = root; GameObject geometry = new GameObject ("geometry"); geometry.transform.parent = node.transform; geometry.AddComponent<MeshFilter> (); MeshRenderer mr = geometry.AddComponent<MeshRenderer> (); geometry.AddComponent<MeshCollider> (); for (int x = 1; x < gridSize +1; x++) { for (int y = 1; y < gridSize +1; y++) { for (int z = 1; z < gridSize +1; z++) { if (checkPositionEdges (x, y, z)) { cubes++; Transform child = Instantiate (box, new Vector3 ((x + vx * gridSize) * 2, (y + vy * gridSize) * 2, (z + + vz * gridSize) * 2), Quaternion.identity) as Transform; child.parent = geometry.transform; child.gameObject.isStatic = true; } } } } MeshFilter[] meshFilters = geometry.GetComponentsInChildren<MeshFilter> (); CombineInstance[] combine = new CombineInstance[meshFilters.Length]; int i = 0; while (i < meshFilters.Length) { combine [i].mesh = meshFilters [i].sharedMesh; combine [i].transform = meshFilters [i].transform.localToWorldMatrix; meshFilters [i].gameObject.active = false; i++; } Mesh m = geometry.transform.GetComponent<MeshFilter> ().mesh = new Mesh (); geometry.transform.GetComponent<MeshCollider> ().sharedMesh = m; Material mat = Resources.Load ("rock", typeof(Material)) as Material; mr.material = mat; geometry.transform.GetComponent<MeshFilter> ().mesh.CombineMeshes (combine); geometry.transform.gameObject.active = true; }
public void InitiateAnimation(Common.LEDAnimations animation, DispatcherTimer timer) { CurrentAnimation = animation; switch (CurrentAnimation) { case Common.LEDAnimations.RED_LED_ANIMATION: CurrentAnimationArray = RED_LED_ANIMATION; CurrentAnimationMaxFrames = 8; CurrentAnimationFrame = 0; timer.Interval = TimeSpan.FromMilliseconds(200); break; case Common.LEDAnimations.GREEN_LED_ANIMATION: CurrentAnimationArray = GREEN_LED_ANIMATION; CurrentAnimationMaxFrames = 8; CurrentAnimationFrame = 0; timer.Interval = TimeSpan.FromMilliseconds(200); break; case Common.LEDAnimations.YELLOW_LED_ANIMATION: CurrentAnimationArray = YELLOW_LED_ANIMATION; CurrentAnimationMaxFrames = 8; CurrentAnimationFrame = 0; timer.Interval = TimeSpan.FromMilliseconds(200); break; case Common.LEDAnimations.BLUE_LED_ANIMATION: CurrentAnimationArray = BLUE_LED_ANIMATION; CurrentAnimationMaxFrames = 8; CurrentAnimationFrame = 0; timer.Interval = TimeSpan.FromMilliseconds(200); break; case Common.LEDAnimations.GAME_START_LED_ANIMATION: CurrentAnimationArray = GAME_START_LED_ANIMATION; CurrentAnimationMaxFrames = 6; CurrentAnimationFrame = 0; timer.Interval = TimeSpan.FromMilliseconds(500); break; case Common.LEDAnimations.GAME_OVER_LED_ANIMATION: CurrentAnimationArray = GAME_OVER_LED_ANIMATION; CurrentAnimationMaxFrames = 7; CurrentAnimationFrame = 0; timer.Interval = TimeSpan.FromMilliseconds(500); break; case Common.LEDAnimations.FILL: CurrentAnimationArray = FILL_LED_ANIMATION; CurrentAnimationMaxFrames = 18; CurrentAnimationFrame = 0; timer.Interval = TimeSpan.FromMilliseconds(175); break; case Common.LEDAnimations.CLEAR: CurrentAnimationArray = CLEAR_LED_ANIMATION; CurrentAnimationMaxFrames = 1; CurrentAnimationFrame = 0; timer.Interval = TimeSpan.FromMilliseconds(175); break; default: break; } }
public void ResetShadows() { light = null; lightheight = null; lightheight = new InfiniteHeightCache(); chunklighted = null; UpdateHeightCache(); loaded = true; }