DirectX Graphics Interfaces

Created by Jijith Nadumuri at 28 Apr 2010 12:14 and updated at 28 Apr 2010 12:51

DirectXGraphics Interfaces

DirectX Graphics is the graphics component of DirectX. It is composed of core Direct3D interfaces, DirectX Extension (D3DX) library interfaces, interfaces for implimenting rendering effects and finally interfaces for interacting with x files.

The total number of interfaces contained in DirectX Graphics components is as follows:-

  • Core Direct3D Interfaces = 17
  • D3DX Uitility library Interfaces = 22
  • Interfaces for implementing rendering effects = 5
  • Interfaces to interact with x files = 7

Thus there are a total of 51 interfaces in the DirectX Graphics component of DirectX9.

Direct3D Interfaces

Direct3D interfaces are the core of DirectX Graphics. Two dimensional graphics, represented by the DirectDraw component belonging to the earlier versions (DirectX7 to down), is now encompassed by Direct3D. Direct3D deals with 3D graphics, that includes 2D graphics. Direct3D is a low level 3D-graphics API upon which the D3DX utility library is built upon as a high level API.

IDirect3D9

IDirect3D is the root interface of DirectXGraphics. Applications use the methods of the IDirect3D9 interface to create Direct3D objects and set up the environment.

Creation method:-

IDirect3D9* Direct3DCreate9(UINT SDKVersion);

IDirect3DDevice9

Idirect3DDevice9 represents the graphics-device (or devices) of the system. It represents graphics devices like the display card, the 3D accelerator card or the GPU of the system. Applications use the methods of the IDirect3DDevice9 interface to create other interface objects, perform rendering, adjust gamma ramp levels, work with system-level variables and work with palettes.

Creation method:-

IDirect3D9::CreateDevice
IDirect3DSwapChain9

IDirect3DswapChain9 interface represents a swap-chain. A swap chain is a chain of (one or more) backbuffers (offscreen surfaces) waiting to be swapped to the frontbuffer (screen). A single swap-chain is always present by default. DirectX9 supports creation of additional swap-chains. Applications use the methods of the

IDirect3DSwapChain9 interface to manipulate a swap chain.

Creation method:-

IDirect3DDevice9::CreateAdditionalSwapChain
IDirect3DStateBlock9

A state-block is a collection of values representing the state of the rendering pileline of the device. Applications use the methods of the IDirect3DStateBlock9 interface to capture the device's current state or to apply a state-block to the device and thus make it the current device state.

Creation method:-

IDirect3DDevice9::CreateStateBlock

IDirect3DQuery9

Applications use the methods of the IDirect3DQuery9 interface to perform asynchronous queries on a driver.

Creation method:-

IDirect3DDevice9::CreateQuery

IDirect3DResource9

IDirect3DResource9 represents a Direct3D memory resource. A resource can be a a texture, a surface (display-memory) or a buffer that stores geometric-data (like a vertex buffer or an index buffer). This interface is a base interface for many child interfaces that represents various types of the above mentioned resources. IDirect3DSurface9, IDirect3DBaseTexture9, IDirect3DvertexBuffer9 and IDirect3dIndexBuffer9 are child-interfaces derived from IDirect3Dresource9.

Creation method:-

This interface is not created as such. Instead, its child interfaces are created through which all the methods of this interface is accessed.

IDirect3DSurface9

This interface is derived from IDirect3Dresource9. A surface represents a display memory. A surface usually resides in the display memory of the display-card, although surfaces can exist in system memory. Applications use the methods of the IDirect3DSurface9 interface to query and prepare surfaces. The frontbuffer (also called the primary surface) that represents the computer-screen is a surface-object. Only frondbuffer is visible on the sceen. Other surfaces which are invisible are called offscreen surfaces. All backbuffers (offscreen surfaces that are waiting to be swapped to the frondbuffer) are surfaces.

A fronntbuffer is a target for rendering, ie the graphics is rendered onto this surface by the graphics-pipleine. Such surfaces are called a render target surface. DirectX9 permits rendering to a backbuffer also. Thus a backbuffer also can be a render target surface.

A depth-buffer and a stencil-buffer that store information to modify the display of each pixel on the screen, also are surfaces. Besides this there are surfaces that represent different layers of a texture.

