essentials.Prefabs.PrefabExtensions Class Reference

Public Types
enum	PrefabTransform {   PrefabTransform.Undefined =0, PrefabTransform.FlipX, PrefabTransform.FlipY, PrefabTransform.FlipZ,   PrefabTransform.RotateZ90, PrefabTransform.RotateZ180, PrefabTransform.RotateZ270 }

Static Public Member Functions
static Prefab	SubPrefab (this Prefab prefab, Vector3i offset, Size3i size, Vector3i? center=null)
static Prefab	Autocrop (this Prefab prefab, Vector3i? center=null)
static Prefab	Transform (this Prefab prefab, Func< Vector3i, Vector3i > transform)
static Prefab	Transform (this Prefab prefab, PrefabTransform transform)

Member Enumeration Documentation

PrefabTransform

enum essentials.Prefabs.PrefabExtensions.PrefabTransform

strong

Enumerator
Undefined
FlipX
FlipY
FlipZ
RotateZ90
RotateZ180
RotateZ270

        {
            Undefined=0,
            FlipX,
            FlipY,
            FlipZ,
            RotateZ90,
            RotateZ180,
            RotateZ270
        }

Member Function Documentation

Autocrop()

static Prefab essentials.Prefabs.PrefabExtensions.Autocrop ( this Prefab  prefab, Vector3i?  center = null  )

static

Attribute: x,y,z

!= 0)

        {
            int minX = int.MaxValue;
            int minY = int.MaxValue;
            int minZ = int.MaxValue;
            int maxX = -int.MaxValue;
            int maxY = -int.MaxValue;
            int maxZ = -int.MaxValue;

            for (int x=0; x<prefab.Width; ++x)
            {
                for (int y=0; y<prefab.Length; ++y)
                {
                    for (int z=0; z<prefab.Height; ++z)
                    {
                        if (prefab[x,y,z] != 0)
                        {
                            minX = Math.Min(minX, x);
                            minY = Math.Min(minY, y);
                            minZ = Math.Min(minZ, z);

                            maxX = Math.Max(maxX, x);
                            maxY = Math.Max(maxY, y);
                            maxZ = Math.Max(maxZ, z);
                        }
                    }
                }
            }

            return SubPrefab(prefab, new Vector3i(minX, minY, minZ), new Size3i(maxX - minX, maxY - minY, maxZ - minZ), center);
        }

SubPrefab()

static Prefab essentials.Prefabs.PrefabExtensions.SubPrefab ( this Prefab  prefab, Vector3i  offset, Size3i  size, Vector3i?  center = null  )

static

Attribute: pt] = prefab[origPoint

;

        {
            Vector3i newCenter = center ?? prefab.Center - offset;
            var cropped = new Prefab(size, newCenter);

            for (int x=0; x<size.Width; ++x)
            {
                for (int y=0; y<size.Length; ++y)
                {
                    for (int z=0; z<size.Height; ++z)
                    {
                        Vector3i pt = new Vector3i(x, y, z);
                        Vector3i origPoint = pt + offset;
                        if (origPoint.X >= 0 && origPoint.Y >= 0 && origPoint.Z >= 0
                            && origPoint.X < prefab.Width && origPoint.Y < prefab.Length && origPoint.Z < prefab.Height)
                        {
                            cropped[pt] = prefab[origPoint];
                        }
                    }
                }
            }

            return cropped;
        }

Transform() [1/2]

static Prefab essentials.Prefabs.PrefabExtensions.Transform ( this Prefab  prefab, Func< Vector3i, Vector3i >  transform  )

static

Attribute: transform(new Vector3i(x, y, z))] = prefab[x, y, z

;

        {
            var l0 = transform(new Vector3i(-1, -1, -1));
            var l1 = transform((Vector3i)prefab.Size);
            var size = (Size3i)Vector3i.ComponentMax(l0, l1);

            var ret = new Prefab(size, transform(prefab.Center));

            for (int x=0; x<prefab.Width; ++x)
            {
                for (int y=0; y<prefab.Length; ++y)
                {
                    for (int z=0; z<prefab.Height; ++z)
                    {
                        ret[transform(new Vector3i(x, y, z))] = prefab[x, y, z];
                    }
                }
            }

            return ret;
        }

Transform() [2/2]

static Prefab essentials.Prefabs.PrefabExtensions.Transform ( this Prefab  prefab, PrefabTransform  transform  )

static

        {
            Func<Vector3i, Vector3i> transformer;
            switch(transform)
            {
                case PrefabTransform.FlipX:
                    transformer = vec => new Vector3i(prefab.Width - vec.X - 1, vec.Y, vec.Z);
                    break;
                case PrefabTransform.FlipY:
                    transformer = vec => new Vector3i(vec.X, prefab.Length - vec.Y - 1, vec.Z);
                    break;
                case PrefabTransform.FlipZ:
                    transformer = vec => new Vector3i(vec.X, vec.Y, prefab.Height - vec.Z - 1);
                    break;
                case PrefabTransform.RotateZ90:
                    transformer = vec => new Vector3i(vec.Y, vec.X, vec.Z);
                    break;
                case PrefabTransform.RotateZ180:
                    transformer = vec => new Vector3i(prefab.Width - vec.X - 1, prefab.Length - vec.Y - 1, vec.Z);
                    break;
                case PrefabTransform.RotateZ270:
                    transformer = vec => new Vector3i(prefab.Length - vec.Y - 1, prefab.Width - vec.X - 1, vec.Z);
                    break;
                default:
                    throw new ArgumentException("Invalid transform", "transform");
            }

            return Transform(prefab, transformer);
        }

---

The documentation for this class was generated from the following file:

• essentials/Prefabs/PrefabExtensions.cs