← Back to branch summary

~ubuntu-branches/ubuntu/trusty/openscenegraph/trusty

« back to all changes in this revision

Viewing changes to OpenSceneGraph/src/osgPlugins/osgTerrain/TerrainTile.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Cyril Brulebois
  • Date: 2008-07-29 04:34:38 UTC
  • mfrom: (1.1.6 upstream) (2.1.3 lenny)
  • Revision ID: james.westby@ubuntu.com-20080729043438-no1h9h0dpsrlzp1y
http://bugs.debian.org/477353
http://bugs.debian.org/482239
* Non-maintainer upload.
* No longer try to detect (using /proc/cpuinfo when available) how many
  CPUs are available, fixing the FTBFS (due to -j0) on various platforms
  (Closes: #477353). The right way to do it is to support parallel=n in
  DEB_BUILD_OPTIONS (see Debian Policy §4.9.1), and adequate support has
  been implemented.
* Add patch to fix FTBFS due to the build system now refusing to handle
  whitespaces (Policy CMP0004 say the logs), thanks to Andreas Putzo who
  provided it (Closes: #482239):
   - debian/patches/fix-cmp0004-build-failure.dpatch
* Remove myself from Uploaders, as requested a while ago, done by Luk in
  his 2.2.0-2.1 NMU, which was never acknowledged.

Show diffs side-by-side

added added

removed removed

Lines of Context:
OpenSceneGraph/src/osgPlugins/osgTerrain/TerrainTile.cpp
 
1
#include <osgTerrain/TerrainTile>
 
2
 
 
3
#include <iostream>
 
4
#include <string>
 
5
 
 
6
#include <osg/Vec3>
 
7
#include <osg/Vec4>
 
8
#include <osg/io_utils>
 
9
 
 
10
#include <osgDB/ReadFile>
 
11
#include <osgDB/Registry>
 
12
#include <osgDB/Input>
 
13
#include <osgDB/Output>
 
14
#include <osgDB/ParameterOutput>
 
15
 
 
16
bool TerrainTile_readLocalData(osg::Object &obj, osgDB::Input &fr);
 
17
bool TerrainTile_writeLocalData(const osg::Object &obj, osgDB::Output &fw);
 
18
 
 
19
osgDB::RegisterDotOsgWrapperProxy TerrainTile_Proxy
 
20
(
 
21
    new osgTerrain::TerrainTile,
 
22
    "TerrainTile",
 
23
    "Object Node TerrainTile Group",
 
24
    TerrainTile_readLocalData,
 
25
    TerrainTile_writeLocalData
 
26
);
 
27
 
 
28
osg::TransferFunction* readTransferFunction(osgDB::Input& fr)
 
29
{
 
30
    osg::ref_ptr<osg::TransferFunction1D> tf = new osg::TransferFunction1D;
 
31
    
 
32
    int entry = fr[0].getNoNestedBrackets();
 
33
 
 
34
    fr += 2;
 
35
 
 
36
    std::vector<osg::Vec4> colours;
 
37
 
 
38
    while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
 
39
    {
 
40
        bool itrAdvanced = false;
 
41
        if (fr.matchSequence("range %f %f"))
 
42
        {
 
43
            float minValue,maxValue;
 
44
            fr[1].getFloat(minValue);
 
45
            fr[2].getFloat(maxValue);
 
46
        
 
47
            tf->setInputRange(minValue,maxValue);
 
48
            
 
49
            fr += 3;
 
50
            itrAdvanced = true;
 
51
        }
 
52
 
 
53
        if (fr.matchSequence("color %f %f %f %f"))
 
54
        {
 
55
            float r,g,b,a;
 
56
            fr[1].getFloat(r);
 
57
            fr[2].getFloat(g);
 
58
            fr[3].getFloat(b);
 
59
            fr[4].getFloat(a);
 
60
        
 
61
            colours.push_back(osg::Vec4(r,g,b,a));
 
62
            
 
63
            fr += 5;
 
64
            itrAdvanced = true;
 
65
        }
 
66
 
 
67
        if (fr.matchSequence("color %f %f %f"))
 
68
        {
 
69
            float r,g,b;
 
70
            fr[1].getFloat(r);
 
71
            fr[2].getFloat(g);
 
72
            fr[3].getFloat(b);
 
73
        
 
74
            colours.push_back(osg::Vec4(r,g,b,1.0f));
 
75
            
 
76
            fr += 5;
 
77
            itrAdvanced = true;
 
78
        }
 
79
 
 
80
        if (!itrAdvanced)
 
81
        {
 
82
            if (fr[0].getStr()) osg::notify(osg::NOTICE)<<"TransferFunction - unreconised token : "<<fr[0].getStr() << std::endl;
 
83
            ++fr;
 
84
        }
 
85
    }
 
86
    
 
87
 
 
88
    // step over trailing }
 
89
    ++fr;
 
90
    
 
91
    if (!colours.empty())
 
92
    {
 
93
        tf->allocate(colours.size());
 
94
        for(unsigned int i=0; i<colours.size(); ++i)
 
95
        {
 
96
            tf->setValue(i, colours[i]);
 
97
        }
 
98
    }
 
99
 
 
100
    if (tf->getNumberCellsX()==0)
 
101
    {
 
102
        tf->allocate(6);
 
103
        tf->setValue(0, osg::Vec4(1.0,1.0,1.0,1.0));
 
104
        tf->setValue(1, osg::Vec4(1.0,0.0,1.0,1.0));
 
105
        tf->setValue(2, osg::Vec4(1.0,0.0,0.0,1.0));
 
106
        tf->setValue(3, osg::Vec4(1.0,1.0,0.0,1.0));
 
107
        tf->setValue(4, osg::Vec4(0.0,1.0,1.0,1.0));
 
108
        tf->setValue(5, osg::Vec4(0.0,1.0,0.0,1.0));
 
109
    }
 
110
 
 
111
    return tf.release();
 
112
}
 
113
 
 
114
 
 
115
bool TerrainTile_readLocalData(osg::Object& obj, osgDB::Input &fr)
 
116
{
 
117
    osgTerrain::TerrainTile& terrainTile = static_cast<osgTerrain::TerrainTile&>(obj);
 
118
 
 
119
    bool itrAdvanced = false;
 
120
 
 
121
    osg::ref_ptr<osg::Object> readObject = fr.readObjectOfType(osgDB::type_wrapper<osgTerrain::Locator>());
 
122
    if (readObject.valid()) itrAdvanced = true;
 
123
 
 
124
    osgTerrain::Locator* locator = dynamic_cast<osgTerrain::Locator*>(readObject.get());
 
125
    if (locator) terrainTile.setLocator(locator);
 
126
 
 
127
    if (fr.matchSequence("ElevationLayer {"))
 
128
    {
 
129
        int entry = fr[0].getNoNestedBrackets();
 
130
        fr += 2;
 
131
 
 
132
        while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
 
133
        {
 
134
            bool localAdvanced = false;
 
135
 
 
136
            osg::ref_ptr<osg::Object> readObject = fr.readObjectOfType(osgDB::type_wrapper<osgTerrain::Locator>());
 
137
            osgTerrain::Locator* locator = dynamic_cast<osgTerrain::Locator*>(readObject.get());
 
138
            if (readObject.valid()) localAdvanced = true;
 
139
 
 
140
            unsigned int minLevel=0;
 
141
            if (fr.read("MinLevel",minLevel))
 
142
            {
 
143
                itrAdvanced = true;
 
144
            }
 
145
 
 
146
            unsigned int maxLevel = MAXIMUM_NUMBER_OF_LEVELS;
 
147
            if (fr.read("MaxLevel",maxLevel))
 
148
            {
 
149
                itrAdvanced = true;
 
150
            }
 
151
 
 
152
            if (fr.matchSequence("ProxyLayer %s") || fr.matchSequence("ProxyLayer %w") )
 
153
            {
 
154
                osgTerrain::ProxyLayer* proxyLayer = new osgTerrain::ProxyLayer;
 
155
                proxyLayer->setFileName(fr[1].getStr());
 
156
 
 
157
                if (locator) proxyLayer->setLocator(locator);
 
158
                if (minLevel!=0) proxyLayer->setMinLevel(minLevel);
 
159
                if (maxLevel!=MAXIMUM_NUMBER_OF_LEVELS) proxyLayer->setMaxLevel(maxLevel);
 
160
 
 
161
                terrainTile.setElevationLayer(proxyLayer);
 
162
            
 
163
                fr += 2;
 
164
 
 
165
                localAdvanced = true;
 
166
            }
 
167
            else
 
168
            {
 
169
                osg::ref_ptr<osg::Object> readObject = fr.readObjectOfType(osgDB::type_wrapper<osgTerrain::Layer>());
 
170
                osgTerrain::Layer* readLayer = dynamic_cast<osgTerrain::Layer*>(readObject.get());
 
171
                if (readLayer)
 
172
                {
 
173
                    if (locator) readLayer->setLocator(locator);
 
174
                    if (minLevel!=0) readLayer->setMinLevel(minLevel);
 
175
                    if (maxLevel!=MAXIMUM_NUMBER_OF_LEVELS) readLayer->setMaxLevel(maxLevel);
 
176
 
 
177
                    terrainTile.setElevationLayer(readLayer);
 
178
                }
 
179
 
 
180
                if (readObject.valid()) localAdvanced = true;
 
181
            }
 
182
 
 
183
            if (!localAdvanced) ++fr;
 
184
        }
 
185
 
 
186
        itrAdvanced = true;
 
187
    }
 
188
 
 
189
    bool firstMatched = false;
 
190
    if ((firstMatched = fr.matchSequence("ColorLayer %i {")) || fr.matchSequence("ColorLayer {") )
 
191
    {
 
192
        unsigned int layerNum = 0;
 
193
        if (firstMatched)
 
194
        {
 
195
            fr[1].getUInt(layerNum);        
 
196
            ++fr;
 
197
        }
 
198
 
 
199
        int entry = fr[0].getNoNestedBrackets();
 
200
        fr += 2;
 
201
 
 
202
        while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
 
203
        {
 
204
            bool localAdvanced = false;
 
205
 
 
206
            osg::ref_ptr<osg::Object> readObject = fr.readObjectOfType(osgDB::type_wrapper<osgTerrain::Locator>());
 
207
            osgTerrain::Locator* locator = dynamic_cast<osgTerrain::Locator*>(readObject.get());
 
208
            if (readObject.valid()) localAdvanced = true;
 
209
 
 
210
            unsigned int minLevel=0;
 
211
            if (fr.read("MinLevel",minLevel))
 
212
            {
 
213
                itrAdvanced = true;
 
214
            }
 
215
 
 
216
            unsigned int maxLevel = MAXIMUM_NUMBER_OF_LEVELS;
 
217
            if (fr.read("MaxLevel",maxLevel))
 
218
            {
 
219
                itrAdvanced = true;
 
220
            }
 
221
 
 
222
            if (fr.matchSequence("ProxyFile %s") || fr.matchSequence("ProxyFile %w") )
 
223
            {
 
224
                osg::ref_ptr<osg::Object> image = osgDB::readObjectFile(std::string(fr[1].getStr())+".gdal");
 
225
                osgTerrain::ProxyLayer* proxyLayer = dynamic_cast<osgTerrain::ProxyLayer*>(image.get());
 
226
                if (proxyLayer)
 
227
                {
 
228
                    if (locator) proxyLayer->setLocator(locator);
 
229
                    if (minLevel!=0) proxyLayer->setMinLevel(minLevel);
 
230
                    if (maxLevel!=MAXIMUM_NUMBER_OF_LEVELS) proxyLayer->setMaxLevel(maxLevel);
 
231
 
 
232
                    terrainTile.setColorLayer(layerNum, proxyLayer);
 
233
                }                
 
234
            
 
235
                fr += 2;
 
236
 
 
237
                localAdvanced = true;
 
238
            }
 
239
            else
 
240
            {
 
241
                osg::ref_ptr<osg::Object> readObject = fr.readObjectOfType(osgDB::type_wrapper<osgTerrain::Layer>());
 
242
                osgTerrain::Layer* readLayer = dynamic_cast<osgTerrain::Layer*>(readObject.get());
 
243
                if (readLayer)
 
244
                {
 
245
                    if (locator) readLayer->setLocator(locator);
 
246
                    if (minLevel!=0) readLayer->setMinLevel(minLevel);
 
247
                    if (maxLevel!=MAXIMUM_NUMBER_OF_LEVELS) readLayer->setMaxLevel(maxLevel);
 
248
 
 
249
                    terrainTile.setColorLayer(layerNum, readLayer);
 
250
                }
 
251
 
 
252
                if (readObject.valid()) localAdvanced = true;
 
253
            }
 
254
 
 
255
            if (!localAdvanced) ++fr;
 
256
        }
 
257
 
 
258
        itrAdvanced = true;
 
259
    }
 
260
 
 
261
 
 
262
    readObject = fr.readObjectOfType(osgDB::type_wrapper<osgTerrain::TerrainTechnique>());
 
263
    if (readObject.valid())
 
264
    {
 
265
        terrainTile.setTerrainTechnique(dynamic_cast<osgTerrain::TerrainTechnique*>(readObject.get()));
 
266
        itrAdvanced = true;
 
267
    }
 
268
 
 
269
 
 
270
    return itrAdvanced;
 
271
}
 
272
 
 
273
bool TerrainTile_writeLocalData(const osg::Object& obj, osgDB::Output& fw)
 
274
{
 
275
    const osgTerrain::TerrainTile& terrainTile = static_cast<const osgTerrain::TerrainTile&>(obj);
 
276
 
 
277
    int prec = fw.precision();
 
278
    fw.precision(15);
 
279
 
 
280
    if (terrainTile.getLocator())
 
281
    {
 
282
        fw.writeObject(*terrainTile.getLocator());
 
283
    }
 
284
 
 
285
    if (terrainTile.getElevationLayer())
 
286
    {
 
287
        fw.indent()<<"ElevationLayer {"<<std::endl;
 
288
 
 
289
        fw.moveIn();
 
290
        
 
291
        const osgTerrain::ProxyLayer* proxyLayer = dynamic_cast<const osgTerrain::ProxyLayer*>(terrainTile.getElevationLayer());
 
292
        if (proxyLayer)
 
293
        {
 
294
            if (!proxyLayer->getFileName().empty())
 
295
            {
 
296
                const osgTerrain::Locator* locator = proxyLayer->getLocator();
 
297
                if (locator && !locator->getDefinedInFile())
 
298
                {
 
299
                    fw.writeObject(*locator);
 
300
                }
 
301
 
 
302
                if (proxyLayer->getMinLevel()!=0)
 
303
                {
 
304
                    fw.indent()<<"MinLevel "<<proxyLayer->getMinLevel()<<std::endl;
 
305
                } 
 
306
 
 
307
                if (proxyLayer->getMaxLevel()!=MAXIMUM_NUMBER_OF_LEVELS)
 
308
                {
 
309
                    fw.indent()<<"MaxLevel "<<proxyLayer->getMaxLevel()<<std::endl;
 
310
                } 
 
311
 
 
312
                fw.indent()<<"ProxyLayer "<<proxyLayer->getFileName()<<std::endl;
 
313
            }
 
314
        }
 
315
        else if (terrainTile.getElevationLayer())
 
316
        {
 
317
            fw.writeObject(*terrainTile.getElevationLayer());
 
318
        }
 
319
 
 
320
        fw.moveOut();
 
321
 
 
322
        fw.indent()<<"}"<<std::endl;
 
323
    }
 
324
 
 
325
    for(unsigned int i=0; i<terrainTile.getNumColorLayers(); ++i)
 
326
    {
 
327
        const osgTerrain::Layer* layer = terrainTile.getColorLayer(i);
 
328
        if (layer)
 
329
        {
 
330
            if (i>0)
 
331
            {
 
332
                fw.indent()<<"ColorLayer "<<i<<" {"<<std::endl;
 
333
            }
 
334
            else
 
335
            {
 
336
                fw.indent()<<"ColorLayer {"<<std::endl;
 
337
            }
 
338
 
 
339
            fw.moveIn();
 
340
            
 
341
            const osgTerrain::ProxyLayer* proxyLayer = dynamic_cast<const osgTerrain::ProxyLayer*>(layer);
 
342
            if (proxyLayer)
 
343
            {
 
344
                const osgTerrain::Locator* locator = proxyLayer->getLocator();
 
345
                if (locator && !locator->getDefinedInFile())
 
346
                {
 
347
                    fw.writeObject(*locator);
 
348
                }
 
349
 
 
350
                if (proxyLayer->getMinLevel()!=0)
 
351
                {
 
352
                    fw.indent()<<"MinLevel "<<proxyLayer->getMinLevel()<<std::endl;
 
353
                } 
 
354
 
 
355
                if (proxyLayer->getMaxLevel()!=MAXIMUM_NUMBER_OF_LEVELS)
 
356
                {
 
357
                    fw.indent()<<"MaxLevel "<<proxyLayer->getMaxLevel()<<std::endl;
 
358
                } 
 
359
 
 
360
                if (!proxyLayer->getFileName().empty()) fw.indent()<<"ProxyLayer "<<proxyLayer->getFileName()<<std::endl;
 
361
            }
 
362
            else if (layer)
 
363
            {
 
364
                fw.writeObject(*terrainTile.getColorLayer(i));
 
365
            }
 
366
 
 
367
            fw.moveOut();
 
368
 
 
369
            fw.indent()<<"}"<<std::endl;
 
370
        }
 
371
    }
 
372
 
 
373
    if (terrainTile.getTerrainTechnique())
 
374
    {
 
375
        fw.writeObject(*terrainTile.getTerrainTechnique());
 
376
    }    
 
377
 
 
378
    fw.precision(prec);
 
379
    
 
380
    return true;
 
381
}