Creation methods:-
IDirect3DDevice9:: CreateOffscreenPlainSurface Create an off-screen surface
IDirect3DDevice9::CreateRenderTarget Creates a render target surface
IDirect3DDevice9::CreateDepthStencilSurface Creates a depth-stencil surface

You can retrive surfaces associated with a device, a swap-chan or a texture by using the Get* methods of the corresponding interfaces viz IDirect3DDevice9, IDirect3DSwapChain9, IDirec3DTexture9 and IDirect3DCubeTexture9.

IDirect3DBaseTexture9

IDirect3DBaseTexture9 represents a texture. This interface is a base interface from which various child interfaces are derived. Each of the child-interface represents various type of textures viz ordinary texture, cube texture and volume texture.

Creation method:-

There are no creation method that creates IDirect3DBaseTexture9 objects as such. Instead its child interfaces are created.

Get method:-

IDirect3DDevice9::GetTexture

This method retrives an IDirect3DBaseTexture9 interface that represents a texture residing in one of the eight texture-stages of a device.

IDirect3DTexture9

IDirect3DTexture9 represents an ordinary texture which is not a cube-texture or a volume texture. This interface is derived from the IDirect3DBaseTexture9 interface

Creation method:-

IDirect3DDevice9::CreateTexture

IDirect3DCubeTexture9

IDirect3DCubeTexture9 represents a cube texture. This interface is derived from the IDirect3DBaseTexture9 interface

Creation method:-

IDirect3DDevice9::CreateCubeTexture

IDirect3DVolumeTexture9

IDirect3DVolumeTexture9 represents a volume texture. This interface is derived from the IDirect3DBaseTexture9 interface

Creation method:-

IDirect3DDevice9::CreateVolumeTexture

IDirect3DVertexBuffer9

IDirect3DVertexBuffer9 represents a vertex buffer. A vertex buffer is a Direct3D resource that can store an arry of vertices. A vertex is usually implemented as a structure, containing member variables such as x,y and z coordinates, texture coordinates, vertex normal, vertex color etc. Programmer can define the structure in any way he wanted. A vertex buffer can store this data, irrespective of the vertex format (which is defined by the vertex structure).

This interface is derived from the IDirect3DResource9 interface.

Creation method:-

IDirect3DDevice9::CreateVertexBuffer

IDirect3DIndexBuffer9

IDirect3DIndexBuffer9 represents an index buffer. Index buffers are memory resources used to hold indices. An array of vertices can be rendered using the index information stored in an index buffer.

This interface is derived from the IDirect3DResource9 interface.

Creation method:-

IDirect3DDevice9::CreateIndexBuffer

IDirect3DVolume9

IDirect3DVolume9 represents a volume into which a volume texture is applied. As there can be many levels of surfaces associated with an ordinary texture, there can be many levels of volumes associated with a volume texture.

Creation method:-

There are no creation method to create a volume.

Get method:-

IDirect3DVolumeTexture9::GetVolumeLevel

IDirect3DPixelShader9

IDirect3DPixelShader9 represents a pixel shader. A pixel shader is a small program or an algorithm (usually designated as a shader) that act and modify every pixel that is rendered on the screen. It is part of the programmable pipleine of DirectX Graphics as against the fixed function pipeline.

Creation method:-

IDirect3DDevice9::CreatePixelShader

IDirect3DVertexShader9

IDirect3DVertexShader9 represents a vertex shader. A vertex-shader is a small program or an algorithm (usually designated as a shader) that act and modify every vertex that is part of the geometry created for rendering. It is part of the programmable pipleine of DirectX Graphics as against the fixed function pipeline.

Creation method:-

IDirect3DDevice9::CreateVertexShader

IDirect3DVertexDeclaration9

IDirect3DVertexDeclarationr9 represents a vertex shader declaration. A vertex shader declaration is a set of information that enable the device to interpret a vertex-shader properly.

Creation method:-

IDirect3DDevice9::CreateVertexDeclaration

Direct3D Extension (D3DX) Interfaces

Direct3D extension interfaces are exntensions to the core Direct3D. These interfaces enable the programmer to deal with 3D graphics at a higher level. These interfaces are distributed as a utility library called D3DX.

ID3DXMatrixStack

The ID3DXMatrixStack interface represents the matrix stack. Matrix stack is a last in first out (LIFO) stack that stores transformation matrices. You can add (push) or remove (pop) matrices to or from the top of the stack. The matrix sitting on the top of the matrix stack is called the current matrix. You can perorm matrix arithematic operations involving the current matrix of the stack and any other matrix.

