Tesla Graphics Engine Documentation (January 2012)
Tesla.Graphics Namespace
TeslaTesla.Graphics
 
Declaration Syntax
C#
namespace Tesla.Graphics
Types
All Types Classes Structures Interfaces Enumerations
Icon Type Description
BaseMaterialLogic
Base MaterialLogic encapsulating common implemention. Material logic can be thought of as "pre-shaders". If a user needs to operate or retrieve a value that the engine does not define every frame, or per-material, that can be done in a material logic. Logic is executed before the material applies itself during rendering.

BaseRenderer
Abstract renderer that serves as the base class for implementation specific renderers.

Blend
Defines blending factors for source and destination colors.

BlendFunction
Defines how to combine source and destination colors for blending operations.

BlendState
BlendState object that controls how pixels are blended during rendering.

Camera
A camera represents how we view the 3D scene. It handles setting/updating the view and projection matrices and holds onto a viewport which the renderer uses to setup where and how the 3D scene is rendered to the screen. This allows for multiple cameras to exist, each containing all the details of how the scene is to be mapped to the 2D screen.

ClearOptions
Options to clear rendertargets and the back buffer.

ColorWriteChannels
Defines the channels that can be written to a render target's color buffer.

ComparisonFunction
Comparison function enumeration for alpha, stencil, or depth-buffer testing.

CubeMapFace
Enumeration of the faces of a CubeMap.

CullMode
Defines how a primitive should be culled.

DataWriteOptions
Options for writing data to a hardware resource.

DepthFormat
Defines the format of a RenderTarget's depth buffer.

DepthStencilState
DepthStencilState object that controls the depth-stencil buffer.

DirectionalLight
A light that is considered infinitely away from the viewer, thus it only has a direction (e.g. the Sun relative to the Earth seems "infinitely" away). Also known as a parallel light. This will ignore the attenuation properties of the Light base class.

DisplayMode
Description for a display mode.

DisplayModeCollection
Collection for display modes.

DisplayOrientation
Defines the display orientation.

Effect
Represents a complete set of shaders on the device used to render geometry. An effect is made up of individual vertex/pixel shaders and 1 or more techniques that use them. Each technique in turn has a set of 1 or more passes.

EffectParameterClass
Defines the class of an effect parameter.

EffectParameterType
Defines the type of an effect parameter.

FillMode
Defines how primitives should be filled.

Glyph
Represents a glyph on a texture.

GraphicsResource
Abstract class that represents a resource bound to the graphics pipeline.

ICamera
Interface that defines a camera. Camera's are set to the renderer before a scene is to be rendered, and contains the viewport used to render the scene to the screen.

IEffectAnnotation
Interface that represents an effect annotation. An annotation is a piece of metadata attached to a shader element (pass, technique, or parameter) and can contain values for editors.

IEffectAnnotationCollection
Interface defining an effect annotation collection.

IEffectParameter
Interface representing a uniform parameter that is defined in an effect.

IEffectParameterCollection
Interface defining an effect parameter collection.

IEffectPass
Interface representing a complete set of shaders (e.g. vertex/pixel) that specifies how to render geometry.

IEffectPassCollection
Interface defining an effect pass collection.

IEffectTechnique
Interface representing an effect technique. A technique is comprised of one or more passes, where each pass defines a complete set of shaders (e.g. vertex/pixel) that specifies how geometry should be rendered.

IEffectTechniqueCollection
Interface defining an effect technique collection.

IGraphicsAdapter
Represents a display subsystem.

ILightCollection
Light collection interface.

IMaterialLogic
Material logic can be thought of as "pre-shaders". If a user needs to operate or retrieve a value that the engine does not define every frame, or per-material, that can be done in a material logic. Logic is executed before the material applies itself during rendering.

IndexBuffer
Represents the indices of vertices in a vertex buffer. This allows for vertex data to be re-used, if duplicate vertices exists which allows for a smaller vertex buffer (thus saving space).

IndexFormat
Format for the index buffer.

