C# (CSharp) MeshingMode Beispiele

Beispiel #1

Datei: Chunk.cs Projekt: RandomTiger/SpaceGame1

        public void GenerateMesh(Voxel[] voxels, float voxelSize,float overlapAmount, int xOffset, int yOffset, int zOffset, int xSize, int ySize, int zSize, int ub0, int ub1, int ub2, float selfShadeIntensity, MeshingMode mode, MeshingMode colliderMode, bool immediate)
#endif
        {
            if (mf == null) mf = GetComponent<MeshFilter>();
            if (mc == null) mc = GetComponent<MeshCollider>();
            if (immediate)
            {
#if UNITY_EDITOR
                Generate(ref voxels, voxelSize, overlapAmount, xOffset, yOffset, zOffset, xSize, ySize, zSize, ub0, ub1, ub2,
                            selfShadeIntensity, mode, paintMode);
#else
                Generate(ref voxels, voxelSize, overlapAmount, xOffset, yOffset, zOffset, xSize, ySize, zSize, ub0, ub1, ub2,
                            selfShadeIntensity, mode);
#endif
                SetMesh();

                if (colliderMode != mode &&transform.parent.parent.parent.GetComponent<Volume>().CollisionMode != CollisionMode.None)
                {
#if UNITY_EDITOR
                    Generate(ref voxels, voxelSize, overlapAmount, xOffset, yOffset, zOffset, xSize, ySize, zSize, ub0, ub1, ub2,
                                selfShadeIntensity, mode, paintMode);
#else
                Generate(ref voxels, voxelSize, overlapAmount, xOffset, yOffset, zOffset, xSize, ySize, zSize, ub0, ub1, ub2,
                            selfShadeIntensity, mode);
#endif

                }

                if (transform.parent.parent.parent.GetComponent<Volume>().CollisionMode != CollisionMode.None)
                    SetColliderMesh();
            }
            else
            {
                if (status != ChunkStatus.NoChange) return;
#if UNITY_WINRT && !UNITY_EDITOR
                System.Threading.Tasks.Task.Run(() =>
                {
                    GenerateThreaded(ref voxels, voxelSize, xOffset, yOffset, zOffset, xSize, ySize, zSize,ub0, ub1, ub2,
                        selfShadeIntensity, mode);
                });
#else
#if UNITY_EDITOR
                ThreadPool.QueueUserWorkItem(delegate
                {
                    GenerateThreaded(ref voxels, voxelSize, overlapAmount, xOffset, yOffset, zOffset, xSize, ySize, zSize, ub0, ub1, ub2,
                        selfShadeIntensity, mode, paintMode);
                });
#else
                 ThreadPool.QueueUserWorkItem(delegate
                {
                    GenerateThreaded(ref voxels, voxelSize, overlapAmount, xOffset, yOffset, zOffset, xSize, ySize, zSize,ub0, ub1, ub2,
                        selfShadeIntensity, mode);
                });
#endif
#endif
            }
        }

Beispiel #2

        public void GenerateMesh(Voxel[] voxels, float voxelSize, float overlapAmount, int xOffset, int yOffset, int zOffset, int xSize, int ySize, int zSize, int ub0, int ub1, int ub2, float selfShadeIntensity, MeshingMode mode, MeshingMode colliderMode, bool immediate)