Creation method:-

D3DXCreateMatrixStack

ID3DXFont

The ID3DXFont interface provides a set of methods that simplify the process of drawing text based on a font using Direct3D. The text will be drawn on the 2D screen space.

Creation methods:-
D3DXCreateFont Takes a handle (HFONT) to a font.
D3DXCreateFontIndirect Takes the address of a LOGFONT-structure describing the attributes of the font-object to create

To create a mesh of 3D text in 3D world space, use the D3DXCreateText function. This function is not related to the ID3DFont interface.

ID3DXLine

The ID3DXLine implements line drawing using textured triangles The line will be drawn on the 2D screen space. However Direct3D allows it to be located in the 3D world space.

Creation method:-

D3DXCreateLine

ID3DXSprite

The ID3DXSprite interface provides a set of methods that simplify the process of drawing sprites using Direct3D. A sprite is a 2D-image, that moves over a backgroud image. Usually a sprite exists on the 2D screen space. However Direct3D allows it to be located in the 3D world space.

Creation method:-

D3DXCreateSprite

You have to pass the Direct3DevicePointer and the address of the sprite to be created as argument to this function.

ID3DXBaseMesh

The ID3DXBaseMesh is the base interface that represents a mesh object. A mesh is a 3D-geometric-object composed of more than one polygon. A mesh is an object made up of a set of polygonal faces. A mesh defines a set of vertices and a set of faces (the faces are defined in terms of the vertices and normals of the mesh). It can represent any real world 3D-object such as a chair, a table, a building, an animal or a human character.

Creation methods:-

ID3DXBaseMesh objects are not created as scuh. Instead, the child interfaces like ID3DXMesh and ID3DXPMesh are used for object creation.

ID3DXMesh

The ID3DXMesh interface inherits from ID3DXBaseMesh. ID3DXMesh represents an ordinary mesh.

Creation methods:-
D3DXCreateMesh Creates a mesh using a declarator array that describes the vertex format
D3DXCreateMeshFVF Creates a mesh using an FVF defenition, that describes the vertex format.

ID3DXPMesh

The ID3DPXMesh interface inherits from ID3DXBaseMesh. ID3DXPMesh represents a progressive mesh. A progressive mesh enables progressive refinement of the mesh object by reducing the number of faces or vertices constituting the mesh.

Creation methods:-

D3DXGeneratePMesh

This method takes an ordinary mesh object (D3DXMesh) and creates a progressive mesh.

ID3DXSPMesh

The ID3DXSPMesh interface represents a simplified progressive mesh. It is also called a simplification mesh. A simplification mesh is used to simplify a given mesh by reducing the number of faces constituting the mesh.
Creation method:-

D3DXCreateSPMesh

This method takes an ordinary mesh object (D3DXMesh) and creates a simplification mesh.

ID3DXPatchMesh

The ID3DXPatchMesh interface represents a patch mesh. A patch mesh is constructed from patches. A patch is a four-sided piece of geometry constructed from curves. The type of curve (Bezier, B-spline etc) used and the order of the curve (1-linear, 2-quadratic, 3-cubic and 5-quintic) can be varied so that the patch surface will fit almost any surface shape.

Creation method:-

D3DXCreatePatchMesh This method takes a Patch information structure to create a patch mesh.
D3DXCreateNPatchMesh This method takes an ordinary mesh object (D3DXMesh) and creates a patch mesh, containing many number of patches.

ID3DXBuffer

The ID3DXBuffer interface is used as a data buffer to store vertex data, adjacency data or material information during the loading of a mesh. They are also used when meshes are optimized using ID3DXPMesh or ID3DXSPMesh. They are general purpose buffers used to store arbitrary length data. (Hence they are also used to receive and store object code and error messages in methods that assemble vertex shaders and pixel shaders.)

Creation method:-

D3DXCreateBuffer

ID3DXAllocateHierarchy

The ID3DXAllocateHierarchy represents a frame heirarchy builder. It can build (and also destroy) a heirarchy of frames to which meshes are added. Frames act as containers for holding meshes. Transformations are applied to a frame to animate a mesh within. Frames containing meshes are subjected to various scale, rotate and translate (SRT) transformations to animate an entire character model (composed of those meshes). For example, applying a translation to the top-frame will move the entire model in 3D world space.

