Utility for working with adapters and the screen.

The XAnimationAllocateHierarchy class serves for loading and releasing frames of the animated mesh.

The XAnimationExpTimeMap class represents time mapping using power function. This time function converts animation time to the virtual animation time.

Represents the frame for the animated mesh (XAnimationMesh).

The XAnimationMesh class that encapsulates working with animated meshes and offers basic animation mechanisms.

Represents the animated mesh container that contains mesh and description of bones that animate the mesh.

The XAnimationMeshFrameSprite class represents the animated mesh frame.

Represents the sprite in the animated mesh sprite hierarchy, that corresponds to the mesh container in the animated mesh hierarchy.

Represents the animated mesh sprite - sprite that is created from the animated mesh; that represents the root frame of the animated mesh.

The XAnimationMeshSprite..::.AnimationHandlerInfo class contains information about the current state of animation playback.

The abstract XAnimationMeshSpriteBase class is the base class for the animated mesh parts.

The XAnimationTableclass makes the XSimpleSpriteAnimator animation table that allows easy animation creation from different kind of sources.

The XAnimationThread class creates new animation thread and cooperates tightly with the XSpace library. If are you creating next threads in that you work with animations or the XSpace library, we recommend you to use this class. Not using it may result in time dependent errors or freezing.

The XArcPath class represents the path along the arc.

The XAudioController class serves for easy working with the audio.

The XAudioSprite class allows to play sounds in the space that can move and that utilizes the Doppler effect.

The XAudioTable class serves for managing the audio.

The XBillboardSprite class supports a great deal of possibilities of working with graphics on the 2D surface. Allows to set different color filters for different components of the material and supports several frames displayable on the surface.

The XBillboardSpriteAnimator class offers a simple interface for XBillboardSpriteAnimator type sprites animation. The animator can animate sprite frames and color filters.

The XBlending class defines the most frequent ways of color blending.

The XBoneCombinationTransform class defines the bone combination transform of the Mesh animated mesh.

The XBoundingVolumeLineBoxSpriteDecorator class allows to decorate the sprite with the bounding volume line box.

The XBoxMesh class allows to create box meshes.

The XBoxTextureNames class defines the default suffixes of the box texture names.

The XBoxTextures class is a box texture set, where every side can have own texture. The texture set utilizes e.g. the XSkyBox skybox.

The XBumpMapping class allows to create the bump-mapping for achieving the effect of realistic surfaces.

The XCamera class represents a camera that can view inside the XSpace world.

The XCameraController class serves for easy XCamera camera manipulation.

The XCameraViewport class defines the views to the world through the XCamera camera. Every view can display another part of the world, if you create several views, you can show them together at the same moment, e.g. looking forward and to the rear-view mirror.

The XCircularMesh class allows to create circular meshes.

Represents information about collision.

The XColorAnimator class allows to animate the Color type property.

The XCombinedAnimator class allows to create animations, which are composed from few partial XSpriteAnimator animations.

The XCombinedPath class represents path created by joining several IXPath paths together. When you create such path, it is easy to move sprite along this path using eg. the XPathAnimator.

The XCylinderMesh class allows to create cylinder meshes.

The XDefaultMaterialManager class offers the basic implementation of the IXMaterialManager interface for material management.

The XDeviceCaps class represents the device capabilities accessible through the DirectX interface.

The XDirectionalLight represents the directional lights. The directional light is a light that illuminates the object from an infinite distance in the given direction.

The XEmptyModel class defines the empty model.

The XFaceBoxSprite class creates a block sprite that consists of the faces.

Class XFaceCollisionSolver implements quick algorithm for two surfaces collison testing.

The XFaceHighlighterSpriteDecorator class allows to decorate the sprite by highlighting one selected face.

The XFacePrimitive class allows to draw face primitives.

The XFaceSprite class creates sprite with one or more faces.

The utility for finding the file used in the SGPRTL library.

The XFog class serves for working with the fog effect.

The XHemisphereMesh class allows to create hemispherical meshes.

Represents the class for working with DirectX Input - interface for working with input devices such joystick, keyboard, mouse or suchlike.

Represents the default action identifiers.

Represents the DirectX Input action - press or release of the button, move of the joystick handle and suchlike.

The XInputActionMap class is a map of user-defined XInputAction actions.

The XInputActionMapState class encapsulates working with the XInputActionMap action map.

The XInputQueue class defines the interface for easy event handling in this window.

The XInputSpriteController class implements the controller for controlling the sprite from the input.

