Class for fire ring particle system scene. More...

#include <AppDemoSceneParticleComplexFire.h>

Inheritance diagram for AppDemoSceneParticleComplexFire:

Public Member Functions
	AppDemoSceneParticleComplexFire (SLSceneID sceneID)

void	registerAssetsToLoad (SLAssetLoader &al) override
	All scene specific assets have to be registered for async loading in here. More...

void	assemble (SLAssetManager am, SLSceneView sv) override
	After parallel loading of the assets the scene gets assembled in here. More...

SLNode *	createComplexFire (SLAssetManager am, SLScene s, SLbool withLight, SLGLTexture texFireCld, SLGLTexture texFireFlm, SLint flipbookCols, SLint flipbookRows, SLGLTexture texCircle, SLGLTexture texSmokeB, SLGLTexture *texSmokeW)
	Creates a complex fire group node. More...

SLNode *	createTorchFire (SLAssetManager am, SLScene s, SLbool withLight, SLGLTexture texFireCld, SLGLTexture texFireFlm, SLint flipbookCols, SLint flipbookRows)

Public Member Functions inherited from SLScene
	SLScene (const SLstring &name)

	~SLScene () override

void	initOculus (SLstring shaderDir)

void	root3D (SLNode *root3D)

void	root2D (SLNode *root2D)

void	skybox (SLSkybox *skybox)

void	stopAnimations (SLbool stop)

void	info (SLstring i)

void	loadTimeMS (SLfloat loadTimeMS)

SLAnimManager &	animManager ()

SLAssetManager *	assetManager ()

SLNode *	root3D ()

SLNode *	root2D ()

SLSkybox *	skybox ()

SLstring &	info ()

SLfloat	elapsedTimeMS () const

SLfloat	elapsedTimeSec () const

SLVEventHandler &	eventHandlers ()

SLfloat	loadTimeMS () const

SLVLight &	lights ()

SLfloat	fps () const

AvgFloat &	frameTimesMS ()

AvgFloat &	updateTimesMS ()

AvgFloat &	updateAnimTimesMS ()

AvgFloat &	updateAABBTimesMS ()

AvgFloat &	updateDODTimesMS ()

SLNode *	singleNodeSelected ()
	Returns the node if only one is selected. See also SLMesh::selectNodeMesh. More...

SLMesh *	singleMeshFullSelected ()
	Returns the node if only one is selected. See also SLMesh::selectNodeMesh. More...

SLVNode &	selectedNodes ()

SLVMesh &	selectedMeshes ()

SLbool	stopAnimations () const

SLint	numSceneCameras ()
	Returns the number of camera nodes in the scene. More...

SLCamera *	nextCameraInScene (SLCamera *activeSVCam)
	Returns the next camera in the scene if there is one. More...

bool	onUpdate (bool renderTypeIsRT, bool voxelsAreShown, bool forceCPUSkinning)
	Updates animations and AABBs. More...

void	init (SLAssetManager *am)

virtual void	unInit ()

void	selectNodeMesh (SLNode nodeToSelect, SLMesh meshToSelect)
	Handles the full mesh selection from double-clicks. More...

void	deselectAllNodesAndMeshes ()
	Deselects all nodes and its meshes. More...

SLGLOculus *	oculus ()

Public Member Functions inherited from SLObject
	SLObject (const SLstring &Name="", const SLstring &url="")

virtual	~SLObject ()

void	name (const SLstring &Name)

void	url (const SLstring &url)

const SLstring &	name () const

const SLstring &	url () const

Private Attributes
SLSceneID	_sceneID

SLGLTexture *	_texFireCld

SLGLTexture *	_texFireFlm

SLGLTexture *	_texCircle

SLGLTexture *	_texSmokeB

SLGLTexture *	_texSmokeW

SLGLTexture *	_texTorchFlm

SLGLTexture *	_texTorchSmk

SLGLTexture *	_texWallDIF

SLGLTexture *	_texWallNRM

SLNode *	_firewood

SLNode *	_torchL

Additional Inherited Members
Protected Attributes inherited from SLScene
SLVLight	_lights
	Vector of all lights. More...

