Ab3d.DirectX Namespace

AnaglyphVirtualRealityProvider is a VirtualRealityProvider that can render stereoscopic anaglyph images that can be viewed with colored glasses - for example red / cyan glasses.

AnaglyphColorTransformation class defines the matrices that are used to multiply colors for left and right eye. It also defines the gamma value that is used to apply gamma correction before the matrix multiplication.

AssemblyShaderBytecodeProvider class provides access to compiled shaders stored as embedded resources in an assembly. The class can be registered by EffectsManager with calling its RegisterShaderResource(String, Byte) or RegisterShaderResourceStatic(ShaderBytecodeProvider) methods. This way the EffectsManager will be able to get shader resources (bytecode) from the resources provided by this class.

BackBufferReadyEventArgs is an event handler that is used for the BackBufferReady event. BackBufferReady event is fired when the scene is rendered to back buffer that is ready to be mapped and copy from graphics card to system memory.

BeginVirtualRealityRenderingStep is a rendering step that prepares the rendering context for rendering the current eye. It is usually added before DXScene.DefaultPrepareRenderTargetsRenderingStep. When the virtual reality provider defined in current VirtualRealityContext is enabled, this step calls the UpdateRenderingContext(RenderingContext, Boolean) method. If virtual reality provider is not enabled this step does nothing.

Bounds defines a BoundingBox and also provides IsEmpty property.

CameraDistanceSortedRenderingQueue is rendering queue where the objects inside the queue are sorted by their distance from the camera. This is uses for transparent object that need to be rendered so that the objects that are more far away from the camera are rendered first. See remarks for more info.

ChangeBackBufferRenderingStep can be used to change the current BackBuffer, RenderTargetView, DepthStencilView or Viewport. To set the new back buffer values use the SetNewBackBuffer(Texture2D, Texture2DDescription, RenderTargetView, DepthStencilView, Int32) method. To set the new Viewport value set the NewViewport property. When this rendering step is executed, the OutputMerger targets are chenged (if SetNewBackBuffer was called) and properties related to current back buffer in RenderingContext are changed. If NewViewport is set then also the Viewport in the RenderingContext and in Rasterizer are changed.

ClonedRenderablePrimitive is rendered with the same resources as originalRenderablePrimitiveBase but with different Material.

CommonStates class defines that standard BlendStates, DepthStencilStates, RasterizerState and SamplerStates.

CommonUtils class defines a few static utility methods.

CompleteRendering is the last rendering step. It Presents SwapChain (if used) or prepares the output buffer that can be send to WPF or CPU memory.

ContextStatesManager is a helper class that is used to set the current BlendStates, DepthStencilStates, RasterizerState and SamplerStates. Before each state change it checks if the state already has the new state value and in this case prevents the actual DirectX state change call to improve performance. ContextStatesManager also collect state changes statistics.

CustomActionRenderingStep can be used to execute custom method as part of rendering process.

CustomRenderableNode is a SceneNode that can be used to fully customize the rendering process. This can be done with creating the CustomRenderableNode object with a Func that create a custom RenderablePrimitiveBase object that is then added to the rendering queue. The CustomRenderableNode object can be also created with a custom Action that is called when this SceneNode needs to be rendered (this creates CustomRenderablePrimitive object and adds it to the rendering queue).

CustomRenderablePrimitive is a class that represent the raw renderable object that can be added to rendering queue and is created with providing custom Action that is called when this object needs to be rendered. CustomRenderablePrimitive is use by the CustomRenderableNode object.

CustomRenderingContext is the same as it base RenderingContext class, except that this class has two additional public methods: SetPerFrameData(Int32, DXSceneChangeNotifications) and SetFinalBackBuffer(Texture2D, Texture2DDescription, RenderTargetView).

DeviceCapabilities class describes the capabilities of a DirectX device.

DeviceCreationException occurs when the DirectX device cannot be created.

DictionaryShaderBytecodeProvider class provides access to shaders stored in a simple dictionary with shader name as key and its bytecode (byte array of compiled shader) as values. The class can be registered by EffectsManager with calling its RegisterShaderResource(String, Byte) or RegisterShaderResourceStatic(ShaderBytecodeProvider) methods. This way the EffectsManager will be able to get shader resources (bytecode) from the resources provided by this class.

