GridCollisionDetectionSystem Class

Collision detection system using uniform spatial partitioning for Broadphase and AABB overlaps in the Narrowphase. More...

Declaration

class helios::engine::modules::physics::collision::systems::GridCollisionDetectionSystem { ... }

Base class

class	System
	Abstract base class for game systems. More...

Public Constructors Index

	GridCollisionDetectionSystem (const helios::math::aabbf &bounds, const float cellSize)
	Constructs a GridCollisionDetectionSystem with specified bounds and cell size. More...

Public Member Functions Index

void	update (helios::engine::runtime::world::UpdateContext &updateContext) noexcept override
	Performs collision detection for all active entities. More...
helios::math::aabbi	worldBoundsToGridBounds (const helios::math::aabbf &aabbf) const noexcept
	Converts world-space AABB bounds to grid cell indices. More...
void	updateCollisionCandidate (helios::engine::ecs::GameObject *go, const helios::math::aabbi &bounds, AabbColliderComponent *aabbColliderComponent, CollisionComponent *collisionComponent, CollisionStateComponent *collisionStateComponent)
	Inserts a collision candidate into all grid cells it overlaps. More...
void	solveCell (GridCell &cell, helios::engine::runtime::world::UpdateContext &updateContext)
	Performs narrow-phase collision detection for all candidates in a cell. More...
GridCell &	cell (const unsigned int x, const unsigned int y, const unsigned int z) noexcept
	Accesses a grid cell by its 3D coordinates. More...
constexpr size_t	cellIndex (const unsigned int x, const unsigned int y, const unsigned int z) const noexcept
	Computes the 1D index of a cell in a 3D grid based on its x, y, and z coordinates. More...
unsigned int	cellsX () const noexcept
	Returns the number of cells along the X axis. More...
unsigned int	cellsY () const noexcept
	Returns the number of cells along the Y axis. More...
unsigned int	cellsZ () const noexcept
	Returns the number of cells along the Z axis. More...

Private Member Functions Index

void	initGrid ()
	Initializes the grid based on world bounds and cell size. More...
void	prepareCollisionDetection ()
	Prepares the grid for a new collision detection pass. More...
void	postEvent (const helios::engine::ecs::GameObject *candidate, const helios::engine::ecs::GameObject *match, const helios::math::vec3f contact, const CollisionStruct collisionStruct, const helios::engine::runtime::world::UpdateContext &updateContext, CollisionStateComponent *csc_a, CollisionStateComponent *csc_b) const noexcept
	Posts collision events to the UpdateContext's event sink. More...
CollisionStruct	findCollisionType (const CollisionComponent *cc, const CollisionComponent *matchCC) const noexcept
	Determines the collision type between two entities based on their layer masks. More...

Private Member Attributes Index

std::unordered_set< std::pair< helios::util::Guid, helios::util::Guid >, GuidPairHash >	solvedCollisions_
	Set of already-processed collision pairs to avoid duplicate events. More...
float	cellSize_
	Size of each grid cell in world units. More...
helios::math::aabbf	gridBounds_
	World-space bounds defining the spatial region covered by the grid. More...
std::vector< GridCell >	cells_
	Flat storage for all grid cells, indexed as x + y * cellsX + z * (cellsX * cellsY). More...
unsigned int	cellsX_
	Number of cells along the X axis. More...
unsigned int	cellsY_
	Number of cells along the Y axis. More...
unsigned int	cellsZ_
	Number of cells along the Z axis. More...
std::vector< size_t >	trackedCells_
	Helper to keep track of updated cells (with potential collisions candidates) in one pass. More...

Private Static Attributes Index

static const auto &	logger_ = helios::util::log::LogManager::loggerForScope(HELIOS_LOG_SCOPE)
	Scoped logger instance for structured logging within the current context. More...

Description

Collision detection system using uniform spatial partitioning for Broadphase and AABB overlaps in the Narrowphase.

This system implements a grid-based spatial partitioning approach for efficient collision detection, following the principles outlined in Ericson's "Real-Time Collision Detection" (Chapter 7). The algorithm divides the world into a uniform 3D grid of cells and assigns each collidable entity to the cells it overlaps.

The detection process consists of two phases: 1. **Broadphase:** Entities are inserted into grid cells based on their AABB. Only entities sharing the same cell are considered potential collision pairs. 2. **Narrowphase:** For each cell with multiple candidates, AABB intersection tests determine actual collisions.