#endif
        {
            if (mf == null)
            {
                mf = GetComponent <MeshFilter>();
            }
            if (mc == null)
            {
                mc = GetComponent <MeshCollider>();
            }
            if (immediate)
            {
#if UNITY_EDITOR
                Generate(ref voxels, voxelSize, overlapAmount, xOffset, yOffset, zOffset, xSize, ySize, zSize, ub0, ub1, ub2,
                         selfShadeIntensity, mode, paintMode);
#else
                Generate(ref voxels, voxelSize, overlapAmount, xOffset, yOffset, zOffset, xSize, ySize, zSize, ub0, ub1, ub2,
                         selfShadeIntensity, mode);
#endif
                SetMesh();

                if (colliderMode != mode && transform.parent.parent.parent.GetComponent <Volume>().CollisionMode != CollisionMode.None)
                {
#if UNITY_EDITOR
                    Generate(ref voxels, voxelSize, overlapAmount, xOffset, yOffset, zOffset, xSize, ySize, zSize, ub0, ub1, ub2,
                             selfShadeIntensity, mode, paintMode);
#else
                    Generate(ref voxels, voxelSize, overlapAmount, xOffset, yOffset, zOffset, xSize, ySize, zSize, ub0, ub1, ub2,
                             selfShadeIntensity, mode);
#endif
                }

                if (transform.parent.parent.parent.GetComponent <Volume>().CollisionMode != CollisionMode.None)
                {
                    SetColliderMesh();
                }
            }
            else
            {
                if (status != ChunkStatus.NoChange)
                {
                    return;
                }
#if UNITY_WINRT && !UNITY_EDITOR
                System.Threading.Tasks.Task.Run(() =>
                {
                    GenerateThreaded(ref voxels, voxelSize, overlapAmount, xOffset, yOffset, zOffset, xSize, ySize, zSize, ub0, ub1, ub2,
                                     selfShadeIntensity, mode);
                });
#else
#if UNITY_WEBGL && !UNITY_EDITOR
                // WEBGL platform does not support threading (yet)
                Generate(ref voxels, voxelSize, overlapAmount, xOffset, yOffset, zOffset, xSize, ySize, zSize, ub0, ub1, ub2,
                         selfShadeIntensity, mode);
                SetMesh();

                if (colliderMode != mode && transform.parent.parent.parent.GetComponent <Volume>().CollisionMode != CollisionMode.None)
                {
                    Generate(ref voxels, voxelSize, overlapAmount, xOffset, yOffset, zOffset, xSize, ySize, zSize, ub0, ub1, ub2,
                             selfShadeIntensity, mode);
                }

                if (transform.parent.parent.parent.GetComponent <Volume>().CollisionMode != CollisionMode.None)
                {
                    SetColliderMesh();
                }
#else
#if UNITY_EDITOR
                if (!ThreadPool.QueueUserWorkItem(delegate
                {
                    GenerateThreaded(ref voxels, voxelSize, overlapAmount, xOffset, yOffset, zOffset, xSize, ySize, zSize, ub0, ub1, ub2,
                                     selfShadeIntensity, mode, paintMode);
                }))
                {
                    Generate(ref voxels, voxelSize, overlapAmount, xOffset, yOffset, zOffset, xSize, ySize, zSize, ub0, ub1, ub2,
                             selfShadeIntensity, mode, paintMode);
                }
#else
                if (!ThreadPool.QueueUserWorkItem(delegate
                {
                    GenerateThreaded(ref voxels, voxelSize, overlapAmount, xOffset, yOffset, zOffset, xSize, ySize, zSize, ub0, ub1, ub2,
                                     selfShadeIntensity, mode);
                }))
                {
                    Generate(ref voxels, voxelSize, overlapAmount, xOffset, yOffset, zOffset, xSize, ySize, zSize, ub0, ub1, ub2,
                             selfShadeIntensity, mode);
                }
#endif
#endif
#endif
            }
        }

Beispiel #3

 public void GenerateMesh(Voxel[] voxels, float voxelSize, float overlapAmount, int xOffset, int yOffset, int zOffset, int xSize,
                          int ySize, int zSize, int ub0, int ub1, int ub2, float selfShadeIntensity, MeshingMode mode, MeshingMode colliderMode, bool immediate,
                          EditorPaintMode paintMode)

Beispiel #4

        private void Generate(ref Voxel[] voxels, float voxelSize, float overlapAmount, int xOffset, int yOffset, int zOffset, int xSize, int ySize, int zSize, int ub0, int ub1, int ub2, float selfShadeIntensity, MeshingMode meshMode)
