コード例 #1
0
ファイル: MeshTool.cs プロジェクト: wachel/block
        public static void SetExtendAo(List <MeshTool.BlockSurface> surface, RayCastManager scene, int normalIndex, VecInt3 gpos)
        {
            for (int i = 0; i < surface.Count; i++)
            {
                VecInt3 pos    = surface[i].pos;
                VecInt3 adjPos = new VecInt3();
                adjPos.x = pos.x + Const.AdjacencyOffsetV[normalIndex].x + gpos.x;
                adjPos.y = pos.y + Const.AdjacencyOffsetV[normalIndex].y + gpos.y;
                adjPos.z = pos.z + Const.AdjacencyOffsetV[normalIndex].z + gpos.z;
                for (int v = 0; v < 4; v++)
                {
                    int curLight = scene.getLight(adjPos.x, adjPos.y, adjPos.z);
                    int num      = 1;
                    for (int b = 0; b < 3; b++)
                    {
                        int sx = Const.VertexSharedOffset[normalIndex, v, b, 0];
                        int sy = Const.VertexSharedOffset[normalIndex, v, b, 1];
                        int sz = Const.VertexSharedOffset[normalIndex, v, b, 2];
                        if (!scene.testBlock(adjPos.x + sx, adjPos.y + sy, adjPos.z + sz, RayCastBlockType.Opacity))
                        {
                            curLight += scene.getLight(adjPos.x + sx, adjPos.y + sy, adjPos.z + sz);
                            num++;
                        }
                    }

                    surface[i].extendAo[v] = curLight / (Const.MaxLightIteration * num * 1.0f);
                }
            }
        }
コード例 #2
0
ファイル: RayMarchingAo.cs プロジェクト: wachel/block
        public static Color[] ToColorsA(RayCastManager rtc, int bits)
        {
            int dgx = rtc.getSizeX();
            int dgy = rtc.getSizeY();
            int dgz = rtc.getSizeZ();

            Color[,,] colors = new Color[dgx, (dgy / bits), dgz];
            for (int gx = 0; gx < dgx; gx++)
            {
                for (int gy = 0; gy < dgy / bits; gy++)
                {
                    for (int gz = 0; gz < dgz; gz++)
                    {
                        int iv = 0;
                        for (int n = 0; n < bits; n++)
                        {
                            iv |= rtc.testBlock(gx, gy * bits + n, gz, RayCastBlockType.Opacity) ? (1 << n) : 0;
                        }
                        float a = iv / (float)((1 << bits) - 1);
                        colors[gx, gy, gz] = new Color(0, 0, 0, a);
                    }
                }
            }


            int sizeX = colors.GetLength(0);
            int sizeY = colors.GetLength(1);
            int sizeZ = colors.GetLength(2);

            Color[] rlt = new Color[sizeX * sizeY * sizeZ];
            for (int x = 0; x < sizeX; x++)
            {
                for (int y = 0; y < sizeY; y++)
                {
                    for (int z = 0; z < sizeZ; z++)
                    {
                        rlt[z * sizeY * sizeX + y * sizeX + x] = colors[x, y, z];
                    }
                }
            }
            return(rlt);
        }
