GraphicsStream Class

Language: Visual BasicC#C++JScript(Show All)

---

Contains a graphics data stream.

Definition

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

Members Table

The following table lists the members exposed by the object. Click a tab on the left to choose the type of member you want to view.

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

Object

MarshalByRefObject

Stream

GraphicsStream

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 Stream 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 Arrays 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

---

Send comments about this topic to Microsoft. © Microsoft Corporation. All rights reserved.

Feedback? Please provide us with your comments on this topic.
For more help, visit the DirectX Developer Center