← Back to branch summary

~ubuntu-branches/ubuntu/quantal/mesa/quantal

« back to all changes in this revision

Viewing changes to src/mesa/drivers/allegro/amesa.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher
  • Date: 2007-02-21 12:44:07 UTC
  • mfrom: (1.2.1 upstream)
  • mto: This revision was merged to the branch mainline in revision 22.
  • Revision ID: james.westby@ubuntu.com-20070221124407-rgcacs32mycrtadl
Import upstream version 6.5.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/mesa/drivers/allegro/amesa.c
1
 
/*
2
 
 * Mesa 3-D graphics library
3
 
 * Version:  3.0
4
 
 * Copyright (C) 1995-1998  Brian Paul
5
 
 *
6
 
 * This library is free software; you can redistribute it and/or
7
 
 * modify it under the terms of the GNU Library General Public
8
 
 * License as published by the Free Software Foundation; either
9
 
 * version 2 of the License, or (at your option) any later version.
10
 
 *
11
 
 * This library is distributed in the hope that it will be useful,
12
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
 
 * Library General Public License for more details.
15
 
 *
16
 
 * You should have received a copy of the GNU Library General Public
17
 
 * License along with this library; if not, write to the Free
18
 
 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19
 
 */
20
 
 
21
 
#include <stdio.h>
22
 
#include <stdlib.h>
23
 
#include <allegro.h>
24
 
#include "buffers.h"
25
 
#include "context.h"
26
 
#include "imports.h"
27
 
#include "matrix.h"
28
 
#include "mtypes.h"
29
 
#include "GL/amesa.h"
30
 
 
31
 
 
32
 
struct amesa_visual
33
 
    {
34
 
    GLvisual   *GLVisual;       /* inherit from GLvisual      */
35
 
    GLboolean   DBFlag;         /* double buffered?           */
36
 
    GLuint      Depth;          /* bits per pixel ( >= 15 )   */
37
 
    };
38
 
 
39
 
 
40
 
struct amesa_buffer
41
 
    {
42
 
    GLframebuffer *GLBuffer;    /* inherit from GLframebuffer */
43
 
    GLuint         Width, Height;
44
 
    BITMAP        *Screen;
45
 
        BITMAP        *Background;
46
 
        BITMAP        *Active;
47
 
    };
48
 
 
49
 
 
50
 
struct amesa_context
51
 
    {
52
 
    GLcontext   *GLContext;     /* inherit from GLcontext     */
53
 
    AMesaVisual  Visual;
54
 
        AMesaBuffer  Buffer;
55
 
    GLuint       ClearColor;
56
 
    GLuint       CurrentColor;
57
 
    };
58
 
 
59
 
 
60
 
static void setup_dd_pointers(GLcontext *ctx);
61
 
 
62
 
 
63
 
/**********************************************************************/
64
 
/*****                   drawing functions                        *****/
65
 
/**********************************************************************/
66
 
 
67
 
#define FLIP(context, y)  (context->Buffer->Height - (y) - 1)
68
 
 
69
 
#include "allegro/generic.h"
70
 
#include "allegro/direct.h"
71
 
 
72
 
 
73
 
/**********************************************************************/
74
 
/*****            15-bit accelerated drawing funcs                *****/
75
 
/**********************************************************************/
76
 
 
77
 
IMPLEMENT_WRITE_RGBA_SPAN(15, unsigned short)
78
 
IMPLEMENT_WRITE_RGB_SPAN(15, unsigned short)
79
 
IMPLEMENT_WRITE_MONO_RGBA_SPAN(15, unsigned short)
80
 
IMPLEMENT_READ_RGBA_SPAN(15, unsigned short)
81
 
IMPLEMENT_WRITE_RGBA_PIXELS(15, unsigned short)
82
 
IMPLEMENT_WRITE_MONO_RGBA_PIXELS(15, unsigned short)
83
 
IMPLEMENT_READ_RGBA_PIXELS(15, unsigned short)
84
 
 
85
 
 
86
 
/**********************************************************************/
87
 
/*****            16-bit accelerated drawing funcs                *****/
88
 
/**********************************************************************/
89
 
 
90
 
IMPLEMENT_WRITE_RGBA_SPAN(16, unsigned short)
91
 
IMPLEMENT_WRITE_RGB_SPAN(16, unsigned short)
92
 
IMPLEMENT_WRITE_MONO_RGBA_SPAN(16, unsigned short)
93
 
IMPLEMENT_READ_RGBA_SPAN(16, unsigned short)
94
 
IMPLEMENT_WRITE_RGBA_PIXELS(16, unsigned short)
95
 
