workbench/libs/mesa/src/aros/mesa3dgl/mesa3dgl_gallium.c

   1 /*
   2     Copyright 2009-2015, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <proto/utility.h>
   7 #include <proto/exec.h>
   8 #include <proto/gallium.h>
   9
  10 #include <gallium/pipe/p_screen.h>
  11 #include <gallium/util/u_inlines.h>
  12
  13 #include "main/context.h"
  14
  15 #define DEBUG 0
  16 #include <aros/debug.h>
  17
  18 #include "mesa3dgl_support.h"
  19 #include "mesa3dgl_gallium.h"
  20
  21 static BOOL MESA3DGLSelectColorFormat(enum pipe_format * colorFormat,
  22     struct pipe_screen * screen, GLint bpp)
  23 {
  24     *colorFormat = PIPE_FORMAT_NONE;
  25
  26     if (bpp == 16)
  27     {
  28         /* Try PIPE_FORMAT_B5G6R5_UNORM */
  29         if (screen->is_format_supported(screen, PIPE_FORMAT_B5G6R5_UNORM,
  30             PIPE_TEXTURE_2D, 0, PIPE_BIND_RENDER_TARGET))
  31         {
  32             *colorFormat = PIPE_FORMAT_B5G6R5_UNORM;
  33             return TRUE;
  34         }
  35     }
  36
  37     if (bpp == 32)
  38     {
  39         /* Try PIPE_FORMAT_B8G8R8A8_UNORM */
  40         if (screen->is_format_supported(screen, PIPE_FORMAT_B8G8R8A8_UNORM,
  41             PIPE_TEXTURE_2D, 0, PIPE_BIND_RENDER_TARGET))
  42         {
  43             *colorFormat = PIPE_FORMAT_B8G8R8A8_UNORM;
  44             return TRUE;
  45         }
  46     }
  47
  48     return FALSE;
  49 }
  50
  51 static BOOL MESA3DGLSelectDepthStencilFormat(enum pipe_format * depthStencilFormat,
  52     struct pipe_screen * screen, BOOL noDepth, BOOL noStencil)
  53 {
  54     /* Defeaul values */
  55     *depthStencilFormat = PIPE_FORMAT_NONE;
  56
  57     if (noDepth)
  58         return TRUE;
  59
  60     /* Try PIPE_FORMAT_S8_USCALED_Z24_UNORM */
  61     if(!noStencil && (screen->is_format_supported(screen, PIPE_FORMAT_S8_USCALED_Z24_UNORM,
  62             PIPE_TEXTURE_2D, 0, PIPE_BIND_DEPTH_STENCIL)))
  63     {
  64         *depthStencilFormat  = PIPE_FORMAT_S8_USCALED_Z24_UNORM;
  65         return TRUE;
  66     }
  67
  68     /* Try PIPE_FORMAT_X8Z24_UNORM */
  69     if(noStencil && (screen->is_format_supported(screen, PIPE_FORMAT_X8Z24_UNORM,
  70             PIPE_TEXTURE_2D, 0, PIPE_BIND_DEPTH_STENCIL)))
  71     {
  72         *depthStencilFormat  = PIPE_FORMAT_X8Z24_UNORM;
  73         return TRUE;
  74     }
  75
  76     /* Try PIPE_FORMAT_Z24X8_UNORM */
  77     if(noStencil && (screen->is_format_supported(screen, PIPE_FORMAT_Z24X8_UNORM,
  78             PIPE_TEXTURE_2D, 0, PIPE_BIND_DEPTH_STENCIL)))
  79     {
  80         *depthStencilFormat  = PIPE_FORMAT_Z24X8_UNORM;
  81         return TRUE;
  82     }
  83
  84     /* Try PIPE_FORMAT_Z16_UNORM */
  85     if(screen->is_format_supported(screen, PIPE_FORMAT_Z16_UNORM,
  86             PIPE_TEXTURE_2D, 0, PIPE_BIND_DEPTH_STENCIL))
  87     {
  88         *depthStencilFormat = PIPE_FORMAT_Z16_UNORM;
  89         return TRUE;
  90     }
  91
  92     return FALSE;
  93 }
  94
  95 BOOL MESA3DGLFillVisual(struct st_visual * stvis, struct pipe_screen * screen, int bpp, struct TagItem *tagList)
  96 {
  97     BOOL noDepth, noStencil, noAccum;
  98
  99     D(bug("[MESA3DGL] MESA3DGLFillVisual\n"));
 100
 101     noStencil   = GetTagData(GLA_NoStencil, GL_FALSE, tagList);
 102     noAccum     = GetTagData(GLA_NoAccum, GL_FALSE, tagList);
 103     noDepth     = GetTagData(GLA_NoDepth, GL_FALSE, tagList);
 104
 105     stvis->color_format = PIPE_FORMAT_NONE;
 106     stvis->depth_stencil_format = PIPE_FORMAT_NONE;
 107     stvis->accum_format = PIPE_FORMAT_NONE;
 108     stvis->render_buffer = ST_ATTACHMENT_INVALID;
 109     stvis->samples = 0;
 110     stvis->buffer_mask = 0;
 111
 112     /* Color buffer */
 113     if (!MESA3DGLSelectColorFormat(&stvis->color_format, screen, bpp))
 114     {
 115         D(bug("[MESA3DGL] MESA3DGLFillVisual - ERROR - No supported color format found\n"));
 116         return FALSE;
 117     }
 118
 119     /* Z-buffer / Stencil buffer */
 120     if (!MESA3DGLSelectDepthStencilFormat(&stvis->depth_stencil_format, screen, noDepth, noStencil))
 121     {
 122         D(bug("[MESA3DGL] MESA3DGLFillVisual - ERROR - No supported depth/stencil format found\n"));
 123         return FALSE;
 124     }
 125
 126     /* Accum buffer */
 127     if (noAccum)
 128         stvis->accum_format = PIPE_FORMAT_NONE;
 129     else
 130         stvis->accum_format = PIPE_FORMAT_R16G16B16A16_SNORM;
 131
 132     /* Buffers */ /* MESA3DGL uses front buffer as back buffer */
 133     stvis->buffer_mask |= ST_ATTACHMENT_FRONT_LEFT_MASK;
 134     if (!noDepth || !noStencil)
 135     stvis->buffer_mask |= ST_ATTACHMENT_DEPTH_STENCIL_MASK;
 136
 137     return TRUE;
 138 }
 139
 140 static VOID MESA3DGLFrameBufferCreateResource(struct mesa3dgl_framebuffer * amfb,
 141     const enum st_attachment_type statt)
 142 {
 143     struct pipe_resource templ;
 144
 145     memset(&templ, 0, sizeof(templ));
 146
 147     if(amfb->screen->get_param(amfb->screen, PIPE_CAP_NPOT_TEXTURES))
 148         templ.target = PIPE_TEXTURE_2D;
 149     else
 150         templ.target = PIPE_TEXTURE_RECT;
 151     templ.width0 = amfb->width;
 152     templ.height0 = amfb->height;
 153     templ.depth0 = 1;
 154     templ.last_level = 0;
 155     templ.array_size = 1;
 156     switch(statt)
 157     {
 158     case ST_ATTACHMENT_FRONT_LEFT:
 159     case ST_ATTACHMENT_BACK_LEFT:
 160     case ST_ATTACHMENT_FRONT_RIGHT:
 161     case ST_ATTACHMENT_BACK_RIGHT:
 162         templ.format    = amfb->stvis.color_format;
 163         templ.bind      = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW;
 164         break;
 165     case ST_ATTACHMENT_DEPTH_STENCIL:
 166         templ.format    = amfb->stvis.depth_stencil_format;
 167         templ.bind      = PIPE_BIND_DEPTH_STENCIL;
 168         break;
 169     default:
 170         return; /* Failure */
 171     }
 172
 173     /* Create resource */
 174     amfb->textures[statt] = amfb->screen->resource_create(amfb->screen, &templ);
 175 }
 176
 177 static boolean MESA3DGLFrameBufferValidate(struct st_framebuffer_iface *stfbi,
 178     const enum st_attachment_type *statts, unsigned count, struct pipe_resource **out)
 179 {
 180     struct mesa3dgl_framebuffer * amfb = (struct mesa3dgl_framebuffer *)stfbi;
 181     LONG i;
 182
 183     /* Check for resize */
 184     if (amfb->resized)
 185     {
 186         amfb->resized = FALSE;
 187         /* Detach "front surface" */
 188         pipe_resource_reference(&amfb->render_resource, NULL);
 189
 190         /* Detach all resources */
 191         for (i = 0; i < ST_ATTACHMENT_COUNT; i++)
 192             pipe_resource_reference(&amfb->textures[i], NULL);
 193     }
 194
 195     /* Create new resources */
 196     for (i = 0; i < count; i++)
 197     {
 198         if (amfb->textures[statts[i]] == NULL)
 199         {
 200             MESA3DGLFrameBufferCreateResource(amfb, statts[i]);
 201             if (statts[i] == ST_ATTACHMENT_FRONT_LEFT)
 202             {
 203                 pipe_resource_reference(&amfb->render_resource, amfb->textures[ST_ATTACHMENT_FRONT_LEFT]);
 204             }
 205         }
 206     }
 207
 208     if (!out)
 209         return TRUE;
 210
 211     for (i = 0; i < count; i++)
 212     {
 213         out[i] = NULL;
 214         pipe_resource_reference(&out[i], amfb->textures[statts[i]]);
 215     }
 216
 217     return TRUE;
 218 }
 219
 220 static boolean MESA3DGLFrameBufferFlushFront(struct st_framebuffer_iface *stfbi,
 221     enum st_attachment_type statt)
 222 {
 223     /* No Op */
 224     return TRUE;
 225 }
 226
 227 struct mesa3dgl_framebuffer * MESA3DGLNewFrameBuffer(struct mesa3dgl_context * ctx, struct st_visual * stvis)
 228 {
 229     struct mesa3dgl_framebuffer * framebuffer =
 230         AllocVec(sizeof(struct mesa3dgl_framebuffer), MEMF_PUBLIC | MEMF_CLEAR);
 231
 232     if (!framebuffer)
 233         return NULL;
 234
 235     framebuffer->stvis = *stvis;
 236     framebuffer->base.visual = &framebuffer->stvis;
 237     framebuffer->base.flush_front = MESA3DGLFrameBufferFlushFront;
 238     framebuffer->base.validate = MESA3DGLFrameBufferValidate;
 239     framebuffer->screen = ctx->stmanager->screen;
 240
 241     return framebuffer;
 242 }
 243
 244 VOID MESA3DGLFreeFrameBuffer(struct mesa3dgl_framebuffer * framebuffer)
 245 {
 246     if (framebuffer)
 247     {
 248         LONG i;
 249
 250         pipe_resource_reference(&framebuffer->render_resource, NULL);
 251
 252         for (i = 0; i < ST_ATTACHMENT_COUNT; i++)
 253             pipe_resource_reference(&framebuffer->textures[i], NULL);
 254
 255         FreeVec(framebuffer);
 256     }
 257 }
 258
 259 VOID MESA3DGLCheckAndUpdateBufferSize(struct mesa3dgl_context * ctx)
 260 {
 261     MESA3DGLRecalculateBufferWidthHeight(ctx);
 262     if (ctx->framebuffer->resized)
 263         ctx->st->notify_invalid_framebuffer(ctx->st,
 264             (struct st_framebuffer_iface *) ctx->framebuffer);
 265 }
 266
 267 static int MESA3DGLStManagerGetParam(struct st_manager *smapi,
 268                 enum st_manager_param param)
 269 {
 270     return 0;
 271 }
 272
 273 struct st_manager * MESA3DGLNewStManager(struct pipe_screen * pscreen)
 274 {
 275     struct st_manager * stmanager =
 276         (struct st_manager *)AllocVec(sizeof(struct st_manager), MEMF_PUBLIC | MEMF_CLEAR);
 277
 278     if (stmanager)
 279     {
 280         stmanager->screen = pscreen;
 281         stmanager->get_param = MESA3DGLStManagerGetParam;
 282     }
 283
 284     return stmanager;
 285 }
 286
 287 VOID MESA3DGLFreeStManager(struct st_manager * stmanager)
 288 {
 289     if (stmanager)
 290     {
 291         if (stmanager->screen)
 292             DestroyPipeScreen(stmanager->screen);
 293         FreeVec(stmanager);
 294     }
 295 }