DirectoryShaderBytecodeProvider class provides access to shaders stored as files in the specified directory on disk. Resources registered by this DirectoryShaderBytecodeProvider are available by file name with extension but without directory path. The class can be registered by EffectsManager with calling its RegisterShaderResource(String, Byte) or RegisterShaderResourceStatic(ShaderBytecodeProvider) methods. This way the EffectsManager will be able to get shader resources (bytecode) from the resources provided by this class.

DisposableDXResource class is a base class for DXEngine resources that can be disposed.

DisposeHelper class provides DisposeAndNullify methods that can help dispose and nullify a disposable object.

DisposeList contains a list of IDisposable objects that are automatically disposed when DisposeList is disposed. The order of disposal is reversed from the order in which the objects were added to the list (first object is disposed last).

DXAttributeCollection contains one or more DXEngine's attributes (DXAttribute) that can be attached to WPF object.

DXAttributeException is an exception that signals that there is a problem with using a DXAttribute.

DXDevice is a DXEngine's wrapper for the DirectX device.

DXDeviceConfiguration is used to define properties that are used for creation of DirectX Device and SwapChain.

DXDeviceResource class is a base class for all resources that are initialized by DXDevice.

DXDiagnostics class contains static properties that define which diagnostics features of the DXEngine will be turned on.

DXEngineException exception thrown is thrown when an error occured when calling DirectX COM methods. The exception class contains details information about the error in the Descriptor property.

DXEngineException is base class for all exception thrown in Ab3d.DXEngine.

DXHitTestContext provides a context information for hit testing.

DXHitTestOptions class specifies hit testing parameters that are used with DXScene's hit testing.

DXHitTestResult is a base class for hit test results in DXEngine.

DXRayHitTestResult class provides result of a ray hit test.

DXRayHitTestWpfModel3DResult class provides result of a ray hit test with a WPF's GeometryModel3D.

DXRayInstancedHitTestResult class provides result of a ray hit test that is executed on instanced object.

DXResourceBase class is the base class for any DXEngine's resource

DXResourcesTracker collects classes that implement IDXResource and can report all colleced classes. Objects are collected with WeakReference.

DXScene is the main object in the DXEngine rendering engine. It defines the 3D scene in a hierarchical tree hat starts with the RootNode. It updates the SceneNodes and renders them.

DXSceneInitializationException is thrown by DXView when no GraphicsProfile can be initialized.

DXSceneResource class is a base class for all resources that are initialized by DXScene.

DXWireframeHelper class contains methods that can be used to annotate ModelVisual3D or Model3D with special property that is used by DXEngine to render the objects with the specified wireframe settings.

Effect is a base class for all effects that can render a mesh (vertex and index buffer) with the material that defines the properties that defined the effect.

EffectRegisteredEventArgs class defines the Effect that was registered by EffectsManager and is used in the EffectRegistered event in EffectsManager.

EffectsManager class help use the Effect classes. It provides loading, caching and reusing the effects and shaders. All access to effects and shaders is thread safe.

Extensions class provides extension methods to convert WPF types to SharpDX types and vice versa.

FeatureLevelsNotSupportedException occurs when the DirectX 11 device cannot be created because the the adapter (graphics card) does not support the required feature levels.

FileShaderBytecodeProvider class provides access to shaders stored as files in file system. The class can be registered by EffectsManager and can be used to generate shaders from the files registered by this class. Before the files can be accessed, the files must be registered by AddResourceFile(String, String), AddResourceFile(String) or AddResourceFiles(IEnumerableString).

GeometryMesh class is used to create Index and Vertex buffers from list of positions, normals, textureCoordinates and triangleIndices.

GeometryMeshGenerator contains static methods that can create Mesh objects.

GraphicsProfile specifies the settings that are used to initialize DXDevice with DirectX 11 device and DXSceneView.

GraphicsProfileRejectedEventArgs is used for GraphicsProfileRejected event and specifes the reasons why the GraphicsProfile was rejected.

HandleCreatedEventArgs is used for the HandleCreated event.

HitTester is a class that can be used do a hit testing on a mesh data with vertex and index buffer. The static methods in this class take a Ray, various types of vertex buffers, index buffer and a few flags and returns a hit test result.