Methods of ID3DXAllocateHierarchy interface are called during loading and destroying frame hierarchies, to build or destroy frame heirarchies.

Technically, it is not the frame but a mesh-container that holds a mesh. Mesh container forms a part of the frame. Apart from a mesh container, the freme will contain a transformation matrix and pointers to other frames (like a child frame). Mesh container will have a pointer to a mesh, a progressive mesh or a patch mesh. It will also have pointers to materials, effects, ajacency info, skin info etc and a pointer to the next mesh container.

Creation method:-

There are no creation method to create objects of this interface. Programmers should derive a class from this interface and implement its methods in the desired fashion. Then an object of this derived class has to be instanciated and passed to D3DXLoadMeshHierarchyFromX or D3DXLoadMeshHierarchyFromXInMemory functions. During the load, the methods of the ID3DXAllocateHierarchy-derived class are invoked to build the frame heirarchy by creating frames and mesh containers. To destroy the frame heirarchy, the same object is passed to the function named D3DXFrameDestroy. Then the appropriate frame desctuction and mesh-container destruction methods of the derived class are invoked to destroy all the frames and mesh-containers (including the meshes within).

ID3DXInterpolator

The ID3DXInterpolator represents an interpolator. Interpolators are the basic building blocks for animation. Interpolator defines the scalling, rotation, and translation (SRT) values at unique points in time. Scale and translation values are stored as vectors, rotations are stored as quaternions.

ID3DXInterpolator is an abstract interface. An application programmer can derive classes from this interface for making their own custom SRT interpolators. The interface named ID3DXKeyFrameInterpolator inherits from this interface.

Creation method:-

There are no creation method to create objects of this interface.

ID3DXKeyFrameInterpolator

This interface is derived from the ID3DXInterpolator interface. It represents a key frame interpolator. A key frame interpolator contains a set of key frames. A key frame is an SRT based frame which is scaled, rotated and translated at unique points of time called key times , or simply keys. A key frame is composed of a key time, two key vectors representing a key scaling and a key translation and a key quartornion representing a key rotation. A key vector is a vector at a given time and a key quarternion is a quarternion at a given time.

Creation method:-

D3DXCreateKeyFrameInterpolator

This method takes arrays of scale keys, rotations keys and translation keys to create a key frame interpolator.

ID3DXAnimationSet

The ID3DXAnimationSet interface represents an animation set. An animation set consists of an array of interpolators, one for each node participating in an animation. Nodes in the animation forms a frame heirarchy (a tree of nodes). Each node uses an interpolator in the animation set, to represent the associated SRT transformation matrix. The. A node is also associated with one or more mesh objects. For example a walk cycle can be implemented using an animation set.

Creation method:-

D3DXCreateAnimationSet

ID3DXAnimationController

The ID3DXAnimationController interface represents an animation controller. It is derived from an older interface called ID3DXAnimationMixer. An animation controller controls an animation mixer. The controller adds methods to modify blending parameters over time to enable smooth transitions. Animation controller have many tracks. Tracks are parallel channels of animation. An animation set can be put in a specific track of the animation controller.

Creation method:-

D3DXCreateAnimationController

ID3DXSkinInfo

The ID3DXSkinInfo interface represents a skin in a bone based animation. A skin, in the context of bone based character animation, is a set of vertices (forming a part or whole of a mesh) that are influenced by one or more bones. A bone is an invisible (non-renderable) moving element of a character model, that moves with respect to a pivote, resulting in the movement and/or deformation of the skin under its influence. Sometimes a skin is also called a skin mesh. The skin mesh will contain a set of bones. Bones are arranged in one or more bone combinations in a bone combination table. The interface is used to manipulate bone influence over skins. It is also used to manipualte bone matrices, which are transformations applied to bones.

This interface is no longer strictly tied to ID3DXMesh and can be used to skin any set of vertex data.

Creation methods:-
D3DXCreateSkinInfo Create skin from a declarator array
D3DXCreateSkinInfoFVF Create skin from an FVF defenition
D3DXCreateSkinInfoFromBlendedMesh Creates a skin from a mesh

ID3DXLoadUserData

