Class TCastleScene

This item is declared in ancestor TCastleTransform.

This item has no description.

Source: transform/castletransform_transform.inc (line 626).

This item is declared in ancestor TCastleTransform.

This item has no description.

Source: transform/castletransform_transform.inc (line 627).

This item is declared in ancestor TCastleTransform.

This item has no description.

Source: transform/castletransform_transform.inc (line 633).

This item is declared in ancestor TCastleTransform.

Default TCastleCamera.Orientation.

Source: transform/castletransform_transform.inc (line 641).

This item is declared in ancestor TCastleSceneCore.

This item has no description.

Source: scene/castlescenecore.pas (line 960).

This item is declared in ancestor TCastleTransform.

Default value of TCastleTransform.Orientation for new TCastleTransform instances, except for cameras (cameras use special DefaultCameraOrientation).

This is otUpYDirectionZ by default. This matches glTF orientation (as exported from Blender and other software).

Source: transform/castletransform_transform.inc (line 649).

This item is declared in ancestor TCastleTransform.

Exclude this object's bounding volume from parent bounding volume.

This should be always False for non-debug scenes. Changing this may cause rendering artifacts, things could disappear when they should not. Using this is reasonable only if you attach a debug geometry to your scene, and you don't want to enlarge your bounding volume (e.g. because this debug geometry visualizes something determined by the bounding volume, and it would create a "feedback loop" if the visualization itself would enlarge the bounding box).

Source: transform/castletransform_transform.inc (line 699).

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

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.

See also

NonVisualComponentsCount

Count of components added by AddNonVisualComponent.

NonVisualComponents

Components added by AddNonVisualComponent.

NonVisualComponentsEnumerate

You can enumerate current non-visual components using loop like for C in MyComponent.NonVisualComponentsEnumerate do ....

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

This item is declared in ancestor TCastleComponent.

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

See also

NonVisualComponentsCount

Count of components added by AddNonVisualComponent.

NonVisualComponents

Components added by AddNonVisualComponent.

NonVisualComponentsEnumerate

You can enumerate current non-visual components using loop like for C in MyComponent.NonVisualComponentsEnumerate do ....

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

This item is declared in ancestor TCastleComponent.

Removes the component previously added by AddNonVisualComponent.

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

This item is declared in ancestor TCastleComponent.

Index of the previously added non-visual component. Returns -1 if the component was not found.

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

This item is declared in ancestor TCastleComponent.

Count of components added by AddNonVisualComponent.

See also

AddNonVisualComponent

Add non-visual component to this component.

NonVisualComponents

Components added by AddNonVisualComponent.

NonVisualComponentsEnumerate

You can enumerate current non-visual components using loop like for C in MyComponent.NonVisualComponentsEnumerate do ....

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

This item is declared in ancestor TCastleComponent.

You can enumerate current non-visual components using loop like for C in MyComponent.NonVisualComponentsEnumerate do .... Do not call this method in other contexts, it is only useful for "for..in" construction.

See also

AddNonVisualComponent

Add non-visual component to this component.

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

This item is declared in ancestor TCastleComponent.

Whether the current value of this object should be written to the stream. This should be True if anything inside this object should be serialized (which means it has non-default value or "stored" specifier indicates that it should be serialized).

This is used by CastleComponentSerialize, which is used in Castle Game Engine for all serialization.

In simple cases, this just says whether the current value of this object equals to some default value.

The default implementation of this class returns True (so always write).

Descendants that override this to sometimes return False (so no need to write) must be very careful: any addition of a new field requires extending this method, otherwise new field may not be saved sometimes (when all other fields are default). Descentants of such classes must also be aware of it. This check must include everything that is inside this object in JSON, including subcomponents and children objects (as done e.g. by TSerializationProcess.ReadWriteList). In practice, overriding this method is only reasonable for simple classes that will not change much in the future, like TCastleVector3Persistent.

The name of this method is consistent with TPropertyEditor.ValueIsStreamed in LCL.

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

This item is declared in ancestor TCastleComponent.

Override to add information that should be visible at design-time. Call SList.Add for each new line of information.

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

This item is declared in ancestor TCastleTransform.

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

Override to add warnings that should be visible at design-time. Call SList.Add for each new warning.

Source: transform/castletransform_transform.inc (line 713).

This item is declared in ancestor TCastleTransform.

This item has no description.

Source: transform/castletransform_transform.inc (line 714).

This item is declared in ancestor TCastleTransform.

Does the item really collide. Trivial shortcut for checking Collides and Exists.

Source: transform/castletransform_transform.inc (line 730).

This item is declared in ancestor TCastleTransform.

Warning: this symbol is deprecated: use CheckCollides

This item has no description.

Source: transform/castletransform_transform.inc (line 731).

This item is declared in ancestor TCastleTransform.

Is the item really pickable. Trivial shortcut for checking Pickable and Exists.

Source: transform/castletransform_transform.inc (line 734).

This item is declared in ancestor TCastleTransform.

Warning: this symbol is deprecated: use CheckPickable

This item has no description.

Source: transform/castletransform_transform.inc (line 735).

This item is declared in ancestor TCastleTransform.

Is the item really visible. Trivial shortcut for checking Visible and Exists.

Source: transform/castletransform_transform.inc (line 738).

This item is declared in ancestor TCastleTransform.

Warning: this symbol is deprecated: use CheckVisible

This item has no description.

Source: transform/castletransform_transform.inc (line 739).

This item is declared in ancestor TCastleTransform.

Add a child.

Note that adding the same child multiple times is allowed, in general you can use the same TCastleTransform instance multiple times in one hierarchy of TCastleRootTransform.

Source: transform/castletransform_transform.inc (line 746).

This item is declared in ancestor TCastleTransform.

Insert a child at a specific position on the children list.

Note: Usually the order of children doesn't matter, so you can as well add children at the end, using Add.

In particular, when rendering opaque (3D or 2D) objects, the front/back is decided by the actual translation of the object, i.e. what is closer to the camera. (In a typical 2D setup, larger Z values mean "closer to the camera".) The position on the children list doesn't matter in this case.

When rendering with blending, we recommend to use TCastleViewport.BlendingSort to automatically use proper order when rendering partially-transparent objects. This will mean that the order of children really doesn't matter.

However, the position matters in case of blending, if you set TCastleViewport.BlendingSort to sortNone. See https://castle-engine.io/blending . For correct blending, when you have multiple partially-transparent scenes, the partially-transparent objects must be sorted from back to front on the list. So you should add them in the proper order, or insert on proper positions.

Source: transform/castletransform_transform.inc (line 770).

This item is declared in ancestor TCastleTransform.

Remove a child.

Adding and removing from the TCastleTransform hierarchy is guaranteed to be fast, so you can do it even in the middle of the game. In particular calling Remove doesn't free rendering reasources of the removed scene, So e.g. removing scene only to add it later to another TCastleViewport.Items is fast.

Note that removing the child Item does not free the Item. It merely makes the Item no longer be a child of this TCastleTransform, so it will no longer be shown in the viewport. If you want to free the item instance, you have to do it explicitly, by Item.Free or FreeAndNil(Item). Freed items are automatically removed from parent. See also What is the difference between Owner and Parent in CGE?.

Source: transform/castletransform_transform.inc (line 789).

This item is declared in ancestor TCastleTransform.

Use this to remove (and possibly free) the child, but not immediately.

The actual removal (and freeing, if FreeItem) will be done at some crucial points:

• Right before we render children.

• Right before we loop over children in the Update method.

• Right after we loop over children in the Update method.

• From our destructor.

This allows to use this method safely even in the middle of iteration over TCastleTransform children. For example you can use it from Update method, from any TCastleTransform.Update or TCastleUserInterface.Update (including TCastleView.Update).

