//
// 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) 2008-2019 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.  

#include "NpCast.h"
#include "GuConvexMesh.h"
#include "GuTriangleMesh.h"
#include "ScbNpDeps.h"
#include "GuBounds.h"

using namespace physx;
using namespace Sq;

static PX_FORCE_INLINE void updatePvdProperties(const Scb::Shape& shape)
{
#if PX_SUPPORT_PVD
	Scb::Scene* scbScene = shape.getScbSceneForAPI();
	if(scbScene)
		scbScene->getScenePvdClient().updatePvdProperties(&shape);
#else
	PX_UNUSED(shape);
#endif
}

NpShape::NpShape(const PxGeometry& geometry, PxShapeFlags shapeFlags, const PxU16* materialIndices, PxU16 materialCount, bool isExclusive)
:	PxShape				(PxConcreteType::eSHAPE, PxBaseFlag::eOWNS_MEMORY | PxBaseFlag::eIS_RELEASABLE)
,	mActor				(NULL)
,	mShape				(geometry, shapeFlags, materialIndices, materialCount, isExclusive)
,	mName				(NULL)
,	mExclusiveAndActorCount (isExclusive ? EXCLUSIVE_MASK : 0)
{
	PX_ASSERT(mShape.getScShape().getPxShape() == static_cast<PxShape*>(this));

	PxShape::userData = NULL;

	incMeshRefCount();
}

NpShape::~NpShape()
{
	decMeshRefCount();

	PxU32 nbMaterials = mShape.getNbMaterials();
	for (PxU32 i=0; i < nbMaterials; i++)
	{
		NpMaterial* mat = static_cast<NpMaterial*>(mShape.getMaterial(i));
		mat->decRefCount();
	}
}

void NpShape::onRefCountZero()
{
	NpFactory::getInstance().onShapeRelease(this);
	// see NpShape.h for ref counting semantics for shapes
	NpDestroy(getScbShape());
}

// PX_SERIALIZATION

NpShape::NpShape(PxBaseFlags baseFlags) : PxShape(baseFlags), mShape(PxEmpty) {}

void NpShape::preExportDataReset()
{
	Cm::RefCountable::preExportDataReset();
	mExclusiveAndActorCount &= EXCLUSIVE_MASK;
}

void NpShape::exportExtraData(PxSerializationContext& context)
{	
	getScbShape().getScShape().exportExtraData(context);
	context.writeName(mName);
}

void NpShape::importExtraData(PxDeserializationContext& context)
{
	getScbShape().getScShape().importExtraData(context);
	context.readName(mName);
}

void NpShape::requiresObjects(PxProcessPxBaseCallback& c)
{
	//meshes
	PxBase* mesh = NULL;
	switch(mShape.getGeometryType())
	{
	case PxGeometryType::eCONVEXMESH:
		mesh = static_cast<const PxConvexMeshGeometry&>(mShape.getGeometry()).convexMesh;
		break;
	case PxGeometryType::eHEIGHTFIELD:
		mesh = static_cast<const PxHeightFieldGeometry&>(mShape.getGeometry()).heightField;
		break;
	case PxGeometryType::eTRIANGLEMESH:
		mesh = static_cast<const PxTriangleMeshGeometry&>(mShape.getGeometry()).triangleMesh;
		break;
	case PxGeometryType::eSPHERE:
	case PxGeometryType::ePLANE:
	case PxGeometryType::eCAPSULE:
	case PxGeometryType::eBOX:
	case PxGeometryType::eGEOMETRY_COUNT:
	case PxGeometryType::eINVALID:
		break;
	}
	
	if(mesh)
		c.process(*mesh);

	//material
	PxU32 nbMaterials = mShape.getNbMaterials();
	for (PxU32 i=0; i < nbMaterials; i++)
	{
		NpMaterial* mat = static_cast<NpMaterial*>(mShape.getMaterial(i));
		c.process(*mat);
	}
}

