← Back to branch summary

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

« back to all changes in this revision

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

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

Show diffs side-by-side

added added

removed removed

Lines of Context:
intern/elbeem/intern/ntl_blenderdumper.cpp
14
14
#include "utilities.h"
15
15
#include "ntl_matrices.h"
16
16
#include "ntl_blenderdumper.h"
17
 
#include "ntl_scene.h"
 
17
#include "ntl_world.h"
 
18
#include "solver_interface.h"
18
19
 
19
20
#include <zlib.h>
20
21
 
23
24
/******************************************************************************
24
25
 * Constructor
25
26
 *****************************************************************************/
 
27
ntlBlenderDumper::ntlBlenderDumper() : ntlWorld()
 
28
{
 
29
        // same as normal constructor here
 
30
}
26
31
ntlBlenderDumper::ntlBlenderDumper(string filename, bool commandlineMode) :
27
 
        ntlWorld(filename,commandlineMode),
28
 
        mpTrafo(NULL)
29
 
{
30
 
  ntlRenderGlobals *glob = mpGlob;
31
 
        AttributeList *pAttrs = glob->getBlenderAttributes();
32
 
        mpTrafo = new ntlMat4Gfx(0.0);
33
 
        mpTrafo->initId();
34
 
        (*mpTrafo) = pAttrs->readMat4Gfx("transform" , (*mpTrafo), "ntlBlenderDumper","mpTrafo", false ); 
35
 
}
36
 
ntlBlenderDumper::ntlBlenderDumper(elbeemSimulationSettings *settings) :
37
 
        ntlWorld(settings), mpTrafo(NULL)
38
 
{
39
 
        // same as normal constructor here
40
 
  ntlRenderGlobals *glob = mpGlob;
41
 
        AttributeList *pAttrs = glob->getBlenderAttributes();
42
 
        mpTrafo = new ntlMat4Gfx(0.0);
43
 
        mpTrafo->initId();
44
 
        (*mpTrafo) = pAttrs->readMat4Gfx("transform" , (*mpTrafo), "ntlBlenderDumper","mpTrafo", false ); 
 
32
        ntlWorld(filename,commandlineMode)
 
33
{
 
34
        // init world
45
35
}
46
36
 
47
37
 
51
41
 *****************************************************************************/
52
42
ntlBlenderDumper::~ntlBlenderDumper()
53
43
{
54
 
        delete mpTrafo;
 
44
        debMsgStd("ntlBlenderDumper",DM_NOTIFY, "ntlBlenderDumper done", 10);
55
45
}
56
46
 
57
47
/******************************************************************************
61
51
{
62
52
        char nrStr[5];                                                          /* nr conversion */
63
53
  ntlRenderGlobals *glob = mpGlob;
64
 
  ntlScene *scene = mpGlob->getScene();
 
54
  ntlScene *scene = mpGlob->getSimScene();
65
55
        bool debugOut = true;
66
 
#if ELBEEM_BLENDER==1
 
56
#if ELBEEM_PLUGIN==1
67
57
        debugOut = false;
68
 
#endif // ELBEEM_BLENDER==1
69
 
 
70
 
        // output path
71
 
        /*std::ostringstream ecrpath("");
72
 
        ecrpath << "/tmp/ecr_" << getpid() <<"/";
73
 
        // make sure the dir exists
74
 
        std::ostringstream ecrpath_create("");
75
 
        ecrpath_create << "mkdir " << ecrpath.str();
76
 
        system( ecrpath_create.str().c_str() );
77
 
        // */
78
 
 
79
 
        vector<string> hideObjs; // geom shaders to hide 
 
58
#endif // ELBEEM_PLUGIN==1
 
59
 
80
60
        vector<string> gmName;   // gm names
81
61
        vector<string> gmMat;    // materials for gm
82
62
        int numGMs = 0;                                  // no. of .obj models created
105
85
                }
