Example #1
0
        private StreamIO getBufferStream(GltfAccessor accessor)
        {
            GltfBufferView bufferView = _root.BufferViews[accessor.BufferView.Value];
            GltfBuffer     buffer     = _root.Buffers[bufferView.Buffer];

            StreamIO stream = new StreamIO(_chunk.GetBytes(0, buffer.ByteLength));

            stream.Position = bufferView.ByteOffset + accessor.ByteOffset;

            return(stream);
        }
Example #2
0
        private static GltfBufferView[] ExtractBufferViews(glTFLoader.Schema.Gltf model)
        {
            var noOfItems = model.BufferViews != null ? model.BufferViews.Length : 0;
            var output    = new GltfBufferView[noOfItems];

            for (var i = 0; i < noOfItems; i += 1)
            {
                output[i] = new GltfBufferView(model.BufferViews[i]);
            }
            return(output);
        }
Example #3
0
        private static void ConstructBufferView(this GltfObject gltfObject, GltfBufferView bufferView)
        {
            bufferView.Buffer = gltfObject.buffers[bufferView.buffer];

            if (bufferView.Buffer.BufferData == null &&
                !string.IsNullOrEmpty(gltfObject.Uri) &&
                !string.IsNullOrEmpty(bufferView.Buffer.uri))
            {
                var parentDirectory = Directory.GetParent(gltfObject.Uri).FullName;
                bufferView.Buffer.BufferData = File.ReadAllBytes($"{parentDirectory}\\{bufferView.Buffer.uri}");
            }
        }
Example #4
0
        public GltfBufferView Extend(Memory <byte> array, int stride, GltfBufferTargetType target)
        {
            var tmp = m_bytes;
            // alignment
            var padding = m_used % stride == 0 ? 0 : stride - m_used % stride;

            if (m_bytes == null || m_used + padding + array.Length > m_bytes.Length)
            {
                // recreate buffer
                var newSize = Math.Max(m_used + padding + array.Length, m_bytes.Length * 2);
                m_bytes = new Byte[newSize];
                if (m_used > 0)
                {
                    // Buffer.BlockCopy(tmp, 0, m_bytes, 0, m_used);
                    tmp.AsSpan().Slice(0, m_used).CopyTo(m_bytes);
                }
            }
            if (m_used + padding + array.Length > m_bytes.Length)
            {
                throw new ArgumentOutOfRangeException();
            }

            array.CopyTo(m_bytes.AsMemory().Slice(m_used + padding, array.Length));

            var result = new GltfBufferView
            {
                buffer     = 0,
                byteLength = array.Length,
                byteOffset = m_used + padding,
                target     = target,
            };

            if (target == GltfBufferTargetType.ARRAY_BUFFER)
            {
                result.byteStride = stride;
            }

            m_used = m_used + padding + array.Length;
            return(result);
        }
Example #5
0
 public Memory <byte> GetBufferBytes(GltfBufferView view)
 {
     return(GetBufferBytes(Gltf.buffers[view.buffer]));
 }