Acme-MITHALDU-BleedingOpenGL
view release on metacpan or search on metacpan
pogl_glu.xs view on Meta::CPAN
AV * vertex_datas;
AV * tess_datas;
};
typedef struct PGLUtess PGLUtess;
#define delete_vertex_datas() \
if (tess->vertex_datas) { \
AV * vds = tess->vertex_datas; \
SV** svp; \
I32 i; \
for (i=0; i<=av_len(vds); i++) { \
svp = av_fetch(vds, i, FALSE); \
free(INT2PTR(GLdouble*, SvIV(*svp))); \
} \
SvREFCNT_dec(tess->vertex_datas); \
tess->vertex_datas = 0; \
}
#define delete_tess_datas() \
if (tess->tess_datas) { \
AV * tds = tess->tess_datas; \
SV** svp; \
I32 i; \
for (i=0; i<=av_len(tds); i++) { \
svp = av_fetch(tds, i, FALSE); \
free(INT2PTR(PGLUtess*, SvIV(*svp))); \
} \
SvREFCNT_dec(tess->tess_datas); \
tess->tess_datas = 0; \
}
#define delete_polygon_data() \
if (tess->polygon_data) { \
SvREFCNT_dec(tess->polygon_data); \
tess->polygon_data = 0; \
}
#ifdef GLU_VERSION_1_2
/* Begin a named callback handler */
#define begin_tess_marshaller(name, type, params, croak_msg, default_handler) \
void CALLBACK _s_marshal_glu_t_callback_ ## name params \
{ \
dSP; \
int i; int j = 3; \
PGLUtess * t = (PGLUtess*)gl_polygon_data; \
SV * handler = t-> type ## _callback; \
if (!handler) croak(croak_msg); \
if (! SvROK(handler)) { /* default */ \
default_handler; \
return; \
} \
PUSHMARK(sp);
/* End a gluTess callback handler */
#define end_tess_marshaller() \
PUTBACK; \
perl_call_sv(handler, G_DISCARD); \
}
/* Declare gluTess BEGIN */
begin_tess_marshaller(begin, begin, (GLenum type, void * gl_polygon_data), "Missing tess callback for begin", glBegin(type))
XPUSHs(sv_2mortal(newSViv(type)));
end_tess_marshaller()
/* Declare gluTess BEGIN_DATA */
begin_tess_marshaller(begin_data, begin, (GLenum type, void * gl_polygon_data), "Missing tess callback for begin_data", glBegin(type))
XPUSHs(sv_2mortal(newSViv(type)));
if (t->polygon_data) XPUSHs((SV*)t->polygon_data);
end_tess_marshaller()
/* Declare gluTess END */
begin_tess_marshaller(end, end, (void * gl_polygon_data), "Missing tess callback for end", glEnd())
end_tess_marshaller()
/* Declare gluTess END_DATA */
begin_tess_marshaller(end_data, end, (void * gl_polygon_data), "Missing tess callback for end_data", glEnd())
if (t->polygon_data) XPUSHs((SV*)t->polygon_data);
end_tess_marshaller()
/* Declare gluTess EDGEFLAG */
begin_tess_marshaller(edgeFlag, edgeFlag, (GLboolean flag, void * gl_polygon_data), "Missing tess callback for edgeFlag", glEdgeFlag(flag))
XPUSHs(sv_2mortal(newSViv(flag)));
end_tess_marshaller()
/* Declare gluTess EDGEFLAG_DATA */
begin_tess_marshaller(edgeFlag_data, edgeFlag, (GLboolean flag, void * gl_polygon_data), "Missing tess callback for edgeFlag_data", glEdgeFlag(flag))
XPUSHs(sv_2mortal(newSViv(flag)));
if (t->polygon_data) XPUSHs((SV*)t->polygon_data);
end_tess_marshaller()
/* Declare gluTess VERTEX */
begin_tess_marshaller(vertex, vertex, (void * gl_polygon_data), "Missing tess callback for vertex", \
GLdouble * vd = t->vertex_data; \
if (t->do_colors) { \
glColor4f(vd[j], vd[j+1], vd[j+2], vd[j+3]); \
j += 4; \
} \
if (t->do_normals) glNormal3f(vd[j], vd[j+1], vd[j+2]); \
glVertex3f(vd[0], vd[1], vd[2]); \
)
{
GLdouble * vd = (GLdouble*) t->vertex_data;
for (i = 0; i < 3; i++)
XPUSHs(sv_2mortal(newSVnv(vd[i])));
if (t->do_colors) {
int J = j + 4;
for ( ; j < J; j++)
XPUSHs(sv_2mortal(newSVnv(vd[j])));
}
if (t->do_normals)
for (i = 0; i < 3; i++)
XPUSHs(sv_2mortal(newSVnv(vd[j++])));
if (t->polygon_data) XPUSHs((SV*)t->polygon_data);
}
end_tess_marshaller()
pogl_glu.xs view on Meta::CPAN
av_push(t->tess_datas, newSViv(PTR2IV(opaque)));
*out_data = opaque;
for (i = 0; i < 4; i++) {
PGLUtess* ot = (PGLUtess*)vertex_data[i];
vd[i] = (GLdouble*)ot->vertex_data;
}
} else {
*out_data = vertex;
for (i = 0; i < 4; i++)
vd[i] = (GLdouble*)vertex_data[i];
}
if (! SvROK(handler)) { /* default */
vertex[0] = coords[0];
vertex[1] = coords[1];
vertex[2] = coords[2];
if (t->do_colors) {
int J = j + 4;
for ( ; j < J; j++) {
vertex[j] = 0;
for (i = 0; i < 4; i++)
if (weight[i]) vertex[j] += weight[i] * vd[i][j];
}
}
if (t->do_normals) {
int J = j + 3;
for ( ; j < J; j++) {
vertex[j] = 0;
for (i = 0; i < 4; i++)
if (weight[i]) vertex[j] += weight[i] * vd[i][j];
}
}
} else {
PUSHMARK(sp);
for (i = 0; i < 3; i++)
XPUSHs(sv_2mortal(newSVnv(coords[i])));
for (i = 0; i < 4; i++) {
AV* vec = (AV*)sv_2mortal((SV*)newAV());
XPUSHs(newRV_inc((SV*)vec));
for (j = 0 ; j < 3; j++)
av_push(vec, sv_2mortal(newSVnv(weight[i] ? vd[i][j] : 0)));
if (t->do_colors) {
int J = j + 4;
for ( ; j < J; j++)
av_push(vec, sv_2mortal(newSVnv(weight[i] ? vd[i][j] : 0)));
}
if (t->do_normals) {
int J = j + 3;
for ( ; j < J; j++)
av_push(vec, sv_2mortal(newSVnv(weight[i] ? vd[i][j] : 0)));
}
if (t->use_vertex_data) {
PGLUtess* ot = (PGLUtess*)vertex_data[i];
av_push(vec, ot->polygon_data ? ot->polygon_data : &PL_sv_undef);
}
}
for (i = 0; i < 4; i++)
XPUSHs(sv_2mortal(newSVnv(weight[i])));
XPUSHs(t->polygon_data ? t->polygon_data : &PL_sv_undef); /* would be nice to have the option to only do this on COMBINE_DATA */
PUTBACK;
n = perl_call_sv(handler, G_ARRAY);
SPAGAIN;
if (t->do_colors) {
if (t->do_normals) {
if (n == 11 && t->use_vertex_data) has_data = TRUE;
else if (n != 10) {
if (t->use_vertex_data) croak("Callback expects (x,y,z, r,g,b,a, nx,ny,nz [,polygon_data])");
else croak("Callback expects (x,y,z, r,g,b,a, nx,ny,nz)");
}
} else {
if (n == 8 && t->use_vertex_data) has_data = TRUE;
else if (n != 7) {
if (t->use_vertex_data) croak("Callback expects (x,y,z, r,g,b,a [,polygon_data])");
else croak("Callback expects (x,y,z, r,g,b,a)");
}
}
} else {
if (t->do_normals) {
if (n == 7 && t->use_vertex_data) has_data = TRUE;
else if (n != 6) {
if (t->use_vertex_data) croak("Callback expects (x,y,z, nx,ny,nz [,polygon_data])");
else croak("Callback expects (x,y,z, nx,ny,nz)");
}
} else {
if (n == 4 && t->use_vertex_data) has_data = TRUE;
else if (n != 3) {
if (t->use_vertex_data) croak("Callback expects (x,y,z [,polygon_data])");
else croak("Callback expects (x,y,z)");
}
}
}
if (t->use_vertex_data) {
PGLUtess* opaque = (PGLUtess*)*out_data;
opaque->polygon_data = (has_data) ? POPs : 0;
}
for (i = n - (has_data ? 2 : 1); i >= 0; i--) {
GLdouble val;
item = POPs;
if (! item || (! SvIOK(item) && ! SvNOK(item)))
croak("Value returned in index %d was not a valid number", i);
val = (GLdouble)SvNV(item);
vertex[i] = val;
}
PUTBACK;
}
}
#endif
#endif /* End IN_POGL_GLU_XS */
MODULE = Acme::MITHALDU::BleedingOpenGL::GLU PACKAGE = Acme::MITHALDU::BleedingOpenGL
#ifdef IN_POGL_GLU_XS
##################### GLU #########################
#ifdef HAVE_GLU
#// $nurb->gluBeginCurve($nurb);
void
gluBeginCurve(nurb)
GLUnurbsObj * nurb
#// gluEndCurve($nurb);
void
gluEndCurve(nurb)
GLUnurbsObj * nurb
#// gluBeginPolygon($tess);
void
gluBeginPolygon(tess)
PGLUtess * tess
CODE:
gluBeginPolygon(tess->triangulator);
#// gluEndPolygon($tess);
void
gluEndPolygon(tess)
PGLUtess * tess
CODE:
gluEndPolygon(tess->triangulator);
#// gluBeginSurface($nurb);
void
gluBeginSurface(nurb)
GLUnurbsObj * nurb
#// gluEndSurface($nurb);
void
gluEndSurface(nurb)
GLUnurbsObj * nurb
#// gluBeginTrim($nurb);
void
gluBeginTrim(nurb)
GLUnurbsObj * nurb
#// gluEndTrim($nurb);
void
gluEndTrim(nurb)
GLUnurbsObj * nurb
#//# gluBuild1DMipmaps_c($target, $internalformat, $width, $format, $type, (CPTR)data);
GLint
gluBuild1DMipmaps_c(target, internalformat, width, format, type, data)
GLenum target
GLuint internalformat
GLsizei width
GLenum format
GLenum type
void * data
CODE:
{
RETVAL=gluBuild1DMipmaps(target, internalformat,
width, format, type, data);
}
OUTPUT:
RETVAL
#//# gluBuild1DMipmaps_s($target, $internalformat, $width, $format, $type, (PACKED)data);
GLint
gluBuild1DMipmaps_s(target, internalformat, width, format, type, data)
GLenum target
GLuint internalformat
GLsizei width
GLenum format
GLenum type
SV * data
CODE:
{
GLvoid * ptr = ELI(data, width, 1, format, type, gl_pixelbuffer_unpack);
RETVAL=gluBuild1DMipmaps(target, internalformat, width, format, type, ptr);
}
OUTPUT:
RETVAL
#//# gluBuild2DMipmaps_c($target, $internalformat, $width, $height, $format, $type, (CPTR)data);
GLint
gluBuild2DMipmaps_c(target, internalformat, width, height, format, type, data)
GLenum target
GLuint internalformat
GLsizei width
GLsizei height
GLenum format
GLenum type
void * data
CODE:
{
RETVAL=gluBuild2DMipmaps(target, internalformat,
width, height, format, type, data);
}
OUTPUT:
RETVAL
#//# gluBuild2DMipmaps_s($target, $internalformat, $width, $height, $format, $type, (PACKED)data);
GLint
gluBuild2DMipmaps_s(target, internalformat, width, height, format, type, data)
GLenum target
GLuint internalformat
GLsizei width
GLsizei height
GLenum format
GLenum type
SV * data
CODE:
{
GLvoid * ptr = ELI(data, width, height, format, type, gl_pixelbuffer_unpack);
RETVAL=gluBuild2DMipmaps(target, internalformat, width, height, format, type, ptr);
}
OUTPUT:
RETVAL
#// gluCylinder($quad, $base, $top, $height, $slices, $stacks);
void
gluCylinder(quad, base, top, height, slices, stacks)
GLUquadricObj * quad
GLdouble base
GLdouble top
GLdouble height
GLint slices
GLint stacks
#// gluDeleteNurbsRenderer($nurb);
void
gluDeleteNurbsRenderer(nurb)
GLUnurbsObj * nurb
#// gluDeleteQuadric($quad);
void
gluDeleteQuadric(quad)
GLUquadricObj * quad
#// gluDeleteTess($tess);
void
gluDeleteTess(tess)
PGLUtess * tess
CODE:
{
if (tess->triangulator)
gluDeleteTess(tess->triangulator);
#ifdef GLU_VERSION_1_2
if (tess->begin_callback)
SvREFCNT_dec(tess->begin_callback);
if (tess->edgeFlag_callback)
SvREFCNT_dec(tess->edgeFlag_callback);
if (tess->vertex_callback)
SvREFCNT_dec(tess->vertex_callback);
if (tess->end_callback)
SvREFCNT_dec(tess->end_callback);
if (tess->error_callback)
SvREFCNT_dec(tess->error_callback);
if (tess->combine_callback)
SvREFCNT_dec(tess->combine_callback);
#endif
delete_vertex_datas()
delete_tess_datas()
delete_polygon_data()
free(tess);
}
#// gluDisk($quad, $inner, $outer, $slices, $loops);
void
gluDisk(quad, inner, outer, slices, loops)
GLUquadricObj * quad
GLdouble inner
GLdouble outer
GLint slices
GLint loops
#//# gluErrorString($error);
char *
gluErrorString(error)
GLenum error
CODE:
RETVAL = (char*)gluErrorString(error);
OUTPUT:
RETVAL
#// gluGetNurbsProperty_p($nurb, $property);
GLfloat
gluGetNurbsProperty_p(nurb, property)
GLUnurbsObj * nurb
GLenum property
CODE:
{
GLfloat param;
gluGetNurbsProperty(nurb, property, ¶m);
RETVAL = param;
}
OUTPUT:
RETVAL
#// gluNurbsProperty(nurb, property, value);
void
gluNurbsProperty(nurb, property, value)
GLUnurbsObj * nurb
GLenum property
GLfloat value
#ifdef GLU_VERSION_1_1
#//# gluGetString($name);
char *
gluGetString(name)
GLenum name
CODE:
RETVAL = (char*)gluGetString(name);
OUTPUT:
RETVAL
#endif
#// gluLoadSamplingMatrices_p(nurb, m1,m2,m3,m4,m5,m6,m7,m8,m9,m10,m11,m12,m13,m14,m15,m16, o1,o2,o3,o4,o5,o6,o7,o8,o9,o10,o11,o12,o13,o14,o15,o16, v1,v2,v3,v4);
void
gluLoadSamplingMatrices_p(nurb, m1,m2,m3,m4,m5,m6,m7,m8,m9,m10,m11,m12,m13,m14,m15,m16, o1,o2,o3,o4,o5,o6,o7,o8,o9,o10,o11,o12,o13,o14,o15,o16, v1,v2,v3,v4)
GLUnurbsObj * nurb
CODE:
{
GLfloat m[16], p[16];
GLint v[4];
int i;
for (i=0;i<16;i++)
m[i] = (GLfloat)SvNV(ST(i+1));
for (i=0;i<16;i++)
p[i] = (GLfloat)SvNV(ST(i+1+16));
for (i=0;i<4;i++)
v[i] = SvIV(ST(i+1+16+16));
gluLoadSamplingMatrices(nurb, m, p, v);
}
#//# gluLookAt($eyeX, $eyeY, $eyeZ, $centerX, $centerY, $centerZ, $upX, $upY, $upZ);
void
gluLookAt(eyeX, eyeY, eyeZ, centerX, centerY, centerZ, upX, upY, upZ)
GLdouble eyeX
GLdouble eyeY
GLdouble eyeZ
GLdouble centerX
GLdouble centerY
GLdouble centerZ
GLdouble upX
GLdouble upY
GLdouble upZ
#// gluNewNurbsRenderer();
GLUnurbsObj *
gluNewNurbsRenderer()
#// gluNewQuadric();
GLUquadricObj *
gluNewQuadric()
#// gluNewTess();
PGLUtess *
gluNewTess(...)
CODE:
{
RETVAL = malloc(sizeof(PGLUtess));
memset(RETVAL, 0, sizeof(PGLUtess));
RETVAL->do_colors = (items > 0) ? SvTRUE(ST(0)) : FALSE;
RETVAL->do_normals = (items > 1) ? SvTRUE(ST(1)) : FALSE;
RETVAL->triangulator = gluNewTess();
}
OUTPUT:
RETVAL
#// gluNextContour(tess, type);
void
gluNextContour(tess, type)
PGLUtess * tess
GLenum type
CODE:
gluNextContour(tess->triangulator, type);
#// gluNurbsCurve_c(nurb, nknots, knot, stride, ctlarray, order, type);
void
gluNurbsCurve_c(nurb, nknots, knot, stride, ctlarray, order, type)
GLUnurbsObj * nurb
GLint nknots
void * knot
GLint stride
void * ctlarray
GLint order
GLenum type
CODE:
gluNurbsCurve(nurb, nknots, knot, stride, ctlarray, order, type);
#// gluNurbsSurface_c(nurb, sknot_count, sknot, tknot_count, tknot, s_stride, t_stride, ctrlarray, sorder, torder, type);
void
gluNurbsSurface_c(nurb, sknot_count, sknot, tknot_count, tknot, s_stride, t_stride, ctrlarray, sorder, torder, type)
GLUnurbsObj * nurb
GLint sknot_count
void * sknot
GLint tknot_count
void * tknot
GLint s_stride
GLint t_stride
void * ctrlarray
GLint sorder
GLint torder
GLenum type
CODE:
gluNurbsSurface(nurb, sknot_count, sknot, tknot_count, tknot, s_stride, t_stride, ctrlarray, sorder, torder, type);
#//# gluOrtho2D($left, $right, $bottom, $top);
void
gluOrtho2D(left, right, bottom, top)
GLdouble left
GLdouble right
GLdouble bottom
GLdouble top
#// gluPartialDisk(quad, inner, outer, slices, loops, start, sweep);
void
gluPartialDisk(quad, inner, outer, slices, loops, start, sweep)
GLUquadricObj* quad
GLdouble inner
GLdouble outer
GLint slices
GLint loops
GLdouble start
GLdouble sweep
#//# gluPerspective($fovy, $aspect, $zNear, $zFar);
pogl_glu.xs view on Meta::CPAN
}
#// gluPwlCurve_c(nurb, count, data, stride, type);
void
gluPwlCurve_c(nurb, count, data, stride, type)
GLUnurbsObj * nurb
GLint count
void * data
GLint stride
GLenum type
CODE:
gluPwlCurve(nurb, count, data, stride, type);
#// gluQuadricDrawStyle(quad, draw);
void
gluQuadricDrawStyle(quad, draw)
GLUquadricObj * quad
GLenum draw
#// gluQuadricNormals(quad, normal);
void
gluQuadricNormals(quad, normal)
GLUquadricObj * quad
GLenum normal
#// gluQuadricOrientation(quad, orientation);
void
gluQuadricOrientation(quad, orientation)
GLUquadricObj * quad
GLenum orientation
#// gluQuadricTexture(quad, texture);
void
gluQuadricTexture(quad, texture)
GLUquadricObj * quad
GLboolean texture
#//# gluScaleImage_s($format, $wIn, $hIn, $typeIn, (PACKED)dataIn, $wOut, $hOut, $typeOut, (PACKED)dataOut);
GLint
gluScaleImage_s(format, wIn, hIn, typeIn, dataIn, wOut, hOut, typeOut, dataOut)
GLenum format
GLsizei wIn
GLsizei hIn
GLenum typeIn
SV * dataIn
GLsizei wOut
GLsizei hOut
GLenum typeOut
SV * dataOut
CODE:
{
GLvoid * inptr, * outptr;
STRLEN discard;
ELI(dataIn, wIn, hIn, format, typeIn, gl_pixelbuffer_unpack);
ELI(dataOut, wOut, hOut, format, typeOut, gl_pixelbuffer_pack);
inptr = SvPV(dataIn, discard);
outptr = SvPV(dataOut, discard);
RETVAL = gluScaleImage(format, wIn, hIn, typeIn, inptr, wOut, hOut, typeOut, outptr);
}
OUTPUT:
RETVAL
#// gluSphere(quad, radius, slices, stacks);
void
gluSphere(quad, radius, slices, stacks)
GLUquadricObj * quad
GLdouble radius
GLint slices
GLint stacks
#ifdef GLU_VERSION_1_2
#// gluGetTessProperty_p(tess, property);
GLdouble
gluGetTessProperty_p(tess, property)
PGLUtess * tess
GLenum property
CODE:
{
GLdouble param;
gluGetTessProperty(tess->triangulator, property, ¶m);
RETVAL = param;
}
OUTPUT:
RETVAL
#// #gluNurbsCallback_p(nurb, which, handler, ...);
#void
#gluNurbsCallback_p(nurb, which, handler, ...)
#// gluNurbsCallbackDataEXT
#void
#gluNurbsCallbackDataEXT
#// gluQuadricCallback
#void
#gluQuadricCallback
#// gluTessBeginContour(tess);
void
gluTessBeginContour(tess)
PGLUtess * tess
CODE:
gluTessBeginContour(tess->triangulator);
#// gluTessEndContour(tess);
void
gluTessEndContour(tess)
PGLUtess * tess
CODE:
gluTessEndContour(tess->triangulator);
#// gluTessBeginPolygon(tess, ...);
void
gluTessBeginPolygon(tess, ...)
PGLUtess * tess
CODE:
{
delete_polygon_data()
if (items > 1) {
tess->polygon_data = newSVsv(ST(1));
}
if (!tess->vertex_datas)
tess->vertex_datas = newAV();
gluTessBeginPolygon(tess->triangulator, tess);
}
#// gluTessEndPolygon(tess);
void
gluTessEndPolygon(tess)
PGLUtess * tess
CODE:
{
gluTessEndPolygon(tess->triangulator);
delete_vertex_datas()
delete_tess_datas()
delete_polygon_data()
}
#// gluTessNormal(tess, valueX, valueY, valueZ)
void
gluTessNormal(tess, valueX, valueY, valueZ)
PGLUtess * tess
GLdouble valueX
( run in 0.781 second using v1.01-cache-2.11-cpan-5a3173703d6 )