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.
|