OSG::Billboard Class Reference

00099     {
00100         AxisOfRotationFieldId = Inherited::NextFieldId,
00101         FocusOnCameraFieldId = AxisOfRotationFieldId + 1,
00102         AlignToScreenFieldId = FocusOnCameraFieldId + 1,
00103         MinAngleFieldId = AlignToScreenFieldId + 1,
00104         MaxAngleFieldId = MinAngleFieldId + 1,
00105         NextFieldId = MaxAngleFieldId + 1
00106     };

00069                          :
00070      Inherited   (),
00071     _camTransform()
00072 {
00073 }

00077                                             :
00078      Inherited   (source              ),
00079     _camTransform(source._camTransform)
00080 {
00081 }

00086 {
00087 }

00123 {
00124     Inherited::changed(whichField, origin, details);
00125 }

00168 {
00169     Pnt3f eyepos(0.f, 0.f, 0.f);
00170     Pnt3f objpos(0.f, 0.f, 0.f);
00171 
00172     Vec3f vDir;
00173     Vec3f n(0.f, 0.f, 1.f);
00174 
00175     Quaternion q1;
00176 
00177     mResult.invertFrom(mToWorld);
00178 
00179     mToWorld.mult(n);
00180 
00181     if(getAxisOfRotation() == Vec3f::Null)
00182     {
00183         if(_sfFocusOnCamera.getValue() == true)
00184         {
00185             Vec3f vUp;
00186             Vec3f uW;
00187             Vec3f vX;
00188 
00189             camToWorld.mult(eyepos);
00190             mToWorld   .mult(objpos);
00191 
00192             vDir = eyepos - objpos;
00193 
00194             vUp.setValue (camToWorld[0]);
00195 
00196             vUp = vDir.cross(vUp);
00197 
00198             vUp.normalize();
00199             vDir.normalize();
00200 
00201             Matrix mTr;
00202 
00203             vX = vUp.cross(vDir);
00204             vX.normalize();
00205 
00206             mTr[0][0] = vX[0];
00207             mTr[0][1] = vX[1];
00208             mTr[0][2] = vX[2];
00209             mTr[1][0] = vUp[0];
00210             mTr[1][1] = vUp[1];
00211             mTr[1][2] = vUp[2];
00212             mTr[2][0] = vDir[0];
00213             mTr[2][1] = vDir[1];
00214             mTr[2][2] = vDir[2];
00215 
00216             q1.setValue(mTr);
00217         }
00218         else
00219         {
00220             if(_sfAlignToScreen.getValue() == false)
00221             {
00222                 Vec3f u  (0.f, 1.f, 0.f);
00223                 Vec3f vUp;
00224                 Vec3f uW;
00225 
00226                 camToWorld.mult(eyepos);
00227                 mToWorld   .mult(objpos);
00228 
00229                 vDir = eyepos - objpos;
00230 
00231 //            vDir.setValue(camToWorld[2]);
00232 
00233                 vUp.setValue (camToWorld[1]);
00234 
00235                 Quaternion qN(n, vDir);
00236 
00237                 mToWorld.mult(u);
00238 
00239                 qN.multVec(u, uW);
00240 
00241                 q1.setValue(uW, vUp);
00242 
00243                 q1.mult(qN);
00244             }
00245             else
00246             {
00247                 Vec3f u  (0.f, 1.f, 0.f);
00248                 Vec3f vUp;
00249                 Vec3f uW;
00250 
00251                 vDir.setValue(camToWorld[2]);
00252 
00253                 vUp.setValue (camToWorld[1]);
00254 
00255                 Quaternion qN(n, vDir);
00256 
00257                 mToWorld.mult(u);
00258 
00259                 qN.multVec(u, uW);
00260 
00261                 q1.setValue(uW, vUp);
00262 
00263                 q1.mult(qN);
00264             }
00265         }
00266     }
00267     else
00268     {
00269         Vec3f wUp;
00270         Vec3f s;
00271         Vec3f tDir;
00272 
00273         camToWorld.mult(eyepos);
00274 
00275         mToWorld.mult(objpos);
00276 
00277         mToWorld.mult(getAxisOfRotation(), wUp);
00278 
00279         vDir = eyepos - objpos;
00280 
00281         s    = vDir.cross(wUp);
00282         tDir = wUp .cross(s  );
00283 
00284         q1.setValue(n, tDir);
00285 
00286         // clamp angle to [min; max]
00287         Vec3f  axis;
00288         Real32 angle;
00289 
00290         if(getMinAngle() <= getMaxAngle())
00291         {
00292             q1.getValueAsAxisRad(axis, angle);
00293 
00294             if(angle < getMinAngle())
00295                 angle = getMinAngle();
00296 
00297             if(angle > getMaxAngle())
00298                 angle = getMaxAngle();
00299 
00300             q1.setValueAsAxisRad(axis, angle);
00301         }
00302     }
00303 
00304     Matrix mTrans;
00305     Matrix mMat;
00306 
00307     mTrans[3][0] = mToWorld[3][0];
00308     mTrans[3][1] = mToWorld[3][1];
00309     mTrans[3][2] = mToWorld[3][2];
00310 
00311     mMat.setTransform(q1);
00312 
00313     mResult.mult(mTrans);
00314     mResult.mult(mMat  );
00315 
00316     mTrans[3][0] = -mToWorld[3][0];
00317     mTrans[3][1] = -mToWorld[3][1];
00318     mTrans[3][2] = -mToWorld[3][2];
00319 
00320     mResult.mult(mTrans);
00321     mResult.mult(mToWorld);
00322 
00323     _camTransform = mResult;
00324 }

00131 {
00132     Inherited::dump(uiIndent, bvFlags);
00133 }

00161 {
00162     result.mult(_camTransform);
00163 }

00139 {
00140     Inherited::adjustVolume(volume);
00141 
00142     // enlarge the volume to adjust for rotations
00143     // keep the center, but make it a cube big enough to contain the
00144     // billboard in all orientations
00145 
00146     Pnt3f min, max;
00147 
00148     volume.getBounds(min, max);
00149 
00150     Vec3f  dia    = max - min;
00151     Pnt3f  center = min + dia * .5;
00152     Real32 extend = dia.maxValue();
00153 
00154     dia.setValues(extend * Sqrt2, extend * Sqrt2, extend * Sqrt2);
00155 
00156     volume.extendBy( center - dia );
00157     volume.extendBy( center + dia );
00158 }

00331 {
00332     IntersectAction *ia = dynamic_cast<IntersectAction *>(action);
00333     Matrix           m(_camTransform);
00334 
00335     m.invert();
00336