void NpShape::resolveReferences(PxDeserializationContext& context)
{	
	// getMaterials() only works after material indices have been patched. 
	// in order to get to the new material indices, we need access to the new materials.
	// this only leaves us with the option of acquiring the material through the context given an old material index (we do have the mapping)
	{
		PxU32 nbIndices = mShape.getScShape().getNbMaterialIndices();
		const PxU16* indices = mShape.getScShape().getMaterialIndices();

		for (PxU32 i=0; i < nbIndices; i++)
		{
			PxBase* base = context.resolveReference(PX_SERIAL_REF_KIND_MATERIAL_IDX, size_t(indices[i]));
			PX_ASSERT(base && base->is<PxMaterial>());

			NpMaterial& material = *static_cast<NpMaterial*>(base);
			getScbShape().getScShape().resolveMaterialReference(i, material.getHandle());
		}
	}

	context.translatePxBase(mActor);

	getScbShape().getScShape().resolveReferences(context);	


	incMeshRefCount();

	// Increment materials' refcounts in a second pass. Works better in case of failure above.
	PxU32 nbMaterials = mShape.getNbMaterials();
	for (PxU32 i=0; i < nbMaterials; i++)
	{
		NpMaterial* mat = static_cast<NpMaterial*>(mShape.getMaterial(i));
		mat->incRefCount();
	}	
}

NpShape* NpShape::createObject(PxU8*& address, PxDeserializationContext& context)
{
	NpShape* obj = new (address) NpShape(PxBaseFlag::eIS_RELEASABLE);
	address += sizeof(NpShape);	
	obj->importExtraData(context);
	obj->resolveReferences(context);
	return obj;
}
//~PX_SERIALIZATION

PxU32 NpShape::getReferenceCount() const
{
	return getRefCount();
}

void NpShape::acquireReference()
{
	incRefCount();
}

void NpShape::release()
{
	PX_CHECK_AND_RETURN(getRefCount() > 1 || getActorCount() == 0, "PxShape::release: last reference to a shape released while still attached to an actor!");
	NP_WRITE_CHECK(getOwnerScene());
	releaseInternal();
}

void NpShape::releaseInternal()
{
	decRefCount();
}

Sc::RigidCore& NpShape::getScRigidObjectExclusive() const
{
	const PxType actorType = mActor->getConcreteType();

	if (actorType == PxConcreteType::eRIGID_DYNAMIC)
		return static_cast<NpRigidDynamic&>(*mActor).getScbBodyFast().getScBody();
	else if (actorType == PxConcreteType::eARTICULATION_LINK)
		return static_cast<NpArticulationLink&>(*mActor).getScbBodyFast().getScBody();
	else
		return static_cast<NpRigidStatic&>(*mActor).getScbRigidStaticFast().getScStatic();
}

void NpShape::updateSQ(const char* errorMessage)
{
	if(mActor && (mShape.getFlags() & PxShapeFlag::eSCENE_QUERY_SHAPE))
	{
		NpScene* scene = NpActor::getAPIScene(*mActor);
		NpShapeManager* shapeManager = NpActor::getShapeManager(*mActor);
		if(scene)
		{
			PxU32 compoundId;
			const PrunerData sqData = shapeManager->findSceneQueryData(*this, compoundId);
			scene->getSceneQueryManagerFast().markForUpdate(compoundId, sqData);
		}

		// invalidate the pruning structure if the actor bounds changed
		if(shapeManager->getPruningStructure())
		{
			Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, errorMessage);
			shapeManager->getPruningStructure()->invalidate(mActor);
		}
	}
}

PxGeometryType::Enum NpShape::getGeometryType() const
{
	NP_READ_CHECK(getOwnerScene());

	return mShape.getGeometryType();
}

void NpShape::setGeometry(const PxGeometry& g)
{
	NP_WRITE_CHECK(getOwnerScene());
	PX_CHECK_AND_RETURN(isWritable(), "PxShape::setGeometry: shared shapes attached to actors are not writable.");
	PX_SIMD_GUARD;

	// PT: fixes US2117
	if(g.getType() != getGeometryTypeFast())
	{
		Ps::getFoundation().error(PxErrorCode::eINVALID_PARAMETER, __FILE__, __LINE__, "PxShape::setGeometry(): Invalid geometry type. Changing the type of the shape is not supported.");
		return;
	}

#if PX_CHECKED
	bool isValid = false;
	switch(g.getType())
	{
		case PxGeometryType::eSPHERE:
			isValid = static_cast<const PxSphereGeometry&>(g).isValid();
		break;

		case PxGeometryType::ePLANE:
			isValid = static_cast<const PxPlaneGeometry&>(g).isValid();
		break;

		case PxGeometryType::eCAPSULE:
			isValid = static_cast<const PxCapsuleGeometry&>(g).isValid();
		break;

		case PxGeometryType::eBOX:
			isValid = static_cast<const PxBoxGeometry&>(g).isValid();
		break;

		case PxGeometryType::eCONVEXMESH:
			isValid = static_cast<const PxConvexMeshGeometry&>(g).isValid();
		break;

		case PxGeometryType::eTRIANGLEMESH:
			isValid = static_cast<const PxTriangleMeshGeometry&>(g).isValid();
		break;

		case PxGeometryType::eHEIGHTFIELD:
			isValid = static_cast<const PxHeightFieldGeometry&>(g).isValid();
		break;
		
		case PxGeometryType::eGEOMETRY_COUNT:
		case PxGeometryType::eINVALID:
			break;
	}

	if(!isValid)
	{
		Ps::getFoundation().error(PxErrorCode::eINVALID_PARAMETER, __FILE__, __LINE__, "PxShape::setGeometry(): Invalid geometry!");
		return;
	}
#endif

	decMeshRefCount();

	mShape.setGeometry(g);

	incMeshRefCount();

	updateSQ("PxShape::setGeometry: Shape is a part of pruning structure, pruning structure is now invalid!");
}

