/*
 * $Id: displaylist.c 200 2007-11-03 11:53:08Z hderuiter $
 *
 * $Date: 2007-11-03 12:26:08 $
 * $Revision: 000 $
 *
 * (C) 2007 by Hans de Ruiter
 * All rights reserved
 *
 * This file is part of the MiniGL library project
 * See the file Licence.txt for more details
 *
 */

#include "displaylists.h"
#include "displaylists_structs.h"
#include <stdio.h>
#include <string.h>
#include <exec/exec.h>
#include <proto/exec.h>
#include <mgl/gl.h>
#include "util.h"
#include "cgl_prototypes.h"

extern GLuint eval_GetMapK1(GLenum target);
extern GLuint eval_GetMapK2(GLenum target);

extern uint32 client_texture_state[];

// Call these macros before and after packed image uploading
#define BEGIN_IMAGEUPLOAD \
	GLint unpackAlignment, unpackRowLength, skipPixels, skipRows;   \
	Self->GLGetIntegerv(GL_UNPACK_ALIGNMENT, &unpackAlignment);     \
	Self->GLGetIntegerv(GL_UNPACK_ROW_LENGTH, &unpackRowLength);    \
	Self->GLGetIntegerv(GL_UNPACK_SKIP_PIXELS, &skipPixels);        \
	Self->GLGetIntegerv(GL_UNPACK_SKIP_ROWS, &skipRows);            \
	                                                                \
	Self->GLPixelStorei(GL_UNPACK_ALIGNMENT, 1);                    \
	Self->GLPixelStorei(GL_UNPACK_ROW_LENGTH, 0);                   \
	Self->GLPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);                  \
	Self->GLPixelStorei(GL_UNPACK_SKIP_ROWS, 0);

#define END_IMAGEUPLOAD  \
	Self->GLPixelStorei(GL_UNPACK_ALIGNMENT, unpackAlignment);     \
	Self->GLPixelStorei(GL_UNPACK_ROW_LENGTH, unpackRowLength);    \
	Self->GLPixelStorei(GL_UNPACK_SKIP_PIXELS, skipPixels);        \
	Self->GLPixelStorei(GL_UNPACK_SKIP_ROWS, skipRows);

// ----- Execution Functions -----

void dl_execute_ActiveTexture(struct GLContextIFace *Self, const DLOperation *op)
{
	cgl_GLActiveTexture(Self,op->opData.e);
}

void dl_execute_AlphaFunc(struct GLContextIFace *Self, const DLOperation *op)
{
	AlphaFuncData *data = (AlphaFuncData*) op->opData.data;
	cgl_GLAlphaFunc(Self,data->func, data->ref);
}

void dl_execute_BlendFunc(struct GLContextIFace *Self, const DLOperation *op)
{
	GLenum *data = (GLenum*) op->opData.data;
	cgl_GLBlendFunc(Self,data[0], data[1]);
}

void dl_execute_Begin(struct GLContextIFace *Self, const DLOperation *op)
{
	cgl_GLBegin(Self,op->opData.e);
}

void dl_execute_BindTexture(struct GLContextIFace *Self, const DLOperation *op)
{
	BindTextureData *data = (BindTextureData*) op->opData.data;
	cgl_GLBindTexture(Self,data->target, data->texture);
}

void dl_execute_Bitmap(struct GLContextIFace *Self, const DLOperation *op)
{
	BitmapData *data = (BitmapData*) op->opData.data;

	BEGIN_IMAGEUPLOAD
	cgl_GLBitmap(Self,
		data->width, data->height, data->xorig, data->yorig,
		data->xmove, data->ymove, (GLvoid*)data->bitmap
	);
	END_IMAGEUPLOAD
}

void dl_execute_DrawPixels(struct GLContextIFace *Self, const DLOperation *op)
{
	DrawPixelsData *data = (DrawPixelsData *)op->opData.data;

	BEGIN_IMAGEUPLOAD
	cgl_GLDrawPixels(Self,
		data->width, data->height, data->format, data->type,
		(GLvoid *)data->pixels
	);
	END_IMAGEUPLOAD
}

void dl_execute_CallList(struct GLContextIFace *Self, const DLOperation *op)
{
	cgl_GLCallList(Self,op->opData.ui);
}

void dl_execute_CallLists(struct GLContextIFace *Self, const DLOperation *op)
{
	CallListsData *data = op->opData.data;
	cgl_GLCallLists(Self,data->n, data->type, data->lists);
}

