Esempio n. 1
0
 public override bool Equals(object obj)
 {
     if (obj is LightVertice)
     {
         LightVertice other = (LightVertice)obj;
         return(v00 == other.v00 && v01 == other.v01 && v11 == other.v11 && v10 == other.v10);
     }
     return(false);
 }
Esempio n. 2
0
        //返回点的顺序要与传入点的顺序一致
        public LightVertice GetBlockLightVertice(Section section, int x, int y, int z, Direction direction)
        {
            LightVertice lv = new LightVertice();

            switch (direction)
            {
            case Direction.up:
                lv.v00 = GetBlockLightAverageValue(section, x, y + 1, z, x - 1, y + 1, z, x - 1, y + 1, z - 1, x, y + 1, z - 1);
                lv.v01 = GetBlockLightAverageValue(section, x, y + 1, z, x - 1, y + 1, z, x - 1, y + 1, z + 1, x, y + 1, z + 1);
                lv.v11 = GetBlockLightAverageValue(section, x, y + 1, z, x + 1, y + 1, z, x + 1, y + 1, z + 1, x, y + 1, z + 1);
                lv.v10 = GetBlockLightAverageValue(section, x, y + 1, z, x + 1, y + 1, z, x + 1, y + 1, z - 1, x, y + 1, z - 1);
                break;

            case Direction.down:
                lv.v00 = GetBlockLightAverageValue(section, x, y - 1, z, x - 1, y - 1, z, x - 1, y - 1, z - 1, x, y - 1, z - 1);
                lv.v01 = GetBlockLightAverageValue(section, x, y - 1, z, x - 1, y - 1, z, x - 1, y - 1, z + 1, x, y - 1, z + 1);
                lv.v11 = GetBlockLightAverageValue(section, x, y - 1, z, x + 1, y - 1, z, x + 1, y - 1, z + 1, x, y - 1, z + 1);
                lv.v10 = GetBlockLightAverageValue(section, x, y - 1, z, x + 1, y - 1, z, x + 1, y - 1, z - 1, x, y - 1, z - 1);
                break;

            case Direction.left:
                lv.v00 = GetBlockLightAverageValue(section, x - 1, y, z, x - 1, y - 1, z, x - 1, y - 1, z - 1, x - 1, y, z - 1);
                lv.v01 = GetBlockLightAverageValue(section, x - 1, y, z, x - 1, y + 1, z, x - 1, y + 1, z - 1, x - 1, y, z - 1);
                lv.v11 = GetBlockLightAverageValue(section, x - 1, y, z, x - 1, y + 1, z, x - 1, y + 1, z + 1, x - 1, y, z + 1);
                lv.v10 = GetBlockLightAverageValue(section, x - 1, y, z, x - 1, y - 1, z, x - 1, y - 1, z + 1, x - 1, y, z + 1);
                break;

            case Direction.right:
                lv.v00 = GetBlockLightAverageValue(section, x + 1, y, z, x + 1, y - 1, z, x + 1, y - 1, z - 1, x + 1, y, z - 1);
                lv.v01 = GetBlockLightAverageValue(section, x + 1, y, z, x + 1, y + 1, z, x + 1, y + 1, z - 1, x + 1, y, z - 1);
                lv.v11 = GetBlockLightAverageValue(section, x + 1, y, z, x + 1, y + 1, z, x + 1, y + 1, z + 1, x + 1, y, z + 1);
                lv.v10 = GetBlockLightAverageValue(section, x + 1, y, z, x + 1, y - 1, z, x + 1, y - 1, z + 1, x + 1, y, z + 1);
                break;

            case Direction.front:
                lv.v00 = GetBlockLightAverageValue(section, x, y, z + 1, x - 1, y, z + 1, x - 1, y - 1, z + 1, x, y - 1, z + 1);
                lv.v01 = GetBlockLightAverageValue(section, x, y, z + 1, x + 1, y, z + 1, x + 1, y - 1, z + 1, x, y - 1, z + 1);
                lv.v11 = GetBlockLightAverageValue(section, x, y, z + 1, x + 1, y, z + 1, x + 1, y + 1, z + 1, x, y + 1, z + 1);
                lv.v10 = GetBlockLightAverageValue(section, x, y, z + 1, x - 1, y, z + 1, x - 1, y + 1, z + 1, x, y + 1, z + 1);
                break;

            case Direction.back:
                lv.v00 = GetBlockLightAverageValue(section, x, y, z - 1, x - 1, y, z - 1, x - 1, y - 1, z - 1, x, y - 1, z - 1);
                lv.v01 = GetBlockLightAverageValue(section, x, y, z - 1, x + 1, y, z - 1, x + 1, y - 1, z - 1, x, y - 1, z - 1);
                lv.v11 = GetBlockLightAverageValue(section, x, y, z - 1, x + 1, y, z - 1, x + 1, y + 1, z - 1, x, y + 1, z - 1);
                lv.v10 = GetBlockLightAverageValue(section, x, y, z - 1, x - 1, y, z - 1, x - 1, y + 1, z - 1, x, y + 1, z - 1);
                break;
            }
            return(lv);
        }