SLVEventHandler	_eventHandlers
	Vector of all event handler. More...

SLAnimManager	_animManager
	Animation manager instance. More...

SLAssetManager *	_assetManager
	Pointer to the external assetManager. More...

SLNode *	_root3D
	Root node for 3D scene. More...

SLNode *	_root2D
	Root node for 2D scene displayed in ortho projection. More...

SLSkybox *	_skybox
	pointer to skybox More...

SLstring	_info
	scene info string More...

SLVNode	_selectedNodes
	Vector of selected nodes. See SLMesh::selectNodeMesh. More...

SLVMesh	_selectedMeshes
	Vector of selected meshes. See SLMesh::selectNodeMesh. More...

SLfloat	_loadTimeMS
	time to load scene in ms More...

SLfloat	_frameTimeMS
	Last frame time in ms. More...

SLfloat	_lastUpdateTimeMS
	Last time after update in ms. More...

SLfloat	_fps
	Averaged no. of frames per second. More...

AvgFloat	_frameTimesMS
	Averaged total time per frame in ms. More...

AvgFloat	_updateTimesMS
	Averaged time for update in ms. More...

AvgFloat	_updateAABBTimesMS
	Averaged time for update the nodes AABB in ms. More...

AvgFloat	_updateAnimTimesMS
	Averaged time for update the animations in ms. More...

AvgFloat	_updateDODTimesMS
	Averaged time for update the SLEntities graph. More...

SLbool	_stopAnimations
	Global flag for stopping all animations. More...

std::unique_ptr< SLGLOculus >	_oculus
	Oculus Rift interface. More...

Protected Attributes inherited from SLObject
SLstring	_name
	name of an object More...

SLstring	_url
	uniform resource locator More...

Detailed Description

Class for fire ring particle system scene.

Definition at line 20 of file AppDemoSceneParticleComplexFire.h.

Constructor & Destructor Documentation

◆ AppDemoSceneParticleComplexFire()

AppDemoSceneParticleComplexFire::AppDemoSceneParticleComplexFire ( SLSceneID sceneID )

Definition at line 22 of file AppDemoSceneParticleComplexFire.cpp.

   : SLScene("Complex Fire Particle System"),
     _sceneID(sceneID)
 {
     info("The fire particle systems contain each multiple sub particle systems.\n"
          "See the scenegraph window for the sub particles systems. "
          "See the properties window for the settings of the particles systems");
 }

Member Function Documentation

◆ assemble()

void AppDemoSceneParticleComplexFire::assemble	(	SLAssetManager *	am,
		SLSceneView *	sv
	)

overridevirtual

After parallel loading of the assets the scene gets assembled in here.

Remarks: All scene-specific assets have to be loaded async by overriding SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and assembling means that it happens in a parallel thread and that in there are no OpenGL calls allowed. OpenGL calls are only allowed in the main thread. It is important that all object instantiations within SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen in a parallel thread. All objects that get rendered have to do their initialization when they are used the first time during rendering in the main thread.

Reimplemented from SLScene.