void dl_execute_Clear(struct GLContextIFace *Self, const DLOperation *op)
{
	cgl_GLClear(Self,op->opData.bf);
}

void dl_execute_ClearColor(struct GLContextIFace *Self, const DLOperation *op)
{
	GLclampf *data = op->opData.data;
	cgl_GLClearColor(Self,data[0], data[1], data[2], data[3]);
}

void dl_execute_ClearDepth(struct GLContextIFace *Self, const DLOperation *op)
{
	cgl_GLClearDepth(Self,op->opData.cd);
}

void dl_execute_ClearStencil(struct GLContextIFace *Self, const DLOperation *op)
{
	cgl_GLClearStencil(Self,op->opData.i);
}

void dl_execute_ClipPlane(struct GLContextIFace *Self, const DLOperation *op)
{
	ClipPlaneData *data = op->opData.data;
	cgl_GLClipPlane(Self,data->plane, data->equ);
}

void dl_execute_Color4f(struct GLContextIFace *Self, const DLOperation *op)
{
	GLfloat *data = op->opData.data;
	cgl_GLColor4f(Self,data[0], data[1], data[2], data[3]);
}

void dl_execute_ColorMask(struct GLContextIFace *Self, const DLOperation *op)
{
	GLboolean *data = op->opData.data;
	cgl_GLColorMask(Self,data[0], data[1], data[2], data[3]);
}

void dl_execute_ColorMaterial(struct GLContextIFace *Self, const DLOperation *op)
{
	GLenum *data = op->opData.data;
	cgl_GLColorMaterial(Self,data[0], data[1]);
}

void dl_execute_ColorTable(struct GLContextIFace *Self, const DLOperation *op)
{
	ColorTableData *data = op->opData.data;
	cgl_GLColorTable(Self,
		data->target, data->internalformat, data->width,
		data->format, data->type, data->data
	);
}

void dl_execute_CopyTexImage2D(struct GLContextIFace *Self, const DLOperation *op)
{
	CopyTexImage2DData *data = (CopyTexImage2DData*) op->opData.data;

	cgl_GLCopyTexImage2D(Self,
		data->target, data->level, data->internalFormat,
		data->x, data->y, data->width, data->height, data->border
	);
}

void dl_execute_CopyTexSubImage2D(struct GLContextIFace *Self, const DLOperation *op)
{
	CopyTexSubImage2DData *data = (CopyTexSubImage2DData*) op->opData.data;

	cgl_GLCopyTexSubImage2D(Self,
		data->target, data->level, data->xoffset, data->yoffset,
		data->x, data->y, data->width, data->height
	);
}

void dl_execute_CullFace(struct GLContextIFace *Self, const DLOperation *op)
{
	cgl_GLCullFace(Self,op->opData.e);
}

void dl_execute_DepthFunc(struct GLContextIFace *Self, const DLOperation *op)
{
	cgl_GLDepthFunc(Self,op->opData.e);
}

void dl_execute_DepthMask(struct GLContextIFace *Self, const DLOperation *op)
{
	cgl_GLDepthMask(Self,op->opData.b);
}

void dl_execute_DepthRange(struct GLContextIFace *Self, const DLOperation *op)
{
	GLclampd *data = op->opData.data;
	cgl_GLDepthRange(Self,data[0], data[1]);
}

void dl_execute_DrawArrays(struct GLContextIFace *Self, const DLOperation *op)
{
	DrawArraysData *data = op->opData.data;

	GLcontext context = GET_INSTANCE(Self);
	struct GLvertex_array_state     old_vertex_array = context->vertex_array;
	context->vertex_array = data->vertex_array;
	cgl_GLDrawArrays(Self,data->mode, data->first, data->count);
	context->vertex_array = old_vertex_array;
}

void dl_execute_DrawBuffer(struct GLContextIFace *Self, const DLOperation *op)
{
	cgl_GLDrawBuffer(Self,op->opData.e);
}

void dl_execute_ReadBuffer(struct GLContextIFace *Self, const DLOperation *op)
{
	cgl_GLReadBuffer(Self,op->opData.e);
}

void dl_execute_DrawElements(struct GLContextIFace *Self, const DLOperation *op)
{
	DrawElementsData *data = op->opData.data;

	GLcontext context = GET_INSTANCE(Self);
	struct GLvertex_array_state     old_vertex_array = context->vertex_array;
	context->vertex_array = data->vertex_array;
	cgl_GLDrawElements(Self,data->mode, data->count, data->type, data->indices);
	context->vertex_array = old_vertex_array;
}