PxGeometryHolder NpShape::getGeometry() const
{
	PX_COMPILE_TIME_ASSERT(sizeof(Gu::GeometryUnion)>=sizeof(PxGeometryHolder));
	return reinterpret_cast<const PxGeometryHolder&>(mShape.getGeometry());
}

template<class T>
static PX_FORCE_INLINE bool getGeometryT(const NpShape* npShape, PxGeometryType::Enum type, T& geom)
{
	NP_READ_CHECK(npShape->getOwnerScene());

	if(npShape->getGeometryTypeFast() != type)
		return false;

	geom = static_cast<const T&>(npShape->getScbShape().getGeometry());
	return true;
}

bool NpShape::getBoxGeometry(PxBoxGeometry& g)							const	{ return getGeometryT(this, PxGeometryType::eBOX, g);			}
bool NpShape::getSphereGeometry(PxSphereGeometry& g)					const	{ return getGeometryT(this, PxGeometryType::eSPHERE, g);		}
bool NpShape::getCapsuleGeometry(PxCapsuleGeometry& g)					const	{ return getGeometryT(this, PxGeometryType::eCAPSULE, g);		}
bool NpShape::getPlaneGeometry(PxPlaneGeometry& g)						const	{ return getGeometryT(this, PxGeometryType::ePLANE, g);		}
bool NpShape::getConvexMeshGeometry(PxConvexMeshGeometry& g)			const	{ return getGeometryT(this, PxGeometryType::eCONVEXMESH, g);	}
bool NpShape::getTriangleMeshGeometry(PxTriangleMeshGeometry& g)		const	{ return getGeometryT(this, PxGeometryType::eTRIANGLEMESH, g);	}
bool NpShape::getHeightFieldGeometry(PxHeightFieldGeometry& g)			const	{ return getGeometryT(this, PxGeometryType::eHEIGHTFIELD, g);	}

PxRigidActor* NpShape::getActor() const
{
	NP_READ_CHECK(getOwnerScene());
	return mActor;
}

void NpShape::setLocalPose(const PxTransform& newShape2Actor)
{
	PX_CHECK_AND_RETURN(newShape2Actor.isSane(), "PxShape::setLocalPose: pose is not valid.");
	PX_CHECK_AND_RETURN(isWritable(), "PxShape::setLocalPose: shared shapes attached to actors are not writable.");
	NP_WRITE_CHECK(getOwnerScene());

	mShape.setShape2Actor(newShape2Actor.getNormalized());

	updateSQ("PxShape::setLocalPose: Shape is a part of pruning structure, pruning structure is now invalid!");
}

PxTransform NpShape::getLocalPose() const
{
	NP_READ_CHECK(getOwnerScene());

	return mShape.getShape2Actor();
}

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

void NpShape::setSimulationFilterData(const PxFilterData& data)
{
	NP_WRITE_CHECK(getOwnerScene());
	PX_CHECK_AND_RETURN(isWritable(), "PxShape::setSimulationFilterData: shared shapes attached to actors are not writable.");
	mShape.setSimulationFilterData(data);
}

PxFilterData NpShape::getSimulationFilterData() const
{
	NP_READ_CHECK(getOwnerScene());
	return mShape.getSimulationFilterData();
}

