All Classes, Interfaces, Objects and Records

Raised by SaveTextureContents when we cannot get texture contents.

type - don't add this Delphi can't parse it correctly

Common class for exceptions related to GLSL programs.

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

TStructList

Descend from this to mark exceptions that should be shown in more concise way by ExceptMessage function.

Raised by various X3D methods searching for X3D items (nodes, fields, events and such) when given item cannot be found.

Data source used in TCastleTableView.

Base node type for the child nodes of TAbstractAppearanceNode.

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.

Common base class for all implemented interpolator nodes.

Base node type for all coordinate node types.

Base type for all drag-style pointing device sensors.

Base type for cubic environment map textures.

Base node type for all font style nodes.

Base node for a visible geometry in X3D.

Base node that contains children nodes.

Base class for all nodes that contain only information without visual semantics.

Basis for all nodes interpolating (animating) values.

Base class for all the light nodes.

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 most (but not 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, but not multi-texture.

Base for all sound nodes.

2D texture.

Base for all nodes which specify texture coordinates.

Base for all nodes which specify a transformation of texture coordinates.

Base type for all touch-style pointing device sensors.

Base type from which all trigger nodes are derived.

Base type for viewpoints in X3D, which are locations from which the user may view the scene.

Activity recognition (detects user stationary, walking, running and so on) (TActivityRecognition).

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.

Information about product possible to be bought given to TInAppPurchases.SetAvailableProducts.

Shadow volumes helper, not depending on OpenGL.

Customize blending (partial transparency) mode.

Stores a boolean value for toggling on/off.

Configurable border size for TCastleUserInterface.Border.

Axis-aligned box.

Rectangular box.

Holds a set of assemblies or parts grouped together.

Hierarchy of nodes used for showing layer structure for the CAD model.

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

This is a very special CastleScript value, used to represent user-defined function parameter.

CastleScript user function definition.

Abstract class for a font that can be used to render text.

Base class to express primitives that can be easily added and adjusted inside TCastleViewport.

An abstract slider user interface.

Application, managing all open TCastleWindow (OpenGL windows).

Automatically create and switch between various navigation classes on a viewport.

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

Bitmap font, where each character is just drawn (and may be multi-color) on a raster image.

Clickable button.

Checkbox with a caption.

Component with various CGE extensions: can be a parent of other non-visual components (to display them in CGE editor and serialize them to files), can be translated, can have custom logic when serializing/deserializing (CustomSerialization).

Store configuration in XML format.

Abstract user interface container.

Note: we need this deprecated class to be a separate class, not just an alias for TCastleControl, to be able to register it using RegisterNoIcon, to support in old projects.

Cylinder with configurable size, position and material.

Directional light shines along a direction in 3D space, simulating a light source far away (like a sun).

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.

Font loaded from a font file, like ttf or otf.

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.

Abstract navigation class that can utilize mouse look, during which mouse cursor is hidden and we look at MouseLookDelta every frame.

Notifications displayed on the screen.

Extended TObjectQueue for Castle Game Engine.

Dialog to open scene (select a file that can be loaded using TCastleScene.Load).

Image open dialog.

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

Panel or a toolbar control.

Plane with configurable size, position and material.

Controls a sound playback initiated by TCastleSoundSource.Play.

Profiler, to measure the speed of execution of your code.

Progress bar user interface.

Manage a list of recently opened files, and show a menu in Lazarus.

Options that control rendering, available at every scene through TCastleScene.RenderOptions.

General save dialog that uses URL.

Complete loading, processing and rendering of a scene.

Deprecated way to manage transformations and scenes.

Container for a user interface children that can be scrolled vertically.

Control with a scrollbar.

Fill the whole window with a simple color.

Sound that can be loaded from URL (possibly reusing a cache, possibly using streaming) and played.

Sphere with configurable size, position and material.

Behavior to make parent TCastleTransform stick to a surface of another TCastleTransform Target.

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

Cell inside TCastleTableView.

Tenjin ( https://www.tenjin.com/ ) integration.

Combine (add, multiply, do maximum or minimum) two other terrain data sources.

Terrain (height map) data taken from intensities in an image.

Terrain heights are generated from a smooth noise, combined with some terrain-specific improvements (Heterogeneous).

Theme for user interface 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.

Basic user-interface class.

List of TCastleUserInterface instances.

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

Container that packs the children vertically.

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

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.

Cone.

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

Interpolate (animate) a set of 2D positions, for example to animate 2D texture coordinates.

Set of 3D coordinates to be used in the Coord field of vertex-based geometry nodes.

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

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 axis, as an X3D node, to easily visualize debug things.

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

Visualization of a bounding volume of a TCastleTransform instance.

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.

Defines the size, family, style and other properties used for TTextNode.

Property editor for URL that refers to a font file.

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

Viewing frustum, defined as 6 plane equations.

Cube environment map texture generated by rendering the 3D world, useful for real-time mirrors.

Functionality for all X3D nodes that represent generated textures.

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.

OpenGL(ES) features, analyzed based on extensions and version.

Rendering to texture with OpenGL.

Easily handle program in GLSL (OpenGL Shading Language).

Video as a sequence of OpenGL textures that can be easily played.

Video expressed as a series of textures, to play as texture on any 3D object.

Grayscale image with an alpha channel.

Contains children nodes without introducing a new transformation.

Alter the shape of coordinate-based geometry within parent H-Anim nodes.

Joint of an animated humanoid.

An attachment point of an animated humanoid, to attach something that held, worm or such by a humanoid.

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

Texture image loaded from a file.

A product that can be bought by in-app purchases (TInAppPurchases).

Mesh with faces (polygons) constructed from vertices.

Common base class for VRML 1.0 indexed polygon nodes (IndexedFaceSet and IndexedTriangleMesh).

Triangles that form a fan shape around the first vertex.

A collection of triangles.

Embed another X3D scene into the current scene.

Motion (movement) of mouse or a finger on a touch device.

A keyboard and/or mouse shortcut for activating some action.

Generate an integer upon receiving any boolean value.

Joystick information.

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

Appearance node with a special name KambiAppearance.

Navigation information with some Castle Game Engine extensions.

Tracking the "pressed" state of keys.

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

Additional visible properties to be applied to all line geometry.

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

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.

Message system to communicate between native code (Pascal) and other languages (Java on Android, Objective-C on iOS) that possibly run in other thread.

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

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

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

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.

Simple component system inside TX3DNode.

Descend from this to hide a parameterless constructor.

Interpolate (animate) a set of 3D directions, for example normal vectors.

Trimming segment that is expressed a NURBS curve and is part of a trimming contour in the u,v domain of the surface.

Visible NURBS curve in 3D.

Visible NURBS 3D surface.

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 2D NURBS curve.

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

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

Single file that may contain a number of shaders and combined effects.

Send along with the animation that should be applied only partially (because it fades-out or fades-in).

Path tracer.

Material information that defines parameters for Phong lighting equations.

Material information that defines parameters for physical lighting equations.

Information send along with TCollisionEvent event, like TRigidBody.OnCollisionEnter, TRigidBody.OnCollisionExit.

3D texture defined as an explicit array of pixel values inside the X3D file.

Alternative (deprecated) version of TRectangle2DNode, compatible with InstantReality X3D browser.

Parameters to use when playing animation, see TCastleSceneCore.PlayAnimation.

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.

Shader that can consist of one or more individually programmable, self-contained pieces in TShaderProgramNode, like a Microsoft HLSL shader.

Projection determines how does the 3D world map onto 2D screen.

Generate events when the viewer enters, exits, and/or moves within a region of 3D space.

Quaternions are useful to represent rotations in 3D that can be easily applied and combined with other rotations.

Information about ray collision with a single 3D object.

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 high-precision RGB colors encoded as 3 floats.

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 you can use from TCastleComponent.CustomSerialization to manage reading/writing of colors.

Load the serialized component once, instantiate it many times.

VRML 1.0 (deprecated) field representing a bitmask, where a number of "flags" can be "on" or "off".

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

Generic class for an X3D field containing a single matrix value.

X3D field containing an image that is "embedded" in the X3D file.

X3D field containing an single integer 32-bit value.

X3D field containing an single integer 32-bit value.

VRML 1.0 SFMatrix field.

X3D field representing a 3D rotation around an arbitrary axis.

X3D field containing a single string.

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.

Manager of allocated sounds.

3D sound emitter.

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.

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.

Choose only one (or none) of the child nodes for processing.

Tangent vectors information, for bump mapping.

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

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

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

4D (homogeneous 3D) texture coordinates, partcularly useful with 3D textures.

2D texture coordinates used by vertex-based geometry nodes.

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

Map Unicode code to a TGlyph representation.

Adjust the texture application properties.

Transformation of texture coordinates in 3D, partcularly useful with 3D textures.

2D transformation that can be applied to texture coordinates (e.g.

Because Indys version isn't generic in FPC.

Contains a list of animation frames.

Single frame of animation.

List of properties.

Tileset definition.

Functionality of all time-dependent nodes.

Generate events as time passes.

Utility for setting and observing a boolean value in various ways.

Tracking of multi-touch, a position of each finger on the screen.

Describe transformation in a way comfortable to apply it in both ways.

Property editor for URL that refers to a file readable by TransformLoad.

Grouping node that transforms (moves, rotates, scales) it's children.

Generates events when the target object enters, exits, and moves within a region of 3D space.

Triangle in 2D space.

Triangle in 4D (or 3D homogeneous) space.

Triangle expressed in particular coordinate system, for TTriangle.

Set of triangles in 2D.

Strips of triangles.

UI state, to manage the state of your game UI.

Material information that defines parameters for unlit lighting equations.

Implement this class, and pass to RegisterUrlProtocol, to read protocols asynchronously (such that TCastleDownload can read them asynchronously).

Generate events upon receiving a boolean TRUE value.

Vector of 2 Cardinal values.

Vector of 2 Integer values.

Vector of 2 SmallInt values.