The XInt32ValueAnimator class allows to animate the Int32 type property.

The XLight class serves the work with light in the XWorld world.

The XLight..::.XLightCollection class is a collection of lights that the XSprite sprite contains.

The XLineBoxPrimitive class allows to draw line box primitives.

The XLineBoxSprite class creates a block sprite that consists of the lines.

The XLineBoxSpriteDecorator class allow to decorate the sprite with the line box.

The XLinePrimitive class allows to draw line primitives.

The abstract XLinePrimitiveBase class allows to implement classes based on drawing the line primitives.

The XLineSprite class creates sprite from one or more lines in space that are given in the form of independent point pairs.

The XLineSpriteDecorator class allows to decorate the sprite with specified lines.

The XMaterial class implements the IXMaterial interface and offers the ability to draw various objects with a different appearance. So, the object can have several textures with a different texture rotation, color, transparency and allows to specify different components of the reflected light.

The XMaterialMesh class encapsulates working with the meshes of the DirectX layer and offers basic mechanisms for using the XMaterial materials.

The XMaterialMeshSubset class encapsulates working with the separate parts of the XMaterialMesh mesh.

The abstract XMaterialSprite class is parent for classes that supports displaying using the XMaterial material.

The XMeshModel class encapsulated working with the mesh models.

The XMeshModelCfgSettings class is designed for saving and loading the extended configuration of the mesh model.

The XMeshModelConfigs class contains collection of all XModelConfig configurations that this mesh owns.

The XMeshSprite class allows the XMaterialMesh mesh objects encapsulation to the form of the XMeshSprite sprite that uses the rendering engine.

The XModel class offers the set of methods for working with models, including creation of the XSprite sprites from the models, finding models according their names, accessing the model properties.

The XModelBoundingVolumeLineBoxSpriteDecorator class allows to decorate the sprite with the bounding volume line box.

The XModelCategory class offers methods for managing the model categories.

The XModelConfigEditor class is the default control for editing the XModelConfig model configuration.

The XModelConfigs class contains collection of all XModelConfig configurations that this model owns.

The XModelException exception is raised when some error occured in the SGP RTL library during working with models.

The XModelNotFoundException exception is raised when model with the given name has not been found.

The XModelViewer class offers the simplified interface for the XModel model selection.

The XModelViewerForm class offers the interface for the XModel model selection.

The XOrientedBoxTree class represents the XOrientedBox oriented box tree.

The XOrientedBoxTree..::.Node class represents the XOrientedBoxTree boundary box tree node.

The XOrientedLineBoxSpriteDecorator class allows to decorate the sprite with the boundary line box.

The XOrientedLineBoxTreeSpriteDecorator class allows to decorate the sprite with the line boxes of the boundary box tree.

The XPathAnimator class allows to animate the sprite along any IXPath path.

The abstract XPathCollection collection class represents the IXPath path collecton. If you want to use path created by joining several paths together, use the XCombinedPath class.

The XPathPrimitive class allows to draw line path primitives.

The XPathSprite class creates a path sprite in the space that consists of the vertices sequence.

The XPathTransform class allows to create paths by transforming the existing ones.

The abstract class XPointCollection describes the collection of the vectors Vector3.

The XPointLight creates new point light. Point light shines like the bulb from one point to all directions. Point light fades with the increasing distance from the source and since certain distance it has no effect.

The XPolygonMesh class allows to create polygonal meshes.

The abstract XPrimitiveSprite class is parent for various sprite primitives from the SGPRTL library.

The XPrimitiveSpriteContainer class for easy working with primitives.

The XQuaternionAnimator class allows to animate the Quaternion type property.

The XRenderableItem class represents an object that can be rendered. It contains references to objects that implements the IXRenderableMaterial, IXRenderableTransform and IXRenderableMaterial interfaces that are necessary for the object rendering.

Represents the rendering context - information needed during the rendering.

The XRenderQueue class defines the render queue that the objects to be rendered are picked out from.

The XRenderQueue..::.XRenderGroupQueueBase class defines the generic render group of the objects.

The XRenderQueue..::.XRenderMaterialGroupQueue class defines the render group of the objects sorted by the same material.

The XRenderQueue..::.XRenderTransparentGroupQueue class defines the render group of the objects sorted by the distance from the camera (suitable for the transparent objects).

The XScene class allows to save the model set definition to the file and restore it as follow. This is fully utilized in the Baltie scenes of the BaltieSpace Baltie space.

The XSceneModel class encapsulated working with the scene models.