void dl_execute_End(struct GLContextIFace *Self, const DLOperation *op)
{
	cgl_GLEnd(Self);
}

void dl_execute_Fogf(struct GLContextIFace *Self, const DLOperation *op)
{
	FogfData *data = op->opData.data;
	cgl_GLFogf(Self,data->pname, data->param);
}

void dl_execute_Fogfv(struct GLContextIFace *Self, const DLOperation *op)
{
	FogfvData *data = op->opData.data;
	cgl_GLFogfv(Self,data->pname, data->params);
}

void dl_execute_FrontFace(struct GLContextIFace *Self, const DLOperation *op)
{
	cgl_GLFrontFace(Self,op->opData.e);
}

void dl_execute_Frustum(struct GLContextIFace *Self, const DLOperation *op)
{
	GLdouble *data = op->opData.data;
	cgl_GLFrustum(Self,data[0], data[1], data[2], data[3], data[4], data[5]);
}

void dl_execute_Hint(struct GLContextIFace *Self, const DLOperation *op){
	GLenum *data = op->opData.data;
	cgl_GLHint(Self,data[0], data[1]);
}

void dl_execute_Lightf(struct GLContextIFace *Self, const DLOperation *op)
{
	LightfData *data = op->opData.data;
	cgl_GLLightf(Self,data->light, data->pname, data->param);
}

void dl_execute_Lightfv(struct GLContextIFace *Self, const DLOperation *op)
{
	LightfvData *data = op->opData.data;
	cgl_GLLightfv(Self,data->light, data->pname, data->params);
}

void dl_execute_Lightiv(struct GLContextIFace *Self, const DLOperation *op){
	LightivData *data = op->opData.data;
	cgl_GLLightiv(Self,data->light, data->pname, data->params);
}

void dl_execute_LightModelf(struct GLContextIFace *Self, const DLOperation *op){
	LightModelfData *data = op->opData.data;
	cgl_GLLightModelf(Self,data->pname, data->param);
}

void dl_execute_LightModelfv(struct GLContextIFace *Self, const DLOperation *op){
	LightModelfvData *data = op->opData.data;
	cgl_GLLightModelfv(Self,data->pname, data->params);
}

void dl_execute_LightModeliv(struct GLContextIFace *Self, const DLOperation *op){
	LightModelivData *data = op->opData.data;
	cgl_GLLightModeliv(Self,data->pname, data->params);
}

void dl_execute_LineWidth(struct GLContextIFace *Self, const DLOperation *op){
	cgl_GLLineWidth(Self,op->opData.f);
}

void dl_execute_LineStipple(struct GLContextIFace *Self, const DLOperation *op){
	LineStippleData *data = op->opData.data;
	cgl_GLLineStipple(Self,data->factor, data->pattern);
}

void dl_execute_ListBase(struct GLContextIFace *Self, const DLOperation *op){
	cgl_GLListBase(Self,op->opData.ui);
}

void dl_execute_LoadIdentity(struct GLContextIFace *Self, const DLOperation *op){
	cgl_GLLoadIdentity(Self);
}

void dl_execute_LoadMatrixf(struct GLContextIFace *Self, const DLOperation *op){
	GLfloat *data = op->opData.data;
	cgl_GLLoadMatrixf(Self,data);
}

void dl_execute_LoadMatrixd(struct GLContextIFace *Self, const DLOperation *op){
	GLdouble *data = op->opData.data;
	cgl_GLLoadMatrixd(Self,data);
}

void dl_execute_Materialf(struct GLContextIFace *Self, const DLOperation *op){
	MaterialfData *data = op->opData.data;
	cgl_GLMaterialf(Self,data->face, data->pname, data->param);
}

void dl_execute_Materialfv(struct GLContextIFace *Self, const DLOperation *op){
	MaterialFVData *data = op->opData.data;
	cgl_GLMaterialfv(Self,data->face, data->pname, data->params);
}

void dl_execute_Materialiv(struct GLContextIFace *Self, const DLOperation *op){
	MaterialIVData *data = op->opData.data;
	cgl_GLMaterialiv(Self,data->face, data->pname, data->params);
}

void dl_execute_MatrixMode(struct GLContextIFace *Self, const DLOperation *op){
	cgl_GLMatrixMode(Self,op->opData.e);
}

void dl_execute_MultiTexCoord2f(struct GLContextIFace *Self, const DLOperation *op){
	MultiTexCoord2fData     *data = op->opData.data;
	cgl_GLMultiTexCoord2f(Self,data->target, data->s, data->t);
}

