home *** CD-ROM | disk | FTP | other *** search
/ DOS/V Power Report 1997 March / VPR9703A.ISO / VPR_DATA / DOGA / SOURCES / POLYEDIT.LZH / MODEL / VSETLIB.C < prev    next >
C/C++ Source or Header  |  1996-07-25  |  11KB  |  417 lines
  1. /*
  2.  *    頂点集合
  3.  *
  4.  *        Copyright T.Kobayashi    1994.7.9
  5.  */
  6.  
  7. #include <stdio.h>
  8. #include <stdlib.h>
  9. #include <string.h>
  10. #include <assert.h>
  11.  
  12. #include "matrix.h"
  13. #include "vector.h"
  14. #include "matclass.h"
  15. #include "strclass.h"
  16. #include "ml.h"
  17.  
  18. #include "poly.h"
  19. #include "view.h"
  20.  
  21. int        VertexSetClassID ;
  22. static int    VertexClassID;
  23. static int    MatrixClassID;
  24.  
  25. static    int        FuncVertexSet(int ident, int args, DataStruct *buf);
  26. static    int        FuncToString(int ident, int args, DataStruct *buf);
  27. static    int        FuncVertex2Select(int ident, int args, DataStruct *buf);
  28. static    int        FuncSelect2Vertex(int ident, int args, DataStruct *buf);
  29. static    int        FuncVertexs(int ident, int args, DataStruct *buf);
  30. static    int        FuncVertexGetVertex(int ident, int args, DataStruct *buf);
  31. static    int        FuncDrawVertex(int ident, int args, DataStruct *buf);
  32. static    int        FuncVertexEqual(int ident, int args, DataStruct *buf);
  33. static    int        FuncVertexLogical(int ident, int args, DataStruct    *buf);
  34. static    int        FuncVertexMulMatrix(int ident, int args, DataStruct    *buf);
  35. static    int        FuncVertexAddVertex(int ident, int args, DataStruct    *buf);
  36. static    int        FuncVertexPositionVertex(int ident, int args, DataStruct    *buf);
  37. static    int        FuncVertexSelectPosition(int ident, int args, DataStruct    *buf);
  38.  
  39. void    VertexSetLibInit()
  40. {
  41.     VertexSetClassID = NewClass( "VertexSet", 0 );
  42.     VertexClassID = ClassName("Vertex");
  43.     MatrixClassID = ClassName("Matrix");
  44.  
  45.     NewFunction( 0, "VertexSet", FuncVertexSet );
  46.     NewFunction( 0, "VertexSelect", FuncSelect2Vertex );
  47.     NewFunction( VertexSetClassID, "tostring", FuncToString );
  48.     NewFunction( VertexSetClassID, "VertexSelect", FuncVertex2Select );
  49.     NewFunction( VertexSetClassID, "VertexGetVertex", FuncVertexGetVertex );
  50.     NewFunction( VertexSetClassID, "Vertexs", FuncVertexs );
  51.     NewFunction( VertexSetClassID, "DrawVertex", FuncDrawVertex );
  52.     NewFunction( VertexSetClassID, "VertexPositionVertex", FuncVertexPositionVertex );
  53.     NewFunction( VertexSetClassID, "VertexSelectPosition", FuncVertexSelectPosition );
  54.     NewOperator( VertexSetClassID, OPE_EQ, FuncVertexEqual );
  55.     NewOperator( VertexSetClassID, OPE_NOTEQ, FuncVertexEqual );
  56.     NewOperator( VertexSetClassID, OPE_AND, FuncVertexLogical );
  57.     NewOperator( VertexSetClassID, OPE_OR, FuncVertexLogical );
  58.     NewOperator( VertexSetClassID, OPE_XOR, FuncVertexLogical );
  59.     NewOperator( VertexSetClassID, OPE_MULT, FuncVertexLogical );
  60.     NewOperator( VertexSetClassID, OPE_PLUS, FuncVertexLogical );
  61.     NewOperator( VertexSetClassID, OPE_MINUS, FuncVertexLogical );
  62. }
  63.  
  64.  
  65. /*    頂点集合を生成する    */
  66. static    int        FuncVertexSet( ident, args, buf )
  67. int        ident ;
  68. int        args ;
  69. DataStruct    *buf ;
  70. {
  71.     VertexSetClass *verset = NULL;
  72.     if (args == 0) {
  73.         verset = VertexAlloc(0);
  74.     } else if (args == 1 && ObjectCheck( &buf[0], VertexClassID )) {
  75.         verset = VertexAppend(VertexAlloc(0),&(((VertexClass*)(buf[0].od.ptr))->ver));
  76.     } else if (args == 1 && ObjectCheck( &buf[0], VectorClassID )) {
  77.         Vector *vec;
  78.         Vertex ver;
  79.         memset(&ver, 0, sizeof(Vertex));
  80.         vec = &(((VectorClass*)(buf[0].od.ptr))->vec);
  81.         ver.x = (short)vec->x;
  82.         ver.y = (short)vec->y;
  83.         ver.z = (short)vec->z;
  84.         verset = VertexAppend(VertexAlloc(0),&ver);
  85.     } else {
  86.         ExecError("VertexSet:引数の型が異なる\n");
  87.     }
  88.     buf = StackAlloc( 1 );
  89.     buf->type = TYPE_OBJECT ;
  90.     buf->od.ptr = (Object*)verset ;
  91.     return RETURN_RETURN ;
  92. }
  93.  
  94. /*    頂点集合を文字列に    */
  95. static    int        FuncToString( ident, args, buf )
  96. int        ident ;
  97. int        args ;
  98. DataStruct    *buf ;
  99. {
  100.     char *p;
  101.     VertexSetClass *verset;
  102.     Vertex *ed;
  103.     StringClass *str;
  104.     int i;
  105.     ArgCheck( "tostring", args, buf, TYPE_OBJECT, TYPE_NOASN );
  106.     verset = (VertexSetClass*)buf[0].od.ptr;
  107.     str = StringAlloc(60 * verset->vers + 1);
  108.     p = str->str;
  109.     ed = verset->ver;
  110.     for (i = 0; i < verset->vers; i++) {
  111.         sprintf(p, "(%6d,%6d,%6d) (%4d %4d %4d) (%4d %4d)\n",
  112.                     ed->x, ed->y, ed->z, ed->vx, ed->vy, ed->vz, ed->u, ed->v);
  113.         ed++;
  114.     }
  115.     buf = StackAlloc( 1 );
  116.     buf->type = TYPE_OBJECT ;
  117.     buf->od.ptr = (Object*)str ;
  118.     return RETURN_RETURN ;
  119. }
  120.  
  121. /*    頂点集合からポリゴンを選択    */
  122. static    int        FuncVertex2Select( ident, args, buf )
  123. int        ident ;
  124. int        args ;
  125. DataStruct    *buf ;
  126. {
  127.     ArgCheck( "VertexSelect", args, buf, TYPE_OBJECT, TYPE_INT|TYPE_BOOLEAN, TYPE_INT, TYPE_NOASN );
  128.     PolySelectVertex( (VertexSetClass*)(buf[0].od.ptr), buf[1].id.i, buf[2].id.i );
  129.     return RETURN_VOID ;
  130. }
  131.  
  132. /*    頂点集合を生成する    */
  133. static    int        FuncSelect2Vertex( ident, args, buf )
  134. int        ident ;
  135. int        args ;
  136. DataStruct    *buf ;
  137. {
  138.     VertexSetClass *verset;
  139.     if (args > 0) {
  140.         ExecError("VertexSelect:引数の型が異なる\n");
  141.     }
  142.     verset = VertexSelect();
  143.  
  144.     buf = StackAlloc( 1 );
  145.     buf->type = TYPE_OBJECT ;
  146.     buf->od.ptr = (Object*)verset ;
  147.  
  148.     return RETURN_RETURN ;
  149. }
  150.  
  151. /*    頂点集合数    */
  152. static    int        FuncVertexs( ident, args, buf )
  153. int        ident ;
  154. int        args ;
  155. DataStruct    *buf ;
  156. {
  157.     ArgCheck( "Vertexs", args, buf, TYPE_OBJECT, TYPE_NOASN );
  158.     StackPushInt( ((VertexSetClass*)(buf[0].od.ptr))->vers );
  159.  
  160.     return RETURN_RETURN ;
  161. }
  162.  
  163. /*    頂点取得    */
  164. static    int        FuncVertexGetVertex( ident, args, buf )
  165. int        ident ;
  166. int        args ;
  167. DataStruct    *buf ;
  168. {
  169.     int pos;
  170.     VertexSetClass *verset;
  171.     VertexClass    *ver ;
  172.  
  173.     verset = (VertexSetClass*)buf[0].od.ptr ;
  174.     if (ObjectCheck( &buf[1], VertexClassID )
  175.      || ObjectCheck( &buf[1], VectorClassID ) ) {
  176.         Vertex *v, tmpver;
  177.         Vector *vec;
  178.         ArgCheck( "VertexGetVertex", args, buf, TYPE_OBJECT, TYPE_OBJECT, TYPE_NOASN);
  179.         if (ObjectCheck( &buf[1], VertexClassID )) {
  180.             v = &(((VertexClass*)buf[1].od.ptr)->ver);
  181.         } else {
  182.             memset(&tmpver, 0, sizeof(Vertex));
  183.             vec = &(((VectorClass*)buf[1].od.ptr)->vec);
  184.             tmpver.x = (short)vec->x;
  185.             tmpver.y = (short)vec->y;
  186.             tmpver.z = (short)vec->z;
  187.             v = &tmpver;
  188.         }
  189.         pos = VertexSearch(verset, v);
  190.         StackPushInt(pos);
  191.         return RETURN_RETURN;
  192.     } else {
  193.         ArgCheck( "VertexGetVertex", args, buf, TYPE_OBJECT, TYPE_INT, TYPE_NOASN);
  194.  
  195.         pos = buf[1].id.i;
  196.  
  197.         if (0 <= pos && pos < verset->vers) {
  198.             ver = (VertexClass*)ObjectAlloc( sizeof( VertexClass ), VertexClassID );
  199.             ver->dtype = POLY_UVSHADE;
  200.             ver->ver = verset->ver[pos];
  201.  
  202.             buf = StackAlloc( 1 );
  203.             buf->type = TYPE_OBJECT ;
  204.             buf->od.ptr = (Object*)ver ;
  205.             return RETURN_RETURN ;
  206.         }
  207.     }
  208.     return RETURN_VOID ;
  209. }
  210.  
  211.  
  212. /*    頂点を描画    */
  213. static    int        FuncDrawVertex( ident, args, buf )
  214. int        ident ;
  215. int        args ;
  216. DataStruct    *buf ;
  217. {
  218.     int i;
  219.     VertexSetClass *verset;
  220.     int color;
  221.     if (args == 2) {
  222.         ArgCheck( "DrawVertex", args, buf, TYPE_OBJECT, TYPE_INT, TYPE_NOASN );
  223.         color = buf[1].id.i;
  224.     } else {
  225.         ArgCheck( "DrawVertex", args, buf, TYPE_OBJECT, TYPE_NOASN );
  226.         color = CURSOR_COLOR;
  227.     }
  228.     verset = (VertexSetClass*)(buf[0].od.ptr);
  229.  
  230.     for (i = 0; i < verset->vers; i++) {
  231.         ViewVertex(&verset->ver[i], color);
  232.     }
  233.  
  234.     return RETURN_VOID ;
  235. }
  236.  
  237. /*    位置のみのVertexSet を得る    */
  238. static    int        FuncVertexPositionVertex( ident, args, buf )
  239. int        ident ;
  240. int        args ;
  241. DataStruct    *buf ;
  242. {
  243.     VertexSetClass *ret;
  244.     ret = VertexPositionVertex((VertexSetClass*)buf[0].od.ptr);
  245.     buf = StackAlloc( 1 );
  246.     buf->type = TYPE_OBJECT ;
  247.     buf->od.ptr = (Object*)ret ;
  248.  
  249.     return RETURN_RETURN ;
  250. }
  251.  
  252. /*    指定位置のVertexSet を得る    */
  253. static    int        FuncVertexSelectPosition( ident, args, buf )
  254. int        ident ;
  255. int        args ;
  256. DataStruct    *buf ;
  257. {
  258.     Vertex v;
  259.     VertexSetClass *ret;
  260.     if (args == 2 && ObjectCheck( &buf[1], VertexClassID )) {
  261.         v = ((VertexClass*)(buf[1].od.ptr))->ver;
  262.     } else if (args == 2 && ObjectCheck( &buf[1], VectorClassID )) {
  263.         Vector *vec;
  264.         vec = &(((VectorClass*)(buf[1].od.ptr))->vec);
  265.         v.x = (short)vec->x;
  266.         v.y = (short)vec->y;
  267.         v.z = (short)vec->z;
  268.     } else {
  269.         ExecError("VertexSelectPosition: 引数の型が異なる\n");
  270.     }
  271.     ret = VertexSelectPosition((VertexSetClass*)buf[0].od.ptr, &v);
  272.     buf = StackAlloc( 1 );
  273.     buf->type = TYPE_OBJECT ;
  274.     buf->od.ptr = (Object*)ret ;
  275.  
  276.     return RETURN_RETURN ;
  277. }
  278.  
  279.  
  280.  
  281. /*    頂点集合の等価判定    */
  282. static    int        FuncVertexEqual( ident, args, buf )
  283. int        ident ;
  284. int        args ;
  285. DataStruct    *buf ;
  286. {
  287.     VertexSetClass    *verset1, *verset2 ;
  288.  
  289.     if ( args != 2 || ObjectCheck( &buf[1], VertexSetClassID ) == FALSE ) {
  290.         ExecError( "論理演算の型が不正です(Vertex)" );
  291.     }
  292.     verset1 = (VertexSetClass*)buf[0].od.ptr ;
  293.     verset2 = (VertexSetClass*)buf[1].od.ptr ;
  294.  
  295.     if (ident == OPE_EQ)
  296.         StackPushBoolean(VertexLogicalEqual(verset1, verset2) );
  297.     else
  298.         StackPushBoolean( ! VertexLogicalEqual(verset1, verset2) );
  299.  
  300.     return RETURN_RETURN ;
  301. }
  302.  
  303.  
  304. /*    頂点集合の論理演算    */
  305. static    int        FuncVertexLogical( ident, args, buf )
  306. int        ident ;
  307. int        args ;
  308. DataStruct    *buf ;
  309. {
  310.     VertexSetClass    *verset1, *verset2, *verset, *ret ;
  311.  
  312.     if (ident == OPE_MULT && args == 2 && ObjectCheck(&buf[1], MatrixClassID)) {
  313.         return FuncVertexMulMatrix(ident, args, buf);
  314.     }
  315.     if ((ident == OPE_OR || ident == OPE_PLUS || ident == OPE_MINUS)
  316.      && (ObjectCheck(&buf[1], VertexClassID) || ObjectCheck(&buf[1], VectorClassID))) {
  317.         return FuncVertexAddVertex(ident, args, buf);
  318.     }
  319.  
  320.     if ( args != 2 || ObjectCheck( &buf[1], VertexSetClassID ) == FALSE ) {
  321.         ExecError( "論理演算の型が不正です(Vertex)" );
  322.     }
  323.     verset1 = (VertexSetClass*)buf[0].od.ptr ;
  324.     verset2 = (VertexSetClass*)buf[1].od.ptr ;
  325.  
  326.     if (ident == OPE_MINUS || verset1->vers > verset2->vers) {
  327.         ret = (VertexSetClass*)ObjectDup((Object*)verset1);
  328.         verset = verset2;
  329.     } else {
  330.         ret = (VertexSetClass*)ObjectDup((Object*)verset2);
  331.         verset = verset1;
  332.     }
  333.  
  334.     switch( ident ) {
  335.     case OPE_AND:
  336.     case OPE_MULT:
  337.         ret = VertexLogicalAnd(ret, verset);
  338.         break;
  339.     case OPE_OR:
  340.     case OPE_PLUS:
  341.         ret = VertexLogicalOr(ret, verset);
  342.         break;
  343.     case OPE_MINUS:
  344.         ret = VertexLogicalSub(ret, verset);
  345.         break;
  346.     case OPE_XOR:
  347.         ret = VertexLogicalXor(ret, verset);
  348.     }
  349.  
  350.     buf = StackAlloc( 1 );
  351.     buf->type = TYPE_OBJECT ;
  352.     buf->od.ptr = (Object*)ret ;
  353.  
  354.     return RETURN_RETURN ;
  355. }
  356.  
  357. /*    頂点集合の論理演算    */
  358. static    int        FuncVertexMulMatrix( ident, args, buf )
  359. int        ident ;
  360. int        args ;
  361. DataStruct    *buf ;
  362. {
  363.     VertexSetClass    *verset, *ret ;
  364.     MatrixClass    *mat;
  365.  
  366.     if ( args != 2 || ObjectCheck( &buf[1], MatrixClassID ) == FALSE ) {
  367.         ExecError( "論理演算の型が不正です(Vertex)" );
  368.     }
  369.     verset = (VertexSetClass*)buf[0].od.ptr ;
  370.     mat = (MatrixClass*)buf[1].od.ptr ;
  371.  
  372.     ret = (VertexSetClass*)ObjectDup((Object*)verset);
  373.     ret = VertexMulMatrix(ret, mat);
  374.  
  375.     buf = StackAlloc( 1 );
  376.     buf->type = TYPE_OBJECT ;
  377.     buf->od.ptr = (Object*)ret ;
  378.  
  379.     return RETURN_RETURN ;
  380. }
  381.  
  382. /*    頂点集合の論理演算    */
  383. static    int        FuncVertexAddVertex( ident, args, buf )
  384. int        ident ;
  385. int        args ;
  386. DataStruct    *buf ;
  387. {
  388.     VertexSetClass *ret;
  389.     Vertex tmpver, *ver;
  390.  
  391.     ret = (VertexSetClass*)ObjectDup(buf[0].od.ptr);
  392.  
  393.     if (ObjectCheck( &buf[1], VertexClassID )) {
  394.         ver = &((VertexClass*)(buf[1].od.ptr))->ver;
  395.     } else if (ObjectCheck( &buf[1], VectorClassID )) {
  396.         Vector *vec;
  397.         memset(&tmpver, 0, sizeof(Vertex));
  398.         vec = &(((VectorClass*)buf[1].od.ptr)->vec);
  399.         tmpver.x = (short)vec->x;
  400.         tmpver.y = (short)vec->y;
  401.         tmpver.z = (short)vec->z;
  402.         ver = &tmpver;
  403.     } else {
  404.         ExecError( "論理演算の型が不正です(Vertex)" );
  405.     }
  406.     if (ident == OPE_PLUS || ident == OPE_OR) {
  407.         ret = VertexAppend(ret, ver);
  408.     } else {
  409.         ret = VertexDelete(ret, ver);
  410.     }
  411.     buf = StackAlloc( 1 );
  412.     buf->type = TYPE_OBJECT ;
  413.     buf->od.ptr = (Object*)ret ;
  414.  
  415.     return RETURN_RETURN ;
  416. }
  417.