main.c File Reference

#include <kernel.h>
#include <malloc.h>
#include <tamtypes.h>
#include <gs_psm.h>
#include <dma.h>
#include <packet2.h>
#include <packet2_utils.h>
#include <graph.h>
#include <draw.h>
#include "zbyszek.c"
#include "mesh_data.c"

Include dependency graph for main.c:

Go to the source code of this file.

Functions
void	calculate_cube (texbuffer_t *t_texbuff)
void	draw_cube (VECTOR t_object_position, texbuffer_t *t_texbuff)
void	init_gs (framebuffer_t *t_frame, zbuffer_t *t_z, texbuffer_t *t_texbuff)
void	init_drawing_environment (framebuffer_t *t_frame, zbuffer_t *t_z)
void	send_texture (texbuffer_t *texbuf)
void	clear_screen (framebuffer_t *frame, zbuffer_t *z)
void	set_lod_clut_prim_tex_buff (texbuffer_t *t_texbuff)
void	render (framebuffer_t *t_frame, zbuffer_t *t_z, texbuffer_t *t_texbuff)
void	vu1_set_double_buffer_settings ()
void	vu1_upload_micro_program ()
int	main (int argc, char **argv)

Variables
unsigned char	zbyszek []
u32	VU1Draw3D_CodeStart
u32	VU1Draw3D_CodeEnd
VECTOR	object_rotation = {0.00f, 0.00f, 0.00f, 1.00f}
VECTOR	camera_position = {140.00f, 140.00f, 40.00f, 1.00f}
VECTOR	camera_rotation = {0.00f, 0.00f, 0.00f, 1.00f}
MATRIX	local_world
MATRIX	world_view
MATRIX	view_screen
MATRIX	local_screen
packet2_t *	vif_packets [2]
packet2_t *	curr_vif_packet
packet2_t *	zbyszek_packet
u8	context = 0
prim_t	prim
clutbuffer_t	clut
lod_t	lod
VECTOR *	c_verts
VECTOR *	c_sts

Function Documentation

calculate_cube()

void calculate_cube

(

texbuffer_t *

t_texbuff

)

Calculate packet for cube data

Definition at line 95 of file main.c.

{
        packet2_add_float(zbyszek_packet, 2048.0F);                                       // scale
        packet2_add_float(zbyszek_packet, 2048.0F);                                       // scale
        packet2_add_float(zbyszek_packet, ((float)0xFFFFFF) / 32.0F); // scale
        packet2_add_s32(zbyszek_packet, faces_count);                             // vertex count
        packet2_utils_gif_add_set(zbyszek_packet, 1);
        packet2_utils_gs_add_lod(zbyszek_packet, &lod);
        packet2_utils_gs_add_texbuff_clut(zbyszek_packet, t_texbuff, &clut);
        packet2_utils_gs_add_prim_giftag(zbyszek_packet, &prim, faces_count, DRAW_STQ2_REGLIST, 3, 0);
        u8 j = 0; // RGBA
        for (j = 0; j < 4; j++)
                packet2_add_u32(zbyszek_packet, 128);
}

References clut, DRAW_STQ2_REGLIST, faces_count, lod, packet2_add_float(), packet2_add_s32(), packet2_add_u32(), packet2_utils_gif_add_set(), packet2_utils_gs_add_lod(), packet2_utils_gs_add_prim_giftag(), packet2_utils_gs_add_texbuff_clut(), prim, and zbyszek_packet.

Referenced by render().

clear_screen()

void clear_screen	(	framebuffer_t *	frame,
		zbuffer_t *	z
	)

Send packet which will clear our screen.

Definition at line 206 of file main.c.

{
        packet2_t *clear = packet2_create(35, P2_TYPE_NORMAL, P2_MODE_NORMAL, 0);
 
        // Clear framebuffer but don't update zbuffer.
        packet2_update(clear, draw_disable_tests(clear->next, 0, z));
        packet2_update(clear, draw_clear(clear->next, 0, 2048.0f - 320.0f, 2048.0f - 256.0f, frame->width, frame->height, 0x40, 0x40, 0x40));
        packet2_update(clear, draw_enable_tests(clear->next, 0, z));
        packet2_update(clear, draw_finish(clear->next));
 
        // Now send our current dma chain.
        dma_wait_fast();
        dma_channel_send_packet2(clear, DMA_CHANNEL_GIF, 1);
 
        packet2_free(clear);
 
        // Wait for scene to finish drawing
        draw_wait_finish();
}

