All Classes, Interfaces, Objects and Records

Part of CastleGLImages unit: rendering to texture (TGLRenderToTexture).

Common class for exceptions related to GLSL programs.

Raised by SaveImage when it's not possible to save image.

OpenGL error.

GPU memory is not sufficient.

Any error related to VRML/X3D.

Raised when there's a problem instantiating X3D prototype, see TX3DPrototypeNode.Instantiate.

Interface for an abstract node type that indicates that the node may be used as a child of a grouping node, e.g.

Base interface type for all sensors.

Interface from which all time-dependent nodes are derived.

Interface for nodes that are valid product structure children.

Interface for all VRML 2.0 / X3D transformation nodes.

Resource used for rendering and processing of 3D objects.

Abstract type from which 3D backgrounds inherit.

Base node type for all Appearance nodes.

Abstract type from which all backgrounds inherit.

Common base class for all cameras in VRML 1.0.

Abstract node type that indicates that the node may be used as a child of a grouping node, e.g.

Base node type for all composed 3D geometry.

Copyright 2002-2018 Michalis Kamburelis.

Base class for all directional lights.

Base type for all the environmental sensor nodes.

Base node type for all geometric property node types.

Geometry node allowed only in VRML <= 1.0.

Common base class for VRML 1.0 indexed nodes (IndexedFaceSet, IndexedTriangleMesh, IndexedLineSet).

Basis for all nodes interpolating (animating) values.

Abstract level information, with information useful to spawn resources like creatures and items.

Provides various levels of detail for a given object, only one of which will be visible at a given time.

Basis for all metadata nodes.

Base X3D node that can have some metadata.

Base type for nodes that provide control curve information in 2D space.

Point light source, that shines from a given point in all directions around, for all VRML and X3D versions.

Abstract class for (most) nodes that are valid product structure children.

Base abstract class for all sensors.

Base node type from which all sequencers (like TIntegerSequencerNode and TBooleanSequencerNode) are derived.

Base node type for all Shape nodes.

Base for all nodes which specify a texture coordinate, but not MultiTextureCoordinate.

Base for all nodes which specify a texture coordinate transform, but not MultiTextureTransform.

Base class for (most) nodes that can emit audio data.

Base type for all node types that specify 3D sources for texture images.

Base for all nodes which specify a texture, possibly multi-texture.

Abstract node from which most (but not all) time-dependent nodes are derived.

Common base class for all VRML 1 nodes that modify the transformation.

Base type for all node types that specify per-vertex attribute information to the shader.

X3D texture that is 2D and can be loaded (from file or some other stream).

Advertisements in game.

Gathering analytics through Google Analytics https://www.google.com/analytics/ and / or Game Analytics http://www.gameanalytics.com/ .

Visual properties of geometry.

Closed circular arc in 2D.

Buffer for sound data, which can be played by the TSoundNode.

3D background of a scene, comprised of sky and ground colors (gradients) and optional six textures (skybox).

Abstract class for octrees that can check and return collisions with TTriangle.

Grouping node that transforms the coordinate system of its children so that they always turn towards the viewer.

Filters boolean events, allowing for selective routing of TRUE or FALSE values and negation.

Generate sequential boolean events.

Trigger node that generates Boolean events upon receiving time events.

Collide as a box.

Read another stream, sequentially, always being able to back one character, and buffering it.

Holds the geometry representing a face of a part.

Represents the location and faces that constitute a part in the CAD model.

Various information that may be useful for implementing some function handlers, but that should be supplied from outside of CastleScript.

This specifies for each type combination (array of TCasScriptValue classes) and for each function (TCasScriptFunction class) how they should be handled.