InitializeRendering is the first rendering step. It sets up the RenderingContext with current RenderTargets, resets statistics, etc.

InputElementFactory is a helper class that can help with creation of InputElement arrays.

InstancedMeshNode represents a SceneNode that can render multiple instances of DXEngine's Mesh.

InvalidDxEngineResourceException exception is thrown when a Texture2D, Buffer, View or some other resource is not in the expected format or was not created with the expected flags.

Material is a base abstract class from which all DXEngine's material must be derived from.

MaterialSortedRenderingQueue is rendering queue where the objects inside the queue are sorted so that objects with the same material are rendered one after another - this minimizes the state changes and increases the performance.

MeshBase is a base class that defines the data about one 3D model that are stored in the DirectX structures that are used to draw the model.

MeshObjectNode is an ObjectNode that can render an object that is defined by object derived from MeshBase class.

MeshOctTree class organizes the triangles in 3D space into multiple levels of MeshOctTreeNode objects so that the search of a triangle or check for triangle ray intersection is very efficient. Each MeshOctTreeNode divide its space into 8 child MeshOctTreeNode.

MeshOctTreeNode class represents one node in a MeshOctTree data structure. Each node represents its part of the 3D space that is defined by the BoundingBox. The node contains triangles that can be fully fitted into node's BoundingBox (and do not find in any of the child nodes). Each node (except the nodes on the MaxNodeLevel) can have up to 8 child MeshOctTreeNodes (number can be lower in case some nodes does not contain any triangles).

MeshTrianglesSorter can be used to sort triangle indices by camera distance. Sorting is done by calling SortByCameraDistance(Vector3, Boolean) method. After that call the SortedIndicesArray array is set to the sorted triangle indices array. MeshTrianglesSorter can be created by vertex buffer defined by PositionNormalTexture, PositionNormal or Vector3.

ObjectNode is a SceneNode that is used by scene nodes that can produce renderable objects (objects derived from RenderablePrimitiveBase class). Renderable objects are defined in the overridden CollectRenderableObjects method.

OctTree class is obsolete and can be removed in a future version. Please use MeshOctTree instead.

OctTreeNode class is obsolete and can be removed in a future version. Please use MeshOctTreeNode instead.

OnePixelTexture class creates a ShaderResourceView with a 1x1 texture (one pixel) with the specified color. The class also provides easy updating of the color. When you do not need to update the color of the texture, then you can also use a static CreateOnePixelTexture(Device, Color4, Format) method. User needs to dispose the created OnePixelTexture to prevent resources leaking.

OptimizedPointMesh class is used to show point cloud and can dynamically reduce the number of rendered positions to improver rendering performance. It creates one Vertex buffer and multiple Index buffers that are used to provide different level of optimized sub-sets of all the vertices.

PlanarShadowRenderingProvider provides support for rendering shadows on a 3D plane surface.

PreparePostProcessingRenderingStep prepares Shader resources and Render targets for RenderPostProcessingRenderingStep.

PrepareRenderTargets is a rendering step that is usually called before objects are rendered. This step also calls DXScene's AfterFrameInitialized event.

PrepareVarianceShadowMappingRenderingStep rendering step prepares other rendering steps for variance shadow rendering.

RenderableInstancedObjectsPrimitive class is a RenderablePrimitive that can be used to render multiple instances of geometry based DXScene's ObjectNode and where the instances are defined by VertexBufferBinding.

RenderableMeshPrimitive class is a RenderablePrimitive that can be used to render geometry based on the MeshBase and SubMesh.

RenderableObjectNodePrimitive class is a RenderablePrimitive that can be used to render 3D objects created from DXScene's ObjectNode objects.

RenderablePrimitive is a base class that is derived from RenderablePrimitiveBase and implements rendering geometry based on the resources defined by the RenderablePrimitive constructor.

RenderablePrimitiveBase is a base abstract class that represents a low level geometry object that is prepared to be rendered with DirectX. It contains all required DirectX buffers and required data to prepare the rendering states. RenderablePrimitiveBase objects are rendered in the RenderObjectsRenderingStep rendering step and can be added to any RenderingQueue.