IRenderable
A renderable defines an object that can be rendered to the screen and as thus contains a set of properties that describe how it should be rendered, and a method to render itself.

IRenderBucket
Defines the interface for a bucket that stores a list of IRenderables that are to be sorted and rendered.

IRenderBucketComparer
Bucket comparer for Spatial types.

IRenderer
Interface defining the methods responsible for drawing graphics and initializing the graphics device. The renderer is the central component in creating graphics objects, manages render states (including preventing redundant state switching), and includes a render queue to organize and sort geometry that are to be rendered.

IRenderQueue
Defines an interface for a render queue, which is a way to organize how renderables are to be drawn to the screen. A queue is composed of several buckets, each with an order. Renderables in each bucket can be sorted to further refine the organization.

IRenderSystemProvider
Interface for a render system, which provides all the means with communicating to the graphics device and creating concrete implementations for graphics objects.

ISamplerStateCollection
Represents the collection of sampler states set onto the device.

ITextureCollection
Represents the collection of textures set onto the device.

Light
The Light class is a base class for all lighting objects used by the engine. Common properties such as ambient, diffuse, and specular color as well as attenuation properties are defined in this class, but may not be used by all subclasses.

LightLogic
Logic that feeds Engine light values into the shader before a renderable is to be drawn. This module is designed to work with the engine's default shader library, although it can be used for custom shaders or replaced outright. An instance of LightLogic is always created with a Material. A unique LightLogic should only be associated with one Material at a given time. GlobalAmbient is expected to be a 3-component float vector. LightCount is expected to be an integer (or float equivalent), and the expected light list is expected to be composed of the following structure:
CopyC#
//Light struct that represents a Point, Spot, or Directional
//light. Point lights are with a 180 degree inner/outer angle,
//and directional lights have their position's w = 1.0 .
struct Light {
  //Color properties
  float3 Ambient;
  float3 Diffuse;
  float3 Specular;

  //Attenuation properties
  bool Attenuate;
  float Constant;
  float Linear;
  float Quadratic;

  //Positional (in world space) properties
  float4 Position; //Note: w = 1 means direction is used
  float3 Direction;
  float InnerAngle;
  float OuterAngle;
};

LightParameter
Enumeration of supported LightLogic parameters.

LightType
Enumeration of supported types of lights.

Material
MaterialCollection
A material collection that represents a complete set of materials in a TEM file, in the order they appear in the file.

MaterialSamplerStateCollection
Sampler State collection for materials, simply a container that mirrors the number of valid samplers the renderer allows.

OpaqueRenderBucketComparer
Opaque bucket comparer that will sort renderables based on their material. If those are equal, or the comparison isn't applicable, then they are sorted front-to-back.

OrthoRenderBucket
Render bucket for managing renderables to be drawn with an orthographic projection.

OrthoRenderBucketComparer
Comparer for the ortho render bucket. This sorts renderables first by their ortho order. Renderables with smaller ortho order values are rendered first.

PointLight
Represents an omni-directional light source located at a specific point in world space.

PresentationParameters
Structure that represents a collection of values used for setting up a graphics presentation, e.g. window and swap chain.

PresentInterval
Describes if presenting should enable or disable VSync.

PrimitiveType
Defines the topology of the mesh store.

ProjectionMode
Specifies the projection mode for a Camera.

RasterizerState
RasterizerState object that controls how 3D geometry is rasterized.

RenderBucket
Standard render bucket used by default. Contains a list of Spatials which it will use the engine's implementation of merge sort when sorting.

RenderBucketType
Render bucket type for how the engine organizes and sorts geometry with the render queue.

RenderQueue
Standard implementation of render queue. Sets up default buckets for each of the pre-defined bucket types.

RenderState
Base class for render state objects. Render states become immutable once bound to the device.

RenderStateKey
Key representing a RenderState - it's type and its hash value.

RenderStateList
Collection for the three main render states - Blend, DepthStencil, and Rasterizer. Setting a SamplerState to this list is meaningless and will be ignored.

RenderStateType
Defines the render state type.

