dev0/PhysX4.1
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
a3a8e7970943b1cbac0ad7fc05b7768c184db5e9
PhysX4.1/kaplademo/source/kaplaDemo/Fracture/SimScene.cpp
dev0 a3a8e79709 Init
2025-11-28 23:13:44 +05:30

737 lines
24 KiB
C++
Raw Blame History

//
// 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 "SimScene.h"
#include <foundation/PxMat44.h>
#include "PxRigidBodyExt.h"
#include "Actor.h"
#include "Compound.h"
#include "Convex.h"
#include "CompoundCreator.h"
#include "PolygonTriangulator.h"
#include "SampleViewerScene.h"
#include <windows.h>
#include <iostream>
using namespace std;
#include <vector>
#include "TerrainMesh.h"
#define USE_CONVEX_RENDERER 1
#define NUM_NO_SOUND_FRAMES 1
//#define REL_VEL_FRACTURE_THRESHOLD 5.0f
#define REL_VEL_FRACTURE_THRESHOLD 0.1f
//extern std::vector<Compound*> delCompoundList;
SimScene* SimScene::createSimScene(PxPhysics *pxPhysics, PxCooking *pxCooking, bool isGrbScene, float minConvexSize, PxMaterial* defaultMat, const char *resourcePath)
{
SimScene* s = PX_NEW(SimScene)(pxPhysics,pxCooking,isGrbScene,minConvexSize,defaultMat,resourcePath);
s->createSingletons();
return s;
}
void SimScene::createSingletons()
{
mCompoundCreator = PX_NEW(CompoundCreator)(this);
mPolygonTriangulator = PX_NEW(PolygonTriangulator)(this);
addActor(createActor());
}
base::Actor* SimScene::createActor()
{
return (base::Actor*)PX_NEW(Actor)(this);
}
base::Convex* SimScene::createConvex()
{
return (base::Convex*)PX_NEW(Convex)(this);
}
base::Compound* SimScene::createCompound(PxReal contactOffset, PxReal restOffset)
{
return (base::Compound*)PX_NEW(Compound)(this, contactOffset, restOffset);
}
SimScene::SimScene(PxPhysics *pxPhysics, PxCooking *pxCooking, bool isGrbScene, float minConvexSize, PxMaterial* defaultMat, const char *resourcePath):
base::SimScene(pxPhysics,pxCooking,isGrbScene,minConvexSize,defaultMat,resourcePath)
{
//mParticles = NULL;
diffuseTexArray = 0;
bumpTexArray = 0;
specularTexArray = 0;
emissiveReflectSpecPowerTexArray = 0;
create3dTexture();
}
// --------------------------------------------------------------------------------------------
SimScene::~SimScene()
{
mShader = NULL;
mShaderMat.init();
if (mRenderBuffers.volTex) glDeleteTextures(1, &mRenderBuffers.volTex);
if (mRenderBuffers.VBO) glDeleteBuffersARB(1, &mRenderBuffers.VBO);
if (mRenderBuffers.IBO) glDeleteBuffersARB(1, &mRenderBuffers.IBO);
if (mRenderBuffers.matTex) glDeleteTextures(1, &mRenderBuffers.matTex);
}
// --------------------------------------------------------------------------------------------
void SimScene::clear()
{
base::SimScene::clear();
}
// --------------------------------------------------------------------------------------------
void SimScene::postSim(float dt, RegularCell3D* fluidSim)
{
for (int i = 0; i < mActors.size(); i++)
{
mActors[i]->postSim(dt);
}
mFrameNr++;
mNoFractureFrames--;
mNoSoundFrames--;
}
void SimScene::profileBegin(const char* name)
{
}
void SimScene::profileEnd(const char* name)
{
}
// ------------------------- Renderering --------------------------------
GLuint SimScene::loadTextureArray(std::vector<std::string>& names) {
GLuint texid;
glGenTextures(1, &texid);
glBindTexture( GL_TEXTURE_2D_ARRAY_EXT, texid);
glTexParameteri( GL_TEXTURE_2D_ARRAY_EXT, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri( GL_TEXTURE_2D_ARRAY_EXT, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri( GL_TEXTURE_2D_ARRAY_EXT, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri( GL_TEXTURE_2D_ARRAY_EXT, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri( GL_TEXTURE_2D_ARRAY_EXT, GL_GENERATE_MIPMAP_SGIS, GL_TRUE);
class BmpLoaderBuffer : public ::BmpLoaderBuffer, public ::physx::shdfnd::UserAllocated {};
BmpLoaderBuffer *bmps;
bmps = PX_NEW(BmpLoaderBuffer)[names.size()];
char path[512];
int w = 0, h = 0, d = 0;
for (int i = 0; i < (int)names.size(); i++) {
if (names[i].size() > 0) {
sprintf_s(path, 512, "%s", names[i].c_str());
int len = strlen(path);
int mw = 0, mh = 0;
if (strcmp(&path[len-4], ".jpg") == 0) {
printf("Can't load %s, jpg no longer supported\n", path);
} else {
bmps[i].loadFile(path);
mw = bmps[i].mWidth;
mh = bmps[i].mHeight;
}
if ((mw != 0) && (mh != 0)) {
if ( ((w != 0) && (w != mw)) ||
((h != 0) && (h != mh)) ) {
printf("Textures in array need to be same size!\n");
}
w = mw;
h = mh;
}
}
}
d = names.size();
if (w == 0) {
w=h=128;
}
unsigned char* tmpBlack = (unsigned char*)PX_ALLOC(sizeof(unsigned char)*w*h*3,PX_DEBUG_EXP("RT_FRACTURE"));
memset(tmpBlack, 0, w*h*3);
glTexImage3D(GL_TEXTURE_2D_ARRAY_EXT, 0, GL_RGB8, w, h, d, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
for (int i = 0; i < (int)names.size(); i++) {
glTexSubImage3D( GL_TEXTURE_2D_ARRAY_EXT, 0, 0, 0, i, w, h, 1, GL_RGB, GL_UNSIGNED_BYTE, (bmps[i].mRGB) ? bmps[i].mRGB :tmpBlack
);
}
glGenerateMipmapEXT(GL_TEXTURE_2D_ARRAY_EXT);
PX_FREE(tmpBlack);
PX_DELETE_ARRAY(bmps);
/* names
// 2D Texture arrays a loaded just like 3D textures
glTexImage3D(GL_TEXTURE_2D_ARRAY_EXT, 0, GL_RGBA8, images[0].getWidth(), images[0].getHeight(), NIMAGES, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
for (int i = 0; i < NIMAGES; i++) {
glTexSubImage3D( GL_TEXTURE_2D_ARRAY_EXT, 0, 0, 0, i, images[i].getWidth(), images[i].getHeight(), 1, images[i].getFormat(), images[i].getType(), images[i].getLevel(0));
}
*/
return texid;
}
void SimScene::loadAndCreateTextureArrays() {
diffuseTexArray = loadTextureArray(diffuseTexNames);
bumpTexArray = loadTextureArray(bumpTexNames);
specularTexArray = loadTextureArray(specularTexNames);
emissiveReflectSpecPowerTexArray = loadTextureArray(emissiveReflectSpecPowerTexNames);
}
// --------------------------------------------------------------------------------------------
#define WIDTH 128
#define HEIGHT 128
#define DEPTH 128
#define BYTES_PER_TEXEL 3
#define LAYER(r) (WIDTH * HEIGHT * r * BYTES_PER_TEXEL)
// 2->1 dimension mapping function
#define TEXEL2(s, t) (BYTES_PER_TEXEL * (s * WIDTH + t))
// 3->1 dimension mapping function
#define TEXEL3(s, t, r) (TEXEL2(s, t) + LAYER(r))
// --------------------------------------------------------------------------------------------
void SimScene::create3dTexture()
{
unsigned char *texels = (unsigned char *)malloc(WIDTH * HEIGHT * DEPTH * BYTES_PER_TEXEL);
memset(texels, 0, WIDTH*HEIGHT*DEPTH);
// each of the following loops defines one layer of our 3d texture, there are 3 unsigned bytes (red, green, blue) for each texel so each iteration sets 3 bytes
// the memory pointed to by texels is technically a single dimension (C++ won't allow more than one dimension to be of variable length), the
// work around is to use a mapping function like the one above that maps the 3 coordinates onto one dimension
// layer 0 occupies the first (width * height * bytes per texel) bytes, followed by layer 1, etc...
// define layer 0 as red
// Perlin perlin(8,4,1,91114);
unsigned char* tt = texels;
float idx = 1.0f / DEPTH;
for (int i = 0; i < DEPTH; i++) {
for (int j = 0; j < HEIGHT; j++) {
for (int k = 0; k < WIDTH; k++) {
//float v[3] = {i*idx, j*idx, k*idx};
//float val = (perlin.noise3(v)*0.5f + 0.5f)*255.0f;//cos( (perlin.Noise3(i*0.01f,j*0.01f,k*0.01f)*255000 + i*0.)*5.0f)*0.5f+0.5f;//perlin.Noise3(k,j,i)*255.0f;
//(cos(perlin.Noise3(k,j,i) + j*0.01f) + 1.0f)*0.5f*255;
unsigned char val = rand() % 255;
tt[0] = val;
tt[1] = val;
tt[2] = val;
tt+=3;
}
}
}
// request 1 texture name from OpenGL
glGenTextures(1, &mRenderBuffers.volTex);
// tell OpenGL we're going to be setting up the texture name it gave us
glBindTexture(GL_TEXTURE_3D, mRenderBuffers.volTex);
// when this texture needs to be shrunk to fit on small polygons, use linear interpolation of the texels to determine the color
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
// when this texture needs to be magnified to fit on a big polygon, use linear interpolation of the texels to determine the color
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// we want the texture to repeat over the S axis, so if we specify coordinates out of range we still get textured.
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_REPEAT);
// same as above for T axis
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// same as above for R axis
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_REPEAT);
// this is a 3d texture, level 0 (max detail), GL should store it in RGB8 format, its WIDTHxHEIGHTxDEPTH in size,
// it doesnt have a border, we're giving it to GL in RGB format as a series of unsigned bytes, and texels is where the texel data is.
glTexImage3D(GL_TEXTURE_3D, 0, GL_RGB8, WIDTH, HEIGHT, DEPTH, 0, GL_RGB, GL_UNSIGNED_BYTE, texels);
glBindTexture(GL_TEXTURE_3D, 0);
}
// --------------------------------------------------------------------------------------------
void SimScene::createRenderBuffers()
{
if (!mRenderBuffers.VBO) {
glGenBuffersARB(1, &mRenderBuffers.VBO);
}
if (!mRenderBuffers.IBO) {
glGenBuffersARB(1, &mRenderBuffers.IBO);
}
if (!mRenderBuffers.matTex) {
glGenTextures(1, &mRenderBuffers.matTex);
glBindTexture(GL_TEXTURE_2D, mRenderBuffers.matTex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glBindTexture(GL_TEXTURE_2D, 0);
}
// Count number of vertices and indices in convexes
// Count number of indices in convexes
mRenderBuffers.numConvexes = 0;
mRenderBuffers.numVertices = 0;
mRenderBuffers.numIndices = 0;
for (int k = 0; k < (int)mActors.size(); k++)
{
const shdfnd::Array<base::Compound*>& mCompounds = mActors[k]->getCompounds();
for (int i = 0; i < (int)mCompounds.size(); i++) {
if (((Compound*)mCompounds[i])->getShader() != mShader)
continue;
const shdfnd::Array<base::Convex*> &convexes = mCompounds[i]->getConvexes();
mRenderBuffers.numConvexes += convexes.size();
for (int j = 0; j < (int)convexes.size(); j++) {
mRenderBuffers.numVertices += convexes[j]->getVisVertices().size();
mRenderBuffers.numIndices += convexes[j]->getVisTriIndices().size();
}
}
}
if (mRenderBuffers.numVertices == 0 || mRenderBuffers.numIndices == 0)
return;
mRenderBuffers.tmpVertices.resize(mRenderBuffers.numVertices*12);
mRenderBuffers.tmpIndices.resize(mRenderBuffers.numIndices);
float* vp = &mRenderBuffers.tmpVertices[0];
unsigned int* ip = &mRenderBuffers.tmpIndices[0];
int sumV = 0;
// Make cpu copy of VBO and IBO
int convexNr = 0;
for (int k = 0; k < (int)mActors.size(); k++)
{
const shdfnd::Array<base::Compound*>& mCompounds = mActors[k]->getCompounds();
for (int i = 0; i < (int)mCompounds.size(); i++) {
if (((Compound*)mCompounds[i])->getShader() != mShader)
continue;
const shdfnd::Array<base::Convex*> &convexes = mCompounds[i]->getConvexes();
for (int j = 0; j < (int)convexes.size(); j++, convexNr++) {
Convex* c = (Convex*)convexes[j];
// PxVec3 matOff = c->getMaterialOffset();
int nv = c->getVisVertices().size();
int ni = c->getVisTriIndices().size();
if (nv > 0) {
float* cvp = (float*)&c->getVisVertices()[0]; // float3
float* cnp = (float*)&c->getVisNormals()[0]; // float3
// float* c3dtp = (float*)&c->getVisVertices()[0]; // float3
float* c2dtp = (float*)&c->getVisTexCoords()[0]; // float2
float* ctanp = (float*)&c->getVisTangents()[0]; // float3
int* cip = (int*)&c->getVisTriIndices()[0];
for (int k = 0; k < nv; k++) {
*(vp++) = *(cvp++);
*(vp++) = *(cvp++);
*(vp++) = *(cvp++);
*(vp++) = *(cnp++);
*(vp++) = *(cnp++);
*(vp++) = *(cnp++);
*(vp++) = *(ctanp++);
*(vp++) = *(ctanp++);
*(vp++) = *(ctanp++);
*(vp++) = (float)convexNr;
*(vp++) = *(c2dtp++);
*(vp++) = *(c2dtp++);
}
for (int k = 0; k < ni; k++) {
*(ip++) = *(cip++) + sumV;
}
}
//memcpy(ip, cip, sizeof(int)*ni);
//ip += 3*ni;
//std::vector<PxVec3> mTriVertices;
//std::vector<PxVec3> mTriNormals;
//std::vector<int> mTriIndices;
//std::vector<float> mTriTexCoords; // 3d + obj nr
sumV += nv;
}
}
}
glBindBufferARB(GL_ARRAY_BUFFER_ARB, mRenderBuffers.VBO);
glBufferDataARB(GL_ARRAY_BUFFER_ARB, mRenderBuffers.tmpVertices.size()*sizeof(float), &mRenderBuffers.tmpVertices[0], GL_STATIC_DRAW);
glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, mRenderBuffers.IBO);
glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB, mRenderBuffers.tmpIndices.size()*sizeof(unsigned int), &mRenderBuffers.tmpIndices[0], GL_STATIC_DRAW);
glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
int oldTexSize = mRenderBuffers.texSize;
if (mRenderBuffers.texSize == 0) {
// First time
oldTexSize = 1;
mRenderBuffers.texSize = 32;
}
while (1) {
int convexesPerRow = mRenderBuffers.texSize / 4;
if (convexesPerRow * mRenderBuffers.texSize >= mRenderBuffers.numConvexes) {
break;
} else {
mRenderBuffers.texSize *= 2;
}
}
if (mRenderBuffers.texSize != oldTexSize) {
mRenderBuffers.tmpTexCoords.resize(mRenderBuffers.texSize*mRenderBuffers.texSize*4);
// Let's allocate texture
glBindTexture(GL_TEXTURE_2D, mRenderBuffers.matTex);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F_ARB, mRenderBuffers.texSize, mRenderBuffers.texSize, 0, GL_RGBA, GL_FLOAT, 0);
glBindTexture(GL_TEXTURE_2D, 0);
}
mRenderBufferVersion = mSceneVersion;
//instanceVBOCPU.resize( newSize * 16);
}
// --------------------------------------------------------------------------------------------
void SimScene::updateConvexesTex()
{
float* tt = &mRenderBuffers.tmpTexCoords[0];
for (int k = 0; k < (int)mActors.size(); k++)
{
const shdfnd::Array<base::Compound*>& mCompounds = mActors[k]->getCompounds();
for (int i = 0; i < (int)mCompounds.size(); i++) {
if ( ((Compound*)mCompounds[i])->getShader() != mShader)
continue;
const shdfnd::Array<base::Convex*> &convexes = mCompounds[i]->getConvexes();
for (int j = 0; j < (int)convexes.size(); j++) {
Convex* c = (Convex*)convexes[j];
PxMat44 pose(convexes[j]->getGlobalPose());
float* mp = (float*)pose.front();
float* ta = tt;
for (int k = 0; k < 16; k++) {
*(tt++) = *(mp++);
}
PxVec3 matOff = c->getMaterialOffset();
ta[3] = matOff.x;
ta[7] = matOff.y;
ta[11] = matOff.z;
int idFor2DTex = c->getSurfaceMaterialId();
int idFor3DTex = 0;
const int MAX_3D_TEX = 8;
ta[15] = (float)(idFor2DTex*MAX_3D_TEX + idFor3DTex);
}
}
}
glBindTexture(GL_TEXTURE_2D, mRenderBuffers.matTex);
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, mRenderBuffers.texSize, mRenderBuffers.texSize,
GL_RGBA, GL_FLOAT, &mRenderBuffers.tmpTexCoords[0]);
glBindTexture(GL_TEXTURE_2D, 0);
}
// --------------------------------------------------------------------------------------------
#ifdef USE_OPTIX
// Updater class for Optix renderer.
class FractureModelUpdate : public optix_demo::IModelUpdate
{
public:
FractureModelUpdate( shdfnd::Array< Compound* > const& compounds, bool complete_update )
: m_compounds(compounds), m_is_complete_update( complete_update )
{}
bool isCompleteUpdate() const {return m_is_complete_update;}
void to_first();
void to_next();
bool at_end() const;
size_t num_vertices() const {return (*m_iconvex)->getVisVertices().size();}
size_t num_indices() const {return (*m_iconvex)->getVisTriIndices().size();}
float const* vertices() const {return &(*m_iconvex)->getVisVertices()[0].x;}
float const* normals() const {return &(*m_iconvex)->getVisNormals()[0].x;}
int const* indices() const {return &(*m_iconvex)->getVisTriIndices()[0];}
void global_transform( float* rmat3x3, float* translation );
private:
void advance();
bool is_valid_convex( Convex const* c ) const
{
return !c->getVisVertices().empty();
}
shdfnd::Array< Compound* > const& m_compounds;
bool m_is_complete_update;
shdfnd::Array< Compound* >::ConstIterator m_icompound;
shdfnd::Array< Convex* >::ConstIterator m_iconvex;
};
void FractureModelUpdate::to_first()
{
m_icompound = m_compounds.begin();
if (m_icompound == m_compounds.end()) return;
while ((*m_icompound)->getConvexes().empty()) {
++m_icompound;
if (m_icompound == m_compounds.end()) return;
}
m_iconvex = (*m_icompound)->getConvexes().begin();
while (!is_valid_convex(*m_iconvex)) {
advance();
if (m_icompound == m_compounds.end()) return;
}
}
void FractureModelUpdate::to_next()
{
if (m_icompound != m_compounds.end()) {
do {
advance();
} while (m_icompound != m_compounds.end() && !is_valid_convex(*m_iconvex));
}
}
void FractureModelUpdate::advance()
{
if (m_iconvex != (*m_icompound)->getConvexes().end()) {
++m_iconvex;
}
if (m_iconvex == (*m_icompound)->getConvexes().end()) {
// End of convexes of this compound.
do {
++m_icompound;
if (m_icompound == m_compounds.end()) return;
} while ((*m_icompound)->getConvexes().empty());
m_iconvex = (*m_icompound)->getConvexes().begin();
}
}
bool FractureModelUpdate::at_end() const
{
return m_icompound == m_compounds.end();
}
void FractureModelUpdate::global_transform( float* rmat3x3, float* translation )
{
PxTransform pose = (*m_iconvex)->getGlobalPose();
PxMat33 rot(pose.q);
rmat3x3[0] = rot.column0.x; rmat3x3[1] = rot.column1.x; rmat3x3[2] = rot.column2.x;
rmat3x3[3] = rot.column0.y; rmat3x3[4] = rot.column1.y; rmat3x3[5] = rot.column2.y;
rmat3x3[6] = rot.column0.z; rmat3x3[7] = rot.column1.z; rmat3x3[8] = rot.column2.z;
translation[0] = pose.p.x;
translation[1] = pose.p.y;
translation[2] = pose.p.z;
}
#endif //USE_OPTIX
extern bool gConvexTexOutdate;
// --------------------------------------------------------------------------------------------
void SimScene::draw(bool useShader)
{
if (mDebugDraw) {
for (int k = 0; k < (int)mActors.size(); k++)
{
const shdfnd::Array<base::Compound*>& mCompounds = mActors[k]->getCompounds();
for (int i = 0; i < (int)mCompounds.size(); i++)
mCompounds[i]->draw(false, true);
}
return;
}
int numCompounds = 0;
for (int k = 0; k < (int)mActors.size(); k++)
{
const shdfnd::Array<base::Compound*>& mCompounds = mActors[k]->getCompounds();
numCompounds += mCompounds.size();
}
if (numCompounds == 0) return;
if (SampleViewerScene::getRenderType() == SampleViewerScene::rtOPENGL) {
#if USE_CONVEX_RENDERER
mConvexRenderer.setShaderMaterial(mShader, mShaderMat);
mConvexRenderer.setTexArrays(diffuseTexArray, bumpTexArray,
specularTexArray, emissiveReflectSpecPowerTexArray);
mConvexRenderer.setVolTex(mRenderBuffers.volTex);
mConvexRenderer.render();
#else
mConvexRenderer.setActive(false);
if (mRenderBufferVersion != mSceneVersion)
createRenderBuffers();
if (mRenderBuffers.numIndices > 0) {
if (gConvexTexOutdate) {
updateConvexesTex();
gConvexTexOutdate = false;
}
mShader->activate(mShaderMat);
// Assume convex all use the same shader
glActiveTexture(GL_TEXTURE7);
glBindTexture(GL_TEXTURE_3D, mRenderBuffers.volTex);
glActiveTexture(GL_TEXTURE8);
glBindTexture(GL_TEXTURE_2D, mRenderBuffers.matTex);
glActiveTexture(GL_TEXTURE10);
glBindTexture(GL_TEXTURE_2D_ARRAY_EXT, diffuseTexArray);
glActiveTexture(GL_TEXTURE11);
glBindTexture(GL_TEXTURE_2D_ARRAY_EXT, bumpTexArray);
glActiveTexture(GL_TEXTURE12);
glBindTexture(GL_TEXTURE_2D_ARRAY_EXT, specularTexArray);
glActiveTexture(GL_TEXTURE13);
glBindTexture(GL_TEXTURE_2D_ARRAY_EXT, emissiveReflectSpecPowerTexArray);
glActiveTexture(GL_TEXTURE0);
float itt = 1.0f/mRenderBuffers.texSize;
mShader->setUniform("diffuseTexArray", 10);
mShader->setUniform("bumpTexArray", 11);
mShader->setUniform("specularTexArray", 12);
mShader->setUniform("emissiveReflectSpecPowerTexArray", 13);
mShader->setUniform("ttt3D", 7);
mShader->setUniform("transTex", 8);
mShader->setUniform("transTexSize", mRenderBuffers.texSize);
mShader->setUniform("iTransTexSize", itt);
mShader->setUniform("bumpTextureUVScale", bumpTextureUVScale);
mShader->setUniform("extraNoiseScale",extraNoiseScale);
mShader->setUniform("roughnessScale", roughnessScale);
if (mShaderMat.color[3] < 1.0f) {
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_DEPTH_TEST);
glColor4f(mShaderMat.color[0], mShaderMat.color[1], mShaderMat.color[2], mShaderMat.color[3]);
}
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY);
glClientActiveTexture(GL_TEXTURE0);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, mRenderBuffers.VBO);
glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, mRenderBuffers.IBO);
int stride = 12*sizeof(float);
glVertexPointer(3, GL_FLOAT, stride, 0);
glNormalPointer(GL_FLOAT, stride, (void*)(3*sizeof(float)));
glTexCoordPointer(4, GL_FLOAT, stride, (void*)(6*sizeof(float)));
glClientActiveTexture(GL_TEXTURE1);
glTexCoordPointer(2, GL_FLOAT, stride, (void*)(10*sizeof(float)));
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glDrawElements(GL_TRIANGLES, mRenderBuffers.numIndices, GL_UNSIGNED_INT, 0);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glClientActiveTexture(GL_TEXTURE0);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
if (mShaderMat.color[3] < 1.0f) {
glDisable(GL_BLEND);
glEnable(GL_DEPTH_TEST);
}
mShader->deactivate();
}
#endif
}
#ifdef USE_OPTIX
else if (SampleViewerScene::getRenderType() == SampleViewerScene::rtOPTIX) {
FractureModelUpdate update( mCompounds, mOptixBufferVersion != mSceneVersion );
if (mOptixBufferVersion != mSceneVersion) {
// Complete buffer update.
mOptixBufferVersion = mSceneVersion;
}
Profiler::getInstance()->begin("Optix data update");
SampleViewerScene::getOptixRenderer()->update( update );
OptixRenderer::Camera cam;
const size_t size_of_float3 = sizeof(float) * 3;
PxVec3 lookat = mCameraPos + mCameraDir;
memcpy( cam.eye, &mCameraPos.x, size_of_float3);
memcpy( cam.lookat, &lookat.x, size_of_float3);
memcpy( cam.up, &mCameraUp.x, size_of_float3);
cam.fov = mCameraFov;
Profiler::getInstance()->end("Optix data update");
Profiler::getInstance()->begin("Optix render");
SampleViewerScene::getOptixRenderer()->render( cam );
Profiler::getInstance()->end("Optix render");
}
#endif // USE_OPTIX
}
// --------------------------------------------------------------------------------------------
void SimScene::dumpSceneGeometry()
{
#ifdef USE_OPTIX
if( SampleViewerScene::getRenderType() == SampleViewerScene::rtOPTIX && SampleViewerScene::getOptixRenderer()) {
SampleViewerScene::getOptixRenderer()->dump_geometry();
}
#endif
}
Reference in New Issue View Git Blame Copy Permalink