RenderablePrimitiveRenderingQueue is derived from RenderingQueue. The difference from RenderingQueue is that RenderablePrimitiveRenderingQueue can accept (with Add method) only objects derived from RenderablePrimitive. This is useful for rendering queues that need to be sorted for example MaterialSortedRenderingQueue and CameraDistanceSortedRenderingQueue.

RenderingContext defines the context of the current rendering pass.

RenderingEventArgs contains the RenderingContext and is used for AfterFrameInitialized and AfterObjectsRendered events on DXScene.

RenderingQueue is a queue that is used to store renderable objects that have similar properties and are rendered one after another. Objects inside the queue can be reordered or sorted to improve performance or make sure that the rendered results are correct (for example for transparency sorting).

RenderingQueueSortingCompletedEventArgs is used for the SortingCompleted event. The event is called after the RenderingQueue is sorted. It allows the code in the event handler to change the order in which objects are rendered by changing the values in the SortedIndexes array (note: use RenderablePrimitives.Count to get number of items because SortedIndexes.Length may be to big).

RenderingStatistics collects various rendering statistics for one rendered frame.

RenderingStepBase is an abstract base class for other rendering step classes. It does not define any rendering logic but provides handling BeforeRunningStep and AfterRunningStep event handling.

RenderingStepsFlowControl is a class that defines a RenderingStep that can control the flow of rendering steps execution with dynamically changing the rendering step that will be exected next.

RenderingStepsGroup is a rendering step that can group multiple rendering steps inside its Children list of rendering steps.

RenderingStepsList is a collection of rendering steps. It provides additional methods to add rendering steps before and after specific rendering step.

RenderingStepsLoop can be used to create loops in RenderingsSteps list. The loop is created with specifiying the beginLoopRenderingStep that is the first RenderingStep in the loop. The beginLoopRenderingStep is executed when the loopPredicate returns true. When the loopPredicate returns false, the execution will continue on the rendering step after this RenderingStepsLoop.

RenderObjects renders the objects

RenderPostProcessing renders the post processing effects.

RenderSpritesRenderingStep rendering step renders the sprites that are defined in the SpriteBatches.

RenderTextureRenderingStep is a rendering step that can render the specified SourceTexture (as ShaderResourceView) to a part of the screen specified with the TargetViewport. Rendering of the colors can be adjusted with setting the Offsets and Factors. It is also possible to specify a CustomBlendState and CustomDepthStencilState.

ResolveBackBufferRenderingStep resolves the multi-sampled back buffer (MSAA) and down-samples the super-samples back buffer (SSAA) into a back buffer without multi-sampling. The source buffer is get from the renderingContext.CurrentBackBuffer. The destination buffer can be customized by calling SetCustomDestinationBuffer(Texture2D, Texture2DDescription, RenderTargetView). When this method is not called, then the renderingContext.FinalBackBuffer is used for destination buffer.

ResolveStereoscopicImagesRenderingStep is a base class for presenting stereoscopic images for left and right eye to the final RenderTarget. The actual implementation of how the two images are presented must be defined in the derived class. This class provides properties that define ShaderResourceView for left and right eye.

ResourceCreationException exception is thrown when DXEngine's resources cannot be found or are not defined correctly.

SceneNode class represents a basic component of a 3D scene that is composed of various SceneNodes organized in a hierarchical structure.

ScreenSpaceLineMesh class prepares the low level DirectX objects (Index and Vertex buffers) for rendering screen-space 3D lines.

ScreenSpaceLineNode class is an ObjectNode that represent one or more 3D lines. The lines are generated in a geometry shader that reads line positions and generates triangles in such a way that the triangles face the camera and define the lines with specified thickness in screen coordinates. Line thickness, color and other properties are defined by the LineMaterial.

ShaderBytecodeProvider is an abstract class that is a base class for all classes that represent the source of shader byte code. The EffectsManager uses the GetShaderBytecode(String) to get the requested shader resource by its name.

ShadowLightData class defines data that are required for shadow mapping and are generated from one shadow light.

ShadowRenderingProviderBase is an abstract class that is a base class for all shadow rendering providers that change DXEngine rendering steps with adding shadow rendering.

SharedDXDeviceResource class is a base class for DXEngine's resources that are initialized by DXDevice and can be shared by many difference objects.

