/*--------------------------------------------------------------------------------- $Id$ Video API vaguely similar to OpenGL Copyright (C) 2005 Michael Noland (joat) Jason Rogers (dovoto) Dave Murphy (WinterMute) This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. ---------------------------------------------------------------------------------*/ #include #include #include #include #include #include #include // this is the actual data of the globals for videoGL // Please use the glGlob pointer to access this data since that makes it easier to move stuff in/out of the header. static gl_hidden_globals glGlobalData; // This returns the pointer to the globals for videoGL gl_hidden_globals* glGetGlobals() { return &glGlobalData; } //--------------------------------------------------------------------------------- void glRotatef32i(int angle, int32 x, int32 y, int32 z) { //--------------------------------------------------------------------------------- int32 axis[3]; int32 sine = SIN[angle & LUT_MASK]; int32 cosine = COS[angle & LUT_MASK]; int32 one_minus_cosine = inttof32(1) - cosine; axis[0]=x; axis[1]=y; axis[2]=z; normalizef32(axis); // should require passed in normalized? MATRIX_MULT3x3 = cosine + mulf32(one_minus_cosine, mulf32(axis[0], axis[0])); MATRIX_MULT3x3 = mulf32(one_minus_cosine, mulf32(axis[0], axis[1])) - mulf32(axis[2], sine); MATRIX_MULT3x3 = mulf32(mulf32(one_minus_cosine, axis[0]), axis[2]) + mulf32(axis[1], sine); MATRIX_MULT3x3 = mulf32(mulf32(one_minus_cosine, axis[0]), axis[1]) + mulf32(axis[2], sine); MATRIX_MULT3x3 = cosine + mulf32(mulf32(one_minus_cosine, axis[1]), axis[1]); MATRIX_MULT3x3 = mulf32(mulf32(one_minus_cosine, axis[1]), axis[2]) - mulf32(axis[0], sine); MATRIX_MULT3x3 = mulf32(mulf32(one_minus_cosine, axis[0]), axis[2]) - mulf32(axis[1], sine); MATRIX_MULT3x3 = mulf32(mulf32(one_minus_cosine, axis[1]), axis[2]) + mulf32(axis[0], sine); MATRIX_MULT3x3 = cosine + mulf32(mulf32(one_minus_cosine, axis[2]), axis[2]); } //--------------------------------------------------------------------------------- void glMaterialf(GL_MATERIALS_ENUM mode, rgb color) { //--------------------------------------------------------------------------------- static uint32 diffuse_ambient = 0; static uint32 specular_emission = 0; switch(mode) { case GL_AMBIENT: diffuse_ambient = (color << 16) | (diffuse_ambient & 0xFFFF); break; case GL_DIFFUSE: diffuse_ambient = color | (diffuse_ambient & 0xFFFF0000); break; case GL_AMBIENT_AND_DIFFUSE: diffuse_ambient= color + (color << 16); break; case GL_SPECULAR: specular_emission = color | (specular_emission & 0xFFFF0000); break; case GL_SHININESS: break; case GL_EMISSION: specular_emission = (color << 16) | (specular_emission & 0xFFFF); break; } GFX_DIFFUSE_AMBIENT = diffuse_ambient; GFX_SPECULAR_EMISSION = specular_emission; } //--------------------------------------------------------------------------------- void glInit_C(void) { //--------------------------------------------------------------------------------- glGlob = glGetGlobals(); glGlob->clearColor = 0; // init texture globals glGlob->activeTexture = 0; glGlob->nextBlock = (uint32*)0x06800000; glGlob->nextPBlock = 0; glGlob->nameCount = 1; while (GFX_STATUS & (1<<27)); // wait till gfx engine is not busy // Clear the FIFO GFX_STATUS |= (1<<29); // Clear overflows from list memory glResetMatrixStack(); // prime the vertex/polygon buffers glFlush(0); // reset the control bits GFX_CONTROL = 0; // reset the rear-plane(a.k.a. clear color) to black, ID=0, and opaque glClearColor(0,0,0,31); glClearPolyID(0); // reset stored texture locations glResetTextures(); // reset the depth to it's max glClearDepth(GL_MAX_DEPTH); GFX_TEX_FORMAT = 0; GFX_POLY_FORMAT = 0; glMatrixMode(GL_PROJECTION); glLoadIdentity(); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glMatrixMode(GL_TEXTURE); glLoadIdentity(); } //--------------------------------------------------------------------------------- void glResetTextures(void) { //--------------------------------------------------------------------------------- glGlob->activeTexture = 0; glGlob->nextBlock = (uint32*)0x06800000; glGlob->nextPBlock = 0; glGlob->nameCount = 1; } //--------------------------------------------------------------------------------- // glGenTextures creates integer names for your table // takes n as the number of textures to generate and // a pointer to the names array that it needs to fill. // Returns 1 if succesful and 0 if out of texture names //--------------------------------------------------------------------------------- int glGenTextures(int n, int *names) { //--------------------------------------------------------------------------------- int index = 0; for(index = 0; index < n; index++) { if(glGlob->nameCount >= MAX_TEXTURES) return 0; else names[index] = glGlob->nameCount++; } return 1; } //--------------------------------------------------------------------------------- // glBindTexure sets the current named // texture to the active texture. Target // is ignored as all DS textures are 2D //--------------------------------------------------------------------------------- void glBindTexture(int target, int name) { //--------------------------------------------------------------------------------- if (name == 0) GFX_TEX_FORMAT = 0; else GFX_TEX_FORMAT = glGlob->textures[name]; glGlob->activeTexture = name; } //--------------------------------------------------------------------------------- // glColorTable establishes the location of the current palette. // Roughly follows glColorTableEXT. Association of palettes with // named textures is left to the application. //--------------------------------------------------------------------------------- void glColorTable( uint8 format, uint32 addr ) { //--------------------------------------------------------------------------------- GFX_PAL_FORMAT = addr>>(4-(format==GL_RGB4)); } //--------------------------------------------------------------------------------- //--------------------------------------------------------------------------------- void glTexCoord2f32(int32 u, int32 v) { //--------------------------------------------------------------------------------- int x, y; x = ((glGlob->textures[glGlob->activeTexture]) >> 20) & 7; y = ((glGlob->textures[glGlob->activeTexture]) >> 23) & 7; glTexCoord2t16(f32tot16 (mulf32(u,inttof32(8<textures[glGlob->activeTexture] = param | (sizeX << 20) | (sizeY << 23) | (((uint32)addr >> 3) & 0xFFFF) | (mode << 26); } //--------------------------------------------------------------------------------- //glGetTexturePointer gets a pointer to vram which contains the texture // //--------------------------------------------------------------------------------- void* glGetTexturePointer( int name) { //--------------------------------------------------------------------------------- return (void*) ((glGlob->textures[name] & 0xFFFF) << 3); } //--------------------------------------------------------------------------------- u32 glGetTexParameter(){ //--------------------------------------------------------------------------------- return glGlob->textures[glGlob->activeTexture]; } //--------------------------------------------------------------------------------- inline uint32 alignVal( uint32 val, uint32 to ) { return (val & (to-1))? (val & ~(to-1)) + to : val; } //--------------------------------------------------------------------------------- int getNextPaletteSlot(u16 count, uint8 format) { //--------------------------------------------------------------------------------- // ensure the result aligns on a palette block for this format uint32 result = alignVal(glGlob->nextPBlock, 1<<(4-(format==GL_RGB4))); // convert count to bytes and align to next (smallest format) palette block count = alignVal( count<<1, 1<<3 ); // ensure that end is within palette video mem if( result+count > 0x10000 ) // VRAM_F - VRAM_E return -1; glGlob->nextPBlock = result+count; return (int)result; } //--------------------------------------------------------------------------------- uint16* vramGetBank(uint16 *addr) { //--------------------------------------------------------------------------------- if(addr >= VRAM_A && addr < VRAM_B) return VRAM_A; else if(addr >= VRAM_B && addr < VRAM_C) return VRAM_B; else if(addr >= VRAM_C && addr < VRAM_D) return VRAM_C; else if(addr >= VRAM_D && addr < VRAM_E) return VRAM_D; else if(addr >= VRAM_E && addr < VRAM_F) return VRAM_E; else if(addr >= VRAM_F && addr < VRAM_G) return VRAM_F; else if(addr >= VRAM_G && addr < VRAM_H) return VRAM_H; else if(addr >= VRAM_H && addr < VRAM_I) return VRAM_H; else return VRAM_I; } //--------------------------------------------------------------------------------- int vramIsTextureBank(uint16 *addr) { //--------------------------------------------------------------------------------- uint16* vram = vramGetBank(addr); if(vram == VRAM_A) { if((VRAM_A_CR & 3) == ((VRAM_A_TEXTURE) & 3)) return 1; else return 0; } else if(vram == VRAM_B) { if((VRAM_B_CR & 3) == ((VRAM_B_TEXTURE) & 3)) return 1; else return 0; } else if(vram == VRAM_C) { if((VRAM_C_CR & 3) == ((VRAM_C_TEXTURE) & 3)) return 1; else return 0; } else if(vram == VRAM_D) { if((VRAM_D_CR & 3) == ((VRAM_D_TEXTURE) & 3)) return 1; else return 0; } else return 0; } //--------------------------------------------------------------------------------- uint32* getNextTextureSlot(int size) { //--------------------------------------------------------------------------------- uint32* result = glGlob->nextBlock; glGlob->nextBlock += size >> 2; //uh-oh...out of texture memory in this bank...find next one assigned to textures while(!vramIsTextureBank((uint16*)glGlob->nextBlock - 1) && glGlob->nextBlock <= (uint32*)VRAM_E) { glGlob->nextBlock = (uint32*)vramGetBank((uint16*)result) + (0x20000 >> 2); //next bank result = glGlob->nextBlock; glGlob->nextBlock += size >> 2; } if(glGlob->nextBlock > (uint32*)VRAM_E) { result = 0; } return result; } //--------------------------------------------------------------------------------- // Similer to glTextImage2D from gl it takes a pointer to data // Empty fields and target are unused but provided for code compatibility. // type is simply the texture type (GL_RGB, GL_RGB8 ect...) //--------------------------------------------------------------------------------- int glTexImage2D(int target, int empty1, GL_TEXTURE_TYPE_ENUM type, int sizeX, int sizeY, int empty2, int param, const uint8* texture) { //--------------------------------------------------------------------------------- uint32 size = 0; uint32* addr; uint32 vramTemp; size = 1 << (sizeX + sizeY + 6); switch (type) { case GL_RGB: case GL_RGBA: size = size << 1; break; case GL_RGB4: size = size >> 2; break; case GL_RGB16: size = size >> 1; break; default: break; } addr = getNextTextureSlot(size); if(!addr) return 0; // unlock texture memory vramTemp = vramSetMainBanks(VRAM_A_LCD,VRAM_B_LCD,VRAM_C_LCD,VRAM_D_LCD); if (type == GL_RGB) { // We do GL_RGB as GL_RGBA, but we set each alpha bit to 1 during the copy u16 * src = (u16*)texture; u16 * dest = (u16*)addr; glTexParameter(sizeX, sizeY, addr, GL_RGBA, param); while (size--) { *dest++ = *src | (1 << 15); src++; } } else { // For everything else, we do a straight copy glTexParameter(sizeX, sizeY, addr, type, param); swiCopy((uint32*)texture, addr , size / 4 | COPY_MODE_WORD); } vramRestoreMainBanks(vramTemp); return 1; } //--------------------------------------------------------------------------------- void glTexLoadPal(const u16* pal, u16 count, u32 addr) { //--------------------------------------------------------------------------------- vramSetBankE(VRAM_E_LCD); swiCopy( pal, &VRAM_E[addr>>1] , count / 2 | COPY_MODE_WORD); vramSetBankE(VRAM_E_TEX_PALETTE); } //--------------------------------------------------------------------------------- int gluTexLoadPal(const u16* pal, u16 count, uint8 format) { //--------------------------------------------------------------------------------- int addr = getNextPaletteSlot(count, format); if( addr>=0 ) glTexLoadPal(pal, count, (u32) addr); return addr; }