draw.c File Reference

#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>

Include dependency graph for draw.c:

Go to the source code of this file.

Functions
qword_t *	draw_setup_environment (qword_t *q, int context, framebuffer_t *frame, zbuffer_t *z)
qword_t *	draw_disable_tests (qword_t *q, int context, zbuffer_t *z)
qword_t *	draw_enable_tests (qword_t *q, int context, zbuffer_t *z)
qword_t *	draw_clear (qword_t *q, int context, float x, float y, float width, float height, int r, int g, int b)
qword_t *	draw_finish (qword_t *q)
void	draw_wait_finish (void)
qword_t *	draw_texture_flush (qword_t *q)
qword_t *	draw_texture_transfer (qword_t *q, void *src, int width, int height, int psm, int dest, int dest_width)
unsigned char	draw_log2 (unsigned int x)

Function Documentation

draw_clear()

qword_t* draw_clear	(	qword_t *	q,
		int	context,
		float	x,
		float	y,
		float	width,
		float	height,
		int	r,
		int	g,
		int	b
	)

Clear the screen based on the screen's origin, width, and height using the defined color.

Definition at line 148 of file draw.c.

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

References rect_t::color, context, draw_rect_filled_strips(), GIF_REG_AD, GIF_SET_TAG, GS_REG_PRMODE, GS_REG_PRMODECONT, GS_SET_PRMODE, GS_SET_PRMODECONT, GS_SET_RGBAQ, PACK_GIFTAG, PRIM_OVERRIDE_DISABLE, PRIM_OVERRIDE_ENABLE, color_t::rgbaq, rect_t::v0, rect_t::v1, vertex_t::x, x, vertex_t::y, y, and vertex_t::z.

Referenced by clear_screen(), main(), render(), and run_demo().

draw_disable_tests()

qword_t* draw_disable_tests	(	qword_t *	q,
		int	context,
		zbuffer_t *	z
	)

Disable pixel testing defaults

Definition at line 120 of file draw.c.

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

References ATEST_KEEP_FRAMEBUFFER, ATEST_METHOD_NOTEQUAL, context, DRAW_DISABLE, DRAW_ENABLE, GIF_FLG_PACKED, GIF_REG_AD, GIF_SET_TAG, GS_REG_TEST, GS_SET_TEST, PACK_GIFTAG, and ZTEST_METHOD_ALLPASS.

Referenced by clear_screen(), and render().

draw_enable_tests()

qword_t* draw_enable_tests	(	qword_t *	q,
		int	context,
		zbuffer_t *	z
	)

Enable pixel testing defaults

Definition at line 134 of file draw.c.

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

References ATEST_KEEP_FRAMEBUFFER, ATEST_METHOD_NOTEQUAL, context, DRAW_DISABLE, DRAW_ENABLE, GIF_FLG_PACKED, GIF_REG_AD, GIF_SET_TAG, GS_REG_TEST, GS_SET_TEST, zbuffer_t::method, and PACK_GIFTAG.

Referenced by clear_screen(), and render().

draw_finish()

qword_t* draw_finish

(

qword_t *

q

)

Signal that drawing is finished

Definition at line 188 of file draw.c.

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

References GIF_FLG_PACKED, GIF_REG_AD, GIF_SET_TAG, GS_REG_FINISH, and PACK_GIFTAG.

Referenced by clear_screen(), draw_init_env(), flip_buffers(), init_drawing_environment(), render(), and run_demo().

draw_log2()

unsigned char draw_log2

(

unsigned int

x

)

Returns the power of 2 needed for texture width and height

Definition at line 348 of file draw.c.

{
 
        unsigned char res;
 
        __asm__ __volatile__ ("plzcw %0, %1\n\t" : "=r" (res) : "r" (x));
 
        res = 31 - (res + 1);
        res += (x > (1<<res) ? 1 : 0);
 
        return res;
}

References x.

Referenced by InitCB(), run_demo(), set_lod_clut_prim_tex_buff(), and setup_texture().

draw_setup_environment()

qword_t* draw_setup_environment	(	qword_t *	q,
		int	context,
		framebuffer_t *	frame,
		zbuffer_t *	z
	)

Sets up the drawing environment based on the framebuffer and zbuffer settings

Definition at line 11 of file draw.c.

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

