SuperShape.h

Go to the documentation of this file.

//    Copyright 2004-2019, SenseGraphics AB
//
//    This file is part of H3D API.
//
//    H3D API is free software; you can redistribute it and/or modify
//    it under the terms of the GNU General Public License as published by
//    the Free Software Foundation; either version 2 of the License, or
//    (at your option) any later version.
//
//    H3D API is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    GNU General Public License for more details.
//
//    You should have received a copy of the GNU General Public License
//    along with H3D API; if not, write to the Free Software
//    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//    A commercial license is also available. Please contact us at 
//    www.sensegraphics.com for more information.
//
//
//
#ifndef __SUPERSHAPE_H__
#define __SUPERSHAPE_H__
 
#include <H3D/X3DGeometryNode.h>
#include <H3D/SFFloat.h>
#include <H3D/SFInt32.h>
#include <H3D/DependentNodeFields.h>
#include <H3D/X3DCoordinateNode.h>
#include <H3D/CoordBoundField.h>
#include <H3D/X3DNormalNode.h>
 
namespace H3D {
 
  class H3DAPI_API SuperShape : public X3DGeometryNode {
  public:
    
    typedef DependentSFNode< X3DNormalNode,
                             FieldRef< X3DGeometricPropertyNode,
                                       Field,
                                       &X3DNormalNode::propertyChanged > > 
    SFNormalNode;
 
    class SFCoordinateNode: public TypedField< DependentSFNode< X3DCoordinateNode,
                             FieldRef< X3DGeometricPropertyNode,
                                       Field,
                                       &X3DCoordinateNode::propertyChanged > >, Types< SFFloat, SFFloat,
                                                              SFFloat, SFFloat,
                                                              SFFloat, SFFloat,
                                                              SFFloat, SFFloat,
                                                              SFFloat, SFFloat,
                                                              SFFloat, SFFloat,
                                                              SFInt32 > > {
      virtual void update();
 
      // Function used internally to define supershape.
      H3DFloat R( H3DFloat phi, H3DFloat m, H3DFloat a, H3DFloat b,
                  H3DFloat n1, H3DFloat n2, H3DFloat n3 ) {
        H3DFloat t2 = m*phi/4.0f;
        H3DFloat t3 = cosf(t2);
        H3DFloat t6 = H3DAbs(t3/a);
        H3DFloat t7 = powf(t6,n2);
        H3DFloat t8 = sinf(t2);
        H3DFloat t11 = H3DAbs(t8/b);
        H3DFloat t12 = powf(t11,n3);
        H3DFloat t14 = powf(t7+t12,-1/n1);
        return t14;
        //return powf(powf(fabsf(cosf((alpha*m)/4.)/a), n2) 
        //            + powf(fabsf(sinf((alpha*m)/4.)/b),n3), -1/n1);
      }
 
      // Function used internally to define supershape.
      Vec3f SS( H3DFloat theta, H3DFloat phi, H3DFloat sm, H3DFloat sa,
              H3DFloat sb, H3DFloat sn1, H3DFloat sn2, H3DFloat sn3,
              H3DFloat tm, H3DFloat ta, H3DFloat tb, H3DFloat tn1,
              H3DFloat tn2, H3DFloat tn3 ) { 
        H3DFloat r1theta = R( theta, sm, sa, sb, sn1, sn2, sn3 );
        H3DFloat r2phi = R( phi, tm, ta, tb, tn1, tn2, tn3 );
 
        H3DFloat x = r1theta * cosf(theta) * r2phi * cosf(phi);
        H3DFloat y = r1theta * sin(theta) * r2phi * cosf(phi);
        H3DFloat z = r2phi * sin(phi);
 
        return Vec3f( x, y, z);
      }
    };
 
    typedef CoordBoundField SFBound;
 
    SuperShape( Inst< SFNode   >  _metadata = 0,
                Inst< SFBound     > _bound = 0,
                Inst< SFFloat  > _ss1_m  = 0,
                Inst< SFFloat  > _ss1_a  = 0,
                Inst< SFFloat  > _ss1_b  = 0,
                Inst< SFFloat  > _ss1_n1 = 0,
                Inst< SFFloat  > _ss1_n2 = 0,
                Inst< SFFloat  > _ss1_n3 = 0,
                Inst< SFFloat  > _ss2_m  = 0,
                Inst< SFFloat  > _ss2_a  = 0,
                Inst< SFFloat  > _ss2_b  = 0,
                Inst< SFFloat  > _ss2_n1 = 0,
                Inst< SFFloat  > _ss2_n2 = 0,
                Inst< SFFloat  > _ss2_n3 = 0,
                Inst< SFInt32  > _resolution = 0 );
 
    virtual void render();
 
    virtual int nrTriangles() {
      H3DInt32 res = resolution->getValue();
      if( res < 0 ) return 0;
      else return res * res * 2;
    }
 
    // Traverse the scenegraph. See X3DGeometryNode::traverseSG
    // for more info.
    virtual void traverseSG( TraverseInfo &ti );
    
    // Fields
    H3DUniquePtr< SFFloat  > ss1_m;
 
    H3DUniquePtr< SFFloat  > ss1_a;
 
    H3DUniquePtr< SFFloat  > ss1_b;
 
    H3DUniquePtr< SFFloat  > ss1_n1;
 
    H3DUniquePtr< SFFloat  > ss1_n2;
 
    H3DUniquePtr< SFFloat  > ss1_n3;
 
    H3DUniquePtr< SFFloat  > ss2_m;
 
    H3DUniquePtr< SFFloat  > ss2_a;
 
    H3DUniquePtr< SFFloat  > ss2_b;
 
    H3DUniquePtr< SFFloat  > ss2_n1;
 
    H3DUniquePtr< SFFloat  > ss2_n2;
 
    H3DUniquePtr< SFFloat  > ss2_n3;
 
    H3DUniquePtr< SFInt32  > resolution;
 
    static H3DNodeDatabase database;
  protected:
 
    void startTexGen();
 
    void stopTexGen();
 
    H3DUniquePtr< SFCoordinateNode > coord;
 
    H3DUniquePtr< SFNormalNode > normal;
 
  };
}
 
#endif