SharedDXResource class is a base class for DXEngine's resources that can be shared by many difference objects.

SharedDXResourceWrapper class is a generic wrapper class that can wrap any IDisposable object and adds reference counting to it.

SharedDXSceneResource class is a base class for DXEngine's resources that are initialized by DXScene and can be shared by many difference objects.

SimpleMesh class is used to create Index and Vertex buffers from a list of structs which type is defined by the type T. For example the following struct SimpleMesh<PositionTexture> is used to define a mesh from a List of PositionTexture structs.

SimpleResolveStereoscopicImagesRenderingStep is a RenderingStep that is using a pixel shader for presenting stereoscopic images for left and right eye to the final RenderTarget. This class provide basic logic with preparing the quad mesh and vertex shader. The user of the class must provide an Action that takes RenderingContext as parameter and binds a pixel shader and sets its constant buffers (LeftEyeShaderResourceView and RightEyeShaderResourceView are already bind to slots 0 and 1 by this SimpleResolveStereoscopicImagesRenderingStep).

SimpleShaderBytecodeProvider class provides access to one shader bytecode with a specified resource name. The class can be registered by EffectsManager with calling its RegisterShaderResource(String, Byte) or RegisterShaderResourceStatic(ShaderBytecodeProvider) methods. This way the EffectsManager will be able to get shader resources (bytecode) from the resources provided by this class.

RenderablePrimitiveRenderingQueue is derived from RenderingQueue. The difference from RenderingQueue is that RenderablePrimitiveRenderingQueue can accept (with Add method) only objects derived from RenderablePrimitive. This is useful for rendering queues that need to be sorted for example MaterialSortedRenderingQueue and CameraDistanceSortedRenderingQueue.

SplitScreenVirtualRealityProvider is a VirtualRealityProvider that can render stereoscopic images where image for the left eye is rendered in one half of the screen and image for the right is rendered in the other half of the screen. This type of 3D rendering can be seen by the 3D TV displays. The SplitScreenVirtualRealityProvider supports SideBySide (vertical) and TopAndBottom (horizontal) split screen.

SpriteBatch class defines a collection of sprites (textures) that can be very quickly rendered to the 3D scene defined by DXScene object.

StereoscopicVirtualRealityProvider is an abstract class and provides common logic to render stereoscopic images.

SubMesh is part of the MeshBase that uses the same vertex and index buffers as the MeshBase but use its own Material, StartIndexLocation and IndexCount.

SuperShadowShaderEffect is an effect that can use SuperShader and configure it to render the scene with using the shadow mapping buffer that was rendered before.

TextureCache class provides texture cashing for DXEngine.

TextureInfo defines some properties of the texture.

TextureLoader static class contains a method that can load image file into ShaderResourceView. In case the image file is png, jpg, tiff, gif, bmp or ico then WIC image decoder is used. In case the image file is dds (DirectDraw Surface file format that is optimized for DirectX graphics), the internal DDS file loader is used.

Transformation defines the Matrix that is used to transform the SceneNode. Transformation is optimized for cases where the Matrix is identity (no transformation).

UpdateStatusEventArgs is used in the AfterUpdated event and defines the DXScene's dirty flags and a Boolena that specifes if the new frame needs to be rendered (this value can be changed by the event subscriber).

VarianceDepthBlurPostProcess is a post process that applies blur to depth data created with variance depth mapping.

VarianceShadowDepthEffect renders the objects with writing the object's depth and depth squared into the render target.

VarianceShadowRenderingProvider provides support for rendering shadows with using Variance shadow rendering technique. Currently only one SpotLight or one DirectionalLight shadow casting light are supported.

VirtualRealityContext provides base class for describing the context used for rendering a virtual reality scene. During rendering of the scene, the VirtualRealityContext can be read from the VirtualRealityContext property. The instace of VirtualRealityContext is created in the VirtualRealityProviderBase.CreateVirtualRealityContext method.

VirtualRealityProviderBase is a base abstract class for all classes that provide virtual reality support to DXEngine.

DXAttribute is a single DXEngine attribute that can be attached to a WPF object. It consists of a attribute type (as DXAttributeType) and its value (as object). The attribute can be attached to a WPF 3D object by using an extension methods (for example SetDXAttribute(Geometry3D, DXAttributeType, Object)).

