Source/System/NodeCores/Drawables/Geometry/Util/OSGSimpleLightGeometry.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *             Copyright (C) 2000-2002 by the OpenSG Forum                   *
   6  *                                                                           *
   7  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
   8  *                                                                           *
   9 \*---------------------------------------------------------------------------*/
  10 /*---------------------------------------------------------------------------*\
  11  *                                License                                    *
  12  *                                                                           *
  13  * This library is free software; you can redistribute it and/or modify it   *
  14  * under the terms of the GNU Library General Public License as published    *
  15  * by the Free Software Foundation, version 2.                               *
  16  *                                                                           *
  17  * This library is distributed in the hope that it will be useful, but       *
  18  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  20  * Library General Public License for more details.                          *
  21  *                                                                           *
  22  * You should have received a copy of the GNU Library General Public         *
  23  * License along with this library; if not, write to the Free Software       *
  24  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
  25  *                                                                           *
  26 \*---------------------------------------------------------------------------*/
  27 /*---------------------------------------------------------------------------*\
  28  *                                Changes                                    *
  29  *                                                                           *
  30  *                                                                           *
  31  *                                                                           *
  32  *                                                                           *
  33  *                                                                           *
  34  *                                                                           *
  35 \*---------------------------------------------------------------------------*/
  36
  37 #ifdef WIN32
  38 #pragma warning( disable : 4305 )
  39 #endif
  40
  41 //---------------------------------------------------------------------------
  42 //  Includes
  43 //---------------------------------------------------------------------------
  44
  45 #include <cstdlib>
  46 #include <cstdio>
  47
  48 #include "OSGConfig.h"
  49 #include "OSGLog.h"
  50 #include "OSGFrustumVolume.h"
  51 #include "OSGQuaternion.h"
  52 #include "OSGMaterial.h"
  53 #include "OSGSimpleMaterial.h"
  54 #include "OSGLineChunk.h"
  55 #include "OSGGeoProperties.h"
  56 #include "OSGSimpleLightGeometry.h"  // for DefaultMaterials
  57 #include "OSGTypedGeoIntegralProperty.h"
  58 #include "OSGTypedGeoVectorProperty.h"
  59
  60 OSG_BEGIN_NAMESPACE
  61
  62 /***************************************************************************\
  63  *                            Description                                  *
  64 \***************************************************************************/
  65
  66 #if defined(OSG_WIN32_ICL) && !defined(OSG_CHECK_FIELDSETARG)
  67 #pragma warning (disable : 383)
  68 #endif
  69
  70 // The Simple Light Geometry creation functions
  71
  72 //
  73 // Attention: the created geometry from these functions do not contain
  74 //            texture coordinates.
  75 //
  76
  77 /*! Creates a spot light with spot direction in +y-direction with the tip
  78     of the spot at (0,0,0).
  79
  80     \param[in] R is the spot range/radius of influence
  81     \param[in] angle is the spot half angle in radians
  82     \param[in] slices is the number of subdivisions in y-Dir, i.e. in spot direction
  83     \param[in] sides is  the number of circle subdivisions
  84     \return NodeTransitPtr to a newly created Node with a Geometry core.
  85
  86     \ingroup GrpDrawablesGeometryUtils
  87  */
  88 NodeTransitPtr makeSpot(
  89     Real32 R,
  90     Real32 angle,
  91     UInt32 slices,
  92     UInt32 sides)
  93 {
  94     GeometryTransitPtr pGeo = makeSpotGeo(R, angle, slices, sides);
  95
  96     if(pGeo == NULL)
  97     {
  98         return NodeTransitPtr(NULL);
  99     }
 100
 101     NodeTransitPtr node = Node::create();
 102
 103     node->setCore(pGeo);
 104
 105     return node;
 106 }
 107
 108 /*! Creates a spot light geometry with spot direction in +y-direction with the tip
 109     of the spot at (0,0,0).
 110
 111     \param[in] R is the spot range/radius of influence
 112     \param[in] angle is the spot half angle in radians
 113     \param[in] slices is the number of subdivisions in y-Dir, i.e. in spot direction
 114     \param[in] sides is  the number of circle subdivisions
 115     \return GeometryTransitPtr to a newly created Geometry core.
 116
 117     \ingroup GrpDrawablesGeometryUtils
 118  */
 119 GeometryTransitPtr makeSpotGeo(
 120     Real32 R,
 121     Real32 angle,
 122     UInt32 slices,
 123     UInt32 sides)
 124 {
 125     if(R <= 0 || angle <= 0)
 126     {
 127         SWARNING << "makeSpotGeo: illegal geometric parameters R=" << R
 128                  << ", angle=" << angle
 129                  << std::endl;
 130         return GeometryTransitPtr(NULL);
 131     }
 132
 133     if(! slices || ! sides)
 134     {
 135         SWARNING << "makeSpotGeo: illegal subdivision parameters slices=" << slices << ", sides="
 136                  << sides << std::endl;
 137         return GeometryTransitPtr(NULL);
 138     }
 139
 140     GeoUInt8PropertyRefPtr   types = GeoUInt8Property::create();
 141     GeoUInt32PropertyRefPtr  lens  = GeoUInt32Property::create();
 142     GeoPnt3fPropertyRefPtr   pnts  = GeoPnt3fProperty::create();
 143     GeoVec3fPropertyRefPtr   norms = GeoVec3fProperty::create();
 144
 145     GeoUInt8Property::StoredFieldType  *t  = types->editFieldPtr();
 146     GeoUInt32Property::StoredFieldType *l  = lens ->editFieldPtr();
 147     GeoPnt3fProperty::StoredFieldType  *p  = pnts ->editFieldPtr();
 148     GeoVec3fProperty::StoredFieldType  *n  = norms->editFieldPtr();
 149
 150     // get even slices and sides
 151     if ( (slices & 1) == 1 )
 152         slices += 1;
 153
 154     if ( (sides & 1) == 1 )
 155         sides += 1;
 156
 157     Real32 a_cone = angle;
 158     Real32 h_cone = R * osgCos(a_cone);
 159     Real32 d_cone = h_cone / slices;
 160
 161     Real32 delta_phi = 2.f * Pi / (sides-1);
 162
 163     Vec3f ey(0,1,0);
 164
 165     typedef std::vector<Pnt3f> VecPntsT;
 166
 167     VecPntsT vecOddPnts(sides), vecEvenPnts(sides);
 168     VecPntsT* pvecLast = &vecOddPnts;
 169     VecPntsT* pvecCurr = &vecEvenPnts;
 170
 171     //
 172     // First the cone itself
 173     //
 174     std::vector<Vec3f> vecNormals(sides);
 175     for (UInt32 i = 0; i < sides; ++i)
 176     {
 177         Real32 phi = i * delta_phi;
 178
 179         vecNormals[i] = -Vec3f(osgCos(a_cone) * osgCos(phi), osgSin(a_cone), osgCos(a_cone) * osgSin(phi));
 180     }
 181
 182     Pnt3f pT(0,0,0);       // tip of spot cone
 183
 184     (*pvecLast)[0] = pT;
 185
 186     for (UInt32 j = 1; j <= slices; ++j)
 187     {
 188         Real32 l_cone = j * d_cone;
 189         Real32 r_cone = l_cone * osgTan(a_cone);
 190
 191         Pnt3f pR = pT + l_cone * ey;
 192
 193 //        Real32 d_phi = (j & 0) ?  delta_phi : delta_phi + delta_phi/2.f;
 194
 195         Real32 phi = (j & 0) ?  0 : delta_phi/2.f;
 196
 197         for (UInt32 i = 0; i < sides-1; ++i)
 198         {
 199             phi += delta_phi;
 200             (*pvecCurr)[i] = pR + r_cone * Vec3f(osgSin(phi), 0, -osgCos(phi));
 201         }
 202
 203         (*pvecCurr)[sides-1] = (*pvecCurr)[0];
 204
 205         if (j == 1)
 206         {
 207             t->push_back(GL_TRIANGLE_FAN);
 208             l->push_back(1 + sides);
 209
 210             p->push_back((*pvecLast)[0]);
 211             n->push_back(Vec3f(0,-1,0));
 212
 213             for (UInt32 i = 0; i < sides; ++i)
 214             {
 215                 p->push_back((*pvecCurr)[i]);
 216                 n->push_back(vecNormals[i]);
 217             }
 218         }
 219         else
 220         {
 221             t->push_back(GL_TRIANGLE_STRIP);
 222             l->push_back(2*sides);
 223
 224             for (UInt32 i = 0; i < sides; ++i)
 225             {
 226                 p->push_back((*pvecLast)[i]);
 227                 p->push_back((*pvecCurr)[i]);
 228
 229                 n->push_back(vecNormals[i]);
 230                 n->push_back(vecNormals[i]);
 231             }
 232         }
 233
 234         std::swap(pvecLast, pvecCurr);
 235     }
 236
 237     //
 238     // Second the sphere cap
 239     //
 240     Real32 d_alpha = a_cone / (slices-1);
 241
 242     for (UInt32 j = 0; j < slices; ++j)
 243     {
 244         if (j < slices-1)
 245         {
 246             Real32 da_cone = a_cone - j * d_alpha;
 247
 248             Real32 l_cone = R * osgCos(da_cone);
 249             Real32 r_cone = R * osgSin(da_cone);
 250
 251             Pnt3f pj = pT + l_cone * ey;
 252
 253             Real32 phi = (j & 0) ?  0 : delta_phi/2.f;
 254
 255             for (UInt32 i = 0; i < sides-1; ++i)
 256             {
 257                 phi += delta_phi;
 258                 (*pvecCurr)[i] = pj + r_cone * Vec3f(osgSin(phi), 0, -osgCos(phi));
 259
 260                 Vec3f vN = (*pvecCurr)[i] - pT;
 261                 vN.normalize();
 262                 vecNormals[i] = vN;
 263             }
 264
 265             (*pvecCurr)[sides-1] = (*pvecCurr)[0];
 266
 267             t->push_back(GL_TRIANGLE_STRIP);
 268             l->push_back(2*sides);
 269
 270             for (UInt32 i = 0; i < sides; ++i)
 271             {
 272                 p->push_back((*pvecLast)[i]);
 273                 p->push_back((*pvecCurr)[i]);
 274
 275                 n->push_back(vecNormals[i]);
 276                 n->push_back(vecNormals[i]);
 277             }
 278         }
 279         else
 280         {
 281             t->push_back(GL_TRIANGLE_FAN);
 282             l->push_back(1 + sides);
 283
 284             p->push_back(pT + R * ey);
 285             n->push_back(Vec3f(0,-1,0));
 286
 287             for (Int32 i = sides-1; i >= 0; --i)
 288             {
 289                 p->push_back((*pvecLast)[i]);
 290                 n->push_back(vecNormals[i]);
 291             }
 292         }
 293
 294         std::swap(pvecLast, pvecCurr);
 295     }
 296
 297     GeometryTransitPtr geo = Geometry::create();
 298
 299     geo->setTypes    (types);
 300     geo->setLengths  (lens);
 301     geo->setPositions(pnts);
 302     geo->setNormals  (norms);
 303
 304     geo->setMaterial(getDefaultUnlitMaterial());
 305
 306     return geo;
 307 }
 308
 309 /*! Creates a cinema light with spot direction in +y-direction with the tip
 310     of the spot at (0,0,0).
 311
 312     \param[in] a is the superellipses width
 313     \param[in] b is the superellipses height
 314     \param[in] r is the superellipses roundness parameter
 315     \param[in] theta is the superellipses twist parameter in radians
 316     \param[in] h is the cinema light range/radius of influence, i.e. the geometry extend along the y-axis
 317     \param[in] slices is the number of subdivisions in y-Dir, i.e. in spot direction
 318     \param[in] sides is  the number of circle subdivisions
 319     \return NodeTransitPtr to a newly created Node with a Geometry core.
 320
 321     \ingroup GrpDrawablesGeometryUtils
 322  */
 323 NodeTransitPtr makeCinema(
 324     Real32 a,
 325     Real32 b,
 326     Real32 r,
 327     Real32 theta,
 328     Real32 h,
 329     UInt32 slices,
 330     UInt32 sides)
 331 {
 332     GeometryTransitPtr pGeo = makeCinemaGeo(a, b, r, theta, h, slices, sides);
 333
 334     if(pGeo == NULL)
 335     {
 336         return NodeTransitPtr(NULL);
 337     }
 338
 339     NodeTransitPtr node = Node::create();
 340
 341     node->setCore(pGeo);
 342
 343     return node;
 344 }
 345
 346 /*! Creates a cinema light geometry with spot direction in +y-direction with the tip
 347     of the spot at (0,0,0).
 348
 349     \param[in] a is the superellipses width
 350     \param[in] b is the superellipses height
 351     \param[in] r is the superellipses roundness parameter
 352     \param[in] theta is the superellipses twist parameter in radians
 353     \param[in] h is the cinema light range/radius of influence, i.e. the geometry extend along the y-axis
 354     \param[in] slices is the number of subdivisions in y-Dir, i.e. in spot direction
 355     \param[in] sides is  the number of circle subdivisions
 356     \return GeometryTransitPtr to a Geometry core.
 357
 358     \ingroup GrpDrawablesGeometryUtils
 359  */
 360 GeometryTransitPtr makeCinemaGeo(
 361     Real32 a,
 362     Real32 b,
 363     Real32 r,
 364     Real32 theta,
 365     Real32 h,
 366     UInt32 slices,
 367     UInt32 sides)
 368 {
 369     if(a <= 0 || b <= 0 || r <= 0 || h <= 0)
 370     {
 371         SWARNING << "makeCinemaGeo: illegal geometric parameters a=" << a
 372                  << ", b=" << b
 373                  << ", r=" << r
 374                  << ", h=" << h
 375                  << std::endl;
 376         return GeometryTransitPtr(NULL);
 377     }
 378
 379     if(! slices || ! sides)
 380     {
 381         SWARNING << "makeCinemaGeo: illegal subdivision parameters slices=" << slices << ", sides="
 382                  << sides << std::endl;
 383         return GeometryTransitPtr(NULL);
 384     }
 385
 386     GeoUInt8PropertyRefPtr   types = GeoUInt8Property::create();
 387     GeoUInt32PropertyRefPtr  lens  = GeoUInt32Property::create();
 388     GeoPnt3fPropertyRefPtr   pnts  = GeoPnt3fProperty::create();
 389     GeoVec3fPropertyRefPtr   norms = GeoVec3fProperty::create();
 390
 391     GeoUInt8Property::StoredFieldType  *t  = types->editFieldPtr();
 392     GeoUInt32Property::StoredFieldType *l  = lens ->editFieldPtr();
 393     GeoPnt3fProperty::StoredFieldType  *p  = pnts ->editFieldPtr();
 394     GeoVec3fProperty::StoredFieldType  *n  = norms->editFieldPtr();
 395
 396     // get even slices and sides
 397     if ( (slices & 1) == 1 )
 398         slices += 1;
 399
 400     if ( (sides & 1) == 1 )
 401         sides += 1;
 402
 403     Real32 cos_theta = osgCos(theta);
 404     Real32 sin_theta = osgSin(theta);
 405
 406     Real32 d_body = h / slices;
 407
 408     Real32 delta_phi = 2.f * Pi / (sides-1);
 409
 410     Real32 two_inv_r = 2.0/r;
 411
 412     Vec3f ey(0,1,0);
 413
 414     typedef std::vector<Pnt3f> VecPntsT;
 415
 416     VecPntsT vecOddPnts(sides), vecEvenPnts(sides);
 417     VecPntsT* pvecLast = &vecOddPnts;
 418     VecPntsT* pvecCurr = &vecEvenPnts;
 419
 420     //
 421     // First the superellipses body itself
 422     //
 423     Pnt3f pT(0,0,0);       // tip of body
 424
 425     (*pvecLast)[0] = pT;
 426
 427     for (UInt32 j = 1; j <= slices; ++j)
 428     {
 429         Real32 l_body = j * d_body;
 430
 431         Pnt3f pR = pT + l_body * ey;
 432
 433         Real32 A = l_body * a;
 434         Real32 B = l_body * b;
 435
 436         Real32 phi = 0.f;
 437
 438         for (UInt32 i = 0; i < sides-1; ++i)
 439         {
 440             Real32 c = osgCos(phi);
 441             Real32 s = osgSin(phi);
 442
 443             Real32 x = A * osgSgn(c) * osgPow(osgAbs(c), two_inv_r);
 444             Real32 z = B * osgSgn(s) * osgPow(osgAbs(s), two_inv_r);
 445
 446             Pnt3f  pP = pR + Vec3f(
 447                                        x * cos_theta - z * sin_theta,
 448                                        0,
 449                                        x * sin_theta + z * cos_theta
 450                                     );
 451
 452             Real32 L = pP.subZero().length();
 453
 454             if (L > h)
 455             {
 456                 Vec3f v = pP.subZero();
 457                 v.normalize();
 458                 v *= h;
 459                 pP = v.addToZero();
 460             }
 461
 462             (*pvecCurr)[i] = pP;
 463
 464             phi += delta_phi;
 465         }
 466
 467         (*pvecCurr)[sides-1] = (*pvecCurr)[0];
 468
 469         if (j == 1)
 470         {
 471             t->push_back(GL_TRIANGLE_FAN);
 472             l->push_back(1 + sides);
 473
 474             p->push_back((*pvecLast)[0]);
 475             n->push_back(Vec3f(0,-1,0));
 476
 477             for (UInt32 i = 0; i < sides; ++i)
 478             {
 479                 p->push_back((*pvecCurr)[i]);
 480
 481                 Vec3f v0;
 482                 Vec3f v1;
 483
 484                 if (i < sides-1)
 485                 {
 486                     v0 = (*pvecCurr)[i]   - (*pvecLast)[0];
 487                     v1 = (*pvecCurr)[i+1] - (*pvecLast)[0];
 488                 }
 489                 else if (i == sides-1)
 490                 {
 491                     v0 = (*pvecCurr)[0] - (*pvecLast)[0];
 492                     v1 = (*pvecCurr)[1] - (*pvecLast)[0];
 493                 }
 494
 495                 Vec3f v = v1.cross(v0);
 496                 v.normalize();
 497                 n->push_back(v);
 498             }
 499         }
 500         else
 501         {
 502             t->push_back(GL_TRIANGLE_STRIP);
 503             l->push_back(2*sides);
 504
 505             for (UInt32 i = 0; i < sides; ++i)
 506             {
 507                 p->push_back((*pvecLast)[i]);
 508                 p->push_back((*pvecCurr)[i]);
 509
 510                 Vec3f v0;
 511                 Vec3f v1;
 512                 Vec3f v2;
 513
 514                 if (i < sides-1)
 515                 {
 516                     v0 = (*pvecLast)[i+1] - (*pvecCurr)[i];
 517                     v1 = (*pvecLast)[i+1] - (*pvecLast)[i];
 518                     v2 = (*pvecCurr)[i+1] - (*pvecLast)[i+1];
 519                 }
 520                 else if (i == sides-1)
 521                 {
 522                     v0 = (*pvecLast)[1] - (*pvecCurr)[0];
 523                     v1 = (*pvecLast)[1] - (*pvecLast)[0];
 524                     v2 = (*pvecCurr)[1] - (*pvecLast)[1];
 525                 }
 526
 527                 Vec3f n0 = v1.cross(v0);
 528                 Vec3f n1 = v2.cross(v1);
 529
 530                 n0.normalize();
 531                 n1.normalize();
 532
 533                 n->push_back(n0);
 534                 n->push_back(n1);
 535             }
 536         }
 537
 538         std::swap(pvecLast, pvecCurr);
 539     }
 540
 541     //
 542     // Second the sphere cap
 543     //
 544     Real32 delta_a = a / (slices - 1);
 545     Real32 delta_b = b / (slices - 1);
 546
 547     Pnt3f pE = pT + h * ey;
 548
 549     for (Int32 j = slices-2; j >= 0; --j)
 550     {
 551         Real32 A = h * delta_a * j;
 552         Real32 B = h * delta_b * j;
 553
 554         Real32 phi = 0.f;
 555
 556         for (UInt32 i = 0; i < sides-1; ++i)
 557         {
 558             Real32 c = osgCos(phi);
 559             Real32 s = osgSin(phi);
 560
 561             Real32 x = A * osgSgn(c) * osgPow(osgAbs(c), two_inv_r);
 562             Real32 z = B * osgSgn(s) * osgPow(osgAbs(s), two_inv_r);
 563
 564             Pnt3f  pP = pE + Vec3f(
 565                                         x * cos_theta - z * sin_theta,
 566                                         0,
 567                                         x * sin_theta + z * cos_theta
 568                                     );
 569
 570             Real32 L = pP.subZero().length();
 571
 572             if (L > h)
 573             {
 574                 Vec3f v = pP.subZero();
 575                 v.normalize();
 576                 v *= h;
 577                 pP = v.addToZero();
 578             }
 579
 580             (*pvecCurr)[i] = pP;
 581
 582             phi += delta_phi;
 583         }
 584
 585         (*pvecCurr)[sides-1] = (*pvecCurr)[0];
 586
 587         if (j < Int32(slices-1) && j > 0)
 588         {
 589             t->push_back(GL_TRIANGLE_STRIP);
 590             l->push_back(2*sides);
 591
 592             for (UInt32 i = 0; i < sides; ++i)
 593             {
 594                 p->push_back((*pvecLast)[i]);
 595                 p->push_back((*pvecCurr)[i]);
 596
 597                 Vec3f v0;
 598                 Vec3f v1;
 599                 Vec3f v2;
 600
 601                 if (i < sides-1)
 602                 {
 603                     v0 = (*pvecLast)[i+1] - (*pvecCurr)[i];
 604                     v1 = (*pvecLast)[i+1] - (*pvecLast)[i];
 605                     v2 = (*pvecCurr)[i+1] - (*pvecLast)[i+1];
 606                 }
 607                 else if (i == sides-1)
 608                 {
 609                     v0 = (*pvecLast)[1] - (*pvecCurr)[0];
 610                     v1 = (*pvecLast)[1] - (*pvecLast)[0];
 611                     v2 = (*pvecCurr)[1] - (*pvecLast)[1];
 612                 }
 613
 614                 Vec3f n0 = v1.cross(v0);
 615                 Vec3f n1 = v2.cross(v1);
 616
 617                 n0.normalize();
 618                 n1.normalize();
 619
 620                 n->push_back(n0);
 621                 n->push_back(n1);
 622             }
 623         }
 624
 625         if (j == 1)
 626         {
 627             t->push_back(GL_TRIANGLE_FAN);
 628             l->push_back(1 + sides);
 629
 630             p->push_back(pE);
 631             n->push_back(Vec3f(0,1,0));
 632
 633             for (Int32 i = sides-1; i >= 0; --i)
 634             {
 635                 p->push_back((*pvecCurr)[i]);
 636
 637                 Vec3f v0;
 638                 Vec3f v1;
 639
 640                 if (i < Int32(sides-1))
 641                 {
 642                     v0 = (*pvecCurr)[i]   - pE;
 643                     v1 = (*pvecCurr)[i+1] - pE;
 644                 }
 645                 else if (i == Int32(sides-1))
 646                 {
 647                     v0 = (*pvecCurr)[0] - pE;
 648                     v1 = (*pvecCurr)[1] - pE;
 649                 }
 650
 651                 Vec3f v = v1.cross(v0);
 652                 v.normalize();
 653                 n->push_back(v);
 654             }
 655         }
 656
 657         std::swap(pvecLast, pvecCurr);
 658     }
 659
 660     GeometryTransitPtr geo = Geometry::create();
 661
 662     geo->setTypes    (types);
 663     geo->setLengths  (lens);
 664     geo->setPositions(pnts);
 665     geo->setNormals  (norms);
 666
 667     geo->setMaterial(getDefaultUnlitMaterial());
 668
 669     return geo;
 670 }
 671
 672 /*! Creates a frustum volume
 673
 674     \param[in] nlt is the near left  top    point of the frustum
 675     \param[in] nlb is the near left  bottom point of the frustum
 676     \param[in] nrt is the near right top    point of the frustum
 677     \param[in] nrb is the near right bottom point of the frustum
 678     \param[in] flt is the far  left  top    point of the frustum
 679     \param[in] flb is the far  left  bottom point of the frustum
 680     \param[in] frt is the far  right top    point of the frustum
 681     \param[in] frb is the far  right bottom point of the frustum
 682     \return NodeTransitPtr to a newly created Node with a Geometry core.
 683
 684     \ingroup GrpDrawablesGeometryUtils
 685  */
 686 NodeTransitPtr makeFrustumVolume(
 687     const Pnt3f& nlt, const Pnt3f& nlb,
 688     const Pnt3f& nrt, const Pnt3f& nrb,
 689     const Pnt3f& flt, const Pnt3f& flb,
 690     const Pnt3f& frt, const Pnt3f& frb)
 691 {
 692     GeometryTransitPtr pGeo = makeFrustumVolumeGeo(nlt, nlb, nrt, nrb, flt, flb, frt, frb);
 693
 694     if(pGeo == NULL)
 695     {
 696         return NodeTransitPtr(NULL);
 697     }
 698
 699     NodeTransitPtr node = Node::create();
 700
 701     node->setCore(pGeo);
 702
 703     return node;
 704 }
 705
 706 /*! Creates a frustum volume geometry
 707
 708     \param[in] nlt is the near left  top    point of the frustum
 709     \param[in] nlb is the near left  bottom point of the frustum
 710     \param[in] nrt is the near right top    point of the frustum
 711     \param[in] nrb is the near right bottom point of the frustum
 712     \param[in] flt is the far  left  top    point of the frustum
 713     \param[in] flb is the far  left  bottom point of the frustum
 714     \param[in] frt is the far  right top    point of the frustum
 715     \param[in] frb is the far  right bottom point of the frustum
 716     \return GeometryTransitPtr to a newly created Geometry core.
 717
 718     \ingroup GrpDrawablesGeometryUtils
 719  */
 720 GeometryTransitPtr makeFrustumVolumeGeo(
 721     const Pnt3f& nlt, const Pnt3f& nlb,
 722     const Pnt3f& nrt, const Pnt3f& nrb,
 723     const Pnt3f& flt, const Pnt3f& flb,
 724     const Pnt3f& frt, const Pnt3f& frb)
 725 {
 726     GeoUInt8PropertyRefPtr type = GeoUInt8Property::create();
 727     type->addValue(GL_QUADS);
 728
 729     GeoUInt32PropertyRefPtr lens = GeoUInt32Property::create();
 730     lens->addValue(6 * 4);
 731
 732     GeoPnt3fPropertyRefPtr  pnts = GeoPnt3fProperty::create();
 733     // front face
 734     pnts->addValue(nlb);
 735     pnts->addValue(nrb);
 736     pnts->addValue(nrt);
 737     pnts->addValue(nlt);
 738
 739     // back face
 740     pnts->addValue(frb);
 741     pnts->addValue(flb);
 742     pnts->addValue(flt);
 743     pnts->addValue(frt);
 744
 745     // left face
 746     pnts->addValue(flb);
 747     pnts->addValue(nlb);
 748     pnts->addValue(nlt);
 749     pnts->addValue(flt);
 750
 751     // right face
 752     pnts->addValue(nrb);
 753     pnts->addValue(frb);
 754     pnts->addValue(frt);
 755     pnts->addValue(nrt);
 756
 757     // top face
 758     pnts->addValue(nrt);
 759     pnts->addValue(frt);
 760     pnts->addValue(flt);
 761     pnts->addValue(nlt);
 762
 763     // bottom face
 764     pnts->addValue(nlb);
 765     pnts->addValue(flb);
 766     pnts->addValue(frb);
 767     pnts->addValue(nrb);
 768
 769     GeoVec3fPropertyRefPtr normals = GeoVec3fProperty::create();
 770     Vec3f v1, v2, n;
 771
 772     // front face
 773     v1 = nrb - nlb; v2 = nlt - nlb; n = v1.cross(v2); n.normalize(); for (int i = 0; i < 4; ++i) normals->addValue(n);
 774
 775     // back face
 776     v1 = flb - frb; v2 = frt - frb; n = v1.cross(v2); n.normalize(); for (int i = 0; i < 4; ++i) normals->addValue(n);
 777
 778     // left face
 779     v1 = nlb - flb; v2 = flt - flb; n = v1.cross(v2); n.normalize(); for (int i = 0; i < 4; ++i) normals->addValue(n);
 780
 781     // right face
 782     v1 = frb - nrb; v2 = nrt - nrb; n = v1.cross(v2); n.normalize(); for (int i = 0; i < 4; ++i) normals->addValue(n);
 783
 784     // top face
 785     v1 = frt - nrt; v2 = nlt - nrt; n = v1.cross(v2); n.normalize(); for (int i = 0; i < 4; ++i) normals->addValue(n);
 786
 787     // bottom face
 788     v1 = flb - nlb; v2 = nrb - nlb; n = v1.cross(v2); n.normalize(); for (int i = 0; i < 4; ++i) normals->addValue(n);
 789
 790     GeometryTransitPtr geo = Geometry::create();
 791
 792     geo->setTypes    (type);
 793     geo->setLengths  (lens);
 794     geo->setPositions(pnts);
 795     geo->setNormals  (normals);
 796
 797     geo->setMaterial(getDefaultUnlitMaterial());
 798
 799     return geo;
 800 }
 801
 802 /*! Creates a frustum volume
 803
 804     \param[in] vol is frustum volume
 805     \return NodeTransitPtr to a newly created Node with a Geometry core.
 806
 807     \ingroup GrpDrawablesGeometryUtils
 808  */
 809 NodeTransitPtr makeFrustumVolume(const FrustumVolume& vol)
 810 {
 811     GeometryTransitPtr pGeo = makeFrustumVolumeGeo(vol);
 812
 813     if(pGeo == NULL)
 814     {
 815         return NodeTransitPtr(NULL);
 816     }
 817
 818     NodeTransitPtr node = Node::create();
 819
 820     node->setCore(pGeo);
 821
 822     return node;
 823 }
 824
 825 /*! Creates a frustum volume geometry
 826
 827     \param[in] vol is frustum volume
 828     \return GeometryTransitPtr to a newly created Geometry core.
 829
 830     \ingroup GrpDrawablesGeometryUtils
 831  */
 832 GeometryTransitPtr makeFrustumVolumeGeo(const FrustumVolume& vol)
 833 {
 834     Pnt3f nlt = vol.getCorner(FrustumVolume::NEAR_LEFT_TOP);
 835     Pnt3f nlb = vol.getCorner(FrustumVolume::NEAR_LEFT_BOTTOM);
 836     Pnt3f nrt = vol.getCorner(FrustumVolume::NEAR_RIGHT_TOP);
 837     Pnt3f nrb = vol.getCorner(FrustumVolume::NEAR_RIGHT_BOTTOM);
 838     Pnt3f flt = vol.getCorner(FrustumVolume::FAR_LEFT_TOP);
 839     Pnt3f flb = vol.getCorner(FrustumVolume::FAR_LEFT_BOTTOM);
 840     Pnt3f frt = vol.getCorner(FrustumVolume::FAR_RIGHT_TOP);
 841     Pnt3f frb = vol.getCorner(FrustumVolume::FAR_RIGHT_BOTTOM);
 842
 843     GeometryTransitPtr geo = makeFrustumVolumeGeo(nlt, nlb, nrt, nrb, flt, flb, frt, frb);
 844     return geo;
 845 }
 846
 847 OSG_END_NAMESPACE