References DMA_CHANNEL_GIF, dma_channel_send_packet2(), dma_wait_fast(), draw_clear(), draw_disable_tests(), draw_enable_tests(), draw_finish(), draw_wait_finish(), framebuffer_t::height, packet2_t::next, P2_MODE_NORMAL, P2_TYPE_NORMAL, packet2_create(), packet2_free(), packet2_update(), and framebuffer_t::width.

Referenced by render().

draw_cube()

void draw_cube	(	VECTOR	t_object_position,
		texbuffer_t *	t_texbuff
	)

Calculate cube position and add packet with cube data

Definition at line 111 of file main.c.

{
        create_local_world(local_world, t_object_position, object_rotation);
        create_world_view(world_view, camera_position, camera_rotation);
        create_local_screen(local_screen, local_world, world_view, view_screen);
        curr_vif_packet = vif_packets[context];
        packet2_reset(curr_vif_packet, 0);
 
        // Add matrix at the beggining of VU mem (skip TOP)
        packet2_utils_vu_add_unpack_data(curr_vif_packet, 0, &local_screen, 8, 0);
 
        u32 vif_added_bytes = 0; // zero because now we will use TOP register (double buffer)
                                                         // we don't wan't to unpack at 8 + beggining of buffer, but at
                                                         // the beggining of the buffer
 
        // Merge packets
        packet2_utils_vu_add_unpack_data(curr_vif_packet, vif_added_bytes, zbyszek_packet->base, packet2_get_qw_count(zbyszek_packet), 1);
        vif_added_bytes += packet2_get_qw_count(zbyszek_packet);
 
        // Add vertices
        packet2_utils_vu_add_unpack_data(curr_vif_packet, vif_added_bytes, c_verts, faces_count, 1);
        vif_added_bytes += faces_count; // one VECTOR is size of qword
 
        // Add sts
        packet2_utils_vu_add_unpack_data(curr_vif_packet, vif_added_bytes, c_sts, faces_count, 1);
        vif_added_bytes += faces_count;
 
        packet2_utils_vu_add_start_program(curr_vif_packet, 0);
        packet2_utils_vu_add_end_tag(curr_vif_packet);
        dma_channel_wait(DMA_CHANNEL_VIF1, 0);
        dma_channel_send_packet2(curr_vif_packet, DMA_CHANNEL_VIF1, 1);
 
        // Switch packet, so we can proceed during DMA transfer
        context = !context;
}

References packet2_t::base, c_sts, c_verts, camera_position, camera_rotation, context, create_local_screen(), create_local_world(), create_world_view(), curr_vif_packet, dma_channel_send_packet2(), DMA_CHANNEL_VIF1, dma_channel_wait(), faces_count, local_screen, local_world, object_rotation, packet2_get_qw_count(), packet2_reset(), packet2_utils_vu_add_end_tag(), packet2_utils_vu_add_start_program(), packet2_utils_vu_add_unpack_data(), view_screen, vif_packets, world_view, and zbyszek_packet.

Referenced by render().

init_drawing_environment()

void init_drawing_environment	(	framebuffer_t *	t_frame,
		zbuffer_t *	t_z
	)

Some initialization of GS 2

Definition at line 174 of file main.c.

{
        packet2_t *packet2 = packet2_create(20, P2_TYPE_NORMAL, P2_MODE_NORMAL, 0);
 
        // This will setup a default drawing environment.
        packet2_update(packet2, draw_setup_environment(packet2->next, 0, t_frame, t_z));
 
        // Now reset the primitive origin to 2048-width/2,2048-height/2.
        packet2_update(packet2, draw_primitive_xyoffset(packet2->next, 0, (2048 - 320), (2048 - 256)));
 
        // Finish setting up the environment.
        packet2_update(packet2, draw_finish(packet2->next));
 
        // Now send the packet, no need to wait since it's the first.
        dma_channel_send_packet2(packet2, DMA_CHANNEL_GIF, 1);
        dma_wait_fast();
 
        packet2_free(packet2);
}

References DMA_CHANNEL_GIF, dma_channel_send_packet2(), dma_wait_fast(), draw_finish(), draw_primitive_xyoffset(), draw_setup_environment(), packet2_t::next, P2_MODE_NORMAL, P2_TYPE_NORMAL, packet2_create(), packet2_free(), and packet2_update().

Referenced by main().

init_gs()

void init_gs	(	framebuffer_t *	t_frame,
		zbuffer_t *	t_z,
		texbuffer_t *	t_texbuff
	)