void NpShape::setQueryFilterData(const PxFilterData& data)
{
	NP_WRITE_CHECK(getOwnerScene());
	PX_CHECK_AND_RETURN(isWritable(), "PxShape::setQueryFilterData: shared shapes attached to actors are not writable.");

	mShape.getScShape().setQueryFilterData(data);	// PT: this one doesn't need double-buffering

	updatePvdProperties(mShape);
}

PxFilterData NpShape::getQueryFilterData() const
{
	NP_READ_CHECK(getOwnerScene());

	return getQueryFilterDataFast();
}

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

void NpShape::setMaterials(PxMaterial*const* materials, PxU16 materialCount)
{
	NP_WRITE_CHECK(getOwnerScene());
	PX_CHECK_AND_RETURN(isWritable(), "PxShape::setMaterials: shared shapes attached to actors are not writable.");

#if PX_CHECKED
	if (!NpShape::checkMaterialSetup(mShape.getGeometry(), "PxShape::setMaterials()", materials,  materialCount))
		return;
#endif

	PxU32 oldMaterialCount = mShape.getNbMaterials();
	PX_ALLOCA(oldMaterials, PxMaterial*, oldMaterialCount);
	PxU32 tmp = mShape.getMaterials(oldMaterials, oldMaterialCount);
	PX_ASSERT(tmp == oldMaterialCount);
	PX_UNUSED(tmp);

	if (mShape.setMaterials(materials, materialCount))
	{
		for(PxU32 i=0; i < materialCount; i++)
			static_cast<NpMaterial*>(materials[i])->incRefCount();

		for(PxU32 i=0; i < oldMaterialCount; i++)
			static_cast<NpMaterial*>(oldMaterials[i])->decRefCount();
	}
}

PxU16 NpShape::getNbMaterials() const
{
	NP_READ_CHECK(getOwnerScene());

	return mShape.getNbMaterials();
}

PxU32 NpShape::getMaterials(PxMaterial** userBuffer, PxU32 bufferSize, PxU32 startIndex) const
{
	NP_READ_CHECK(getOwnerScene());

	return mShape.getMaterials(userBuffer, bufferSize, startIndex);
}

PxMaterial* NpShape::getMaterialFromInternalFaceIndex(PxU32 faceIndex) const
{
	NP_READ_CHECK(getOwnerScene());

	bool isHf = (getGeometryType() == PxGeometryType::eHEIGHTFIELD);
	bool isMesh = (getGeometryType() == PxGeometryType::eTRIANGLEMESH);
	if( faceIndex == 0xFFFFffff && (isHf || isMesh) )
	{
		Ps::getFoundation().error(PxErrorCode::eDEBUG_WARNING, __FILE__, __LINE__,
			"PxShape::getMaterialFromInternalFaceIndex received 0xFFFFffff as input - returning NULL.");
		return NULL;
	}

	PxMaterialTableIndex hitMatTableId = 0;

	if(isHf)
	{
		PxHeightFieldGeometry hfGeom;
		getHeightFieldGeometry(hfGeom);

		hitMatTableId = hfGeom.heightField->getTriangleMaterialIndex(faceIndex);
	}
	else if(isMesh)
	{
		PxTriangleMeshGeometry triGeo;
		getTriangleMeshGeometry(triGeo);

		Gu::TriangleMesh* tm = static_cast<Gu::TriangleMesh*>(triGeo.triangleMesh);
		if(tm->hasPerTriangleMaterials())
			hitMatTableId = triGeo.triangleMesh->getTriangleMaterialIndex(faceIndex);
	}

	return getMaterial(hitMatTableId);
}

void NpShape::setContactOffset(PxReal contactOffset)
{
	NP_WRITE_CHECK(getOwnerScene());

	PX_CHECK_AND_RETURN(PxIsFinite(contactOffset), "PxShape::setContactOffset: invalid float");
	PX_CHECK_AND_RETURN((contactOffset >= 0.0f && contactOffset > mShape.getRestOffset()), "PxShape::setContactOffset: contactOffset should be positive, and greater than restOffset!");
	PX_CHECK_AND_RETURN(isWritable(), "PxShape::setContactOffset: shared shapes attached to actors are not writable.");

	mShape.setContactOffset(contactOffset);
}

PxReal NpShape::getContactOffset() const
{
	NP_READ_CHECK(getOwnerScene());

	return mShape.getContactOffset();
}

