AddArea - adds a 2d-contour area. Computes the best fitting plane for the points and projects them on it zmin and zmax are the dimensions along this plane's normal if set, pTessIdx is the surface's triangulation (3 idx per tri), used if the points are not close enough to the plane pFlows is per-vertex (0..npt-1) water flow vectors

AddArea - creates a general geometry area. Typically, primitives work best, but can be a mesh or a heightfield In the latter case, it chages water plane in buoyancy params based on local height perturbation (used for waves)

AddEventClient - adds a phyisics event listener bLogged==1 for a logged event version, 0 for immediate listeners are called in the order of decreasing priorities if a listener returns 0, further event processing stops

AddExplosionShape - registers a boolean carving shape for breakable meashes size is the shape's 'characteristic' size; during the actual carving the caller provides a desired size, and the shape is scaled by desired_size/this_size. idmat is the breakability index this shape gets assigned to. if there are several shapes for one index, the ones with the size closest to the requested are selected, and among those one is selected randomly based on relative probability returns shape id, which can be used to unregister the shape later

adds a global phys area or returns an existing one

AddRefEntInPODGrid: makes sure the entity gets an on-demand AddRef for each on-demand sector it touches (needed when manually creating entities outside on-deman callback)

Clean up memory pools after level was unloaded. should only be called when all outside references to physics where deleted.