Note: It is not a problem if the child scheduled to be removed will also be removed (or even freed) directly e.g. by just calling Free on it. We ignore removal of items that are no longer our children, and we automatically remove the child from "pending to remove" list if it is freed. You only need to be careful in case you add the same TCastleTransform instance multiple times to the same parent (see https://castle-engine.io/viewport_and_scenes_from_code#_multiple_instances_of_the_same_scene ) as then each removal removes one instance (not all) of the child from parent.

Note: When you want to free the Item (that is, FreeItem parameter is True) then it actually doesn't matter on what parent will you call this. Freeing the Item will always remove it from all parents.

Source: transform/castletransform_transform.inc (line 819).

This item is declared in ancestor TCastleTransform.

Remove a child, by index on the Items list.

Source: transform/castletransform_transform.inc (line 822).

This item is declared in ancestor TCastleTransform.

Count of current children, to iterate over Items from 0 to Count-1.

Source: transform/castletransform_transform.inc (line 828).

This item is declared in ancestor TCastleTransform.

Remove all children TCastleTransform instances.

Note that removing the children using this method, just like using Remove, does not free the children. It merely makes the children no longer be inside this TCastleTransform, so they will no longer be shown in the viewport. If you want to free the children, you have to do it explicitly, calling Item.Free or FreeAndNil(Item) for each child. Freed items are automatically removed from parent. See also What is the difference between Owner and Parent in CGE?.

Source: transform/castletransform_transform.inc (line 842).

This item is declared in ancestor TCastleTransform.

Exchange position of 2 children TCastleTransform instances.

Source: transform/castletransform_transform.inc (line 845).

This item is declared in ancestor TCastleTransform.

Bounding box of this object, in the coordinate system of the parent transformation. This method takes into account current transformation (like Translation, Rotation) but not parent TCastleTransform transformations. Use WorldBoundingBox instead to know bounding box that accounts for all TCastleTransform transformations. Use LocalBoundingBox instead to know bounding box that does not account for any parent or this TCastleTransform transformations.

Takes into account both collidable and visible objects. For example, invisible walls (not visible) and fake walls (not collidable) should all be accounted here.

It's a bounding volume, it should be as large as necessary to include the object inside. At the same time, it should be as "tight" as it can, to make various optimizations work best.

See also

WorldBoundingBox

Bounding box of this object, taking into account all transformations of this and parents.

LocalBoundingBox

Bounding box of this object, ignoring the transformations of this scene and parents.

Source: transform/castletransform_transform.inc (line 914).

This item is declared in ancestor TCastleTransform.

Bounding box of this object, taking into account all transformations of this and parents.

See also

BoundingBox

Bounding box of this object, in the coordinate system of the parent transformation.

LocalBoundingBox

Bounding box of this object, ignoring the transformations of this scene and parents.

Source: transform/castletransform_transform.inc (line 927).

This item is declared in ancestor TCastleTransform.

Render given object. Should check and immediately exit when CheckVisible is False.

The rendering transformation, frustum, and filtering is specified inside TRenderParams class. This method should only update TRenderParams.Statistics.

Source: transform/castletransform_transform.inc (line 935).

This item is declared in ancestor TCastleTransform.

Warning: this symbol is deprecated: use Render method without an explicit Frustum parameter, it is in Params.Frustum now

This item has no description.

Source: transform/castletransform_transform.inc (line 937).

This item is declared in ancestor TCastleTransform.

Render shadow quads for all the things rendered by Render. This is done only if Exists and CastShadows.

It does shadow volumes culling inside (so ShadowVolumeRenderer should have FrustumCullingInit already initialized).

Params.Transformation describe the transformation, just like for Render.

Source: transform/castletransform_transform.inc (line 954).

This item is declared in ancestor TCastleTransform.

Called on update. Update listeners fire after all behaviors have been processed.

Source: transform/castletransform_transform.inc (line 1100).

This item is declared in ancestor TCastleTransform.

This item has no description.

Source: transform/castletransform_transform.inc (line 1101).

This item is declared in ancestor TCastleTransform.

Something visible changed inside this object. This is usually called by implementation of this object, to notify others that it changed.

Changes is a set describing what changes occurred. See TVisibleChange docs for more information. It must specify all things that possibly changed.

Changes can be [], meaning "something tells us to redraw, but no visible change happened yet, maybe something will happen during a redraw" (this is used when e.g. possibly LOD level changed). We still increase TCastleAbstractRootTransform.InternalVisibleStateId even when Changes=[].

The information about visibility changed is passed to TCastleAbstractRootTransform in World. It increases TCastleAbstractRootTransform.InternalVisibleStateId, TCastleAbstractRootTransform.InternalVisibleGeometryStateId, TCastleAbstractRootTransform.InternalVisibleNonGeometryStateId. If you want to react to visibility changes, you should not override this method, instead watch above "state id" variables and react when they change.

Source: transform/castletransform_transform.inc (line 1125).

This item is declared in ancestor TCastleTransform.

Middle point, usually "eye point", of the 3D model. This is used for sphere center (if CollisionSphereRadius is non-zero or Sphere returns True) and is the central point from which collisions of this object are checked (Move, MoveAllowed, Height, LineOfSight). It's useful for dynamic objects like player and moving creatures, which rely on MoveAllowed and gravity.

In short, it's usually most comfortable to think about this as a position of the eye, or the middle of the creature's head.

In an ideal situation, it should not be based on anything dynamic. For example, when this is based on the current bounding box of the animation, there is a risk that a large and sudden change in animation box could make the Middle point to jump to the other side of the wall (breaking collisions, as it changes Middle without a chance to check for collisions by MoveAllowed). Ideally, it should remain constant even when the shape of the object changes, and be possible to change only when MoveAllowed is checked (so only when TCastleTransform.Translation can change).

In this class this returns something sensible above the bottom of the box. See TCastleTransform.MiddleHeight.

This is expressed in the parent coordinate system (so it is close to the Translation value, but moved up, following GravityUp). So use Transform.Parent.LocalToWorld(Transform.Middle) to convert this to world coordinates.

Source: transform/castletransform_transform.inc (line 1168).

This item is declared in ancestor TCastleTransform.

Our Middle, in world coordinates.

Source: transform/castletransform_transform.inc (line 1174).

This item is declared in ancestor TCastleTransform.

Can the approximate sphere (around Middle point) be used for some collision-detection tasks. If True then Radius (and Middle point) determine the approximate sphere surrounding the 3D object (it does not have to be a perfect bounding sphere around the object), and it may be used for some collisions instead of BoundingBox. See CollidesWithMoving and MoveAllowed for when it may happen.

Just like Middle and CollisionSphereRadius, this is expressed in the parent coordinate system.

Must return False when not Exists (because we can't express "empty sphere" by Sphere method for now, but BoundingBox can express TBox3D.Empty).

By default, in TCastleTransform class, this returns True if CollisionSphereRadius is non-zero.

The advantages of using a sphere, that does not have to be a perfect bounding sphere (it may be smaller than necessary, and only account e.g. for upper body part of the creature), are:

• It can have constant radius, even though the actual creature animates. This allows us to perfectly, reliably guarantee that sphere absolutely never collides with level and such.

  In case of a tight bounding volume (box or sphere) that animates, this guarantee is not really possible. Simply increasing time changes the animation to the next frame, which may be slightly larger in one dimension because e.g. creature moves a hand in this direction. This means that simply increasing time may change the non-collidable creature into a collidable one, if creature stands close to a wall/other creature and such. And we cannot simply stop/reverse an arbitrary animation at an arbitrary time (to avoid collision), this would look weird for some animations and would require some additional work at preparing animations and designing AI (as then "every action can be interrupted").

  Also using a bounding volume large enough to account for all possible positions is not doable, as it would be too large. Consider that for humanoid creatures, walking animation usually has tall and thin bounding box (creature stands) but dead/lying animation usually has flat and wide bounding box.

  So, only a bounding volume (like a sphere) that may be smaller than bounding volume can remain constant and easily guarantee the assertion "it never collides".

  This means that using such sphere results in simpler collision detection routines, as they may assume that collision doesn't occur. In contrast, detection routines looking at our (possibly animated) BoundingBox must take into account that collision may already be happening, and they must incorporate code to allow creatures/players to "get unstruck".

• Using smaller sphere also allows to naturally ascend the stairs and upward slopes. Sphere can move forward slightly, and then creature may raise up, to reach it's preferred height. Then sphere can move further forward, and so on. This alllows to allow stair climbing for creatures without any extra effort in the code.

  The downside is that creature legs will temporarily "sink into the floor" when climbing up the stairs. But it's not noticeable if "growing up" mechanism works fast enough.

Sphere disadvantage:

• Sphere is far from perfect as a bounding volume — it's too small, sometimes also too large, sometimes both at the same time...

  Since the Sphere radius remains always the same, it must be good for many creature animation frames. In cases where the sphere isn't suitable, and you don't need advantages above — you can make Sphere return False. E.g. a dead creature may be stuck in a wall, and it doesn't have to climb stairs. So you don't really need sphere advantages listed above, and Sphere may return False when creature is in dying state.

  But still it may be a problem sometimes, if some creature states have entirely different animations and bounding boxes. Then you will be forced to choose one universal Radius for all creature states. And you need constant radius to keep the advantage above of "guarantee".

  1. Obviously you can't set radius too small, because if it's much smaller than actual creature's geometry then the creature will noticeably collide with level geometry and other creatures.

  2. On the other hand, you can't set radius too large (or move sphere center, Middle, much lower). This would block stair climbing.

Source: transform/castletransform_transform.inc (line 1271).

This item is declared in ancestor TCastleTransform.

Get height of my point above the rest of the world.

The given MyPosition, and returned AboveHeight, are in the parent coordinate system of this TCastleTransform. So for example query like this works naturally: MyTransform.Height(MyTransform.Translation, ...).

This ignores the geometry of this 3D object (to not accidentally collide with your own geometry), and checks collisions with the rest of the world.

Source: transform/castletransform_transform.inc (line 1296).

This item is declared in ancestor TCastleTransform.

This item has no description.

Source: transform/castletransform_transform.inc (line 1298).

This item is declared in ancestor TCastleTransform.

Whether there is line of sight (the line segment does not collide with anything opaque) between these 2 points.

The given Pos1, Pos2 are in the parent coordinate system of this TCastleTransform. So for example query like this works naturally: MyTransform.LineOfSight(MyTransform.Translation, MyTransform.Translation + MyTransform.Direction * 10).

This ignores the geometry of this 3D object (to not accidentally collide with your own geometry), and checks collisions with the rest of the world.

Source: transform/castletransform_transform.inc (line 1312).

This item is declared in ancestor TCastleTransform.

Is the move from OldPos to ProposedNewPos possible for this object. Returns true and sets NewPos if some move is allowed.

The NewPos may be different than ProposedNewPos, which allows to perform wall-sliding. Wall sliding will only work if collision sphere is defined, which should be configured by setting CollisionSphereRadius to something non-zero. Otherwise, the move uses only box collisions, and wall sliding doesn't happen.

When checking collisions, it avoids colliding with itself, so it only checks collisions with the rest of the world (things outside of this TCastleTransform).

The given OldPos, ProposedNewPos, NewPos are in the parent coordinate system of this TCastleTransform. Intuitively, you are asking "Can I change Translation from OldPos to NewPos". So this method is consistent with Move, Translate.

Source: transform/castletransform_transform.inc (line 1331).

This item is declared in ancestor TCastleTransform.

Is the move from OldPos to NewPos possible for this object.

This overloaded version of MoveAllowed doesn't do wall-sliding (use the version with ProposedNewPos for wall-sliding).

If this object allows to use sphere for collisions (see CollisionSphereRadius and Sphere) then sphere will be used. Otherwise, it will collide as a bounding box.

When checking collisions, it avoids colliding with itself, so it only checks collisions with the rest of the world (things outside of this TCastleTransform).

The given OldPos, NewPos are in the parent coordinate system of this TCastleTransform. Intuitively, you are asking "Can I change Translation from OldPos to NewPos". So this method is consistent with Move, Translate.

Source: transform/castletransform_transform.inc (line 1352).

This item is declared in ancestor TCastleTransform.

Cast a ray, see what is hit (checks the whole world, not just this TCastleTransform hierarchy).

The given RayOrigin, RayDirection are in the parent coordinate system of this TCastleTransform. So for example query like this works naturally: MyTransform.Ray(MyTransform.Translation, MyTransform.Direction).

This ignores the geometry of this object (to not accidentally collide with your own geometry), and checks collisions with the rest of the world.

Source: transform/castletransform_transform.inc (line 1368).

This item is declared in ancestor TCastleTransform.

Cast a ray, see what is hit (checks the whole world, not just this TCastleTransform hierarchy).

The given RayOrigin, RayDirection are in the parent coordinate system of this TCastleTransform. So for example query like this works naturally: MyTransform.RayCast(MyTransform.Translation, MyTransform.Direction). In case of the overloaded version with Distance parameter, the Distance is consistently in the same, parent coordinate system.

This ignores the geometry of this object (to not accidentally collide with your own geometry), and checks collisions with the rest of the world.

This returns the TCastleTransform that is hit (this is the "leaf" TCastleTransform in the TCastleTransform tree that is hit) and a distance from RayOrigin to the hit point. Returns Nil (Distance is undefined in this case) if nothing was hit. Use Ray for a more advanced version of this, with more complicated result.

Source: transform/castletransform_transform.inc (line 1388).

This item is declared in ancestor TCastleTransform.

This item has no description.

Source: transform/castletransform_transform.inc (line 1390).

This item is declared in ancestor TCastleTransform.

Convert position between local and outside coordinate system. This is called OutsideToLocal, not WorldToLocal, because it only handles transformation defined in this item — it does not recursively apply all transform on the way to root.

Source: transform/castletransform_transform.inc (line 1398).

This item is declared in ancestor TCastleTransform.

This item has no description.

Source: transform/castletransform_transform.inc (line 1399).

This item is declared in ancestor TCastleTransform.

Convert position between local and world coordinate system. This applies all the transformations on the way to root, so it looks at this object as well as all parents' transformations.

Source: transform/castletransform_transform.inc (line 1406).

This item is declared in ancestor TCastleTransform.

This item has no description.

Source: transform/castletransform_transform.inc (line 1407).

This item is declared in ancestor TCastleTransform.

Convert direction between local and world coordinate system. This applies all the transformations on the way to root, so it looks at this object as well as all parents' transformations.

Source: transform/castletransform_transform.inc (line 1414).

This item is declared in ancestor TCastleTransform.

This item has no description.

Source: transform/castletransform_transform.inc (line 1415).

This item is declared in ancestor TCastleTransform.

Convert distance, like sphere radius, between local and world coordinate system. This applies all the scaling on the way to root, so it looks at this object as well as all parents' transformations.

Source: transform/castletransform_transform.inc (line 1422).

This item is declared in ancestor TCastleTransform.

This item has no description.

Source: transform/castletransform_transform.inc (line 1423).

This item is declared in ancestor TCastleTransform.

Warning: this symbol is deprecated: use physics (TCastleRigidBody, TCastleCollider) to make things affected by gravity

The preferred height of the object Middle above the ground, when the object is standing on the ground firmly. This is used by objects affected by gravity (like non-flying creatures and items) to know how far they should fall down or grow up.

The default implementation in this class looks at MiddleHeight property, see the algorithm described there. This may be dynamic (may change during creature lifetime, so you can make the creature duck or grow if you want).

Source: transform/castletransform_transform.inc (line 1467).

This item is declared in ancestor TCastleTransform.

Transformation (from local to outside) as a matrix. This matrix represents a concise version of properties like Translation, Rotation, Scale. It does not take into account the transformation of parent TCastleTransform (for this, use WorldTransform).

Source: transform/castletransform_transform.inc (line 1523).

This item is declared in ancestor TCastleTransform.

Inverse transformation as a matrix, thus transforming from outside to local coordinate system. This is an inverse of Transform.

Source: transform/castletransform_transform.inc (line 1527).

This item is declared in ancestor TCastleTransform.

All conditions are satisfied to have WorldTransform. When this returns True, you know that WorldTransform and WorldInverseTransform will not raise ETransformParentUndefined.

Source: transform/castletransform_transform.inc (line 1532).

This item is declared in ancestor TCastleTransform.

Transformation (from local to world) as a matrix. This accumulates the transformation of this instance (derived from properties like Translation, Rotation, Scale) with the transformation of parent TCastleTransform instances, all the way up to and including the root transformation (TCastleAbstractRootTransform). Thus, this is a transformation to the world known to the TCastleViewport instance.

Two conditions are necessary to make this available:

• This instance must be part of some World. So it must be added to Viewport.Items, or to some other TCastleTransform that is part of World.

  Otherwise reading this raises ENotAddedToWorld.

• This instance must not be present multiple times inside the World. Ever (even in the past).

  In general, it is allowed to have multiple references to the same TCastleTransform within the same World. So you can add the same TCastleTransform or TCastleScene many times to Viewport.Items. This is a useful optimization (sharing), and is explicitly allowed. But if you do this — you cannot rely on WorldTransform property.

  Otherwise reading this raises EMultipleReferencesInWorld or ETransformParentUndefined.

You can check HasWorldTransform before calling this method, to avoid catching an exception.

Note that the WorldTransform is not updated in Update, it is smartly updated on-demand. So you do not have to wait for Update or other method to be called before accessing the WorldTransform.

Exceptions raised

ENotAddedToWorld

When this instance is not yet part of World.

EMultipleReferencesInWorld

When this instance is added multiple times to World.

ETransformParentUndefined

When this instance was once added multiple times to World, or for some other reason cannot be calculated. This is an ancestor of ENotAddedToWorld and EMultipleReferencesInWorld too.

Source: transform/castletransform_transform.inc (line 1588).

This item is declared in ancestor TCastleTransform.

Inverse transformation of WorldTransform, thus transforming from world to local coordinate system.

See WorldTransform for more details how this works.

Exceptions raised

ENotAddedToWorld

When this instance is not yet part of World.

EMultipleReferencesInWorld

When this instance is added multiple times to World.

EMultipleReferencesInWorld

When this instance was once added multiple times to World, or for some other reason cannot be calculated. This is an ancestor of ENotAddedToWorld and EMultipleReferencesInWorld too.

Source: transform/castletransform_transform.inc (line 1605).

This item is declared in ancestor TCastleTransform.

Unconditionally move this object by a given vector.

To move and check collisions, use Move instead of this method.

The provided TranslationChange should be a direction in the parent coordinate system of this TCastleTransform. Using this routine is exactly equivalent to Translation := Translation + TranslationChange.

Source: transform/castletransform_transform.inc (line 1615).

This item is declared in ancestor TCastleTransform.

Move, if possible (checking collisions with other objects in world). This is the simplest way to move an object, and a basic building block for artificial intelligence of creatures.

Checks move possibility by MoveAllowed, using Middle point. Actual move is done using Translate.

Note that wall sliding will only work if collision sphere is defined, which should be configured by setting CollisionSphereRadius to something non-zero. Otherwise, the move uses only box collisions, and wall sliding doesn't happen.

The provided TranslationChange should be a direction in the parent coordinate system of this TCastleTransform, so using this routine is consistent with doing Translation := Translation + TranslationChange however this checks collisions.

Source: transform/castletransform_transform.inc (line 1633).

This item is declared in ancestor TCastleTransform.

Make the transform do nothing — zero Translation, zero Rotation, Scale to one. Also resets ScaleOrientation and Center.

Source: transform/castletransform_transform.inc (line 1759).

This item is declared in ancestor TCastleTransform.

Get at once vectors: position, direction, up.

Just like Translation and Rotation, these vectors reflect the transformation defined locally in this TCastleTransform, disregarding the parent transformations. Use GetWorldView to account for parent transformations.

Source: transform/castletransform_transform.inc (line 1896).

This item is declared in ancestor TCastleTransform.

Get position, direction, up. Similar to GetView, but in world coordinates.

Returned ADir and AUp are always orthogonal. Returned ADir and AUp are always normalized.

Source: transform/castletransform_transform.inc (line 1902).

This item is declared in ancestor TCastleTransform.

Get position in world coordinates.

The returned position is the same as by GetWorldView. This method just doesn't calculation anything else, thus it is faster than GetWorldView if you don't need direction/up.

Source: transform/castletransform_transform.inc (line 1923).

This item is declared in ancestor TCastleTransform.

Set at once vectors: position, direction, up.

ADir and AUp given here do not have to be normalized (they will be normalized if needed). They will be automatically fixed to be orthogonal, if necessary: when AdjustUp = True (the default) we will adjust the up vector (preserving the given direction value), otherwise we will adjust the direction (preserving the given up value).

Just like Translation and Rotation, these vectors reflect the transformation defined locally in this TCastleTransform, disregarding the parent transformations. Use SetWorldView to account for parent transformations.

Source: transform/castletransform_transform.inc (line 1938).

This item is declared in ancestor TCastleTransform.

This item has no description.

Source: transform/castletransform_transform.inc (line 1940).

This item is declared in ancestor TCastleTransform.

Set position, direction, up. Similar to SetView, but in world coordinates.

Given ADir, AUp do not have to be normalized, we will normalize them internally if necessary. But make sure they are non-zero.

We will automatically fix ADir and AUp to be orthogonal, if necessary: when AdjustUp = True (the default) we will adjust the up vector (preserving the given direction value), otherwise we will adjust the direction (preserving the given up value).

Source: transform/castletransform_transform.inc (line 1953).

This item is declared in ancestor TCastleTransform.

Change up vector, keeping the direction unchanged. If necessary, the up vector provided here will be fixed to be orthogonal to direction.

This is similar to assigning Up vector using it's property setter, but different behavior happens when we need to fix vectors to have direction orthogonal to up (which must be always true). In case of assigning Up by property setter, the Direction vector is changed (if necessary, to be orthogonal to up). In case of this method, the up vector is changed (if necessary, to be orthogonal to direction).

It's good to use this if you have a preferred up vector for creatures, but still preserving the direction vector has the highest priority.

Source: transform/castletransform_transform.inc (line 1970).

This item is declared in ancestor TCastleTransform.

Add a TCastleBehavior to this TCastleTransform. In effect, the virtual methods of TCastleBehavior, like TCastleBehavior.Update, will be automatically called. Also the TCastleBehavior.Parent gets assigned.

If the given Behavior was part of another TCastleTransform, it is removed from it. If the given Behavior was already part of this TCastleTransform, nothing happens (note: we do not move the behavior to the end of the list).

See also

FindBehavior

Find the first behavior of the given class, Nil if none.

BehaviorsEnumerate

You can enumerate current behaviors using loop like for B in MyTransform.BehaviorsEnumerate do ....

Source: transform/castletransform_transform.inc (line 2016).

This item is declared in ancestor TCastleTransform.

Insert a TCastleBehavior to this TCastleTransform at a specified index. In effect, the virtual methods of TCastleBehavior, like TCastleBehavior.Update, will be automatically called. Also the TCastleBehavior.Parent gets assigned.

If the given Behavior was part of another TCastleTransform, it is removed from it. If the given Behavior was already part of this TCastleTransform, nothing happens (note: we do not move the behavior to the new index).

See also

FindBehavior

Find the first behavior of the given class, Nil if none.

BehaviorsEnumerate

You can enumerate current behaviors using loop like for B in MyTransform.BehaviorsEnumerate do ....

Source: transform/castletransform_transform.inc (line 2030).

This item is declared in ancestor TCastleTransform.

Returns the behavior index, -1 means not found.

Source: transform/castletransform_transform.inc (line 2033).

This item is declared in ancestor TCastleTransform.

Remove TCastleBehavior from this TCastleTransform. In effect, the virtual methods of TCastleBehavior, like TCastleBehavior.Update, will no longer be automatically called. The TCastleBehavior.Parent is set to Nil.

Source: transform/castletransform_transform.inc (line 2039).

This item is declared in ancestor TCastleTransform.

Find the first behavior of the given class, Nil if none.

Source: transform/castletransform_transform.inc (line 2042).

This item is declared in ancestor TCastleTransform.

Find all behaviors of given class, in this transform and children (up to any depth). The behaviors are added to the list, disregaring the Exists or ExistsInRoot property of parents. Returned class does not own children. The caller is responsible for freeing the returned list.

Source: transform/castletransform_transform.inc (line 2048).

This item is declared in ancestor TCastleTransform.

Find the first behavior of the given class, or create and add a new one if necessary. Never returns Nil.

Source: transform/castletransform_transform.inc (line 2052).

This item is declared in ancestor TCastleTransform.

Count of behaviors.

See also

AddBehavior

Add a TCastleBehavior to this TCastleTransform.

RemoveBehavior

Remove TCastleBehavior from this TCastleTransform.

Source: transform/castletransform_transform.inc (line 2057).

This item is declared in ancestor TCastleTransform.

You can enumerate current behaviors using loop like for B in MyTransform.BehaviorsEnumerate do .... Do not call this method in other contexts, it is only useful for "for..in" construction.

Source: transform/castletransform_transform.inc (line 2067).

This item is declared in ancestor TCastleTransform.

Adds a behavior to the list that needs to be informed about the world change. Adding multiple times the same behavior is harmless and has no effect.

Source: transform/castletransform_transform.inc (line 2071).

This item is declared in ancestor TCastleTransform.

Removes a behavior from the list that needs to be informed about the world change.

Source: transform/castletransform_transform.inc (line 2075).

This item is declared in ancestor TCastleTransform.

Create X3D nodes graph representing this TCastleTransorm (and its children). This can be used to save to any format supported by the SaveNode, like X3D and STL. See this news post for a summary of available features.

This method is internal, because:

• It is not the adviced way to save TCastleTransform to file. Rather, we advise to save hierarchy using the TransformSave to .castle-transform files. See also CastleComponentSerialize. You can then reuse designs using the TCastleTransformDesign component. This is the way to reliably save and restore 100% of published properties of TCastleTransform and its descendants.

• The export is not complete, and it will never be. X3D and other formats cannot express everything that Castle Game Engine components can express.

• While you can load the resulting X3D back inside the engine editor, this will be just a single component TCastleScene, not all the components you exported.

  (though it could be an option some day, see https://castle-engine.io/expose ).

  Solution: If you want to use CGE editor for authoring X3D or other model formats, just keep the original CGE editor files around, as the "source" version of your 3D / 2D world and export it to X3D as many times as you wish.

That said, this is useful, because:

• It allows to open things designed in CGE in X3D browsers, like Castle Model Viewer, Castle Model Viewer Mobile, X3DOM (in WWW browser), X_ITE (in WWW browser), FreeWRL. See X3D Resources for even more useful tools.

• It's useful for debugging purposes when developing CGE.

  Since some CGE components are realized under the hood using X3D as well, e.g. light components like TCastlePointLight are mostly just wrappers for X3D nodes like TPointLightNode – just with somewhat better defaults and sometimes better naming. Though it is not guaranteed to always be like it (our own components allow us to implement lights without X3D nodes under the hood as well), but when it is -> this method allows to "peek under the hood" at nodes really used to render.

Result must be TTransformNode but it cannot be declared as such.

It exports content for all nodes, even csTransient, and thus it is never Nil. Caller should avoid check for csTransient in Transform.ComponentState if you want to avoid this.

Source: transform/castletransform_transform.inc (line 2156).

This item is declared in ancestor TX3DEventsEngine.

This item has no description.

Source: scene/x3d/x3dnodes_eventsengine.inc (line 53).

This item is declared in ancestor TX3DEventsEngine.

This item has no description.

Source: scene/x3d/x3dnodes_eventsengine.inc (line 54).

This item is declared in ancestor TX3DEventsEngine.

This item has no description.

Source: scene/x3d/x3dnodes_eventsengine.inc (line 55).

This item is declared in ancestor TCastleSceneCore.

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/castlescenecore.pas (line 967).

This item is declared in ancestor TCastleSceneCore.

Load the given model. This replaces RootNode with new value.

Note that you should never load the same TX3DRootNode instance into multiple TCastleScene instances.

// DON'T DO THIS!
Node := LoadNode(Url);
Scene1 := TCastleScene.Create(Application);
Scene1.Load(Node, false);
Scene2 := TCastleScene.Create(Application);
Scene2.Load(Node, false);

If you need to load the same model into multiple scenes, it is best to use the Clone method:

SceneTemplate := TCastleScene.Create(Application);
SceneTemplate.Load(Url);
Scene1 := SceneTemplate.Clone(Application);
Scene2 := SceneTemplate.Clone(Application);

Using the Clone makes a copy of the underlying X3D graph, so it is roughly like doing:

Node := LoadNode(Url);
Scene1 := TCastleScene.Create(Application);
Scene1.Load(Node.DeepCopy as TX3DRootNode, false);
Scene2 := TCastleScene.Create(Application);
Scene2.Load(Node.DeepCopy as TX3DRootNode, false);

Note that sometimes you don't need to create multiple scenes to show the same model many times. You can simply insert the same TCastleScene instance multiple times to TCastleViewport.Items (TCastleRootTransform). See the manual: https://castle-engine.io/manual_scene.php#section_many_instances

Parameters

ARootNode

The model to load. This will become a new value of our RootNode property.

AOwnsRootNode

Should the scene take care of freeing this root node when it is no longer used. If False, you are expected to free it yourself, but only after the scene using it was freed.

AResetTime

If True then we will reset time at loading (using ResetTimeAtLoad), changing the Time. This is usually what you want when you load a new world.

Source: scene/castlescenecore.pas (line 1032).

This item is declared in ancestor TCastleSceneCore.

Load the 3D model from given URL.

We load a number of 3D model formats (X3D, VRML, Collada, Wavefront OBJ...) and some 2D model formats (Spine JSON). See https://castle-engine.io/creating_data_model_formats.php for the complete list.

URL is downloaded using the CastleDownload unit, so it supports files, http resources and more. See https://castle-engine.io/url about supported URL schemes. If you all you care about is loading normal files, then just pass a normal filename (absolute or relative to the current directory) as the URL parameter.

Source: scene/castlescenecore.pas (line 1049).

This item is declared in ancestor TCastleSceneCore.

Warning: this symbol is deprecated: use Load with (AUrl: String, AOptions: TSceneLoadOptions) parameters. AllowStdIn is not implemented anymore.

This item has no description.

Source: scene/castlescenecore.pas (line 1050).

This item is declared in ancestor TCastleSceneCore.

Save the current 3D model (X3D nodes graph) to the given file (URL).

The X3D encoding is automatically guessed from the URL extension. By default it is XML, and we suggest using the .x3d extension. If you specify an extension indicating "classic encoding", we will use such encoding (use .x3dv for X3D in classic encoding, or .wrl for older VRML content).

The file may also be automatically gzip compressed if extension indicates it. Use .x3d.gz to indicated XML compressed with gzip, or use .x3dv.gz or .wrl.gz to indicate classic encoding compressed with gzip.

The Url property is also changed.

Source: scene/castlescenecore.pas (line 1067).

This item is declared in ancestor TCastleSceneCore.

This item has no description.

Source: scene/castlescenecore.pas (line 1069).

This item is declared in ancestor TCastleSceneCore.

Bounding box of the given shape (TAbstractShapeNode). The shape node may be used multiple times in the nodes graph (in RootNode), in which case this method correctly (and fast) sums bounding box of all the occurrences of the given shape node.

Source: scene/castlescenecore.pas (line 1081).

This item is declared in ancestor TCastleSceneCore.

Number of active shapes in the Shapes tree. This is equivalent to Shapes.ShapesCount(true), except that this is faster (it's cached and reused in this instance, and automatically invalidated only when needed).

Source: scene/castlescenecore.pas (line 1087).

This item is declared in ancestor TCastleSceneCore.

Number of active and visible (TShape.Visible) shapes in the Shapes tree.

See also

ShapesActiveCount

Number of active shapes in the Shapes tree.

Source: scene/castlescenecore.pas (line 1093).

This item is declared in ancestor TCastleSceneCore.

Calculate the number of triangls and vertexes of all shapa states. For detailed specification of what these functions do see appropriate TAbstractGeometryNode methods. Here, we just sum their results for all shapes.

Source: scene/castlescenecore.pas (line 1100).

This item is declared in ancestor TCastleSceneCore.

This item has no description.

Source: scene/castlescenecore.pas (line 1101).

This item is declared in ancestor TCastleSceneCore.

Number of viewpoints (named camera position+orientation). -1 if none.

Source: scene/castlescenecore.pas (line 1106).

This item is declared in ancestor TCastleSceneCore.

Viewpoint node (TAbstractViewpointNode) from an index between 0 and ViewpointsCount.

Source: scene/castlescenecore.pas (line 1109).

This item is declared in ancestor TCastleSceneCore.

Good name to show user for a viewpoint, defined by an index between 0 and ViewpointsCount.

Source: scene/castlescenecore.pas (line 1112).

This item is declared in ancestor TCastleSceneCore.

Move current camera of the enclosing TCastleViewport to reflect the given viewpoint. This changes the camera position and orientation.

In X3D terminology, the new viewpoint node becomes "bound" (current). Switching the viewpoint that is already bound (current) also has an effect, it will change the camera position and orientation to reflect the viewpoint defined position / orientation.

Source: scene/castlescenecore.pas (line 1121).

This item is declared in ancestor TCastleSceneCore.

Add to scene nodes (graph in RootNode) new viewpoint node reflecting current camera and navigation settings. The new viewpoint increases ViewpointsCount, so it's also immediately available for switching to it.

Source: scene/castlescenecore.pas (line 1127).

This item is declared in ancestor TCastleSceneCore.

Call Node.FreeRemovingFromAllParents, making sure that changes to our VRML/X3D node graph are allowed. This makes sure we call BeforeNodesFree befor freeing, and ChangedAll afterwards.

This avoids a common pitfall with relying on TShape or such existence between BeforeNodesFree and ChangedAll. BeforeNodesFree may free all our TShape instances, so if you want to free TX3DNode from our graph — you typically want to get this TX3DNode instance *before* calling BeforeNodesFree. Using this method to free the node ensures this.

Source: scene/castlescenecore.pas (line 1161).

This item is declared in ancestor TCastleSceneCore.

Remove the shape node from the scene. In case of VRML 1.0 / Inventor, when the Shape doesn't have a node, we remove the geometry node.

Source: scene/castlescenecore.pas (line 1166).

This item is declared in ancestor TCastleSceneCore.

Notify scene that potentially everything changed in the VRML/X3D graph. This includes adding/removal of some nodes within RootNode graph and changing their fields' values. (Before freeing the nodes, remember to also call BeforeNodesFree earlier.)

You usually never need to call this method explicitly. It's called by engine when necesssary. However, you need to call it yourself if you change the X3D graph directly through nodes' FdXxx fields, and you don't want to call for some reason FdXxx.Changed.

ChangedAll causes recalculation of all things dependent on RootNode, so it's very costly to call this. Avoid calling this. When you change a simple field, like by FdXxx.Value := ..., you should rather call FdXxx.Changed, and it may do something much faster than rebuilding the scene.

Descendant implementors notes: ChangedAll is virtual, when overriding it remember that it's called by constructor of this class, so you can put a lot of your initialization there (instead of in the constructor).

ChangedAll calls BeforeNodesFree(true) first, for safety (and TGLShape actually depends on it, see implementation comments).

Source: scene/castlescenecore.pas (line 1193).

This item is declared in ancestor TCastleSceneCore.

Call OnViewpointsChanged, if assigned.

Source: scene/castlescenecore.pas (line 1266).

This item is declared in ancestor TCastleSceneCore.

Call OnBoundViewpointVectorsChanged, if assigned.

Source: scene/castlescenecore.pas (line 1269).

This item is declared in ancestor TCastleSceneCore.

This item has no description.

Source: scene/castlescenecore.pas (line 1273).

This item is declared in ancestor TCastleSceneCore.

Mechanism to schedule ChangedAll calls.

Since these calls may be costly (traversing the hierarchy), and their results are often not immediately needed by TCastleSceneCore or TX3DNode hierarchy, it's sometimes not desirable to call them immediately when geometry changed / all changed.

So you can use ScheduleChangedAll instead of ChangedAll. All event handlers within TCastleSceneCore already do this.

When you're within Begin/EndChangesSchedule, then ScheduleChangedAll just sets an internal flag and actual ChangedAll will be done only once at EndChangesSchedule. Otherwise (when not within Begin/EndChangesSchedule), ScheduleChangedAll will immediately call ChangedAll.

Source: scene/castlescenecore.pas (line 1293).

This item is declared in ancestor TCastleSceneCore.

This item has no description.

Source: scene/castlescenecore.pas (line 1294).

This item is declared in ancestor TCastleSceneCore.

This item has no description.

Source: scene/castlescenecore.pas (line 1295).

This item is declared in ancestor TCastleSceneCore.

Warning: this symbol is deprecated: do not use this, better to construct a summary string yourself

Returns short information about the scene. This consists of a few lines, separated by newlines. Last line also ends with CastleUtils.NL.

Source: scene/castlescenecore.pas (line 1301).

This item is declared in ancestor TCastleSceneCore.

Warning: this symbol is deprecated: better to construct a string yourself, use TrianglesCount, VerticesCount

This item has no description.

Source: scene/castlescenecore.pas (line 1306).

This item is declared in ancestor TCastleSceneCore.

Warning: this symbol is deprecated: better to construct a string yourself, use BoundingBox.ToString

This item has no description.

Source: scene/castlescenecore.pas (line 1308).

This item is declared in ancestor TCastleSceneCore.

Warning: this symbol is deprecated: better to construct a string yourself, use EdgesCount

This item has no description.

Source: scene/castlescenecore.pas (line 1310).

This item is declared in ancestor TCastleSceneCore.

Is this scene detected as "whole scene is manifold", so some shapes are not 2-manifold but whole scene is 2-manifold. This is independent (doesn't take into account) the value of RenderOptions.WholeSceneManifold.

Source: scene/castlescenecore.pas (line 1318).

This item is declared in ancestor TCastleSceneCore.

Edges count in the scene, for information purposes.

Source: scene/castlescenecore.pas (line 1322).

This item is declared in ancestor TCastleSceneCore.

A spatial structure containing all visible shapes. Set PreciseCollisions to True to have this non-nil.

This is used internally for "frustum culling", it will be automatically used by TCastleScene rendering to speed it up. You should not need to use this directly.

This octree will be automatically updated on dynamic scenes (when e.g. animation moves some shape by changing it's transformation).

Note that when VRML/X3D scene contains Collision nodes, this octree contains the visible (not necessarily collidable) objects.

Source: scene/castlescenecore.pas (line 1361).

This item is declared in ancestor TCastleSceneCore.

A spatial structure containing all collidable shapes (and then collidable triangles for a specifc shape). Set PreciseCollisions to True to have this non-nil.

This is actually a hierarchy of octrees: scene is partitioned first into Shapes (each instance of VRML/X3D geometry node), and then each Shape has an octree of triangles inside. Thanks to this, merely transforming some Shape means that only one item needs to be moved in the top-level shape tree. So this is the most important structure for collision detection on dynamic scenes.

This octree is useful for all kinds of collision detection. This is automatically used by the XxxCollision methods in this class.

You should not usually use this directly. Instead use TCastleViewport and then use Viewport.Items.WorldXxxCollision methods like Viewport.Items.WorldRay or Viewport.Items.WorldSphereCollision.

Note that when VRML/X3D scene contains Collision nodes, this octree contains the collidable (not necessarily rendered) objects.

This is kept up-to-date automatically when the scene changes. TODO: Temporarily, this is updated simply by rebuilding.

Source: scene/castlescenecore.pas (line 1389).

This item is declared in ancestor TCastleSceneCore.

Octree for collisions.

This is equal to InternalOctreeDynamicCollisions now as we don't have other ways to check for collisions. Set PreciseCollisions to True to have this non-nil.

You should not usually use this directly. Instead use TCastleViewport and then use Viewport.Items.WorldXxxCollision methods like Viewport.Items.WorldRay or Viewport.Items.WorldSphereCollision.

Source: scene/castlescenecore.pas (line 1402).

This item is declared in ancestor TCastleSceneCore.

This item has no description.

Source: scene/castlescenecore.pas (line 1404).

This item is declared in ancestor TCastleSceneCore.

Viewpoint defined in the 3D file (or some default camera settings if no viewpoint is found).

GetViewpoint seeks for VRML/X3D nodes like Viewpoint, OrthoViewpoint (actually, any X3DViewpointNode) and VRML 1.0 PerspectiveCamera and OrthographicCamera. GetPerspectiveViewpoint seeks only for perspective viewpoints.

If ViewpointDescription = '', they return the first found viewpoint node. Otherwise, they look for X3DViewpointNode with description field mathing given string.

If camera properties were found in some node, it returns this node. Otherwise it returns nil. This way you can optionally extract some additional info from used viewpoint node, or do something special if default values were used. Often you will just ignore result of this function — after all, the most important feature of this function is that you don't have to care about details of dealing with camera node.

Returned CamDir and CamUp and GravityUp are always normalized — reasons the same as for TAbstractViewpointNode.GetView.

Source: scene/castlescenecore.pas (line 1431).

This item is declared in ancestor TCastleSceneCore.

This item has no description.

Source: scene/castlescenecore.pas (line 1437).

This item is declared in ancestor TCastleSceneCore.

Warning: this symbol is deprecated: use Node.UnregisterScene

Recursively unset node's TX3DNode.Scene.

Source: scene/castlescenecore.pas (line 1448).

This item is declared in ancestor TCastleSceneCore.

Scene processes X3D key sensor nodes here, https://castle-engine.io/x3d_implementation_keydevicesensor.php . Remember to set ListenPressRelease to process the key sensor nodes.

Source: scene/castlescenecore.pas (line 1453).

This item is declared in ancestor TCastleSceneCore.

This item has no description.

Source: scene/castlescenecore.pas (line 1454).

This item is declared in ancestor TCastleSceneCore.

This item has no description. Showing description inherited from TCastleTransform.PointingDevicePress.

Pointing device (mouse or touch) events, you can override these to handle pointing device events. These methods are automatically called by the TCastleViewport. They are exposed here only to allow overriding them. Return True if you handled the event.

• PointingDevicePress signals that the picking button (usually, left mouse button) was pressed.

  Note that the exact key or mouse responsible for this is configurable in our engine by Input_Interact. By default it's the left mouse button, as is usual for VRML/X3D browsers. But it can be configured to be other mouse button or a key, for example most 3D games use "e" key to interact.

• PointingDeviceRelease signals that the picking button is released.

  An extra parameter CancelAction indicates whether this pointing device "press and release" sequence may be considered a "click". When CancelAction = True, then you should not make a "click" event (e.g. TouchSensor should not send touchTime event etc.).

• PointingDeviceMove signals that pointer moves over this object.

They receive Pick information (TRayCollisionNode) about what exactly is hit by the 3D ray corresponding to the current pointing device position. It contains the detailed information about the point, triangle and ray (all in local coordinate system of this TCastleTransform) that are indicated by the pointing device. TRayCollisionNode.Triangle is Nil when it was not possible to determine, and TRayCollisionNode.Point is undefined in this case.

They also receive Distance to the collision point, in world coordinates. See TRayCollision.Distance. The Distance may be MaxSingle when it was not possible to determine.

There is a concept of a TCastleTransform that is currently "capturing" the pointing device events. Once TCastleTransform handles TCastleTransform.PointingDevicePress (returns True for it), it captures the following PointingDeviceMove and PointingDeviceRelease events, regardless if ray still hits this TCastleTransform instance. The "capturing" instance of TCastleTransform is informed first about pointing device move/release.

After the "capturing" instance, every pointing device event (press, release or move) is send to the leaf in TCastleTransform hierarchy (usually a TCastleScene) that is under the mouse/touch position. If the event is not handled, it is passed to other objects under the mouse/touch position.

The PointingDeviceMove event is also always passed to TCastleRootTransform.MainScene at the end (if it wasn't already the "capturing" transform, or under the mouse/touch position). This way TCastleRootTransform.MainScene is always informed about pointing device movement.

These methods are called only if the object Exists. There's no need to check this condition inside the method implementation.

Source: scene/castlescenecore.pas (line 1456).

This item is declared in ancestor TCastleSceneCore.

This item has no description.

Source: scene/castlescenecore.pas (line 1458).

This item is declared in ancestor TCastleSceneCore.

Called when pointing device moves. This may generate the continuously-generated events like hitPoint_changed, also it updates PointingDeviceOverItem and PointingDeviceOverPoint, thus producing isOver and such events.

For pointing device sensors to work, you must have collision structures set up by setting PreciseCollisions to True.

Source: scene/castlescenecore.pas (line 1469).

This item is declared in ancestor TCastleSceneCore.

Pointing-device sensors over which the pointing device is. This is just a shortcut for PointingDeviceOverItemˆ.State.PointingDeviceSensors, returning Nil if PointingDeviceOverItem = Nil.

Source: scene/castlescenecore.pas (line 1490).

This item is declared in ancestor TCastleSceneCore.

Clear any references to PTriangle passed previously in TRayCollisionNode argument to PointingDevicePress, PointingDeviceRelease, PointingDeviceMove. This is internally used in case some of past seen PTriangle may become invalid, so any memory about them should be cleared.

This doesn't cause any X3D events (contrary to e.g. calling PointingDeviceMove with Pick.Triangle = Nil).

This method clears any references to saved PTriangle and PointingDeviceActiveSensors. Note that this still calls DoPointingDeviceSensorsChange (making OnPointingDeviceSensorsChange event), if PointingDeviceActiveSensors / PointingDeviceSensors possibly changed.

Source: scene/castlescenecore.pas (line 1520).

This item is declared in ancestor TCastleSceneCore.

This item has no description. Showing description inherited from TCastleTransform.LocalBoundingBox.

Bounding box of this object, ignoring the transformations of this scene and parents.

Source: scene/castlescenecore.pas (line 1533).

This item is declared in ancestor TCastleSceneCore.

Change current scene time, setting Time. This causes time to be passed to appropriate time-dependent nodes, events will be called etc.

You must call this continuously to have time-dependent features working, like TTimeSensorNode nodes inside the scene (driving all animations) and TMovieTextureNode. See Time for details what is affected by this.

This is automatically called if you added this scene to TCastleViewport.Items. Then our TCastleViewport takes care of calling our Update which in turn will call this method (and account for TimePlaying and TimePlayingSpeed).

SetTime and IncreaseTime do exactly the same, the difference is only that for IncreaseTime you specify increase in the time (that is, NewTime = Time + TimeIncrease). Use whichever version is more handy.

Following X3D specification, time should only grow. So NewValue should be > Time (or TimeIncrease > 0). Otherwise we ignore this call. For resetting the time (when you don't necessarily want to grow Time) see ResetTime.

If a change of Time will produce some visible change in the model (for example, MovieTexture will change, or TimeSensor change will be routed by interpolator to coordinates of some visible node) it will be reported by usual method, that is VisibleChangeHere.

Source: scene/castlescenecore.pas (line 1567).

This item is declared in ancestor TCastleSceneCore.

This item has no description.

Source: scene/castlescenecore.pas (line 1568).

This item is declared in ancestor TCastleSceneCore.

Warning: this symbol is deprecated: it should not be necessary to call this, ever; using TX3DEvent.Send(...) or TX3DEvent.Send(..., NextEventTime) will automatically behave Ok.

This item has no description.

Source: scene/castlescenecore.pas (line 1571).

This item is declared in ancestor TCastleSceneCore.

Current time within this scene, in seconds. Increasing this "drives" the animations (by increasing time of time-dependent nodes like TTimeSensorNode, which in turn drive the rest of the animation).

You can use SetTime or IncreaseTime to move time forward manually. But usually there's no need for it: our Update method takes care of it automatically, you only need to place the scene inside TCastleViewport.Items.

You can start/stop time progress by TimePlaying and scale it by TimePlayingSpeed. These properties affect how the time is updated by the Update method (so if you use SetTime or IncreaseTime methods, you're working around these properties).

Default time value is 0.0 (zero). However it will be reset at load to a current time (seconds since Unix epoch — that's what X3D standard says to use, although you can change it by TNavigationInfoNode.timeOriginAtLoad, see https://castle-engine.io/x3d_time_origin_considered_uncomfortable ). You can perform this "time reset" yourself by ResetTimeAtLoad or ResetTime.

Source: scene/castlescenecore.pas (line 1597).

This item is declared in ancestor TCastleSceneCore.

Time that should be used for next event. You usually don't need to call this directly, this is automatically used by TX3DEvent.Send when you don't specify explicit time.

Source: scene/castlescenecore.pas (line 1602).

This item is declared in ancestor TCastleSceneCore.

Set Time to an arbitrary value.

You should only use this when you loaded new model. It is automatically called by Load so in practice you don't need to call this yourself.

Unlike SetTime and IncreaseTime, this doesn't require that Time grows. It still does some time-dependent events work, although some time-dependent nodes may be just unconditionally reset by this to starting value (as they keep local time, and so require TimeIncrease notion, without it we can only reset them).

Source: scene/castlescenecore.pas (line 1617).

This item is declared in ancestor TCastleSceneCore.

Set Time to suitable initial value after loading a world.

This honours X3D specification about the time origin, and our extensions too. See https://castle-engine.io/x3d_time_origin_considered_uncomfortable

Source: scene/castlescenecore.pas (line 1625).

This item is declared in ancestor TCastleSceneCore.

This item has no description.

Source: scene/castlescenecore.pas (line 1669).

This item is declared in ancestor TCastleSceneCore.

This item has no description.

Source: scene/castlescenecore.pas (line 1670).

This item is declared in ancestor TCastleSceneCore.

This item has no description.

Source: scene/castlescenecore.pas (line 1671).

This item is declared in ancestor TCastleSceneCore.

This item has no description.

Source: scene/castlescenecore.pas (line 1672).

This item is declared in ancestor TCastleSceneCore.

Register compiled script handler, for VRML/X3D Script node with "compiled:" protocol. See [https://castle-engine.io/x3d_extensions.php#section_ext_script_compiled].

Source: scene/castlescenecore.pas (line 1682).

This item is declared in ancestor TCastleSceneCore.

Update TCastleNavigation properties based on currently bound TNavigationInfoNode.

Bound TNavigationInfoNode is taken from NavigationInfoStack.Top. If no such node is bound (NavigationInfoStack.Top is Nil) then we behave as if TNavigationInfoNode with all fields at default was active.

Note that, since some fields are only in some descendants (e.g. MoveSpeed is only at TCastleWalkNavigation) then some TNavigationInfoNode settings are just not transferred to all Navigation instances like TCastleExamineNavigation

Source: scene/castlescenecore.pas (line 1695).

This item is declared in ancestor TCastleSceneCore.

Warning: this symbol is deprecated: use Camera.AnimateTo(APosition, ADirection, AUp)

Make Camera go to the view given by (world coordinates) APosition, ADirection, AUp.

Honours current NavigationInfo.transitionType and transitionTime. If transitionType indicates instanteneous transition, then jumps by simple Camera.SetWorldView(APosition, ADirection, AUp). Otherwise makes a smooth animation into new values by Camera.AnimateTo(APosition, ADirection, AUp, TransitionTime).

Will generate NavigationInfo.transitionComplete when transition ends.

Source: scene/castlescenecore.pas (line 1748).

This item is declared in ancestor TCastleSceneCore.

Warning: this symbol is deprecated: use Camera.AnimateTo(APosition, ADirection, AUp)

This item has no description.

Source: scene/castlescenecore.pas (line 1750).

This item is declared in ancestor TCastleSceneCore.

Warning: this symbol is deprecated: use Camera.AnimateTo(APosition, ADirection, AUp)

This item has no description.

Source: scene/castlescenecore.pas (line 1752).

This item is declared in ancestor TCastleSceneCore.

Warning: this symbol is deprecated: use Camera.AnimateTo(APosition, ADirection, AUp)

This item has no description.

Source: scene/castlescenecore.pas (line 1754).

This item is declared in ancestor TCastleSceneCore.

Light node that should be used for headlight, or Nil if default directional headlight is suitable.

This never returns Nil. It's not concerned whether the headlight should actually be used — for this, see HeadlightOn.

Source: scene/castlescenecore.pas (line 1784).

This item is declared in ancestor TCastleSceneCore.

Nice scene caption. Uses the "title" of WorldInfo node inside the VRML/X3D scene. If there is no WorldInfo node (or it has empty title) then result is based on loaded URL.

Source: scene/castlescenecore.pas (line 1813).

This item is declared in ancestor TCastleSceneCore.

Find a named X3D node in the current node graph.

By default it searches both active and inactive graph parts. Add fnOnlyActive to search only in active parts.

It searches only within nodes of given type (NodeClass). Specifying NodeClass helps to make search unambiguous (as name clashes are possible, some authoring tools may write models with duplicate names for materials, meshes etc. and both glTF and X3D allow it). This allows to safely write code like:

MyMaterial := Scene.Node(TNodePhysicalMaterial, 'MyMaterial') as TNodePhysicalMaterial;

TODO: An even better version, "MyMaterial := Scene.Node<TNodePhysicalMaterial>('MyMaterial')", may be available in the future, if FPC support for generic methods will improve. Define GENERIC_METHODS to try it out now, but heed the warnings in castleconf.inc .

Exceptions raised

EX3DNotFound

When node is not found. Unless fnNilOnMissing in Options, then it returns Nil on missing node, and EX3DNotFound is never raised.

Source: scene/castlescenecore.pas (line 1842).

This item is declared in ancestor TCastleSceneCore.

This item has no description.

Source: scene/castlescenecore.pas (line 1844).

This item is declared in ancestor TCastleSceneCore.

Find a named field within an X3D node in the current node graph.

Like Node, this searches all nodes (in active or not) graph parts.

Exceptions raised

EX3DNotFound

If given node or field could not be found.

Source: scene/castlescenecore.pas (line 1856).

This item is declared in ancestor TCastleSceneCore.

Find a named event within an X3D node in the current node graph.

Like Node, this searches all nodes (in active or not) graph parts.

Exceptions raised

EX3DNotFound

If given node or event could not be found.

Source: scene/castlescenecore.pas (line 1864).

This item is declared in ancestor TCastleSceneCore.

Does named animation with given name exist.

See also

AnimationsList

List the names of available animations in current scene.

PlayAnimation

Source: scene/castlescenecore.pas (line 1920).

This item is declared in ancestor TCastleSceneCore.

TimeSensor of this animation. Nil if this name not found.

Source: scene/castlescenecore.pas (line 1923).

This item is declared in ancestor TCastleSceneCore.

TimeSensor of this animation, by animation index (index on AnimationsList). Nil if this index not found.

Source: scene/castlescenecore.pas (line 1927).

This item is declared in ancestor TCastleSceneCore.

Forcefully, immediately, set pose from given animation, with given time in animation.

This avoids the normal passage of time in X3D scenes, it ignores the ProcessEvents and AnimateOnlyWhenVisible properties, it ignores the current animation set by PlayAnimation, and forces the current time on TimeSensors by TTimeSensorNode.FakeTime.

Source: scene/castlescenecore.pas (line 1936).

This item is declared in ancestor TCastleSceneCore.

Play an animation specified by name.

You can specify the animation name, whether it should loop, and whether to play it forward or backward using parameters to this method.

Or you can specify even more parameters using TPlayAnimationParameters instance. TPlayAnimationParameters can additionally specify a stop notification, initial time and more. It is OK to create a short-lived TPlayAnimationParameters instance and destroy it right after calling this method. This method doesn't store the TPlayAnimationParameters instance reference.

To get the list of available animations, see AnimationsList.

This is one of the simplest way to play animations using Castle Game Engine. Alternative (that calls PlayAnimation under the hood) is to set AutoAnimation. See https://castle-engine.io/viewport_3d#_play_animation .

Playing an already-playing animation is guaranteed to restart it from the beginning (more precisely: from TPlayAnimationParameters.InitialTime, if you pass TPlayAnimationParameters).

If the given animation name exists, then we stop previously playing animation (if any), calling it's stop notification (see TPlayAnimationParameters.StopNotification), start playing the new animation, and return True. If the animation name does not exist then we return False, make a warning and the current animation is unchanged.

The change from previous to new animation can be smooth (using animation cross-fading) if you use TPlayAnimationParameters with TPlayAnimationParameters.TransitionDuration or if you set DefaultAnimationTransition to something non-zero.

This automatically turns on ProcessEvents, if it wasn't turned on already. Processing events is necessary for playing animations.

More details about how this works:

• Calling this method does not change the scene immediately. There may be a delay between calling PlayAnimation and actually changing the scene to reflect the state at the beginning of the indicated animation. This delay is usually 1 frame (that is, the scene is updated at the next Update call), but it may be larger if you use the optimization AnimateSkipTicks.

  This is often a desirable optimization. There's often no "rush" to visually change the animation right now, and doing it at the nearest Update call is acceptable. It also means that calling PlayAnimation multiple times before a single Update call is not expensive.

  If you really need to change the scene immediately (for example, because you don't want to show user the initial scene state), simply call ForceInitialAnimationPose right after PlayAnimation.

• The animation is performed using X3D TTimeSensorNode.

  For example, TTimeSensorNode may instruct a TCoordinateInterpolatorNode to update the TIndexedFaceSetNode coordinates, and in effect the animation can deform a mesh. Or TTimeSensorNode may instruct a TPositionInterpolatorNode to update TTransformNode.Translation, and in effect the animation can move something. See https://castle-engine.io/x3d_implementation_interpolation.php for a thorough description how the animation works in X3D.

  This means that during the animation, the X3D nodes graph (within RootNode) is being changed.

  If you load a model from a castle-anim-frames or MD3 format, note that it is animated using a special "node interpolator". This also works using a special (internal) X3D node that switches which node is visible.

• Starting an animation effectively cancels any effect from any previous animation. That is, even if the new animation doesn't modify some transformations, these transformations are not left "as is", instead they are reset to the default model state using ResetAnimationState. This is usually the desired effect, corresponding to how the animations should intuitively behave, e.g. if you have "walk" and "idle" animations.

  If you want to simultaneously play multiple animations or if you want to simultaneously modify scene by code (while playing some animation) then you can control each time sensor using TTimeSensorNode.Start and TTimeSensorNode.Stop. See also the example in examples/animations/simultaneous_animations_one_scene .

Source: scene/castlescenecore.pas (line 2034).

This item is declared in ancestor TCastleSceneCore.

This item has no description.

Source: scene/castlescenecore.pas (line 2035).

This item is declared in ancestor TCastleSceneCore.

Force the model to look like the initial animation frame now.

Use this after calling PlayAnimation. Calling this is simply ignored if no PlayAnimation was called earlier, of if the model already looks following the animation requested by PlayAnimation.

If you don't use this method, there may be a 1-frame delay between calling PlayAnimation and actually updating the rendered scene look. If during that time a rendering will happen, the user will see a scene in previous pose (not in the first pose of animation you requested by PlayAnimation). To avoid this, simply call this method right after PlayAnimation.

This sets first animation frame, unless you used TPlayAnimationParameters.InitialTime <> 0.

Source: scene/castlescenecore.pas (line 2054).

This item is declared in ancestor TCastleSceneCore.

Duration, in seconds, of the named animation (named animations are detected by AnimationsList method). For a looping animation, this is the duration of a single cycle. 0 if not found.

Source: scene/castlescenecore.pas (line 2060).

This item is declared in ancestor TCastleSceneCore.

Stop the CurrentAnimation, started by last PlayAnimation call. Note that this leaves the model in a state in the middle of the last animation.

You can use ResetAnimationState to reset the state afterwards. Calling ForceInitialAnimationPose also will do it.

Note that it is not necessary to stop the previous animation before starting a new one (by PlayAnimation). PlayAnimation will automatically stop the previous animation. Moreover, PlayAnimation may do animation blending (cross-fade) between old and new animation (if you use TPlayAnimationParameters.TransitionDuration), which only works if you did not call StopAnimation.

When animation is stopped (by this or any other means), by default it's TPlayAnimationParameters.StopNotification is called. You can use DisableStopNotification to avoid it, which should be used only in exceptional situations.

Source: scene/castlescenecore.pas (line 2110).

This item is declared in ancestor TCastleSceneCore.

Reset all the fields affected by animations. See TimeSensor.detectAffectedFields documentation (https://castle-engine.io/x3d_implementation_time_extensions.php#section_detect_affected_fields) for details how these fields are detected, and when this is useful. By default this is enabled, for all TimeSensor nodes.

If IgnoreAffectedBy <> nil, the fields affected by the given TimeSensor may not be reset. This is an optimization useful in case this TimeSensor will modify the scene very soon, so resetting its affected fields is a waste of time. Do not depend on 100% that the fields affected by given TimeSensor are left untouched (in the current implementation, this field is ignored).

Source: scene/castlescenecore.pas (line 2124).

This item is declared in ancestor TCastleSceneCore.

Force recalculating the text shapes when font changed. For now, we don't detect font changes (e.g. when TFontStyleNode.CustomFont changed) automatically. This calls TTextNode.FontChanged and TAsciiTextNode_1.FontChanged on all appropriate nodes.

Source: scene/castlescenecore.pas (line 2131).

This item is declared in ancestor TCastleSceneCore.

This item has no description.

Source: scene/castlescenecore.pas (line 2149).

This item is declared in ancestor TCastleSceneCore.

Load again the model from current URL. This makes sense to be used when underlying file on disk changed, and you want to reload it.

TODO: If the file is cached using Cache, then it will not reload the version in cache, so effectively it will not load new version from disk. This will be fixed at some point.

Source: scene/castlescenecore.pas (line 2159).

This item is declared in ancestor TCastleComponent.

Components added by AddNonVisualComponent.

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

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

This item is declared in ancestor TCastleTransform.

Warning: this symbol is deprecated: use Exists

This item has no description.

Source: transform/castletransform_transform.inc (line 717).

This item is declared in ancestor TCastleTransform.

List of current children.

Source: transform/castletransform_transform.inc (line 825).

This item is declared in ancestor TCastleTransform.

Parent TCastleTransform.

In most cases, a TCastleTransform is just a child of one other TCastleTransform, and then this property returns this natural parent.

Returns Nil if TCastleTransform is not a child of any other TCastleTransform.

Setting this property removes us from old parent, and adds to the new one. The local transformation (translation, rotation, scale) doesn't change, so changing parent may change the effective (world) transformation of the object.

In rare cases the child can have multiple parents. The behavior is then:

• It ignores (never returns) parents caused by referencing transform in TCastleTransformReference.

• If there is (or was, at some point) more than 1 parent (not counting parents caused by TCastleTransformReference) then it may return nil, or any of the existing parents – it is undefined which exactly.

  In general, one TCastleTransform instance may be used multiple times as a child of other TCastleTransform instances (as long as they are all within the same TCastleViewport). The parent TCastleTransform instances may include TCastleTransformReference (this allows to create multiple references to one TCastleTransform from editor) but in general any parents are allowed (when you use code, you can just insert TCastleTransform as a child of other TCastleTransform, without the need for TCastleTransformReference).

  This property indicates the one parent that is not TCastleTransformReference. If there are multiple such parents (this is impossible at design-time in editor, but it is possible at runtime if you add/remove TCastleTransform children by code) then this returns Nil or any of existing parents.

• Setting is not allowed if child has (or ever had) multiple parents. The behavior is undefined.