Windows Dev Center

GraphicsStream Class (Microsoft.DirectX)

Contains a graphics data stream.

Definition

Visual Basic NotInheritable Public Class GraphicsStream
    Inherits StreamLeave Site
C# public sealed class GraphicsStream : StreamLeave Site
C++ public ref class GraphicsStream sealed : StreamLeave Site
JScript public final class GraphicsStream extends StreamLeave Site

Members Table

The following table lists the members exposed by the object.

Methods

Method Description
Close Closes the current stream and releases any resources associated with it.
Dispose Immediately releases the unmanaged resources used by an object.
Equals Returns a value that indicates whether the current instance is equal to a specified object.
Finalize Called during garbage collection. If implemented, allows an object to free resources before it is destroyed by the garbage collector.
Flush Flushing the graphics stream is not supported.
GetHashCode Returns the hash code for the current instance.
GraphicsStream Initializes a new instance of the GraphicsStream class.
Read Reads from the current stream and advances the position within it by the number of bytes read.
Seek Sets the position within the current stream.
SetLength Resizing the graphics stream is not supported.
Write Writes to the current stream and advances the current position within it by the number of bytes written.

Properties

Property Description
CanRead Retrieves a value that indicates whether the current stream supports reading.
CanSeek Retrieves a value that indicates whether the current stream supports seeking.
CanWrite Retrieves a value that indicates whether the current stream supports writing.
InternalBuffer This internal data member is the direct pointer to the unmanaged memory. It can be used, for example, to glue in unmanaged code that renders to dynamic textures.
InternalBufferPointer This internal data member is the direct pointer to the unmanaged memory. It can be used, for example, to glue in unmanaged code that renders to dynamic textures.
InternalData This internal data member is the direct pointer to the unmanaged memory. It can be used, for example, to glue in unmanaged code that renders to dynamic textures.
InternalDataPointer This internal data member is the direct pointer to the unmanaged memory. It can be used, for example, to glue in unmanaged code that renders to dynamic textures.
Length Retrieves the length of the stream in bytes.
Position Retrieves or sets the position within the current stream.

Inheritance Hierarchy

How Do I...?

Read and Write VertexBuffer and IndexBuffer Data With GraphicsStreams

This example demonstrates how to use GraphicsStream objects to fill and retrieve data from a VertexBuffer and IndexBuffer objects.

