src/api.c

   1 #include "zgl.h"
   2 #include <stdio.h>
   3 /* glVertex */
   4
   5 void glVertex4f(float x,float y,float z,float w)
   6 {
   7         GLParam p[5];
   8
   9         p[0].op=OP_Vertex;
  10         p[1].f=x;
  11         p[2].f=y;
  12         p[3].f=z;
  13         p[4].f=w;
  14
  15         gl_add_op(p);
  16 }
  17
  18 void glVertex2f(float x,float y)
  19 {
  20         glVertex4f(x,y,0,1);
  21 }
  22
  23 void glVertex3f(float x,float y,float z)
  24 {
  25         glVertex4f(x,y,z,1);
  26 }
  27
  28 void glVertex3fv(float *v)
  29 {
  30         glVertex4f(v[0],v[1],v[2],1);
  31 }
  32
  33 /* glNormal */
  34
  35 void glNormal3f(float x,float y,float z)
  36 {
  37         GLParam p[4];
  38
  39         p[0].op=OP_Normal;
  40         p[1].f=x;
  41         p[2].f=y;
  42         p[3].f=z;
  43
  44         gl_add_op(p);
  45 }
  46
  47 void glNormal3fv(float *v)
  48 {
  49         glNormal3f(v[0],v[1],v[2]);
  50 }
  51
  52 /* glColor */
  53
  54 void glColor4f(float r,float g,float b,float a)
  55 {
  56         GLParam p[8];
  57
  58         p[0].op=OP_Color;
  59         p[1].f=r;
  60         p[2].f=g;
  61         p[3].f=b;
  62         p[4].f=a;
  63         /* direct convertion to integer to go faster if no shading */
  64         p[5].ui = (unsigned int) (r * (ZB_POINT_RED_MAX - ZB_POINT_RED_MIN) +
  65                         ZB_POINT_RED_MIN);
  66         p[6].ui = (unsigned int) (g * (ZB_POINT_GREEN_MAX - ZB_POINT_GREEN_MIN) +
  67                         ZB_POINT_GREEN_MIN);
  68         p[7].ui = (unsigned int) (b * (ZB_POINT_BLUE_MAX - ZB_POINT_BLUE_MIN) +
  69                         ZB_POINT_BLUE_MIN);
  70         gl_add_op(p);
  71 }
  72
  73 void glColor4fv(float *v)
  74 {
  75         GLParam p[8];
  76
  77         p[0].op=OP_Color;
  78         p[1].f=v[0];
  79         p[2].f=v[1];
  80         p[3].f=v[2];
  81         p[4].f=v[3];
  82         /* direct convertion to integer to go faster if no shading */
  83         p[5].ui = (unsigned int) (v[0] * (ZB_POINT_RED_MAX - ZB_POINT_RED_MIN) +
  84                         ZB_POINT_RED_MIN);
  85         p[6].ui = (unsigned int) (v[1] * (ZB_POINT_GREEN_MAX - ZB_POINT_GREEN_MIN) +
  86                         ZB_POINT_GREEN_MIN);
  87         p[7].ui = (unsigned int) (v[2] * (ZB_POINT_BLUE_MAX - ZB_POINT_BLUE_MIN) +
  88                         ZB_POINT_BLUE_MIN);
  89         gl_add_op(p);
  90 }
  91
  92 void glColor3f(float x,float y,float z)
  93 {
  94         glColor4f(x,y,z,1);
  95 }
  96
  97 void glColor3fv(float *v)
  98 {
  99         glColor4f(v[0],v[1],v[2],1);
 100 }
 101
 102
 103 /* TexCoord */
 104
 105 void glTexCoord4f(float s,float t,float r,float q)
 106 {
 107         GLParam p[5];
 108
 109         p[0].op=OP_TexCoord;
 110         p[1].f=s;
 111         p[2].f=t;
 112         p[3].f=r;
 113         p[4].f=q;
 114
 115         gl_add_op(p);
 116 }
 117
 118 void glTexCoord2f(float s,float t)
 119 {
 120         glTexCoord4f(s,t,0,1);
 121 }
 122
 123 void glTexCoord2fv(float *v)
 124 {
 125         glTexCoord4f(v[0],v[1],0,1);
 126 }
 127
 128 void glEdgeFlag(int flag)
 129 {
 130         GLParam p[2];
 131
 132         p[0].op=OP_EdgeFlag;
 133         p[1].i=flag;
 134
 135         gl_add_op(p);
 136 }
 137
 138 /* misc */
 139
 140 void glShadeModel(int mode)
 141 {
 142         GLParam p[2];
 143
 144         assert(mode == GL_FLAT || mode == GL_SMOOTH);
 145
 146         p[0].op=OP_ShadeModel;
 147         p[1].i=mode;
 148
 149         gl_add_op(p);
 150 }
 151
 152 void glCullFace(int mode)
 153 {
 154         GLParam p[2];
 155
 156         assert(mode == GL_BACK ||
 157                         mode == GL_FRONT ||
 158                         mode == GL_FRONT_AND_BACK);
 159
 160         p[0].op=OP_CullFace;
 161         p[1].i=mode;
 162
 163         gl_add_op(p);
 164 }
 165
 166 void glFrontFace(int mode)
 167 {
 168         GLParam p[2];
 169
 170         assert(mode == GL_CCW || mode == GL_CW);
 171
 172         mode = (mode != GL_CCW);
 173
 174         p[0].op=OP_FrontFace;
 175         p[1].i=mode;
 176
 177         gl_add_op(p);
 178 }
 179
 180 void glPolygonMode(int face,int mode)
 181 {
 182         GLParam p[3];
 183
 184         assert(face == GL_BACK ||
 185                         face == GL_FRONT ||
 186                         face == GL_FRONT_AND_BACK);
 187         assert(mode == GL_POINT || mode == GL_LINE || mode==GL_FILL);
 188
 189         p[0].op=OP_PolygonMode;
 190         p[1].i=face;
 191         p[2].i=mode;
 192
 193         gl_add_op(p);
 194 }
 195
 196
 197 /* glEnable / glDisable */
 198
 199 void glEnable(int cap)
 200 {
 201         GLParam p[3];
 202
 203         p[0].op=OP_EnableDisable;
 204         p[1].i=cap;
 205         p[2].i=1;
 206
 207         gl_add_op(p);
 208 }
 209
 210 void glDisable(int cap)
 211 {
 212         GLParam p[3];
 213
 214         p[0].op=OP_EnableDisable;
 215         p[1].i=cap;
 216         p[2].i=0;
 217
 218         gl_add_op(p);
 219 }
 220
 221 /* glBegin / glEnd */
 222
 223 void glBegin(int mode)
 224 {
 225         GLParam p[2];
 226
 227         p[0].op=OP_Begin;
 228         p[1].i=mode;
 229
 230         gl_add_op(p);
 231 }
 232
 233 void glEnd(void)
 234 {
 235         GLParam p[1];
 236
 237         p[0].op=OP_End;
 238
 239         gl_add_op(p);
 240 }
 241
 242 /* matrix */
 243
 244 void glMatrixMode(int mode)
 245 {
 246         GLParam p[2];
 247
 248         p[0].op=OP_MatrixMode;
 249         p[1].i=mode;
 250
 251         gl_add_op(p);
 252 }
 253
 254 void glLoadMatrixf(const float *m)
 255 {
 256         GLParam p[17];
 257         int i;
 258
 259         p[0].op=OP_LoadMatrix;
 260         for(i=0;i<16;i++) p[i+1].f=m[i];
 261
 262         gl_add_op(p);
 263 }
 264
 265 void glLoadIdentity(void)
 266 {
 267         GLParam p[1];
 268
 269         p[0].op=OP_LoadIdentity;
 270
 271         gl_add_op(p);
 272 }
 273
 274 void glMultMatrixf(const float *m)
 275 {
 276         GLParam p[17];
 277         int i;
 278
 279         p[0].op=OP_MultMatrix;
 280         for(i=0;i<16;i++) p[i+1].f=m[i];
 281
 282         gl_add_op(p);
 283 }
 284
 285 void glPushMatrix(void)
 286 {
 287         GLParam p[1];
 288
 289         p[0].op=OP_PushMatrix;
 290
 291         gl_add_op(p);
 292 }
 293
 294 void glPopMatrix(void)
 295 {
 296         GLParam p[1];
 297
 298         p[0].op=OP_PopMatrix;
 299
 300         gl_add_op(p);
 301 }
 302
 303 void glRotatef(float angle,float x,float y,float z)
 304 {
 305         GLParam p[5];
 306
 307         p[0].op=OP_Rotate;
 308         p[1].f=angle;
 309         p[2].f=x;
 310         p[3].f=y;
 311         p[4].f=z;
 312
 313         gl_add_op(p);
 314 }
 315
 316 void glTranslatef(float x,float y,float z)
 317 {
 318         GLParam p[4];
 319
 320         p[0].op=OP_Translate;
 321         p[1].f=x;
 322         p[2].f=y;
 323         p[3].f=z;
 324
 325         gl_add_op(p);
 326 }
 327
 328 void glScalef(float x,float y,float z)
 329 {
 330         GLParam p[4];
 331
 332         p[0].op=OP_Scale;
 333         p[1].f=x;
 334         p[2].f=y;
 335         p[3].f=z;
 336
 337         gl_add_op(p);
 338 }
 339
 340
 341 void glViewport(int x,int y,int width,int height)
 342 {
 343         GLParam p[5];
 344
 345         p[0].op=OP_Viewport;
 346         p[1].i=x;
 347         p[2].i=y;
 348         p[3].i=width;
 349         p[4].i=height;
 350
 351         gl_add_op(p);
 352 }
 353
 354 void glFrustum(double left,double right,double bottom,double top,
 355                 double near,double farv)
 356 {
 357         GLParam p[7];
 358
 359         p[0].op=OP_Frustum;
 360         p[1].f=left;
 361         p[2].f=right;
 362         p[3].f=bottom;
 363         p[4].f=top;
 364         p[5].f=near;
 365         p[6].f=farv;
 366
 367         gl_add_op(p);
 368 }
 369
 370 /* lightening */
 371
 372 void glMaterialfv(int mode,int type,float *v)
 373 {
 374         GLParam p[7];
 375         int i,n;
 376
 377         assert(mode == GL_FRONT  || mode == GL_BACK || mode==GL_FRONT_AND_BACK);
 378
 379         p[0].op=OP_Material;
 380         p[1].i=mode;
 381         p[2].i=type;
 382         n=4;
 383         if (type == GL_SHININESS) n=1;
 384         for(i=0;i<4;i++) p[3+i].f=v[i];
 385         for(i=n;i<4;i++) p[3+i].f=0;
 386
 387         gl_add_op(p);
 388 }
 389
 390 void glMaterialf(int mode,int type,float v)
 391 {
 392         GLParam p[7];
 393         int i;
 394
 395         p[0].op=OP_Material;
 396         p[1].i=mode;
 397         p[2].i=type;
 398         p[3].f=v;
 399         for(i=0;i<3;i++) p[4+i].f=0;
 400
 401         gl_add_op(p);
 402 }
 403
 404 void glColorMaterial(int mode,int type)
 405 {
 406         GLParam p[3];
 407
 408         p[0].op=OP_ColorMaterial;
 409         p[1].i=mode;
 410         p[2].i=type;
 411
 412         gl_add_op(p);
 413 }
 414
 415 void glLightfv(int light,int type,float *v)
 416 {
 417         GLParam p[7];
 418         int i;
 419
 420         p[0].op=OP_Light;
 421         p[1].i=light;
 422         p[2].i=type;
 423         /* TODO: 3 composants ? */
 424         for(i=0;i<4;i++) p[3+i].f=v[i];
 425
 426         gl_add_op(p);
 427 }
 428
 429
 430 void glLightf(int light,int type,float v)
 431 {
 432         GLParam p[7];
 433         int i;
 434
 435         p[0].op=OP_Light;
 436         p[1].i=light;
 437         p[2].i=type;
 438         p[3].f=v;
 439         for(i=0;i<3;i++) p[4+i].f=0;
 440
 441         gl_add_op(p);
 442 }
 443
 444 void glLightModeli(int pname,int param)
 445 {
 446         GLParam p[6];
 447         int i;
 448
 449         p[0].op=OP_LightModel;
 450         p[1].i=pname;
 451         p[2].f=(float)param;
 452         for(i=0;i<4;i++) p[3+i].f=0;
 453
 454         gl_add_op(p);
 455 }
 456
 457 void glLightModelfv(int pname,float *param)
 458 {
 459         GLParam p[6];
 460         int i;
 461
 462         p[0].op=OP_LightModel;
 463         p[1].i=pname;
 464         for(i=0;i<4;i++) p[2+i].f=param[i];
 465
 466         gl_add_op(p);
 467 }
 468
 469 /* clear */
 470
 471 void glClear(int mask)
 472 {
 473         GLParam p[2];
 474
 475         p[0].op=OP_Clear;
 476         p[1].i=mask;
 477
 478         gl_add_op(p);
 479 }
 480
 481 void glClearColor(float r,float g,float b,float a)
 482 {
 483         GLParam p[5];
 484
 485         p[0].op=OP_ClearColor;
 486         p[1].f=r;
 487         p[2].f=g;
 488         p[3].f=b;
 489         p[4].f=a;
 490
 491         gl_add_op(p);
 492 }
 493
 494 void glClearDepth(double depth)
 495 {
 496         GLParam p[2];
 497
 498         p[0].op=OP_ClearDepth;
 499         p[1].f=depth;
 500
 501         gl_add_op(p);
 502 }
 503
 504
 505 /* textures */
 506
 507 void glTexImage2D( int target, int level, int components,
 508                 int width, int height, int border,
 509                 int format, int type, void *pixels)
 510 {
 511         GLParam p[10];
 512
 513         p[0].op=OP_TexImage2D;
 514         p[1].i=target;
 515         p[2].i=level;
 516         p[3].i=components;
 517         p[4].i=width;
 518         p[5].i=height;
 519         p[6].i=border;
 520         p[7].i=format;
 521         p[8].i=type;
 522         p[9].p=pixels;
 523
 524         gl_add_op(p);
 525 }
 526
 527
 528 void glBindTexture(int target,int texture)
 529 {
 530         GLParam p[3];
 531
 532         p[0].op=OP_BindTexture;
 533         p[1].i=target;
 534         p[2].i=texture;
 535
 536         gl_add_op(p);
 537 }
 538
 539 void glTexEnvi(int target,int pname,int param)
 540 {
 541         GLParam p[8];
 542
 543         p[0].op=OP_TexEnv;
 544         p[1].i=target;
 545         p[2].i=pname;
 546         p[3].i=param;
 547         p[4].f=0;
 548         p[5].f=0;
 549         p[6].f=0;
 550         p[7].f=0;
 551
 552         gl_add_op(p);
 553 }
 554
 555 void glTexParameteri(int target,int pname,int param)
 556 {
 557         GLParam p[8];
 558
 559         p[0].op=OP_TexParameter;
 560         p[1].i=target;
 561         p[2].i=pname;
 562         p[3].i=param;
 563         p[4].f=0;
 564         p[5].f=0;
 565         p[6].f=0;
 566         p[7].f=0;
 567
 568         gl_add_op(p);
 569 }
 570
 571 void glPixelStorei(int pname,int param)
 572 {
 573         GLParam p[3];
 574
 575         p[0].op=OP_PixelStore;
 576         p[1].i=pname;
 577         p[2].i=param;
 578
 579         gl_add_op(p);
 580 }
 581
 582 /* selection */
 583
 584 void glInitNames(void)
 585 {
 586         GLParam p[1];
 587
 588         p[0].op=OP_InitNames;
 589
 590         gl_add_op(p);
 591 }
 592
 593 void glPushName(unsigned int name)
 594 {
 595         GLParam p[2];
 596
 597         p[0].op=OP_PushName;
 598         p[1].i=name;
 599
 600         gl_add_op(p);
 601 }
 602
 603 void glPopName(void)
 604 {
 605         GLParam p[1];
 606
 607         p[0].op=OP_PopName;
 608
 609         gl_add_op(p);
 610 }
 611
 612 void glLoadName(unsigned int name)
 613 {
 614         GLParam p[2];
 615
 616         p[0].op=OP_LoadName;
 617         p[1].i=name;
 618
 619         gl_add_op(p);
 620 }
 621
 622         void
 623 glPolygonOffset(GLfloat factor, GLfloat units)
 624 {
 625         GLParam p[3];
 626         p[0].op = OP_PolygonOffset;
 627         p[1].f = factor;
 628         p[2].f = units;
 629 }
 630
 631 /* Special Functions */
 632
 633 void glCallList(unsigned int list)
 634 {
 635         GLParam p[2];
 636
 637         p[0].op=OP_CallList;
 638         p[1].i=list;
 639
 640         gl_add_op(p);
 641 }
 642
 643 void glFlush(void)
 644 {
 645         /* nothing to do */
 646 }
 647
 648 void glHint(int target,int mode)
 649 {
 650         GLParam p[3];
 651
 652         p[0].op=OP_Hint;
 653         p[1].i=target;
 654         p[2].i=mode;
 655
 656         gl_add_op(p);
 657 }
 658
 659 /* Non standard functions */
 660
 661 void glDebug(int mode)
 662 {
 663         GLContext *c=gl_get_context();
 664         c->print_flag=mode;
 665 }
 666