Esempio n. 1
0
        public static bool[, ,] GetVisibleBlocks(BlockChunk chunk, BlockTypeFunBase blockFun)
        {
            bool[, ,] blocks = new bool[Const.ChunkSize, Const.ChunkSize, Const.ChunkSize];
            for (int normalIndex = 0; normalIndex < 6; normalIndex++)
            {
                int stepX = normalIndex == 0 ? -1 : (normalIndex == 1 ? 1 : 0);
                int stepY = normalIndex == 2 ? -1 : (normalIndex == 3 ? 1 : 0);
                int stepZ = normalIndex == 4 ? -1 : (normalIndex == 5 ? 1 : 0);
                for (int x = 0; x < Const.ChunkSize; x++)
                {
                    for (int y = 0; y < Const.ChunkSize; y++)
                    {
                        for (int z = 0; z < Const.ChunkSize; z++)
                        {
                            int   nextX = x + stepX;
                            int   nextY = y + stepY;
                            int   nextZ = z + stepZ;
                            short block = chunk.getBlock(x, y, z);
                            if (block != 0)
                            {
                                bool  isCurrentVisible = blockFun.isCollider(block);
                                short nextBlock        = chunk.getBlock(nextX, nextY, nextZ);

                                bool isNextOpacity = blockFun.isCollider(nextBlock);
                                if (isCurrentVisible && !isNextOpacity)
                                {
                                    blocks[x, y, z] = true;
                                }
                            }
                        }
                    }
                }
            }
            return(blocks);
        }
Esempio n. 2
0
        public static List <BlockSurface> getChunkSurface(BlockChunk chunk, BlockTypeFunBase blockFun, int normalIndex)
        {
            int stepX = normalIndex == 0 ? -1 : (normalIndex == 1 ? 1 : 0);
            int stepY = normalIndex == 2 ? -1 : (normalIndex == 3 ? 1 : 0);
            int stepZ = normalIndex == 4 ? -1 : (normalIndex == 5 ? 1 : 0);
            List <BlockSurface> surfacePoints = new List <BlockSurface>();

            for (int x = 0; x < Const.ChunkSize; x++)
            {
                for (int y = 0; y < Const.ChunkSize; y++)
                {
                    for (int z = 0; z < Const.ChunkSize; z++)
                    {
                        int   nextX            = x + stepX;
                        int   nextY            = y + stepY;
                        int   nextZ            = z + stepZ;
                        short block            = chunk.getBlock(x, y, z);
                        bool  isCurrentVisible = blockFun.isVisible(block);
                        bool  isNextOpacity    = blockFun.isOpacity(chunk.getBlockSmart(nextX, nextY, nextZ));
                        if (isCurrentVisible && !isNextOpacity)
                        {
                            BlockSurface surface = new BlockSurface(new Vector3(x, y, z), block, new float[4], new float[4]);
                            for (int v = 0; v < 4; v++)
                            {
                                surface.smallAo[v] = getVertexSmallAo(chunk, blockFun, x, y, z, normalIndex, v);
                            }
                            surfacePoints.Add(surface);
                        }
                    }
                }
            }
            return(surfacePoints);
        }
Esempio n. 3
0
 public void create(int chunkNumX, int chunkNumY, int chunkNumZ, BlockTypeFunBase blockTypeFun)
 {
     this.chunkNumX    = chunkNumX;
     this.chunkNumY    = chunkNumY;
     this.chunkNumZ    = chunkNumZ;
     this.blockTypeFun = blockTypeFun;
     Array.Resize(ref chunks, chunkNumX * chunkNumY * chunkNumZ);
     for (int i = 0; i < chunks.Length; i++)
     {
         chunks[i] = new BlockChunk(blockTypeFun);
     }
     forEachChunk((chunk, i, j, k) =>
     {
         for (int x = -1; x <= 1; x++)
         {
             for (int y = -1; y <= 1; y++)
             {
                 for (int z = -1; z <= 1; z++)
                 {
                     // int index = (z+1)*9+(y+1)*3+x+1;
                     if (i + x >= 0 && i + x < chunkNumX && j + y >= 0 && j + y < chunkNumY && k + z >= 0 && k + z < chunkNumZ)
                     {
                         chunk.setAdjacencyChunk(x, y, z, getChunk(i + x, j + y, k + z));
                     }
                 }
             }
         }
     });
 }
Esempio n. 4
0
        static BlockChunk createDefaultChunk()
        {
            BlockChunk rlt = new BlockChunk(null);

            for (int i = 0; i < Const.ChunkSize; i++)
            {
                for (int j = 0; j < Const.ChunkSize; j++)
                {
                    for (int k = 0; k < Const.ChunkSize; k++)
                    {
                        rlt.setBlock(i, j, k, (short)BlockTypeEnum.Out);
                    }
                }
            }
            return(rlt);
        }
