Sorry for the big commit, but I've been fixing many of these
authorNils Thuerey <nils@thuerey.de>
Mon, 27 Feb 2006 11:45:42 +0000 (11:45 +0000)
committerNils Thuerey <nils@thuerey.de>
Mon, 27 Feb 2006 11:45:42 +0000 (11:45 +0000)
issues in parallel... So this commit contains: an update of
the solver (e.g. moving objects), integration of blender IPOs,
improved rendering (motion blur, smoothed normals) and a first particle
test. In more detail:

Solver update:
- Moving objects using a relatively simple model, and not yet fully optimized - ok
  for box falling into water, water in a moving glass might cause trouble. Simulation
  times are influenced by overall no. of triangles of the mesh, scaling meshes up a lot
  might also cause slowdowns.
- Additional obstacle settings: noslip (as before), free slip (move along wall freely)
  and part slip (mix of both).
- Obstacle settings also added for domain boundaries now, the six walls of the domain are
  obstacles after all as well
- Got rid of templates, should make compiling for e.g. macs more convenient,
  for linux there's not much difference. Finally got rid of parser (and some other code
  parts), the simulation now uses the internal API to transfer data.
- Some unnecessary file were removed, the GUI now needs 3 settings buttons...
  This should still be changed (maybe by adding a new panel for domain objects).

IPOs:
- Animated params: viscosity, time and gravity for domains. In contrast
  to normal time IPO for Blender objects, the fluidsim one scales the time
  step size - so a constant 1 has no effect, values towards 0 slow it down,
  larger ones speed the simulation up (-> longer time steps, more compuations).
  The viscosity IPO is also only a factor for the selected viscosity (again, 1=no effect).
- For objects that are enabled for fluidsim, a new IPO type shows up. Inflow
  objects can use the velocity channels to animate the inflow. Obstacles, in/outflow
  objects can be switched on (Active IPO>0) and off (<0) during the simulation.
- Movement, rotation and scaling of those 3 types is exported from the normal
  Blender channels (Loc,dLoc,etc.).

Particles:
- This is still experimental, so it might be deactivated for a
  release... It should at some point be used to model smaller splashes,
  depending on the the realworld size and the particle generation
  settings particles are generated during simulation (stored in _particles_X.gz
  files).
- These are loaded by enabling the particle field for an arbitrary object,
  which should be given a halo material. For each frame, similar to the mesh
  loading, the particle system them loads the simulated particle positions.
- For rendering, I "abused" the part->rt field - I couldnt find any use
  for it in the code and it seems to work fine. The fluidsim particles
  store their size there.

Rendering:
- The fluidims particles use scaled sizes and alpha values to give a more varied
  appearance. In convertblender.c fluidsim particle systems use the p->rt field
  to scale up the size and down the alpha of "smaller particles". Setting the
  influence fields in the fluidims settings to 0 gives equally sized particles
  with same alpha everywhere. Higher values cause larger differences.
- Smoothed normals: for unmodified fluid meshes (e.g. no subdivision) the normals
  computed by the solver are used. This is basically done by switching off the
  normal recalculation in convertblender.c (the function calc_fluidsimnormals
  handles other mesh inits instead of calc_vertexnormals).
  This could also be used to e.g. modify mesh normals in a modifier...
- Another change is that fluidsim meshes load the velocities computed
  during the simulation for image based motion blur. This is inited in
  load_fluidsimspeedvectors for the vector pass (they're loaded during the
  normal load in DerivedMesh readBobjgz). Generation and loading can be switched
  off in the settings. Vector pass currently loads the fluidism meshes 3 times,
  so this should still be optimized.

Examples:
- smoothed normals versus normals from subdividing once:
  http://www10.informatik.uni-erlangen.de/~sinithue/temp/v060227_1smoothnorms.png
  http://www10.informatik.uni-erlangen.de/~sinithue/temp/v060227_2subdivnorms.png
- fluidsim particles, size/alpha influence 0:
  http://www10.informatik.uni-erlangen.de/~sinithue/temp/v060227_3particlesnorm.png
  size influence 1:
  http://www10.informatik.uni-erlangen.de/~sinithue/temp/v060227_4particlessize.png
  size & alpha influence 1:
  http://www10.informatik.uni-erlangen.de/~sinithue/temp/v060227_5particlesalpha.png
- the standard drop with motion blur and particles:
  http://www10.informatik.uni-erlangen.de/~sinithue/temp/elbeemupdate_t2new.mpg
  (here's how it looks without
  http://www10.informatik.uni-erlangen.de/~sinithue/temp/elbeemupdate_t1old.mpg)
- another inflow animation (moving, switched on/off) with a moving obstacle
  (and strong mblur :)
  http://www10.informatik.uni-erlangen.de/~sinithue/temp/elbeemupdate_t3ipos.mpg

Things still to fix:
- rotating & scaling domains causes wrong speed vectors
- get rid of SDL code for threading, use pthreads as well?
- update wiki documentation
- cool effects for rendering would be photon maps for caustics,
  and motion blur for particles :)

70 files changed:
intern/elbeem/SConscript
intern/elbeem/extern/LBM_fluidsim.h
intern/elbeem/intern/attributes.cpp
intern/elbeem/intern/attributes.h
intern/elbeem/intern/blendercall.cpp [deleted file]
intern/elbeem/intern/blenderdummy.cpp [deleted file]
intern/elbeem/intern/cfglexer.cpp
intern/elbeem/intern/cfgparser.cpp
intern/elbeem/intern/cfgparser.h
intern/elbeem/intern/elbeem.cpp
intern/elbeem/intern/elbeem.h
intern/elbeem/intern/globals.h [deleted file]
intern/elbeem/intern/isosurface.cpp
intern/elbeem/intern/isosurface.h
intern/elbeem/intern/ntl_blenderdumper.cpp
intern/elbeem/intern/ntl_bsptree.cpp
intern/elbeem/intern/ntl_bsptree.h
intern/elbeem/intern/ntl_geometryclass.h
intern/elbeem/intern/ntl_geometrymodel.cpp
intern/elbeem/intern/ntl_geometryobject.cpp
intern/elbeem/intern/ntl_geometryobject.h
intern/elbeem/intern/ntl_geometryshader.h
intern/elbeem/intern/ntl_lighting.cpp [moved from intern/elbeem/intern/ntl_lightobject.cpp with 78% similarity]
intern/elbeem/intern/ntl_lighting.h [moved from intern/elbeem/intern/ntl_material.h with 73% similarity]
intern/elbeem/intern/ntl_lightobject.h [deleted file]
intern/elbeem/intern/ntl_matrices.h
intern/elbeem/intern/ntl_ray.cpp
intern/elbeem/intern/ntl_ray.h
intern/elbeem/intern/ntl_renderglobals.h [deleted file]
intern/elbeem/intern/ntl_rndstream.h [deleted file]
intern/elbeem/intern/ntl_scene.cpp [deleted file]
intern/elbeem/intern/ntl_scene.h [deleted file]
intern/elbeem/intern/ntl_triangle.h [deleted file]
intern/elbeem/intern/ntl_vector3dim.h
intern/elbeem/intern/ntl_world.cpp
intern/elbeem/intern/ntl_world.h
intern/elbeem/intern/parametrizer.cpp
intern/elbeem/intern/parametrizer.h
intern/elbeem/intern/particletracer.cpp
intern/elbeem/intern/particletracer.h
intern/elbeem/intern/simulation_object.cpp
intern/elbeem/intern/simulation_object.h
intern/elbeem/intern/solver_class.h
intern/elbeem/intern/solver_dimenions.h [deleted file]
intern/elbeem/intern/solver_init.cpp
intern/elbeem/intern/solver_interface.cpp
intern/elbeem/intern/solver_interface.h
intern/elbeem/intern/solver_main.cpp
intern/elbeem/intern/solver_relax.h
intern/elbeem/intern/solver_util.cpp
intern/elbeem/intern/utilities.cpp
intern/elbeem/intern/utilities.h
source/blender/blenkernel/intern/DerivedMesh.c
source/blender/blenkernel/intern/depsgraph.c
source/blender/blenkernel/intern/effect.c
source/blender/blenkernel/intern/ipo.c
source/blender/blenloader/intern/readfile.c
source/blender/include/BSE_editipo.h
source/blender/include/butspace.h
source/blender/makesdna/DNA_ID.h
source/blender/makesdna/DNA_ipo_types.h
source/blender/makesdna/DNA_object_fluidsim.h
source/blender/render/intern/source/convertblender.c
source/blender/src/buttons_object.c
source/blender/src/drawobject.c
source/blender/src/editipo.c
source/blender/src/editipo_lib.c
source/blender/src/editipo_mods.c
source/blender/src/fluidsim.c
source/blender/src/header_ipo.c

index 8c1aa59170c6ac1f9873547121313bf04e0f563d..3044ecff0b73ff5d480196f328b29c88b3ed60c8 100644 (file)
@@ -1,21 +1,9 @@
 #!/usr/bin/python
 import sys
 import os
-Import('env')
-#if use_fluidsim=='false':
-#   # print "El'Beem Fluid Simulation Disabled..." # debug
-#   elbeem_env.Append (CPPPATH = user_options_dict['PNG_INCLUDE'])
-#   elbeem_env.Append (CPPPATH = user_options_dict['SDL_INCLUDE'])
-#   elbeem_env.Append(CPPDEFINES= 'ELBEEM_DUMMIES');
-#   # dummy interface build
-#   Sources = [ 
-#       "intern/utilities.cpp",
-#       "intern/blenderdummy.cpp"
-#           ]; # sources
+import('env')
 
 sources = env.Glob('intern/*.cpp')
-sources.remove('intern'+os.sep+'blenderdummy.cpp')
 
 defs = 'NOGUI ELBEEM_BLENDER=1'
 if env['OURPLATFORM']=='win32-vc':
index ff0b0a465dde38e2c6fde55e29ce61140dabce58..b879dd4139627ae5577fb1d8a8aa9d515a2d11c4 100644 (file)
@@ -53,7 +53,7 @@ void fluidsimBake(struct Object* ob);
 
 /* read & write bobj / bobj.gz files (e.g. for fluid sim surface meshes) */
 void writeBobjgz(char *filename, struct Object *ob);
-struct Mesh* readBobjgz(char *filename, struct Mesh *orgmesh);
+struct Mesh* readBobjgz(char *filename, struct Mesh *orgmesh, float* bbstart, float *bbsize);
 
 /* create derived mesh for fluid sim objects */
 // WARNING - currently implemented in DerivedMesh.c!
@@ -66,7 +66,7 @@ int performElbeemSimulation(char *cfgfilename);
 /* init axis aligned BB for mesh object */
 // implemented in source/blender/blenkernel/intern/DerivedMesh.c
 void fluidsimGetAxisAlignedBB(struct Mesh *mesh, float obmat[][4],
-                /*RET*/ float start[3], /*RET*/ float size[3] );
+                /*RET*/ float start[3], /*RET*/ float size[3], /*RET*/ struct Mesh **bbmesh );
 
 // implemented in intern/elbeem/utilities.cpp
 /* set elbeem debug output level (0=off to 10=full on) */
index 8689a3fe98ed978daf8325aef74b7ddd645a2e50..abdd931a4bfe86a4e75427ed203a21834cc73389 100644 (file)
@@ -8,12 +8,17 @@
  *****************************************************************************/
 
 #include "attributes.h"
+#include "ntl_matrices.h"
+#include "elbeem.h"
 #include <sstream>
 
 
 //! output attribute values? on=1/off=0
 #define DEBUG_ATTRIBUTES 0
 
+//! output channel values? on=1/off=0
+#define DEBUG_CHANNELS 0
+
 
 /******************************************************************************
  * attribute conversion functions
@@ -70,20 +75,19 @@ bool Attribute::initChannel(int elemSize) {
        mValue = newvalue;
 
        mChannelInited = elemSize;
-       print();
+       if(DEBUG_CHANNELS) print();
        return true;
 }
 
 // get value as string 
-string Attribute::getAsString()
+string Attribute::getAsString(bool debug)
 {
-       if(mIsChannel) {
+       if(mIsChannel && (!debug)) {
                errMsg("Attribute::getAsString", "Attribute \"" << mName << "\" used as string is a channel! Not allowed...");
                print();
                return string("");
        }
        if(mValue.size()!=1) {
-               //errMsg("Attribute::getAsString", "Attribute \"" << mName << "\" used as string has invalid value '"<< getCompleteString() <<"' ");
                // for directories etc. , this might be valid! cutoff "..." first
                string comp = getCompleteString();
                if(comp.size()<2) return string("");
@@ -215,7 +219,7 @@ ntlVec3d Attribute::getAsVec3d()
 }
                
 // get value as 4x4 matrix 
-ntlMat4Gfx Attribute::getAsMat4Gfx()
+void Attribute::getAsMat4Gfx(ntlMat4Gfx *mat)
 {
        bool success = true;
        ntlMat4Gfx ret(0.0);
@@ -265,9 +269,10 @@ ntlMat4Gfx Attribute::getAsMat4Gfx()
 #if ELBEEM_PLUGIN!=1
                gElbeemState = -4; // parse error
 #endif
-               return ntlMat4Gfx(0.0);
+               *mat = ntlMat4Gfx(0.0);
+               return;
        }
-       return ret;
+       *mat = ret;
 }
                
 
@@ -355,7 +360,7 @@ bool AttributeList::checkUnusedParams()
                        i != mAttrs.end(); i++) {
                if((*i).second) {
                        if(!(*i).second->getUsed()) {
-                               errMsg("AttributeList::checkUnusedParams", "List "<<mName<<" has unknown parameter '"<<(*i).first<<"' = '"<< mAttrs[(*i).first]->getAsString() <<"' ");
+                               errMsg("AttributeList::checkUnusedParams", "List "<<mName<<" has unknown parameter '"<<(*i).first<<"' = '"<< mAttrs[(*i).first]->getAsString(true) <<"' ");
                                found = true;
                        }
                }
@@ -409,7 +414,7 @@ string AttributeList::readString(string name, string defaultValue, string source
        } 
        if(DEBUG_ATTRIBUTES==1) { debugOut( source << " Var '"<< target <<"' set to '"<< find(name)->getCompleteString() <<"' as type int " , 3); }
        find(name)->setUsed(true);
-       return find(name)->getAsString(); 
+       return find(name)->getAsString(false); 
 }
 ntlVec3d AttributeList::readVec3d(string name, ntlVec3d defaultValue, string source,string target, bool needed) {
        if(!exists(name)) {
@@ -421,14 +426,16 @@ ntlVec3d AttributeList::readVec3d(string name, ntlVec3d defaultValue, string sou
        return find(name)->getAsVec3d(); 
 }
 
-ntlMat4Gfx AttributeList::readMat4Gfx(string name, ntlMat4Gfx defaultValue, string source,string target, bool needed) {
+void AttributeList::readMat4Gfx(string name, ntlMat4Gfx defaultValue, string source,string target, bool needed, ntlMat4Gfx *mat) {
        if(!exists(name)) {
                if(needed) { errFatal("AttributeList::readInt","Required attribute '"<<name<<"' for "<< source <<"  not set! ", SIMWORLD_INITERROR); }
-               return defaultValue;
+               *mat = defaultValue;
+               return;
        } 
        if(DEBUG_ATTRIBUTES==1) { debugOut( source << " Var '"<< target <<"' set to '"<< find(name)->getCompleteString() <<"' as type int " , 3); }
        find(name)->setUsed(true);
-       return find(name)->getAsMat4Gfx(); 
+       find(name)->getAsMat4Gfx( mat ); 
+       return;
 }
 
 // set that a parameter can be given, and will be ignored...
@@ -442,15 +449,39 @@ bool AttributeList::ignoreParameter(string name, string source) {
 // read channels
 AnimChannel<double> AttributeList::readChannelFloat(string name) {
        if(!exists(name)) { return AnimChannel<double>(0.0); } 
-       return find(name)->getChannelFloat(); 
+       AnimChannel<double> ret = find(name)->getChannelFloat(); 
+       find(name)->setUsed(true);
+       channelSimplifyd(ret);
+       return ret;
 }
 AnimChannel<int> AttributeList::readChannelInt(string name) {
        if(!exists(name)) { return AnimChannel<int>(0); } 
-       return find(name)->getChannelInt(); 
+       AnimChannel<int> ret = find(name)->getChannelInt(); 
+       find(name)->setUsed(true);
+       channelSimplifyi(ret);
+       return ret;
 }
 AnimChannel<ntlVec3d> AttributeList::readChannelVec3d(string name) {
        if(!exists(name)) { return AnimChannel<ntlVec3d>(0.0); } 
-       return find(name)->getChannelVec3d(); 
+       AnimChannel<ntlVec3d> ret = find(name)->getChannelVec3d(); 
+       find(name)->setUsed(true);
+       channelSimplifyVd(ret);
+       return ret;
+}
+AnimChannel<ntlVec3f> AttributeList::readChannelVec3f(string name) {
+       if(!exists(name)) { return AnimChannel<ntlVec3f>(0.0); } 
+
+       AnimChannel<ntlVec3d> convert = find(name)->getChannelVec3d(); 
+       // convert to float
+       vector<ntlVec3f> vals;
+       for(size_t i=0; i<convert.accessValues().size(); i++) {
+               vals.push_back( vec2F(convert.accessValues()[i]) );
+       }
+       vector<double> times = convert.accessTimes();
+       AnimChannel<ntlVec3f> ret(vals, times);
+       find(name)->setUsed(true);
+       channelSimplifyVf(ret);
+       return ret;
 }
 
 /******************************************************************************
@@ -509,7 +540,6 @@ void AttributeList::print()
 }
 
 
-
 /******************************************************************************
  * import attributes from other attribute list
  *****************************************************************************/
@@ -526,5 +556,133 @@ void AttributeList::import(AttributeList *oal)
 }
 
 
+/******************************************************************************
+ * channel max finding
+ *****************************************************************************/
+ntlVec3f channelFindMaxVf (AnimChannel<ntlVec3f> channel) {
+       ntlVec3f ret(0.0);
+       float maxLen = 0.0;
+       for(size_t i=0; i<channel.accessValues().size(); i++) {
+               float nlen = normNoSqrt(channel.accessValues()[i]);
+               if(nlen>maxLen) { ret=channel.accessValues()[i]; maxLen=nlen; }
+       }
+       return ret;
+}
+ntlVec3d channelFindMaxVd (AnimChannel<ntlVec3d> channel) {
+       ntlVec3d ret(0.0);
+       float maxLen = 0.0;
+       for(size_t i=0; i<channel.accessValues().size(); i++) {
+               float nlen = normNoSqrt(channel.accessValues()[i]);
+               if(nlen>maxLen) { ret=channel.accessValues()[i]; maxLen=nlen; }
+       }
+       return ret;
+}
+int      channelFindMaxi  (AnimChannel<float   > channel) {
+       int ret = 0;
+       float maxLen = 0.0;
+       for(size_t i=0; i<channel.accessValues().size(); i++) {
+               float nlen = ABS(channel.accessValues()[i]);
+               if(nlen>maxLen) { ret= (int)channel.accessValues()[i]; maxLen=nlen; }
+       }
+       return ret;
+}
+float    channelFindMaxf  (AnimChannel<float   > channel) {
+       float ret = 0.0;
+       float maxLen = 0.0;
+       for(size_t i=0; i<channel.accessValues().size(); i++) {
+               float nlen = ABS(channel.accessValues()[i]);
+               if(nlen>maxLen) { ret=channel.accessValues()[i]; maxLen=nlen; }
+       }
+       return ret;
+}
+double   channelFindMaxd  (AnimChannel<double  > channel) {
+       double ret = 0.0;
+       float maxLen = 0.0;
+       for(size_t i=0; i<channel.accessValues().size(); i++) {
+               float nlen = ABS(channel.accessValues()[i]);
+               if(nlen>maxLen) { ret=channel.accessValues()[i]; maxLen=nlen; }
+       }
+       return ret;
+}
+
+/******************************************************************************
+ // unoptimized channel simplification functions, use elbeem.cpp functions
+ // warning - currently only with single precision
+ *****************************************************************************/
+
+template<class SCALAR>
+static bool channelSimplifyScalarT(AnimChannel<SCALAR> &channel) {
+       int   size = channel.getSize();
+       if(size<=1) return false;
+       float *nchannel = new float[2*size];
+       if(DEBUG_CHANNELS) errMsg("channelSimplifyf","S" << channel.printChannel() );
+       // convert to array
+       for(size_t i=0; i<channel.accessValues().size(); i++) {
+               nchannel[i*2 + 0] = (float)channel.accessValues()[i];
+               nchannel[i*2 + 1] = (float)channel.accessTimes()[i];
+       }
+       bool ret = elbeemSimplifyChannelFloat(nchannel, &size);
+       if(ret) {
+               vector<SCALAR> vals;
+               vector<double> times;
+               for(int i=0; i<size; i++) {
+                       vals.push_back(  (SCALAR)(nchannel[i*2 + 0]) );
+                       times.push_back( (double)(nchannel[i*2 + 1]) );
+               }
+               channel = AnimChannel<SCALAR>(vals, times);
+               if(DEBUG_CHANNELS) errMsg("channelSimplifyf","C" << channel.printChannel() );
+       }
+       delete [] nchannel;
+       return ret;
+}
+bool channelSimplifyi  (AnimChannel<int   > &channel) { return channelSimplifyScalarT<int>(channel); }
+bool channelSimplifyf  (AnimChannel<float> &channel) { return channelSimplifyScalarT<float>(channel); }
+bool channelSimplifyd  (AnimChannel<double  > &channel) { return channelSimplifyScalarT<double>(channel); }
+template<class VEC>
+static bool channelSimplifyVecT(AnimChannel<VEC> &channel) {
+       int   size = channel.getSize();
+       if(size<=1) return false;
+       float *nchannel = new float[4*size];
+       if(DEBUG_CHANNELS) errMsg("channelSimplifyf","S" << channel.printChannel() );
+       // convert to array
+       for(size_t i=0; i<channel.accessValues().size(); i++) {
+               nchannel[i*4 + 0] = (float)channel.accessValues()[i][0];
+               nchannel[i*4 + 1] = (float)channel.accessValues()[i][1];
+               nchannel[i*4 + 2] = (float)channel.accessValues()[i][2];
+               nchannel[i*4 + 3] = (float)channel.accessTimes()[i];
+       }
+       bool ret = elbeemSimplifyChannelVec3(nchannel, &size);
+       if(ret) {
+               vector<VEC> vals;
+               vector<double> times;
+               for(int i=0; i<size; i++) {
+                       vals.push_back(  VEC(nchannel[i*4 + 0], nchannel[i*4 + 1], nchannel[i*4 + 2] ) );
+                       times.push_back( (double)(nchannel[i*4 + 3]) );
+               }
+               channel = AnimChannel<VEC>(vals, times);
+               if(DEBUG_CHANNELS) errMsg("channelSimplifyf","C" << channel.printChannel() );
+       }
+       delete [] nchannel;
+       return ret;
+}
+bool channelSimplifyVf (AnimChannel<ntlVec3f> &channel) {
+       return channelSimplifyVecT<ntlVec3f>(channel);
+}
+bool channelSimplifyVd (AnimChannel<ntlVec3d> &channel) {
+       return channelSimplifyVecT<ntlVec3d>(channel);
+}
+
+template<class Scalar>
+string AnimChannel<Scalar>::printChannel() {
+       std::ostringstream ostr;
+       ostr << " CHANNEL #"<<  mValue.size() <<" = { ";
+       for(size_t i=0;i<mValue.size();i++) {
+               ostr <<"'"<< mValue[i]<<"' ";
+               ostr << "@"<<mTimes[i]<<"; ";
+       }
+       ostr << " } ";
+       return ostr.str();
+} // */
+
 
 
index f9f44e2eb52786432a4df9259eafd3dbb75d559c..730e136f962cb8a328762ae100617bdcd7785fce 100644 (file)
@@ -11,7 +11,7 @@
 #ifndef NTL_ATTRIBUTES_H
 
 #include "utilities.h"
-#include "ntl_matrices.h"
+template<class T> class ntlMatrix4x4;
 
 
 //! An animated attribute channel
@@ -19,19 +19,24 @@ template<class Scalar>
 class AnimChannel
 {
        public:
+               // default constructor
+               AnimChannel() : 
+                       mValue(), mTimes() { mInited = false; }
+
                // null init constructor
                AnimChannel(Scalar null) : 
-                       mValue(1), mTimes(1) { mValue[0]=null; mTimes[0]=0.0; };
+                       mValue(1), mTimes(1) { mValue[0]=null; mTimes[0]=0.0; mInited = true; }
 
                // proper init
                AnimChannel(vector<Scalar> v, vector<double> t) : 
-                       mValue(v), mTimes(t) { };
+                       mValue(v), mTimes(t) { mInited = true; }
 
                // desctructor, nothing to do
                ~AnimChannel() { };
 
                // get interpolated value at time t
                Scalar get(double t) {
+                       if(!mInited) { Scalar null; null=(Scalar)(0.0); return null; }
                        if(t<=mTimes[0])               { return mValue[0]; }
                        if(t>=mTimes[mTimes.size()-1]) { return mValue[mTimes.size()-1]; }
                        for(size_t i=0; i<mTimes.size()-1; i++) {
@@ -40,7 +45,7 @@ class AnimChannel
                                        // interpolate
                                        double d = mTimes[i+1]-mTimes[i];
                                        double f = (t-mTimes[i])/d;
-                                       return mValue[i] * (1.0-f) + mValue[i+1] * f;
+                                       return (Scalar)(mValue[i] * (1.0-f) + mValue[i+1] * f);
                                }
                        }
                        // whats this...?
@@ -50,6 +55,7 @@ class AnimChannel
                // get uninterpolated value at time t
                Scalar getConstant(double t) {
                        //errMsg("DEBB","getc"<<t<<" ");
+                       if(!mInited) { Scalar null; null=(Scalar)0.0; return null; }
                        if(t<=mTimes[0])               { return mValue[0]; }
                        if(t>=mTimes[mTimes.size()-1]) { return mValue[mTimes.size()-1]; }
                        for(size_t i=0; i<mTimes.size()-1; i++) {
@@ -69,14 +75,29 @@ class AnimChannel
                        mTimes.push_back(0.0);
                }
 
+               //! debug function, prints channel as string
+               string printChannel();
+               //! valid init?
+               bool isInited() { return mInited; }
+
+               //! get number of entries (value and time sizes have to be equal)
+               int getSize() { return mValue.size(); };
+               //! raw access of value vector
+               vector<Scalar> &accessValues() { return mValue; }
+               //! raw access of time vector
+               vector<double> &accessTimes() { return mTimes; }
+               
        protected:
 
+               /*! inited at least once? */
+               bool mInited;
                /*! anim channel attribute values */
                vector<Scalar> mValue;
                /*! anim channel attr times */
                vector<double> mTimes;
 };
 
+
 //! A single attribute
 class Attribute
 {
@@ -106,7 +127,7 @@ class Attribute
                bool getIsChannel() { return mIsChannel; }
 
                //! get value as string 
-               string getAsString();
+               string getAsString(bool debug=false);
                //! get value as integer value
                int getAsInt();
                //! get value as boolean
@@ -116,13 +137,13 @@ class Attribute
                //! get value as 3d vector 
                ntlVec3d getAsVec3d();
                //! get value as 4x4 matrix
-               ntlMat4Gfx getAsMat4Gfx();
+               void getAsMat4Gfx(ntlMatrix4x4<gfxReal> *mat);
 
                //! get channel as integer value
                AnimChannel<int> getChannelInt();
                //! get channel as double value
                AnimChannel<double> getChannelFloat();
-               //! get channel as double value
+               //! get channel as double vector
                AnimChannel<ntlVec3d> getChannelVec3d();
 
                //! get the concatenated string of all value string
@@ -207,11 +228,12 @@ class AttributeList
                double   readFloat(string name, double defaultValue,   string source,string target, bool needed);
                string   readString(string name, string defaultValue,   string source,string target, bool needed);
                ntlVec3d readVec3d(string name, ntlVec3d defaultValue,  string source,string target, bool needed);
-               ntlMat4Gfx readMat4Gfx(string name, ntlMat4Gfx defaultValue,  string source,string target, bool needed);
+               void readMat4Gfx(string name, ntlMatrix4x4<gfxReal> defaultValue,  string source,string target, bool needed, ntlMatrix4x4<gfxReal> *mat);
                //! read attributes channels (attribute should be inited before)
                AnimChannel<int>     readChannelInt(string name);
                AnimChannel<double>  readChannelFloat(string name);
                AnimChannel<ntlVec3d> readChannelVec3d(string name);
+               AnimChannel<ntlVec3f> readChannelVec3f(string name);
 
                //! set that a parameter can be given, and will be ignored...
                bool ignoreParameter(string name, string source);
@@ -229,6 +251,19 @@ class AttributeList
 
 };
 
+ntlVec3f channelFindMaxVf (AnimChannel<ntlVec3f> channel);
+ntlVec3d channelFindMaxVd (AnimChannel<ntlVec3d> channel);
+int      channelFindMaxi  (AnimChannel<int     > channel);
+float    channelFindMaxf  (AnimChannel<float   > channel);
+double   channelFindMaxd  (AnimChannel<double  > channel);
+
+// unoptimized channel simplification functions, use elbeem.cpp functions
+bool channelSimplifyVf (AnimChannel<ntlVec3f> &channel);
+bool channelSimplifyVd (AnimChannel<ntlVec3d> &channel);
+bool channelSimplifyi  (AnimChannel<int     > &channel);
+bool channelSimplifyf  (AnimChannel<float   > &channel);
+bool channelSimplifyd  (AnimChannel<double  > &channel);
+
 #define NTL_ATTRIBUTES_H
 #endif
 
diff --git a/intern/elbeem/intern/blendercall.cpp b/intern/elbeem/intern/blendercall.cpp
deleted file mode 100644 (file)
index f1617da..0000000
+++ /dev/null
@@ -1,44 +0,0 @@
-/******************************************************************************
- *
- * El'Beem - Free Surface Fluid Simulation with the Lattice Boltzmann Method
- * All code distributed as part of El'Beem is covered by the version 2 of the 
- * GNU General Public License. See the file COPYING for details.
- * Copyright 2003-2005 Nils Thuerey
- *
- * Blender call interface
- *
- *****************************************************************************/
-#include "globals.h"
-#include "utilities.h"
-#include "ntl_blenderdumper.h"
-#include <stdlib.h>
-
-// ELBEEM_BLENDER always =1 here
-extern "C" void elbeemCheckDebugEnv(void);
-
-extern "C" 
-int performElbeemSimulation(char *cfgfilename) {
-       gElbeemState = SIMWORLD_INVALID;
-       strcpy(gElbeemErrorString,"[none]");
-
-       //if(gDebugLevel>0) {
-       elbeemCheckDebugEnv();
-       debMsgStd("performElbeemSimulation",DM_NOTIFY,"Running El'Beem from Blender with file '"<< cfgfilename <<"', debugLevel:"<<gDebugLevel<<" ...\n", 2);
-       //}
-       // load given file in command line mode
-       ntlBlenderDumper elbeem(cfgfilename, true);
-       if(SIMWORLD_OK()) {
-               gElbeemState = SIMWORLD_INITED;
-               myTime_t timestart = getTime();
-               elbeem.renderAnimation();
-               myTime_t timeend = getTime();
-               debMsgStd("performElbeemSimulation",DM_NOTIFY, "El'Beem simulation done, time: "<<((timeend-timestart)/(double)1000.0) <<" seconds.\n", 2 ); 
-       } else {
-               // signal there was an initialization problem
-               setGlobalBakeState( -2 );
-       }
-       return 1;
-};
-
-
diff --git a/intern/elbeem/intern/blenderdummy.cpp b/intern/elbeem/intern/blenderdummy.cpp
deleted file mode 100644 (file)
index 4d672de..0000000
+++ /dev/null
@@ -1,19 +0,0 @@
-/******************************************************************************
- *
- * El'Beem - Free Surface Fluid Simulation with the Lattice Boltzmann Method
- * All code distributed as part of El'Beem is covered by the version 2 of the 
- * GNU General Public License. See the file COPYING for details.
- * Copyright 2003-2005 Nils Thuerey
- *
- * Blender call for disabled fluidsim
- *
- *****************************************************************************/
-#include <stdlib.h>
-
-extern "C" 
-int performElbeemSimulation(char *cfgfilename) {
-       return 1;
-};
-
-
index 472c692945111eaa05abda780fb238d8fedc855f..0bc9d96b5b23e98ec1f5ff3516de466a111c9d9c 100644 (file)
@@ -430,16 +430,16 @@ static yyconst flex_int32_t yy_ec[256] =
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    4,    1,    5,    6,    1,    1,    1,    1,    1,
-        1,    7,    1,    1,    8,    9,   10,   11,   11,   11,
-       11,   11,   11,   11,   11,   11,   11,   12,   13,    1,
-       14,    1,    1,    1,   17,   18,   19,   20,   21,   22,
-       23,   24,   25,   26,   27,   28,   29,   30,   31,   32,
-       33,   34,   35,   36,   37,   38,   39,   40,   41,   33,
-        1,   15,    1,    1,   16,    1,   17,   18,   19,   20,
-
-       21,   22,   23,   24,   25,   26,   27,   28,   29,   30,
-       31,   32,   33,   34,   35,   36,   37,   38,   39,   40,
-       41,   33,   42,    1,   43,    1,    1,    1,    1,    1,
+        1,    7,    8,    1,    9,   10,   11,   12,   12,   12,
+       12,   12,   12,   12,   12,   12,   12,   13,   14,    1,
+       15,    1,    1,    1,   18,   19,   20,   21,   22,   23,
+       24,   25,   26,   27,   28,   29,   30,   31,   32,   33,
+       34,   35,   36,   37,   38,   39,   40,   41,   42,   34,
+        1,   16,    1,    1,   17,    1,   18,   19,   20,   21,
+
+       22,   23,   24,   25,   26,   27,   28,   29,   30,   31,
+       32,   33,   34,   35,   36,   37,   38,   39,   40,   41,
+       42,   34,   43,    1,   44,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
@@ -456,103 +456,103 @@ static yyconst flex_int32_t yy_ec[256] =
         1,    1,    1,    1,    1
     } ;
 
-static yyconst flex_int32_t yy_meta[44] =
+static yyconst flex_int32_t yy_meta[45] =
     {   0,
-        1,    2,    3,    4,    1,    1,    1,    5,    6,    5,
-        6,    5,    2,    1,    5,    6,    6,    6,    6,    6,
+        1,    2,    3,    4,    1,    1,    1,    5,    5,    6,
+        5,    6,    5,    2,    1,    5,    6,    6,    6,    6,
         6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
         6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
-        6,    1,    1
+        6,    6,    1,    1
     } ;
 
