← Back to branch summary

~ubuntu-branches/ubuntu/natty/mesa/natty-proposed

« back to all changes in this revision

Viewing changes to src/gallium/tests/graw/quad-tex.c

  • Committer: Bazaar Package Importer
  • Author(s): Robert Hooker, Robert Hooker, Christopher James Halse Rogers
  • Date: 2010-09-14 08:55:40 UTC
  • mfrom: (1.2.28 upstream)
  • Revision ID: james.westby@ubuntu.com-20100914085540-m4fpl0hdjlfd4jgz
Tags: 7.9~git20100909-0ubuntu1
https://launchpad.net/bugs/631413
https://launchpad.net/bugs/628930
https://launchpad.net/bugs/628727
https://launchpad.net/bugs/596292
https://launchpad.net/bugs/599741
https://launchpad.net/bugs/630315
https://launchpad.net/bugs/613694
https://launchpad.net/bugs/599741
https://launchpad.net/bugs/578619
https://launchpad.net/bugs/626943
https://launchpad.net/bugs/610541
https://launchpad.net/bugs/601052
[ Robert Hooker ]
* New upstream git snapshot up to commit 94118fe2d4b1e5 (LP: #631413)
* New features include ATI HD5xxx series support in r600, and a vastly
  improved glsl compiler.
* Remove pre-generated .pc's, use the ones generated at build time
  instead.
* Remove all references to mesa-utils now that its no longer shipped
  with the mesa source.
* Disable the experimental ARB_fragment_shader option by default on
  i915, it exposes incomplete functionality that breaks KDE compositing
  among other things. It can be enabled via driconf still. (LP: #628930).

[ Christopher James Halse Rogers ]
* debian/patches/04_osmesa_version.diff:
  - Refresh for new upstream
* Bugs fixed in this release:
  - Fixes severe rendering corruption in Unity on radeon (LP: #628727,
    LP: #596292, LP: #599741, LP: #630315, LP: #613694, LP: #599741).
  - Also fixes rendering in gnome-shell (LP: #578619).
  - Flickering in OpenGL apps on radeon (LP: #626943, LP: #610541).
  - Provides preliminary support for new intel chips (LP: #601052).
* debian/rules:
  - Update configure flags to match upstream reshuffling.
  - Explicitly remove gallium DRI drivers that we don't want to ship.
* Update debian/gbp.conf for this Maverick-specific packaging
* libegl1-mesa-dri-x11,kms: There are no longer separate kms or x11 drivers
  for EGL, libegl1-mesa-drivers now contains a single driver that provides
  both backends.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gallium/tests/graw/quad-tex.c
 
1
/* Display a cleared blue window.  This demo has no dependencies on
 
2
 * any utility code, just the graw interface and gallium.
 
3
 */
 
4
 
 
5
#include "state_tracker/graw.h"
 
6
#include "pipe/p_screen.h"
 
7
#include "pipe/p_context.h"
 
8
#include "pipe/p_shader_tokens.h"
 
9
#include "pipe/p_state.h"
 
10
#include "pipe/p_defines.h"
 
11
 
 
12
#include "util/u_debug.h"       /* debug_dump_surface_bmp() */
 
13
#include "util/u_inlines.h"
 
14
#include "util/u_memory.h"      /* Offset() */
 
15
#include "util/u_draw_quad.h"
 
16
#include "util/u_box.h"    
 
17
 
 
18
enum pipe_format formats[] = {
 
19
   PIPE_FORMAT_R8G8B8A8_UNORM,
 
20
   PIPE_FORMAT_B8G8R8A8_UNORM,
 
21
   PIPE_FORMAT_NONE
 
22
};
 
23
 
 
24
static const int WIDTH = 300;
 
25
static const int HEIGHT = 300;
 
26
 
 
27
static struct pipe_screen *screen = NULL;
 
28
static struct pipe_context *ctx = NULL;
 
29
static struct pipe_resource *rttex = NULL;
 
30
static struct pipe_resource *samptex = NULL;
 
31
static struct pipe_surface *surf = NULL;
 
32
static struct pipe_sampler_view *sv = NULL;
 
33
static void *sampler = NULL;
 
34
static void *window = NULL;
 
35
 
 
36
struct vertex {
 
37
   float position[4];
 
38
   float color[4];
 
39
};
 
40
 
 
41
static struct vertex vertices[] =
 
42
{
 
43
   { { 0.9, -0.9, 0.0, 1.0 },
 
44
     { 1, 0, 0, 1 } },
 
45
 
 
46
   { { 0.9,  0.9, 0.0, 1.0 },
 
47
     { 1, 1, 0, 1 } },
 
48
 
 
49
   { {-0.9,  0.9, 0.0, 1.0 },
 
50
     { 0, 1, 0, 1 } },
 
51
 
 
52
   { {-0.9,  -0.9, 0.0, 1.0 },
 
53
     { 0, 0, 0, 1 } },
 
54
};
 
55
 
 
56
 
 
57
 
 
58
 
 
59
static void set_viewport( float x, float y,
 
60
                          float width, float height,
 
61
                          float near, float far)
 
62
{
 
63
   float z = far;
 
64
   float half_width = (float)width / 2.0f;
 
65
   float half_height = (float)height / 2.0f;
 
66
   float half_depth = ((float)far - (float)near) / 2.0f;
 
67
   struct pipe_viewport_state vp;
 
68
 
 
69
   vp.scale[0] = half_width;
 
70
   vp.scale[1] = half_height;
 
71
   vp.scale[2] = half_depth;
 
72
   vp.scale[3] = 1.0f;
 
73
 
 
74
   vp.translate[0] = half_width + x;
 
75
   vp.translate[1] = half_height + y;
 
76
   vp.translate[2] = half_depth + z;
 
77
   vp.translate[3] = 0.0f;
 
78
 
 
79
   ctx->set_viewport_state( ctx, &vp );
 
80
}
 
81
 
 
82
static void set_vertices( void )
 
83
{
 
84
   struct pipe_vertex_element ve[2];
 
85
   struct pipe_vertex_buffer vbuf;
 
86
   void *handle;
 
87
 
 
88
   memset(ve, 0, sizeof ve);
 
89
 
 
90
   ve[0].src_offset = Offset(struct vertex, position);
 
91
   ve[0].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
 
92
   ve[1].src_offset = Offset(struct vertex, color);
 
93
   ve[1].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
 
94
 
 
95
   handle = ctx->create_vertex_elements_state(ctx, 2, ve);
 
96
   ctx->bind_vertex_elements_state(ctx, handle);
 
97
 
 
98
 
 
99
   vbuf.stride = sizeof( struct vertex );
 
100
   vbuf.max_index = sizeof(vertices) / vbuf.stride;
 
101
   vbuf.buffer_offset = 0;
 
102
   vbuf.buffer = screen->user_buffer_create(screen,
 
103
                                            vertices,
 
104
                                            sizeof(vertices),
 
105
                                            PIPE_BIND_VERTEX_BUFFER);
 
106
 
 
107
   ctx->set_vertex_buffers(ctx, 1, &vbuf);
 
108
}
 
109
 
 
110
static void set_vertex_shader( void )
 
111
{
 
112
   void *handle;
 
113
   const char *text =
 
114
      "VERT\n"
 
115
      "DCL IN[0]\n"
 
116
      "DCL IN[1]\n"
 
117
      "DCL OUT[0], POSITION\n"
 
118
      "DCL OUT[1], GENERIC[0]\n"
 
119
      "  0: MOV OUT[1], IN[1]\n"
 
120
      "  1: MOV OUT[0], IN[0]\n"
 
121
      "  2: END\n";
 
122
 
 
123
   handle = graw_parse_vertex_shader(ctx, text);
 
124
   ctx->bind_vs_state(ctx, handle);
 
125
}
 
126
 
 
127
static void set_fragment_shader( void )
 
128
{
 
129
   void *handle;
 
130
   const char *text =
 
131
      "FRAG\n"
 
132
      "DCL IN[0], GENERIC[0], PERSPECTIVE\n"
 
133
      "DCL OUT[0], COLOR\n"
 
134
      "DCL TEMP[0]\n"
 
135
      "DCL SAMP[0]\n"
 
136
      "  0: TXP TEMP[0], IN[0], SAMP[0], 2D\n"
 
137
      "  1: MOV OUT[0], TEMP[0]\n"
 
138
      "  2: END\n";
 
139
 
 
140
   handle = graw_parse_fragment_shader(ctx, text);
 
141
   ctx->bind_fs_state(ctx, handle);
 
142
}
 
143
 
 
144
 
 
145
static void draw( void )
 
146
{
 
147
   float clear_color[4] = {.5,.5,.5,1};
 
148
 
 
149
   ctx->clear(ctx, PIPE_CLEAR_COLOR, clear_color, 0, 0);
 
150
   util_draw_arrays(ctx, PIPE_PRIM_QUADS, 0, 4);
 
151
   ctx->flush(ctx, PIPE_FLUSH_RENDER_CACHE, NULL);
 
152
 
 
153
#if 0
 
154
   /* At the moment, libgraw leaks out/makes available some of the
 
155
    * symbols from gallium/auxiliary, including these debug helpers.
 
156
    * Will eventually want to bless some of these paths, and lock the
 
157
    * others down so they aren't accessible from test programs.
 
158
    *
 
159
    * This currently just happens to work on debug builds - a release
 
160
    * build will probably fail to link here:
 
161
    */
 
162
   debug_dump_surface_bmp(ctx, "result.bmp", surf);
 
163
#endif
 
164
 
 
165
   screen->flush_frontbuffer(screen, surf, window);
 
166
}
 
167
 
 
168
#define SIZE 16
 
169
 
 
170
static void init_tex( void )
 
171
{ 
 
172
   struct pipe_sampler_view sv_template;
 
173
   struct pipe_sampler_state sampler_desc;
 
174
   struct pipe_resource templat;
 
175
   struct pipe_box box;
 
176
   ubyte tex2d[SIZE][SIZE][4];
 
177
   int s, t;
 
178
 
 
179
#if (SIZE != 2)
 
180
   for (s = 0; s < SIZE; s++) {
 
181
      for (t = 0; t < SIZE; t++) {
 
182
         if (0) {
 
183
            int x = (s ^ t) & 1;
 
184
            tex2d[t][s][0] = (x) ? 0 : 63;
 
185
            tex2d[t][s][1] = (x) ? 0 : 128;
 
186
            tex2d[t][s][2] = 0;
 
187
            tex2d[t][s][3] = 0xff;
 
188
         }
 
189
         else {
 
190
            int x = ((s ^ t) >> 2) & 1;
 
191
            tex2d[t][s][0] = s*255/(SIZE-1);
 
192
            tex2d[t][s][1] = t*255/(SIZE-1);
 
193
            tex2d[t][s][2] = (x) ? 0 : 128;
 
194
            tex2d[t][s][3] = 0xff;
 
195
         }
 
196
      }
 
197
   }
 
198
#else
 
199
   tex2d[0][0][0] = 0;
 
200
   tex2d[0][0][1] = 255;
 
201
   tex2d[0][0][2] = 255;
 
202
   tex2d[0][0][3] = 0;
 
203
 
 
204
   tex2d[0][1][0] = 0;
 
205
   tex2d[0][1][1] = 0;
 
206
   tex2d[0][1][2] = 255;
 
207
   tex2d[0][1][3] = 255;
 
208
 
 
209
   tex2d[1][0][0] = 255;
 
210
   tex2d[1][0][1] = 255;
 
211
   tex2d[1][0][2] = 0;
 
212
   tex2d[1][0][3] = 255;
 
213
 
 
214
   tex2d[1][1][0] = 255;
 
215
   tex2d[1][1][1] = 0;
 
216
   tex2d[1][1][2] = 0;
 
217
   tex2d[1][1][3] = 255;
 
218
#endif
 
219
 
 
220
   templat.target = PIPE_TEXTURE_2D;
 
221
   templat.format = PIPE_FORMAT_B8G8R8A8_UNORM;
 
222
   templat.width0 = SIZE;
 
223
   templat.height0 = SIZE;
 
224
   templat.depth0 = 1;
 
225
   templat.last_level = 0;
 
226
   templat.nr_samples = 1;
 
227
   templat.bind = PIPE_BIND_SAMPLER_VIEW;
 
228
 
 
229
   
 
230
   samptex = screen->resource_create(screen,
 
231
                                 &templat);
 
232
   if (samptex == NULL)
 
233
      exit(4);
 
234
 
 
235
   u_box_2d(0,0,SIZE,SIZE, &box);
 
236
 
 
237
   ctx->transfer_inline_write(ctx,
 
238
                              samptex,
 
239
                              u_subresource(0,0),
 
240
                              PIPE_TRANSFER_WRITE,
 
241
                              &box,
 
242
                              tex2d,
 
243
                              sizeof tex2d[0],
 
244
                              sizeof tex2d);
 
245
 
 
246
   /* Possibly read back & compare against original data:
 
247
    */
 
248
   if (0)
 
249
   {
 
250
      struct pipe_transfer *t;
 
251
      uint32_t *ptr;
 
252
      t = pipe_get_transfer(ctx, samptex,
 
253
                            0, 0, 0, /* face, level, zslice */
 
254
                            PIPE_TRANSFER_READ,
 
255
                            0, 0, SIZE, SIZE); /* x, y, width, height */
 
256
 
 
257
      ptr = ctx->transfer_map(ctx, t);
 
258
 
 
259
      if (memcmp(ptr, tex2d, sizeof tex2d) != 0) {
 
260
         assert(0);
 
261
         exit(9);
 
262
      }
 
263
 
 
264
      ctx->transfer_unmap(ctx, t);
 
265
 
 
266
      ctx->transfer_destroy(ctx, t);
 
267
   }
 
268
 
 
269
   memset(&sv_template, 0, sizeof sv_template);
 
270
   sv_template.format = samptex->format;
 
271
   sv_template.texture = samptex;
 
272
   sv_template.first_level = 0;
 
273
   sv_template.last_level = 0;
 
274
   sv_template.swizzle_r = 0;
 
275
   sv_template.swizzle_g = 1;
 
276
   sv_template.swizzle_b = 2;
 
277
   sv_template.swizzle_a = 3;
 
278
   sv = ctx->create_sampler_view(ctx, samptex, &sv_template);
 
279
   if (sv == NULL)
 
280
      exit(5);
 
281
 
 
282
   ctx->set_fragment_sampler_views(ctx, 1, &sv);
 
283
   
 
284
 
 
285
   memset(&sampler_desc, 0, sizeof sampler_desc);
 
286
   sampler_desc.wrap_s = PIPE_TEX_WRAP_REPEAT;
 
287
   sampler_desc.wrap_t = PIPE_TEX_WRAP_REPEAT;
 
288
   sampler_desc.wrap_r = PIPE_TEX_WRAP_REPEAT;
 
289
   sampler_desc.min_img_filter = PIPE_TEX_FILTER_NEAREST;
 
290
   sampler_desc.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
 
291
   sampler_desc.mag_img_filter = PIPE_TEX_FILTER_NEAREST;
 
292
   sampler_desc.compare_mode = PIPE_TEX_COMPARE_NONE;
 
293
   sampler_desc.compare_func = 0;
 
294
   sampler_desc.normalized_coords = 1;
 
295
   sampler_desc.max_anisotropy = 0;
 
296
   
 
297
   sampler = ctx->create_sampler_state(ctx, &sampler_desc);
 
298
   if (sampler == NULL)
 
299
      exit(6);
 
300
 
 
301
   ctx->bind_fragment_sampler_states(ctx, 1, &sampler);
 
302
   
 
303
}
 
304
 
 
305
static void init( void )
 
306
{
 
307
   struct pipe_framebuffer_state fb;
 
308
   struct pipe_resource templat;
 
309
   int i;
 
310
 
 
311
   /* It's hard to say whether window or screen should be created
 
312
    * first.  Different environments would prefer one or the other.
 
313
    *
 
314
    * Also, no easy way of querying supported formats if the screen
 
315
    * cannot be created first.
 
316
    */
 
317
   for (i = 0; 
 
318
        window == NULL && formats[i] != PIPE_FORMAT_NONE;
 
319
        i++) {
 
320
      
 
321
      screen = graw_create_window_and_screen(0,0,300,300,
 
322
                                             formats[i],
 
323
                                             &window);
 
324
   }
 
325
   
 
326
   ctx = screen->context_create(screen, NULL);
 
327
   if (ctx == NULL)
 
328
      exit(3);
 
329
 
 
330
   templat.target = PIPE_TEXTURE_2D;
 
331
   templat.format = formats[i];
 
332
   templat.width0 = WIDTH;
 
333
   templat.height0 = HEIGHT;
 
334
   templat.depth0 = 1;
 
335
   templat.last_level = 0;
 
336
   templat.nr_samples = 1;
 
337
   templat.bind = (PIPE_BIND_RENDER_TARGET |
 
338
                   PIPE_BIND_DISPLAY_TARGET);
 
339
   
 
340
   rttex = screen->resource_create(screen,
 
341
                                 &templat);
 
342
   if (rttex == NULL)
 
343
      exit(4);
 
344
 
 
345
   surf = screen->get_tex_surface(screen, rttex, 0, 0, 0,
 
346
                                  PIPE_BIND_RENDER_TARGET |
 
347
                                  PIPE_BIND_DISPLAY_TARGET);
 
348
   if (surf == NULL)
 
349
      exit(5);
 
350
 
 
351
   memset(&fb, 0, sizeof fb);
 
352
   fb.nr_cbufs = 1;
 
353
   fb.width = WIDTH;
 
354
   fb.height = HEIGHT;
 
355
   fb.cbufs[0] = surf;
 
356
 
 
357
   ctx->set_framebuffer_state(ctx, &fb);
 
358
   
 
359
   {
 
360
      struct pipe_blend_state blend;
 
361
      void *handle;
 
362
      memset(&blend, 0, sizeof blend);
 
363
      blend.rt[0].colormask = PIPE_MASK_RGBA;
 
364
      handle = ctx->create_blend_state(ctx, &blend);
 
365
      ctx->bind_blend_state(ctx, handle);
 
366
   }
 
367
 
 
368
   {
 
369
      struct pipe_depth_stencil_alpha_state depthstencil;
 
370
      void *handle;
 
371
      memset(&depthstencil, 0, sizeof depthstencil);
 
372
      handle = ctx->create_depth_stencil_alpha_state(ctx, &depthstencil);
 
373
      ctx->bind_depth_stencil_alpha_state(ctx, handle);
 
374
   }
 
375
 
 
376
   {
 
377
      struct pipe_rasterizer_state rasterizer;
 
378
      void *handle;
 
379
      memset(&rasterizer, 0, sizeof rasterizer);
 
380
      rasterizer.cull_face = PIPE_FACE_NONE;
 
381
      rasterizer.gl_rasterization_rules = 1;
 
382
      handle = ctx->create_rasterizer_state(ctx, &rasterizer);
 
383
      ctx->bind_rasterizer_state(ctx, handle);
 
384
   }
 
385
 
 
386
   set_viewport(0, 0, WIDTH, HEIGHT, 30, 1000);
 
387
 
 
388
   init_tex();
 
389
 
 
390
   set_vertices();
 
391
   set_vertex_shader();
 
392
   set_fragment_shader();
 
393
}
 
394
 
 
395
 
 
396
int main( int argc, char *argv[] )
 
397
{
 
398
   init();
 
399
 
 
400
   graw_set_display_func( draw );
 
401
   graw_main_loop();
 
402
   return 0;
 
403
}