Collision events are published to the `UpdateContext`'s event sink, distinguishing between:

• **Solid collisions:** Symmetric collisions where both entities can physically interact.
• **Trigger collisions:** Asymmetric collisions for gameplay logic (e.g., pickups, zones).

During the broadphase, the system uses additional layer masks to filter which entity types can collide with each other, enabling fine-grained control over collision pairs.

See Also

CollisionComponent

See Also

AabbColliderComponent

See Also

TriggerCollisionEvent

See Also

SolidCollisionEvent

See Also

[Eri05, Chapter 7]

Definition at line 74 of file GridCollisionDetectionSystem.ixx.

Public Constructors

GridCollisionDetectionSystem()

helios::engine::modules::physics::collision::systems::GridCollisionDetectionSystem::GridCollisionDetectionSystem (const helios::math::aabbf & bounds, const float cellSize)

inline explicit

Constructs a GridCollisionDetectionSystem with specified bounds and cell size.

The grid is initialized to cover the given world bounds. Cell size determines the granularity of spatial partitioning; smaller cells reduce false positives but increase memory and insertion overhead.

Parameters

bounds	World-space AABB defining the region where collision detection is active.
cellSize	Size of each grid cell in world units. Must be greater than zero.

info

Given n objects, the 1/3 rule should be applied for determining the number of cells for partitioning, i.e. with n objects, the cube should consist of k x k x k cells, with k = n^{1/3} - that is, on average, one cell fits one object that should be tested for collision. Dimensions of said cells are derived by taking the reference space into account, e.g. WorldBounds.size/k (see [HS99]).

Definition at line 385 of file GridCollisionDetectionSystem.ixx.

385 explicit GridCollisionDetectionSystem(

386 const helios::math::aabbf& bounds,

387 const float cellSize

388 ) : gridBounds_(bounds),

389 cellSize_(cellSize) {

390 assert(cellSize_ > 0.0f && "cellSize must not be <= 0.0f");

391 initGrid();

392 }

Public Member Functions

cell()

GridCell & helios::engine::modules::physics::collision::systems::GridCollisionDetectionSystem::cell (const unsigned int x, const unsigned int y, const unsigned int z)

inline nodiscard noexcept

Accesses a grid cell by its 3D coordinates.

Parameters

x	X-coordinate of the cell (0 to cellsX - 1).
y	Y-coordinate of the cell (0 to cellsY - 1).
z	Z-coordinate of the cell (0 to cellsZ - 1).

Returns

Reference to the GridCell at the specified coordinates.

Definition at line 622 of file GridCollisionDetectionSystem.ixx.

622 [[nodiscard]] inline GridCell& cell(const unsigned int x, const unsigned int y, const unsigned int z) noexcept {

623 return cells_[cellIndex(x, y, z)];

624 }

Reference cellIndex.

Referenced by solveCell and updateCollisionCandidate.

cellIndex()

size_t helios::engine::modules::physics::collision::systems::GridCollisionDetectionSystem::cellIndex (const unsigned int x, const unsigned int y, const unsigned int z)

inline nodiscard constexpr noexcept

Computes the 1D index of a cell in a 3D grid based on its x, y, and z coordinates.

Parameters