Some initialization of GS and VRAM allocation

Definition at line 148 of file main.c.

{
        // Define a 32-bit 640x512 framebuffer.
        t_frame->width = 640;
        t_frame->height = 512;
        t_frame->mask = 0;
        t_frame->psm = GS_PSM_32;
        t_frame->address = graph_vram_allocate(t_frame->width, t_frame->height, t_frame->psm, GRAPH_ALIGN_PAGE);
 
        // Enable the zbuffer.
        t_z->enable = DRAW_ENABLE;
        t_z->mask = 0;
        t_z->method = ZTEST_METHOD_GREATER_EQUAL;
        t_z->zsm = GS_ZBUF_32;
        t_z->address = graph_vram_allocate(t_frame->width, t_frame->height, t_z->zsm, GRAPH_ALIGN_PAGE);
 
        // Allocate some vram for the texture buffer
        t_texbuff->width = 128;
        t_texbuff->psm = GS_PSM_24;
        t_texbuff->address = graph_vram_allocate(128, 128, GS_PSM_24, GRAPH_ALIGN_BLOCK);
 
        // Initialize the screen and tie the first framebuffer to the read circuits.
        graph_initialize(t_frame->address, t_frame->width, t_frame->height, t_frame->psm, 0, 0);
}

References framebuffer_t::address, zbuffer_t::address, texbuffer_t::address, DRAW_ENABLE, zbuffer_t::enable, GRAPH_ALIGN_BLOCK, GRAPH_ALIGN_PAGE, graph_initialize(), graph_vram_allocate(), GS_PSM_24, GS_PSM_32, GS_ZBUF_32, framebuffer_t::height, framebuffer_t::mask, zbuffer_t::mask, zbuffer_t::method, framebuffer_t::psm, texbuffer_t::psm, framebuffer_t::width, texbuffer_t::width, zbuffer_t::zsm, and ZTEST_METHOD_GREATER_EQUAL.

Referenced by main().

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 350 of file main.c.

{
 
        // Init DMA channels.
        dma_channel_initialize(DMA_CHANNEL_GIF, NULL, 0);
        dma_channel_initialize(DMA_CHANNEL_VIF1, NULL, 0);
        dma_channel_fast_waits(DMA_CHANNEL_GIF);
        dma_channel_fast_waits(DMA_CHANNEL_VIF1);
 
        // Initialize vif packets
        zbyszek_packet = packet2_create(10, P2_TYPE_NORMAL, P2_MODE_CHAIN, 1);
        vif_packets[0] = packet2_create(11, P2_TYPE_NORMAL, P2_MODE_CHAIN, 1);
        vif_packets[1] = packet2_create(11, P2_TYPE_NORMAL, P2_MODE_CHAIN, 1);
 
        vu1_upload_micro_program();
        vu1_set_double_buffer_settings();
 
        // The buffers to be used.
        framebuffer_t frame;
        zbuffer_t z;
        texbuffer_t texbuff;
 
        // Init the GS, framebuffer, zbuffer, and texture buffer.
        init_gs(&frame, &z, &texbuff);
 
        // Init the drawing environment and framebuffer.
        init_drawing_environment(&frame, &z);
 
        // Load the texture into vram.
        send_texture(&texbuff);
 
        // Render textured cube
        render(&frame, &z, &texbuff);
 
        packet2_free(vif_packets[0]);
        packet2_free(vif_packets[1]);
        packet2_free(zbyszek_packet);
 
        // Sleep
        SleepThread();
 
        // End program.
        return 0;
}

References dma_channel_fast_waits(), DMA_CHANNEL_GIF, dma_channel_initialize(), DMA_CHANNEL_VIF1, init_drawing_environment(), init_gs(), NULL, P2_MODE_CHAIN, P2_TYPE_NORMAL, packet2_create(), packet2_free(), render(), send_texture(), SleepThread(), vif_packets, vu1_set_double_buffer_settings(), vu1_upload_micro_program(), and zbyszek_packet.

render()

void render	(	framebuffer_t *	t_frame,
		zbuffer_t *	t_z,
		texbuffer_t *	t_texbuff
	)

Allocate some space for object position calculating. c_ prefix = calc_

Definition at line 257 of file main.c.

