void game_init(GameState* gs) {
// Bind tiles vbo
glGenBuffers(1, &gs->tiles_vbo);
glBindBuffer(GL_ARRAY_BUFFER, gs->tiles_vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(TILES_VBO)*sizeof(float), TILES_VBO, GL_STATIC_DRAW);
gs->tiles_sheet = bitmap_load("bmp/tiles.bmp");
gs->tiles_program = pipeline_new(
shader_new(SHADER_VERTEX, "shader/tiles.vert"),
shader_new(SHADER_FRAGMENT, "shader/tiles.frag"));
pipeline_attribute(gs->tiles_program, "coord", 0);
pipeline_attribute(gs->tiles_program, "st", 1);
pipeline_uniform(gs->tiles_program, "pos", 0);
pipeline_uniform(gs->tiles_program, "tex", 1);
pipeline_uniform(gs->tiles_program, "tile", 2);
// Bind player vbo
glGenBuffers(1, &gs->player_vbo);
glBindBuffer(GL_ARRAY_BUFFER, gs->player_vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(PLAYER_VBO)*sizeof(float), PLAYER_VBO, GL_STATIC_DRAW);
// load player spritesheet
gs->player_spritesheet = bitmap_load("bmp/player.bmp");
gs->player_x = gs->player_y = 0;
gs->player_vx = gs->player_vy = 0;
// create player render pipeline
gs->player_program = pipeline_new(
shader_new(SHADER_VERTEX, "shader/player.vert"),
shader_new(SHADER_FRAGMENT, "shader/player.frag"));
pipeline_attribute(gs->player_program, "coord", 0);
pipeline_attribute(gs->player_program, "st", 1);
pipeline_uniform(gs->player_program, "pos", 0);
pipeline_uniform(gs->player_program, "tex", 1);
pipeline_uniform(gs->player_program, "dir", 2);
// Load audio stuff
gs->bounce_sound = sound_load("sound/bounce.ogg");
gs->ouch_sound = sound_load("sound/ouch.ogg");
alGenSources(1, &gs->player_source);
// Entity stuff
gs->num_entities = 1;
gs->ent[0].vbo = gs->player_vbo;
gs->ent[0].spritesheet = gs->player_spritesheet;
gs->ent[0].frame = 0;
gs->ent[0].vx = gs->ent[0].vy = 8;
gs->ent[0].x = gs->ent[0].y = 8;
gs->ent[0].program = gs->player_program;
}
int main(void)
{
struct sched_param param = { .sched_priority = 0 };
FILE * fp;
size_t fb_size;
if (sched_setscheduler(getpid(), SCHED_FIFO, ¶m)) {
perror("failed to set SCHED_FIFO");
return 1;
}
bip = bitmap_load("ball.bmp");
if (!bip) {
perror("Failed to load a bitmap");
return 1;
}
fp = fopen("/dev/fbmm0", "r");
if (!fp) {
perror("Failed to open fb");
return 1;
}
ioctl(fileno(fp), IOCTL_FB_GETRES, &resolution);
fb_size = resolution.height * resolution.pitch + resolution.width * 3;
fb = mmap(NULL, fb_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fileno(fp), 0);
bf = malloc(fb_size);
bouncer();
munmap(fb, 0);
return 0;
}
static void main_window_load(Window *window) {
Layer *root_layer = window_get_root_layer(window);
bitmap_load(root_layer);
date_time_load(root_layer);
battery_load(root_layer);
}
/**
* Load text data, font bitmap and clear list and structure chars
* @return TRUE if it completed successfully or FALSE otherwise
*/
bool
scrolltext_once_init (void)
{
Sint32 i;
fntscroll *schar;
scrolltext_free ();
if (!scrolltext_load ())
{
return FALSE;
}
/* extract scrolltext font bitmap (12,143 bytes) */
if (!bitmap_load
("graphics/bitmap/fonts/font_scrolltext.spr", &fnt_scroll[0], 1,
FONT_SCROLLTEXT_MAXOF_GLYPHS))
{
return FALSE;
}
/* allocate empty string */
if (scrolltext_emtpy == NULL)
{
scrolltext_emtpy = memory_allocation (SCROLLTEXT_EMPTY_LENGTH + 1);
if (scrolltext_emtpy == NULL)
{
LOG_ERR ("scrolltext_emtpy out of memory");
return FALSE;
}
for (i = 0; i < SCROLLTEXT_EMPTY_LENGTH; i++)
{
scrolltext_emtpy[i] = ' ';
}
scrolltext_emtpy[i] = '\0';
}
/* allocate chars elements */
if (scrolltext_chars == NULL)
{
scrolltext_chars =
(fntscroll *) memory_allocation (SCROLLTEXT_MAXOF_CHARS *
sizeof (fntscroll));
if (scrolltext_chars == NULL)
{
LOG_ERR ("scrolltext_chars out of memory");
return FALSE;
}
}
/* clear list and chars elements */
for (i = 0; i < SCROLLTEXT_MAXOF_CHARS; i++)
{
schar = &scrolltext_chars[i];
schar->is_enabled = FALSE;
}
scrolltext_numof_chars = 0;
scrolltext_init ();
return TRUE;
}
/*
* Initialize mixer control thread
*/
int mixer_init(void)
{
msgqueue_init(&mixerq);
pthread_t mixerthread;
pthread_mutex_init(&mixer_mutex, NULL);
pthread_cond_init(&state_cond, NULL);
pthread_create(&mixerthread, NULL, (void *) mixer_msg_loop, NULL);
bitmap_load(&volume_control, "gfx/volume.u16");
volume_backing.width = volume_control.width;
volume_backing.height = volume_control.height;
volume_backing.bitmap = malloc(volume_control.width * volume_control.height * sizeof(__u16));
volume_backing.x = 0;
volume_backing.y = 0;
if (!volume_backing.bitmap) {
/* out of memory already, we are in trouble...... */
DBG_PRINTF("mixer: out-of-memory\n");
return -1;
}
set_volume(master_volume, master_volume);
return 0;
}
void projectile_list_init(){
if( (projectiles = (projectile_list *)malloc(sizeof(projectile_list))) == NULL)
return;
projectile_img = bitmap_load("projectile.bmp");
projectiles->head = NULL;
return;
}
int bitmap_play(char * filename)
{
char ch;
if (fb_init())
{
printf ("Unable to init framebuffer device\n");
return 2;
}
fb_pixel * bmp_buffer;
if ((bmp_buffer = bitmap_load(filename)) == NULL)
{
fb_uninit();
printf ("Error while reading bitmap\n");
return 1;
}
fb_clear_screen(screen);
bitmap_render(bmp_buffer);
init_keyboard();
ch=0;
while (1)
{
if (!kbhit())
{
ch = readch();
if (ch == KEY_ESC) break;
if (ch == KEY_UP && position_y >= JUMP_SIZE) position_y-=JUMP_SIZE;
if (ch == KEY_DOWN && fb_yres <= (bmp_info.bi_height-position_y-JUMP_SIZE)) position_y+=JUMP_SIZE;
if (ch == KEY_LEFT && position_x >= JUMP_SIZE) position_x-=JUMP_SIZE;
if (ch == KEY_RIGHT && fb_xres <= (bmp_info.bi_width-position_x-JUMP_SIZE)) position_x+=JUMP_SIZE;
ch = 0;
bitmap_render(bmp_buffer);
}
}
close_keyboard();
fflush(stdin);
fb_clear_screen(screen);
bitmap_free(bmp_buffer);
fb_uninit();
return 0;
}
void start_menu_init(){
start_menu = create_menu("spaceinvader_font_transparent.bmp");
button* singleplayer = create_button(512, 250, 500, 90, ALIGN_CENTER, &start_menu_singleplayer_on_click, "Singleplayer", rgb(0xFFFFFF), ALIGN_CENTER);
menu_add_button(start_menu, singleplayer);
button* multiplayer = create_button(512, 350, 500, 90, ALIGN_CENTER, &start_menu_multiplayer_on_click, "Multiplayer", rgb(0xFFFFFF), ALIGN_CENTER);
menu_add_button(start_menu, multiplayer);
button* highscore = create_button(512, 450, 500, 90, ALIGN_CENTER, &start_menu_highscore_on_click, "Highscores", rgb(0xFFFFFF), ALIGN_CENTER);
menu_add_button(start_menu, highscore);
button* options = create_button(512, 550, 500, 90, ALIGN_CENTER, &start_menu_options_on_click, "Options", rgb(0xFFFFFF), ALIGN_CENTER);
menu_add_button(start_menu, options);
button* exit = create_button(512, 650, 500, 90, ALIGN_CENTER, &start_menu_exit_on_click, "Exit", rgb(0xFFFFFF), ALIGN_CENTER);
menu_add_button(start_menu, exit);
title = bitmap_load("title.bmp");
}
void boot_init(int* argc, char** argv) {
int error;
fail_if(glfwInit() == false);
// OpenGL version 3
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3);
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 0);
// No window resize
glfwOpenWindowHint(GLFW_WINDOW_NO_RESIZE, true);
// 400% gameboy scale, 5 bit rgb with 1 bit alpha, 8 bit z buffer
fail_if(glfwOpenWindow(160 * 4, 144 * 4, 5, 5, 5, 1, 8, 0, GLFW_WINDOW) == false);
glfwSetWindowTitle("");
glfwEnable(GLFW_AUTO_POLL_EVENTS); // Automatically poll input on swap
glfwSwapInterval(1); // 0: vsync off, 1: vsync on
printf("Renderer: %s\n", glGetString(GL_RENDERER));
printf("GL Version: %s\n", glGetString(GL_VERSION));
printf("Using GLSL: %s\n", glGetString(GL_SHADING_LANGUAGE_VERSION));
error = glewInit();
if (error != GLEW_OK) {
fprintf(stderr, "GLEW error: %s\n", glewGetErrorString(error));
}
printf("GL Extension Wrangler: %s\n", glewGetString(GLEW_VERSION));
// Load audio
fail_if(alutInit(argc, argv) == false);
glClearColor(206.0/255.0, 230.0/255.0, 165.0/255.0, 1.0f);
glEnable(GL_SCISSOR_TEST); // For geom culling
// transparency
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// z-buffer
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
// Set up perspective
glOrtho(0, 160, 144, 0, -1.0, 1.0);
glDepthRange(-1.0f, 1.0f);
glViewport(0, 0, 160 * 4, 144 * 4);
// This is where Ill put the logo thing
unsigned logo = bitmap_load("bmp/logo.bmp");
unsigned logo_vbo;
float t0, t1, dt;
float logo_x = 16, logo_y = -80;
float logo_v[] = {
0, 0, 0, 1.0 - 0,
0, 128, 0, 1.0 - 1,
128, 128, 1, 1.0 - 1,
128, 0, 1, 1.0 - 0,
};
glGenBuffers(1, &logo_vbo);
glBindBuffer(GL_ARRAY_BUFFER, logo_vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(logo_v)*sizeof(float), logo_v, GL_STATIC_DRAW);
Pipeline* logo_program = pipeline_new(
shader_new(SHADER_VERTEX, "shader/logo.vert"),
shader_new(SHADER_FRAGMENT, "shader/logo.frag"));
pipeline_attribute(logo_program, "coord", 0);
pipeline_attribute(logo_program, "st", 1);
pipeline_uniform(logo_program, "pos", 0);
pipeline_uniform(logo_program, "tex", 1);
glUseProgram(logo_program->id);
// Bind the logo to texture 0
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, logo);
glUniform1i(logo_program->uniform[1], 0);
// Bind logo vbo
glBindBuffer(GL_ARRAY_BUFFER, logo_vbo);
glEnableVertexAttribArray(logo_program->attribute[0]);
glVertexAttribPointer(logo_program->attribute[0], 2, GL_FLOAT, false, 4*sizeof(float), (void*)0);
glEnableVertexAttribArray(logo_program->attribute[1]);
glVertexAttribPointer(logo_program->attribute[1], 2, GL_FLOAT, false, 4*sizeof(float), (void*)(2 * sizeof(float)));
// load sound
unsigned sound_source;
alGenSources(1, &sound_source);
Sound* ding = sound_load("sound/ding.ogg");
alSourcei(sound_source, AL_BUFFER, ding->buffer);
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
glfwSwapBuffers();
sleep(1);
t0 = glfwGetTime();
while (logo_y < 8) {
t1 = glfwGetTime();
dt = t1 - t0;
t0 = t1;
logo_y += 50 * dt;
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
glUniform2f(logo_program->uniform[0], roundf(logo_x), roundf(logo_y));
// Render logo
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
glfwSwapBuffers();
}
alSourcePlay(sound_source);
glDisableVertexAttribArray(logo_program->attribute[0]);
glDisableVertexAttribArray(logo_program->attribute[1]);
sleep(1);
}
static int simplefs_fill_super(struct super_block *sb, void *data, int silent) {
struct buffer_head *bh;
struct simplefs_super *rsb;
struct simplefs_super_info *sbi;
struct inode *root;
int i, j, cnt, ret = 0;
printk(KERN_INFO "simplefs_fill_super\n");
if (!(bh = sb_bread(sb, SIMPLEFS_SUPER_BNO))) {
printk(KERN_ERR "Simplefs: unable to read superblock\n");
return -ENOMEM;
}
sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
if (!sbi) {
ret = -ENOMEM;
goto out;
}
sbi->s_sb = bh;
memcpy(&sbi->raw_super, bh->b_data, sizeof(sbi->raw_super));
sb->s_fs_info = sbi;
sb->s_blocksize = SIMPLEFS_BLOCKSIZE;
sb->s_flags = sb->s_flags & ~MS_POSIXACL;
/*
* set up enough so that it can read an inode
*/
sb->s_op = &simplefs_super_operations;
root = simplefs_iget(sb, SIMPLEFS_ROOT_INO);
if (!root) {
printk(KERN_ERR "Simplefs: corrupt root inode\n");
ret = -EINVAL;
goto failed_root;
}
printk(KERN_INFO "simplefs_fill_super -> simplefs_iget ok: %ld\n", root->i_ino);
sb->s_root = d_alloc_root(root);
if (!sb->s_root) {
iput(root);
printk(KERN_ERR "Simplefs: get root dentry failed\n");
ret = -ENOMEM;
goto failed_root;
}
printk(KERN_INFO "simplefs_fill_super -> d_alloc_root ok\n");
cnt = sbi->raw_super.s_inode_bitmap_blknr + sbi->raw_super.s_block_bitmap_blknr;
if (!(sbi->s_bitmaps = kzalloc(sizeof(struct buffer_head *) * cnt, GFP_KERNEL)))
goto failed_bitmap;
for (i = 0, j = 0; i < cnt; i++) {
if (!(bh = bitmap_load(sb, SIMPLEFS_SUPER_BNO + 1 + i)))
goto failed_load;
sbi->s_bitmaps[j++] = bh;
printk(KERN_INFO "simplefs_fill_super bitmap ok:%d -> %d\n", cnt, i);
}
rsb = &sbi->raw_super;
printk("fill super ok: (inode %d %d %d) (block %d %d %d)\n",
rsb->s_inode_bitmap_blknr, rsb->s_inode_blknr, rsb->s_free_inodes_count,
rsb->s_block_bitmap_blknr, rsb->s_block_blknr, rsb->s_free_blocks_count);
return 0;
failed_load:
for (i = 0; i < j; i++) {
brelse(sbi->s_bitmaps[i]);
}
failed_bitmap:
dput(sb->s_root);
failed_root:
kfree(sbi);
out:
brelse(bh);
sbi->s_sb = NULL;
printk("simplefs get sb failed.\n");
return ret;
}
void alien_list_init() {
direction = 1;
if ((invaders = (alien_list*) malloc(sizeof(alien_list))) == NULL)
return;
invaders->head = NULL;
invaders->last = NULL;
invaders->movement_frequency = INITIAL_MOV_FREQ;
ufo = NULL;
unsigned char row_pos;
unsigned char line = 0;
unsigned char counter;
int x = INITIAL_X_POS;
int y = INITIAL_Y_POS;
enum alien_type type;
for (counter = 0; counter < ALIENS_PER_ROW * ALIEN_ROWS; counter++) {
if (counter % ALIENS_PER_ROW == 0) {
y += ALIEN_HEIGHT + ALIEN_SPACEMENT;
x = INITIAL_X_POS;
line++;
}
else
x += ALIEN_WIDTH + ALIEN_SPACEMENT;
switch(line){
case 1:
type = SMALL;
break;
case 2: case 3:
type = MEDIUM;
break;
case 4: case 5:
type = LARGE;
break;
}
alien_add((alien_init(x, y, type)));
}
search_new_extreme(1);
search_new_extreme(2);
//initialize small aliens animation
invaders->small_alien = animation_init();
animation_add_by_filename(invaders->small_alien, "small_invader1.bmp");
animation_add_by_filename(invaders->small_alien, "small_invader2.bmp");
//initialize medium aliens animation
invaders->medium_alien = animation_init();
animation_add_by_filename(invaders->medium_alien, "medium_invader1.bmp");
animation_add_by_filename(invaders->medium_alien, "medium_invader2.bmp");
//initialize large aliens animation
invaders->large_alien = animation_init();
animation_add_by_filename(invaders->large_alien, "large_invader1.bmp");
animation_add_by_filename(invaders->large_alien, "large_invader2.bmp");
//initialize ufo image
ufo_img = bitmap_load("ufo.bmp");
invaders->destroy = animation_init();
animation_add_by_filename(invaders->destroy, "explosion.bmp");
}
int racinix_start()
{
//vg_exit(); // Fix darker colors first time the mode is changed.
vg_init(RACINIX_VIDEO_MODE);
vbe_get_mode_info(RACINIX_VIDEO_MODE, &vmi);
mouse_position = vectorCreate(vmi.XResolution / 2, vmi.YResolution / 2);
// Initialize pointers to NULL so that in case of error the program is terminated properly.
race = NULL;
bitmap_background = NULL;
bitmap_mouse_cursor = NULL;
bitmap_red_car = NULL;
bitmap_blue_car = NULL;
bitmap_credits = NULL;
bitmap_speedometer = NULL;
font_impact = NULL;
ad = NULL;
bitmap_background = bitmap_load(RACINIX_FOLDER_IMAGES "background.bmp");
if (bitmap_background == NULL)
{
return 1;
}
bitmap_mouse_cursor = bitmap_load(RACINIX_FOLDER_IMAGES "cursor.bmp");
if (bitmap_mouse_cursor == NULL)
{
return 1;
}
bitmap_red_car = bitmap_load(RACINIX_FOLDER_IMAGES "red_car.bmp");
if (bitmap_red_car == NULL)
{
return 1;
}
bitmap_blue_car = bitmap_load(RACINIX_FOLDER_IMAGES "blue_car.bmp");
if (bitmap_blue_car == NULL)
{
return 1;
}
bitmap_credits = bitmap_load(RACINIX_FOLDER_IMAGES "credits.bmp");
if (bitmap_credits == NULL)
{
return 1;
}
bitmap_speedometer = bitmap_load(RACINIX_FOLDER_IMAGES "speedometer.bmp");
if (bitmap_speedometer == NULL)
{
return 1;
}
font_impact = font_load(RACINIX_FOLDER_FONTS "impact");
if (font_impact == NULL)
{
return 1;
}
if ((ad = ad_create(RACINIX_FILE_ADS, 120, font_impact, RACINIX_COLOR_ORANGE)) == NULL)
{
return 1;
}
vehicle_keys[0].accelerate = KEY_W;
vehicle_keys[0].brake = KEY_S;
vehicle_keys[0].turn_left = KEY_A;
vehicle_keys[0].turn_right = KEY_D;
vehicle_keys[1].accelerate = KEY_ARR_UP;
vehicle_keys[1].brake = KEY_ARR_DOWN;
vehicle_keys[1].turn_left = KEY_ARR_LEFT;
vehicle_keys[1].turn_right = KEY_ARR_RIGHT;
vehicle_colors[0] = VIDEO_GR_RED;
vehicle_colors[1] = VIDEO_GR_BLUE;
vehicle_bitmaps[0] = bitmap_red_car;
vehicle_bitmaps[1] = bitmap_blue_car;
if (racinix_dispatcher())
{
return 1;
}
return 0;
}