RenderTarget2D
Represents a Texture2D that can be used as a render target, which is generated dynamically by rendering data into it and which can be used later as a regular texture.

RenderTargetBinding
Provides a general way to bind render targets to the graphics pipeline.

RenderTargetCube
Render Target that is an array of 6 Texture2D's that are put together in a Cube.

RenderTargetUsage
Determines how data is used when a render target is activated.

ResourceUsage
Resource usage enumeration.

SamplerState
SamplerState object that controls how a texture is sampled.

SpotLight
A SpotLight is similar to point with it being located at a specific point in world space. However, it's light influence is restricted to a cone (opposed to being omni-directional) that is controlled by a direction and two angles for falloff to create a soft edge.

SpriteBatch
SpriteFlipEffect
Bit flag enumeration for how sprites should be flipped when drawn, if at all.

SpriteFont
SpriteFont represents a font texture where each character corresponds to a portion of the texture and includes spacing data such as kernings to properly render string data.

SpriteSortMode
Sprite sort mode enumeration.

StencilOperation
Stencil buffer operation enumeration.

SurfaceFormat
Defines a surface's encoding format.

SwapChain
SwapChain represents the back/front buffers that the scene is rendered to. The back buffer accumulates the rendered primitives and is presented to the window that is being rendered to (e.g. swapped with the front buffer).

Texture
Abstract base class for all texture resources.

Texture1D
Represents a 1-Dimensional texture resource that simply has width.

Texture2D
Represents a 2-Dimensional texture that has height and width.

Texture3D
Represents a 3-Dimensional texture that has width, height, and depth.

TextureAddressMode
Addressing mode for textures.

TextureCube
Represents a cube where each face is a 2-Dimensional texture.

TextureDimensions
Enumeration for texture dimensions.

TextureFilter
Enumeration for valid filtering schemes involving shrinking (minify), expanding (magnify), or filtering between mipmap levels.

TransparencyType
Transparency type for how the engine will render transparent geometry.

TransparentRenderBucket
Render bucket for transparent renderables. Transparent renderables are sorted back-to-front to achieve proper transparency. Transparent renderables with TransparencyType.OneSided are rendered as usual. If a renderable's TransparencyType is TwoSided the renderable is rendered in two passes. The first pass renders the back faces and the second pass renders the front faces. The render states enforced during these passes can be overriden and their defaults are described below. Renderables with a material that has more than one pass defines are rendered as usual, without any state enforcing, as they may not follow the above paradigm.

TransparentRenderBucketComparer
Comparer for transparent objects. These are always rendered back-to-front regardless of material in order to ensure correct rendering.

VertexBuffer
Represents a list of vertices that exists on the GPU. A vertex typically has a position and a number of additional properties such as a color or normal vector.

VertexBufferBinding
Provides a general way to bind vertex buffers to the graphics pipeline.

VertexDeclaration
Represents the organization of vertex data in a vertex buffer, which is used by the device to process the vertex stream.

VertexElement
Represents a vertex element in a vertex buffer.

VertexElementBinding
Defines a relationship between a single DataBuffer and a VertexElement which the buffer represents.

VertexFormat
Format for a vertex element in the vertex buffer.

VertexPositionColor
Represents a vertex with position and vertex color data.

VertexPositionColorTexture
Represents a vertex with position, vertex color, and texture coordinate data.

VertexPositionNormalColorTexture
Represents a vertex with position, normal, vertex color, and texture coordinate data.

VertexPositionNormalTexture
Represents a vertex with position, normal, and texture coordinate data.

VertexPositionTexture
Represents a vertex that has position and texture coordinate data.

VertexSemantic
Enumeration for vertex element usage, these correspond directly to the semantics of vertex-shader inputs. There is a certain level of disconnect of these semantics and actual store, since texture coordinates can be used for custom store and fog/point expansion must be done by the user.

VertexWinding
Defines the how vertices are wound. This defines the criteria to define what are the back and front of a primitive.

Viewport
Defines the 2D region where the 3D rendering is projected onto.