This interface is implemented by the application programmer to load any additional user data embedded in .x files. An instance of this interface is passed to the function D3DXLoadMeshHierarchyFromX, and D3DX calls the appropriate method on this interface every time the appropriate data is encountered. For example, for each frame object in the .x file, ID3DXLoadUserData::LoadFrameChildData is called.

Creation method:-

No creation method. User has to create this interface and instanciate objects.

ID3DXSaveUserData

This interface is implemented by the application programmer to save any additional user data embedded in .x files. An instance of this interface is passed to the function D3DXSaveMeshHierarchyFromX, and D3DX calls the appropriate method on this interface every time the appropriate data is encountered. For example, for each frame object in the .x file, ID3DXSaveUserData::AddFrameChildData is called.

Creation method:-

No creation method. User has to create this interface and instanciate objects.

ID3DXRenderToEnvMap

The ID3DXRenderToEnvMap interface is used to generalize the process of rendering to environment maps. An environment map is used to texture-map scene geometry to provide a more sophisticated scene without using complex geometry. This interface supports creating surfaces for the following kinds of geometry: cube, half sphere or hemispheric, parabolic, or sphere.

Creation method:-

D3DXCreateRenderToEnvMap

ID3DXRenderToSurface

The ID3DXRenderToSurface interface is used to generalize the process of rendering to surfaces. Surfaces can be used as render-targets. Rendering to offscreen surfaces and textures are supported in DirectX9. If the surface is not a render target, a compatible render target is used, and the result is copied to the surface.

Creation method:-

D3DXCreateRenderToSurface

ID3DXConstantTable

The ID3DXConstantTable interface is used to access a constant table, which contains the variables that are used by high-level language shaders and effects. A structure named D3DXSHADER_CONSTANTTABLE also does the same function of managing a constant table.

A shader is a small program that act on every vertex (vertex shader) or on every pixel (pixel shader) as the Direct3D execution pass through the programmable geometric pipeline and the programmable rendering pipleline respecitvely.

Effects are a higher level abstraction that take advantage of vertex and pixel shaders to encapsulate rendering effects. Effects can be written with the high-level language or with the shader assembly language.

Creation method:-

No creation method. A constant table is generated by D3DXCompileShader and embedded in the body of the shader. You can get a constant table embedded inside shader by using a Get method.

Get method:-

D3DXGetShaderConstantTable

ID3DXFragmentLinker

The ID3DXFragmentLinker interface is used to link shader fragments at runtime. A fragment is an OpenGL terminology, adopted by DirectX, used to denot a pixel and associated data, that influences how it is going to be rendered on the screen. The linker links one or more shader fragments togather.

Creation method:-

D3DXCreateFragmentLinker

D3DX Interfaces for rendering Effects

Effects are a higher level abstraction that take advantage of vertex and pixel shaders to encapsulate rendering effects. Effects can be written with the high-level language or with the shader assembly language. Effects are implemented with the following interfaces.

ID3DXBaseEffect

The ID3DXBaseEffect interface is a base interface for implementing effects. It has methods for setting and getting effect parameters. The effect parameters can be constants, functions, shadars or techniques.

Creation method:-

ID3DXBaseEffect is not created as such. Its childs are created instead.

ID3DXEffect

The ID3DXEffect interface inherits from ID3DXBaseEffect. An effect object can contain multiple techniques to render the same effect. It has methods for setting and getting effect parameters.

Creation method:-

D3DXCreateEffect Create an effect from an ASCII or binary effect description data
D3DXCreateEffectFromFile Create an effect from an ASCII or binary effect description file
D3DXCreateEffectFromResource Create an effect from an ASCII or binary effect resource

ID3DXEffectCompiler

The ID3DXEffectCompiler interface inherits from the ID3DXBaseEffect interface. The ID3DXEffectCompiler interface represents an effect compliler. It compiles an effect from a function or from a vertex shader.
Creation method:-

D3DXCreateCompilerEffect Create an effect-compiler from an ASCII or binary effect description data
D3DXCreateEffectCompilerFromFile Create an effect-compiler from an ASCII or binary effect description file
D3DXCreateEffectCompilerFromResource Create an effect-compiler from an ASCII or binary effect resource

ID3DXEffectPool

The ID3DXEffectPool interface repesents a shared pool of parameters that are shared between many effects. For effects sharing a pool, the parameters with the same name share values. Thus they becomes shared parameters.

Creation method:-

D3DXCreateEffectPool

