Initial revision

1 files changed, 395 insertions, 0 deletions

diff --git a/src/mesa/drivers/allegro/amesa.c b/src/mesa/drivers/allegro/amesa.c
new file mode 100644
index 00000000000..6e0f21d804d
--- /dev/null
+++ b/src/mesa/drivers/allegro/amesa.c
@@ -0,0 +1,395 @@
+/*

+ * Mesa 3-D graphics library

+ * Version:  3.0

+ * Copyright (C) 1995-1998  Brian Paul

+ *

+ * This library is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Library General Public

+ * License as published by the Free Software Foundation; either

+ * version 2 of the License, or (at your option) any later version.

+ *

+ * This library is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+ * Library General Public License for more details.

+ *

+ * You should have received a copy of the GNU Library General Public

+ * License along with this library; if not, write to the Free

+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

+ */

+

+#include <stdio.h>

+#include <stdlib.h>

+#include <allegro.h>

+#include "context.h"

+#include "matrix.h"

+#include "types.h"

+#include "GL/amesa.h"

+

+

+struct amesa_visual

+    {

+    GLvisual   *GLVisual;       /* inherit from GLvisual      */

+    GLboolean   DBFlag;         /* double buffered?           */

+    GLuint      Depth;          /* bits per pixel ( >= 15 )   */

+    };

+

+

+struct amesa_buffer

+    {

+    GLframebuffer *GLBuffer;    /* inherit from GLframebuffer */

+    GLuint         Width, Height;

+    BITMAP        *Screen;

+	BITMAP        *Background;

+	BITMAP        *Active;

+    };

+

+

+struct amesa_context

+    {

+    GLcontext   *GLContext;     /* inherit from GLcontext     */

+    AMesaVisual  Visual;

+	AMesaBuffer  Buffer;

+    GLuint       ClearColor;

+    GLuint       CurrentColor;

+    };

+

+

+static void setup_dd_pointers(GLcontext *ctx);

+

+

+/**********************************************************************/

+/*****                   drawing functions                        *****/

+/**********************************************************************/

+

+#define FLIP(context, y)  (context->Buffer->Height - (y) - 1)

+

+#include "allegro/generic.h"

+#include "allegro/direct.h"

+

+

+/**********************************************************************/

+/*****            15-bit accelerated drawing funcs                *****/

+/**********************************************************************/

+

+IMPLEMENT_WRITE_RGBA_SPAN(15, unsigned short)

+IMPLEMENT_WRITE_RGB_SPAN(15, unsigned short)

+IMPLEMENT_WRITE_MONO_RGBA_SPAN(15, unsigned short)

+IMPLEMENT_READ_RGBA_SPAN(15, unsigned short)

+IMPLEMENT_WRITE_RGBA_PIXELS(15, unsigned short)

+IMPLEMENT_WRITE_MONO_RGBA_PIXELS(15, unsigned short)

+IMPLEMENT_READ_RGBA_PIXELS(15, unsigned short)

+

+

+/**********************************************************************/

+/*****            16-bit accelerated drawing funcs                *****/

+/**********************************************************************/

+

+IMPLEMENT_WRITE_RGBA_SPAN(16, unsigned short)

+IMPLEMENT_WRITE_RGB_SPAN(16, unsigned short)

+IMPLEMENT_WRITE_MONO_RGBA_SPAN(16, unsigned short)

+IMPLEMENT_READ_RGBA_SPAN(16, unsigned short)

+IMPLEMENT_WRITE_RGBA_PIXELS(16, unsigned short)

+IMPLEMENT_WRITE_MONO_RGBA_PIXELS(16, unsigned short)

+IMPLEMENT_READ_RGBA_PIXELS(16, unsigned short)

+

+

+/**********************************************************************/

+/*****            32-bit accelerated drawing funcs                *****/

+/**********************************************************************/

+

+IMPLEMENT_WRITE_RGBA_SPAN(32, unsigned long)

+IMPLEMENT_WRITE_RGB_SPAN(32, unsigned long)

+IMPLEMENT_WRITE_MONO_RGBA_SPAN(32, unsigned long)

+IMPLEMENT_READ_RGBA_SPAN(32, unsigned long)

+IMPLEMENT_WRITE_RGBA_PIXELS(32, unsigned long)

+IMPLEMENT_WRITE_MONO_RGBA_PIXELS(32, unsigned long)

+IMPLEMENT_READ_RGBA_PIXELS(32, unsigned long)

+

+

+/**********************************************************************/

+/*****              Miscellaneous device driver funcs             *****/

+/**********************************************************************/

+

+static GLboolean set_buffer(GLcontext *ctx, GLenum mode)