コード例 #3
0
        public static RayCastResult rayTraceSmall(Vector3 startPos, DirInfo dirInfo, RayCastManager rtm, Face faceIn, float maxLength, RayCastBlockType mask)
        {
            int   X        = (int)(startPos.x + dirInfo.stepX * 0.0001f);
            int   Y        = (int)(startPos.y + dirInfo.stepY * 0.0001f);
            int   Z        = (int)(startPos.z + dirInfo.stepZ * 0.0001f);
            float tMaxX    = (dirInfo.stepX > 0 ? (1 - (startPos.x - X)) : (startPos.x - X)) * dirInfo.tDeltaX;//沿射线走多远才能跳到下一个X格
            float tMaxY    = (dirInfo.stepY > 0 ? (1 - (startPos.y - Y)) : (startPos.y - Y)) * dirInfo.tDeltaY;
            float tMaxZ    = (dirInfo.stepZ > 0 ? (1 - (startPos.z - Z)) : (startPos.z - Z)) * dirInfo.tDeltaZ;
            int   outSizeX = dirInfo.stepX > 0 ? rtm.getSizeX() : -1;
            int   outSizeY = dirInfo.stepY > 0 ? rtm.getSizeY() : -1;
            int   outSizeZ = dirInfo.stepZ > 0 ? rtm.getSizeZ() : -1;

            while (true)
            {
                if (tMaxX < tMaxY)
                {
                    if (tMaxX < tMaxZ)
                    {
                        X += dirInfo.stepX;
                        if (X == outSizeX)
                        {
                            return(new RayCastResult(false, X, Y, Z, dirInfo.stepX > 0 ? Face.FNI_x0 : Face.FNI_x1, tMaxX));
                        }
                        else
                        {
                            if (tMaxX > maxLength)
                            {
                                return(new RayCastResult(false, X, Y, Z, Face.FNI_OutOfLength, tMaxX));
                            }
                            else if (rtm.testBlock(X, Y, Z, mask))
                            {
                                return(new RayCastResult(true, X, Y, Z, dirInfo.stepX > 0 ? Face.FNI_x0 : Face.FNI_x1, tMaxX));
                            }
                        }
                        tMaxX += dirInfo.tDeltaX;
                    }
                    else
                    {
                        Z += dirInfo.stepZ;
                        if (Z == outSizeZ)
                        {
                            return(new RayCastResult(false, X, Y, Z, dirInfo.stepZ > 0 ? Face.FNI_z0 : Face.FNI_z1, tMaxZ));
                        }
                        else
                        {
                            if (tMaxZ > maxLength)
                            {
                                return(new RayCastResult(false, X, Y, Z, Face.FNI_OutOfLength, tMaxZ));
                            }
                            else if (rtm.testBlock(X, Y, Z, mask))
                            {
                                return(new RayCastResult(true, X, Y, Z, dirInfo.stepZ > 0 ? Face.FNI_z0 : Face.FNI_z1, tMaxZ));
                            }
                        }
                        tMaxZ += dirInfo.tDeltaZ;
                    }
                }
                else
                {
                    if (tMaxY < tMaxZ)
                    {
                        Y += dirInfo.stepY;
                        if (Y == outSizeY)
                        {
                            return(new RayCastResult(false, X, Y, Z, dirInfo.stepY > 0 ? Face.FNI_y0 : Face.FNI_y1, tMaxY));
                        }
                        else
                        {
                            if (tMaxY > maxLength)
                            {
                                return(new RayCastResult(false, X, Y, Z, Face.FNI_OutOfLength, tMaxY));
                            }
                            else if (rtm.testBlock(X, Y, Z, mask))
                            {
                                return(new RayCastResult(true, X, Y, Z, dirInfo.stepY > 0 ? Face.FNI_y0 : Face.FNI_y1, tMaxY));
                            }
                        }

                        tMaxY += dirInfo.tDeltaY;
                    }
                    else
                    {
                        Z += dirInfo.stepZ;
                        if (Z == outSizeZ)
                        {
                            return(new RayCastResult(false, X, Y, Z, dirInfo.stepZ > 0 ? Face.FNI_z0 : Face.FNI_z1, tMaxZ));
                        }
                        else
                        {
                            if (tMaxZ > maxLength)
                            {
                                return(new RayCastResult(false, X, Y, Z, Face.FNI_OutOfLength, tMaxZ));
                            }
                            else if (rtm.testBlock(X, Y, Z, mask))
                            {
                                return(new RayCastResult(true, X, Y, Z, dirInfo.stepZ > 0 ? Face.FNI_z0 : Face.FNI_z1, tMaxZ));
                            }
                        }

                        tMaxZ += dirInfo.tDeltaZ;
                    }
                }
            }
        }