Exemplo n.º 1
0
        private static byte[] GetQbFromVoxelData(VoxelData data)
        {
            List <byte> bytes = new List <byte>();

            bytes.AddRange(System.BitConverter.GetBytes((uint)257));
            bytes.AddRange(System.BitConverter.GetBytes((uint)0));       // Always RGBA
            bytes.AddRange(System.BitConverter.GetBytes((uint)1));       // Always Right Handed
            bytes.AddRange(System.BitConverter.GetBytes(0));             // Always Not Compressed
            bytes.AddRange(System.BitConverter.GetBytes((uint)1));
            bytes.AddRange(System.BitConverter.GetBytes((uint)data.Voxels.Count));

            for (int index = 0; index < data.Voxels.Count; index++)
            {
                var voxels = data.Voxels[index];

                // Get Size
                int sizeX = voxels.GetLength(0);
                int sizeY = voxels.GetLength(1);
                int sizeZ = voxels.GetLength(2);

                // Get Position
                Vector3 size = data.GetModelSize(index);
                Vector3 pos, rot, scl;
                data.GetModelTransform(index, out pos, out rot, out scl);
                int posX = (int)pos.x - (int)size.x / 2;
                int posY = (int)pos.y - (int)size.y / 2;
                int posZ = (int)pos.z - (int)size.z / 2;

                // name
                bytes.Add(0);

                // size
                bytes.AddRange(System.BitConverter.GetBytes(sizeX));
                bytes.AddRange(System.BitConverter.GetBytes(sizeY));
                bytes.AddRange(System.BitConverter.GetBytes(sizeZ));

                // pos
                bytes.AddRange(System.BitConverter.GetBytes(posX));
                bytes.AddRange(System.BitConverter.GetBytes(posY));
                bytes.AddRange(System.BitConverter.GetBytes(posZ));

                // voxels
                for (int z = 0; z < sizeZ; z++)
                {
                    for (int y = 0; y < sizeY; y++)
                    {
                        for (int x = 0; x < sizeX; x++)
                        {
                            int v = voxels[x, y, z];
                            bytes.AddRange(System.BitConverter.GetBytes(
                                               v == 0 ? 0 : ColorToInt(data.GetColorFromPalette(v))
                                               ));
                        }
                    }
                }
            }


            return(bytes.ToArray());
        }
Exemplo n.º 2
0
        // LGC
        private static Voxel[,,] GetVoxels(VoxelData voxelData, int modelIndex)
        {
            var size  = voxelData.GetModelSize(modelIndex);
            int sizeX = (int)size.x;
            int sizeY = (int)size.z;
            int sizeZ = (int)size.y;

            Voxel[,,] voxels = new Voxel[sizeX, sizeY, sizeZ];
            for (int i = 0; i < sizeX; i++)
            {
                for (int j = 0; j < sizeY; j++)
                {
                    for (int k = 0; k < sizeZ; k++)
                    {
                        voxels[i, j, k].Init();
                        voxels[i, j, k].ColorIndex = voxelData.Voxels[modelIndex][i, k, j];
                    }
                }
            }
            for (int i = 0; i < sizeX; i++)
            {
                for (int j = 0; j < sizeY; j++)
                {
                    for (int k = 0; k < sizeZ; k++)
                    {
                        if (voxels[i, j, k].IsEmpty)
                        {
                            voxels[i, j, k].IsVisible = true;
                            continue;
                        }
                        voxels[i, j, k].VisibleLeft  = i > 0 ? voxels[i - 1, j, k].IsEmpty : true;
                        voxels[i, j, k].VisibleRight = i < sizeX - 1 ? voxels[i + 1, j, k].IsEmpty : true;
                        voxels[i, j, k].VisibleFront = j > 0 ? voxels[i, j - 1, k].IsEmpty : true;
                        voxels[i, j, k].VisibleBack  = j < sizeY - 1 ? voxels[i, j + 1, k].IsEmpty : true;
                        voxels[i, j, k].VisibleDown  = k > 0 ? voxels[i, j, k - 1].IsEmpty : true;
                        voxels[i, j, k].VisibleUp    = k < sizeZ - 1 ? voxels[i, j, k + 1].IsEmpty : true;
                    }
                }
            }
            return(voxels);
        }