The XScreen class encapsulated working with the screen, display modes and the view rendering.

The XScreen..::.DeviceStateCache class is used for the caching Device and RenderStateManager of the DirectX render pipeline and for increasing the overall performance of SGPRTL.

The XScreen..::.SamplerState class is used for the caching SamplerStateManager of the DirectX render pipeline and for increasing the overall performance of SGPRTL.

The XScreen..::.TextureState class is used for the caching TextureStateManager of the DirectX render pipeline and for increasing the overall performance of SGPRTL.

The class XSimpleSpriteAnimator provides a simple interface for the sprite animation.

The XSingleValueAnimator class allows to animate the Single type property.

The XSkyBox class allow to create a virtual horizon in the infinite distance that the observer can never get closer to and that moves with the observer. It creates an impression of the real world, a landscape where the observer is moving.

The XSpace class represents the space where all the XWorld worlds are located. The space does exist only one, but any number of worlds can be created.

The XSpaceUtility class supplies useful methods for working with the space.

The XSpaceUtility..::.XFaceArrayAdapter class is the standard implementation of the IXFaceArray interface for working with the face array.

The XSpaceUtility..::.XVertexArrayAdapter class is the standard implementation of the IXVertexArray interface for working with the vector array. It encapsulates different types of input data.

The XSpaceUtility..::.XVertexArrayAdapter1 class implements the IXVertexArray interface for working with the Vector3 vector array.

The XSpaceUtility..::.XVertexArrayAdapter2 class implements the IXVertexArray interface for working with the Vector3 vector array with the possibility of filtering vectors not contained in the faces collection.

The XSpaceUtility..::.XVertexArrayAdapter2I class implements the IXVertexArray interface for working with the IXVertexArray vector array with the possibility of filtering vectors not contained in the faces collection.

The XSpaceUtility..::.XVertexArrayAdapter3 class implements the IXVertexArray interface for working with the IXVertexArray vector array with the possibility of filtering vectors not contained in the faces collection and the vertices collection.

The XSphereMesh class allows to create spherical meshes.

The XSplinePath class allows to create paths along defined curve.

The XSpotLight class represents the spotlight. The spotlight suggests the flashlight effect that illuminates the object in the given direction. In the InnerConeAngle inner cone the illumination intensity is highest, the further from the center the weaker the illumination, and in the OuterConeAngle outer cone there is no light at all.

The XSprite class is the base class for all other sprites in the SGPRTL library. Sprites is an object in space that the displaying engine can render.

The XSprite..::.XSpriteCollection class is a collection of sprites that are owned by the IXSpriteCollectionOwner owner.

The XSprite2D class allows to work with sprites displayable on the 2D surface and in the 3D space as with the 2D objects.

The XSpriteAnimator class offers basic interface for sprite animation.