Definition at line 88 of file AppDemoSceneParticleComplexFire.cpp.

 {
     if (_sceneID == SID_ParticleSystem_ComplexFire)
     {
         // Create a scene group node
         SLNode* scene = new SLNode("Root Scene Node");
         root3D(scene);
  
         // Create and add camera
         SLCamera* cam1 = new SLCamera("Camera 1");
         cam1->translation(0, 1.2f, 4.0f);
         cam1->lookAt(0, 1.2f, 0);
         cam1->focalDist(4.5f);
         cam1->setInitialState();
         scene->addChild(cam1);
         sv->camera(cam1);
  
         SLNode* complexFire = createComplexFire(am,
                                                 this,
                                                 true,
                                                 _texTorchSmk,
                                                 _texFireFlm,
                                                 8,
                                                 8,
                                                 _texCircle,
                                                 _texSmokeB,
                                                 _texSmokeW);
         scene->addChild(complexFire);
  
         // Room parent node
         SLNode* room = new SLNode("Room");
         scene->addChild(room);
  
         // Back wall material
         SLMaterial* matWall = new SLMaterial(am,
                                              "mat3",
                                              _texWallDIF,
                                              _texWallNRM);
         matWall->specular(SLCol4f::BLACK);
         matWall->metalness(0);
         matWall->roughness(1);
         matWall->reflectionModel(RM_CookTorrance);
  
         // Room dimensions
         SLfloat pL = -2.0f, pR = 2.0f;  // left/right
         SLfloat pB = -0.01f, pT = 4.0f; // bottom/top
         SLfloat pN = 2.0f, pF = -2.0f;  // near/far
  
         // bottom rectangle
         SLNode* b = new SLNode(new SLRectangle(am,
                                                SLVec2f(pL, -pN),
                                                SLVec2f(pR, -pF),
                                                10,
                                                10,
                                                "Floor",
                                                matWall));
         b->rotate(90, -1, 0, 0);
         b->translate(0, 0, pB, TS_object);
         room->addChild(b);
  
         // far rectangle
         SLNode* f = new SLNode(new SLRectangle(am,
                                                SLVec2f(pL, pB),
                                                SLVec2f(pR, pT),
                                                10,
                                                10,
                                                "Wall far",
                                                matWall));
         f->translate(0, 0, pF, TS_object);
         room->addChild(f);
  
         // near rectangle
         SLNode* n = new SLNode(new SLRectangle(am,
                                                SLVec2f(pL, pB),
                                                SLVec2f(pR, pT),
                                                10,
                                                10,
                                                "Wall near",
                                                matWall));
         n->rotate(180, 0, 1, 0);
         n->translate(0, 0, pF, TS_object);
         room->addChild(n);
  
         // left rectangle
         SLNode* l = new SLNode(new SLRectangle(am,
                                                SLVec2f(-pN, pB),
                                                SLVec2f(-pF, pT),
                                                10,
                                                10,
                                                "Wall left",
                                                matWall));
         l->rotate(90, 0, 1, 0);
         l->translate(0, 0, pL, TS_object);
         room->addChild(l);
  
         // right rectangle
         SLNode* r = new SLNode(new SLRectangle(am,
                                                SLVec2f(pF, pB),
                                                SLVec2f(pN, pT),
                                                10,
                                                10,
                                                "Wall right",
                                                matWall));
         r->rotate(90, 0, -1, 0);
         r->translate(0, 0, -pR, TS_object);
         room->addChild(r);
  
         // Firewood
         _firewood->scale(2);
         scene->addChild(_firewood);
  
         // Torch
         _torchL->name("Torch Left");
         SLNode* torchR = _torchL->copyRec();
         torchR->name("Torch Right");
         _torchL->translate(-2, 1.5f, 0);
         _torchL->rotate(90, 0, 1, 0);
         _torchL->scale(2);
         scene->addChild(_torchL);
         torchR->translate(2, 1.5f, 0);
         torchR->rotate(-90, 0, 1, 0);
         torchR->scale(2);
         scene->addChild(torchR);
  
         // Torch flame left
         SLNode* torchFlameNodeL = createTorchFire(am,
                                                   this,
                                                   true,
                                                   _texTorchSmk,
                                                   _texTorchFlm,
                                                   16,
                                                   4);
         torchFlameNodeL->translate(-1.6f, 2.25f, 0);
         torchFlameNodeL->name("Torch Fire Left");
         scene->addChild(torchFlameNodeL);
  
         // Torch flame right
         SLNode* torchFlameNodeR = createTorchFire(am,
                                                   this,
                                                   true,
                                                   _texTorchSmk,
                                                   _texTorchFlm,
                                                   16,
                                                   4);
         torchFlameNodeR->translate(1.6f, 2.25f, 0);
         torchFlameNodeR->name("Torch Fire Right");
         scene->addChild(torchFlameNodeR);
  
         // Set background color and the root scene node
         sv->sceneViewCamera()->background().colors(SLCol4f(0.8f, 0.8f, 0.8f),
                                                    SLCol4f(0.2f, 0.2f, 0.2f));
         // Save energy
         sv->doWaitOnIdle(false);
     }
     else if (_sceneID == SID_Benchmark_ParticleSystemComplexFire)
     {
         SLCamera* cam1 = new SLCamera("Camera 1");
         cam1->clipNear(0.1f);
         cam1->clipFar(1000);
         cam1->translation(0, 10, 40);
         cam1->focalDist(100);
         cam1->lookAt(0, 0, 0);
         cam1->background().colors(SLCol4f(0.3f, 0.3f, 0.3f));
         cam1->setInitialState();
  
         // Root scene node
         SLNode* root = new SLNode("Root Scene Node");
         root3D(root);
         root->addChild(cam1);
         const int NUM_NODES = 250;
  
         SLVNode nodes(NUM_NODES);
         for (int i = 0; i < NUM_NODES; ++i)
         {
             SLNode* fireComplex = createComplexFire(am,
                                                     this,
                                                     false,
                                                     _texFireCld,
                                                     _texFireFlm,
                                                     8,
                                                     4,
                                                     _texCircle,
                                                     _texSmokeB,
                                                     _texSmokeW);
             fireComplex->translate(-20.0f + (float)(i % 20) * 2,
                                    0.0f,
                                    -(float)((i - (float)(i % 20)) / 20) * 4,
                                    TS_object);
             root->addChild(fireComplex);
         }
  
         sv->camera(cam1);
         sv->doWaitOnIdle(false);
     }
     else
         SL_EXIT_MSG("Assemble: Should not get here!");
 }

