← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/blender/gutsy-security

« back to all changes in this revision

Viewing changes to intern/elbeem/intern/ntl_world.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Lukas Fittl
  • Date: 2006-09-20 01:57:27 UTC
  • mfrom: (1.2.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20060920015727-gmoqlxwstx9wwqs3
Tags: 2.42a-1ubuntu1
* Merge from Debian unstable (Closes: Malone #55903). Remaining changes:
  - debian/genpot: Add python scripts from Lee June <blender@eyou.com> to
    generate a reasonable PO template from the sources. Since gettext is used
    in a highly nonstandard way, xgettext does not work for this job.
  - debian/rules: Call the scripts, generate po/blender.pot, and clean it up
    in the clean target.
  - Add a proper header to the generated PO template.
* debian/control: Build depend on libavformat-dev >= 3:0.cvs20060823-3.1,
  otherwise this package will FTBFS

Show diffs side-by-side

added added

removed removed

Lines of Context:
intern/elbeem/intern/ntl_world.cpp
12
12
#include <sstream>
13
13
#include "utilities.h"
14
14
#include "ntl_world.h"
15
 
#include "ntl_scene.h"
16
15
#include "parametrizer.h"
17
 
#include "globals.h"
18
16
 
19
17
// for non-threaded renderViz
20
18
#ifndef NOGUI
25
23
 
26
24
 
27
25
/* external parser functions from cfgparser.cxx */
 
26
#ifndef ELBEEM_PLUGIN
28
27
/* parse given file as config file */
29
28
void parseFile(string filename);
30
29
/* set pointers for parsing */
31
30
void setPointers( ntlRenderGlobals *setglob);
 
31
#endif // ELBEEM_PLUGIN
32
32
 
33
33
 
34
34
/******************************************************************************
35
35
 * Constructor
36
36
 *****************************************************************************/
 
37
 
 
38
ntlWorld::ntlWorld() {
 
39
        initDefaults();
 
40
}
 
41
 
37
42
ntlWorld::ntlWorld(string filename, bool commandlineMode) 
38
 
        /*:
39
 
        mpGlob(NULL), 
40
 
  mpLightList(NULL), mpPropList(NULL), mpSims(NULL),
41
 
        mpOpenGLRenderer(NULL),
42
 
        mStopRenderVisualization( false ),
43
 
        mThreadRunning( false ), 
44
 
        mSimulationTime(0.0), mFirstSim(-1),
45
 
        mSingleStepDebug( false ),
46
 
        mFrameCnt(0)*/
47
43
{
48
 
#if 0
49
 
  /* create scene storage */
50
 
  mpGlob = new ntlRenderGlobals();
51
 
  mpLightList = new vector<ntlLightObject*>;
52
 
  mpPropList = new vector<ntlMaterial*>;
53
 
  mpSims = new vector<SimulationObject*>;
54
 
 
55
 
  mpGlob->setLightList(mpLightList);
56
 
  mpGlob->setMaterials(mpPropList);
57
 
  mpGlob->setSims(mpSims);
58
 
 
59
 
        /* init default material */
60
 
  ntlMaterial *def = GET_GLOBAL_DEFAULT_MATERIAL;
61
 
        mpPropList->push_back( def );
62
 
 
63
 
        /* init the scene object */
64
 
        ntlScene *scene;
65
 
        scene = new ntlScene( mpGlob );
66
 
        mpGlob->setScene( scene );
67
 
 
68
 
        // moved TODO test...
69
 
#endif // 0
70
 
 
71
 
        initDefaults();
72
 
#ifndef NOGUI
73
 
        // setup opengl display, save first animation step for start time 
74
 
        if(!commandlineMode) {
75
 
                mpOpenGLRenderer = new ntlOpenGLRenderer( mpGlob );
76
 
        }
77
 
#else // NOGUI
78
 
        commandlineMode = true; // remove warning...
79
 
#endif // NOGUI
80
 
        // load config
81
 
  setPointers( getRenderGlobals() );
82
 
  parseFile( filename.c_str() );
83
 
        finishWorldInit();
84
 
        /*if(!SIMWORLD_OK()) return;
85
 
 
86
 
        // init the scene for the first time
87
 
  long sstartTime = getTime();
88
 
        scene->buildScene();
89
 
        long sstopTime = getTime();
90
 
        debMsgStd("ntlWorld::ntlWorld",DM_MSG,"Scene build time: "<< getTimeString(sstopTime-sstartTime) <<" ", 10);
91
 
 
92
 
        // TODO check simulations, run first steps
93
 
        mFirstSim = -1;
94
 
        if(mpSims->size() > 0) {
95
 
 
96
 
                // use values from first simulation as master time scale
97
 
                long startTime = getTime();
98
 
                
99
 
                // remember first active sim
100
 
                for(size_t i=0;i<mpSims->size();i++) {
101
 
                        if(!(*mpSims)[i]->getVisible()) continue;
102
 
                        if((*mpSims)[i]->getPanic())    continue;
103
 
 
104
 
                        // check largest timestep
105
 
                        if(mFirstSim>=0) {
106
 
                                if( (*mpSims)[i]->getStepTime() > (*mpSims)[mFirstSim]->getStepTime() ) {
107
 
                                        mFirstSim = i;
108
 
                                        debMsgStd("ntlWorld::ntlWorld",DM_MSG,"First Sim changed: "<<i ,10);
109
 
                                }
110
 
                        }
111
 
                        // check any valid sim
112
 
                        if(mFirstSim<0) {
113
 
                                mFirstSim = i;
114
 
                                debMsgStd("ntlWorld::ntlWorld",DM_MSG,"First Sim: "<<i ,10);
115
 
                        }
116
 
                }
117
 
 
118
 
                if(mFirstSim>=0) {
119
 
                        debMsgStd("ntlWorld::ntlWorld",DM_MSG,"Anistart Time: "<<(*mpSims)[mFirstSim]->getStartTime() ,10);
120
 
                        while(mSimulationTime < (*mpSims)[mFirstSim]->getStartTime() ) {
121
 
                        debMsgStd("ntlWorld::ntlWorld",DM_MSG,"Anistart Time: "<<(*mpSims)[mFirstSim]->getStartTime()<<" simtime:"<<mSimulationTime ,10);
122
 
                                advanceSims(-1);
123
 
                        }
124
 
                        long stopTime = getTime();
125
 
 
126
 
                        mSimulationTime += (*mpSims)[mFirstSim]->getStartTime();
127
 
                        debMsgStd("ntlWorld::ntlWorld",DM_MSG,"Time for start simulations times "<<": "<< getTimeString(stopTime-startTime) <<"s ", 1);
128
 
#ifndef NOGUI
129
 
                        guiResetSimulationTimeRange( mSimulationTime );
130
 
#endif
131
 
                } else {
132
 
                        if(!mpGlob->getSingleFrameMode()) debMsgStd("ntlWorld::ntlWorld",DM_WARNING,"No active simulations!", 1);
133
 
                }
134
 
        }
135
 
*/
 
44
#ifndef ELBEEM_PLUGIN
 
45
 
 
46
                initDefaults();
 
47
#       ifdef NOGUI
 
48
                commandlineMode = true; // remove warning...
 
49
#       endif // NOGUI
 
50
 
 
51
                // load config
 
52
                setPointers( getRenderGlobals() );
 
53
                parseFile( filename.c_str() );
 
54
#       ifndef NOGUI
 
55
                // setup opengl display, save first animation step for start time 
 
56
                // init after parsing file...
 
57
                if(!commandlineMode) {
 
58
                        mpOpenGLRenderer = new ntlOpenGLRenderer( mpGlob );
 
59
                }
 
60
#       endif // NOGUI
 
61
                finishWorldInit();
 
62
 
 
63
#else // ELBEEM_PLUGIN
 
64
        errFatal("ntlWorld::init","Cfg file parsing not supported for API version!", SIMWORLD_INITERROR);
 
65
#endif // ELBEEM_PLUGIN
136
66
}
137
67
 
138
 
ntlWorld::ntlWorld(elbeemSimulationSettings *settings)
 
68
 
 
69
int globalDomainCounter = 1;
 
70
int ntlWorld::addDomain(elbeemSimulationSettings *settings)
139
71
{
140
 
        initDefaults();
141
 
        // todo init settings
 
72
        // create domain obj
142
73
        SimulationObject *sim = new SimulationObject();
 
74
        char simname[100];
 
75
        snprintf(simname,100,"domain%04d",globalDomainCounter);
 
76
        globalDomainCounter++;
 
77
        sim->setName(string(simname));
143
78
        mpGlob->getSims()->push_back( sim );
144
 
        mpGlob->getScene()->addGeoClass( sim );
 
79
 
 
80
        // important - add to both, only render scene objects are free'd 
 
81
        mpGlob->getRenderScene()->addGeoClass( sim );
 
82
        mpGlob->getSimScene()->addGeoClass( sim );
145
83
        sim->setGeoStart(ntlVec3Gfx(settings->geoStart[0],settings->geoStart[1],settings->geoStart[2]));
146
84
        sim->setGeoEnd(ntlVec3Gfx(
147
85
                        settings->geoStart[0]+settings->geoSize[0],
148
86
                        settings->geoStart[1]+settings->geoSize[1],
149
87
                        settings->geoStart[2]+settings->geoSize[2] ));
150
 
        sim->getSolver()->setSmoothing(1.0, 0.0);
151
 
        sim->getSolver()->setPreviewSize(settings->previewresxyz);
152
 
        sim->getSolver()->setRefinementDesired(settings->maxRefine);
 
88
        // further init in postGeoConstrInit/initializeLbmSimulation of SimulationObject
 
89
        sim->copyElbeemSettings(settings);
153
90
 
154
91
        Parametrizer *param = sim->getParametrizer();
155
92
        param->setSize( settings->resolutionxyz );
156
93
        param->setDomainSize( settings->realsize );
157
 
        param->setViscosity( settings->viscosity );
158
 
        param->setGravity( ParamVec(settings->gravx, settings->gravy, settings->gravx) );
159
94
        param->setAniStart( settings->animStart );
160
 
        param->setAniFrameTime( settings->aniFrameTime );
161
95
        param->setNormalizedGStar( settings->gstar );
162
96
 
163
 
        // dont setup lights, camera, materials...?
164
 
  /*
165
 
        ntlMaterial *fluidmat = new ntlMaterial( );
166
 
        currentMaterial->setAmbientRefl( ntlColor(0.3, 0.5, 0.9) ); 
167
 
        currentMaterial->setDiffuseRefl( ntlColor(0.3, 0.5, 0.9) ); 
168
 
        currentMaterial->setSpecular( 0.2 ); 
169
 
        currentMaterial->setSpecExponent( 10.0 ); 
170
 
        mpGlob->getMaterials()->push_back( fluidmat );
171
 
        // */
 
97
        // init domain channels
 
98
        vector<ParamFloat> valf; 
 
99
        vector<ParamVec> valv; 
 
100
        vector<double> time;
 
101
 
 
102
#define INIT_CHANNEL_FLOAT(channel,size) \
 
103
        valf.clear(); time.clear(); elbeemSimplifyChannelFloat(channel,&size); \
 
104
        for(int i=0; i<size; i++) { valf.push_back( channel[2*i+0] ); time.push_back( channel[2*i+1] ); } 
 
105
#define INIT_CHANNEL_VEC(channel,size) \
 
106
        valv.clear(); time.clear(); elbeemSimplifyChannelVec3(channel,&size); \
 
107
        for(int i=0; i<size; i++) { valv.push_back( ParamVec(channel[4*i+0],channel[4*i+1],channel[4*i+2]) ); time.push_back( channel[4*i+3] ); } 
 
108
 
 
109
        param->setViscosity( settings->viscosity );
 
110
        if((settings->channelViscosity)&&(settings->channelSizeViscosity>0)) {
 
111
                INIT_CHANNEL_FLOAT(settings->channelViscosity, settings->channelSizeViscosity);
 
112
                param->initViscosityChannel(valf,time); }
 
113
 
 
114
        param->setGravity( ParamVec(settings->gravity[0], settings->gravity[1], settings->gravity[2]) );
 
115
        if((settings->channelGravity)&&(settings->channelSizeGravity>0)) {
 
116
                INIT_CHANNEL_VEC(settings->channelGravity, settings->channelSizeGravity);
 
117
                param->initGravityChannel(valv,time); }
 
118
 
 
119
        param->setAniFrameTimeChannel( settings->aniFrameTime );
 
120
        if((settings->channelFrameTime)&&(settings->channelSizeFrameTime>0)) {
 
121
                INIT_CHANNEL_FLOAT(settings->channelFrameTime, settings->channelSizeFrameTime);
 
122
                param->initAniFrameTimeChannel(valf,time); }
 
123
 
 
124
#undef INIT_CHANNEL_FLOAT
 
125
#undef INIT_CHANNEL_VEC
 
126
        
 
127
        // might be set by previous domain
 
128
        if(mpGlob->getAniFrames() < settings->noOfFrames)       mpGlob->setAniFrames( settings->noOfFrames );
 
129
        // set additionally to SimulationObject->mOutFilename
 
130
        mpGlob->setOutFilename( settings->outputPath );
 
131
 
 
132
        return 0;
172
133
}
173
134
 
174
135
void ntlWorld::initDefaults()
196
157
        mpPropList->push_back( def );
197
158
 
198
159
        /* init the scene object */
199
 
        ntlScene *newscene = new ntlScene( mpGlob );
200
 
        mpGlob->setScene( newscene );
 
160
        ntlScene *renderscene = new ntlScene( mpGlob, true );
 
161
        mpGlob->setRenderScene( renderscene );
 
162
        // sim scene shouldnt delete objs, may only contain subset
 
163
        ntlScene *simscene = new ntlScene( mpGlob, false );
 
164
        mpGlob->setSimScene( simscene );
201
165
}
202
166
 
203
167
void ntlWorld::finishWorldInit()
204
168
{
205
 
        if(!SIMWORLD_OK()) return;
 
169
        if(! isSimworldOk() ) return;
206
170
 
207
171
        // init the scene for the first time
208
172
  long sstartTime = getTime();
209
 
        mpGlob->getScene()->buildScene();
 
173
 
 
174
        // first init sim scene for geo setup
 
175
        mpGlob->getSimScene()->buildScene(0.0, true);
 
176
        if(! isSimworldOk() ) return;
 
177
        mpGlob->getRenderScene()->buildScene(0.0, true);
 
178
        if(! isSimworldOk() ) return;
210
179
        long sstopTime = getTime();
211
180
        debMsgStd("ntlWorld::ntlWorld",DM_MSG,"Scene build time: "<< getTimeString(sstopTime-sstartTime) <<" ", 10);
212
181
 
213
 
        if(!SIMWORLD_OK()) return;
214
182
        // TODO check simulations, run first steps
215
183
        mFirstSim = -1;
216
184
        if(mpSims->size() > 0) {
225
193
 
226
194
                        // check largest timestep
227
195
                        if(mFirstSim>=0) {
228
 
                                if( (*mpSims)[i]->getStepTime() > (*mpSims)[mFirstSim]->getStepTime() ) {
 
196
                                if( (*mpSims)[i]->getTimestep() > (*mpSims)[mFirstSim]->getTimestep() ) {
229
197
                                        mFirstSim = i;
230
198
                                        debMsgStd("ntlWorld::ntlWorld",DM_MSG,"First Sim changed: "<<i ,10);
231
199
                                }
246
214
                        long stopTime = getTime();
247
215
 
248
216
                        mSimulationTime += (*mpSims)[mFirstSim]->getStartTime();
249
 
                        debMsgStd("ntlWorld::ntlWorld",DM_MSG,"Time for start simulations times "<<": "<< getTimeString(stopTime-startTime) <<"s ", 1);
 
217
                        debMsgStd("ntlWorld::ntlWorld",DM_MSG,"Time for start-sims:"<< getTimeString(stopTime-startTime) , 1);
250
218
#ifndef NOGUI
251
219
                        guiResetSimulationTimeRange( mSimulationTime );
252
220
#endif
254
222
                        if(!mpGlob->getSingleFrameMode()) debMsgStd("ntlWorld::ntlWorld",DM_WARNING,"No active simulations!", 1);
255
223
                }
256
224
        }
 
225
 
 
226
        if(! isSimworldOk() ) return;
 
227
        setElbeemState( SIMWORLD_INITED );
257
228
}
258
229
 
259
230
 
263
234
 *****************************************************************************/
264
235
ntlWorld::~ntlWorld()
265
236
{
266
 
        delete mpGlob->getScene();
 
237
        delete mpGlob->getRenderScene();
 
238
        delete mpGlob->getSimScene();
267
239
  delete mpGlob;
268
240
  delete mpLightList;
269
241
  delete mpPropList;
271
243
#ifndef NOGUI
272
244
        if(mpOpenGLRenderer) delete mpOpenGLRenderer;
273
245
#endif // NOGUI
 
246
        debMsgStd("ntlWorld",DM_NOTIFY, "ntlWorld done", 10);
274
247
}
275
248
 
276
249
/******************************************************************************/
285
258
 *****************************************************************************/
286
259
 
287
260
// blender interface
288
 
#if ELBEEM_BLENDER==1
289
 
extern "C" {
290
 
        void simulateThreadIncreaseFrame(void);
291
 
}
292
 
#endif // ELBEEM_BLENDER==1
 
261
//#if ELBEEM_BLENDER==1
 
262
//extern "C" { void simulateThreadIncreaseFrame(void); }
 
263
//#endif // ELBEEM_BLENDER==1
293
264
 
294
265
int ntlWorld::renderAnimation( void )
295
266
{
306
277
        } 
307
278
 
308
279
        mThreadRunning = true; // not threaded, but still use the same flags
309
 
        renderScene();
 
280
        if(getElbeemState() == SIMWORLD_INITED) {
 
281
                renderScene();
 
282
        } else if(getElbeemState() == SIMWORLD_STOP) {
 
283
                // dont render now, just continue
 
284
                setElbeemState( SIMWORLD_INITED );
 
285
                mFrameCnt--; // counted one too many from last abort...
 
286
        } else {
 
287
                debMsgStd("ntlWorld::renderAnimation",DM_NOTIFY,"Not properly inited, stopping...",1);
 
288
                return 1;
 
289
        }
 
290
        
310
291
        if(mpSims->size() <= 0) {
311
292
                debMsgStd("ntlWorld::renderAnimation",DM_NOTIFY,"No simulations found, stopping...",1);
312
293
                return 1;
313
294
        }
314
295
 
315
 
        for(mFrameCnt=0; ((mFrameCnt<mpGlob->getAniFrames()) && (!getStopRenderVisualization() )); mFrameCnt++) {
 
296
        bool simok = true;
 
297
        for( ; ((mFrameCnt<mpGlob->getAniFrames()) && (!getStopRenderVisualization() ) && (simok)); mFrameCnt++) {
316
298
                if(!advanceSims(mFrameCnt)) {
317
299
                        renderScene();
318
 
#if ELBEEM_BLENDER==1
 
300
//#if ELBEEM_BLENDER==1
319
301
                        // update Blender gui display after each frame
320
 
                        simulateThreadIncreaseFrame();
321
 
#endif // ELBEEM_BLENDER==1
 
302
                        //simulateThreadIncreaseFrame();
 
303
//#endif // ELBEEM_BLENDER==1
322
304
                } // else means sim panicked, so dont render...
 
305
                else { simok=false; }
323
306
        }
324
307
        mThreadRunning = false;
325
308
        return 0;
333
316
int ntlWorld::renderVisualization( bool multiThreaded ) 
334
317
{
335
318
#ifndef NOGUI
336
 
        //gfxReal deltat = 0.0015;
 
319
        if(getElbeemState() != SIMWORLD_INITED) { return 0; }
 
320
 
337
321
        if(multiThreaded) mThreadRunning = true;
 
322
        // TODO, check global state?
338
323
        while(!getStopRenderVisualization()) {
339
324
 
340
325
                if(mpSims->size() <= 0) {
349
334
                        advanceSims(mFrameCnt);
350
335
                        mFrameCnt++;
351
336
                        long stopTime = getTime();
352
 
                        debMsgStd("ntlWorld::renderVisualization",DM_MSG,"Time for "<<mSimulationTime<<": "<< getTimeString(stopTime-startTime) <<"s ", 10);
 
337
                        debMsgStd("ntlWorld::renderVisualization",DM_MSG,"Time for t="<<mSimulationTime<<": "<< getTimeString(stopTime-startTime) <<" ", 10);
353
338
                } else {
354
 
                        double targetTime = mSimulationTime + (*mpSims)[mFirstSim]->getStepTime();
 
339
                        double targetTime = mSimulationTime + (*mpSims)[mFirstSim]->getTimestep();
355
340
                        singleStepSims(targetTime);
356
341
 
357
342
                        // check paniced sims (normally done by advanceSims
363
348
                                warnMsg("ntlWorld::advanceSims","All sims panicked... stopping thread" );
364
349
                                setStopRenderVisualization( true );
365
350
                        }
366
 
                        if(!SIMWORLD_OK()) {
 
351
                        if(! isSimworldOk() ) {
367
352
                                warnMsg("ntlWorld::advanceSims","World state error... stopping" );
368
353
                                setStopRenderVisualization( true );
369
354
                        }
390
375
int ntlWorld::singleStepVisualization( void ) 
391
376
{
392
377
        mThreadRunning = true;
393
 
        double targetTime = mSimulationTime + (*mpSims)[mFirstSim]->getStepTime();
 
378
        double targetTime = mSimulationTime + (*mpSims)[mFirstSim]->getTimestep();
394
379
        singleStepSims(targetTime);
395
380
        mSimulationTime = (*mpSims)[0]->getCurrentTime();
396
381
 
416
401
{
417
402
        bool done = false;
418
403
        bool allPanic = true;
419
 
        //debMsgStd("ntlWorld::advanceSims",DM_MSG,"Advancing sims to "<<targetTime, 10 ); // timedebug
 
404
 
 
405
        // stop/quit, dont display/render
 
406
        if(getElbeemState()==SIMWORLD_STOP) { 
 
407
                return 1;
 
408
        }
420
409
 
421
410
        for(size_t i=0;i<mpSims->size();i++) { (*mpSims)[i]->setFrameNum(framenum); }
422
 
        double targetTime = mSimulationTime + (*mpSims)[mFirstSim]->getFrameTime();
423
 
//FIXME check blender abort here...
424
 
//FIXME check no ipo export
 
411
        double targetTime = mSimulationTime + (*mpSims)[mFirstSim]->getFrameTime(framenum);
425
412
 
426
413
        // time stopped? nothing else to do...
427
 
        if( (*mpSims)[mFirstSim]->getFrameTime() <= 0.0 ){ 
 
414
        if( (*mpSims)[mFirstSim]->getFrameTime(framenum) <= 0.0 ){ 
428
415
                done=true; allPanic=false; 
429
416
        }
430
417
 
431
 
#if ELBEEM_BLENDER==1
 
418
        int gstate = 0;
 
419
//#if ELBEEM_BLENDER==1
432
420
        // same as solver_main check, but no mutex check here
433
 
        if(getGlobalBakeState()<0) {
434
 
                // this means abort... cause panic
435
 
                allPanic = true; done = true;
436
 
        }
437
 
#endif // ELBEEM_BLENDER==1
 
421
        //gstate = getGlobalBakeState();
 
422
        //if(gstate<0) { allPanic = true; done = true; } // this means abort... cause panic
 
423
//#endif // ELBEEM_BLENDER==1
438
424
 
439
425
        // step all the sims, and check for panic
 
426
        debMsgStd("ntlWorld::advanceSims",DM_MSG, " sims "<<mpSims->size()<<" t"<<targetTime<<" done:"<<done<<" panic:"<<allPanic<<" gstate:"<<gstate, 10); // debug // timedebug
440
427
        while(!done) {
441
 
                double nextTargetTime = (*mpSims)[mFirstSim]->getCurrentTime() + (*mpSims)[mFirstSim]->getStepTime();
 
428
                double nextTargetTime = (*mpSims)[mFirstSim]->getCurrentTime() + (*mpSims)[mFirstSim]->getTimestep();
442
429
                singleStepSims(nextTargetTime);
443
430
 
444
431
                // check target times
445
432
                done = true;
446
433
                allPanic = false;
447
 
                for(size_t i=0;i<mpSims->size();i++) {
448
 
                        if(!(*mpSims)[i]->getVisible()) continue;
449
 
                        if((*mpSims)[i]->getPanic()) allPanic = true; // do any panic now!?
450
 
                        //debMsgStd("ntlWorld::advanceSims",DM_MSG, " sim "<<i<<" c"<<(*mpSims)[i]->getCurrentTime()<<" p"<<(*mpSims)[i]->getPanic()<<" t"<<targetTime, 10); // debug // timedebug
 
434
                
 
435
                if((*mpSims)[mFirstSim]->getTimestep() <1e-9 ) { 
 
436
                        // safety check, avoid timesteps that are too small
 
437
                        errMsg("ntlWorld::advanceSims","Invalid time step, causing panic! curr:"<<(*mpSims)[mFirstSim]->getCurrentTime()<<" next:"<<nextTargetTime<<", stept:"<< (*mpSims)[mFirstSim]->getTimestep() );
 
438
                        allPanic = true; 
 
439
                } else {
 
440
                        for(size_t i=0;i<mpSims->size();i++) {
 
441
                                if(!(*mpSims)[i]->getVisible()) continue;
 
442
                                if((*mpSims)[i]->getPanic()) allPanic = true; // do any panic now!?
 
443
                                debMsgStd("ntlWorld::advanceSims",DM_MSG, "Sim "<<i<<", currt:"<<(*mpSims)[i]->getCurrentTime()<<", nt:"<<nextTargetTime<<", panic:"<<(*mpSims)[i]->getPanic()<<", targett:"<<targetTime, 10); // debug // timedebug
 
444
                        } 
451
445
                }
452
446
                if( (targetTime - (*mpSims)[mFirstSim]->getCurrentTime()) > LBM_TIME_EPSILON) done=false;
453
447
                if(allPanic) done = true;
474
468
/* dont check target time, if *targetTime==NULL */
475
469
void ntlWorld::singleStepSims(double targetTime) {
476
470
        const bool debugTime = false;
477
 
        //double targetTime = mSimulationTime + (*mpSims)[mFirstSim]->getStepTime();
 
471
        //double targetTime = mSimulationTime + (*mpSims)[mFirstSim]->getTimestep();
478
472
        if(debugTime) errMsg("ntlWorld::singleStepSims","Target time: "<<targetTime);
479
473
 
480
474
        for(size_t i=0;i<mpSims->size();i++) {
484
478
                bool done = false;
485
479
                while(!done) {
486
480
                        // try to prevent round off errs
487
 
                        if(debugTime) errMsg("ntlWorld::singleStepSims","Test sim "<<i<<" curt:"<< sim->getCurrentTime()<<" target:"<<targetTime<<" delta:"<<(targetTime - sim->getCurrentTime())<<" stept:"<<sim->getStepTime()<<" leps:"<<LBM_TIME_EPSILON ); // timedebug
 
481
                        if(debugTime) errMsg("ntlWorld::singleStepSims","Test sim "<<i<<" curt:"<< sim->getCurrentTime()<<" target:"<<targetTime<<" delta:"<<(targetTime - sim->getCurrentTime())<<" stept:"<<sim->getTimestep()<<" leps:"<<LBM_TIME_EPSILON ); // timedebug
488
482
                        if( (targetTime - sim->getCurrentTime()) > LBM_TIME_EPSILON) {
489
483
                                if(debugTime) errMsg("ntlWorld::singleStepSims","Stepping sim "<<i<<" t:"<< sim->getCurrentTime()); // timedebug
490
484
                                sim->step();
509
503
 *****************************************************************************/
510
504
int ntlWorld::renderScene( void )
511
505
{
512
 
#ifndef ELBEEM_BLENDER
513
 
        char nrStr[5];                                                                                                          /* nr conversion */
514
 
        //std::ostringstream outfilename("");                                     /* ppm file */
515
 
        std::ostringstream outfn_conv("");                                              /* converted ppm with other suffix */
516
 
  ntlRenderGlobals *glob;                       /* storage for global rendering parameters */
517
 
  myTime_t timeStart,totalStart,timeEnd;                /* measure user running time */
518
 
  myTime_t rendStart,rendEnd;                           /* measure user rendering time */
 
506
#ifndef ELBEEM_PLUGIN
 
507
        char nrStr[5];                                                                                                          // nr conversion 
 
508
        std::ostringstream outfn_conv("");                      // converted ppm with other suffix 
 
509
  ntlRenderGlobals *glob;                       // storage for global rendering parameters 
 
510
  myTime_t timeStart,totalStart,timeEnd;                // measure user running time 
 
511
  myTime_t rendStart,rendEnd;                           // measure user rendering time 
519
512
  glob = mpGlob;
520
513
 
521
514
        /* check if picture already exists... */
541
534
  /* start program */
542
535
        timeStart = getTime();
543
536
 
544
 
        /* build scene geometry */
545
 
        glob->getScene()->prepareScene();
 
537
        /* build scene geometry, calls buildScene(t,false) */
 
538
        glob->getRenderScene()->prepareScene(mSimulationTime);
546
539
 
547
540
  /* start program */
548
541
        totalStart = getTime();
566
559
 
567
560
        /* check if vectors are valid */
568
561
        if( (equal(upVec,ntlVec3Gfx(0.0))) || (equal(rightVec,ntlVec3Gfx(0.0))) ) {
569
 
                errorOut("NTL ERROR: Invalid viewpoint vectors!\n");
 
562
                errMsg("ntlWorld::renderScene","Invalid viewpoint vectors! up="<<upVec<<" right="<<rightVec);
570
563
                return(1);
571
564
        }
572
565
 
856
849
        delete [] aaCol;
857
850
        delete [] aaUse;
858
851
        delete [] finalPic;
859
 
        glob->getScene()->cleanupScene();
 
852
        glob->getRenderScene()->cleanupScene();
860
853
 
861
854
        if(mpGlob->getSingleFrameMode() ) {
862
855
                debMsgStd("ntlWorld::renderScene",DM_NOTIFY, "Single frame mode done...", 1 );
863
856
                return 1;
864
857
        }
865
 
#endif // ELBEEM_BLENDER
 
858
#endif // ELBEEM_PLUGIN
866
859
        return 0;
867
860
}
868
861
 
869
862
 
 
863
/******************************************************************************
 
864
 * renderglobals
 
865
 *****************************************************************************/
 
866
 
 
867
 
 
868
/*****************************************************************************/
 
869
/* Constructor with standard value init */
 
870
ntlRenderGlobals::ntlRenderGlobals() :
 
871
        mpRenderScene(NULL), mpSimScene(NULL),
 
872
  mpLightList( NULL ), mpMaterials( NULL ), mpSims( NULL ),
 
873
  mResX(320), mResY(200), mAADepth(-1), mMaxColVal(255), 
 
874
  mRayMaxDepth( 5 ),
 
875
  mvEye(0.0,0.0,5.0), mvLookat(0.0,0.0,0.0), mvUpvec(0.0,1.0,0.0), 
 
876
  mAspect(320.0/200.0), 
 
877
  mFovy(45), mcBackgr(0.0,0.0,0.0), mcAmbientLight(0.0,0.0,0.0), 
 
878
  mDebugOut( 0 ),
 
879
  mAniStart(0), mAniFrames( -1 ), mAniCount( 0 ),
 
880
        mFrameSkip( 0 ),
 
881
  mCounterRays( 0 ), mCounterShades( 0 ), mCounterSceneInter( 0 ),
 
882
        mOutFilename( "pic" ),
 
883
        mTreeMaxDepth( 30 ), mTreeMaxTriangles( 30 ),
 
884
        mpOpenGlAttr(NULL),
 
885
        mpBlenderAttr(NULL),
 
886
        mTestSphereEnabled( false ),
 
887
        mDebugPixelX( -1 ), mDebugPixelY( -1 ), mTestMode(false),
 
888
        mSingleFrameMode(false), mSingleFrameFilename("")
 
889
        //,mpRndDirections( NULL ), mpRndRoulette( NULL )
 
890
{ 
 
891
        // create internal attribute list for opengl renderer
 
892
        mpOpenGlAttr = new AttributeList("__ntlOpenGLRenderer");
 
893
        mpBlenderAttr = new AttributeList("__ntlBlenderAttr");
 
894
};
 
895
 
 
896
 
 
897
/*****************************************************************************/
 
898
/* Destructor */
 
899
ntlRenderGlobals::~ntlRenderGlobals() {
 
900
        if(mpOpenGlAttr) delete mpOpenGlAttr;
 
901
        if(mpBlenderAttr) delete mpBlenderAttr;
 
902
}
 
903
 
 
904
 
 
905
/*****************************************************************************/
 
906
//! get the next random photon direction
 
907
//ntlVec3Gfx ntlRenderGlobals::getRandomDirection( void ) { 
 
908
        //return ntlVec3Gfx( 
 
909
                        //(mpRndDirections->getGfxReal()-0.5), 
 
910
                        //(mpRndDirections->getGfxReal()-0.5),  
 
911
                        //(mpRndDirections->getGfxReal()-0.5) ); 
 
912
//} 
 
913
 
870
914