Controller::Controller(const ControllerResource* cr, SceneGraph& sg, UnitId id, PxPhysics* physics, PxControllerManager* manager)
: m_resource(cr)
, m_scene_graph(sg)
, _unit_id(id)
, m_manager(manager)
, m_controller(NULL)
{
TransformInstance ti = sg.get(id);
const Vector3 pos = sg.world_position(ti);
PxCapsuleControllerDesc desc;
desc.climbingMode = PxCapsuleClimbingMode::eCONSTRAINED;
desc.nonWalkableMode = PxCCTNonWalkableMode::eFORCE_SLIDING;
desc.radius = cr->radius;
desc.height = cr->height;
desc.slopeLimit = cos(cr->slope_limit);
desc.stepOffset = cr->step_offset;
desc.contactOffset = cr->contact_offset;
desc.upDirection = PxVec3(0.0, 1.0, 0.0);
desc.material = physics->createMaterial(0.5f, 0.5f, 0.5f);
desc.position = PxExtendedVec3(pos.x, pos.y, pos.z);
desc.reportCallback = &m_callback;
CE_ASSERT(desc.isValid(), "Capsule is not valid");
m_controller = manager->createController(desc);
CE_ASSERT(m_controller, "Failed to create controller");
}
Node::~Node()
{
deleteChildNodes(); //Remove this string for optimise process of release memory
SceneGraph *sg = getSceneGraph();
if (sg) {
if (sg->getSelectedShapeNode() == this)
sg->setSelectedShapeNode(NULL);
if (sg->getSelectedNode() == this)
sg->setSelectedNode(NULL);
}
remove();
if (isInstanceNode() == true)
setOriginalMembers();
#if defined(CX3D_SUPPORT_JSAI)
delete mJNode;
#endif
delete mName;
delete mExposedField;
delete mEventInField;
delete mEventOutField;
delete mField;
delete mPrivateField;
delete mPrivateNodeVector;
delete mChildNodes;
delete mInitialized;
}
Node::~Node()
{
deleteChildNodes();
SceneGraph *sg = getSceneGraph();
if (sg) {
if (sg->getSelectedShapeNode() == this)
sg->setSelectedShapeNode(NULL);
if (sg->getSelectedNode() == this)
sg->setSelectedNode(NULL);
}
remove();
if (isInstanceNode() == true)
setOriginalMembers();
#ifdef SUPPORT_JSAI
delete mJNode;
#endif
delete mName;
delete mType;
delete mExposedField;
delete mEventInField;
delete mEventOutField;
delete mField;
delete mPrivateField;
delete mPrivateNodeVector;
delete mChildNodes;
delete mInitialized;
}
void UndoOrthoViewChangeTransformScaleFn(void *info)
{
UndoOrthoViewChangeTransformScale *undoInfo = (UndoOrthoViewChangeTransformScale *)info;
SceneGraph *sg = GetWorld()->getSceneGraph();
if (sg->hasNode(undoInfo->transform) == true)
undoInfo->transform->setScale(undoInfo->scale);
}
void UndoOrthoViewChangeTransformRotationFn(void *info)
{
UndoOrthoViewChangeTransformRotation *undoInfo = (UndoOrthoViewChangeTransformRotation *)info;
SceneGraph *sg = GetWorld()->getSceneGraph();
if (sg->hasNode(undoInfo->transform) == true)
undoInfo->transform->setRotation(undoInfo->rotation);
}
void UndoOrthoViewCreatePrimitiveFn(void *info)
{
UndoOrthoViewCreatePrimitive *undoInfo = (UndoOrthoViewCreatePrimitive *)info;
SceneGraph *sg = GetWorld()->getSceneGraph();
if (sg->hasNode(undoInfo->transform) == true) {
CtbGetTreeView()->deleteSceneGraphNode(undoInfo->transform);
delete undoInfo->transform;
}
}
void initSceneData() {
scene = loadScene("data/room.obj");
scene.generateBvhs();
scene.setCamera(Camera(glm::vec3(0.0f, 2.0f, -4.0f),
glm::vec3(0.0f, 1.5f, -1.5f),
glm::vec3(0.0f, 1.0f, 0.0f),
60.0f, PROJ_WIDTH, PROJ_HEIGHT));
scene.addLight(Light(glm::vec3(0.0f, 2.99f, -0.75f),
glm::vec3(1.0f, 1.0f, 1.0f), 20.0f));
}
void Node::removeRoutes()
{
SceneGraph *sg = getSceneGraph();
if (sg) {
Route *route=sg->getRoutes();
while (route) {
Route *nextRoute = route->next();
if (route->getEventInNode() == this || route->getEventOutNode() == this)
delete route;
route = nextRoute;
}
}
}
int main(int argc, char** argv) {
SceneGraph* sg = new SceneGraph();
sg->Parse("scene1.txt");
sg->traverse(glm::mat4());//begin traversing
sg->writeToFile("scene1_results.txt");
SceneGraph* sg2 = new SceneGraph();
sg2->Parse("scene2.txt");
sg2->traverse(glm::mat4());//begin traversing
sg2->writeToFile("scene2_results.txt");
//system("pause");
}
void UndoOrthoViewDeletePrimitiveFn(void *info)
{
UndoOrthoViewDeletePrimitive *undoInfo = (UndoOrthoViewDeletePrimitive *)info;
SceneGraph *sg = GetWorld()->getSceneGraph();
if (undoInfo->parentNode != NULL) {
if (sg->hasNode(undoInfo->parentNode) == true)
undoInfo->parentNode->addChildNode(undoInfo->shape);
}
else
sg->addNode(undoInfo->shape);
CtbGetTreeView()->addSceneGraphNode(undoInfo->shape, undoInfo->parentNode);
}
void Object3D::addDragger(osgManipulator::Dragger *dragger)
{
if(_isPickable)
{
removeDragger();
this->getOrCreateStateSet()->setMode(GL_NORMALIZE, osg::StateAttribute::ON);
dragger->setupDefaultGeometry();
ref_ptr<osgManipulator::Selection> selection = _selNode;
#if 0
int mask = dragger->getNodeMask();
mask = mask & ~SHADOW_CASTER_MASK;
mask = mask & ~SHADOW_RECEIVER_MASK;
dragger->setNodeMask(mask);
SceneGraph* sg = *(_sgList.begin());
sg->getSceneGraph()->addChild(dragger);
#else
ref_ptr<Group> parent = new Group;
// the dragger is added to the scenegraph of the viewer in which the add is made, and only this one
Group* group = this->getParent(0)->getParent(0)->getParent(0)
#if USE_SHADOWS
->getParent(0)
#endif
;
parent->addChild(dragger);
group->addChild(parent);
#endif
float scale = this->getOriginalNode()->getBound().radius() * 1.6;
dragger->setMatrix(this->getFrameMatrix() *
Matrix::inverse(Matrix::translate(this->getFrameMatrix().getTrans())) *
Matrix::inverse(Matrix::rotate(this->getTransformationMatrix().getRotate())) *
Matrix::scale(scale, scale, scale) *
Matrix::translate(this->getOriginalNode()->getBound().center()));
dragger->postMult(selection->getMatrix());
ref_ptr<osgManipulator::CommandManager> commandManager = new osgManipulator::CommandManager();
commandManager->connect(*dragger, *selection);
_dragger = dragger;
int mask = _dragger->getNodeMask();
mask = mask & ~SHADOW_CASTER_MASK;
mask = mask & ~SHADOW_RECEIVER_MASK;
_dragger->setNodeMask(mask);
}
else printNonPickable();
}
void GBufferPass::update_ubershader_from_scene(RenderContext const& ctx,
SerializedScene const& scene,
SceneGraph const& graph) {
bool ubershader_available = true;
for (auto const& geometry_pair : scene.geometrynodes_) {
ubershader_available =
ubershader_available && ubershaders_.count(geometry_pair.first);
}
if (!ubershader_available) {
auto get_ubershader = [&](node::Node * n) {
node::GeometryNode* geode = dynamic_cast<node::GeometryNode*>(n);
if (geode) {
std::type_index type(typeid(*geode));
if (!ubershaders_.count(type)) {
auto const& ressource =
GeometryDatabase::instance()->lookup(geode->get_filename());
if (ressource) {
auto ubershader = ressource->create_ubershader();
ubershader->cleanup(ctx);
ubershader->create(cached_materials_);
ubershaders_[type] = ubershader;
}
}
}
}
;
gua::dfs_traverse(graph.get_root().get(), get_ubershader);
}
}
void Node::removeSFNodes()
{
SceneGraph *sg = getSceneGraph();
if (sg) {
for (ScriptNode *script = sg->findScriptNode(); script; script=script->nextTraversal()) {
for (int n=0; n<script->getNFields(); n++) {
Field *field = script->getField(n);
if (field->getType() == fieldTypeSFNode) {
SFNode *sfnode = (SFNode *)field;
if (sfnode->getValue() == this)
sfnode->setValue((Node *)NULL);
}
}
}
}
}
void Serializer::check(SerializedScene& output,
SceneGraph const& scene_graph,
std::string const& render_mask,
bool draw_bounding_boxes,
bool draw_rays,
bool enable_frustum_culling) {
data_ = &output;
std::size_t geometry_count = data_->geometrynodes_.size();
std::size_t volume_count = data_->volumenodes_.size();
std::size_t point_light_count = data_->point_lights_.size();
std::size_t spot_light_count = data_->spot_lights_.size();
std::size_t sun_light_count = data_->sun_lights_.size();
std::size_t ray_count = data_->rays_.size();
std::size_t textured_quad_count = data_->textured_quads_.size();
data_->geometrynodes_.clear();
data_->volumenodes_.clear();
data_->point_lights_.clear();
data_->spot_lights_.clear();
data_->sun_lights_.clear();
data_->textured_quads_.clear();
data_->bounding_boxes_.clear();
data_->rays_.clear();
draw_bounding_boxes_ = draw_bounding_boxes;
draw_rays_ = draw_rays;
if (draw_bounding_boxes_) {
data_->materials_.insert("gua_bounding_box");
data_->bounding_boxes_.reserve(geometry_count + point_light_count + spot_light_count + ray_count);
}
if (draw_rays_) {
data_->materials_.insert("gua_bounding_box");
data_->rays_.reserve(ray_count);
}
data_->materials_.insert("gua_textured_quad");
// assuming the number of nodes stays quite constant through time,
// reserving the old size might save some time
data_->volumenodes_.reserve(volume_count);
data_->point_lights_.reserve(point_light_count);
data_->spot_lights_.reserve(spot_light_count);
data_->sun_lights_.reserve(sun_light_count);
data_->textured_quads_.reserve(textured_quad_count);
enable_frustum_culling_ = enable_frustum_culling;
current_render_mask_ = Mask(render_mask);
current_frustum_ = output.frustum;
current_center_of_interest_ = output.center_of_interest;
scene_graph.accept(*this);
}
void Object3D::removeDragger()
{
if(_dragger.valid())
{
#if 0
SceneGraph* sg = *(_sgList.begin());
sg->getSceneGraph()->removeChild(_dragger.get());
#else
osg::Group* group = this->getParent(0)->getParent(0)->getParent(0)
#if USE_SHADOWS
->getParent(0)
#endif
;
group->removeChild(_dragger->getParent(0));
#endif
_dragger = NULL;
}
}
//---------------------------------------------------------------
void LightExporter::exportLights ( )
{
if ( !ExportOptions::exportLights() ) return;
// Get the list with the transform nodes.
SceneGraph* sceneGraph = mDocumentExporter->getSceneGraph();
SceneElementsList* exportNodesTree = sceneGraph->getExportNodesTree();
// Export all/selected DAG nodes
size_t length = exportNodesTree->size();
for ( uint i = 0; i < length; ++i )
{
SceneElement* sceneElement = ( *exportNodesTree ) [i];
exportLights ( sceneElement );
}
closeLibrary();
}
virtual void *operator()( void *item )
{
SceneGraph *s = (SceneGraph*)item;
ScenePlug::ScenePath path;
s->path( path );
try
{
ContextPtr context = new Context( *m_context, Context::Borrowed );
context->set( ScenePlug::scenePathContextName, path );
Context::Scope scopedContext( context.get() );
if( m_update )
{
// we're re-traversing this location, so lets only recompute attributes where
// their hashes change:
IECore::MurmurHash attributesHash = m_scene->attributesPlug()->hash();
if( attributesHash != s->m_attributesHash )
{
s->m_attributes = m_scene->attributesPlug()->getValue( &attributesHash );
s->m_attributesHash = attributesHash;
}
}
else
{
// First traversal: attributes and attribute hash should have been computed
// by the SceneGraphBuildTasks, so we only need to compute the object/transform:
s->m_object = m_scene->objectPlug()->getValue();
s->m_transform = m_scene->transformPlug()->getValue();
}
}
catch( const std::exception &e )
{
std::string name;
ScenePlug::pathToString( path, name );
IECore::msg( IECore::Msg::Error, "InteractiveRender::update", name + ": " + e.what() );
}
return s;
}
void Node::remove()
{
LinkedListNode<Node>::remove();
if (isInstanceNode() == false) {
removeRoutes();
removeSFNodes();
removeInstanceNodes();
if (isBindableNode()) {
SceneGraph *sceneGraph = getSceneGraph();
if (sceneGraph)
sceneGraph->setBindableNode((BindableNode *)this, false);
}
}
setParentNode(NULL);
setSceneGraph(NULL);
}
static void iterateScenePortals(SceneGraph& scene, TFunc func)
{
scene.getSceneComponentLists().iterateComponents<PortalComponent>([&](PortalComponent& comp) {
Portal& s = static_cast<Portal&>(comp.getSceneNode());
if(func(s))
{
return;
}
});
}
static void iterateSceneSectors(SceneGraph& scene, TFunc func)
{
scene.getSceneComponentLists().iterateComponents<SectorComponent>([&](SectorComponent& comp) {
Sector& s = static_cast<Sector&>(comp.getSceneNode());
if(func(s))
{
return;
}
});
}
void ProximitySensorNode::update()
{
if (!isEnabled())
return;
SceneGraph *sg = getSceneGraph();
if (!sg)
return;
ViewpointNode *vpoint = sg->getViewpointNode();
if (vpoint == NULL)
vpoint = sg->getDefaultViewpointNode();
float vpos[3];
vpoint->getPosition(vpos);
float center[3];
getCenter(center);
float size[3];
getSize(size);
if (inRegion() == false) {
if (isRegion(vpos, center, size) == true) {
setInRegion(true);
double time = GetCurrentSystemTime();
setEnterTime(time);
sendEvent(getEventOut(enterTimeFieldString));
setIsActive(true);
sendEvent(getEventOut(isActiveFieldString));
}
}
else {
if (isRegion(vpos, center, size) == false) {
setInRegion(false);
double time = GetCurrentSystemTime();
setExitTime(time);
sendEvent(getEventOut(exitTimeFieldString));
setIsActive(false);
sendEvent(getEventOut(isActiveFieldString));
}
}
}
Error MainRenderer::render(SceneGraph& scene)
{
ANKI_TRACE_START_EVENT(RENDER);
// First thing, reset the temp mem pool
m_frameAlloc.getMemoryPool().reset();
GrManager& gl = m_r->getGrManager();
CommandBufferInitInfo cinf;
cinf.m_hints = m_cbInitHints;
CommandBufferPtr cmdb = gl.newInstance<CommandBuffer>(cinf);
// Set some of the dynamic state
cmdb->setPolygonOffset(0.0, 0.0);
// Run renderer
RenderingContext ctx(m_frameAlloc);
if(m_rDrawToDefaultFb)
{
ctx.m_outFb = m_defaultFb;
ctx.m_outFbWidth = m_width;
ctx.m_outFbHeight = m_height;
}
ctx.m_commandBuffer = cmdb;
ctx.m_frustumComponent = &scene.getActiveCamera().getComponent<FrustumComponent>();
ANKI_CHECK(m_r->render(ctx));
// Blit renderer's result to default FB if needed
if(!m_rDrawToDefaultFb)
{
cmdb->beginRenderPass(m_defaultFb);
cmdb->setViewport(0, 0, m_width, m_height);
cmdb->bindPipeline(m_blitPpline);
cmdb->bindResourceGroup(m_rcGroup, 0, nullptr);
m_r->drawQuad(cmdb);
cmdb->endRenderPass();
}
// Flush the command buffer
cmdb->flush();
// Set the hints
m_cbInitHints = cmdb->computeInitHints();
ANKI_TRACE_STOP_EVENT(RENDER);
return ErrorCode::NONE;
}
void DestroyScene()
{
if(PXEngine)
{
PXEngine->ShutdownPhysX();
PXEngine = NULL;
}
sceneGraph.Destroy();
/*gMeshOpaque.Destroy();
gMeshOpaque2.Destroy();
gMeshAlpha.Destroy();*/
SAFE_RELEASE(gSkyboxSRV);
}
void Node::removeInstanceNodes()
{
SceneGraph *sg = getSceneGraph();
if (sg && isInstanceNode() == false) {
Node *node = sg->getNodes();
while (node) {
Node *nextNode = node->nextTraversal();
if (node->isInstanceNode() == true) {
Node *refNode = node->getReferenceNode();
while (refNode->isInstanceNode() == true)
refNode = refNode->getReferenceNode();
if (refNode == this) {
node->deleteChildNodes();
nextNode = node->nextTraversal();
delete node;
}
}
node = nextNode;
}
}
}
//------------------------------------------------------
void MaterialExporter::exportMaterialsBySceneGraph ()
{
// Get the list with the transform nodes.
SceneGraph* sceneGraph = mDocumentExporter->getSceneGraph();
SceneElementsList* exportNodesTree = sceneGraph->getExportNodesTree();
// Now go through scene graph and find all shaders, connected to the meshes.
// So you can find the default shaders of an object.
size_t length = exportNodesTree->size();
for ( size_t i = 0; i < length; ++i )
{
SceneElement* sceneElement = ( *exportNodesTree ) [i];
if ( !sceneElement->getIsLocal() ) continue;
if ( !sceneElement->getIsExportNode () ) continue;
size_t childCount = sceneElement->getChildCount();
for ( size_t i=0; i<childCount; ++i )
{
SceneElement* childSceneElement = sceneElement->getChild ( i );
exportConnectedMaterials ( childSceneElement );
}
}
}
int main(int argc, char **argv)
{
if (argc < 2){
fprintf(stderr, "Usage: %s filename\n", argv[0]);
exit(0);
}
SceneGraph sceneGraph;
bool lodingResult = sceneGraph.load(argv[1], false);
if (lodingResult == true) {
sceneGraph.print();
}
else {
cout << "Error(" << sceneGraph.getParserErrorLineNumber() << ") : " << sceneGraph.getParserErrorLineString() << endl;
cout << "\t" << sceneGraph.getParserErrorMessage() << endl;
cout << "\t" << sceneGraph.getParserErrorToken() << endl;
}
return 0;
}
int main(int, char**) {
TrollEngine engine;
GLFWWindow win(1280, 720, "TrollEngine GLFW Window", true, true);
win.setResizeCallback([] (int w, int h) { glViewport(0, 0, w, h); });
win.showCursor(false);
std::cout << win.context_info() << std::endl;
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glEnable(GL_BLEND);
glBlendEquation(GL_FUNC_ADD);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glClearColor(0.2f, 0.2f, 0.2f, 1.f);
glClearDepth(1.f);
glDepthFunc(GL_LESS);
ProgramBuilder pb;
pb.vertexShader("vs.glsl")
.fragmentShader("fs.glsl")
.uniform("tex", ProgramBuilder::UniformType::Int)
.uniform("modelView", ProgramBuilder::UniformType::Mat4)
.uniform("camera", ProgramBuilder::UniformType::Mat4)
.uniform("projection", ProgramBuilder::UniformType::Mat4);
auto program = std::move(pb.build());
UBO<TextOptions> opts;
opts.data = {true, false, false, 0.1f};
opts.upload_std140();
auto optsIndex = program.getUniformBlockIndex("Options");
program.uniformBlockBinding(optsIndex, 0);
opts.bindBase(GL_UNIFORM_BUFFER, 0);
auto texImg = GreyscaleImage::load("distanceField.png");
auto tex = Texture::fromImage(texImg);
glm::mat4 p = glm::perspective(glm::radians(55.f), 16.f / 9.f, 0.1f, 100.f),
t = glm::translate(glm::mat4(1.f), glm::vec3(-6.f, 0.f, -7.f)),
r = glm::rotate(glm::mat4(1.f), 0.f, glm::vec3(0.f, 1.f, 0.f)),
m = t * r;
SceneGraph scene;
vector<glm::vec2> uvs = stringTexCoords("Hello world!");
auto quadStrip = Mesh::quadStrip(uvs);
auto quadStripObj = quadStrip->instantiate(m, &program, &tex);
scene.addChild(quadStripObj);
program.use();
auto ubTexture = program.getUniform("tex"),
ubModelView = program.getUniform("modelView"),
ubProjection = program.getUniform("projection");
auto uTexture = dynamic_cast<Uniform<int>*>(ubTexture);
auto uModelView = dynamic_cast<Uniform<glm::mat4>*>(ubModelView);
auto uProjection = dynamic_cast<Uniform<glm::mat4>*>(ubProjection);
uTexture->set(0);
uModelView->set(m);
uProjection->set(p);
win.registerKeyCallback('A', [&] () {
opts.data.softenRange = min(opts.data.softenRange + 0.1f, 0.95f);
opts.upload_std140();
});
win.registerKeyCallback('E', [&] () {
opts.data.softenRange = max(opts.data.softenRange - 0.1f, 0.05f);
opts.upload_std140();
});
while(!win.shouldClose()) {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
scene.render();
win.swapBuffers();
win.pollEvents();
}
}
void CALLBACK OnD3D11FrameRender(ID3D11Device* d3dDevice, ID3D11DeviceContext* d3dDeviceContext, double time,
float elapsedTime, void* userContext)
{
D3DXVECTOR3 cubePos;
if (gZeroNextFrameTime) {
elapsedTime = 0.0f;
}
gZeroNextFrameTime = false;
if (gD3DSettingsDlg.IsActive()) {
gD3DSettingsDlg.OnRender(elapsedTime);
return;
}
// Lazily create the application if need be
if (!gApp) {
InitApp(d3dDevice);
}
// Lazily load scene
/*!gMeshOpaque.IsLoaded() && !gMeshAlpha.IsLoaded() &&!gMeshOpaque2.IsLoaded()*/
if (!sceneGraph.IsLoaded()) {
InitScene(d3dDevice);
}
if(PXEngine)
{
for(int i = 0; i < cubeList->size(); i++)
PXEngine->StepPhysX();
if(cubeList)
{
for(int i = 0; i < cubeList->size(); i++)
{
if((*cubeList)[i]->id<0)
{
sceneGraph.SetInstancePosition(1,(*cubeList)[i]->id, (*cubeList)[i]->x, (*cubeList)[i]->y, (*cubeList)[i]->z);
}
else
{
sceneGraph.SetMeshPosition(0,(*cubeList)[i]->id, (*cubeList)[i]->x, (*cubeList)[i]->y, (*cubeList)[i]->z);
}
}
}
}
//crosshair
D3DRECT rec2 = {screenCenterX-20, screenCenterY, screenCenterX + 20, screenCenterY + 2};
D3DRECT rec3 = {screenCenterX, screenCenterY - 20, screenCenterX + 2, screenCenterY + 20};
ID3D11RenderTargetView* pRTV = DXUTGetD3D11RenderTargetView();
D3D11_VIEWPORT viewport;
viewport.Width = static_cast<float>(DXUTGetDXGIBackBufferSurfaceDesc()->Width);
viewport.Height = static_cast<float>(DXUTGetDXGIBackBufferSurfaceDesc()->Height);
viewport.MinDepth = 0.0f;
viewport.MaxDepth = 1.0f;
viewport.TopLeftX = 0.0f;
viewport.TopLeftY = 0.0f;
screenCenterX = viewport.Width / 2;
screenCenterY = viewport.Height / 2;
gViewPort.Width = viewport.Width;
gViewPort.Height = viewport.Height;
gViewPort.MaxZ = viewport.MaxDepth;
gViewPort.MinZ = viewport.MinDepth;
gViewPort.X = viewport.TopLeftX;
gViewPort.Y = viewport.TopLeftY;
gApp->Render(d3dDeviceContext, pRTV, sceneGraph, gSkyboxSRV,
gWorldMatrix, &gViewerCamera, &viewport, &gUIConstants);
sceneGraph.SetMeshPosition(0,1, 100000, 100000, 100000);
if (gDisplayUI) {
d3dDeviceContext->RSSetViewports(1, &viewport);
// Render HUDs in reverse order
d3dDeviceContext->OMSetRenderTargets(1, &pRTV, 0);
for (int i = HUD_NUM - 1; i >= 0; --i) {
gHUD[i].OnRender(elapsedTime);
}
// Render text
gTextHelper->Begin();
gTextHelper->SetInsertionPos(2, 0);
gTextHelper->SetForegroundColor(D3DXCOLOR(1.0f, 1.0f, 0.0f, 1.0f));
gTextHelper->DrawTextLine(DXUTGetFrameStats(DXUTIsVsyncEnabled()));
//gTextHelper->DrawTextLine(DXUTGetDeviceStats());
// Output frame time
{
std::wostringstream oss;
oss << 1000.0f / DXUTGetFPS() << " ms / frame";
gTextHelper->DrawTextLine(oss.str().c_str());
}
// Output light info
{
std::wostringstream oss;
oss << "Lights: " << gApp->GetActiveLights();
gTextHelper->DrawTextLine(oss.str().c_str());
}
gTextHelper->End();
}
}
void InitScene(ID3D11Device* d3dDevice)
{
DestroyScene();
D3DXVECTOR3 cameraEye(0.0f, 0.0f, 0.0f);
D3DXVECTOR3 cameraAt(0.0f, 0.0f, 0.0f);
float sceneScaling = 1.0f;
D3DXVECTOR3 sceneTranslation(0.0f, 0.0f, 0.0f);
bool zAxisUp = false;
#pragma region Pick Scene
SCENE_SELECTION scene = static_cast<SCENE_SELECTION>(PtrToUlong(gSceneSelectCombo->GetSelectedData()));
scene = CUBES;
switch (scene) {
case CUBE_WORLD: {
#pragma region CUBE_WORLD
sceneScaling = 1.0f;
D3DXMatrixScaling(&gWorldMatrix, sceneScaling, sceneScaling, sceneScaling);
if (zAxisUp) {
D3DXMATRIXA16 m;
D3DXMatrixRotationX(&m, -D3DX_PI / 2.0f);
gWorldMatrix *= m;
}
{
D3DXMATRIXA16 t;
D3DXMatrixTranslation(&t, sceneTranslation.x, sceneTranslation.y, sceneTranslation.z);
gWorldMatrix *= t;
}
sceneGraph.StartScene(gWorldMatrix,sceneScaling);
sceneGraph.Add(d3dDevice, L"..\\media\\cube\\cube.sdkmesh",0,0,0,1,500,500);
//gMeshOpaque.Create(d3dDevice, L"..\\media\\cube\\cube.sdkmesh");
LoadSkybox(d3dDevice, L"..\\media\\Skybox\\EmptySpace.dds");
cameraEye = sceneScaling * D3DXVECTOR3(100.0f, 5.0f, 5.0f);
cameraAt = sceneScaling * D3DXVECTOR3(0.0f, 0.0f, 0.0f);
} break;
#pragma endregion
case POWER_PLANT_SCENE: {
#pragma region POWER_PLANT_SCENE
sceneScaling = 1.0f;
D3DXMatrixScaling(&gWorldMatrix, sceneScaling, sceneScaling, sceneScaling);
if (zAxisUp) {
D3DXMATRIXA16 m;
D3DXMatrixRotationX(&m, -D3DX_PI / 2.0f);
gWorldMatrix *= m;
}
{
D3DXMATRIXA16 t;
D3DXMatrixTranslation(&t, sceneTranslation.x, sceneTranslation.y, sceneTranslation.z);
gWorldMatrix *= t;
}
sceneGraph.StartScene(gWorldMatrix,sceneScaling);
sceneGraph.Add(d3dDevice, L"..\\media\\powerplant\\powerplant.sdkmesh");
//gMeshOpaque.Create(d3dDevice, L"..\\media\\powerplant\\powerplant.sdkmesh");
LoadSkybox(d3dDevice, L"..\\media\\Skybox\\EmptySpace.dds");
cameraEye = sceneScaling * D3DXVECTOR3(100.0f, 5.0f, 5.0f);
cameraAt = sceneScaling * D3DXVECTOR3(0.0f, 0.0f, 0.0f);
} break;
#pragma endregion
case SPONZA_SCENE: {
#pragma region SPONZA_SCENE
sceneScaling = 0.05f;
D3DXMatrixScaling(&gWorldMatrix, sceneScaling, sceneScaling, sceneScaling);
if (zAxisUp) {
D3DXMATRIXA16 m;
D3DXMatrixRotationX(&m, -D3DX_PI / 2.0f);
gWorldMatrix *= m;
}
{
D3DXMATRIXA16 t;
D3DXMatrixTranslation(&t, sceneTranslation.x, sceneTranslation.y, sceneTranslation.z);
gWorldMatrix *= t;
}
sceneGraph.StartScene(gWorldMatrix,sceneScaling);
sceneGraph.Add(d3dDevice, L"..\\media\\Sponza\\sponza_dds.sdkmesh");
//gMeshOpaque.Create(d3dDevice, L"..\\media\\Sponza\\sponza_dds.sdkmesh");
LoadSkybox(d3dDevice, L"..\\media\\Skybox\\EmptySpace.dds");
cameraEye = sceneScaling * D3DXVECTOR3(1200.0f, 200.0f, 100.0f);
cameraAt = sceneScaling * D3DXVECTOR3(0.0f, 0.0f, 0.0f);
} break;
#pragma endregion
case MULTI_SCENE:{
#pragma region MULTI_SCENE
sceneScaling = .05f;
D3DXMatrixScaling(&gWorldMatrix, sceneScaling, sceneScaling, sceneScaling);
if (zAxisUp) {
D3DXMATRIXA16 m;
D3DXMatrixRotationX(&m, -D3DX_PI / 2.0f);
gWorldMatrix *= m;
}
{
D3DXMATRIXA16 t;
D3DXMatrixTranslation(&t, sceneTranslation.x, sceneTranslation.y, sceneTranslation.z);
gWorldMatrix *= t;
}
sceneGraph.StartScene(gWorldMatrix,sceneScaling);
sceneGraph.Add(d3dDevice, L"..\\media\\Sponza\\sponza_dds.sdkmesh");
D3DXMATRIXA16 translate;
D3DXMatrixTranslation(&translate,0,10,0);
sceneGraph.Add(d3dDevice,L"..\\media\\powerplant\\powerplant.sdkmesh",translate);
//gMeshOpaque.Create(d3dDevice, L"..\\media\\Sponza\\sponza_dds.sdkmesh");
//gMeshOpaque2.Create(d3dDevice,L"..\\media\\powerplant\\powerplant.sdkmesh");
LoadSkybox(d3dDevice, L"..\\media\\Skybox\\EmptySpace.dds");
cameraEye = sceneScaling * D3DXVECTOR3(100.0f, 5.0f, 5.0f);
cameraAt = sceneScaling * D3DXVECTOR3(0.0f, 0.0f, 0.0f);
}break;
#pragma endregion
case CUBES:
{
#pragma region CUBES
sceneScaling = 1.0f;
D3DXMatrixScaling(&gWorldMatrix, sceneScaling, sceneScaling, sceneScaling);
if (zAxisUp) {
D3DXMATRIXA16 m;
D3DXMatrixRotationX(&m, -D3DX_PI / 2.0f);
gWorldMatrix *= m;
}
{
D3DXMATRIXA16 t;
D3DXMatrixTranslation(&t, sceneTranslation.x, sceneTranslation.y, sceneTranslation.z);
gWorldMatrix *= t;
}
sceneGraph.StartScene(gWorldMatrix,sceneScaling);
D3DXMATRIXA16 translate;
D3DXMatrixTranslation(&translate,0,0,0);
D3DXMATRIXA16 s;
D3DXMatrixScaling(&s,100,0.01,100);
s=s*translate;
//sceneGraph.Add(d3dDevice, L"..\\media\\cube\\cube.sdkmesh",s);
//sceneGraph.Add(d3dDevice, L"..\\media\\cube\\cube.sdkmesh",s);
//Initializing PhysX
if(!PXEngine)
PXEngine = new PhysXEngine();
sceneGraph.AddMeshInstance(d3dDevice, L"..\\media\\cube\\cube.sdkmesh");
//sceneGraph.Add(d3dDevice,L"..\\media\\powerplant\\powerplant.sdkmesh",translate);
if(PXEngine)
PXEngine->InitializePhysX(cubeList, PhysXUnProject, PhysXProject);
sceneGraph.Add(d3dDevice, L"..\\media\\cube\\cube.sdkmesh",0,0,0,1000,1000,1000);
//Creating all of the cubes
for(int i = 0; i < cubeList->size(); i++)
{
if(i%10==0)
{
sceneGraph.Add(d3dDevice, L"..\\media\\cube\\cube.sdkmesh",0,0,0,1,1,1);
}
else
(*cubeList)[i]->id = sceneGraph.AddInstance(1,(*cubeList)[i]->x, (*cubeList)[i]->y, (*cubeList)[i]->z, (*cubeList)[i]->sx, (*cubeList)[i]->sy, (*cubeList)[i]->sz);
}
/*
for(float x =0; x<15;x+=5)
{
for(float y=0; y<15; y+=5)
{
for(float z=0; z<15; z+=5)
{
D3DXMatrixTranslation(&translate,x,y,z);
sceneGraph.Add(d3dDevice, L"..\\media\\cube\\cube.sdkmesh",x,y,z,1,1,1);
}
}
}
*/
LoadSkybox(d3dDevice, L"..\\media\\Skybox\\Clouds.dds");
cameraEye = sceneScaling * D3DXVECTOR3(100.0f, 5.0f, 5.0f);
cameraAt = sceneScaling * D3DXVECTOR3(0.0f, 0.0f, 0.0f);
}break;
#pragma endregion
};
#pragma endregion
cameraEye.x += 200;
gViewerCamera.SetViewParams(&cameraEye, &cameraAt);
gViewerCamera.SetScalers(0.01f, 100.0f);
gViewerCamera.FrameMove(0.0f);
// Zero out the elapsed time for the next frame
gZeroNextFrameTime = true;
}
//---------------------------------------------------------------
void LightExporter::exportLights ( SceneElement* sceneElement )
{
// If we have a external reference, we don't need to export the data here.
if ( !sceneElement->getIsLocal() ) return;
if ( !sceneElement->getIsExportNode () ) return;
// Check if it is a light.
SceneElement::Type sceneElementType = sceneElement->getType();
if ( sceneElementType == SceneElement::LIGHT )
{
// Get the current dag path
MDagPath dagPath = sceneElement->getPath();
// Check if the current scene element isn't already exported.
SceneGraph* sceneGraph = mDocumentExporter->getSceneGraph();
if ( sceneGraph->findExportedElement ( dagPath ) ) return;
// Check if the current element is an instance.
// We don't need to export instances, because we export the original instanced element.
bool isInstance = ( dagPath.isInstanced() && dagPath.instanceNumber() > 0 );
// If the original instanced element isn't already exported, we have to export it now.
if ( isInstance )
{
// Get the original instanced element.
MDagPath instancedPath;
dagPath.getPath ( instancedPath, 0 );
// Check if the original instanced element is already exported.
SceneGraph* sceneGraph = mDocumentExporter->getSceneGraph();
SceneElement* exportedElement = sceneGraph->findExportedElement ( instancedPath );
if (exportedElement == 0)
{
// Export the original instanced element and push it in the exported scene graph.
if (exportLight(instancedPath))
{
SceneElement* instancedSceneElement = sceneGraph->findElement(instancedPath);
SceneGraph* sceneGraph = mDocumentExporter->getSceneGraph();
sceneGraph->addExportedElement(instancedSceneElement);
}
}
}
else
{
// Export the element and push it in the exported scene graph.
if ( exportLight ( dagPath ) )
{
SceneGraph* sceneGraph = mDocumentExporter->getSceneGraph();
sceneGraph->addExportedElement( sceneElement );
}
}
}
// Recursive call for all the child elements
for ( uint i=0; i<sceneElement->getChildCount(); ++i )
{
SceneElement* childElement = sceneElement->getChild ( i );
exportLights ( childElement );
}
}