Esempio n. 5
0
        private static float getVertexSmallAo(BlockChunk blocks, BlockTypeFunBase blockFun, int x, int y, int z, int faceIndex, int vertixIndex)
        {
            float rlt = 1.0f;

            int  offset0X = Const.VertexAdjacencyOffset[faceIndex, vertixIndex, 0, 0];
            int  offset0Y = Const.VertexAdjacencyOffset[faceIndex, vertixIndex, 0, 1];
            int  offset0Z = Const.VertexAdjacencyOffset[faceIndex, vertixIndex, 0, 2];
            bool bBlock0  = blockFun.isOpacity(blocks.getBlockSmart(x + offset0X, y + offset0Y, z + offset0Z));

            int  offset1X = Const.VertexAdjacencyOffset[faceIndex, vertixIndex, 1, 0];
            int  offset1Y = Const.VertexAdjacencyOffset[faceIndex, vertixIndex, 1, 1];
            int  offset1Z = Const.VertexAdjacencyOffset[faceIndex, vertixIndex, 1, 2];
            bool bBlock1  = blockFun.isOpacity(blocks.getBlockSmart(x + offset1X, y + offset1Y, z + offset1Z));

            int  offset2X = Const.VertexAdjacencyOffset[faceIndex, vertixIndex, 2, 0];
            int  offset2Y = Const.VertexAdjacencyOffset[faceIndex, vertixIndex, 2, 1];
            int  offset2Z = Const.VertexAdjacencyOffset[faceIndex, vertixIndex, 2, 2];
            bool bBlock2  = blockFun.isOpacity(blocks.getBlockSmart(x + offset2X, y + offset2Y, z + offset2Z));

            if (bBlock0 && bBlock2)  //如果两个共边对角块都是实体,则共点对角块存不存在已经无所谓,说明是三面内角
            {
                rlt *= 0.7f;
            }
            else if ((bBlock0 && bBlock1) || (bBlock1 && bBlock2))  //如果有一个共边对角块和一个共点对角块,则说明是阶梯的内角
            {
                rlt *= 0.8f;
            }
            else if (bBlock0 || bBlock1 || bBlock2)
            {
                rlt *= 0.8f;
            }
            else
            {
                rlt *= 1.0f;
            }
            return(rlt);
        }
Esempio n. 6
0
 public static void calcChunkLight(BlockChunk chunk, int cx, int cy, int cz, RayCastManager rayTraceManager, Vector3[][] rays, Vector3 sunDir)
 {
     //List<VecInt3>[] surfaces = chunk.calcSurfaceList();
     //for (int f = 0; f < 6; f++) {
     //    List<VecInt3> surs = surfaces[f];
     //    for (int i = 0; i < surs.Count; i++) {
     //        VecInt3 surface = surs[i];
     //        int gx = cx * Const.ChunkSize + surface.x;
     //        int gy = cy * Const.ChunkSize + surface.y;
     //        int gz = cz * Const.ChunkSize + surface.z;
     //        Vector3 faceNormal = Const.getFaceNormal(f);
     //        float faceLightFactor = Vector3.Dot(faceNormal, -sunDir);
     //        Vector3 startPos = (new Vector3(gx, gy, gz) + Vector3.one * 0.5f + faceNormal * 0.51f) * Const.BlockSize;
     //
     //        float directionLight = 0;
     //        float aoLight = 0;
     //        float aoLenght = 8.0f;
     //        if(faceLightFactor > 0){
     //            RayCastRestult rlt = rayTraceManager.rayCast(startPos, -sunDir, 30);
     //            directionLight += rlt.bHit ? 0 : faceLightFactor;
     //        }
     //        for (int r = 0; r < rays[f].Length; r++) {
     //            RayCastRestult rlt = rayTraceManager.rayCast(startPos, rays[f][r], aoLenght);
     //            if (rlt.bHit && rlt.hitLength < aoLenght) {
     //                float a = ((rlt.hitLength) / aoLenght);
     //                aoLight += (a / rays[f].Length);
     //            }
     //            else {
     //                aoLight += 1.0f / rays[f].Length;
     //            }
     //        }
     //        float brightness = directionLight * 0.35f + aoLight * 0.45f + 0.2f;
     //        brightness = Mathf.Clamp(brightness, 0, 1);
     //        chunk.setBrightness(surface.x, surface.y, surface.z, f, (Byte)(brightness * Const.MaxBrightness));
     //    }
     //}
 }
Esempio n. 7
0
 public void setAdjacencyChunk(int x, int y, int z, BlockChunk chunk)
 {
     adjacencyChunks[(z + 1) * 9 + (y + 1) * 3 + (x + 1)] = chunk;
 }