1430 lines
40 KiB
C++
1430 lines
40 KiB
C++
// 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-2025 NVIDIA Corporation. All rights reserved.
|
|
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
|
|
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
|
|
|
|
// ****************************************************************************
|
|
// This snippet illustrates how to use a standalone PxBVH for path-tracing.
|
|
//
|
|
// This is an advanced snippet that demonstrates how to use PxBVH in a more
|
|
// realistic/complex case than SnippetStandaloneBVH. It also reuses some
|
|
// multithreading code from SnippetMultiThreading, so you should get familiar
|
|
// with these two snippets first.
|
|
//
|
|
// This snippet also illustrates some micro-optimizations (see defines below)
|
|
// that don't make much difference in a regular game/setup, but can save
|
|
// milliseconds when running a lot of raycasts.
|
|
//
|
|
// The path-tracing code itself is a mashup of various implementations found
|
|
// online, most notably:
|
|
// http://aras-p.info/blog/2018/03/28/Daily-Pathtracer-Part-0-Intro/
|
|
// https://blog.demofox.org/2020/05/25/casual-shadertoy-path-tracing-1-basic-camera-diffuse-emissive/
|
|
//
|
|
// ****************************************************************************
|
|
|
|
#include <ctype.h>
|
|
#include "PxPhysicsAPI.h"
|
|
#include "foundation/PxArray.h"
|
|
#include "foundation/PxMathUtils.h"
|
|
#include "foundation/PxFPU.h"
|
|
#include "../snippetcommon/SnippetPrint.h"
|
|
#include "../snippetcommon/SnippetPVD.h"
|
|
#include "../snippetutils/SnippetUtils.h"
|
|
#ifdef RENDER_SNIPPET
|
|
#include "../snippetrender/SnippetCamera.h"
|
|
#include "../snippetrender/SnippetRender.h"
|
|
#endif
|
|
|
|
using namespace physx;
|
|
|
|
//#define PRINT_TIMINGS
|
|
//#define STATS
|
|
|
|
// PT: flags controlling micro optimizations
|
|
#define OPTIM_SKIP_INTERNAL_SIMD_GUARD 1 // Take care of SSE control register directly in the snippet, skip internal version
|
|
#define OPTIM_BAKE_MESH_SCALE 1 // Bake scale in mesh vertices (queries against scaled meshes are a bit slower)
|
|
#define OPTIM_SHADOW_RAY_CODEPATH 1 // Use dedicated codepath for shadow rays (early exit + skip pos/normal hit computations)
|
|
|
|
static PxDefaultAllocator gAllocator;
|
|
static PxDefaultErrorCallback gErrorCallback;
|
|
static PxFoundation* gFoundation = NULL;
|
|
static int gFrameIndex = 0;
|
|
#if OPTIM_SKIP_INTERNAL_SIMD_GUARD
|
|
static const PxGeometryQueryFlags gQueryFlags = PxGeometryQueryFlag::Enum(0);
|
|
#else
|
|
static const PxGeometryQueryFlags gQueryFlags = PxGeometryQueryFlag::eDEFAULT;
|
|
#endif
|
|
|
|
namespace
|
|
{
|
|
enum MaterialType
|
|
{
|
|
Lambert,
|
|
Metal,
|
|
Dielectric,
|
|
};
|
|
|
|
struct CustomMaterial
|
|
{
|
|
MaterialType mType;
|
|
PxVec3 mAlbedo;
|
|
PxVec3 mEmissive;
|
|
float mRoughness;
|
|
float mRI;
|
|
};
|
|
|
|
struct CustomObject
|
|
{
|
|
PxGeometryHolder mGeom;
|
|
PxTransform mPose;
|
|
CustomMaterial mMaterial;
|
|
};
|
|
|
|
struct CustomHit : PxGeomRaycastHit
|
|
{
|
|
protected:
|
|
const CustomObject* mObject;
|
|
public:
|
|
PX_FORCE_INLINE void setObject(const CustomObject* obj) { mObject = obj; }
|
|
PX_FORCE_INLINE const CustomObject* getObject() const { return mObject; }
|
|
PX_FORCE_INLINE MaterialType getType() const { return mObject->mMaterial.mType; }
|
|
PX_FORCE_INLINE PxVec3 getAlbedo() const { return mObject->mMaterial.mAlbedo; }
|
|
PX_FORCE_INLINE PxVec3 getEmissive() const { return mObject->mMaterial.mEmissive; }
|
|
PX_FORCE_INLINE float getRoughness() const { return mObject->mMaterial.mRoughness; }
|
|
PX_FORCE_INLINE float getRI() const { return mObject->mMaterial.mRI; }
|
|
};
|
|
|
|
struct Ray
|
|
{
|
|
PxVec3 mPos;
|
|
PxVec3 mDir;
|
|
};
|
|
|
|
// PT: helper to avoid recomputing the same things for each ray
|
|
class RayProvider
|
|
{
|
|
public:
|
|
RayProvider(float screenWidth, float screenHeight, float fov, const PxVec3& camDir);
|
|
|
|
PX_FORCE_INLINE PxVec3 computeWorldRayF(float xs, float ys) const;
|
|
|
|
PxMat33 mInvView;
|
|
const PxVec3 mCamDir;
|
|
float mWidth;
|
|
float mHeight;
|
|
float mOneOverWidth;
|
|
float mOneOverHeight;
|
|
float mHTan;
|
|
float mVTan;
|
|
|
|
PX_NOCOPY(RayProvider)
|
|
};
|
|
|
|
RayProvider::RayProvider(float screenWidth, float screenHeight, float fov, const PxVec3& camDir) :
|
|
mCamDir (camDir),
|
|
mWidth (screenWidth*0.5f),
|
|
mHeight (screenHeight*0.5f),
|
|
mOneOverWidth (2.0f/screenWidth),
|
|
mOneOverHeight (2.0f/screenHeight)
|
|
{
|
|
const float HTan = tanf(0.25f * fabsf(PxDegToRad(fov * 2.0f)));
|
|
mHTan = HTan;
|
|
mVTan = HTan*(screenWidth/screenHeight);
|
|
|
|
PxVec3 right, up;
|
|
PxComputeBasisVectors(camDir, right, up);
|
|
|
|
mInvView = PxMat33(-right, up, mCamDir);
|
|
}
|
|
|
|
PX_FORCE_INLINE PxVec3 RayProvider::computeWorldRayF(float xs, float ys) const
|
|
{
|
|
const float u = (xs - mWidth)*mOneOverWidth;
|
|
const float v = -(ys - mHeight)*mOneOverHeight;
|
|
|
|
const PxVec3 CamRay(mVTan*u, mHTan*v, 1.0f);
|
|
|
|
return mInvView.transform(CamRay).getNormalized();
|
|
}
|
|
|
|
class CustomScene
|
|
{
|
|
public:
|
|
CustomScene();
|
|
~CustomScene();
|
|
|
|
void release();
|
|
void addGeom(const PxGeometry& geom, const PxTransform& pose, const PxVec3& albedo, const PxVec3& emissive, MaterialType type=Lambert, float roughness=0.0f, float ri=0.0f);
|
|
void createBVH();
|
|
void render() const;
|
|
PxVec3 trace(const PxVec3& camPos, const PxVec3& dir, PxU32& rngState) const;
|
|
PxVec3 trace2(const Ray& ray, PxU32& rngState, PxU32 depth, bool doMaterialE = true) const;
|
|
|
|
bool raycast(const PxVec3& origin, const PxVec3& unitDir, float maxDist, CustomHit& hit) const;
|
|
#if OPTIM_SHADOW_RAY_CODEPATH
|
|
bool shadowRay(const PxVec3& origin, const PxVec3& unitDir, float maxDist, const CustomObject* filtered) const;
|
|
#endif
|
|
bool scatter(const Ray& r, const CustomHit& hit, PxVec3& attenuation, Ray& scattered, PxVec3& outLightE, PxU32& state) const;
|
|
PxU32 traceKernel(PxVec3* dest, const PxVec3& camPos, const RayProvider& rp, float fScreenWidth, float fScreenHeight, PxU32 seed, PxU32 offseti, PxU32 offsetj) const;
|
|
|
|
PxArray<CustomObject> mObjects;
|
|
PxArray<PxU32> mEmissiveObjects; // Indices of emissive objects
|
|
PxBVH* mBVH;
|
|
};
|
|
|
|
CustomScene::CustomScene() : mBVH(NULL)
|
|
{
|
|
}
|
|
|
|
CustomScene::~CustomScene()
|
|
{
|
|
}
|
|
|
|
void CustomScene::release()
|
|
{
|
|
PX_RELEASE(mBVH);
|
|
mObjects.reset();
|
|
PX_DELETE_THIS;
|
|
}
|
|
|
|
void CustomScene::addGeom(const PxGeometry& geom, const PxTransform& pose, const PxVec3& albedo, const PxVec3& emissive, MaterialType type, float roughness, float ri)
|
|
{
|
|
const PxU32 id = mObjects.size();
|
|
|
|
CustomObject obj;
|
|
obj.mGeom.storeAny(geom);
|
|
obj.mPose = pose;
|
|
obj.mMaterial.mType = type;
|
|
obj.mMaterial.mAlbedo = albedo;
|
|
obj.mMaterial.mEmissive = emissive;
|
|
obj.mMaterial.mRoughness = roughness;
|
|
obj.mMaterial.mRI = ri;
|
|
mObjects.pushBack(obj);
|
|
|
|
if(!emissive.isZero())
|
|
mEmissiveObjects.pushBack(id);
|
|
}
|
|
|
|
void CustomScene::createBVH()
|
|
{
|
|
const PxU32 nbObjects = mObjects.size();
|
|
PxBounds3* bounds = new PxBounds3[nbObjects];
|
|
for(PxU32 i=0;i<nbObjects;i++)
|
|
{
|
|
const CustomObject& obj = mObjects[i];
|
|
PxGeometryQuery::computeGeomBounds(bounds[i], obj.mGeom.any(), obj.mPose);
|
|
}
|
|
|
|
PxBVHDesc bvhDesc;
|
|
bvhDesc.bounds.count = nbObjects;
|
|
bvhDesc.bounds.data = bounds;
|
|
bvhDesc.bounds.stride = sizeof(PxBounds3);
|
|
mBVH = PxCreateBVH(bvhDesc);
|
|
delete [] bounds;
|
|
}
|
|
|
|
#ifdef STATS
|
|
static PxU32 gTotalNbRays = 0;
|
|
#endif
|
|
|
|
bool CustomScene::raycast(const PxVec3& origin, const PxVec3& unitDir, float maxDist, CustomHit& hit) const
|
|
{
|
|
#ifdef STATS
|
|
gTotalNbRays++;
|
|
#endif
|
|
if(!mBVH)
|
|
return false;
|
|
|
|
struct LocalCB : PxBVH::RaycastCallback
|
|
{
|
|
LocalCB(const CustomScene& scene, const PxVec3& origin_, const PxVec3& dir, CustomHit& hit_) :
|
|
mScene (scene),
|
|
mHit (hit_),
|
|
mOrigin (origin_),
|
|
mDir (dir),
|
|
mStatus (false)
|
|
{
|
|
}
|
|
|
|
virtual bool reportHit(PxU32 boundsIndex, PxReal& distance)
|
|
{
|
|
const CustomObject& obj = mScene.mObjects[boundsIndex];
|
|
if(PxGeometryQuery::raycast(mOrigin, mDir, obj.mGeom.any(), obj.mPose, distance, PxHitFlag::eDEFAULT, 1, &mLocalHit, sizeof(PxGeomRaycastHit), gQueryFlags))
|
|
{
|
|
// We need to discard internal hits for refracted rays
|
|
if(mLocalHit.distance==0.0f)
|
|
return true;
|
|
|
|
if(mLocalHit.distance<distance)
|
|
{
|
|
distance = mLocalHit.distance;
|
|
static_cast<PxGeomRaycastHit&>(mHit) = mLocalHit;
|
|
mHit.setObject(&obj);
|
|
mStatus = true;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
const CustomScene& mScene;
|
|
CustomHit& mHit;
|
|
PxGeomRaycastHit mLocalHit;
|
|
const PxVec3& mOrigin;
|
|
const PxVec3& mDir;
|
|
bool mStatus;
|
|
|
|
LocalCB& operator=(const LocalCB&)
|
|
{
|
|
PX_ASSERT(0);
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
LocalCB CB(*this, origin, unitDir, hit);
|
|
mBVH->raycast(origin, unitDir, maxDist, CB, gQueryFlags);
|
|
return CB.mStatus;
|
|
}
|
|
|
|
#if OPTIM_SHADOW_RAY_CODEPATH
|
|
bool CustomScene::shadowRay(const PxVec3& origin, const PxVec3& unitDir, float maxDist, const CustomObject* filtered) const
|
|
{
|
|
#ifdef STATS
|
|
gTotalNbRays++;
|
|
#endif
|
|
|
|
if(!mBVH)
|
|
return false;
|
|
|
|
struct LocalCB : PxBVH::RaycastCallback
|
|
{
|
|
LocalCB(const CustomScene& scene, const PxVec3& origin_, const PxVec3& dir, const CustomObject* filtered_) :
|
|
mScene (scene),
|
|
mFiltered (filtered_),
|
|
mOrigin (origin_),
|
|
mDir (dir),
|
|
mStatus (false)
|
|
{
|
|
}
|
|
|
|
virtual bool reportHit(PxU32 boundsIndex, PxReal& distance)
|
|
{
|
|
const CustomObject& obj = mScene.mObjects[boundsIndex];
|
|
|
|
if(&obj==mFiltered)
|
|
return true;
|
|
|
|
// PT: we don't need the hit position/normal for shadow rays, so we tell PhysX it can skip computing them.
|
|
// We also use eANY_HIT to tell the system not to look for the closest hit on triangle meshes.
|
|
if(PxGeometryQuery::raycast(mOrigin, mDir, obj.mGeom.any(), obj.mPose, distance, PxHitFlag::eANY_HIT, 1, &mLocalHit, sizeof(PxGeomRaycastHit), gQueryFlags))
|
|
{
|
|
mStatus = true;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
const CustomScene& mScene;
|
|
const CustomObject* mFiltered;
|
|
PxGeomRaycastHit mLocalHit;
|
|
const PxVec3& mOrigin;
|
|
const PxVec3& mDir;
|
|
bool mStatus;
|
|
|
|
LocalCB& operator=(const LocalCB&)
|
|
{
|
|
PX_ASSERT(0);
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
LocalCB CB(*this, origin, unitDir, filtered);
|
|
mBVH->raycast(origin, unitDir, maxDist, CB, gQueryFlags);
|
|
return CB.mStatus;
|
|
}
|
|
#endif
|
|
|
|
struct TracerThread
|
|
{
|
|
TracerThread() : mScene(NULL), mRndState(42), mActive(true)
|
|
{
|
|
}
|
|
|
|
SnippetUtils::Sync* mWorkReadySyncHandle;
|
|
SnippetUtils::Thread* mThreadHandle;
|
|
SnippetUtils::Sync* mWorkDoneSyncHandle;
|
|
|
|
const CustomScene* mScene;
|
|
const RayProvider* mRayProvider;
|
|
PxVec3* mDest;
|
|
PxVec3 mCamPos;
|
|
float mScreenWidth;
|
|
float mScreenHeight;
|
|
PxU32 mOffsetX;
|
|
PxU32 mOffsetY;
|
|
PxU32 mRndState;
|
|
bool mActive;
|
|
|
|
void Setup(const CustomScene* scene, const RayProvider* rp, PxVec3* dest, const PxVec3& camPos, float width, float height, PxU32 offsetX, PxU32 offsetY)
|
|
{
|
|
mScene = scene;
|
|
mRayProvider = rp;
|
|
mDest = dest;
|
|
mCamPos = camPos;
|
|
mScreenWidth = width;
|
|
mScreenHeight = height;
|
|
mOffsetX = offsetX;
|
|
mOffsetY = offsetY;
|
|
}
|
|
|
|
void Run()
|
|
{
|
|
if(mActive)
|
|
mRndState = mScene->traceKernel(mDest, mCamPos, *mRayProvider, mScreenWidth, mScreenHeight, mRndState, mOffsetX, mOffsetY);
|
|
}
|
|
};
|
|
const PxU32 gNumThreads = 16;
|
|
TracerThread gThreads[gNumThreads];
|
|
|
|
static PX_FORCE_INLINE PxU32 wang_hash(PxU32& seed)
|
|
{
|
|
seed = PxU32(seed ^ PxU32(61)) ^ PxU32(seed >> PxU32(16));
|
|
seed *= PxU32(9);
|
|
seed = seed ^ (seed >> 4);
|
|
seed *= PxU32(0x27d4eb2d);
|
|
seed = seed ^ (seed >> 15);
|
|
return seed;
|
|
}
|
|
|
|
/*static PX_FORCE_INLINE PxU32 XorShift32(PxU32& state)
|
|
{
|
|
PxU32 x = state;
|
|
x ^= x << 13;
|
|
x ^= x >> 17;
|
|
x ^= x << 15;
|
|
state = x;
|
|
return x;
|
|
}*/
|
|
|
|
static const float gInvValue = float(1.0 / 4294967296.0);
|
|
//static const float gInvValue2 = float(1.0 / 16777216.0);
|
|
|
|
static PX_FORCE_INLINE float RandomFloat01(PxU32& state)
|
|
{
|
|
// return float(wang_hash(state)) / 4294967296.0;
|
|
return float(wang_hash(state)) * gInvValue;
|
|
// return (XorShift32(state) & 0xFFFFFF) / 16777216.0f;
|
|
// return (XorShift32(state) & 0xFFFFFF) * gInvValue2;
|
|
}
|
|
|
|
/*static PxVec3 RandomInUnitDisk(PxU32& state)
|
|
{
|
|
PxVec3 p;
|
|
do
|
|
{
|
|
p = 2.0f * PxVec3(RandomFloat01(state), RandomFloat01(state), 0.0f) - PxVec3(1.0f, 1.0f, 0.0f);
|
|
} while (p.dot(p) >= 1.0f);
|
|
return p;
|
|
}*/
|
|
|
|
static PxVec3 RandomInUnitSphere(PxU32& state)
|
|
{
|
|
PxVec3 p;
|
|
do {
|
|
p = 2.0f * PxVec3(RandomFloat01(state), RandomFloat01(state), RandomFloat01(state)) - PxVec3(1.0f);
|
|
} while (p.dot(p) >= 1.0f);
|
|
return p;
|
|
}
|
|
|
|
static PX_FORCE_INLINE PxVec3 RandomUnitVector(PxU32& state)
|
|
{
|
|
const float z = RandomFloat01(state) * 2.0f - 1.0f;
|
|
const float a = RandomFloat01(state) * PxTwoPi;
|
|
const float r = sqrtf(1.0f - z * z);
|
|
const float x = r * cosf(a);
|
|
const float y = r * sinf(a);
|
|
return PxVec3(x, y, z);
|
|
}
|
|
|
|
static PX_FORCE_INLINE PxVec3 sky(const PxVec3& dir)
|
|
{
|
|
const float t = 0.5f * (dir.y + 1.0f);
|
|
const PxVec3 white(1.0f);
|
|
const PxVec3 blue(0.5f, 0.7f, 1.0f);
|
|
return white*(1.0f-t) + blue*t;
|
|
}
|
|
|
|
static PX_FORCE_INLINE PxVec3 mul(const PxVec3& v0, const PxVec3& v1)
|
|
{
|
|
return PxVec3(v0.x*v1.x, v0.y*v1.y, v0.z*v1.z);
|
|
}
|
|
|
|
#ifdef RENDER_SNIPPET
|
|
static PX_FORCE_INLINE PxVec3 div(const PxVec3& v0, const PxVec3& v1)
|
|
{
|
|
const float x = v1.x!=0.0f ? v0.x/v1.x : 0.0f;
|
|
const float y = v1.y!=0.0f ? v0.y/v1.y : 0.0f;
|
|
const float z = v1.z!=0.0f ? v0.z/v1.z : 0.0f;
|
|
return PxVec3(x, y, z);
|
|
// return PxVec3(v0.x/v1.x, v0.y/v1.y, v0.z/v1.z);
|
|
}
|
|
|
|
/*static PX_FORCE_INLINE float saturate(float a)
|
|
{
|
|
return (a < 0.0f) ? 0.0f : (a > 1.0f) ? 1.0f : a;
|
|
}*/
|
|
|
|
static PX_FORCE_INLINE PxVec3 ACESTonemap(const PxVec3& inColor)
|
|
{
|
|
const float a = 2.51f;
|
|
const float b = 0.03f;
|
|
const float c = 2.43f;
|
|
const float d = 0.59f;
|
|
const float e = 0.14f;
|
|
const PxVec3 col = div((mul(inColor, (PxVec3(b) + inColor * a))) , (mul(inColor, (inColor * c + PxVec3(d)) + PxVec3(e))));
|
|
// return PxVec3(saturate(col.x), saturate(col.y), saturate(col.z));
|
|
return col;
|
|
}
|
|
#endif
|
|
|
|
/*static PX_FORCE_INLINE PxVec3 LessThan(const PxVec3& f, float value)
|
|
{
|
|
return PxVec3(
|
|
(f.x < value) ? 1.0f : 0.0f,
|
|
(f.y < value) ? 1.0f : 0.0f,
|
|
(f.z < value) ? 1.0f : 0.0f);
|
|
}*/
|
|
|
|
/*PX_FORCE_INLINE float sqLength(const PxVec3& v)
|
|
{
|
|
return v.dot(v);
|
|
}*/
|
|
|
|
#ifdef RENDER_SNIPPET
|
|
static PX_FORCE_INLINE PxVec3 max3(const PxVec3& v, float e)
|
|
{
|
|
return PxVec3(PxMax(v.x, e), PxMax(v.y, e), PxMax(v.z, e));
|
|
}
|
|
|
|
static PX_FORCE_INLINE PxVec3 pow(const PxVec3& v, float e)
|
|
{
|
|
return PxVec3(powf(v.x, e), powf(v.y, e), powf(v.z, e));
|
|
}
|
|
#endif
|
|
|
|
/*static PX_FORCE_INLINE PxVec3 pow(const PxVec3& v, const PxVec3& e)
|
|
{
|
|
return PxVec3(powf(v.x, e.x), powf(v.y, e.y), powf(v.z, e.z));
|
|
}
|
|
|
|
static PX_FORCE_INLINE PxVec3 mix(const PxVec3& x, const PxVec3& y, const PxVec3& a)
|
|
{
|
|
const PxVec3 b = PxVec3(1.0f) - a;
|
|
return mul(x,b) + mul(y,a);
|
|
}*/
|
|
|
|
/*static PX_FORCE_INLINE PxVec3 mix(const PxVec3& x, const PxVec3& y, float a)
|
|
{
|
|
const float b = 1.0f - a;
|
|
return (x*b) + (y*a);
|
|
}*/
|
|
|
|
static PX_FORCE_INLINE PxVec3 reflect(const PxVec3& I, const PxVec3& N)
|
|
{
|
|
return I - 2.0f * N.dot(I) * N;
|
|
}
|
|
|
|
/*static PX_FORCE_INLINE PxVec3 LinearToSRGB(const PxVec3& rgb)
|
|
{
|
|
return mix(
|
|
pow(rgb, PxVec3(1.0f / 2.4f)) * 1.055f - PxVec3(0.055f),
|
|
rgb * 12.92f,
|
|
LessThan(rgb, 0.0031308f)
|
|
);
|
|
}*/
|
|
|
|
#ifdef RENDER_SNIPPET
|
|
static PX_FORCE_INLINE PxVec3 LinearToSRGB2(const PxVec3 rgb)
|
|
{
|
|
// rgb = max(rgb, float3(0, 0, 0));
|
|
return max3(1.055f * pow(rgb, 0.416666667f) - PxVec3(0.055f), 0.0f);
|
|
}
|
|
#endif
|
|
|
|
/*static PX_FORCE_INLINE PxVec3 SRGBToLinear(const PxVec3& rgb2)
|
|
{
|
|
// rgb = clamp(rgb, 0.0f, 1.0f);
|
|
PxVec3 rgb = rgb2;
|
|
if(rgb.x>255.0f)
|
|
rgb.x = 255.0f;
|
|
if(rgb.y>255.0f)
|
|
rgb.y = 255.0f;
|
|
if(rgb.z>255.0f)
|
|
rgb.z = 255.0f;
|
|
|
|
return mix(
|
|
pow(((rgb + PxVec3(0.055f)) / 1.055f), PxVec3(2.4f)),
|
|
rgb / 12.92f,
|
|
LessThan(rgb, 0.04045f)
|
|
);
|
|
}*/
|
|
|
|
static PxVec3* gAccumPixels = NULL;
|
|
static PxVec3* gCurrentPixels = NULL;
|
|
#ifdef RENDER_SNIPPET
|
|
static GLubyte* gCurrentTexture = NULL;
|
|
static GLuint gTexID = 0;
|
|
#endif
|
|
|
|
static const PxU32 RAYTRACING_RENDER_WIDTH = 512;
|
|
static const PxU32 RAYTRACING_RENDER_HEIGHT = 512;
|
|
static bool gUseMultipleThreads = true;
|
|
static bool gShowAllThreadRenders = false;
|
|
static bool gToneMapping = true;
|
|
static bool gLinearToSRGB = false;
|
|
static float gSkyCoeff = 0.4f;
|
|
static float gExposure = 0.5f;
|
|
static const float gRayPosNormalNudge = 0.01f;
|
|
static const PxU32 gMaxNbBounces = 8;
|
|
static const PxU32 gNbSamplesPerPixel = 1;
|
|
static const float gOneOverNbSamples = 1.0f / float(gNbSamplesPerPixel);
|
|
#define DO_LIGHT_SAMPLING 1
|
|
#define ANTIALIASING
|
|
|
|
static void resetRender()
|
|
{
|
|
gFrameIndex = 0;
|
|
if(gAccumPixels)
|
|
PxMemZero(gAccumPixels, RAYTRACING_RENDER_WIDTH*RAYTRACING_RENDER_HEIGHT*sizeof(PxVec3));
|
|
}
|
|
|
|
static PX_FORCE_INLINE bool refract(PxVec3 v, PxVec3 n, float nint, PxVec3& outRefracted)
|
|
{
|
|
const float dt = v.dot(n);
|
|
const float discr = 1.0f - nint*nint*(1.0f-dt*dt);
|
|
if(discr > 0.0f)
|
|
{
|
|
outRefracted = nint * (v - n*dt) - n*sqrtf(discr);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static PX_FORCE_INLINE float schlick(float cosine, float ri)
|
|
{
|
|
float r0 = (1.0f-ri) / (1.0f+ri);
|
|
r0 = r0*r0;
|
|
return r0 + (1.0f-r0)*powf(1.0f-cosine, 5.0f);
|
|
}
|
|
|
|
bool CustomScene::scatter(const Ray& r, const CustomHit& hit, PxVec3& attenuation, Ray& scattered, PxVec3& outLightE, PxU32& state) const
|
|
{
|
|
outLightE = PxVec3(0.0f);
|
|
|
|
const MaterialType type = hit.getType();
|
|
if(type == Lambert)
|
|
{
|
|
// random point on unit sphere that is tangent to the hit point
|
|
attenuation = hit.getAlbedo();
|
|
|
|
scattered.mPos = hit.position + hit.normal * gRayPosNormalNudge;
|
|
scattered.mDir = (hit.normal + RandomUnitVector(state)).getNormalized();
|
|
|
|
#if DO_LIGHT_SAMPLING
|
|
const PxU32 nbLights = mEmissiveObjects.size();
|
|
// sample lights
|
|
for(PxU32 j=0; j<nbLights; j++)
|
|
{
|
|
const int i = mEmissiveObjects[j];
|
|
const CustomObject& smat = mObjects[i];
|
|
if(hit.getObject() == &smat)
|
|
continue; // skip self
|
|
PX_ASSERT(smat.mGeom.getType()==PxGeometryType::eSPHERE);
|
|
const PxSphereGeometry& sphereGeom = smat.mGeom.sphere();
|
|
const PxVec3& sphereCenter = smat.mPose.p;
|
|
|
|
// create a random direction towards sphere
|
|
// coord system for sampling: sw, su, sv
|
|
PxVec3 delta = sphereCenter - hit.position;
|
|
const float maxDist2 = delta.magnitudeSquared();
|
|
const float maxDist = PxSqrt(maxDist2);
|
|
PxVec3 sw = delta/maxDist;
|
|
PxVec3 su;
|
|
if(fabsf(sw.x)>0.01f)
|
|
su = PxVec3(0,1,0).cross(sw);
|
|
else
|
|
su = PxVec3(1,0,0).cross(sw);
|
|
su.normalize();
|
|
PxVec3 sv = sw.cross(su);
|
|
// sample sphere by solid angle
|
|
const float tmp = 1.0f - sphereGeom.radius*sphereGeom.radius / maxDist2;
|
|
const float cosAMax = tmp>0.0f ? sqrtf(tmp) : 0.0f;
|
|
const float eps1 = RandomFloat01(state), eps2 = RandomFloat01(state);
|
|
const float cosA = 1.0f - eps1 + eps1 * cosAMax;
|
|
const float sinA = sqrtf(1.0f - cosA*cosA);
|
|
const float phi = PxTwoPi * eps2;
|
|
const PxVec3 l = su * (cosf(phi) * sinA) + sv * (sinf(phi) * sinA) + sw * cosA;
|
|
//l = normalize(l); // NOTE(fg): This is already normalized, by construction.
|
|
|
|
// shoot shadow ray
|
|
#if OPTIM_SHADOW_RAY_CODEPATH
|
|
if(!shadowRay(scattered.mPos, l, maxDist, &smat))
|
|
#else
|
|
CustomHit lightHit;
|
|
if(raycast(scattered.mPos, l, 5000.0f, lightHit) && lightHit.getObject()==&smat)
|
|
#endif
|
|
{
|
|
const float omega = PxTwoPi * (1.0f - cosAMax);
|
|
const PxVec3 nl = hit.normal.dot(r.mDir) < 0.0f ? hit.normal : -hit.normal;
|
|
outLightE += (mul(hit.getAlbedo(), smat.mMaterial.mEmissive)) * (PxMax(0.0f, l.dot(nl)) * omega / PxPi);
|
|
}
|
|
}
|
|
#endif
|
|
return true;
|
|
}
|
|
else if(type == Metal)
|
|
{
|
|
const PxVec3 refl = reflect(r.mDir, hit.normal);
|
|
// reflected ray, and random inside of sphere based on roughness
|
|
const float roughness = hit.getRoughness();
|
|
scattered.mPos = hit.position + hit.normal * gRayPosNormalNudge;
|
|
scattered.mDir = (refl + roughness*RandomInUnitSphere(state)).getNormalized();
|
|
attenuation = hit.getAlbedo();
|
|
return scattered.mDir.dot(hit.normal) > 0.0f;
|
|
}
|
|
else if(type == Dielectric)
|
|
{
|
|
attenuation = PxVec3(1.0f);
|
|
|
|
const PxVec3& rdir = r.mDir;
|
|
const float matri = hit.getRI();
|
|
|
|
PxVec3 outwardN;
|
|
float nint;
|
|
float cosine;
|
|
if(rdir.dot(hit.normal) > 0)
|
|
{
|
|
outwardN = -hit.normal;
|
|
nint = matri;
|
|
cosine = matri * rdir.dot(hit.normal);
|
|
}
|
|
else
|
|
{
|
|
outwardN = hit.normal;
|
|
nint = 1.0f / matri;
|
|
cosine = -rdir.dot(hit.normal);
|
|
}
|
|
|
|
float reflProb;
|
|
PxVec3 refr(1.0f);
|
|
if(refract(rdir, outwardN, nint, refr))
|
|
reflProb = schlick(cosine, matri);
|
|
else
|
|
reflProb = 1.0f;
|
|
|
|
if(RandomFloat01(state) < reflProb)
|
|
{
|
|
const PxVec3 refl = reflect(rdir, hit.normal);
|
|
scattered.mPos = hit.position + hit.normal * gRayPosNormalNudge;
|
|
scattered.mDir = refl.getNormalized();
|
|
}
|
|
else
|
|
{
|
|
scattered.mPos = hit.position - hit.normal * gRayPosNormalNudge;
|
|
scattered.mDir = refr.getNormalized();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
attenuation = PxVec3(1.0f, 0.0f, 1.0f);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
PxVec3 CustomScene::trace2(const Ray& ray, PxU32& rngState, PxU32 depth, bool doMaterialE) const
|
|
{
|
|
CustomHit hit;
|
|
if(raycast(ray.mPos, ray.mDir, 5000.0f, hit))
|
|
{
|
|
Ray scattered;
|
|
PxVec3 attenuation;
|
|
PxVec3 lightE;
|
|
PxVec3 matE = hit.getEmissive();
|
|
if(depth < gMaxNbBounces && scatter(ray, hit, attenuation, scattered, lightE, rngState))
|
|
{
|
|
#if DO_LIGHT_SAMPLING
|
|
if(!doMaterialE)
|
|
matE = PxVec3(0.0f); // don't add material emission if told so
|
|
// for Lambert materials, we just did explicit light (emissive) sampling and already
|
|
// for their contribution, so if next ray bounce hits the light again, don't add
|
|
// emission
|
|
doMaterialE = hit.getType() != Lambert;
|
|
#endif
|
|
return matE + lightE + mul(attenuation, trace2(scattered, rngState, depth+1, doMaterialE));
|
|
}
|
|
else
|
|
return matE;
|
|
}
|
|
else return sky(ray.mDir)*gSkyCoeff;
|
|
}
|
|
|
|
PxU32 CustomScene::traceKernel(PxVec3* dest, const PxVec3& camPos, const RayProvider& rp, float fScreenWidth, float fScreenHeight, PxU32 seed, PxU32 offseti, PxU32 offsetj) const
|
|
{
|
|
#if OPTIM_SKIP_INTERNAL_SIMD_GUARD
|
|
PX_SIMD_GUARD
|
|
#endif
|
|
|
|
PxU32 rngState = seed;
|
|
|
|
for(PxU32 jj=0;jj<RAYTRACING_RENDER_HEIGHT;jj+=4)
|
|
{
|
|
const PxU32 j = jj + offsetj;
|
|
|
|
#ifndef ANTIALIASING
|
|
const PxU32 yi = PxU32(fScreenHeight*float(j));
|
|
#endif
|
|
for(PxU32 ii=0;ii<RAYTRACING_RENDER_WIDTH;ii+=4)
|
|
{
|
|
const PxU32 i = ii + offseti;
|
|
|
|
PxVec3 color(0.0f);
|
|
for(PxU32 k=0;k<gNbSamplesPerPixel;k++)
|
|
{
|
|
#ifdef ANTIALIASING
|
|
const float radius = 1.0f;
|
|
const float jitterX = radius*(RandomFloat01(rngState) - 0.5f);
|
|
const float jitterY = radius*(RandomFloat01(rngState) - 0.5f);
|
|
const float xf = fScreenWidth*(float(i)+jitterX);
|
|
const float yf = fScreenHeight*(float(j)+jitterY);
|
|
const PxVec3 dir = rp.computeWorldRayF(xf, yf);
|
|
#else
|
|
const PxU32 xi = PxU32(fScreenWidth*float(i));
|
|
const PxVec3 dir = rp.computeWorldRayF(float(xi), float(yi));
|
|
#endif
|
|
Ray r;
|
|
r.mPos = camPos;
|
|
r.mDir = dir;
|
|
color += trace2(r, rngState, 0);
|
|
}
|
|
*dest++ = color * gOneOverNbSamples;
|
|
}
|
|
|
|
dest += (RAYTRACING_RENDER_HEIGHT/4)*3;
|
|
}
|
|
return rngState;
|
|
}
|
|
|
|
void CustomScene::render() const
|
|
{
|
|
#if OPTIM_SKIP_INTERNAL_SIMD_GUARD
|
|
PX_SIMD_GUARD
|
|
#endif
|
|
|
|
#ifdef RENDER_SNIPPET
|
|
if(0)
|
|
{
|
|
const PxVec3 color(1.0f, 0.5f, 0.25f);
|
|
const PxU32 nbObjects = mObjects.size();
|
|
for(PxU32 i=0;i<nbObjects;i++)
|
|
{
|
|
const CustomObject& obj = mObjects[i];
|
|
Snippets::renderGeoms(1, &obj.mGeom, &obj.mPose, false, color);
|
|
}
|
|
}
|
|
|
|
const PxU32 screenWidth = Snippets::getScreenWidth();
|
|
const PxU32 screenHeight = Snippets::getScreenHeight();
|
|
Snippets::Camera* sCamera = Snippets::getCamera();
|
|
const PxVec3 camPos = sCamera->getEye();
|
|
const PxVec3 camDir = sCamera->getDir();
|
|
|
|
static PxVec3 cachedPos(0.0f);
|
|
static PxVec3 cachedDir(0.0f);
|
|
if(cachedPos!=camPos || cachedDir!=camDir)
|
|
{
|
|
cachedPos=camPos;
|
|
cachedDir=camDir;
|
|
resetRender();
|
|
}
|
|
|
|
const PxU32 textureWidth = RAYTRACING_RENDER_WIDTH;
|
|
const PxU32 textureHeight = RAYTRACING_RENDER_HEIGHT;
|
|
|
|
if(!gAccumPixels)
|
|
{
|
|
gAccumPixels = new PxVec3[textureWidth*textureHeight];
|
|
PxMemZero(gAccumPixels, textureWidth*textureHeight*sizeof(PxVec3));
|
|
}
|
|
|
|
const float fScreenWidth = float(screenWidth)/float(RAYTRACING_RENDER_WIDTH);
|
|
const float fScreenHeight = float(screenHeight)/float(RAYTRACING_RENDER_HEIGHT);
|
|
|
|
static PxU32 rngState = 42;
|
|
|
|
if(!gCurrentPixels)
|
|
{
|
|
gCurrentPixels = new PxVec3[textureWidth*textureHeight];
|
|
PxMemZero(gCurrentPixels, textureWidth*textureHeight*sizeof(PxVec3));
|
|
}
|
|
|
|
#ifdef PRINT_TIMINGS
|
|
const DWORD tgt = timeGetTime();
|
|
const DWORD64 time0 = __rdtsc();
|
|
#endif
|
|
const RayProvider rp(float(screenWidth), float(screenHeight), 60.0f, camDir);
|
|
|
|
PxVec3* buffer = gCurrentPixels;
|
|
|
|
if(gUseMultipleThreads)
|
|
{
|
|
PxU32 index = 0;
|
|
for(PxU32 j=0;j<4;j++)
|
|
{
|
|
for(PxU32 i=0;i<4;i++)
|
|
{
|
|
PxU32 offset = (RAYTRACING_RENDER_WIDTH/4)*i;
|
|
offset += (RAYTRACING_RENDER_HEIGHT/4)*j*RAYTRACING_RENDER_WIDTH;
|
|
gThreads[index++].Setup(this, &rp, buffer + offset, camPos, fScreenWidth, fScreenHeight, i, j);
|
|
}
|
|
}
|
|
|
|
{
|
|
for (PxU32 i=0; i<gNumThreads; i++)
|
|
SnippetUtils::syncSet(gThreads[i].mWorkReadySyncHandle);
|
|
|
|
for (PxU32 i=0; i<gNumThreads; i++)
|
|
{
|
|
SnippetUtils::syncWait(gThreads[i].mWorkDoneSyncHandle);
|
|
SnippetUtils::syncReset(gThreads[i].mWorkDoneSyncHandle);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for(PxU32 j=0;j<RAYTRACING_RENDER_HEIGHT;j++)
|
|
{
|
|
#ifndef ANTIALIASING
|
|
const PxU32 yi = PxU32(fScreenHeight*float(j));
|
|
#endif
|
|
for(PxU32 i=0;i<RAYTRACING_RENDER_WIDTH;i++)
|
|
{
|
|
PxVec3 color(0.0f);
|
|
for(PxU32 k=0;k<gNbSamplesPerPixel;k++)
|
|
{
|
|
#ifdef ANTIALIASING
|
|
const float radius = 1.0f;
|
|
const float jitterX = radius*(RandomFloat01(rngState) - 0.5f);
|
|
const float jitterY = radius*(RandomFloat01(rngState) - 0.5f);
|
|
const float xf = fScreenWidth*(float(i)+jitterX);
|
|
const float yf = fScreenHeight*(float(j)+jitterY);
|
|
const PxVec3 dir = rp.computeWorldRayF(xf, yf);
|
|
#else
|
|
const PxU32 xi = PxU32(fScreenWidth*float(i));
|
|
const PxVec3 dir = rp.computeWorldRayF(float(xi), float(yi));
|
|
#endif
|
|
Ray r;
|
|
r.mPos = camPos;
|
|
r.mDir = dir;
|
|
color += trace2(r, rngState, 0);
|
|
}
|
|
*buffer++ = color * gOneOverNbSamples;
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef PRINT_TIMINGS
|
|
const DWORD64 time1 = __rdtsc();
|
|
#endif
|
|
gFrameIndex++;
|
|
const float coeff = 1.0f/float(gFrameIndex);
|
|
const float coeff2 = 1.0f-coeff;
|
|
|
|
if(gUseMultipleThreads && !gShowAllThreadRenders)
|
|
{
|
|
for(PxU32 j=0;j<4;j++)
|
|
{
|
|
for(PxU32 i=0;i<4;i++)
|
|
{
|
|
PxU32 offset = (RAYTRACING_RENDER_WIDTH/4)*i;
|
|
offset += (RAYTRACING_RENDER_HEIGHT/4)*j*RAYTRACING_RENDER_WIDTH;
|
|
|
|
const PxVec3* src = gCurrentPixels + offset;
|
|
PxVec3* dst = gAccumPixels + i + j*RAYTRACING_RENDER_WIDTH;
|
|
|
|
for(PxU32 jj=0;jj<RAYTRACING_RENDER_HEIGHT/4;jj++)
|
|
{
|
|
for(PxU32 ii=0;ii<RAYTRACING_RENDER_WIDTH/4;ii++)
|
|
{
|
|
dst[ii*4] = dst[ii*4]*coeff2 + src[ii]*coeff;
|
|
}
|
|
src += RAYTRACING_RENDER_WIDTH;
|
|
dst += RAYTRACING_RENDER_WIDTH*4;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for(PxU32 i=0;i<textureWidth*textureHeight;i++)
|
|
{
|
|
gAccumPixels[i] = gAccumPixels[i]*coeff2 + gCurrentPixels[i]*coeff;
|
|
}
|
|
}
|
|
|
|
if(!gCurrentTexture)
|
|
gCurrentTexture = new GLubyte[textureWidth*textureHeight*4];
|
|
|
|
if(1)
|
|
{
|
|
for(PxU32 i=0;i<textureWidth*textureHeight;i++)
|
|
{
|
|
PxVec3 col = gAccumPixels[i];
|
|
|
|
// apply exposure (how long the shutter is open)
|
|
col *= gExposure;
|
|
|
|
if(gToneMapping)
|
|
{
|
|
// convert unbounded HDR color range to SDR color range
|
|
col = ACESTonemap(col);
|
|
}
|
|
|
|
if(gLinearToSRGB)
|
|
col = LinearToSRGB2(col);
|
|
|
|
col *= 255.99f;
|
|
|
|
if(col.x>255.0f)
|
|
col.x = 255.0f;
|
|
if(col.y>255.0f)
|
|
col.y = 255.0f;
|
|
if(col.z>255.0f)
|
|
col.z = 255.0f;
|
|
|
|
gCurrentTexture[i*4+0] = GLubyte(col.x);
|
|
gCurrentTexture[i*4+1] = GLubyte(col.y);
|
|
gCurrentTexture[i*4+2] = GLubyte(col.z);
|
|
gCurrentTexture[i*4+3] = 255;
|
|
}
|
|
}
|
|
|
|
if(1)
|
|
{
|
|
if(!gTexID)
|
|
gTexID = Snippets::CreateTexture(textureWidth, textureHeight, gCurrentTexture, false);
|
|
else
|
|
Snippets::UpdateTexture(gTexID, textureWidth, textureHeight, gCurrentTexture, false);
|
|
// Snippets::DisplayTexture(gTexID, RAYTRACING_RENDER_WIDTH, 10);
|
|
Snippets::DisplayTexture(gTexID, 0, 0);
|
|
}
|
|
|
|
#ifdef PRINT_TIMINGS
|
|
const DWORD64 time2 = __rdtsc();
|
|
const DWORD tgt2 = timeGetTime();
|
|
if(1)
|
|
{
|
|
printf("Render: %d\n", int(time1-time0)/1024);
|
|
printf("End : %d\n", int(time2-time1)/1024);
|
|
printf("Total : %d\n", int(time2-time0)/1024);
|
|
printf("Total : %d ms\n\n", tgt2 - tgt);
|
|
}
|
|
#endif
|
|
#ifdef STATS
|
|
printf("Total #rays: %d\n", gTotalNbRays);
|
|
gTotalNbRays = 0;
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
|
|
}
|
|
|
|
static PxConvexMesh* createConvexMesh(const PxVec3* verts, const PxU32 numVerts, const PxCookingParams& params)
|
|
{
|
|
PxConvexMeshDesc convexDesc;
|
|
convexDesc.points.count = numVerts;
|
|
convexDesc.points.stride = sizeof(PxVec3);
|
|
convexDesc.points.data = verts;
|
|
convexDesc.flags = PxConvexFlag::eCOMPUTE_CONVEX;
|
|
return PxCreateConvexMesh(params, convexDesc);
|
|
}
|
|
|
|
static PxConvexMesh* createCylinderMesh(const PxF32 width, const PxF32 radius, const PxCookingParams& params)
|
|
{
|
|
PxVec3 points[2*16];
|
|
for(PxU32 i = 0; i < 16; i++)
|
|
{
|
|
const PxF32 cosTheta = PxCos(i*PxPi*2.0f/16.0f);
|
|
const PxF32 sinTheta = PxSin(i*PxPi*2.0f/16.0f);
|
|
const PxF32 y = radius*cosTheta;
|
|
const PxF32 z = radius*sinTheta;
|
|
points[2*i+0] = PxVec3(-width/2.0f, y, z);
|
|
points[2*i+1] = PxVec3(+width/2.0f, y, z);
|
|
}
|
|
return createConvexMesh(points, 32, params);
|
|
}
|
|
|
|
static PxConvexMesh* gConvexMesh = NULL;
|
|
static PxTriangleMesh* gTriangleMesh = NULL;
|
|
|
|
static CustomScene* gScene = NULL;
|
|
|
|
static const float gMeshScaleValue = 1.5f;
|
|
|
|
enum SceneIndex
|
|
{
|
|
SCENE_FIRST = 0,
|
|
|
|
SCENE_ARAS = 0,
|
|
SCENE_BUNNY = 1,
|
|
SCENE_SPHERES = 2,
|
|
|
|
SCENE_COUNT
|
|
};
|
|
|
|
static PxU32 gSceneIndex = SCENE_BUNNY;
|
|
|
|
static void initScene()
|
|
{
|
|
const PxVec3 red(1.0f, 0.25f, 0.2f);
|
|
const PxVec3 green(0.5f, 1.0f, 0.4f);
|
|
const PxVec3 blue(0.1f, 0.5f, 1.0f);
|
|
const PxVec3 grey(0.5f);
|
|
const PxVec3 noEmissive(0.0f);
|
|
const PxVec3 smallEmissive(0.0f);
|
|
// const PxVec3 bigEmissive(0.7f);
|
|
const PxVec3 bigEmissive(70.0f);
|
|
const PxVec3 color(1.0f, 0.5f, 0.25f);
|
|
|
|
#if OPTIM_BAKE_MESH_SCALE
|
|
// PT: queries against scaled meshes are slightly slower, so we pre-scale the vertices
|
|
const PxMeshScale meshScale(1.0f);
|
|
#else
|
|
const PxMeshScale meshScale(gMeshScaleValue);
|
|
#endif
|
|
|
|
gScene = new CustomScene;
|
|
|
|
gSkyCoeff = 0.4f;
|
|
gExposure = 0.5f;
|
|
|
|
if(gSceneIndex==SCENE_ARAS)
|
|
{
|
|
gScene->addGeom(PxSphereGeometry(100.0f), PxTransform(PxVec3(0,-100.5,-1)), PxVec3(0.8f, 0.8f, 0.8f), noEmissive);
|
|
gScene->addGeom(PxSphereGeometry(0.5f), PxTransform(PxVec3(2,0,-1)), PxVec3(0.8f, 0.4f, 0.4f), noEmissive);
|
|
gScene->addGeom(PxSphereGeometry(0.5f), PxTransform(PxVec3(0,0,-1)), PxVec3(0.4f, 0.8f, 0.4f), noEmissive);
|
|
gScene->addGeom(PxSphereGeometry(0.5f), PxTransform(PxVec3(-2,0,-1)), PxVec3(0.4f, 0.4f, 0.8f), noEmissive, Metal);
|
|
gScene->addGeom(PxSphereGeometry(0.5f), PxTransform(PxVec3(2,0,1)), PxVec3(0.4f, 0.8f, 0.4f), noEmissive, Metal);
|
|
gScene->addGeom(PxSphereGeometry(0.5f), PxTransform(PxVec3(0,0,1)), PxVec3(0.4f, 0.8f, 0.4f), noEmissive, Metal, 0.2f);
|
|
gScene->addGeom(PxSphereGeometry(0.5f), PxTransform(PxVec3(-2,0,1)), PxVec3(0.4f, 0.8f, 0.4f), noEmissive, Metal, 0.6f);
|
|
gScene->addGeom(PxSphereGeometry(0.5f), PxTransform(PxVec3(0.5f,1,0.5f)), PxVec3(0.4f, 0.4f, 0.4f), noEmissive, Dielectric, 0.0f, 1.5f);
|
|
gScene->addGeom(PxSphereGeometry(0.3f), PxTransform(PxVec3(-1.5f,1.5f,0.f)), PxVec3(0.8f, 0.6f, 0.2f), PxVec3(30,25,15));
|
|
}
|
|
else if(gSceneIndex==SCENE_BUNNY)
|
|
{
|
|
gScene->addGeom(PxSphereGeometry(1.0f), PxTransform(PxVec3(0.0f, 8.0f, 0.0f)), grey, PxVec3(70,65,55));
|
|
// gScene->addGeom(PxSphereGeometry(1.0f), PxTransform(PxVec3(0.0f, 8.0f, 0.0f)), grey, PxVec3(7.0f,6.5f,5.5f));
|
|
// gScene->addGeom(PxSphereGeometry(1.0f), PxTransform(PxVec3(4.0f, 4.5f, 4.0f)), grey, bigEmissive);
|
|
// gScene->addGeom(PxSphereGeometry(0.1f), PxTransform(PxVec3(4.0f, 4.5f, 4.0f)), grey, bigEmissive);
|
|
|
|
gScene->addGeom(PxBoxGeometry(PxVec3(15.0f, 0.01f, 15.0f)), PxTransform(PxVec3(0.0f, 0.0f, 0.0f)), grey, smallEmissive);
|
|
|
|
gScene->addGeom(PxBoxGeometry(PxVec3(1.0f, 2.0f, 0.5f)), PxTransform(PxVec3(0.0f, 2.0f, -4.0f)), color, smallEmissive);
|
|
gScene->addGeom(PxSphereGeometry(1.5f), PxTransform(PxVec3(4.0f, 1.55f, -4.0f)), grey, smallEmissive, Metal, 0.0f);
|
|
gScene->addGeom(PxSphereGeometry(1.5f), PxTransform(PxVec3(4.0f, 1.55f, 0.0f)), grey, smallEmissive, Metal, 0.1f);
|
|
gScene->addGeom(PxSphereGeometry(1.5f), PxTransform(PxVec3(4.0f, 1.55f, 4.0f)), grey, smallEmissive, Metal, 0.2f);
|
|
// gScene->addGeom(PxCapsuleGeometry(1.0f, 1.0f), PxTransform(PxVec3(-4.0f, 1.05f, 0.0f)), blue, smallEmissive, Dielectric, 0.0f, 1.2f);
|
|
gScene->addGeom(PxCapsuleGeometry(1.0f, 1.0f), PxTransform(PxVec3(-4.0f, 1.05f, 0.0f)), blue, smallEmissive);
|
|
gScene->addGeom(PxConvexMeshGeometry(gConvexMesh), PxTransform(PxVec3(0.0f, 1.05f, 4.0f)), green, smallEmissive);
|
|
gScene->addGeom(PxTriangleMeshGeometry(gTriangleMesh, meshScale), PxTransform(PxVec3(0.0f, 0.70f*gMeshScaleValue, 0.0f)), red, smallEmissive);
|
|
// gScene->addGeom(PxBoxGeometry(PxVec3(1.0f)), PxTransform(PxVec3(0.0f, 1.0f, 0.0f)), color, smallEmissive);
|
|
}
|
|
else if(gSceneIndex==SCENE_SPHERES)
|
|
{
|
|
gScene->addGeom(PxBoxGeometry(PxVec3(150.0f, 0.0001f, 150.0f)), PxTransform(PxVec3(0.0f, 0.0f, 0.0f)), grey, smallEmissive);
|
|
gScene->addGeom(PxSphereGeometry(10.0f), PxTransform(PxVec3(0.0f, 40.0f, 0.0f)), grey, PxVec3(100.0f));
|
|
const PxU32 nb = 16;
|
|
PxU32 state = 42;
|
|
// const PxVec3 base(1.0f, 0.5f, 0.25f);
|
|
const PxVec3 base(1.0f, 0.5f, 0.2f);
|
|
for(PxU32 i=0;i<nb;i++)
|
|
{
|
|
const float CoeffX = float(i) - float(nb/2);
|
|
for(PxU32 j=0;j<nb;j++)
|
|
{
|
|
const float CoeffZ = float(j) - float(nb/2);
|
|
|
|
const float x = CoeffX * 4.0f;
|
|
const float z = CoeffZ * 4.0f;
|
|
|
|
PxVec3 rndColor(RandomFloat01(state), RandomFloat01(state), RandomFloat01(state));
|
|
rndColor += base;
|
|
rndColor *= 0.5f;
|
|
|
|
// gScene->addGeom(PxSphereGeometry(1.0f), PxTransform(PxVec3(x, 1.0f, z)), rndColor, smallEmissive, Metal, 0.25f);
|
|
gScene->addGeom(PxSphereGeometry(1.0f), PxTransform(PxVec3(x, 1.0f, z)), rndColor, smallEmissive, Metal, 0.0f);
|
|
// gScene->addGeom(PxBoxGeometry(PxVec3(1.0f)), PxTransform(PxVec3(x, 1.0f, z)), rndColor, smallEmissive, Metal, 0.0f);
|
|
// gScene->addGeom(PxTriangleMeshGeometry(gTriangleMesh, meshScale), PxTransform(PxVec3(x, 0.75f*gMeshScaleValue, z)), rndColor, smallEmissive);
|
|
}
|
|
}
|
|
}
|
|
|
|
gScene->createBVH();
|
|
}
|
|
|
|
static void releaseScene()
|
|
{
|
|
PX_RELEASE(gScene);
|
|
}
|
|
|
|
void renderScene()
|
|
{
|
|
if(gScene)
|
|
gScene->render();
|
|
}
|
|
|
|
static void threadExecute(void* data)
|
|
{
|
|
TracerThread* tracerThread = static_cast<TracerThread*>(data);
|
|
|
|
for(;;)
|
|
{
|
|
SnippetUtils::syncWait(tracerThread->mWorkReadySyncHandle);
|
|
SnippetUtils::syncReset(tracerThread->mWorkReadySyncHandle);
|
|
|
|
if (SnippetUtils::threadQuitIsSignalled(tracerThread->mThreadHandle))
|
|
break;
|
|
|
|
tracerThread->Run();
|
|
SnippetUtils::syncSet(tracerThread->mWorkDoneSyncHandle);
|
|
}
|
|
|
|
SnippetUtils::threadQuit(tracerThread->mThreadHandle);
|
|
}
|
|
|
|
void initPhysics(bool /*interactive*/)
|
|
{
|
|
gFoundation = PxCreateFoundation(PX_PHYSICS_VERSION, gAllocator, gErrorCallback);
|
|
|
|
const PxTolerancesScale scale;
|
|
PxCookingParams params(scale);
|
|
params.midphaseDesc.setToDefault(PxMeshMidPhase::eBVH34);
|
|
// params.midphaseDesc.mBVH34Desc.quantized = false;
|
|
// We don't need the extra data structures for just doing raycasts vs the mesh
|
|
params.meshPreprocessParams |= PxMeshPreprocessingFlag::eDISABLE_ACTIVE_EDGES_PRECOMPUTE;
|
|
params.meshPreprocessParams |= PxMeshPreprocessingFlag::eDISABLE_CLEAN_MESH;
|
|
|
|
gConvexMesh = createCylinderMesh(3.0f, 1.0f, params);
|
|
|
|
{
|
|
PxTriangleMeshDesc meshDesc;
|
|
meshDesc.points.count = SnippetUtils::Bunny_getNbVerts();
|
|
meshDesc.points.stride = sizeof(PxVec3);
|
|
meshDesc.points.data = SnippetUtils::Bunny_getVerts();
|
|
meshDesc.triangles.count = SnippetUtils::Bunny_getNbFaces();
|
|
meshDesc.triangles.stride = sizeof(int)*3;
|
|
meshDesc.triangles.data = SnippetUtils::Bunny_getFaces();
|
|
|
|
#if OPTIM_BAKE_MESH_SCALE
|
|
PxVec3* verts = const_cast<PxVec3*>(SnippetUtils::Bunny_getVerts());
|
|
for(PxU32 i=0;i<meshDesc.points.count;i++)
|
|
verts[i] *= gMeshScaleValue;
|
|
#endif
|
|
|
|
gTriangleMesh = PxCreateTriangleMesh(params, meshDesc);
|
|
}
|
|
|
|
initScene();
|
|
|
|
#ifdef RENDER_SNIPPET
|
|
Snippets::enableVSync(false);
|
|
#endif
|
|
for (PxU32 i=0; i<gNumThreads; i++)
|
|
{
|
|
gThreads[i].mWorkReadySyncHandle = SnippetUtils::syncCreate();
|
|
gThreads[i].mWorkDoneSyncHandle = SnippetUtils::syncCreate();
|
|
gThreads[i].mThreadHandle = SnippetUtils::threadCreate(threadExecute, &gThreads[i]);
|
|
}
|
|
}
|
|
|
|
void stepPhysics(bool /*interactive*/)
|
|
{
|
|
}
|
|
|
|
void cleanupPhysics(bool /*interactive*/)
|
|
{
|
|
for (PxU32 i=0; i<gNumThreads; i++)
|
|
{
|
|
SnippetUtils::threadSignalQuit(gThreads[i].mThreadHandle);
|
|
SnippetUtils::syncSet(gThreads[i].mWorkReadySyncHandle);
|
|
}
|
|
|
|
for (PxU32 i=0; i<gNumThreads; i++)
|
|
{
|
|
SnippetUtils::threadWaitForQuit(gThreads[i].mThreadHandle);
|
|
SnippetUtils::threadRelease(gThreads[i].mThreadHandle);
|
|
SnippetUtils::syncRelease(gThreads[i].mWorkReadySyncHandle);
|
|
}
|
|
|
|
for (PxU32 i=0; i<gNumThreads; i++)
|
|
SnippetUtils::syncRelease(gThreads[i].mWorkDoneSyncHandle);
|
|
|
|
releaseScene();
|
|
|
|
#ifdef RENDER_SNIPPET
|
|
Snippets::ReleaseTexture(gTexID);
|
|
#endif
|
|
PX_RELEASE(gConvexMesh);
|
|
PX_RELEASE(gFoundation);
|
|
|
|
#ifdef RENDER_SNIPPET
|
|
if(gCurrentTexture)
|
|
{
|
|
delete [] gCurrentTexture;
|
|
gCurrentTexture = NULL;
|
|
}
|
|
#endif
|
|
if(gCurrentPixels)
|
|
{
|
|
delete [] gCurrentPixels;
|
|
gCurrentPixels = NULL;
|
|
}
|
|
|
|
if(gAccumPixels)
|
|
{
|
|
delete [] gAccumPixels;
|
|
gAccumPixels = NULL;
|
|
}
|
|
|
|
printf("SnippetPathTracing done.\n");
|
|
}
|
|
|
|
void keyPress(unsigned char key, const PxTransform& /*camera*/)
|
|
{
|
|
if(key == 1)
|
|
{
|
|
gSceneIndex++;
|
|
if(gSceneIndex==SCENE_COUNT)
|
|
gSceneIndex = SCENE_FIRST;
|
|
releaseScene();
|
|
initScene();
|
|
resetRender();
|
|
}
|
|
else if(key == 2)
|
|
{
|
|
if(gSceneIndex)
|
|
gSceneIndex--;
|
|
else
|
|
gSceneIndex = SCENE_COUNT-1;
|
|
releaseScene();
|
|
initScene();
|
|
resetRender();
|
|
}
|
|
else if(key == 3)
|
|
{
|
|
gSkyCoeff += 0.1f;
|
|
printf("Sky coeff: %f\n", double(gSkyCoeff));
|
|
resetRender();
|
|
}
|
|
else if(key == 4)
|
|
{
|
|
gSkyCoeff -= 0.1f;
|
|
if(gSkyCoeff<0.0f)
|
|
gSkyCoeff=0.0f;
|
|
printf("Sky coeff: %f\n", double(gSkyCoeff));
|
|
resetRender();
|
|
}
|
|
else if(key == 5)
|
|
{
|
|
gExposure += 0.1f;
|
|
printf("Exposure: %f\n", double(gExposure));
|
|
resetRender();
|
|
}
|
|
else if(key == 6)
|
|
{
|
|
gExposure -= 0.1f;
|
|
if(gExposure<0.0f)
|
|
gExposure=0.0f;
|
|
printf("Exposure: %f\n", double(gExposure));
|
|
resetRender();
|
|
}
|
|
else if(key == 'r' || key == 'R')
|
|
{
|
|
resetRender();
|
|
}
|
|
else if(key == 'g' || key == 'G')
|
|
{
|
|
gShowAllThreadRenders = !gShowAllThreadRenders;
|
|
printf("Debug multithread: %d\n", gShowAllThreadRenders);
|
|
}
|
|
else if(key == 'm' || key == 'M')
|
|
{
|
|
gUseMultipleThreads = !gUseMultipleThreads;
|
|
printf("Multithreading: %d\n", gUseMultipleThreads);
|
|
}
|
|
else if(key == 't' || key == 'T')
|
|
{
|
|
gToneMapping = !gToneMapping;
|
|
printf("Tone mapping: %d\n", gToneMapping);
|
|
}
|
|
else if(key == 'l' || key == 'L')
|
|
{
|
|
gLinearToSRGB = !gLinearToSRGB;
|
|
printf("Linear-to-SRGB: %d\n", gLinearToSRGB);
|
|
}
|
|
}
|
|
|
|
int snippetMain(int, const char*const*)
|
|
{
|
|
printf("PxBVH PathTracing snippet. Use these keys:\n");
|
|
printf(" F1/F2 - change scene\n");
|
|
printf(" F3/F4 - change sky color intensity\n");
|
|
printf(" F5/F6 - change exposure value\n");
|
|
printf(" m - multithreading on/off\n");
|
|
printf(" t - tone mapping on/off\n");
|
|
printf(" l - linear to SRGB/off\n");
|
|
printf(" r - reset scene\n");
|
|
printf(" g - debug multithreading on/off\n");
|
|
printf("\n");
|
|
|
|
#ifdef RENDER_SNIPPET
|
|
extern void renderLoop();
|
|
renderLoop();
|
|
#else
|
|
static const PxU32 frameCount = 100;
|
|
initPhysics(false);
|
|
for(PxU32 i=0; i<frameCount; i++)
|
|
stepPhysics(false);
|
|
cleanupPhysics(false);
|
|
#endif
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
|