void NpShape::setRestOffset(PxReal restOffset)
{
	NP_WRITE_CHECK(getOwnerScene());
	PX_CHECK_AND_RETURN(PxIsFinite(restOffset), "PxShape::setRestOffset: invalid float");
	PX_CHECK_AND_RETURN((restOffset < mShape.getContactOffset()), "PxShape::setRestOffset: restOffset should be less than contactOffset!");
	PX_CHECK_AND_RETURN(isWritable(), "PxShape::setRestOffset: shared shapes attached to actors are not writable.");

	mShape.setRestOffset(restOffset);
}

PxReal NpShape::getRestOffset() const
{
	NP_READ_CHECK(getOwnerScene());

	return mShape.getRestOffset();
}

void NpShape::setTorsionalPatchRadius(PxReal radius)
{
	NP_WRITE_CHECK(getOwnerScene());
	PX_CHECK_AND_RETURN(PxIsFinite(radius), "PxShape::setTorsionalPatchRadius: invalid float");
	PX_CHECK_AND_RETURN((radius >= 0.f), "PxShape::setTorsionalPatchRadius: must be >= 0.f");

	mShape.setTorsionalPatchRadius(radius);
}

PxReal NpShape::getTorsionalPatchRadius() const
{
	NP_READ_CHECK(getOwnerScene());
	return mShape.getTorsionalPatchRadius();
}

void NpShape::setMinTorsionalPatchRadius(PxReal radius)
{
	NP_WRITE_CHECK(getOwnerScene());
	PX_CHECK_AND_RETURN(PxIsFinite(radius), "PxShape::setMinTorsionalPatchRadius: invalid float");
	PX_CHECK_AND_RETURN((radius >= 0.f), "PxShape::setMinTorsionalPatchRadius: must be >= 0.f");

	mShape.setMinTorsionalPatchRadius(radius);
}

PxReal NpShape::getMinTorsionalPatchRadius() const
{
	NP_READ_CHECK(getOwnerScene());
	return mShape.getMinTorsionalPatchRadius();
}

void NpShape::setFlagsInternal(PxShapeFlags inFlags)
{
	const bool hasMeshTypeGeom = mShape.getGeometryType() == PxGeometryType::eTRIANGLEMESH || mShape.getGeometryType() == PxGeometryType::eHEIGHTFIELD;

	if(hasMeshTypeGeom && (inFlags & PxShapeFlag::eTRIGGER_SHAPE))
	{
		Ps::getFoundation().error(PxErrorCode::eINVALID_PARAMETER, __FILE__, __LINE__, 
			"PxShape::setFlag(s): triangle mesh and heightfield triggers are not supported!");
		return;
	}

	if((inFlags & PxShapeFlag::eSIMULATION_SHAPE) && (inFlags & PxShapeFlag::eTRIGGER_SHAPE))
	{
		Ps::getFoundation().error(PxErrorCode::eINVALID_PARAMETER, __FILE__, __LINE__, 
			"PxShape::setFlag(s): shapes cannot simultaneously be trigger shapes and simulation shapes.");
		return;
	}

	const PxShapeFlags oldFlags = mShape.getFlags();

	const bool oldIsSimShape = oldFlags & PxShapeFlag::eSIMULATION_SHAPE;
	const bool isSimShape = inFlags & PxShapeFlag::eSIMULATION_SHAPE;

	if(mActor)
	{
		const PxType type = mActor->getConcreteType();

		// PT: US5732 - support kinematic meshes
		bool isKinematic = false;
		if(type==PxConcreteType::eRIGID_DYNAMIC)
		{
			PxRigidDynamic* rigidDynamic = static_cast<PxRigidDynamic*>(mActor);
			isKinematic = rigidDynamic->getRigidBodyFlags() & PxRigidBodyFlag::eKINEMATIC;
		}

		if((type != PxConcreteType::eRIGID_STATIC) && !isKinematic && isSimShape && !oldIsSimShape && (hasMeshTypeGeom || mShape.getGeometryType() == PxGeometryType::ePLANE))
		{
			Ps::getFoundation().error(PxErrorCode::eINVALID_PARAMETER, __FILE__, __LINE__, 
				"PxShape::setFlag(s): triangle mesh, heightfield and plane shapes can only be simulation shapes if part of a PxRigidStatic!");
			return;
		}
	}

	const bool oldHasSceneQuery = oldFlags & PxShapeFlag::eSCENE_QUERY_SHAPE;
	const bool hasSceneQuery = inFlags & PxShapeFlag::eSCENE_QUERY_SHAPE;

	mShape.setFlags(inFlags);

	if(oldHasSceneQuery != hasSceneQuery && mActor)
	{
		NpScene* npScene = getAPIScene();
		NpShapeManager* shapeManager = NpActor::getShapeManager(*mActor);
		if(npScene)
		{
			if(hasSceneQuery)
				shapeManager->setupSceneQuery(npScene->getSceneQueryManagerFast(), *mActor, *this);
			else
				shapeManager->teardownSceneQuery(npScene->getSceneQueryManagerFast(), *this);
		}

		// invalidate the pruning structure if the actor bounds changed
		if(shapeManager->getPruningStructure())
		{
			Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "PxShape::setFlag: Shape is a part of pruning structure, pruning structure is now invalid!");
			shapeManager->getPruningStructure()->invalidate(mActor);
		}
	}
}

