/*
* Copyright (c) 2001 Dan Gudmundsson
* See the file "license.terms" for information on usage and redistribution
* of this file, and for a DISCLAIMER OF ALL WARRANTIES.
*
* $Id: esdl_glu.c,v 1.3 2005/06/29 14:45:38 dgud Exp $
*
*
* GLU wrapper
*
*/
#include <stdio.h> /* malloc */
#include <stdlib.h> /* malloc */
#include <string.h> /* malloc */
#include <math.h> /* malloc */
#ifdef FLAVOUR_WOGGLE
#include <woggle_driver.h>
#else
#include "esdl.h"
#endif
#ifdef _OSX_COCOA
#include <OpenGL/glu.h>
#else
#include <GL/glu.h>
#endif
#define ASIZE(a) (sizeof(a)/sizeof(a[0]))
typedef struct _tessdata3 * eglu_tessdata_ptr;
typedef struct _tessdata3 {
eglu_tessdata_ptr next;
GLdouble data[3];
} eglu_tessdata;
typedef struct _tessobj {
GLUtesselator *tess;
eglu_tessdata *data;
GLdouble* freep;
GLdouble def_heap[64];
} eglu_tessobj;
#ifndef CALLBACK
# define CALLBACK
#endif
#define ESDL_TESSCB_NONE 0 /* No callback */
#define ESDL_TESSCB_GLBEGIN 1 /* calls gl:begin(Type) */
#define ESDL_TESSCB_GLEND 2 /* calls gl:end() */
#define ESDL_TESSCB_GLVERTEX 3 /* calls gl:3dv(vertex) */
#define ESDL_TESSCB_ERROR_PRINT 4 /* Prints error on stderr. */
#define ESDL_TESSCB_COMBINE 5 /* Adds vertex */
#define ESDL_TESSCB_GLEDGEFLAG 6 /* calls gl:edgeFlag(Flag) */
#define ESDL_TESSCB_UDATA_VERTEX 7 /* calls various gl functions
* depending on user data
*/
#define ESDL_TESSCB_NOP 8 /* does nothing */
#define ESDL_TESS_VTXDATA_MATERIAL 1
#define ESDL_TESS_VTXDATA_TEXCOORD2 2
#define ESDL_TESS_VTXDATA_NORMAL 4
#define ESDL_TESS_VTXDATA_COLOR 8
void CALLBACK esdl_nop_callback(GLboolean flag)
{
}
void CALLBACK errorCallback(GLenum errorCode)
{
const GLubyte *err;
err = gluErrorString(errorCode);
fprintf(stderr, "Tesselation error: %d: %s\r\n", (int)errorCode, err);
}
void CALLBACK esdl_combine(GLdouble coords[3],
void *vertex_data[4],
GLfloat w[4],
void **outData,
void *polygon_data
)
{
int size = 0;
int max = 0;
eglu_tessobj *eobj = polygon_data;
eglu_tessdata* mycoords = NULL;
unsigned char* combined = NULL;
unsigned char* datap[4] = {NULL, NULL, NULL, NULL};
unsigned flags;
flags = ((unsigned char *)vertex_data[0])[-1];
for (max = 0; max < 4 && vertex_data[max] != NULL; max++) {
if (((unsigned char *)vertex_data[max])[-1] != flags) {
flags = 0;
}
datap[max] = (unsigned char *) (((GLdouble *)vertex_data[max])+3);
}
if (flags & ESDL_TESS_VTXDATA_MATERIAL) {
size += 5*4;
}
if (flags & ESDL_TESS_VTXDATA_TEXCOORD2) {
size += 2*4;
}
if (flags & ESDL_TESS_VTXDATA_NORMAL) {
size += 3*4;
}
if (flags & ESDL_TESS_VTXDATA_COLOR) {
size += 2*4;
}
mycoords = (eglu_tessdata*) malloc(sizeof(GLdouble) +
sizeof(eglu_tessdata) + size);
combined = (unsigned char *) (mycoords->data+4);
mycoords->next = eobj->data;
eobj->data = mycoords;
mycoords->data[1] = coords[0];
mycoords->data[2] = coords[1];
mycoords->data[3] = coords[2];
*outData = mycoords->data + 1;
flags = 0;
((char *) (mycoords->data+1))[-1] = flags;
}
void CALLBACK
esdl_udata_vertex(GLdouble* coords)
{
GLfloat* datap = (GLfloat *) (coords+3);
unsigned flags = ((unsigned char *) coords)[-1];
/* fprintf(stderr, "Flags: %d\r\n", flags); */
if (flags & ESDL_TESS_VTXDATA_MATERIAL) {
GLenum face = ((unsigned short *) datap)[0];
GLenum pname = ((unsigned short *) datap)[1];
datap++;
glMaterialfv(face, pname, datap);
datap += 4;
}
if (flags & ESDL_TESS_VTXDATA_TEXCOORD2) {
glTexCoord2fv(datap);
datap += 2;
}
if (flags & ESDL_TESS_VTXDATA_NORMAL) {
glNormal3fv(datap);
datap += 3;
}
if (flags & ESDL_TESS_VTXDATA_COLOR) {
glColor4fv(datap);
datap += 4;
}
glVertex3dv(coords);
}
void eglu_newTess (sdl_data *sd, int len, char * buff)
{
char *bp, *start;
int sendlen;
GLUtesselator* tobj;
eglu_tessobj * eobj;
tobj = gluNewTess();
eobj = (eglu_tessobj *) malloc(sizeof(eglu_tessobj));
eobj->tess = tobj;
eobj->data = NULL;
eobj->freep = eobj->def_heap;
/* fprintf(stderr, "New tess: %d -> %d \r\n", (int) eobj, (int) tobj); */
/*
* Send back result.
*/
bp = start = sdl_get_temp_buff(sd, 8);
/* putPointer(bp, eobj); */
PUSHGLPTR(eobj, bp);
sendlen = bp - start;
sdl_send(sd, sendlen);
}
void eglu_deleteTess (sdl_data *sd, int len, char * buff)
{
char *bp;
eglu_tessobj *eobj;
bp = buff;
POPGLPTR(eobj, bp);
gluDeleteTess(eobj->tess);
free(eobj);
/* fprintf(stderr, "Deleting tess: %d\r\n", (int) eobj); */
}
void eglu_tessBeginPolygon (sdl_data *sd, int len, char* bp)
{
eglu_tessobj *eobj;
POPGLPTR(eobj, bp);
gluTessBeginPolygon(eobj->tess, (void *) eobj);
}
void eglu_tessVertex(sdl_data *sd, int len, char* bp)
{
eglu_tessobj *eobj;
eglu_tessdata* coords;
size_t size;
size_t ndoubles;
size_t nbytes;
char* extrap;
POPGLPTR(eobj, bp);
size = len - 8;
nbytes = sizeof(GLdouble) + sizeof(eglu_tessdata) + size;
ndoubles = (nbytes-1)/sizeof(GLdouble) + 1;
if (ndoubles <= eobj->def_heap+ASIZE(eobj->def_heap)-eobj->freep) {
coords = (eglu_tessdata*) eobj->freep;
eobj->freep += ndoubles;
} else {
coords = (eglu_tessdata*) malloc(nbytes);
coords->next = eobj->data;
eobj->data = coords;
}
memcpy(coords->data+1, bp, size);
extrap = (char *) (coords->data+1);
if (size > 3*sizeof(GLdouble)) {
extrap[-1] = bp[size-1];
} else {
extrap[-1] = 0;
}
/* fprintf(stderr, "tessVertex: %d %g %g %g\r\n", */
/* (int) eobj, coords->data[0], coords->data[1], coords->data[2]); */
gluTessVertex(eobj->tess, coords->data+1, coords->data+1);
}
void eglu_tessEndPolygon (sdl_data *sd, int len, char * buff)
{
char *bp;
eglu_tessobj *eobj;
eglu_tessdata *remove, *temp;
bp = buff;
POPGLPTR(eobj, bp);
gluTessEndPolygon(eobj->tess);
remove = eobj->data;
while (remove != NULL) {
temp = remove->next;
free(remove);
remove = temp;
}
eobj->data = NULL;
eobj->freep = eobj->def_heap;
/* fprintf(stderr, "End Polygon: %d\r\n", (int) eobj); */
}
void eglu_tessCallback(sdl_data *sd, int len, char * buff)
{
char *bp;
eglu_tessobj *eobj;
GLenum *which;
GLint cbId;
GLvoid (CALLBACK *cbfn)();
bp = buff;
POPGLPTR(eobj, bp);
which = (GLenum *) bp; bp += sizeof(GLenum);
cbId = * (GLint *) bp; bp += sizeof(GLint);
switch(*which) {
case GLU_TESS_COMBINE:
*which = GLU_TESS_COMBINE_DATA;
break;
default:
break;
};
switch (cbId) {
case ESDL_TESSCB_NONE:
cbfn = NULL;
break;
case ESDL_TESSCB_GLBEGIN:
cbfn = (GLvoid (CALLBACK *)()) glBegin;
break;
case ESDL_TESSCB_GLEND:
cbfn = (GLvoid (CALLBACK *)()) glEnd;
break;
case ESDL_TESSCB_GLVERTEX:
cbfn = (GLvoid (CALLBACK *)()) glVertex3dv;
break;
case ESDL_TESSCB_GLEDGEFLAG:
cbfn = (GLvoid (CALLBACK *)()) glEdgeFlag;
break;
case ESDL_TESSCB_ERROR_PRINT:
cbfn = (GLvoid (CALLBACK *)()) errorCallback;
break;
case ESDL_TESSCB_COMBINE:
cbfn = (GLvoid (CALLBACK *)()) esdl_combine;
break;
case ESDL_TESSCB_UDATA_VERTEX:
cbfn = (GLvoid (CALLBACK *)()) esdl_udata_vertex;
break;
case ESDL_TESSCB_NOP:
cbfn = (GLvoid (CALLBACK *)()) esdl_nop_callback;
break;
default:
cbfn = NULL;
break;
};
gluTessCallback(eobj->tess, *which, cbfn);
/* fprintf(stderr, "Tess Callback: %d %d\r\n", (int) eobj, *cbId); */
}
void eglu_beginCurve(sdl_data *egl_sd, int egl_len, char *egl_buff)
{
char * bp;
GLUnurbs * nurb;
bp = egl_buff;
POPGLPTR(nurb,bp);
gluBeginCurve(nurb);
}
void eglu_beginSurface(sdl_data *egl_sd, int egl_len, char *egl_buff)
{
char * bp;
GLUnurbs * nurb;
bp = egl_buff;
POPGLPTR(nurb, bp);
gluBeginSurface(nurb);
}
void eglu_beginTrim(sdl_data *egl_sd, int egl_len, char *egl_buff)
{
char * bp;
GLUnurbs * nurb;
bp = egl_buff;
POPGLPTR(nurb, bp);
gluBeginTrim(nurb);
}
void eglu_build1DMipmaps(sdl_data *egl_sd, int egl_len, char *egl_buff)
{
char * bp;
char * egl_start;
int egl_sendlen;
GLint egl_res;
GLenum target;
GLint internalFormat;
GLsizei width;
GLenum format;
GLenum type;
bp = egl_buff;
target = *(GLenum *) bp; bp += sizeof(GLenum);
internalFormat = *(GLint *) bp; bp += sizeof(GLint);
width = *(GLsizei *) bp; bp += sizeof(GLsizei);
format = *(GLenum *) bp; bp += sizeof(GLenum);
type = *(GLenum *) bp; bp += sizeof(GLenum);
if (egl_sd->next_bin == 1) {
GLvoid* data = egl_sd->bin[0].base;
egl_res = gluBuild1DMipmaps(target, internalFormat, width, format, type, data);
sdl_free_binaries(egl_sd);
bp = egl_start = sdl_get_temp_buff(egl_sd, sizeof(GLint));
* (GLint *) bp = egl_res;
bp += sizeof(GLint);
egl_sendlen = bp - egl_start;
sdl_send(egl_sd, egl_sendlen);
}
}
void eglu_build2DMipmaps(sdl_data *egl_sd, int egl_len, char *egl_buff)
{
char * bp;
char * egl_start;
int egl_sendlen;
GLint egl_res;
GLenum * target;
GLint * internalFormat;
GLsizei * width;
GLsizei * height;
GLenum * format;
GLenum * type;
bp = egl_buff;
target = (GLenum *) bp; bp += sizeof(GLenum);
internalFormat = (GLint *) bp; bp += sizeof(GLint);
width = (GLsizei *) bp; bp += sizeof(GLsizei);
height = (GLsizei *) bp; bp += sizeof(GLsizei);
format = (GLenum *) bp; bp += sizeof(GLenum);
type = (GLenum *) bp; bp += sizeof(GLenum);
if (egl_sd->next_bin == 1) {
GLvoid* data = egl_sd->bin[0].base;
egl_res = gluBuild2DMipmaps(*target, *internalFormat, *width,
*height, *format, *type, data);
sdl_free_binaries(egl_sd);
bp = egl_start = sdl_get_temp_buff(egl_sd, sizeof(GLint));
* (GLint *) bp = egl_res;
bp += sizeof(GLint);
egl_sendlen = bp - egl_start;
sdl_send(egl_sd, egl_sendlen);
}
}
void eglu_cylinder(sdl_data *egl_sd, int egl_len, char *egl_buff)
{
char * bp;
GLUquadric * quad;
GLdouble arg[3];
GLint * slices;
GLint * stacks;
bp = egl_buff;
POPGLPTR(quad, bp);
memcpy(arg, bp, sizeof(arg)); bp += sizeof(arg);
slices = (GLint *) bp; bp += sizeof(GLint);
stacks = (GLint *) bp;
gluCylinder(quad, arg[0], arg[1], arg[2], *slices, *stacks);
}
void eglu_deleteNurbsRenderer(sdl_data *egl_sd, int egl_len, char *egl_buff)
{
char * bp;
GLUnurbs * nurb;
bp = egl_buff;
POPGLPTR(nurb, bp);
gluDeleteNurbsRenderer(nurb);
}
void eglu_deleteQuadric(sdl_data *egl_sd, int egl_len, char *egl_buff)
{
char * bp;
GLUquadric * quad;
bp = egl_buff;
POPGLPTR(quad, bp);
gluDeleteQuadric(quad);
}
void eglu_disk(sdl_data *egl_sd, int egl_len, char *egl_buff)
{
char * bp;
GLUquadric * quad;
GLdouble inner;
GLdouble outer;
GLint * slices;
GLint * loops;
bp = egl_buff;
POPGLPTR(quad, bp);
memcpy(&inner, bp, sizeof(GLdouble)); bp += sizeof(GLdouble);
memcpy(&outer, bp, sizeof(GLdouble)); bp += sizeof(GLdouble);
slices = (GLint *) bp; bp += sizeof(GLint);
loops = (GLint *) bp; bp += sizeof(GLint);
gluDisk(quad, inner, outer, *slices, *loops);
}
void eglu_endCurve(sdl_data *egl_sd, int egl_len, char *egl_buff)
{
char * bp;
GLUnurbs * nurb;
bp = egl_buff;
POPGLPTR(nurb, bp);
gluEndCurve(nurb);
}
void eglu_endSurface(sdl_data *egl_sd, int egl_len, char *egl_buff)
{
char * bp;
GLUnurbs * nurb;
bp = egl_buff;
POPGLPTR(nurb, bp);
gluEndSurface(nurb);
}
void eglu_endTrim(sdl_data *egl_sd, int egl_len, char *egl_buff)
{
char * bp;
GLUnurbs * nurb;
bp = egl_buff;
POPGLPTR(nurb, bp);
gluEndTrim(nurb);
}
void eglu_errorString(sdl_data *egl_sd, int egl_len, char *egl_buff)
{
char * bp;
char * egl_start;
int egl_sendlen;
const GLubyte *egl_res;
GLenum * error;
bp = egl_buff;
error = (GLenum *) bp; bp += sizeof(GLenum);
egl_res = gluErrorString(*error);
bp = egl_start = sdl_get_temp_buff(egl_sd, strlen(egl_res));
strcpy((GLubyte *)bp, egl_res);
bp += strlen(egl_res);
egl_sendlen = bp - egl_start;
sdl_send(egl_sd, egl_sendlen);
}
void eglu_getNurbsProperty(sdl_data *egl_sd, int egl_len, char *egl_buff)
{
char * bp;
char * egl_start;
int egl_sendlen;
GLUnurbs * nurb;
GLenum * property;
GLfloat data[1];
bp = egl_buff;
POPGLPTR(nurb,bp);
property = (GLenum *) bp; bp += sizeof(GLenum);
gluGetNurbsProperty(nurb, *property, data);
bp = egl_start = sdl_getbuff(egl_sd, sizeof(GLfloat) *1);
* (GLfloat *)bp = data[0]; bp += sizeof(GLfloat);
egl_sendlen = bp - egl_start;
sdl_send(egl_sd, egl_sendlen);
}
void eglu_getString(sdl_data *egl_sd, int egl_len, char *egl_buff)
{
char * bp;
char * egl_start;
int egl_sendlen;
const GLubyte *egl_res;
GLenum * name;
bp = egl_buff;
name = (GLenum *) bp; bp += sizeof(GLenum);
egl_res = gluGetString(*name);
bp = egl_start = sdl_get_temp_buff(egl_sd, strlen(egl_res));
strcpy((GLubyte *)bp, egl_res);
bp += strlen(egl_res);
egl_sendlen = bp - egl_start;
sdl_send(egl_sd, egl_sendlen);
}
void eglu_getTessProperty(sdl_data *egl_sd, int egl_len, char *egl_buff)
{
char * bp;
char * egl_start;
int egl_sendlen;
eglu_tessobj * tess;
GLenum * which;
GLdouble data[1];
bp = egl_buff;
POPGLPTR(tess,bp);
which = (GLenum *) bp; bp += sizeof(GLenum);
gluGetTessProperty(tess->tess, *which, data);
bp = egl_start = sdl_get_temp_buff(egl_sd, sizeof(GLdouble) *1);
memcpy(bp,data,sizeof(GLdouble)); bp += sizeof(GLdouble),
egl_sendlen = bp - egl_start;
sdl_send(egl_sd, egl_sendlen);
}
void eglu_loadSamplingMatrices(sdl_data *egl_sd, int egl_len, char *egl_buff)
{
char * bp;
GLUnurbs * nurb;
GLfloat * model;
GLfloat * perspective;
GLint * view;
bp = egl_buff;
POPGLPTR(nurb, bp);
model = (GLfloat *) bp; bp += sizeof(GLfloat)*16;
perspective = (GLfloat *) bp; bp += sizeof(GLfloat)*16;
view = (GLint *) bp; bp += sizeof(GLint)*16;
gluLoadSamplingMatrices(nurb, model, perspective, view);
}
void eglu_lookAt(sdl_data *egl_sd, int egl_len, char *egl_buff)
{
char * bp;
GLdouble data[9];
bp = egl_buff;
memcpy(data, bp, sizeof(GLdouble)*9); bp += sizeof(GLdouble)*9;
gluLookAt(data[0],data[1],data[2],
data[3],data[4],data[5],
data[6],data[7],data[8]);
}
void eglu_newNurbsRenderer(sdl_data *egl_sd, int egl_len, char *egl_buff)
{
char * bp;
char * egl_start;
int egl_sendlen;
GLUnurbs *egl_res;
bp = egl_buff;
egl_res = gluNewNurbsRenderer();
bp = egl_start = sdl_get_temp_buff(egl_sd, 8);
PUSHGLPTR(egl_res, bp);
egl_sendlen = bp - egl_start;
sdl_send(egl_sd, egl_sendlen);
}
void eglu_newQuadric(sdl_data *egl_sd, int egl_len, char *egl_buff)
{
char * bp;
char * egl_start;
int egl_sendlen;
GLUquadric *egl_res;
bp = egl_buff;
egl_res = gluNewQuadric();
bp = egl_start = sdl_get_temp_buff(egl_sd, 8);
PUSHGLPTR(egl_res, bp);
egl_sendlen = bp - egl_start;
sdl_send(egl_sd, egl_sendlen);
}
void eglu_nurbsCurve(sdl_data *egl_sd, int egl_len, char *egl_buff)
{
char * bp;
GLUnurbs * nurb;
GLint knotCount;
GLfloat * knots = NULL;
GLint * stride;
GLfloat * control = NULL;
GLint * order;
GLenum * type;
bp = egl_buff;
POPGLPTR(nurb, bp);
knotCount = * (GLint *) bp; bp += sizeof(GLint);
knots = (GLfloat *) bp; bp += sizeof(GLfloat)*(knotCount);
stride = (GLint *) bp; bp += sizeof(GLint);
order = (GLint *) bp; bp += sizeof(GLint);
type = (GLenum *) bp; bp += sizeof(GLenum);
if (egl_sd->next_bin == 1) {
control = (GLfloat *) egl_sd->bin[0].base;
gluNurbsCurve(nurb, knotCount, knots, *stride, control, *order, *type);
sdl_free_binaries(egl_sd);
}
}
void eglu_nurbsProperty(sdl_data *egl_sd, int egl_len, char *egl_buff)
{
char * bp;
GLUnurbs * nurb;
GLenum * property;
GLfloat * value;
bp = egl_buff;
POPGLPTR(nurb, bp);
property = (GLenum *) bp; bp += sizeof(GLenum);
value = (GLfloat *) bp; bp += sizeof(GLfloat);
gluNurbsProperty(nurb, *property, *value);
}
void eglu_nurbsSurface(sdl_data *egl_sd, int egl_len, char *egl_buff)
{
char * bp;
GLUnurbs * nurb;
GLint sKnotCount;
GLfloat * sKnots = NULL;
GLint tKnotCount;
GLfloat * tKnots = NULL;
GLint * sStride;
GLint * tStride;
GLfloat * control = NULL;
GLint * sOrder;
GLint * tOrder;
GLenum * type;
bp = egl_buff;
POPGLPTR(nurb, bp);
sKnotCount = * (GLint *) bp; bp += sizeof(GLint);
sKnots = (GLfloat *) bp; bp += sizeof(GLfloat)*(sKnotCount);
tKnotCount = *(GLint *) bp; bp += sizeof(GLint);
tKnots = (GLfloat *) bp; bp += sizeof(GLfloat)*(tKnotCount);
sStride = (GLint *) bp; bp += sizeof(GLint);
tStride = (GLint *) bp; bp += sizeof(GLint);
sOrder = (GLint *) bp; bp += sizeof(GLint);
tOrder = (GLint *) bp; bp += sizeof(GLint);
type = (GLenum *) bp; bp += sizeof(GLenum);
if (egl_sd->next_bin == 1) {
control = (GLfloat *) egl_sd->bin[0].base;
gluNurbsSurface(nurb, sKnotCount, sKnots, tKnotCount, tKnots,
*sStride, *tStride, control, *sOrder, *tOrder, *type);
sdl_free_binaries(egl_sd);
}
}
void eglu_ortho2D(sdl_data *egl_sd, int egl_len, char *bp)
{
GLdouble arg[4];
memcpy(arg, bp, sizeof(arg));
gluOrtho2D(arg[0], arg[1], arg[2], arg[3]);
}
void eglu_partialDisk(sdl_data *egl_sd, int egl_len, char *egl_buff)
{
char * bp;
GLUquadric * quad;
GLdouble inner;
GLdouble outer;
GLint * slices;
GLint * loops;
GLdouble start;
GLdouble sweep;
bp = egl_buff;
POPGLPTR(quad, bp);
memcpy(&inner, bp, sizeof(GLdouble)); bp += sizeof(GLdouble);
memcpy(&outer, bp, sizeof(GLdouble)); bp += sizeof(GLdouble);
slices = (GLint *) bp; bp += sizeof(GLint);
loops = (GLint *) bp; bp += sizeof(GLint);
memcpy(&start, bp, sizeof(GLdouble)); bp += sizeof(GLdouble);
memcpy(&sweep, bp, sizeof(GLdouble)); bp += sizeof(GLdouble);
gluPartialDisk(quad, inner, outer, *slices, *loops, start, sweep);
}
void eglu_perspective(sdl_data *egl_sd, int egl_len, char *bp)
{
GLdouble arg[4];
memcpy(arg, bp, sizeof(arg));
gluPerspective(arg[0], arg[1], arg[2], arg[3]);
}
void eglu_pickMatrix(sdl_data *egl_sd, int egl_len, char *bp)
{
GLdouble arg[4];
GLint* viewport;
memcpy(arg, bp, sizeof(arg)); bp += sizeof(arg);
viewport = (GLint *) bp;
gluPickMatrix(arg[0], arg[1], arg[2], arg[3], viewport);
}
void eglu_project(sdl_data *egl_sd, int egl_len, char *bp)
{
GLint egl_res;
GLdouble arg[3+16+16];
GLint* view;
GLdouble res[3];
memcpy(arg, bp, sizeof(arg)); bp += sizeof(arg);
view = (GLint *) bp;
egl_res = gluProject(arg[0], arg[1], arg[2], arg+3, arg+3+16, view,
res+0, res+1, res+2);
if (egl_res) {
bp = sdl_get_temp_buff(egl_sd, sizeof(res));
memcpy(bp, res, sizeof(res));
sdl_send(egl_sd, sizeof(res));
}
}
void eglu_pwlCurve(sdl_data *egl_sd, int egl_len, char *egl_buff)
{
char * bp;
GLUnurbs * nurb;
GLint * count;
GLfloat * data = NULL;
GLint * stride;
GLenum * type;
bp = egl_buff;
POPGLPTR(nurb, bp);
count = (GLint *) bp; bp += sizeof(GLint);
stride = (GLint *) bp; bp += sizeof(GLint);
type = (GLenum *) bp; bp += sizeof(GLenum);
gluPwlCurve(nurb, *count, data, *stride, *type);
if (egl_sd->next_bin == 1) {
data = (GLfloat *) egl_sd->bin[0].base;
gluPwlCurve(nurb, *count, data, *stride, *type);
sdl_free_binaries(egl_sd);
}
}
void eglu_quadricDrawStyle(sdl_data *egl_sd, int egl_len, char *egl_buff)
{
char * bp;
GLUquadric * quad;
GLenum * draw;
bp = egl_buff;
POPGLPTR(quad, bp);
draw = (GLenum *) bp; bp += sizeof(GLenum);
gluQuadricDrawStyle(quad, *draw);
}
void eglu_quadricNormals(sdl_data *egl_sd, int egl_len, char *egl_buff)
{
char * bp;
GLUquadric * quad;
GLenum * normal;
bp = egl_buff;
POPGLPTR(quad, bp);
normal = (GLenum *) bp; bp += sizeof(GLenum);
gluQuadricNormals(quad, *normal);
}
void eglu_quadricOrientation(sdl_data *egl_sd, int egl_len, char *egl_buff)
{
char * bp;
GLUquadric * quad;
GLenum * orientation;
bp = egl_buff;
POPGLPTR(quad, bp);
orientation = (GLenum *) bp; bp += sizeof(GLenum);
gluQuadricOrientation(quad, *orientation);
}
void eglu_quadricTexture(sdl_data *egl_sd, int egl_len, char *egl_buff)
{
char * bp;
GLUquadric * quad;
GLboolean * texture;
bp = egl_buff;
POPGLPTR(quad, bp);
texture = (GLboolean *) bp; bp += sizeof(GLboolean);
gluQuadricTexture(quad, *texture);
}
void eglu_scaleImage(sdl_data *egl_sd, int egl_len, char *egl_buff)
{
char * bp;
char * egl_start;
int egl_sendlen;
GLint egl_res;
GLenum * format;
GLsizei * wIn;
GLsizei * hIn;
GLenum * typeIn;
GLsizei * wOut;
GLsizei * hOut;
GLenum * typeOut;
bp = egl_buff;
format = (GLenum *) bp; bp += sizeof(GLenum);
wIn = (GLsizei *) bp; bp += sizeof(GLsizei);
hIn = (GLsizei *) bp; bp += sizeof(GLsizei);
typeIn = (GLenum *) bp; bp += sizeof(GLenum);
wOut = (GLsizei *) bp; bp += sizeof(GLsizei);
hOut = (GLsizei *) bp; bp += sizeof(GLsizei);
typeOut = (GLenum *) bp; bp += sizeof(GLenum);
if (egl_sd->next_bin == 2) {
void* dataIn = egl_sd->bin[0].base;
void* dataOut = egl_sd->bin[1].base;
egl_res = gluScaleImage(*format, *wIn, *hIn, *typeIn, dataIn,
*wOut, *hOut, *typeOut, dataOut);
sdl_free_binaries(egl_sd);
bp = egl_start = sdl_get_temp_buff(egl_sd, sizeof(GLint));
* (GLint *) bp = egl_res;
bp += sizeof(GLint);
egl_sendlen = bp - egl_start;
sdl_send(egl_sd, egl_sendlen);
}
}
void eglu_sphere(sdl_data *egl_sd, int egl_len, char *egl_buff)
{
char * bp;
GLUquadric * quad;
GLdouble radius;
GLint * slices;
GLint * stacks;
bp = egl_buff;
POPGLPTR(quad, bp);
memcpy(&radius, bp, sizeof(GLdouble)); bp += sizeof(GLdouble);
slices = (GLint *) bp; bp += sizeof(GLint);
stacks = (GLint *) bp; bp += sizeof(GLint);
gluSphere(quad, radius, *slices, *stacks);
}
void eglu_tessBeginContour(sdl_data *egl_sd, int egl_len, char *egl_buff)
{
char * bp;
eglu_tessobj * tess;
bp = egl_buff;
POPGLPTR(tess, bp);
gluTessBeginContour(tess->tess);
}
void eglu_tessEndContour(sdl_data *egl_sd, int egl_len, char *egl_buff)
{
char * bp;
eglu_tessobj * tess;
bp = egl_buff;
POPGLPTR(tess, bp);
gluTessEndContour(tess->tess);
/* fprintf(stderr, "Begin Contour: %d\r\n", (int) tess); */
}
void eglu_tessNormal(sdl_data *egl_sd, int egl_len, char *bp)
{
eglu_tessobj* tess;
GLdouble values[3];
POPGLPTR(tess, bp);
memcpy(values, bp, sizeof(values));
gluTessNormal(tess->tess, values[0], values[1], values[2]);
}
void eglu_tessProperty(sdl_data *egl_sd, int egl_len, char *egl_buff)
{
char * bp;
eglu_tessobj * tess;
GLenum * which;
GLdouble data;
bp = egl_buff;
POPGLPTR(tess, bp);
which = (GLenum *) bp; bp += sizeof(GLenum);
memcpy(&data, bp, sizeof(GLdouble)); bp += sizeof(GLdouble);
gluTessProperty(tess->tess, *which, data);
}
void eglu_unProject(sdl_data *egl_sd, int egl_len, char *bp)
{
GLint egl_res;
GLdouble arg[3+16+16];
GLdouble res[3];
GLint* view;
memcpy(arg, bp, sizeof(arg)); bp += sizeof(arg);
view = (GLint *) bp;
egl_res = gluUnProject(arg[0], arg[1], arg[2], arg+3, arg+3+16, view,
res+0, res+1, res+2);
if (egl_res) {
bp = sdl_get_temp_buff(egl_sd, sizeof(res));
memcpy(bp, res, sizeof(res));
sdl_send(egl_sd, sizeof(res));
}
}
syntax highlighted by Code2HTML, v. 0.9.1