#endif
        {
#if UNITY_EDITOR
            switch (meshMode)
            {
            case MeshingMode.Culled:
                MeshGenerator.GenerateCulled(vertices, uvs, colors, indexes, ref voxels, voxelSize, overlapAmount, xOffset, yOffset, zOffset, xSize, ySize, zSize, ub0, ub1, ub2,
                                             selfShadeIntensity, paintMode);
                break;

            case MeshingMode.Greedy:
                MeshGenerator.GenerateGreedy(vertices, uvs, colors, indexes, ref voxels, voxelSize, overlapAmount, xOffset, yOffset, zOffset, xSize, ySize, zSize, ub0, ub1, ub2,
                                             selfShadeIntensity, paintMode);
                break;

            case MeshingMode.Marching:
                MeshGenerator.GenerateMarching(vertices, uvs, colors, indexes, ref voxels, voxelSize, xOffset, yOffset, zOffset, xSize, ySize, zSize, ub0, ub1, ub2,
                                               selfShadeIntensity, paintMode);
                break;
            }
#else
            switch (meshMode)
            {
            case MeshingMode.Culled:
                MeshGenerator.GenerateCulled(vertices, uvs, colors, indexes, ref voxels, voxelSize, overlapAmount, xOffset, yOffset, zOffset, xSize, ySize, zSize, ub0, ub1, ub2,
                                             selfShadeIntensity);
                break;

            case MeshingMode.Greedy:
                MeshGenerator.GenerateGreedy(vertices, uvs, colors, indexes, ref voxels, voxelSize, overlapAmount, xOffset, yOffset, zOffset, xSize, ySize, zSize, ub0, ub1, ub2,
                                             selfShadeIntensity);
                break;

            case MeshingMode.Marching:
                MeshGenerator.GenerateMarching(vertices, uvs, colors, indexes, ref voxels, voxelSize, xOffset, yOffset, zOffset, xSize, ySize, zSize, ub0, ub1, ub2,
                                               selfShadeIntensity);
                break;
            }
#endif
        }

Beispiel #5

 private void Generate(ref Voxel[] voxels, float voxelSize, float overlapAmount, int xOffset, int yOffset, int zOffset, int xSize, int ySize, int zSize, int ub0, int ub1, int ub2, float selfShadeIntensity, MeshingMode meshMode, EditorPaintMode paintMode)

Beispiel #6

        private void GenerateThreaded(ref Voxel[] voxels, float voxelSize, float overlapAmount, int xOffset, int yOffset, int zOffset, int xSize, int ySize, int zSize, int ub0, int ub1, int ub2, float selfShadeIntensity, MeshingMode meshMode)
#endif
        {
            status = ChunkStatus.CalculatingMesh;
#if UNITY_EDITOR
            Generate(ref voxels, voxelSize, overlapAmount, xOffset, yOffset, zOffset, xSize, ySize, zSize, ub0, ub1, ub2,
                     selfShadeIntensity, meshMode, paintMode);
#else
            Generate(ref voxels, voxelSize, overlapAmount, xOffset, yOffset, zOffset, xSize, ySize, zSize, ub0, ub1, ub2,
                     selfShadeIntensity, meshMode);
#endif

            status = ChunkStatus.Ready;
        }

Beispiel #7

Datei: Chunk.cs Projekt: CreatureSurvive/Project-Cygnus

 public void GenerateMesh(Voxel[] voxels, float voxelSize, float overlapAmount, int xOffset, int yOffset, int zOffset, int xSize,
     int ySize, int zSize, int ub0, int ub1, int ub2, float selfShadeIntensity, MeshingMode mode, MeshingMode colliderMode, bool immediate,
     EditorPaintMode paintMode)

Beispiel #8

Datei: Chunk.cs Projekt: CreatureSurvive/Project-Cygnus

        private void Generate(ref Voxel[] voxels, float voxelSize,float overlapAmount, int xOffset, int yOffset, int zOffset, int xSize, int ySize, int zSize, int ub0, int ub1, int ub2, float selfShadeIntensity, MeshingMode meshMode)