◆ createComplexFire()

SLNode * AppDemoSceneParticleComplexFire::createComplexFire	(	SLAssetManager *	am,
		SLScene *	s,
		SLbool	withLight,
		SLGLTexture *	texFireCld,
		SLGLTexture *	texFireFlm,
		SLint	flipbookCols,
		SLint	flipbookRows,
		SLGLTexture *	texCircle,
		SLGLTexture *	texSmokeB,
		SLGLTexture *	texSmokeW
	)

Creates a complex fire group node.

Definition at line 288 of file AppDemoSceneParticleComplexFire.cpp.

 {
     SLNode* fireComplex = new SLNode("Fire complex node");
  
     // Fire light node
     if (withLight)
     {
         SLLightSpot* light1 = new SLLightSpot(am,
                                               s,
                                               0.1f,
                                               180.0f,
                                               false);
         light1->name("Fire light node");
         light1->translate(0, 1.0f, 0);
         light1->diffuseColor(SLCol4f(1, 0.7f, 0.2f));
         light1->diffusePower(15);
         light1->attenuation(0, 0, 1);
         fireComplex->addChild(light1);
     }
  
     // Fire glow mesh
     {
         SLParticleSystem* glow = new SLParticleSystem(am,
                                                       24,
                                                       SLVec3f(-0.1f, 0.0f, -0.1f),
                                                       SLVec3f(0.1f, 0.0f, 0.1f),
                                                       4.0f,
                                                       texFireCld,
                                                       "Fire glow PS");
         glow->timeToLive(2.0f);
         glow->billboardType(BT_Camera);
         glow->radiusW(0.4f);
         glow->radiusH(0.4f);
         glow->doShape(false);
         glow->doRotation(true);
         glow->doRotRange(true);
         glow->doSizeOverLT(false);
         glow->doAlphaOverLT(false);
         glow->doColorOverLT(false);
         glow->doBlendBrightness(true);
         glow->color(SLCol4f(0.925f, 0.5f, 0.097f, 0.199f));
         glow->doAcceleration(false);
         SLNode* flameGlowNode = new SLNode(glow, "Fire glow node");
         flameGlowNode->translate(0, 0.15f, 0);
         fireComplex->addChild(flameGlowNode);
     }
  
     // Fire flame mesh
     {
         SLParticleSystem* flame = new SLParticleSystem(am,
                                                        1,
                                                        SLVec3f(0.0f, 0.0f, 0.0f),
                                                        SLVec3f(0.0f, 0.0f, 0.0f),
  
                                                        1.0f,
                                                        texFireCld,
                                                        "Fire flame PS",
                                                        texFireFlm);
         // Fire flame flipbook settings
         flame->flipbookColumns(flipbookCols);
         flame->flipbookRows(flipbookRows);
         flame->doFlipBookTexture(true);
         flame->doCounterGap(false); // We don't want to have flickering
  
         flame->doAlphaOverLT(false);
         flame->doSizeOverLT(false);
         flame->doRotation(false);
  
         flame->frameRateFB(64);
         flame->radiusW(0.6f);
         flame->radiusH(0.6f);
         flame->scale(1.2f);
         flame->billboardType(BT_Vertical);
  
         // Fire flame color
         flame->doColor(true);
         flame->color(SLCol4f(0.52f, 0.47f, 0.32f, 1.0f));
         flame->doBlendBrightness(true);
  
         // Fire flame size
         flame->doSizeOverLTCurve(true);
         float sizeCPArrayFl[4] = {0.0f, 1.25f, 0.0f, 1.0f};
         flame->bezierControlPointSize(sizeCPArrayFl);
         float sizeSEArrayFl[4] = {0.0f, 1.0f, 1.0f, 1.0f};
         flame->bezierStartEndPointSize(sizeSEArrayFl);
         flame->generateBernsteinPSize();
  
         // Fire flame node
         SLNode* fireFlameNode = new SLNode(flame, "Fire flame node");
         fireFlameNode->translate(0.0f, 0.7f, 0.0f, TS_object);
         fireComplex->addChild(fireFlameNode);
     }
  
     // Fire smoke black mesh
     {
         SLParticleSystem* smokeB = new SLParticleSystem(am,
                                                         8,
                                                         SLVec3f(0.0f, 1.0f, 0.0f),
                                                         SLVec3f(0.0f, 0.7f, 0.0f),
                                                         2.0f,
                                                         texSmokeB,
                                                         "Fire smoke black PS");
         smokeB->doColor(false);
  
         // Fire smoke black size
         smokeB->doSizeOverLT(true);
         smokeB->doSizeOverLTCurve(true);
         float sizeCPArraySB[4] = {0.0f, 1.0f, 1.0f, 2.0f};
         smokeB->bezierControlPointSize(sizeCPArraySB);
         float sizeSEArraySB[4] = {0.0f, 1.0f, 1.0f, 2.0f};
         smokeB->bezierStartEndPointSize(sizeSEArraySB);
         smokeB->generateBernsteinPSize();
  
         // Fire smoke black alpha
         smokeB->doAlphaOverLT(true);
         smokeB->doAlphaOverLTCurve(true);
         float alphaCPArraySB[4] = {0.0f, 0.4f, 1.0f, 0.4f};
         smokeB->bezierControlPointAlpha(alphaCPArraySB);
         float alphaSEArraySB[4] = {0.0f, 0.0f, 1.0f, 0.0f};
         smokeB->bezierStartEndPointAlpha(alphaSEArraySB);
         smokeB->generateBernsteinPAlpha();
  
         // Fire smoke black acceleration
         smokeB->doAcceleration(true);
         smokeB->doAccDiffDir(true);
         smokeB->acceleration(0.0f, 0.25f, 0.3f);
  
         SLNode* fireSmokeBlackNode = new SLNode(smokeB, "Fire smoke black node");
         fireSmokeBlackNode->translate(0.0f, 0.9f, 0.0f, TS_object);
         fireComplex->addChild(fireSmokeBlackNode);
     }
  
     // Fire smoke white mesh
     {
         SLParticleSystem* smokeW = new SLParticleSystem(am,
                                                         40,
                                                         SLVec3f(0.0f, 0.8f, 0.0f),
                                                         SLVec3f(0.0f, 0.6f, 0.0f),
                                                         4.0f,
                                                         texSmokeW,
                                                         "Fire smoke white PS");
  
         smokeW->doColor(false);
  
         // Size
         smokeW->doSizeOverLT(true);
         smokeW->doSizeOverLTCurve(true);
         float sizeCPArraySW[4] = {0.0f, 0.5f, 1.0f, 2.0f};
         smokeW->bezierControlPointSize(sizeCPArraySW);
         float sizeSEArraySW[4] = {0.0f, 0.5f, 1.0f, 2.0f};
         smokeW->bezierStartEndPointSize(sizeSEArraySW);
         smokeW->generateBernsteinPSize();
  
         // Alpha
         smokeW->doAlphaOverLT(true);
         smokeW->doAlphaOverLTCurve(true);
         float alphaCPArraySW[4] = {0.0f, 0.018f, 1.0f, 0.018f};
         smokeW->bezierControlPointAlpha(alphaCPArraySW);
         float alphaSEArraySW[4] = {0.0f, 0.0f, 1.0f, 0.0f};
         smokeW->bezierStartEndPointAlpha(alphaSEArraySW);
         smokeW->generateBernsteinPAlpha();
  
         // Acceleration
         smokeW->doAcceleration(true);
         smokeW->doAccDiffDir(true);
         smokeW->acceleration(0.0f, 0.25f, 0.3f);
  
         SLNode* fireSmokeWNode = new SLNode(smokeW, "Fire smoke white node");
         fireSmokeWNode->translate(0.0f, 0.9f, 0.0f, TS_object);
         fireComplex->addChild(fireSmokeWNode);
     }
  
     // Fire sparks rising mesh
     {
         SLParticleSystem* fireSparksRising = new SLParticleSystem(am,
                                                                   30,
                                                                   SLVec3f(-0.5f, 1, -0.5f),
                                                                   SLVec3f(0.5f, 2, 0.5f),
                                                                   1.2f,
                                                                   texCircle,
                                                                   "Fire sparks rising PS",
                                                                   nullptr,
                                                                   new SLTexColorLUT(am,
                                                                                     CLUT_WYR,
                                                                                     256));
         fireSparksRising->scale(0.05f);
         fireSparksRising->radiusH(0.8f);
         fireSparksRising->radiusW(0.3f);
         fireSparksRising->doShape(true);
         fireSparksRising->doRotation(false);
         fireSparksRising->shapeType(ST_Sphere);
         fireSparksRising->shapeRadius(0.05f);
         fireSparksRising->doAcceleration(true);
         fireSparksRising->acceleration(0, 1.5f, 0);
         fireSparksRising->doColor(true);
         fireSparksRising->doColorOverLT(true);
         fireSparksRising->doBlendBrightness(true);
         fireSparksRising->doSizeOverLT(false);
         fireSparksRising->doAlphaOverLT(false);
         fireSparksRising->doGravity(false);
         fireComplex->addChild(new SLNode(fireSparksRising,
                                          "Fire sparks rising node"));
     }
  
     return fireComplex;
 }