void dl_execute_MultiTexCoord4f(struct GLContextIFace *Self, const DLOperation *op){
	MultiTexCoord4fData     *data = op->opData.data;
	cgl_GLMultiTexCoord4f(Self,data->target, data->s, data->t, data->r, data->q);
}

void dl_execute_MultMatrixf(struct GLContextIFace *Self, const DLOperation *op){
	GLfloat *data = op->opData.data;
	cgl_GLMultMatrixf(Self,data);
}

void dl_execute_MultMatrixd(struct GLContextIFace *Self, const DLOperation *op){
	GLdouble *data = op->opData.data;
	cgl_GLMultMatrixd(Self,data);
}

void dl_execute_Normal3f(struct GLContextIFace *Self, const DLOperation *op){
	GLfloat *data = op->opData.data;
	cgl_GLNormal3f(Self,data[0], data[1], data[2]);
}

void dl_execute_Ortho(struct GLContextIFace *Self, const DLOperation *op){
	GLdouble *data = op->opData.data;
	cgl_GLOrtho(Self,data[0], data[1], data[2], data[3], data[4], data[5]);
}

void dl_execute_PinTexture(struct GLContextIFace *Self, const DLOperation *op){
	cgl_PinTexture(Self,op->opData.ui);
}

void dl_execute_PointSize(struct GLContextIFace *Self, const DLOperation *op){
	cgl_GLPointSize(Self,op->opData.f);
}

void dl_execute_PolygonMode(struct GLContextIFace *Self, const DLOperation *op){
	GLenum *data = op->opData.data;
	cgl_GLPolygonMode(Self,data[0], data[1]);
}

void dl_execute_PolygonStipple(struct GLContextIFace *Self, const DLOperation *op){
	PolygonStippleData *data = (PolygonStippleData*) op->opData.data;

	BEGIN_IMAGEUPLOAD
	cgl_GLPolygonStipple(Self,data->pattern);
	END_IMAGEUPLOAD
}

void dl_execute_PolygonOffset(struct GLContextIFace *Self, const DLOperation *op){
	GLfloat *data = op->opData.data;
	cgl_GLPolygonOffset(Self,data[0], data[1]);
}

void dl_execute_PopAttrib(struct GLContextIFace *Self, const DLOperation *op){
	cgl_GLPopAttrib(Self);
}

void dl_execute_PopMatrix(struct GLContextIFace *Self, const DLOperation *op){
	cgl_GLPopMatrix(Self);
}

void dl_execute_PushAttrib(struct GLContextIFace *Self, const DLOperation *op){
	cgl_GLPushAttrib(Self,op->opData.bf);
}

void dl_execute_PushMatrix(struct GLContextIFace *Self, const DLOperation *op){
	cgl_GLPushMatrix(Self);
}

void dl_execute_RasterPos4f(struct GLContextIFace *Self, const DLOperation *op){
	GLfloat *data = op->opData.data;
	cgl_GLRasterPos4f(Self,data[0], data[1], data[2], data[3]);
}

void dl_execute_Rectf(struct GLContextIFace *Self, const DLOperation *op){
	GLfloat *data = op->opData.data;
	cgl_GLRectf(Self,data[0], data[1], data[2], data[3]);
}

void dl_execute_Rotatef(struct GLContextIFace *Self, const DLOperation *op){
	GLfloat *data = op->opData.data;
	cgl_GLRotatef(Self,data[0], data[1], data[2], data[3]);
}

void dl_execute_Scalef(struct GLContextIFace *Self, const DLOperation *op){
	GLfloat *data = op->opData.data;
	cgl_GLScalef(Self,data[0], data[1], data[2]);
}

void dl_execute_Scissor(struct GLContextIFace *Self, const DLOperation *op){
	ScissorData     *data = op->opData.data;
	cgl_GLScissor(Self,data->x, data->y, data->width, data->height);
}

void dl_execute_SetState(struct GLContextIFace *Self, const DLOperation *op){
	SetStateData *data = op->opData.data;
	cgl_SetState(Self,data->cap, data->flag);
}

void dl_execute_SetTextureRenderTarget(struct GLContextIFace *Self, const DLOperation *op){
	cgl_SetTextureRenderTarget(Self,op->opData.ui);
}

void dl_execute_SetZOffset(struct GLContextIFace *Self, const DLOperation *op){
	cgl_SetZOffset(Self,op->opData.f);
}

