source: rtems/c/src/lib/libbsp/arm/nds/libnds/source/arm9/videoGL.c @ 9b4422a2

/*---------------------------------------------------------------------------------
        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 <nds/jtypes.h>
#include <nds/memory.h>
#include <nds/bios.h>
#include <nds/arm9/math.h>
#include <nds/arm9/video.h>
#include <nds/arm9/videoGL.h>
#include <nds/arm9/trig_lut.h>

// 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<<x))), f32tot16 (mulf32(v,inttof32(8<<y))));
}

//---------------------------------------------------------------------------------
// glTexParameter although named the same
//      as its gl counterpart it is not compatible
//      Effort may be made in the future to make it so.
//---------------------------------------------------------------------------------
void glTexParameter(    uint8 sizeX, uint8 sizeY,
                                                const uint32* addr,
                                                GL_TEXTURE_TYPE_ENUM mode,
                                                uint32 param) {
//---------------------------------------------------------------------------------
        glGlob->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;
}