draw.c

#include <dma_tags.h>
#include <gif_tags.h>
 
#include <gs_privileged.h>
#include <gs_gp.h>
#include <gs_psm.h>
 
#include <draw.h>
#include <draw2d.h>
 
qword_t *draw_setup_environment(qword_t *q, int context, framebuffer_t *frame, zbuffer_t *z)
{
 
    // Change this if modifying the gif packet after the giftag.
    int qword_count = 15;
 
    atest_t atest;
    dtest_t  dtest;
    ztest_t ztest;
    blend_t blend;
    texwrap_t wrap;
 
    atest.enable = DRAW_ENABLE;
    atest.method = ATEST_METHOD_NOTEQUAL;
    atest.compval = 0x00;
    atest.keep = ATEST_KEEP_FRAMEBUFFER;
 
    dtest.enable = DRAW_DISABLE;
    dtest.pass = DRAW_DISABLE;
 
    // Enable or Disable ZBuffer
    if (z->enable)
    {
        ztest.enable = DRAW_ENABLE;
        ztest.method = z->method;
    }
    else
    {
        z->mask = 1;
        ztest.enable = DRAW_ENABLE;
        ztest.method = ZTEST_METHOD_ALLPASS;
    }
 
    // Setup alpha blending
    blend.color1 = BLEND_COLOR_SOURCE;
    blend.color2 = BLEND_COLOR_DEST;
    blend.alpha  = BLEND_ALPHA_SOURCE;
    blend.color3 = BLEND_COLOR_DEST;
    blend.fixed_alpha = 0x80;
 
    // Setup whole texture clamping
    wrap.horizontal = WRAP_CLAMP;
    wrap.vertical = WRAP_CLAMP;
    wrap.minu = wrap.maxu = 0;
    wrap.minv = wrap.maxv = 0;
 
    // Begin packed gif data packet with another qword.
    PACK_GIFTAG(q,GIF_SET_TAG(qword_count,0,0,0,GIF_FLG_PACKED,1),GIF_REG_AD);
    q++;
    // Framebuffer setting
    PACK_GIFTAG(q, GS_SET_FRAME(frame->address>>11,frame->width>>6,frame->psm,frame->mask), GS_REG_FRAME + context);
    q++;
    // ZBuffer setting
    PACK_GIFTAG(q, GS_SET_ZBUF(z->address>>11,z->zsm,z->mask), GS_REG_ZBUF + context);
    q++;
    // Override Primitive Control
    PACK_GIFTAG(q, GS_SET_PRMODECONT(PRIM_OVERRIDE_DISABLE),GS_REG_PRMODECONT);
    q++;
    // Primitive coordinate offsets
    PACK_GIFTAG(q, GS_SET_XYOFFSET(ftoi4(2048.0f),ftoi4(2048.0f)), GS_REG_XYOFFSET + context);
    q++;
    // Scissoring area
    PACK_GIFTAG(q, GS_SET_SCISSOR(0,frame->width-1,0,frame->height-1), GS_REG_SCISSOR + context);
    q++;
    // Pixel testing
    PACK_GIFTAG(q, GS_SET_TEST(atest.enable,atest.method,atest.compval,atest.keep,
                               dtest.enable,dtest.pass,
                               ztest.enable,ztest.method), GS_REG_TEST + context);
    q++;
    // Fog Color
    PACK_GIFTAG(q, GS_SET_FOGCOL(0,0,0), GS_REG_FOGCOL);
    q++;
    // Per-pixel Alpha Blending (Blends if MSB of ALPHA is true)
    PACK_GIFTAG(q, GS_SET_PABE(DRAW_DISABLE), GS_REG_PABE);
    q++;
    // Alpha Blending
    PACK_GIFTAG(q, GS_SET_ALPHA(blend.color1,blend.color2,blend.alpha,
                                blend.color3,blend.fixed_alpha), GS_REG_ALPHA + context);
    q++;
    // Dithering
    PACK_GIFTAG(q, GS_SET_DTHE(GS_DISABLE), GS_REG_DTHE);
    q++;
    PACK_GIFTAG(q, GS_SET_DIMX(4,2,5,3,0,6,1,7,5,3,4,2,1,7,0,6), GS_REG_DIMX);
    q++;
    // Color Clamp
    PACK_GIFTAG(q,GS_SET_COLCLAMP(GS_ENABLE),GS_REG_COLCLAMP);
    q++;
    // Alpha Correction
    if ((frame->psm == GS_PSM_16) || (frame->psm == GS_PSM_16S))
    {
        PACK_GIFTAG(q,GS_SET_FBA(ALPHA_CORRECT_RGBA16),GS_REG_FBA + context);
        q++;
    }
    else
    {
        PACK_GIFTAG(q,GS_SET_FBA(ALPHA_CORRECT_RGBA32),GS_REG_FBA + context);
        q++;
    }
    // Texture wrapping/clamping
    PACK_GIFTAG(q, GS_SET_CLAMP(wrap.horizontal,wrap.vertical,wrap.minu,
                                wrap.maxu,wrap.minv,wrap.maxv), GS_REG_CLAMP + context);
    q++;
    PACK_GIFTAG(q, GS_SET_TEXA(0x80,ALPHA_EXPAND_NORMAL,0x80),GS_REG_TEXA);
    q++;
 
    return q;
 
}
 