IMPLEMENT_WRITE_MONO_RGBA_PIXELS(16, unsigned short)
96
 
IMPLEMENT_READ_RGBA_PIXELS(16, unsigned short)
97
 
 
98
 
 
99
 
/**********************************************************************/
100
 
/*****            32-bit accelerated drawing funcs                *****/
101
 
/**********************************************************************/
102
 
 
103
 
IMPLEMENT_WRITE_RGBA_SPAN(32, unsigned long)
104
 
IMPLEMENT_WRITE_RGB_SPAN(32, unsigned long)
105
 
IMPLEMENT_WRITE_MONO_RGBA_SPAN(32, unsigned long)
106
 
IMPLEMENT_READ_RGBA_SPAN(32, unsigned long)
107
 
IMPLEMENT_WRITE_RGBA_PIXELS(32, unsigned long)
108
 
IMPLEMENT_WRITE_MONO_RGBA_PIXELS(32, unsigned long)
109
 
IMPLEMENT_READ_RGBA_PIXELS(32, unsigned long)
110
 
 
111
 
 
112
 
/**********************************************************************/
113
 
/*****              Miscellaneous device driver funcs             *****/
114
 
/**********************************************************************/
115
 
 
116
 
static GLboolean set_buffer(GLcontext *ctx, GLframebuffer *buffer, GLuint bit)
117
 
    {
118
 
    AMesaContext context = (AMesaContext)(ctx->DriverCtx);
119
 
    GLboolean    ok      = GL_TRUE;
120
 
 
121
 
    if (bit == DD_FRONT_LEFT_BIT)
122
 
        context->Buffer->Active = context->Buffer->Screen;
123
 
 
124
 
    else if (bit == DD_BACK_LEFT)
125
 
        {
126
 
        if (context->Buffer->Background)
127
 
            context->Buffer->Active = context->Buffer->Background;
128
 
        else
129
 
            ok = GL_FALSE;
130
 
        }
131
 
 
132
 
    else
133
 
        ok = GL_FALSE;
134
 
 
135
 
    return ok;
136
 
    }
137
 
 
138
 
 
139
 
static void get_buffer_size(GLcontext *ctx, GLuint *width, GLuint *height)
140
 
    {
141
 
        AMesaContext context = (AMesaContext)(ctx->DriverCtx);
142
 
 
143
 
    *width  = context->Buffer->Width;
144
 
    *height = context->Buffer->Height;
145
 
    }
146
 
 
147
 
 
148
 
static void viewport(GLcontext *ctx, GLint x, GLint y, GLsizei w, GLsizei h)
149
 
{
150
 
   /* poll for window size change and realloc software Z/stencil/etc if needed */
151
 
   _mesa_ResizeBuffersMESA();
152
 
}
153
 
 
154
 
 
155
 
/**********************************************************************/
156
 
/**********************************************************************/
157
 
 
158
 