#endif
        {
#if UNITY_EDITOR
            switch (meshMode)
            {
                case MeshingMode.Culled:
                    MeshGenerator.GenerateCulled(vertices, uvs, colors, indexes, ref vertArray, ref uvArray, ref colorArray,
                        ref indexArray, ref voxels, voxelSize, overlapAmount, xOffset, yOffset, zOffset, xSize, ySize, zSize, ub0, ub1, ub2,
                        selfShadeIntensity, paintMode);
                    break;
                case MeshingMode.Greedy:
                    MeshGenerator.GenerateGreedy(vertices, uvs, colors, indexes, ref vertArray, ref uvArray, ref colorArray,
                        ref indexArray, ref voxels, voxelSize, overlapAmount, xOffset, yOffset, zOffset, xSize, ySize, zSize, ub0, ub1, ub2,
                        selfShadeIntensity, paintMode);
                    break;
                case MeshingMode.Marching:
                    MeshGenerator.GenerateMarching(vertices, uvs, colors, indexes, ref vertArray, ref uvArray, ref colorArray,
                        ref indexArray, ref voxels, voxelSize, xOffset, yOffset, zOffset, xSize, ySize, zSize, ub0, ub1, ub2,
                        selfShadeIntensity, paintMode);
                    break;
            }
#else
           switch (meshMode)
            {
                case MeshingMode.Culled:
                    MeshGenerator.GenerateCulled(vertices, uvs, colors, indexes, ref vertArray, ref uvArray, ref colorArray,
                        ref indexArray, ref voxels, voxelSize, overlapAmount,xOffset, yOffset, zOffset, xSize, ySize, zSize, ub0, ub1, ub2,
                        selfShadeIntensity);
                    break;
                case MeshingMode.Greedy:
                    MeshGenerator.GenerateGreedy(vertices, uvs, colors, indexes, ref vertArray, ref uvArray, ref colorArray,
                        ref indexArray, ref voxels, voxelSize, overlapAmount,xOffset, yOffset, zOffset, xSize, ySize, zSize, ub0, ub1, ub2,
                        selfShadeIntensity);
                    break;
                case MeshingMode.Marching:
                    MeshGenerator.GenerateMarching(vertices, uvs, colors, indexes, ref vertArray, ref uvArray, ref colorArray,
                        ref indexArray, ref voxels, voxelSize, xOffset, yOffset, zOffset, xSize, ySize, zSize, ub0, ub1, ub2,
                        selfShadeIntensity);
                    break;
            }    
#endif
        }

Beispiel #9

Datei: Chunk.cs Projekt: CreatureSurvive/Project-Cygnus

 private void Generate(ref Voxel[] voxels, float voxelSize, float overlapAmount, int xOffset, int yOffset, int zOffset, int xSize, int ySize, int zSize, int ub0, int ub1, int ub2, float selfShadeIntensity, MeshingMode meshMode, EditorPaintMode paintMode)

Beispiel #10

Datei: Chunk.cs Projekt: CreatureSurvive/Project-Cygnus

        private void GenerateThreaded(ref Voxel[] voxels, float voxelSize,float overlapAmount, int xOffset, int yOffset, int zOffset, int xSize, int ySize, int zSize, int ub0, int ub1, int ub2, float selfShadeIntensity, MeshingMode meshMode)
#endif
        {
            status = ChunkStatus.CalculatingMesh;
#if UNITY_EDITOR
            Generate(ref voxels, voxelSize, overlapAmount, xOffset, yOffset, zOffset, xSize, ySize, zSize, ub0, ub1, ub2,
                        selfShadeIntensity, meshMode, paintMode);
#else
            Generate(ref voxels, voxelSize, overlapAmount, xOffset, yOffset, zOffset, xSize, ySize, zSize, ub0, ub1, ub2,
                        selfShadeIntensity, meshMode);
#endif

            status = ChunkStatus.Ready;
        }