The XSpriteController class serves as a base class for different types of controlling the sprite (e.g. controlling sprite's motion on the surface).

The abstract XSpriteDecoratorBase class allows to create decoration for any sprite. For example highlight the sprite borders using the XModelBoundingVolumeLineBoxSpriteDecorator line box.

The XSpritePropertyAnimator class allows to animate different sprite properties.

The XSpriteTerrainMotionController class implements the sprite motion controller on the generic terrain.

Class XTachometer calculates current object speed from given discrete samples.

The XTeapotMesh class allows to create the tea pot mesh.

The XTerrain class allows to create 3D terrain randomly or from the height maps.

The XText2D class wraps the displayed text, its color, font-type, margin size. The text is displayed on the XTextArea2D 2D surface in front of the scene.

The XTextArea2D class represents a surface that is rendered in front of the scene and displays the XText2D texts.

The XTextMesh class serves for defining the 3D text in the form of a mesh. Allowa to set various font type properties.

The XTextMeshSprite class allows the XTextMesh mesh objects encapsulation to the form of the XSprite sprite that uses the rendering engine.

The XTextureGraphics class allow to draw to the Texture texture using the Graphics canvas from the GDI+ library.

The XTextureLayer class allows to define various number of material layers with different texture and settings. Object, rendered using the multi-layer material, can have several different textures.

The XTextureLayerCollection class is a collection of material layers that are contained by the XMaterial material.

The XTextureLayerOperation class defines operations between texture layers, that are applied to the single layers to get the resulting color of the object.

The XTextureMapping class encapsulates the basic texture mapping algorithms.

The XTextureMappingAlgorithm class implements the base algorithm for mapping a texture.

The XTextureMappingBillboardAlgorithm class implements the square faces texture mapping algorithm.

The XTextureMappingCubeAlgorithm class encapsulates the cube texture mapping algorithm.

The XTextureMappingCustomAlgorithm class implements an algorithm for mapping texture using specified table of points.

The XTextureMappingPolygonAlgorithm class implements the polygon texture mapping algorithm.

The XTextureMappingSphericalAlgorithm class implements the sphere texture mapping algorithm.

Class XTextureTiles allows to cut Texture texture to the tiles using delegated IXTileCut interface.

Class XTileCut provides implicit implementation of the IXTileCut interface that allows to cut area to matrix-addressable tiles.

The XTimerTable class defines the table of timers using that it is possible to measure the elapsed time very accurately.

The XTorusMesh class allows to create the torus meshes.

The XVector3Animator class allows to animate Vector3 type property.

The XVideoController class serves for easy working with the video.

The XVideoTable class serves for managing the video.

The XViewport abstract class defines the views to the world. Every view can display another part of the world, if you create several views, you can show them together at the same moment, e.g. looking forward and to the rear-view mirror.

The XViewportForm class represents the main application window, where the XViewportInputPanel panel, allowing to draw 3D graphics, is located.

The XViewportInputPanel class enables the extended support for working with user input, including user inputs reading and event processing. Like XViewportPanel, it allows to manage several views to the world.

The XViewportMouseController class enables the default in-scene camera controll using the mouse, the controller is attached to the view and offers handling familiar from the SGP tools that works with the 3D space.

The XViewportMouseController..::.MDFAStateInfo class represents the mouse controller state.

The XViewportMouseController..::.XStateAnimator animator class allows to animate the camera according to the XViewportMouseController mouse controller settings.

The XViewportPanel class provides infrastructure for displaying the world on the user screen.

One XViewportPanel viewport panel can contain an unlimited number of viewsports of the XWorld world. Every viewport with the camera can watch different part of the world.

The XWorld class defines world that is in the XSpace space. Although the space is known just one, we can create several different worlds we can work with. For example, we can create few different sceneries with the possibility of quick switching during the rendering. Every world contains its own definition of lights, fog and time.

The XWorld2D class represents the world for displaying the two-dimensional objects. It differs from the XWorld class in creating the default camera for this world. The XCamera camera for two-dimensional world uses identical displaying and identical projection.

The XOrientedBox structure represents the axially oriented box.

Represents information about the bone combination, which animates the animated mesh (XAnimationMesh).

Represents information about two surfaces collision.

The XFileResourceLocator..::.Location structure defines the file location.

The XInputSpriteController..::.InputActionInfo structure contains the information about reactions to the user input.

Represents the information about the ray intersection with the mesh.

The XModelConfig class describes one model configuration. Different configurations allows the same model to be placed to different positions, with different rotation and scale. The configurations are fully used by e.g. SGP.Baltie Baltie when conjuring, the floor model can be conjured as a floor, ceiling or wall.

The XOrientedBox structure represents the oriented box in space.

The XOrientedBoxTree..::.HitInfo class contains information about two boundary boxes intersection.

The XPlane structure allows easy working with plane, calculating distance of a point from the plane, testing the XRay, Intersect(XRay, Vector3%) ray intersection with the plane.

The XRay structure describes the ray with its origin and the direction vector. The ray is used for intersection testing in the XWorld world.

The XSpeed structure describes event and evenly accelerated (decelerated) motion. Allows to calculate travelled distance and perform speed acceleration.

The XSpriteRayIntersectionInfo structure contains information about the ray intersection with the object in the XWorld world.

The XTextureFiltering structure defines ways of the texture filtering.

The XViewportMouseControllerState structure represents the state of the mouse controller. Includes the coordinates of the center, relative distance from the camera and the angles.

The IXAnimationTimeMapFunction interface defines time mapping function that converts animation time to the correspondent virtual animation time.

The IXBoxVertices interface defines properties and methods that must be supplied by the box vertices array implementation.

The interface IXFaceArray defines properties, which must supply an implementation of a face array based on this interface.

Interface IXFrameAnimation defines properties, that can control count of frames and number of the current frame of animation of the object implementing this interface.

The IXMaterial interface defines basic material qualities.

The IXMaterialManager interface defines methods and properties for material management.

The IXMouseController interface represents methods of the mouse controller that are called by the agent that receives the mouse events and delegates them to the controller.

The IXMouseControllerPort interface defines port for attaching and detaching the mouse controllers.

The IXPath interface represents the path in space where eg. the XPathAnimator animation can move along.

The IXPath2D interface represents the path on the 2D area.

The IXPathTransformable interface defines methods for transformable paths.

The IXRenderable interface is an interface file of IXRenderableMaterial, IXRenderableTransform and IXRenderablePrimitive. Gives the rendering engine object that contains all necessary information for correct drawing.

The IXRenderableMaterial interface that gives the renreding engine information about the material that will be used for rendering the object.

The IXRenderablePrimitive interface allows the object, implementing this interface, perform the object rendering.

Represents the interface for coordinate transformation of the rendered object.

The IXSceneExtensionReader interface offers the possibility of extending the reading automaton with reading its own extended information stored through the IXSceneExtensionWriter interface.

The IXSceneExtensionWriter interface offers the possibility of extending the writing automaton with its own extended information.

The interface IXSpriteCollectionOwner represents a collection owner XSprite..::.XSpriteCollection, which must implement methods and properties of this interface to be an owner of a collection.

The IXSpriteController interface defines different types of controlling the sprite (e.g. controlling sprite's motion on the surface).

The IXSpriteDecorator interface allows to create decoration for any sprite. For example highlight the sprite borders using the XModelBoundingVolumeLineBoxSpriteDecorator line box.

The IXSpriteWithMesh interface defines properties and methods that must be implemented by the sprite object, created from the Mesh mesh.

The IXTextureMappingAlgorithm interface serves for definition of the texture mapping algorithm.

Interface IXTileCut allows to cut image into matrix-addressable tiles.

The IXVertexArray interface defines properties that must be supplied by the vector array implementation based on this interface.

The XModel..::.IXModelFactory interface defines way of creating models from the given resources.

The XSprite..::.IXPointAtAlgorithm interface that allows to create your own algorithms for pointing to given point in space, e.g. using rotation.

The XAnimationMeshSprite..::.AnimationHandler delegate serves for animation run-time controll and allows to change sprite state during animation.

Represents the method that handles the XInputAction event (DirectX Input action).

The XOrientedBoxTree..::.BoxHitCallback box intersection delegate.

The XOrientedBoxTree..::.EnumerateCallback enumeration delegate for the XOrientedBoxTree tree.

The XOrientedBoxTree..::.FaceTestCallback edge test delegate.

The XSpriteAnimateHandler delegate for sprite animation.

The XSpriteCollisionHandler delegate of the sprite collision.

The XSpriteLocalTransformationChangedHandler delegate of the local transformation change.

The XSpriteParentChangedHandler delegate that informs about the sprites parent change. The oldParent gives the original parent. The newParent gives the new parent.

The XSpriteSubspriteInsertedHandler delegate that informs about adding the sprite insertedSprite to the Sprites sprite collection.

The XSpriteSubspriteRemovedHandler delegate that informs about removing the sprite removedSprite from the Sprites sprite collection.

The XTextureLayerAnimateHandler delegate is called by the material layer. It signals that the material animation is in progress.

Enum XAnimationLoop defines way the animaton will be repeated.

The XBoxTexture enumeration defines the names of the 6 different box sides.

Defines which back faces will not be rendered within the camera.

Defines the performing of the collision detection.

The XInputSpriteController..::.InputAction enumeration that contains the pre-defined reactions to the user input.

Defines which back faces will not be rendered within the material.

The XModelConfig..::.AngleUnit enumeration defines the configuration angle unit.

The XModelConfig..::.VectorUnit enumeration defines unit and way of distance interpretation in the configuration.

The XModelFilter enumaration allows to filter the found XModel models according their types.

The XPlane..::.Side enumeration defines different point location in respect of the plane.

The XRelativePoint enumeration defines different types of the relative point in the cube. The relative point always relates to the cube and its real value can only be calculated with the knowledge of the cube.

The XRenderGroup enumeration defines the render groups.

The XSimpleColorOperation enumeration defining simple color operations.

The XSprite..::.ChangedNotification enumeration defines the types of changes that happened during the sprite properties change.

The XSpriteControllerMode enumeration defines the way the controller is moving the XSprite sprite.

The XSpriteRayIntersectFlags enumeration defines different limitations of ray intersection with the 3D world object.

The XViewportBoundsMode enumeration defines the modes of interpreting the coordinates given for the XViewport views.

The XViewportMouseController..::.MDFAState enumeration defines the mouse controller state.

The XViewportMouseController..::.OptionFlags enumeration defines the mouse controller options.

The XVMCAnimate enumeration defines the mode of animation parameters unit interpretation.