static void setup_dd_pointers(GLcontext *ctx)
159
 
        {
160
 
        AMesaContext context = (AMesaContext)(ctx->DriverCtx);
161
 
 
162
 
        /* Initialize all the pointers in the driver struct. Do this whenever */
163
 
        /* a new context is made current or we change buffers via set_buffer! */
164
 
 
165
 
    ctx->Driver.UpdateState   = setup_dd_pointers;
166
 
    ctx->Driver.SetBuffer     = set_buffer;
167
 
    ctx->Driver.GetBufferSize = get_buffer_size;
168
 
    ctx->Driver.Viewport      = viewport;
169
 
 
170
 
    ctx->Driver.Color               = set_color_generic;
171
 
    ctx->Driver.ClearColor          = clear_color_generic;
172
 
    ctx->Driver.Clear               = clear_generic;
173
 
    ctx->Driver.WriteRGBASpan       = write_rgba_span_generic;
174
 
    ctx->Driver.WriteRGBSpan        = write_rgb_span_generic;
175
 
    ctx->Driver.WriteMonoRGBASpan   = write_mono_rgba_span_generic;
176
 
    ctx->Driver.WriteRGBAPixels     = write_rgba_pixels_generic;
177
 
    ctx->Driver.WriteMonoRGBAPixels = write_mono_rgba_pixels_generic;
178
 
    ctx->Driver.ReadRGBASpan        = read_rgba_span_generic;
179
 
    ctx->Driver.ReadRGBAPixels      = read_rgba_pixels_generic;
180
 
 
181
 
    if (context->Buffer->Active != screen)
182
 
        {
183
 
        switch (context->Visual->Depth)
184
 
            {
185
 
            case 15:
186
 
                ctx->Driver.WriteRGBASpan       = write_rgba_span_15;
187
 
                ctx->Driver.WriteRGBSpan        = write_rgb_span_15;
188
 
                ctx->Driver.WriteMonoRGBASpan   = write_mono_rgba_span_15;
189
 
                ctx->Driver.WriteRGBAPixels     = write_rgba_pixels_15;
190
 
                ctx->Driver.WriteMonoRGBAPixels = write_mono_rgba_pixels_15;
191
 
                ctx->Driver.ReadRGBASpan        = read_rgba_span_15;
192
 
                ctx->Driver.ReadRGBAPixels      = read_rgba_pixels_15;
193
 
                break;
194
 
 
195
 
            case 16:
196
 
                ctx->Driver.WriteRGBASpan       = write_rgba_span_16;
197
 
                ctx->Driver.WriteRGBSpan        = write_rgb_span_16;
198
 
                ctx->Driver.WriteMonoRGBASpan   = write_mono_rgba_span_16;
199
 
                ctx->Driver.WriteRGBAPixels     = write_rgba_pixels_16;
200
 
                ctx->Driver.WriteMonoRGBAPixels = write_mono_rgba_pixels_16;
201
 
                ctx->Driver.ReadRGBASpan        = read_rgba_span_16;
202
 
                ctx->Driver.ReadRGBAPixels      = read_rgba_pixels_16;
203
 
                break;
204
 
 
205
 
            case 32:
206
 
                ctx->Driver.WriteRGBASpan       = write_rgba_span_32;
207
 
                ctx->Driver.WriteRGBSpan        = write_rgb_span_32;
208
 
                ctx->Driver.WriteMonoRGBASpan   = write_mono_rgba_span_32;
209
 
                ctx->Driver.WriteRGBAPixels     = write_rgba_pixels_32;
210
 
                ctx->Driver.WriteMonoRGBAPixels = write_mono_rgba_pixels_32;
211
 
                ctx->Driver.ReadRGBASpan        = read_rgba_span_32;
212
 
                ctx->Driver.ReadRGBAPixels      = read_rgba_pixels_32;
213
 
                break;
214
 
            }
215
 
        }
216
 
        }
217
 
 
218
 
 
219
 
/**********************************************************************/
220
 
/*****                AMesa Public API Functions                  *****/
221
 
/**********************************************************************/
222
 
 
223
 
 
224
 
AMesaVisual AMesaCreateVisual(GLboolean dbFlag, GLint depth,
225
 
                              GLint depthSize, GLint stencilSize, GLint accumSize)
226
 
        {
227
 
        AMesaVisual visual;
228
 
    GLbyte      redBits, greenBits, blueBits;
229
 
 
230
 
    visual = (AMesaVisual)calloc(1, sizeof(struct amesa_visual));
231
 
        if (!visual)
232
 
        return NULL;
233
 
 
234
 
    switch (depth)
235
 
        {
236
 
        case 15:
237
 
            redBits   = 5;
238
 
            greenBits = 5;
239
 
            blueBits  = 5;
240
 
            break;
241
 
 
242
 
        case 16:
243
 
            redBits   = 5;
244
 
            greenBits = 6;
245
 
            blueBits  = 5;
246
 
            break;
247
 
 
248
 
        case 24: case 32:
249
 
            redBits   = 8;
250
 
            greenBits = 8;
251
 
            blueBits  = 8;
252
 
            break;
253
 
 
254
 
        default:
255
 
            free(visual);
256
 
            return NULL;
257
 
        }
258
 
 
259
 
    visual->DBFlag   = dbFlag;
260
 
    visual->Depth    = depth;
261
 
    visual->GLVisual = _mesa_create_visual(GL_TRUE,    /* rgb mode       */
262
 
                                           dbFlag,     /* db_flag        */
263
 
                                           GL_FALSE,   /* stereo         */
264
 
                                           redBits, greenBits, blueBits, 8,
265
 
                                           0,          /* index bits     */
266
 
                                           depthSize,  /* depth bits     */
267
 
                                           stencilSize,/* stencil bits   */
268
 
                                           accumSize,  /* accum bits     */
269
 
                                           accumSize,  /* accum bits     */
270
 
                                           accumSize,  /* accum bits     */
271
 
                                           accumSize,  /* accum bits     */
272
 
                                           1 );
273
 
    if (!visual->GLVisual)
274
 
        {
275
 
        free(visual);
276
 
        return NULL;
277
 
        }
278
 
 
279
 
        return visual;
280
 
        }
281
 
 
282
 
 
283
 
