Class TCastleViewport

Description

Hierarchy

Unit

CastleViewport

Declaration

type TCastleViewport = class(TCastleScreenEffects)

Description

Viewport displays a tree of scenes and transformations (TCastleTransform and descendants of it, like TCastleScene). Add the scenes and transformations to Items. See https://castle-engine.io/viewport_and_scenes .

Each viewport has a Camera with a position and orientation. Viewport may have multiple cameras.

Viewport may also have a navigation that allows to move camera by keyboard, mouse and other inputs. You can use any navigation method implemented in the engine (TCastleExamineNavigation, TCastleWalkNavigation, TCastleThirdPersonNavigation) or implement your own (you can create your own descendants of TCastleNavigation, or just move/rotate the camera by calling Viewport.Camera.SetWorldView from anywhere). Just add TCastleNavigation as a child of TCastleViewport.

Viewport may display a background. It may be a solid color, a 3D skybox or a gradient. See Background, BackgroundColor properties and https://castle-engine.io/background . Alternatively, viewport background may be transparent (so other TCastleUserInterface underneath will be visible) if Transparent.

Multiple viewports can display the same world. To do this, simply copy Items reference from one TCastleViewport to another. You can also just create your own TCastleRootTransform instance and then assign it to multiple viewports. This allows e.g. to make a split-screen game (played by 2 people, with 2 viewports, on a single monitor). Or you can show in a 3D FPS game an additional view from some security camera, or from a flying rocket. See https://castle-engine.io/multiple_viewports_to_display_one_world .

Source: scene/castleviewport.pas (line 78).

Hierarchy

TObject
TPersistent
TComponent
TCastleComponent
TCastleUserInterface
TCastleScreenEffects
TCastleViewport

Show Additional Members: Inherited Protected

Overview

Constants

Public	`DefaultWidth = 100.0;`
Public	`DefaultHeight = 100.0;`
Public	`DefaultScreenSpaceAmbientOcclusion = false;`
Public	`DefaultScreenSpaceReflections = False;`
Public	`DefaultScreenSpaceReflectionsSurfaceGlossiness = 0.5;`
Public	`DefaultUseGlobalLights = true;`
Public	`DefaultUseGlobalFog = true;`
Public	`DefaultShadowVolumes = true;`
Public	`DefaultBackgroundColor: TVector4 = (X: 0.1; Y: 0.1; Z: 0.1; W: 1);`
Public	`Default2DProjectionFar = CastleTransform.Default2DProjectionFar deprecated 'this default is not used; ProjectionFar in orthographic projection is now automatically adjusted to what you display';`
Public	`Default2DProjectionNear = CastleTransform.Default2DProjectionNear deprecated 'this default is not used; ProjectionNear in orthographic projection is now automatically adjusted to what you display';`
Public	`Default2DCameraZ = CastleTransform.Default2DCameraZ;`
Public	`DefaultPrepareOptions = [prRenderSelf, prRenderClones, prBackground, prBoundingBox, prScreenEffects];`
Public	`DefaultInternalGridAxis = false;`

Fields

Protected	`RenderScreenEffects: Boolean;`
Public	`var CustomRenderingPass: TUserRenderingPass;`
Public	`InternalDesignCamera: TCastleCamera;`

Methods

Protected	`function GetInternalText: String; virtual;`
Protected	`procedure SetInternalText(const Value: String); virtual;`
Protected	`procedure SetName(const Value: TComponentName); override;`
Protected	`procedure TranslateProperties(const TranslatePropertyEvent: TTranslatePropertyEvent); virtual;`
Public	`procedure SetTransient;`
Public	`procedure AddNonVisualComponent(const NonVisualComponent: TComponent);`
Public	`procedure InsertNonVisualComponent(const Index: Integer; const NonVisualComponent: TComponent);`
Public	`procedure RemoveNonVisualComponent(const NonVisualComponent: TComponent);`
Public	`function NonVisualComponentsIndexOf(const NonVisualComponent: TComponent): Integer;`
Public	`function NonVisualComponentsCount: Integer;`
Public	`function NonVisualComponentsEnumerate: TNonVisualComponentsEnumerator;`
Public	`function ValueIsStreamed: Boolean; virtual;`
Protected	`function ContainerWidth: Cardinal; virtual; deprecated 'arrange UI using anchors, FullSize and friends; if you really need container size, use "Container.UnscaledWidth" or "Container.PixelsWidth" after checking "Container <> nil"';`
Protected	`function ContainerHeight: Cardinal; virtual; deprecated 'arrange UI using anchors, FullSize and friends; if you really need container size, use "Container.UnscaledHeight" or "Container.PixelsHeight" after checking "Container <> nil"';`
Protected	`function ContainerRect: TRectangle; virtual; deprecated 'arrange UI using anchors, FullSize and friends; if you really need container size, use "Container.UnscaledRect" or "Container.PixelsRect" after checking "Container <> nil"';`
Protected	`function ContainerSizeKnown: boolean; virtual; deprecated 'arrange UI using anchors, FullSize and friends; if you really need container size, use "Container.UnscaledWidth/Height" or "Container.PixelsWidth/Height" after checking "Container <> nil"';`
Protected	`procedure DoCursorChange; virtual; deprecated 'better override VisibleChange and watch for chCursor in Changes';`
Protected	`procedure DefineProperties(Filer: TFiler); override;`
Protected	`procedure UIScaleChanged; virtual;`
Protected	`procedure PreferredSize(var PreferredWidth, PreferredHeight: Single); virtual;`
Protected	`procedure BeforeSizing; virtual;`
Protected	`procedure DoInternalMouseEnter; virtual;`
Protected	`procedure DoInternalMouseLeave; virtual;`
Protected	`function Theme: TCastleTheme;`
Public	`procedure DesignerInfo(const SList: TStrings); override;`
Public	`procedure DesignerWarnings(const SList: TStrings); override;`
Public	`function GetEnumerator: TEnumerator;`
Public	`procedure InternalSetContainer(const Value: TCastleContainer); virtual;`
Public	`function PreviewPress(const Event: TInputPressRelease): boolean; virtual;`
Public	`function PreviewRelease(const Event: TInputPressRelease): boolean; virtual;`
Public	`function SensorRotation(const X, Y, Z, Angle: Double; const SecondsPassed: Single): boolean; virtual;`
Public	`function SensorTranslation(const X, Y, Z, Length: Double; const SecondsPassed: Single): boolean; virtual;`
Public	`procedure VisibleChange(const Changes: TCastleUserInterfaceChanges; const ChangeInitiatedByChildren: boolean = false); overload; virtual;`
Public	`procedure Resize; virtual;`
Public	`function ControlsCount: Integer;`
Public	`procedure InsertFront(const NewItem: TCastleUserInterface); overload;`
Public	`procedure InsertFrontIfNotExists(const NewItem: TCastleUserInterface);`
Public	`procedure InsertFront(const NewItems: TCastleUserInterfaceList); overload;`
Public	`procedure InsertBack(const NewItem: TCastleUserInterface); overload;`
Public	`procedure InsertBackIfNotExists(const NewItem: TCastleUserInterface);`
Public	`procedure InsertBack(const NewItems: TCastleUserInterfaceList); overload;`
Public	`procedure InsertControl(const Index: Integer; const NewItem: TCastleUserInterface);`
Public	`procedure RemoveControl(const Item: TCastleUserInterface);`
Public	`function IndexOfControl(const Item: TCastleUserInterface): Integer;`
Public	`procedure ClearControls;`
Public	`procedure MoveToFront;`
Public	`function CapturesEventsAtPosition(const Position: TVector2): boolean; virtual;`
Public	`function TooltipExists: Boolean; virtual; deprecated 'use TooltipControl to customize tooltip look';`
Public	`procedure TooltipRender(const TooltipPosition: TVector2); virtual; deprecated 'use TooltipControl to customize tooltip look';`
Public	`procedure SetFocused(const Value: boolean); virtual;`
Public	`function EffectiveRect: TFloatRectangle;`
Public	`function EffectiveWidth: Single;`
Public	`function EffectiveHeight: Single;`
Public	`function EffectiveWidthForChildren: Single;`
Public	`function EffectiveHeightForChildren: Single;`
Public	`function CalculatedWidth: Cardinal; deprecated 'use EffectiveWidth';`
Public	`function CalculatedHeight: Cardinal; deprecated 'use EffectiveHeight';`
Public	`function CalculatedRect: TRectangle; deprecated 'use EffectiveRect';`
Public	`function RenderRect: TFloatRectangle;`
Public	`function RenderRectWithBorder: TFloatRectangle;`
Public	`function ScreenRect: TRectangle; deprecated 'use RenderRect';`
Public	`function ContainerToLocalPosition(ContainerPosition: TVector2; const ContainerPositionScaled: Boolean = true): TVector2;`
Public	`function LocalToContainerPosition(const LocalPosition: TVector2; const ContainerPositionScaled: Boolean = true): TVector2;`
Public	`function ParentRect: TFloatRectangle;`
Public	`procedure Anchor(const AHorizontalAnchor: THorizontalPosition; const TranslationX: Single = 0); overload;`
Public	`procedure Anchor( const AHorizontalAnchorSelf, AHorizontalAnchorParent: THorizontalPosition; const TranslationX: Single = 0); overload;`
Public	`procedure Anchor(const AVerticalAnchor: TVerticalPosition; const TranslationY: Single = 0); overload;`
Public	`procedure Anchor( const AVerticalAnchorSelf, AVerticalAnchorParent: TVerticalPosition; const TranslationY: Single = 0); overload;`
Public	`procedure AlignHorizontal( const ControlPosition: TPositionRelative = prMiddle; const ContainerPosition: TPositionRelative = prMiddle; const X: Single = 0); deprecated 'use Anchor';`
Public	`procedure Align( const ControlPosition: THorizontalPosition; const ContainerPosition: THorizontalPosition; const X: Single = 0); overload; deprecated 'use Anchor';`
Public	`procedure AlignVertical( const ControlPosition: TPositionRelative = prMiddle; const ContainerPosition: TPositionRelative = prMiddle; const Y: Single = 0); deprecated 'use Anchor';`
Public	`procedure Align( const ControlPosition: TVerticalPosition; const ContainerPosition: TVerticalPosition; const Y: Single = 0); overload; deprecated 'use Anchor';`
Public	`procedure Center; deprecated 'use Anchor(hpMiddle); Anchor(vpMiddle); to reliably center the control';`
Public	`function UIScale: Single; virtual;`
Public	`procedure EditorAllowResize(out ResizeWidth, ResizeHeight: Boolean; out Reason: String); virtual;`
Public	`function EffectiveFullSize: Boolean;`
Public	`procedure AddScreenEffect(const Node: TAbstractChildNode);`
Public	`procedure RemoveScreenEffect(const Node: TAbstractChildNode);`
Public	`procedure Render; override;`
Public	`procedure RenderOverChildren; override;`
Public	`procedure PrepareResources;`
Protected	`function CalculateProjection: TProjection; virtual;`
Protected	`procedure InitializeGlobalLights(const GlobalLights: TLightInstancesList); virtual;`
Protected	`procedure InitializeLights(const GlobalLights: TLightInstancesList); deprecated 'use InitializeGlobalLights';`
Protected	`procedure RenderFromViewEverything(const RenderingCamera: TRenderingCamera); virtual;`
Protected	`procedure RenderFromView3D(const Params: TRenderParams); virtual;`
Protected	`procedure RenderOnePass(const Params: TRenderParams; const PassParams: TRenderOnePassParams); virtual;`
Protected	`procedure Notification(AComponent: TComponent; Operation: TOperation); override;`
Protected	`function InternalExtraGetScreenEffects( const Index: Integer): TGLSLProgram; override;`
Protected	`function InternalExtraScreenEffectsCount: Integer; override;`
Protected	`function InternalExtraScreenEffectsNeedDepth: Boolean; override;`
Protected	`procedure PointingDevicePressFailed; virtual;`
Protected	`procedure BoundNavigationInfoChanged; virtual;`
Protected	`procedure BoundViewpointChanged; virtual;`
Protected	`procedure RenderWithoutScreenEffects; override;`
Protected	`procedure Loaded; override;`
Public	`constructor Create(AOwner: TComponent); override;`
Public	`destructor Destroy; override;`
Public	`function AllowSuspendForInput: boolean; override;`
Public	`function Press(const Event: TInputPressRelease): boolean; override;`
Public	`function Release(const Event: TInputPressRelease): boolean; override;`
Public	`function Motion(const Event: TInputMotion): boolean; override;`
Public	`procedure Update(const SecondsPassed: Single; var HandleInput: boolean); override;`
Public	`procedure BeforeRender; override;`
Public	`function PropertySections(const PropertyName: String): TPropertySections; override;`
Public	`procedure CustomSerialization(const SerializationProcess: TSerializationProcess); override;`
Public	`function GetMainScene: TCastleScene; deprecated 'use Items.MainScene';`
Public	`procedure AssignDefaultCamera; virtual;`
Public	`function ScreenSpaceAmbientOcclusionAvailable: boolean;`
Public	`function ScreenSpaceReflectionsAvailable: boolean;`
Public	`procedure GLContextOpen; override;`
Public	`procedure GLContextClose; override;`
Public	`function PrepareParams: TPrepareParams; deprecated 'use TCastleViewport.PrepareResources to prepare transforms';`
Public	`function BaseLights: TLightInstancesList; deprecated 'this is internal info, you should not need this; use PrepareParams to get opaque information to pass to TCastleTransform.PrepareResources';`
Public	`function Statistics: TRenderStatistics;`
Public	`function TriangleHit: PTriangle;`
Public	`procedure Setup2D;`
Public	`function PositionToCameraPlane(const Position: TVector2; const ContainerCoordinates: Boolean; const Depth: Single; out PlanePosition: TVector3): Boolean;`
Public	`procedure PositionToRay(const Position: TVector2; const ContainerCoordinates: Boolean; out RayOrigin, RayDirection: TVector3);`
Public	`function PositionToWorldPlane(const Position: TVector2; const ContainerCoordinates: Boolean; const PlaneConstCoord: T3DAxis; const PlaneConstValue: Single; out PlanePosition: TVector3): Boolean; overload;`
Public	`function PositionToWorldPlane(const Position: TVector2; const ContainerCoordinates: Boolean; const PlaneConstValue: Single; out PlanePosition: TVector3): Boolean; overload; deprecated 'use PositionToWorldPlane overload with PlaneConstCoord parameter; this version assumes PlaneConstCoord = 2';`
Public	`function PositionTo2DWorld(const Position: TVector2; const ContainerCoordinates: Boolean): TVector2;`
Public	`function PositionFrom2DWorld(const WorldPosition: TVector2; const ContainerCoordinates: Boolean): TVector2;`
Public	`function PositionFromWorld(const WorldPosition: TVector3): TVector2;`
Public	`procedure PrepareResources(const DisplayProgressTitle: string; const Options: TPrepareResourcesOptions = DefaultPrepareOptions); overload; deprecated 'use overload without DisplayProgressTitle: String';`
Public	`procedure PrepareResources(const Item: TCastleTransform; const DisplayProgressTitle: string; Options: TPrepareResourcesOptions = DefaultPrepareOptions); overload; deprecated 'use overload without DisplayProgressTitle: String';`
Public	`procedure PrepareResources( const Options: TPrepareResourcesOptions = DefaultPrepareOptions); overload;`
Public	`procedure PrepareResources(const Item: TCastleTransform; Options: TPrepareResourcesOptions = DefaultPrepareOptions); overload; virtual;`
Public	`function TransformUnderMouse: TCastleTransform;`
Public	`function TransformHit(const Position: TVector2; const ContainerCoordinates: Boolean; const MaxDistance: Single = 0): TCastleTransform;`
Public	`procedure SetupCamera;`
Public	`function InternalBuildNode(const SaveBaseUrl: String): TX3DRootNode;`