{
        int i, j;
 
        set_lod_clut_prim_tex_buff(t_texbuff);
 
        c_verts = (VECTOR *)memalign(128, sizeof(VECTOR) * faces_count);
        c_sts = (VECTOR *)memalign(128, sizeof(VECTOR) * faces_count);
 
        VECTOR c_zbyszek_position;
 
        for (i = 0; i < faces_count; i++)
        {
                c_verts[i][0] = vertices[faces[i]][0];
                c_verts[i][1] = vertices[faces[i]][1];
                c_verts[i][2] = vertices[faces[i]][2];
                c_verts[i][3] = vertices[faces[i]][3];
 
                c_sts[i][0] = sts[faces[i]][0];
                c_sts[i][1] = sts[faces[i]][1];
                c_sts[i][2] = sts[faces[i]][2];
                c_sts[i][3] = sts[faces[i]][3];
        }
 
        // Create the view_screen matrix.
        create_view_screen(view_screen, graph_aspect_ratio(), -3.00f, 3.00f, -3.00f, 3.00f, 1.00f, 2000.00f);
        calculate_cube(t_texbuff);
 
        // The main loop...
        for (;;)
        {
                // Spin the cube a bit.
                object_rotation[0] += 0.008f;
                while (object_rotation[0] > 3.14f)
                {
                        object_rotation[0] -= 6.28f;
                }
                object_rotation[1] += 0.012f;
                while (object_rotation[1] > 3.14f)
                {
                        object_rotation[1] -= 6.28f;
                }
 
                camera_position[2] += .5F;
                camera_rotation[2] += 0.002f;
                if (camera_position[2] >= 400.0F)
                {
                        camera_position[2] = 40.0F;
                        camera_rotation[2] = 0.00f;
                }
 
                clear_screen(t_frame, t_z);
 
                for (i = 0; i < 8; i++)
                {
                        c_zbyszek_position[0] = i * 40.0F;
                        for (j = 0; j < 8; j++)
                        {
                                c_zbyszek_position[1] = j * 40.0F;
                                draw_cube(c_zbyszek_position, t_texbuff);
                        }
                }
 
                graph_wait_vsync();
        }
}

References c_sts, c_verts, calculate_cube(), camera_position, camera_rotation, clear_screen(), create_view_screen(), draw_cube(), faces, faces_count, graph_aspect_ratio(), graph_wait_vsync(), object_rotation, set_lod_clut_prim_tex_buff(), sts, vertices, and view_screen.

Referenced by main().

send_texture()

void send_texture

(

texbuffer_t *

texbuf

)

Send texture data to GS.

Definition at line 195 of file main.c.

{
        packet2_t *packet2 = packet2_create(50, P2_TYPE_NORMAL, P2_MODE_CHAIN, 0);
        packet2_update(packet2, draw_texture_transfer(packet2->next, zbyszek, 128, 128, GS_PSM_24, texbuf->address, texbuf->width));
        packet2_update(packet2, draw_texture_flush(packet2->next));
        dma_channel_send_packet2(packet2, DMA_CHANNEL_GIF, 1);
        dma_wait_fast();
        packet2_free(packet2);
}

References texbuffer_t::address, DMA_CHANNEL_GIF, dma_channel_send_packet2(), dma_wait_fast(), draw_texture_flush(), draw_texture_transfer(), GS_PSM_24, packet2_t::next, P2_MODE_CHAIN, P2_TYPE_NORMAL, packet2_create(), packet2_free(), packet2_update(), texbuffer_t::width, and zbyszek.

Referenced by main().

set_lod_clut_prim_tex_buff()

void set_lod_clut_prim_tex_buff

(

texbuffer_t *

t_texbuff

)

Definition at line 226 of file main.c.

{
        lod.calculation = LOD_USE_K;
        lod.max_level = 0;
        lod.mag_filter = LOD_MAG_NEAREST;
        lod.min_filter = LOD_MIN_NEAREST;
        lod.l = 0;
        lod.k = 0;
 
        clut.storage_mode = CLUT_STORAGE_MODE1;
        clut.start = 0;
        clut.psm = 0;
        clut.load_method = CLUT_NO_LOAD;
        clut.address = 0;
 
        // Define the triangle primitive we want to use.
        prim.type = PRIM_TRIANGLE;
        prim.shading = PRIM_SHADE_GOURAUD;
        prim.mapping = DRAW_ENABLE;
        prim.fogging = DRAW_DISABLE;
        prim.blending = DRAW_ENABLE;
        prim.antialiasing = DRAW_DISABLE;
        prim.mapping_type = PRIM_MAP_ST;
        prim.colorfix = PRIM_UNFIXED;
 
        t_texbuff->info.width = draw_log2(128);
        t_texbuff->info.height = draw_log2(128);
        t_texbuff->info.components = TEXTURE_COMPONENTS_RGB;
        t_texbuff->info.function = TEXTURE_FUNCTION_DECAL;
}