void dl_execute_ShadeModel(struct GLContextIFace *Self, const DLOperation *op){
	cgl_GLShadeModel(Self,op->opData.e);
}

void dl_execute_StencilFunc(struct GLContextIFace *Self, const DLOperation *op){
	StencilFuncData *data = op->opData.data;
	cgl_GLStencilFunc(Self,data->func, data->ref, data->mask);
}

void dl_execute_StencilMask(struct GLContextIFace *Self, const DLOperation *op){
	cgl_GLStencilMask(Self,op->opData.ui);
}

void dl_execute_StencilOp(struct GLContextIFace *Self, const DLOperation *op){
	GLenum *data = op->opData.data;
	cgl_GLStencilOp(Self,data[0], data[1], data[2]);
}

void dl_execute_TexCoord2f(struct GLContextIFace *Self, const DLOperation *op){
	GLfloat *data = op->opData.data;
	cgl_GLTexCoord2f(Self,data[0], data[1]);
}

void dl_execute_TexCoord4f(struct GLContextIFace *Self, const DLOperation *op){
	GLfloat *data = op->opData.data;
	cgl_GLTexCoord4f(Self,data[0], data[1], data[2], data[3]);
}

void dl_execute_TexEnvi(struct GLContextIFace *Self, const DLOperation *op){
	TexEnviData *data = op->opData.data;
	cgl_GLTexEnvi(Self,data->target, data->pname, data->param);
}

void dl_execute_TexEnvfv(struct GLContextIFace *Self, const DLOperation *op){
	TexEnvfvData *data = op->opData.data;
	cgl_GLTexEnvfv(Self,data->target, data->pname, data->params);
}

void dl_execute_TexGeni(struct GLContextIFace *Self, const DLOperation *op){
	TexGeniData *data = op->opData.data;
	cgl_GLTexGeni(Self,data->coord, data->pname, data->param);
}

void dl_execute_TexGenfv(struct GLContextIFace *Self, const DLOperation *op){
	TexGenfvData *data = op->opData.data;
	cgl_GLTexGenfv(Self,data->coord, data->pname, data->params);
}

void dl_execute_TexImage2D(struct GLContextIFace *Self, const DLOperation *op){
	TexImage2DData *data = (TexImage2DData*) op->opData.data;

	BEGIN_IMAGEUPLOAD
	cgl_GLTexImage2D(Self,
		data->target, data->level, data->internalformat, data->width, data->height, data->border,
		data->format, data->type, (GLvoid*)data->pixels
	);
	END_IMAGEUPLOAD
}

void dl_execute_TexParameteri(struct GLContextIFace *Self, const DLOperation *op){
	TexParameteriData *data= op->opData.data;
	cgl_GLTexParameteri(Self,data->target, data->pname, data->param);
}

void dl_execute_TexSubImage2D(struct GLContextIFace *Self, const DLOperation *op){
	TexSubImage2DData *data = (TexSubImage2DData*) op->opData.data;

	BEGIN_IMAGEUPLOAD
	cgl_GLTexSubImage2D(Self,
		data->target, data->level, data->xoffset, data->yoffset,
		data->width, data->height,
		data->format, data->type, (GLvoid*)data->pixels
	);
	END_IMAGEUPLOAD
}

void dl_execute_Translatef(struct GLContextIFace *Self, const DLOperation *op){
	GLfloat *data= op->opData.data;
	cgl_GLTranslatef(Self,data[0], data[1], data[2]);
}

void dl_execute_UnpinTexture(struct GLContextIFace *Self, const DLOperation *op){
	cgl_UnpinTexture(Self,op->opData.ui);
}

void dl_execute_Vertex4f(struct GLContextIFace *Self, const DLOperation *op){
	GLfloat *data = op->opData.data;
	cgl_GLVertex4f(Self,data[0], data[1], data[2], data[3]);
}

void dl_execute_Viewport(struct GLContextIFace *Self, const DLOperation *op){
	ViewportData *data = op->opData.data;
	cgl_GLViewport(Self,data->x, data->y, data->width, data->height);
}

void dl_execute_InitNames(struct GLContextIFace *Self, const DLOperation *op)
{
	cgl_GLInitNames(Self);
}

void dl_execute_LoadName(struct GLContextIFace *Self, const DLOperation *op)
{
	GLuint name = op->opData.ui;
	cgl_GLLoadName(Self,name);
}