Esempio n. 3
0
        public virtual void CalculateMesh(Chunk chunk, MeshData meshData, Block self, Direction renderDirection,
                                          Vector3 v1, Vector3 v2, Vector3 v3, Vector3 v4,
                                          LightVertice sunLight, LightVertice blockLight)
        {
            meshData.AddVertice(v1);
            meshData.AddVertice(v2);
            meshData.AddVertice(v3);
            meshData.AddVertice(v4);
            if ((int)renderDirection > 0)
            {
                meshData.AddQuadTriangles(true);
            }
            else
            {
                meshData.AddQuadTriangles(false);
            }
            AddRenderUV(meshData, self.ExtendId, renderDirection);

            meshData.AddColor(MeshBaseDataCache.Instance.GetColor(sunLight.v00, blockLight.v00, 0, 1));
            meshData.AddColor(MeshBaseDataCache.Instance.GetColor(sunLight.v01, blockLight.v01, 0, 1));
            meshData.AddColor(MeshBaseDataCache.Instance.GetColor(sunLight.v11, blockLight.v11, 0, 1));
            meshData.AddColor(MeshBaseDataCache.Instance.GetColor(sunLight.v10, blockLight.v10, 0, 1));
        }
Esempio n. 4
0
 public bool EqualOther(LightVertice other)
 {
     return(v00 == other.v00 && v01 == other.v01 && v11 == other.v11 && v10 == other.v10);
 }
Esempio n. 5
0
 public override void CalculateMesh(Chunk chunk, MeshData meshData, Block self, Direction renderDirection, Vector3 v1, Vector3 v2, Vector3 v3, Vector3 v4, LightVertice sunLight, LightVertice blockLight)
 {
 }
