Skip to content

A fast 2D and 3D game engine — TypeScript SDK, C++/WebAssembly core, visual editor. Ship one project to web, desktop, WeChat MiniGames, playable ads, and native Android / iOS.

7.6 KB
Raw Blame
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// SPDX-FileCopyrightText: Copyright (c) 2008-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
// SPDX-License-Identifier: Apache-2.0

#ifndef PXS_SIMPLE_ISLAND_GEN_H
#define PXS_SIMPLE_ISLAND_GEN_H

#include "foundation/PxUserAllocated.h"
#include "PxsIslandSim.h"
#include "CmTask.h"

/*
PT: runs first part of the island gen's second pass in parallel with the Pxg-level constraint partitioning.

mIslandGen task spawns Pxg constraint partitioning task(s).
mIslandGen runs processNarrowPhaseTouchEvents() in parallel with Pxg.

///////////////////////////////////////////////////////////////////////////////

Previous design:

mPostIslandGen runs as a continuation task after mIslandGen and Pxg.

mPostIslandGen mainly runs mSetEdgesConnectedTask, which:
- calls mSimpleIslandManager->setEdgeConnected()
- calls mSimpleIslandManager-secondPassIslandGen()
- calls wakeObjectsUp()

///////////////////////////////////////////////////////////////////////////////

New design:

postIslandGen is not a task anymore (mPostIslandGen does not exist).
postIslandGen is directly called at the end of mIslandGen.
So it now runs in parallel with Pxg.
mIslandGen and Pxg continue to mSolver task.

postIslandGen mainly runs mSetEdgesConnectedTask, which:
- calls mSimpleIslandManager->setEdgeConnected()
- calls mSimpleIslandManager->secondPassIslandGenPart1()

mSolver now first runs the parts that don't overlap with Pxg:
- calls mSimpleIslandManager-secondPassIslandGenPart2()
- calls wakeObjectsUp()

///////////////////////////////////////////////////////////////////////////////

Before:
mIslandGen->processNarrowPhaseTouchEvents	|mPostIslandGen											|mSolver
=>PxgConstraintPartition					|=>setEdgesConnected->secondPassIslandGen->wakeObjectsUp|

After:
mIslandGen->processNarrowPhaseTouchEvents->postIslandGen									|secondPassIslandGenPart2->wakeObjectsUp->mSolver
=>PxgConstraintPartition					=>setEdgesConnected->secondPassIslandGenPart1	|
*/
#define USE_SPLIT_SECOND_PASS_ISLAND_GEN	1

namespace physx
{
	class PxsContactManager;

// PT: TODO: fw declaring an Sc class here is not good
namespace Sc
{
	class Interaction;
}

namespace Dy
{
	struct Constraint;
}

namespace IG
{
	class SimpleIslandManager;

class ThirdPassTask : public Cm::Task
{
	SimpleIslandManager& mIslandManager;
	IslandSim& mIslandSim;

public:

	ThirdPassTask(PxU64 contextID, SimpleIslandManager& islandManager, IslandSim& islandSim);

	virtual void runInternal() PX_OVERRIDE;

	virtual const char* getName() const PX_OVERRIDE
	{
		return "ThirdPassIslandGenTask";
	}

private:
	PX_NOCOPY(ThirdPassTask)
};

class PostThirdPassTask : public Cm::Task
{
	SimpleIslandManager& mIslandManager;

public:

	PostThirdPassTask(PxU64 contextID, SimpleIslandManager& islandManager);

	virtual void runInternal() PX_OVERRIDE;

	virtual const char* getName() const PX_OVERRIDE
	{
		return "PostThirdPassTask";
	}
private:
	PX_NOCOPY(PostThirdPassTask)
};

class AuxCpuData
{
	public:
	PX_FORCE_INLINE PxsContactManager*	getContactManager(IG::EdgeIndex edgeId)	const { return reinterpret_cast<PxsContactManager*>(mConstraintOrCm[edgeId]);	}
	PX_FORCE_INLINE Dy::Constraint*		getConstraint(IG::EdgeIndex edgeId)		const { return reinterpret_cast<Dy::Constraint*>(mConstraintOrCm[edgeId]);		}

	Cm::BlockArray<void*>	mConstraintOrCm;	//! Pointers to either the constraint or Cm for this pair
};

class SimpleIslandManager : public PxUserAllocated
{
	HandleManager<PxU32> mNodeHandles;		//! Handle manager for nodes
	HandleManager<EdgeIndex> mEdgeHandles;	//! Handle manager for edges

	//An array of destroyed nodes
	PxArray<PxNodeIndex> mDestroyedNodes;
	Cm::BlockArray<Sc::Interaction*> mInteractions;

	//Edges destroyed this frame
	PxArray<EdgeIndex> mDestroyedEdges;
	GPUExternalData	mGpuData;

	CPUExternalData	mCpuData;
	AuxCpuData		mAuxCpuData;

	PxBitMap mConnectedMap;

