var(Display) const StaticMesh StaticMesh; // StaticMesh if DrawType=DT_StaticMesh
// Owner.
var const Actor Owner; // Owner actor.
var const Actor Base; // Actor we're standing on.
struct ActorRenderDataPtr { var int Ptr; };
struct LightRenderDataPtr { var int Ptr; };
var const native ActorRenderDataPtr ActorRenderData;
var const native LightRenderDataPtr LightRenderData;
var const native int RenderRevision;
enum EFilterState
{
FS_Maybe,
FS_Yes,
FS_No
};
var const native EFilterState StaticFilterState;
struct BatchReference
{
var int BatchIndex,
ElementIndex;
};
var const native array<BatchReference> StaticSectionBatches;
var(Display) const name ForcedVisibilityZoneTag; // Makes the visibility code treat the actor as if it was in the zone with the given tag.
// Lighting.
var(Lighting) bool bSpecialLit; // Only affects special-lit surfaces.
var(Lighting) bool bActorShadows; // Light casts actor shadows.
var(Lighting) bool bCorona; // Light uses Skin as a corona.
var(Lighting) bool bLightingVisibility; // Calculate lighting visibility for this actor with line checks.
var(Display) bool bUseDynamicLights;
var bool bLightChanged; // Recalculate this light's lighting now.
// Detail mode enum.
enum EDetailMode
{
DM_Low,
DM_High,
DM_SuperHigh
};
// Flags.
var const bool bStatic; // Does not move or change over time. Don't let L.D.s change this - screws up net play
var(Advanced) bool bHidden; // Is hidden during gameplay.
var(Advanced) const bool bNoDelete; // Cannot be deleted during play.
var const bool bDeleteMe; // About to be deleted.
var transient const bool bTicked; // Actor has been updated.
var(Lighting) bool bDynamicLight; // This light is dynamic.
var bool bTimerLoop; // Timer loops (else is one-shot).
var bool bOnlyOwnerSee; // Only owner can see this actor.
var(Advanced) bool bHighDetail; // Only show up in high or super high detail mode.
var(Advanced) bool bSuperHighDetail; // Only show up in super high detail mode.
var bool bOnlyDrawIfAttached; // don't draw this actor if not attached (useful for net clients where attached actors and their bases' replication may not be synched)
var(Advanced) bool bStasis; // In StandAlone games, turn off if not in a recently rendered zone turned off if bStasis and physics = PHYS_None or PHYS_Rotating.
var bool bTrailerAllowRotation; // If PHYS_Trailer and want independent rotation control.
var bool bTrailerSameRotation; // If PHYS_Trailer and true, have same rotation as owner.
var bool bTrailerPrePivot; // If PHYS_Trailer and true, offset from owner by PrePivot.
var bool bWorldGeometry; // Collision and Physics treats this actor as world geometry
var(Display) bool bAcceptsProjectors; // Projectors can project onto this actor
var bool bOrientOnSlope; // when landing, orient base on slope of floor
var const bool bOnlyAffectPawns; // Optimisation - only test ovelap against pawns. Used for influences etc.
var(Display) bool bDisableSorting; // Manual override for translucent material sorting.
var(Movement) bool bIgnoreEncroachers; // Ignore collisions between movers and
var bool bShowOctreeNodes;
var bool bWasSNFiltered; // Mainly for debugging - the way this actor was inserted into Octree.
// Networking flags
var const bool bNetTemporary; // Tear-off simulation in network play.
var bool bOnlyRelevantToOwner; // this actor is only relevant to its owner.
var transient const bool bNetDirty; // set when any attribute is assigned a value in unrealscript, reset when the actor is replicated
var bool bAlwaysRelevant; // Always relevant for network.
var bool bReplicateInstigator; // Replicate instigator to client (used by bNetTemporary projectiles).
var bool bReplicateMovement; // if true, replicate movement/location related properties
var bool bSkipActorPropertyReplication; // if true, don't replicate actor class variables for this actor
var bool bUpdateSimulatedPosition; // if true, update velocity/location after initialization for simulated proxies
var bool bTearOff; // if true, this actor is no longer replicated to new clients, and
// is "torn off" (becomes a ROLE_Authority) on clients to which it was being replicated.
var bool bOnlyDirtyReplication; // if true, only replicate actor if bNetDirty is true - useful if no C++ changed attributes (such as physics)
// bOnlyDirtyReplication only used with bAlwaysRelevant actors
var bool bReplicateAnimations; // Should replicate SimAnim
var const bool bNetInitialRotation; // Should replicate initial rotation
var bool bCompressedPosition; // used by networking code to flag compressed position replication
var bool bAlwaysZeroBoneOffset; // if true, offset always zero when attached to skeletalmesh
// Net variables.
enum ENetRole
{
ROLE_None, // No role at all.
ROLE_DumbProxy, // Dumb proxy of this actor.
ROLE_SimulatedProxy, // Locally simulated proxy of this actor.
ROLE_AutonomousProxy, // Locally autonomous proxy of this actor.
ROLE_Authority, // Authoritative control over the actor.
};
var ENetRole RemoteRole, Role;
var const transient int NetTag;
var const float NetUpdateTime; // time of last update
var float NetUpdateFrequency; // How many seconds between net updates.
var float NetPriority; // Higher priorities means update it more frequently.
var Pawn Instigator; // Pawn responsible for damage caused by this actor.
// Symmetric network flags, valid during replication only.
var const bool bNetInitial; // Initial network update.
var const bool bNetOwner; // Player owns this actor.
var const bool bNetRelevant; // Actor is currently relevant. Only valid server side, only when replicating variables.
var const bool bDemoRecording; // True we are currently demo recording
var const bool bClientDemoRecording;// True we are currently recording a client-side demo
var const bool bRepClientDemo; // True if remote client is recording demo
var const bool bClientDemoNetFunc;// True if we're client-side demo recording and this call originated from the remote.
var const bool bDemoOwner; // Demo recording driver owns this actor.
var bool bNoRepMesh; // don't replicate mesh
//Editing flags
var(Advanced) bool bHiddenEd; // Is hidden during editing.
var(Advanced) bool bHiddenEdGroup;// Is hidden by the group brower.
var(Advanced) bool bDirectional; // Actor shows direction arrow during editing.
var const bool bSelected; // Selected in UnrealEd.
var(Advanced) bool bEdShouldSnap; // Snap to grid in editor.
var transient bool bEdSnap; // Should snap to grid in UnrealEd.
var transient const bool bTempEditor; // Internal UnrealEd.
var bool bObsolete; // actor is obsolete - warn level designers to remove it
var(Collision) bool bPathColliding;// this actor should collide (if bWorldGeometry && bBlockActors is true) during path building (ignored if bStatic is true, as actor will always collide during path building)
var transient bool bPathTemp; // Internal/path building
var bool bScriptInitialized; // set to prevent re-initializing of actors spawned during level startup
var(Advanced) bool bLockLocation; // Prevent the actor from being moved in the editor.
// Iterator functions for dealing with sets of actors.
/* AllActors() - avoid using AllActors() too often as it iterates through the whole actor list and is therefore slow
*/
native(304) final iterator function AllActors ( class<actor> BaseClass, out actor Actor, optional name MatchTag );
/* DynamicActors() only iterates through the non-static actors on the list (still relatively slow, bu
much better than AllActors). This should be used in most cases and replaces AllActors in most of
Epic's game code.
*/
native(313) final iterator function DynamicActors ( class<actor> BaseClass, out actor Actor, optional name MatchTag );
/* ChildActors() returns all actors owned by this actor. Slow like AllActors()
*/
native(305) final iterator function ChildActors ( class<actor> BaseClass, out actor Actor );
/* BasedActors() returns all actors based on the current actor (slow, like AllActors)
*/
native(306) final iterator function BasedActors ( class<actor> BaseClass, out actor Actor );
/* TouchingActors() returns all actors touching the current actor (fast)
*/
native(307) final iterator function TouchingActors( class<actor> BaseClass, out actor Actor );
/* TraceActors() return all actors along a traced line. Reasonably fast (like any trace)
*/
native(309) final iterator function TraceActors ( class<actor> BaseClass, out actor Actor, out vector HitLoc, out vector HitNorm, vector End, optional vector Start, optional vector Extent );
/* RadiusActors() returns all actors within a give radius. Slow like AllActors(). Use CollidingActors() or VisibleCollidingActors() instead if desired actor types are visible
(not bHidden) and in the collision hash (bCollideActors is true)
*/
native(310) final iterator function RadiusActors ( class<actor> BaseClass, out actor Actor, float Radius, optional vector Loc );
/* VisibleActors() returns all visible actors within a radius. Slow like AllActors(). Use VisibleCollidingActors() instead if desired actor types are
in the collision hash (bCollideActors is true)
*/
native(311) final iterator function VisibleActors ( class<actor> BaseClass, out actor Actor, optional float Radius, optional vector Loc );
/* VisibleCollidingActors() returns visible (not bHidden) colliding (bCollideActors==true) actors within a certain radius.
Much faster than AllActors() since it uses the collision hash
*/
native(312) final iterator function VisibleCollidingActors ( class<actor> BaseClass, out actor Actor, float Radius, optional vector Loc, optional bool bIgnoreHidden );
/* CollidingActors() returns colliding (bCollideActors==true) actors within a certain radius.
Much faster than AllActors() for reasonably small radii since it uses the collision hash
*/
native(321) final iterator function CollidingActors ( class<actor> BaseClass, out actor Actor, float Radius, optional vector Loc );
