Пример #1
0
        public bool SetVertices(MLOD mlod, MLOD.Mesh mesh, VRTF vrtf, Vertex[] vertices, float[] uvscales)
        {
            bool okay = SetVertices(mlod, mesh.VertexBufferIndex, mesh.StreamOffset, mesh.VertexCount, vrtf, vertices, uvscales);

            mesh.VertexCount = vertices.Length;
            return(okay);
        }
Пример #2
0
        public bool SetVertices(MLOD mlod, MLOD.Mesh mesh, MLOD.GeometryState geo, VRTF vrtf, Vertex[] vertices, float[] uvscales)
        {
            long beforeLength = mesh.StreamOffset + (geo.MinVertexIndex * vrtf.Stride);
            bool okay         = SetVertices(mlod, mesh.VertexBufferIndex, beforeLength, geo.VertexCount, vrtf, vertices, uvscales);

            geo.VertexCount = vertices.Length;
            return(okay);
        }
Пример #3
0
            public static SegmentInfo FromMesh(MLOD.Mesh mesh, VRTF vrtf)
            {
                var segment = new SegmentInfo(0, null);

                segment.VertexSize  = vrtf.Stride;
                segment.VertexCount = mesh.VertexCount;
                segment.ByteOffset  = mesh.StreamOffset;

                foreach (var layout in vrtf.Layouts)
                {
                    switch (layout.Format)
                    {
                    case VRTF.ElementFormat.Float1:
                    case VRTF.ElementFormat.UByte4:
                    case VRTF.ElementFormat.UByte4N:
                    case VRTF.ElementFormat.ColorUByte4:
                    case VRTF.ElementFormat.Dec3N:
                    case VRTF.ElementFormat.UDec3N:
                        segment.Swizzles.Add(new SwizzleEntry(0, null, SwizzleCmd.Swizzle32));
                        break;

                    case VRTF.ElementFormat.Float2:
                        segment.Swizzles.Add(new SwizzleEntry(0, null, SwizzleCmd.Swizzle32));
                        segment.Swizzles.Add(new SwizzleEntry(0, null, SwizzleCmd.Swizzle32));
                        break;

                    case VRTF.ElementFormat.Float3:
                        segment.Swizzles.Add(new SwizzleEntry(0, null, SwizzleCmd.Swizzle32));
                        segment.Swizzles.Add(new SwizzleEntry(0, null, SwizzleCmd.Swizzle32));
                        segment.Swizzles.Add(new SwizzleEntry(0, null, SwizzleCmd.Swizzle32));
                        break;

                    case VRTF.ElementFormat.Float4:
                        segment.Swizzles.Add(new SwizzleEntry(0, null, SwizzleCmd.Swizzle32));
                        segment.Swizzles.Add(new SwizzleEntry(0, null, SwizzleCmd.Swizzle32));
                        segment.Swizzles.Add(new SwizzleEntry(0, null, SwizzleCmd.Swizzle32));
                        segment.Swizzles.Add(new SwizzleEntry(0, null, SwizzleCmd.Swizzle32));
                        break;

                    case VRTF.ElementFormat.Short2:
                    case VRTF.ElementFormat.Short2N:
                    case VRTF.ElementFormat.UShort2N:
                    case VRTF.ElementFormat.Float16_2:
                        segment.Swizzles.Add(new SwizzleEntry(0, null, SwizzleCmd.Swizzle16x2));
                        break;

                    case VRTF.ElementFormat.Short4:
                    case VRTF.ElementFormat.Short4N:
                    case VRTF.ElementFormat.UShort4N:
                    case VRTF.ElementFormat.Float16_4:
                        segment.Swizzles.Add(new SwizzleEntry(0, null, SwizzleCmd.Swizzle16x2));
                        segment.Swizzles.Add(new SwizzleEntry(0, null, SwizzleCmd.Swizzle16x2));
                        break;
                    }
                }
                return(segment);
            }
Пример #4
0
        public BoundingBox GetBoundingBox(MLOD.Mesh mesh, VRTF vrtf)
        {
            BoundingBox bbox = null;

            GetBoundingBox(GetVertices(mesh, vrtf, null), ref bbox);
            foreach (var geos in mesh.GeometryStates)
            {
                GetBoundingBox(GetVertices(mesh, vrtf, geos, null), ref bbox);
            }

            return(bbox ?? new BoundingBox(0, null));
        }
Пример #5
0
 public static VRTF CreateDefaultForMesh(MLOD.Mesh mesh)
 {
     return(mesh.IsShadowCaster ? CreateDefaultForSunShadow() : CreateDefaultForDropShadow());
 }
Пример #6
0
 public bool SetVertices(MLOD mlod, MLOD.Mesh mesh, int geoIndex, VRTF vrtf, Vertex[] vertices, float[] uvscales)
 {
     return(SetVertices(mlod, mesh, mesh.GeometryStates[geoIndex], vrtf, vertices, uvscales));
 }
Пример #7
0
 public Vertex[] GetVertices(MLOD.Mesh mesh, VRTF vrtf, MLOD.GeometryState geo, float[] uvscales)
 {
     return(GetVertices(vrtf, mesh.StreamOffset + (geo.MinVertexIndex * vrtf.Stride), geo.VertexCount, uvscales));
 }
Пример #8
0
 public Vertex[] GetVertices(MLOD.Mesh mesh, VRTF vrtf, float[] uvscales)
 {
     return(GetVertices(vrtf, mesh.StreamOffset, mesh.VertexCount, uvscales));
 }
Пример #9
0
 public void SetIndices(MLOD mlod, MLOD.Mesh mesh, int geoStateIndex, Int32[] indices)
 {
     MLOD.GeometryState geometryState = mesh.GeometryStates[geoStateIndex];
     SetIndices(mlod, mesh, geometryState, indices);
 }
Пример #10
0
 public void SetIndices(MLOD mlod, MLOD.Mesh mesh, Int32[] indices)
 {
     SetIndices(mlod, mesh.IndexBufferIndex, mesh.PrimitiveType, mesh.StartIndex, mesh.PrimitiveCount, indices);
     mesh.PrimitiveCount = indices.Length / IndexCountFromPrimitiveType(mesh.PrimitiveType);
 }
Пример #11
0
 public Int32[] GetIndices(MLOD.Mesh mesh, MLOD.GeometryState geometryState)
 {
     return(GetIndices(mesh.PrimitiveType, geometryState.StartIndex, geometryState.PrimitiveCount)
            .Select(x => x - geometryState.MinVertexIndex).ToArray());
 }
Пример #12
0
 public Int32[] GetIndices(MLOD.Mesh mesh, int geoStateIndex)
 {
     return(GetIndices(mesh, mesh.GeometryStates[geoStateIndex]));
 }
Пример #13
0
 public Int32[] GetIndices(MLOD.Mesh mesh)
 {
     return(GetIndices(mesh.PrimitiveType, mesh.StartIndex, mesh.PrimitiveCount));
 }
Пример #14
0
 public void SetIndices(MLOD mlod, MLOD.Mesh mesh, MLOD.GeometryState geometryState, Int32[] indices)
 {
     SetIndices(mlod, mesh.IndexBufferIndex, mesh.PrimitiveType, geometryState.StartIndex, geometryState.PrimitiveCount,
                indices.Select(x => x + geometryState.MinVertexIndex).ToArray());
     geometryState.PrimitiveCount = indices.Length / IndexCountFromPrimitiveType(mesh.PrimitiveType);
 }