References clutbuffer_t::address, prim_t::antialiasing, prim_t::blending, lod_t::calculation, clut, CLUT_NO_LOAD, CLUT_STORAGE_MODE1, prim_t::colorfix, texinfo_t::components, DRAW_DISABLE, DRAW_ENABLE, draw_log2(), prim_t::fogging, texinfo_t::function, texinfo_t::height, texbuffer_t::info, lod_t::k, lod_t::l, clutbuffer_t::load_method, lod, LOD_MAG_NEAREST, LOD_MIN_NEAREST, LOD_USE_K, lod_t::mag_filter, prim_t::mapping, prim_t::mapping_type, lod_t::max_level, lod_t::min_filter, prim, PRIM_MAP_ST, PRIM_SHADE_GOURAUD, PRIM_TRIANGLE, PRIM_UNFIXED, clutbuffer_t::psm, prim_t::shading, clutbuffer_t::start, clutbuffer_t::storage_mode, TEXTURE_COMPONENTS_RGB, TEXTURE_FUNCTION_DECAL, prim_t::type, and texinfo_t::width.

Referenced by render().

vu1_set_double_buffer_settings()

void vu1_set_double_buffer_settings

(

)

Definition at line 328 of file main.c.

{
        packet2_t *packet2 = packet2_create(1, P2_TYPE_NORMAL, P2_MODE_CHAIN, 1);
        packet2_utils_vu_add_double_buffer(packet2, 8, 496);
        packet2_utils_vu_add_end_tag(packet2);
        dma_channel_send_packet2(packet2, DMA_CHANNEL_VIF1, 1);
        dma_channel_wait(DMA_CHANNEL_VIF1, 0);
        packet2_free(packet2);
}

References dma_channel_send_packet2(), DMA_CHANNEL_VIF1, dma_channel_wait(), P2_MODE_CHAIN, P2_TYPE_NORMAL, packet2_create(), packet2_free(), packet2_utils_vu_add_double_buffer(), and packet2_utils_vu_add_end_tag().

Referenced by main().

vu1_upload_micro_program()

void vu1_upload_micro_program

(

)

Definition at line 338 of file main.c.

{
        u32 packet_size =
                packet2_utils_get_packet_size_for_program(&VU1Draw3D_CodeStart, &VU1Draw3D_CodeEnd) + 1; // + 1 for end tag
        packet2_t *packet2 = packet2_create(packet_size, P2_TYPE_NORMAL, P2_MODE_CHAIN, 1);
        packet2_vif_add_micro_program(packet2, 0, &VU1Draw3D_CodeStart, &VU1Draw3D_CodeEnd);
        packet2_utils_vu_add_end_tag(packet2);
        dma_channel_send_packet2(packet2, DMA_CHANNEL_VIF1, 1);
        dma_channel_wait(DMA_CHANNEL_VIF1, 0);
        packet2_free(packet2);
}

References dma_channel_send_packet2(), DMA_CHANNEL_VIF1, dma_channel_wait(), P2_MODE_CHAIN, P2_TYPE_NORMAL, packet2_create(), packet2_free(), packet2_utils_get_packet_size_for_program(), packet2_utils_vu_add_end_tag(), packet2_vif_add_micro_program(), VU1Draw3D_CodeEnd, and VU1Draw3D_CodeStart.

Referenced by main().

Variable Documentation

c_sts

VECTOR * c_sts

Definition at line 92 of file main.c.

Referenced by draw_cube(), and render().

c_verts

VECTOR* c_verts

Helper arrays. Needed for calculations.

Definition at line 92 of file main.c.

Referenced by draw_cube(), and render().

camera_position

VECTOR camera_position = {140.00f, 140.00f, 40.00f, 1.00f}

Definition at line 55 of file main.c.

Referenced by draw_cube(), and render().

camera_rotation

VECTOR camera_rotation = {0.00f, 0.00f, 0.00f, 1.00f}

Definition at line 56 of file main.c.

Referenced by draw_cube(), and render().

clut

clutbuffer_t clut

Color look up table. Needed for texture.

Definition at line 80 of file main.c.

Referenced by calculate_cube(), draw_clutbuffer(), draw_texturebuffer(), packet2_utils_gs_add_texbuff_clut(), run_demo(), set_lod_clut_prim_tex_buff(), and setup_texture().

context

u8 context = 0

