void glTexEnvf (GLenum target, GLenum pname, GLfloat param)
{
if (target != GL_TEXTURE_ENV) {
xe_gl_error("glTexEnvf: unimplemented target\n");
return;
}
if (!xeTmus[xeCurrentTMU].boundtexture) return;
if (!xeTmus[xeCurrentTMU].boundtexture->teximg ) return;
/** Do shader work here !! **/
switch (pname)
{
case GL_TEXTURE_ENV_MODE:
switch ((GLint)param)
{
case GL_REPLACE:
xeTmus[xeCurrentTMU].texture_env_mode = (int)GL_REPLACE;
break;
case GL_MODULATE:
xeTmus[xeCurrentTMU].texture_env_mode = (int)GL_MODULATE;
break;
default:
xe_gl_error("glTexEnvf: unimplemented param\n");
break;
}
break;
default:
xe_gl_error("glTexEnvf: unimplemented pname\n");
break;
}
}
static glXeSurface_t *Xe_AllocTexture(void)
{
int i = 0;
glXeSurface_t *tex;
// find a free texture
for (i = 0; i< XE_MAX_TEXTURE; i++)
{
tex = &glXeSurfaces[i];
// no texture
if (!tex->teximg)
{
Xe_InitTexture(tex);
return tex;
}
// free slot
if (tex->glnum == TEXTURE_SLOT_EMPTY)
{
Xe_InitTexture(tex);
return tex;
}
}
xe_gl_error("Xe_AllocTexture: out of textures!!!\n");
return NULL;
}
static int Gl_Prim_2_Xe_Prim(GLenum mode)
{
// default to this
int ret = XE_PRIMTYPE_TRIANGLELIST;
switch (xe_PrimitiveMode) {
case GL_TRIANGLE_FAN:
case GL_POLYGON:
ret = XE_PRIMTYPE_TRIANGLEFAN;
break;
case GL_TRIANGLES:
ret = XE_PRIMTYPE_TRIANGLELIST;
break;
case GL_TRIANGLE_STRIP:
ret = XE_PRIMTYPE_TRIANGLESTRIP;
break;
case GL_POINTS:
ret = XE_PRIMTYPE_POINTLIST;
break;
case GL_LINES:
ret = XE_PRIMTYPE_LINELIST;
break;
case GL_QUAD_STRIP:
case GL_QUADS:
ret = XE_PRIMTYPE_QUADLIST;
break;
default:
xe_gl_error("Unknow prim : %x\n", mode);
break;
}
return ret;
}
void glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
{
if (type != GL_FLOAT)
xe_gl_error("Unimplemented vertex pointer type");
vertexPointer.size = size;
vertexPointer.type = type;
vertexPointer.stride = stride;
vertexPointer.pointer = (GLvoid *) pointer;
}
static inline int src_format_to_bypp(GLenum format)
{
int ret = 0;
if (format == 1 || format == GL_LUMINANCE)
ret = 1;
else if (format == 3 || format == GL_RGB)
ret = 3;
else if (format == 4 || format == GL_RGBA || format == GL_RGB8)
ret = 4;
else
xe_gl_error ("D3D_FillTextureLevel: illegal format");
if (ret != 4)
printf("src_format_to_bypp %d\n", ret);
return ret;
}
void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
{
if (type != GL_FLOAT)
xe_gl_error("Unimplemented texcoord pointer type\n");
// Packed
if (stride == 0) {
stride = sizeof(float) * size;
}
texCoordPointer[vArray_TMU].size = size;
texCoordPointer[vArray_TMU].type = type;
texCoordPointer[vArray_TMU].stride = stride;
texCoordPointer[vArray_TMU].pointer = (GLvoid *) pointer;
}
void glMatrixMode (GLenum mode) {
switch (mode)
{
case GL_MODELVIEW:
current_matrix = &GLImpl.modelview_matrix;
break;
case GL_PROJECTION:
current_matrix = &GLImpl.projection_matrix;
break;
default:
xe_gl_error ("glMatrixMode: unimplemented mode\n");
break;
}
}
void glBindTexture(GLenum target, GLuint texture)
{
int i;
glXeSurface_t *tex;
if (target != GL_TEXTURE_2D)
return;
xeTmus[xeCurrentTMU].boundtexture = NULL;
// find a texture
for (i = 0; i< XE_MAX_TEXTURE; i++)
{
tex = &glXeSurfaces[i];
if (tex && tex->glnum == texture)
{
xeTmus[xeCurrentTMU].boundtexture = tex;
break;
}
}
// did we find it?
if (!xeTmus[xeCurrentTMU].boundtexture)
{
// nope, so fill in a new one (this will make it work with texture_extension_number)
// (i don't know if the spec formally allows this but id seem to have gotten away with it...)
xeTmus[xeCurrentTMU].boundtexture = Xe_AllocTexture();
// reserve this slot
xeTmus[xeCurrentTMU].boundtexture->glnum = texture;
// ensure that it won't be reused
if (texture > texture_count)
texture_count = texture;
}
// this should never happen
if (!xeTmus[xeCurrentTMU].boundtexture)
xe_gl_error("glBindTexture: out of textures!!!\n");
// dirty the params
xeTmus[xeCurrentTMU].texparamdirty = TRUE;
}
void glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer)
{
if ((type == GL_FLOAT) || (type == GL_UNSIGNED_BYTE)) {
// Packed
if (stride == 0) {
if ( type == GL_FLOAT ) {
stride = sizeof(float) * size;
} else if(type == GL_UNSIGNED_BYTE) {
stride = sizeof(char) * size;
}
}
colorPointer.size = size;
colorPointer.type = type;
colorPointer.stride = stride;
colorPointer.pointer = (GLvoid *) pointer;
} else {
xe_gl_error("Unimplemented color pointer type");
}
}
void glDisableClientState (GLenum array)
{
// switch the pointer to NULL
switch (array)
{
case GL_VERTEX_ARRAY:
vertexPointer.pointer = NULL;
break;
case GL_COLOR_ARRAY:
colorPointer.pointer = NULL;
break;
case GL_TEXTURE_COORD_ARRAY:
texCoordPointer[vArray_TMU].pointer = NULL;
break;
default:
xe_gl_error("Invalid Vertex Array Spec...!\n");
}
}
void glTexImage2D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum pixelformat, GLenum type, const GLvoid *pixels)
{
int format;
int need_texture = 1;
struct XenosSurface * surf = NULL;
if (type != GL_UNSIGNED_BYTE) {
xe_gl_error("glTexImage2D: Unrecognised pixel format\n");
return;
}
if (target != GL_TEXTURE_2D)
return;
if (!xeTmus[xeCurrentTMU].boundtexture) {
printf("No texture bound\n");
return;
}
if (level > 0)
return;
#if 1
int srcbytes = src_format_to_bypp(pixelformat);
int dstbytes = 4;
// validate format
switch (internalformat)
{
case 1:
case GL_LUMINANCE:
dstbytes = 1;
format = XE_FMT_8;
break;
case 3:
case GL_RGB:
dstbytes = 4;
format = XE_FMT_ARGB|XE_FMT_8888;
break;
case 4:
case GL_RGB8:
case GL_RGBA:
dstbytes = 4;
format = XE_FMT_ARGB|XE_FMT_8888;
break;
default:
printf("%X internalformat\n" , internalformat);
xe_gl_error ("invalid texture internal format\n");
return;
}
if (xeTmus[xeCurrentTMU].boundtexture->teximg) {
surf = xeTmus[xeCurrentTMU].boundtexture->teximg;
if ((surf->width != width) || (surf->height != height) || (surf->format != format)) {
need_texture = 1;
// destroy texture
Xe_DestroyTexture(xe, xeTmus[xeCurrentTMU].boundtexture->teximg);
}
else {
need_texture = 0;
}
}
if (need_texture) {
#ifdef USE_TILED_TEXTURE
surf = MyXeCreateTexture(xe, width, height, 0, format, 1);
#else
surf = MyXeCreateTexture(xe, width, height, 0, format, 0);
#endif
xeTmus[xeCurrentTMU].boundtexture->teximg = surf;
}
memset(surf->base, 0xFF, surf->wpitch * surf->hpitch);
xeTmus[xeCurrentTMU].boundtexture->internalformat = internalformat;
uint8_t * surfbuf = (uint8_t*) MyXeSurfaceLockRect(xe, surf, 0, 0, 0, 0, XE_LOCK_WRITE);
uint8_t * srcdata = (uint8_t*) pixels;
uint8_t * dstdata = surfbuf;
int y, x;
check_format(srcbytes, dstbytes);
for (y = 0; y <height; y++) {
dstdata = surfbuf + ((y * width) * dstbytes);
for (x = 0; x < width; x++) {
if (srcbytes == 4) {
if (dstbytes == 4) {
dstdata[0] = srcdata[3];
dstdata[3] = srcdata[2];
dstdata[2] = srcdata[1];
dstdata[1] = srcdata[0];
} else if(dstbytes == 1) {
dstdata[0] = ((int) srcdata[0] + (int) srcdata[1] + (int) srcdata[2] + (int) srcdata[3]) / 3;
}
srcdata += srcbytes;
dstdata += dstbytes;
} else if (srcbytes == 3) {
if (dstbytes == 4) {
dstdata[0] = 0xff;
dstdata[3] = srcdata[2];
dstdata[2] = srcdata[1];
dstdata[1] = srcdata[0];
} else if (dstbytes == 1) {
dstdata[0] = ((int) srcdata[0] + (int) srcdata[1] + (int) srcdata[2]) / 3;
}
srcdata += srcbytes;
dstdata += dstbytes;
} else if (srcbytes == 1) {
if (dstbytes == 1) {
dstdata[0] = srcdata[0];
} else if (dstbytes == 4) {
dstdata[0] = srcdata[0];
dstdata[1] = srcdata[0];
dstdata[2] = srcdata[0];
dstdata[3] = srcdata[0];
}
srcdata += srcbytes;
dstdata += dstbytes;
}
}
}
MyXeSurfaceUnlock(xe, surf);
xeTmus[xeCurrentTMU].boundtexture->dirty = 1;
#endif
handle_small_surface(surf, NULL);
}
void glTexImage2D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum pixelformat, GLenum type, const GLvoid *pixels)
{
D3DFORMAT format;
int need_texture = 1;
GLTexture * surf= NULL;
if (type != GL_UNSIGNED_BYTE) {
xe_gl_error("glTexImage2D: Unrecognised pixel format\n");
return;
}
if (target != GL_TEXTURE_2D)
return;
if (!GLImpl.tmus[GLImpl.current_tmu].boundtexture) {
printf("No texture bound\n");
return;
}
#if 1 // no mipmap
if (level > 0)
return;
#endif
GLImpl.device->SetTexture(0, NULL);
int srcbytes = src_format_to_bypp(pixelformat);
int dstbytes = 4;
// validate format
switch (internalformat)
{
case 1:
case GL_LUMINANCE:
dstbytes = 1;
//format = D3DFMT_LIN_L8;
format = D3DFMT_L8;
break;
case 3:
case GL_RGB8:
case GL_RGB:
dstbytes = 4;
//format = D3DFMT_LIN_A8R8G8B8;
format = D3DFMT_A8R8G8B8;
break;
case 4:
case GL_RGBA:
case GL_RGBA8:
dstbytes = 4;
//format = D3DFMT_LIN_A8R8G8B8;
format = D3DFMT_A8R8G8B8;
break;
default:
printf("%X internalformat\n" , internalformat);
xe_gl_error ("invalid texture internal format\n");
return;
}
if (level > 0) {
need_texture = 0;
}
if (GLImpl.tmus[GLImpl.current_tmu].boundtexture->teximg && level == 0) {
D3DSURFACE_DESC desc;
surf = GLImpl.tmus[GLImpl.current_tmu].boundtexture->teximg;
surf->GetLevelDesc(level, &desc);
if ((desc.Width != width) || (desc.Height != height) || (desc.Format != format)) {
need_texture = 1;
// destroy texture
delete GLImpl.tmus[GLImpl.current_tmu].boundtexture->teximg;
}
else {
need_texture = 0;
}
}
if (need_texture) {
surf = new GLTexture(width, height, format);
GLImpl.tmus[GLImpl.current_tmu].boundtexture->teximg = surf;
} else {
surf = GLImpl.tmus[GLImpl.current_tmu].boundtexture->teximg;
}
// lock texture
surf->lockTexture(level);
memset(surf->getData(), 0x00, surf->getPitch() * height);
GLImpl.tmus[GLImpl.current_tmu].boundtexture->internalformat = internalformat;
BYTE * surfbuf = (BYTE*) surf->getData();
BYTE * srcdata = (BYTE*) pixels;
BYTE * dstdata = surfbuf;
check_format(srcbytes, dstbytes);
copyImage(0, 0, width, height, srcdata, srcbytes, surfbuf, dstbytes);
surf->unlockTexture(level);
GLImpl.tmus[GLImpl.current_tmu].boundtexture->dirty = 1;
}