qword_t *draw_disable_tests(qword_t *q, int context, zbuffer_t *z)
{
    (void)z;
 
    PACK_GIFTAG(q,GIF_SET_TAG(1,0,0,0,GIF_FLG_PACKED,1), GIF_REG_AD);
    q++;
    PACK_GIFTAG(q, GS_SET_TEST(DRAW_ENABLE,ATEST_METHOD_NOTEQUAL,0x00,ATEST_KEEP_FRAMEBUFFER,
                               DRAW_DISABLE,DRAW_DISABLE,
                               DRAW_ENABLE,ZTEST_METHOD_ALLPASS), GS_REG_TEST + context);
    q++;
 
    return q;
 
}
 
qword_t *draw_enable_tests(qword_t *q, int context, zbuffer_t *z)
{
 
    PACK_GIFTAG(q,GIF_SET_TAG(1,0,0,0,GIF_FLG_PACKED,1), GIF_REG_AD);
    q++;
    PACK_GIFTAG(q, GS_SET_TEST(DRAW_ENABLE,ATEST_METHOD_NOTEQUAL,0x00,ATEST_KEEP_FRAMEBUFFER,
                               DRAW_DISABLE,DRAW_DISABLE,
                               DRAW_ENABLE,z->method), GS_REG_TEST + context);
    q++;
 
    return q;
 
}
 
qword_t *draw_clear(qword_t *q, int context, float x, float y, float width, float height, int r, int g, int b)
{
 
    rect_t rect;
 
    union{
        float   fvalue;
        u32 ivalue;
    } q0 = {
        1.0f
    };
 
    rect.v0.x = x;
    rect.v0.y = y;
    rect.v0.z = 0x00000000;
 
    rect.color.rgbaq = GS_SET_RGBAQ(r,g,b,0x80,q0.ivalue);
 
    rect.v1.x = x + width - 0.9375f;
    rect.v1.y = y + height - 0.9375f;
    rect.v1.z = 0x00000000;
 
    PACK_GIFTAG(q, GIF_SET_TAG(2,0,0,0,0,1), GIF_REG_AD);
    q++;
    PACK_GIFTAG(q, GS_SET_PRMODECONT(PRIM_OVERRIDE_ENABLE),GS_REG_PRMODECONT);
    q++;
    PACK_GIFTAG(q, GS_SET_PRMODE(0,0,0,0,0,0,context,1), GS_REG_PRMODE);
    q++;
 
    q = draw_rect_filled_strips(q, context, &rect);
 
    PACK_GIFTAG(q, GIF_SET_TAG(1,0,0,0,0,1), GIF_REG_AD);
    q++;
    PACK_GIFTAG(q, GS_SET_PRMODECONT(PRIM_OVERRIDE_DISABLE),GS_REG_PRMODECONT);
    q++;
 
    return q;
 
}
 
qword_t *draw_finish(qword_t *q)
{
 
    PACK_GIFTAG(q,GIF_SET_TAG(1,1,0,0,GIF_FLG_PACKED,1),GIF_REG_AD);
    q++;
    PACK_GIFTAG(q,1,GS_REG_FINISH);
    q++;
 
    return q;
 
}
 