Definition at line 71 of file main.c.

Referenced by draw_alpha_blending(), draw_alpha_correction(), draw_arc_filled(), draw_arc_outline(), draw_clear(), draw_clutbuffer(), draw_cube(), draw_disable_tests(), draw_enable_tests(), draw_framebuffer(), draw_line(), draw_mipmap1(), draw_mipmap2(), draw_pixel_test(), draw_point(), draw_prim_start(), draw_primitive_override_setting(), draw_primitive_xyoffset(), draw_rect_filled(), draw_rect_filled_strips(), draw_rect_outline(), draw_rect_textured(), draw_rect_textured_strips(), draw_round_rect_filled(), draw_round_rect_outline(), draw_scissor_area(), draw_setup_environment(), draw_texture_sampling(), draw_texture_wrapping(), draw_texturebuffer(), draw_triangle_filled(), draw_triangle_outline(), draw_zbuffer(), fontstudio_print_string(), fontx_print_ascii(), fontx_print_sjis(), graph_set_framebuffer(), GsClearDrawEnv1(), GsClearDrawEnv2(), packet2_utils_gs_add_prim_giftag(), render(), and run_demo().

curr_vif_packet

packet2_t* curr_vif_packet

Definition at line 66 of file main.c.

Referenced by draw_cube().

local_screen

MATRIX local_screen

Definition at line 57 of file main.c.

Referenced by calculate_vertices(), create_local_screen(), draw_cube(), render(), and render_teapot().

local_world

MATRIX local_world

Definition at line 57 of file main.c.

Referenced by create_local_screen(), create_local_world(), draw_cube(), render(), and render_teapot().

lod

lod_t lod

Level of details. Needed for texture.

Definition at line 86 of file main.c.

Referenced by calculate_cube(), draw_texture_sampling(), packet2_utils_gs_add_lod(), run_demo(), set_lod_clut_prim_tex_buff(), and setup_texture().

object_rotation

VECTOR object_rotation = {0.00f, 0.00f, 0.00f, 1.00f}

Definition at line 54 of file main.c.

Referenced by draw_cube(), and render().

prim

prim_t prim

Set GS primitive type of drawing.

Definition at line 74 of file main.c.

Referenced by calculate_cube(), draw_prim_start(), draw_primitive_override_setting(), packet2_utils_gs_add_prim_giftag(), render(), render_teapot(), and set_lod_clut_prim_tex_buff().

view_screen

MATRIX view_screen

Definition at line 57 of file main.c.

Referenced by create_local_screen(), create_view_screen(), draw_cube(), render(), and render_teapot().

vif_packets

packet2_t* vif_packets[2]

Packets for sending VU data Each packet will have: a) View/Projection matrix (calculated every frame) b) Cube data (prim,lod,vertices,sts,...) added from zbyszek_packet.

Definition at line 65 of file main.c.

Referenced by draw_cube(), and main().

VU1Draw3D_CodeEnd

u32 VU1Draw3D_CodeEnd

extern

Referenced by vu1_upload_micro_program().

VU1Draw3D_CodeStart

u32 VU1Draw3D_CodeStart

extern

Data of VU1 micro program (draw_3D.vcl/vsm). How we can use it:

1. Upload program to VU1.
2. Send calculated local_screen matrix once per mesh (3D object)
3. Set buffers size. (double-buffering described below)
4. Send packet with: lod, clut, tex buffer, scale vector, rgba, verts and sts. What this program is doing?

1. Load local_screen.
2. Zero clipping flag.
3. Set current buffer start address from TOP register (xtop command) To use pararelism, we set two buffers in the VU1. It means, that when VU1 is working with one verts packet, we can load second one into another buffer. xtop command is automatically switching buffers. I think that AAA games used quad buffers (TOP+TOPS) which can give best performance and no VIF_FLUSH should be needed.
4. Load rest of data.
5. Prepare GIF tag.
6. For every vertex: transform, clip, scale, perspective divide.
7. Send it to GS via XGKICK command.

Referenced by vu1_upload_micro_program().

world_view

MATRIX world_view

Definition at line 57 of file main.c.

Referenced by create_local_screen(), create_world_view(), draw_cube(), render(), and render_teapot().

zbyszek

unsigned char zbyszek[]

extern

Data of our texture (24bit, RGB8)

Referenced by send_texture().

zbyszek_packet

packet2_t* zbyszek_packet

Cube data

Definition at line 69 of file main.c.

Referenced by calculate_cube(), draw_cube(), and main().