x	The x-coordinate of the cell (must be less than the grid's x-dimension).
y	The y-coordinate of the cell (must be less than the grid's y-dimension).
z	The z-coordinate of the cell (must be less than the grid's z-dimension).

Returns

The 1D index of the cell in the grid.

Definition at line 635 of file GridCollisionDetectionSystem.ixx.

635 [[nodiscard]] inline constexpr size_t cellIndex(const unsigned int x, const unsigned int y, const unsigned int z) const noexcept {

636 assert (x < cellsX_ && y < cellsY_ && z < cellsZ_ && "Invalid range values");

637

638 return x + y * cellsX_ + (z * cellsX_ * cellsY_);

639 }

Referenced by cell and updateCollisionCandidate.

cellsX()

unsigned int helios::engine::modules::physics::collision::systems::GridCollisionDetectionSystem::cellsX ()

inline nodiscard noexcept

Returns the number of cells along the X axis.

Returns

Number of grid cells in the X dimension.

Definition at line 646 of file GridCollisionDetectionSystem.ixx.

646 [[nodiscard]] unsigned int cellsX() const noexcept {

647 return cellsX_;

648 }

cellsY()

unsigned int helios::engine::modules::physics::collision::systems::GridCollisionDetectionSystem::cellsY ()

inline nodiscard noexcept

Returns the number of cells along the Y axis.

Returns

Number of grid cells in the Y dimension.

Definition at line 655 of file GridCollisionDetectionSystem.ixx.

655 [[nodiscard]] unsigned int cellsY() const noexcept {

656 return cellsY_;

657 }

cellsZ()

unsigned int helios::engine::modules::physics::collision::systems::GridCollisionDetectionSystem::cellsZ ()

inline nodiscard noexcept

Returns the number of cells along the Z axis.

Returns

Number of grid cells in the Z dimension.

Definition at line 664 of file GridCollisionDetectionSystem.ixx.

664 [[nodiscard]] unsigned int cellsZ() const noexcept {

665 return cellsZ_;

666 }

solveCell()

void helios::engine::modules::physics::collision::systems::GridCollisionDetectionSystem::solveCell (GridCell & cell, helios::engine::runtime::world::UpdateContext & updateContext)

inline

Performs narrow-phase collision detection for all candidates in a cell.

Tests all unique pairs of collision candidates within the cell using AABB intersection. For each collision detected, determines collision type (solid/trigger) based on layer masks and publishes appropriate events. Uses a solved-set to avoid duplicate events when entities span multiple cells.

Parameters

cell	The grid cell containing collision candidates to test.
updateContext	Context for pushing collision events to the event queue.

Definition at line 546 of file GridCollisionDetectionSystem.ixx.

546 inline void solveCell(GridCell& cell, helios::engine::runtime::world::UpdateContext& updateContext) {

547

548 auto& candidates = cell.collisionCandidates;

549

550 // we will skip this cell if none of the candidates reports a collision

551 bool isCollisionReporter = false;

552 for (const auto& candidate : candidates) {

553 if (candidate.collisionComponent->isCollisionReporter()) {

554 isCollisionReporter = true;

555 break;

556 }

557 }

558

559 if (!isCollisionReporter) {

560 return;

561 }

562

563 for (size_t i = 0; i < candidates.size(); i++) {

564

565 CollisionCandidate& candidate = candidates[i];

566 CollisionComponent* cc = candidate.collisionComponent;

567 CollisionStateComponent* csc = candidate.collisionStateComponent;

568

569 const helios::math::aabbf& aabbCandidate = candidate.aabbColliderComponent->bounds();

570

571 for (size_t j = i+1; j < candidates.size(); j++) {

572

573 auto& [gameObject, aabbColliderComponent, collisionComponent, collisionStateComponent] = candidates[j];

574

575 CollisionComponent* matchCC = collisionComponent;

576 CollisionStateComponent* matchCSC = collisionStateComponent;

577

578 const auto collisionStruct = findCollisionType(cc, matchCC);

579

580 if (!collisionStruct.hasAnyInteraction()) {

581 continue;

582 }

583

584 const helios::math::aabbf& aabbMatch = aabbColliderComponent->bounds();

585 if (!aabbCandidate.intersects(aabbMatch)) {

586 continue;

587 }

588

589 auto lGuid = candidate.gameObject->guid();

590 auto rGuid = gameObject->guid();

591

592 if (lGuid > rGuid) {

593 std::swap(lGuid, rGuid);

594 }

595

596 // if we have already processed a collision, do not add this collision again.

597 if (solvedCollisions_.contains({lGuid, rGuid})) {

598 continue;

599 }

600

601 solvedCollisions_.insert({lGuid, rGuid});

602

603 postEvent(

604 candidate.gameObject, gameObject,

605 helios::math::overlapCenter(aabbCandidate, aabbMatch),

606 collisionStruct,

607 updateContext, csc, matchCSC

608 );

609 }

610 }

611 }

References helios::engine::modules::physics::collision::components::AabbColliderComponent::bounds, cell, helios::engine::ecs::GameObject::guid, helios::math::aabb< T >::intersects and helios::math::overlapCenter.

Referenced by update.

update()

void helios::engine::modules::physics::collision::systems::GridCollisionDetectionSystem::update (helios::engine::runtime::world::UpdateContext & updateContext)

inline noexcept virtual

Performs collision detection for all active entities.

Executes the complete collision detection pipeline each frame: 1. Clears all grid cells and resets solved collision pairs. 2. Iterates all active GameObjects with CollisionComponent and AabbColliderComponent. 3. Inserts each entity into all grid cells its AABB overlaps. 4. For each cell with multiple candidates, runs narrow-phase AABB intersection tests. 5. Publishes collision events (TriggerCollisionEvent, SolidCollisionEvent) to the event queue.

Parameters

updateContext

The update context providing access to GameWorld and event queue.

Definition at line 406 of file GridCollisionDetectionSystem.ixx.

406 void update(helios::engine::runtime::world::UpdateContext& updateContext) noexcept override {

407

408 prepareCollisionDetection();

409

410 // only consider enabled CollisionSettingsComponents

411 constexpr auto filter = helios::engine::ecs::query::GameObjectFilter::Active | helios::engine::ecs::query::GameObjectFilter::ComponentEnabled;

412

413 for (auto [entity, cc, csc, acc] : gameWorld_->find<

414 CollisionComponent,

415 CollisionStateComponent,

416 AabbColliderComponent

417

418 >(filter).each()) {

419

420 if (!acc->boundsInitialized()) {

421 continue;

422 }

423

424 if (!cc->isEnabled() || (cc->triggerCollisionMask() == 0 && cc->solidCollisionMask() == 0)) {

425 continue;

426 }

427

428 const auto& worldBounds = acc->bounds();

429

430 updateCollisionCandidate(

431 entity,

432 worldBoundsToGridBounds(worldBounds),

433 acc,

434 cc,

435 csc

436 );

437 }

438

439 for (const auto idx : trackedCells_) {

440

441 if (cells_[idx].collisionCandidates.size() < 2) {

442 continue;

443 }

444

445 solveCell(cells_[idx], updateContext);

446 }

447 }

References helios::engine::ecs::query::Active, helios::engine::ecs::query::ComponentEnabled, helios::engine::ecs::System::gameWorld_, helios::engine::ecs::Component::isEnabled, helios::engine::modules::physics::collision::components::CollisionComponent::solidCollisionMask, solveCell, helios::engine::modules::physics::collision::components::CollisionComponent::triggerCollisionMask, updateCollisionCandidate and worldBoundsToGridBounds.

updateCollisionCandidate()

void helios::engine::modules::physics::collision::systems::GridCollisionDetectionSystem::updateCollisionCandidate (helios::engine::ecs::GameObject * go, const helios::math::aabbi & bounds, AabbColliderComponent * aabbColliderComponent, CollisionComponent * collisionComponent, CollisionStateComponent * collisionStateComponent)

inline

Inserts a collision candidate into all grid cells it overlaps.

Iterates through all cells within the given bounds and adds the candidate to each cell's collision candidate list for subsequent narrow-phase testing.

Parameters

go	Pointer to the GameObject entity.
bounds	Grid cell index bounds (integer AABB) the entity spans.
aabbColliderComponent	Pointer to the entity's AABB collider component.
collisionComponent	Pointer to the entity's collision component.

Definition at line 495 of file GridCollisionDetectionSystem.ixx.

495 inline void updateCollisionCandidate(

496 helios::engine::ecs::GameObject* go,

497 const helios::math::aabbi& bounds,

498 AabbColliderComponent* aabbColliderComponent,

499 CollisionComponent* collisionComponent,

500 CollisionStateComponent* collisionStateComponent

501 ) {

502 const auto xMin = bounds.min()[0];

503 const auto xMax = bounds.max()[0];

504 const auto yMin = bounds.min()[1];

505 const auto yMax = bounds.max()[1];

506 const auto zMin = bounds.min()[2];

507 const auto zMax = bounds.max()[2];

508

509 for (int x = xMin; x <= xMax; x++) {

510 for (int y = yMin; y <= yMax; y++) {

511 for (int z = zMin; z <= zMax; z++) {

512 auto& [collisionCandidates] = cell(x, y, z);

513

514 collisionCandidates.push_back(

515 CollisionCandidate{

516 go,

517 aabbColliderComponent,

518 collisionComponent,

519 collisionStateComponent

520 }

521 );

522

523 // only consider the first added to prevent dups

524 if (collisionCandidates.size() == 1) {

525 const auto idx = cellIndex(x, y, z);

526 trackedCells_.push_back(idx);

527 }

528 }

529 }

530 }

531

532 }

References cell, cellIndex, helios::math::aabb< T >::max and helios::math::aabb< T >::min.

Referenced by update.

worldBoundsToGridBounds()

helios::math::aabbi helios::engine::modules::physics::collision::systems::GridCollisionDetectionSystem::worldBoundsToGridBounds (const helios::math::aabbf & aabbf)

inline nodiscard noexcept

Converts world-space AABB bounds to grid cell indices.

Transforms a floating-point AABB in world space to integer cell coordinates, clamped to the valid grid range. Used to determine which cells an entity occupies.

Parameters

aabbf

The world-space AABB to convert.

Returns

An integer AABB representing the range of grid cell indices the entity spans.

Definition at line 460 of file GridCollisionDetectionSystem.ixx.

460 [[nodiscard]] helios::math::aabbi worldBoundsToGridBounds(const helios::math::aabbf& aabbf) const noexcept {

461

462 helios::math::vec3f min = aabbf.min() - gridBounds_.min();

463 helios::math::vec3f max = aabbf.max() - gridBounds_.min();

464

465 int xMin = static_cast<int>(std::floor(min[0] / cellSize_));

466 int yMin = static_cast<int>(std::floor(min[1] / cellSize_));

467 int zMin = static_cast<int>(std::floor(min[2] / cellSize_));

468

469 int xMax = static_cast<int>(std::floor(max[0] / cellSize_));

470 int yMax = static_cast<int>(std::floor(max[1] / cellSize_));

471 int zMax = static_cast<int>(std::floor(max[2] / cellSize_));

472

473 return helios::math::aabbi{

474 std::clamp(xMin, 0, static_cast<int>(cellsX_ - 1)),

475 std::clamp(yMin, 0, static_cast<int>(cellsY_ - 1)),

476 std::clamp(zMin, 0, static_cast<int>(cellsZ_ - 1)),

477 std::clamp(xMax, 0, static_cast<int>(cellsX_ - 1)),

478 std::clamp(yMax, 0, static_cast<int>(cellsY_ - 1)),

479 std::clamp(zMax, 0, static_cast<int>(cellsZ_ - 1)),

480 };

481 }

References helios::math::aabb< T >::max and helios::math::aabb< T >::min.

Referenced by update.

Private Member Functions

findCollisionType()

CollisionStruct helios::engine::modules::physics::collision::systems::GridCollisionDetectionSystem::findCollisionType (const CollisionComponent * cc, const CollisionComponent * matchCC)

inline nodiscard noexcept

Determines the collision type between two entities based on their layer masks.

Evaluates both solid and trigger collision masks to determine if and how two entities can collide. Solid collisions are symmetric (both entities must accept collision with each other), while trigger collisions are asymmetric (either entity can trigger).

Parameters

cc	Collision component of the first entity.
matchCC	Collision component of the second entity.

Returns

CollisionStruct a struct with the requested collision information.

Definition at line 321 of file GridCollisionDetectionSystem.ixx.

321 [[nodiscard]] inline CollisionStruct findCollisionType(

322 const CollisionComponent* cc,

323 const CollisionComponent* matchCC

324 ) const noexcept {

325

326 auto isSolidCollision = false;

327 auto isTriggerCollision = false;

328

329 auto aIsCollisionReporter = cc->isCollisionReporter();

330 auto bIsCollisionReporter = matchCC->isCollisionReporter();

331

332 // none of the reports a collision as a pair? skip!

333 if (!aIsCollisionReporter && !bIsCollisionReporter) {

334 return CollisionStruct{};

335 }

336

337 bool aCanSolidCollideWithB = (cc->solidCollisionMask() & matchCC->layerId()) != 0;

338 bool bCanSolidCollideWithA = (matchCC->solidCollisionMask() & cc->layerId()) != 0;

339

340 bool aCanTriggerCollideWithB = (cc->triggerCollisionMask() & matchCC->layerId()) != 0;

341 bool bCanTriggerCollideWithA = (matchCC->triggerCollisionMask() & cc->layerId()) != 0;

342

343 // solid collision is treated symmetric

344 isSolidCollision = aCanSolidCollideWithB && bCanSolidCollideWithA;

345

346 #if HELIOS_DEBUG

347 // detect asymmetric solid collision

348 if (aCanSolidCollideWithB && !bCanSolidCollideWithA) {

349 logger_.warn("Collision Asymmetry detected!");

350 }

351 #endif

352

353 // trigger collision is treated asymmetric

354 isTriggerCollision = aCanTriggerCollideWithB || bCanTriggerCollideWithA;

355

356 return CollisionStruct {

357 isSolidCollision,

358 isTriggerCollision,

359 aIsCollisionReporter,

360 bIsCollisionReporter,

361 isSolidCollision

362 ? cc->solidCollisionBehavior(matchCC->layerId()) : cc->triggerCollisionBehavior(matchCC->layerId()),

363 isSolidCollision

364 ? matchCC->solidCollisionBehavior(cc->layerId()) : matchCC->triggerCollisionBehavior(cc->layerId())

365 };

366 }

initGrid()

void helios::engine::modules::physics::collision::systems::GridCollisionDetectionSystem::initGrid ()

inline

Initializes the grid based on world bounds and cell size.

Computes the number of cells needed in each dimension and allocates the cell storage.

Definition at line 225 of file GridCollisionDetectionSystem.ixx.

225 void initGrid() {

226

227 helios::math::vec3f size = gridBounds_.size();

228

229 cellsX_ = std::max(1u, static_cast<unsigned int>(std::ceil(size[0] / cellSize_)));

230 cellsY_ = std::max(1u, static_cast<unsigned int>(std::ceil(size[1] / cellSize_)));

231 cellsZ_ = std::max(1u, static_cast<unsigned int>(std::ceil(size[2] / cellSize_)));

232

233 const size_t cellCount = static_cast<size_t>(cellsX_) * cellsY_ * cellsZ_;

234

235 // this would make 100'000'000 * sizeof(GridCell) Bytes

236 // if we have 24 Bytes per GridCell, we end up with 2,4 GB alone for this spatial grid.

237 if (cellCount > 100'000'000) {

238 logger_.warn(std::format("Spatial Grid requested {0} cells", cellCount));

239 throw std::runtime_error("Cell count too high.");

240 }

241

242 trackedCells_.reserve(cellCount);

243 cells_.resize(cellCount);

244 }

postEvent()

void helios::engine::modules::physics::collision::systems::GridCollisionDetectionSystem::postEvent (const helios::engine::ecs::GameObject * candidate, const helios::engine::ecs::GameObject * match, const helios::math::vec3f contact, const CollisionStruct collisionStruct, const helios::engine::runtime::world::UpdateContext & updateContext, CollisionStateComponent * csc_a, CollisionStateComponent * csc_b)

inline noexcept

Posts collision events to the UpdateContext's event sink.

Updates the CollisionStateComponent of both entities with collision information including contact point, collision type, behavior, and reporter status. An entity marked as collision reporter receives the event as the "source" entity.

Parameters

candidate	First collision candidate (potential event source).
match	Second collision candidate (collision partner).
contact	The contact point between the two AABBs.
collisionStruct	Struct containing collision type and behavior information.
updateContext	Context for pushing events to the event queue.
csc_a	Collision state component of the first entity.
csc_b	Collision state component of the second entity.

Definition at line 276 of file GridCollisionDetectionSystem.ixx.

276 inline void postEvent(

277 const helios::engine::ecs::GameObject* candidate,

278 const helios::engine::ecs::GameObject* match,

279 const helios::math::vec3f contact,

280 const CollisionStruct collisionStruct,

281 const helios::engine::runtime::world::UpdateContext& updateContext,

282 CollisionStateComponent* csc_a,

283 CollisionStateComponent* csc_b

284 ) const noexcept {

285

286 bool aIsCollisionReporter = collisionStruct.aIsCollisionReporter;

287 bool bIsCollisionReporter = collisionStruct.bIsCollisionReporter;

288 bool isSolidCollision = collisionStruct.isSolidCollision;

289 bool isTriggerCollision = collisionStruct.isTriggerCollision;

290

291 assert((isSolidCollision || isTriggerCollision)

292 && (aIsCollisionReporter || bIsCollisionReporter)

293 && "Preconditions not matched for postEvent.");

294

295 // post the events

296 if (isTriggerCollision || isSolidCollision) {

297 csc_a->setState(

298 contact, isSolidCollision, isTriggerCollision, collisionStruct.aCollisionBehavior,

299 aIsCollisionReporter, match->guid()

300 );

301 csc_b->setState(

302 contact, isSolidCollision, isTriggerCollision, collisionStruct.bCollisionBehavior,

303 bIsCollisionReporter, candidate->guid()

304 );

305 }

306

307 }

prepareCollisionDetection()

void helios::engine::modules::physics::collision::systems::GridCollisionDetectionSystem::prepareCollisionDetection ()

inline

Prepares the grid for a new collision detection pass.

Clears all collision candidates from every cell and resets the set of already-solved collision pairs.

Definition at line 252 of file GridCollisionDetectionSystem.ixx.

252 inline void prepareCollisionDetection() {

253 for (const auto idx : trackedCells_) {

254 cells_[idx].clear();

255 }

256

257 trackedCells_.clear();

258 solvedCollisions_.clear();

259 }

Private Member Attributes

cells_

std::vector<GridCell> helios::engine::modules::physics::collision::systems::GridCollisionDetectionSystem::cells_

Flat storage for all grid cells, indexed as x + y * cellsX + z * (cellsX * cellsY).

Definition at line 197 of file GridCollisionDetectionSystem.ixx.

197 std::vector<GridCell> cells_;

cellSize_

float helios::engine::modules::physics::collision::systems::GridCollisionDetectionSystem::cellSize_

Size of each grid cell in world units.

Definition at line 187 of file GridCollisionDetectionSystem.ixx.

187 float cellSize_;

cellsX_

unsigned int helios::engine::modules::physics::collision::systems::GridCollisionDetectionSystem::cellsX_

Number of cells along the X axis.

Definition at line 202 of file GridCollisionDetectionSystem.ixx.

202 unsigned int cellsX_;

cellsY_

unsigned int helios::engine::modules::physics::collision::systems::GridCollisionDetectionSystem::cellsY_

Number of cells along the Y axis.

Definition at line 207 of file GridCollisionDetectionSystem.ixx.

207 unsigned int cellsY_;

cellsZ_

unsigned int helios::engine::modules::physics::collision::systems::GridCollisionDetectionSystem::cellsZ_

Number of cells along the Z axis.

Definition at line 212 of file GridCollisionDetectionSystem.ixx.

212 unsigned int cellsZ_;

gridBounds_

helios::math::aabbf helios::engine::modules::physics::collision::systems::GridCollisionDetectionSystem::gridBounds_

World-space bounds defining the spatial region covered by the grid.

Definition at line 192 of file GridCollisionDetectionSystem.ixx.

192 helios::math::aabbf gridBounds_;

solvedCollisions_

std::unordered_set<std::pair<helios::util::Guid, helios::util::Guid>, GuidPairHash> helios::engine::modules::physics::collision::systems::GridCollisionDetectionSystem::solvedCollisions_

Set of already-processed collision pairs to avoid duplicate events.

Stores pairs of GUIDs in canonical order (smaller GUID first) to ensure each collision pair is processed only once per frame, even when entities span multiple cells.

Definition at line 182 of file GridCollisionDetectionSystem.ixx.

182 std::unordered_set<std::pair<helios::util::Guid, helios::util::Guid>, GuidPairHash> solvedCollisions_;

trackedCells_

std::vector<size_t> helios::engine::modules::physics::collision::systems::GridCollisionDetectionSystem::trackedCells_

Helper to keep track of updated cells (with potential collisions candidates) in one pass.

Definition at line 217 of file GridCollisionDetectionSystem.ixx.

217 std::vector<size_t> trackedCells_;

Private Static Attributes

logger_

const auto& helios::engine::modules::physics::collision::systems::GridCollisionDetectionSystem::logger_ = helios::util::log::LogManager::loggerForScope(HELIOS_LOG_SCOPE)

static

Scoped logger instance for structured logging within the current context.

Definition at line 174 of file GridCollisionDetectionSystem.ixx.

174 static inline const auto& logger_ = helios::util::log::LogManager::loggerForScope(HELIOS_LOG_SCOPE);

---

The documentation for this class was generated from the following file:

• GridCollisionDetectionSystem.ixx

---

Generated via doxygen2docusaurus 2.0.0 by Doxygen 1.15.0.