Esempio n. 6
0
        public void CalculateSectionMesh(Section section, MeshData meshData)
        {
            MeshCalculateWay way = GetCalculateWay(section);

            if (way == MeshCalculateWay.None)
            {
                return;
            }
            for (int d = 0; d < 3; d++)
            {
                int i, j, k, l, w, h,
                    u = (d + 1) % 3,
                    v = (d + 2) % 3;
                ClearIntArr(x);
                ClearIntArr(q);
//				int[] x = new int[]{0,0,0};
//				int[] q = new int[]{0,0,0};

                int direction = d + 1;

                q[d] = 1;
                if (way == MeshCalculateWay.Side)
                {
                    x[d] = dims[d] - 1;
                }
                else
                {
                    x[d] = 0;
                }
                for (; x[d] < dims[d];)
                {
                    int  n         = 0;
                    bool bBInRange = x[d] < dims[d] - 1;
                    for (x[v] = 0; x[v] < dims[v]; x[v]++)
                    {
                        for (x[u] = 0; x[u] < dims[u]; x[u]++)
                        {
                            int x1 = x[0], y1 = x[1], z1 = x[2], x2 = x1 + q[0], y2 = y1 + q[1], z2 = z1 + q[2];

                            Block bA = (x[d] < 1 || way == MeshCalculateWay.Side) ? section.GetBlock(x1, y1, z1, true) : _prevBlocks[n];
                            BlockAttributeCalculator aBAC = BlockAttributeCalculatorFactory.GetCalculator(bA.BlockType);

                            Block bB = section.GetBlock(x2, y2, z2, bBInRange);
                            BlockAttributeCalculator bBAC = BlockAttributeCalculatorFactory.GetCalculator(bB.BlockType);

                            CalculateRenderMesh(section.chunk, meshData, x1, y1 + section.chunkOffsetY, z1, x2, y2 + section.chunkOffsetY, z2, bA, bB, aBAC, bBAC, direction, bBInRange);
                            RefreshRenderMask(_renderMask, _renderDirectionMask, _curRenderBlocks, _sunLightsMask, _blockLightsMask, n, section, x1, y1, z1, x2, y2, z2, bA, bB, aBAC, bBAC, bBInRange, direction);
                            RefreshColliderMask(_faceMask, _colliderMask, n, bA, bB, aBAC, bBAC, direction);

                            _prevBlocks[n] = bB;
                            n++;
                        }
                    }
                    x[d]++;

//					//贪心简化碰撞网格
//					n = 0;
//					for (j = 0; j < dims[v]; j++) {
//						for (i = 0; i < dims[u];) {
//							bool c = _faceMask[n];
//							MeshColliderType c1 = _colliderMask[n];
//							if(c1 != MeshColliderType.none)
//							{
//								for (w = 1;i + w < dims[u] && c1 == _colliderMask[n + w] && c == _faceMask[n + w] ; w++);
//								bool done = false;
//								for (h = 1; j + h < dims[v]; h++) {
//									for (k = 0; k < w; k++) {
//										int doneIndex = n + k + h * dims[u];
//										if(c1 != _colliderMask[doneIndex] || c != _faceMask[doneIndex])
//										{
//											done = true;
//											break;
//										}
//									}
//									if(done)break;
//								}
//
//								x[u] = i; x[v] = j;
//								ClearIntArr(du);
//								ClearIntArr(dv);
////								int[] du = new int[]{0,0,0};
////								int[] dv = new int[]{0,0,0};
//								du[u] = w;
//								dv[v] = h;
//								//因为shader的需求,这边不能-0.5
//								AddFace(c,c1,meshData,MeshBaseDataCache.Instance.GetVector3(x[0],x[1] + section.chunkOffsetY,x[2]),
//								        MeshBaseDataCache.Instance.GetVector3(x[0] + du[0],x[1] + du[1] + section.chunkOffsetY,x[2] + du[2]),
//								        MeshBaseDataCache.Instance.GetVector3(x[0] + du[0] + dv[0],x[1] + du[1] + dv[1] + section.chunkOffsetY,x[2] + du[2] + dv[2]),
//								        MeshBaseDataCache.Instance.GetVector3(x[0] + dv[0],x[1] + dv[1] + section.chunkOffsetY,x[2] + dv[2]));
//								for (l = 0; l < h; l++) {
//									for (k = 0; k < w; k++) {
//										int maskIndex = n + k + l * dims[u];
//										_faceMask[maskIndex] = true;
//										_colliderMask[maskIndex] = MeshColliderType.none;
//									}
//								}
//								i+=w;
//								n+=w;
//							}
//							else
//							{
//								i++;n++;
//							}
//						}
//					}

                    //贪心简化渲染网格

                    n = 0;
                    for (j = 0; j < dims[v]; j++)
                    {
                        for (i = 0; i < dims[u];)
                        {
                            bool      canRender       = _renderMask[n];
                            Direction renderDirection = _renderDirectionMask[n];
                            Block     curBlock        = _curRenderBlocks[n];
                            BlockAttributeCalculator curCalculator = BlockAttributeCalculatorFactory.GetCalculator(curBlock.BlockType);
                            LightVertice             sunLight      = _sunLightsMask[n];
                            LightVertice             blockLight    = _blockLightsMask[n];
                            if (canRender)
                            {
                                for (w = 1; i + w < dims[u] && _renderMask[n + w] && renderDirection == _renderDirectionMask[n + w] &&
                                     curCalculator.CanCombineWithBlock(curBlock.ExtendId, _curRenderBlocks[n + w]) &&
                                     sunLight.EqualOther(_sunLightsMask[n + w]) && blockLight.EqualOther(_blockLightsMask[n + w]); w++)
                                {
                                    ;
                                }
                                bool done = false;
                                for (h = 1; j + h < dims[v]; h++)
                                {
                                    for (k = 0; k < w; k++)
                                    {
                                        int doneIndex = n + k + h * dims[u];
                                        if (!_renderMask[doneIndex] || renderDirection != _renderDirectionMask[doneIndex] ||
                                            !curCalculator.CanCombineWithBlock(curBlock.ExtendId, _curRenderBlocks[doneIndex]) ||
                                            !sunLight.EqualOther(_sunLightsMask[doneIndex]) || !blockLight.EqualOther(_blockLightsMask[doneIndex]))
                                        {
                                            done = true;
                                            break;
                                        }
                                    }
                                    if (done)
                                    {
                                        break;
                                    }
                                }

                                x[u] = i; x[v] = j;
                                ClearIntArr(du);
                                ClearIntArr(dv);
//								int[] du = new int[]{0,0,0};
//								int[] dv = new int[]{0,0,0};
                                du[u] = w;
                                dv[v] = h;
                                curCalculator.CalculateMesh(section.chunk, meshData, curBlock, renderDirection,
                                                            MeshBaseDataCache.Instance.GetVector3(x[0], x[1] + section.chunkOffsetY, x[2]),
                                                            MeshBaseDataCache.Instance.GetVector3(x[0] + du[0], x[1] + du[1] + section.chunkOffsetY, x[2] + du[2]),
                                                            MeshBaseDataCache.Instance.GetVector3(x[0] + du[0] + dv[0], x[1] + du[1] + dv[1] + section.chunkOffsetY, x[2] + du[2] + dv[2]),
                                                            MeshBaseDataCache.Instance.GetVector3(x[0] + dv[0], x[1] + dv[1] + section.chunkOffsetY, x[2] + dv[2]), sunLight, blockLight);
                                for (l = 0; l < h; l++)
                                {
                                    for (k = 0; k < w; k++)
                                    {
                                        int maskIndex = n + k + l * dims[u];
                                        _renderMask[maskIndex] = false;
                                    }
                                }
                                i += w;
                                n += w;
                            }
                            else
                            {
                                i++; n++;
                            }
                        }
                    }
                }
            }
            //计算boxcollider
            int nn = 0;

            for (int y = 0; y < dims[1]; y++)
            {
                for (int x = 0; x < dims[0]; x++)
                {
                    for (int z = 0; z < dims[2]; z++)
                    {
                        Block block = section.GetBlock(x, y, z, true);
                        BlockAttributeCalculator calculator   = BlockAttributeCalculatorFactory.GetCalculator(block.BlockType);
                        MeshColliderType         colliderType = calculator.GetMeshColliderType(block.ExtendId);
                        _terrainColliderMask[nn] = colliderType;
                        nn++;
                    }
                }
            }
            nn = 0;
            int dd;
            int ww;
            int hh;
            int kk;
            int ll;
            int mm;

            for (int y = 0; y < dims[1]; y++)
            {
                for (int x = 0; x < dims[0]; x++)
                {
                    for (int z = 0; z < dims[2];)
                    {
                        MeshColliderType flag = _terrainColliderMask[nn];
                        if (flag != MeshColliderType.none)
                        {
                            for (dd = 1; z + dd < dims[2] && flag == _terrainColliderMask[nn + dd]; dd++)
                            {
                                ;
                            }
                            bool done = false;
                            for (ww = 1; x + ww < dims[0]; ww++)
                            {
                                for (kk = 0; kk < dd; kk++)
                                {
                                    int doneIndex = nn + kk + ww * dims[2];
                                    if (flag != _terrainColliderMask[doneIndex])
                                    {
                                        done = true;
                                        break;
                                    }
                                }
                                if (done)
                                {
                                    break;
                                }
                            }
                            done = false;
                            for (hh = 1; y + hh < dims[1]; hh++)
                            {
                                for (ll = 0; ll < ww; ll++)
                                {
                                    for (kk = 0; kk < dd; kk++)
                                    {
                                        int doneIndex = nn + kk + ll * dims[2] + hh * dims[0] * dims[2];
                                        if (flag != _terrainColliderMask[doneIndex])
                                        {
                                            done = true;
                                            break;
                                        }
                                    }
                                    if (done)
                                    {
                                        break;
                                    }
                                }
                                if (done)
                                {
                                    break;
                                }
                            }

                            Vector3 min    = new Vector3(x, y, z);
                            Vector3 max    = new Vector3(x + ww, y + hh, z + dd);
                            Vector3 center = (min + max) / 2;
                            center.y += section.chunkOffsetY;
                            Vector3 size = max - min;
                            if (flag == MeshColliderType.terrainCollider)
                            {
                                meshData.terrainCollider.AddBox(center, size);
                            }
                            else
                            {
                                meshData.supportCollider.AddBox(center, size);
                            }

                            for (mm = 0; mm < hh; mm++)
                            {
                                for (ll = 0; ll < ww; ll++)
                                {
                                    for (kk = 0; kk < dd; kk++)
                                    {
                                        int maskIndex = nn + kk + ll * dims[2] + mm * dims[0] * dims[2];
                                        _terrainColliderMask[maskIndex] = MeshColliderType.none;
                                    }
                                }
                            }
                            nn += dd;
                            z  += dd;
                        }
                        else
                        {
                            nn++;
                            z++;
                        }
                    }
                }
            }
        }
Esempio n. 7
0
 public override void CalculateMesh(Chunk chunk, MeshData meshData, Block self, Direction renderDirection, Vector3 v1, Vector3 v2, Vector3 v3, Vector3 v4, LightVertice sunLight, LightVertice blockLight)
 {
     meshData.useTransparentTexture = true;
     meshData.useDoubleFace         = true;
     base.CalculateMesh(chunk, meshData, self, renderDirection, v1, v2, v3, v4, sunLight, blockLight);
     meshData.useTransparentTexture = MeshData.DefaultUseTransparentTexture;
     meshData.useDoubleFace         = MeshData.DefaultUseDoubleFace;
 }