Star

代码

// 系统及版本声明

#define  VERSION  10.0.554
#define  I386
#define  WIN32
#define  SWAP_BITFIELDS
#define  DLLEXPORT __declspec(dllexport)
#define  SESI_LITTLE_ENDIAN
#define  MAKING_DSO  
// 头文件声明
#include  < UT / UT_DSOVersion.h >
#include  < UT / UT_Interrupt.h >
#include  < GU / GU_PrimPoly.h >
#include  < CH / CH_LocalVariable.h >

#include  < PRM / PRM_Include.h >
#include  < OP / OP_Operator.h >
#include  < OP / OP_OperatorTable.h >

#include  < SOP / SOP_Node.h >

// 头文件定义
namespace  HDK_Sample{
class  SOP_Star: public  SOP_Node
{
public :
     static  OP_Node                     * myConstructor(OP_Network  * ,  const   char   * , OP_Operator  * );
     static  PRM_Template                myTemplateList[];
     static  CH_LocalVariable            myVariables[];
protected :
            SOP_Star(OP_Network  * net, const   char   * name,OP_Operator  * op);
     virtual   ~ SOP_Star();
     virtual  unsigned                disableParms();
     virtual  OP_ERROR                cookMySop(OP_Context  & context);
     virtual      float                     getVariableValue( int  index, int  thread);
private :
     int         DIVISIONS( float  t)            { return  evalInt        ( " divs " , 0 ,t);}
     float     XRADIUS( float  t)            { return  evalFloat    ( " rad " , 0 ,t);}
     float     YRADIUS( float  t)            { return  evalFloat    ( " rad " , 1 ,t);}
     int         NEGRADIUS()                    { return     evalInt        ( " nradius " , 0 , 0 );}
     float     CENTERX( float  t)            { return  evalFloat    ( " t " , 0 ,t);}
     float     CENTERY( float  t)            { return  evalFloat    ( " t " , 1 ,t);}
     float     CENTERZ( float  t)            { return  evalFloat    ( " t " , 2 ,t);}
     int         ORIENT()                    { return  evalInt        ( " orient " , 0 , 0 );}
     int         myCurrPoint;
     int         myTotalPoints;
};
}
using   namespace  HDK_Sample;
// 消息钩子
void
newSopOperator(OP_OperatorTable  * table)
{
    table -> addOperator(
         new  OP_Operator( " hdk_star " , " Star " ,
        SOP_Star::myConstructor,
        SOP_Star::myTemplateList,
         0 , 0 ,
        SOP_Star::myVariables,
        OP_FLAG_GENERATOR
        )
        );
}

// 参数定义
static  PRM_Name                negativeName( " nradius " , " Negative Radius " );
static  PRM_Default            fiveDefault( 5 );
static  PRM_Default            radiDefaults[] = {
                                PRM_Default( 1 ),
                                PRM_Default( 0.3 )
};
PRM_Template
SOP_Star::myTemplateList[] = {
    PRM_Template(PRM_INT_J, 1 , & PRMdivName, & fiveDefault, 0 , & PRMdivision2Range),
    PRM_Template(PRM_XYZ_J, 2 , & PRMradiusName,radiDefaults),
    PRM_Template(PRM_TOGGLE, 1 , & negativeName),
    PRM_Template(PRM_XYZ_J, 3 , & PRMcenterName),
    PRM_Template(PRM_ORD, 1 , & PRMorientName, 0 , & PRMplaneMenu),
    PRM_Template()
};

// 定义局部变量
enum { VAR_PT,VAR_NPT};
CH_LocalVariable
SOP_Star::myVariables[] = {
    { " PT " ,        VAR_PT,     0 },
    { " NPT " ,        VAR_NPT, 0 },
    { 0 , 0 , 0 },
};
float
SOP_Star::getVariableValue( int  index,  int  thread)
{
     if (myCurrPoint < 0 )     return   0 ;
     switch (index)
    {
     case  VAR_PT:     return  myCurrPoint;
     case  VAR_NPT:     return  myTotalPoints;
    }
     return  SOP_Node::getVariableValue(index,thread);
}

// 节点构造
OP_Node  *
SOP_Star::myConstructor(OP_Network  * net,  const   char   * name, OP_Operator  * op)
{
     return   new  SOP_Star(net,name,op);
}
// 功能函数构造
SOP_Star::SOP_Star(OP_Network  * net, const   char   * name,OP_Operator  * op):SOP_Node(net,name,op)
{
    myCurrPoint  =   - 1 ;
}
// 功能函数析构
SOP_Star:: ~ SOP_Star(){}
unsigned
SOP_Star::disableParms(){ return   0 ;}
// 制作
OP_ERROR
SOP_Star::cookMySop(OP_Context  & context)
{
     float             now;
     float             rad,tx,ty,tz;
     int                 divisions,plane,negradius;
     int                 xcoord,ycoord,zcoord;
     float             tmp,tinc;
    GEO_Point         * ppt;
    GU_PrimPoly         * poly;
     int                 i;
    UT_Interrupt     * boss;

    now  =  context.myTime;

    divisions  =  DIVISIONS(now) * 2 ;
    myTotalPoints  =  divisions;
    myCurrPoint  =   0 ;

    plane         =  ORIENT();
    negradius     =  NEGRADIUS();
    tx             =  CENTERX(now);
    ty             =  CENTERY(now);
    tz             =  CENTERZ(now);

     switch (plane)
    {
     case   0 :
        xcoord  =   0 ;
        ycoord  =   1 ;
        zcoord  =   2 ;
         break ;
     case   1 :
        xcoord  =   1 ;
        ycoord  =   2 ;
        zcoord  =   0 ;
         break ;
     case   2 :
        xcoord  =   0 ;
        ycoord  =   2 ;
        zcoord  =   1 ;
         break ;
    }
     if (error() < UT_ERROR_ABORT)
    {
        boss  =  UTgetInterrupt();
         if (divisions  <   4 )
        {
            addWarning(SOP_MESSAGE, " Invalid divisions " );
            divisions  =   4 ;
        }
        gdp -> clearAndDestroy();
        boss -> opStart( " Building Star " );
        poly  =  GU_PrimPoly::build(gdp,divisions,GU_POLY_CLOSED);
        tinc  =  M_PI * 2 / ( float )divisions;

         for (i = 0 ;i < divisions;i ++ )
        {
             if (boss -> opInterrupt())
                 break ;
            myCurrPoint  =  i;
            tmp  =  ( float )i  *  tinc;
            rad  =  (i  &   1 ) ? XRADIUS(now) :YRADIUS(now);
             if ( ! negradius && rad < 0 )
                rad  =   0 ;
            ppt  =  poly -> getVertex(i).getPt();
            ppt -> getPos()(xcoord)  =  cos(tmp)  *  rad  +  tx;
            ppt -> getPos()(ycoord)  =  sin(tmp)  *  rad  +  ty;
            ppt -> getPos()(zcoord)  =   0   +  tz;
        }
        select(GU_SPrimitive);
        boss -> opEnd();
    }
    myCurrPoint  =   - 1 ;
     return  error();
}

   ppt = poly->getVertex(i).getPt();
   ppt->getPos()(xcoord) = cos(tmp) * radx + tx;
   ppt->getPos()(ycoord) = sin(tmp) * rady + ty;
   ppt->getPos()(zcoord) = 0 + tz;