void NpShape::setFlag(PxShapeFlag::Enum flag, bool value)
{
	NP_WRITE_CHECK(getOwnerScene());
	PX_CHECK_AND_RETURN(isWritable(), "PxShape::setFlag: shared shapes attached to actors are not writable.");
	PX_SIMD_GUARD;

	PxShapeFlags shapeFlags = mShape.getFlags();
	shapeFlags = value ? shapeFlags | flag : shapeFlags & ~flag;
	
	setFlagsInternal(shapeFlags);
}

void NpShape::setFlags(PxShapeFlags inFlags)
{
	NP_WRITE_CHECK(getOwnerScene());
	PX_CHECK_AND_RETURN(isWritable(), "PxShape::setFlags: shared shapes attached to actors are not writable.");
	PX_SIMD_GUARD;

	setFlagsInternal(inFlags);
}

PxShapeFlags NpShape::getFlags() const
{
	NP_READ_CHECK(getOwnerScene());
	return mShape.getFlags();
}

bool NpShape::isExclusive() const
{
	NP_READ_CHECK(getOwnerScene());
	return (mExclusiveAndActorCount & EXCLUSIVE_MASK) != 0;
}

void NpShape::onActorAttach(PxRigidActor& actor)
{
	incRefCount();
	if(isExclusiveFast())
		mActor = &actor;
	Ps::atomicIncrement(&mExclusiveAndActorCount);
}

void NpShape::onActorDetach()
{
	PX_ASSERT(getActorCount() > 0);
	Ps::atomicDecrement(&mExclusiveAndActorCount);
	if(isExclusiveFast())
		mActor = NULL;
	decRefCount();
}

void NpShape::setName(const char* debugName)		
{
	NP_WRITE_CHECK(getOwnerScene());
	PX_CHECK_AND_RETURN(isWritable(), "PxShape::setName: shared shapes attached to actors are not writable.");

	mName = debugName;

	updatePvdProperties(mShape);
}

const char* NpShape::getName() const
{
	NP_READ_CHECK(getOwnerScene());

	return mName;
}

NpScene* NpShape::getOwnerScene()	const 
{	
	return mActor ? NpActor::getOwnerScene(*mActor) : NULL; 
}

NpScene* NpShape::getAPIScene()	const 
{	
	// gets called when we update SQ structures due to a write - in which case there must be an actor 
	PX_ASSERT(mActor);
	return NpActor::getAPIScene(*mActor);
}

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

namespace physx
{
Sc::RigidCore* NpShapeGetScRigidObjectFromScbSLOW(const Scb::Shape& scb)
{
	const NpShape* np = getNpShape(&scb);
	return np->NpShape::getActor() ? &np->getScRigidObjectExclusive() : NULL;
}

size_t NpShapeGetScPtrOffset()
{
	const size_t offset = size_t(&(reinterpret_cast<NpShape*>(0)->getScbShape().getScShape()));	
	return offset;
}

void NpShapeIncRefCount(Scb::Shape& scb)
{
	NpShape* np = const_cast<NpShape*>(getNpShape(&scb));
	np->incRefCount();
}

void NpShapeDecRefCount(Scb::Shape& scb)
{
	NpShape* np = const_cast<NpShape*>(getNpShape(&scb));
	np->decRefCount();
}
}