CreatePhysicalEntity - creates an entity with specified type, sets foreign data and optionally initializes if some pe_params if id is left <0, the physics will assign one (note: internally there's a id->ptr array map, so keep ids wihin some sane range) returns a valid entity pointer even if the physics thread is busy during the call

CreatePhysicalPlaceholder - placeholder is a lightweight structure that requests creation of a full entity when needed via IPhysicsStreamer->CreatePhysicalEntity

deactivates sector-based on-demand physicalization

DeformPhysicalEntity - applies boolean breaking for entity parts that have >=0 breakability index r is used to scale the corresponding explosion (boolean) shape

DestroyDynamicEntities - immediately destroys all physical, living, and detached entities; flushes the deleted entities All subsequent calls to DestroyPhysicalEntity for non-static entities are ignored until the next non-static entity is created

DestroyPhysicalEntity - moves the entity to the to-be-destroyed list (mode 0), destroys areas and placeholders mode 1-suspend the entity (unregister from all physics structures, but don't delete), 2-restore from suspended state mode & 4 - doesn't delete the entity if it is still referenced and returns 0 even if this flag is not set, referenced entities (nRefCount>0) will not be physically deleted until freed request can get queued if the physics thread is busy, unless bThreadSafe is set

GetEntitiesInBox - uses entity grid to query entites in bbox (objtypes - see enum entity_query_flags) unless ent_allocate_list is set, returns pre-alocated internal list for iCaller==MAX_PHYS_THREADS otherwise, tries to use supplied pList up to szListPrealloc, allocates a new one if the size's not enough returns the number of entities

RasterizeEntities - builds a depth map from physical gometries in a box specified by grid; only updates area affected by offsBBox +/- sizeBBox depth is z values, scaled and clamped so that the grid box's -size.z..+size.z is mapped to 0..255

Performs a raycast through the physical world, returning possible hits into the provided hits structure

#include 
#include 

// Example of how we can cast a ray through the physical world and receive hit information
void RayWorldIntersection()
{
    // Store the half render size, used to calculate a direction that points outwards from the camera
    const float halfRenderWidth = static_cast(gEnv->pRenderer->GetWidth()) * 0.5f;
    const float halfRenderHeight = static_cast(gEnv->pRenderer->GetHeight()) * 0.5f;
    
    // For the sake of this example we will cast the ray 50 meters outwards from the camera
    const float searchRange = 50.f;

    // Calculate the centered position of the near and far planes
    Vec3 cameraCenterNear, cameraCenterFar;
    gEnv->pRenderer->UnProjectFromScreen(halfRenderWidth, halfRenderHeight, 0, &cameraCenterNear.x, &cameraCenterNear.y, &cameraCenterNear.z);
    gEnv->pRenderer->UnProjectFromScreen(halfRenderWidth, halfRenderHeight, 1, &cameraCenterFar.x, &cameraCenterFar.y, &cameraCenterFar.z);

    // Now subtract the far and near positions to get a direction, and multiply by the desired range
    const Vec3 searchDirection = (cameraCenterFar - cameraCenterNear).GetNormalized() * searchRange;

    // The result of RayWorldIntersection will be stored in this array
    // For the sake of this example we will limit to only one hit
    std::array hits;

    // Specify query flags, in this case we will allow any type of entity
    const uint32 queryFlags = ent_all;
    // Specify ray flags, see rwi_flags.
    // Values of 0 - 15 will indicate which surface types the ray will be able to pass through, this depends on the pierceability set in each project's surface types definition.
    // A < check is used, thus lower values are more "durable". For example, pierceability set to 10, and an encountered surface type with pierceability 11 results in the ray passing through. Otherwise, the ray stops at that surface type.
    // A pierceability of 15, or rwi_stop_at_pierceable will mean that the ray does not pierce any surface types.
    // Note that the first ray_hit result is *always* a solid object, thus hits can be reported while the first hit is invalid - this indicates that hits[1] and above were pierced through.
    const uint32 rayFlags = rwi_stop_at_pierceable;

    // Perform the ray intersection, note that this happens on the main thread and can thus be a slow operation
    const int numHits = gEnv->pPhysicalWorld->RayWorldIntersection(cameraCenterNear, searchDirection, queryFlags, rayFlags, hits.data(), hits.max_size());
    if (numHits > 0)
    {
        if (IEntity* pHitEntity = gEnv->pEntitySystem->GetEntityFromPhysics(hits[0].pCollider))
        {
            /* An entity was hit, and we can now use the pHitEntity pointer */
        }
    }
}

Performs a raycast through the physical world, returning possible hits into the provided hits structure

#include 
#include 

// Example of how we can cast a ray through the physical world and receive hit information
void RayWorldIntersection()
{
    // Store the half render size, used to calculate a direction that points outwards from the camera
    const float halfRenderWidth = static_cast(gEnv->pRenderer->GetWidth()) * 0.5f;
    const float halfRenderHeight = static_cast(gEnv->pRenderer->GetHeight()) * 0.5f;
    
    // For the sake of this example we will cast the ray 50 meters outwards from the camera
    const float searchRange = 50.f;

    // Calculate the centered position of the near and far planes
    Vec3 cameraCenterNear, cameraCenterFar;
    gEnv->pRenderer->UnProjectFromScreen(halfRenderWidth, halfRenderHeight, 0, &cameraCenterNear.x, &cameraCenterNear.y, &cameraCenterNear.z);
    gEnv->pRenderer->UnProjectFromScreen(halfRenderWidth, halfRenderHeight, 1, &cameraCenterFar.x, &cameraCenterFar.y, &cameraCenterFar.z);

    // Now subtract the far and near positions to get a direction, and multiply by the desired range
    const Vec3 searchDirection = (cameraCenterFar - cameraCenterNear).GetNormalized() * searchRange;

    // The result of RayWorldIntersection will be stored in this array
    // For the sake of this example we will limit to only one hit
    std::array hits;

    // Specify query flags, in this case we will allow any type of entity
    const uint32 queryFlags = ent_all;
    // Specify ray flags, see rwi_flags.
    // Values of 0 - 15 will indicate which surface types the ray will be able to pass through, this depends on the pierceability set in each project's surface types definition.
    // A < check is used, thus lower values are more "durable". For example, pierceability set to 10, and an encountered surface type with pierceability 11 results in the ray passing through. Otherwise, the ray stops at that surface type.
    // A pierceability of 15, or rwi_stop_at_pierceable will mean that the ray does not pierce any surface types.
    // Note that the first ray_hit result is *always* a solid object, thus hits can be reported while the first hit is invalid - this indicates that hits[1] and above were pierced through.
    const uint32 rayFlags = rwi_stop_at_pierceable;

    // Perform the ray intersection, note that this happens on the main thread and can thus be a slow operation
    const int numHits = gEnv->pPhysicalWorld->RayWorldIntersection(cameraCenterNear, searchDirection, queryFlags, rayFlags, hits.data(), hits.max_size());
    if (numHits > 0)
    {
        if (IEntity* pHitEntity = gEnv->pEntitySystem->GetEntityFromPhysics(hits[0].pCollider))
        {
            /* An entity was hit, and we can now use the pHitEntity pointer */
        }
    }
}

Performs a raycast through the physical world, returning possible hits into the provided hits structure

#include 
#include 

// Example of how we can cast a ray through the physical world and receive hit information
void RayWorldIntersection()
{
    // Store the half render size, used to calculate a direction that points outwards from the camera
    const float halfRenderWidth = static_cast(gEnv->pRenderer->GetWidth()) * 0.5f;
    const float halfRenderHeight = static_cast(gEnv->pRenderer->GetHeight()) * 0.5f;
    
    // For the sake of this example we will cast the ray 50 meters outwards from the camera
    const float searchRange = 50.f;

    // Calculate the centered position of the near and far planes
    Vec3 cameraCenterNear, cameraCenterFar;
    gEnv->pRenderer->UnProjectFromScreen(halfRenderWidth, halfRenderHeight, 0, &cameraCenterNear.x, &cameraCenterNear.y, &cameraCenterNear.z);
    gEnv->pRenderer->UnProjectFromScreen(halfRenderWidth, halfRenderHeight, 1, &cameraCenterFar.x, &cameraCenterFar.y, &cameraCenterFar.z);

    // Now subtract the far and near positions to get a direction, and multiply by the desired range
    const Vec3 searchDirection = (cameraCenterFar - cameraCenterNear).GetNormalized() * searchRange;

    // The result of RayWorldIntersection will be stored in this array
    // For the sake of this example we will limit to only one hit
    std::array hits;

    // Specify query flags, in this case we will allow any type of entity
    const uint32 queryFlags = ent_all;
    // Specify ray flags, see rwi_flags.
    // Values of 0 - 15 will indicate which surface types the ray will be able to pass through, this depends on the pierceability set in each project's surface types definition.
    // A < check is used, thus lower values are more "durable". For example, pierceability set to 10, and an encountered surface type with pierceability 11 results in the ray passing through. Otherwise, the ray stops at that surface type.
    // A pierceability of 15, or rwi_stop_at_pierceable will mean that the ray does not pierce any surface types.
    // Note that the first ray_hit result is *always* a solid object, thus hits can be reported while the first hit is invalid - this indicates that hits[1] and above were pierced through.
    const uint32 rayFlags = rwi_stop_at_pierceable;

    // Perform the ray intersection, note that this happens on the main thread and can thus be a slow operation
    const int numHits = gEnv->pPhysicalWorld->RayWorldIntersection(cameraCenterNear, searchDirection, queryFlags, rayFlags, hits.data(), hits.max_size());
    if (numHits > 0)
    {
        if (IEntity* pHitEntity = gEnv->pEntitySystem->GetEntityFromPhysics(hits[0].pCollider))
        {
            /* An entity was hit, and we can now use the pHitEntity pointer */
        }
    }
}

Freezes (resets velocities of) all physical, living, and detached entities

SetSurfaceParameters: sets parameters for surface_idx (0..511 currently) bounciness - restitution coefficient (for pair of surfaces k = sum of their coefficients, clamped to [0..1] friction - friction coefficient (for pair of surfaces k = sum of their coefficients, clamped to [0..inf) flags - see surface_flags enum

SetupEntityGrid: initializes entity hash grid for broad-phase collision detection and raytracing entity grid partitions the space along x and axes; grid's axisz can be aligned with any world axis (0-x,1-y,2- log2PODscale sets how many grid cells comprise one on-demand physicalization sector (on_demand_sector = 1<

Simulates an explosion in the world, affecting entities near the epicenter (and within the specified radius)

#include 

// Example of how an explosion can be simulated in the world, affecting entities near the epicenter
void SimulateExplosion()
{
    // The position at which the explosion epicenter is, in world coordinates
    const Vec3 explosionPosition = ZERO;
    // Radius from the epicenter that the explosion will affect
    const float explosionRadius = 10.f;

    // Populate the pe_explosion structure
    pe_explosion explosion;
    // Set the epicenter and epicenter impulse (identical for the sake of this example)
    explosion.epicenter = explosion.epicenterImp = explosionPosition;
    // Set the radius, we keep it uniform for the sake of this example - but can be made to scale downwards further into the radius
    explosion.rmin = explosion.rmax = explosion.r = explosionRadius;

    // Simulate the explosion
    gEnv->pPhysicalWorld->SimulateExplosion(&explosion);
}

TimeStep - the main world's function flags - entity types to update (ent_..; ent_deleted to purge deletion physics-on-demand state monitoring)

Traces ray requests (rwi calls with rwi_queue set); logs and calls EventPhysRWIResult for each returns the number of rays traced

UpdateDeformingEntities - normally this happens automatically during TimeStep; can be called manually for ex. during loading.

normally this happens during TimeStep