Properties

Public	`property NonVisualComponents [const Index: Integer]: TComponent read GetNonVisualComponents;`
Public	`property IsLoading: Boolean read FIsLoading;`
Public	`property OnVisibleChange: TCastleUserInterfaceChangeEvent read FOnVisibleChange write FOnVisibleChange;`
Public	`property Container: TCastleContainer read FContainer;`
Public	`property OnCursorChange: TNotifyEvent read FOnCursorChange write FOnCursorChange; deprecated 'use OnVisibleChange (or override VisibleChange) and watch for Changes that include chCursor';`
Public	`property ExclusiveEvents: boolean read FExclusiveEvents write FExclusiveEvents default true; deprecated 'do not use this; supporting this property was complicated and had no real benefit; everything now works as if ExclusiveEvents=true, always';`
Public	`property Controls [const Index: Integer]: TCastleUserInterface read GetControls write SetControls;`
Public	`property GetExists: Boolean read FExists; deprecated 'use Exists';`
Public	`property GLInitialized: boolean read FGLInitialized default false;`
Public	`property Focused: boolean read FFocused write SetFocused;`
Public	`property Parent: TCastleUserInterface read FParent ;`
Public	`property FloatWidth: Single read FWidth write SetWidth stored false; deprecated 'use Width';`
Public	`property FloatHeight: Single read FHeight write SetHeight stored false; deprecated 'use Height';`
Public	`property AnchorDelta: TVector2 read FTranslation write SetTranslation; deprecated 'use Translation';`
Public	`property Translation: TVector2 read FTranslation write SetTranslation;`
Public	`property KeepInFront: boolean read FKeepInFront write FKeepInFront default false;`
Public	`property BorderColor: TCastleColor read FBorderColor write SetBorderColor;`
Public	`property HasHorizontalAnchor: boolean read FHasHorizontalAnchor write FHasHorizontalAnchor stored false; deprecated 'this property does not do anything anymore, anchors are always active';`
Public	`property HasVerticalAnchor: boolean read FHasVerticalAnchor write FHasVerticalAnchor stored false; deprecated 'this property does not do anything anymore, anchors are always active';`
Public	`property HorizontalAnchorDelta: Single read GetHorizontalAnchorDelta write SetHorizontalAnchorDelta default 0; deprecated 'use Translation.X';`
Public	`property VerticalAnchorDelta: Single read GetVerticalAnchorDelta write SetVerticalAnchorDelta default 0; deprecated 'use Translation.Y';`
Public	`property Visible: Boolean read FVisible;`
Public	`property EnableUIScaling: boolean read FEnableUIScaling write SetEnableUIScaling default true;`
Public	`property CapturesEvents: boolean read FCapturesEvents write FCapturesEvents default true;`
Public	`property OnInternalMouseEnter: TUiNotifyEvent read FOnInternalMouseEnter write FOnInternalMouseEnter;`
Public	`property OnInternalMouseLeave: TUiNotifyEvent read FOnInternalMouseLeave write FOnInternalMouseLeave;`
Published	`property Cursor: TMouseCursor read FCursor write SetCursor default mcDefault;`
Published	`property OnUpdate: TUiUpdateEvent read FOnUpdate write FOnUpdate;`
Published	`property OnPress: TUiPressReleaseEvent read FOnPress write FOnPress;`
Published	`property OnRelease: TUiPressReleaseEvent read FOnRelease write FOnRelease;`
Published	`property OnMotion: TUiMotionEvent read FOnMotion write FOnMotion;`
Published	`property OnRender: TUiNotifyEvent read FOnRender write FOnRender;`
Published	`property Exists: boolean read FExists write SetExists default true;`
Published	`property Left: Single read FLeft write SetLeft stored false default 0; deprecated 'use Translation.X';`
Published	`property Bottom: Single read FBottom write SetBottom default 0; deprecated 'use Translation.Y';`
Published	`property FullSize: boolean read FFullSize write SetFullSize default false;`
Published	`property Width: Single read FWidth write SetWidth default DefaultWidth;`
Published	`property Height: Single read FHeight write SetHeight default DefaultHeight;`
Published	`property WidthFraction: Single read FWidthFraction write SetWidthFraction default 0.0;`
Published	`property HeightFraction: Single read FHeightFraction write SetHeightFraction default 0.0;`
Published	`property AutoSizeToChildren: Boolean read FAutoSizeToChildren write SetAutoSizeToChildren default false;`
Published	`property AutoSizeToChildrenPaddingRight: Single read FAutoSizeToChildrenPaddingRight write SetAutoSizeToChildrenPaddingRight default 0;`
Published	`property AutoSizeToChildrenPaddingTop: Single read FAutoSizeToChildrenPaddingTop write SetAutoSizeToChildrenPaddingTop default 0;`
Published	`property HorizontalAnchorSelf: THorizontalPosition read FHorizontalAnchorSelf write SetHorizontalAnchorSelf default hpLeft;`
Published	`property HorizontalAnchorParent: THorizontalPosition read FHorizontalAnchorParent write SetHorizontalAnchorParent default hpLeft;`
Published	`property VerticalAnchorSelf: TVerticalPosition read FVerticalAnchorSelf write SetVerticalAnchorSelf default vpBottom;`
Published	`property VerticalAnchorParent: TVerticalPosition read FVerticalAnchorParent write SetVerticalAnchorParent default vpBottom;`
Published	`property Culling: Boolean read FCulling write SetCulling default false;`
Published	`property ClipChildren: Boolean read FClipChildren write SetClipChildren default false;`
Published	`property Border: TBorder read FBorder;`
Published	`property CustomTheme: TCastleTheme read FCustomTheme write SetCustomTheme;`
Published	`property TooltipControl: TCastleUserInterface read FTooltipControl write SetTooltipControl;`
Published	`property EditorSelectOnHover: Boolean read FEditorSelectOnHover write FEditorSelectOnHover default true;`
Published	`property BorderColorPersistent: TCastleColorPersistent read FBorderColorPersistent ;`
Published	`property TranslationPersistent: TCastleVector2Persistent read FTranslationPersistent ;`
Public	`property ScreenEffectsTimeScale: Single read FScreenEffectsTimeScale write FScreenEffectsTimeScale default 1;`
Public	`property ScreenEffectsEnable: Boolean read FScreenEffectsEnable write FScreenEffectsEnable default true;`
Public	`property Projection: TProjection read FProjection; deprecated 'in most cases, you can instead read Camera parameters, like Camera.Orthographic.EffectiveWidth, Camera.Orthographic.EffectiveHeight';`
Public	`property BackgroundColor: TCastleColor read FBackgroundColor write FBackgroundColor;`
Public	`property ScreenSpaceAmbientOcclusion: boolean read FScreenSpaceAmbientOcclusion write SetScreenSpaceAmbientOcclusion default DefaultScreenSpaceAmbientOcclusion;`
Public	`property ScreenSpaceReflections: Boolean read FScreenSpaceReflections write SetScreenSpaceReflections default DefaultScreenSpaceReflections;`
Public	`property ScreenSpaceReflectionsSurfaceGlossiness: Single read FScreenSpaceReflectionsSurfaceGlossiness write SetScreenSpaceReflectionsSurfaceGlossiness;`
Public	`property OnCameraChanged: TNotifyEvent read FOnCameraChanged write FOnCameraChanged;`
Public	`property MouseRayHit: TRayCollision read GetMouseRayHit;`
Public	`property AvoidNavigationCollisions: TCastleTransform read FAvoidNavigationCollisions write SetAvoidNavigationCollisions;`
Public	`property Paused: boolean read GetPaused write SetPaused default false; deprecated 'use Items.Paused';`
Public	`property Navigation: TCastleNavigation read GetNavigation write SetNavigation stored false; deprecated 'instead of this property: to get, just remember current navigation instance on your side; to set, add it like "MyViewport.InsertBack(MyNavigation)"';`
Published	`property Items: TCastleRootTransform read FItems write SetItems;`
Published	`property Camera: TCastleCamera read FCamera write SetCamera;`
Published	`property ShadowVolumes: boolean read FShadowVolumes write FShadowVolumes default DefaultShadowVolumes;`
Published	`property ShadowVolumesRender: boolean read FShadowVolumesRender write FShadowVolumesRender default false;`
Published	`property Background: TCastleBackground read FBackground write SetBackground;`
Published	`property Fog: TCastleFog read FFog write SetFog;`
Published	`property BackgroundWireframe: boolean read FBackgroundWireframe write FBackgroundWireframe default false;`
Published	`property Transparent: boolean read FTransparent write FTransparent default false;`
Published	`property ClearDepth: boolean read FClearDepth write FClearDepth default true;`
Published	`property UseGlobalLights: boolean read FUseGlobalLights write FUseGlobalLights default DefaultUseGlobalLights; deprecated 'if you need to tweak this, then do not use MainScene; use regular TCastleScene and set CastGlobalLights as needed';`
Published	`property UseGlobalFog: boolean read FUseGlobalFog write FUseGlobalFog default DefaultUseGlobalFog; deprecated 'configure fog by assigning to TCastleViewport.Fog component; leave deprecated MyViewport.Items.MainScene = nil';`
Published	`property ApproximateActivation: boolean read FApproximateActivation write FApproximateActivation default false;`
Published	`property OnProjection: TProjectionEvent read FOnProjection write FOnProjection; deprecated 'adjust projection by changing Camera.ProjectionType and other projection parameters inside Camera';`
Published	`property EnableParentDragging: boolean read FEnableParentDragging write FEnableParentDragging default false;`
Published	`property AutoCamera: Boolean read FAutoCamera write SetAutoCamera default false; deprecated 'it is simpler to set camera at design-time explicitly, or use CameraViewpointForWholeScene to auto-adjust camera; if you want to animate the camera, attach TCastleCamera to a bone transformation exposed by Scene.ExposeTransforms';`
Published	`property OnBoundViewpointChanged: TNotifyEvent read FOnBoundViewpointChanged write FOnBoundViewpointChanged;`
Published	`property OnBoundNavigationInfoChanged: TNotifyEvent read FOnBoundNavigationInfoChanged write FOnBoundNavigationInfoChanged;`
Published	`property PreventInfiniteFallingDown: Boolean read FPreventInfiniteFallingDown write FPreventInfiniteFallingDown default false;`
Published	`property DynamicBatching: Boolean read FDynamicBatching write SetDynamicBatching default false;`
Published	`property OcclusionCulling: boolean read FOcclusionCulling write SetOcclusionCulling default false;`
Published	`property OcclusionSort: TShapeSort read FOcclusionSort write FOcclusionSort default sortAuto;`
Published	`property BlendingSort: TShapeSort read FBlendingSort write FBlendingSort default sortAuto;`
Published	`property OnCustomShapeSort: TShapeSortEvent read FOnCustomShapeSort write FOnCustomShapeSort;`
Published	`property UpdateSoundListener: Boolean read FUpdateSoundListener write FUpdateSoundListener default true;`
Published	`property BackgroundColorPersistent: TCastleColorPersistent read FBackgroundColorPersistent ;`