◆ createTorchFire()

SLNode * AppDemoSceneParticleComplexFire::createTorchFire	(	SLAssetManager *	am,
		SLScene *	s,
		SLbool	withLight,
		SLGLTexture *	texFireCld,
		SLGLTexture *	texFireFlm,
		SLint	flipbookCols,
		SLint	flipbookRows
	)

Definition at line 504 of file AppDemoSceneParticleComplexFire.cpp.

 {
  
     SLNode* torchFire = new SLNode("Fire torch node");
  
     // Fire light node
     if (withLight)
     {
         SLLightSpot* light1 = new SLLightSpot(am,
                                               s,
                                               0.1f,
                                               180.0f,
                                               false);
         light1->name("Fire light node");
         light1->translate(0, 0, 0);
         light1->diffuseColor(SLCol4f(1, 0.4f, 0.0f));
         light1->diffusePower(2);
         light1->attenuation(0, 0, 1);
         torchFire->addChild(light1);
     }
  
     // Fire glow mesh
     {
         SLParticleSystem* glow = new SLParticleSystem(am,
                                                       40,
                                                       SLVec3f(-0.1f, 0.0f, -0.1f),
                                                       SLVec3f(0.1f, 0.0f, 0.1f),
                                                       1.5f,
                                                       texFireCld,
                                                       "Torch Glow PS");
         glow->color(SLCol4f(0.9f, 0.5f, 0, 0.63f));
         glow->doBlendBrightness(true);
         glow->radiusW(0.15f);
         glow->radiusH(0.15f);
         glow->doSizeOverLT(false);
         SLNode* fireGlowNode = new SLNode(glow, "Torch Glow Node");
         fireGlowNode->translate(0, -0.4f, 0);
         torchFire->addChild(fireGlowNode);
     }
  
     // Fire torches
     {
         SLParticleSystem* flame = new SLParticleSystem(am,
                                                        1,
                                                        SLVec3f(0.0f, 0.0f, 0.0f),
                                                        SLVec3f(0.0f, 0.0f, 0.0f),
                                                        4.0f,
                                                        texFireCld,
                                                        "Torch Flame PS",
                                                        texFireFlm);
         flame->flipbookColumns(flipbookCols);
         flame->flipbookRows(flipbookRows);
         flame->doFlipBookTexture(true);
         flame->doCounterGap(false); // We don't want to have flickering
         flame->doAlphaOverLT(false);
         flame->doSizeOverLT(false);
         flame->doRotation(false);
         flame->doColor(false);
         flame->frameRateFB(64);
         flame->radiusW(0.3f);
         flame->radiusH(0.8f);
         flame->billboardType(BT_Vertical);
         SLNode* torchFlameNode = new SLNode(flame, "Torch Flame Node");
         torchFlameNode->translate(0, 0.3f, 0);
         torchFire->addChild(torchFlameNode);
     }
  
     return torchFire;
 }

