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; }