106
86
                if(tid & GEOCLASSTID_SHADER) {
107
87
                        ntlGeometryShader *geoshad = (ntlGeometryShader*)(*iter); //dynamic_cast<ntlGeometryShader*>(*iter);
108
 
                        hideObjs.push_back( (*iter)->getName() );
 
88
                        string outname = geoshad->getOutFilename();
 
89
                        if(outname.length()<1) outname = mpGlob->getOutFilename();
 
90
                        geoshad->notifyShaderOfDump(DUMP_FULLGEOMETRY, glob->getAniCount(),nrStr,outname);
 
91
 
109
92
                        for (vector<ntlGeometryObject*>::iterator siter = geoshad->getObjectsBegin();
110
93
                                        siter != geoshad->getObjectsEnd();
111
94
                                        siter++) {
112
95
                                if(debugOut) debMsgStd("ntlBlenderDumper::BuildScene",DM_MSG,"added shader geometry "<<(*siter)->getName(), 8);
 
96
 
 
97
                                (*siter)->notifyOfDump(DUMP_FULLGEOMETRY, glob->getAniCount(),nrStr,outname, this->mSimulationTime);
 
98
                                bool doDump = false;
 
99
                                bool isPreview = false;
 
100
                                // only dump final&preview surface meshes
 
101
                                if( (*siter)->getName().find( "final" ) != string::npos) {
 
102
                                        doDump = true;
 
103
                                } else if( (*siter)->getName().find( "preview" ) != string::npos) {
 
104
                                        doDump = true;
 
105
                                        isPreview = true;
 
106
                                }
 
107
                                if(!doDump) continue;
113
108
                                
114
109
                                // only dump geo shader objects
115
110
                                Triangles.clear();
116
111
                                Vertices.clear();
117
112
                                VertNormals.clear();
118
113
                                (*siter)->initialize( mpGlob );
119
 
                                (*siter)->getTriangles(&Triangles, &Vertices, &VertNormals, idCnt);
 
114
                                (*siter)->getTriangles(this->mSimulationTime, &Triangles, &Vertices, &VertNormals, idCnt);
 
115
 
120
116
                                idCnt ++;
121
117
 
122
118
                                // always dump mesh, even empty ones...
123
 
                                //if(Vertices.size() <= 0) continue;
124
 
                                //if(Triangles.size() <= 0) continue;
125
 
 
126
 
                                for(size_t i=0; i<Vertices.size(); i++) {
127
 
                                        Vertices[i] = (*mpTrafo) * Vertices[i];
128
 
                                }
129
119
 
130
120
                                // dump to binary file
131
121
                                std::ostringstream boutfilename("");
132
 
                                //boutfilename << ecrpath.str() << glob->getOutFilename() <<"_"<< (*siter)->getName() <<"_" << nrStr << ".obj";
133
 
                                boutfilename << glob->getOutFilename() <<"_"<< (*siter)->getName() <<"_" << nrStr << ".bobj";
 
122
                                //boutfilename << ecrpath.str() << outname <<"_"<< (*siter)->getName() <<"_" << nrStr << ".obj";
 
123
                                boutfilename << outname <<"_"<< (*siter)->getName() <<"_" << nrStr;
134
124
                                if(debugOut) debMsgStd("ntlBlenderDumper::renderScene",DM_MSG,"B-Dumping: "<< (*siter)->getName() 
135
125
                                                <<", triangles:"<<Triangles.size()<<", vertices:"<<Vertices.size()<<
136
126
                                                " to "<<boutfilename.str() , 7);
137
 
                                bool isPreview = false;
138
 
                                if( (*siter)->getName().find( "preview" ) != string::npos) {
139
 
                                        isPreview = true;
140
 
                                }
141
 
                                boutfilename << ".gz";
142
 
 
143
 
                                // compress all bobj's except for preview ones...
144
127
                                gzFile gzf;
145
 
                                if(isPreview) {
146
 
                                        gzf = gzopen(boutfilename.str().c_str(), "wb1");
147
 
                                } else {
148
 
                                        gzf = gzopen(boutfilename.str().c_str(), "wb9");
 
128
 
 
129
                                // output velocities if desired
 
130
                                // WARNING - this is dirty, but simobjs are the only geoshaders right now
 
131
                                SimulationObject *sim = (SimulationObject *)geoshad;
 
132
                                LbmSolverInterface *lbm = sim->getSolver();
 
133
                                if((!isPreview) && (lbm->getDumpVelocities())) {
 
134
                                        std::ostringstream bvelfilename;
 
135
                                        bvelfilename << boutfilename.str();
 
136
                                        bvelfilename << ".bvel.gz";
 
137
                                        gzf = gzopen(bvelfilename.str().c_str(), "wb9");
 
138
                                        if(gzf) {
 
139
                                                int numVerts;
 
140
                                                if(sizeof(numVerts)!=4) { errMsg("ntlBlenderDumper::renderScene","Invalid int size"); return 1; }
 
141
                                                numVerts = Vertices.size();
 
142
                                                gzwrite(gzf, &numVerts, sizeof(numVerts));
 
143
                                                for(size_t i=0; i<Vertices.size(); i++) {
 
144
                                                        // returns smoothed velocity, scaled by frame time
 
145
                                                        ntlVec3Gfx v = lbm->getVelocityAt( Vertices[i][0], Vertices[i][1], Vertices[i][2] );
 
146
                                                        // translation not necessary, test rotation & scaling?
 
147
                                                        for(int j=0; j<3; j++) {
 
148
                                                                float vertp = v[j];
 
149
                                                                //if(i<20) errMsg("ntlBlenderDumper","DUMP_VEL final "<<i<<" = "<<v);
 
150
                                                                gzwrite(gzf, &vertp, sizeof(vertp)); }
 
151
                                                }
 
152
                                                gzclose( gzf );
 
153
                                        }
149
154
                                }
 
155
 
 
156
                                // compress all bobj's 
 
157
                                boutfilename << ".bobj.gz";
 
158
                                //if(isPreview) { } else { }
 
159
                                gzf = gzopen(boutfilename.str().c_str(), "wb1"); // wb9 is slow for large meshes!
150
160
                                if (!gzf) {
151
161
                                        errMsg("ntlBlenderDumper::renderScene","Unable to open output '"<<boutfilename<<"' ");
152
162
                                        return 1; }
153
163
                                
154
 
                                int wri;
155
 
                                float wrf;
156
 
                                if(sizeof(wri)!=4) { errMsg("ntlBlenderDumper::renderScene","Invalid int size"); return 1; }
157
 
                                wri = Vertices.size();
158
 
                                gzwrite(gzf, &wri, sizeof(wri));
 
164
                                //! current transform matrix
 
165
                                ntlMatrix4x4<gfxReal> *trafo;
 
166
                                trafo = lbm->getDomainTrafo();
 
167
                                if(trafo) {
 
168
                                        //trafo->initArrayCheck(ettings->surfaceTrafo);
 
169
                                        //errMsg("ntlBlenderDumper","mpTrafo : "<<(*mpTrafo) );
 
170
                                        // transform into source space
 
171
                                        for(size_t i=0; i<Vertices.size(); i++) {
 
172
                                                Vertices[i] = (*trafo) * Vertices[i];
 
173
                                        }
 
174
                                }
 
175
 
 
176
                                // write to file
 
177
                                int numVerts;
 
178
                                if(sizeof(numVerts)!=4) { errMsg("ntlBlenderDumper::renderScene","Invalid int size"); return 1; }
 
179
                                numVerts = Vertices.size();
 
180
                                gzwrite(gzf, &numVerts, sizeof(numVerts));
159
181
                                for(size_t i=0; i<Vertices.size(); i++) {
160
182
                                        for(int j=0; j<3; j++) {
161
 
                                                wrf = Vertices[i][j];
162
 
                                                gzwrite(gzf, &wrf, sizeof(wrf)); }
 
183
                                                float vertp = Vertices[i][j];
 
184
                                                gzwrite(gzf, &vertp, sizeof(vertp)); }
163
185
                                }
164
186
 
165
187
                                // should be the same as Vertices.size
166
 
                                wri = VertNormals.size();
167
 
                                gzwrite(gzf, &wri, sizeof(wri));
 
188
                                if(VertNormals.size() != (size_t)numVerts) {
 
189
                                        errMsg("ntlBlenderDumper::renderScene","Normals have to have same size as vertices!");
 
190
                                        VertNormals.resize( Vertices.size() );
 
191
                                }
 
192
                                gzwrite(gzf, &numVerts, sizeof(numVerts));
168
193
                                for(size_t i=0; i<VertNormals.size(); i++) {
169
194
                                        for(int j=0; j<3; j++) {
170
 
                                                wrf = VertNormals[i][j];
171
 
                                                gzwrite(gzf, &wrf, sizeof(wrf)); }
 
195
                                                float normp = VertNormals[i][j];
 
196
                                                gzwrite(gzf, &normp, sizeof(normp)); }
172
197
                                }
173
198
 
174
 
                                wri = Triangles.size();
175
 
                                gzwrite(gzf, &wri, sizeof(wri));
 
199
                                int numTris = Triangles.size();
 
200
                                gzwrite(gzf, &numTris, sizeof(numTris));
176
201
                                for(size_t i=0; i<Triangles.size(); i++) {
177
202
                                        for(int j=0; j<3; j++) {
178
 
                                                wri = Triangles[i].getPoints()[j];
179
 
                                                gzwrite(gzf, &wri, sizeof(wri)); }
 
203
                                                int triIndex = Triangles[i].getPoints()[j];
 
204
                                                gzwrite(gzf, &triIndex, sizeof(triIndex)); }
180
205
                                }
181
206
                                gzclose( gzf );
182
 
                                debMsgDirect(" Wrote: '"<<boutfilename.str()<<"'. ");
 
207
                                debMsgStd("ntlBlenderDumper::renderScene",DM_NOTIFY," Wrote: '"<<boutfilename.str()<<"' ", 2);
183
208
                                numGMs++;
184
209
                        }
185
210
                }
200
225
        debMsgStd("ntlBlenderDumper::renderScene",DM_MSG,"Scene #"<<nrStr<<" dump time: "<< getTimeString(stopTime-startTime) <<" ", 10);
201
226
 
202
227
        // still render for preview...
 
228
debugOut = false; // DEBUG!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
203
229
        if(debugOut) {
204
230
                debMsgStd("ntlBlenderDumper::renderScene",DM_NOTIFY,"Performing preliminary render", 1);
205
231
                ntlWorld::renderScene(); }