public static GpuIndexBuffer CreateIndexBuffer(int indexCount, GpuBufferFlags flags)
        {
            if (indexCount == 0)
            {
                Log.Fatal("GpuBufferManager: CreateIndexBuffer: indexCount == 0.");
            }

            return(new GpuIndexBuffer(null, indexCount, flags));
        }
        public static GpuIndexBuffer CreateIndexBuffer(int[] indices, GpuBufferFlags flags = 0)
        {
            if (indices.Length == 0)
            {
                Log.Fatal("GpuBufferManager: CreateIndexBuffer: indices.Length == 0.");
            }
            if (flags.HasFlag(GpuBufferFlags.ComputeWrite))
            {
                Log.Fatal("GpuBufferManager: CreateIndexBuffer: ComputeWrite buffer can't write data from CPU.");
            }

            return(new GpuIndexBuffer(indices, indices.Length, flags));
        }
Beispiel #3
0
        //

        internal GpuIndexBuffer(int[] indices, int indexCount, GpuBufferFlags flags)
        {
            lock (GpuBufferManager.indexBuffers)
                GpuBufferManager.indexBuffers.Add(this);

            this.indices     = indices;
            this.flags       = flags;
            this.indexCount  = indexCount;
            indexCountActual = indexCount;

            if (Flags.HasFlag(GpuBufferFlags.Dynamic))
            {
                if (this.indices == null)
                {
                    this.indices = new int[indexCount];
                }
                dynamic_needUpdateNative = true;
            }
        }
        //

        internal unsafe GpuVertexBuffer(byte[] vertices, int vertexCount, SharpBgfx.VertexLayout vertexDeclaration, GpuBufferFlags flags)
        {
            lock (GpuBufferManager.vertexBuffers)
                GpuBufferManager.vertexBuffers.Add(this);

            this.vertices          = vertices;
            this.vertexDeclaration = vertexDeclaration;
            this.vertexCount       = vertexCount;
            vertexCountActual      = vertexCount;
            this.flags             = flags;
            vertexSize             = vertexDeclaration.Stride;

            if (Flags.HasFlag(GpuBufferFlags.Dynamic))
            {
                if (this.vertices == null)
                {
                    this.vertices = new byte[vertexCount * vertexSize];
                }
                dynamic_needUpdateNative = true;
            }
        }
        public static GpuVertexBuffer CreateVertexBuffer(int vertexCount, SharpBgfx.VertexLayout vertexDeclaration, GpuBufferFlags flags)
        {
            if (vertexCount == 0)
            {
                Log.Fatal("GpuBufferManager: CreateVertexBuffer: vertexCount == 0.");
            }

            return(new GpuVertexBuffer(null, vertexCount, vertexDeclaration, flags));
        }
        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

        //public static GpuBuffer[] GetBuffers()
        //{
        //	lock( buffers )
        //		return buffers.ToArray();
        //}

        public static GpuVertexBuffer CreateVertexBuffer(byte[] vertices, SharpBgfx.VertexLayout vertexDeclaration, GpuBufferFlags flags = 0)
        {
            if (vertices.Length == 0)
            {
                Log.Fatal("GpuBufferManager: CreateVertexBuffer: vertices.Length == 0.");
            }
            if (flags.HasFlag(GpuBufferFlags.ComputeWrite))
            {
                Log.Fatal("GpuBufferManager: CreateVertexBuffer: ComputeWrite buffer can't write data from CPU.");
            }

            var vertexCount = vertices.Length / vertexDeclaration.Stride;

            return(new GpuVertexBuffer(vertices, vertexCount, vertexDeclaration, flags));
        }