/*
 * $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 "displaylists_execute.h"
#include <stdio.h>
#include <string.h>
#include <exec/exec.h>
#include <proto/exec.h>

#include <mgl/gl.h>

#include "util.h"

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

extern uint32 client_texture_state[];

extern DLOperation* dl_NewOperation(DLOperation *prevOp, GLuint extraBytes);
extern GLsizei      dl_getVertexArrayCountFromIndices(GLsizei count, GLint type, const void *indices);
extern int          dl_getVertexArraySize(GLcontext context, GLsizei count);

extern void         dl_copyVertexArray(
	GLcontext context, struct GLvertex_array_state *vertexArray, GLvoid *vertexArrayBuffer, GLint first, GLsizei count
);

extern GLuint       dl_imageSize(
	GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type
);

extern void         dl_copyImage(
	struct GLContextIFace *Self, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLint border, GLenum format,
	GLenum type, const void *srcImage, void *destImage
);

#define NEW_OP(size) \
	DLOperation *newOp = dl_NewOperation(context->TargetDisplayListEnd, (size)); \
	if (!newOp) { \
		context->DisplayListCompileError = GL_OUT_OF_MEMORY; \
		return; \
	} \
	context->TargetDisplayListEnd = newOp;

// ----- Save Functions -----

void dl_save_ActiveTexture(struct GLContextIFace *Self, GLenum unit)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(0);

	newOp->opFunc = dl_execute_ActiveTexture;
	newOp->opData.e = unit;
}

void dl_save_AlphaFunc(struct GLContextIFace *Self, GLenum func, GLclampf ref)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(AlphaFuncData));

	newOp->opFunc = dl_execute_AlphaFunc;
	AlphaFuncData *data = (AlphaFuncData*)newOp->opData.data;
	data->func = func;
	data->ref = ref;
}

void dl_save_BlendFunc(struct GLContextIFace *Self, GLenum sfactor, GLenum dfactor)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(GLenum) * 2);

	newOp->opFunc = dl_execute_BlendFunc;
	GLenum *data = (GLenum*)newOp->opData.data;
	data[0] = sfactor;
	data[1] = dfactor;
}

void dl_save_Begin(struct GLContextIFace *Self, GLenum mode)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(0);

	newOp->opFunc = dl_execute_Begin;
	newOp->opData.e = mode;
}

void dl_save_BindTexture(struct GLContextIFace *Self, GLenum target, GLuint texture)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(BindTextureData));

	newOp->opFunc = dl_execute_BindTexture;
	BindTextureData *data = (BindTextureData*)newOp->opData.data;
	data->target = target;
	data->texture = texture;
}

void dl_save_Bitmap(
	struct GLContextIFace *Self,
	GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLvoid *bitmap
)
{
	GLcontext context = GET_INSTANCE(Self);

	GLuint bitmapSize = dl_imageSize(width, height, 0,  GL_COLOR_INDEX, GL_BITMAP);

	NEW_OP(sizeof(BitmapData) + bitmapSize - 1);

	newOp->opFunc = dl_execute_Bitmap;
	BitmapData *data = (BitmapData*)newOp->opData.data;
	data->width  = width;
	data->height = height;
	data->xorig  = xorig;
	data->yorig  = yorig;
	data->xmove  = xmove;
	data->ymove  = ymove;
	dl_copyImage(Self, 0, 0, width, height, 0, GL_COLOR_INDEX, GL_BITMAP, bitmap, (GLvoid*)data->bitmap);
}

void dl_save_DrawPixels(
	struct GLContextIFace *Self, GLsizei width, GLsizei height, GLenum format, GLenum type,  const GLvoid *pixels
)
{
	GLcontext context = GET_INSTANCE(Self);
	GLuint imageSize  = dl_imageSize(width, height, 0, format, type);

	NEW_OP(sizeof(DrawPixelsData) + imageSize -1);

	newOp->opFunc = dl_execute_DrawPixels;

	DrawPixelsData *data = (DrawPixelsData *)newOp->opData.data;
	data->width  = width;
	data->height = height;
	data->type   = type;
	data->format = format;

	dl_copyImage(Self, 0, 0, width, height, 0, format, type, pixels, (GLvoid*)data->pixels);
}

void dl_save_CallList(struct GLContextIFace *Self, GLuint list)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(0);

	newOp->opFunc = dl_execute_CallList;
	newOp->opData.ui = list;
}

void dl_save_CallLists(struct GLContextIFace *Self, GLsizei n, GLenum type, const GLvoid *lists)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(CallListsData) + sizeof(GLuint) * (n - 1));

	newOp->opFunc = dl_execute_CallLists;
	CallListsData *data = (CallListsData*)newOp->opData.data;
	GLuint *listIds = (GLuint*)lists;
	for(int i = 0; i < n; i++) {
		data->lists[i] = listIds[i];
	}
}

void dl_save_Clear(struct GLContextIFace *Self, GLbitfield mask)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(0);

	newOp->opFunc = dl_execute_Clear;
	newOp->opData.bf = mask;
}

void dl_save_ClearColor(struct GLContextIFace *Self, GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(GLclampf) * 4);

	newOp->opFunc = dl_execute_ClearColor;
	GLclampf *data = (GLclampf*)newOp->opData.data;
	data[0] = red;
	data[1] = green;
	data[2] = blue;
	data[3] = alpha;
}

void dl_save_ClearDepth(struct GLContextIFace *Self, GLclampd depth)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(0);

	newOp->opFunc = dl_execute_ClearDepth;
	newOp->opData.cd = depth;
}

void dl_save_ClearStencil(struct GLContextIFace *Self, GLint s)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(0);

	newOp->opFunc = dl_execute_ClearStencil;
	newOp->opData.i = s;
}

void dl_save_ClipPlane(struct GLContextIFace *Self, GLenum plane, const GLdouble *equ)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(ClipPlaneData));

	newOp->opFunc = dl_execute_ClipPlane;
	ClipPlaneData *data = (ClipPlaneData*)newOp->opData.data;
	data->plane = plane;
	data->equ[0] = equ[0];
	data->equ[1] = equ[1];
	data->equ[2] = equ[2];
	data->equ[3] = equ[3];
}

void dl_save_Color4f(struct GLContextIFace *Self, GLfloat r, GLfloat g, GLfloat b, GLfloat a)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(GLfloat) * 4);

	newOp->opFunc = dl_execute_Color4f;
	GLfloat *data = (GLfloat*)newOp->opData.data;
	data[0] = r;
	data[1] = g;
	data[2] = b;
	data[3] = a;
}

void dl_save_ColorMask(struct GLContextIFace *Self, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(GLboolean) * 4);

	newOp->opFunc = dl_execute_ColorMask;
	GLboolean *data = (GLboolean*)newOp->opData.data;
	data[0] = red;
	data[1] = green;
	data[2] = blue;
	data[3] = alpha;
}

void dl_save_ColorMaterial(struct GLContextIFace *Self, GLenum face, GLenum mode)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(GLenum) * 2);

	newOp->opFunc = dl_execute_ColorMaterial;
	GLenum *data = (GLenum*)newOp->opData.data;
	data[0] = face;
	data[1] = mode;
}

void dl_save_ColorTable(
	struct GLContextIFace *Self, GLenum target, GLenum internalformat, GLint width, GLenum format, GLenum type, const GLvoid* data)
{
	GLcontext context = GET_INSTANCE(Self);

	GLuint elementSize, typeSize;
	switch (format) {
		case GL_RED:
		case GL_GREEN:
		case GL_BLUE:
		case GL_ALPHA:
		case GL_LUMINANCE:
		case GL_LUMINANCE_ALPHA:
			elementSize = 1;
			break;

		case GL_RGB:
		case GL_BGR:
			elementSize = 3;
			break;

		case GL_RGBA:
		case GL_BGRA:
			elementSize = 4;
			break;

	default:
		context->DisplayListCompileError = GL_INVALID_VALUE;
		return;
	}

	switch (type) {
		case GL_UNSIGNED_BYTE:
		case GL_BYTE:
		case GL_UNSIGNED_BYTE_3_3_2:
		case GL_UNSIGNED_BYTE_2_3_3_REV:
			typeSize = sizeof(GLbyte);
			break;

		case GL_UNSIGNED_SHORT:
		case GL_UNSIGNED_SHORT_5_6_5:
		case GL_UNSIGNED_SHORT_5_6_5_REV:
		case GL_UNSIGNED_SHORT_4_4_4_4:
		case GL_UNSIGNED_SHORT_4_4_4_4_REV:
		case GL_UNSIGNED_SHORT_5_5_5_1:
		case GL_UNSIGNED_SHORT_1_5_5_5_REV:
		case GL_SHORT:
			typeSize = sizeof(GLshort);
			break;

		case GL_UNSIGNED_INT:
		case GL_INT:
		case GL_UNSIGNED_INT_8_8_8_8:
		case GL_UNSIGNED_INT_8_8_8_8_REV:
		case GL_UNSIGNED_INT_10_10_10_2:
	//case GL_UNSIGNED_INT_2_10_10_10_RE:
			typeSize = sizeof(GLint);
			break;

		case GL_FLOAT:
			typeSize = sizeof(GLfloat);
			break;

		default:
			context->DisplayListCompileError = GL_INVALID_VALUE;
			return;
	}

	GLuint tableSize = width * elementSize *typeSize;

  NEW_OP(sizeof(ColorTableData) + tableSize - 1);

	newOp->opFunc = dl_execute_ColorTable;
	ColorTableData *opData = (ColorTableData*)newOp->opData.data;
	opData->target = target;
	opData->internalformat = internalformat;
	opData->width = width;
	opData->format = format;
	opData->type = type;

	GLubyte *ubData = (GLubyte*)data;
	for(GLuint i = 0; i < tableSize; i++){
		opData->data[i] = ubData[i];
	}
}

void dl_save_CopyTexImage2D(
	struct GLContextIFace *Self,
	GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border
)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(CopyTexImage2DData));

	newOp->opFunc = dl_execute_CopyTexImage2D;
	CopyTexImage2DData *data = (CopyTexImage2DData*)newOp->opData.data;
	data->target = target;
	data->level  = level;
	data->internalFormat = internalFormat;
	data->x = x;
	data->y = y;
	data->width = width;
	data->height = height;
	data->border = border;
}

extern void dl_save_CopyTexSubImage2D(
	struct GLContextIFace *Self,
	GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height
)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(CopyTexSubImage2DData));

	newOp->opFunc = dl_execute_TexSubImage2D;
	CopyTexSubImage2DData *data = (CopyTexSubImage2DData*)newOp->opData.data;
	data->target = target;
	data->level = level;
	data->xoffset = xoffset;
	data->yoffset = yoffset;
	data->x = x;
	data->y = y;
	data->width = width;
	data->height = height;
}

void dl_save_CullFace(struct GLContextIFace *Self, GLenum mode)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(0);

	newOp->opFunc = dl_execute_CullFace;
	newOp->opData.e = mode;
}

void dl_save_DepthFunc(struct GLContextIFace *Self, GLenum func)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(0);

	newOp->opFunc = dl_execute_DepthFunc;
	newOp->opData.e = func;
}

void dl_save_DepthMask(struct GLContextIFace *Self, GLboolean mask)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(0);

	newOp->opFunc = dl_execute_DepthMask;
	newOp->opData.b = mask;
}

void dl_save_DepthRange(struct GLContextIFace *Self, GLclampd nearval, GLclampd farval)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(GLclampd) * 2);

	newOp->opFunc = dl_execute_DepthRange;
	GLclampd *data = (GLclampd*)newOp->opData.data;
	data[0] = nearval;
	data[1] = farval;
}

void dl_save_DrawArrays(struct GLContextIFace *Self, GLenum mode, GLint first, GLsizei count)
{
	GLcontext context = GET_INSTANCE(Self);

	int vertexArraySize = dl_getVertexArraySize(context, count);
	if (vertexArraySize == 0) {
		context->DisplayListCompileError = GL_INVALID_VALUE;
		return;
	}

	NEW_OP(sizeof(DrawArraysData) + vertexArraySize);

	newOp->opFunc = dl_execute_DrawArrays;
	DrawArraysData *data = (DrawArraysData*)newOp->opData.data;
	data->mode = mode;
	data->first = first;
	data->count  = count;

	// Now copying the vertex array into the vertex array buffer
	void *vertexArrayBuffer = ((uint8*)data + sizeof(DrawArraysData));
	dl_copyVertexArray(context, &(data->vertex_array), vertexArrayBuffer, first, count);
}

void dl_save_DrawBuffer(struct GLContextIFace *Self, GLenum mode)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(0);

	newOp->opFunc = dl_execute_DrawBuffer;
	newOp->opData.e = mode;
}


void dl_save_ReadBuffer(struct GLContextIFace *Self, GLenum mode)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(0);

	newOp->opFunc = dl_execute_ReadBuffer;
	newOp->opData.e = mode;
}

void dl_save_DrawElements(
	struct GLContextIFace *Self, GLenum mode,
	GLsizei count, GLenum type, const GLvoid *indices)
{
	GLcontext context = GET_INSTANCE(Self);

	GLsizei elementSize;
	switch (type) {
		case GL_UNSIGNED_BYTE:
			elementSize = sizeof(GLubyte);
			break;

		case GL_UNSIGNED_SHORT:
			elementSize = sizeof(GLushort);
			break;

		case GL_UNSIGNED_INT:
			elementSize = sizeof(GLuint);
			break;

		default:
			context->DisplayListCompileError = GL_INVALID_VALUE;
			return;
	}

	int indexArraySize    = count * elementSize;
	int dataPlusIndexSize = indexArraySize +
		sizeof(DrawElementsData) + 4 -
		indexArraySize % 4;  // ensure alignment of following vertexArray

	GLsizei vertexArrayCount = dl_getVertexArrayCountFromIndices(count, type, indices);
	if (vertexArrayCount == 0) {
		context->DisplayListCompileError = GL_INVALID_VALUE;
		return;
	}

	int vertexArraySize = dl_getVertexArraySize(context, vertexArrayCount);
	if (vertexArraySize == 0) {
		context->DisplayListCompileError = GL_INVALID_VALUE;
		return;
	}

	NEW_OP(dataPlusIndexSize + vertexArraySize);

	newOp->opFunc = dl_execute_DrawElements;
	DrawElementsData *data = (DrawElementsData*)newOp->opData.data;
	data->mode = mode;
	data->count = count;
	data->type = type;

	// Copy the index array
	switch(type){
		case GL_UNSIGNED_BYTE: {
			GLubyte *srcIndices = (GLubyte*) indices;
			GLubyte *destIndices = (GLubyte*) data->indices;
			for(GLsizei i = 0; i < count; i++){
				destIndices[i] = srcIndices[i];
			}
			break;
		}
		case GL_UNSIGNED_SHORT: {
			GLushort *srcIndices = (GLushort*) indices;
			GLushort *destIndices = (GLushort*) data->indices;
			for(GLsizei i = 0; i < count; i++){
				destIndices[i] = srcIndices[i];
			}
			break;
		}
		case GL_UNSIGNED_INT: {
			GLuint *srcIndices = (GLuint*) indices;
			GLuint *destIndices = (GLuint*) data->indices;
			for(GLsizei i = 0; i < count; i++){
				destIndices[i] = srcIndices[i];
			}
			break;
		}
		default:
			context->DisplayListCompileError = GL_INVALID_VALUE;
	}

	// Now copying the vertex array into the vertex array buffer
	void *vertexArrayBuffer = ((uint8*)data + dataPlusIndexSize);
	dl_copyVertexArray(context, &(data->vertex_array), vertexArrayBuffer, 0, vertexArrayCount);
}

void dl_save_End(struct GLContextIFace *Self)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(0);

	newOp->opFunc = dl_execute_End;
}

void dl_save_Fogf(struct GLContextIFace *Self, GLenum pname, GLfloat param)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(FogfData));

	newOp->opFunc = dl_execute_Fogf;
	FogfData *data = (FogfData*)newOp->opData.data;
	data->pname = pname;
	data->param = param;
}

void dl_save_Fogfv(struct GLContextIFace *Self, GLenum pname, const GLfloat *params){
GLcontext context = GET_INSTANCE(Self);

	int opSize = pname == GL_FOG_COLOR ? (sizeof(FogfvData) + sizeof(GLfloat) * 3) : sizeof(FogfvData);

	NEW_OP(opSize);

	newOp->opFunc = dl_execute_Fogfv;
	FogfvData *data = (FogfvData*)newOp->opData.data;
	data->pname = pname;
	data->params[0] = params[0];
	if (pname == GL_FOG_COLOR){
		data->params[1] = params[1];
		data->params[2] = params[2];
		data->params[3] = params[3];
	}
}

void dl_save_FrontFace(struct GLContextIFace *Self, GLenum mode)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(0);

	newOp->opFunc = dl_execute_FrontFace;
	newOp->opData.e = mode;
}

void dl_save_Frustum(
	struct GLContextIFace *Self, GLdouble left, GLdouble right,
	GLdouble bottom, GLdouble top,
	GLdouble nearval, GLdouble farval)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(GLdouble) * 6);

	newOp->opFunc = dl_execute_Frustum;
	GLfloat *data = (GLfloat*)newOp->opData.data;
	data[0] = left;
	data[1] = right;
	data[2] = bottom;
	data[3] = top;
	data[4] = nearval;
	data[5] = farval;
}

void dl_save_Hint(struct GLContextIFace *Self, GLenum target, GLenum mode)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(GLenum) * 2);

	newOp->opFunc = dl_execute_Hint;
	GLenum *data = (GLenum*)newOp->opData.data;
	data[0] = target;
	data[1] = mode;
}

void dl_save_Lightf(struct GLContextIFace *Self, GLenum light, GLenum pname, GLfloat param)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(LightfData));

	newOp->opFunc = dl_execute_Lightf;
	LightfData *data = (LightfData*)newOp->opData.data;
	data->light = light;
	data->pname = pname;
	data->param = param;
}

void dl_save_Lightfv(struct GLContextIFace *Self, GLenum light, GLenum pname, const GLfloat *params)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(LightfvData));

	newOp->opFunc = dl_execute_Lightfv;
	LightfvData *data = (LightfvData*)newOp->opData.data;
	data->light = light;
	data->pname = pname;
	data->params[0] = params[0];
	switch (pname) {
		case GL_AMBIENT:
		case GL_DIFFUSE:
		case GL_SPECULAR:
		case GL_POSITION:
			data->params[3] = params[3];
		case GL_SPOT_DIRECTION:
			data->params[1] = params[1];
			data->params[2] = params[2];
	}
}

void dl_save_Lightiv(
	struct GLContextIFace *Self, GLenum light, GLenum pname,
	const GLint *params)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(LightivData));

	newOp->opFunc = dl_execute_Lightiv;
	LightivData *data = (LightivData*)newOp->opData.data;
	data->light = light;
	data->pname = pname;
	data->params[0] = params[0];
	switch(pname){
		case GL_AMBIENT:
		case GL_DIFFUSE:
		case GL_SPECULAR:
		case GL_POSITION:
			data->params[3] = params[3];
		case GL_SPOT_DIRECTION:
			data->params[1] = params[1];
			data->params[2] = params[2];
	}
}

void dl_save_LightModelf(struct GLContextIFace *Self, GLenum pname, GLfloat param)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(LightModelfData));

	newOp->opFunc = dl_execute_Lightf;
	LightModelfData *data = (LightModelfData*)newOp->opData.data;
	data->pname = pname;
	data->param = param;
}

void dl_save_LightModelfv(struct GLContextIFace *Self, GLenum pname, const GLfloat *params)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(LightModelfvData));

	newOp->opFunc = dl_execute_LightModelfv;
	LightModelfvData *data = (LightModelfvData*)newOp->opData.data;
	data->pname = pname;
	data->params[0] = params[0];
	if (pname == GL_LIGHT_MODEL_AMBIENT) {
		data->params[1] = params[1];
		data->params[2] = params[2];
		data->params[3] = params[3];
	}
}

void dl_save_LightModeliv(struct GLContextIFace *Self, GLenum pname, const GLint *params)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(LightModelivData));

	newOp->opFunc = dl_execute_LightModeliv;
	LightModelivData *data = (LightModelivData*)newOp->opData.data;
	data->pname = pname;
	data->params[0] = params[0];
	if (pname == GL_LIGHT_MODEL_AMBIENT) {
		data->params[1] = params[1];
		data->params[2] = params[2];
		data->params[3] = params[3];
	}
}

void dl_save_LineWidth(struct GLContextIFace *Self, GLfloat width)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(0);

	newOp->opFunc = dl_execute_LineWidth;
	newOp->opData.f = width;
}

void dl_save_LineStipple(struct GLContextIFace *Self, GLint factor, GLushort pattern)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(LineStippleData));

	newOp->opFunc = dl_execute_LineStipple;
	LineStippleData *data = (LineStippleData*)newOp->opData.data;
	data->factor = factor;
	data->pattern = pattern;
}

void dl_save_ListBase(struct GLContextIFace *Self, GLuint base)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(0);

	newOp->opFunc = dl_execute_ListBase;
	newOp->opData.ui = base;
}

void dl_save_LoadIdentity(struct GLContextIFace *Self)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(0);

	newOp->opFunc = dl_execute_LoadIdentity;
}

void dl_save_LoadMatrixf(struct GLContextIFace *Self, const GLfloat *m)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(GLfloat) * 16);

	newOp->opFunc = dl_execute_LoadMatrixf;
	GLfloat *data = (GLfloat*)newOp->opData.data;
	data[0]  = m[0];
	data[1]  = m[1];
	data[2]  = m[2];
	data[3]  = m[3];
	data[4]  = m[4];
	data[5]  = m[5];
	data[6]  = m[6];
	data[7]  = m[7];
	data[8]  = m[8];
	data[9]  = m[9];
	data[10] = m[10];
	data[11] = m[11];
	data[12] = m[12];
	data[13] = m[13];
	data[14] = m[14];
	data[15] = m[15];
}

void dl_save_LoadMatrixd(struct GLContextIFace *Self, const GLdouble *m)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(GLdouble) * 16);

	newOp->opFunc = dl_execute_LoadMatrixd;
	GLdouble *data = (GLdouble*)newOp->opData.data;
	data[0]  = m[0];
	data[1]  = m[1];
	data[2]  = m[2];
	data[3]  = m[3];
	data[4]  = m[4];
	data[5]  = m[5];
	data[6]  = m[6];
	data[7]  = m[7];
	data[8]  = m[8];
	data[9]  = m[9];
	data[10] = m[10];
	data[11] = m[11];
	data[12] = m[12];
	data[13] = m[13];
	data[14] = m[14];
	data[15] = m[15];
}

void dl_save_Materialf(struct GLContextIFace *Self, GLenum face, GLenum pname, GLfloat param)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(MaterialfData));

	newOp->opFunc = dl_execute_Materialf;
	MaterialfData *data = (MaterialfData*)newOp->opData.data;
	data->face = face;
	data->pname = pname;
	data->param = param;

	context->TargetDisplayListEnd = newOp;
}

void dl_save_Materialfv(struct GLContextIFace *Self, GLenum face, GLenum pname, const GLfloat *params)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(MaterialFVData));

	newOp->opFunc = dl_execute_Materialfv;
	MaterialFVData *data = (MaterialFVData*)newOp->opData.data;
	data->face = face;
	data->pname = pname;

	context->TargetDisplayListEnd = newOp;

	switch (pname) {
		case GL_SHININESS:
			data->params[0] = *params;
			break;

		case GL_AMBIENT:
		case GL_DIFFUSE:
		case GL_SPECULAR:
		case GL_EMISSION:
		case GL_AMBIENT_AND_DIFFUSE:
			data->params[0] = params[0];
			data->params[1] = params[1];
			data->params[2] = params[2];
			data->params[3] = params[3];
			break;
		case GL_COLOR_INDEXES:
			data->params[0] = params[0];
			data->params[1] = params[1];
			data->params[2] = params[2];
			break;
	}
}

void dl_save_Materialiv(struct GLContextIFace *Self, GLenum face, GLenum pname, const GLint *params)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(MaterialFVData));

	newOp->opFunc = dl_execute_Materialiv;
	MaterialIVData *data = (MaterialIVData*)newOp->opData.data;
	data->face = face;
	data->pname = pname;

	context->TargetDisplayListEnd = newOp;

	switch (pname) {
			case GL_SHININESS:
				data->params[0] = *params;
				break;

			case GL_AMBIENT:
			case GL_DIFFUSE:
			case GL_SPECULAR:
			case GL_EMISSION:
			case GL_AMBIENT_AND_DIFFUSE:
				data->params[0] = params[0];
				data->params[1] = params[1];
				data->params[2] = params[2];
				data->params[3] = params[3];
				break;
			case GL_COLOR_INDEXES:
				data->params[0] = params[0];
				data->params[1] = params[1];
				data->params[2] = params[2];
				break;
	}
}

void dl_save_MatrixMode(struct GLContextIFace *Self, GLenum mode)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(0);

	newOp->opFunc = dl_execute_MatrixMode;
	newOp->opData.e = mode;
}

void dl_save_MultiTexCoord2f(struct GLContextIFace *Self, GLenum target, GLfloat s, GLfloat t)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(MultiTexCoord2fData));

	newOp->opFunc = dl_execute_MultiTexCoord2f;
	MultiTexCoord2fData *data = (MultiTexCoord2fData*)newOp->opData.data;
	data->target = target;
	data->s = s;
	data->t = t;
}

void dl_save_MultiTexCoord4f(
	struct GLContextIFace *Self, GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(MultiTexCoord4fData));

	newOp->opFunc = dl_execute_MultiTexCoord4f;
	MultiTexCoord4fData *data = (MultiTexCoord4fData*)newOp->opData.data;
	data->target = target;
	data->s = s;
	data->t = t;
	data->r = r;
	data->q = q;
}

void dl_save_MultMatrixf(struct GLContextIFace *Self, const GLfloat *m)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(GLfloat) * 16);

	newOp->opFunc = dl_execute_MultMatrixf;
	GLfloat *data = (GLfloat*)newOp->opData.data;
	data[0]  = m[0];
	data[1]  = m[1];
	data[2]  = m[2];
	data[3]  = m[3];
	data[4]  = m[4];
	data[5]  = m[5];
	data[6]  = m[6];
	data[7]  = m[7];
	data[8]  = m[8];
	data[9]  = m[9];
	data[10] = m[10];
	data[11] = m[11];
	data[12] = m[12];
	data[13] = m[13];
	data[14] = m[14];
	data[15] = m[15];
}

void dl_save_MultMatrixd(struct GLContextIFace *Self, const GLdouble *m)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(GLdouble) * 16);

	newOp->opFunc = dl_execute_MultMatrixd;
	GLdouble *data = (GLdouble*)newOp->opData.data;
	data[0] = m[0];
	data[1] = m[1];
	data[2] = m[2];
	data[3] = m[3];
	data[4] = m[4];
	data[5] = m[5];
	data[6] = m[6];
	data[7] = m[7];
	data[8] = m[8];
	data[9] = m[9];
	data[10] = m[10];
	data[11] = m[11];
	data[12] = m[12];
	data[13] = m[13];
	data[14] = m[14];
	data[15] = m[15];
}

void dl_save_Normal3f(struct GLContextIFace *Self, GLfloat nx, GLfloat ny, GLfloat nz)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(GLfloat) * 3);

	newOp->opFunc = dl_execute_Normal3f;
	GLfloat *data = (GLfloat*)newOp->opData.data;
	data[0] = nx;
	data[1] = ny;
	data[2] = nz;
}

void dl_save_Ortho(
	struct GLContextIFace *Self,
	GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble nearval, GLdouble farval
)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(GLdouble) * 6);

	newOp->opFunc = dl_execute_Ortho;
	GLdouble *data = (GLdouble*)newOp->opData.data;
	data[0] = left;
	data[1] = right;
	data[2] = bottom;
	data[3] = top;
	data[4] = nearval;
	data[5] = farval;
}

void dl_save_PinTexture(struct GLContextIFace *Self, GLuint texnum)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(0);

	newOp->opFunc = dl_execute_PinTexture;
	newOp->opData.ui = texnum;
}

void dl_save_PointSize(struct GLContextIFace *Self, GLfloat size)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(0);

	newOp->opFunc = dl_execute_PointSize;
	newOp->opData.f = size;
}

void dl_save_PolygonMode(struct GLContextIFace *Self, GLenum face, GLenum mode)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(GLenum) * 2);

	newOp->opFunc = dl_execute_PolygonMode;
	GLenum *data = (GLenum*)newOp->opData.data;
	data[0] = face;
	data[1] = mode;
}

void dl_save_PolygonStipple(struct GLContextIFace *Self, const GLubyte *pattern)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(PolygonStippleData))

	newOp->opFunc = dl_execute_PolygonStipple;
	PolygonStippleData *data = (PolygonStippleData*)newOp->opData.data;
	dl_copyImage(
		Self, 0, 0, 32, 32, 0, GL_COLOR_INDEX, GL_BITMAP,
		(GLvoid*)pattern, (GLvoid*)data->pattern
	);
}

void dl_save_PolygonOffset(struct GLContextIFace *Self, GLfloat factor, GLfloat units)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(GLfloat) * 2);

	newOp->opFunc = dl_execute_PolygonOffset;
	GLfloat *data = (GLfloat*)newOp->opData.data;
	data[0] = factor;
	data[1] = units;
}

void dl_save_PopAttrib(struct GLContextIFace *Self)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(0);

	newOp->opFunc = dl_execute_PopAttrib;
}

void dl_save_PopMatrix(struct GLContextIFace *Self)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(0);

	newOp->opFunc = dl_execute_PopMatrix;
}

void dl_save_PushAttrib(struct GLContextIFace *Self, GLbitfield mask)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(0);

	newOp->opFunc = dl_execute_PushAttrib;
	newOp->opData.bf = mask;
}

void dl_save_PushMatrix(struct GLContextIFace *Self)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(0);

	newOp->opFunc = dl_execute_PushMatrix;
}

void dl_save_RasterPos4f(struct GLContextIFace *Self, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(GLfloat) * 4);

	newOp->opFunc = dl_execute_RasterPos4f;
	GLfloat *data = (GLfloat*)newOp->opData.data;
	data[0] = x;
	data[1] = y;
	data[2] = z;
	data[3] = w;
}

void dl_save_Rectf(struct GLContextIFace *Self, GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(GLfloat) * 4);

	newOp->opFunc = dl_execute_Rectf;
	GLfloat *data = (GLfloat*)newOp->opData.data;
	data[0] = x1;
	data[1] = y1;
	data[2] = x2;
	data[3] = y2;
}

void dl_save_Rotatef(struct GLContextIFace *Self, GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(GLfloat) * 4);

	newOp->opFunc = dl_execute_Rotatef;
	GLfloat *data = (GLfloat*)newOp->opData.data;
	data[0] = angle;
	data[1] = x;
	data[2] = y;
	data[3] = z;
}

void dl_save_Scalef(struct GLContextIFace *Self, GLfloat x, GLfloat y, GLfloat z)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(GLfloat) * 3);

	newOp->opFunc = dl_execute_Scalef;
	GLfloat *data = (GLfloat*)newOp->opData.data;
	data[0] = x;
	data[1] = y;
	data[2] = z;
}

void dl_save_Scissor(struct GLContextIFace *Self, GLint x, GLint y, GLsizei width, GLsizei height)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(ScissorData));

	newOp->opFunc = dl_execute_Scissor;
	ScissorData     *data = (ScissorData*)newOp->opData.data;
	data->x = x;
	data->y = y;
	data->width = width;
	data->height = height;
}

void dl_save_SetState(struct GLContextIFace *Self, GLenum cap, GLboolean flag)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(SetStateData));

	newOp->opFunc = dl_execute_SetState;
	SetStateData *data = (SetStateData*)newOp->opData.data;
	data->cap = cap;
	data->flag = flag;
}

void dl_save_SetZOffset(struct GLContextIFace *Self, GLfloat offset)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(0);

	newOp->opFunc = dl_execute_SetZOffset;
	newOp->opData.f = offset;
}

void dl_save_SetTextureRenderTarget(struct GLContextIFace *Self, GLuint texnum)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(0);

	newOp->opFunc = dl_execute_SetTextureRenderTarget;
	newOp->opData.ui = texnum;
}

void dl_save_ShadeModel(struct GLContextIFace *Self, GLenum mode)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(0);

	newOp->opFunc = dl_execute_ShadeModel;
	newOp->opData.e = mode;
}

void dl_save_StencilFunc(struct GLContextIFace *Self, GLenum func, GLint ref, GLuint mask)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(StencilFuncData));

	newOp->opFunc = dl_execute_StencilFunc;
	StencilFuncData *data = (StencilFuncData*)newOp->opData.data;
	data->func = func;
	data->ref = ref;
	data->mask = mask;
}

void dl_save_StencilMask(struct GLContextIFace *Self, GLuint mask)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(0);

	newOp->opFunc = dl_execute_StencilMask;
	newOp->opData.ui = mask;
}

void dl_save_StencilOp(struct GLContextIFace *Self, GLenum fail, GLenum zfail, GLenum zpass)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(GLenum) * 3);

	newOp->opFunc = dl_execute_StencilOp;
	GLenum *data = (GLenum*)newOp->opData.data;
	data[0] = fail;
	data[1] = zfail;
	data[2] = zpass;
}

void dl_save_TexCoord2f(struct GLContextIFace *Self, GLfloat s, GLfloat t)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(GLfloat) * 2);

	newOp->opFunc = dl_execute_TexCoord2f;
	GLfloat *data = (GLfloat*)newOp->opData.data;
	data[0] = s;
	data[1] = t;
}

void dl_save_TexCoord4f(struct GLContextIFace *Self, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(GLfloat) * 4);

	newOp->opFunc = dl_execute_TexCoord4f;
	GLfloat *data = (GLfloat*)newOp->opData.data;
	data[0] = s;
	data[1] = t;
	data[2] = r;
	data[3] = q;
}

void dl_save_TexEnvi(struct GLContextIFace *Self, GLenum target, GLenum pname, GLint param)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(TexEnviData));

	newOp->opFunc = dl_execute_TexEnvi;
	TexEnviData *data = (TexEnviData*)newOp->opData.data;
	data->target = target;
	data->pname = pname;
	data->param = param;
}

void dl_save_TexEnvfv(struct GLContextIFace *Self, GLenum target, GLenum pname, const GLfloat *params)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(TexEnvfvData));

	newOp->opFunc = dl_execute_TexEnvfv;
	TexEnvfvData *data = (TexEnvfvData*)newOp->opData.data;
	data->target = target;
	data->pname = pname;
	data->params[0] = params[0];
	if (pname == GL_TEXTURE_ENV_COLOR){
		data->params[1] = params[1];
		data->params[2] = params[2];
		data->params[3] = params[3];
	}
}

void dl_save_TexGeni(struct GLContextIFace *Self, GLenum coord, GLenum pname, GLint param)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(TexGeniData));

	newOp->opFunc = dl_execute_TexGeni;
	TexGeniData *data = (TexGeniData*)newOp->opData.data;
	data->coord = coord;
	data->pname = pname;
	data->param = param;
}

void dl_save_TexGenfv(struct GLContextIFace *Self, GLenum coord, GLenum pname, const GLfloat *params)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(TexGenfvData));

	newOp->opFunc = dl_execute_TexGenfv;
	TexGenfvData *data = (TexGenfvData*)newOp->opData.data;
	data->coord = coord;
	data->pname = pname;
	data->params[0] = params[0];
	switch(pname){
		case GL_OBJECT_PLANE:
		case GL_EYE_PLANE:
			data->params[1] = params[1];
			data->params[2] = params[2];
			data->params[3] = params[3];
	}
}

void dl_save_TexImage2D(
	struct GLContextIFace *Self,
	GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format,
	GLenum type, const GLvoid *pixels
)
{
	GLcontext context = GET_INSTANCE(Self);

	GLuint imageSize = dl_imageSize(width, height, border,  format, type);

	NEW_OP(sizeof(TexImage2DData) + imageSize - 1);

	newOp->opFunc = dl_execute_TexImage2D;
	TexImage2DData *data = (TexImage2DData*)newOp->opData.data;
	data->target = target;
	data->level = level;
	data->internalformat = internalformat;
	data->width = width;
	data->height = height;
	data->border = border;
	data->format = format;
	data->type = type;
	dl_copyImage(Self, 0, 0, width, height, border, format, type, pixels, (GLvoid*)data->pixels);
}

void dl_save_TexParameteri(struct GLContextIFace *Self, GLenum target, GLenum pname, const GLint param)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(TexParameteriData));

	newOp->opFunc = dl_execute_TexParameteri;
	TexParameteriData *data = (TexParameteriData*)newOp->opData.data;
	data->target = target;
	data->pname = pname;
	data->param = param;
}

void dl_save_TexSubImage2D(
	struct GLContextIFace *Self,
	GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type,
	const GLvoid *pixels
)
{
	GLcontext context = GET_INSTANCE(Self);

	GLuint imageSize = dl_imageSize(width, height, 0,  format, type);

	NEW_OP(sizeof(TexSubImage2DData) + imageSize - 1);

	newOp->opFunc = dl_execute_TexSubImage2D;
	TexSubImage2DData *data = (TexSubImage2DData*)newOp->opData.data;
	data->target = target;
	data->level = level;
	data->xoffset = xoffset;
	data->yoffset = yoffset;
	data->width = width;
	data->height = height;
	data->format = format;
	data->type = type;
	dl_copyImage(Self, 0, 0, width, height, 0, format, type, pixels, (GLvoid*)data->pixels);
}

void dl_save_Translatef(struct GLContextIFace *Self, GLfloat x, GLfloat y, GLfloat z)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(GLfloat) * 3);

	newOp->opFunc = dl_execute_Translatef;
	GLfloat *data = (GLfloat*)newOp->opData.data;
	data[0] = x;
	data[1] = y;
	data[2] = z;
}

void dl_save_UnpinTexture(struct GLContextIFace *Self, GLuint texnum)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(0);

	newOp->opFunc = dl_execute_UnpinTexture;
	newOp->opData.ui = texnum;
}

void dl_save_Vertex4f(struct GLContextIFace *Self, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(GLfloat) * 4);

	newOp->opFunc = dl_execute_Vertex4f;
	GLfloat *data = (GLfloat*)newOp->opData.data;
	data[0] = x;
	data[1] = y;
	data[2] = z;
	data[3] = w;
}

void dl_save_Viewport(struct GLContextIFace *Self, GLint x, GLint y, GLsizei width, GLsizei height)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(ViewportData));

	newOp->opFunc = dl_execute_Viewport;
	ViewportData *data = (ViewportData*)newOp->opData.data;
	data->x = x;
	data->y = y;
	data->width = width;
	data->height = height;
}

void dl_save_InitNames(struct GLContextIFace *Self)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(0);

	newOp->opFunc = dl_execute_InitNames;
}

void dl_save_LoadName(struct GLContextIFace *Self, GLuint name)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(0);

	newOp->opFunc = dl_execute_LoadName;
	newOp->opData.ui = name;
}


void dl_save_PushName(struct GLContextIFace *Self, GLuint name)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(0);

	newOp->opFunc = dl_execute_PushName;
	newOp->opData.ui = name;
}


void dl_save_PopName(struct GLContextIFace *Self)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(0);

	newOp->opFunc = dl_execute_PopName;
}


void dl_save_Map1f(
	struct GLContextIFace *Self, GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points
)
{
	GLcontext context = GET_INSTANCE(Self);
	GLuint mapK = eval_GetMapK1(target);
	GLuint size = mapK * order * sizeof(GLfloat);

	NEW_OP(sizeof(Map1fData) + size);

	newOp->opFunc = dl_execute_Map1f;

	Map1fData *data = (Map1fData *)newOp->opData.data;
	data->target = target;
	data->u1 = u1;
	data->u2 = u2;
	data->order = order;

	GLfloat *targetData = &data->points[0];
	int i, j;
	for (i = 0; i < order; i++) {
		for (j = 0; j < mapK; j++) {
			*targetData++ = (GLfloat)points[j];
		}
		points += stride;
	}
}

void dl_save_Map1d(struct GLContextIFace *Self, GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
{
	GLcontext context = GET_INSTANCE(Self);
	GLuint mapK = eval_GetMapK1(target);
	GLuint size = mapK * order * sizeof(GLdouble);

	NEW_OP(sizeof(Map1fData) + size);

	newOp->opFunc = dl_execute_Map1d;

	Map1dData *data = (Map1dData *)newOp->opData.data;
	data->target = target;
	data->u1 = u1;
	data->u2 = u2;
	data->order = order;

	GLdouble *targetData = &data->points[0];
	int i, j;
	for (i = 0; i < order; i++) {
		for (j = 0; j < mapK; j++) {
			*targetData++ = (GLdouble)points[j];
		}
		points += stride;
	}
}


void dl_save_EvalCoord1f(struct GLContextIFace *Self, GLfloat arg)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(EvalCoord1Data));

	newOp->opFunc = dl_execute_EvalCoord1f;

	EvalCoord1Data *data = (EvalCoord1Data *)newOp->opData.data;
	data->arg = arg;
}


void dl_save_MapGrid1f(struct GLContextIFace *Self, GLint n, GLfloat u1, GLfloat u2)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(MapGrid1Data));

	newOp->opFunc = dl_execute_MapGrid1f;

	MapGrid1Data *data = (MapGrid1Data *)newOp->opData.data;
	data->n = n;
	data->u1 = u1;
	data->u2 = u2;
}


void dl_save_EvalMesh1(struct GLContextIFace *Self, GLenum mode, GLint p1, GLint p2)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(EvalMesh1Data));

	newOp->opFunc = dl_execute_EvalMesh1;

	EvalMesh1Data *data = (EvalMesh1Data *)newOp->opData.data;
	data->mode = mode;
	data->p1 = p1;
	data->p2 = p2;
}


void dl_save_EvalPoint1(struct GLContextIFace *Self, GLint p)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(EvalPoint1Data));

	newOp->opFunc = dl_execute_EvalPoint1;

	EvalPoint1Data *data = (EvalPoint1Data *)newOp->opData.data;
	data->p = p;
}


void dl_save_Map2f(struct GLContextIFace *Self,
	GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride,
	GLint vorder, const GLfloat *points
)
{
	GLcontext context = GET_INSTANCE(Self);
	GLuint mapK = eval_GetMapK2(target);
	GLuint size = mapK * uorder * vorder * sizeof(GLfloat);

	NEW_OP(sizeof(Map2fData) + size);

	newOp->opFunc = dl_execute_Map2f;

	Map2fData *data = (Map2fData *)newOp->opData.data;
	data->target = target;
	data->u1 = u1;
	data->u2 = u2;
	data->uorder = uorder;
	data->v1 = v1;
	data->v2 = v2;
	data->vorder = vorder;

	GLfloat *targetData = &data->points[0];
	int i, j, k;
	for (i = 0; i < uorder; i++) {
		const GLfloat *oldPoints = points;
		for (j = 0; j < vorder; j++) {
			for (k = 0; k < mapK; k++) {
				*targetData++ = points[k];
			}
			points += vstride;
		}
		points = oldPoints + ustride;
	}
}


void dl_save_Map2d(
	struct GLContextIFace *Self,
	GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride,
	GLint vorder, const GLdouble *points
)
{
	GLcontext context = GET_INSTANCE(Self);
	GLuint mapK = eval_GetMapK2(target);
	GLuint size = mapK * uorder * vorder * sizeof(GLdouble);

	NEW_OP(sizeof(Map2dData) + size);

	newOp->opFunc = dl_execute_Map2d;

	Map2dData *data = (Map2dData *)newOp->opData.data;
	data->target = target;
	data->u1 = u1;
	data->u2 = u2;
	data->uorder = uorder;
	data->v1 = v1;
	data->v2 = v2;
	data->vorder = vorder;

	GLdouble *targetData = &data->points[0];
	int i, j, k;
	for (i = 0; i < uorder; i++) {
		const GLdouble *oldPoints = points;
		for (j = 0; j < vorder; j++) {
			for (k = 0; k < mapK; k++) {
				*targetData++ = points[k];
			}
			points += vstride;
		}
		points = oldPoints + ustride;
	}
}


void dl_save_EvalCoord2f(struct GLContextIFace *Self, GLfloat u, GLfloat v)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(EvalCoord2Data))

	newOp->opFunc = dl_execute_EvalCoord2f;

	EvalCoord2Data *data = (EvalCoord2Data *)newOp->opData.data;
	data->u = u;
	data->v = v;
}


void dl_save_MapGrid2f(struct GLContextIFace *Self, GLint nu, GLfloat u1, GLfloat u2, GLint nv, GLfloat v1, GLfloat v2)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(MapGrid2Data));

	newOp->opFunc = dl_execute_MapGrid2f;

	MapGrid2Data *data = (MapGrid2Data *)newOp->opData.data;
	data->nu = nu;
	data->u1 = u1;
	data->u2 = u2;
	data->nv = nv;
	data->v1 = v1;
	data->v2 = v2;
}


void dl_save_EvalMesh2(struct GLContextIFace *Self, GLenum mode, GLint p1, GLint p2, GLint q1, GLint q2)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(EvalMesh2Data));

	newOp->opFunc = dl_execute_EvalMesh2;

	EvalMesh2Data *data = (EvalMesh2Data *)newOp->opData.data;
	data->mode = mode;
	data->p1 = p1;
	data->p2 = p2;
	data->q1 = q1;
	data->q2 = q2;
}


void dl_save_EvalPoint2(struct GLContextIFace *Self, GLint p, GLint q)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(EvalPoint2Data));

	newOp->opFunc = dl_execute_EvalPoint2;

	EvalPoint2Data *data = (EvalPoint2Data *)newOp->opData.data;
	data->p = p;
	data->q = 1;
}


void dl_save_PixelTransfer(struct GLContextIFace *Self, GLenum param, GLfloat value)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(PixelTransferData));

	newOp->opFunc = dl_execute_PixelTransfer;

	PixelTransferData *data = (PixelTransferData *)newOp->opData.data;
	data->param = param;
	data->value = value;
}

void dl_save_PixelZoom(struct GLContextIFace *Self, GLfloat zx, GLfloat zy)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(PixelZoomData));

	newOp->opFunc = dl_execute_PixelZoom;

	PixelZoomData *data = (PixelZoomData *)newOp->opData.data;
	data->zoom_x = zx;
	data->zoom_y = zy;
}

void dl_save_CopyPixels(struct GLContextIFace *Self, GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(CopyPixelData));

	newOp->opFunc = dl_execute_CopyPixels;

	CopyPixelData *data = (CopyPixelData *)newOp->opData.data;
	data->x = x;
	data->y = y;
	data->width = width;
	data->height = height;
	data->type = type;
}


void dl_save_LogicOp(struct GLContextIFace *Self, GLenum op)
{
	GLcontext context = GET_INSTANCE(Self);

	NEW_OP(sizeof(LogicOpModeData));

	newOp->opFunc = dl_execute_LogicOp;

	LogicOpModeData *data = (LogicOpModeData *)newOp->opData.data;
	data->op = op;
}