root/OpenSceneGraph/trunk/src/osgPlugins/vrml/ReaderWriterVRML2.cpp @ 13041

Revision 13041, 24.8 kB (checked in by robert, 2 years ago)

Ran script to remove trailing spaces and tabs

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1// -*-c++-*-
2
3/*
4 *
5 * VRML2 file converter for OpenSceneGraph.
6 *
7 * authors :
8 *           Johan Nouvel (johan_nouvel@yahoo.com) for the writeNode function.
9 *
10 *           Jan Ciger (jan.ciger@gmail.com),
11 *           Tolga Abaci (tolga.abaci@gmail.com),
12 *           Bruno Herbelin (bruno.herbelin@gmail.com)
13 *
14 *           (c) VRlab EPFL, Switzerland, 2004-2006
15 *
16 *           Gino van den Bergen, DTECTA (gino@dtecta.com)
17 *           Xiangxian Wang (xiangxianwang@yahoo.com.cn)
18 *
19 */
20
21#include "ReaderWriterVRML2.h"
22#include "ConvertToVRML.h"
23
24#include <iostream>
25#include <fstream>
26
27#include <boost/algorithm/string/predicate.hpp>
28#include <boost/utility.hpp>
29
30#if defined(_MSC_VER)
31#   pragma warning(disable: 4250)
32#   pragma warning(disable: 4290)
33#   pragma warning(disable: 4800)
34#endif
35
36#include <openvrml/browser.h>
37#include <openvrml/node.h>
38
39#include <osg/TexEnv>
40#include <osg/CullFace>
41
42#include <osg/Geode>
43#include <osg/Geometry>
44#include <osg/Material>
45#include <osg/Image>
46#include <osg/Texture2D>
47#include <osg/Group>
48#include <osg/MatrixTransform>
49#include <osg/Light>
50#include <osg/LightSource>
51#include <osg/Depth>
52
53#include <osg/Notify>
54#include <osgDB/Registry>
55#include <osgDB/ReadFile>
56#include <osgDB/FileNameUtils>
57#include <osgDB/FileUtils>
58
59#include <assert.h>
60#include <map>
61
62// -------------------------------------------------------------------------------------
63// OpenVRML helper class
64// -------------------------------------------------------------------------------------
65class resource_fetcher: public openvrml::resource_fetcher
66{
67    private:
68        virtual std::auto_ptr<openvrml::resource_istream> do_get_resource(const std::string & uri)
69        {
70            using std::auto_ptr;
71            using std::invalid_argument;
72            using std::string;
73            using openvrml::resource_istream;
74
75            class file_resource_istream: public resource_istream
76            {
77                    std::string url_;
78                    std::filebuf buf_;
79
80                public:
81                    explicit file_resource_istream(const std::string & path) :
82                        resource_istream(&this->buf_)
83                    {
84                        //
85                        // Note that the failbit is set in the constructor if no data
86                        // can be read from the stream.  This is important.  If the
87                        // failbit is not set on such a stream, OpenVRML will attempt
88                        // to read data from a stream that cannot provide it.
89                        //
90                        if (!this->buf_.open(path.c_str(), ios_base::in | ios_base::binary))
91                        {
92                            this->setstate(ios_base::badbit);
93                        }
94                    }
95
96                    void url(const std::string & str) throw (std::bad_alloc)
97                    {
98                        this->url_ = str;
99                    }
100
101                private:
102                    virtual const std::string do_url() const throw ()
103                    {
104                        return this->url_;
105                    }
106
107                    virtual const std::string do_type() const throw ()
108                    {
109                        //
110                        // A real application should use OS facilities for this;
111                        // however, that is beyond the scope of this example (which
112                        // is intended to be portable and stupid).
113                        //
114                        using std::find;
115                        using std::string;
116                        using boost::algorithm::iequals;
117                        string media_type = "application/octet-stream";
118
119                        const string::const_reverse_iterator dot_pos = find(this->url_.rbegin(), this->url_.rend(), '.');
120                        if (dot_pos == this->url_.rend() || boost::next(dot_pos.base()) == this->url_.end())
121                        {
122                            return media_type;
123                        }
124
125                        const string::const_iterator hash_pos = find(boost::next(dot_pos.base()), this->url_.end(), '#');
126                        const string ext(dot_pos.base(), hash_pos);
127
128                        if (iequals(ext, "wrl") || iequals(ext, "vrml"))
129                        {
130                            media_type = "model/vrml";
131                        }
132                        else if (iequals(ext, "png"))
133                        {
134                            media_type = "image/png";
135                        }
136                        else if (iequals(ext, "jpg") || iequals(ext, "jpeg"))
137                        {
138                            media_type = "image/jpeg";
139                        }
140                        return media_type;
141                    }
142
143                    virtual bool do_data_available() const throw ()
144                    {
145                        return !!(*this);
146                    }
147            };
148
149            const string scheme = uri.substr(0, uri.find_first_of(':'));
150            if (scheme != "file")
151            {
152                throw invalid_argument('\"' + scheme + "\" URI scheme not "
153                    "supported");
154            }
155            //
156            // file://
157            //        ^
158            // 01234567
159            //
160            string path = uri.substr(uri.find_first_of('/', 7));
161
162            auto_ptr<resource_istream> in(new file_resource_istream(path));
163            static_cast<file_resource_istream *> (in.get())->url(uri);
164
165            return in;
166        }
167};
168
169// -------------------------------------------------------------------------------------
170
171
172// Register with Registry to instantiate the above reader/writer.
173REGISTER_OSGPLUGIN(vrml, ReaderWriterVRML2)
174
175osgDB::ReaderWriter::ReadResult ReaderWriterVRML2::readNode(const std::string& fname, const osgDB::Options* opt) const
176{
177    std::string fileName = osgDB::findDataFile(fname, opt);
178    if (fileName.empty())
179        return ReadResult::FILE_NOT_FOUND;
180
181    std::fstream null;
182    resource_fetcher fetcher;
183    openvrml::browser *b = new openvrml::browser(fetcher, null, null);
184
185    osgDB::ifstream vrml_stream(fileName.c_str());
186    if (!vrml_stream.is_open())
187    {
188        OSG_INFO << "ReaderWriterVRML2: Could not open \"" << fileName << "\"" << std::endl;
189        return ReadResult::FILE_NOT_FOUND;
190    }
191
192    try
193    {
194        const std::vector< boost::intrusive_ptr< openvrml::node > > & mfn = b->create_vrml_from_stream(vrml_stream);
195
196        if(mfn.empty())
197        {
198            OSG_INFO << "ReaderWriterVRML2: OpenVRML library did not return any vrml nodes." << std::endl;
199            return ReadResult::FILE_NOT_HANDLED;
200        }
201        else
202        {
203            osg::ref_ptr<osg::MatrixTransform> osg_root = new osg::MatrixTransform(osg::Matrix( 1, 0, 0, 0,
204                                                                                                0, 0, 1, 0,
205                                                                                                0, -1, 0, 0,
206                                                                                                0, 0, 0, 1));
207
208            osgDB::getDataFilePathList().push_front(osgDB::getFilePath(fileName));
209            for (unsigned i = 0; i < mfn.size(); i++)
210            {
211                openvrml::node *vrml_node = mfn[i].get();
212                osg_root->addChild(convertFromVRML(vrml_node));
213            }
214            osgDB::getDataFilePathList().pop_front();
215            return osg_root.get();
216        }
217    }
218
219    catch (const openvrml::invalid_vrml& e)
220    {
221        OSG_INFO << "ReaderWriterVRML2: Invalid VRML in line " << e.line << " at column " << e.column << ": \"" << e.what() << "\"" << std::endl;
222        return ReadResult::FILE_NOT_HANDLED;
223    }
224    catch (const std::invalid_argument& e)
225    {
226        OSG_INFO << "ReaderWriterVRML2: Invalid argument: \"" << e.what() << "\"" << std::endl;
227        return ReadResult::FILE_NOT_HANDLED;
228    }
229}
230
231osgDB::ReaderWriter::WriteResult ReaderWriterVRML2::writeNode(const osg::Node& root,const std::string& filename, const osgDB::ReaderWriter::Options *options) const
232{
233  std::string ext = osgDB::getLowerCaseFileExtension(filename);
234  if (!acceptsExtension(ext)) return WriteResult::FILE_NOT_HANDLED;
235
236
237  osg::notify(osg::INFO) << "osgDB::ReaderWriterVRML::writeNode() Writing file "
238                         << filename << std::endl;
239
240  return(convertToVRML(root,filename,options));
241}
242
243
244
245
246osg::Node* ReaderWriterVRML2::convertFromVRML(openvrml::node *obj) const
247{
248    //static int osgLightNum = 0; //light
249
250    if (obj->type().id() == "Group") // Group node
251
252    {
253        openvrml::grouping_node *vrml_group;
254        vrml_group = dynamic_cast<openvrml::grouping_node *>(obj);
255
256        osg::ref_ptr<osg::Group> osg_group = new osg::Group;
257
258        try
259        {
260            std::auto_ptr<openvrml::field_value> fv = obj->field("children");
261
262            if ( fv->type() == openvrml::field_value::mfnode_id )
263            {
264                const openvrml::mfnode* mfn = dynamic_cast<const openvrml::mfnode *>(fv.get());
265                openvrml::mfnode::value_type node_ptr_vector = mfn->value();
266                openvrml::mfnode::value_type::iterator it_npv;
267
268                for (it_npv = node_ptr_vector.begin(); it_npv != node_ptr_vector.end(); it_npv++)
269                {
270                    openvrml::node *node = (*(it_npv)).get();
271                    osg_group->addChild(convertFromVRML(node));
272                }
273            }
274        }
275        catch (openvrml::unsupported_interface&)
276        {
277            // no children
278        }
279
280        return osg_group.release();
281
282    }
283
284    else if (obj->type().id() == "Transform") // Handle transforms
285
286    {
287        openvrml::transform_node *vrml_transform;
288        vrml_transform = dynamic_cast<openvrml::transform_node *>(obj);
289
290        openvrml::mat4f vrml_m = vrml_transform->transform();
291        osg::ref_ptr<osg::MatrixTransform> osg_m = new osg::MatrixTransform(osg::Matrix(vrml_m[0][0], vrml_m[0][1], vrml_m[0][2], vrml_m[0][3], vrml_m[1][0], vrml_m[1][1], vrml_m[1][2], vrml_m[1][3], vrml_m[2][0], vrml_m[2][1], vrml_m[2][2], vrml_m[2][3], vrml_m[3][0], vrml_m[3][1], vrml_m[3][2], vrml_m[3][3]));
292
293        try
294        {
295            std::auto_ptr<openvrml::field_value> fv = obj->field("children");
296
297            if ( fv->type() == openvrml::field_value::mfnode_id )
298            {
299                const openvrml::mfnode* mfn = dynamic_cast<const openvrml::mfnode *>(fv.get());
300                openvrml::mfnode::value_type node_ptr_vector = mfn->value();
301                openvrml::mfnode::value_type::iterator it_npv;
302
303                for (it_npv = node_ptr_vector.begin(); it_npv != node_ptr_vector.end(); it_npv++)
304                {
305                    openvrml::node *node = (*(it_npv)).get();
306                    osg_m->addChild(convertFromVRML(node));
307                }
308            }
309        }
310        catch (openvrml::unsupported_interface&)
311        {
312            // no children
313        }
314
315        return osg_m.release();
316
317    }
318
319    else if ((obj->type()).id() == "Shape") // Handle Shape node
320
321    {
322        osg::ref_ptr<osg::Geometry> osg_geom;
323
324        // parse the geometry
325        {
326            std::auto_ptr<openvrml::field_value> fv = obj->field("geometry");
327
328            if (fv->type() == openvrml::field_value::sfnode_id)
329            {
330                const openvrml::sfnode * sfn = dynamic_cast<const openvrml::sfnode *>(fv.get());
331                openvrml::sfnode::value_type node_ptr = sfn->value();
332
333                if (node_ptr.get()) {
334                    // is it indexed_face_set_node ?
335                    if (node_ptr->type().id()=="IndexedFaceSet")
336                        osg_geom = convertVRML97IndexedFaceSet(node_ptr.get());
337
338                    else if (node_ptr->type().id()=="IndexedLineSet")
339                        osg_geom = convertVRML97IndexedLineSet(node_ptr.get());
340
341                    else if (node_ptr->type().id() == "Box")
342                        osg_geom = convertVRML97Box(node_ptr.get());
343
344                    else if (node_ptr->type().id() == "Sphere")
345                        osg_geom = convertVRML97Sphere(node_ptr.get());
346
347                    else if (node_ptr->type().id() == "Cone")
348                        osg_geom = convertVRML97Cone(node_ptr.get());
349
350                    else if (node_ptr->type().id() == "Cylinder")
351                        osg_geom = convertVRML97Cylinder(node_ptr.get());
352
353                    else
354                    {
355                        // other geometry types not handled yet
356                    }
357                }
358            }
359        }
360
361        osg::ref_ptr<osg::Geode> osg_geode = new osg::Geode();
362        osg_geode->addDrawable(osg_geom.get());
363        osg::StateSet *osg_stateset = osg_geode->getOrCreateStateSet();
364
365        osg::ref_ptr<osg::Material> osg_mat = new osg::Material();
366        osg_stateset->setAttributeAndModes(osg_mat.get());
367        osg_mat->setColorMode(osg::Material::AMBIENT_AND_DIFFUSE);
368
369        // parse the appearance
370        {
371            std::auto_ptr<openvrml::field_value> fv = obj->field("appearance");
372
373            if (fv->type() == openvrml::field_value::sfnode_id)
374            {
375                const openvrml::sfnode *sfn = dynamic_cast<const openvrml::sfnode *>(fv.get());
376                openvrml::appearance_node *vrml_app = dynamic_cast<openvrml::appearance_node *>(sfn->value().get());
377
378                const boost::intrusive_ptr<openvrml::node> vrml_material_node = vrml_app->material();
379                const boost::intrusive_ptr<openvrml::texture_node> vrml_texture_node = openvrml::node_cast<openvrml::texture_node*>(vrml_app->texture().get());
380                const openvrml::material_node *vrml_material = dynamic_cast<const openvrml::material_node *>(vrml_material_node.get());
381
382                if (vrml_material != NULL)
383                {
384                    osg_mat->setAmbient(osg::Material::FRONT_AND_BACK,
385                                    osg::Vec4(vrml_material->ambient_intensity(),
386                                                    vrml_material->ambient_intensity(),
387                                                    vrml_material->ambient_intensity(),
388                                                    1.0));
389                    osg_mat->setDiffuse(osg::Material::FRONT_AND_BACK,
390                                    osg::Vec4(vrml_material->diffuse_color().r(),
391                                                    vrml_material->diffuse_color().g(),
392                                                    vrml_material->diffuse_color().b(),
393                                                    1.0));
394                    osg_mat->setEmission(osg::Material::FRONT_AND_BACK,
395                                    osg::Vec4(vrml_material->emissive_color().r(),
396                                                    vrml_material->emissive_color().g(),
397                                                    vrml_material->emissive_color().b(),
398                                                    1.0));
399                    osg_mat->setSpecular(osg::Material::FRONT_AND_BACK,
400                                    osg::Vec4(vrml_material->specular_color().r(),
401                                                    vrml_material->specular_color().g(),
402                                                    vrml_material->specular_color().b(),
403                                                    1.0));
404
405                    osg_mat->setShininess(osg::Material::FRONT_AND_BACK, vrml_material->shininess() );
406
407                    if (vrml_material->transparency() > 0.0f)
408                    {
409                        osg_mat->setTransparency(osg::Material::FRONT_AND_BACK, vrml_material->transparency());
410                        osg_stateset->setMode(GL_BLEND, osg::StateAttribute::ON);
411                        osg_stateset->setAttribute(new osg::Depth(osg::Depth::LESS, 0.0, 1.0, false)); // GvdB: transparent objects do not write depth
412                        osg_stateset->setRenderingHint(osg::StateSet::TRANSPARENT_BIN);
413                    }
414                    else
415                    {
416                        osg_stateset->setMode(GL_BLEND, osg::StateAttribute::OFF);
417                        osg_stateset->setRenderingHint(osg::StateSet::OPAQUE_BIN);
418                    }
419
420                    osg_stateset->setAttributeAndModes(osg_mat.get());
421
422                }
423
424                // if texture is provided
425                if (vrml_texture_node != 0)
426                {
427                    osg::ref_ptr<osg::Image> image;
428
429                    if (vrml_texture_node->type().id() == "ImageTexture")
430                    {
431                        try
432                        {
433                            std::auto_ptr<openvrml::field_value> texture_url_fv = vrml_texture_node->field("url");
434                            const openvrml::mfstring *mfs = dynamic_cast<const openvrml::mfstring *>(texture_url_fv.get());
435                            const std::string &url = mfs->value()[0];
436
437                            image = osgDB::readRefImageFile(url);
438
439                            if (!image.valid())
440                            {
441                                std::cerr << "texture file " << url << " not found !" << std::endl << std::flush;
442                            }
443                        }
444                        catch (openvrml::unsupported_interface&)
445                        {
446                            // no url field in the texture
447                        }
448                    }
449
450                    if (!image.valid())
451                    {
452                        // If we cannot read the image try the openvrml builtin mechanisms to read the image.
453                        // This includes PixelTexture fields.
454                        const openvrml::image& vrml_image = vrml_texture_node->image();
455
456                        // Convert to an osg image
457                        image = new osg::Image;
458                        image->allocateImage(vrml_image.x(), vrml_image.y(), 1, GL_RGBA, GL_UNSIGNED_BYTE);
459                        for (std::size_t y = 0; y < vrml_image.y(); ++y)
460                        {
461                            for (std::size_t x = 0; x < vrml_image.x(); ++x)
462                            {
463                                openvrml::int32 p = vrml_image.pixel(x, y);
464                                unsigned char* data = image->data(x, y);
465                                data[0] = 0xff & (p >> 24);
466                                data[1] = 0xff & (p >> 16);
467                                data[2] = 0xff & (p >> 8);
468                                data[3] = 0xff & (p >> 0);
469                            }
470                        }
471                    }
472
473                    if (image.valid())
474                    {
475                        osg::ref_ptr<osg::Texture2D> texture = new osg::Texture2D;
476                        texture->setImage(image.get());
477
478                        // get the real texture wrapping parameters
479                        if (vrml_texture_node->repeat_s())
480                        {
481                            texture->setWrap(osg::Texture::WRAP_S, osg::Texture::REPEAT);
482                        }
483                        else
484                        {
485                            texture->setWrap(osg::Texture::WRAP_S, osg::Texture::CLAMP);
486                        }
487
488                        if (vrml_texture_node->repeat_t())
489                        {
490                            texture->setWrap(osg::Texture::WRAP_T, osg::Texture::REPEAT);
491                        }
492                        else
493                        {
494                            texture->setWrap(osg::Texture::WRAP_T, osg::Texture::CLAMP);
495                        }
496                        texture->setWrap(osg::Texture::WRAP_R, osg::Texture::REPEAT);
497
498                        osg_stateset->setTextureAttributeAndModes(0, texture.get());
499
500                        if (image->isImageTranslucent()) {
501                            osg_stateset->setMode(GL_BLEND, osg::StateAttribute::ON);
502                            osg_stateset->setRenderingHint(osg::StateSet::TRANSPARENT_BIN);
503                        }
504                    }
505                }
506            }
507        }
508
509        return osg_geode.release();
510    }
511    else
512    {
513        return 0;
514    }
515#if 0
516    /*
517     } else if(obj->type.id == "DirectionalLight")    // Handle lights
518     {
519     osg::Group* lightGroup = new osg::Group;
520
521     openvrml::vrml97_node::directional_light_node *vrml_light;
522     vrml_light = dynamic_cast<openvrml::vrml97_node::directional_light_node *>(obj);
523
524     // create light with global params
525     osg::Light* myLight = new osg::Light;
526     myLight->setLightNum(osgLightNum);
527     myLight->setAmbient(osg::Vec4(vrml_light->ambient_intensity(),vrml_light->ambient_intensity(),vrml_light->ambient_intensity(),vrml_light->ambient_intensity()));
528     float osgR = vrml_light->color().r()*vrml_light->intensity();
529     float osgG = vrml_light->color().g()*vrml_light->intensity();
530     float osgB = vrml_light->color().b()*vrml_light->intensity();
531     myLight->setDiffuse(osg::Vec4(osgR, osgG, osgB, 1.0f));
532     myLight->setSpecular(osg::Vec4(osgR, osgG, osgB, 1.0f));
533
534     // configure light as DIRECTIONAL
535     openvrml::sfvec3f &dir = vrml_light->direction_;
536     myLight->setDirection(osg::Vec3(dir.value[0],dir.value[1],dir.value[2]));
537     myLight->setPosition(osg::Vec4(dir.value[0],dir.value[1],dir.value[2], 0.0f));
538
539     // add the light in the scenegraph
540     osg::LightSource* lightS = new osg::LightSource;
541     lightS->setLight(myLight);
542     if (vrml_light->on()) {
543     lightS->setLocalStateSetModes(osg::StateAttribute::ON);
544     //lightS->setStateSetModes(*rootStateSet,osg::StateAttribute::ON);
545     }
546
547     lightGroup->addChild(lightS);
548     osgLightNum++;
549
550     return lightGroup;
551
552     } else if(obj->type.id == "PointLight")    // Handle lights
553     {
554     osg::Group* lightGroup = new osg::Group;
555
556     openvrml::vrml97_node::point_light_node *vrml_light;
557     vrml_light = dynamic_cast<openvrml::vrml97_node::point_light_node *>(obj);
558
559     // create light with global params
560     osg::Light* myLight = new osg::Light;
561     myLight->setLightNum(osgLightNum);
562     //std::cout<<"lightnum = "<<osgLightNum;
563
564     openvrml::sfvec3f &pos = vrml_light->location_;
565     myLight->setPosition(osg::Vec4(pos.value[0], pos.value[1], pos.value[2], 1.0f));
566
567     myLight->setAmbient(osg::Vec4(vrml_light->ambient_intensity(),vrml_light->ambient_intensity(),vrml_light->ambient_intensity(),vrml_light->ambient_intensity()));
568     float osgR = vrml_light->color().r()*vrml_light->intensity();
569     float osgG = vrml_light->color().g()*vrml_light->intensity();
570     float osgB = vrml_light->color().b()*vrml_light->intensity();
571     myLight->setDiffuse(osg::Vec4(osgR, osgG, osgB, 1.0f));
572     myLight->setSpecular(osg::Vec4(osgR, osgG, osgB, 1.0f));
573
574     // configure light as POINT
575     myLight->setDirection(osg::Vec3(0.f,0.f,0.f));
576
577     // add the light in the scenegraph
578     osg::LightSource* lightS = new osg::LightSource;
579     lightS->setLight(myLight);
580     if (vrml_light->on()) {
581     lightS->setLocalStateSetModes(osg::StateAttribute::ON);
582     //lightS->setStateSetModes(*rootStateSet,osg::StateAttribute::ON);
583     }
584
585     lightGroup->addChild(lightS);
586     osgLightNum++;
587
588     return lightGroup;
589
590     } else if(obj->type.id == "SpotLight")    // Handle lights
591     {
592     osg::Group* lightGroup = new osg::Group;
593
594     openvrml::vrml97_node::spot_light_node *vrml_light;
595     vrml_light = dynamic_cast<openvrml::vrml97_node::spot_light_node *>(obj);
596
597     // create light with global params
598     osg::Light* myLight = new osg::Light;
599     myLight->setLightNum(osgLightNum);
600     myLight->setPosition(osg::Vec4(0.0f, 0.0f, 0.0f, 1.0f));
601     myLight->setAmbient(osg::Vec4(vrml_light->ambient_intensity(),vrml_light->ambient_intensity(),vrml_light->ambient_intensity(),vrml_light->ambient_intensity()));
602     float osgR = vrml_light->color().r()*vrml_light->intensity();
603     float osgG = vrml_light->color().g()*vrml_light->intensity();
604     float osgB = vrml_light->color().b()*vrml_light->intensity();
605     myLight->setDiffuse(osg::Vec4(osgR, osgG, osgB, 1.0f));
606     myLight->setSpecular(osg::Vec4(osgR, osgG, osgB, 1.0f));
607
608     // configure light as SPOT
609     openvrml::sfvec3f &dir = vrml_light->direction_;
610     myLight->setDirection(osg::Vec3(dir.value[0],dir.value[1],dir.value[2]));
611
612     // The cutOff value in osg ranges from 0 to 90, we need
613     // to divide by 2 to avoid openGL error.
614     //      myLight->setSpotCutoff(ls.fallsize/2.0f);
615     // The bigger the differens is between fallsize and hotsize
616     // the bigger the exponent should be.
617     //      float diff = ls.fallsize - ls.hotsize;
618     //      myLight->setSpotExponent(diff);
619
620     // add the light in the scenegraph
621     osg::LightSource* lightS = new osg::LightSource;
622     lightS->setLight(myLight);
623     if (vrml_light->on()) {
624     lightS->setLocalStateSetModes(osg::StateAttribute::ON);
625     //lightS->setStateSetModes(*rootStateSet,osg::StateAttribute::ON);
626     }
627
628     lightGroup->addChild(lightS);
629     osgLightNum++;
630
631     return lightGroup;
632
633     }  else {
634
635     return NULL;
636     }
637     */
638
639#endif
640
641    return 0;
642}
Note: See TracBrowser for help on using the browser.