-static yyconst flex_int16_t yy_base[576] =
+static yyconst flex_int16_t yy_base[575] =
     {   0,
-        0,    0,   43,   86,  128,  170,  704,  705,   60,  705,
-       63,    0,    0,   43,  692,   53,   50,   47,   53,   78,
-       47,   39,   87,  681,   43,   82,   54,   80,  117,   92,
-       93,  112,  116,  669,   99,  123,  138,  149,  152,    0,
-      141,    0,  695,  156,  101,  705,  157,  160,  163,  175,
-      180,  694,    0,  687,  176,  686,  705,    0,  177,  660,
-      677,  153,  662,  657,  673,  101,  651,  161,   46,  175,
-      178,  670,  668,  660,  659,  649,  647,  186,  653,  645,
-      651,  658,  649,  168,  645,  649,  648,  650,  653,  644,
-      705,  652,  641,  174,  630,  192,  653,  131,  652,  633,
-
-      198,  635,  628,  631,  629,  214,  219,  222,  226,    0,
-      227,    0,  658,  657,  230,    0,  235,  705,    0,  636,
-      635,  146,  634,  637,  623,  629,  625,  624,  705,  617,
-      617,  620,  618,  612,  623,  619,  624,  705,  613,  609,
-      622,  617,  600,  611,  604,  609,  616,  601,  611,  607,
-      612,  598,  597,  609,  206,  600,  705,  603,  597,  596,
-      584,  599,  587,  601,  587,  600,  588,  598,  598,  595,
-      581,  578,  583,  591,  590,  589,  588,  572,  582,  238,
-      568,  584,  570,  567,  585,  582,  575,  576,  578,  567,
-      561,  559,  183,  577,  570,  562,  570,  553,  558,  567,
-
-      216,  567,  705,  565,  555,  563,  549,  545,  545,  563,
-      545,  561,  546,  705,  545,  554,  543,  705,  550,  549,
-      548,  534,  535,  543,  550,  545,  537,  533,  526,  528,
-      525,  531,  524,  529,  705,  705,  538,  535,  537,  533,
-      523,  535,  534,  522,  513,  530,  513,  525,  705,  521,
-      519,  705,  509,  508,  221,  520,  521,  504,  513,  705,
-      506,  519,  507,  499,  512,  496,  495,  496,  705,  493,
-      503,  486,  492,  497,  490,  503,  494,  705,  490,  495,
-      502,  480,  498,  482,  478,  475,  485,  491,  705,  480,
-      193,  493,  705,  469,  480,  705,  471,  477,  471,  479,
-
-      705,  466,  471,  467,  483,  480,  705,  477,  476,  465,
-      470,  478,  457,  471,  461,  470,  460,  470,  460,  458,
-      451,  705,  462,  705,  466,  462,  705,  440,  444,  458,
-      461,  447,  445,  456,  453,  448,  453,  435,  441,  452,
-      705,  448,  221,  450,  426,  705,  444,  436,  442,  426,
-      444,  424,  422,  441,  437,  227,  428,  417,  434,  413,
-      435,  417,  705,  414,  428,  427,  418,  421,  705,  404,
-      427,  415,  421,  418,  415,  411,  402,  705,  407,  411,
-      400,  404,  416,  407,  414,  396,  408,  408,  391,  392,
-      227,  705,  400,  219,  705,  389,  402,  392,  385,  389,
-
-      385,  394,  231,  399,  395,  394,  393,  377,  387,  705,
-      705,  705,  705,  379,  705,  391,  705,  377,  377,  388,
-      705,  370,  705,  375,  380,  383,  365,  370,  368,  705,
-      705,  374,  379,  376,  375,  361,  371,  705,  368,  705,
-      357,  371,  354,  350,  354,  356,  369,  351,  355,  355,
-      705,  354,  345,  361,  705,  358,  342,  347,  355,  341,
-      351,  356,  351,  336,  340,  351,  332,  336,  336,  333,
-      339,  339,  333,  705,  705,  327,  325,  342,  322,  325,
-      335,  705,  705,  705,  321,  705,  705,  330,  318,  317,
-      705,  705,  331,  310,  313,  705,  323,  322,  318,  326,
-
-      308,  326,  306,  320,  705,  705,  320,  308,  705,  308,
-      312,  705,  705,  705,  305,  705,  310,  317,  295,  705,
-      311,  307,  300,  705,  705,  236,  299,  305,  309,  287,
-      306,  289,  302,  705,  705,  299,  296,  296,  281,  274,
-      267,  264,  263,  705,  705,  269,  258,  261,  705,  267,
-      250,  705,  705,  245,  225,  222,  705,  212,  166,  705,
-      705,  155,  705,  705,  705,  268,  274,  277,  283,  113,
-      289,  295,  301,  307,  313
+        0,    0,   44,    0,   87,  130,  713,  714,   95,  714,
+      102,    0,    0,   84,  700,   96,   90,   85,   91,   92,
+       86,   83,  122,  689,   82,   85,  101,  111,  133,  118,
+      137,  128,  125,  677,  136,  124,  166,  167,  173,    0,
+      174,    0,  704,  177,  173,  714,  181,  185,  188,  191,
+      192,  703,    0,  695,  187,  694,  714,    0,  188,  668,
+      685,  175,  670,  665,  681,  180,  659,  167,  178,  190,
+      192,  678,  676,  668,  667,  657,  655,  200,  661,  653,
+      659,  666,  657,  182,  653,  657,  656,  658,  661,  652,
+      714,  660,  649,  191,  638,  205,  661,  199,  660,  641,
+
+      208,  643,  636,  639,  637,  231,  235,  236,  240,    0,
+      241,    0,  667,  666,  245,    0,  246,  714,    0,  644,
+      643,  229,  642,  645,  631,  637,  633,  632,  714,  625,
+      625,  628,  626,  620,  631,  627,  632,  714,  621,  617,
+      630,  625,  608,  619,  612,  617,  624,  609,  619,  615,
+      620,  606,  605,  617,  222,  608,  714,  611,  605,  604,
+      592,  607,  595,  609,  595,  608,  596,  606,  606,  603,
+      589,  586,  591,  599,  598,  597,  596,  580,  590,  252,
+      576,  592,  578,  575,  593,  590,  583,  584,  586,  575,
+      569,  567,  229,  585,  578,  570,  578,  561,  566,  575,
+
+      227,  575,  714,  573,  563,  571,  557,  553,  553,  571,
+      553,  569,  554,  714,  553,  562,  551,  714,  558,  557,
+      556,  542,  543,  551,  558,  553,  545,  541,  534,  536,
+      533,  539,  532,  537,  714,  714,  546,  543,  545,  541,
+      531,  543,  542,  530,  521,  538,  521,  533,  714,  529,
+      527,  714,  517,  516,  239,  528,  529,  512,  521,  714,
+      514,  527,  515,  507,  520,  504,  503,  504,  714,  501,
+      511,  494,  500,  505,  498,  511,  502,  714,  498,  503,
+      510,  488,  506,  490,  486,  483,  493,  499,  714,  488,
+      244,  501,  714,  477,  488,  714,  479,  485,  479,  487,
+
+      714,  474,  479,  475,  491,  488,  714,  485,  484,  473,
+      478,  486,  465,  479,  469,  478,  468,  478,  468,  466,
+      459,  714,  470,  714,  474,  470,  714,  448,  452,  466,
+      469,  455,  453,  464,  461,  456,  461,  443,  449,  460,
+      714,  456,  249,  458,  434,  714,  452,  444,  450,  434,
+      452,  432,  430,  449,  445,  245,  436,  425,  442,  421,
+      443,  425,  714,  422,  436,  435,  426,  429,  714,  412,
+      435,  423,  429,  426,  423,  419,  410,  714,  415,  419,
+      408,  412,  424,  415,  422,  404,  416,  416,  399,  400,
+      252,  714,  408,  238,  714,  397,  410,  400,  393,  397,
+
+      393,  402,  246,  407,  403,  402,  401,  385,  395,  714,
+      714,  714,  714,  387,  714,  399,  714,  385,  385,  396,
+      714,  378,  714,  383,  388,  391,  373,  378,  376,  714,
+      714,  382,  387,  384,  383,  369,  379,  714,  376,  714,
+      365,  379,  362,  358,  362,  364,  377,  359,  363,  363,
+      714,  362,  353,  369,  714,  366,  350,  355,  363,  349,
+      359,  364,  359,  344,  348,  359,  340,  344,  344,  341,
+      347,  347,  341,  714,  714,  335,  333,  350,  330,  333,
+      343,  714,  714,  714,  329,  714,  714,  338,  326,  325,
+      714,  714,  339,  318,  321,  714,  331,  330,  326,  334,
+
+      316,  334,  314,  328,  714,  714,  328,  316,  714,  316,
+      320,  714,  714,  714,  313,  714,  318,  325,  303,  714,
+      319,  315,  305,  714,  714,  261,  299,  300,  300,  278,
+      297,  277,  290,  714,  714,  287,  280,  268,  256,  254,
+      252,  252,  251,  714,  714,  256,  248,  231,  714,  228,
+      197,  714,  714,  207,  167,  149,  714,  150,  106,  714,
+      714,  101,  714,  714,  714,  294,  297,  303,   89,  309,
+      315,  321,  327,  333
     } ;
 
-static yyconst flex_int16_t yy_def[576] =
+static yyconst flex_int16_t yy_def[575] =
     {   0,
-      565,    1,  566,  566,  567,  567,  565,  565,  565,  565,
-      565,  568,  569,  565,  565,  565,  565,  565,  565,  565,
+      565,    1,  565,    3,  566,  566,  565,  565,  565,  565,
+      565,  567,  568,  565,  565,  565,  565,  565,  565,  565,
       565,  565,  565,  565,  565,  565,  565,  565,  565,  565,
-      565,  565,  565,  565,  565,  565,  565,  565,  565,  570,
-      565,  571,  572,  573,  571,  565,  571,  571,  565,  565,
-      565,  568,  569,  565,  565,  565,  565,  574,  565,  565,
+      565,  565,  565,  565,  565,  565,  565,  565,  565,  569,
+      565,  570,  571,  572,  570,  565,  570,  570,  565,  565,
+      565,  567,  568,  565,  565,  565,  565,  573,  565,  565,
       565,  565,  565,  565,  565,  565,  565,  565,  565,  565,
       565,  565,  565,  565,  565,  565,  565,  565,  565,  565,
       565,  565,  565,  565,  565,  565,  565,  565,  565,  565,
       565,  565,  565,  565,  565,  565,  565,  565,  565,  565,
 
-      565,  565,  565,  565,  565,  565,  565,  565,  565,  570,
-      565,  571,  572,  572,  573,  571,  575,  565,  574,  565,
+      565,  565,  565,  565,  565,  565,  565,  565,  565,  569,
+      565,  570,  571,  571,  572,  570,  574,  565,  573,  565,
       565,  565,  565,  565,  565,  565,  565,  565,  565,  565,
       565,  565,  565,  565,  565,  565,  565,  565,  565,  565,
       565,  565,  565,  565,  565,  565,  565,  565,  565,  565,
       565,  565,  565,  565,  565,  565,  565,  565,  565,  565,
       565,  565,  565,  565,  565,  565,  565,  565,  565,  565,
-      565,  565,  565,  565,  565,  565,  565,  565,  565,  575,
+      565,  565,  565,  565,  565,  565,  565,  565,  565,  574,
       565,  565,  565,  565,  565,  565,  565,  565,  565,  565,
       565,  565,  565,  565,  565,  565,  565,  565,  565,  565,
 
@@ -596,175 +596,177 @@ static yyconst flex_int16_t yy_def[576] =
       565,  565,  565,  565,  565,  565,  565,  565,  565,  565,
       565,  565,  565,  565,  565,  565,  565,  565,  565,  565,
       565,  565,  565,  565,    0,  565,  565,  565,  565,  565,
-      565,  565,  565,  565,  565
+      565,  565,  565,  565
     } ;
 
-static yyconst flex_int16_t yy_nxt[749] =
+static yyconst flex_int16_t yy_nxt[759] =
     {   0,
-        8,    9,   10,   11,   12,   13,    8,   14,   15,   16,
-       17,    8,    8,    8,    8,    8,   18,   19,   20,   21,
-       22,   23,   24,    8,   25,    8,    8,   26,   27,   28,
-       29,   30,    8,   31,   32,   33,   34,   35,    8,    8,
-        8,   36,   37,    8,   38,   10,   39,    8,   13,    8,
-        8,   54,   16,   55,    8,    8,   41,    8,   54,   57,
-       59,   49,   58,   49,   49,   60,   49,   70,   72,   65,
-       84,   71,   80,  132,  133,   61,   62,   81,   85,   73,
-       66,   63,   64,   67,   36,   37,    8,   38,   10,   39,
-        8,   13,    8,    8,   68,   16,   86,    8,    8,   41,
-
-        8,   50,   51,   74,   50,   51,   82,  116,   69,   95,
-      117,   75,   83,   96,   76,   93,   87,   77,  110,  104,
-       78,  127,   94,  105,  106,  128,  106,   36,   37,    9,
-       10,   11,   43,   44,   88,   97,  100,   45,   89,  107,
-       46,  107,  111,   98,  111,   90,   91,   99,   92,  101,
-      108,  169,  108,  108,  170,  108,  102,   53,  106,   53,
-      106,  107,  109,  107,   49,  109,   49,  183,   53,   47,
-       48,    9,   10,   11,   43,   44,  106,  122,  106,   45,
-      184,  107,   46,  107,   54,   54,   55,   59,  123,  564,
-       50,   51,  134,   50,   51,  130,  135,  131,  136,  137,
-
-      563,  161,  144,  151,   50,   51,  145,  152,  162,  343,
-      164,   47,   48,  165,  173,  106,  252,  106,  174,  253,
-      107,  166,  107,  108,  344,  108,  167,  111,  111,  111,
-      111,   53,  562,   53,  175,  109,  119,  215,  119,  119,
-      388,  119,   53,  216,  261,  262,  435,  119,  309,  310,
-      119,  401,  311,  438,  439,  537,  389,  561,  402,  447,
-      560,  403,  436,   50,   51,  559,  448,  538,   40,   40,
-       40,   40,   40,   40,   42,   42,   42,   42,   42,   42,
-       52,   52,   52,   53,   53,  558,   53,   53,   53,  112,
-      557,  556,  555,  112,  112,  113,  554,  553,  552,  113,
-
-      113,  115,  115,  551,  115,  115,  115,  119,  119,  550,
-      119,  119,  119,  180,  180,  549,  180,  180,  180,  548,
-      547,  546,  545,  544,  543,  542,  541,  540,  539,  536,
-      535,  534,  533,  532,  531,  530,  529,  528,  527,  526,
-      525,  524,  523,  522,  521,  520,  519,  518,  517,  516,
-      515,  514,  513,  512,  511,  510,  509,  508,  507,  506,
-      505,  504,  503,  502,  501,  500,  499,  498,  497,  496,
-      495,  494,  493,  492,  491,  490,  489,  488,  487,  486,
-      485,  484,  483,  482,  481,  480,  479,  478,  477,  476,
-      475,  474,  473,  472,  471,  470,  469,  468,  467,  466,
-
-      465,  464,  463,  462,  461,  460,  459,  458,  457,  456,
-      455,  454,  453,  452,  451,  450,  449,  446,  445,  444,
-      443,  442,  441,  440,  437,  434,  433,  432,  431,  430,
-      429,  428,  427,  426,  425,  424,  423,  422,  421,  420,
-      419,  418,  417,  416,  415,  414,  413,  412,  411,  410,
-      409,  408,  407,  406,  405,  404,  400,  399,  398,  397,
-      396,  395,  394,  393,  392,  391,  390,  387,  386,  385,
-      384,  383,  382,  381,  380,  379,  378,  377,  376,  375,
-      374,  373,  372,  371,  370,  369,  368,  367,  366,  365,
-      364,  363,  362,  361,  360,  359,  358,  357,  356,  355,
-
-      354,  353,  352,  351,  350,  349,  348,  347,  346,  345,
-      342,  341,  340,  339,  338,  337,  336,  335,  334,  333,
-      332,  331,  330,  329,  328,  327,  326,  325,  324,  323,
-      322,  321,  320,  319,  318,  317,  316,  315,  314,  313,
-      312,  308,  307,  306,  305,  304,  303,  302,  301,  300,
-      299,  298,  297,  296,  295,  294,  293,  292,  291,  290,
-      289,  288,  287,  286,  285,  284,  283,  282,  281,  280,
-      279,  278,  277,  276,  275,  274,  273,  272,  271,  270,
-      269,  268,  267,  266,  265,  264,  263,  260,  259,  258,
-      257,  256,  255,  254,  251,  250,  249,  248,  247,  246,
-
-      245,  244,  243,  242,  241,  240,  239,  238,  237,  236,
-      235,  234,  233,  232,  231,  230,  229,  228,  227,  226,
-      225,  224,  223,  222,  221,  220,  219,  218,  217,  214,
-      213,  212,  211,  210,  209,  208,  207,  206,  205,  204,
-      203,  202,  201,  200,  199,  198,  197,  196,  195,  194,
-      193,  192,  191,  190,  189,  188,  187,  186,  185,  182,
-      181,  114,  114,  179,  178,  177,  176,  172,  171,  168,
-      163,  160,  159,  158,  157,  156,  155,  154,  153,  150,
-      149,  148,  147,  146,  143,  142,  141,  140,  139,  138,
-      129,  126,  125,  124,  121,  120,   56,   56,  118,  114,
-
-      103,   79,   56,  565,    7,  565,  565,  565,  565,  565,
+        8,    9,   10,   11,   12,   13,    8,    8,   14,   15,
+       16,   17,    8,    8,    8,    8,    8,   18,   19,   20,
+       21,   22,   23,   24,    8,   25,    8,    8,   26,   27,
+       28,   29,   30,    8,   31,   32,   33,   34,   35,    8,
+        8,    8,   36,   37,    8,   38,   10,   39,    8,   13,
+        8,    8,    8,   40,   16,   40,    8,    8,   41,    8,
+       40,   40,   40,   40,   40,   40,   40,   40,   40,   40,
+       40,   40,   40,   40,   40,   40,   40,   40,   40,   40,
+       40,   40,   40,   40,   40,   40,   36,   37,    9,   10,
+       11,   43,   44,   54,  110,   55,   49,   45,   49,   54,
+
+       46,   59,   57,   49,   60,   49,   58,   70,   65,   68,
+       82,   71,   80,   72,   61,   62,   83,   81,   84,   66,
+       63,   64,   67,   69,   73,  106,   85,  106,   86,   47,
+       48,    9,   10,   11,   43,   44,  564,   50,   51,   74,
+       45,  563,   93,   46,   50,   51,  100,   75,   87,   94,
+       76,   88,   97,   77,   95,   89,   78,  104,   96,  101,
+       98,  105,   90,   91,   99,   92,  102,  107,  108,  107,
+      108,  562,   47,   48,  108,  111,  108,  111,   53,  116,
+       53,  109,  106,  117,  106,  561,  107,  109,  107,   49,
+       53,   49,  106,  107,  106,  107,   54,   54,   55,   59,
+
+      122,  127,  130,  560,  131,  128,  132,  133,  134,   50,
+       51,  123,  135,  136,  137,   50,   51,  144,  151,  161,
+      169,  145,  152,  170,  164,  173,  162,  165,  559,  174,
+       50,   51,  106,  558,  106,  166,  107,  108,  107,  108,
+      167,  111,  111,  111,  111,  175,   53,  119,   53,  119,
+      109,  183,  557,  119,  215,  119,  261,  262,   53,  119,
+      216,  343,  556,  252,  184,  119,  253,  309,  310,  388,
+      401,  311,  435,  438,  439,  447,  344,  402,   50,   51,
+      403,  537,  448,  555,  554,  389,  553,  552,  436,  551,
+      550,  549,  548,  538,   42,   42,   42,   42,   42,   42,
+
+       52,   52,   52,   53,   53,  547,   53,   53,   53,  112,
+      546,  545,  544,  112,  112,  113,  543,  542,  541,  113,
+      113,  115,  115,  540,  115,  115,  115,  119,  119,  539,
+      119,  119,  119,  180,  180,  536,  180,  180,  180,  535,
+      534,  533,  532,  531,  530,  529,  528,  527,  526,  525,
+      524,  523,  522,  521,  520,  519,  518,  517,  516,  515,
+      514,  513,  512,  511,  510,  509,  508,  507,  506,  505,
+      504,  503,  502,  501,  500,  499,  498,  497,  496,  495,
+      494,  493,  492,  491,  490,  489,  488,  487,  486,  485,
+      484,  483,  482,  481,  480,  479,  478,  477,  476,  475,
+
+      474,  473,  472,  471,  470,  469,  468,  467,  466,  465,
+      464,  463,  462,  461,  460,  459,  458,  457,  456,  455,
+      454,  453,  452,  451,  450,  449,  446,  445,  444,  443,
+      442,  441,  440,  437,  434,  433,  432,  431,  430,  429,
+      428,  427,  426,  425,  424,  423,  422,  421,  420,  419,
+      418,  417,  416,  415,  414,  413,  412,  411,  410,  409,
+      408,  407,  406,  405,  404,  400,  399,  398,  397,  396,
+      395,  394,  393,  392,  391,  390,  387,  386,  385,  384,
+      383,  382,  381,  380,  379,  378,  377,  376,  375,  374,
+      373,  372,  371,  370,  369,  368,  367,  366,  365,  364,
+
+      363,  362,  361,  360,  359,  358,  357,  356,  355,  354,
+      353,  352,  351,  350,  349,  348,  347,  346,  345,  342,
+      341,  340,  339,  338,  337,  336,  335,  334,  333,  332,
+      331,  330,  329,  328,  327,  326,  325,  324,  323,  322,
+      321,  320,  319,  318,  317,  316,  315,  314,  313,  312,
+      308,  307,  306,  305,  304,  303,  302,  301,  300,  299,
+      298,  297,  296,  295,  294,  293,  292,  291,  290,  289,
+      288,  287,  286,  285,  284,  283,  282,  281,  280,  279,
+      278,  277,  276,  275,  274,  273,  272,  271,  270,  269,
+      268,  267,  266,  265,  264,  263,  260,  259,  258,  257,
+
+      256,  255,  254,  251,  250,  249,  248,  247,  246,  245,
+      244,  243,  242,  241,  240,  239,  238,  237,  236,  235,
+      234,  233,  232,  231,  230,  229,  228,  227,  226,  225,
+      224,  223,  222,  221,  220,  219,  218,  217,  214,  213,
+      212,  211,  210,  209,  208,  207,  206,  205,  204,  203,
+      202,  201,  200,  199,  198,  197,  196,  195,  194,  193,
+      192,  191,  190,  189,  188,  187,  186,  185,  182,  181,
+      114,  114,  179,  178,  177,  176,  172,  171,  168,  163,
+      160,  159,  158,  157,  156,  155,  154,  153,  150,  149,
+      148,  147,  146,  143,  142,  141,  140,  139,  138,  129,
+
+      126,  125,  124,  121,  120,   56,   56,  118,  114,  103,
+       79,   56,  565,    7,  565,  565,  565,  565,  565,  565,
       565,  565,  565,  565,  565,  565,  565,  565,  565,  565,
       565,  565,  565,  565,  565,  565,  565,  565,  565,  565,
       565,  565,  565,  565,  565,  565,  565,  565,  565,  565,
       565,  565,  565,  565,  565,  565,  565,  565
     } ;
 