InstanceData contains World and Color data that describe the world transformation and color of one geometry instance. After each change of InstancesData user must call Update method in InstancedGeometryVisual3D.

PositionNormal is a struct used for vertex buffer that defines Position and Normal

PositionNormalTexture is a struct used for vertex buffer that defines Position, Normal and Color (as Color3).

PositionNormalTexture is a struct used for vertex buffer that defines Position, Normal and TextureCoordinate

PositionTexture is a struct used for vertex buffer that defines Position, TextureCoordinate

PositionTextureColor is struct used for vertex buffer that defines Position, TextureCoordinate and Color

Enumerator for enumerating RenderingStepBase

ICamera is base interface that defines a 3D camera in DXEngine

IDisposableDXResource interface defines the IsDisposed property.

IDXDeviceResource interface defines properties and methods that are used by resources that are initialized by DXDevice.

IDXResource interface defines base properties for any DXEngine's resource

IDXSceneResource interface defines properties and methods that are used by resources that are initialized by DXScene.

IDynamicVertexBufferCreator interface defines CreateDynamicVertexBuffer property and is used on meshes that can create a dynamic vertex buffer.

ILightNode interface is used by SceneNodes that contain a light.

IMeshNode interface is implemented by SceneNodes that defined GetMesh method.

IMultiPassEffect interface provides methods that are used for effect with multiple rendering passes.

IOctTreeMesh interface defines OctTree property and CreateOctTree method and is used by meshes that can use OctTrees.

IRayHitTestedObject interface can be implemented by a objects that supports hit testing.

IShadowCastingNode interface is implemented by a SceneNode that can cast shadow and implements the IsCastingShadow property.

IShadowReceivingNode interface is implemented by a SceneNode that can receive shadow and implements the IsReceivingShadow property.

ISharedDXResource interface defines properties that are used for reference counted resources that can be shared by many difference objects.

ISortedRenderingQueue interface defines methods that are used by RenderingQueue that support sorting of its items.

ITriangularMesh interface can be implemented by meshes that are defined from triangles and implement TrianglesCount property and GetTrianglePositions(Int32, Vector3, Vector3, Vector3) method.

BackBufferReadyEventHandler is used to describe the BackBufferReady event handler

Delegate that defined the CustomAction used by CustomActionRenderingStep.

EffectRegisteredEventHandler is an event handler with EffectRegisteredEventArgs as an argument and is used for the EffectRegistered event in EffectsManager.

HandleCreatedEventHandler is a delegate for the HandleCreatedEventArgs.

RenderingEventHandler is an event handler with RenderingEventArgs as event arguments

RenderingQueueSortingCompletedEventHandler is an event handler with SortingCompleted event.

UpdateStatusEventHandler is an event handler with UpdateStatusEventArgs as event arguments

ResetType enum contain values that can be used to reset only some of the current values in ContextStatesManager.

DXAttributeType enum defines possible types of DXAttributes that can be used to annotate WPF objects with DXEngine's properties.

LogLevels define log levels that are used to specify which DXEngine messages are written to Console / Output window.

Specifies the return result of a hit test filter callback method.

ChangeNotifications enum defines flags that describe what changes have occur in the DXScene from last time the scene was rendered.

Represents left or right eye.

DriverTypes enum defined the driver types that can be used by DXSceneView

GraphicsProfileRejectedReason defines reasons that describe why the GraphicsProfile is rejected.

InputLayoutType defines the possible components of InputLayout. Note that it is possible to define data for first and second input slot.

RenderablePrimitiveRenderingFlags define flags that can be used by the RenderingFlags field.

TextureChannelsCount enum defines how many channels (colors) will be rendered with the RenderTextureRenderingStep.

SceneNodeDirtyFlags enum defines the flags that are used to mark which part of the SceneNode was changed (is dirty).

ShaderQuality enum specifies possible values for shader quality that define what kind of shaders should be used to render the scene.

RenderingQueueSorterType defines types of sorting that can be used by a RenderingQueue

SplitScreenType defines the possible types of split screen.

SupersamplingResolveFilterType enum defines possible filtering types that are used to down-sample a super-sampled texture.

TextureFilteringTypes enum defines the common Texture filtering types.