◆ registerAssetsToLoad()

void AppDemoSceneParticleComplexFire::registerAssetsToLoad ( SLAssetLoader & al )

overridevirtual

All scene specific assets have to be registered for async loading in here.

All assets the should be loaded in parallel must be registered in here.

Remarks: All scene sspecific assets have to be loaded async by overriding SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and assembling means that it happens in a parallel thread and that in there are no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.

Reimplemented from SLScene.

Definition at line 32 of file AppDemoSceneParticleComplexFire.cpp.

 {
     al.addTextureToLoad(_texFireCld,
                         AppCommon::texturePath +
                           "ParticleFirecloudTransparent_C.png");
     al.addTextureToLoad(_texFireFlm,
                         AppCommon::texturePath +
                           "ParticleFlames_06_8x8_C.png");
     al.addTextureToLoad(_texCircle,
                         AppCommon::texturePath +
                           "ParticleCircle_05_C.png");
     al.addTextureToLoad(_texSmokeB,
                         AppCommon::texturePath +
                           "ParticleCloudBlack_C.png");
     al.addTextureToLoad(_texSmokeW,
                         AppCommon::texturePath +
                           "ParticleCloudWhite_C.png");
     al.addTextureToLoad(_texTorchFlm,
                         AppCommon::texturePath +
                           "ParticleFlames_04_16x4_C.png");
     al.addTextureToLoad(_texTorchSmk,
                         AppCommon::texturePath +
                           "ParticleSmoke_08_C.png");
  
     al.addTextureToLoad(_texWallDIF,
                         AppCommon::texturePath +
                           "BrickLimestoneGray_1K_DIF.jpg",
                         SL_ANISOTROPY_MAX,
                         GL_LINEAR);
     al.addTextureToLoad(_texWallNRM,
                         AppCommon::texturePath +
                           "BrickLimestoneGray_1K_NRM.jpg",
                         SL_ANISOTROPY_MAX,
                         GL_LINEAR);
  
     al.addNodeToLoad(_firewood,
                      AppCommon::modelPath +
                        "GLTF/Firewood/Firewood1.gltf",
                      nullptr,
                      false,
                      true,
                      nullptr,
                      0.3f,
                      true);
     al.addNodeToLoad(_torchL,
                      AppCommon::modelPath +
                        "GLTF/Torch/Torch.gltf",
                      nullptr,
                      false,
                      true,
                      nullptr,
                      0.3f,
                      true);
 }