void dl_execute_PushName(struct GLContextIFace *Self, const DLOperation *op)
{
	GLuint name = op->opData.ui;
	cgl_GLPushName(Self,name);
}


void dl_execute_PopName(struct GLContextIFace *Self, const DLOperation *op)
{
	cgl_GLPopName(Self);
}


void dl_execute_Map1f(struct GLContextIFace *Self, const DLOperation *op)
{
	Map1fData *data = op->opData.data;
	cgl_GLMap1f(Self,
		data->target, data->u1, data->u2, eval_GetMapK1(data->target),
		data->order, &data->points[0]
	);
}


void dl_execute_Map1d(struct GLContextIFace *Self, const DLOperation *op)
{
	Map1dData *data = op->opData.data;
	cgl_GLMap1d(Self,
		data->target, data->u1, data->u2, eval_GetMapK1(data->target),
		data->order, &data->points[0]
	);
}


void dl_execute_EvalCoord1f(struct GLContextIFace *Self, const DLOperation *op)
{
	EvalCoord1Data *data = op->opData.data;
	cgl_GLEvalCoord1f(Self,data->arg);
}


void dl_execute_MapGrid1f(struct GLContextIFace *Self, const DLOperation *op)
{
	MapGrid1Data *data = op->opData.data;
	cgl_GLMapGrid1f(Self,data->n, data->u1, data->u2);
}


void dl_execute_EvalMesh1(struct GLContextIFace *Self, const DLOperation *op)
{
	EvalMesh1Data *data = op->opData.data;
	cgl_GLEvalMesh1(Self,data->mode, data->p1, data->p2);
}


void dl_execute_EvalPoint1(struct GLContextIFace *Self, const DLOperation *op)
{
	EvalPoint1Data *data = op->opData.data;
	cgl_GLEvalPoint1(Self,data->p);
}


void dl_execute_Map2f(struct GLContextIFace *Self, const DLOperation *op)
{
	Map2fData *data = op->opData.data;
	cgl_GLMap2f(Self,
		data->target, data->u1, data->u2, eval_GetMapK2(data->target) * data->vorder,
		data->uorder, data->v1, data->v2, eval_GetMapK2(data->target),
		data->vorder, &data->points[0]
	);
}


void dl_execute_Map2d(struct GLContextIFace *Self, const DLOperation *op)
{
	Map2dData *data = op->opData.data;
	cgl_GLMap2d(Self,
		data->target, data->u1, data->u2, eval_GetMapK2(data->target) * data->vorder,
		data->uorder, data->v1, data->v2, eval_GetMapK2(data->target),
		data->vorder, &data->points[0]
	);
}


void dl_execute_EvalCoord2f(struct GLContextIFace *Self, const DLOperation *op)
{
	EvalCoord2Data *data = op->opData.data;
	cgl_GLEvalCoord2f(Self,data->u, data->v);
}


void dl_execute_MapGrid2f(struct GLContextIFace *Self, const DLOperation *op)
{
	MapGrid2Data *data = op->opData.data;
	cgl_GLMapGrid2f(Self,data->nu, data->u1, data->u2, data->nv, data->v1, data->v2);
}


void dl_execute_EvalMesh2(struct GLContextIFace *Self, const DLOperation *op)
{
	EvalMesh2Data *data = op->opData.data;
	cgl_GLEvalMesh2(Self,data->mode, data->p1, data->p2, data->q1, data->q2);
}


void dl_execute_EvalPoint2(struct GLContextIFace *Self, const DLOperation *op)
{
	EvalPoint2Data *data = op->opData.data;
	cgl_GLEvalPoint2(Self,data->p, data->q);
}


void dl_execute_PixelTransfer(struct GLContextIFace *Self, const DLOperation *op)
{
	PixelTransferData *data = op->opData.data;
	cgl_GLPixelTransferf(Self,data->param, data->value);
}

void dl_execute_PixelZoom(struct GLContextIFace *Self, const DLOperation *op)
{
	PixelZoomData *data = op->opData.data;
	cgl_GLPixelZoom(Self,data->zoom_x, data->zoom_y);
}

void dl_execute_CopyPixels(struct GLContextIFace *Self, const DLOperation *op)
{
	CopyPixelData *data = op->opData.data;
	cgl_GLCopyPixels(Self,data->x, data->y, data->width, data->height, data->type);
}

void dl_execute_LogicOp(struct GLContextIFace *Self, const DLOperation *op)
{
	LogicOpModeData *data = op->opData.data;
	cgl_GLLogicOp(Self,data->op);
}