CastleScript function shortcut, see [https://castle-engine.io/castle_script.php#function_shortcut].

Root of transformations and scenes (tree of TCastleTransform and TCastleScene).

Transform representing an alive thing.

Application, managing all open TCastleWindowBase (OpenGL windows).

Behaviors can be attached to TCastleTransform to perform specific logic, for example implement creature movement.

Clickable button.

Checkbox with a caption.

TCastleColor record represented as a TPersistent descendant, to be able to visually edit it (in Lazarus and Delphi visual designer, and Castle Game Engine visual designer) and to serialize it.

Component with small CGE extensions.

Class helper to read CastleScript expressions from XML config files.

Control to render everything (3D or 2D) with Castle Game Engine.

Contents of this user-interface control are loaded from an indicated file (by the URL property).

Edit box to input a single line of text.

Fade out, flash, and similar screen effects done by blending screen with given color.

Slider to change a float value within a given range.

Profiler gathering statistics about each game frame.

An abstract class representing image as a simple array of pixels.

Image that can be easily loaded from URL (possibly reusing a cache), drawn, and serialized to/from file.

Descendant of TCastleEdit specialized for editing integer numbers.

Label with possibly multiline text, in an optional box.

TMOFile descendant that allows iterating through all strings.

Transformation moving and potentially pushing other objects.

Notifications displayed on the screen.

Extended TObjectQueue for Castle Game Engine.

On-screen menu, with all menu items displayed on the screen, one under another.

Menu item of TCastleOnScreenMenuItem that can be toggled.

General open dialog that uses URL.

Subcomponent used in TCastleCamera.Orthographic to set orthographic projection parameters.

Panel or a toolbar control.

This gesture recognizer detects pan and pinch gesture, as both use two fingers, but cannot be done at the same time (to have only one active recognizer).

Structure obtained by calling TCastleProfiler.Start.

Custom, fast random number generator.

Fill a rectangle on screen with given color or theme image.

Root of transformations and scenes (tree of TCastleTransform and TCastleScene).

Image save dialog.

Loading and processing of a scene.

Control that applies shader screen effects (post-processing) on the rendering done by children and (when this class is used as an ancestor) it's descendants.

Abstract user interface with a scrollbar.

Draw a simple shape (rectangle, circle) with given color and optional outline.

Behavior to play spatial sounds, that automatically follow the parent TCastleTransform transformation.

Touch-friendly checkbox control with representing on/off state.

Cell inside TCastleTableView.

Theme for 2D GUI controls.

Display a map created in Tiled (https://www.mapeditor.org/).

Touch user interface to navigate in a 3D world.

Group and transform (move, rotate, scale) children objects.

List of TCastleTransform instances.

Base class for all user interface controls using a font.

TVector2 record represented as a TPersistent descendant, to be able to visually edit it (in Lazarus and Delphi visual designer, and Castle Game Engine visual designer) and to serialize it.

TVector4 record represented as a TPersistent descendant, to be able to visually edit it (in Lazarus and Delphi visual designer, and Castle Game Engine visual designer) and to serialize it.

Viewport displays a tree of scenes and transformations (TCastleTransform and TCastleScene).

Navigation by walking or flying (classic first-person shooter navigation) in a 3D scene.

Window to render everything (3D or 2D) with Castle Game Engine.

Circle in 2D.

Classic Whitted-style ray-tracer.

Clipping plane, along with a transformation.

Clip the geometry with a plane.

Shape used for collision detection of a rigid body TRigidBody.

Represents a collision with a 3D objects tree.

Grouping node that specifies the collision detection properties for its children.

Interpolate (animate) a single color.

Set of RGBA colours.

Advanced material that can be heavily configured using textures (specular maps, normal maps and much more).

Cube environment map texture defined as a six individual 2D texture nodes.

3D texture defined as a collection of 2D texture sources at various depths.

Groups a set of curve segments for a composite contour, for X3D.

Piecewise linear curve segment as a part of a trimming contour in the u, v domain of a surface.

Same as TGameSceneManager, redefined only to work as a sub-component of TCastleControl, otherwise Lazarus fails to update the uses clause correctly and you cannot edit the events of CastleControl1.SceneManager subcomponent.

3D coordinates defines using double precision floating point values.

Interpolate (animate) a set of 3D positions, for example to animate coordinates of a mesh.

Base creature, using any TCreatureResource.

Basic abstract resource used by all creatures.

Interpolate (animate) a set of 3D positions, using cubic Bezier curve instead of linear interpolation.

Cylinder.

Pointing device sensor to rotate objects around a constrained axis.

3D arrow, as an X3D node, to easily visualize debug things.

3D box, as an X3D node, to easily visualize debug things.

Like TDebugTransformBox, but visualizes also additional properties.

Light source that shines along a given direction, like a sun.

Disc (filled circle) in 2D.

Class helper to read CastleScript expressions from DOM (XML files).

Image that can be drawn.

Support controlled gradual transitions by modifying TimeSensor node fractions.

Part of a shader effect, used with TEffectNode.

Abstract class for an image with unspecified, possibly compressed, memory format.

2D cross-section shape extruded along a 3D spine.

Describe a range of indexes where the face (polygon and such) is located.

Additional visual properties to be applied to all polygonal areas.

2D rectangle with float coordinates.

Provide explicit fog depths on a per-vertex basis.

Simulate atmospheric fog effects (for the whole scene) by blending with the fog colour, based on the distance from the viewer.

Font family, with different subfonts for normal, bold, italic, bold+italic variants.

Utility to measure frames per second, independent of actual rendering API.

Viewing frustum, defined as 6 plane equations.

Integration with a game service, that can be used to show achievements, leaderboards, and store save games "in the cloud".

Generate texture by rendering a depth (shadow) map.

OpenGL(ES) library version information.

2x2 matrix of floating-point values.

3x3 matrix of floating-point values.

4x4 matrix of floating-point values.

Vector of 2 floating-point values.

Vector of 3 floating-point values.

Vector of 4 floating-point values.

Elevation grid expressed in geo-centric coordinates.

Giftiz (http://www.giftiz.com/) integration.

OpenGL memory information.

GLSL shader program specialized for rendering screen effects.

Video expressed as a series of TDrawableImage, to play as 2D GUI control.

Image compressed using one of the GPU texture compression algorithms.

Grayscale image.

Central node for moving the animated humanoid.

Visible segment of an animated humanoid, always a child of a TJointNode.

Helpshift (http://helpshift.com/) integration.

Cube environment map texture loaded from a single file, like DDS.

Texture image loaded from a file.

Manage in-app purchases in your game.

Geometry formed by constructing polylines from 3D vertices.

Quads.

IndexedTriangleMesh (from Inventor 1.0).

Strips of triangles.

Embed another X3D scene into the current scene, with explicit "load" control (VRML 97 version).

Base class for things that listen to user input.

Input press or release event.

Group of TInputShortcut, to easily manage (search, load, save...) the inputs.

Generate sequential integer events.

Common helper for all X3DTimeDependentNode descendants.

An item that can be used, kept in the inventory, or (using PutOnWorld that wraps it in TItemOnWorld) dropped on 3D world.

Basic resource of an item that can be picked up, used and such.

Weapon that can make an immiediate attack (short-range/shoot) or fire a missile.

Joystick information.

Properties of a given joystick, use by accessing Joysticks[Index].

Appearance node with a special name KambiAppearance.

Embed a scene from another file, and replace some of it's nodes.

Tracking the "pressed" state of keys.

Convert LCL OnKeyDown and OnUTF8KeyPress into a single CGE event OnPress.

Level logic.

Light source instance in the scene.

Lines.

Monitors the progress and success of downloading URL elements over a network.

Provides various levels of detail for a given object, only one of which will be visible at a given time, for X3D.

Provides various levels of detail for a given object, only one of which will be visible at a given time, for VRML 2.0.

X3D events logging.

Material determines how the geometry looks on the screen, by providing parameters to the lighting equations.

Store information that is naturally associated with a given material or texture in an external file.

List of TMatrix3Double.

Per-vertex 3x3 matrix attributes, available to shaders.

List of TMatrix4.

Transform children by an explicit 4x4 matrix.

TMenuEntry that contains a list of menu entries.

TMenuItem that should visualize Checked state somehow to the user.

A group of radio buttons.

TMenuEntry that acts as a visual separator (horizontal line or something like that) between menu items.

Collide as a mesh, constructed from the given scene shapes.

Used by TMessaging to manage a list of listeners.

A metadata (extra, custom information at a node) with a boolean type.

A metadata (extra, custom information at a node) with a single-precision floating point number type.

A metadata (extra, custom information at a node) set, to reference of collection of other metadata nodes.

VRML/X3D field holding a list of nodes.

Creature using TMissileCreatureResource.

Movie file, that can be played and displayed as a texture.

Multiple texture coordinates per vertex, to be used with multi-texturing by TMultiTextureNode.

Multiple texture transforms, to be used with multi-texturing by TMultiTextureNode.

Describe the physical characteristics of the viewer's avatar and navigation.

A TPersistent descendant that can use interfaces and is not reference counted.

Normal (information for lighting) node.

Calculate NURBS basis functions.

Calculate point on a NURBS curve.

Visible NURBS curve in 3D, in VRML 2.0.

Interpolate (animate) orientations as tangent vectors of the 3D NURBS curve.

Interpolate (animate) positions along the 3D NURBS curve.

Groups a set of NURBS surface nodes to a common group for rendering purposes, to ensure a common tesselation within the group.

Interpolate (animate) by sampling a position and normal at 3D NURBS surface from an input 2D surface parameters.

Path in 2D space (that can be constructed from NURBS curves, or straight segments) extruded along a 3D NURBS curve.

NURBS surface existing in the parametric domain of its surface host specifying the mapping of the texture onto the surface.

Visible 3D NURBS surface (like a TNurbsPatchSurfaceNode) that is trimmed by a set of trimming loops.

Command-line option specification, for TParameters.Parse.

Interpolate (animate) a 2D orientation, during which angle changes but axis remains constant.

Viewpoint that provides an orthographic view of the scene.

Storing and processing command-line parameters and options.

Space-filling Peano curve.

TPhotoService enables to store/retrieve images to/from the system Photos app.

Configure physics simulation calculation.

Piecewise (composite) cubic Bezier curve.

Texture specified as an explicit array of pixel values (see FdImage field).

Collide as an infinite plane.

Pointing device sensor to move objects on a plane.

Player, 3D object controlling the camera, main enemy of hostile creatures, carries a backpack, may cause fadeout effects on screen and such.

List of pointing device sensors.

Points.

Series of line segments in 2D.

Set of vertices in 2D.

Interpolate (animate) a 3D position, for example to animate TTransformNode.Translation.

Information that a TCastleTransform object needs to prepare rendering.

Current time from ProcessTimer.

Progress bar functionality.

Generate texture coordinates by projection.

Quads, not indexed.

Represents a ray collision with a 3D objects tree.

Calculate primary rays for given camera settings and screen size.

2D rectangle with integer coordinates.

The OpenGL / OpenGLES context state.

Information that a TCastleTransform object needs to render.

Sound engine that keeps a repository of sounds, defined in a nice XML file.

Image with pixel represented as a TVector3Byte (red, green, blue).

Rigid body properties for the physics engine, see TCastleTransform.RigidBody.

RotationXYZ node (from Inventor).

Interpolate (animate) a single floating-point value, for example to animate TMaterialNode.Transparency.

Scissor to clip displayed things, in addition to the global scissor affected by TRenderContext.ScissorEnable / TRenderContext.ScissorDisable.

Program behavior in a scene using scripts.

Helper methods extending TSerializedComponent.

X3D field containing a single boolean value.

X3D field containing an RGB color.

X3D field containing an RGBA color (with an alpha).

X3D field containing a floating-point value with Double precision.

VRML 1.0 (deprecated) field representing an enumerated value, which means that you choose one (named) value from a set of possible values.

X3D field containing a vector.

X3D field containing a 3x3 matrix with Double precision.

X3D field containing a 3x3 matrix with Single precision.

X3D field containing a 4x4 matrix with Double precision.

X3D field containing a 4x4 matrix with Single precision.

VRML/X3D field holding a reference to a single node.

X3D field containing a single string.

X3D field containing a time, expressed as seconds that passed since some moment.

Time field, that ignores it's input event when parent time-dependent node is active.

Self-container shader part used with TProgramShaderNode, for example with Microsoft HLSL shader language.

Shape is a geometry node Geometry instance and it's State.

Tree of shapes.

Iterates over all TShape items that would be enumerated by Tree.Traverse.

Node of the TShapeTree representing an alternative, choosing one (or none) child from it's children list as active.

Font using a texture to define character images with constant width and height.

Manager of allocated sounds.

Sound engine, responsible for loading and playing sound.

Parameters to use when playing sound, see TSoundEngine.PlaySound.

On-screen menu item that allows to control sound volume.

Collide as a sphere.

Non-linearly interpolate (animate) a 2D position.

Non-linearly interpolate (animate) a single floating-point value.

Custom animation of a sprite.

Non-linearly interpolate (animate) a rotation.

Ask user to choose from a number of options.

Ask user a press any key, and return this key.

Ask user a press anything (key, mouse button, mouse wheel), for example to configure a keybinding for a game.

Children nodes which cannot be modified.

Creature that just stays still.

TStringList that is case sensitive.

Generates events as the user inputs a longer string on the keyboard, useful for example to simulate "input fields" in 3D.

List of structures.

Simple space-filling curve that goes row by row, swapping direction.

Teapot geometry, useful for testing purposes.

Terrain (height for each X, Y) data calculated from CastleScript expression.

Terrain (height for each X, Y) data taken from intensities in an image.

Multiline text, visualized as a set of flat and textured polygons.

Common class for reading or writing a stream like a text file.

Old BS Contact name for TextureCoordinateGenerator.

3D texture coordinates, partcularly useful with 3D textures.

Automatic generation of texture coordinates.

Data for a 2D font initialized from a FreeType font file, like ttf.