+    {

+    AMesaContext context = (AMesaContext)(ctx->DriverCtx);

+    GLboolean    ok      = GL_TRUE;

+

+    if (mode == GL_FRONT_LEFT)

+        context->Buffer->Active = context->Buffer->Screen;

+

+    else if (mode == GL_BACK_LEFT)

+        {

+        if (context->Buffer->Background)

+            context->Buffer->Active = context->Buffer->Background;

+        else

+            ok = GL_FALSE;

+        }

+

+    else

+        ok = GL_FALSE;

+

+    return ok;

+    }

+

+

+static void get_buffer_size(GLcontext *ctx, GLuint *width, GLuint *height)

+    {

+	AMesaContext context = (AMesaContext)(ctx->DriverCtx);

+

+    *width  = context->Buffer->Width;

+    *height = context->Buffer->Height;

+    }

+

+

+/**********************************************************************/

+/**********************************************************************/

+

+static void setup_dd_pointers(GLcontext *ctx)

+	{

+	AMesaContext context = (AMesaContext)(ctx->DriverCtx);

+

+   	/* Initialize all the pointers in the driver struct. Do this whenever */

+   	/* a new context is made current or we change buffers via set_buffer! */

+

+    ctx->Driver.UpdateState   = setup_dd_pointers;

+   	ctx->Driver.SetBuffer     = set_buffer;

+   	ctx->Driver.GetBufferSize = get_buffer_size;

+

+    ctx->Driver.Color               = set_color_generic;

+    ctx->Driver.ClearColor          = clear_color_generic;

+    ctx->Driver.Clear               = clear_generic;

+    ctx->Driver.WriteRGBASpan       = write_rgba_span_generic;

+    ctx->Driver.WriteRGBSpan        = write_rgb_span_generic;

+    ctx->Driver.WriteMonoRGBASpan   = write_mono_rgba_span_generic;

+    ctx->Driver.WriteRGBAPixels     = write_rgba_pixels_generic;

+    ctx->Driver.WriteMonoRGBAPixels = write_mono_rgba_pixels_generic;

+    ctx->Driver.ReadRGBASpan        = read_rgba_span_generic;

+    ctx->Driver.ReadRGBAPixels      = read_rgba_pixels_generic;

+

+    if (context->Buffer->Active != screen)

+        {

+        switch (context->Visual->Depth)

+            {

+            case 15:

+                ctx->Driver.WriteRGBASpan       = write_rgba_span_15;

+                ctx->Driver.WriteRGBSpan        = write_rgb_span_15;

+                ctx->Driver.WriteMonoRGBASpan   = write_mono_rgba_span_15;

+                ctx->Driver.WriteRGBAPixels     = write_rgba_pixels_15;

+                ctx->Driver.WriteMonoRGBAPixels = write_mono_rgba_pixels_15;

+                ctx->Driver.ReadRGBASpan        = read_rgba_span_15;

+                ctx->Driver.ReadRGBAPixels      = read_rgba_pixels_15;

+                break;

+

+            case 16:

+                ctx->Driver.WriteRGBASpan       = write_rgba_span_16;

+                ctx->Driver.WriteRGBSpan        = write_rgb_span_16;

+                ctx->Driver.WriteMonoRGBASpan   = write_mono_rgba_span_16;

+                ctx->Driver.WriteRGBAPixels     = write_rgba_pixels_16;

+                ctx->Driver.WriteMonoRGBAPixels = write_mono_rgba_pixels_16;

+                ctx->Driver.ReadRGBASpan        = read_rgba_span_16;

+                ctx->Driver.ReadRGBAPixels      = read_rgba_pixels_16;

+                break;

+

+            case 32:

+                ctx->Driver.WriteRGBASpan       = write_rgba_span_32;

+                ctx->Driver.WriteRGBSpan        = write_rgb_span_32;

+                ctx->Driver.WriteMonoRGBASpan   = write_mono_rgba_span_32;

+                ctx->Driver.WriteRGBAPixels     = write_rgba_pixels_32;

+                ctx->Driver.WriteMonoRGBAPixels = write_mono_rgba_pixels_32;

+                ctx->Driver.ReadRGBASpan        = read_rgba_span_32;

+                ctx->Driver.ReadRGBAPixels      = read_rgba_pixels_32;

+                break;

+            }

+        }

+	}

+

+

+/**********************************************************************/

+/*****                AMesa Public API Functions                  *****/

+/**********************************************************************/

+

+

+AMesaVisual AMesaCreateVisual(GLboolean dbFlag, GLint depth,

+                              GLint depthSize, GLint stencilSize, GLint accumSize)