void draw_wait_finish(void)
{
 
    while(!(*GS_REG_CSR & 2));
    *GS_REG_CSR |= 2;
 
}
 
qword_t *draw_texture_flush(qword_t *q)
{
 
    // Flush texture buffer
    DMATAG_END(q,2,0,0,0);
    q++;
    PACK_GIFTAG(q,GIF_SET_TAG(1,1,0,0,GIF_FLG_PACKED,1),GIF_REG_AD);
    q++;
    PACK_GIFTAG(q,1,GS_REG_TEXFLUSH);
    q++;
 
    return q;
 
}
 
qword_t *draw_texture_transfer(qword_t *q, void *src, int width, int height, int psm, int dest, int dest_width)
{
 
    int i;
    int remaining;
    int qwords = 0;
 
    switch (psm)
    {
        case GS_PSM_8:
        {
            qwords = (width*height)>>4;
            break;
        }
 
        case GS_PSM_32:
        case GS_PSM_24:
        {
            qwords = (width*height)>>2;
            break;
        }
 
        case GS_PSM_4:
        {
            qwords = (width*height)>>5;
            break;
        }
 
        case GS_PSM_16:
        case GS_PSM_16S:
        {
            qwords = (width*height)>>3;
            break;
        }
 
        default:
        {
            switch (psm)
            {
                case GS_PSM_8H:
                {
                    qwords = (width*height)>>4;
                    break;
                }
 
                case GS_PSMZ_32:
                case GS_PSMZ_24:
                {
                    qwords = (width*height)>>2;
                    break;
                }
 
                case GS_PSMZ_16:
                case GS_PSMZ_16S:
                {
                    qwords = (width*height)>>3;
                    break;
                }
 
                case GS_PSM_4HL:
                case GS_PSM_4HH:
                {
                    qwords = (width*height)>>5;
                    break;
                }
            }
            break;
        }
    }
 
    // Determine number of iterations based on the number of qwords
    // that can be handled per dmatag
    i = qwords / GIF_BLOCK_SIZE;
 
    // Now calculate the remaining image data left over
    remaining  = qwords % GIF_BLOCK_SIZE;
 
    // Setup the transfer
    DMATAG_CNT(q,5,0,0,0);
    q++;
    PACK_GIFTAG(q,GIF_SET_TAG(4,0,0,0,GIF_FLG_PACKED,1),GIF_REG_AD);
    q++;
    PACK_GIFTAG(q,GS_SET_BITBLTBUF(0,0,0,dest>>6,dest_width>>6,psm),GS_REG_BITBLTBUF);
    q++;
    PACK_GIFTAG(q,GS_SET_TRXPOS(0,0,0,0,0),GS_REG_TRXPOS);
    q++;
    PACK_GIFTAG(q,GS_SET_TRXREG(width,height),GS_REG_TRXREG);
    q++;
    PACK_GIFTAG(q,GS_SET_TRXDIR(0),GS_REG_TRXDIR);
    q++;
 
 
    while(i-- > 0)
    {
 
        // Setup image data dma chain
        DMATAG_CNT(q,1,0,0,0);
        q++;
        PACK_GIFTAG(q,GIF_SET_TAG(GIF_BLOCK_SIZE,0,0,0,2,0),0);
        q++;
        DMATAG_REF(q,GIF_BLOCK_SIZE,(unsigned int)src,0,0,0);
        q++;
 
        //Now increment the address by the number of qwords in bytes
        src = (void *)((u8 *)src + (GIF_BLOCK_SIZE*16));
 
    }
 
    if(remaining)
    {
 
        // Setup remaining image data dma chain
        DMATAG_CNT(q,1,0,0,0);
        q++;
        PACK_GIFTAG(q,GIF_SET_TAG(remaining,0,0,0,2,0),0);
        q++;
        DMATAG_REF(q,remaining,(unsigned int)src,0,0,0);
        q++;
 
    }
 
    return q;
 
}
 
unsigned char draw_log2(unsigned int x)
{
 
    unsigned char res;
 
    __asm__ __volatile__ ("plzcw %0, %1\n\t" : "=r" (res) : "r" (x));
 
    res = 31 - (res + 1);
    res += (x > (unsigned int)(1<<res) ? 1 : 0);
 
    return res;
}