projects / mesa.git / blob
? search:


d1c2232e26a8aa1c890e54631c08b0233c45ab5b
[mesa.git] / src / mesa / drivers / common / meta.c
1 /*
2 * Mesa 3-D graphics library
3 * Version: 7.6
4 *
5 * Copyright (C) 2009 VMware, Inc. All Rights Reserved.
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
21 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 */
24
25 /**
26 * Meta operations. Some GL operations can be expressed in terms of
27 * other GL operations. For example, glBlitFramebuffer() can be done
28 * with texture mapping and glClear() can be done with polygon rendering.
29 *
30 * \author Brian Paul
31 */
32
33
34 #include "main/glheader.h"
35 #include "main/mtypes.h"
36 #include "main/imports.h"
37 #include "main/arrayobj.h"
38 #include "main/blend.h"
39 #include "main/bufferobj.h"
40 #include "main/buffers.h"
41 #include "main/depth.h"
42 #include "main/enable.h"
43 #include "main/fbobject.h"
44 #include "main/image.h"
45 #include "main/macros.h"
46 #include "main/matrix.h"
47 #include "main/mipmap.h"
48 #include "main/polygon.h"
49 #include "main/readpix.h"
50 #include "main/scissor.h"
51 #include "main/shaders.h"
52 #include "main/stencil.h"
53 #include "main/texobj.h"
54 #include "main/texenv.h"
55 #include "main/teximage.h"
56 #include "main/texparam.h"
57 #include "main/texstate.h"
58 #include "main/varray.h"
59 #include "main/viewport.h"
60 #include "shader/program.h"
61 #include "shader/arbprogram.h"
62 #include "swrast/swrast.h"
63 #include "drivers/common/meta.h"
64
65
66 /**
67 * State which we may save/restore across meta ops.
68 * XXX this may be incomplete...
69 */
70 struct save_state
71 {
72 GLbitfield SavedState; /**< bitmask of META_* flags */
73
74 /** META_ALPHA_TEST */
75 GLboolean AlphaEnabled;
76
77 /** META_BLEND */
78 GLboolean BlendEnabled;
79 GLboolean ColorLogicOpEnabled;
80
81 /** META_COLOR_MASK */
82 GLubyte ColorMask[4];
83
84 /** META_DEPTH_TEST */
85 struct gl_depthbuffer_attrib Depth;
86
87 /** META_FOG */
88 GLboolean Fog;
89
90 /** META_PIXEL_STORE */
91 struct gl_pixelstore_attrib Pack, Unpack;
92
93 /** META_RASTERIZATION */
94 GLenum FrontPolygonMode, BackPolygonMode;
95 GLboolean PolygonOffset;
96 GLboolean PolygonSmooth;
97 GLboolean PolygonStipple;
98 GLboolean PolygonCull;
99
100 /** META_SCISSOR */
101 struct gl_scissor_attrib Scissor;
102
103 /** META_SHADER */
104 GLboolean VertexProgramEnabled;
105 struct gl_vertex_program *VertexProgram;
106 GLboolean FragmentProgramEnabled;
107 struct gl_fragment_program *FragmentProgram;
108 GLuint Shader;
109
110 /** META_STENCIL_TEST */
111 struct gl_stencil_attrib Stencil;
112
113 /** META_TRANSFORM */
114 GLenum MatrixMode;
115 GLfloat ModelviewMatrix[16];
116 GLfloat ProjectionMatrix[16];
117 GLfloat TextureMatrix[16];
118 GLbitfield ClipPlanesEnabled;
119
120 /** META_TEXTURE */
121 GLuint ActiveUnit;
122 GLuint ClientActiveUnit;
123 /** for unit[0] only */
124 struct gl_texture_object *CurrentTexture[NUM_TEXTURE_TARGETS];
125 /** mask of TEXTURE_2D_BIT, etc */
126 GLbitfield TexEnabled[MAX_TEXTURE_UNITS];
127 GLbitfield TexGenEnabled[MAX_TEXTURE_UNITS];
128 GLuint EnvMode; /* unit[0] only */
129
130 /** META_VERTEX */
131 struct gl_array_object *ArrayObj;
132 struct gl_buffer_object *ArrayBufferObj;
133
134 /** META_VIEWPORT */
135 GLint ViewportX, ViewportY, ViewportW, ViewportH;
136 GLclampd DepthNear, DepthFar;
137
138 /** Miscellaneous (always disabled) */
139 GLboolean Lighting;
140 };
141
142
143 /**
144 * Temporary texture used for glBlitFramebuffer, glDrawPixels, etc.
145 * This is currently shared by all the meta ops. But we could create a
146 * separate one for each of glDrawPixel, glBlitFramebuffer, glCopyPixels, etc.
147 */
148 struct temp_texture
149 {
150 GLuint TexObj;
151 GLenum Target; /**< GL_TEXTURE_2D or GL_TEXTURE_RECTANGLE */
152 GLsizei MinSize; /**< Min texture size to allocate */
153 GLsizei MaxSize; /**< Max possible texture size */
154 GLboolean NPOT; /**< Non-power of two size OK? */
155 GLsizei Width, Height; /**< Current texture size */
156 GLenum IntFormat;
157 GLfloat Sright, Ttop; /**< right, top texcoords */
158 };
159
160
161 /**
162 * State for glBlitFramebufer()
163 */
164 struct blit_state
165 {
166 GLuint ArrayObj;
167 GLuint VBO;
168 GLuint DepthFP;
169 };
170
171
172 /**
173 * State for glClear()
174 */
175 struct clear_state
176 {
177 GLuint ArrayObj;
178 GLuint VBO;
179 };
180
181
182 /**
183 * State for glCopyPixels()
184 */
185 struct copypix_state
186 {
187 GLuint ArrayObj;
188 GLuint VBO;
189 };
190
191
192 /**
193 * State for glDrawPixels()
194 */
195 struct drawpix_state
196 {
197 GLuint ArrayObj;
198 GLuint VBO;
199
200 GLuint StencilFP; /**< Fragment program for drawing stencil images */
201 GLuint DepthFP; /**< Fragment program for drawing depth images */
202 };
203
204
205 /**
206 * State for glBitmap()
207 */
208 struct bitmap_state
209 {
210 GLuint ArrayObj;
211 GLuint VBO;
212 struct temp_texture Tex; /**< separate texture from other meta ops */
213 };
214
215
216 /**
217 * State for _mesa_meta_generate_mipmap()
218 */
219 struct gen_mipmap_state
220 {
221 GLuint ArrayObj;
222 GLuint VBO;
223 GLuint FBO;
224 };
225
226
227 /**
228 * All per-context meta state.
229 */
230 struct gl_meta_state
231 {
232 struct save_state Save; /**< state saved during meta-ops */
233
234 struct temp_texture TempTex;
235
236 struct blit_state Blit; /**< For _mesa_meta_blit_framebuffer() */
237 struct clear_state Clear; /**< For _mesa_meta_clear() */
238 struct copypix_state CopyPix; /**< For _mesa_meta_copy_pixels() */
239 struct drawpix_state DrawPix; /**< For _mesa_meta_draw_pixels() */
240 struct bitmap_state Bitmap; /**< For _mesa_meta_bitmap() */
241 struct gen_mipmap_state Mipmap; /**< For _mesa_meta_generate_mipmap() */
242 };
243
244
245 /**
246 * Initialize meta-ops for a context.
247 * To be called once during context creation.
248 */
249 void
250 _mesa_meta_init(GLcontext *ctx)
251 {
252 ASSERT(!ctx->Meta);
253
254 ctx->Meta = CALLOC_STRUCT(gl_meta_state);
255 }
256
257
258 /**
259 * Free context meta-op state.
260 * To be called once during context destruction.
261 */
262 void
263 _mesa_meta_free(GLcontext *ctx)
264 {
265 struct gl_meta_state *meta = ctx->Meta;
266
267 if (_mesa_get_current_context()) {
268 /* if there's no current context, these textures, buffers, etc should
269 * still get freed by _mesa_free_context_data().
270 */
271
272 /* the temporary texture */
273 _mesa_DeleteTextures(1, &meta->TempTex.TexObj);
274
275 /* glBlitFramebuffer */
276 _mesa_DeleteBuffersARB(1, & meta->Blit.VBO);
277 _mesa_DeleteVertexArraysAPPLE(1, &meta->Blit.ArrayObj);
278 _mesa_DeletePrograms(1, &meta->Blit.DepthFP);
279
280 /* glClear */
281 _mesa_DeleteBuffersARB(1, & meta->Clear.VBO);
282 _mesa_DeleteVertexArraysAPPLE(1, &meta->Clear.ArrayObj);
283
284 /* glCopyPixels */
285 _mesa_DeleteBuffersARB(1, & meta->CopyPix.VBO);
286 _mesa_DeleteVertexArraysAPPLE(1, &meta->CopyPix.ArrayObj);
287
288 /* glDrawPixels */
289 _mesa_DeleteBuffersARB(1, & meta->DrawPix.VBO);
290 _mesa_DeleteVertexArraysAPPLE(1, &meta->DrawPix.ArrayObj);
291 _mesa_DeletePrograms(1, &meta->DrawPix.DepthFP);
292 _mesa_DeletePrograms(1, &meta->DrawPix.StencilFP);
293
294 /* glBitmap */
295 _mesa_DeleteBuffersARB(1, & meta->Bitmap.VBO);
296 _mesa_DeleteVertexArraysAPPLE(1, &meta->Bitmap.ArrayObj);
297 _mesa_DeleteTextures(1, &meta->Bitmap.Tex.TexObj);
298 }
299
300 _mesa_free(ctx->Meta);
301 ctx->Meta = NULL;
302 }
303
304
305 /**
306 * Enter meta state. This is like a light-weight version of glPushAttrib
307 * but it also resets most GL state back to default values.
308 *
309 * \param state bitmask of META_* flags indicating which attribute groups
310 * to save and reset to their defaults
311 */
312 static void
313 _mesa_meta_begin(GLcontext *ctx, GLbitfield state)
314 {
315 struct save_state *save = &ctx->Meta->Save;
316
317 save->SavedState = state;
318
319 if (state & META_ALPHA_TEST) {
320 save->AlphaEnabled = ctx->Color.AlphaEnabled;
321 if (ctx->Color.AlphaEnabled)
322 _mesa_set_enable(ctx, GL_ALPHA_TEST, GL_FALSE);
323 }
324
325 if (state & META_BLEND) {
326 save->BlendEnabled = ctx->Color.BlendEnabled;
327 if (ctx->Color.BlendEnabled)
328 _mesa_set_enable(ctx, GL_BLEND, GL_FALSE);
329 save->ColorLogicOpEnabled = ctx->Color.ColorLogicOpEnabled;
330 if (ctx->Color.ColorLogicOpEnabled)
331 _mesa_set_enable(ctx, GL_COLOR_LOGIC_OP, GL_FALSE);
332 }
333
334 if (state & META_COLOR_MASK) {
335 COPY_4V(save->ColorMask, ctx->Color.ColorMask);
336 if (!ctx->Color.ColorMask[0] ||
337 !ctx->Color.ColorMask[1] ||
338 !ctx->Color.ColorMask[2] ||
339 !ctx->Color.ColorMask[3])
340 _mesa_ColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
341 }
342
343 if (state & META_DEPTH_TEST) {
344 save->Depth = ctx->Depth; /* struct copy */
345 if (ctx->Depth.Test)
346 _mesa_set_enable(ctx, GL_DEPTH_TEST, GL_FALSE);
347 }
348
349 if (state & META_FOG) {
350 save->Fog = ctx->Fog.Enabled;
351 if (ctx->Fog.Enabled)
352 _mesa_set_enable(ctx, GL_FOG, GL_FALSE);
353 }
354
355 if (state & META_PIXEL_STORE) {
356 save->Pack = ctx->Pack;
357 save->Unpack = ctx->Unpack;
358 ctx->Pack = ctx->DefaultPacking;
359 ctx->Unpack = ctx->DefaultPacking;
360 }
361
362 if (state & META_RASTERIZATION) {
363 save->FrontPolygonMode = ctx->Polygon.FrontMode;
364 save->BackPolygonMode = ctx->Polygon.BackMode;
365 save->PolygonOffset = ctx->Polygon.OffsetFill;
366 save->PolygonSmooth = ctx->Polygon.SmoothFlag;
367 save->PolygonStipple = ctx->Polygon.StippleFlag;
368 save->PolygonCull = ctx->Polygon.CullFlag;
369 _mesa_PolygonMode(GL_FRONT_AND_BACK, GL_FILL);
370 _mesa_set_enable(ctx, GL_POLYGON_OFFSET_FILL, GL_FALSE);
371 _mesa_set_enable(ctx, GL_POLYGON_SMOOTH, GL_FALSE);
372 _mesa_set_enable(ctx, GL_POLYGON_STIPPLE, GL_FALSE);
373 _mesa_set_enable(ctx, GL_CULL_FACE, GL_FALSE);
374 }
375
376 if (state & META_SCISSOR) {
377 save->Scissor = ctx->Scissor; /* struct copy */
378 }
379
380 if (state & META_SHADER) {
381 if (ctx->Extensions.ARB_vertex_program) {
382 save->VertexProgramEnabled = ctx->VertexProgram.Enabled;
383 save->VertexProgram = ctx->VertexProgram.Current;
384 _mesa_set_enable(ctx, GL_VERTEX_PROGRAM_ARB, GL_FALSE);
385 }
386
387 if (ctx->Extensions.ARB_fragment_program) {
388 save->FragmentProgramEnabled = ctx->FragmentProgram.Enabled;
389 save->FragmentProgram = ctx->FragmentProgram.Current;
390 _mesa_set_enable(ctx, GL_FRAGMENT_PROGRAM_ARB, GL_FALSE);
391 }
392
393 if (ctx->Extensions.ARB_shader_objects) {
394 save->Shader = ctx->Shader.CurrentProgram ?
395 ctx->Shader.CurrentProgram->Name : 0;
396 _mesa_UseProgramObjectARB(0);
397 }
398 }
399
400 if (state & META_STENCIL_TEST) {
401 save->Stencil = ctx->Stencil; /* struct copy */
402 if (ctx->Stencil.Enabled)
403 _mesa_set_enable(ctx, GL_STENCIL_TEST, GL_FALSE);
404 /* NOTE: other stencil state not reset */
405 }
406
407 if (state & META_TEXTURE) {
408 GLuint u, tgt;
409
410 save->ActiveUnit = ctx->Texture.CurrentUnit;
411 save->ClientActiveUnit = ctx->Array.ActiveTexture;
412 save->EnvMode = ctx->Texture.Unit[0].EnvMode;
413
414 if (ctx->Texture._EnabledUnits |
415 ctx->Texture._EnabledCoordUnits |
416 ctx->Texture._TexGenEnabled |
417 ctx->Texture._TexMatEnabled) {
418
419 /* Disable all texture units */
420 for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
421 save->TexEnabled[u] = ctx->Texture.Unit[u].Enabled;
422 save->TexGenEnabled[u] = ctx->Texture.Unit[u].TexGenEnabled;
423 if (ctx->Texture.Unit[u].Enabled ||
424 ctx->Texture.Unit[u].TexGenEnabled) {
425 _mesa_ActiveTextureARB(GL_TEXTURE0 + u);
426 _mesa_set_enable(ctx, GL_TEXTURE_1D, GL_FALSE);
427 _mesa_set_enable(ctx, GL_TEXTURE_2D, GL_FALSE);
428 _mesa_set_enable(ctx, GL_TEXTURE_3D, GL_FALSE);
429 _mesa_set_enable(ctx, GL_TEXTURE_CUBE_MAP, GL_FALSE);
430 _mesa_set_enable(ctx, GL_TEXTURE_RECTANGLE, GL_FALSE);
431 _mesa_set_enable(ctx, GL_TEXTURE_GEN_S, GL_FALSE);
432 _mesa_set_enable(ctx, GL_TEXTURE_GEN_T, GL_FALSE);
433 _mesa_set_enable(ctx, GL_TEXTURE_GEN_R, GL_FALSE);
434 _mesa_set_enable(ctx, GL_TEXTURE_GEN_Q, GL_FALSE);
435 }
436 }
437 }
438
439 /* save current texture objects for unit[0] only */
440 for (tgt = 0; tgt < NUM_TEXTURE_TARGETS; tgt++) {
441 _mesa_reference_texobj(&save->CurrentTexture[tgt],
442 ctx->Texture.Unit[0].CurrentTex[tgt]);
443 }
444
445 /* set defaults for unit[0] */
446 _mesa_ActiveTextureARB(GL_TEXTURE0);
447 _mesa_ClientActiveTextureARB(GL_TEXTURE0);
448 _mesa_TexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
449 }
450
451 if (state & META_TRANSFORM) {
452 GLuint activeTexture = ctx->Texture.CurrentUnit;
453 _mesa_memcpy(save->ModelviewMatrix, ctx->ModelviewMatrixStack.Top->m,
454 16 * sizeof(GLfloat));
455 _mesa_memcpy(save->ProjectionMatrix, ctx->ProjectionMatrixStack.Top->m,
456 16 * sizeof(GLfloat));
457 _mesa_memcpy(save->TextureMatrix, ctx->TextureMatrixStack[0].Top->m,
458 16 * sizeof(GLfloat));
459 save->MatrixMode = ctx->Transform.MatrixMode;
460 /* set 1:1 vertex:pixel coordinate transform */
461 _mesa_ActiveTextureARB(GL_TEXTURE0);
462 _mesa_MatrixMode(GL_TEXTURE);
463 _mesa_LoadIdentity();
464 _mesa_ActiveTextureARB(GL_TEXTURE0 + activeTexture);
465 _mesa_MatrixMode(GL_MODELVIEW);
466 _mesa_LoadIdentity();
467 _mesa_MatrixMode(GL_PROJECTION);
468 _mesa_LoadIdentity();
469 _mesa_Ortho(0.0F, ctx->DrawBuffer->Width,
470 0.0F, ctx->DrawBuffer->Height,
471 -1.0F, 1.0F);
472 save->ClipPlanesEnabled = ctx->Transform.ClipPlanesEnabled;
473 if (ctx->Transform.ClipPlanesEnabled) {
474 GLuint i;
475 for (i = 0; i < ctx->Const.MaxClipPlanes; i++) {
476 _mesa_set_enable(ctx, GL_CLIP_PLANE0 + i, GL_FALSE);
477 }
478 }
479 }
480
481 if (state & META_VERTEX) {
482 /* save vertex array object state */
483 _mesa_reference_array_object(ctx, &save->ArrayObj,
484 ctx->Array.ArrayObj);
485 _mesa_reference_buffer_object(ctx, &save->ArrayBufferObj,
486 ctx->Array.ArrayBufferObj);
487 /* set some default state? */
488 }
489
490 if (state & META_VIEWPORT) {
491 /* save viewport state */
492 save->ViewportX = ctx->Viewport.X;
493 save->ViewportY = ctx->Viewport.Y;
494 save->ViewportW = ctx->Viewport.Width;
495 save->ViewportH = ctx->Viewport.Height;
496 /* set viewport to match window size */
497 if (ctx->Viewport.X != 0 ||
498 ctx->Viewport.Y != 0 ||
499 ctx->Viewport.Width != ctx->DrawBuffer->Width ||
500 ctx->Viewport.Height != ctx->DrawBuffer->Height) {
501 _mesa_set_viewport(ctx, 0, 0,
502 ctx->DrawBuffer->Width, ctx->DrawBuffer->Height);
503 }
504 /* save depth range state */
505 save->DepthNear = ctx->Viewport.Near;
506 save->DepthFar = ctx->Viewport.Far;
507 /* set depth range to default */
508 _mesa_DepthRange(0.0, 1.0);
509 }
510
511 /* misc */
512 {
513 save->Lighting = ctx->Light.Enabled;
514 if (ctx->Light.Enabled)
515 _mesa_set_enable(ctx, GL_LIGHTING, GL_FALSE);
516 }
517 }
518
519
520 /**
521 * Leave meta state. This is like a light-weight version of glPopAttrib().
522 */
523 static void
524 _mesa_meta_end(GLcontext *ctx)
525 {
526 struct save_state *save = &ctx->Meta->Save;
527 const GLbitfield state = save->SavedState;
528
529 if (state & META_ALPHA_TEST) {
530 if (ctx->Color.AlphaEnabled != save->AlphaEnabled)
531 _mesa_set_enable(ctx, GL_ALPHA_TEST, save->AlphaEnabled);
532 }
533
534 if (state & META_BLEND) {
535 if (ctx->Color.BlendEnabled != save->BlendEnabled)
536 _mesa_set_enable(ctx, GL_BLEND, save->BlendEnabled);
537 if (ctx->Color.ColorLogicOpEnabled != save->ColorLogicOpEnabled)
538 _mesa_set_enable(ctx, GL_COLOR_LOGIC_OP, save->ColorLogicOpEnabled);
539 }
540
541 if (state & META_COLOR_MASK) {
542 if (!TEST_EQ_4V(ctx->Color.ColorMask, save->ColorMask))
543 _mesa_ColorMask(save->ColorMask[0], save->ColorMask[1],
544 save->ColorMask[2], save->ColorMask[3]);
545 }
546
547 if (state & META_DEPTH_TEST) {
548 if (ctx->Depth.Test != save->Depth.Test)
549 _mesa_set_enable(ctx, GL_DEPTH_TEST, save->Depth.Test);
550 _mesa_DepthFunc(save->Depth.Func);
551 _mesa_DepthMask(save->Depth.Mask);
552 }
553
554 if (state & META_FOG) {
555 _mesa_set_enable(ctx, GL_FOG, save->Fog);
556 }
557
558 if (state & META_PIXEL_STORE) {
559 ctx->Pack = save->Pack;
560 ctx->Unpack = save->Unpack;
561 }
562
563 if (state & META_RASTERIZATION) {
564 _mesa_PolygonMode(GL_FRONT, save->FrontPolygonMode);
565 _mesa_PolygonMode(GL_BACK, save->BackPolygonMode);
566 _mesa_set_enable(ctx, GL_POLYGON_STIPPLE, save->PolygonStipple);
567 _mesa_set_enable(ctx, GL_POLYGON_OFFSET_FILL, save->PolygonOffset);
568 _mesa_set_enable(ctx, GL_POLYGON_SMOOTH, save->PolygonSmooth);
569 _mesa_set_enable(ctx, GL_CULL_FACE, save->PolygonCull);
570 }
571
572 if (state & META_SCISSOR) {
573 _mesa_set_enable(ctx, GL_SCISSOR_TEST, save->Scissor.Enabled);
574 _mesa_Scissor(save->Scissor.X, save->Scissor.Y,
575 save->Scissor.Width, save->Scissor.Height);
576 }
577
578 if (state & META_SHADER) {
579 if (ctx->Extensions.ARB_vertex_program) {
580 _mesa_set_enable(ctx, GL_VERTEX_PROGRAM_ARB,
581 save->VertexProgramEnabled);
582 _mesa_reference_vertprog(ctx, &ctx->VertexProgram.Current,
583 save->VertexProgram);
584 }
585
586 if (ctx->Extensions.ARB_fragment_program) {
587 _mesa_set_enable(ctx, GL_FRAGMENT_PROGRAM_ARB,
588 save->FragmentProgramEnabled);
589 _mesa_reference_fragprog(ctx, &ctx->FragmentProgram.Current,
590 save->FragmentProgram);
591 }
592
593 if (ctx->Extensions.ARB_shader_objects) {
594 _mesa_UseProgramObjectARB(save->Shader);
595 }
596 }
597
598 if (state & META_STENCIL_TEST) {
599 const struct gl_stencil_attrib *stencil = &save->Stencil;
600
601 _mesa_set_enable(ctx, GL_STENCIL_TEST, stencil->Enabled);
602 _mesa_ClearStencil(stencil->Clear);
603 if (ctx->Extensions.EXT_stencil_two_side) {
604 _mesa_set_enable(ctx, GL_STENCIL_TEST_TWO_SIDE_EXT,
605 stencil->TestTwoSide);
606 _mesa_ActiveStencilFaceEXT(stencil->ActiveFace
607 ? GL_BACK : GL_FRONT);
608 }
609 /* front state */
610 _mesa_StencilFuncSeparate(GL_FRONT,
611 stencil->Function[0],
612 stencil->Ref[0],
613 stencil->ValueMask[0]);
614 _mesa_StencilMaskSeparate(GL_FRONT, stencil->WriteMask[0]);
615 _mesa_StencilOpSeparate(GL_FRONT, stencil->FailFunc[0],
616 stencil->ZFailFunc[0],
617 stencil->ZPassFunc[0]);
618 /* back state */
619 _mesa_StencilFuncSeparate(GL_BACK,
620 stencil->Function[1],
621 stencil->Ref[1],
622 stencil->ValueMask[1]);
623 _mesa_StencilMaskSeparate(GL_BACK, stencil->WriteMask[1]);
624 _mesa_StencilOpSeparate(GL_BACK, stencil->FailFunc[1],
625 stencil->ZFailFunc[1],
626 stencil->ZPassFunc[1]);
627 }
628
629 if (state & META_TEXTURE) {
630 GLuint u, tgt;
631
632 ASSERT(ctx->Texture.CurrentUnit == 0);
633
634 /* restore texenv for unit[0] */
635 _mesa_TexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, save->EnvMode);
636
637 /* restore texture objects for unit[0] only */
638 for (tgt = 0; tgt < NUM_TEXTURE_TARGETS; tgt++) {
639 _mesa_reference_texobj(&ctx->Texture.Unit[0].CurrentTex[tgt],
640 save->CurrentTexture[tgt]);
641 }
642
643 /* Re-enable textures, texgen */
644 for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
645 if (save->TexEnabled[u]) {
646 _mesa_ActiveTextureARB(GL_TEXTURE0 + u);
647
648 if (save->TexEnabled[u] & TEXTURE_1D_BIT)
649 _mesa_set_enable(ctx, GL_TEXTURE_1D, GL_TRUE);
650 if (save->TexEnabled[u] & TEXTURE_2D_BIT)
651 _mesa_set_enable(ctx, GL_TEXTURE_2D, GL_TRUE);
652 if (save->TexEnabled[u] & TEXTURE_3D_BIT)
653 _mesa_set_enable(ctx, GL_TEXTURE_3D, GL_TRUE);
654 if (save->TexEnabled[u] & TEXTURE_CUBE_BIT)
655 _mesa_set_enable(ctx, GL_TEXTURE_CUBE_MAP, GL_TRUE);
656 if (save->TexEnabled[u] & TEXTURE_RECT_BIT)
657 _mesa_set_enable(ctx, GL_TEXTURE_RECTANGLE, GL_TRUE);
658 }
659
660 if (save->TexGenEnabled[u]) {
661 _mesa_ActiveTextureARB(GL_TEXTURE0 + u);
662
663 if (save->TexGenEnabled[u] & S_BIT)
664 _mesa_set_enable(ctx, GL_TEXTURE_GEN_S, GL_TRUE);
665 if (save->TexGenEnabled[u] & T_BIT)
666 _mesa_set_enable(ctx, GL_TEXTURE_GEN_T, GL_TRUE);
667 if (save->TexGenEnabled[u] & R_BIT)
668 _mesa_set_enable(ctx, GL_TEXTURE_GEN_R, GL_TRUE);
669 if (save->TexGenEnabled[u] & Q_BIT)
670 _mesa_set_enable(ctx, GL_TEXTURE_GEN_Q, GL_TRUE);
671 }
672 }
673
674 /* restore current unit state */
675 _mesa_ActiveTextureARB(GL_TEXTURE0 + save->ActiveUnit);
676 _mesa_ClientActiveTextureARB(GL_TEXTURE0 + save->ClientActiveUnit);
677 }
678
679 if (state & META_TRANSFORM) {
680 GLuint activeTexture = ctx->Texture.CurrentUnit;
681 _mesa_ActiveTextureARB(GL_TEXTURE0);
682 _mesa_MatrixMode(GL_TEXTURE);
683 _mesa_LoadMatrixf(save->TextureMatrix);
684 _mesa_ActiveTextureARB(GL_TEXTURE0 + activeTexture);
685
686 _mesa_MatrixMode(GL_MODELVIEW);
687 _mesa_LoadMatrixf(save->ModelviewMatrix);
688
689 _mesa_MatrixMode(GL_PROJECTION);
690 _mesa_LoadMatrixf(save->ProjectionMatrix);
691
692 _mesa_MatrixMode(save->MatrixMode);
693
694 save->ClipPlanesEnabled = ctx->Transform.ClipPlanesEnabled;
695 if (save->ClipPlanesEnabled) {
696 GLuint i;
697 for (i = 0; i < ctx->Const.MaxClipPlanes; i++) {
698 if (save->ClipPlanesEnabled & (1 << i)) {
699 _mesa_set_enable(ctx, GL_CLIP_PLANE0 + i, GL_TRUE);
700 }
701 }
702 }
703 }
704
705 if (state & META_VERTEX) {
706 /* restore vertex buffer object */
707 _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, save->ArrayBufferObj->Name);
708 _mesa_reference_buffer_object(ctx, &save->ArrayBufferObj, NULL);
709
710 /* restore vertex array object */
711 _mesa_BindVertexArray(save->ArrayObj->Name);
712 _mesa_reference_array_object(ctx, &save->ArrayObj, NULL);
713 }
714
715 if (state & META_VIEWPORT) {
716 if (save->ViewportX != ctx->Viewport.X ||
717 save->ViewportY != ctx->Viewport.Y ||
718 save->ViewportW != ctx->Viewport.Width ||
719 save->ViewportH != ctx->Viewport.Height) {
720 _mesa_set_viewport(ctx, save->ViewportX, save->ViewportY,
721 save->ViewportW, save->ViewportH);
722 }
723 _mesa_DepthRange(save->DepthNear, save->DepthFar);
724 }
725
726 /* misc */
727 if (save->Lighting) {
728 _mesa_set_enable(ctx, GL_LIGHTING, GL_TRUE);
729 }
730 if (save->Fog) {
731 _mesa_set_enable(ctx, GL_FOG, GL_TRUE);
732 }
733 }
734
735
736 /**
737 * One-time init for a temp_texture object.
738 * Choose tex target, compute max tex size, etc.
739 */
740 static void
741 init_temp_texture(GLcontext *ctx, struct temp_texture *tex)
742 {
743 /* prefer texture rectangle */
744 if (ctx->Extensions.NV_texture_rectangle) {
745 tex->Target = GL_TEXTURE_RECTANGLE;
746 tex->MaxSize = ctx->Const.MaxTextureRectSize;
747 tex->NPOT = GL_TRUE;
748 }
749 else {
750 /* use 2D texture, NPOT if possible */
751 tex->Target = GL_TEXTURE_2D;
752 tex->MaxSize = 1 << (ctx->Const.MaxTextureLevels - 1);
753 tex->NPOT = ctx->Extensions.ARB_texture_non_power_of_two;
754 }
755 tex->MinSize = 16; /* 16 x 16 at least */
756 assert(tex->MaxSize > 0);
757
758 _mesa_GenTextures(1, &tex->TexObj);
759 _mesa_BindTexture(tex->Target, tex->TexObj);
760 }
761
762
763 /**
764 * Return pointer to temp_texture info for non-bitmap ops.
765 * This does some one-time init if needed.
766 */
767 static struct temp_texture *
768 get_temp_texture(GLcontext *ctx)
769 {
770 struct temp_texture *tex = &ctx->Meta->TempTex;
771
772 if (!tex->TexObj) {
773 init_temp_texture(ctx, tex);
774 }
775
776 return tex;
777 }
778
779
780 /**
781 * Return pointer to temp_texture info for _mesa_meta_bitmap().
782 * We use a separate texture for bitmaps to reduce texture
783 * allocation/deallocation.
784 */
785 static struct temp_texture *
786 get_bitmap_temp_texture(GLcontext *ctx)
787 {
788 struct temp_texture *tex = &ctx->Meta->Bitmap.Tex;
789
790 if (!tex->TexObj) {
791 init_temp_texture(ctx, tex);
792 }
793
794 return tex;
795 }
796
797
798 /**
799 * Compute the width/height of texture needed to draw an image of the
800 * given size. Return a flag indicating whether the current texture
801 * can be re-used (glTexSubImage2D) or if a new texture needs to be
802 * allocated (glTexImage2D).
803 * Also, compute s/t texcoords for drawing.
804 *
805 * \return GL_TRUE if new texture is needed, GL_FALSE otherwise
806 */
807 static GLboolean
808 alloc_texture(struct temp_texture *tex,
809 GLsizei width, GLsizei height, GLenum intFormat)
810 {
811 GLboolean newTex = GL_FALSE;
812
813 ASSERT(width <= tex->MaxSize);
814 ASSERT(height <= tex->MaxSize);
815
816 if (width > tex->Width ||
817 height > tex->Height ||
818 intFormat != tex->IntFormat) {
819 /* alloc new texture (larger or different format) */
820
821 if (tex->NPOT) {
822 /* use non-power of two size */
823 tex->Width = MAX2(tex->MinSize, width);
824 tex->Height = MAX2(tex->MinSize, height);
825 }
826 else {
827 /* find power of two size */
828 GLsizei w, h;
829 w = h = tex->MinSize;
830 while (w < width)
831 w *= 2;
832 while (h < height)
833 h *= 2;
834 tex->Width = w;
835 tex->Height = h;
836 }
837
838 tex->IntFormat = intFormat;
839
840 newTex = GL_TRUE;
841 }
842
843 /* compute texcoords */
844 if (tex->Target == GL_TEXTURE_RECTANGLE) {
845 tex->Sright = (GLfloat) width;
846 tex->Ttop = (GLfloat) height;
847 }
848 else {
849 tex->Sright = (GLfloat) width / tex->Width;
850 tex->Ttop = (GLfloat) height / tex->Height;
851 }
852
853 return newTex;
854 }
855
856
857 /**
858 * Setup/load texture for glCopyPixels or glBlitFramebuffer.
859 */
860 static void
861 setup_copypix_texture(struct temp_texture *tex,
862 GLboolean newTex,
863 GLint srcX, GLint srcY,
864 GLsizei width, GLsizei height, GLenum intFormat,
865 GLenum filter)
866 {
867 _mesa_BindTexture(tex->Target, tex->TexObj);
868 _mesa_TexParameteri(tex->Target, GL_TEXTURE_MIN_FILTER, filter);
869 _mesa_TexParameteri(tex->Target, GL_TEXTURE_MAG_FILTER, filter);
870 _mesa_TexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
871
872 /* copy framebuffer image to texture */
873 if (newTex) {
874 /* create new tex image */
875 if (tex->Width == width && tex->Height == height) {
876 /* create new tex with framebuffer data */
877 _mesa_CopyTexImage2D(tex->Target, 0, tex->IntFormat,
878 srcX, srcY, width, height, 0);
879 }
880 else {
881 /* create empty texture */
882 _mesa_TexImage2D(tex->Target, 0, tex->IntFormat,
883 tex->Width, tex->Height, 0,
884 intFormat, GL_UNSIGNED_BYTE, NULL);
885 /* load image */
886 _mesa_CopyTexSubImage2D(tex->Target, 0,
887 0, 0, srcX, srcY, width, height);
888 }
889 }
890 else {
891 /* replace existing tex image */
892 _mesa_CopyTexSubImage2D(tex->Target, 0,
893 0, 0, srcX, srcY, width, height);
894 }
895 }
896
897
898 /**
899 * Setup/load texture for glDrawPixels.
900 */
901 static void
902 setup_drawpix_texture(struct temp_texture *tex,
903 GLboolean newTex,
904 GLenum texIntFormat,
905 GLsizei width, GLsizei height,
906 GLenum format, GLenum type,
907 const GLvoid *pixels)
908 {
909 _mesa_BindTexture(tex->Target, tex->TexObj);
910 _mesa_TexParameteri(tex->Target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
911 _mesa_TexParameteri(tex->Target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
912 _mesa_TexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
913
914 /* copy pixel data to texture */
915 if (newTex) {
916 /* create new tex image */
917 if (tex->Width == width && tex->Height == height) {
918 /* create new tex and load image data */
919 _mesa_TexImage2D(tex->Target, 0, tex->IntFormat,
920 tex->Width, tex->Height, 0, format, type, pixels);
921 }
922 else {
923 /* create empty texture */
924 _mesa_TexImage2D(tex->Target, 0, tex->IntFormat,
925 tex->Width, tex->Height, 0, format, type, NULL);
926 /* load image */
927 _mesa_TexSubImage2D(tex->Target, 0,
928 0, 0, width, height, format, type, pixels);
929 }
930 }
931 else {
932 /* replace existing tex image */
933 _mesa_TexSubImage2D(tex->Target, 0,
934 0, 0, width, height, format, type, pixels);
935 }
936 }
937
938
939
940 /**
941 * One-time init for drawing depth pixels.
942 */
943 static void
944 init_blit_depth_pixels(GLcontext *ctx)
945 {
946 static const char *program =
947 "!!ARBfp1.0\n"
948 "TEX result.depth, fragment.texcoord[0], texture[0], %s; \n"
949 "END \n";
950 char program2[200];
951 struct blit_state *blit = &ctx->Meta->Blit;
952 struct temp_texture *tex = get_temp_texture(ctx);
953 const char *texTarget;
954
955 assert(blit->DepthFP == 0);
956
957 /* replace %s with "RECT" or "2D" */
958 assert(strlen(program) + 4 < sizeof(program2));
959 if (tex->Target == GL_TEXTURE_RECTANGLE)
960 texTarget = "RECT";
961 else
962 texTarget = "2D";
963 _mesa_snprintf(program2, sizeof(program2), program, texTarget);
964
965 _mesa_GenPrograms(1, &blit->DepthFP);
966 _mesa_BindProgram(GL_FRAGMENT_PROGRAM_ARB, blit->DepthFP);
967 _mesa_ProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
968 strlen(program2), (const GLubyte *) program2);
969 }
970
971
972 /**
973 * Meta implementation of ctx->Driver.BlitFramebuffer() in terms
974 * of texture mapping and polygon rendering.
975 */
976 void
977 _mesa_meta_blit_framebuffer(GLcontext *ctx,
978 GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
979 GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
980 GLbitfield mask, GLenum filter)
981 {
982 struct blit_state *blit = &ctx->Meta->Blit;
983 struct temp_texture *tex = get_temp_texture(ctx);
984 const GLsizei maxTexSize = tex->MaxSize;
985 const GLint srcX = MIN2(srcX0, srcX1);
986 const GLint srcY = MIN2(srcY0, srcY1);
987 const GLint srcW = abs(srcX1 - srcX0);
988 const GLint srcH = abs(srcY1 - srcY0);
989 const GLboolean srcFlipX = srcX1 < srcX0;
990 const GLboolean srcFlipY = srcY1 < srcY0;
991 GLfloat verts[4][4]; /* four verts of X,Y,S,T */
992 GLboolean newTex;
993
994 if (srcW > maxTexSize || srcH > maxTexSize) {
995 /* XXX avoid this fallback */
996 _swrast_BlitFramebuffer(ctx, srcX0, srcY0, srcX1, srcY1,
997 dstX0, dstY0, dstX1, dstY1, mask, filter);
998 return;
999 }
1000
1001 if (srcFlipX) {
1002 GLint tmp = dstX0;
1003 dstX0 = dstX1;
1004 dstX1 = tmp;
1005 }
1006
1007 if (srcFlipY) {
1008 GLint tmp = dstY0;
1009 dstY0 = dstY1;
1010 dstY1 = tmp;
1011 }
1012
1013 /* only scissor effects blit so save/clear all other relevant state */
1014 _mesa_meta_begin(ctx, ~META_SCISSOR);
1015
1016 if (blit->ArrayObj == 0) {
1017 /* one-time setup */
1018
1019 /* create vertex array object */
1020 _mesa_GenVertexArrays(1, &blit->ArrayObj);
1021 _mesa_BindVertexArray(blit->ArrayObj);
1022
1023 /* create vertex array buffer */
1024 _mesa_GenBuffersARB(1, &blit->VBO);
1025 _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, blit->VBO);
1026 _mesa_BufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(verts),
1027 NULL, GL_DYNAMIC_DRAW_ARB);
1028
1029 /* setup vertex arrays */
1030 _mesa_VertexPointer(2, GL_FLOAT, sizeof(verts[0]),
1031 (void *) (0 * sizeof(GLfloat)));
1032 _mesa_TexCoordPointer(2, GL_FLOAT, sizeof(verts[0]),
1033 (void *) (2 * sizeof(GLfloat)));
1034 _mesa_EnableClientState(GL_VERTEX_ARRAY);
1035 _mesa_EnableClientState(GL_TEXTURE_COORD_ARRAY);
1036 }
1037 else {
1038 _mesa_BindVertexArray(blit->ArrayObj);
1039 _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, blit->VBO);
1040 }
1041
1042 newTex = alloc_texture(tex, srcW, srcH, GL_RGBA);
1043
1044 /* vertex positions/texcoords (after texture allocation!) */
1045 {
1046 verts[0][0] = (GLfloat) dstX0;
1047 verts[0][1] = (GLfloat) dstY0;
1048 verts[1][0] = (GLfloat) dstX1;
1049 verts[1][1] = (GLfloat) dstY0;
1050 verts[2][0] = (GLfloat) dstX1;
1051 verts[2][1] = (GLfloat) dstY1;
1052 verts[3][0] = (GLfloat) dstX0;
1053 verts[3][1] = (GLfloat) dstY1;
1054
1055 verts[0][2] = 0.0F;
1056 verts[0][3] = 0.0F;
1057 verts[1][2] = tex->Sright;
1058 verts[1][3] = 0.0F;
1059 verts[2][2] = tex->Sright;
1060 verts[2][3] = tex->Ttop;
1061 verts[3][2] = 0.0F;
1062 verts[3][3] = tex->Ttop;
1063
1064 /* upload new vertex data */
1065 _mesa_BufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, sizeof(verts), verts);
1066 }
1067
1068 _mesa_set_enable(ctx, tex->Target, GL_TRUE);
1069
1070 if (mask & GL_COLOR_BUFFER_BIT) {
1071 setup_copypix_texture(tex, newTex, srcX, srcY, srcW, srcH,
1072 GL_RGBA, filter);
1073 _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
1074 mask &= ~GL_COLOR_BUFFER_BIT;
1075 }
1076
1077 if (mask & GL_DEPTH_BUFFER_BIT) {
1078 GLuint *tmp = (GLuint *) _mesa_malloc(srcW * srcH * sizeof(GLuint));
1079 if (tmp) {
1080 if (!blit->DepthFP)
1081 init_blit_depth_pixels(ctx);
1082
1083 /* maybe change tex format here */
1084 newTex = alloc_texture(tex, srcW, srcH, GL_DEPTH_COMPONENT);
1085
1086 _mesa_ReadPixels(srcX, srcY, srcW, srcH,
1087 GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, tmp);
1088
1089 setup_drawpix_texture(tex, newTex, GL_DEPTH_COMPONENT, srcW, srcH,
1090 GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, tmp);
1091
1092 _mesa_BindProgram(GL_FRAGMENT_PROGRAM_ARB, blit->DepthFP);
1093 _mesa_set_enable(ctx, GL_FRAGMENT_PROGRAM_ARB, GL_TRUE);
1094 _mesa_ColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
1095 _mesa_set_enable(ctx, GL_DEPTH_TEST, GL_TRUE);
1096 _mesa_DepthFunc(GL_ALWAYS);
1097 _mesa_DepthMask(GL_TRUE);
1098
1099 _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
1100 mask &= ~GL_DEPTH_BUFFER_BIT;
1101
1102 _mesa_free(tmp);
1103 }
1104 }
1105
1106 if (mask & GL_STENCIL_BUFFER_BIT) {
1107 /* XXX can't easily do stencil */
1108 }
1109
1110 _mesa_set_enable(ctx, tex->Target, GL_FALSE);
1111
1112 _mesa_meta_end(ctx);
1113
1114 if (mask) {
1115 _swrast_BlitFramebuffer(ctx, srcX0, srcY0, srcX1, srcY1,
1116 dstX0, dstY0, dstX1, dstY1, mask, filter);
1117 }
1118 }
1119
1120
1121 /**
1122 * Meta implementation of ctx->Driver.Clear() in terms of polygon rendering.
1123 */
1124 void
1125 _mesa_meta_clear(GLcontext *ctx, GLbitfield buffers)
1126 {
1127 struct clear_state *clear = &ctx->Meta->Clear;
1128 GLfloat verts[4][7]; /* four verts of X,Y,Z,R,G,B,A */
1129 /* save all state but scissor, pixel pack/unpack */
1130 GLbitfield metaSave = META_ALL - META_SCISSOR - META_PIXEL_STORE;
1131
1132 if (buffers & BUFFER_BITS_COLOR) {
1133 /* if clearing color buffers, don't save/restore colormask */
1134 metaSave -= META_COLOR_MASK;
1135 }
1136
1137 _mesa_meta_begin(ctx, metaSave);
1138
1139 if (clear->ArrayObj == 0) {
1140 /* one-time setup */
1141
1142 /* create vertex array object */
1143 _mesa_GenVertexArrays(1, &clear->ArrayObj);
1144 _mesa_BindVertexArray(clear->ArrayObj);
1145
1146 /* create vertex array buffer */
1147 _mesa_GenBuffersARB(1, &clear->VBO);
1148 _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, clear->VBO);
1149 _mesa_BufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(verts),
1150 NULL, GL_DYNAMIC_DRAW_ARB);
1151
1152 /* setup vertex arrays */
1153 _mesa_VertexPointer(3, GL_FLOAT, sizeof(verts[0]),
1154 (void *) (0 * sizeof(GLfloat)));
1155 _mesa_ColorPointer(4, GL_FLOAT, sizeof(verts[0]),
1156 (void *) (3 * sizeof(GLfloat)));
1157 _mesa_EnableClientState(GL_VERTEX_ARRAY);
1158 _mesa_EnableClientState(GL_COLOR_ARRAY);
1159 }
1160 else {
1161 _mesa_BindVertexArray(clear->ArrayObj);
1162 _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, clear->VBO);
1163 }
1164
1165 /* GL_COLOR_BUFFER_BIT */
1166 if (buffers & BUFFER_BITS_COLOR) {
1167 /* leave colormask, glDrawBuffer state as-is */
1168 }
1169 else {
1170 ASSERT(metaSave & META_COLOR_MASK);
1171 _mesa_ColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
1172 }
1173
1174 /* GL_DEPTH_BUFFER_BIT */
1175 if (buffers & BUFFER_BIT_DEPTH) {
1176 _mesa_set_enable(ctx, GL_DEPTH_TEST, GL_TRUE);
1177 _mesa_DepthFunc(GL_ALWAYS);
1178 _mesa_DepthMask(GL_TRUE);
1179 }
1180 else {
1181 assert(!ctx->Depth.Test);
1182 }
1183
1184 /* GL_STENCIL_BUFFER_BIT */
1185 if (buffers & BUFFER_BIT_STENCIL) {
1186 _mesa_set_enable(ctx, GL_STENCIL_TEST, GL_TRUE);
1187 _mesa_StencilOpSeparate(GL_FRONT_AND_BACK,
1188 GL_REPLACE, GL_REPLACE, GL_REPLACE);
1189 _mesa_StencilFuncSeparate(GL_FRONT_AND_BACK, GL_ALWAYS,
1190 ctx->Stencil.Clear & 0x7fffffff,
1191 ctx->Stencil.WriteMask[0]);
1192 }
1193 else {
1194 assert(!ctx->Stencil.Enabled);
1195 }
1196
1197 /* vertex positions/colors */
1198 {
1199 const GLfloat x0 = (GLfloat) ctx->DrawBuffer->_Xmin;
1200 const GLfloat y0 = (GLfloat) ctx->DrawBuffer->_Ymin;
1201 const GLfloat x1 = (GLfloat) ctx->DrawBuffer->_Xmax;
1202 const GLfloat y1 = (GLfloat) ctx->DrawBuffer->_Ymax;
1203 const GLfloat z = 1.0 - 2.0 * ctx->Depth.Clear;
1204 GLuint i;
1205
1206 verts[0][0] = x0;
1207 verts[0][1] = y0;
1208 verts[0][2] = z;
1209 verts[1][0] = x1;
1210 verts[1][1] = y0;
1211 verts[1][2] = z;
1212 verts[2][0] = x1;
1213 verts[2][1] = y1;
1214 verts[2][2] = z;
1215 verts[3][0] = x0;
1216 verts[3][1] = y1;
1217 verts[3][2] = z;
1218
1219 /* vertex colors */
1220 for (i = 0; i < 4; i++) {
1221 COPY_4FV(&verts[i][3], ctx->Color.ClearColor);
1222 }
1223
1224 /* upload new vertex data */
1225 _mesa_BufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, sizeof(verts), verts);
1226 }
1227
1228 /* draw quad */
1229 _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
1230
1231 _mesa_meta_end(ctx);
1232 }
1233
1234
1235 /**
1236 * Meta implementation of ctx->Driver.CopyPixels() in terms
1237 * of texture mapping and polygon rendering.
1238 */
1239 void
1240 _mesa_meta_copy_pixels(GLcontext *ctx, GLint srcX, GLint srcY,
1241 GLsizei width, GLsizei height,
1242 GLint dstX, GLint dstY, GLenum type)
1243 {
1244 struct copypix_state *copypix = &ctx->Meta->CopyPix;
1245 struct temp_texture *tex = get_temp_texture(ctx);
1246 GLfloat verts[4][5]; /* four verts of X,Y,Z,S,T */
1247 GLboolean newTex;
1248 GLenum intFormat = GL_RGBA;
1249
1250 if (type != GL_COLOR ||
1251 ctx->_ImageTransferState ||
1252 ctx->Fog.Enabled ||
1253 width > tex->MaxSize ||
1254 height > tex->MaxSize) {
1255 /* XXX avoid this fallback */
1256 _swrast_CopyPixels(ctx, srcX, srcY, width, height, dstX, dstY, type);
1257 return;
1258 }
1259
1260 /* Most GL state applies to glCopyPixels, but a there's a few things
1261 * we need to override:
1262 */
1263 _mesa_meta_begin(ctx, (META_RASTERIZATION |
1264 META_SHADER |
1265 META_TEXTURE |
1266 META_TRANSFORM |
1267 META_VERTEX |
1268 META_VIEWPORT));
1269
1270 if (copypix->ArrayObj == 0) {
1271 /* one-time setup */
1272
1273 /* create vertex array object */
1274 _mesa_GenVertexArrays(1, &copypix->ArrayObj);
1275 _mesa_BindVertexArray(copypix->ArrayObj);
1276
1277 /* create vertex array buffer */
1278 _mesa_GenBuffersARB(1, &copypix->VBO);
1279 _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, copypix->VBO);
1280 _mesa_BufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(verts),
1281 NULL, GL_DYNAMIC_DRAW_ARB);
1282
1283 /* setup vertex arrays */
1284 _mesa_VertexPointer(3, GL_FLOAT, sizeof(verts[0]),
1285 (void *) (0 * sizeof(GLfloat)));
1286 _mesa_TexCoordPointer(2, GL_FLOAT, sizeof(verts[0]),
1287 (void *) (3 * sizeof(GLfloat)));
1288 _mesa_EnableClientState(GL_VERTEX_ARRAY);
1289 _mesa_EnableClientState(GL_TEXTURE_COORD_ARRAY);
1290 }
1291 else {
1292 _mesa_BindVertexArray(copypix->ArrayObj);
1293 _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, copypix->VBO);
1294 }
1295
1296 newTex = alloc_texture(tex, width, height, intFormat);
1297
1298 /* vertex positions, texcoords (after texture allocation!) */
1299 {
1300 const GLfloat dstX0 = (GLfloat) dstX;
1301 const GLfloat dstY0 = (GLfloat) dstY;
1302 const GLfloat dstX1 = dstX + width * ctx->Pixel.ZoomX;
1303 const GLfloat dstY1 = dstY + height * ctx->Pixel.ZoomY;
1304 const GLfloat z = ctx->Current.RasterPos[2];
1305
1306 verts[0][0] = dstX0;
1307 verts[0][1] = dstY0;
1308 verts[0][2] = z;
1309 verts[0][3] = 0.0F;
1310 verts[0][4] = 0.0F;
1311 verts[1][0] = dstX1;
1312 verts[1][1] = dstY0;
1313 verts[1][2] = z;
1314 verts[1][3] = tex->Sright;
1315 verts[1][4] = 0.0F;
1316 verts[2][0] = dstX1;
1317 verts[2][1] = dstY1;
1318 verts[2][2] = z;
1319 verts[2][3] = tex->Sright;
1320 verts[2][4] = tex->Ttop;
1321 verts[3][0] = dstX0;
1322 verts[3][1] = dstY1;
1323 verts[3][2] = z;
1324 verts[3][3] = 0.0F;
1325 verts[3][4] = tex->Ttop;
1326
1327 /* upload new vertex data */
1328 _mesa_BufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, sizeof(verts), verts);
1329 }
1330
1331 /* Alloc/setup texture */
1332 setup_copypix_texture(tex, newTex, srcX, srcY, width, height,
1333 GL_RGBA, GL_NEAREST);
1334
1335 _mesa_set_enable(ctx, tex->Target, GL_TRUE);
1336
1337 /* draw textured quad */
1338 _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
1339
1340 _mesa_set_enable(ctx, tex->Target, GL_FALSE);
1341
1342 _mesa_meta_end(ctx);
1343 }
1344
1345
1346
1347 /**
1348 * When the glDrawPixels() image size is greater than the max rectangle
1349 * texture size we use this function to break the glDrawPixels() image
1350 * into tiles which fit into the max texture size.
1351 */
1352 static void
1353 tiled_draw_pixels(GLcontext *ctx,
1354 GLint tileSize,
1355 GLint x, GLint y, GLsizei width, GLsizei height,
1356 GLenum format, GLenum type,
1357 const struct gl_pixelstore_attrib *unpack,
1358 const GLvoid *pixels)
1359 {
1360 struct gl_pixelstore_attrib tileUnpack = *unpack;
1361 GLint i, j;
1362
1363 if (tileUnpack.RowLength == 0)
1364 tileUnpack.RowLength = width;
1365
1366 for (i = 0; i < width; i += tileSize) {
1367 const GLint tileWidth = MIN2(tileSize, width - i);
1368 const GLint tileX = (GLint) (x + i * ctx->Pixel.ZoomX);
1369
1370 tileUnpack.SkipPixels = unpack->SkipPixels + i;
1371
1372 for (j = 0; j < height; j += tileSize) {
1373 const GLint tileHeight = MIN2(tileSize, height - j);
1374 const GLint tileY = (GLint) (y + j * ctx->Pixel.ZoomY);
1375
1376 tileUnpack.SkipRows = unpack->SkipRows + j;
1377
1378 _mesa_meta_draw_pixels(ctx, tileX, tileY,
1379 tileWidth, tileHeight,
1380 format, type, &tileUnpack, pixels);
1381 }
1382 }
1383 }
1384
1385
1386 /**
1387 * One-time init for drawing stencil pixels.
1388 */
1389 static void
1390 init_draw_stencil_pixels(GLcontext *ctx)
1391 {
1392 /* This program is run eight times, once for each stencil bit.
1393 * The stencil values to draw are found in an 8-bit alpha texture.
1394 * We read the texture/stencil value and test if bit 'b' is set.
1395 * If the bit is not set, use KIL to kill the fragment.
1396 * Finally, we use the stencil test to update the stencil buffer.
1397 *
1398 * The basic algorithm for checking if a bit is set is:
1399 * if (is_odd(value / (1 << bit)))
1400 * result is one (or non-zero).
1401 * else
1402 * result is zero.
1403 * The program parameter contains three values:
1404 * parm.x = 255 / (1 << bit)
1405 * parm.y = 0.5
1406 * parm.z = 0.0
1407 */
1408 static const char *program =
1409 "!!ARBfp1.0\n"
1410 "PARAM parm = program.local[0]; \n"
1411 "TEMP t; \n"
1412 "TEX t, fragment.texcoord[0], texture[0], %s; \n" /* NOTE %s here! */
1413 "# t = t * 255 / bit \n"
1414 "MUL t.x, t.a, parm.x; \n"
1415 "# t = (int) t \n"
1416 "FRC t.y, t.x; \n"
1417 "SUB t.x, t.x, t.y; \n"
1418 "# t = t * 0.5 \n"
1419 "MUL t.x, t.x, parm.y; \n"
1420 "# t = fract(t.x) \n"
1421 "FRC t.x, t.x; # if t.x != 0, then the bit is set \n"
1422 "# t.x = (t.x == 0 ? 1 : 0) \n"
1423 "SGE t.x, -t.x, parm.z; \n"
1424 "KIL -t.x; \n"
1425 "# for debug only \n"
1426 "#MOV result.color, t.x; \n"
1427 "END \n";
1428 char program2[1000];
1429 struct drawpix_state *drawpix = &ctx->Meta->DrawPix;
1430 struct temp_texture *tex = get_temp_texture(ctx);
1431 const char *texTarget;
1432
1433 assert(drawpix->StencilFP == 0);
1434
1435 /* replace %s with "RECT" or "2D" */
1436 assert(strlen(program) + 4 < sizeof(program2));
1437 if (tex->Target == GL_TEXTURE_RECTANGLE)
1438 texTarget = "RECT";
1439 else
1440 texTarget = "2D";
1441 _mesa_snprintf(program2, sizeof(program2), program, texTarget);
1442
1443 _mesa_GenPrograms(1, &drawpix->StencilFP);
1444 _mesa_BindProgram(GL_FRAGMENT_PROGRAM_ARB, drawpix->StencilFP);
1445 _mesa_ProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
1446 strlen(program2), (const GLubyte *) program2);
1447 }
1448
1449
1450 /**
1451 * One-time init for drawing depth pixels.
1452 */
1453 static void
1454 init_draw_depth_pixels(GLcontext *ctx)
1455 {
1456 static const char *program =
1457 "!!ARBfp1.0\n"
1458 "PARAM color = program.local[0]; \n"
1459 "TEX result.depth, fragment.texcoord[0], texture[0], %s; \n"
1460 "MOV result.color, color; \n"
1461 "END \n";
1462 char program2[200];
1463 struct drawpix_state *drawpix = &ctx->Meta->DrawPix;
1464 struct temp_texture *tex = get_temp_texture(ctx);
1465 const char *texTarget;
1466
1467 assert(drawpix->DepthFP == 0);
1468
1469 /* replace %s with "RECT" or "2D" */
1470 assert(strlen(program) + 4 < sizeof(program2));
1471 if (tex->Target == GL_TEXTURE_RECTANGLE)
1472 texTarget = "RECT";
1473 else
1474 texTarget = "2D";
1475 _mesa_snprintf(program2, sizeof(program2), program, texTarget);
1476
1477 _mesa_GenPrograms(1, &drawpix->DepthFP);
1478 _mesa_BindProgram(GL_FRAGMENT_PROGRAM_ARB, drawpix->DepthFP);
1479 _mesa_ProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
1480 strlen(program2), (const GLubyte *) program2);
1481 }
1482
1483
1484 /**
1485 * Meta implementation of ctx->Driver.DrawPixels() in terms
1486 * of texture mapping and polygon rendering.
1487 */
1488 void
1489 _mesa_meta_draw_pixels(GLcontext *ctx,
1490 GLint x, GLint y, GLsizei width, GLsizei height,
1491 GLenum format, GLenum type,
1492 const struct gl_pixelstore_attrib *unpack,
1493 const GLvoid *pixels)
1494 {
1495 struct drawpix_state *drawpix = &ctx->Meta->DrawPix;
1496 struct temp_texture *tex = get_temp_texture(ctx);
1497 const struct gl_pixelstore_attrib unpackSave = ctx->Unpack;
1498 const GLuint origStencilMask = ctx->Stencil.WriteMask[0];
1499 GLfloat verts[4][5]; /* four verts of X,Y,Z,S,T */
1500 GLenum texIntFormat;
1501 GLboolean fallback, newTex;
1502 GLbitfield metaExtraSave = 0x0;
1503
1504 /*
1505 * Determine if we can do the glDrawPixels with texture mapping.
1506 */
1507 fallback = GL_FALSE;
1508 if (ctx->_ImageTransferState ||
1509 ctx->Fog.Enabled) {
1510 fallback = GL_TRUE;
1511 }
1512
1513 if (_mesa_is_color_format(format)) {
1514 /* use more compact format when possible */
1515 /* XXX disable special case for GL_LUMINANCE for now to work around
1516 * apparent i965 driver bug (see bug #23670).
1517 */
1518 if (/*format == GL_LUMINANCE ||*/ format == GL_LUMINANCE_ALPHA)
1519 texIntFormat = format;
1520 else
1521 texIntFormat = GL_RGBA;
1522 }
1523 else if (_mesa_is_stencil_format(format)) {
1524 if (ctx->Extensions.ARB_fragment_program &&
1525 type == GL_UNSIGNED_BYTE) {
1526 /* We'll store stencil as alpha. This only works for GLubyte
1527 * image data because of how incoming values are mapped to alpha
1528 * in [0,1].
1529 */
1530 texIntFormat = GL_ALPHA;
1531 metaExtraSave = (META_COLOR_MASK |
1532 META_DEPTH_TEST |
1533 META_SHADER |
1534 META_STENCIL_TEST);
1535 }
1536 else {
1537 fallback = GL_TRUE;
1538 }
1539 }
1540 else if (_mesa_is_depth_format(format)) {
1541 if (ctx->Extensions.ARB_depth_texture &&
1542 ctx->Extensions.ARB_fragment_program) {
1543 texIntFormat = GL_DEPTH_COMPONENT;
1544 metaExtraSave = (META_SHADER);
1545 }
1546 else {
1547 fallback = GL_TRUE;
1548 }
1549 }
1550 else {
1551 fallback = GL_TRUE;
1552 }
1553
1554 if (fallback) {
1555 _swrast_DrawPixels(ctx, x, y, width, height,
1556 format, type, unpack, pixels);
1557 return;
1558 }
1559
1560 /*
1561 * Check image size against max texture size, draw as tiles if needed.
1562 */
1563 if (width > tex->MaxSize || height > tex->MaxSize) {
1564 tiled_draw_pixels(ctx, tex->MaxSize, x, y, width, height,
1565 format, type, unpack, pixels);
1566 return;
1567 }
1568
1569 /* Most GL state applies to glDrawPixels (like blending, stencil, etc),
1570 * but a there's a few things we need to override:
1571 */
1572 _mesa_meta_begin(ctx, (META_RASTERIZATION |
1573 META_SHADER |
1574 META_TEXTURE |
1575 META_TRANSFORM |
1576 META_VERTEX |
1577 META_VIEWPORT |
1578 metaExtraSave));
1579
1580 if (drawpix->ArrayObj == 0) {
1581 /* one-time setup */
1582
1583 /* create vertex array object */
1584 _mesa_GenVertexArrays(1, &drawpix->ArrayObj);
1585 _mesa_BindVertexArray(drawpix->ArrayObj);
1586
1587 /* create vertex array buffer */
1588 _mesa_GenBuffersARB(1, &drawpix->VBO);
1589 _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, drawpix->VBO);
1590 _mesa_BufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(verts),
1591 NULL, GL_DYNAMIC_DRAW_ARB);
1592
1593 /* setup vertex arrays */
1594 _mesa_VertexPointer(3, GL_FLOAT, sizeof(verts[0]),
1595 (void *) (0 * sizeof(GLfloat)));
1596 _mesa_TexCoordPointer(2, GL_FLOAT, sizeof(verts[0]),
1597 (void *) (3 * sizeof(GLfloat)));
1598 _mesa_EnableClientState(GL_VERTEX_ARRAY);
1599 _mesa_EnableClientState(GL_TEXTURE_COORD_ARRAY);
1600 }
1601 else {
1602 _mesa_BindVertexArray(drawpix->ArrayObj);
1603 _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, drawpix->VBO);
1604 }
1605
1606 newTex = alloc_texture(tex, width, height, texIntFormat);
1607
1608 /* vertex positions, texcoords (after texture allocation!) */
1609 {
1610 const GLfloat x0 = (GLfloat) x;
1611 const GLfloat y0 = (GLfloat) y;
1612 const GLfloat x1 = x + width * ctx->Pixel.ZoomX;
1613 const GLfloat y1 = y + height * ctx->Pixel.ZoomY;
1614 const GLfloat z = ctx->Current.RasterPos[2];
1615
1616 verts[0][0] = x0;
1617 verts[0][1] = y0;
1618 verts[0][2] = z;
1619 verts[0][3] = 0.0F;
1620 verts[0][4] = 0.0F;
1621 verts[1][0] = x1;
1622 verts[1][1] = y0;
1623 verts[1][2] = z;
1624 verts[1][3] = tex->Sright;
1625 verts[1][4] = 0.0F;
1626 verts[2][0] = x1;
1627 verts[2][1] = y1;
1628 verts[2][2] = z;
1629 verts[2][3] = tex->Sright;
1630 verts[2][4] = tex->Ttop;
1631 verts[3][0] = x0;
1632 verts[3][1] = y1;
1633 verts[3][2] = z;
1634 verts[3][3] = 0.0F;
1635 verts[3][4] = tex->Ttop;
1636
1637 /* upload new vertex data */
1638 _mesa_BufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, sizeof(verts), verts);
1639 }
1640
1641 /* set given unpack params */
1642 ctx->Unpack = *unpack;
1643
1644 _mesa_set_enable(ctx, tex->Target, GL_TRUE);
1645
1646 if (_mesa_is_stencil_format(format)) {
1647 /* Drawing stencil */
1648 GLint bit;
1649
1650 if (!drawpix->StencilFP)
1651 init_draw_stencil_pixels(ctx);
1652
1653 setup_drawpix_texture(tex, newTex, texIntFormat, width, height,
1654 GL_ALPHA, type, pixels);
1655
1656 _mesa_ColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
1657
1658 _mesa_set_enable(ctx, GL_STENCIL_TEST, GL_TRUE);
1659 _mesa_StencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
1660
1661 _mesa_BindProgram(GL_FRAGMENT_PROGRAM_ARB, drawpix->StencilFP);
1662 _mesa_set_enable(ctx, GL_FRAGMENT_PROGRAM_ARB, GL_TRUE);
1663
1664 for (bit = 0; bit < ctx->Visual.stencilBits; bit++) {
1665 const GLuint mask = 1 << bit;
1666 if (mask & origStencilMask) {
1667 _mesa_StencilFunc(GL_ALWAYS, mask, mask);
1668 _mesa_StencilMask(mask);
1669
1670 _mesa_ProgramLocalParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, 0,
1671 255.0 / mask, 0.5, 0.0, 0.0);
1672
1673 _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
1674 }
1675 }
1676 }
1677 else if (_mesa_is_depth_format(format)) {
1678 /* Drawing depth */
1679 if (!drawpix->DepthFP)
1680 init_draw_depth_pixels(ctx);
1681
1682 _mesa_BindProgram(GL_FRAGMENT_PROGRAM_ARB, drawpix->DepthFP);
1683 _mesa_set_enable(ctx, GL_FRAGMENT_PROGRAM_ARB, GL_TRUE);
1684
1685 /* polygon color = current raster color */
1686 _mesa_ProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, 0,
1687 ctx->Current.RasterColor);
1688
1689 setup_drawpix_texture(tex, newTex, texIntFormat, width, height,
1690 format, type, pixels);
1691
1692 _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
1693 }
1694 else {
1695 /* Drawing RGBA */
1696 setup_drawpix_texture(tex, newTex, texIntFormat, width, height,
1697 format, type, pixels);
1698 _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
1699 }
1700
1701 _mesa_set_enable(ctx, tex->Target, GL_FALSE);
1702
1703 /* restore unpack params */
1704 ctx->Unpack = unpackSave;
1705
1706 _mesa_meta_end(ctx);
1707 }
1708
1709
1710 /**
1711 * Do glBitmap with a alpha texture quad. Use the alpha test to
1712 * cull the 'off' bits. If alpha test is already enabled, fall back
1713 * to swrast (should be a rare case).
1714 * A bitmap cache as in the gallium/mesa state tracker would
1715 * improve performance a lot.
1716 */
1717 void
1718 _mesa_meta_bitmap(GLcontext *ctx,
1719 GLint x, GLint y, GLsizei width, GLsizei height,
1720 const struct gl_pixelstore_attrib *unpack,
1721 const GLubyte *bitmap1)
1722 {
1723 struct bitmap_state *bitmap = &ctx->Meta->Bitmap;
1724 struct temp_texture *tex = get_bitmap_temp_texture(ctx);
1725 const GLenum texIntFormat = GL_ALPHA;
1726 const struct gl_pixelstore_attrib unpackSave = *unpack;
1727 GLfloat verts[4][9]; /* four verts of X,Y,Z,S,T,R,G,B,A */
1728 GLboolean newTex;
1729 GLubyte *bitmap8;
1730
1731 /*
1732 * Check if swrast fallback is needed.
1733 */
1734 if (ctx->_ImageTransferState ||
1735 ctx->Color.AlphaEnabled ||
1736 ctx->Fog.Enabled ||
1737 ctx->Texture._EnabledUnits ||
1738 width > tex->MaxSize ||
1739 height > tex->MaxSize) {
1740 _swrast_Bitmap(ctx, x, y, width, height, unpack, bitmap1);
1741 return;
1742 }
1743
1744 /* Most GL state applies to glBitmap (like blending, stencil, etc),
1745 * but a there's a few things we need to override:
1746 */
1747 _mesa_meta_begin(ctx, (META_ALPHA_TEST |
1748 META_PIXEL_STORE |
1749 META_RASTERIZATION |
1750 META_SHADER |
1751 META_TEXTURE |
1752 META_TRANSFORM |
1753 META_VERTEX |
1754 META_VIEWPORT));
1755
1756 if (bitmap->ArrayObj == 0) {
1757 /* one-time setup */
1758
1759 /* create vertex array object */
1760 _mesa_GenVertexArraysAPPLE(1, &bitmap->ArrayObj);
1761 _mesa_BindVertexArrayAPPLE(bitmap->ArrayObj);
1762
1763 /* create vertex array buffer */
1764 _mesa_GenBuffersARB(1, &bitmap->VBO);
1765 _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, bitmap->VBO);
1766 _mesa_BufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(verts),
1767 NULL, GL_DYNAMIC_DRAW_ARB);
1768
1769 /* setup vertex arrays */
1770 _mesa_VertexPointer(3, GL_FLOAT, sizeof(verts[0]),
1771 (void *) (0 * sizeof(GLfloat)));
1772 _mesa_TexCoordPointer(2, GL_FLOAT, sizeof(verts[0]),
1773 (void *) (3 * sizeof(GLfloat)));
1774 _mesa_ColorPointer(4, GL_FLOAT, sizeof(verts[0]),
1775 (void *) (5 * sizeof(GLfloat)));
1776
1777 _mesa_EnableClientState(GL_VERTEX_ARRAY);
1778 _mesa_EnableClientState(GL_TEXTURE_COORD_ARRAY);
1779 _mesa_EnableClientState(GL_COLOR_ARRAY);
1780 }
1781 else {
1782 _mesa_BindVertexArray(bitmap->ArrayObj);
1783 _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, bitmap->VBO);
1784 }
1785
1786 newTex = alloc_texture(tex, width, height, texIntFormat);
1787
1788 /* vertex positions, texcoords, colors (after texture allocation!) */
1789 {
1790 const GLfloat x0 = (GLfloat) x;
1791 const GLfloat y0 = (GLfloat) y;
1792 const GLfloat x1 = (GLfloat) (x + width);
1793 const GLfloat y1 = (GLfloat) (y + height);
1794 const GLfloat z = ctx->Current.RasterPos[2];
1795 GLuint i;
1796
1797 verts[0][0] = x0;
1798 verts[0][1] = y0;
1799 verts[0][2] = z;
1800 verts[0][3] = 0.0F;
1801 verts[0][4] = 0.0F;
1802 verts[1][0] = x1;
1803 verts[1][1] = y0;
1804 verts[1][2] = z;
1805 verts[1][3] = tex->Sright;
1806 verts[1][4] = 0.0F;
1807 verts[2][0] = x1;
1808 verts[2][1] = y1;
1809 verts[2][2] = z;
1810 verts[2][3] = tex->Sright;
1811 verts[2][4] = tex->Ttop;
1812 verts[3][0] = x0;
1813 verts[3][1] = y1;
1814 verts[3][2] = z;
1815 verts[3][3] = 0.0F;
1816 verts[3][4] = tex->Ttop;
1817
1818 for (i = 0; i < 4; i++) {
1819 verts[i][5] = ctx->Current.RasterColor[0];
1820 verts[i][6] = ctx->Current.RasterColor[1];
1821 verts[i][7] = ctx->Current.RasterColor[2];
1822 verts[i][8] = ctx->Current.RasterColor[3];
1823 }
1824
1825 /* upload new vertex data */
1826 _mesa_BufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, sizeof(verts), verts);
1827 }
1828
1829 bitmap1 = _mesa_map_pbo_source(ctx, &unpackSave, bitmap1);
1830 if (!bitmap1)
1831 return;
1832
1833 bitmap8 = (GLubyte *) _mesa_calloc(width * height);
1834 if (bitmap8) {
1835 _mesa_expand_bitmap(width, height, &unpackSave, bitmap1,
1836 bitmap8, width, 0xff);
1837
1838 _mesa_set_enable(ctx, tex->Target, GL_TRUE);
1839
1840 _mesa_set_enable(ctx, GL_ALPHA_TEST, GL_TRUE);
1841 _mesa_AlphaFunc(GL_GREATER, 0.0);
1842
1843 setup_drawpix_texture(tex, newTex, texIntFormat, width, height,
1844 GL_ALPHA, GL_UNSIGNED_BYTE, bitmap8);
1845
1846 _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
1847
1848 _mesa_set_enable(ctx, tex->Target, GL_FALSE);
1849
1850 _mesa_free(bitmap8);
1851 }
1852
1853 _mesa_unmap_pbo_source(ctx, &unpackSave);
1854
1855 _mesa_meta_end(ctx);
1856 }
1857
1858
1859 void
1860 _mesa_meta_generate_mipmap(GLcontext *ctx, GLenum target,
1861 struct gl_texture_object *texObj)
1862 {
1863 struct gen_mipmap_state *mipmap = &ctx->Meta->Mipmap;
1864 struct { GLfloat x, y, s, t, r; } verts[4];
1865 const GLuint baseLevel = texObj->BaseLevel;
1866 const GLuint maxLevel = texObj->MaxLevel;
1867 const GLenum minFilterSave = texObj->MinFilter;
1868 const GLenum magFilterSave = texObj->MagFilter;
1869 const GLuint fboSave = ctx->DrawBuffer->Name;
1870 GLenum faceTarget;
1871 GLuint level;
1872 GLuint border = 0;
1873
1874 /* check for fallbacks */
1875 if (!ctx->Extensions.EXT_framebuffer_object) {
1876 _mesa_generate_mipmap(ctx, target, texObj);
1877 return;
1878 }
1879
1880 if (target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X &&
1881 target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z) {
1882 faceTarget = target;
1883 target = GL_TEXTURE_CUBE_MAP;
1884 }
1885 else {
1886 faceTarget = target;
1887 }
1888
1889 _mesa_meta_begin(ctx, META_ALL);
1890
1891 if (mipmap->ArrayObj == 0) {
1892 /* one-time setup */
1893
1894 /* create vertex array object */
1895 _mesa_GenVertexArraysAPPLE(1, &mipmap->ArrayObj);
1896 _mesa_BindVertexArrayAPPLE(mipmap->ArrayObj);
1897
1898 /* create vertex array buffer */
1899 _mesa_GenBuffersARB(1, &mipmap->VBO);
1900 _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, mipmap->VBO);
1901 _mesa_BufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(verts),
1902 NULL, GL_DYNAMIC_DRAW_ARB);
1903
1904 /* setup vertex arrays */
1905 _mesa_VertexPointer(2, GL_FLOAT, sizeof(verts[0]),
1906 (void *) (0 * sizeof(GLfloat)));
1907 _mesa_TexCoordPointer(3, GL_FLOAT, sizeof(verts[0]),
1908 (void *) (2 * sizeof(GLfloat)));
1909
1910 _mesa_EnableClientState(GL_VERTEX_ARRAY);
1911 _mesa_EnableClientState(GL_TEXTURE_COORD_ARRAY);
1912 }
1913 else {
1914 _mesa_BindVertexArray(mipmap->ArrayObj);
1915 _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, mipmap->VBO);
1916 }
1917
1918 if (!mipmap->FBO) {
1919 /* Bind the new renderbuffer to the color attachment point. */
1920 _mesa_GenFramebuffersEXT(1, &mipmap->FBO);
1921 }
1922
1923 _mesa_BindFramebufferEXT(GL_FRAMEBUFFER_EXT, mipmap->FBO);
1924
1925 _mesa_TexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1926 _mesa_TexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
1927 _mesa_set_enable(ctx, target, GL_TRUE);
1928
1929 /* setup texcoords once (XXX what about border?) */
1930 switch (faceTarget) {
1931 case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
1932 break;
1933 case GL_TEXTURE_2D:
1934 verts[0].s = 0.0F;
1935 verts[0].t = 0.0F;
1936 verts[0].r = 0.0F;
1937 verts[1].s = 1.0F;
1938 verts[1].t = 0.0F;
1939 verts[2].r = 0.0F;
1940 verts[3].s = 1.0F;
1941 verts[3].t = 1.0F;
1942 verts[3].r = 0.0F;
1943 verts[4].s = 0.0F;
1944 verts[4].t = 1.0F;
1945 verts[4].r = 0.0F;
1946 break;
1947 }
1948
1949
1950 for (level = baseLevel + 1; level <= maxLevel; level++) {
1951 const struct gl_texture_image *srcImage;
1952 const GLuint srcLevel = level - 1;
1953 GLsizei srcWidth, srcHeight;
1954 GLsizei newWidth, newHeight;
1955 GLenum status;
1956
1957 srcImage = _mesa_select_tex_image(ctx, texObj, target, srcLevel);
1958 assert(srcImage->Border == 0); /* XXX we can fix this */
1959
1960 srcWidth = srcImage->Width - 2 * border;
1961 srcHeight = srcImage->Height - 2 * border;
1962
1963 newWidth = MAX2(1, srcWidth / 2) + 2 * border;
1964 newHeight = MAX2(1, srcHeight / 2) + 2 * border;
1965
1966 if (newWidth == srcImage->Width && newHeight == srcImage->Height) {
1967 break;
1968 }
1969
1970 /* Create empty image */
1971 _mesa_TexImage2D(GL_TEXTURE_2D, level, srcImage->InternalFormat,
1972 newWidth, newHeight, border,
1973 GL_RGBA, GL_UNSIGNED_BYTE, NULL);
1974
1975 /* vertex positions */
1976 {
1977 verts[0].x = 0.0F;
1978 verts[0].y = 0.0F;
1979 verts[1].x = (GLfloat) newWidth;
1980 verts[1].y = 0.0F;
1981 verts[2].x = (GLfloat) newWidth;
1982 verts[2].y = (GLfloat) newHeight;
1983 verts[3].x = 0.0F;
1984 verts[3].y = (GLfloat) newHeight;
1985
1986 /* upload new vertex data */
1987 _mesa_BufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, sizeof(verts), verts);
1988 }
1989
1990 /* limit sampling to src level */
1991 _mesa_TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, srcLevel);
1992 _mesa_TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, srcLevel);
1993
1994 /* Set to draw into the current level */
1995 _mesa_FramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,
1996 GL_COLOR_ATTACHMENT0_EXT,
1997 target,
1998 texObj->Name,
1999 level);
2000
2001 /* Choose to render to the color attachment. */
2002 _mesa_DrawBuffer(GL_COLOR_ATTACHMENT0_EXT);
2003
2004 status = _mesa_CheckFramebufferStatusEXT (GL_FRAMEBUFFER_EXT);
2005 if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
2006 abort();
2007 break;
2008 }
2009
2010 _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
2011 }
2012
2013 _mesa_meta_end(ctx);
2014
2015 _mesa_TexParameteri(target, GL_TEXTURE_MIN_FILTER, minFilterSave);
2016 _mesa_TexParameteri(target, GL_TEXTURE_MAG_FILTER, magFilterSave);
2017
2018 /* restore (XXX add to meta_begin/end()? */
2019 _mesa_BindFramebufferEXT(GL_FRAMEBUFFER_EXT, fboSave);
2020 }