Description

Constants

Public DefaultWidth = 100.0;

This item is declared in ancestor TCastleUserInterface.

This item has no description.

Source: ui/castleuicontrols_userinterface.inc (line 310).

Public DefaultHeight = 100.0;

This item is declared in ancestor TCastleUserInterface.

This item has no description.

Source: ui/castleuicontrols_userinterface.inc (line 311).

Public DefaultScreenSpaceAmbientOcclusion = false;

This item has no description.

Source: scene/castleviewport.pas (line 442).

Public DefaultScreenSpaceReflections = False;

This item has no description.

Source: scene/castleviewport.pas (line 443).

Public DefaultScreenSpaceReflectionsSurfaceGlossiness = 0.5;

This item has no description.

Source: scene/castleviewport.pas (line 444).

Public DefaultUseGlobalLights = true;

This item has no description.

Source: scene/castleviewport.pas (line 445).

Public DefaultUseGlobalFog = true;

This item has no description.

Source: scene/castleviewport.pas (line 446).

Public DefaultShadowVolumes = true;

This item has no description.

Source: scene/castleviewport.pas (line 447).

Public DefaultBackgroundColor: TVector4 = (X: 0.1; Y: 0.1; Z: 0.1; W: 1);

This item has no description.

Source: scene/castleviewport.pas (line 448).

Public Default2DProjectionFar = CastleTransform.Default2DProjectionFar deprecated 'this default is not used; ProjectionFar in orthographic projection is now automatically adjusted to what you display';

Warning: this symbol is deprecated: this default is not used; ProjectionFar in orthographic projection is now automatically adjusted to what you display

referencing deprecated in deprecated

Source: scene/castleviewport.pas (line 450).

Public Default2DProjectionNear = CastleTransform.Default2DProjectionNear deprecated 'this default is not used; ProjectionNear in orthographic projection is now automatically adjusted to what you display';

Warning: this symbol is deprecated: this default is not used; ProjectionNear in orthographic projection is now automatically adjusted to what you display

This item has no description.

Source: scene/castleviewport.pas (line 451).

Public Default2DCameraZ = CastleTransform.Default2DCameraZ;

This item has no description.

Source: scene/castleviewport.pas (line 453).

Public DefaultPrepareOptions = [prRenderSelf, prRenderClones, prBackground, prBoundingBox, prScreenEffects];

This item has no description.

Source: scene/castleviewport.pas (line 454).

Public DefaultInternalGridAxis = false;

This item has no description.

Source: scene/castleviewport.pas (line 457).

Fields

Protected RenderScreenEffects: Boolean;

This item is declared in ancestor TCastleScreenEffects.

Valid only between Render and RenderOverChildren calls. Tells whether we actually use screen effects, thus RenderWithoutScreenEffects renders to texture. Read-only in descendants.

Source: scene/castlescreeneffects.pas (line 107).

Public var CustomRenderingPass: TUserRenderingPass;

Rendering pass, for user purposes. Useful to keep shaders cached when you render the same scene multiple times in the same frame (under different lighting conditions or other things that change shaders). By default this is always 0, the engine doesn't modify this. You can set this field manually.

Source: scene/castleviewport.pas (line 466).

Public InternalDesignCamera: TCastleCamera;

At design-time (in CGE editor), this is the camera used by the editor. Usually use InternalCamera, to automatically pick either design-time camera or runtime Camera.

Source: scene/castleviewport.pas (line 491).

Methods

Protected function GetInternalText: String; virtual;

This item is declared in ancestor TCastleComponent.

This item has no description.

Source: base/castleclassutils.pas (line 575).

Protected procedure SetInternalText(const Value: String); virtual;

This item is declared in ancestor TCastleComponent.

This item has no description.

Source: base/castleclassutils.pas (line 576).

Protected procedure SetName(const Value: TComponentName); override;

This item is declared in ancestor TCastleComponent.

This item has no description.

Source: base/castleclassutils.pas (line 577).

Protected procedure TranslateProperties(const TranslatePropertyEvent: TTranslatePropertyEvent); virtual;

This item is declared in ancestor TCastleComponent.

Enumerate all properties that are possible to translate in this component. E.g. in TCastleLabel it will return TCastleLabel.Caption, in TCastleEdit it will return TCastleEdit.Text and TCastleEdit.Placeholder.

Returns only non-empty properties, thus assuming that if current (by convention, English) text is empty, then there is no point in translating it. Moreover descendants may define boolean properties to exclude particular text from translating, e.g. TCastleLabel.CaptionTranslate, TCastleEdit.TextTranslate, TCastleEdit.PlaceholderTranslate.