+	{

+   	AMesaVisual visual;

+    GLbyte      redBits, greenBits, blueBits;

+

+    visual = (AMesaVisual)calloc(1, sizeof(struct amesa_visual));

+   	if (!visual)

+    	return NULL;

+

+    switch (depth)

+        {

+        case 15:

+            redBits   = 5;

+            greenBits = 5;

+            blueBits  = 5;

+            break;

+

+        case 16:

+            redBits   = 5;

+            greenBits = 6;

+            blueBits  = 5;

+            break;

+

+        case 24: case 32:

+            redBits   = 8;

+            greenBits = 8;

+            blueBits  = 8;

+            break;

+

+        default:

+            free(visual);

+            return NULL;

+        }

+

+    visual->DBFlag   = dbFlag;

+    visual->Depth    = depth;

+    visual->GLVisual = gl_create_visual(GL_TRUE,    /* rgb mode       */

+                                        GL_TRUE,    /* software alpha */

+                                        dbFlag,     /* db_flag        */

+                                        GL_FALSE,   /* stereo         */

+                                        depthSize,  /* depth bits     */

+                                        stencilSize,/* stencil bits   */

+                                        accumSize,  /* accum bits     */

+                                        0,          /* index bits     */

+                                        redBits, greenBits, blueBits, 0);

+    if (!visual->GLVisual)

+        {

+        free(visual);

+        return NULL;

+        }

+

+  	return visual;

+	}

+

+

+void AMesaDestroyVisual(AMesaVisual visual)

+	{

+    gl_destroy_visual(visual->GLVisual);

+   	free(visual);

+	}

+

+

+AMesaBuffer AMesaCreateBuffer(AMesaVisual visual,

+							  GLint width, GLint height)

+	{

+   	AMesaBuffer buffer;

+

+    buffer = (AMesaBuffer)calloc(1, sizeof(struct amesa_buffer));

+   	if (!buffer)

+     	return NULL;

+

+	buffer->Screen     = NULL;

+	buffer->Background = NULL;

+	buffer->Active     = NULL;

+	buffer->Width      = width;

+	buffer->Height     = height;

+

+	if (visual->DBFlag)

+		{

+		buffer->Background = create_bitmap_ex(visual->Depth, width, height);

+		if (!buffer->Background)

+			{

+			free(buffer);

+			return NULL;

+			}

+		}

+

+    buffer->GLBuffer = gl_create_framebuffer(visual->GLVisual);

+    if (!buffer->GLBuffer)

+        {

+        if (buffer->Background) destroy_bitmap(buffer->Background);

+        free(buffer);

+        return NULL;

+        }

+

+   	return buffer;

+	}

+

+

+void AMesaDestroyBuffer(AMesaBuffer buffer)

+	{

+    if (buffer->Screen)     destroy_bitmap(buffer->Screen);

+	if (buffer->Background) destroy_bitmap(buffer->Background);

+    gl_destroy_framebuffer(buffer->GLBuffer);

+   	free(buffer);

+	}

+

+

+AMesaContext AMesaCreateContext(AMesaVisual visual,

+                                AMesaContext share)

+	{

+   	AMesaContext context;

+   	GLboolean    direct = GL_FALSE;

+

+    context = (AMesaContext)calloc(1, sizeof(struct amesa_context));

+	if (!context)

+		return NULL;

+

+	context->Visual       = visual;

+	context->Buffer		  = NULL;

+	context->ClearColor   = 0;

+	context->CurrentColor = 0;

+    context->GLContext    = gl_create_context(visual->GLVisual,

+                                              share ? share->GLContext : NULL,

+                                  		      (void*)context,

+                                              direct);

+    if (!context->GLContext)

+        {

+        free(context);

+        return NULL;

+        }

+

+   	return context;

+	}

+

+

+void AMesaDestroyContext(AMesaContext context)

+	{

+    gl_destroy_context(context->GLContext);

+   	free(context);

+	}

+

+

+GLboolean AMesaMakeCurrent(AMesaContext context, AMesaBuffer buffer)

+	{

+   	if (context && buffer)

+   		{

+      	set_color_depth(context->Visual->Depth);

+        if (set_gfx_mode(GFX_AUTODETECT, buffer->Width, buffer->Height, 0, 0) != 0)

+            return GL_FALSE;

+

+		context->Buffer = buffer;

+        buffer->Screen  = screen;

+        buffer->Active  = buffer->Background ? buffer->Background : screen;

+        

+        setup_dd_pointers(context->GLContext);

+        gl_make_current(context->GLContext, buffer->GLBuffer);

+        gl_Viewport(context->GLContext, 0, 0, buffer->Width, buffer->Height);

+     	}

+  	else

+  		{

+        destroy_bitmap(context->Buffer->Screen);

+        context->Buffer->Screen = NULL;

+        context->Buffer->Active = NULL;

+        context->Buffer         = NULL;

+     	gl_make_current(NULL, NULL);

+   		}

+

+    return GL_TRUE;

+	}

+

+

+void AMesaSwapBuffers(AMesaBuffer buffer)

+	{

+	if (buffer->Background)

+		{

+		blit(buffer->Background, buffer->Screen,

+             0, 0, 0, 0,

+             buffer->Width, buffer->Height);

+		}

+	}