-static yyconst flex_int16_t yy_chk[749] =
+static yyconst flex_int16_t yy_chk[759] =
     {   0,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    3,    3,    3,    3,    3,    3,    3,
-        3,   14,    3,   14,    3,    3,    3,    3,   17,   16,
-       17,    9,   16,    9,   11,   18,   11,   21,   22,   19,
-       27,   21,   25,   69,   69,   18,   18,   25,   27,   22,
-       19,   18,   18,   19,    3,    3,    4,    4,    4,    4,
-        4,    4,    4,    4,   20,    4,   28,    4,    4,    4,
-
-        4,    9,    9,   23,   11,   11,   26,   45,   20,   31,
-       45,   23,   26,   31,   23,   30,   28,   23,  570,   35,
-       23,   66,   30,   35,   36,   66,   36,    4,    4,    5,
-        5,    5,    5,    5,   29,   32,   33,    5,   29,   37,
-        5,   37,   41,   32,   41,   29,   29,   32,   29,   33,
-       38,   98,   38,   39,   98,   39,   33,   44,   47,   44,
-       47,   48,   38,   48,   49,   39,   49,  122,   44,    5,
-        5,    6,    6,    6,    6,    6,   50,   62,   50,    6,
-      122,   51,    6,   51,   55,   59,   55,   59,   62,  562,
-       38,   38,   70,   39,   39,   68,   70,   68,   71,   71,
-
-      559,   94,   78,   84,   49,   49,   78,   84,   94,  291,
-       96,    6,    6,   96,  101,  106,  193,  106,  101,  193,
-      107,   96,  107,  108,  291,  108,   96,  109,  111,  109,
-      111,  115,  558,  115,  101,  108,  117,  155,  117,  180,
-      343,  180,  115,  155,  201,  201,  391,  117,  255,  255,
-      180,  356,  255,  394,  394,  526,  343,  556,  356,  403,
-      555,  356,  391,  108,  108,  554,  403,  526,  566,  566,
-      566,  566,  566,  566,  567,  567,  567,  567,  567,  567,
-      568,  568,  568,  569,  569,  551,  569,  569,  569,  571,
-      550,  548,  547,  571,  571,  572,  546,  543,  542,  572,
-
-      572,  573,  573,  541,  573,  573,  573,  574,  574,  540,
-      574,  574,  574,  575,  575,  539,  575,  575,  575,  538,
-      537,  536,  533,  532,  531,  530,  529,  528,  527,  523,
-      522,  521,  519,  518,  517,  515,  511,  510,  508,  507,
-      504,  503,  502,  501,  500,  499,  498,  497,  495,  494,
-      493,  490,  489,  488,  485,  481,  480,  479,  478,  477,
-      476,  473,  472,  471,  470,  469,  468,  467,  466,  465,
-      464,  463,  462,  461,  460,  459,  458,  457,  456,  454,
-      453,  452,  450,  449,  448,  447,  446,  445,  444,  443,
-      442,  441,  439,  437,  436,  435,  434,  433,  432,  429,
-
-      428,  427,  426,  425,  424,  422,  420,  419,  418,  416,
-      414,  409,  408,  407,  406,  405,  404,  402,  401,  400,
-      399,  398,  397,  396,  393,  390,  389,  388,  387,  386,
-      385,  384,  383,  382,  381,  380,  379,  377,  376,  375,
-      374,  373,  372,  371,  370,  368,  367,  366,  365,  364,
-      362,  361,  360,  359,  358,  357,  355,  354,  353,  352,
-      351,  350,  349,  348,  347,  345,  344,  342,  340,  339,
-      338,  337,  336,  335,  334,  333,  332,  331,  330,  329,
-      328,  326,  325,  323,  321,  320,  319,  318,  317,  316,
-      315,  314,  313,  312,  311,  310,  309,  308,  306,  305,
-
-      304,  303,  302,  300,  299,  298,  297,  295,  294,  292,
-      290,  288,  287,  286,  285,  284,  283,  282,  281,  280,
-      279,  277,  276,  275,  274,  273,  272,  271,  270,  268,
-      267,  266,  265,  264,  263,  262,  261,  259,  258,  257,
-      256,  254,  253,  251,  250,  248,  247,  246,  245,  244,
-      243,  242,  241,  240,  239,  238,  237,  234,  233,  232,
-      231,  230,  229,  228,  227,  226,  225,  224,  223,  222,
-      221,  220,  219,  217,  216,  215,  213,  212,  211,  210,
-      209,  208,  207,  206,  205,  204,  202,  200,  199,  198,
-      197,  196,  195,  194,  192,  191,  190,  189,  188,  187,
-
-      186,  185,  184,  183,  182,  181,  179,  178,  177,  176,
-      175,  174,  173,  172,  171,  170,  169,  168,  167,  166,
-      165,  164,  163,  162,  161,  160,  159,  158,  156,  154,
-      153,  152,  151,  150,  149,  148,  147,  146,  145,  144,
-      143,  142,  141,  140,  139,  137,  136,  135,  134,  133,
-      132,  131,  130,  128,  127,  126,  125,  124,  123,  121,
-      120,  114,  113,  105,  104,  103,  102,  100,   99,   97,
-       95,   93,   92,   90,   89,   88,   87,   86,   85,   83,
-       82,   81,   80,   79,   77,   76,   75,   74,   73,   72,
-       67,   65,   64,   63,   61,   60,   56,   54,   52,   43,
-
-       34,   24,   15,    7,  565,  565,  565,  565,  565,  565,
+        1,    1,    1,    1,    3,    3,    3,    3,    3,    3,
+        3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
+        3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
+        3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
+        3,    3,    3,    3,    3,    3,    3,    3,    5,    5,
+        5,    5,    5,   14,  569,   14,    9,    5,    9,   17,
+
+        5,   17,   16,   11,   18,   11,   16,   21,   19,   20,
+       26,   21,   25,   22,   18,   18,   26,   25,   27,   19,
+       18,   18,   19,   20,   22,   36,   27,   36,   28,    5,
+        5,    6,    6,    6,    6,    6,  562,    9,    9,   23,
+        6,  559,   30,    6,   11,   11,   33,   23,   28,   30,
+       23,   29,   32,   23,   31,   29,   23,   35,   31,   33,
+       32,   35,   29,   29,   32,   29,   33,   37,   38,   37,
+       38,  558,    6,    6,   39,   41,   39,   41,   44,   45,
+       44,   38,   47,   45,   47,  556,   48,   39,   48,   49,
+       44,   49,   50,   51,   50,   51,   55,   59,   55,   59,
+
+       62,   66,   68,  555,   68,   66,   69,   69,   70,   38,
+       38,   62,   70,   71,   71,   39,   39,   78,   84,   94,
+       98,   78,   84,   98,   96,  101,   94,   96,  554,  101,
+       49,   49,  106,  551,  106,   96,  107,  108,  107,  108,
+       96,  109,  111,  109,  111,  101,  115,  117,  115,  117,
+      108,  122,  550,  180,  155,  180,  201,  201,  115,  117,
+      155,  291,  548,  193,  122,  180,  193,  255,  255,  343,
+      356,  255,  391,  394,  394,  403,  291,  356,  108,  108,
+      356,  526,  403,  547,  546,  343,  543,  542,  391,  541,
+      540,  539,  538,  526,  566,  566,  566,  566,  566,  566,
+
+      567,  567,  567,  568,  568,  537,  568,  568,  568,  570,
+      536,  533,  532,  570,  570,  571,  531,  530,  529,  571,
+      571,  572,  572,  528,  572,  572,  572,  573,  573,  527,
+      573,  573,  573,  574,  574,  523,  574,  574,  574,  522,
+      521,  519,  518,  517,  515,  511,  510,  508,  507,  504,
+      503,  502,  501,  500,  499,  498,  497,  495,  494,  493,
+      490,  489,  488,  485,  481,  480,  479,  478,  477,  476,
+      473,  472,  471,  470,  469,  468,  467,  466,  465,  464,
+      463,  462,  461,  460,  459,  458,  457,  456,  454,  453,
+      452,  450,  449,  448,  447,  446,  445,  444,  443,  442,
+
+      441,  439,  437,  436,  435,  434,  433,  432,  429,  428,
+      427,  426,  425,  424,  422,  420,  419,  418,  416,  414,
+      409,  408,  407,  406,  405,  404,  402,  401,  400,  399,
+      398,  397,  396,  393,  390,  389,  388,  387,  386,  385,
+      384,  383,  382,  381,  380,  379,  377,  376,  375,  374,
+      373,  372,  371,  370,  368,  367,  366,  365,  364,  362,
+      361,  360,  359,  358,  357,  355,  354,  353,  352,  351,
+      350,  349,  348,  347,  345,  344,  342,  340,  339,  338,
+      337,  336,  335,  334,  333,  332,  331,  330,  329,  328,
+      326,  325,  323,  321,  320,  319,  318,  317,  316,  315,
+
+      314,  313,  312,  311,  310,  309,  308,  306,  305,  304,
+      303,  302,  300,  299,  298,  297,  295,  294,  292,  290,
+      288,  287,  286,  285,  284,  283,  282,  281,  280,  279,
+      277,  276,  275,  274,  273,  272,  271,  270,  268,  267,
+      266,  265,  264,  263,  262,  261,  259,  258,  257,  256,
+      254,  253,  251,  250,  248,  247,  246,  245,  244,  243,
+      242,  241,  240,  239,  238,  237,  234,  233,  232,  231,
+      230,  229,  228,  227,  226,  225,  224,  223,  222,  221,
+      220,  219,  217,  216,  215,  213,  212,  211,  210,  209,
+      208,  207,  206,  205,  204,  202,  200,  199,  198,  197,
+
+      196,  195,  194,  192,  191,  190,  189,  188,  187,  186,
+      185,  184,  183,  182,  181,  179,  178,  177,  176,  175,
+      174,  173,  172,  171,  170,  169,  168,  167,  166,  165,
+      164,  163,  162,  161,  160,  159,  158,  156,  154,  153,
+      152,  151,  150,  149,  148,  147,  146,  145,  144,  143,
+      142,  141,  140,  139,  137,  136,  135,  134,  133,  132,
+      131,  130,  128,  127,  126,  125,  124,  123,  121,  120,
+      114,  113,  105,  104,  103,  102,  100,   99,   97,   95,
+       93,   92,   90,   89,   88,   87,   86,   85,   83,   82,
+       81,   80,   79,   77,   76,   75,   74,   73,   72,   67,
+
+       65,   64,   63,   61,   60,   56,   54,   52,   43,   34,
+       24,   15,    7,  565,  565,  565,  565,  565,  565,  565,
       565,  565,  565,  565,  565,  565,  565,  565,  565,  565,
       565,  565,  565,  565,  565,  565,  565,  565,  565,  565,
       565,  565,  565,  565,  565,  565,  565,  565,  565,  565,
@@ -800,10 +802,11 @@ char *yy_text;
 /* this header file is automatically generated by bison 
  * and includes all token definitions, as well as yy_lval */
 #if ELBEEM_BLENDER==1
+// for blender the headers have to be .h 
 #include "cfgparser.h"
-#else // ELBEEM_BLENDER==1
+#else 
 #include "cfgparser.hpp"
-#endif // ELBEEM_BLENDER==1
+#endif
 #include "utilities.h"
 
 #include <string.h>
@@ -825,7 +828,7 @@ extern "C" int yy_wrap (void ) { return 1; }
  * rules start 
  */
 /*----------------------------------------------------------------------------*/
-#line 829 "<stdout>"
+#line 832 "<stdout>"
 
 #define INITIAL 0
 #define ATTR 1
@@ -978,11 +981,11 @@ YY_DECL
        register char *yy_cp, *yy_bp;
        register int yy_act;
     
-#line 54 "src/cfglexer.ll"
+#line 55 "src/cfglexer.ll"
 
 
 
-#line 986 "<stdout>"
+#line 989 "<stdout>"
 
        if ( (yy_init) )
                {
@@ -1063,25 +1066,25 @@ do_action:      /* This label is used only to access EOF actions. */
 
 case 1:
 YY_RULE_SETUP
-#line 57 "src/cfglexer.ll"
+#line 58 "src/cfglexer.ll"
 { return KW_PAROPEN; }
        YY_BREAK
 case 2:
 YY_RULE_SETUP
-#line 58 "src/cfglexer.ll"
+#line 59 "src/cfglexer.ll"
 { BEGIN(INITIAL); // '}' always closes scopes
                        return KW_PARCLOSE; }
        YY_BREAK
 case 3:
 YY_RULE_SETUP
-#line 61 "src/cfglexer.ll"
+#line 62 "src/cfglexer.ll"
 { 
                        BEGIN(ATTRVALUE);
                        return KW_EQUALS; }
        YY_BREAK
 case 4:
 YY_RULE_SETUP
-#line 64 "src/cfglexer.ll"
+#line 65 "src/cfglexer.ll"
 { /* attribute name = normal string */
                strncpy( charBuffer, yy_text, CHAR_BUFFER_SIZE-2 );
                yy_lval.charValue = charBuffer;
@@ -1091,7 +1094,7 @@ YY_RULE_SETUP
        YY_BREAK
 case 5:
 YY_RULE_SETUP
-#line 70 "src/cfglexer.ll"
+#line 71 "src/cfglexer.ll"
 { /* quoted string! attribute name = normal string */
                strncpy( charBuffer, yy_text, CHAR_BUFFER_SIZE-2 );
                        /* get rid of " " */
@@ -1102,7 +1105,7 @@ YY_RULE_SETUP
        YY_BREAK
 case 6:
 YY_RULE_SETUP
-#line 77 "src/cfglexer.ll"
+#line 78 "src/cfglexer.ll"
 { /* ends at newline or ';' */
                strncpy( charBuffer, yy_text, CHAR_BUFFER_SIZE-2 );
                yy_lval.charValue = charBuffer;
@@ -1110,433 +1113,433 @@ YY_RULE_SETUP
        YY_BREAK
 case 7:
 YY_RULE_SETUP
-#line 81 "src/cfglexer.ll"
+#line 82 "src/cfglexer.ll"
 { /* return end token... */
                        BEGIN(ATTR); 
                        return KW_ATTREND; }
        YY_BREAK
 case 8:
 YY_RULE_SETUP
-#line 86 "src/cfglexer.ll"
+#line 87 "src/cfglexer.ll"
 { return KW_LBMSIM; }
        YY_BREAK
 case 9:
 YY_RULE_SETUP
-#line 87 "src/cfglexer.ll"
+#line 88 "src/cfglexer.ll"
 { return KW_COMPARELBM; }
        YY_BREAK
 case 10:
 YY_RULE_SETUP
-#line 88 "src/cfglexer.ll"
+#line 89 "src/cfglexer.ll"
 { return KW_DEBUGMODE; }
        YY_BREAK
 case 11:
 YY_RULE_SETUP
-#line 89 "src/cfglexer.ll"
+#line 90 "src/cfglexer.ll"
 { return KW_DEBUGLEVEL; }
        YY_BREAK
 case 12:
 YY_RULE_SETUP
-#line 90 "src/cfglexer.ll"
+#line 91 "src/cfglexer.ll"
 { return KW_RAYTRACING; }
        YY_BREAK
 case 13:
 YY_RULE_SETUP
-#line 93 "src/cfglexer.ll"
+#line 94 "src/cfglexer.ll"
 { return KW_RESOLUTION; }
        YY_BREAK
 case 14:
 YY_RULE_SETUP
-#line 94 "src/cfglexer.ll"
+#line 95 "src/cfglexer.ll"
 { return KW_ANTIALIAS; }
        YY_BREAK
 case 15:
 YY_RULE_SETUP
-#line 95 "src/cfglexer.ll"
+#line 96 "src/cfglexer.ll"
 { return KW_EYEPOINT; }
        YY_BREAK
 case 16:
 YY_RULE_SETUP
-#line 96 "src/cfglexer.ll"
+#line 97 "src/cfglexer.ll"
 { return KW_LOOKAT ; }
        YY_BREAK
 case 17:
 YY_RULE_SETUP
-#line 97 "src/cfglexer.ll"
+#line 98 "src/cfglexer.ll"
 { return KW_UPVEC ; }
        YY_BREAK
 case 18:
 YY_RULE_SETUP
-#line 98 "src/cfglexer.ll"
+#line 99 "src/cfglexer.ll"
 { return KW_FOVY; }
        YY_BREAK
 case 19:
 YY_RULE_SETUP
-#line 99 "src/cfglexer.ll"
+#line 100 "src/cfglexer.ll"
 { return KW_ASPECT ; }
        YY_BREAK
 case 20:
 YY_RULE_SETUP
-#line 100 "src/cfglexer.ll"
+#line 101 "src/cfglexer.ll"
 { return KW_AMBIENCE; }
        YY_BREAK
 case 21:
 YY_RULE_SETUP
-#line 101 "src/cfglexer.ll"
+#line 102 "src/cfglexer.ll"
 { return KW_BACKGROUND; }
        YY_BREAK
 case 22:
 YY_RULE_SETUP
-#line 102 "src/cfglexer.ll"
+#line 103 "src/cfglexer.ll"
 { return KW_ANISTART; }
        YY_BREAK
 case 23:
 YY_RULE_SETUP
-#line 103 "src/cfglexer.ll"
+#line 104 "src/cfglexer.ll"
 { return KW_ANIFRAMES; }
        YY_BREAK
 case 24:
 YY_RULE_SETUP
-#line 104 "src/cfglexer.ll"
+#line 105 "src/cfglexer.ll"
 { return KW_ANIFRAMETIME; }
        YY_BREAK
 case 25:
 YY_RULE_SETUP
-#line 105 "src/cfglexer.ll"
+#line 106 "src/cfglexer.ll"
 { return KW_FRAMESKIP; }
        YY_BREAK
 case 26:
 YY_RULE_SETUP
-#line 106 "src/cfglexer.ll"
+#line 107 "src/cfglexer.ll"
 { return KW_FILENAME; }
        YY_BREAK
 case 27:
 YY_RULE_SETUP
-#line 107 "src/cfglexer.ll"
+#line 108 "src/cfglexer.ll"
 { return KW_PMCAUSTICS; }
        YY_BREAK
 case 28:
 YY_RULE_SETUP
-#line 108 "src/cfglexer.ll"
+#line 109 "src/cfglexer.ll"
 { return KW_CAUSTICDIST; }
        YY_BREAK
 case 29:
 YY_RULE_SETUP
-#line 109 "src/cfglexer.ll"
+#line 110 "src/cfglexer.ll"
 { return KW_CAUSTICPHOT; }
        YY_BREAK
 case 30:
 YY_RULE_SETUP
-#line 110 "src/cfglexer.ll"
+#line 111 "src/cfglexer.ll"
 { return KW_SHADOWMAPBIAS; }
        YY_BREAK
 case 31:
 YY_RULE_SETUP
-#line 111 "src/cfglexer.ll"
+#line 112 "src/cfglexer.ll"
 { return KW_MAXRAYDEPTH; }
        YY_BREAK
 case 32:
 YY_RULE_SETUP
-#line 112 "src/cfglexer.ll"
+#line 113 "src/cfglexer.ll"
 { return KW_TREEMAXDEPTH; }
        YY_BREAK
 case 33:
 YY_RULE_SETUP
-#line 113 "src/cfglexer.ll"
+#line 114 "src/cfglexer.ll"
 { return KW_TREEMAXTRIANGLES; }
        YY_BREAK
 case 34:
 YY_RULE_SETUP
-#line 114 "src/cfglexer.ll"
+#line 115 "src/cfglexer.ll"
 { return KW_DEBUGPIXEL; }
        YY_BREAK
 case 35:
 YY_RULE_SETUP
-#line 115 "src/cfglexer.ll"
+#line 116 "src/cfglexer.ll"
 { return KW_TESTMODE; }
        YY_BREAK
 case 36:
 YY_RULE_SETUP
-#line 116 "src/cfglexer.ll"
+#line 117 "src/cfglexer.ll"
 { return KW_OPENGLATTR; }
        YY_BREAK
 case 37:
 YY_RULE_SETUP
-#line 117 "src/cfglexer.ll"
+#line 118 "src/cfglexer.ll"
 { return KW_BLENDERATTR; }
        YY_BREAK
 case 38:
 YY_RULE_SETUP
-#line 119 "src/cfglexer.ll"
+#line 120 "src/cfglexer.ll"
 { return KW_OBJATTR; /* assign attr to obj */ }
        YY_BREAK
 case 39:
 YY_RULE_SETUP
-#line 120 "src/cfglexer.ll"
+#line 121 "src/cfglexer.ll"
 { BEGIN(ATTR); return KW_ATTRIBUTE;  /* global attr list */ }
        YY_BREAK
 case 40:
 YY_RULE_SETUP
-#line 121 "src/cfglexer.ll"
+#line 122 "src/cfglexer.ll"
 { BEGIN(ATTR); return KW_DEFINEATTR; /* obj defines new attrs */ }
        YY_BREAK
 case 41:
 YY_RULE_SETUP
-#line 122 "src/cfglexer.ll"
+#line 123 "src/cfglexer.ll"
 { BEGIN(ATTR); return KW_DEFINEATTR; }
        YY_BREAK
 case 42:
 YY_RULE_SETUP
-#line 123 "src/cfglexer.ll"
+#line 124 "src/cfglexer.ll"
 { BEGIN(ATTR); return KW_DEFINEATTR; }
        YY_BREAK
 case 43:
 YY_RULE_SETUP
-#line 125 "src/cfglexer.ll"
+#line 126 "src/cfglexer.ll"
 { return KW_GEOMETRY; }
        YY_BREAK
 case 44:
 YY_RULE_SETUP
-#line 126 "src/cfglexer.ll"
+#line 127 "src/cfglexer.ll"
 { return KW_TYPE; }
        YY_BREAK
 case 45:
 YY_RULE_SETUP
-#line 127 "src/cfglexer.ll"
+#line 128 "src/cfglexer.ll"
 { return KW_GEOTYPE_BOX; }
        YY_BREAK
 case 46:
 YY_RULE_SETUP
-#line 128 "src/cfglexer.ll"
+#line 129 "src/cfglexer.ll"
 { return KW_GEOTYPE_SPHERE; }
        YY_BREAK
 case 47:
 YY_RULE_SETUP
-#line 129 "src/cfglexer.ll"
+#line 130 "src/cfglexer.ll"
 { return KW_GEOTYPE_OBJMODEL; }
        YY_BREAK
 case 48:
 YY_RULE_SETUP
-#line 130 "src/cfglexer.ll"
+#line 131 "src/cfglexer.ll"
 { return KW_CASTSHADOWS; }  
        YY_BREAK
 case 49:
 YY_RULE_SETUP
-#line 131 "src/cfglexer.ll"
+#line 132 "src/cfglexer.ll"
 { return KW_RECEIVESHADOWS ; }
        YY_BREAK
 case 50:
 YY_RULE_SETUP
-#line 132 "src/cfglexer.ll"
+#line 133 "src/cfglexer.ll"
 { return KW_VISIBLE; }  
        YY_BREAK
 case 51:
 YY_RULE_SETUP
-#line 133 "src/cfglexer.ll"
+#line 134 "src/cfglexer.ll"
 { return KW_BOX_START; }
        YY_BREAK
 case 52:
 YY_RULE_SETUP
-#line 134 "src/cfglexer.ll"
+#line 135 "src/cfglexer.ll"
 { return KW_BOX_END; }
        YY_BREAK
 case 53:
 YY_RULE_SETUP
-#line 135 "src/cfglexer.ll"
+#line 136 "src/cfglexer.ll"
 { return KW_POLY ; }
        YY_BREAK
 case 54:
 YY_RULE_SETUP
-#line 136 "src/cfglexer.ll"
+#line 137 "src/cfglexer.ll"
 { return KW_POLY ; }
        YY_BREAK
 case 55:
 YY_RULE_SETUP
-#line 137 "src/cfglexer.ll"
+#line 138 "src/cfglexer.ll"
 { return KW_NUMVERTICES; }
        YY_BREAK
 case 56:
 YY_RULE_SETUP
-#line 138 "src/cfglexer.ll"
+#line 139 "src/cfglexer.ll"
 { return KW_VERTEX; }
        YY_BREAK
 case 57:
 YY_RULE_SETUP
-#line 139 "src/cfglexer.ll"
+#line 140 "src/cfglexer.ll"
 { return KW_NUMPOLYGONS; }
        YY_BREAK
 case 58:
 YY_RULE_SETUP
-#line 140 "src/cfglexer.ll"
+#line 141 "src/cfglexer.ll"
 { return KW_ISOSURF; }  
        YY_BREAK
 case 59:
 YY_RULE_SETUP
-#line 141 "src/cfglexer.ll"
+#line 142 "src/cfglexer.ll"
 { return KW_FILEMODE; }  
        YY_BREAK
 case 60:
 YY_RULE_SETUP
-#line 142 "src/cfglexer.ll"
+#line 143 "src/cfglexer.ll"
 { return KW_INVERT; }  
        YY_BREAK
 case 61:
 YY_RULE_SETUP
-#line 144 "src/cfglexer.ll"
+#line 145 "src/cfglexer.ll"
 { return KW_MATERIAL; }
        YY_BREAK
 case 62:
 YY_RULE_SETUP
-#line 145 "src/cfglexer.ll"
+#line 146 "src/cfglexer.ll"
 { return KW_MATTYPE_PHONG; }
        YY_BREAK
 case 63:
 YY_RULE_SETUP
-#line 146 "src/cfglexer.ll"
+#line 147 "src/cfglexer.ll"
 { return KW_MATTYPE_BLINN; }
        YY_BREAK
 case 64:
 YY_RULE_SETUP
-#line 147 "src/cfglexer.ll"
+#line 148 "src/cfglexer.ll"
 { return KW_NAME; }
        YY_BREAK
 case 65:
 YY_RULE_SETUP
-#line 148 "src/cfglexer.ll"
+#line 149 "src/cfglexer.ll"
 { return KW_AMBIENT; }
        YY_BREAK
 case 66:
 YY_RULE_SETUP
-#line 149 "src/cfglexer.ll"
+#line 150 "src/cfglexer.ll"
 { return KW_DIFFUSE; }
        YY_BREAK
 case 67:
 YY_RULE_SETUP
-#line 150 "src/cfglexer.ll"
+#line 151 "src/cfglexer.ll"
 { return KW_SPECULAR; }
        YY_BREAK
 case 68:
 YY_RULE_SETUP
-#line 151 "src/cfglexer.ll"
+#line 152 "src/cfglexer.ll"
 { return KW_MIRROR; }
        YY_BREAK
 case 69:
 YY_RULE_SETUP
-#line 152 "src/cfglexer.ll"
+#line 153 "src/cfglexer.ll"
 { return KW_TRANSPARENCE; }
        YY_BREAK
 case 70:
 YY_RULE_SETUP
-#line 153 "src/cfglexer.ll"
+#line 154 "src/cfglexer.ll"
 { return KW_REFRACINDEX; }
        YY_BREAK
 case 71:
 YY_RULE_SETUP
-#line 154 "src/cfglexer.ll"
+#line 155 "src/cfglexer.ll"
 { return KW_TRANSADDITIVE; }
        YY_BREAK
 case 72:
 YY_RULE_SETUP
-#line 155 "src/cfglexer.ll"
+#line 156 "src/cfglexer.ll"
 { return KW_TRANSATTCOL; }
        YY_BREAK
 case 73:
 YY_RULE_SETUP
-#line 156 "src/cfglexer.ll"
+#line 157 "src/cfglexer.ll"
 { return KW_FRESNEL; }
        YY_BREAK
 case 74:
 YY_RULE_SETUP
-#line 157 "src/cfglexer.ll"
+#line 158 "src/cfglexer.ll"
 { return KW_FRESNEL; }
        YY_BREAK
 case 75:
 YY_RULE_SETUP
-#line 159 "src/cfglexer.ll"
+#line 160 "src/cfglexer.ll"
 { return KW_LIGHT; }
        YY_BREAK
 case 76:
 YY_RULE_SETUP
-#line 160 "src/cfglexer.ll"
+#line 161 "src/cfglexer.ll"
 { return KW_LIGHT_OMNI; }
        YY_BREAK
 case 77:
 YY_RULE_SETUP
-#line 161 "src/cfglexer.ll"
+#line 162 "src/cfglexer.ll"
 { return KW_ACTIVE; }
        YY_BREAK
 case 78:
 YY_RULE_SETUP
-#line 162 "src/cfglexer.ll"
+#line 163 "src/cfglexer.ll"
 { return KW_COLOUR; }
        YY_BREAK
 case 79:
 YY_RULE_SETUP
-#line 163 "src/cfglexer.ll"
+#line 164 "src/cfglexer.ll"
 { return KW_COLOUR; }
        YY_BREAK
 case 80:
 YY_RULE_SETUP
-#line 164 "src/cfglexer.ll"
+#line 165 "src/cfglexer.ll"
 { return KW_POSITION; }
        YY_BREAK
 case 81:
 YY_RULE_SETUP
-#line 165 "src/cfglexer.ll"
+#line 166 "src/cfglexer.ll"
 { return KW_CAUSTICPHOTONS; }
        YY_BREAK
 case 82:
 YY_RULE_SETUP
-#line 166 "src/cfglexer.ll"
+#line 167 "src/cfglexer.ll"
 { return KW_CAUSTICSTRENGTH; }
        YY_BREAK
 case 83:
 YY_RULE_SETUP
-#line 167 "src/cfglexer.ll"
+#line 168 "src/cfglexer.ll"
 { return KW_SHADOWMAP; }
        YY_BREAK
 case 84:
 YY_RULE_SETUP
-#line 168 "src/cfglexer.ll"
+#line 169 "src/cfglexer.ll"
 { return KW_CAUSTICSMAP; }
        YY_BREAK
 case 85:
 YY_RULE_SETUP
-#line 170 "src/cfglexer.ll"
+#line 171 "src/cfglexer.ll"
 { yy_lval.intValue = 1; return DT_INTEGER; }
        YY_BREAK
 case 86:
 YY_RULE_SETUP
-#line 171 "src/cfglexer.ll"
+#line 172 "src/cfglexer.ll"
 { yy_lval.intValue = 0; return DT_INTEGER; }
        YY_BREAK
 case 87:
 YY_RULE_SETUP
-#line 172 "src/cfglexer.ll"
+#line 173 "src/cfglexer.ll"
 { yy_lval.intValue = 1; return DT_INTEGER; }
        YY_BREAK
 case 88:
 YY_RULE_SETUP
-#line 173 "src/cfglexer.ll"
+#line 174 "src/cfglexer.ll"
 { yy_lval.intValue = 0; return DT_INTEGER; }
        YY_BREAK
 case 89:
 YY_RULE_SETUP
-#line 176 "src/cfglexer.ll"
+#line 177 "src/cfglexer.ll"
 { // integer number
   yy_lval.intValue = atoi( yy_text );
   return DT_INTEGER; }
        YY_BREAK
 case 90:
 YY_RULE_SETUP
-#line 180 "src/cfglexer.ll"
+#line 181 "src/cfglexer.ll"
 { // floating point number
   yy_lval.floatValue = atof( yy_text );
   return DT_FLOAT; }
        YY_BREAK
 case 91:
 YY_RULE_SETUP
-#line 184 "src/cfglexer.ll"
+#line 185 "src/cfglexer.ll"
 { /* normal character strings, now also for paths/filenames */
   strncpy( charBuffer, yy_text, CHAR_BUFFER_SIZE-2 );
        /* get rid of " " */
@@ -1547,17 +1550,17 @@ YY_RULE_SETUP
        YY_BREAK
 case 92:
 YY_RULE_SETUP
-#line 192 "src/cfglexer.ll"
+#line 193 "src/cfglexer.ll"
 { /* one line comment */  }
        YY_BREAK
 case 93:
 YY_RULE_SETUP
-#line 193 "src/cfglexer.ll"
+#line 194 "src/cfglexer.ll"
 { /* one line comment */  }
        YY_BREAK
 case 94:
 YY_RULE_SETUP
-#line 194 "src/cfglexer.ll"
+#line 195 "src/cfglexer.ll"
 { /* multiline comment */
        register int c; 
        for ( ; ; )     {
@@ -1583,26 +1586,26 @@ YY_RULE_SETUP
 case 95:
 /* rule 95 can match eol */
 YY_RULE_SETUP
-#line 218 "src/cfglexer.ll"
+#line 219 "src/cfglexer.ll"
 { // count line numbers
   lineCount++; }
        YY_BREAK
 case 96:
 YY_RULE_SETUP
-#line 221 "src/cfglexer.ll"
+#line 222 "src/cfglexer.ll"
 { /* do nothing by default... */ }
        YY_BREAK
 case 97:
 YY_RULE_SETUP
-#line 223 "src/cfglexer.ll"
+#line 224 "src/cfglexer.ll"
 { /*errorOut( "cfgLexer, Line "<<lineCount<<" : Unknown character '"<<(char)yyinput()<<"' " ); xit(1); */ }
        YY_BREAK
 case 98:
 YY_RULE_SETUP
-#line 226 "src/cfglexer.ll"
+#line 227 "src/cfglexer.ll"
 ECHO;
        YY_BREAK
-#line 1606 "<stdout>"
+#line 1609 "<stdout>"
 case YY_STATE_EOF(INITIAL):
 case YY_STATE_EOF(ATTR):
 case YY_STATE_EOF(ATTRVALUE):
@@ -2567,4 +2570,4 @@ void yy_free (void * ptr )
 #undef YY_DECL_IS_OURS
 #undef YY_DECL
 #endif
-#line 226 "src/cfglexer.ll"
+#line 227 "src/cfglexer.ll"
index 16a8772ff7274d06faf3195ad7a05bfe94915fea..6ca309f77a5efdeddc9f2135860646297bef6b50 100644 (file)
   int yy_parse( void );
 
 // local variables to access objects 
+#include "solver_interface.h"
 #include "simulation_object.h"
 #ifdef LBM_INCLUDE_TESTSOLVERS
 #include "simulation_complbm.h"
 #endif // LBM_INCLUDE_TESTSOLVERS
 
 #include "parametrizer.h"
-#include "ntl_renderglobals.h"
-#include "ntl_scene.h"
-
-#include "ntl_lightobject.h"
-#include "ntl_material.h"
+#include "ntl_world.h"
+#include "ntl_ray.h"
+#include "ntl_lighting.h"
 #include "ntl_geometrymodel.h"
-#include "globals.h"
 
        /* global variables */
        static map<string,AttributeList*> attrs; /* global attribute storage */
        AttributeList                           *currentAttrib;
        string                                                  currentAttrName, currentAttribAddName;
 
-#ifndef ELBEEM_BLENDER
+#ifndef ELBEEM_PLUGIN
 #include "ntl_geometrybox.h"
 #include "ntl_geometrysphere.h"
        ntlGeometryBox      *currentGeometryBox;
-#endif //ELBEEM_BLENDER
+#endif //ELBEEM_PLUGIN
        
        /* material init checks */
        ntlMaterial                             *currentMaterial;
 #endif
 
 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
-#line 87 "src/cfgparser.yy"
+#line 85 "src/cfgparser.yy"
 typedef union YYSTYPE {
   int    intValue;
   float  floatValue;
   char  *charValue;
 } YYSTYPE;
 /* Line 190 of yacc.c.  */
-#line 369 "bld-std-gcc/src/cfgparser.cpp"
+#line 367 "bld-std-gcc/src/cfgparser.cpp"
 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
 # define YYSTYPE_IS_DECLARED 1
 # define YYSTYPE_IS_TRIVIAL 1
@@ -377,7 +375,7 @@ typedef union YYSTYPE {
 
 
 /* Line 213 of yacc.c.  */
-#line 381 "bld-std-gcc/src/cfgparser.cpp"
+#line 379 "bld-std-gcc/src/cfgparser.cpp"
 
 #if ! defined (yyoverflow) || YYERROR_VERBOSE
 
@@ -609,21 +607,21 @@ static const short int yyrhs[] =
 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
 static const unsigned short int yyrline[] =
 {
-       0,   146,   146,   147,   150,   151,   152,   153,   157,   160,
-     175,   176,   176,   179,   180,   181,   182,   184,   185,   186,
-     187,   188,   189,   190,   191,   192,   193,   194,   195,   196,
-     197,   198,   199,   200,   202,   203,   204,   205,   210,   214,
-     219,   223,   229,   233,   237,   241,   245,   249,   253,   257,
-     261,   265,   269,   273,   277,   281,   285,   289,   294,   303,
-     314,   315,   318,   326,   327,   328,   329,   333,   338,   343,
-     348,   366,   365,   386,   387,   390,   399,   407,   412,   418,
-     430,   431,   432,   433,   434,   435,   436,   437,   438,   443,
-     448,   454,   460,   466,   471,   486,   502,   508,   518,   529,
-     530,   533,   538,   542,   543,   544,   545,   546,   547,   548,
-     549,   550,   551,   556,   561,   566,   571,   577,   582,   587,
-     592,   597,   602,   613,   613,   623,   623,   626,   626,   629,
-     630,   629,   637,   638,   637,   645,   648,   658,   661,   673,
-     675,   681,   692,   704
+       0,   144,   144,   145,   148,   149,   150,   151,   155,   158,
+     173,   174,   174,   177,   178,   179,   180,   182,   183,   184,
+     185,   186,   187,   188,   189,   190,   191,   192,   193,   194,
+     195,   196,   197,   198,   200,   201,   202,   203,   208,   212,
+     217,   221,   227,   231,   235,   239,   243,   247,   251,   255,
+     259,   263,   267,   271,   275,   279,   283,   287,   292,   301,
+     312,   313,   316,   324,   325,   326,   327,   331,   336,   341,
+     346,   364,   363,   385,   386,   389,   398,   406,   411,   417,
+     429,   430,   431,   432,   433,   434,   435,   436,   437,   442,
+     447,   453,   459,   465,   470,   485,   501,   510,   520,   531,
+     532,   535,   540,   544,   545,   546,   547,   548,   549,   550,
+     551,   552,   553,   558,   563,   568,   573,   579,   584,   589,
+     594,   599,   604,   615,   615,   625,   625,   628,   628,   631,
+     632,   631,   639,   640,   639,   647,   650,   660,   663,   675,
+     677,   683,   694,   706
 };
 #endif
 
@@ -1583,12 +1581,12 @@ yyreduce:
   switch (yyn)
     {
         case 8:
-#line 157 "src/cfgparser.yy"
+#line 155 "src/cfgparser.yy"
     { yy_debug = (yyvsp[0].intValue); }
     break;
 
   case 9:
-#line 160 "src/cfgparser.yy"
+#line 158 "src/cfgparser.yy"
     { 
                int sdebug = (yyvsp[0].intValue); 
                if(sdebug<0) sdebug=0;
@@ -1598,114 +1596,114 @@ yyreduce:
     break;
 
   case 38:
-#line 211 "src/cfgparser.yy"
+#line 209 "src/cfgparser.yy"
     { reglob->setAniStart( (yyvsp[0].intValue) ); }
     break;
 
   case 39:
-#line 215 "src/cfgparser.yy"
+#line 213 "src/cfgparser.yy"
     { /*reglob->setAniFrameTime( $2 );*/ debMsgStd("cfgparser",DM_NOTIFY,"Deprecated setting aniframetime!",1); }
     break;
 
   case 40:
-#line 220 "src/cfgparser.yy"
+#line 218 "src/cfgparser.yy"
     { reglob->setAniFrames( ((yyvsp[0].intValue))-1 ); }
     break;
 
   case 41:
-#line 224 "src/cfgparser.yy"
+#line 222 "src/cfgparser.yy"
     { reglob->setFrameSkip( ((yyvsp[0].intValue)) ); }
     break;
 
   case 42:
-#line 230 "src/cfgparser.yy"
+#line 228 "src/cfgparser.yy"
     { reglob->setResX( (yyvsp[-1].intValue) ); reglob->setResY( (yyvsp[0].intValue)); }
     break;
 
   case 43:
-#line 234 "src/cfgparser.yy"
+#line 232 "src/cfgparser.yy"
     { reglob->setAADepth( (yyvsp[0].intValue) ); }
     break;
 
   case 44:
-#line 238 "src/cfgparser.yy"
+#line 236 "src/cfgparser.yy"
     { reglob->setEye( ntlVec3Gfx((yyvsp[-2].floatValue),(yyvsp[-1].floatValue),(yyvsp[0].floatValue)) ); }
     break;
 
   case 45:
-#line 242 "src/cfgparser.yy"
+#line 240 "src/cfgparser.yy"
     { reglob->setLookat( ntlVec3Gfx((yyvsp[-2].floatValue),(yyvsp[-1].floatValue),(yyvsp[0].floatValue)) ); }
     break;
 
   case 46:
-#line 246 "src/cfgparser.yy"
+#line 244 "src/cfgparser.yy"
     { reglob->setUpVec( ntlVec3Gfx((yyvsp[-2].floatValue),(yyvsp[-1].floatValue),(yyvsp[0].floatValue)) ); }
     break;
 
   case 47:
-#line 250 "src/cfgparser.yy"
+#line 248 "src/cfgparser.yy"
     { reglob->setFovy( (yyvsp[0].floatValue) ); }
     break;
 
   case 48:
-#line 254 "src/cfgparser.yy"
+#line 252 "src/cfgparser.yy"
     { reglob->setAspect( (yyvsp[0].floatValue) ); }
     break;
 
   case 49:
-#line 258 "src/cfgparser.yy"
+#line 256 "src/cfgparser.yy"
     { reglob->setAmbientLight( ntlColor((yyvsp[-2].floatValue),(yyvsp[-1].floatValue),(yyvsp[0].floatValue))  ); }
     break;
 
   case 50:
-#line 262 "src/cfgparser.yy"
+#line 260 "src/cfgparser.yy"
     { reglob->setBackgroundCol( ntlColor((yyvsp[-2].floatValue),(yyvsp[-1].floatValue),(yyvsp[0].floatValue)) ); }
     break;
 
   case 51:
-#line 266 "src/cfgparser.yy"
+#line 264 "src/cfgparser.yy"
     { reglob->setOutFilename( (yyvsp[0].charValue) ); }
     break;
 
   case 52:
-#line 270 "src/cfgparser.yy"
+#line 268 "src/cfgparser.yy"
     { reglob->setTreeMaxDepth( (yyvsp[0].intValue) ); }
     break;
 
   case 53:
-#line 274 "src/cfgparser.yy"
+#line 272 "src/cfgparser.yy"
     { reglob->setTreeMaxTriangles( (yyvsp[0].intValue) ); }
     break;
 
   case 54:
-#line 278 "src/cfgparser.yy"
+#line 276 "src/cfgparser.yy"
     { reglob->setRayMaxDepth( (yyvsp[0].intValue) ); }
     break;
 
   case 55:
-#line 282 "src/cfgparser.yy"
+#line 280 "src/cfgparser.yy"
     { reglob->setDebugPixel( (yyvsp[-1].intValue), (yyvsp[0].intValue) ); }
     break;
 
   case 56:
-#line 286 "src/cfgparser.yy"
+#line 284 "src/cfgparser.yy"
     { reglob->setTestMode( (yyvsp[0].intValue) ); }
     break;
 
   case 57:
-#line 290 "src/cfgparser.yy"
+#line 288 "src/cfgparser.yy"
     { if(attrs[(yyvsp[0].charValue)] == NULL){ yyerror("OPENGL ATTRIBUTES: The attribute was not found!"); }
                        reglob->getOpenGlAttributes()->import( attrs[(yyvsp[0].charValue)] ); }
     break;
 
   case 58:
-#line 295 "src/cfgparser.yy"
+#line 293 "src/cfgparser.yy"
     { if(attrs[(yyvsp[0].charValue)] == NULL){ yyerror("BLENDER ATTRIBUTES: The attribute was not found!"); }
                        reglob->getBlenderAttributes()->import( attrs[(yyvsp[0].charValue)] ); }
     break;
 
   case 59:
-#line 307 "src/cfgparser.yy"
+#line 305 "src/cfgparser.yy"
     { 
                                /* reset light pointers */
                                currentLightOmni = NULL; 
@@ -1713,7 +1711,7 @@ yyreduce:
     break;
 
   case 62:
-#line 319 "src/cfgparser.yy"
+#line 317 "src/cfgparser.yy"
     { currentLightOmni = new ntlLightObject( reglob );
                  currentLight = currentLightOmni;
                        reglob->getLightList()->push_back(currentLight);
@@ -1721,28 +1719,28 @@ yyreduce:
     break;
 
   case 67:
-#line 333 "src/cfgparser.yy"
+#line 331 "src/cfgparser.yy"
     { 
                        currentLight->setActive( (yyvsp[0].intValue) ); 
                }
     break;
 
   case 68:
-#line 338 "src/cfgparser.yy"
+#line 336 "src/cfgparser.yy"
     { 
                        currentLight->setCastShadows( (yyvsp[0].intValue) ); 
                }
     break;
 
   case 69:
-#line 343 "src/cfgparser.yy"
+#line 341 "src/cfgparser.yy"
     { 
                        currentLight->setColor( ntlColor((yyvsp[-2].floatValue),(yyvsp[-1].floatValue),(yyvsp[0].floatValue)) ); 
                }
     break;
 
   case 70:
-#line 348 "src/cfgparser.yy"
+#line 346 "src/cfgparser.yy"
     { 
                int init = 0;
                if(currentLightOmni != NULL) {
@@ -1752,16 +1750,17 @@ yyreduce:
     break;
 
   case 71:
-#line 366 "src/cfgparser.yy"
+#line 364 "src/cfgparser.yy"
     {
                                // geo classes have attributes...
-                               reglob->getScene()->addGeoClass(currentGeoClass);
+                               reglob->getRenderScene()->addGeoClass(currentGeoClass);
+                               reglob->getSimScene()->addGeoClass(currentGeoClass);
                                currentAttrib = currentGeoClass->getAttributeList();
                        }
     break;
 
   case 72:
-#line 372 "src/cfgparser.yy"
+#line 371 "src/cfgparser.yy"
     { 
                                /* reset geometry object pointers */
                                currentGeoObj                    = NULL; 
@@ -1769,39 +1768,39 @@ yyreduce:
                                currentGeometrySim = NULL; 
                                currentGeometryModel = NULL; 
                                currentAttrib = NULL;
-#ifndef ELBEEM_BLENDER
+#ifndef ELBEEM_PLUGIN
                                currentGeometryBox = NULL; 
-#endif // ELBEEM_BLENDER
+#endif // ELBEEM_PLUGIN
                        }
     break;
 
   case 75:
-#line 390 "src/cfgparser.yy"
+#line 389 "src/cfgparser.yy"
     { 
-#ifndef ELBEEM_BLENDER
+#ifndef ELBEEM_PLUGIN
                        currentGeometryBox = new ntlGeometryBox( );
                        currentGeoClass = currentGeometryBox;
                        currentGeoObj = (ntlGeometryObject*)( currentGeometryBox );
-#else // ELBEEM_BLENDER
+#else // ELBEEM_PLUGIN
                        yyerror("GEOTYPE_BOX : This object type is not supported in this version!");
-#endif // ELBEEM_BLENDER
+#endif // ELBEEM_PLUGIN
                }
     break;
 
   case 76:
-#line 399 "src/cfgparser.yy"
+#line 398 "src/cfgparser.yy"
     { 
-#ifndef ELBEEM_BLENDER
+#ifndef ELBEEM_PLUGIN
                        currentGeoClass = new ntlGeometrySphere( );
                        currentGeoObj = (ntlGeometryObject*)( currentGeoClass );
-#else // ELBEEM_BLENDER
+#else // ELBEEM_PLUGIN
                        yyerror("GEOTYPE_SPHERE : This object type is not supported in this version!");
-#endif // ELBEEM_BLENDER
+#endif // ELBEEM_PLUGIN
                }
     break;
 
   case 77:
-#line 407 "src/cfgparser.yy"
+#line 406 "src/cfgparser.yy"
     { 
                        currentGeometryModel = new ntlGeometryObjModel( );
                        currentGeoClass = currentGeometryModel;
@@ -1810,7 +1809,7 @@ yyreduce:
     break;
 
   case 78:
-#line 412 "src/cfgparser.yy"
+#line 411 "src/cfgparser.yy"
     { 
                        currentGeometrySim = new SimulationObject();
                        currentGeoClass = currentGeometrySim;
@@ -1820,7 +1819,7 @@ yyreduce:
     break;
 
   case 79:
-#line 418 "src/cfgparser.yy"
+#line 417 "src/cfgparser.yy"
     { 
 #ifdef LBM_INCLUDE_TESTSOLVERS
                        currentGeometrySim = new SimulationCompareLbm();
@@ -1833,14 +1832,14 @@ yyreduce:
     break;
 
   case 89:
-#line 443 "src/cfgparser.yy"
+#line 442 "src/cfgparser.yy"
     { 
                        currentGeoClass->setName( (yyvsp[0].charValue) ); 
                }
     break;
 
   case 90:
-#line 448 "src/cfgparser.yy"
+#line 447 "src/cfgparser.yy"
     { 
                        if(currentGeoObj == NULL){ yyerror(" MATERIAL : This property can only be set for geometry objects!"); }
                        currentGeoObj->setMaterialName( (yyvsp[0].charValue) ); 
@@ -1848,7 +1847,7 @@ yyreduce:
     break;
 
   case 91:
-#line 454 "src/cfgparser.yy"
+#line 453 "src/cfgparser.yy"
     { 
                        if(currentGeoObj == NULL){ yyerror(" CAST_SHADOW : This property can only be set for geometry objects!"); }
                        currentGeoObj->setCastShadows( (yyvsp[0].intValue) ); 
@@ -1856,7 +1855,7 @@ yyreduce:
     break;
 
   case 92:
-#line 460 "src/cfgparser.yy"
+#line 459 "src/cfgparser.yy"
     { 
                        if(currentGeoObj == NULL){ yyerror(" RECEIVE_SHADOW : This property can only be set for geometry objects!"); }
                        currentGeoObj->setReceiveShadows( (yyvsp[0].intValue) ); 
@@ -1864,21 +1863,21 @@ yyreduce:
     break;
 
   case 93:
-#line 466 "src/cfgparser.yy"
+#line 465 "src/cfgparser.yy"
     { 
                        currentGeoClass->setVisible( (yyvsp[0].intValue) ); 
                }
     break;
 
   case 94:
-#line 471 "src/cfgparser.yy"
+#line 470 "src/cfgparser.yy"
     { 
                int init = 0;
-#ifndef ELBEEM_BLENDER
+#ifndef ELBEEM_PLUGIN
                if(currentGeometryBox != NULL){ 
                        currentGeometryBox->setStart( ntlVec3Gfx((yyvsp[-2].floatValue),(yyvsp[-1].floatValue),(yyvsp[0].floatValue)) ); init=1; }
-#else // ELBEEM_BLENDER
-#endif // ELBEEM_BLENDER
+#else // ELBEEM_PLUGIN
+#endif // ELBEEM_PLUGIN
                if(currentGeometrySim != NULL){ 
                        currentGeometrySim->setGeoStart( ntlVec3Gfx((yyvsp[-2].floatValue),(yyvsp[-1].floatValue),(yyvsp[0].floatValue)) ); init=1; }
                if(currentGeometryModel != NULL){ 
@@ -1888,14 +1887,14 @@ yyreduce:
     break;
 
   case 95:
-#line 486 "src/cfgparser.yy"
+#line 485 "src/cfgparser.yy"
     { 
                int init = 0;
-#ifndef ELBEEM_BLENDER
+#ifndef ELBEEM_PLUGIN
                if(currentGeometryBox != NULL){ 
                        currentGeometryBox->setEnd( ntlVec3Gfx((yyvsp[-2].floatValue),(yyvsp[-1].floatValue),(yyvsp[0].floatValue)) ); init=1; }
-#else // ELBEEM_BLENDER
-#endif // ELBEEM_BLENDER
+#else // ELBEEM_PLUGIN
+#endif // ELBEEM_PLUGIN
                if(currentGeometrySim != NULL){ 
                        currentGeometrySim->setGeoEnd( ntlVec3Gfx((yyvsp[-2].floatValue),(yyvsp[-1].floatValue),(yyvsp[0].floatValue)) ); init=1; }
                if(currentGeometryModel != NULL){ 
@@ -1905,20 +1904,23 @@ yyreduce:
     break;
 
   case 96:
-#line 502 "src/cfgparser.yy"
+#line 501 "src/cfgparser.yy"
     { 
                        if(attrs[(yyvsp[0].charValue)] == NULL){ yyerror("GEO ATTRIBUTES: The attribute was not found!"); }
-                       currentGeoClass->getAttributeList()->import( attrs[(yyvsp[0].charValue)] ); 
+                       else {
+                               if(currentGeoClass->getAttributeList())
+                                       currentGeoClass->getAttributeList()->import( attrs[(yyvsp[0].charValue)] ); 
+                       }
                }
     break;
 
   case 97:
-#line 510 "src/cfgparser.yy"
+#line 512 "src/cfgparser.yy"
     { }
     break;
 
   case 98:
-#line 522 "src/cfgparser.yy"
+#line 524 "src/cfgparser.yy"
     { 
                                /* reset geometry object pointers */
                                currentMaterial = NULL; 
@@ -1926,7 +1928,7 @@ yyreduce:
     break;
 
   case 101:
-#line 534 "src/cfgparser.yy"
+#line 536 "src/cfgparser.yy"
     { currentMaterial = new ntlMaterial( );
                        currentMaterial = currentMaterial;
                        reglob->getMaterials()->push_back(currentMaterial);
@@ -1934,34 +1936,34 @@ yyreduce:
     break;
 
   case 102:
-#line 538 "src/cfgparser.yy"
+#line 540 "src/cfgparser.yy"
     {
                yyerror("MATTYPE: Blinn NYI!"); }
     break;
 
   case 113:
-#line 556 "src/cfgparser.yy"
+#line 558 "src/cfgparser.yy"
     { 
                        currentMaterial->setName( (yyvsp[0].charValue) ); 
                }
     break;
 
   case 114:
-#line 561 "src/cfgparser.yy"
+#line 563 "src/cfgparser.yy"
     {
                        currentMaterial->setAmbientRefl( ntlColor((yyvsp[-2].floatValue),(yyvsp[-1].floatValue),(yyvsp[0].floatValue)) ); 
                }
     break;
 
   case 115:
-#line 566 "src/cfgparser.yy"
+#line 568 "src/cfgparser.yy"
     { 
                        currentMaterial->setDiffuseRefl( ntlColor((yyvsp[-2].floatValue),(yyvsp[-1].floatValue),(yyvsp[0].floatValue)) ); 
                }
     break;
 
   case 116:
-#line 571 "src/cfgparser.yy"
+#line 573 "src/cfgparser.yy"
     { 
                        currentMaterial->setSpecular( (yyvsp[-1].floatValue) ); 
                        currentMaterial->setSpecExponent( (yyvsp[0].floatValue) ); 
@@ -1969,56 +1971,56 @@ yyreduce:
     break;
 
   case 117:
-#line 577 "src/cfgparser.yy"
+#line 579 "src/cfgparser.yy"
     { 
                        currentMaterial->setMirror( (yyvsp[0].floatValue) ); 
                }
     break;
 
   case 118:
-#line 582 "src/cfgparser.yy"
+#line 584 "src/cfgparser.yy"
     { 
                        currentMaterial->setTransparence( (yyvsp[0].floatValue) ); 
                }
     break;
 
   case 119:
-#line 587 "src/cfgparser.yy"
+#line 589 "src/cfgparser.yy"
     { 
                        currentMaterial->setRefracIndex( (yyvsp[0].floatValue) ); 
                }
     break;
 
   case 120:
-#line 592 "src/cfgparser.yy"
+#line 594 "src/cfgparser.yy"
     { 
                        currentMaterial->setTransAdditive( (yyvsp[0].floatValue) ); 
                }
     break;
 
   case 121:
-#line 597 "src/cfgparser.yy"
+#line 599 "src/cfgparser.yy"
     { 
                        currentMaterial->setTransAttCol( ntlColor((yyvsp[-2].floatValue),(yyvsp[-1].floatValue),(yyvsp[0].floatValue)) ); 
                }
     break;
 
   case 122:
-#line 602 "src/cfgparser.yy"
+#line 604 "src/cfgparser.yy"
     {
                currentMaterial->setFresnel( (yyvsp[0].intValue) ); 
        }
     break;
 
   case 123:
-#line 613 "src/cfgparser.yy"
+#line 615 "src/cfgparser.yy"
     { 
                currentAttrib = new AttributeList((yyvsp[-1].charValue)); 
                currentAttrName = (yyvsp[-1].charValue); }
     break;
 
   case 124:
-#line 616 "src/cfgparser.yy"
+#line 618 "src/cfgparser.yy"
     { // store attribute
                        //std::cerr << " NEW ATTR " << currentAttrName << std::endl;
                        //currentAttrib->print();
@@ -2027,12 +2029,12 @@ yyreduce:
     break;
 
   case 129:
-#line 629 "src/cfgparser.yy"
+#line 631 "src/cfgparser.yy"
     { currentAttrValue.clear(); currentAttribAddName = (yyvsp[-1].charValue); }
     break;
 
   case 130:
-#line 630 "src/cfgparser.yy"
+#line 632 "src/cfgparser.yy"
     {
       currentAttrib->addAttr( currentAttribAddName, currentAttrValue, lineCount, true); 
                        //std::cerr << " ADD ATTRCHANNEL " << currentAttribAddName << std::endl;
@@ -2041,12 +2043,12 @@ yyreduce:
     break;
 
   case 132:
-#line 637 "src/cfgparser.yy"
+#line 639 "src/cfgparser.yy"
     { currentAttrValue.clear(); currentAttribAddName = (yyvsp[-1].charValue); }
     break;
 
   case 133:
-#line 638 "src/cfgparser.yy"
+#line 640 "src/cfgparser.yy"
     {
       currentAttrib->addAttr( currentAttribAddName, currentAttrValue, lineCount, false); 
                        //std::cerr << " ADD ATTRNORM " << currentAttribAddName << std::endl;
@@ -2055,21 +2057,21 @@ yyreduce:
     break;
 
   case 135:
-#line 645 "src/cfgparser.yy"
+#line 647 "src/cfgparser.yy"
     { 
                //std::cerr << "LLL "<<$2<<std::endl; // ignore newline entries  
                if(strcmp((yyvsp[0].charValue),"\n")) currentAttrValue.push_back((yyvsp[0].charValue)); }
     break;
 
   case 136:
-#line 648 "src/cfgparser.yy"
+#line 650 "src/cfgparser.yy"
     {  
                //std::cerr << "LRR "<<$1<<std::endl;
                if(strcmp((yyvsp[0].charValue),"\n")) currentAttrValue.push_back((yyvsp[0].charValue)); }
     break;
 
   case 138:
-#line 662 "src/cfgparser.yy"
+#line 664 "src/cfgparser.yy"
     {
   if ( ((yyvsp[0].floatValue) < 0.0) || ((yyvsp[0].floatValue) > 1.0) ) {
     yyerror("Value out of range (only 0 to 1 allowed)");
@@ -2081,17 +2083,17 @@ yyreduce:
     break;
 
   case 139:
-#line 674 "src/cfgparser.yy"
+#line 676 "src/cfgparser.yy"
     { (yyval.floatValue) = (yyvsp[0].floatValue); }
     break;
 
   case 140:
-#line 676 "src/cfgparser.yy"
+#line 678 "src/cfgparser.yy"
     { (yyval.floatValue) = (float) (yyvsp[0].intValue); /* conversion from integers */ }
     break;
 
   case 141:
-#line 682 "src/cfgparser.yy"
+#line 684 "src/cfgparser.yy"
     {
   if ( (yyvsp[0].intValue) <= 0 ) {
     yy_error("Value out of range (has to be above zero)");
@@ -2103,7 +2105,7 @@ yyreduce:
     break;
 
   case 142:
-#line 693 "src/cfgparser.yy"
+#line 695 "src/cfgparser.yy"
     {
   //cout << " " << $1 << " ";
   if ( (yyvsp[0].intValue) < 0 ) {
@@ -2116,7 +2118,7 @@ yyreduce:
     break;
 
   case 143:
-#line 705 "src/cfgparser.yy"
+#line 707 "src/cfgparser.yy"
     {
   if( ( (yyvsp[0].intValue) != 0 ) && ( (yyvsp[0].intValue) != 1 ) ) {
     yy_error("Boolean value has to be 1|0, 'true'|'false' or 'on'|'off'!");
@@ -2130,7 +2132,7 @@ yyreduce:
     }
 
 /* Line 1037 of yacc.c.  */
-#line 2134 "bld-std-gcc/src/cfgparser.cpp"
+#line 2136 "bld-std-gcc/src/cfgparser.cpp"
 \f
   yyvsp -= yylen;
   yyssp -= yylen;
@@ -2358,7 +2360,7 @@ yyreturn:
 }
 
 
-#line 713 "src/cfgparser.yy"
+#line 715 "src/cfgparser.yy"
 
 
 /*---------------------------------------------------------------------------*/
index 20b46f4e34638dc65e99d93539f17ad07020d55a..2b7791a78cb20c0379e2c9aa511201acd082eb27 100644 (file)
 
 
 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
-#line 87 "src/cfgparser.yy"
+#line 85 "src/cfgparser.yy"
 typedef union YYSTYPE {
   int    intValue;
   float  floatValue;
index a1072d842972bfaac82031edb6712366477bd2a0..8e96879737f0765bf5a7024bd3bd06c84d1555dc 100644 (file)
@@ -12,7 +12,7 @@
 #include "ntl_blenderdumper.h"
 extern "C" void elbeemCheckDebugEnv(void);
 
-#include "ntl_scene.h"
+#include "ntl_world.h"
 #include "ntl_geometrymodel.h"
 
 /*****************************************************************************/
@@ -29,15 +29,51 @@ int guiRoiMaxLev=6, guiRoiMinLev=0;
 //! global raytracer pointer (=world)
 ntlWorld *gpWorld = NULL;
 
-//! debug output switch
-bool myDebugOut = false;
 
-//! global leave program / abort variable
-bool gQuit = false;
+// API
 
+// reset elbeemSimulationSettings struct with defaults
+extern "C" 
+void elbeemResetSettings(elbeemSimulationSettings *set) {
+       if(!set) return;
+  set->version = 2;
+       for(int i=0 ; i<3; i++) set->geoStart[i] = 0.0;
+       for(int i=0 ; i<3; i++) set->geoSize[i] = 1.0;
+  set->resolutionxyz = 64;
+  set->previewresxyz = 24;
+  set->realsize = 1.0;
+  set->viscosity = 0.000001;
 
-// API
+       for(int i=0 ; i<2; i++) set->gravity[i] = 0.0;
+       set->gravity[2] = -9.81;
+
+  set->animStart = 0; 
+       set->aniFrameTime = 0.01;
+       set->noOfFrames = 10;
+  set->gstar = 0.005;
+  set->maxRefine = -1;
+  set->generateParticles = 1.0;
+  strcpy(set->outputPath,"./elbeemdata_");
+
+       set->channelSizeFrameTime=0;
+       set->channelFrameTime=NULL;
+       set->channelSizeViscosity=0;
+       set->channelViscosity=NULL;
+       set->channelSizeGravity=0;
+       set->channelGravity=NULL; 
 
+       set->obstacleType= FLUIDSIM_OBSTACLE_NOSLIP;
+       set->obstaclePartslip= 0.;
+       set->generateVertexVectors = 0;
+       set->surfaceSmoothing = 1.;
+
+       // init identity
+       for(int i=0; i<16; i++) set->surfaceTrafo[i] = 0.0;
+       for(int i=0; i<4; i++) set->surfaceTrafo[i*4+i] = 1.0;
+}
+
+// start fluidsim init
+extern "C" 
 int elbeemInit(elbeemSimulationSettings *settings) {
        gElbeemState = SIMWORLD_INVALID;
        strcpy(gElbeemErrorString,"[none]");
@@ -51,10 +87,41 @@ int elbeemInit(elbeemSimulationSettings *settings) {
        return 0;
 }
 
+// reset elbeemMesh struct with zeroes
+extern "C" 
+void elbeemResetMesh(elbeemMesh *mesh) {
+       if(!mesh) return;
+  mesh->type = 0;
+  mesh->numVertices = 0;
+       mesh->vertices = NULL;
+       mesh->numTriangles = 0;
+  mesh->triangles = NULL;
+       mesh->channelSizeTranslation = 0;
+       mesh->channelTranslation = NULL;
+       mesh->channelSizeRotation = 0;
+       mesh->channelRotation = NULL;
+       mesh->channelSizeScale = 0;
+       mesh->channelScale = NULL;
+       mesh->channelSizeActive = 0;
+       mesh->channelActive = NULL;
+       mesh->channelSizeInitialVel = 0;
+       mesh->channelInitialVel = NULL;
+       mesh->localInivelCoords = 0;
+       mesh->obstacleType= FLUIDSIM_OBSTACLE_NOSLIP;
+       mesh->obstaclePartslip= 0.;
+       mesh->name = "[unnamed]";
+}
+
+// add mesh as fluidsim object
+extern "C" 
 int elbeemAddMesh(elbeemMesh *mesh) {
        int initType = -1;
        switch(mesh->type) {
-               case OB_FLUIDSIM_OBSTACLE: initType = FGI_BNDNO; break;
+               case OB_FLUIDSIM_OBSTACLE: 
+                       if     (mesh->obstacleType==FLUIDSIM_OBSTACLE_PARTSLIP) initType = FGI_BNDPART; 
+                       else if(mesh->obstacleType==FLUIDSIM_OBSTACLE_FREESLIP) initType = FGI_BNDFREE; 
+                       else /*if(mesh->obstacleType==FLUIDSIM_OBSTACLE_NOSLIP)*/ initType = FGI_BNDNO; 
+                       break;
                case OB_FLUIDSIM_FLUID: initType = FGI_FLUID; break;
                case OB_FLUIDSIM_INFLOW: initType = FGI_MBNDINFLOW; break;
                case OB_FLUIDSIM_OUTFLOW: initType = FGI_MBNDOUTFLOW; break;
@@ -63,15 +130,30 @@ int elbeemAddMesh(elbeemMesh *mesh) {
        if(initType<0) return 1;
        
        ntlGeometryObjModel *obj = new ntlGeometryObjModel( );
-       gpWorld->getRenderGlobals()->getScene()->addGeoClass( obj );
+       gpWorld->getRenderGlobals()->getSimScene()->addGeoClass( obj );
        obj->initModel(mesh->numVertices, mesh->vertices, mesh->numTriangles, mesh->triangles);
-       obj->setGeoInitId(true);
+       if(mesh->name) obj->setName(std::string(mesh->name));
+       else obj->setName(std::string("[unnamed]"));
+       obj->setGeoInitId(1);
        obj->setGeoInitIntersect(true);
        obj->setGeoInitType(initType);
-       obj->setInitialVelocity( ntlVec3Gfx(mesh->iniVelx, mesh->iniVely, mesh->iniVelz) );
+       obj->setGeoPartSlipValue(mesh->obstaclePartslip);
+       // use channel instead, obj->setInitialVelocity( ntlVec3Gfx(mesh->iniVelocity[0], mesh->iniVelocity[1], mesh->iniVelocity[2]) );
+       obj->initChannels(
+                       mesh->channelSizeTranslation, mesh->channelTranslation, 
+                       mesh->channelSizeRotation,    mesh->channelRotation, 
+                       mesh->channelSizeScale,       mesh->channelScale,
+                       mesh->channelSizeActive,      mesh->channelActive,
+                       mesh->channelSizeInitialVel,  mesh->channelInitialVel
+               );
+       obj->setLocalCoordInivel( mesh->localInivelCoords );
+
+       debMsgStd("elbeemAddMesh",DM_MSG,"Added elbeem mesh: "<<obj->getName()<<" type="<<initType<<" "<<obj->getIsAnimated(), 9 );
        return 0;
 }
 
+// do the actual simulation
+extern "C" 
 int elbeemSimulate(void) {
        if(!gpWorld) return 1;
 
@@ -82,7 +164,7 @@ int elbeemSimulate(void) {
                myTime_t timestart = getTime();
                gpWorld->renderAnimation();
                myTime_t timeend = getTime();
-               debMsgStd("performElbeemSimulation",DM_NOTIFY, "El'Beem simulation done, time: "<<((timeend-timestart)/(double)1000.0) <<" seconds.\n", 2 ); 
+               debMsgStd("elbeemSimulate",DM_NOTIFY, "El'Beem simulation done, time: "<<getTimeString(timeend-timestart)<<".\n", 2 ); 
 
                // ok, we're done...
                delete gpWorld;
@@ -95,4 +177,121 @@ int elbeemSimulate(void) {
 }
 
 
+// global vector to flag values to remove
+vector<int> gKeepVal;
+
+#define SIMPLIFY_FLOAT_EPSILON (1e-6f)
+#define SIMPLIFY_DOUBLE_EPSILON (1e-12f)
+#define SFLOATEQ(x,y)  (ABS((x)-(y)) < SIMPLIFY_FLOAT_EPSILON)
+#define SDOUBLEEQ(x,y) (ABS((x)-(y)) < SIMPLIFY_DOUBLE_EPSILON)
+#define SVECFLOATEQ(x,y)  ( \
+       (ABS((x)[0]-(y)[0]) < SIMPLIFY_FLOAT_EPSILON) && \
+       (ABS((x)[1]-(y)[1]) < SIMPLIFY_FLOAT_EPSILON) && \
+       (ABS((x)[2]-(y)[2]) < SIMPLIFY_FLOAT_EPSILON) )
+
+// helper function - simplify animation channels
+extern "C" 
+int elbeemSimplifyChannelFloat(float *channel, int* size) {
+       bool changed = false;
+       int nsize = *size;
+       int orgsize = *size;
+       if(orgsize<1) return false;
+       gKeepVal.resize( orgsize );
+       for(int i=0; i<orgsize; i++) { gKeepVal[i] = true; }
+       const bool debugSF = false;
+
+       float last = channel[0 + 0];
+       for(int i=1; i<orgsize; i++) {
+               float curr = channel[2*i + 0];
+               bool remove = false;
+               if(SFLOATEQ(curr,last)) remove = true;
+               // dont remove if next value is different
+               if((remove)&&(i<orgsize-1)) {
+                       float next = channel[2*(i+1)+0];
+                       if(!SFLOATEQ(next,curr)) remove = false;
+               }
+               if(remove) {
+                       changed = true;
+                       gKeepVal[i] = false;
+                       nsize--;
+               }
+               if(debugSF) errMsg("elbeemSimplifyChannelFloat","i"<<i<<"/"<<orgsize<<" v"<<channel[ (i*2) + 0 ]<<" t"<<channel[ (i*2) + 1 ]<<"   nsize="<<nsize<<" r"<<remove );
+               last = curr;
+       }
+
+       if(changed) {
+               nsize = 1;
+               for(int i=1; i<orgsize; i++) {
+                       if(gKeepVal[i]) {
+                               channel[ (nsize*2) + 0 ] = channel[ (i*2) + 0 ];
+                               channel[ (nsize*2) + 1 ] = channel[ (i*2) + 1 ];
+                               nsize++;
+                       }
+               }
+               *size = nsize;
+       }
+
+       if(debugSF) for(int i=1; i<nsize; i++) {
+               errMsg("elbeemSimplifyChannelFloat","n i"<<i<<"/"<<nsize<<" v"<<channel[ (i*2) + 0 ]<<" t"<<channel[ (i*2) + 1 ] );
+       }
+
+       return changed;
+}
+
+extern "C" 
+int elbeemSimplifyChannelVec3(float *channel, int* size) {
+       bool changed = false;
+       int nsize = *size;
+       int orgsize = *size;
+       if(orgsize<1) return false;
+       gKeepVal.resize( orgsize );
+       for(int i=0; i<orgsize; i++) { gKeepVal[i] = true; }
+       const bool debugVF = false;
+
+       ntlVec3f last( channel[0 + 0], channel[0 + 1], channel[0 + 2] );
+       for(int i=1; i<orgsize; i++) {
+               ntlVec3f curr( channel[4*i + 0], channel[4*i + 1], channel[4*i + 2]);
+               bool remove = false;
+               if(SVECFLOATEQ(curr,last)) remove = true;
+               // dont remove if next value is different
+               if((remove)&&(i<orgsize-1)) {
+                       ntlVec3f next( channel[4*(i+1)+0], channel[4*(i+1)+1], channel[4*(i+1)+2]);
+                       if(!SVECFLOATEQ(next,curr)) remove = false;
+               }
+               if(remove) {
+                       changed = true;
+                       gKeepVal[i] = false;
+                       nsize--;
+               }
+               if(debugVF) errMsg("elbeemSimplifyChannelVec3","i"<<i<<"/"<<orgsize<<" v"<<
+                               channel[ (i*4) + 0 ]<<","<< channel[ (i*4) + 1 ]<<","<< channel[ (i*4) + 2 ]<<
+                               " t"<<channel[ (i*4) + 3 ]<<"   nsize="<<nsize<<" r"<<remove );
+               last = curr;
+       }
+
+       if(changed) {
+               nsize = 1;
+               for(int i=1; i<orgsize; i++) {
+                       if(gKeepVal[i]) {
+                               for(int j=0; j<4; j++){ channel[ (nsize*4) + j ] = channel[ (i*4) + j ]; }
+                               nsize++;
+                       }
+               }
+               *size = nsize;
+       }
+
+       if(debugVF) for(int i=1; i<nsize; i++) {
+               errMsg("elbeemSimplifyChannelVec3","n i"<<i<<"/"<<nsize<<" v"<<
+                               channel[ (i*4) + 0 ]<<","<< channel[ (i*4) + 1 ]<<","<< channel[ (i*4) + 2 ]<<
+                               " t"<<channel[ (i*4) + 3 ] );
+       }
+
+       return changed;
+}
+
+
+#undef SIMPLIFY_FLOAT_EPSILON
+#undef SIMPLIFY_DOUBLE_EPSILON
+#undef SFLOATEQ
+#undef SDOUBLEEQ
 
index efbda58a09618b89b158c31b8d18fb3fd6358922..83a9cb99afcad8ca5ad4e638500de383e4fd654e 100644 (file)
 #define ELBEEM_API_H
 
 
-
-/*! fluid geometry init types */
-#define FGI_FLAGSTART   16
-#define FGI_FLUID                        (1<<(FGI_FLAGSTART+ 0))
-#define FGI_NO_FLUID     (1<<(FGI_FLAGSTART+ 1))
-#define FGI_BNDNO                        (1<<(FGI_FLAGSTART+ 2))
-#define FGI_BNDFREE              (1<<(FGI_FLAGSTART+ 3))
-#define FGI_BNDPART              (1<<(FGI_FLAGSTART+ 4))
-#define FGI_NO_BND               (1<<(FGI_FLAGSTART+ 5))
-#define FGI_MBNDINFLOW (1<<(FGI_FLAGSTART+ 6))
-#define FGI_MBNDOUTFLOW        (1<<(FGI_FLAGSTART+ 7))
-
-#define FGI_ALLBOUNDS ( FGI_BNDNO | FGI_BNDFREE | FGI_BNDPART | FGI_MBNDINFLOW | FGI_MBNDOUTFLOW )
-
-
 /*! blender types for mesh->type */
 //#define OB_FLUIDSIM_DOMAIN      2
 #define OB_FLUIDSIM_FLUID       4
 #define OB_FLUIDSIM_INFLOW      16
 #define OB_FLUIDSIM_OUTFLOW     32
 
+#define FLUIDSIM_OBSTACLE_NOSLIP     1
+#define FLUIDSIM_OBSTACLE_PARTSLIP   2
+#define FLUIDSIM_OBSTACLE_FREESLIP   3
+
 
 // global settings for the simulation
 typedef struct elbeemSimulationSettings {
@@ -51,16 +40,39 @@ typedef struct elbeemSimulationSettings {
   /* fluid properties */
   double viscosity;
   /* gravity strength */
-  float gravx,gravy,gravz;
+  float gravity[3];
   /* anim start end time */
   float animStart, aniFrameTime;
+       /* no. of frames to simulate & output */
+       short noOfFrames;
   /* g star param (LBM compressibility) */
   float gstar;
   /* activate refinement? */
   short maxRefine;
+  /* amount of particles to generate (0=off) */
+  float generateParticles;
 
   /* store output path, and file prefix for baked fluid surface */
-  char surfdataPath[160+80];
+  char outputPath[160+80];
+
+       /* channel for frame time, visc & gravity animations */
+       int channelSizeFrameTime;
+       float *channelFrameTime;
+       int channelSizeViscosity;
+       float *channelViscosity;
+       int channelSizeGravity;
+       float *channelGravity;  // vector
+
+       /* boundary types and settings for domain walls */
+       short obstacleType;
+       float obstaclePartslip;
+       /* generate speed vectors for vertices (e.g. for image based motion blur)*/
+       short generateVertexVectors;
+       /* strength of surface smoothing */
+       float surfaceSmoothing;
+
+       /* global transformation to apply to fluidsim mesh */
+       float surfaceTrafo[4*4];
 } elbeemSimulationSettings;
 
 
@@ -69,9 +81,6 @@ typedef struct elbeemMesh {
   /* obstacle,fluid or inflow... */
   short type;
 
-  /* initial velocity (for fluid/inflow) */
-  float iniVelx,iniVely,iniVelz;
-
        /* vertices */
   int numVertices;
        float *vertices; // = float[][3];
@@ -79,13 +88,46 @@ typedef struct elbeemMesh {
        /* triangles */
        int   numTriangles;
   int   *triangles; // = int[][3];
+
+       /* animation channels */
+       int channelSizeTranslation;
+       float *channelTranslation;
+       int channelSizeRotation;
+       float *channelRotation;
+       int channelSizeScale;
+       float *channelScale;
+       
+       /* active channel */
+       int channelSizeActive;
+       float *channelActive;
+       /* initial velocity channel (e.g. for inflow) */
+       int channelSizeInitialVel;
+       float *channelInitialVel; // vector
+       /* use initial velocity in object coordinates? (e.g. for rotation) */
+       short localInivelCoords;
+       /* boundary types and settings */
+       short obstacleType;
+       float obstaclePartslip;
+
+       /* name of the mesh, mostly for debugging */
+       char *name;
 } elbeemMesh;
 
 // API functions
 
+#ifdef __cplusplus
+extern "C"  {
+#endif // __cplusplus
+// reset elbeemSimulationSettings struct with defaults
+void elbeemResetSettings(struct elbeemSimulationSettings*);
 // start fluidsim init
 int elbeemInit(struct elbeemSimulationSettings*);
 
+// reset elbeemMesh struct with zeroes
+void elbeemResetMesh(struct elbeemMesh*);
+
 // add mesh as fluidsim object
 int elbeemAddMesh(struct elbeemMesh*);
 
@@ -93,5 +135,30 @@ int elbeemAddMesh(struct elbeemMesh*);
 int elbeemSimulate(void);
 
 
+// helper function - simplify animation channels
+// returns if the channel and its size changed
+int elbeemSimplifyChannelFloat(float *channel, int *size);
+int elbeemSimplifyChannelVec3(float *channel, int *size);
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+/******************************************************************************/
+// internal defines, do not use for setting up simulation
+
+/*! fluid geometry init types */
+#define FGI_FLAGSTART   16
+#define FGI_FLUID                        (1<<(FGI_FLAGSTART+ 0))
+#define FGI_NO_FLUID     (1<<(FGI_FLAGSTART+ 1))
+#define FGI_BNDNO                        (1<<(FGI_FLAGSTART+ 2))
+#define FGI_BNDFREE              (1<<(FGI_FLAGSTART+ 3))
+#define FGI_BNDPART              (1<<(FGI_FLAGSTART+ 4))
+#define FGI_NO_BND               (1<<(FGI_FLAGSTART+ 5))
+#define FGI_MBNDINFLOW (1<<(FGI_FLAGSTART+ 6))
+#define FGI_MBNDOUTFLOW        (1<<(FGI_FLAGSTART+ 7))
+
+#define FGI_ALLBOUNDS ( FGI_BNDNO | FGI_BNDFREE | FGI_BNDPART | FGI_MBNDINFLOW | FGI_MBNDOUTFLOW )
+
 
 #endif // ELBEEM_API_H
diff --git a/intern/elbeem/intern/globals.h b/intern/elbeem/intern/globals.h
deleted file mode 100644 (file)
index c2a092a..0000000
+++ /dev/null
@@ -1,26 +0,0 @@
-/******************************************************************************
- *
- * El'Beem - Free Surface Fluid Simulation with the Lattice Boltzmann Method
- * All code distributed as part of El'Beem is covered by the version 2 of the 
- * GNU General Public License. See the file COPYING for details.
- * Copyright 2003-2005 Nils Thuerey
- *
- * Global variables (unavoidable at times...)
- * all defines in main.cpp
- *
- *****************************************************************************/
-
-/*****************************************************************************/
-//! user interface variables
-
-// global raytracer pointer (=world)
-class ntlWorld;
-extern ntlWorld *gpWorld;
-
-// debug output switch
-extern bool myDebugOut;
-
-// global leave program / abort variable
-extern bool gQuit;
-
index 545cdc89eff7b5ea98e2aa486413299fb31fa2c0..ed0fab289d8fc8647ad5ca6431d758f4799264f6 100644 (file)
@@ -9,7 +9,7 @@
 
 #include "isosurface.h"
 #include "mcubes_tables.h"
-#include "ntl_scene.h"
+#include "ntl_ray.h"
 
 #include <algorithm>
 #include <stdio.h>
 #include <ieeefp.h>
 #endif
 
-/*
-template class vector<IsoLevelVertex>;
-template class vector<int>;
-template class vector<unsigned int>;
-template class vector<float>;
-template class vector<ntlVec3Gfx>;
-template class vector< vector<int> >;
-*/
 
 /******************************************************************************
  * Constructor
  *****************************************************************************/
-IsoSurface::IsoSurface(double iso, double blend) :
+IsoSurface::IsoSurface(double iso) :
        ntlGeometryObject(),
        mSizex(-1), mSizey(-1), mSizez(-1),
+       mpData(NULL),
   mIsoValue( iso ), 
-       mBlendVal( blend ),
        mPoints(), 
        mpEdgeVerticesX(NULL), mpEdgeVerticesY(NULL), mpEdgeVerticesZ(NULL),
        mIndices(),
@@ -44,7 +36,10 @@ IsoSurface::IsoSurface(double iso, double blend) :
   mStart(0.0), mEnd(0.0), mDomainExtent(0.0),
   mInitDone(false),
        mSmoothSurface(0.0), mSmoothNormals(0.0),
-       mAcrossEdge(), mAdjacentFaces()
+       mAcrossEdge(), mAdjacentFaces(),
+       mCutoff(-1), // off by default
+       mFlagCnt(1),
+       mSCrad1(0.), mSCrad2(0.), mSCcenter(0.)
 {
 }
 
@@ -87,16 +82,6 @@ void IsoSurface::initializeIsosurface(int setx, int sety, int setz, ntlVec3Gfx e
   
        // marching cubes are ready 
        mInitDone = true;
-       /*unsigned long int memCnt = (3*sizeof(int)*nodes + sizeof(float)*nodes);
-       double memd = memCnt;
-       char *sizeStr = "";
-       const double sfac = 1000.0;
-       if(memd>sfac){ memd /= sfac; sizeStr="KB"; }
-       if(memd>sfac){ memd /= sfac; sizeStr="MB"; }
-       if(memd>sfac){ memd /= sfac; sizeStr="GB"; }
-       if(memd>sfac){ memd /= sfac; sizeStr="TB"; }
-
-       debMsgStd("IsoSurface::initializeIsosurface",DM_MSG,"Inited "<<PRINT_VEC(setx,sety,setz)<<" alloced:"<< memd<<" "<<sizeStr<<"." ,10);*/
 }
 
 
@@ -107,11 +92,10 @@ void IsoSurface::initializeIsosurface(int setx, int sety, int setz, ntlVec3Gfx e
  *****************************************************************************/
 IsoSurface::~IsoSurface( void )
 {
-
+       if(mpData) delete [] mpData;
        if(mpEdgeVerticesX) delete [] mpEdgeVerticesX;
        if(mpEdgeVerticesY) delete [] mpEdgeVerticesY;
        if(mpEdgeVerticesZ) delete [] mpEdgeVerticesZ;
-
 }
 
 
@@ -132,10 +116,10 @@ void IsoSurface::triangulate( void )
                return;
        }
 
-  // get grid spacing
-  gsx = (mEnd[0]-mStart[0])/(double)(mSizex-1.0);
-  gsy = (mEnd[1]-mStart[1])/(double)(mSizey-1.0);
-  gsz = (mEnd[2]-mStart[2])/(double)(mSizez-1.0);
+  // get grid spacing (-2 to have same spacing as sim)
+  gsx = (mEnd[0]-mStart[0])/(double)(mSizex-2.0);
+  gsy = (mEnd[1]-mStart[1])/(double)(mSizey-2.0);
+  gsz = (mEnd[2]-mStart[2])/(double)(mSizez-2.0);
 
   // clean up previous frame
        mIndices.clear();
@@ -169,13 +153,13 @@ void IsoSurface::triangulate( void )
                0,0,0,0,  1,1,1,1 };
 
   // let the cubes march 
-       pz = mStart[2]-gsz;
+       pz = mStart[2]-gsz*0.5;
        for(int k=1;k<(mSizez-2);k++) {
                pz += gsz;
-               py = mStart[1]-gsy;
+               py = mStart[1]-gsy*0.5;
                for(int j=1;j<(mSizey-2);j++) {
       py += gsy;
-                       px = mStart[0]-gsx;
+                       px = mStart[0]-gsx*0.5;
                        for(int i=1;i<(mSizex-2);i++) {
                        px += gsx;
                                int baseIn = ISOLEVEL_INDEX( i+0, j+0, k+0);
@@ -275,6 +259,12 @@ void IsoSurface::triangulate( void )
 
                                }
 
+                               const int coAdd=2;
+                               if(i<coAdd+mCutoff) continue;
+                               if(j<coAdd+mCutoff) continue;
+                               if((mCutoff>0) && (k<coAdd)) continue;
+                               if(i>mSizex-2-coAdd-mCutoff) continue;
+                               if(j>mSizey-2-coAdd-mCutoff) continue;
 
                                // Create the triangles... 
                                for(int e=0; mcTriTable[cubeIndex][e]!=-1; e+=3) {
@@ -283,13 +273,10 @@ void IsoSurface::triangulate( void )
                                        mIndices.push_back( triIndices[ mcTriTable[cubeIndex][e+1] ] );
                                        mIndices.push_back( triIndices[ mcTriTable[cubeIndex][e+2] ] );
                                }
-
                                
-      }
-    }
-
+      }//i
+    }// j
   } // k
-  
 
   // precalculate normals using an approximation of the scalar field gradient 
        for(int ni=0;ni<(int)mPoints.size();ni++) {
@@ -297,11 +284,10 @@ void IsoSurface::triangulate( void )
                normalize( mPoints[ni].n );
        }
 
-       //for(int i=0; i<mLoopSubdivs; i++) { subdivide(); }// DEBUG test
-       if(mSmoothSurface>0.0) { smoothSurface(mSmoothSurface); }
+       if(mSmoothSurface>0.0) { smoothSurface(mSmoothSurface, (mSmoothNormals<=0.0) ); }
        if(mSmoothNormals>0.0) { smoothNormals(mSmoothNormals); }
        myTime_t tritimeend = getTime(); 
-       debMsgStd("IsoSurface::triangulate",DM_MSG,"took "<< ((tritimeend-tritimestart)/(double)1000.0)<<"s, ss="<<mSmoothSurface<<" sm="<<mSmoothNormals , 10 );
+       debMsgStd("IsoSurface::triangulate",DM_MSG,"took "<< getTimeString(tritimeend-tritimestart)<<", S("<<mSmoothSurface<<","<<mSmoothNormals<<")" , 10 );
 }
 
 
@@ -406,7 +392,6 @@ inline ntlVec3Gfx IsoSurface::getNormal(int i, int j,int k) {
 
 
 
-
 /******************************************************************************
  * 
  * Surface improvement
@@ -418,334 +403,109 @@ inline ntlVec3Gfx IsoSurface::getNormal(int i, int j,int k) {
  * 
  *****************************************************************************/
 
-
-// Subdivide a mesh allways loop
-/*void IsoSurface::subdivide()
-{
-       int i;
-
-       mAdjacentFaces.clear(); 
-       mAcrossEdge.clear();
-
-       //void TriMesh::need_adjacentfaces()
-       {
-               vector<int> numadjacentfaces(mPoints.size());
-               //errMsg("SUBDIV ADJFA1", " "<<mPoints.size()<<" - "<<numadjacentfaces.size() );
-               int i;
-               for (i = 0; i < (int)mIndices.size()/3; i++) {
-                       numadjacentfaces[mIndices[i*3 + 0]]++;
-                       numadjacentfaces[mIndices[i*3 + 1]]++;
-                       numadjacentfaces[mIndices[i*3 + 2]]++;
-               }
-
-               mAdjacentFaces.resize(mPoints.size());
-               for (i = 0; i < (int)mPoints.size(); i++)
-                       mAdjacentFaces[i].reserve(numadjacentfaces[i]);
-
-               for (i = 0; i < (int)mIndices.size()/3; i++) {
-                       for (int j = 0; j < 3; j++)
-                               mAdjacentFaces[mIndices[i*3 + j]].push_back(i);
-               }
-
-       }
-
-       // Find the face across each edge from each other face (-1 on boundary)
-       // If topology is bad, not necessarily what one would expect...
-       //void TriMesh::need_across_edge()
-       {
-               mAcrossEdge.resize(mIndices.size(), -1);
-
-               for (int i = 0; i < (int)mIndices.size()/3; i++) {
-                       for (int j = 0; j < 3; j++) {
-                               if (mAcrossEdge[i*3 + j] != -1)
-                                       continue;
-                               int v1 = mIndices[i*3 + ((j+1)%3)];
-                               int v2 = mIndices[i*3 + ((j+2)%3)];
-                               const vector<int> &a1 = mAdjacentFaces[v1];
-                               const vector<int> &a2 = mAdjacentFaces[v2];
-                               for (int k1 = 0; k1 < (int)a1.size(); k1++) {
-                                       int other = a1[k1];
-                                       if (other == i)
-                                               continue;
-                                       vector<int>::const_iterator it =
-                                               std::find(a2.begin(), a2.end(), other);
-                                       if (it == a2.end())
-                                               continue;
-
-                                       //int ind = (faces[other].indexof(v1)+1)%3;
-                                       int ind = -1;
-                                       if( mIndices[other*3+0] == (unsigned int)v1 ) ind = 0;
-                                       else if( mIndices[other*3+1] == (unsigned int)v1 ) ind = 1;
-                                       else if( mIndices[other*3+2] == (unsigned int)v1 ) ind = 2;
-                                       ind = (ind+1)%3;
-
-                                       if ( (int)mIndices[other*3 + ((ind+1)%3)] != v2)
-                                               continue;
-                                       mAcrossEdge[i*3 + j] = other;
-                                       mAcrossEdge[other*3 + ind] = i;
-                                       break;
-                               }
-                       }
-               }
-
-               //errMsg("SUBDIV ACREDG", "Done.\n");
-       }
-
-       //errMsg("SUBDIV","start");
-       // Introduce new vertices
-       int nf = (int)mIndices.size() / 3;
-
-       //vector<TriMesh::Face> newverts(nf, TriMesh::Face(-1,-1,-1));
-       vector<int> newverts(nf*3); //, TriMesh::Face(-1,-1,-1));
-       for(int j=0; j<(int)newverts.size(); j++) newverts[j] = -1;
-
-       int old_nv = (int)mPoints.size();
-       mPoints.reserve(4 * old_nv);
-       vector<int> newvert_count(old_nv + 3*nf); // wichtig...?
-       //errMsg("NC", newvert_count.size() );
-
-       for (i = 0; i < nf; i++) {
-               for (int j = 0; j < 3; j++) {
-                       int ae = mAcrossEdge[i*3 + j];
-                       if (newverts[i*3 + j] == -1 && ae != -1) {
-                               if (mAcrossEdge[ae*3 + 0] == i)
-                                       newverts[i*3 + j] = newverts[ae*3 + 0];
-                               else if (mAcrossEdge[ae*3 + 1] == i)
-                                       newverts[i*3 + j] = newverts[ae*3 + 1];
-                               else if (mAcrossEdge[ae*3 + 2] == i)
-                                       newverts[i*3 + j] = newverts[ae*3 + 2];
-                       }
-                       if (newverts[i*3 + j] == -1) {
-                               IsoLevelVertex ilv;
-                               ilv.v = ntlVec3Gfx(0.0);
-                               ilv.n = ntlVec3Gfx(0.0);
-                               mPoints.push_back(ilv);
-                               newverts[i*3 + j] = (int)mPoints.size() - 1;
-                               if (ae != -1) {
-                                       if (mAcrossEdge[ae*3 + 0] == i)
-                                               newverts[ae*3 + 0] = newverts[i*3 + j];
-                                       else if (mAcrossEdge[ae*3 + 1] == i)
-                                               newverts[ae*3 + 1] = newverts[i*3 + j];
-                                       else if (mAcrossEdge[ae*3 + 2] == i)
-                                               newverts[ae*3 + 2] = newverts[i*3 + j];
-                               }
-                       }
-                       if(ae != -1) {
-                               mPoints[newverts[i*3 + j]].v +=
-                                       mPoints[ mIndices[i*3 + ( j     )] ].v * 0.25f  + // j = 0,1,2?
-                                       mPoints[ mIndices[i*3 + ((j+1)%3)] ].v * 0.375f +
-                                       mPoints[ mIndices[i*3 + ((j+2)%3)] ].v * 0.375f;
-#if RECALCNORMALS==0
-                               mPoints[newverts[i*3 + j]].n +=
-                                       mPoints[ mIndices[i*3 + ( j     )] ].n * 0.25f  + // j = 0,1,2?
-                                       mPoints[ mIndices[i*3 + ((j+1)%3)] ].n * 0.375f +
-                                       mPoints[ mIndices[i*3 + ((j+2)%3)] ].n * 0.375f;
-#endif // RECALCNORMALS==0
-                       } else {
-                               mPoints[newverts[i*3 + j]].v +=
-                                       mPoints[ mIndices[i*3 + ((j+1)%3)] ].v * 0.5f   +
-                                       mPoints[ mIndices[i*3 + ((j+2)%3)] ].v * 0.5f  ;
-#if RECALCNORMALS==0
-                               mPoints[newverts[i*3 + j]].n +=
-                                       mPoints[ mIndices[i*3 + ((j+1)%3)] ].n * 0.5f   +
-                                       mPoints[ mIndices[i*3 + ((j+2)%3)] ].n * 0.5f  ;
-#endif // RECALCNORMALS==0
-                       }
-
-                       newvert_count[newverts[i*3 + j]]++;
-               }
-       }
-       for (i = old_nv; i < (int)mPoints.size(); i++) {
-               if (!newvert_count[i])
-                       continue;
-               float scale = 1.0f / newvert_count[i];
-               mPoints[i].v *= scale;
-
-#if RECALCNORMALS==0
-               //mPoints[i].n *= scale;
-               //normalize( mPoints[i].n );
-#endif // RECALCNORMALS==0
-       }
-
-       // Update old vertices
-       for (i = 0; i < old_nv; i++) {
-                       ntlVec3Gfx bdyavg(0.0), nbdyavg(0.0);
-                       ntlVec3Gfx norm_bdyavg(0.0), norm_nbdyavg(0.0); // N
-                       int nbdy = 0, nnbdy = 0;
-                       int naf = (int)mAdjacentFaces[i].size();
-                       if (!naf)
-                               continue;
-                       for (int j = 0; j < naf; j++) {
-                               int af = mAdjacentFaces[i][j];
-
-                               int afi = -1;
-                               if( mIndices[af*3+0] == (unsigned int)i ) afi = 0;
-                               else if( mIndices[af*3+1] == (unsigned int)i ) afi = 1;
-                               else if( mIndices[af*3+2] == (unsigned int)i ) afi = 2;
-
-                               int n1 = (afi+1) % 3;
-                               int n2 = (afi+2) % 3;
-                               if (mAcrossEdge[af*3 + n1] == -1) {
-                                       bdyavg += mPoints[newverts[af*3 + n1]].v;
-#if RECALCNORMALS==0
-                                       //norm_bdyavg += mPoints[newverts[af*3 + n1]].n;
-#endif // RECALCNORMALS==0
-                                       nbdy++;
-                               } else {
-                                       nbdyavg += mPoints[newverts[af*3 + n1]].v;
-#if RECALCNORMALS==0
-                                       //norm_nbdyavg += mPoints[newverts[af*3 + n1]].n;
-#endif // RECALCNORMALS==0
-                                       nnbdy++;
-                               }
-                               if (mAcrossEdge[af*3 + n2] == -1) {
-                                       bdyavg += mPoints[newverts[af*3 + n2]].v;
-#if RECALCNORMALS==0
-                                       //norm_bdyavg += mPoints[newverts[af*3 + n2]].n;
-#endif // RECALCNORMALS==0
-                                       nbdy++;
-                               } else {
-                                       nbdyavg += mPoints[newverts[af*3 + n2]].v;
-#if RECALCNORMALS==0
-                                       //norm_nbdyavg += mPoints[newverts[af*3 + n2]].n;
-#endif // RECALCNORMALS==0
-                                       nnbdy++;
-                               }
-                       }
-
-                       float alpha;
-                       ntlVec3Gfx newpt;
-                       if (nbdy) {
-                               newpt = bdyavg / (float) nbdy;
-                               alpha = 0.5f;
-                       } else if (nnbdy) {
-                               newpt = nbdyavg / (float) nnbdy;
-                               if (nnbdy == 6)
-                                       alpha = 1.05;
-                               else if (nnbdy == 8)
-                                       alpha = 0.86;
-                               else if (nnbdy == 10)
-                                       alpha = 0.7;
-                               else
-                                       alpha = 0.6;
-                       } else {
-                               continue;
-                       }
-                       mPoints[i].v *= 1.0f - alpha;
-                       mPoints[i].v += newpt * alpha;
-
-#if RECALCNORMALS==0
-                       //mPoints[i].n *= 1.0f - alpha;
-                       //mPoints[i].n += newpt * alpha;
-#endif // RECALCNORMALS==0
-       }
-
-       // Insert new faces
-       mIndices.reserve(4*nf);
-       for (i = 0; i < nf; i++) {
-               mIndices.push_back( mIndices[i*3 + 0]);
-               mIndices.push_back( newverts[i*3 + 2]);
-               mIndices.push_back( newverts[i*3 + 1]);
-
-               mIndices.push_back( mIndices[i*3 + 1]);
-               mIndices.push_back( newverts[i*3 + 0]);
-               mIndices.push_back( newverts[i*3 + 2]);
-
-               mIndices.push_back( mIndices[i*3 + 2]);
-               mIndices.push_back( newverts[i*3 + 1]);
-               mIndices.push_back( newverts[i*3 + 0]);
-
-               mIndices[i*3+0] = newverts[i*3+0];
-               mIndices[i*3+1] = newverts[i*3+1];
-               mIndices[i*3+2] = newverts[i*3+2];
-       }
-
-       // recalc normals
-#if RECALCNORMALS==1
-       {
-               int nf = (int)mIndices.size()/3, nv = (int)mPoints.size(), i;
-               for (i = 0; i < nv; i++) {
-                       mPoints[i].n = ntlVec3Gfx(0.0);
-               }
-               for (i = 0; i < nf; i++) {
-                       const ntlVec3Gfx &p0 = mPoints[mIndices[i*3+0]].v;
-                       const ntlVec3Gfx &p1 = mPoints[mIndices[i*3+1]].v;
-                       const ntlVec3Gfx &p2 = mPoints[mIndices[i*3+2]].v;
-                       ntlVec3Gfx a = p0-p1, b = p1-p2, c = p2-p0;
-                       float l2a = normNoSqrt(a), l2b = normNoSqrt(b), l2c = normNoSqrt(c);
-
-                       ntlVec3Gfx facenormal = cross(a, b);
-
-                       mPoints[mIndices[i*3+0]].n += facenormal * (1.0f / (l2a * l2c));
-                       mPoints[mIndices[i*3+1]].n += facenormal * (1.0f / (l2b * l2a));
-                       mPoints[mIndices[i*3+2]].n += facenormal * (1.0f / (l2c * l2b));
-               }
-
-               for (i = 0; i < nv; i++) {
-                       normalize(mPoints[i].n);
-               }
-       }
-#else // RECALCNORMALS==1
-               for (i = 0; i < (int)mPoints.size(); i++) {
-                       normalize(mPoints[i].n);
-               }
-#endif // RECALCNORMALS==1
-
-       //errMsg("SUBDIV","done nv:"<<mPoints.size()<<" nf:"<<mIndices.size() );
-}*/
-
+void IsoSurface::setSmoothRad(float radi1, float radi2, ntlVec3Gfx mscc) {
+       mSCrad1 = radi1*radi1;
+       mSCrad2 = radi2*radi2;
+       mSCcenter = mscc;
+}
 
 // Diffuse a vector field at 1 vertex, weighted by
 // a gaussian of width 1/sqrt(invsigma2)
-void IsoSurface::diffuseVertexField(ntlVec3Gfx *field, const int pointerScale, int v, float invsigma2, ntlVec3Gfx &flt)
+bool IsoSurface::diffuseVertexField(ntlVec3Gfx *field, const int pointerScale, int src, float invsigma2, ntlVec3Gfx &flt)
 {
+       if((neighbors[src].size()<1) || (pointareas[src]<=0.0)) return 0;
+       const ntlVec3Gfx srcp = mPoints[src].v;
+       const ntlVec3Gfx srcn = mPoints[src].n;
+       if(mSCrad1>0.0 && mSCrad2>0.0) {
+               ntlVec3Gfx dp = mSCcenter-srcp; dp[2] = 0.0; // only xy-plane
+               float rd = normNoSqrt(dp);
+               if(rd > mSCrad2) {
+               //errMsg("TRi","p"<<srcp<<" c"<<mSCcenter<<" rd:"<<rd<<" r1:"<<mSCrad1<<" r2:"<<mSCrad2<<" ");
+                       //invsigma2 *= (rd*rd-mSCrad1);
+                       //flt = ntlVec3Gfx(100); return 1;
+                       return 0;
+               } else if(rd > mSCrad1) {
+                       // optimize?
+                       float org = 1.0/sqrt(invsigma2);
+                       org *= (1.0- (rd-mSCrad1) / (mSCrad2-mSCrad1));
+                       invsigma2 = 1.0/(org*org);
+                       //flt = ntlVec3Gfx((rd-mSCrad1) / (mSCrad2-mSCrad1)); return 1;
+                       //errMsg("TRi","p"<<srcp<<" rd:"<<rd<<" r1:"<<mSCrad1<<" r2:"<<mSCrad2<<" org:"<<org<<" is:"<<invsigma2);
+                       //invsigma2 *= (rd*rd-mSCrad1);
+                       //return 0;
+               } else {
+               }
+       }
        flt = ntlVec3Gfx(0.0);
-       flt += *(field+pointerScale*v) *pointareas[v];
-       float sum_w = pointareas[v];
-       const ntlVec3Gfx &nv = mPoints[v].n;
-
-       unsigned &flag = flag_curr;
-       flag++;
-       flags[v] = flag;
-       vector<int> boundary = neighbors[v];
-       while (!boundary.empty()) {
-               const int bbn = boundary.back();
-               boundary.pop_back();
-               if (flags[bbn] == flag) continue;
+       flt += *(field+pointerScale*src) *pointareas[src];
+       float sum_w = pointareas[src];
+       //const ntlVec3Gfx &nv = mPoints[src].n;
+
+       int flag = mFlagCnt; 
+       mFlagCnt++;
+       flags[src] = flag;
+       //vector<int> mDboundary = neighbors[src];
+       mDboundary = neighbors[src];
+       while (!mDboundary.empty()) {
+               const int bbn = mDboundary.back();
+               mDboundary.pop_back();
+               if(flags[bbn]==flag) continue;
                flags[bbn] = flag;
 
+               // normal check
+               const float nvdot = dot(srcn, mPoints[bbn].n); // faster than before d2 calc?
+               if(nvdot <= 0.0f) continue; // faster than before d2 calc?
+
                // gaussian weight of width 1/sqrt(invsigma2)
-               const float d2 = invsigma2 * normNoSqrt(mPoints[bbn].v - mPoints[v].v);
+               const float d2 = invsigma2 * normNoSqrt(mPoints[bbn].v - srcp);
                if(d2 >= 9.0f) continue; // 25 also possible  , slower
-               //float w = (d2 >=  9.0f) ? 0.0f : exp(-0.5f*d2);
-               float w = exp(-0.5f*d2);
-               if(dot(nv, mPoints[bbn].n) <= 0.0f) continue; // faster than before d2 calc?
+               //if(dot(srcn, mPoints[bbn].n) <= 0.0f) continue; // faster than before d2 calc?
 
+               //float w = (d2 >=  9.0f) ? 0.0f : exp(-0.5f*d2);
+               //float w = expf(-0.5f*d2); 
+#if 0
+               float w=1.0;
                // Downweight things pointing in different directions
-               w *= dot(nv , mPoints[bbn].n);
+               w *= nvdot; //dot(srcn , mPoints[bbn].n);
                // Surface area "belonging" to each point
                w *= pointareas[bbn];
                // Accumulate weight times field at neighbor
                flt += *(field+pointerScale*bbn)*w;
-
                sum_w += w;
-               for (int i = 0; i < (int)neighbors[bbn].size(); i++) {
-                       int nn = neighbors[bbn][i];
+               // */
+#else
+               // more aggressive smoothing with: float w=1.0;
+               float w=nvdot * pointareas[bbn];
+               // Accumulate weight times field at neighbor
+               flt += *(field+pointerScale*bbn)*w;
+               sum_w += w;
+#endif
+               // */
+
+               for(int i = 0; i < (int)neighbors[bbn].size(); i++) {
+                       const int nn = neighbors[bbn][i];
                        if (flags[nn] == flag) continue;
-                       boundary.push_back(nn);
+                       mDboundary.push_back(nn);
                }
        }
        flt /= sum_w;
+       return 1;
 }
 
-void IsoSurface::smoothSurface(float sigma)
+// REF
+// TestData::getTriangles message: Time for surface generation:3.75s, S(0.0390625,0.1171875) 
+       // ntlWorld::ntlWorld message: Time for start-sims:0s
+       // TestData::getTriangles message: Time for surface generation:3.69s, S(0.0390625,0.1171875) 
+
+       
+
+void IsoSurface::smoothSurface(float sigma, bool normSmooth)
 {
        int nv = mPoints.size();
        if ((int)flags.size() != nv) flags.resize(nv);
        int nf = mIndices.size()/3;
 
        { // need neighbors
-
                vector<int> numneighbors(mPoints.size());
                int i;
                for (i = 0; i < (int)mIndices.size()/3; i++) {
@@ -845,10 +605,11 @@ void IsoSurface::smoothSurface(float sigma)
 
        vector<ntlVec3Gfx> dflt(nv);
        for (int i = 0; i < nv; i++) {
-               diffuseVertexField( &mPoints[0].v, 2,
-                                  i, invsigma2, dflt[i]);
-               // Just keep the displacement
-               dflt[i] -= mPoints[i].v;
+               if(diffuseVertexField( &mPoints[0].v, 2,
+                                  i, invsigma2, dflt[i])) {
+                       // Just keep the displacement
+                       dflt[i] -= mPoints[i].v;
+               } else { dflt[i] = 0.0; } //?mPoints[i].v; }
        }
 
        // Slightly better small-neighborhood approximation
@@ -869,8 +630,9 @@ void IsoSurface::smoothSurface(float sigma)
        // Filter displacement field
        vector<ntlVec3Gfx> dflt2(nv);
        for (int i = 0; i < nv; i++) {
-               diffuseVertexField( &dflt[0], 1,
-                                  i, invsigma2, dflt2[i]);
+               if(diffuseVertexField( &dflt[0], 1,
+                                  i, invsigma2, dflt2[i])) { }
+               else { /*mPoints[i].v=0.0;*/ dflt2[i] = 0.0; }//dflt2[i]; }
        }
 
        // Update vertex positions
@@ -881,10 +643,13 @@ void IsoSurface::smoothSurface(float sigma)
        // when normals smoothing off, this cleans up quite well
        // costs ca. 50% additional time though
        float nsFac = 1.5f;
-       { float ninvsigma2 = 1.0f / (nsFac*nsFac*sigma*sigma);
+       if(normSmooth) { float ninvsigma2 = 1.0f / (nsFac*nsFac*sigma*sigma);
                for (int i = 0; i < nv; i++) {
-                       diffuseVertexField( &mPoints[0].n, 2, i, ninvsigma2, dflt[i]);
-                       normalize(dflt[i]);
+                       if( diffuseVertexField( &mPoints[0].n, 2, i, ninvsigma2, dflt[i]) ) {
+                               normalize(dflt[i]);
+                       } else {
+                               dflt[i] = mPoints[i].n;
+                       }
                }
                for (int i = 0; i < nv; i++) {
                        mPoints[i].n = dflt[i];
@@ -896,7 +661,9 @@ void IsoSurface::smoothSurface(float sigma)
 
 void IsoSurface::smoothNormals(float sigma)
 {
-       { // need neighbor
+       // reuse from smoothSurface
+       if(neighbors.size() != mPoints.size()) { 
+               // need neighbor
                vector<int> numneighbors(mPoints.size());
                int i;
                for (i = 0; i < (int)mIndices.size()/3; i++) {
@@ -998,13 +765,13 @@ void IsoSurface::smoothNormals(float sigma)
 
        vector<ntlVec3Gfx> nflt(nv);
        for (int i = 0; i < nv; i++) {
-               diffuseVertexField( &mPoints[0].n, 2, i, invsigma2, nflt[i]);
-               normalize(nflt[i]);
+               if(diffuseVertexField( &mPoints[0].n, 2, i, invsigma2, nflt[i])) {
+                       normalize(nflt[i]);
+               } else { nflt[i]=mPoints[i].n; }
        }
 
-       for (int i = 0; i < nv; i++) {
-               mPoints[i].n = nflt[i];
-       }
+       // copy back
+       for (int i = 0; i < nv; i++) { mPoints[i].n = nflt[i]; }
 
        //errMsg("SMNRMLS","done v:"<<sigma); // DEBUG
 }
index 9682b571b2153f01ebaeceb4133fbce4c4dc6890..90a4e11e95f1ac0216ecb42853caa674e403ffef 100644 (file)
@@ -40,9 +40,9 @@ class IsoSurface :
        public:
 
                /*! Constructor */
-               IsoSurface(double iso, double blend);
+               IsoSurface(double iso);
                /*! Destructor */
-               ~IsoSurface();
+               virtual ~IsoSurface();
 
                /*! Init ararys etc. */
                virtual void initializeIsosurface(int setx, int sety, int setz, ntlVec3Gfx extent);
@@ -63,9 +63,6 @@ class IsoSurface :
                //! Level of the iso surface 
                double mIsoValue;
 
-               //! blending distance for marching cubes 
-               double mBlendVal;
-
                //! Store all the triangles vertices 
                vector<IsoLevelVertex> mPoints;
 
@@ -96,8 +93,12 @@ class IsoSurface :
                vector<int> mAcrossEdge;
                vector< vector<int> > mAdjacentFaces;
 
-               vector<unsigned> flags;
-               unsigned flag_curr;
+               //! cutoff border area
+               int mCutoff;
+               
+               //! trimesh vars
+               vector<int> flags;
+               int mFlagCnt;
                vector<ntlVec3Gfx> cornerareas;
                vector<float> pointareas;
                vector< vector<int> > neighbors;
@@ -116,6 +117,8 @@ class IsoSurface :
                //! set loop subdiv num
                inline void setSmoothSurface(float set) { mSmoothSurface = set; };
                inline void setSmoothNormals(float set) { mSmoothNormals = set; };
+               inline float getSmoothSurface() { return mSmoothSurface; }
+               inline float getSmoothNormals() { return mSmoothNormals; }
 
                // geometry object functions 
                virtual void getTriangles( vector<ntlTriangle> *triangles, 
@@ -155,6 +158,8 @@ class IsoSurface :
                        return mpData + ISOLEVEL_INDEX(ii+1,jj+1,kk+1); 
 #endif
                }
+               //! set cut off border
+               inline void setCutoff(int set) { mCutoff = set; };
 
                //! OpenGL viz "interface"
                unsigned int getIsoVertexCount() {
@@ -169,16 +174,21 @@ class IsoSurface :
                unsigned int *getIsoIndexArray() {
                        return &(mIndices[0]);
                }
+               
+               // surface smoothing functions
+               void setSmoothRad(float radi1, float radi2, ntlVec3Gfx mscc);
+               void smoothSurface(float val, bool smoothNorm);
+               void smoothNormals(float val);
 
        protected:
 
-               //! computer normal
+               //! compute normal
                inline ntlVec3Gfx getNormal(int i, int j,int k);
-
-               void subdivide();
-               void smoothSurface(float val);
-               void smoothNormals(float val);
-               void diffuseVertexField(ntlVec3Gfx *field, const int pointerScale, int v, float invsigma2, ntlVec3Gfx &flt);
+               //! smoothing helper function
+               bool diffuseVertexField(ntlVec3Gfx *field, int pointerScale, int v, float invsigma2, ntlVec3Gfx &flt);
+               vector<int> mDboundary;
+               float mSCrad1, mSCrad2;
+               ntlVec3Gfx mSCcenter;
 };
 
 
index e9e67b1a72d1fc36059686772deafdb2fffee3c9..fce5a085f595f09d1bccf7b90f7f1fbefe344bb1 100644 (file)
@@ -14,7 +14,8 @@
 #include "utilities.h"
 #include "ntl_matrices.h"
 #include "ntl_blenderdumper.h"
-#include "ntl_scene.h"
+#include "ntl_world.h"
+#include "solver_interface.h"
 
 #include <zlib.h>
 
@@ -31,17 +32,15 @@ ntlBlenderDumper::ntlBlenderDumper(string filename, bool commandlineMode) :
        AttributeList *pAttrs = glob->getBlenderAttributes();
        mpTrafo = new ntlMat4Gfx(0.0);
        mpTrafo->initId();
-       (*mpTrafo) = pAttrs->readMat4Gfx("transform" , (*mpTrafo), "ntlBlenderDumper","mpTrafo", false ); 
+       pAttrs->readMat4Gfx("transform" , (*mpTrafo), "ntlBlenderDumper","mpTrafo", false, mpTrafo ); 
 }
 ntlBlenderDumper::ntlBlenderDumper(elbeemSimulationSettings *settings) :
        ntlWorld(settings), mpTrafo(NULL)
 {
        // same as normal constructor here
-  ntlRenderGlobals *glob = mpGlob;
-       AttributeList *pAttrs = glob->getBlenderAttributes();
        mpTrafo = new ntlMat4Gfx(0.0);
-       mpTrafo->initId();
-       (*mpTrafo) = pAttrs->readMat4Gfx("transform" , (*mpTrafo), "ntlBlenderDumper","mpTrafo", false ); 
+       mpTrafo->initArrayCheck(settings->surfaceTrafo);
+       //errMsg("ntlBlenderDumper","mpTrafo inited: "<<(*mpTrafo) );
 }
 
 
@@ -52,6 +51,7 @@ ntlBlenderDumper::ntlBlenderDumper(elbeemSimulationSettings *settings) :
 ntlBlenderDumper::~ntlBlenderDumper()
 {
        delete mpTrafo;
+       debMsgStd("ntlBlenderDumper",DM_NOTIFY, "ntlBlenderDumper done", 10);
 }
 
 /******************************************************************************
@@ -61,11 +61,11 @@ int ntlBlenderDumper::renderScene( void )
 {
        char nrStr[5];                                                          /* nr conversion */
   ntlRenderGlobals *glob = mpGlob;
-  ntlScene *scene = mpGlob->getScene();
+  ntlScene *scene = mpGlob->getSimScene();
        bool debugOut = true;
-#if ELBEEM_BLENDER==1
+#if ELBEEM_PLUGIN==1
        debugOut = false;
-#endif // ELBEEM_BLENDER==1
+#endif // ELBEEM_PLUGIN==1
 
        // output path
        /*std::ostringstream ecrpath("");
@@ -91,6 +91,7 @@ int ntlBlenderDumper::renderScene( void )
   vector<ntlTriangle> Triangles;
   vector<ntlVec3Gfx>  Vertices;
   vector<ntlVec3Gfx>  VertNormals;
+       errMsg("ntlBlenderDumper","mpTrafo : "<<(*mpTrafo) );
 
        /* init geometry array, first all standard objects */
        int idCnt = 0;          // give IDs to objects
@@ -106,80 +107,117 @@ int ntlBlenderDumper::renderScene( void )
                if(tid & GEOCLASSTID_SHADER) {
                        ntlGeometryShader *geoshad = (ntlGeometryShader*)(*iter); //dynamic_cast<ntlGeometryShader*>(*iter);
                        hideObjs.push_back( (*iter)->getName() );
+                       geoshad->notifyShaderOfDump(glob->getAniCount(),nrStr,glob->getOutFilename());
                        for (vector<ntlGeometryObject*>::iterator siter = geoshad->getObjectsBegin();
                                        siter != geoshad->getObjectsEnd();
                                        siter++) {
                                if(debugOut) debMsgStd("ntlBlenderDumper::BuildScene",DM_MSG,"added shader geometry "<<(*siter)->getName(), 8);
+
+                               (*siter)->notifyOfDump(glob->getAniCount(),nrStr,glob->getOutFilename());
+                               bool doDump = false;
+                               bool isPreview = false;
+                               // only dump final&preview surface meshes
+                               if( (*siter)->getName().find( "final" ) != string::npos) {
+                                       doDump = true;
+                               } else if( (*siter)->getName().find( "preview" ) != string::npos) {
+                                       doDump = true;
+                                       isPreview = true;
+                               }
+                               if(!doDump) continue;
                                
                                // only dump geo shader objects
                                Triangles.clear();
                                Vertices.clear();
                                VertNormals.clear();
                                (*siter)->initialize( mpGlob );
+                               //int vstart = mVertNormals.size()-1;
                                (*siter)->getTriangles(&Triangles, &Vertices, &VertNormals, idCnt);
+
                                idCnt ++;
 
                                // always dump mesh, even empty ones...
-                               //if(Vertices.size() <= 0) continue;
-                               //if(Triangles.size() <= 0) continue;
-
-                               for(size_t i=0; i<Vertices.size(); i++) {
-                                       Vertices[i] = (*mpTrafo) * Vertices[i];
-                               }
 
                                // dump to binary file
                                std::ostringstream boutfilename("");
                                //boutfilename << ecrpath.str() << glob->getOutFilename() <<"_"<< (*siter)->getName() <<"_" << nrStr << ".obj";
-                               boutfilename << glob->getOutFilename() <<"_"<< (*siter)->getName() <<"_" << nrStr << ".bobj";
+                               boutfilename << glob->getOutFilename() <<"_"<< (*siter)->getName() <<"_" << nrStr;
                                if(debugOut) debMsgStd("ntlBlenderDumper::renderScene",DM_MSG,"B-Dumping: "<< (*siter)->getName() 
                                                <<", triangles:"<<Triangles.size()<<", vertices:"<<Vertices.size()<<
                                                " to "<<boutfilename.str() , 7);
-                               bool isPreview = false;
-                               if( (*siter)->getName().find( "preview" ) != string::npos) {
-                                       isPreview = true;
-                               }
-                               boutfilename << ".gz";
-
-                               // compress all bobj's except for preview ones...
                                gzFile gzf;
-                               if(isPreview) {
-                                       gzf = gzopen(boutfilename.str().c_str(), "wb1");
-                               } else {
-                                       gzf = gzopen(boutfilename.str().c_str(), "wb9");
+
+                               // output velocities if desired
+                               // WARNING - this is dirty, but simobjs are the only geoshaders right now
+                               SimulationObject *sim = (SimulationObject *)geoshad;
+                               LbmSolverInterface *lbm = sim->getSolver();
+                               if((!isPreview) && (lbm->getDumpVelocities())) {
+                                       std::ostringstream bvelfilename;
+                                       bvelfilename << boutfilename.str();
+                                       bvelfilename << ".bvel.gz";
+                                       gzf = gzopen(bvelfilename.str().c_str(), "wb9");
+                                       if(gzf) {
+                                               int numVerts;
+                                               if(sizeof(numVerts)!=4) { errMsg("ntlBlenderDumper::renderScene","Invalid int size"); return 1; }
+                                               numVerts = Vertices.size();
+                                               gzwrite(gzf, &numVerts, sizeof(numVerts));
+                                               for(size_t i=0; i<Vertices.size(); i++) {
+                                                       // returns smoothed velocity, scaled by frame time
+                                                       ntlVec3Gfx v = lbm->getVelocityAt( Vertices[i][0], Vertices[i][1], Vertices[i][2] );
+                                                       // translation not necessary, test rotation & scaling?
+                                                       //? v = (*mpTrafo) * v;
+                                                       for(int j=0; j<3; j++) {
+                                                               float vertp = v[j];
+                                                               //if(i<20) errMsg("ntlBlenderDumper","DUMP_VEL final "<<i<<" = "<<v);
+                                                               gzwrite(gzf, &vertp, sizeof(vertp)); }
+                                               }
+                                               gzclose( gzf );
+                                       }
                                }
+
+                               // compress all bobj's 
+                               boutfilename << ".bobj.gz";
+                               //if(isPreview) { } else { }
+                               gzf = gzopen(boutfilename.str().c_str(), "wb1"); // wb9 is slow for large meshes!
                                if (!gzf) {
                                        errMsg("ntlBlenderDumper::renderScene","Unable to open output '"<<boutfilename<<"' ");
                                        return 1; }
                                
-                               int wri;
-                               float wrf;
-                               if(sizeof(wri)!=4) { errMsg("ntlBlenderDumper::renderScene","Invalid int size"); return 1; }
-                               wri = Vertices.size();
-                               gzwrite(gzf, &wri, sizeof(wri));
+                               // transform into source space
+                               for(size_t i=0; i<Vertices.size(); i++) {
+                                       Vertices[i] = (*mpTrafo) * Vertices[i];
+                               }
+                               // write to file
+                               int numVerts;
+                               if(sizeof(numVerts)!=4) { errMsg("ntlBlenderDumper::renderScene","Invalid int size"); return 1; }
+                               numVerts = Vertices.size();
+                               gzwrite(gzf, &numVerts, sizeof(numVerts));
                                for(size_t i=0; i<Vertices.size(); i++) {
                                        for(int j=0; j<3; j++) {
-                                               wrf = Vertices[i][j];
-                                               gzwrite(gzf, &wrf, sizeof(wrf)); }
+                                               float vertp = Vertices[i][j];
+                                               gzwrite(gzf, &vertp, sizeof(vertp)); }
                                }
 
                                // should be the same as Vertices.size
-                               wri = VertNormals.size();
-                               gzwrite(gzf, &wri, sizeof(wri));
+                               if(VertNormals.size() != (size_t)numVerts) {
+                                       errMsg("ntlBlenderDumper::renderScene","Normals have to have same size as vertices!");
+                                       VertNormals.resize( Vertices.size() );
+                               }
+                               gzwrite(gzf, &numVerts, sizeof(numVerts));
                                for(size_t i=0; i<VertNormals.size(); i++) {
                                        for(int j=0; j<3; j++) {
-                                               wrf = VertNormals[i][j];
-                                               gzwrite(gzf, &wrf, sizeof(wrf)); }
+                                               float normp = VertNormals[i][j];
+                                               gzwrite(gzf, &normp, sizeof(normp)); }
                                }
 
-                               wri = Triangles.size();
-                               gzwrite(gzf, &wri, sizeof(wri));
+                               int numTris = Triangles.size();
+                               gzwrite(gzf, &numTris, sizeof(numTris));
                                for(size_t i=0; i<Triangles.size(); i++) {
                                        for(int j=0; j<3; j++) {
-                                               wri = Triangles[i].getPoints()[j];
-                                               gzwrite(gzf, &wri, sizeof(wri)); }
+                                               int triIndex = Triangles[i].getPoints()[j];
+                                               gzwrite(gzf, &triIndex, sizeof(triIndex)); }
                                }
                                gzclose( gzf );
-                               debMsgDirect(" Wrote: '"<<boutfilename.str()<<"'. ");
+                               debMsgStd("ntlBlenderDumper::renderScene",DM_NOTIFY," Wrote: '"<<boutfilename.str()<<"' ", 2);
                                numGMs++;
                        }
                }
@@ -200,6 +238,7 @@ int ntlBlenderDumper::renderScene( void )
        debMsgStd("ntlBlenderDumper::renderScene",DM_MSG,"Scene #"<<nrStr<<" dump time: "<< getTimeString(stopTime-startTime) <<" ", 10);
 
        // still render for preview...
+debugOut = false; // DEBUG!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
        if(debugOut) {
                debMsgStd("ntlBlenderDumper::renderScene",DM_NOTIFY,"Performing preliminary render", 1);
                ntlWorld::renderScene(); }
index 59b0fd50ea2cc8c003e1d0b9bda3c8ac4b402067..afa1fa5804c8ff19e3a582d6c902feb2665e7ed2 100644 (file)
@@ -9,7 +9,6 @@
 
 
 #include "ntl_bsptree.h"
-#include "ntl_scene.h"
 #include "utilities.h"
 
 #include <algorithm>
@@ -146,7 +145,7 @@ ntlTree::ntlTree(int depth, int objnum, ntlScene *scene, int triFlagMask) :
   mStart(0.0), mEnd(0.0), mMaxDepth( depth ), mMaxListLength( objnum ), mpRoot( NULL) ,
   mpNodeStack( NULL), mpTBB( NULL ),
        mTriangleMask( 0xFFFF ),
-  mCurrentDepth(0), mCurrentNodes(0)
+  mCurrentDepth(0), mCurrentNodes(0), mTriDoubles(0)
 {  
        // init scene data pointers
        mpVertices = scene->getVertexPointer();
@@ -175,11 +174,12 @@ ntlTree::ntlTree(int depth, int objnum, ntlScene *scene, int triFlagMask) :
        mpTBB = new TriangleBBox[ noOfTriangles ];
        int bbCount = 0;
   mStart = mEnd = (*mpVertices)[ mpTriangles->front().getPoints()[0] ];
+       //errMsg("TreeDebug","Start");
   for (vector<ntlTriangle>::iterator iter = mpTriangles->begin();
        iter != mpTriangles->end(); 
        iter++ ) {
+               //errorOut(" d "<< convertFlags2String((int)(*iter).getFlags()) <<" "<< convertFlags2String( (int)mTriangleMask)<<" add? "<<( ((int)(*iter).getFlags() & (int)mTriangleMask) != 0 ) );
                // discard triangles that dont match mask
-               //errorOut(" d "<<(int)(*iter).getFlags() <<" "<< (int)mTriangleMask );
                if( ((int)(*iter).getFlags() & (int)mTriangleMask) == 0 ) {
                        continue;
                }
@@ -194,9 +194,11 @@ ntlTree::ntlTree(int depth, int objnum, ntlScene *scene, int triFlagMask) :
                // */
 
                ntlVec3Gfx bbs, bbe;
+               //errMsg("TreeDebug","Triangle");
                for(int i=0;i<3;i++) {
                        int index = (*iter).getPoints()[i];
                        ntlVec3Gfx tp = (*mpVertices)[ index ];
+                       //errMsg("TreeDebug","  Point "<<i<<" = "<<tp<<" ");
                        if(tp[0] < mStart[0]) mStart[0]= tp[0];
                        if(tp[0] > mEnd[0])   mEnd[0]= tp[0];
                        if(tp[1] < mStart[1]) mStart[1]= tp[1];
@@ -241,6 +243,8 @@ ntlTree::ntlTree(int depth, int objnum, ntlScene *scene, int triFlagMask) :
        mpRoot->cloneVec = 0;
        globalSortingPoints = mpVertices;
        mpTriDist = new char[ mppTriangles->size() ];
+       mNumNodes = 1;
+       mAbortSubdiv = 0;
 
   /* create tree */
   debugOutInter( "Generating BSP Tree...  (Nodes "<< mCurrentNodes <<
@@ -265,9 +269,15 @@ ntlTree::ntlTree(int depth, int objnum, ntlScene *scene, int triFlagMask) :
        triPerLeaf /= (gfxReal)noLeafs;
        debMsgStd("ntlTree::ntlTree",DM_MSG,"Tree ("<<doSort<<","<<chooseAxis<<") Stats: Leafs:"<<noLeafs<<", avgDepth:"<<avgDepth<<
                        ", triPerLeaf:"<<triPerLeaf<<", triDoubles:"<<mTriDoubles<<", totalTris:"<<totalTris
+                       <<" nodes:"<<mNumNodes
                        //<<" T"<< (totalTris%3)  // 0=ich, 1=f, 2=a
                        , 2 );
 
+       if(mAbortSubdiv) {
+               errMsg("ntlTree::ntlTree","Aborted... "<<mNumNodes);
+       deleteNode(mpRoot);
+               mpRoot = NULL;
+       }
 }
 
 /******************************************************************************
@@ -295,6 +305,7 @@ void ntlTree::subdivide(BSPNode *node, int depth, int axis)
        if( ( (int)node->members->size() > mMaxListLength) &&
                        (depth < mMaxDepth ) 
                        && (node->cloneVec<10)
+                       && (!mAbortSubdiv)
                        ) {
 
                gfxReal planeDiv = 0.499999;    // position of plane division
@@ -339,6 +350,9 @@ void ntlTree::subdivide(BSPNode *node, int depth, int axis)
                        node->child[i]->members = NULL;
                        nextAxis = (axis+1)%3;
                        node->child[i]->axis = nextAxis;
+                       mNumNodes++;
+                       // abort when using 256MB only for tree...
+                       if(mNumNodes*sizeof(BSPNode)> 1024*1024*512) mAbortSubdiv = 1;
 
                        /* current division plane */
                        if(!i) {
@@ -489,6 +503,7 @@ void ntlTree::intersect(const ntlRay &ray, gfxReal &distance,
   ray.intersectCompleteAABB(mStart,mEnd,mindist,maxdist);
 
   if((maxdist < 0.0) ||
+                (!mpRoot) ||
      (mindist == GFX_REAL_MAX) ||
      (maxdist == GFX_REAL_MAX) ) {
     distance = -1.0;
@@ -681,6 +696,7 @@ void ntlTree::intersectX(const ntlRay &ray, gfxReal &distance,
   ray.intersectCompleteAABB(mStart,mEnd,mindist,maxdist); // +X
 
   if((maxdist < 0.0) ||
+                (!mpRoot) ||
      (mindist == GFX_REAL_MAX) ||
      (maxdist == GFX_REAL_MAX) ) {
     distance = -1.0;
index d9746532fc089a89c3d72873a34a79c09e099fd0..face7c3aa7feb106800a805af938f43b8535ab1a 100644 (file)
@@ -6,14 +6,11 @@
  * Tree container for fast triangle intersects
  *
  *****************************************************************************/
-
-
-#ifndef NTL_TREE_HH
-#define NTL_TREE_HH
+#ifndef NTL_TREE_H
+#define NTL_TREE_H
 
 #include "ntl_vector3dim.h"
 #include "ntl_ray.h"
-#include "ntl_triangle.h"
 
 
 #define AXIS_X 0
@@ -29,6 +26,8 @@ class BSPNode;
 class BSPStackElement;
 class BSPStack;
 class TriangleBBox;
+class ntlScene;
+class ntlTriangle;
 
 
 //! Class for a bsp tree for triangles
@@ -85,6 +84,9 @@ class ntlTree
 
                //! root node pointer
                BSPNode *mpRoot;
+               //! count no. of node
+               int mNumNodes;
+               int mAbortSubdiv;
 
                //! stack for the node pointers
                BSPStack *mpNodeStack;
index 145f36bbc5f325a844e214327fd7e5511fb3e9c6..bcc5a32fb58a88a1d1f37943aca6c9d16b1f0ae8 100644 (file)
@@ -28,6 +28,7 @@ class ntlGeometryClass
                //! Default constructor
                inline ntlGeometryClass() :
                        mVisible( 1 ), mName( "[ObjNameUndef]" ),
+                       mObjectId(-1),
                        mpAttrs( NULL ) 
                { 
                                mpAttrs = new AttributeList("objAttrs"); 
@@ -62,6 +63,10 @@ class ntlGeometryClass
                virtual inline ntlVec3Gfx *getBBStart() { return NULL; }
                virtual inline ntlVec3Gfx *getBBEnd()   { return NULL; }
 
+               /*! Set/get the object id*/
+               inline void setObjectId(int set) { mObjectId=set; }
+               inline int getObjectId() const { return mObjectId; }
+
                /*! GUI - this function is called for selected objects to display debugging information with OpenGL */
                virtual void drawDebugDisplay() { /* do nothing by default */ }
                /*! GUI - this function is called for selected objects to display interactive information with OpenGL */
@@ -79,6 +84,9 @@ class ntlGeometryClass
                /*! Name of this object */
                string mName;
 
+               /*! global scene object id */
+               int mObjectId;
+
                /*! configuration attributes */
                AttributeList *mpAttrs;
 
index 2ab80f5be79c5ba7da70e2f10b9f4e04cf0c7422..3c2e05a8c36205e9618ac1c4d91bb955e47cc27b 100644 (file)
@@ -9,7 +9,7 @@
 
 #include "ntl_geometrymodel.h"
 #include "ntl_ray.h"
-#include "ntl_scene.h"
+#include "ntl_world.h"
 #include "zlib.h"
 
 #ifdef WIN32
@@ -46,6 +46,13 @@ ntlGeometryObjModel::~ntlGeometryObjModel()
 /*****************************************************************************/
 void ntlGeometryObjModel::initialize(ntlRenderGlobals *glob) 
 {
+       // perhaps the model is already inited from initModel below?
+       if(mLoaded==1) {
+               // init default material
+               searchMaterial( glob->getMaterials() );
+               return;
+       }
+       
        ntlGeometryObject::initialize(glob);
        mFilename = mpAttrs->readString("filename", mFilename,"ntlGeometryObjModel", "mFilename", true);
 
@@ -73,36 +80,32 @@ void ntlGeometryObjModel::initialize(ntlRenderGlobals *glob)
        }
 }
 
-
-/* defines */
-#define T(x) model->triangles[(x)]
-
 /******************************************************************************
- * 
+ * init model from given vertex and triangle arrays 
  *****************************************************************************/
-void 
-ntlGeometryObjModel::getTriangles( vector<ntlTriangle> *triangles, 
-                                                                                                                       vector<ntlVec3Gfx> *vertices, 
-                                                                                                                       vector<ntlVec3Gfx> *normals, int objectId )
+
+int ntlGeometryObjModel::initModel(int numVertices, float *vertices, int numTriangles, int *triangles)
 {
-       if(!mLoaded) { // invalid type...
-               return;
+       mVertices.clear();
+       mVertices.resize( numVertices );
+       mNormals.resize( numVertices );
+       for(int i=0; i<numVertices; i++) {
+               mVertices[i] = ntlVec3Gfx(vertices[i*3+0],vertices[i*3+1],vertices[i*3+2]);
+               mNormals[i] = ntlVec3Gfx(1.0); // unused, set to !=0.0
        }
 
-       for(int i=0; i<(int)mTriangles.size(); i+=3) {
-               int trip[3];
-               trip[0] = mTriangles[i+0];
-               trip[1] = mTriangles[i+1];
-               trip[2] = mTriangles[i+2];
-               sceneAddTriangle( 
-                               mVertices[trip[0]], mVertices[trip[1]], mVertices[trip[2]], 
-                               mNormals[trip[0]], mNormals[trip[1]], mNormals[trip[2]], 
-                               ntlVec3Gfx(0.0), 1 ); /* normal unused */
+       mTriangles.clear();
+       mTriangles.resize( 3*numTriangles );
+       for(int i=0; i<numTriangles; i++) {
+               mTriangles[3*i+0] = triangles[i*3+0];
+               mTriangles[3*i+1] = triangles[i*3+1];
+               mTriangles[3*i+2] = triangles[i*3+2];
        }
-       // bobj
-       return;
-}
 
+       // inited, no need to parse attribs etc.
+       mLoaded = 1;
+       return 0;
+}
 
 
 /******************************************************************************
@@ -119,67 +122,61 @@ int ntlGeometryObjModel::loadBobjModel(string filename)
                return 1;
        }
 
-       int wri;
-       int gotbytes = -1;
-       gotbytes = gzread(gzf, &wri, sizeof(wri) );
-       if(gotbytes != sizeof(int)){ errMsg("Reading GZ_BOBJ"," Invalid readNV size "<< wri); goto gzreaderror; }
-       if(sizeof(wri)!=4) {  // paranoia check
-               errMsg("Reading GZ_BOBJ"," Invalid int size "<< wri); 
+       int numVerts;
+       if(sizeof(numVerts)!=4) {  // paranoia check
+               errMsg("Reading GZ_BOBJ"," Invalid int size, check compiler settings: int has to be 4 byte long"); 
                goto gzreaderror;
        }
-       if(wri<0 || wri>1e9) {
-               errMsg("Reading GZ_BOBJ"," invalid num vertices "<< wri);
+       gzread(gzf, &numVerts, sizeof(numVerts) );
+       if(numVerts<0 || numVerts>1e9) {
+               errMsg("Reading GZ_BOBJ"," invalid num vertices "<< numVerts);
                goto gzreaderror;
        }
        mVertices.clear();
-       mVertices.resize( wri );
-       for(int i=0; i<wri; i++) {
+       mVertices.resize( numVerts );
+       for(int i=0; i<numVerts; i++) {
                float x[3];
                for(int j=0; j<3; j++) {
-                       gotbytes = gzread(gzf, &(x[j]), sizeof( (x[j]) ) ); 
-                       if(gotbytes != sizeof(float)){ errMsg("Reading GZ_BOBJ"," Invalid readV size "<< wri); goto gzreaderror; } // CHECK
+                       gzread(gzf, &(x[j]), sizeof( (x[j]) ) ); 
                }
                mVertices[i] = ntlVec3Gfx(x[0],x[1],x[2]);
        }
-       if(debugPrint) errMsg("NV"," "<<wri<<" "<< mVertices.size() );
+       if(debugPrint) errMsg("NV"," "<<numVerts<<" "<< mVertices.size() );
 
        // should be the same as Vertices.size
-       gotbytes = gzread(gzf, &wri, sizeof(wri) );
-       if(gotbytes != sizeof(int)){ errMsg("Reading GZ_BOBJ","Invalid readNN size "<< wri); goto gzreaderror; }
-       if(wri<0 || wri>1e9) {
-               errMsg("Reading GZ_BOBJ","invalid num normals "<< wri);
+       gzread(gzf, &numVerts, sizeof(numVerts) );
+       if(numVerts<0 || numVerts>1e9) {
+               errMsg("Reading GZ_BOBJ","invalid num normals "<< numVerts);
                goto gzreaderror;
        }
        mNormals.clear();
-       mNormals.resize( wri );
-       for(int i=0; i<wri; i++) {
+       mNormals.resize( numVerts );
+       for(int i=0; i<numVerts; i++) {
                float n[3];
                for(int j=0; j<3; j++) {
-                       gotbytes = gzread(gzf, &(n[j]), sizeof( (n[j]) ) ); 
-                       if(gotbytes != sizeof(float)){ errMsg("Reading GZ_BOBJ","Invalid readN size "<< wri); goto gzreaderror; }
+                       gzread(gzf, &(n[j]), sizeof( (n[j]) ) ); 
                }
                mNormals[i] = ntlVec3Gfx(n[0],n[1],n[2]);
        }
-       if(debugPrint) errMsg("NN"," "<<wri<<" "<< mNormals.size() );
+       if(debugPrint) errMsg("NN"," "<<numVerts<<" "<< mNormals.size() );
 
-       gotbytes = gzread(gzf, &wri, sizeof(wri) );
-       if(gotbytes != sizeof(int)){ errMsg("Reading GZ_BOBJ","Invalid readNT size "<< wri); goto gzreaderror; }
-       if(wri<0 || wri>1e9) {
-               errMsg("Reading GZ_BOBJ","invalid num normals "<< wri);
+       int numTris;
+       gzread(gzf, &numTris, sizeof(numTris) );
+       if(numTris<0 || numTris>1e9) {
+               errMsg("Reading GZ_BOBJ","invalid num normals "<< numTris);
                goto gzreaderror;
        }
-       mTriangles.resize( 3*wri );
-       for(int i=0; i<wri; i++) {
+       mTriangles.resize( 3*numTris );
+       for(int i=0; i<numTris; i++) {
                int tri[3];
                for(int j=0; j<3; j++) {
-                       gotbytes = gzread(gzf, &(tri[j]), sizeof( (tri[j]) ) ); 
-                       if(gotbytes != sizeof(int)){ errMsg("Reading GZ_BOBJ","Invalid readT size "<< wri); goto gzreaderror; }
+                       gzread(gzf, &(tri[j]), sizeof( (tri[j]) ) ); 
                }
                mTriangles[3*i+0] = tri[0];
                mTriangles[3*i+1] = tri[1];
                mTriangles[3*i+2] = tri[2];
        }
-       if(debugPrint) errMsg("NT"," "<<wri<<" "<< mTriangles.size() );
+       if(debugPrint) errMsg("NT"," "<<numTris<<" "<< mTriangles.size() );
 
        debMsgStd("ntlGeometryObjModel::loadBobjModel",DM_MSG, "File '"<<filename<<"' loaded, #Vertices: "<<mVertices.size()<<", #Normals: "<<mNormals.size()<<", #Triangles: "<<(mTriangles.size()/3)<<" ", 1 );
 
@@ -196,27 +193,34 @@ gzreaderror:
 
 
 /******************************************************************************
- * init model from given vertex and triangle arrays 
+ * 
  *****************************************************************************/
-
-int ntlGeometryObjModel::initModel(int numVertices, float *vertices, int numTriangles, int *triangles)
+void 
+ntlGeometryObjModel::getTriangles( vector<ntlTriangle> *triangles, 
+                                                                                                                       vector<ntlVec3Gfx> *vertices, 
+                                                                                                                       vector<ntlVec3Gfx> *normals, int objectId )
 {
-       mVertices.clear();
-       mVertices.resize( numVertices );
-       for(int i=0; i<numVertices; i++) {
-               //mVertices[i] = ntlVec3Gfx(vertices[i][0],vertices[i][1],vertices[i][2]);
-               mVertices[i] = ntlVec3Gfx(vertices[i*3+0],vertices[i*3+1],vertices[i*3+2]);
+       if(!mLoaded) { // invalid type...
+               return;
        }
 
-       mTriangles.clear();
-       mTriangles.resize( 3*numTriangles );
-       for(int i=0; i<numTriangles; i++) {
-               mTriangles[3*i+0] = triangles[i*3+0];
-               mTriangles[3*i+1] = triangles[i*3+1];
-               mTriangles[3*i+2] = triangles[i*3+2];
-       }
+       for(int i=0; i<(int)mTriangles.size(); i+=3) {
+               int trip[3];
+               trip[0] = mTriangles[i+0];
+               trip[1] = mTriangles[i+1];
+               trip[2] = mTriangles[i+2];
 
-       return 0;
+               sceneAddTriangle( 
+                               mVertices[trip[0]], mVertices[trip[1]], mVertices[trip[2]], 
+                               mNormals[trip[0]], mNormals[trip[1]], mNormals[trip[2]], 
+                               ntlVec3Gfx(0.0), 1 , triangles,vertices,normals ); /* normal unused */
+       }
+       objectId = -1; // remove warning
+       // bobj
+       return;
 }
 
 
+
+
+
index a9340fd2dec7dbf1adaee9742ddb69a1b8549134..7bbae5d87a1db454c462a21424a7afc60a1a2663 100644 (file)
@@ -10,7 +10,8 @@
 
 
 #include "ntl_geometryobject.h"
-#include "ntl_renderglobals.h"
+#include "ntl_world.h"
+#include "ntl_matrices.h"
 
 // for FGI
 #include "elbeem.h"
 /* Default constructor */
 /*****************************************************************************/
 ntlGeometryObject::ntlGeometryObject() :
-       mpMaterial( NULL ),
+       mIsInitialized(false), mpMaterial( NULL ),
        mMaterialName( "default" ),
        mCastShadows( 1 ),
        mReceiveShadows( 1 ),
        mGeoInitId( -1 ), mGeoInitType( 0 ), 
-       mInitialVelocity(0.0),
-       mGeoInitIntersect(false)
+       mInitialVelocity(0.0), mcInitialVelocity(0.0), mLocalCoordInivel(false),
+       mGeoInitIntersect(false),
+       mGeoPartSlipValue(0.0),
+       mOnlyThinInit(false),
+       mInitialPos(0.),
+       mcTrans(0.), mcRot(0.), mcScale(1.),
+       mIsAnimated(false),
+       mMovPoints(), mMovNormals(),
+       mHaveCachedMov(false),
+       mCachedMovPoints(), mCachedMovNormals(),
+       mMovPntsInited(-100.0), mMaxMovPnt(-1),
+       mcGeoActive(1.)
 { 
 };
 
@@ -60,6 +71,11 @@ static int initStringTypes[GEOINIT_STRINGS] = {
 void ntlGeometryObject::initialize(ntlRenderGlobals *glob) 
 {
        //debugOut("ntlGeometryObject::initialize: '"<<getName()<<"' ", 10);
+       // initialize only once...
+       if(mIsInitialized) return;
+       
+       // init material, always necessary
+       searchMaterial( glob->getMaterials() );
        
        mGeoInitId = mpAttrs->readInt("geoinitid", mGeoInitId,"ntlGeometryObject", "mGeoInitId", false);
        mGeoInitIntersect = mpAttrs->readInt("geoinit_intersect", mGeoInitIntersect,"ntlGeometryObject", "mGeoInitIntersect", false);
@@ -74,7 +90,7 @@ void ntlGeometryObject::initialize(ntlRenderGlobals *glob)
                }
 
                if(!gotit) {
-                       errFatal("ntlGeometryObject::initialize","Unkown 'geoinittype' value: '"<< ginitStr <<"' ", SIMWORLD_INITERROR);
+                       errFatal("ntlGeometryObject::initialize","Obj '"<<mName<<"', Unkown 'geoinittype' value: '"<< ginitStr <<"' ", SIMWORLD_INITERROR);
                        return;
                }
        }
@@ -84,32 +100,77 @@ void ntlGeometryObject::initialize(ntlRenderGlobals *glob)
                // disable geo init again...
                mGeoInitId = -1;
        }
-       mInitialVelocity = vec2G( mpAttrs->readVec3d("initial_velocity", vec2D(mInitialVelocity),"ntlGeometryObject", "mInitialVelocity", false));
+       mInitialVelocity  = vec2G( mpAttrs->readVec3d("initial_velocity", vec2D(mInitialVelocity),"ntlGeometryObject", "mInitialVelocity", false));
+       if(getAttributeList()->exists("initial_velocity") || (!mcInitialVelocity.isInited()) ) {
+               mcInitialVelocity = mpAttrs->readChannelVec3f("initial_velocity");
+       }
+       // always use channel
+       if(!mcInitialVelocity.isInited()) { mcInitialVelocity = AnimChannel<ntlVec3Gfx>(mInitialVelocity); }
+       mLocalCoordInivel = mpAttrs->readBool("geoinit_localinivel", mLocalCoordInivel,"ntlGeometryObject", "mLocalCoordInivel", false);
+
        mGeoPartSlipValue = mpAttrs->readFloat("geoinit_partslip", mGeoPartSlipValue,"ntlGeometryObject", "mGeoPartSlipValue", false);
-       debMsgStd("ntlGeometryObject::initialize",DM_MSG,"GeoObj '"<<this->getName()<<"': gid="<<mGeoInitId<<" gtype="<<mGeoInitType<<","<<ginitStr<<
-                       " gvel="<<mInitialVelocity<<" gisect="<<mGeoInitIntersect, 10); // debug
+       mOnlyThinInit     = mpAttrs->readBool("geoinit_onlythin", mOnlyThinInit,"ntlGeometryObject", "mOnlyThinInit", false);
 
        // override cfg types
        mVisible = mpAttrs->readBool("visible", mVisible,"ntlGeometryObject", "mVisible", false);
        mReceiveShadows = mpAttrs->readBool("recv_shad", mReceiveShadows,"ntlGeometryObject", "mReceiveShadows", false);
        mCastShadows = mpAttrs->readBool("cast_shad", mCastShadows,"ntlGeometryObject", "mCastShadows", false);
-       
-       // init material
-       searchMaterial( glob->getMaterials() );
+
+       // read mesh animation channels
+       ntlVec3d translation(0.0);
+       translation = mpAttrs->readVec3d("translation", translation,"ntlGeometryObject", "translation", false);
+       if(getAttributeList()->exists("translation") || (!mcTrans.isInited()) ) {
+               mcTrans = mpAttrs->readChannelVec3f("translation");
+       }
+       ntlVec3d rotation(0.0);
+       rotation = mpAttrs->readVec3d("rotation", rotation,"ntlGeometryObject", "rotation", false);
+       if(getAttributeList()->exists("rotation") || (!mcRot.isInited()) ) {
+               mcRot = mpAttrs->readChannelVec3f("rotation");
+       }
+       ntlVec3d scale(1.0);
+       scale = mpAttrs->readVec3d("scale", scale,"ntlGeometryObject", "scale", false);
+       if(getAttributeList()->exists("scale") || (!mcScale.isInited()) ) {
+               mcScale = mpAttrs->readChannelVec3f("scale");
+       }
+
+       float geoactive=1.;
+       geoactive = mpAttrs->readFloat("geoactive", geoactive,"ntlGeometryObject", "geoactive", false);
+       if(getAttributeList()->exists("geoactive") || (!mcGeoActive.isInited()) ) {
+               mcGeoActive = mpAttrs->readChannelFloat("geoactive");
+       }
+       // always use channel
+       if(!mcGeoActive.isInited()) { mcGeoActive = AnimChannel<double>(geoactive); }
+
+       if(    (mcTrans.accessValues().size()>1)  // VALIDATE
+           || (mcRot.accessValues().size()>1) 
+           || (mcScale.accessValues().size()>1) 
+           || (mcGeoActive.accessValues().size()>1) 
+           || (mcInitialVelocity.accessValues().size()>1) 
+               ) {
+               mIsAnimated = true;
+       }
+
+       mIsInitialized = true;
+       debMsgStd("ntlGeometryObject::initialize",DM_MSG,"GeoObj '"<<this->getName()<<"': visible="<<this->mVisible<<" gid="<<mGeoInitId<<" gtype="<<mGeoInitType<<","<<ginitStr<<
+                       " gvel="<<mInitialVelocity<<" gisect="<<mGeoInitIntersect, 10); // debug
 }
 
+/*! notify object that dump is in progress (e.g. for particles) */
+// default action - do nothing...
+void ntlGeometryObject::notifyOfDump(int frameNr,char *frameNrStr,string outfilename) {
+  bool debugOut=false;
+       if(debugOut) debMsgStd("ntlGeometryObject::notifyOfDump",DM_MSG,"obj:"<<this->getName()<<" frame:"<<frameNrStr<<","<<frameNr<<" to "<<outfilename, 10); // DEBUG
+}
 
 /*****************************************************************************/
 /* Search the material for this object from the material list */
 /*****************************************************************************/
 void ntlGeometryObject::searchMaterial(vector<ntlMaterial *> *mat)
 {
-       //errorOut("my: "<<mMaterialName); // DEBUG
        /* search the list... */
        int i=0;
        for (vector<ntlMaterial*>::iterator iter = mat->begin();
          iter != mat->end(); iter++) {
-               //if(strcmp(mMaterialName, (*iter)->getName()) == 0) { // DEBUG
                if( mMaterialName == (*iter)->getName() ) {
                        //warnMsg("ntlGeometryObject::searchMaterial","for obj '"<<getName()<<"' found - '"<<(*iter)->getName()<<"' "<<i); // DEBUG
                        mpMaterial = (*iter);
@@ -118,8 +179,385 @@ void ntlGeometryObject::searchMaterial(vector<ntlMaterial *> *mat)
                i++;
        }
        errFatal("ntlGeometryObject::searchMaterial","Unknown material '"<<mMaterialName<<"' ! ", SIMWORLD_INITERROR);
+       mpMaterial = new ntlMaterial();
        return;
 }
 
+/******************************************************************************
+ * static add triangle function
+ *****************************************************************************/
+void ntlGeometryObject::sceneAddTriangle(
+               ntlVec3Gfx  p1,ntlVec3Gfx  p2,ntlVec3Gfx  p3,
+               ntlVec3Gfx pn1,ntlVec3Gfx pn2,ntlVec3Gfx pn3,
+               ntlVec3Gfx trin, bool smooth,
+               vector<ntlTriangle> *triangles,
+               vector<ntlVec3Gfx>  *vertices,
+               vector<ntlVec3Gfx>  *normals) {
+       ntlTriangle tri;
+       int tempVert;
+  
+       if(normals->size() != vertices->size()) {
+               errFatal("ntlGeometryObject::sceneAddTriangle","For '"<<this->mName<<"': Vertices and normals sizes to not match!!!",SIMWORLD_GENERICERROR);
+
+       } else {
+               
+               vertices->push_back( p1 ); 
+               normals->push_back( pn1 ); 
+               tempVert = normals->size()-1;
+               tri.getPoints()[0] = tempVert;
+               
+               vertices->push_back( p2 ); 
+               normals->push_back( pn2 ); 
+               tempVert = normals->size()-1;
+               tri.getPoints()[1] = tempVert;
+               
+               vertices->push_back( p3 ); 
+               normals->push_back( pn3 ); 
+               tempVert = normals->size()-1;
+               tri.getPoints()[2] = tempVert;
+               
+               
+               /* init flags from ntl_ray.h */
+               int flag = 0; 
+               if(getVisible()){ flag |= TRI_GEOMETRY; }
+               if(getCastShadows() ) { 
+                       flag |= TRI_CASTSHADOWS; } 
+               if( (getMaterial()->getMirror()>0.0) ||  
+                               (getMaterial()->getTransparence()>0.0) ||  
+                               (getMaterial()->getFresnel()>0.0) ) { 
+                       flag |= TRI_MAKECAUSTICS; } 
+               else { 
+                       flag |= TRI_NOCAUSTICS; } 
+               
+               /* init geo init id */
+               int geoiId = getGeoInitId(); 
+               if((geoiId > 0) && (!mOnlyThinInit) && (!mIsAnimated)) { 
+                       flag |= (1<< (geoiId+4)); 
+                       flag |= mGeoInitType; 
+               } 
+               /*errMsg("ntlScene::addTriangle","DEBUG flag="<<convertFlags2String(flag) ); */ 
+               tri.setFlags( flag );
+               
+               /* triangle normal missing */
+               tri.setNormal( trin );
+               tri.setSmoothNormals( smooth );
+               tri.setObjectId( this->mObjectId );
+               triangles->push_back( tri ); 
+       } /* normals check*/ 
+}
+
+
+
+/******************************************************************************/
+/* Init channels from float arrays (for elbeem API) */
+/******************************************************************************/
+
+#define ADD_CHANNEL_VEC(dst,nvals,val) \
+               vals.clear(); time.clear(); elbeemSimplifyChannelVec3(val,&nvals); \
+               for(int i=0; i<(nvals); i++) { \
+                       vals.push_back(ntlVec3Gfx((val)[i*4+0], (val)[i*4+1],(val)[i*4+2] )); \
+                       time.push_back( (val)[i*4+3] ); \
+               } \
+               (dst) = AnimChannel< ntlVec3Gfx >(vals,time); 
+
+#define ADD_CHANNEL_FLOAT(dst,nvals,val) \
+               valsd.clear(); time.clear(); elbeemSimplifyChannelFloat(val,&nvals); \
+               for(int i=0; i<(nvals); i++) { \
+                       valsd.push_back( (val)[i*2+0] ); \
+                       time.push_back( (val)[i*2+1] ); \
+               } \
+               (dst) = AnimChannel< double >(valsd,time); 
+
+void ntlGeometryObject::initChannels(
+               int nTrans, float *trans, int nRot, float *rot, int nScale, float *scale,
+               int nAct, float *act, int nIvel, float *ivel
+               ) {
+       const bool debugInitc=true;
+       if(debugInitc) { debMsgStd("ntlGeometryObject::initChannels",DM_MSG,"nt:"<<nTrans<<" nr:"<<nRot<<" ns:"<<nScale, 10); 
+                        debMsgStd("ntlGeometryObject::initChannels",DM_MSG,"na:"<<nAct<<" niv:"<<nIvel<<" ", 10); }
+       vector<ntlVec3Gfx> vals;
+       vector<double> valsd;
+       vector<double> time;
+       if((trans)&&(nTrans>0)) {  ADD_CHANNEL_VEC(mcTrans, nTrans, trans); }
+       if((rot)&&(nRot>0)) {      ADD_CHANNEL_VEC(mcRot, nRot, rot); }
+       if((scale)&&(nScale>0)) {  ADD_CHANNEL_VEC(mcScale, nScale, scale); }
+       if((act)&&(nAct>0)) {      ADD_CHANNEL_FLOAT(mcGeoActive, nAct, act); }
+       if((ivel)&&(nIvel>0)) {    ADD_CHANNEL_VEC(mcInitialVelocity, nIvel, ivel); }
+
+       if(    (mcTrans.accessValues().size()>1)  // VALIDATE
+           || (mcRot.accessValues().size()>1) 
+           || (mcScale.accessValues().size()>1) 
+           || (mcGeoActive.accessValues().size()>1) 
+           || (mcInitialVelocity.accessValues().size()>1) 
+               ) {
+               mIsAnimated = true;
+       }
+       if(debugInitc) { 
+               debMsgStd("ntlGeometryObject::initChannels",DM_MSG,getName()<<
+                               " nt:"<<mcTrans.accessValues().size()<<" nr:"<<mcRot.accessValues().size()<<
+                               " ns:"<<mcScale.accessValues().size()<<" isAnim:"<<mIsAnimated, 10); }
+
+       if(debugInitc) {
+               std::ostringstream ostr;
+               ostr << "trans: ";
+               for(size_t i=0; i<mcTrans.accessValues().size(); i++) {
+                       ostr<<" "<<mcTrans.accessValues()[i]<<"@"<<mcTrans.accessTimes()[i]<<" ";
+               } ostr<<";   ";
+               ostr<<"rot: ";
+               for(size_t i=0; i<mcRot.accessValues().size(); i++) {
+                       ostr<<" "<<mcRot.accessValues()[i]<<"@"<<mcRot.accessTimes()[i]<<" ";
+               } ostr<<";   ";
+               ostr<<"scale: ";
+               for(size_t i=0; i<mcScale.accessValues().size(); i++) {
+                       ostr<<" "<<mcScale.accessValues()[i]<<"@"<<mcScale.accessTimes()[i]<<" ";
+               } ostr<<";   ";
+               ostr<<"act: ";
+               for(size_t i=0; i<mcGeoActive.accessValues().size(); i++) {
+                       ostr<<" "<<mcGeoActive.accessValues()[i]<<"@"<<mcGeoActive.accessTimes()[i]<<" ";
+               } ostr<<";   ";
+               ostr<<"ivel: ";
+               for(size_t i=0; i<mcInitialVelocity.accessValues().size(); i++) {
+                       ostr<<" "<<mcInitialVelocity.accessValues()[i]<<"@"<<mcInitialVelocity.accessTimes()[i]<<" ";
+               } ostr<<";   ";
+               debMsgStd("ntlGeometryObject::initChannels",DM_MSG,"Inited "<<ostr.str(),10);
+       }
+}
+#undef ADD_CHANNEL
+
+
+/*****************************************************************************/
+/* apply object translation at time t*/
+/*****************************************************************************/
+void ntlGeometryObject::applyTransformation(double t, vector<ntlVec3Gfx> *verts, vector<ntlVec3Gfx> *norms, int vstart, int vend, int forceTrafo) {
+       if(    (mcTrans.accessValues().size()>1)  // VALIDATE
+           || (mcRot.accessValues().size()>1) 
+           || (mcScale.accessValues().size()>1) 
+           || (forceTrafo)
+           || (!mHaveCachedMov)
+               ) {
+               // transformation is animated, continue
+               ntlVec3Gfx pos = mcTrans.get(t);
+               ntlVec3Gfx scale = mcScale.get(t);
+               ntlVec3Gfx rot = mcRot.get(t);
+               ntlMat4Gfx rotMat;
+               rotMat.initRotationXYZ(rot[0],rot[1],rot[2]);
+               pos += mInitialPos;
+               //errMsg("ntlGeometryObject::applyTransformation","obj="<<getName()<<" t"<<pos<<" r"<<rot<<" s"<<scale);
+               for(int i=vstart; i<vend; i++) {
+                       (*verts)[i] *= scale;
+                       (*verts)[i] = rotMat * (*verts)[i];
+                       (*verts)[i] += pos;
+               }
+               if(norms) {
+                       for(int i=vstart; i<vend; i++) {
+                               (*norms)[i] = rotMat * (*norms)[i];
+                       }
+               }
+       } else {
+               // not animated, cached points were already returned
+               errMsg ("ntlGeometryObject::applyTransformation","Object "<<getName()<<" used cached points ");
+       }
+}
+
+/*! Prepare points for moving objects */
+void ntlGeometryObject::initMovingPoints(gfxReal featureSize) {
+       if(mMovPntsInited==featureSize) return;
+       const bool debugMoinit=false;
+
+       vector<ntlTriangle> triangles; 
+       vector<ntlVec3Gfx> vertices; 
+       vector<ntlVec3Gfx> normals; 
+       int objectId = 1;
+       this->getTriangles(&triangles,&vertices,&normals,objectId);
+       
+       mMovPoints.clear(); //= vertices;
+       mMovNormals.clear(); //= normals;
+       if(debugMoinit) errMsg("ntlGeometryObject::initMovingPoints","Object "<<getName()<<" has v:"<<vertices.size()<<" t:"<<triangles.size() );
+       // no points?
+       if(vertices.size()<1) {
+               mMaxMovPnt=-1;
+               return; 
+       }
+
+       ntlVec3f maxscale = channelFindMaxVf(mcScale);
+       float maxpart = ABS(maxscale[0]);
+       if(ABS(maxscale[1])>maxpart) maxpart = ABS(maxscale[1]);
+       if(ABS(maxscale[2])>maxpart) maxpart = ABS(maxscale[2]);
+       float scaleFac = 1.0/(maxpart);
+       // TODO - better reinit from time to time?
+       const gfxReal fsTri = featureSize*0.5 *scaleFac;
+       if(debugMoinit) errMsg("ntlGeometryObject::initMovingPoints","maxscale:"<<maxpart<<" featureSize:"<<featureSize<<" fsTri:"<<fsTri );
+
+       // debug: count points to init
+       if(debugMoinit) {
+               errMsg("ntlGeometryObject::initMovingPoints","Object "<<getName()<<" estimating...");
+               int countp=vertices.size()*2;
+               for(size_t i=0; i<triangles.size(); i++) {
+                       ntlVec3Gfx p0 = vertices[ triangles[i].getPoints()[0] ];
+                       ntlVec3Gfx side1 = vertices[ triangles[i].getPoints()[1] ] - p0;
+                       ntlVec3Gfx side2 = vertices[ triangles[i].getPoints()[2] ] - p0;
+                       int divs1=0, divs2=0;
+                       if(normNoSqrt(side1) > fsTri*fsTri) { divs1 = (int)(norm(side1)/fsTri); }
+                       if(normNoSqrt(side2) > fsTri*fsTri) { divs2 = (int)(norm(side2)/fsTri); }
+                       errMsg("ntlGeometryObject::initMovingPoints","tri:"<<i<<" p:"<<p0<<" s1:"<<side1<<" s2:"<<side2<<" -> "<<divs1<<","<<divs2 );
+                       if(divs1+divs2 > 0) {
+                               for(int u=0; u<=divs1; u++) {
+                                       for(int v=0; v<=divs2; v++) {
+                                               const gfxReal uf = (gfxReal)(u+0.25) / (gfxReal)(divs1+0.0);
+                                               const gfxReal vf = (gfxReal)(v+0.25) / (gfxReal)(divs2+0.0);
+                                               if(uf+vf>1.0) continue;
+                                               countp+=2;
+                                       }
+                               }
+                       }
+               }
+               errMsg("ntlGeometryObject::initMovingPoints","Object "<<getName()<<" requires:"<<countp*2);
+       }
+
+       bool discardInflowBack = false;
+       if( (mGeoInitType==FGI_MBNDINFLOW) && (mcInitialVelocity.accessValues().size()<1) ) discardInflowBack = true;
+       discardInflowBack = false; // DEBUG disable for now
+
+
+       // init std points
+       for(size_t i=0; i<vertices.size(); i++) {
+               ntlVec3Gfx p = vertices[ i ];
+               ntlVec3Gfx n = normals[ i ];
+               // discard inflow backsides
+               //if( (mGeoInitType==FGI_MBNDINFLOW) && (!mIsAnimated)) {
+               if(discardInflowBack) { //if( (mGeoInitType==FGI_MBNDINFLOW) && (!mIsAnimated)) {
+                       if(dot(mInitialVelocity,n)<0.0) continue;
+               }
+               mMovPoints.push_back(p);
+               mMovNormals.push_back(n);
+       }
+       // init points & refine...
+       for(size_t i=0; i<triangles.size(); i++) {
+               ntlVec3Gfx p0 = vertices[ triangles[i].getPoints()[0] ];
+               ntlVec3Gfx side1 = vertices[ triangles[i].getPoints()[1] ] - p0;
+               ntlVec3Gfx side2 = vertices[ triangles[i].getPoints()[2] ] - p0;
+               int divs1=0, divs2=0;
+               if(normNoSqrt(side1) > fsTri*fsTri) { divs1 = (int)(norm(side1)/fsTri); }
+               if(normNoSqrt(side2) > fsTri*fsTri) { divs2 = (int)(norm(side2)/fsTri); }
+               /* if( (i!=6) &&
+                               (i!=6) ) { divs1=divs2=0; } // DEBUG */
+               if(divs1+divs2 > 0) {
+                       for(int u=0; u<=divs1; u++) {
+                               for(int v=0; v<=divs2; v++) {
+                                       const gfxReal uf = (gfxReal)(u+0.25) / (gfxReal)(divs1+0.0);
+                                       const gfxReal vf = (gfxReal)(v+0.25) / (gfxReal)(divs2+0.0);
+                                       if(uf+vf>1.0) continue;
+                                       ntlVec3Gfx p = vertices[ triangles[i].getPoints()[0] ] * (1.0-uf-vf)+
+                                               vertices[ triangles[i].getPoints()[1] ]*uf +
+                                               vertices[ triangles[i].getPoints()[2] ]*vf;
+                                       ntlVec3Gfx n = normals[ triangles[i].getPoints()[0] ] * (1.0-uf-vf)+
+                                               normals[ triangles[i].getPoints()[1] ]*uf +
+                                               normals[ triangles[i].getPoints()[2] ]*vf;
+                                       normalize(n);
+                                       //if(mGeoInitType==FGI_MBNDINFLOW) {
+                                       // discard inflow backsides
+                                       if(discardInflowBack) { //if( (mGeoInitType==FGI_MBNDINFLOW) && (!mIsAnimated)) {
+                                               if(dot(mInitialVelocity,n)<0.0) continue;
+                                       }
+
+                                       mMovPoints.push_back(p);
+                                       mMovNormals.push_back(n);
+                               }
+                       }
+               }
+       }
+
+       // duplicate insides
+       size_t mpsize = mMovPoints.size();
+       for(size_t i=0; i<mpsize; i++) {
+               //normalize(normals[i]);
+               //errMsg("TTAT"," moved:"<<(mMovPoints[i] - mMovPoints[i]*featureSize)<<" org"<<mMovPoints[i]<<" norm"<<mMovPoints[i]<<" fs"<<featureSize);
+               mMovPoints.push_back(mMovPoints[i] - mMovNormals[i]*0.5*featureSize);
+               mMovNormals.push_back(mMovNormals[i]);
+       }
+
+       // find max point
+       mMaxMovPnt = 0;
+       gfxReal dist = normNoSqrt(mMovPoints[0]);
+       for(size_t i=0; i<mpsize; i++) {
+               if(normNoSqrt(mMovPoints[i])>dist) {
+                       mMaxMovPnt = i;
+                       dist = normNoSqrt(mMovPoints[0]);
+               }
+       }
+
+       if(    (mcTrans.accessValues().size()>1)  // VALIDATE
+           || (mcRot.accessValues().size()>1) 
+           || (mcScale.accessValues().size()>1) 
+               ) {
+               // also do trafo...
+       } else {
+               mCachedMovPoints = mMovPoints;
+               mCachedMovNormals = mMovNormals;
+               applyTransformation(0., &mCachedMovPoints, &mCachedMovNormals, 0, mCachedMovPoints.size(), true);
+               mHaveCachedMov = true;
+               debMsgStd("ntlGeometryObject::initMovingPoints",DM_MSG,"Object "<<getName()<<" cached points ", 7);
+       }
+
+       mMovPntsInited = featureSize;
+       debMsgStd("ntlGeometryObject::initMovingPoints",DM_MSG,"Object "<<getName()<<" inited v:"<<vertices.size()<<"->"<<mMovPoints.size() , 5);
+}
+
+/*! Prepare points for moving objects */
+void ntlGeometryObject::getMovingPoints(vector<ntlVec3Gfx> &ret, vector<ntlVec3Gfx> *norms) {
+       if(mHaveCachedMov) {
+               ret = mCachedMovPoints;
+               if(norms) { *norms = mCachedMovNormals; }
+               errMsg ("ntlGeometryObject::getMovingPoints","Object "<<getName()<<" used cached points ");
+               return;
+       }
+
+       ret = mMovPoints;
+       if(norms) { *norms = mMovNormals; }
+}
+
 
+/*! Calculate max. velocity on object from t1 to t2 */
+ntlVec3Gfx ntlGeometryObject::calculateMaxVel(double t1, double t2) {
+       ntlVec3Gfx vel(0.);
+       if(mMaxMovPnt<0) return vel;
+               
+       vector<ntlVec3Gfx> verts1,verts2;
+       verts1.push_back(mMovPoints[mMaxMovPnt]);
+       verts2 = verts1;
+       applyTransformation(t1,&verts1,NULL, 0,verts1.size(), true);
+       applyTransformation(t2,&verts2,NULL, 0,verts2.size(), true);
+
+       vel = (verts2[0]-verts1[0]); // /(t2-t1);
+       errMsg("ntlGeometryObject::calculateMaxVel","t1="<<t1<<" t2="<<t2<<" p1="<<verts1[0]<<" p2="<<verts2[0]<<" v="<<vel);
+       return vel;
+}
+
+/*! get translation at time t*/
+ntlVec3Gfx ntlGeometryObject::getTranslation(double t) {
+       ntlVec3Gfx pos = mcTrans.get(t);
+       return pos;
+}
+/*! get active flag time t*/
+float ntlGeometryObject::getGeoActive(double t) {
+       //float act = mcGeoActive.getConstant(t);
+       float act = mcGeoActive.get(t); // if <= 0.0 -> off
+       return act;
+}
+
+void ntlGeometryObject::setInitialVelocity(ntlVec3Gfx set) { 
+       mInitialVelocity=set; 
+       mcInitialVelocity = AnimChannel<ntlVec3Gfx>(set); 
+}
+ntlVec3Gfx ntlGeometryObject::getInitialVelocity(double t) { 
+       ntlVec3Gfx v =  mcInitialVelocity.get(t); //return mInitialVelocity; 
+       if(!mLocalCoordInivel) return v;
+
+       ntlVec3Gfx rot = mcRot.get(t);
+       ntlMat4Gfx rotMat;
+       rotMat.initRotationXYZ(rot[0],rot[1],rot[2]);
+       v = rotMat * v;
+       return v;
+}
+       
 
index 71a5566d8eb81965ae14547bb2b6c32b0dd3953a..157d160c0e447a3e3b649a9c10d3a1b55bab453b 100644 (file)
@@ -7,13 +7,14 @@
  * all other geometry objects are derived from this one
  *
  *****************************************************************************/
-#ifndef NTL_GEOMETRYOBJECT_HH
+#ifndef NTL_GEOMETRYOBJECT_H
+#define NTL_GEOMETRYOBJECT_H
 
 #include "ntl_geometryclass.h"
-#include "ntl_material.h"
-#include "ntl_triangle.h"
-class ntlRay;
+#include "ntl_lighting.h"
+#include "ntl_ray.h"
 class ntlRenderGlobals;
+class ntlTriangle;
 
 
 class ntlGeometryObject : public ntlGeometryClass
@@ -28,13 +29,16 @@ class ntlGeometryObject : public ntlGeometryClass
                //! Return type id
                virtual int getTypeId() { return GEOCLASSTID_OBJECT; }
 
+               /*! Init attributes etc. of this object */
+               virtual void initialize(ntlRenderGlobals *glob);
+
                /*! Get the triangles from this object */
                virtual void getTriangles( vector<ntlTriangle> *triangles, 
                                vector<ntlVec3Gfx> *vertices, 
                                vector<ntlVec3Gfx> *normals, int objectId ) = 0;
-
-               /*! Init attributes etc. of this object */
-               virtual void initialize(ntlRenderGlobals *glob);
+               
+               /*! notify object that dump is in progress (e.g. for particles) */
+               virtual void notifyOfDump(int frameNr,char *frameNrStr,string outfilename);
 
                /*! Search the material for this object from the material list */
                void searchMaterial(vector<ntlMaterial *> *mat);
@@ -68,20 +72,64 @@ class ntlGeometryObject : public ntlGeometryClass
                /*! Returns the geo init typ */
                inline int getGeoInitType() const { return mGeoInitType; }
 
-               /*! Set/get the cast initial veocity attribute */
-               inline void       setInitialVelocity(ntlVec3Gfx set) { mInitialVelocity=set; }
-               inline ntlVec3Gfx getInitialVelocity() const         { return mInitialVelocity; }
-
                /*! Set/get the intersect init flag */
                inline bool getGeoInitIntersect() const { return mGeoInitIntersect; }
                inline void setGeoInitIntersect(bool set) { mGeoInitIntersect=set; }
 
                /*! Set/get the part slip value*/
-               inline bool getGeoPartSlipValue() const { return mGeoPartSlipValue; }
+               inline float getGeoPartSlipValue() const { return mGeoPartSlipValue; }
                inline void setGeoPartSlipValue(float set) { mGeoPartSlipValue=set; }
 
+               /*! Set/get the part slip value*/
+               inline bool getOnlyThinInit() const { return mOnlyThinInit; }
+               inline void setOnlyThinInit(float set) { mOnlyThinInit=set; }
+
+               /*! Set/get the cast initial veocity attribute */
+               void setInitialVelocity(ntlVec3Gfx set);
+               ntlVec3Gfx getInitialVelocity(double t);
+
+               /*! Set/get the local inivel coords flag */
+               inline bool getLocalCoordInivel() const { return mLocalCoordInivel; }
+               inline void setLocalCoordInivel(bool set) { mLocalCoordInivel=set; }
+
+               /*! Init channels from float arrays (for elbeem API) */
+               void initChannels(
+                               int nTrans, float *trans, int nRot, float *rot, int nScale, float *scale,
+                         int nAct, float *act, int nIvel, float *ivel
+                               );
+
+               /*! is the object animated? */
+               inline bool getIsAnimated() const { return mIsAnimated; }
+
+               /*! apply object translation at time t*/
+               void applyTransformation(double t, vector<ntlVec3Gfx> *verts, vector<ntlVec3Gfx> *norms, int vstart, int vend, int forceTrafo);
+
+               /*! Prepare points for moving objects */
+               void initMovingPoints(gfxReal featureSize);
+               /*! Prepare points for moving objects (copy into ret) */
+               void getMovingPoints(vector<ntlVec3Gfx> &ret, vector<ntlVec3Gfx> *norms = NULL);
+               /*! Calculate max. velocity on object from t1 to t2 */
+               ntlVec3Gfx calculateMaxVel(double t1, double t2);
+               /*! get translation at time t*/
+               ntlVec3Gfx getTranslation(double t);
+               /*! get active flag time t*/
+               float getGeoActive(double t);
+
+               /*! add triangle to scene and init flags */
+               //  helper function for getTriangles
+               void sceneAddTriangle(
+                               ntlVec3Gfx  p1,ntlVec3Gfx  p2,ntlVec3Gfx  p3,
+                               ntlVec3Gfx pn1,ntlVec3Gfx pn2,ntlVec3Gfx pn3,
+                               ntlVec3Gfx trin, bool smooth,
+                               vector<ntlTriangle> *triangles,
+                               vector<ntlVec3Gfx>  *vertices,
+                               vector<ntlVec3Gfx>  *vertNormals);
+
        protected:
 
+               /* initialized for scene? */
+               bool mIsInitialized; 
+
                /*! Point to a property object describing the surface of this object */
                ntlMaterial *mpMaterial;
 
@@ -100,15 +148,41 @@ class ntlGeometryObject : public ntlGeometryClass
                int mGeoInitType;
                /*! initial velocity for fluid objects */
                ntlVec3Gfx mInitialVelocity;
+               AnimChannel<ntlVec3Gfx> mcInitialVelocity;
+               /*! use object local inflow? */
+               bool mLocalCoordInivel;
                /*! perform more accurate intersecting geo init for this object? */
                bool mGeoInitIntersect;
                /*! part slip bc value */
                float mGeoPartSlipValue;
+               /*! only init as thin object, dont fill? */
+               bool mOnlyThinInit;
+
+               /*! initial offset for rot/scale */
+               ntlVec3Gfx mInitialPos;
+               /*! animated channels for postition, rotation and scale */
+               AnimChannel<ntlVec3Gfx> mcTrans, mcRot, mcScale;
+               /*! easy check for animation */
+               bool mIsAnimated;
+               
+               /*! moving point/normal storage */
+               vector<ntlVec3Gfx> mMovPoints;
+               vector<ntlVec3Gfx> mMovNormals;
+               /*! cached points for non moving objects/timeslots */
+               bool mHaveCachedMov;
+               vector<ntlVec3Gfx> mCachedMovPoints;
+               vector<ntlVec3Gfx> mCachedMovNormals;
+               /*! inited? */
+               float mMovPntsInited;
+               /*! point with max. distance from center */
+               int mMaxMovPnt;
+
+               /*! animated channels for in/outflow on/off */
+               AnimChannel<double> mcGeoActive;
 
        public:
 
 };
 
-#define NTL_GEOMETRYOBJECT_HH
 #endif
 
index 06a11838149bac36833123bb4be5612f7c0fd19f..7d767b0f8b91f02e15fa399aeaaafa1fe2ad3c8b 100644 (file)
@@ -38,6 +38,9 @@ class ntlGeometryShader :
                virtual vector<ntlGeometryObject *>::iterator getObjectsBegin() { return mObjects.begin(); }
                /*! Get end iterator for all objects */
                virtual vector<ntlGeometryObject *>::iterator getObjectsEnd() { return mObjects.end(); }
+               
+               /*! notify object that dump is in progress (e.g. for field dump) */
+               virtual void notifyShaderOfDump(int frameNr,char *frameNrStr,string outfilename) = 0;
 
        protected:
 
similarity index 78%
rename from intern/elbeem/intern/ntl_lightobject.cpp
rename to intern/elbeem/intern/ntl_lighting.cpp
index c8db66bab74e907885f592434f6e9e00e590f65a..d4eae7051e06babb2fa771c266f14078e373d821 100644 (file)
@@ -8,10 +8,9 @@
  *****************************************************************************/
 
 
-#include "ntl_lightobject.h"
+#include "ntl_lighting.h"
 #include "ntl_ray.h"
-#include "ntl_scene.h"
-#include "ntl_renderglobals.h"
+#include "ntl_world.h"
 
 
 /******************************************************************************
@@ -126,7 +125,7 @@ ntlColor ntlLightObject::illuminatePoint(ntlRay &reflectedRay, ntlGeometryObject
                ntlTriangle *tri;
                ntlVec3Gfx triNormal;
                gfxReal trit;
-               mpGlob->getScene()->intersectScene(rayOfLight, trit, triNormal, tri, TRI_CASTSHADOWS);
+               mpGlob->getRenderScene()->intersectScene(rayOfLight, trit, triNormal, tri, TRI_CASTSHADOWS);
                if(( trit>0 )&&( trit<lightDirNorm )) visibility = 0.0;
                if(mpGlob->getDebugOut() > 5) errorOut("Omni lighting with "<<visibility );
        }
@@ -142,3 +141,42 @@ ntlColor ntlLightObject::illuminatePoint(ntlRay &reflectedRay, ntlGeometryObject
 }
 
 
+
+/******************************************************************************
+ * Default constructor
+ *****************************************************************************/
+ntlMaterial::ntlMaterial( void ) : 
+       mName( "default" ),
+  mDiffuseRefl(0.5,0.5,0.5),  mAmbientRefl(0.0,0.0,0.0),
+  mSpecular(0.0), mSpecExponent(0.0), mMirror(0.0),
+  mTransparence(0.0), mRefracIndex(0.0), mTransAdditive(0.0), mTransAttCol(0.0),
+       mFresnel( 0 )
+  //mNtfId(0), mNtfFluid(0), mNtfSolid(0)
+{ 
+  // just do default init...
+}
+
+
+
+/******************************************************************************
+ * Init constructor
+ *****************************************************************************/
+ntlMaterial::ntlMaterial( string name,
+                                                                                                       const ntlColor& Ref, const ntlColor& Amb,
+                                                                                                       gfxReal Spec, gfxReal SpecEx, gfxReal Mirr,
+                                                                                                       gfxReal Trans, gfxReal Refrac, gfxReal TAdd,
+                                                                                                       const ntlColor& Att, int fres)
+{
+       mName                                   = name;
+       mDiffuseRefl  = Ref;
+       mAmbientRefl  = Amb;
+       mSpecular     = Spec;
+       mSpecExponent = SpecEx;
+       mMirror       = Mirr;
+       mTransparence = Trans;
+       mRefracIndex  = Refrac;
+       mTransAdditive = TAdd;
+       mTransAttCol   = Att;
+       mFresnel                        = fres;
+}
+
similarity index 73%
rename from intern/elbeem/intern/ntl_material.h
rename to intern/elbeem/intern/ntl_lighting.h
index 41bfd167bb25cbf18263817c8094cdb38819565c..af53a13ebc79b4d180bbee4d5eab60ec93eb29b8 100644 (file)
@@ -3,15 +3,89 @@
  * El'Beem - Free Surface Fluid Simulation with the Lattice Boltzmann Method
  * Copyright 2003,2004 Nils Thuerey
  *
- * a geometry object
- * all other geometry objects are derived from this one
+ * a light object
+ * default omni light implementation
  *
  *****************************************************************************/
-#ifndef NTL_MATERIAL_HH
-#define NTL_MATERIAL_HH
+#ifndef NTL_LIGHTING_H
+#define NTL_LIGHTING_H
 
 #include "ntl_vector3dim.h"
+class ntlMaterial;
 class ntlRay;
+class ntlRenderGlobals;
+class ntlGeometryObject;
+
+
+
+/* shadow map directions */
+#define LSM_RIGHT 0
+#define LSM_LEFT  1
+#define LSM_UP    2
+#define LSM_DOWN  3
+#define LSM_FRONT 4
+#define LSM_BACK  5
+
+/*! Basic object for lights, all other light are derived from this one */
+class ntlLightObject
+{
+public:
+  /* CONSTRUCTORS */
+  /*! Default constructor */
+  ntlLightObject(ntlRenderGlobals *glob);
+  /*! Constructor with parameters */
+  ntlLightObject(ntlRenderGlobals *glob, const ntlColor& col);
+  /*! Destructor */
+  virtual ~ntlLightObject();
+
+       /*! prepare light for rendering (for example shadow maps) */
+       virtual void prepare( bool );
+       
+       /*! do the illumination... */
+       virtual ntlColor illuminatePoint(ntlRay &reflectedRay, 
+                                                                                                                                        ntlGeometryObject *closest,
+                                                                                                                                        ntlColor &highlight);
+       /*! shade the point */
+       const ntlColor
+       getShadedColor(const ntlRay &reflectedray, ntlVec3Gfx lightDir,
+                                                                ntlMaterial *surf, ntlColor &highlight) const;
+
+
+  /* access methods */
+  /*! Access the active flag */
+  inline void setActive(bool set) { mActive = set; }
+  inline bool getActive() const { return mActive; }
+  /*! Access the shadow flag */
+  inline void setCastShadows(bool set) { mCastShadows = set; }
+  inline bool getCastShadows() const { return mCastShadows; }
+  /*! Access the light color */
+  inline void setColor(ntlColor set) { mcColor = set; }
+  inline ntlColor getColor() const { return mcColor; }
+  
+  /*! Access the omni light position */
+  void setPosition(ntlVec3Gfx set) { mvPosition = set; }
+  ntlVec3Gfx getPosition() const { return mvPosition; }
+       
+
+protected:
+       /*! render globals */
+       ntlRenderGlobals *mpGlob;
+
+       /*! is this light acitve? */
+       bool mActive;
+
+       /*! does it cast shadows? */
+       bool mCastShadows;
+
+  /*! color of this light */
+       ntlColor  mcColor;
+
+       /*! light position */
+       ntlVec3Gfx  mvPosition;
+
+private:
+
+};
 
 
 //! Properties of an geo object, describing the reflection properties of the surface
@@ -20,12 +94,12 @@ class ntlMaterial
 public:
   // CONSTRUCTORS
   //! Default constructor
-  inline ntlMaterial( void );
+  ntlMaterial( void );
   //! Constructor with parameters
   /*! Sets reflectance, ambient reflection, specular intensity
    *  specular exponent, mirror intensity 
    *  transparency, refraction index */
-  inline ntlMaterial( string name,
+  ntlMaterial( string name,
          const ntlColor& Ref, const ntlColor& Amb, 
                           gfxReal Spec, gfxReal Exp, gfxReal Mirror,
                           gfxReal Trans, gfxReal Refrac, gfxReal TAdd,
@@ -121,47 +195,6 @@ public:
 };
 
 
-
-
-/******************************************************************************
- * Default constructor
- *****************************************************************************/
-inline ntlMaterial::ntlMaterial( void ) : 
-       mName( "default" ),
-  mDiffuseRefl(0.5,0.5,0.5),  mAmbientRefl(0.0,0.0,0.0),
-  mSpecular(0.0), mSpecExponent(0.0), mMirror(0.0),
-  mTransparence(0.0), mRefracIndex(0.0), mTransAdditive(0.0), mTransAttCol(0.0),
-       mFresnel( 0 )
-  //mNtfId(0), mNtfFluid(0), mNtfSolid(0)
-{ 
-  // just do default init...
-}
-
-
-
-/******************************************************************************
- * Init constructor
- *****************************************************************************/
-inline 
-ntlMaterial::ntlMaterial( string name,
-                                                                                                       const ntlColor& Ref, const ntlColor& Amb,
-                                                                                                       gfxReal Spec, gfxReal SpecEx, gfxReal Mirr,
-                                                                                                       gfxReal Trans, gfxReal Refrac, gfxReal TAdd,
-                                                                                                       const ntlColor& Att, int fres)
-{
-       mName                                   = name;
-       mDiffuseRefl  = Ref;
-       mAmbientRefl  = Amb;
-       mSpecular     = Spec;
-       mSpecExponent = SpecEx;
-       mMirror       = Mirr;
-       mTransparence = Trans;
-       mRefracIndex  = Refrac;
-       mTransAdditive = TAdd;
-       mTransAttCol   = Att;
-       mFresnel                        = fres;
-}
-
 /******************************************************************************
  * Macro to define the default surface properties for a newly created object
  *****************************************************************************/
@@ -201,3 +234,5 @@ ntlMaterial::calculateFresnel(const ntlVec3Gfx &dir, const ntlVec3Gfx &normal, g
 
 
 #endif
+
+
diff --git a/intern/elbeem/intern/ntl_lightobject.h b/intern/elbeem/intern/ntl_lightobject.h
deleted file mode 100644 (file)
index 19dde88..0000000
+++ /dev/null
@@ -1,91 +0,0 @@
-/******************************************************************************
- *
- * El'Beem - Free Surface Fluid Simulation with the Lattice Boltzmann Method
- * Copyright 2003,2004 Nils Thuerey
- *
- * a light object
- * default omni light implementation
- *
- *****************************************************************************/
-#ifndef NTL_LIGHTOBJECT_HH
-#define NTL_LIGHTOBJECT_HH
-
-#include "ntl_vector3dim.h"
-#include "ntl_material.h"
-class ntlRay;
-class ntlRenderGlobals;
-class ntlGeometryObject;
-
-
-
-/* shadow map directions */
-#define LSM_RIGHT 0
-#define LSM_LEFT  1
-#define LSM_UP    2
-#define LSM_DOWN  3
-#define LSM_FRONT 4
-#define LSM_BACK  5
-
-/*! Basic object for lights, all other light are derived from this one */
-class ntlLightObject
-{
-public:
-  /* CONSTRUCTORS */
-  /*! Default constructor */
-  ntlLightObject(ntlRenderGlobals *glob);
-  /*! Constructor with parameters */
-  ntlLightObject(ntlRenderGlobals *glob, const ntlColor& col);
-  /*! Destructor */
-  virtual ~ntlLightObject();
-
-       /*! prepare light for rendering (for example shadow maps) */
-       virtual void prepare( bool );
-       
-       /*! do the illumination... */
-       virtual ntlColor illuminatePoint(ntlRay &reflectedRay, 
-                                                                                                                                        ntlGeometryObject *closest,
-                                                                                                                                        ntlColor &highlight);
-       /*! shade the point */
-       const ntlColor
-       getShadedColor(const ntlRay &reflectedray, ntlVec3Gfx lightDir,
-                                                                ntlMaterial *surf, ntlColor &highlight) const;
-
-
-  /* access methods */
-  /*! Access the active flag */
-  inline void setActive(bool set) { mActive = set; }
-  inline bool getActive() const { return mActive; }
-  /*! Access the shadow flag */
-  inline void setCastShadows(bool set) { mCastShadows = set; }
-  inline bool getCastShadows() const { return mCastShadows; }
-  /*! Access the light color */
-  inline void setColor(ntlColor set) { mcColor = set; }
-  inline ntlColor getColor() const { return mcColor; }
-  
-  /*! Access the omni light position */
-  void setPosition(ntlVec3Gfx set) { mvPosition = set; }
-  ntlVec3Gfx getPosition() const { return mvPosition; }
-       
-
-protected:
-       /*! render globals */
-       ntlRenderGlobals *mpGlob;
-
-       /*! is this light acitve? */
-       bool mActive;
-
-       /*! does it cast shadows? */
-       bool mCastShadows;
-
-  /*! color of this light */
-       ntlColor  mcColor;
-
-       /*! light position */
-       ntlVec3Gfx  mvPosition;
-
-private:
-
-};
-
-#endif
-
index 8a70dceb1c73f357660bd333d82b4c42ab74ee85..7d27a6e7c7af8ce35f2c3f4b1b458ecde0ccd342 100644 (file)
@@ -77,9 +77,12 @@ public:
        inline void initRotationX(Scalar rot);
        inline void initRotationY(Scalar rot);
        inline void initRotationZ(Scalar rot);
+       inline void initRotationXYZ(Scalar rotx,Scalar roty, Scalar rotz);
        //! init scaling matrix
        inline void initScaling(Scalar scale);
        inline void initScaling(Scalar x, Scalar y, Scalar z);
+       //! from 16 value array (init id if all 0)
+       inline void initArrayCheck(Scalar *array);
 
        //! public to avoid [][] operators
   Scalar value[4][4];  //< Storage of vector values
@@ -593,8 +596,8 @@ template<class Scalar>
 inline void 
 ntlMatrix4x4<Scalar>::initRotationX(Scalar rot)
 {
-       double drot = (double)rot;
-       while(drot < 0.0) drot += (M_PI*2.0);
+       double drot = (double)(rot/360.0*2.0*M_PI);
+       //? while(drot < 0.0) drot += (M_PI*2.0);
 
        this->initId();
        value[1][1] = (Scalar)  cos(drot);
@@ -606,8 +609,8 @@ template<class Scalar>
 inline void 
 ntlMatrix4x4<Scalar>::initRotationY(Scalar rot)
 {
-       double drot = (double)rot;
-       while(drot < 0.0) drot += (M_PI*2.0);
+       double drot = (double)(rot/360.0*2.0*M_PI);
+       //? while(drot < 0.0) drot += (M_PI*2.0);
 
        this->initId();
        value[0][0] = (Scalar)  cos(drot);
@@ -619,8 +622,8 @@ template<class Scalar>
 inline void 
 ntlMatrix4x4<Scalar>::initRotationZ(Scalar rot)
 {
-       double drot = (double)rot;
-       while(drot < 0.0) drot += (M_PI*2.0);
+       double drot = (double)(rot/360.0*2.0*M_PI);
+       //? while(drot < 0.0) drot += (M_PI*2.0);
 
        this->initId();
        value[0][0] = (Scalar)  cos(drot);
@@ -628,6 +631,32 @@ ntlMatrix4x4<Scalar>::initRotationZ(Scalar rot)
        value[1][0] = (Scalar)(-sin(drot));
        value[1][1] = (Scalar)  cos(drot);
 }
+template<class Scalar>
+inline void 
+ntlMatrix4x4<Scalar>::initRotationXYZ( Scalar rotx, Scalar roty, Scalar rotz)
+{
+       ntlMatrix4x4<Scalar> val;
+       ntlMatrix4x4<Scalar> rot;
+       this->initId();
+
+       // org
+       /*rot.initRotationX(rotx);
+       (*this) *= rot;
+       rot.initRotationY(roty);
+       (*this) *= rot;
+       rot.initRotationZ(rotz);
+       (*this) *= rot;
+       // org */
+
+       // blender
+       rot.initRotationZ(rotz);
+       (*this) *= rot;
+       rot.initRotationY(roty);
+       (*this) *= rot;
+       rot.initRotationX(rotx);
+       (*this) *= rot;
+       // blender */
+}
 
 //! init scaling matrix
 template<class Scalar>
@@ -651,6 +680,20 @@ ntlMatrix4x4<Scalar>::initScaling(Scalar x, Scalar y, Scalar z)
 }
 
 
+//! from 16 value array (init id if all 0)
+template<class Scalar>
+inline void 
+ntlMatrix4x4<Scalar>::initArrayCheck(Scalar *array)
+{
+       bool allZero = true;
+       for(int i=0; i<4; i++) {
+               for(int j=0; j<4; j++) {
+                       value[i][j] = array[i*4+j];
+                       if(array[i*4+j]!=0.0) allZero=false;
+               }
+       }
+       if(allZero) this->initId();
+}
 
 
 #define NTL_MATRICES_H
index ed5f96a4541b34faaf4bd583292e1d74bdb124aa..5df9c0068f9c71bab4ad68b3cd56657e34a1d512 100644 (file)
@@ -8,8 +8,11 @@
  *****************************************************************************/
 
 
+#include "utilities.h"
 #include "ntl_ray.h"
-#include "ntl_scene.h"
+#include "ntl_world.h"
+#include "ntl_geometryobject.h"
+#include "ntl_geometryshader.h"
 
 
 /* Minimum value for refl/refr to be traced */
@@ -116,7 +119,7 @@ ntlRay::~ntlRay()
 #define MIDDLE 2
 
 //! intersect ray with AABB
-#ifndef ELBEEM_BLENDER
+#ifndef ELBEEM_PLUGIN
 void ntlRay::intersectFrontAABB(ntlVec3Gfx mStart, ntlVec3Gfx mEnd, gfxReal &t, ntlVec3Gfx &retnormal,ntlVec3Gfx &retcoord) const
 {
   char   inside = true;   /* inside box? */
@@ -288,7 +291,7 @@ void ntlRay::intersectBackAABB(ntlVec3Gfx mStart, ntlVec3Gfx mEnd, gfxReal &t, n
   retnormal = normal;
   retcoord = coord;
 }
-#endif // ELBEEM_BLENDER
+#endif // ELBEEM_PLUGIN
 
 //! intersect ray with AABB
 void ntlRay::intersectCompleteAABB(ntlVec3Gfx mStart, ntlVec3Gfx mEnd, gfxReal &tmin, gfxReal &tmax) const
@@ -441,7 +444,7 @@ void ntlRay::intersectCompleteAABB(ntlVec3Gfx mStart, ntlVec3Gfx mEnd, gfxReal &
  *****************************************************************************/
 const ntlColor ntlRay::shade() //const
 {
-#ifndef ELBEEM_BLENDER
+#ifndef ELBEEM_PLUGIN
   ntlGeometryObject           *closest = NULL;
   gfxReal                      minT = GFX_REAL_MAX;
   vector<ntlLightObject*>     *lightlist = mpGlob->getLightList();
@@ -457,9 +460,9 @@ const ntlColor ntlRay::shade() //const
   /* find closes object that intersects */
        ntlTriangle *tri = NULL;
        ntlVec3Gfx normal;
-       mpGlob->getScene()->intersectScene(*this, minT, normal, tri, 0);
+       mpGlob->getRenderScene()->intersectScene(*this, minT, normal, tri, 0);
        if(minT>0) {
-               closest = mpGlob->getScene()->getObject( tri->getObjectId() );
+               closest = mpGlob->getRenderScene()->getObject( tri->getObjectId() );
        }
 
   /* object hit... */
@@ -481,7 +484,7 @@ const ntlColor ntlRay::shade() //const
     ntlMaterial *clossurf = closest->getMaterial();
                /*if(mpGlob->getDebugOut() > 5) {
                        errorOut("Ray hit: at "<<intersectionPosition<<" n:"<<normal<<"    dn:"<<valDN<<" ins:"<<intersectionInside<<"  cl:"<<((unsigned int)closest) ); 
-                       errorOut(" t1:"<<mpGlob->getScene()->getVertex(tri->getPoints()[0])<<" t2:"<<mpGlob->getScene()->getVertex(tri->getPoints()[1])<<" t3:"<<mpGlob->getScene()->getVertex(tri->getPoints()[2]) ); 
+                       errorOut(" t1:"<<mpGlob->getRenderScene()->getVertex(tri->getPoints()[0])<<" t2:"<<mpGlob->getRenderScene()->getVertex(tri->getPoints()[1])<<" t3:"<<mpGlob->getScene()->getVertex(tri->getPoints()[2]) ); 
                        errorOut(" trin:"<<tri->getNormal() );
                } // debug */
 
@@ -559,9 +562,9 @@ const ntlColor ntlRay::shade() //const
                                        refractionPosition2 -= (triangleNormal*getVecEpsilon() );
 
                                        ntlRay reflectedRay2 = ntlRay(refractionPosition2, reflectedDir, mDepth+1, mContribution*currRefl, mpGlob);
-                                       mpGlob->getScene()->intersectScene(reflectedRay2, minT2, normal2, tri2, 0);
+                                       mpGlob->getRenderScene()->intersectScene(reflectedRay2, minT2, normal2, tri2, 0);
                                        if(minT2>0) {
-                                               closest2 = mpGlob->getScene()->getObject( tri2->getObjectId() );
+                                               closest2 = mpGlob->getRenderScene()->getObject( tri2->getObjectId() );
                                        }
 
                                        /* object hit... */
@@ -649,13 +652,254 @@ const ntlColor ntlRay::shade() //const
     return ntlColor(currentColor);
   }
 
-#endif // ELBEEM_BLENDER
+#endif // ELBEEM_PLUGIN
   /* no object hit -> ray goes to infinity */
   return mpGlob->getBackgroundCol(); 
 }
 
 
 
+/******************************************************************************
+ ******************************************************************************
+ ******************************************************************************
+ * scene implementation
+ ******************************************************************************
+ ******************************************************************************
+ *****************************************************************************/
+
+
+
+/******************************************************************************
+ * Constructor
+ *****************************************************************************/
+ntlScene::ntlScene( ntlRenderGlobals *glob, bool del ) :
+       mpGlob( glob ), mSceneDel(del),
+       mpTree( NULL ),
+       mDisplayListId( -1 ), 
+       mSceneBuilt( false ), mFirstInitDone( false )
+{
+}
+
+
+/******************************************************************************
+ * Destructor
+ *****************************************************************************/
+ntlScene::~ntlScene()
+{
+       if(mpTree != NULL) delete mpTree;
+
+       // cleanup lists, only if this is the rendering cleanup scene
+       if(mSceneDel) {
+               for (vector<ntlGeometryClass*>::iterator iter = mGeos.begin();
+                               iter != mGeos.end(); iter++) {
+                       //errMsg("ntlScene::~ntlScene","Deleting obj "<<(*iter)->getName() );
+                       delete (*iter);
+               }
+               for (vector<ntlLightObject*>::iterator iter = mpGlob->getLightList()->begin();
+                                iter != mpGlob->getLightList()->end(); iter++) {
+                       delete (*iter);
+               }
+               for (vector<ntlMaterial*>::iterator iter = mpGlob->getMaterials()->begin();
+                                iter != mpGlob->getMaterials()->end(); iter++) {
+                       delete (*iter);
+               }
+       }
+       errMsg("ntlScene::~ntlScene","Deleted, ObjFree:"<<mSceneDel);
+}
+
+
+/******************************************************************************
+ * Build the scene arrays (obj, tris etc.)
+ *****************************************************************************/
+void ntlScene::buildScene(double time,bool firstInit)
+{
+       const bool buildInfo=true;
+
+       if(firstInit) {
+               mObjects.clear();
+               /* init geometry array, first all standard objects */
+               for (vector<ntlGeometryClass*>::iterator iter = mGeos.begin();
+                               iter != mGeos.end(); iter++) {
+                       bool geoinit = false;
+                       int tid = (*iter)->getTypeId();
+                       if(tid & GEOCLASSTID_OBJECT) {
+                               ntlGeometryObject *geoobj = (ntlGeometryObject*)(*iter);
+                               geoinit = true;
+                               mObjects.push_back( geoobj );
+                               if(buildInfo) debMsgStd("ntlScene::BuildScene",DM_MSG,"added GeoObj "<<geoobj->getName()<<" Id:"<<geoobj->getObjectId(), 5 );
+                       }
+                       //if(geoshad) {
+                       if(tid & GEOCLASSTID_SHADER) {
+                               ntlGeometryShader *geoshad = (ntlGeometryShader*)(*iter);
+                               geoinit = true;
+                               if(!mFirstInitDone) {
+                                       // only on first init
+                                       geoshad->initializeShader();
+                               }
+                               for (vector<ntlGeometryObject*>::iterator siter = geoshad->getObjectsBegin();
+                                               siter != geoshad->getObjectsEnd();
+                                               siter++) {
+                                       if(buildInfo) debMsgStd("ntlScene::BuildScene",DM_MSG,"added shader geometry "<<(*siter)->getName()<<" Id:"<<(*siter)->getObjectId(), 5 );
+                                       mObjects.push_back( (*siter) );
+                               }
+                       }
+
+                       if(!geoinit) {
+                               errFatal("ntlScene::BuildScene","Invalid geometry class!", SIMWORLD_INITERROR);
+                               return;
+                       }
+               }
+       }
+
+       // collect triangles
+       mTriangles.clear();
+       mVertices.clear();
+       mVertNormals.clear();
+
+       /* for test mode deactivate transparencies etc. */
+       if( mpGlob->getTestMode() ) {
+               debugOut("ntlScene::buildScene : Test Mode activated!", 2);
+               // assign random colors to dark materials
+               int matCounter = 0;
+               ntlColor stdCols[] = { ntlColor(0,0,1.0), ntlColor(0,1.0,0), ntlColor(1.0,0.7,0) , ntlColor(0.7,0,0.6) };
+               int stdColNum = 4;
+               for (vector<ntlMaterial*>::iterator iter = mpGlob->getMaterials()->begin();
+                                        iter != mpGlob->getMaterials()->end(); iter++) {
+                       (*iter)->setTransparence(0.0);
+                       (*iter)->setMirror(0.0);
+                       (*iter)->setFresnel(false);
+                       // too dark?
+                       if( norm((*iter)->getDiffuseRefl()) <0.01) {
+                               (*iter)->setDiffuseRefl( stdCols[matCounter] );
+                               matCounter ++;
+                               matCounter = matCounter%stdColNum;
+                       }
+               }
+
+               // restrict output file size to 400
+               float downscale = 1.0;
+               if(mpGlob->getResX() > 400){ downscale = 400.0/(float)mpGlob->getResX(); }
+               if(mpGlob->getResY() > 400){ 
+                       float downscale2 = 400.0/(float)mpGlob->getResY(); 
+                       if(downscale2<downscale) downscale=downscale2;
+               }
+               mpGlob->setResX( (int)(mpGlob->getResX() * downscale) );
+               mpGlob->setResY( (int)(mpGlob->getResY() * downscale) );
+
+       }
+
+       /* collect triangles from objects */
+       int idCnt = 0;          // give IDs to objects
+       bool debugTriCollect = false;
+       if(debugTriCollect) debMsgStd("ntlScene::buildScene",DM_MSG,"Start...",5);
+  for (vector<ntlGeometryObject*>::iterator iter = mObjects.begin();
+       iter != mObjects.end();
+       iter++) {
+               /* only add visible objects */
+               if(firstInit) {
+                       if(debugTriCollect) debMsgStd("ntlScene::buildScene",DM_MSG,"Collect init of "<<(*iter)->getName()<<" idCnt:"<<idCnt, 4 );
+                       (*iter)->initialize( mpGlob ); }
+               if(debugTriCollect) debMsgStd("ntlScene::buildScene",DM_MSG,"Collecting tris from "<<(*iter)->getName(), 4 );
+
+               int vstart = mVertNormals.size();
+               (*iter)->setObjectId(idCnt);
+               (*iter)->getTriangles(&mTriangles, &mVertices, &mVertNormals, idCnt);
+               (*iter)->applyTransformation(time, &mVertices, &mVertNormals, vstart, mVertices.size(), false );
+
+               if(debugTriCollect) debMsgStd("ntlScene::buildScene",DM_MSG,"Done with "<<(*iter)->getName()<<" totTris:"<<mTriangles.size()<<" totVerts:"<<mVertices.size()<<" totNorms:"<<mVertNormals.size(), 4 );
+               idCnt ++;
+       }
+       if(debugTriCollect) debMsgStd("ntlScene::buildScene",DM_MSG,"End",5);
+
+
+       /* calculate triangle normals, and initialize flags */
+  for (vector<ntlTriangle>::iterator iter = mTriangles.begin();
+       iter != mTriangles.end();
+       iter++) {
+
+               // calculate normal from triangle points
+               ntlVec3Gfx normal = 
+                       cross( (ntlVec3Gfx)( (mVertices[(*iter).getPoints()[2]] - mVertices[(*iter).getPoints()[0]]) *-1.0),  // BLITZ minus sign right??
+                       (ntlVec3Gfx)(mVertices[(*iter).getPoints()[1]] - mVertices[(*iter).getPoints()[0]]) );
+               normalize(normal);
+               (*iter).setNormal( normal );
+       }
+
+
+
+       // scene geometry built 
+       mSceneBuilt = true;
+
+       // init shaders that require complete geometry
+       if(!mFirstInitDone) {
+               // only on first init
+               for (vector<ntlGeometryClass*>::iterator iter = mGeos.begin();
+                               iter != mGeos.end(); iter++) {
+                       if( (*iter)->getTypeId() & GEOCLASSTID_SHADER ) {
+                               ntlGeometryShader *geoshad = (ntlGeometryShader*)(*iter);
+                               geoshad->postGeoConstrInit( mpGlob );
+                       }
+               }
+               mFirstInitDone = true;
+       }
+
+       // check unused attributes (for classes and objects!)
+  for (vector<ntlGeometryObject*>::iterator iter = mObjects.begin(); iter != mObjects.end(); iter++) {
+               if((*iter)->getAttributeList()->checkUnusedParams()) {
+                       (*iter)->getAttributeList()->print(); // DEBUG
+                       errFatal("ntlScene::buildScene","Unused params for object '"<< (*iter)->getName() <<"' !", SIMWORLD_INITERROR );
+                       return;
+               }
+       }
+       for (vector<ntlGeometryClass*>::iterator iter = mGeos.begin(); iter != mGeos.end(); iter++) { 
+               if((*iter)->getAttributeList()->checkUnusedParams()) {
+                       (*iter)->getAttributeList()->print(); // DEBUG
+                       errFatal("ntlScene::buildScene","Unused params for object '"<< (*iter)->getName() <<"' !", SIMWORLD_INITERROR );
+                       return;
+               }
+       }
+
+}
+
+/******************************************************************************
+ * Prepare the scene triangles and maps for raytracing
+ *****************************************************************************/
+void ntlScene::prepareScene(double time)
+{
+       /* init triangles... */
+       buildScene(time, false);
+       // what for currently not used ???
+       if(mpTree != NULL) delete mpTree;
+       mpTree = new ntlTree( mpGlob->getTreeMaxDepth(), mpGlob->getTreeMaxTriangles(), 
+                                                                                               this, TRI_GEOMETRY );
+
+       //debMsgStd("ntlScene::prepareScene",DM_MSG,"Stats - tris:"<< (int)mTriangles.size()<<" verts:"<<mVertices.size()<<" vnorms:"<<mVertNormals.size(), 5 );
+}
+/******************************************************************************
+ * Do some memory cleaning, when frame is finished
+ *****************************************************************************/
+void ntlScene::cleanupScene( void )
+{
+       mTriangles.clear();
+       mVertices.clear();
+       mVertNormals.clear();
+
+       if(mpTree != NULL) delete mpTree;
+       mpTree = NULL;
+}
+
+
+/******************************************************************************
+ * Intersect a ray with the scene triangles
+ *****************************************************************************/
+void ntlScene::intersectScene(const ntlRay &r, gfxReal &distance, ntlVec3Gfx &normal, ntlTriangle *&tri,int flags) const
+{
+       distance = -1.0;
+  mpGlob->setCounterSceneInter( mpGlob->getCounterSceneInter()+1 );
+       mpTree->intersect(r, distance, normal, tri, flags, false);
+}
+
+
 
 
 
index 71fac128e26940ab6780b6d6e8d6645cc1eb9e18..716a620bfab3059830586568db59133d4b91fa6a 100644 (file)
@@ -6,14 +6,20 @@
  * ray class
  *
  *****************************************************************************/
-#ifndef NTL_RAY_HH
-#define NTL_RAY_HH
+#ifndef NTL_RAY_H
+#define NTL_RAY_H
 
+#include <sstream>
 #include "ntl_vector3dim.h"
-#include "ntl_lightobject.h"
+#include "ntl_lighting.h"
 #include "ntl_geometryobject.h"
-#include "ntl_renderglobals.h"
+#include "ntl_bsptree.h"
 
+class ntlTriangle;
+class ntlRay;
+class ntlTree;
+class ntlScene;
+class ntlRenderGlobals;
 
 //! store data for an intersection of a ray and a triangle
 // NOT YET USED
@@ -131,12 +137,279 @@ private:
 };
 
 
-
+/******************************************************************************
+ *
+ * a single triangle
+ *
+ *****************************************************************************/
 
 // triangle intersection code in bsptree.cpp
 // intersectTriangle(vector<ntlVec3Gfx> *mpV, ntlTriangle *tri, gfxReal &t, gfxReal &u, gfxReal &v);
-// ...
 
+/*! Triangle flag defines */
+#define TRI_GEOMETRY      (1<<0)
+#define TRI_CASTSHADOWS   (1<<1)
+#define TRI_MAKECAUSTICS  (1<<2)
+#define TRI_NOCAUSTICS    (1<<3)
+
+
+class ntlTriangle
+{
+public:
+  /* CONSTRUCTORS */
+  /*! Default constructor */
+  inline ntlTriangle( void );
+  /*! Constructor with parameters */
+  inline ntlTriangle(int *p, bool smooth, int obj, ntlVec3Gfx norm, int setflags);
+  /*! Copy - Constructor */
+  inline ntlTriangle(const ntlTriangle &tri);
+  /*! Destructor */
+  inline ~ntlTriangle() {}
+
+       /* Access methods */
+
+       /*! Acces to points of triangle */
+       inline int *getPoints( void ) { return mPoints; }
+       /*! Acces normal smoothing */
+       inline bool getSmoothNormals( void ) const { return mSmoothNormals; }
+       inline void setSmoothNormals( bool set){ mSmoothNormals = set; }
+       /*! Access object */
+       inline int getObjectId( void ) const { return mObjectId; }
+       inline void setObjectId( int set) { mObjectId = set; }
+       /*! Acces normal index */
+       inline ntlVec3Gfx getNormal( void ) const { return mNormal; }
+       inline void setNormal( ntlVec3Gfx set ) { mNormal = set; }
+       /*! Acces flags */
+       inline int getFlags( void ) const { return mFlags; }
+       inline void setFlags( int set ) { mFlags = set; }
+       /*! Access last intersection ray ID */
+       inline int  getLastRay( void ) const { return mLastRay; }
+       inline void setLastRay( int set ) { mLastRay = set; }
+       /*! Acces bbox id */
+       inline int getBBoxId( void ) const { return mBBoxId; }
+       inline void setBBoxId( int set ) { mBBoxId = set; }
+
+       /*! Get average of the three points for this axis */
+       inline gfxReal getAverage( int axis ) const;
+
+       /*! operator < for sorting, uses global sorting axis */
+       inline friend bool operator<(const ntlTriangle &lhs, const ntlTriangle &rhs);
+       /*! operator > for sorting, uses global sorting axis */
+       inline friend bool operator>(const ntlTriangle &lhs, const ntlTriangle &rhs);
+
+protected:
+
+private:
+
+       /*! indices to the three points of the triangle */
+       int mPoints[3];
+
+       /*! bounding box id (for tree generation), -1 if invalid */
+       int mBBoxId;
+
+       /*! Should the normals of this triangle get smoothed? */
+       bool mSmoothNormals;
+
+       /*! Id of parent object */
+       int mObjectId;
+
+       /*! Index to normal (for not smooth triangles) */
+       //int mNormalIndex; ??
+       ntlVec3Gfx mNormal;
+
+       /*! Flags for object attributes cast shadows, make caustics etc. */
+       int mFlags;
+
+       /*! ID of last ray that an intersection was calculated for */
+       int mLastRay;
+
+};
+
+
+       
+
+/******************************************************************************
+ * Default Constructor
+ *****************************************************************************/
+ntlTriangle::ntlTriangle( void ) :
+       mBBoxId(-1),
+       mLastRay( 0 )
+{
+       mPoints[0] = mPoints[1] = mPoints[2] = 0;
+       mSmoothNormals = 0;
+       mObjectId = 0;
+       mNormal = ntlVec3Gfx(0.0);
+       mFlags = 0;
+}
+
+
+/******************************************************************************
+ * Constructor
+ *****************************************************************************/
+ntlTriangle::ntlTriangle(int *p, bool smooth, int obj, ntlVec3Gfx norm, int setflags) :
+       mBBoxId(-1),
+       mLastRay( 0 )
+{
+       mPoints[0] = p[0];
+       mPoints[1] = p[1];
+       mPoints[2] = p[2];
+       mSmoothNormals = smooth;
+       mObjectId = obj;
+       mNormal = norm;
+       mFlags = setflags;
+}
+
+
+/******************************************************************************
+ * Copy Constructor
+ *****************************************************************************/
+ntlTriangle::ntlTriangle(const ntlTriangle &tri) :
+       mBBoxId(-1),
+       mLastRay( 0 )
+{
+       mPoints[0] = tri.mPoints[0];
+       mPoints[1] = tri.mPoints[1];
+       mPoints[2] = tri.mPoints[2];
+       mSmoothNormals = tri.mSmoothNormals;
+       mObjectId      = tri.mObjectId;
+       mNormal        = tri.mNormal;
+       mFlags         = tri.mFlags;
+}
+
+
+
+
+/******************************************************************************
+ * Triangle sorting functions
+ *****************************************************************************/
+
+/* variables imported from ntl_bsptree.cc, necessary for using the stl sort funtion */
+/* Static global variable for sorting direction */
+extern int globalSortingAxis;
+/* Access to points array for sorting */
+extern vector<ntlVec3Gfx> *globalSortingPoints;
+       
+
+gfxReal ntlTriangle::getAverage( int axis ) const
+{ 
+       return ( ( (*globalSortingPoints)[ mPoints[0] ][axis] + 
+                                                (*globalSortingPoints)[ mPoints[1] ][axis] + 
+                                                (*globalSortingPoints)[ mPoints[2] ][axis] )/3.0);
+}
+
+bool operator<(const ntlTriangle &lhs,const ntlTriangle &rhs)
+{
+       return ( lhs.getAverage(globalSortingAxis) < 
+                                        rhs.getAverage(globalSortingAxis) );
+}
+
+bool operator>(const ntlTriangle &lhs,const ntlTriangle &rhs)
+{
+       return ( lhs.getAverage(globalSortingAxis) > 
+                                        rhs.getAverage(globalSortingAxis) );
+}
+
+
+
+/******************************************************************************
+ *
+ * Scene object, that contains and manages all geometry objects
+ *
+ *****************************************************************************/
+
+
+
+class ntlScene
+{
+public:
+  /* CONSTRUCTORS */
+  /*! Default constructor */
+  ntlScene( ntlRenderGlobals *glob, bool del=true );
+  /*! Default destructor */
+   ~ntlScene();
+
+       /*! Add an object to the scene */
+       inline void addGeoClass(ntlGeometryClass *geo) { 
+               mGeos.push_back( geo ); 
+               geo->setObjectId(mGeos.size());
+       }
+
+       /*! Acces a certain object */
+       inline ntlGeometryObject *getObject(int id) { 
+               if(!mSceneBuilt) { errMsg("ntlScene::getObject","Scene not inited!"); return NULL; }
+               return mObjects[id]; }
+
+       /*! Acces object array */
+       inline vector<ntlGeometryObject*> *getObjects() { 
+               if(!mSceneBuilt) { errMsg("ntlScene::getObjects[]","Scene not inited!"); return NULL; }
+               return &mObjects; }
+
+       /*! Acces geo class array */
+       inline vector<ntlGeometryClass*> *getGeoClasses() { 
+               if(!mSceneBuilt) { errMsg("ntlScene::getGeoClasses[]","Scene not inited!"); return NULL; }
+               return &mGeos; }
+
+       /*! draw scene with opengl */
+       //void draw();
+       
+       /*! Build/first init the scene arrays */
+       void buildScene(double time, bool firstInit);
+       
+       //! Prepare the scene triangles and maps for raytracing
+       void prepareScene(double time);
+       //! Do some memory cleaning, when frame is finished
+       void cleanupScene( void );
+
+       /*! Intersect a ray with the scene triangles */
+       void intersectScene(const ntlRay &r, gfxReal &distance, ntlVec3Gfx &normal, ntlTriangle *&tri, int flags) const;
+
+       /*! return a vertex */
+       ntlVec3Gfx getVertex(int index) { return mVertices[index]; } 
+
+       // for tree generation 
+       /*! return pointer to vertices vector */
+       vector<ntlVec3Gfx> *getVertexPointer( void ) { return &mVertices; }
+       /*! return pointer to vertices vector */
+       vector<ntlVec3Gfx> *getVertexNormalPointer( void ) { return &mVertNormals; }
+       /*! return pointer to vertices vector */
+       vector<ntlTriangle> *getTrianglePointer( void ) { return &mTriangles; }
+
+private:
+
+       /*! Global settings */
+       ntlRenderGlobals *mpGlob;
+
+       /*! free objects? (only necessary for render scene, which  contains all) */
+       bool mSceneDel;
+
+  /*! List of geometry classes */
+  vector<ntlGeometryClass *> mGeos;
+
+  /*! List of geometry objects */
+  vector<ntlGeometryObject *> mObjects;
+
+  /*! List of triangles */
+  vector<ntlTriangle> mTriangles;
+  /*! List of vertices */
+  vector<ntlVec3Gfx>  mVertices;
+  /*! List of normals */
+  vector<ntlVec3Gfx>  mVertNormals;
+  /*! List of triangle normals */
+  vector<ntlVec3Gfx>  mTriangleNormals;
+
+       /*! Tree to store quickly intersect triangles */
+       ntlTree *mpTree;
+
+       /*! id of dislpay list for raytracer stuff */
+       int mDisplayListId;
+
+       /*! was the scene successfully built? only then getObject(i) requests are valid */
+       bool mSceneBuilt;
+
+       /*! shader/obj initializations are only done on first init */
+       bool mFirstInitDone;
+
+};
 
 
 #endif
diff --git a/intern/elbeem/intern/ntl_renderglobals.h b/intern/elbeem/intern/ntl_renderglobals.h
deleted file mode 100644 (file)
index 606d058..0000000
+++ /dev/null
@@ -1,365 +0,0 @@
-/******************************************************************************
- *
- * El'Beem - Free Surface Fluid Simulation with the Lattice Boltzmann Method
- * Copyright 2003,2004 Nils Thuerey
- *
- * main renderer class
- *
- *****************************************************************************/
-#ifndef NTL_RENDERGLOBALS_HH
-#define NTL_RENDERGLOBALS_HH
-
-
-#include "ntl_vector3dim.h"
-#include "ntl_rndstream.h"
-#include "ntl_geometryobject.h"
-#include "ntl_material.h"
-#include "ntl_lightobject.h"
-class ntlScene;
-class SimulationObject;
-
-
-
-//! Display mode
-#define DM_VIZ  0
-#define DM_RAY  1
-#define DM_LBM  2
-
-
-
-//! Class that handles global rendering parameters
-class ntlRenderGlobals
-{
-       public:
-               //! Standard constructor
-               inline ntlRenderGlobals();
-               //! Destructor
-               ~ntlRenderGlobals();
-
-               //! Returns the scene manager
-               inline ntlScene *getScene(void) { return mpScene; }
-               //! Set the scene manager
-               inline void setScene(ntlScene *set) { mpScene = set;} 
-
-               //! Returns the object list
-               //inline vector<ntlGeometryObject*> *getObjectList(void) { return mpObjList; }
-               //! Set the object list
-               //inline void setObjectList(vector<ntlGeometryObject*> *set) { mpObjList = set;} 
-
-               //! Returns the light object list
-               inline vector<ntlLightObject*> *getLightList(void) { return mpLightList; }
-               //! Set the light list
-               inline void setLightList(vector<ntlLightObject*> *set) { mpLightList = set;} 
-
-               //! Returns the property object list
-               inline vector<ntlMaterial*> *getMaterials(void) { return mpMaterials; }
-               //! Set the property list
-               inline void setMaterials(vector<ntlMaterial*> *set) { mpMaterials = set;} 
-
-               //! Returns the list of simulations
-               inline vector<SimulationObject*> *getSims(void) { return mpSims; }
-               //! Set the pointer to the list of simulations
-               inline void setSims(vector<SimulationObject*> *set) { mpSims = set;} 
-
-               //! Set the x resolution
-               inline void setResX(unsigned int set) { mResX = set; }
-               //! Set the y resolution
-               inline void setResY(unsigned int set) { mResY = set; }
-               //! Set the anti-aliasing depth
-               inline void setAADepth(int set) { mAADepth = set; }
-               //! Set the max color value
-               inline void setMaxColVal(unsigned int set) { mMaxColVal = set; }
-               //! Set the maximum ray recursion
-               inline void setRayMaxDepth(unsigned int set) { mRayMaxDepth = set; }
-               //! Set the eye point
-               inline void setEye(ntlVec3Gfx set) { mvEye = set; }
-               //! Set the look at vector
-               inline void setLookat(ntlVec3Gfx set) { mvLookat = set; }
-               //! Set the up vector
-               inline void setUpVec(ntlVec3Gfx set) { mvUpvec = set; }
-               //! Set the image aspect
-               inline void setAspect(float set) { mAspect = set; }
-               //! Set the field of view
-               inline void setFovy(float set) { mFovy = set; }
-               //! Set the background color
-               inline void setBackgroundCol(ntlColor set) { mcBackgr = set; }
-               //! Set the ambient lighting color
-               inline void setAmbientLight(ntlColor set) { mcAmbientLight = set; }
-               //! Set the debug output var 
-               inline void setDebugOut(int  set) { mDebugOut = set; }
-
-               //! Set the animation start time
-               inline void setAniStart(int set) { mAniStart = set; }
-               //! Set the animation number of frames
-               inline void setAniFrames(int set) { mAniFrames = set; }
-               //! Set the animation
-               inline void setAniCount(int set) { mAniCount = set; }
-               //! Set the ray counter
-               inline void setCounterRays(int set) { mCounterRays = set; }
-               //! Set the ray shades counter
-               inline void setCounterShades(int set) { mCounterShades = set; }
-               //! Set the scenen intersection counter
-               inline void setCounterSceneInter(int set) { mCounterSceneInter = set; }
-               //! Set if existing frames should be skipped
-               inline void setFrameSkip(int set) { mFrameSkip = set; }
-
-               //! Set the outfilename
-               inline void setOutFilename(string set) { mOutFilename = set; }
-
-               //! get Maximum depth for BSP tree
-               inline void setTreeMaxDepth( int set ) { mTreeMaxDepth = set; }
-               //! get Maxmimum nr of triangles per BSP tree node
-               inline void setTreeMaxTriangles( int set ) { mTreeMaxTriangles = set; }
-
-               //! set the enable flag of the test sphere
-               inline void setTestSphereEnabled( bool set ) { mTestSphereEnabled = set; }
-               //! set the center of the test sphere
-               inline void setTestSphereCenter( ntlVec3Gfx set ) { mTestSphereCenter = set; }
-               //! set the radius of the test sphere
-               inline void setTestSphereRadius( gfxReal set ) { mTestSphereRadius = set; }
-               //! set the material name of the test sphere
-               inline void setTestSphereMaterialName( char* set ) { mTestSphereMaterialName = set; }
-               //! set debugging pixel coordinates
-               inline void setDebugPixel( int setx, int sety ) { mDebugPixelX = setx; mDebugPixelY = sety; }
-               //! set test mode flag
-               inline void setTestMode( bool set ) { mTestMode = set; }
-               //! set single frame mode flag
-               inline void setSingleFrameMode(bool set) {mSingleFrameMode = set; };
-               //! set single frame mode filename
-               inline void setSingleFrameFilename(string set) {mSingleFrameFilename = set; };
-               
-
-               //! Return the x resolution
-               inline unsigned int getResX(void) { return mResX; }
-               //! Return the y resolution
-               inline unsigned int getResY(void) { return mResY; }
-               //! Return the anti-aliasing depth
-               inline int getAADepth(void) { return mAADepth; }
-               //! Return the max color value for ppm
-               inline unsigned int getMaxColVal(void) { return mMaxColVal; }
-               //! Return the maximum ray recursion
-               inline unsigned int getRayMaxDepth(void) { return mRayMaxDepth; }
-               //! Return the eye point
-               inline ntlVec3Gfx getEye(void) { return mvEye; }
-               //! Return the look at vector
-               inline ntlVec3Gfx getLookat(void) { return mvLookat; }
-               //! Return the up vector
-               inline ntlVec3Gfx getUpVec(void) { return mvUpvec; }
-               //! Return the image aspect 
-               inline float getAspect(void) { return mAspect; }
-               //! Return the field of view
-               inline float getFovy(void) { return mFovy; }
-               //! Return the background color
-               inline ntlColor getBackgroundCol(void) { return mcBackgr; }
-               //! Return the ambient color
-               inline ntlColor getAmbientLight(void) { return mcAmbientLight; }
-               //! Return the debug mode setting
-               inline int getDebugOut(void) { return mDebugOut; }
-
-               //! Return the animation start time
-               inline int getAniStart(void) { return mAniStart; }
-               //! Return the animation frame number
-               inline int getAniFrames(void) { return mAniFrames; }
-               //! Return the animation counter
-               inline int getAniCount(void) { return mAniCount; }
-               //! Return the ray counter
-               inline int getCounterRays(void) { return mCounterRays; }
-               //! Return the ray shades counter
-               inline int getCounterShades(void) { return mCounterShades; }
-               //! Return the scene intersection counter 
-               inline int getCounterSceneInter(void) { return mCounterSceneInter; }
-               //! Check if existing frames should be skipped
-               inline int getFrameSkip( void ) { return mFrameSkip; }
-
-
-               //! Return the outfilename
-               inline string getOutFilename(void) { return mOutFilename; }
-
-               //! get Maximum depth for BSP tree
-               inline int getTreeMaxDepth( void ) { return mTreeMaxDepth; }
-               //! get Maxmimum nr of triangles per BSP tree node
-               inline int getTreeMaxTriangles( void ) { return mTreeMaxTriangles; }
-               
-               //! get open gl attribute list
-               inline AttributeList* getOpenGlAttributes( void ) { return mpOpenGlAttr; }
-               //! get blender output attribute list
-               inline AttributeList* getBlenderAttributes( void ) { return mpBlenderAttr; }
-               
-               //! is the test sphere enabled? 
-               inline bool getTestSphereEnabled( void ) { return mTestSphereEnabled; }
-               //! get the center of the test sphere
-               inline ntlVec3Gfx getTestSphereCenter( void ) { return mTestSphereCenter; }
-               //! get the radius of the test sphere
-               inline gfxReal getTestSphereRadius( void) { return mTestSphereRadius; }
-               //! get the materialname of the test sphere
-               inline char *getTestSphereMaterialName( void) { return mTestSphereMaterialName; }
-               //! get the debug pixel coordinate
-               inline int getDebugPixelX( void ) { return mDebugPixelX; }
-               //! get the debug pixel coordinate
-               inline int getDebugPixelY( void ) { return mDebugPixelY; }
-               //! get test mode flag
-               inline bool getTestMode( void ) { return mTestMode; }
-               //! set single frame mode flag
-               inline bool getSingleFrameMode() { return mSingleFrameMode; };
-               //! set single frame mode filename
-               inline string getSingleFrameFilename() { return mSingleFrameFilename; };
-
-
-               // random number functions
-               //! init random numbers for photon directions
-               inline void initRandomDirections( int seed ) { if(mpRndDirections) delete mpRndDirections; mpRndDirections = new ntlRandomStream( seed ); } 
-               //! get the next random photon direction
-               inline ntlVec3Gfx getRandomDirection( void );
-               //! init random numbers for russian roulette
-               inline void initRandomRoulette( int seed ) { if(mpRndRoulette) delete mpRndRoulette; mpRndRoulette = new ntlRandomStream( seed ); } 
-               //! get the next random  number for russion roulette
-               inline gfxReal getRandomRoulette( void ) { return mpRndRoulette->getGfxReal(); }
-
-
-protected:
-  
-private:
-
-       /*! Scene storage */
-       ntlScene *mpScene;
-
-  //! List of geometry objects
-  //vector<ntlGeometryObject*>  *mpObjList;
-  //! List of light objects
-  vector<ntlLightObject*> *mpLightList;
-  //! List of surface properties
-  vector<ntlMaterial*> *mpMaterials;
-       /*! storage for simulations */
-       vector<SimulationObject*> *mpSims;
-
-  //! resolution of the picture
-  unsigned int mResX, mResY;
-  //! Anti-Aliasing depth
-  int mAADepth;
-  //! max color value for ppm
-  unsigned int mMaxColVal;
-  /* Maximal ray recursion depth */
-  int mRayMaxDepth;
-  //! The eye point
-  ntlVec3Gfx  mvEye;
-  //! The look at point
-  ntlVec3Gfx  mvLookat;
-  //! The up vector
-  ntlVec3Gfx  mvUpvec;
-  //! The image aspect = Xres/Yres
-  float  mAspect;
-  //! The horizontal field of view
-  float  mFovy;
-  //! The background color
-  ntlColor  mcBackgr;
-  //! The ambient color
-  ntlColor  mcAmbientLight;
-  //! how much debug output is needed? off by default
-  char mDebugOut;
-
-
-  //! animation properties, start time
-  int mAniStart;
-  //! animation properties, number of frames to render
-  int mAniFrames;
-  //! animation status, current frame number
-  int mAniCount;
-       /*! Should existing picture frames be skipped? */
-       int mFrameSkip;
-
-
-  //! count the total number of rays created (also used for ray ID's)
-  int  mCounterRays;
-  //! count the total number of rays shaded
-  int  mCounterShades;
-  //! count the total number of scene intersections
-  int  mCounterSceneInter;
-
-       /*! filename of output pictures (without suffix or numbers) */
-  string mOutFilename;
-
-       //! get Maximum depth for BSP tree
-       int mTreeMaxDepth;
-       //! get Maxmimum nr of triangles per BSP tree node
-       int mTreeMaxTriangles; 
-
-       //! attribute list for opengl renderer
-       AttributeList *mpOpenGlAttr;
-       //! attribute list for blender output 
-       AttributeList *mpBlenderAttr;
-
-
-       //! Enable test sphere?
-       bool mTestSphereEnabled;
-       //! Center of the test sphere
-       ntlVec3Gfx mTestSphereCenter;
-       //! Radius of the test sphere
-       gfxReal mTestSphereRadius;
-       //! Materialname of the test sphere
-       char *mTestSphereMaterialName;
-       //! coordinates of the debugging pixel
-       int mDebugPixelX, mDebugPixelY;
-
-       //! test mode for quick rendering activated?, inited in ntl_scene::buildScene
-       bool mTestMode;
-
-       //! single frame flag
-       bool mSingleFrameMode;
-       //! filename for single frame mode
-       string mSingleFrameFilename;
-
-       /*! Two random number streams for photon generation (one for the directions, the other for russion roulette) */
-       ntlRandomStream *mpRndDirections, *mpRndRoulette;
-
-};
-
-
-
-
-/*****************************************************************************/
-/* Constructor with standard value init */
-inline ntlRenderGlobals::ntlRenderGlobals() :
-  mpLightList( NULL ), mpMaterials( NULL ), mpSims( NULL ),
-  mResX(320), mResY(200), mAADepth(-1), mMaxColVal(255), 
-  mRayMaxDepth( 5 ),
-  mvEye(0.0,0.0,5.0), mvLookat(0.0,0.0,0.0), mvUpvec(0.0,1.0,0.0), 
-  mAspect(320.0/200.0), 
-  mFovy(45), mcBackgr(0.0,0.0,0.0), mcAmbientLight(0.0,0.0,0.0), 
-  mDebugOut( 0 ),
-  mAniStart(0), mAniFrames( -1 ), mAniCount( 0 ),
-       mFrameSkip( 0 ),
-  mCounterRays( 0 ), mCounterShades( 0 ), mCounterSceneInter( 0 ),
-       mOutFilename( "pic" ),
-       mTreeMaxDepth( 30 ), mTreeMaxTriangles( 30 ),
-       mpOpenGlAttr(NULL),
-       mpBlenderAttr(NULL),
-       mTestSphereEnabled( false ),
-       mDebugPixelX( -1 ), mDebugPixelY( -1 ), mTestMode(false),
-       mSingleFrameMode(false), mSingleFrameFilename(""),
-       mpRndDirections( NULL ), mpRndRoulette( NULL )
-{ 
-       // create internal attribute list for opengl renderer
-       mpOpenGlAttr = new AttributeList("__ntlOpenGLRenderer");
-       mpBlenderAttr = new AttributeList("__ntlBlenderAttr");
-};
-
-
-/*****************************************************************************/
-/* Destructor */
-inline ntlRenderGlobals::~ntlRenderGlobals() {
-       if(mpOpenGlAttr) delete mpOpenGlAttr;
-       if(mpBlenderAttr) delete mpBlenderAttr;
-}
-
-
-/*****************************************************************************/
-//! get the next random photon direction
-inline ntlVec3Gfx ntlRenderGlobals::getRandomDirection( void ) { 
-       return ntlVec3Gfx( 
-                       (mpRndDirections->getGfxReal()-0.5), 
-                       (mpRndDirections->getGfxReal()-0.5),  
-                       (mpRndDirections->getGfxReal()-0.5) ); 
-} 
-
-#endif
-
diff --git a/intern/elbeem/intern/ntl_rndstream.h b/intern/elbeem/intern/ntl_rndstream.h
deleted file mode 100644 (file)
index 9eaa909..0000000
+++ /dev/null
@@ -1,127 +0,0 @@
-/******************************************************************************
- *
- * El'Beem - Free Surface Fluid Simulation with the Lattice Boltzmann Method
- * Copyright 2003,2004 Nils Thuerey
- *
- * A seperate random number stream (e.g. for photon tracing)
- * (cf. Numerical recipes in C, sec. ed., p 283, Knuth method)
- *
- *****************************************************************************/
-#ifndef NTL_RANDOMSTREAM_H
-
-
-//! some big number
-#define MBIG 1000000000
-
-//! modify initial seed
-#define MSEED 161803398
-
-//! minimum value - no idea why this is a define?
-#define MZ 0
-
-//! for normalization to 0..1
-#define FAC (1.0/MBIG)
-
-
-/*! a stream of random numbers using Knuth's portable method */
-class ntlRandomStream
-{
-public:
-  /*! Default constructor */
-  inline ntlRandomStream(long seed);
-  /*! Destructor */
-  ~ntlRandomStream() {}
-
-       /*! get a random number from the stream */
-       inline double getDouble( void );
-
-#ifdef HAVE_GFXTYPES
-       //! gfx random functions
-       
-       /*! get a random number from the stream */
-       inline gfxReal getGfxReal( void );
-#endif
-
-private:
-
-       /*! random number state */
-       long idnum;
-
-       /*! pointers into number table */ 
-       int inext, inextp;
-       /*! store seed and number for subtraction */
-       long ma[56];
-
-};
-
-
-/* init random stream tables */
-inline ntlRandomStream::ntlRandomStream(long seed)
-{
-       idnum = seed;
-
-       long mj = MSEED - (idnum < 0 ? -idnum : idnum);
-       mj %= MBIG;
-       ma[55] = mj;
-       long mk = 1;
-
-       // init table once, otherwise strange results...
-       for(int i=0;i<=55;i++) ma[i] = (i*i+seed); 
-
-       // init table in random order
-       for(int i=1;i<=54;i++) {
-               int ii = (21*i) % 56;
-               ma[ii] = mk;
-               mk = mj - mk;
-               if(mk < MZ) mk += MBIG;
-               mj = ma[ii];
-       }
-
-       // "warm up" generator
-       for(int k=1;k<=4;k++) 
-               for(int i=1;i<=55;i++) {
-                       ma[i] -= ma[1+ (i+30) % 55];
-                       if(ma[i] < MZ) ma[i] += MBIG;
-               }
-
-       inext = 0;
-       inextp = 31; // the special "31"
-       idnum = 1;
-}
-
-
-/* return one random value */
-inline double ntlRandomStream::getDouble( void )
-{
-       if( ++inext == 56) inext = 1;
-       if( ++inextp == 56) inextp = 1;
-
-       // generate by subtaction
-       long mj = ma[inext] - ma[inextp];
-
-       // check range
-       if(mj < MZ) mj += MBIG;
-       ma[ inext ] = mj;
-       return (double)(mj * FAC);
-}
-
-#ifdef HAVE_GFXTYPES
-/* return one random value */
-inline gfxReal ntlRandomStream::getGfxReal( void )
-{
-       if( ++inext == 56) inext = 1;
-       if( ++inextp == 56) inextp = 1;
-
-       // generate by subtaction
-       long mj = ma[inext] - ma[inextp];
-
-       // check range
-       if(mj < MZ) mj += MBIG;
-       ma[ inext ] = mj;
-       return (gfxReal)(mj * FAC);
-}
-#endif
-
-#define NTL_RANDOMSTREAM_H
-#endif
-
diff --git a/intern/elbeem/intern/ntl_scene.cpp b/intern/elbeem/intern/ntl_scene.cpp
deleted file mode 100644 (file)
index 4e98094..0000000
+++ /dev/null
@@ -1,235 +0,0 @@
-/******************************************************************************
- *
- * El'Beem - Free Surface Fluid Simulation with the Lattice Boltzmann Method
- * Copyright 2003,2004 Nils Thuerey
- *
- * Scene object, that contains and manages all geometry objects
- *
- *****************************************************************************/
-
-#include "utilities.h"
-#include "ntl_scene.h"
-#include "ntl_geometryobject.h"
-#include "ntl_geometryshader.h"
-
-
-/******************************************************************************
- * Constructor
- *****************************************************************************/
-ntlScene::ntlScene( ntlRenderGlobals *glob ) :
-       mpGlob( glob ),
-       mpTree( NULL ),
-       mDisplayListId( -1 ), 
-       mSceneBuilt( false ), mFirstInitDone( false )
-{
-}
-
-
-/******************************************************************************
- * Destructor
- *****************************************************************************/
-ntlScene::~ntlScene()
-{
-       cleanupScene();
-
-       // cleanup lists
-       for (vector<ntlGeometryClass*>::iterator iter = mGeos.begin();
-                       iter != mGeos.end(); iter++) {
-               delete (*iter);
-       }
-       for (vector<ntlLightObject*>::iterator iter = mpGlob->getLightList()->begin();
-                        iter != mpGlob->getLightList()->end(); iter++) {
-               delete (*iter);
-       }
-       for (vector<ntlMaterial*>::iterator iter = mpGlob->getMaterials()->begin();
-                        iter != mpGlob->getMaterials()->end(); iter