It is not recursive (it doesn't enumerate children properties). Use global TranslateProperties procedure to call this on a hierarchy of TComponent.

You usually don't want to call this method (it is called by other engine routines). But you may find it useful to override this, if you define new component.

Source: base/castleclassutils.pas (line 598).

Public procedure SetTransient;

This item is declared in ancestor TCastleComponent.

Ignore this component when serializing parent's TCastleUserInterface.Controls list or TCastleTransform.List, and do not show this component in CGE editor. This simply sets csTransient flag in ComponentStyle.

This is useful for children that are automatically managed by the parent, and should not be modified by user code. For example, TCastleCheckbox is internally composed from TCastleImageControl and TCastleLabel children, but we don't want to serialize or even show these children to user.

Note that if you want to prevent this component from serializing as part of TCastleUserInterface.Controls list or TCastleTransform.List, but you still want it to be visible in CGE editor, then make it a "subcomponent" instead, by SetSubComponent(true).

Note that both csSubComponent and csTransient only disable the component serialization as part of parent's lists enumerated by CustomSerialization (see internal TCastleUserInterface.SerializeChildrenEnumerate , TCastleTransform.SerializeChildrenEnumerate, TCastleTransform.SerializeBehaviorsEnumerate).

If you will make the component published in its own property (which is normal for "subcomponents") then it will be serialized anyway, just as part of it's own property (like TCastleScrollView.ScrollArea). So to really avoid serializing a children component make it csSubComponent and/or csTransient, and do not publish it.

Source: base/castleclassutils.pas (line 663).

Public procedure AddNonVisualComponent(const NonVisualComponent: TComponent);

This item is declared in ancestor TCastleComponent.

Add non-visual component to this component. This is used to organize non-visual components in a tree hierarchy, in CGE designs and editor.

Parameters

X: X axis (tilt forward/backwards)
Y: Y axis (rotate)
Z: Z axis (tilt sidewards)
Angle: Angle of rotation (in radians)
SecondsPassed: The time passed since last SensorRotation call. This is necessary because some sensors, e.g. 3Dconnexion, may *not* reported as often as normal Update calls.

Source: ui/castleuicontrols_userinterface.inc (line 418).

Public function SensorTranslation(const X, Y, Z, Length: Double; const SecondsPassed: Single): boolean; virtual;

This item is declared in ancestor TCastleUserInterface.

Translation detected by 3D sensor. Used for example by 3Dconnexion devices.

Parameters

X: X axis (move left/right)
Y: Y axis (move up/down)
Z: Z axis (move forward/backwards)
Length: Length of the vector consisting of the above
SecondsPassed: The time passed since last SensorRotation call. This is necessary because some sensors, e.g. 3Dconnexion, may *not* reported as often as normal Update calls.

Source: ui/castleuicontrols_userinterface.inc (line 430).

Public procedure VisibleChange(const Changes: TCastleUserInterfaceChanges; const ChangeInitiatedByChildren: boolean = false); overload; virtual;

This item is declared in ancestor TCastleUserInterface.

Called always when something important inside this control (or it's children) changed. To be more precise, this is called when something mentioned among the TCastleUserInterfaceChange enumerated items changed.

This is always called with Changes <> [] (non-empty set).

Source: ui/castleuicontrols_userinterface.inc (line 512).

Public procedure Resize; virtual;

This item is declared in ancestor TCastleUserInterface.

Event called when the container (component or window with OpenGL context) size changes.

You can resize/reposition your component here to react to parent size changes. This is called only when the rendering context of the container is initialized, so you can be sure that this is called only between GLContextOpen and GLContextClose.

We also call this once when inserting into the controls list (like TCastleWindow.Controls or TCastleControl.Controls or inside parent TCastleUserInterface), if inserting into the container/parent with already initialized OpenGL context. If inserting into the container/parent without OpenGL context initialized, it will be called later, when OpenGL context will get initialized, right after GLContextOpen.

In other words, this is always called to let the control know the size of the container, if and only if the OpenGL context is initialized.

Source: ui/castleuicontrols_userinterface.inc (line 556).

Public function ControlsCount: Integer;

This item is declared in ancestor TCastleUserInterface.

This item has no description.

Source: ui/castleuicontrols_userinterface.inc (line 587).

Public procedure InsertFront(const NewItem: TCastleUserInterface); overload;

This item is declared in ancestor TCastleUserInterface.

Add child control, at the front of other children.

Source: ui/castleuicontrols_userinterface.inc (line 590).

Public procedure InsertFrontIfNotExists(const NewItem: TCastleUserInterface);

This item is declared in ancestor TCastleUserInterface.

This item has no description.

Source: ui/castleuicontrols_userinterface.inc (line 591).

Public procedure InsertFront(const NewItems: TCastleUserInterfaceList); overload;

This item is declared in ancestor TCastleUserInterface.

This item has no description.

Source: ui/castleuicontrols_userinterface.inc (line 592).

Public procedure InsertBack(const NewItem: TCastleUserInterface); overload;

This item is declared in ancestor TCastleUserInterface.

Add child control, at the back of other children.

Source: ui/castleuicontrols_userinterface.inc (line 595).

Public procedure InsertBackIfNotExists(const NewItem: TCastleUserInterface);

This item is declared in ancestor TCastleUserInterface.

This item has no description.

Source: ui/castleuicontrols_userinterface.inc (line 596).

Public procedure InsertBack(const NewItems: TCastleUserInterfaceList); overload;

This item is declared in ancestor TCastleUserInterface.

This item has no description.

Source: ui/castleuicontrols_userinterface.inc (line 597).

Public procedure InsertControl(const Index: Integer; const NewItem: TCastleUserInterface);

This item is declared in ancestor TCastleUserInterface.

Add child control at specified position. It is usually easier to use InsertFront or InsertBack, if possible.

Source: ui/castleuicontrols_userinterface.inc (line 602).

Public procedure RemoveControl(const Item: TCastleUserInterface);

This item is declared in ancestor TCastleUserInterface.

Remove control added by InsertFront or InsertBack.

Note that this method does not free the Item instance. This method merely removes Item from our controls, so that Item is no longer rendered as part of this parent. It is still the caller's responsibility to make sure the Item is freed at some point.

See https://castle-engine.io/modern_pascal#_freeing_classes for description how to free instances in Pascal. As TCastleUserInterface descends from TComponent, a simple and proper solution is often just to create it with some "owner" (like TCastleView.FreeAtStop or Application) that will take care of freeing it.

Source: ui/castleuicontrols_userinterface.inc (line 617).

Public function IndexOfControl(const Item: TCastleUserInterface): Integer;

This item is declared in ancestor TCastleUserInterface.

Index of child control, or -1 if not present.

Source: ui/castleuicontrols_userinterface.inc (line 620).

Public procedure ClearControls;

This item is declared in ancestor TCastleUserInterface.

Remove all child controls added by InsertFront or InsertBack.

Note that, just like RemoveControl, this method does not free the children controls. This method merely removes children controls, so they are no longer rendered as part of the parent. It is still the caller's responsibility to make sure the children controls are freed at some point.

Source: ui/castleuicontrols_userinterface.inc (line 635).

Public procedure MoveToFront;

This item is declared in ancestor TCastleUserInterface.

Move to become the front-most control within the parent.

This works when this control is a child of another control (has Parent assigned) or when it's a direct child of the container (in which case Parent is not assigned by Container is, which means the control is directly on TCastleContainer.Controls list).

This is ignored if this control is not within any container (so, also not within any parent).

Source: ui/castleuicontrols_userinterface.inc (line 646).

Public function CapturesEventsAtPosition(const Position: TVector2): boolean; virtual;

This item is declared in ancestor TCastleUserInterface.

Does this control capture events under this container position. The default implementation simply checks whether Position is inside RenderRect. It also checks whether CapturesEvents is True.

Always treated like False when Exists returns False, so the implementation of this method only needs to make checks assuming that Exists = True.

Source: ui/castleuicontrols_userinterface.inc (line 660).

Public function TooltipExists: Boolean; virtual; deprecated 'use TooltipControl to customize tooltip look';

This item is declared in ancestor TCastleUserInterface.

Warning: this symbol is deprecated: use TooltipControl to customize tooltip look

Render a tooltip of this control. If you want to have tooltip for this control detected, you have to override TooltipExists. Then the TooltipRender will be called.

TooltipRender is called in the same way as Render. TooltipRender is always called as a last (front-most) control. Argument TooltipPosition is the left-bottom (in screen space, regardless of UIScaling) suggested position of the tooltip.

It is simplest to descend from TCastleUserInterfaceFont, that implements simple TCastleUserInterfaceFont.Tooltip property and overrides these two methods as necessary.

Source: ui/castleuicontrols_userinterface.inc (line 741).

Public procedure TooltipRender(const TooltipPosition: TVector2); virtual; deprecated 'use TooltipControl to customize tooltip look';

This item is declared in ancestor TCastleUserInterface.

Warning: this symbol is deprecated: use TooltipControl to customize tooltip look

This item has no description.

Source: ui/castleuicontrols_userinterface.inc (line 742).

Public procedure SetFocused(const Value: boolean); virtual;

This item is declared in ancestor TCastleUserInterface.

Called when this control becomes or stops being focused, that is: under the mouse cursor and will receive events.

This updates Focused property. This also calls OnInternalMouseEnter / OnInternalMouseLeave.

Source: ui/castleuicontrols_userinterface.inc (line 813).

Public function EffectiveRect: TFloatRectangle;

This item is declared in ancestor TCastleUserInterface.

Control position and size. Use this to base other controls size/position on this control's calculated size/position.

The algorithm that determines control position and size is like this:

When AutoSizeToChildren is True:
The control size is adjusted to children, to surround them. Left and Bottom and our anchors still matter, but our Width and Height do not matter. See the AutoSizeToChildren documentation for details.
Otherwise, when FullSize is True:
The control always fills the whole parent. If the control is added directly to the container, it will fill the whole container (TCastleWindow or TCastleControl).
Otherwise (when FullSize and AutoSizeToChildren are both False):
The position and size of the control is determined by the Left, Bottom, Width, Height properties.
Moreover, WidthFraction, if non-zero, specifies the control width as a fraction of the parent width. E.g. WidthFraction = 1.0 means that width equals parent, 0.5 means it's half the width of the parent etc. In this case the explicit Width is ignored.
Similarly you can use HeightFraction to express height as a fraction of parent. When HeightFraction is not zero, then the explicit Height is ignored.
If at least one of the resulting sizes is zero, the rectangle is empty (it is TFloatRectangle.Empty).

The above describes the size of the content and border, summed. The content itself may be a little smaller, when the Border is used. The size of the "content itself" is returned only by RenderRect (in already-scaled coordinates, i.e. using final device pixels).

The anchors (see Anchor) also affect the final position of the control.

Note that some descendants do auto-sizing by default. This means that some of these properties may be ignored, and instead the calculated size (EffectiveWidth, EffectiveHeight) depends on some core values of the control.

For example:

TCastleImageControl adjusts to image (unless you set TCastleImageControl.Stretch to True),
TCastleLabel adjusts to caption (unless you set TCastleLabel.AutoSize to False),
TCastleButton adjusts to caption and icon (unless you set TCastleButton.AutoSize to False),
TCastleVerticalGroup adjusts to children sizes,
... and so on.

Consult the documentation of each descendant for the exact specification of the size behavior.

This method returns the rectangle in local coordinates (relative to the parent 2D control). The returned rectangle size includes the border size. The returned rectangle size uses "unscaled" coordinates, which means that they correspond to the sizes you set e.g. in TCastleUserInterface.Width, TCastleUserInterface.Height, and translation units you use with e.g. TCastleUserInterface.Anchor.

If you're looking for a way to query the size of the control in final scaled coordinates (in real device pixels), and not relative to the parent position, use RenderRect or RenderRectWithBorder instead.

This method ignores the current value of the Exists method and Exists property, that is: the result of this function assumes that control does exist.

Parameters

ContainerPositionScaled: If True (default) then the container position (the ContainerPosition parameter) is assumed to be in final device pixels, i.e. the window area in X is from 0 to TCastleContainer.Width, in Y from 0 and TCastleContainer.Height. This is useful when the parameter comes e.g. from TInputPressRelease.Position.
If False then the container position (the ContainerPosition parameter) is assumed to be in unscaled device pixels, i.e. the window area in X is from 0 to TCastleContainer.UnscaledWidth, in Y from 0 and TCastleContainer.UnscaledHeight.

Source: ui/castleuicontrols_userinterface.inc (line 1003).

Public function LocalToContainerPosition(const LocalPosition: TVector2; const ContainerPositionScaled: Boolean = true): TVector2;

This item is declared in ancestor TCastleUserInterface.

Convert position relative to this UI control (in coordinates with UI scaling) into relative to container (in final device coordinates, without UI scaling, by default). Reverses ContainerToLocalPosition.

Parameters

ContainerPositionScaled: If True (default) then the container position (the result of this method) is assumed to be in final device pixels, i.e. the window area in X is from 0 to TCastleContainer.Width, in Y from 0 and TCastleContainer.Height.
If False then the container position (the result of this method) is assumed to be in unscaled device pixels, i.e. the window area in X is from 0 to TCastleContainer.UnscaledWidth, in Y from 0 and TCastleContainer.UnscaledHeight.

Source: ui/castleuicontrols_userinterface.inc (line 1022).

Public function ParentRect: TFloatRectangle;

This item is declared in ancestor TCastleUserInterface.

Rectangle filling the parent control (or container), in local coordinates. Since this is in local coordinates, the returned rectangle Left and Bottom are always zero, unless parent has Border (the returned rectangle is shrunk by Parent.Border). This is already scaled by UI scaling.

Source: ui/castleuicontrols_userinterface.inc (line 1030).

Public procedure Anchor(const AHorizontalAnchor: THorizontalPosition; const TranslationX: Single = 0); overload;

This item is declared in ancestor TCastleUserInterface.

Adjust position to align us with the parent horizontally. The resulting EffectiveRect and RenderRect and RenderRectWithBorder will immediately reflect the new position.

Note that position set here (anchors, Translation) are ignored when FullSize is set to true. In case of FullSize, the control fills the parent perfectly.

This utility method sets HorizontalAnchorSelf, HorizontalAnchorParent, Translation.X.

Source: ui/castleuicontrols_userinterface.inc (line 1042).

Public procedure Anchor( const AHorizontalAnchorSelf, AHorizontalAnchorParent: THorizontalPosition; const TranslationX: Single = 0); overload;

This item is declared in ancestor TCastleUserInterface.

Adjust position to align us with the parent horizontally. The resulting EffectiveRect and RenderRect and RenderRectWithBorder will immediately reflect the new position.

Note that position set here (anchors, Translation) are ignored when FullSize is set to true. In case of FullSize, the control fills the parent perfectly.

This utility method sets HorizontalAnchorSelf, HorizontalAnchorParent, Translation.X.

Source: ui/castleuicontrols_userinterface.inc (line 1055).

Public procedure Anchor(const AVerticalAnchor: TVerticalPosition; const TranslationY: Single = 0); overload;

This item is declared in ancestor TCastleUserInterface.

Adjust position to align us to the parent vertically. The resulting EffectiveRect and RenderRect and RenderRectWithBorder will immediately reflect the new position.

Note that position set here (anchors, Translation) are ignored when FullSize is set to true. In case of FullSize, the control fills the parent perfectly.

This utility method sets VerticalAnchorSelf, VerticalAnchorParent, Translation.Y.

Source: ui/castleuicontrols_userinterface.inc (line 1069).

Public procedure Anchor( const AVerticalAnchorSelf, AVerticalAnchorParent: TVerticalPosition; const TranslationY: Single = 0); overload;

This item is declared in ancestor TCastleUserInterface.

Adjust position to align us to the parent vertically. The resulting EffectiveRect and RenderRect and RenderRectWithBorder will immediately reflect the new position.

Note that position set here (anchors, Translation) are ignored when FullSize is set to true. In case of FullSize, the control fills the parent perfectly.

This utility method sets VerticalAnchorSelf, VerticalAnchorParent, Translation.Y.

Source: ui/castleuicontrols_userinterface.inc (line 1082).

Public procedure AlignHorizontal( const ControlPosition: TPositionRelative = prMiddle; const ContainerPosition: TPositionRelative = prMiddle; const X: Single = 0); deprecated 'use Anchor';

This item is declared in ancestor TCastleUserInterface.

Warning: this symbol is deprecated: use Anchor

Immediately position the control with respect to the parent by adjusting Left. Deprecated, use Align with THorizontalPosition.

Source: ui/castleuicontrols_userinterface.inc (line 1091).

Public procedure Align( const ControlPosition: THorizontalPosition; const ContainerPosition: THorizontalPosition; const X: Single = 0); overload; deprecated 'use Anchor';

This item is declared in ancestor TCastleUserInterface.

Warning: this symbol is deprecated: use Anchor

Immediately position the control with respect to the parent by adjusting Left.

Note that using Anchor is often more comfortable than this method, since you only need to set anchor once (for example, right after creating the control). In contrast, adjusting position using this method will typically need to be repeated at each window on resize, like in TCastleUserInterface.Resize.

Source: ui/castleuicontrols_userinterface.inc (line 1104).

Public procedure AlignVertical( const ControlPosition: TPositionRelative = prMiddle; const ContainerPosition: TPositionRelative = prMiddle; const Y: Single = 0); deprecated 'use Anchor';

This item is declared in ancestor TCastleUserInterface.

Warning: this symbol is deprecated: use Anchor

Immediately position the control with respect to the parent by adjusting Bottom. Deprecated, use Align with TVerticalPosition.

Source: ui/castleuicontrols_userinterface.inc (line 1112).

Public procedure Align( const ControlPosition: TVerticalPosition; const ContainerPosition: TVerticalPosition; const Y: Single = 0); overload; deprecated 'use Anchor';

This item is declared in ancestor TCastleUserInterface.

Warning: this symbol is deprecated: use Anchor

Immediately position the control with respect to the parent by adjusting Bottom.

Source: ui/castleuicontrols_userinterface.inc (line 1125).

Public procedure Center; deprecated 'use Anchor(hpMiddle); Anchor(vpMiddle); to reliably center the control';

This item is declared in ancestor TCastleUserInterface.

Warning: this symbol is deprecated: use Anchor(hpMiddle); Anchor(vpMiddle); to reliably center the control

Immediately center the control within the parent, both horizontally and vertically.

Note that using Anchor is often more comfortable than this method, since you only need to set anchor once. For example, right after creating the control call Anchor(hpMiddle); Anchor(vpMiddle);. In contrast, adjusting position using this method will typically need to be repeated at each window on resize, like in TCastleUserInterface.Resize.

Source: ui/castleuicontrols_userinterface.inc (line 1141).

Public function UIScale: Single; virtual;

This item is declared in ancestor TCastleUserInterface.

UI scale of this control, derived from container (see TCastleContainer.UIScaling and EnableUIScaling).

Source: ui/castleuicontrols_userinterface.inc (line 1145).

Public procedure EditorAllowResize(out ResizeWidth, ResizeHeight: Boolean; out Reason: String); virtual;

This item is declared in ancestor TCastleUserInterface.

Override this to prevent resizing some dimension in CGE editor.

Source: ui/castleuicontrols_userinterface.inc (line 1148).

Public function EffectiveFullSize: Boolean;

This item is declared in ancestor TCastleUserInterface.

Is the FullSize actually active. Checks FullSize and not AutoSizeToChildren, i.e. it accounts that AutoSizeToChildren overrides FullSize (since they cannot both work at the same time).

Source: ui/castleuicontrols_userinterface.inc (line 1254).

Public procedure AddScreenEffect(const Node: TAbstractChildNode);

This item is declared in ancestor TCastleScreenEffects.

Add or remove a ScreenEffect node that defines new shader screen effect. See https://castle-engine.io/x3d_extensions_screen_effects.php .

In the simple case, you can pass here an instance of TScreenEffectNode. In a general case, you can passs here any X3D node you want, just remember that only the TScreenEffectNode inside will be rendered. You can e.g. pass a TGroupNode with TScreenEffectNode and TTimeSensorNode as children, and use TTimeSensorNode to provide time to your shader uniform parameter. Or you can e.g. pass an X3D graph loaded from X3D file using X3DLoad.LoadNode, this way you can define effects inside an external X3D file, e.g. like this:

ScreenEffects.AddScreenEffect(
  LoadNode('castle-data:/screen_effects_scene.x3dv'));

If you're looking for inspirations what to put in screen_effects_scene.x3dv, see https://github.com/castle-engine/demo-models/tree/master/screen_effects . See also CGE example in "examples/screen_effects_demo/" directory ( https://github.com/castle-engine/castle-engine/tree/master/examples/screen_effects_demo ) that shows more screen effects code, and shows how to load or construct X3D node graph with ScreenEffect.

The memory management of the node added here is automatic: the added screen effect becomes owned by the internal X3D Group node. It's reference-count is increased at AddScreenEffect, and decreased at RemoveScreenEffect, and it is automatically freed when reference-count drops to zero.

This means that, if you create the provided Node by code, and don't add it anywhere else, then the node will be freed automatically at our destructor (if you call AddScreenEffect and do not call RemoveScreenEffect on it), or at RemoveScreenEffect call. If you don't want this, use TX3DNode.WaitForRelease to manage the node destruction yourself.

Note that the given Node should not be used by other TCastleScene instances. In general, a node should not be present in more than one TCastleScene instance, and we already insert the node into an internal TCastleScene instance. Use TX3DNode.DeepCopy if necessary to duplicate node into multiple scenes.

Note that you can enable/disable the effect using TScreenEffectNode.Enabled, or enable/disable all using ScreenEffectsEnable. You do not need to remove the node by RemoveScreenEffect if you only want to disable it temporarily.

Source: scene/castlescreeneffects.pas (line 183).

Public procedure RemoveScreenEffect(const Node: TAbstractChildNode);

This item is declared in ancestor TCastleScreenEffects.

This item has no description.

Source: scene/castlescreeneffects.pas (line 184).

Public procedure Render; override;

This item is declared in ancestor TCastleScreenEffects.

This item has no description. Showing description inherited from TCastleUserInterface.Render.

Render a control. Called only when Exists and render context is initialized.

Do not call this method. It will be automatically called by the engine when needed. It will be called when UI is part of TCastleContainer.Controls list or rendered (e.g. for off-screen rendering) by TCastleContainer.RenderControl.

You should only override this method.

See https://castle-engine.io/manual_2d_ui_custom_drawn.php for examples what you can put here.

You can depend on some OpenGL state being set before calling this method. You can depend on it being set, and you can carelessly change it. This state we set:

Viewport is set to include whole container.
Depth test is off.
For ancient fixed-function pipeline (see TGLFeatures.RequestCapabilities):
- The 2D orthographic projection is always set at the beginning. Useful for 2D controls.
- The modelview matrix is set to identity. The matrix mode is always modelview.
- The raster position is set to (0,0). The (deprecated) WindowPos is also set to (0,0).
- Texturing, lighting, fog is off.

Beware that GLSL RenderContext.CurrentProgram has undefined value when this is called. You should always set it, before making direct OpenGL drawing calls (all the engine drawing routines do it already, this is only a concern if you make direct OpenGL / OpenGLES calls).

Source: scene/castlescreeneffects.pas (line 187).

Public procedure RenderOverChildren; override;

This item is declared in ancestor TCastleScreenEffects.

This item has no description. Showing description inherited from TCastleUserInterface.RenderOverChildren.

Render a control contents over the children controls. This is analogous to Render, but it executes after children are drawn. You should usually prefer to override Render instead of this method, as the convention is that the parent is underneath children.

You should only override this method (do not call it, it will be called by the engine).

See https://castle-engine.io/manual_2d_ui_custom_drawn.php for examples what you can put here.

Source: scene/castlescreeneffects.pas (line 188).

Public procedure PrepareResources;

This item is declared in ancestor TCastleScreenEffects.

Make the screen effects rendering resources ready (e.g. link shaders).

Source: scene/castlescreeneffects.pas (line 209).

Protected function CalculateProjection: TProjection; virtual;

Calculate projection parameters. Determines if the view is perspective or orthogonal and exact field of view parameters. Called each time at the beginning of rendering.

The default implementation of this method in TCastleViewport calculates projection based on the Camera parameters.

In turn, the Camera parameters may be automatically calculated (if AutoCamera) based on the nodes in the TCastleRootTransform.MainScene. Nodes like TViewpointNode or TOrthoViewpointNode or TNavigationInfoNode determine the default camera and projection details.

You can override this method, or assign the OnProjection event to adjust the projection settings. But please note: instead of overriding this method, it's usually easier (and more advised) to simply change the Camera properties, like Camera.ProjectionType or Camera.Orthographic.Width or Camera.Perspective.FieldOfView.

Source: scene/castleviewport.pas (line 390).

Protected procedure InitializeGlobalLights(const GlobalLights: TLightInstancesList); virtual;

Prepare lights shining on everything. GlobalLights contents should be initialized here. The implementation in this class adds headlight determined by the Items.UseHeadlight value.

Source: scene/castleviewport.pas (line 396).

Protected procedure InitializeLights(const GlobalLights: TLightInstancesList); deprecated 'use InitializeGlobalLights';

Warning: this symbol is deprecated: use InitializeGlobalLights

This item has no description.

Source: scene/castleviewport.pas (line 398).

Protected procedure RenderFromViewEverything(const RenderingCamera: TRenderingCamera); virtual;

Render everything from given camera view (as TRenderingCamera). Given RenderingCamera.Target says to where we generate the image. This method must take care of making many rendering passes for shadow volumes, but doesn't take care of updating generated textures.

Source: scene/castleviewport.pas (line 404).

Protected procedure RenderFromView3D(const Params: TRenderParams); virtual;

Render the scene, assuming that buffers were already cleared and background was rendered. Called by RenderFromViewEverything at the end. Lights are calculated in Params at this point.

Source: scene/castleviewport.pas (line 409).

Protected procedure RenderOnePass(const Params: TRenderParams; const PassParams: TRenderOnePassParams); virtual;

Render one pass, with current camera and parameters. All current camera settings are saved in RenderParams.RenderingCamera.

Parameters

Params: Rendering parameters, see TRenderParams. TODO: move all relevant to TRenderOnePassParams.
PassParams: Rendering parameters of this pass, see TRenderOnePassParams.

Source: scene/castleviewport.pas (line 419).

Protected procedure Notification(AComponent: TComponent; Operation: TOperation); override;

This item has no description.

Source: scene/castleviewport.pas (line 422).

Protected function InternalExtraGetScreenEffects( const Index: Integer): TGLSLProgram; override;

This item has no description.

Source: scene/castleviewport.pas (line 424).

Protected function InternalExtraScreenEffectsCount: Integer; override;

This item has no description.

Source: scene/castleviewport.pas (line 426).

Protected function InternalExtraScreenEffectsNeedDepth: Boolean; override;

This item has no description.

Source: scene/castleviewport.pas (line 427).

Protected procedure PointingDevicePressFailed; virtual;

Called when PointingDevicePress was not handled by any TCastleTransform object. You can override this to make a message / sound signal to notify user that his Input_Interact click was not successful.

Source: scene/castleviewport.pas (line 432).

Protected procedure BoundNavigationInfoChanged; virtual;

This item has no description.

Source: scene/castleviewport.pas (line 434).

Protected procedure BoundViewpointChanged; virtual;

This item has no description.

Source: scene/castleviewport.pas (line 435).

Protected procedure RenderWithoutScreenEffects; override;

This item has no description. Showing description inherited from TCastleScreenEffects.RenderWithoutScreenEffects.

Descendants with special rendering code should override this, and never override Render or RenderOverChildren (as those two methods have special implementation in this class).

This rendering method will be called regardless if we have or not some screen effects. When no screen effects are actually used (e.g. AddScreenEffect wasn't used, InternalExtraScreenEffectsCount is zero), then our Render trivially calls this method without doing anything else.

Source: scene/castleviewport.pas (line 437).

Protected procedure Loaded; override;

This item has no description.

Source: scene/castleviewport.pas (line 439).

Public constructor Create(AOwner: TComponent); override;

This item has no description.

Source: scene/castleviewport.pas (line 493).

Public destructor Destroy; override;

This item has no description.

Source: scene/castleviewport.pas (line 494).

Public function AllowSuspendForInput: boolean; override;

This item has no description. Showing description inherited from TCastleUserInterface.AllowSuspendForInput.

Allow window containing this control to suspend waiting for user input. Typically you want to override this to return False when you do something in the overridden Update method.

In this class, this simply returns always True.

Source: scene/castleviewport.pas (line 496).

Public function Press(const Event: TInputPressRelease): boolean; override;

This item has no description. Showing description inherited from TCastleUserInterface.Press.

Override this method to react to user pressing a key, mouse button or mouse wheel. Return True if the event was handled, which prevents from passing this event to other UI controls.

When implementing in descendants it is best to override it like this:

function TMyControl.Press(const Event: TInputPressRelease): boolean;
begin
  Result := inherited;
  if Result then Exit; // exit if ancestor already handled this event

  if Event.IsKey(keyEnter) then
  begin
    // do something in reaction to Enter key
    ...
    // let engine know that this input event was handled
    Exit(true);
  end;

  if Event.IsMouseButton(buttonLeft) then
  begin
    // do something in reaction to left mouse button press
    ...
    // let engine know that this input event was handled
    Exit(true);
  end;
end;

These events are generated for all UI controls, whether they are considered "interactive" or not. These events are generated for non-interactive controls like TCastleRectangleControl or TCastleLabel as well. For example, these events ignore the TCastleButton.Enabled state, they are generated always (see https://github.com/castle-engine/castle-engine/issues/413 ). Use instead TCastleButton.OnClick to detect clicks on a button in a way that honors the TCastleButton.Enabled state.

When a control returns True from Press, it means it starts to "capture" subsequent mouse events: subsequent mouse moves and release will be send to this control even if mouse will move outside of this control.

The events Press and Release are passed to the parent only after the children had a chance to process this event. Overriding them makes sense if you draw something that "looks clickable" in TCastleUserInterface.Render, which is the standard place you should draw stuff. For example our TCastleButton draws there.

In contrast, the events PreviewPress and PreviewRelease are passed first to the parent control, before children have a chance to process this event. In partcular, overriding them makes sense if you draw something that "looks clickable" in TCastleUserInterface.RenderOverChildren.

Source: scene/castleviewport.pas (line 497).

Public function Release(const Event: TInputPressRelease): boolean; override;

This item has no description. Showing description inherited from TCastleUserInterface.Release.

Override this method to react to user releasing a key, mouse button. Return True if the event was handled, which prevents from passing this event to other UI controls.

This is counterpart to Press method. See Press for more details.

Note: We'd like this method to also be called when user releases a mouse wheel. But currently releasing of the mouse wheel is not reported now by any backend. Only releasing of keys and mouse buttons is reported.

Source: scene/castleviewport.pas (line 498).

Public function Motion(const Event: TInputMotion): boolean; override;

This item has no description. Showing description inherited from TCastleUserInterface.Motion.

Motion of mouse or touch.

Source: scene/castleviewport.pas (line 499).

Public procedure Update(const SecondsPassed: Single; var HandleInput: boolean); override;

This item has no description. Showing description inherited from TCastleUserInterface.Update.

Control may do here anything that must be continuously repeated. E.g. camera handles here falling down due to gravity, rotating model in Examine mode, and many more.

This method may be used, among many other things, to continuously react to the fact that user pressed some key (or mouse button). For example, if holding some key should move some 3D object, you should do something like:

if HandleInput then
begin
  if Container.Pressed[keyArrowRight] then
  begin
    Transform.Position := Transform.Position + Vector3(SecondsPassed * 10, 0, 0);
    HandleInput := false;
  end;
end;

Instead of directly using a key code, consider also using TInputShortcut that makes the input key nicely configurable. See engine tutorial about handling inputs.

Multiplying movement by SecondsPassed makes your operation frame-rate independent. Object will move by 10 units in a second, regardless of how many FPS your game has.

The code related to HandleInput is important if you write a generally-useful control that should nicely cooperate with all other controls, even when placed on top of them or under them. The correct approach is to only look at pressed keys/mouse buttons if HandleInput is True. Moreover, if you did check that HandleInput is True, and you did actually handle some keys, then you have to set HandleInput := false. This will prevent the other controls (behind the current control) from handling the keys (they will get HandleInput = False). And this is important to avoid doubly-processing the same key press, e.g. if two controls react to the same key, only the one on top should process it.

Note that to handle a single press / release (like "switch light on when pressing a key") you should rather use Press and Release methods. Use this method only for continuous handling (like "holding this key makes the light brighter and brighter").

To understand why such HandleInput approach is needed, realize that the "Update" events are called differently than simple mouse and key events like "Press" and "Release". "Press" and "Release" events return whether the event was somehow "handled", and the container passes them only to the controls under the mouse (decided by TCastleUserInterface.CapturesEventsAtPosition). And as soon as some control says it "handled" the event, other controls (even if under the mouse) will not receive the event.

This approach is not suitable for Update events. Some controls need to do the Update job all the time, regardless of whether the control is under the mouse and regardless of what other controls already did. So all controls (well, all controls that exist, in case of TCastleUserInterface, see TCastleUserInterface.Exists) receive Update calls.

So the "handled" status is passed through HandleInput. If a control is not under the mouse, it will receive HandleInput = False. If a control is under the mouse, it will receive HandleInput = True as long as no other control on top of it didn't already change it to False.

Source: scene/castleviewport.pas (line 500).

Public procedure BeforeRender; override;

This item has no description. Showing description inherited from TCastleUserInterface.BeforeRender.

Prepare your resources, right before drawing. Called only when Exists and GLInitialized.

Do not explicitly call this method. Instead, render controls by adding them to the TCastleContainer.Controls list, or render them explicitly (for off-screen rendering) by TCastleContainer.RenderControl.

Source: scene/castleviewport.pas (line 502).

Public function PropertySections(const PropertyName: String): TPropertySections; override;

This item has no description. Showing description inherited from TCastleComponent.PropertySections.

Section where to show property in the editor.

Source: scene/castleviewport.pas (line 503).

Public procedure CustomSerialization(const SerializationProcess: TSerializationProcess); override;

This item has no description. Showing description inherited from TCastleComponent.CustomSerialization.

Override this method to call various methods of SerializationProcess, which in turn allows to serialize/deserialize things that are not published. This allows to serialize/deserialize with more freedom, e.g. to serialize/deserialize some private field.

Source: scene/castleviewport.pas (line 504).

Public function GetMainScene: TCastleScene; deprecated 'use Items.MainScene';

Warning: this symbol is deprecated: use Items.MainScene

This item has no description.

Source: scene/castleviewport.pas (line 550).

Public procedure AssignDefaultCamera; virtual;

Set current camera vectors and projection, to best reflect current Items.MainScene or current Items bounding box.

If Items.MainScene is set and it has a preferred camera (TViewpointNode, which can be specified in X3D, glTF, Collada files) then it will be used. Otherwise we calculate camera using CameraViewpointForWholeScne to see the whole world.

This method only fills existing Camera with contents, it doesn't change the Camera to a new component. It will do nothing if Camera is Nil.

This is automatically used at first rendering if AutoCamera (deprecated, only sensible now if you make X3D browser that must react to X3D events changing viewpoint). You can also use it explicitly (this is recommended).

Source: scene/castleviewport.pas (line 580).

Public function ScreenSpaceAmbientOcclusionAvailable: boolean;

Does the graphic card support our ScreenSpaceAmbientOcclusion shader. This does not depend on the current state of ScreenSpaceAmbientOcclusion property. You can use it e.g. to disable the menu item to switch SSAO in 3D viewer.

Source: scene/castleviewport.pas (line 586).

Public function ScreenSpaceReflectionsAvailable: boolean;

Does the graphic card support our ScreenSpaceReflections shader. This does not depend on the current state of ScreenSpaceReflections property. You can use it e.g. to disable the menu item to switch SSR in 3D viewer.

Source: scene/castleviewport.pas (line 592).

Public procedure GLContextOpen; override;

This item has no description. Showing description inherited from TCastleUserInterface.GLContextOpen.

Initialize your OpenGL resources.

This is called when OpenGL context of the container is created, or when the control is added to the already existing context. In other words, this is the moment when you can initialize OpenGL resources, like display lists, VBOs, OpenGL texture names, etc.

As an exception, this is called regardless of the Exists value. This way a control can prepare it's resources, regardless if it exists now.

Source: scene/castleviewport.pas (line 594).

Public procedure GLContextClose; override;

This item has no description. Showing description inherited from TCastleUserInterface.GLContextClose.

Destroy your OpenGL resources.

Called when OpenGL context of the container is destroyed. Also called when controls is removed from the container Controls list. Also called from the destructor.

You should release here any resources that are tied to the OpenGL context. In particular, the ones created in GLContextOpen.

As an exception, this is called regardless of the Exists value. This way a control can release it's resources, regardless if it exists now.

Source: scene/castleviewport.pas (line 595).

Public function PrepareParams: TPrepareParams; deprecated 'use TCastleViewport.PrepareResources to prepare transforms';

Warning: this symbol is deprecated: use TCastleViewport.PrepareResources to prepare transforms

Parameters to prepare items that are to be rendered within this world. This should be passed to TCastleTransform.PrepareResources.

Note: Instead of using TCastleTransform.PrepareResources, and this method, it's usually easier to call TCastleViewport.PrepareResources. Then the appropriate TPrepareParams will be passed automatically.

Source: scene/castleviewport.pas (line 605).

Public function BaseLights: TLightInstancesList; deprecated 'this is internal info, you should not need this; use PrepareParams to get opaque information to pass to TCastleTransform.PrepareResources';

Warning: this symbol is deprecated: this is internal info, you should not need this; use PrepareParams to get opaque information to pass to TCastleTransform.PrepareResources

This item has no description.

Source: scene/castleviewport.pas (line 607).

Public function Statistics: TRenderStatistics;

Statistics about last rendering frame. See TRenderStatistics docs.

Source: scene/castleviewport.pas (line 610).

Public function TriangleHit: PTriangle;

Current 3D triangle under the mouse cursor. Updated in every mouse move. May be Nil.

Source: scene/castleviewport.pas (line 624).

Public procedure Setup2D;

Utility method to set camera to a suitable state for 2D games.

Sets both initial and current camera vectors like this:
- Position camera at (0, 0, 500),
- Looks along the -Z direction,
- "Up" vector is in +Y.
This way the 2D world spans horizontally in X and vertically in Y. The Z (depth) can be used to put things in front/behind each other.
Since this initialized the camera sensibly, we also set AutoCamera to false.
Sets orthographic projection for the camera (TCastleCamera.ProjectionType set to ptOrthographic).
By default our visible X range is [0..viewport width in pixels], visible Y range is [0..viewport height in pixels]. Use the properties of Camera.Orthographic to control the projection. For example set Camera.Orthographic.Width and/or Camera.Orthographic.Height to define visible projection size (horizontal or vertical) explicitly, regardless of the viewport size.
Setting Camera.Orthographic.Origin is also often useful, e.g. set it to (0.5,0.5) to make the things positioned at (0,0) in the world visible at the middle of the viewport.
By default our visible Z range is [-1500, 500], because this sets ProjectionNear to -1000, ProjectionFar to 1000, and camera default depth (Camera.Translation.Z) is 500. This was chosen to be comfortable for all cases – you can keep camera Z unchanged and comfortably position things around [-500, 500], or set camera Z to zero and then comfortably position things around [-1000, 1000].

Source: scene/castleviewport.pas (line 705).

Public function PositionToCameraPlane(const Position: TVector2; const ContainerCoordinates: Boolean; const Depth: Single; out PlanePosition: TVector3): Boolean;

Convert 2D position on the viewport into 3D "world coordinates", by colliding camera ray with a plane parallel to the viewport at given Depth. "World coordinates" are coordinates space seen by TCastleTransform / TCastleScene inside viewport Items. Use Depth > 0 for positions in front of the camera.

This is similar to "Unproject" GLU routine. It allows to map points from the 2D viewport back to the 3D space inside viewport.

The interpretation of Position depends on ContainerCoordinates:

When ContainerCoordinates = True, then Position is relative to the whole container (like TCastleWindow or TCastleControl).
And it is expressed in real device coordinates, just like TInputPressRelease.Position when mouse is being clicked, or like TInputMotion.Position when mouse is moved.
When ContainerCoordinates = False, then Position is relative to this UI control.
And it is expressed in coordinates after UI scaling. IOW, if the size of this control is Width = 100, then Position.X between 0 and 100 reflects the visible range of this control.

Returns true and sets 3D PlanePosition if such intersection is found. Returns false if it's not possible to determine such point (which should not be possible, unless camera field of view is larger than 180 degrees).

Source: scene/castleviewport.pas (line 742).

Public procedure PositionToRay(const Position: TVector2; const ContainerCoordinates: Boolean; out RayOrigin, RayDirection: TVector3);

Convert 2D position on the viewport into 3D ray.

The interpretation of Position depends on ContainerCoordinates:

When ContainerCoordinates = True, then Position is relative to the whole container (like TCastleWindow or TCastleControl).
And it is expressed in real device coordinates, just like TInputPressRelease.Position when mouse is being clicked, or like TInputMotion.Position when mouse is moved.
When ContainerCoordinates = False, then Position is relative to this UI control.
And it is expressed in coordinates after UI scaling. IOW, if the size of this control is Width = 100, then Position.X between 0 and 100 reflects the visible range of this control.

Source: scene/castleviewport.pas (line 770).

Public function PositionToWorldPlane(const Position: TVector2; const ContainerCoordinates: Boolean; const PlaneConstCoord: T3DAxis; const PlaneConstValue: Single; out PlanePosition: TVector3): Boolean; overload;

Convert 2D position on the viewport into 3D "world coordinates", by colliding camera ray with a plane at constant X, Y or Z. "World coordinates" are coordinates space seen by TCastleTransform / TCastleScene inside viewport Items.

This works with any projection (perspective or orthographic).

You can use it to pick a point on any plane with constant X (PlaneConstCoord = 0), constant Y (PlaneConstCoord = 1), constant Z (PlaneConstCoord = 2).

This intersects the ray cast by Camera with a plane where given coordinate (PlaneConstCoord) has value equal to PlaneConstValue. The parameter names and interpretation is consistent e.g. with TrySimplePlaneRayIntersection.

The interpretation of Position depends on ContainerCoordinates:

When ContainerCoordinates = True, then Position is relative to the whole container (like TCastleWindow or TCastleControl).
And it is expressed in real device coordinates, just like TInputPressRelease.Position when mouse is being clicked, or like TInputMotion.Position when mouse is moved.
When ContainerCoordinates = False, then Position is relative to this UI control.
And it is expressed in coordinates after UI scaling. IOW, if the size of this control is Width = 100, then Position.X between 0 and 100 reflects the visible range of this control.

Returns true and sets 3D PlanePosition (the PlaneConstCoord component of this vector must always be equal to PlaneConstValue) if such intersection is found. Returns false if it's not possible to determine such point (when the camera looks in the other direction).

Source: scene/castleviewport.pas (line 815).

Public function PositionToWorldPlane(const Position: TVector2; const ContainerCoordinates: Boolean; const PlaneConstValue: Single; out PlanePosition: TVector3): Boolean; overload; deprecated 'use PositionToWorldPlane overload with PlaneConstCoord parameter; this version assumes PlaneConstCoord = 2';

Warning: this symbol is deprecated: use PositionToWorldPlane overload with PlaneConstCoord parameter; this version assumes PlaneConstCoord = 2

This item has no description.

Source: scene/castleviewport.pas (line 820).

Public function PositionTo2DWorld(const Position: TVector2; const ContainerCoordinates: Boolean): TVector2;

Convert 2D position into "world coordinates", which is the coordinate space seen by TCastleTransform / TCastleScene inside viewport Items, assuming that we use orthographic projection in XY axes.

The interpretation of Position depends on ContainerCoordinates:

When ContainerCoordinates = True, then Position is relative to the whole container (like TCastleWindow or TCastleControl).
And it is expressed in real device coordinates, just like TInputPressRelease.Position when mouse is being clicked, or like TInputMotion.Position when mouse is moved.
When ContainerCoordinates = False, then Position is relative to this UI control.
And it is expressed in coordinates after UI scaling. IOW, if the size of this control is Width = 100, then Position.X between 0 and 100 reflects the visible range of this control.

This assumes that camera "up vector" is +Y, and it is looking along the negative Z axis. It also assumes orthographic projection (Camera.ProjectionType equal ptOrthographic). These are default camera direction, up and projection types set by Setup2D.

Source: scene/castleviewport.pas (line 857).

Public function PositionFrom2DWorld(const WorldPosition: TVector2; const ContainerCoordinates: Boolean): TVector2;

Invert PositionTo2DWorld, converting the "world coordinates" (the coordinate space seen by TCastleTransform / TCastleScene inside viewport Items) into final screen position.

Just like PositionTo2DWorld, this assumes that camera "up vector" is +Y, and it is looking along the negative Z axis. It also assumes orthographic projection (Camera.ProjectionType equal ptOrthographic). These are default camera direction, up and projection types set by Setup2D.

Source: scene/castleviewport.pas (line 870).

Public function PositionFromWorld(const WorldPosition: TVector3): TVector2;

Project 3D coordinates (the coordinate space seen by TCastleTransform / TCastleScene inside viewport Items) into 2D position on the viewport UI.

The resulting position is relative to this viewport control and it is expressed in coordinates after UI scaling. IOW, if the size of this control is EffectiveWidth = 100, then Position.X between 0 and 100 reflects the visible range of this control. This is like using ContainerCoordinates = False with PositionToRay.

Source: scene/castleviewport.pas (line 882).

Public procedure PrepareResources(const DisplayProgressTitle: string; const Options: TPrepareResourcesOptions = DefaultPrepareOptions); overload; deprecated 'use overload without DisplayProgressTitle: String';

Warning: this symbol is deprecated: use overload without DisplayProgressTitle: String

This item has no description.

Source: scene/castleviewport.pas (line 884).

Public procedure PrepareResources(const Item: TCastleTransform; const DisplayProgressTitle: string; Options: TPrepareResourcesOptions = DefaultPrepareOptions); overload; deprecated 'use overload without DisplayProgressTitle: String';

Warning: this symbol is deprecated: use overload without DisplayProgressTitle: String

This item has no description.

Source: scene/castleviewport.pas (line 887).

Public procedure PrepareResources( const Options: TPrepareResourcesOptions = DefaultPrepareOptions); overload;

Prepare resources, to make various methods (like Render) execute fast. Call it only when rendering context is initialized (ApplicationProperties.IsGLContextOpen).

Source: scene/castleviewport.pas (line 894).

Public procedure PrepareResources(const Item: TCastleTransform; Options: TPrepareResourcesOptions = DefaultPrepareOptions); overload; virtual;

This item has no description.

Source: scene/castleviewport.pas (line 896).

Public function TransformUnderMouse: TCastleTransform;

Current TCastleTransform pointed by the mouse cursor position. This is the first object being hit by the ray from camera through the mouse cursor position.

Automatically updated to always reflect the current mouse position. May be Nil if nothing is hit.

The "mouse cursor position" on touch devices is just the last touch point. When the navigation uses mouse look (like TCastleWalkNavigation.MouseLook), we automatically use viewport center as the "mouse cursor position".

Properties

Public property NonVisualComponents [const Index: Integer]: TComponent read GetNonVisualComponents;

This item is declared in ancestor TCastleComponent.

Components added by AddNonVisualComponent.

Source: base/castleclassutils.pas (line 698).

Public property IsLoading: Boolean read FIsLoading;

This item is declared in ancestor TCastleComponent.

Is the component during deserialization now.

Note: We can't use csLoading in ComponentState because in Delphi it is not possible to control it from CastleComponentSerialize.

Source: base/castleclassutils.pas (line 711).

Public property OnVisibleChange: TCastleUserInterfaceChangeEvent read FOnVisibleChange write FOnVisibleChange;

This item is declared in ancestor TCastleUserInterface.

Called always when something important inside this control (or it's children) changed. See VisibleChange for details about when and how this is called.

Be careful when handling this event. Various changes may cause this, so be prepared to handle it at any moment, even in the middle when UI control is changing. It may also occur very often. It's usually safest to only set a boolean flag like "something should be recalculated" when this event happens, and do the actual recalculation later.

Source: ui/castleuicontrols_userinterface.inc (line 524).

Public property Container: TCastleContainer read FContainer;

This item is declared in ancestor TCastleUserInterface.

Container of this control. When adding control to container's Controls list (like TCastleWindow.Controls) container will automatically set itself here, and when removing from container this will be changed back to Nil.

May be Nil if this control is not yet inserted into any container.

Source: ui/castleuicontrols_userinterface.inc (line 564).

Public property OnCursorChange: TNotifyEvent read FOnCursorChange write FOnCursorChange; deprecated 'use OnVisibleChange (or override VisibleChange) and watch for Changes that include chCursor';

This item is declared in ancestor TCastleUserInterface.

Warning: this symbol is deprecated: use OnVisibleChange (or override VisibleChange) and watch for Changes that include chCursor

Event called when the Cursor property changes. This event is, in normal circumstances, used by the Container, so you should not use it in your own programs.

Source: ui/castleuicontrols_userinterface.inc (line 570).

Public property ExclusiveEvents: boolean read FExclusiveEvents write FExclusiveEvents default true; deprecated 'do not use this; supporting this property was complicated and had no real benefit; everything now works as if ExclusiveEvents=true, always';

This item is declared in ancestor TCastleUserInterface.

Warning: this symbol is deprecated: do not use this; supporting this property was complicated and had no real benefit; everything now works as if ExclusiveEvents=true, always

Should we disable further mouse / keys handling for events that we already handled in this control. If True, then our events will return True for mouse and key events handled.

This means that events will not be simultaneously handled by both this control and some other (or camera or normal window callbacks), which is usually more sensible, but sometimes somewhat limiting.

Source: ui/castleuicontrols_userinterface.inc (line 582).

Public property Controls [const Index: Integer]: TCastleUserInterface read GetControls write SetControls;

This item is declared in ancestor TCastleUserInterface.

This item has no description.

Source: ui/castleuicontrols_userinterface.inc (line 586).

Public property GetExists: Boolean read FExists; deprecated 'use Exists';

This item is declared in ancestor TCastleUserInterface.

Warning: this symbol is deprecated: use Exists

This item has no description.

Source: ui/castleuicontrols_userinterface.inc (line 649).

Public property GLInitialized: boolean read FGLInitialized default false;

This item is declared in ancestor TCastleUserInterface.

This item has no description.

Source: ui/castleuicontrols_userinterface.inc (line 769).

Public property Focused: boolean read FFocused write SetFocused;

This item is declared in ancestor TCastleUserInterface.

See SetFocused.

Source: ui/castleuicontrols_userinterface.inc (line 816).

Public property Parent: TCastleUserInterface read FParent ;

This item is declared in ancestor TCastleUserInterface.

Visual parent control. This control is rendered within the parent, and it's anchors and coordinates are relative to the parent. Parent may be Nil, which means that the Container (if set) is our direct parent.

Note that this property doesn't have a setter, as it could be confusing: the order in which children are inserted into parent sometimes matters, for back-and-front order. If you want to change the parent, you can use code like this:

if Control.Parent <> nil then
  Control.Parent.RemoveControl(Control);
if NewParent <> nil then
  NewParent.InsertFront(Control); // or InsertBack, as InsertControl...

Source: ui/castleuicontrols_userinterface.inc (line 834).

Public property FloatWidth: Single read FWidth write SetWidth stored false; deprecated 'use Width';

This item is declared in ancestor TCastleUserInterface.

Warning: this symbol is deprecated: use Width

This item has no description.

Source: ui/castleuicontrols_userinterface.inc (line 1152).

Public property FloatHeight: Single read FHeight write SetHeight stored false; deprecated 'use Height';

This item is declared in ancestor TCastleUserInterface.

Warning: this symbol is deprecated: use Height

This item has no description.

Source: ui/castleuicontrols_userinterface.inc (line 1154).

Public property AnchorDelta: TVector2 read FTranslation write SetTranslation; deprecated 'use Translation';

This item is declared in ancestor TCastleUserInterface.

Warning: this symbol is deprecated: use Translation

Position of the control, relative to the anchor at parent (by default, relative to left-bottom corner of the parent).

Source: ui/castleuicontrols_userinterface.inc (line 1160).

Public property Translation: TVector2 read FTranslation write SetTranslation;

This item is declared in ancestor TCastleUserInterface.

Position of the control, relative to the anchor at parent (by default, relative to left-bottom corner of the parent).

Source: ui/castleuicontrols_userinterface.inc (line 1165).

Public property KeepInFront: boolean read FKeepInFront write FKeepInFront default false;

This item is declared in ancestor TCastleUserInterface.

Keep the control in front of other controls (with KeepInFront=False) when inserting.

TODO: Do not change this property while the control is already a child of something.

Source: ui/castleuicontrols_userinterface.inc (line 1172).

Public property BorderColor: TCastleColor read FBorderColor write SetBorderColor;

This item is declared in ancestor TCastleUserInterface.

Color of the Border, by default completely transparent black.

Source: ui/castleuicontrols_userinterface.inc (line 1176).

Public property HasHorizontalAnchor: boolean read FHasHorizontalAnchor write FHasHorizontalAnchor stored false; deprecated 'this property does not do anything anymore, anchors are always active';

This item is declared in ancestor TCastleUserInterface.

Warning: this symbol is deprecated: this property does not do anything anymore, anchors are always active

This item has no description.

Source: ui/castleuicontrols_userinterface.inc (line 1179).

Public property HasVerticalAnchor: boolean read FHasVerticalAnchor write FHasVerticalAnchor stored false; deprecated 'this property does not do anything anymore, anchors are always active';

This item is declared in ancestor TCastleUserInterface.

Warning: this symbol is deprecated: this property does not do anything anymore, anchors are always active

This item has no description.

Source: ui/castleuicontrols_userinterface.inc (line 1182).

Public property HorizontalAnchorDelta: Single read GetHorizontalAnchorDelta write SetHorizontalAnchorDelta default 0; deprecated 'use Translation.X';

This item is declared in ancestor TCastleUserInterface.

Warning: this symbol is deprecated: use Translation.X

Delta between our border and parent.

Castle Game Engine

API Reference

Class TCastleViewport

Unit

Declaration

Description

Hierarchy

Overview

Constants

Fields

Methods

Properties

Description

Constants

Fields

Methods

See also

See also

See also

See also

See also

See also

Parameters

Parameters

See also

See also

See also

Parameters

Parameters

Parameters

See also

Properties

See also

See also

See also

See also

See also

See also

See also

See also

See also

See also

See also

See also