	// PT: TODO: figure out why we still need both
	IslandSim mAccurateIslandManager;
	IslandSim mSpeculativeIslandManager;

	ThirdPassTask mSpeculativeThirdPassTask;
	ThirdPassTask mAccurateThirdPassTask;

	PostThirdPassTask mPostThirdPassTask;
	PxU32 mMaxDirtyNodesPerFrame;

	const PxU64	mContextID;
	const bool mGPU;
public:

	SimpleIslandManager(bool useEnhancedDeterminism, bool gpu, PxU64 contextID);
	~SimpleIslandManager();

	PxNodeIndex	addNode(bool isActive, bool isKinematic, Node::NodeType type, void* object);
	void		removeNode(const PxNodeIndex index);

	// PT: these two functions added for multithreaded implementation of Sc::Scene::islandInsertion
	void preallocateContactManagers(PxU32 nb, EdgeIndex* handles);
	bool addPreallocatedContactManager(EdgeIndex handle, PxsContactManager* manager, PxNodeIndex nodeHandle1, PxNodeIndex nodeHandle2, Sc::Interaction* interaction, Edge::EdgeType edgeType);

	EdgeIndex addContactManager(PxsContactManager* manager, PxNodeIndex nodeHandle1, PxNodeIndex nodeHandle2, Sc::Interaction* interaction, Edge::EdgeType edgeType);
	EdgeIndex addConstraint(Dy::Constraint* constraint, PxNodeIndex nodeHandle1, PxNodeIndex nodeHandle2, Sc::Interaction* interaction);

	PX_FORCE_INLINE	PxIntBool isEdgeConnected(EdgeIndex edgeIndex) const { return mConnectedMap.test(edgeIndex); }

	void activateNode(PxNodeIndex index);
	void deactivateNode(PxNodeIndex index);
	void putNodeToSleep(PxNodeIndex index);

	void removeConnection(EdgeIndex edgeIndex);
	
	void firstPassIslandGen();
	void additionalSpeculativeActivation();
	void secondPassIslandGen();
	void secondPassIslandGenPart1();
	void secondPassIslandGenPart2();
	void thirdPassIslandGen(PxBaseTask* continuation);

	PX_INLINE void clearDestroyedPartitionEdges()
	{
		mGpuData.mDestroyedPartitionEdges.forceSize_Unsafe(0);
	}

	void setEdgeConnected(EdgeIndex edgeIndex, Edge::EdgeType edgeType);
	void setEdgeDisconnected(EdgeIndex edgeIndex);

	void setEdgeRigidCM(const EdgeIndex edgeIndex, PxsContactManager* cm);

	void clearEdgeRigidCM(const EdgeIndex edgeIndex);

	void setKinematic(PxNodeIndex nodeIndex);

	void setDynamic(PxNodeIndex nodeIndex);

	PX_FORCE_INLINE	IslandSim&			getSpeculativeIslandSim()			{ return mSpeculativeIslandManager;	}
	PX_FORCE_INLINE	const IslandSim&	getSpeculativeIslandSim()	const	{ return mSpeculativeIslandManager;	}

	PX_FORCE_INLINE	IslandSim&			getAccurateIslandSim()				{ return mAccurateIslandManager;	}
	PX_FORCE_INLINE	const IslandSim&	getAccurateIslandSim()		const	{ return mAccurateIslandManager;	}

	PX_FORCE_INLINE	const AuxCpuData&	getAuxCpuData()				const	{ return mAuxCpuData;				}

	PX_FORCE_INLINE PxU32				getNbEdgeHandles()			const	{ return mEdgeHandles.getTotalHandles(); }

	PX_FORCE_INLINE PxU32				getNbNodeHandles()			const	{ return mNodeHandles.getTotalHandles(); }

	void deactivateEdge(const EdgeIndex edge);

	PX_FORCE_INLINE PxsContactManager*	getContactManager(IG::EdgeIndex edgeId)	const { return reinterpret_cast<PxsContactManager*>(mAuxCpuData.mConstraintOrCm[edgeId]);	}
	PX_FORCE_INLINE Dy::Constraint*		getConstraint(IG::EdgeIndex edgeId)		const { return reinterpret_cast<Dy::Constraint*>(mAuxCpuData.mConstraintOrCm[edgeId]);		}

	PX_FORCE_INLINE Sc::Interaction*	getInteractionFromEdgeIndex(IG::EdgeIndex edgeId) const { return mInteractions[edgeId]; }

	PX_FORCE_INLINE	PxU64				getContextId() const { return mContextID; }

	bool checkInternalConsistency();

private:

	friend class ThirdPassTask;
	friend class PostThirdPassTask;

	bool		validateDeactivations() const;
	EdgeIndex	addEdge(void* edge, PxNodeIndex nodeHandle1, PxNodeIndex nodeHandle2, Sc::Interaction* interaction);
	EdgeIndex	resizeEdgeArrays(EdgeIndex handle, bool flag);

	PX_NOCOPY(SimpleIslandManager)
};

}
}

#endif