Init

kaplademo/source/kaplaDemo/Fracture/Core/SimSceneBase.h

@@ -0,0 +1,275 @@
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+//  * Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+//  * Redistributions in binary form must reproduce the above copyright
+//    notice, this list of conditions and the following disclaimer in the
+//    documentation and/or other materials provided with the distribution.
+//  * Neither the name of NVIDIA CORPORATION nor the names of its
+//    contributors may be used to endorse or promote products derived
+//    from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+// PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Copyright (c) 2018 NVIDIA Corporation. All rights reserved.
+
+#include "RTdef.h"
+#if RT_COMPILE
+#ifndef SIM_SCENE_BASE
+#define SIM_SCENE_BASE
+
+#include "PxSimulationEventCallback.h"
+#include <PsArray.h>
+#include <PsUserAllocated.h>
+#include "PsHashMap.h"
+
+#include "RTdef.h"
+
+namespace physx
+{
+class PxPhysics;
+class PxCooking;
+class PxScene;
+class PxRigidDynamic;
+class PxD6Joint;
+namespace fracture
+{
+namespace base
+{
+
+class Actor;
+class Compound;
+class Convex;
+class FracturePattern;
+class CompoundCreator;
+class Delaunay2d;
+class Delaunay3d;
+class PolygonTriangulator;
+
+// -----------------------------------------------------------------------------------
+class SimScene :  
+	public PxSimulationEventCallback, public ::physx::shdfnd::UserAllocated
+{
+	friend class Actor;
+public:
+	static SimScene* createSimScene(PxPhysics *pxPhysics, PxCooking *pxCooking, bool isGrbScene, float minConvexSize, PxMaterial* defaultMat, const char *resourcePath);
+protected:
+	SimScene(PxPhysics *pxPhysics, PxCooking *pxCooking, bool isGrbScene, float minConvexSize, PxMaterial* defaultMat, const char *resourcePath);
+public:
+	virtual ~SimScene();
+
+	// Creates Scene Level Singletons
+	virtual void createSingletons();
+	// Access singletons
+	CompoundCreator* getCompoundCreator() {return mCompoundCreator;}
+	PolygonTriangulator* getPolygonTriangulator() {return mPolygonTriangulator;}
+
+	// Create non-Singletons
+	virtual Actor* createActor();
+	virtual Convex* createConvex();
+	virtual Compound* createCompound(const FracturePattern *pattern, const FracturePattern *secondaryPattern = NULL, PxReal contactOffset = 0.005f, PxReal restOffset = -0.001f);
+	virtual void clear();
+	void addCompound(Compound *m);
+	void removeCompound(Compound *m);
+	// perform deferred deletion
+	void deleteCompounds();
+
+	void setScene(PxScene* scene) { mScene = scene; }
+	// 
+	bool findCompound(const Compound* c, int& actorNr, int& compoundNr);
+
+	void removeActor(Actor* a);
+
+	// Profiler hooks
+	virtual void profileBegin(const char* /*name*/) {}
+	virtual void profileEnd(const char* /*name*/) {}
+
+	virtual void playSound(const char * /*name*/, int /*nr*/ = -1) {}
+
+	// accessors
+	shdfnd::Array<Compound*> getCompounds(); //{ return mCompounds; }
+	shdfnd::Array<Actor*> getActors() { return mActors; }
+	PxPhysics* getPxPhysics() { return mPxPhysics; }
+	PxCooking* getPxCooking() { return mPxCooking; }
+	PxScene* getScene() { return mScene; }
+
+	//ConvexRenderer &getConvexRenderer() { return mConvexRenderer; }
+
+	void preSim(float dt);
+	void postSim(float dt); //, RegularCell3D* fluidSim);
+
+	void setPlaySounds(bool play) { mPlaySounds = play; }
+	void setContactImpactRadius(float radius) { mContactImpactRadius = radius; }
+	void setNumNoFractureFrames(int num) { mNumNoFractureFrames = num; }
+
+	void setCamera(const PxVec3 &pos, const PxVec3 &dir, const PxVec3 &up, float fov ) {
+		mCameraPos = pos; mCameraDir = dir; mCameraUp = up; mCameraFov = fov;
+	}
+
+	//void draw(bool useShader, Shader* particleShader = NULL) {}
+	//void setShaderMaterial(Shader* shader, const ShaderMaterial& mat) {this->mShader = shader; this->mShaderMat = mat;}
+	//void setFractureForceThreshold(float threshold) { mFractureForceThreshold = threshold; }
+
+	PxMaterial *getPxDefaultMaterial() { return mPxDefaultMaterial; }
+
+	void toggleDebugDrawing() { mDebugDraw = !mDebugDraw; }
+
+	virtual bool pickStart(const PxVec3 &orig, const PxVec3 &dir);
+	virtual void pickMove(const PxVec3 &orig, const PxVec3 &dir);
+	virtual void pickRelease();
+	PxRigidDynamic* getPickActor() { return mPickActor; }
+	const PxVec3 &getPickPos() { return mPickPos; }
+	const PxVec3 &getPickLocalPos() { return mPickLocalPos; }
+
+	// callback interface
+
+	void onContactNotify(unsigned int arraySizes, void ** shape0Array, void ** shape1Array, void ** actor0Array, void ** actor1Array, float * positionArray, float * normalArray);
+	void onConstraintBreak(PxConstraintInfo* constraints, PxU32 count)	{ PX_UNUSED((constraints, count)); }
+	void onWake(PxActor** actors, PxU32 count)							{ PX_UNUSED((actors, count)); }
+	void onSleep(PxActor** actors, PxU32 count)							{ PX_UNUSED((actors, count)); }
+	void onTrigger(PxTriggerPair* pairs, PxU32 count)					{ PX_UNUSED((pairs, count)); }
+	void onContact(const PxContactPairHeader& pairHeader, const PxContactPair* pairs, PxU32 nbPairs);
+	void onAdvance(const PxRigidBody*const* bodyBuffer, const PxTransform* poseBuffer, const PxU32 count) { PX_UNUSED(bodyBuffer);  PX_UNUSED(poseBuffer);  PX_UNUSED(count); }
+
+	void toggleRenderDebris() {mRenderDebris = !mRenderDebris;}
+	bool getRenderDebrs() {return mRenderDebris;}
+	//virtual void dumpSceneGeometry() {}
+	shdfnd::Array<PxVec3>& getDebugPoints();
+	//virtual void createRenderBuffers() {}
+	//void loadAndCreateTextureArrays();
+
+	shdfnd::Array<PxVec3>& getCrackNormals() {return crackNormals;}
+	shdfnd::Array<PxVec3>& getTmpPoints() {return tmpPoints;}
+
+	bool mapShapeToConvex(const PxShape& shape, Convex& convex);
+	bool unmapShape(const PxShape& shape);
+	Convex* findConvexForShape(const PxShape& shape);
+	bool owns(const PxShape& shape) {return NULL != findConvexForShape(shape);}
+
+protected:
+	//virtual void create3dTexture() {}
+	//virtual void updateConvexesTex() {}
+	//void playShatterSound(float objectSize);
+
+	void addActor(Actor* a);  // done internally upon creation
+
+	PxPhysics *mPxPhysics;
+	PxCooking *mPxCooking;
+	PxScene *mScene;
+	const char *mResourcePath;
+	bool mPlaySounds;
+
+	//shdfnd::Array<Compound*> mCompounds;
+	shdfnd::Array<Actor*> mActors;
+
+	float mFractureForceThreshold;
+	float mContactImpactRadius;
+
+	shdfnd::Array<PxContactPairPoint> mContactPoints;
+	struct FractureEvent {
+		void init() {
+			compound = NULL; 
+			pos = normal = PxVec3(0.0f, 0.0f, 0.0f); 
+			additionalRadialImpulse = additionalNormalImpulse = 0.0f;
+			withStatic = false;
+		}
+		Compound *compound;
+		PxVec3 pos;
+		PxVec3 normal;
+		float additionalRadialImpulse;
+		float additionalNormalImpulse;
+		bool withStatic;
+	};
+
+	struct RenderBuffers {
+		void init() {
+			numVertices = 0; numIndices = 0;
+			VBO = 0; IBO = 0; matTex = 0; volTex = 0;
+			texSize = 0; numConvexes = -1;
+		}
+		shdfnd::Array<float> tmpVertices;
+		shdfnd::Array<unsigned int> tmpIndices;
+		shdfnd::Array<float> tmpTexCoords;
+		int numVertices, numIndices;
+		unsigned int VBO;
+		unsigned int IBO;
+		unsigned int volTex;
+		unsigned int matTex;
+		int texSize;
+		int numConvexes;
+	};
+	RenderBuffers mRenderBuffers;
+	unsigned int  mSceneVersion;		// changed on each update
+	unsigned int  mRenderBufferVersion;	// to handle updates
+	unsigned int  mOptixBufferVersion;	// to handle updates
+
+	PxMaterial *mPxDefaultMaterial;
+
+	//ConvexRenderer mConvexRenderer;
+
+	int mNoFractureFrames;
+	int mNoSoundFrames;
+	int mFrameNr;
+	bool mDebugDraw;
+
+	float mPickDepth;
+	PxRigidDynamic *mPickActor;
+	PxD6Joint* mPickJoint;
+	PxVec3 mPickPos;
+	PxVec3 mPickLocalPos;
+
+	float mMinConvexSize;
+	int mNumNoFractureFrames; // > 1 to prevent a slow down by too many fracture events
+
+	PxVec3 mCameraPos, mCameraDir, mCameraUp;
+	float  mCameraFov;
+
+	float bumpTextureUVScale;
+	float extraNoiseScale;
+	float roughnessScale;
+
+	float particleBumpTextureUVScale;
+	float particleRoughnessScale;
+	float particleExtraNoiseScale;
+	shdfnd::Array<PxVec3> debugPoints;
+	bool mRenderDebris;
+
+	PxSimulationEventCallback* mAppNotify;
+
+	//GLuint diffuseTexArray, bumpTexArray, specularTexArray, emissiveReflectSpecPowerTexArray;
+
+	//GLuint loadTextureArray(std::vector<std::string>& names);
+
+	//Singletons
+	CompoundCreator* mCompoundCreator;
+	PolygonTriangulator* mPolygonTriangulator;
+
+	//Array for use by Compound (effectively static)
+	shdfnd::Array<PxVec3> crackNormals;
+	shdfnd::Array<PxVec3> tmpPoints;
+
+	// Deferred Deletion list
+	shdfnd::Array<Compound*> delCompoundList;
+
+	// Map used to determine SimScene ownership of shape
+	shdfnd::HashMap<const PxShape*,Convex*> mShapeMap;
+};
+
+}
+}
+}
+
+#endif
+#endif