// see NpConvexMesh.h, NpHeightField.h, NpTriangleMesh.h for details on how ref counting works for meshes
Cm::RefCountable* NpShape::getMeshRefCountable()
{
	switch(mShape.getGeometryType())
	{
		case PxGeometryType::eCONVEXMESH:
			return static_cast<Gu::ConvexMesh*>(
				static_cast<const PxConvexMeshGeometry&>(mShape.getGeometry()).convexMesh);

		case PxGeometryType::eHEIGHTFIELD:
			return static_cast<Gu::HeightField*>(
				static_cast<const PxHeightFieldGeometry&>(mShape.getGeometry()).heightField);

		case PxGeometryType::eTRIANGLEMESH:
			return static_cast<Gu::TriangleMesh*>(
				static_cast<const PxTriangleMeshGeometry&>(mShape.getGeometry()).triangleMesh);
		
		case PxGeometryType::eSPHERE:
		case PxGeometryType::ePLANE:
		case PxGeometryType::eCAPSULE:
		case PxGeometryType::eBOX:
		case PxGeometryType::eGEOMETRY_COUNT:
		case PxGeometryType::eINVALID:
			break;
	}
	return NULL;
}

bool NpShape::isWritable()
{
	// a shape is writable if it's exclusive, or it's not connected to any actors (which is true if the ref count is 1 and the user ref is not released.)
	return isExclusiveFast() || (getRefCount()==1 && (mBaseFlags & PxBaseFlag::eIS_RELEASABLE));
}

void NpShape::incMeshRefCount()
{
	Cm::RefCountable* npMesh = getMeshRefCountable();
	if(npMesh)
		npMesh->incRefCount();
}

void NpShape::decMeshRefCount()
{
	Cm::RefCountable* npMesh = getMeshRefCountable();
	if(npMesh)
		npMesh->decRefCount();
}

bool NpShape::checkMaterialSetup(const PxGeometry& geom, const char* errorMsgPrefix, PxMaterial*const* materials, PxU16 materialCount)
{
	for(PxU32 i=0; i<materialCount; ++i)
	{
		if(!materials[i])
		{
			Ps::getFoundation().error(PxErrorCode::eDEBUG_WARNING, __FILE__, __LINE__, 
					"material pointer %d is NULL!", i);
			return false;
		}
	}

	// check that simple shapes don't get assigned multiple materials
	if (materialCount > 1 && (geom.getType() != PxGeometryType::eHEIGHTFIELD) && (geom.getType() != PxGeometryType::eTRIANGLEMESH))
	{
		Ps::getFoundation().error(PxErrorCode::eINVALID_PARAMETER, __FILE__, __LINE__, 
			"%s: multiple materials defined for single material geometry!", errorMsgPrefix);
		return false;
	}

	//  verify we provide all materials required
	if (materialCount > 1 && (geom.getType() == PxGeometryType::eTRIANGLEMESH))
	{
		const PxTriangleMeshGeometry& meshGeom = static_cast<const PxTriangleMeshGeometry&>(geom);
		const PxTriangleMesh& mesh = *meshGeom.triangleMesh;
		if(mesh.getTriangleMaterialIndex(0) != 0xffff)
		{
			for(PxU32 i = 0; i < mesh.getNbTriangles(); i++)
			{
				const PxMaterialTableIndex meshMaterialIndex = mesh.getTriangleMaterialIndex(i);
				if(meshMaterialIndex >= materialCount)
				{
					Ps::getFoundation().error(PxErrorCode::eINVALID_PARAMETER, __FILE__, __LINE__, 
						"%s: PxTriangleMesh material indices reference more materials than provided!", errorMsgPrefix);
					break;
				}
			}
		}
	}
	if (materialCount > 1 && (geom.getType() == PxGeometryType::eHEIGHTFIELD))
	{
		const PxHeightFieldGeometry& meshGeom = static_cast<const PxHeightFieldGeometry&>(geom);
		const PxHeightField& mesh = *meshGeom.heightField;
		if(mesh.getTriangleMaterialIndex(0) != 0xffff)
		{
			const PxU32 nbTris = mesh.getNbColumns()*mesh.getNbRows()*2;
			for(PxU32 i = 0; i < nbTris; i++)
			{
				const PxMaterialTableIndex meshMaterialIndex = mesh.getTriangleMaterialIndex(i);
				if(meshMaterialIndex != PxHeightFieldMaterial::eHOLE && meshMaterialIndex >= materialCount)
				{
					Ps::getFoundation().error(PxErrorCode::eINVALID_PARAMETER, __FILE__, __LINE__, 
						"%s: PxHeightField material indices reference more materials than provided!", errorMsgPrefix);
					break;
				}
			}
		}
	}

	return true;
}

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