References framebuffer_t::address, zbuffer_t::address, blend_t::alpha, ALPHA_CORRECT_RGBA16, ALPHA_CORRECT_RGBA32, ALPHA_EXPAND_NORMAL, ATEST_KEEP_FRAMEBUFFER, ATEST_METHOD_NOTEQUAL, BLEND_ALPHA_SOURCE, BLEND_COLOR_DEST, BLEND_COLOR_SOURCE, blend_t::color1, blend_t::color2, blend_t::color3, atest_t::compval, context, DRAW_DISABLE, DRAW_ENABLE, zbuffer_t::enable, atest_t::enable, dtest_t::enable, ztest_t::enable, blend_t::fixed_alpha, ftoi4, GIF_FLG_PACKED, GIF_REG_AD, GIF_SET_TAG, GS_DISABLE, GS_ENABLE, GS_PSM_16, GS_PSM_16S, GS_REG_ALPHA, GS_REG_CLAMP, GS_REG_COLCLAMP, GS_REG_DIMX, GS_REG_DTHE, GS_REG_FBA, GS_REG_FOGCOL, GS_REG_FRAME, GS_REG_PABE, GS_REG_PRMODECONT, GS_REG_SCISSOR, GS_REG_TEST, GS_REG_TEXA, GS_REG_XYOFFSET, GS_REG_ZBUF, GS_SET_ALPHA, GS_SET_CLAMP, GS_SET_COLCLAMP, GS_SET_DIMX, GS_SET_DTHE, GS_SET_FBA, GS_SET_FOGCOL, GS_SET_FRAME, GS_SET_PABE, GS_SET_PRMODECONT, GS_SET_SCISSOR, GS_SET_TEST, GS_SET_TEXA, GS_SET_XYOFFSET, GS_SET_ZBUF, framebuffer_t::height, texwrap_t::horizontal, atest_t::keep, framebuffer_t::mask, zbuffer_t::mask, texwrap_t::maxu, texwrap_t::maxv, zbuffer_t::method, atest_t::method, ztest_t::method, texwrap_t::minu, texwrap_t::minv, PACK_GIFTAG, dtest_t::pass, PRIM_OVERRIDE_DISABLE, framebuffer_t::psm, texwrap_t::vertical, framebuffer_t::width, WRAP_CLAMP, zbuffer_t::zsm, and ZTEST_METHOD_ALLPASS.

Referenced by draw_init_env(), init_drawing_environment(), and main().

draw_texture_flush()

qword_t* draw_texture_flush

(

qword_t *

q

)

Flush the texture cache

Definition at line 208 of file draw.c.

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

References DMATAG_END, GIF_FLG_PACKED, GIF_REG_AD, GIF_SET_TAG, GS_REG_TEXFLUSH, and PACK_GIFTAG.

Referenced by init_texture(), load_texture(), and send_texture().

draw_texture_transfer()

qword_t* draw_texture_transfer	(	qword_t *	q,
		void *	src,
		int	width,
		int	height,
		int	psm,
		int	dest,
		int	dest_width
	)

Creates a dma chain filled with image information

Definition at line 223 of file draw.c.

{
 
        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 += (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;
 
}

References DMATAG_CNT, DMATAG_REF, GIF_BLOCK_SIZE, GIF_FLG_PACKED, GIF_REG_AD, GIF_SET_TAG, GS_PSM_16, GS_PSM_16S, GS_PSM_24, GS_PSM_32, GS_PSM_4, GS_PSM_4HH, GS_PSM_4HL, GS_PSM_8, GS_PSM_8H, GS_PSMZ_16, GS_PSMZ_16S, GS_PSMZ_24, GS_PSMZ_32, GS_REG_BITBLTBUF, GS_REG_TRXDIR, GS_REG_TRXPOS, GS_REG_TRXREG, GS_SET_BITBLTBUF, GS_SET_TRXDIR, GS_SET_TRXPOS, GS_SET_TRXREG, and PACK_GIFTAG.

Referenced by init_texture(), load_texture(), and send_texture().

draw_wait_finish()

void draw_wait_finish

(

void

)

Wait until finish event occurs

Definition at line 200 of file draw.c.

{
 
        while(!(*GS_REG_CSR & 2));
        *GS_REG_CSR |= 2;
 
}

References GS_REG_CSR.

Referenced by clear_screen(), flip_buffers(), init_drawing_environment(), render(), and run_demo().