gallium: Have pipe_buffer_* receive a pipe_screen instead of a pipe_context.
[mesa.git] / src / mesa / state_tracker / st_context.c
1 /**************************************************************************
2 *
3 * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
4 * All Rights Reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
13 *
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
16 * of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 *
26 **************************************************************************/
27
28 #include "main/imports.h"
29 #include "main/context.h"
30 #include "main/extensions.h"
31 #include "main/matrix.h"
32 #include "main/buffers.h"
33 #include "main/scissor.h"
34 #include "vbo/vbo.h"
35 #include "shader/shader_api.h"
36 #include "glapi/glapi.h"
37 #include "st_public.h"
38 #include "st_context.h"
39 #include "st_cb_accum.h"
40 #include "st_cb_bitmap.h"
41 #include "st_cb_blit.h"
42 #include "st_cb_bufferobjects.h"
43 #include "st_cb_clear.h"
44 #if FEATURE_drawpix
45 #include "st_cb_drawpixels.h"
46 #include "st_cb_rasterpos.h"
47 #endif
48 #ifdef FEATURE_OES_draw_texture
49 #include "st_cb_drawtex.h"
50 #endif
51 #include "st_cb_fbo.h"
52 #include "st_cb_get.h"
53 #if FEATURE_feedback
54 #include "st_cb_feedback.h"
55 #endif
56 #include "st_cb_program.h"
57 #include "st_cb_queryobj.h"
58 #include "st_cb_readpixels.h"
59 #include "st_cb_texture.h"
60 #include "st_cb_flush.h"
61 #include "st_cb_strings.h"
62 #include "st_atom.h"
63 #include "st_draw.h"
64 #include "st_extensions.h"
65 #include "st_gen_mipmap.h"
66 #include "st_program.h"
67 #include "pipe/p_context.h"
68 #include "pipe/p_inlines.h"
69 #include "draw/draw_context.h"
70 #include "cso_cache/cso_cache.h"
71 #include "cso_cache/cso_context.h"
72
73
74 /**
75 * Called via ctx->Driver.UpdateState()
76 */
77 void st_invalidate_state(GLcontext * ctx, GLuint new_state)
78 {
79 struct st_context *st = st_context(ctx);
80
81 st->dirty.mesa |= new_state;
82 st->dirty.st |= ST_NEW_MESA;
83
84 /* This is the only core Mesa module we depend upon.
85 * No longer use swrast, swsetup, tnl.
86 */
87 _vbo_InvalidateState(ctx, new_state);
88 }
89
90
91 static struct st_context *
92 st_create_context_priv( GLcontext *ctx, struct pipe_context *pipe )
93 {
94 uint i;
95 struct st_context *st = CALLOC_STRUCT( st_context );
96
97 ctx->st = st;
98
99 st->ctx = ctx;
100 st->pipe = pipe;
101
102 /* state tracker needs the VBO module */
103 _vbo_CreateContext(ctx);
104
105 #if FEATURE_feedback || FEATURE_drawpix
106 st->draw = draw_create(); /* for selection/feedback */
107
108 /* Disable draw options that might convert points/lines to tris, etc.
109 * as that would foul-up feedback/selection mode.
110 */
111 draw_wide_line_threshold(st->draw, 1000.0f);
112 draw_wide_point_threshold(st->draw, 1000.0f);
113 draw_enable_line_stipple(st->draw, FALSE);
114 draw_enable_point_sprites(st->draw, FALSE);
115 #endif
116
117 st->dirty.mesa = ~0;
118 st->dirty.st = ~0;
119
120 st->cso_context = cso_create_context(pipe);
121
122 st_init_atoms( st );
123 st_init_bitmap(st);
124 st_init_clear(st);
125 st_init_draw( st );
126 st_init_generate_mipmap(st);
127 st_init_blit(st);
128
129 for (i = 0; i < PIPE_MAX_SAMPLERS; i++)
130 st->state.sampler_list[i] = &st->state.samplers[i];
131
132 /* we want all vertex data to be placed in buffer objects */
133 vbo_use_buffer_objects(ctx);
134
135 /* Need these flags:
136 */
137 st->ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
138 st->ctx->FragmentProgram._UseTexEnvProgram = GL_TRUE;
139
140 st->ctx->VertexProgram._MaintainTnlProgram = GL_TRUE;
141
142 st->pixel_xfer.cache = _mesa_new_program_cache();
143
144 /* GL limits and extensions */
145 st_init_limits(st);
146 st_init_extensions(st);
147
148 return st;
149 }
150
151
152 struct st_context *st_create_context(struct pipe_context *pipe,
153 const __GLcontextModes *visual,
154 struct st_context *share)
155 {
156 GLcontext *ctx;
157 GLcontext *shareCtx = share ? share->ctx : NULL;
158 struct dd_function_table funcs;
159
160 memset(&funcs, 0, sizeof(funcs));
161 st_init_driver_functions(&funcs);
162
163 ctx = _mesa_create_context(visual, shareCtx, &funcs, NULL);
164
165 return st_create_context_priv(ctx, pipe);
166 }
167
168
169 static void st_destroy_context_priv( struct st_context *st )
170 {
171 uint i;
172
173 #if FEATURE_feedback || FEATURE_drawpix
174 draw_destroy(st->draw);
175 #endif
176 st_destroy_atoms( st );
177 st_destroy_draw( st );
178 st_destroy_generate_mipmap(st);
179 #if FEATURE_EXT_framebuffer_blit
180 st_destroy_blit(st);
181 #endif
182 st_destroy_clear(st);
183 #if FEATURE_drawpix
184 st_destroy_bitmap(st);
185 st_destroy_drawpix(st);
186 #endif
187 #ifdef FEATURE_OES_draw_texture
188 st_destroy_drawtex(st);
189 #endif
190
191 _vbo_DestroyContext(st->ctx);
192
193 for (i = 0; i < Elements(st->state.sampler_texture); i++) {
194 pipe_texture_reference(&st->state.sampler_texture[i], NULL);
195 }
196
197 for (i = 0; i < Elements(st->state.constants); i++) {
198 if (st->state.constants[i].buffer) {
199 pipe_buffer_reference(st->pipe->screen, &st->state.constants[i].buffer, NULL);
200 }
201 }
202
203 if (st->default_texture) {
204 st->ctx->Driver.DeleteTexture(st->ctx, st->default_texture);
205 st->default_texture = NULL;
206 }
207
208 free( st );
209 }
210
211
212 void st_destroy_context( struct st_context *st )
213 {
214 struct pipe_context *pipe = st->pipe;
215 struct cso_context *cso = st->cso_context;
216 GLcontext *ctx = st->ctx;
217
218 /* need to unbind and destroy CSO objects before anything else */
219 cso_release_all(st->cso_context);
220
221 st_reference_fragprog(st, &st->fp, NULL);
222 st_reference_vertprog(st, &st->vp, NULL);
223
224 _mesa_delete_program_cache(st->ctx, st->pixel_xfer.cache);
225
226 _mesa_free_context_data(ctx);
227
228 st_destroy_context_priv(st);
229
230 cso_destroy_context(cso);
231
232 pipe->destroy( pipe );
233
234 free(ctx);
235 }
236
237
238 void st_make_current(struct st_context *st,
239 struct st_framebuffer *draw,
240 struct st_framebuffer *read)
241 {
242 if (st) {
243 GLboolean firstTime = st->ctx->FirstTimeCurrent;
244 _mesa_make_current(st->ctx, &draw->Base, &read->Base);
245 /* Need to initialize viewport here since draw->Base->Width/Height
246 * will still be zero at this point.
247 * This could be improved, but would require rather extensive work
248 * elsewhere (allocate rb surface storage sooner)
249 */
250 if (firstTime) {
251 GLuint w = draw->InitWidth, h = draw->InitHeight;
252 _mesa_set_viewport(st->ctx, 0, 0, w, h);
253 _mesa_set_scissor(st->ctx, 0, 0, w, h);
254
255 }
256 }
257 else {
258 _mesa_make_current(NULL, NULL, NULL);
259 }
260 }
261
262
263 void st_copy_context_state(struct st_context *dst,
264 struct st_context *src,
265 uint mask)
266 {
267 _mesa_copy_context(dst->ctx, src->ctx, mask);
268 }
269
270
271
272 st_proc st_get_proc_address(const char *procname)
273 {
274 return (st_proc) _glapi_get_proc_address(procname);
275 }
276
277
278
279 void st_init_driver_functions(struct dd_function_table *functions)
280 {
281 _mesa_init_glsl_driver_functions(functions);
282
283 #if FEATURE_accum
284 st_init_accum_functions(functions);
285 #endif
286 #if FEATURE_EXT_framebuffer_blit
287 st_init_blit_functions(functions);
288 #endif
289 st_init_bufferobject_functions(functions);
290 st_init_clear_functions(functions);
291 #if FEATURE_drawpix
292 st_init_bitmap_functions(functions);
293 st_init_drawpixels_functions(functions);
294 st_init_rasterpos_functions(functions);
295 #endif
296 st_init_fbo_functions(functions);
297 st_init_get_functions(functions);
298 #if FEATURE_feedback
299 st_init_feedback_functions(functions);
300 #endif
301 st_init_program_functions(functions);
302 #if FEATURE_ARB_occlusion_query
303 st_init_query_functions(functions);
304 #endif
305 st_init_readpixels_functions(functions);
306 st_init_texture_functions(functions);
307 st_init_flush_functions(functions);
308 st_init_string_functions(functions);
309
310 functions->UpdateState = st_invalidate_state;
311 }