ID3DXInclude

The ID3DXInclude interface is used to provide callbacks for #include directives, encountered in a shader defenition or an effect defenition. This interface has to be implemented by the application programmer. Its objects are to be passed on to functions that compile or assemble shaders, or gather shader fragments as well as those that create effects and effect compilers.

Creation method:-

No creation method. Programmer has to implement this interface and instanciate its objects.

D3DX Interfaces for X Files

There are many D3DX interfaces that are used to interact with X files. The X file format is a file-format used for storing 3D graphics data. It is a proprietary file format of Microsoft DirectX, distributed freely to the application programmers. X files have an extension *.x.

X files are part of DirectX from DirectX2 onwards. Binary version started from DirectX3 onwards. Interfaces for X files originated from DirectX6 onwards.

X files can store meshes, textures, animations, and user-definable objects. Support for animation sets enables you to store predefined paths for playback in real time. Instancing and hierarchies are also supported. Instancing enables multiple references to an object, such as a mesh, while storing its data only once per file. Hierarchies are used to express relationships between data records.

X files support use of graphical templates. A template helps to define higher-level primitives based on low-level data primitives.

IDirectXFile

The IDirectXFile interface represents an X file. It has methods to register templates contained in the x file and to create other interfaces that deal with loading and saving of data-objects from and to an x file.

Creation method:-

DirectXFileCreate

IDirectXFileEnumObject

The IDirectXFileEnumObject interface represents an enumerator. It is used to assist loading of data-objects from an x file by enumerating the data-objects within an x file. The data objects can be identified by its name or by its GUID (Globally Unique IDentifier).

Data objects in the x-files are stored in heirarchies. The enumerator is used to cycle through the parent object to each of its child objects and to the next parent object.

Creation method:-

IDirectXFile::CreateEnumObject

IDirectXFileSaveObject

The IDirectXFileSaveObject interface represents an archiver that saves data objects. This interface is not just an archiver. It also creates the data objects that are to be saved. The data objects are saved in a parent to child heirarchy. It also saves graphical templates, if there are any.

Creation method:-

IDirectXFile::CreateSaveObject

IDirectXFileObject

The IDirectXFileObject interface represents a file object , the entities that exists inside an X file. The file objects have a name and a GUID (Globally Unique IDentifier) for its identification. This interface is a base interface. Other interfaces, which represents various file objects like data objects are dereived from this interface.

Creation method:-

No creation method. Its child interfaces are created, instead.

IDirectXFileData

The IDirectXFileObject interface represents a data object. Data objects are created and saved to an x file by the IDirectXFileSaveObject. They are saved based on a heirarchy. A graphical template dictates the heirarchy. A template may permit optional objects to be saved as part of a data object. This optional objects are saved as childs of the data object. The optional object can be just another data object or a data reference object or a binary object. The optional members are not a must, but an object might miss important information without them. Apart from a name and a GUID, a data object have its data consisting of the above mentioned child data objects, data reference objects and binary data objects.

This interface is derived from the IDirectXFileObject interface.

Creation method:-

IDirectXFileSaveObject::CreateDataObject

IDirectXFileDataReference

The IDirectXFileDataReference interface represents a data reference object. A data reference object points to an existing data object in the x file. Thus it reduces the duplication of a data object. This is called instancing. This enables you to use the same object multiple times without repeating it in the file. Apart from a name and a GUID, a data reference object have a reference to its associacted data object.

This interface is derived from the IDirectXFileObject interface.

Creation method:-

IDirectXFileData::AddDataReference

This method creates and adds a data reference object as a child of the data object. Here the data object is an instance of the IDirectXFileData, which calls the AddDataReference method.

IDirectXFileBinary

The IDirectXFileBinary interface represents a binary data object. A binary data object can appear as an optional data associated with a data object, in an x file. Apart from a name and a GUID, a binary data object have a MIME-type (Multipurpose Internet Mail Extensions – type) associated with it. The size of the binary data also is important.

This interface is derived from the IDirectXFileObject interface.

Creation method:-

IDirectXFileData::AddBinaryObject

This method creates and adds a binary object as a child of the data object. Here the data object is an instance of the IDirectXFileData, which calls the AddBinaryObject method.

Share:- Facebook

Unless otherwise stated, the content of this page is licensed under Creative Commons Attribution-ShareAlike 3.0 License