← Back to branch summary

~ubuntu-branches/ubuntu/dapper/vice/dapper

« back to all changes in this revision

Viewing changes to src/raster/raster-sprite-status.c

  • Committer: Bazaar Package Importer
  • Author(s): Zed Pobre
  • Date: 2004-08-26 13:35:51 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20040826133551-gcje8j31q5cqgdq2
Tags: 1.14-3
Apply patch from Spiro Trikaliotis <vice@trikaliotis.net> to fix a
problem that some users were experiencing with a floating point
exception on startup related to the fullscreen option being enabled
during compile.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/raster/raster-sprite-status.c
3
3
 *
4
4
 * Written by
5
5
 *  Ettore Perazzoli <ettore@comm2000.it>
 
6
 *  Andreas Boose <viceteam@t-online.de>
6
7
 *
7
8
 * This file is part of VICE, the Versatile Commodore Emulator.
8
9
 * See README for copyright notice.
27
28
#include "vice.h"
28
29
 
29
30
#include <stdio.h>
 
31
#include <string.h>
30
32
 
 
33
#include "lib.h"
 
34
#include "raster-sprite-cache.h"
31
35
#include "raster-sprite-status.h"
32
36
#include "raster-sprite.h"
 
37
#include "raster.h"
33
38
#include "types.h"
34
 
#include "utils.h"
35
 
 
36
 
void raster_sprite_status_init(raster_sprite_status_t *s,
37
 
                               unsigned int num_sprites)
 
39
 
 
40
 
 
41
static void raster_sprite_status_init(raster_sprite_status_t *status,
 
42
                                      unsigned int num_sprites)
 
43
{
 
44
    status->num_sprites = num_sprites;
 
45
    status->cache_init_func = raster_sprite_cache_init;
 
46
 
 
47
    status->draw_function = NULL;
 
48
    status->draw_partial_function = NULL;
 
49
    status->cache_function = NULL;
 
50
 
 
51
    if (num_sprites > 0) {
 
52
        status->sprites = lib_malloc(sizeof(*status->sprites) * num_sprites);
 
53
        status->sprite_data_1 = lib_malloc(sizeof(DWORD) * num_sprites);
 
54
        status->sprite_data_2 = lib_malloc(sizeof(DWORD) * num_sprites);
 
55
    } else {
 
56
        status->sprites = NULL;
 
57
        status->sprite_data_1 = NULL;
 
58
        status->sprite_data_2 = NULL;
 
59
    }
 
60
 
 
61
    raster_sprite_status_reset(status);
 
62
}
 
63
 
 
64
static void raster_sprite_status_shutdown(raster_sprite_status_t *status,
 
65
                                          unsigned int num_sprites)
 
66
{
 
67
    if (num_sprites > 0) {
 
68
        lib_free(status->sprites);
 
69
        lib_free(status->sprite_data_1);
 
70
        lib_free(status->sprite_data_2);
 
71
    }
 
72
}
 
73
 
 
74
void raster_sprite_status_new(raster_t *raster, unsigned int num_sprites)
 
75
{
 
76
    raster->sprite_status = (raster_sprite_status_t *)lib_malloc(
 
77
                            sizeof(raster_sprite_status_t));
 
78
    raster_sprite_status_init(raster->sprite_status, num_sprites);
 
79
}
 
80
 
 
81
void raster_sprite_status_destroy(raster_t *raster)
 
82
{
 
83
    if (raster->sprite_status) {
 
84
        raster_sprite_status_shutdown(raster->sprite_status,
 
85
                                      raster->sprite_status->num_sprites);
 
86
        lib_free(raster->sprite_status);
 
87
    }
 
88
}
 
89
 
 
90
void raster_sprite_status_reset(raster_sprite_status_t *status)
38
91
{
39
92
    unsigned int i;
40
93
 
41
 
    s->num_sprites = num_sprites;
42
 
 
43
 
    s->draw_function = NULL;
44
 
 
45
 
    s->visible_msk = 0;
46
 
    s->dma_msk = 0;
47
 
    s->new_dma_msk = 0;
48
 
 
49
 
    s->mc_sprite_color_1 = 0;
50
 
    s->mc_sprite_color_2 = 0;
51
 
 
52
 
    if (num_sprites > 0) {
53
 
        s->sprites = xmalloc (sizeof (*s->sprites) * num_sprites);
54
 
        s->sprite_data_1 = xmalloc (sizeof (DWORD) * num_sprites);
55
 
        s->sprite_data_2 = xmalloc (sizeof (DWORD) * num_sprites);
56
 
    } else {
57
 
        s->sprites = NULL;
58
 
        s->sprite_data_1 = NULL;
59
 
        s->sprite_data_2 = NULL;
60
 
    }
61
 
 
62
 
    s->sprite_data = s->sprite_data_1;
63
 
    s->new_sprite_data = s->sprite_data_2;
64
 
 
65
 
    for (i = 0; i < num_sprites; i++)
66
 
        raster_sprite_init (&s->sprites[i]);
67
 
}
68
 
 
69
 
raster_sprite_status_t *raster_sprite_status_new (unsigned int num_sprites)
70
 
{
71
 
    raster_sprite_status_t *new_status;
72
 
 
73
 
    new_status
74
 
        = (raster_sprite_status_t *)xmalloc(sizeof(raster_sprite_status_t));
75
 
    raster_sprite_status_init(new_status, num_sprites);
76
 
 
77
 
    return new_status;
 
94
    status->visible_msk = 0;
 
95
    status->dma_msk = 0;
 
96
    status->new_dma_msk = 0;
 
97
 
 
98
    status->mc_sprite_color_1 = 0;
 
99
    status->mc_sprite_color_2 = 0;
 
100
 
 
101
    memset(status->sprite_data_1, 0, sizeof(DWORD) * status->num_sprites);
 
102
    memset(status->sprite_data_2, 0, sizeof(DWORD) * status->num_sprites);
 
103
 
 
104
    status->sprite_data = status->sprite_data_1;
 
105
    status->new_sprite_data = status->sprite_data_2;
 
106
 
 
107
    for (i = 0; i < status->num_sprites; i++)
 
108
        raster_sprite_reset(&status->sprites[i]);
78
109
}
79
110
 
80
111
void raster_sprite_status_set_draw_function(raster_sprite_status_t *status,
83
114
    status->draw_function = function;
84
115
}
85
116
 
 
117
void raster_sprite_status_set_cache_function(raster_sprite_status_t *status,
 
118
                                raster_sprite_status_cache_function_t function)
 
119
{
 
120
    status->cache_function = function;
 
121
}
 
122
 
 
123
void raster_sprite_status_set_draw_partial_function(raster_sprite_status_t *status,
 
124
                                raster_sprite_status_draw_partial_function_t function)
 
125
{
 
126
    status->draw_partial_function = function;
 
127
}