void AMesaDestroyVisual(AMesaVisual visual)
284
 
        {
285
 
           _mesa_destroy_visual(visual->GLVisual);
286
 
           free(visual);
287
 
        }
288
 
 
289
 
 
290
 
AMesaBuffer AMesaCreateBuffer(AMesaVisual visual,
291
 
                                                          GLint width, GLint height)
292
 
        {
293
 
        AMesaBuffer buffer;
294
 
 
295
 
    buffer = (AMesaBuffer)calloc(1, sizeof(struct amesa_buffer));
296
 
        if (!buffer)
297
 
        return NULL;
298
 
 
299
 
        buffer->Screen     = NULL;
300
 
        buffer->Background = NULL;
301
 
        buffer->Active     = NULL;
302
 
        buffer->Width      = width;
303
 
        buffer->Height     = height;
304
 
 
305
 
        if (visual->DBFlag)
306
 
                {
307
 
                buffer->Background = create_bitmap_ex(visual->Depth, width, height);
308
 
                if (!buffer->Background)
309
 
                        {
310
 
                        free(buffer);
311
 
                        return NULL;
312
 
                        }
313
 
                }
314
 
 
315
 
    buffer->GLBuffer = _mesa_create_framebuffer(visual->GLVisual);
316
 
    if (!buffer->GLBuffer)
317
 
        {
318
 
        if (buffer->Background) destroy_bitmap(buffer->Background);
319
 
        free(buffer);
320
 
        return NULL;
321
 
        }
322
 
 
323
 
        return buffer;
324
 
        }
325
 
 
326
 
 
327
 
void AMesaDestroyBuffer(AMesaBuffer buffer)
328
 
{
329
 
   if (buffer->Screen)     destroy_bitmap(buffer->Screen);
330
 
   if (buffer->Background) destroy_bitmap(buffer->Background);
331
 
   _mesa_destroy_framebuffer(buffer->GLBuffer);
332
 
   free(buffer);
333
 
}
334
 
 
335
 
 
336
 
AMesaContext AMesaCreateContext(AMesaVisual visual,
337
 
                                AMesaContext share)
338
 
{
339
 
        AMesaContext context;
340
 
        GLboolean    direct = GL_FALSE;
341
 
 
342
 
        context = (AMesaContext)calloc(1, sizeof(struct amesa_context));
343
 
        if (!context)
344
 
                return NULL;
345
 
 
346
 
        context->Visual       = visual;
347
 
        context->Buffer           = NULL;
348
 
        context->ClearColor   = 0;
349
 
        context->CurrentColor = 0;
350
 
        context->GLContext    = _mesa_create_context(visual->GLVisual,
351
 
                                              share ? share->GLContext : NULL,
352
 
                                                (void *) context, GL_FALSE );
353
 
        if (!context->GLContext)
354
 
        {
355
 
                free(context);
356
 
                return NULL;
357
 
        }
358
 
 
359
 
        return context;
360
 
}
361
 
 
362
 
 
363
 
void AMesaDestroyContext(AMesaContext context)
364
 
{
365
 
   _mesa_destroy_context(context->GLContext);
366
 
   free(context);
367
 
}
368
 
 
369
 
 
370
 
GLboolean AMesaMakeCurrent(AMesaContext context, AMesaBuffer buffer)
371
 
{
372
 
   if (context && buffer) {
373
 
      set_color_depth(context->Visual->Depth);
374
 
      if (set_gfx_mode(GFX_AUTODETECT, buffer->Width, buffer->Height, 0, 0) != 0)
375
 
         return GL_FALSE;
376
 
 
377
 
      context->Buffer = buffer;
378
 
      buffer->Screen  = screen;
379
 
      buffer->Active  = buffer->Background ? buffer->Background : screen;
380
 
        
381
 
      setup_dd_pointers(context->GLContext);
382
 
      _mesa_make_current(context->GLContext, buffer->GLBuffer);
383
 
   }
384
 
   else {
385
 
      /* XXX I don't think you want to destroy anything here! */
386
 
      destroy_bitmap(context->Buffer->Screen);
387
 
      context->Buffer->Screen = NULL;
388
 
      context->Buffer->Active = NULL;
389
 
      context->Buffer         = NULL;
390
 
      _mesa_make_current(NULL, NULL);
391
 
   }
392
 
 
393
 
   return GL_TRUE;
394
 
}
395
 
 
396
 
 
397
 
void AMesaSwapBuffers(AMesaBuffer buffer)
398
 
{
399
 
   if (buffer->Background) {
400
 
      blit(buffer->Background, buffer->Screen,
401
 
           0, 0, 0, 0,
402
 
           buffer->Width, buffer->Height);
403
 
   }
404
 
}