[C#]

In the following C# code example, a VertexBuffer object is created using a flexible vertex format (FVF) type defined by the PositionNormalTexVertex structure. The vertex buffer data is then locked using its offset and size in bytes. A GraphicsStream object is returned which is derived from StreamLeave Site and can be used in a similar fashon. In the code example, the Write method is used to copy data into the stream from an array of vertex data.

The second part of the method shows use of GraphicsStream using unsafe data access. The InternalDataPointerGraphicsStream.InternalData property returns a void pointer to the vertex buffer data. In this code example, the data is cast to an array of PositionNormalTexVertex structures which makes data manipulation more readable.

using System;
using Microsoft.DirectX;
using Microsoft.DirectX.Direct3D;

public struct PositionNormalTexVertex
{
	public Vector3 Position;
	public Vector3 Normal;
	public  float Tu0, Tv0;
	public static readonly VertexFormats FVF = VertexFormats.Position | VertexFormats.Texture1;
}
public class Example
{
	public unsafe void  GraphicsStreamReadWrite()
	{
		//Create a vertex buffer in the managed pool
		VertexBuffer vb = new VertexBuffer(typeof(PositionNormalTexVertex), 100, device, Usage.None, PositionNormalTexVertex.FVF, Pool.Managed);

		//First, fill an array of PositionNormalTexVertex elements with data.
		PositionNormalTexVertex[] vertices = new PositionNormalTexVertex[50];
		for(int i=0; i<50; i++)
		{
			//fill the vertices with some data...
			vertices[i].Position = new Vector3(3f,4f,5f);
		}

		//The size of the verticies are 32-bytes each (float3 (12) + float3 (12) + float(4) + float(4))
		//To lock 50 verticies, the size of the lock would be 1600 (32 * 50)
		GraphicsStream vbData =  vb.Lock(0,1600, LockFlags.None);

		//copy the vertex data into the vertex buffer
		vbData.Write(vertices);

		//Unlock the VB
		vb.Unlock();


		//This time, lock the entire VertexBuffer
		vbData =  vb.Lock(0, 3200, LockFlags.None);

		//Cast the InternalDataPointer (a void pointer) to an array of verticies
		PositionNormalTexVertex* vbArray = (PositionNormalTexVertex*) vbData.InternalDataPointer;

		for(int i=0; i<100; i++)
		{
			//perform some operations on the data
			vbArray[i].Tu0 = i;
			vbArray[i].Tv0 = vbArray[i].Tu0 * 2;

			Console.WriteLine(vbArray[i].Tv0.ToString());
		}

		//Unlock the buffer
		vb.Unlock();
		vb.Dispose();
	}
}
Read and Write VertexBuffer Data With Arrays

This example demonstrates how to use arrays to fill and retrieve data from a VertexBuffer and IndexBuffer objects.

[C#]

In the following C# code example, a VertexBuffer object is created using a FVF type defined by the PositionNormalTexVertex structure. The first part of the code sample shows the use of Lock to lock an arbitrary number of vertices and fill them with data. The second part shows how to lock an entire VertexBuffer for reading and retrieving data from the array. A similar procedure can be used to write to and read from nearly all Microsoft Direct3D resource types.

Using ArraysLeave Site is not the most efficient method for filling and reading from Direct3D resources; it requires extra memory and cycles to copy the unmanaged resources into managed arrays. However, it makes for very readable code with no unsafe access.

using System;
using Microsoft.DirectX;
using Microsoft.DirectX.Direct3D;

public struct PositionNormalTexVertex
{
	public Vector3 Position;
	public Vector3 Normal;
	public float Tu0, Tv0;
	public static readonly VertexFormats FVF = VertexFormats.Position | VertexFormats.Texture1;
}

public class Example
{
	public void ArrayBasedReadWrite()
	{
		//Create a vertex buffer in the managed pool
		VertexBuffer vb = new VertexBuffer(typeof(PositionNormalTexVertex), 100, device, Usage.None, PositionNormalTex1Vertex.FVF, Pool.Managed);

		//Fill an array of the appropriate type with the VB data using Lock()
		PositionNormalTexVertex[] vbData = (PositionNormalTexVertex[]) vb.Lock(0, typeof(PositionNormalTexVertex), LockFlags.None, 50);
		for(int i=0; i<50; i++)
		{
			//set your vertices to something...
			vbData[i].Position = new Vector3(2f,2f,2f);  
			vbData[i].Normal = new Vector3(1f,0f,0f);
			vbData[i].Tu0 = i;
			vbData[i].Tv0 = i;
		}
		//Unlock the vb before you can use it elsewhere
		vb.Unlock();

		//This lock overload simply locks the entire VB -- setting ReadOnly can improve perf when reading a vertexbuffer
		vbData = (PositionNormalTexVertex[]) vb.Lock(0, LockFlags.ReadOnly);
		for(int i=0; i<100; i++)
		{
			//read some vertex data
			Console.WriteLine("Vertex " + i + "Tu: " +  vbData[i].Tu0 + " , Tv: " + vbData[i].Tv0);
		}

		//Unlock the buffer
		vb.Unlock();


		vb.Dispose();
	}
}

Class Information

Namespace Microsoft.DirectX
Assembly Microsoft.DirectX (microsoft.directx.dll)
Strong Name Microsoft.DirectX,  Version=1.0.900.0,  Culture=neutral,  PublicKeyToken=d3231b57b74a1492
Show:
© 2015 Microsoft