src/gallium/state_trackers/g3dvl/vl_context.c

   1 #define VL_INTERNAL
   2 #include "vl_context.h"
   3 #include <assert.h>
   4 #include <pipe/p_context.h>
   5 #include <pipe/p_state.h>
   6 #include <util/u_memory.h>
   7 #include "vl_render.h"
   8 #include "vl_r16snorm_mc_buf.h"
   9 #include "vl_csc.h"
  10 #include "vl_basic_csc.h"
  11
  12 static int vlInitCommon(struct vlContext *context)
  13 {
  14         struct pipe_context                     *pipe;
  15         struct pipe_rasterizer_state            rast;
  16         struct pipe_blend_state                 blend;
  17         struct pipe_depth_stencil_alpha_state   dsa;
  18         unsigned int                            i;
  19
  20         assert(context);
  21
  22         pipe = context->pipe;
  23
  24         rast.flatshade = 1;
  25         rast.flatshade_first = 0;
  26         rast.light_twoside = 0;
  27         rast.front_winding = PIPE_WINDING_CCW;
  28         rast.cull_mode = PIPE_WINDING_CW;
  29         rast.fill_cw = PIPE_POLYGON_MODE_FILL;
  30         rast.fill_ccw = PIPE_POLYGON_MODE_FILL;
  31         rast.offset_cw = 0;
  32         rast.offset_ccw = 0;
  33         rast.scissor = 0;
  34         rast.poly_smooth = 0;
  35         rast.poly_stipple_enable = 0;
  36         rast.point_sprite = 0;
  37         rast.point_size_per_vertex = 0;
  38         rast.multisample = 0;
  39         rast.line_smooth = 0;
  40         rast.line_stipple_enable = 0;
  41         rast.line_stipple_factor = 0;
  42         rast.line_stipple_pattern = 0;
  43         rast.line_last_pixel = 0;
  44         rast.bypass_vs_clip_and_viewport = 0;
  45         rast.line_width = 1;
  46         rast.point_smooth = 0;
  47         rast.point_size = 1;
  48         rast.offset_units = 1;
  49         rast.offset_scale = 1;
  50         /*rast.sprite_coord_mode[i] = ;*/
  51         context->raster = pipe->create_rasterizer_state(pipe, &rast);
  52         pipe->bind_rasterizer_state(pipe, context->raster);
  53
  54         blend.blend_enable = 0;
  55         blend.rgb_func = PIPE_BLEND_ADD;
  56         blend.rgb_src_factor = PIPE_BLENDFACTOR_ONE;
  57         blend.rgb_dst_factor = PIPE_BLENDFACTOR_ONE;
  58         blend.alpha_func = PIPE_BLEND_ADD;
  59         blend.alpha_src_factor = PIPE_BLENDFACTOR_ONE;
  60         blend.alpha_dst_factor = PIPE_BLENDFACTOR_ONE;
  61         blend.logicop_enable = 0;
  62         blend.logicop_func = PIPE_LOGICOP_CLEAR;
  63         /* Needed to allow color writes to FB, even if blending disabled */
  64         blend.colormask = PIPE_MASK_RGBA;
  65         blend.dither = 0;
  66         context->blend = pipe->create_blend_state(pipe, &blend);
  67         pipe->bind_blend_state(pipe, context->blend);
  68
  69         dsa.depth.enabled = 0;
  70         dsa.depth.writemask = 0;
  71         dsa.depth.func = PIPE_FUNC_ALWAYS;
  72         dsa.depth.occlusion_count = 0;
  73         for (i = 0; i < 2; ++i)
  74         {
  75                 dsa.stencil[i].enabled = 0;
  76                 dsa.stencil[i].func = PIPE_FUNC_ALWAYS;
  77                 dsa.stencil[i].fail_op = PIPE_STENCIL_OP_KEEP;
  78                 dsa.stencil[i].zpass_op = PIPE_STENCIL_OP_KEEP;
  79                 dsa.stencil[i].zfail_op = PIPE_STENCIL_OP_KEEP;
  80                 dsa.stencil[i].ref_value = 0;
  81                 dsa.stencil[i].valuemask = 0;
  82                 dsa.stencil[i].writemask = 0;
  83         }
  84         dsa.alpha.enabled = 0;
  85         dsa.alpha.func = PIPE_FUNC_ALWAYS;
  86         dsa.alpha.ref_value = 0;
  87         context->dsa = pipe->create_depth_stencil_alpha_state(pipe, &dsa);
  88         pipe->bind_depth_stencil_alpha_state(pipe, context->dsa);
  89
  90         return 0;
  91 }
  92
  93 int vlCreateContext
  94 (
  95         struct vlScreen *screen,
  96         struct pipe_context *pipe,
  97         unsigned int picture_width,
  98         unsigned int picture_height,
  99         enum vlFormat picture_format,
 100         enum vlProfile profile,
 101         enum vlEntryPoint entry_point,
 102         struct vlContext **context
 103 )
 104 {
 105         struct vlContext *ctx;
 106
 107         assert(screen);
 108         assert(context);
 109         assert(pipe);
 110
 111         ctx = CALLOC_STRUCT(vlContext);
 112
 113         if (!ctx)
 114                 return 1;
 115
 116         ctx->screen = screen;
 117         ctx->pipe = pipe;
 118         ctx->picture_width = picture_width;
 119         ctx->picture_height = picture_height;
 120         ctx->picture_format = picture_format;
 121         ctx->profile = profile;
 122         ctx->entry_point = entry_point;
 123
 124         vlInitCommon(ctx);
 125
 126         vlCreateR16SNormBufferedMC(pipe, picture_width, picture_height, picture_format, &ctx->render);
 127         vlCreateBasicCSC(pipe, &ctx->csc);
 128
 129         *context = ctx;
 130
 131         return 0;
 132 }
 133
 134 int vlDestroyContext
 135 (
 136         struct vlContext *context
 137 )
 138 {
 139         assert(context);
 140
 141         /* XXX: Must unbind shaders before we can delete them for some reason */
 142         context->pipe->bind_vs_state(context->pipe, NULL);
 143         context->pipe->bind_fs_state(context->pipe, NULL);
 144
 145         context->render->vlDestroy(context->render);
 146         context->csc->vlDestroy(context->csc);
 147
 148         context->pipe->delete_blend_state(context->pipe, context->blend);
 149         context->pipe->delete_rasterizer_state(context->pipe, context->raster);
 150         context->pipe->delete_depth_stencil_alpha_state(context->pipe, context->dsa);
 151
 152         FREE(context);
 153
 154         return 0;
 155 }
 156
 157 struct vlScreen* vlContextGetScreen
 158 (
 159         struct vlContext *context
 160 )
 161 {
 162         assert(context);
 163
 164         return context->screen;
 165 }
 166
 167 struct pipe_context* vlGetPipeContext
 168 (
 169         struct vlContext *context
 170 )
 171 {
 172         assert(context);
 173
 174         return context->pipe;
 175 }
 176
 177 unsigned int vlGetPictureWidth
 178 (
 179         struct vlContext *context
 180 )
 181 {
 182         assert(context);
 183
 184         return context->picture_width;
 185 }
 186
 187 unsigned int vlGetPictureHeight
 188 (
 189         struct vlContext *context
 190 )
 191 {
 192         assert(context);
 193
 194         return context->picture_height;
 195 }
 196
 197 enum vlFormat vlGetPictureFormat
 198 (
 199         struct vlContext *context
 200 )
 201 {
 202         assert(context);
 203
 204         return context->picture_format;
 205 }