← Back to branch summary

~ubuntu-branches/ubuntu/precise/mesa/precise-updates

« back to all changes in this revision

Viewing changes to src/gallium/drivers/failover/fo_state.c

  • Committer: Package Import Robot
  • Author(s): Robert Hooker
  • Date: 2012-02-02 12:05:48 UTC
  • mfrom: (1.7.1) (3.3.27 sid)
  • Revision ID: package-import@ubuntu.com-20120202120548-nvkma85jq0h4coix
Tags: 8.0~rc2-0ubuntu4
Drop drisearchdir handling, it is no longer needed with multiarch
and dri-alternates being removed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gallium/drivers/failover/fo_state.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
 
/* Authors:  Keith Whitwell <keith@tungstengraphics.com>
29
 
 */
30
 
 
31
 
#include "util/u_inlines.h"
32
 
#include "util/u_memory.h"
33
 
#include "util/u_transfer.h"
34
 
 
35
 
#include "fo_context.h"
36
 
 
37
 
 
38
 
/* This looks like a lot of work at the moment - we're keeping a
39
 
 * duplicate copy of the state up-to-date.  
40
 
 *
41
 
 * This can change in two ways:
42
 
 * - With constant state objects we would only need to save a pointer,
43
 
 *     not the whole object.
44
 
 * - By adding a callback in the state tracker to re-emit state.  The
45
 
 *     state tracker knows the current state already and can re-emit it 
46
 
 *     without additional complexity.
47
 
 *
48
 
 * This works as a proof-of-concept, but a final version will have
49
 
 * lower overheads.
50
 
 */
51
 
 
52
 
 
53
 
 
54
 
static void *
55
 
failover_create_blend_state( struct pipe_context *pipe,
56
 
                             const struct pipe_blend_state *blend )
57
 
{
58
 
   struct fo_state *state = MALLOC(sizeof(struct fo_state));
59
 
   struct failover_context *failover = failover_context(pipe);
60
 
 
61
 
   state->sw_state = failover->sw->create_blend_state(failover->sw, blend);
62
 
   state->hw_state = failover->hw->create_blend_state(failover->hw, blend);
63
 
 
64
 
   return state;
65
 
}
66
 
 
67
 
static void
68
 
failover_bind_blend_state( struct pipe_context *pipe,
69
 
                           void *blend )
70
 
{
71
 
   struct failover_context *failover = failover_context(pipe);
72
 
   struct fo_state *state = (struct fo_state *)blend;
73
 
   failover->blend = state;
74
 
   failover->dirty |= FO_NEW_BLEND;
75
 
   failover->sw->bind_blend_state( failover->sw, state->sw_state );
76
 
   failover->hw->bind_blend_state( failover->hw, state->hw_state );
77
 
}
78
 
 
79
 
static void
80
 
failover_delete_blend_state( struct pipe_context *pipe,
81
 
                             void *blend )
82
 
{
83
 
   struct fo_state *state = (struct fo_state*)blend;
84
 
   struct failover_context *failover = failover_context(pipe);
85
 
 
86
 
   failover->sw->delete_blend_state(failover->sw, state->sw_state);
87
 
   failover->hw->delete_blend_state(failover->hw, state->hw_state);
88
 
   state->sw_state = 0;
89
 
   state->hw_state = 0;
90
 
   FREE(state);
91
 
}
92
 
 
93
 
static void
94
 
failover_set_blend_color( struct pipe_context *pipe,
95
 
                          const struct pipe_blend_color *blend_color )
96
 
{
97
 
   struct failover_context *failover = failover_context(pipe);
98
 
 
99
 
   failover->blend_color = *blend_color;
100
 
   failover->dirty |= FO_NEW_BLEND_COLOR;
101
 
   failover->sw->set_blend_color( failover->sw, blend_color );
102
 
   failover->hw->set_blend_color( failover->hw, blend_color );
103
 
}
104
 
 
105
 
static void
106
 
failover_set_stencil_ref( struct pipe_context *pipe,
107
 
                          const struct pipe_stencil_ref *stencil_ref )
108
 
{
109
 
   struct failover_context *failover = failover_context(pipe);
110
 
 
111
 
   failover->stencil_ref = *stencil_ref;
112
 
   failover->dirty |= FO_NEW_STENCIL_REF;
113
 
   failover->sw->set_stencil_ref( failover->sw, stencil_ref );
114
 
   failover->hw->set_stencil_ref( failover->hw, stencil_ref );
115
 
}
116
 
 
117
 
static void 
118
 
failover_set_clip_state( struct pipe_context *pipe,
119
 
                         const struct pipe_clip_state *clip )
120
 
{
121
 
   struct failover_context *failover = failover_context(pipe);
122
 
 
123
 
   failover->clip = *clip;
124
 
   failover->dirty |= FO_NEW_CLIP;
125
 
   failover->sw->set_clip_state( failover->sw, clip );
126
 
   failover->hw->set_clip_state( failover->hw, clip );
127
 
}
128
 
 
129
 
static void
130
 
failover_set_sample_mask(struct pipe_context *pipe,
131
 
                         unsigned sample_mask)
132
 
{
133
 
   struct failover_context *failover = failover_context(pipe);
134
 
 
135
 
   failover->sample_mask = sample_mask;
136
 
   failover->dirty |= FO_NEW_SAMPLE_MASK;
137
 
   failover->sw->set_sample_mask( failover->sw, sample_mask );
138
 
   failover->hw->set_sample_mask( failover->hw, sample_mask );
139
 
 
140
 
}
141
 
 
142
 
 
143
 
static void *
144
 
failover_create_depth_stencil_state(struct pipe_context *pipe,
145
 
                              const struct pipe_depth_stencil_alpha_state *templ)
146
 
{
147
 
   struct fo_state *state = MALLOC(sizeof(struct fo_state));
148
 
   struct failover_context *failover = failover_context(pipe);
149
 
 
150
 
   state->sw_state = failover->sw->create_depth_stencil_alpha_state(failover->sw, templ);
151
 
   state->hw_state = failover->hw->create_depth_stencil_alpha_state(failover->hw, templ);
152
 
 
153
 
   return state;
154
 
}
155
 
 
156
 
static void
157
 
failover_bind_depth_stencil_state(struct pipe_context *pipe,
158
 
                                  void *depth_stencil)
159
 
{
160
 
   struct failover_context *failover = failover_context(pipe);
161
 
   struct fo_state *state = (struct fo_state *)depth_stencil;
162
 
   failover->depth_stencil = state;
163
 
   failover->dirty |= FO_NEW_DEPTH_STENCIL;
164
 
   failover->sw->bind_depth_stencil_alpha_state(failover->sw, state->sw_state);
165
 
   failover->hw->bind_depth_stencil_alpha_state(failover->hw, state->hw_state);
166
 
}
167
 
 
168
 
static void
169
 
failover_delete_depth_stencil_state(struct pipe_context *pipe,
170
 
                                    void *ds)
171
 
{
172
 
   struct fo_state *state = (struct fo_state*)ds;
173
 
   struct failover_context *failover = failover_context(pipe);
174
 
 
175
 
   failover->sw->delete_depth_stencil_alpha_state(failover->sw, state->sw_state);
176
 
   failover->hw->delete_depth_stencil_alpha_state(failover->hw, state->hw_state);
177
 
   state->sw_state = 0;
178
 
   state->hw_state = 0;
179
 
   FREE(state);
180
 
}
181
 
 
182
 
static void
183
 
failover_set_framebuffer_state(struct pipe_context *pipe,
184
 
                               const struct pipe_framebuffer_state *framebuffer)
185
 
{
186
 
   struct failover_context *failover = failover_context(pipe);
187
 
 
188
 
   failover->framebuffer = *framebuffer;
189
 
   failover->dirty |= FO_NEW_FRAMEBUFFER;
190
 
   failover->sw->set_framebuffer_state( failover->sw, framebuffer );
191
 
   failover->hw->set_framebuffer_state( failover->hw, framebuffer );
192
 
}
193
 
 
194
 
 
195
 
static void *
196
 
failover_create_fs_state(struct pipe_context *pipe,
197
 
                         const struct pipe_shader_state *templ)
198
 
{
199
 
   struct fo_state *state = MALLOC(sizeof(struct fo_state));
200
 
   struct failover_context *failover = failover_context(pipe);
201
 
 
202
 
   state->sw_state = failover->sw->create_fs_state(failover->sw, templ);
203
 
   state->hw_state = failover->hw->create_fs_state(failover->hw, templ);
204
 
 
205
 
   return state;
206
 
}
207
 
 
208
 
static void
209
 
failover_bind_fs_state(struct pipe_context *pipe, void *fs)
210
 
{
211
 
   struct failover_context *failover = failover_context(pipe);
212
 
   struct fo_state *state = (struct fo_state*)fs;
213
 
   failover->fragment_shader = state;
214
 
   failover->dirty |= FO_NEW_FRAGMENT_SHADER;
215
 
   failover->sw->bind_fs_state(failover->sw, state->sw_state);
216
 
   failover->hw->bind_fs_state(failover->hw, state->hw_state);
217
 
}
218
 
 
219
 
static void
220
 
failover_delete_fs_state(struct pipe_context *pipe,
221
 
                         void *fs)
222
 
{
223
 
   struct fo_state *state = (struct fo_state*)fs;
224
 
   struct failover_context *failover = failover_context(pipe);
225
 
 
226
 
   failover->sw->delete_fs_state(failover->sw, state->sw_state);
227
 
   failover->hw->delete_fs_state(failover->hw, state->hw_state);
228
 
   state->sw_state = 0;
229
 
   state->hw_state = 0;
230
 
   FREE(state);
231
 
}
232
 
 
233
 
static void *
234
 
failover_create_vs_state(struct pipe_context *pipe,
235
 
                         const struct pipe_shader_state *templ)
236
 
{
237
 
   struct fo_state *state = MALLOC(sizeof(struct fo_state));
238
 
   struct failover_context *failover = failover_context(pipe);
239
 
 
240
 
   state->sw_state = failover->sw->create_vs_state(failover->sw, templ);
241
 
   state->hw_state = failover->hw->create_vs_state(failover->hw, templ);
242
 
 
243
 
   return state;
244
 
}
245
 
 
246
 
static void
247
 
failover_bind_vs_state(struct pipe_context *pipe,
248
 
                       void *vs)
249
 
{
250
 
   struct failover_context *failover = failover_context(pipe);
251
 
 
252
 
   struct fo_state *state = (struct fo_state*)vs;
253
 
   failover->vertex_shader = state;
254
 
   failover->dirty |= FO_NEW_VERTEX_SHADER;
255
 
   failover->sw->bind_vs_state(failover->sw, state->sw_state);
256
 
   failover->hw->bind_vs_state(failover->hw, state->hw_state);
257
 
}
258
 
 
259
 
static void
260
 
failover_delete_vs_state(struct pipe_context *pipe,
261
 
                         void *vs)
262
 
{
263
 
   struct fo_state *state = (struct fo_state*)vs;
264
 
   struct failover_context *failover = failover_context(pipe);
265
 
 
266
 
   failover->sw->delete_vs_state(failover->sw, state->sw_state);
267
 
   failover->hw->delete_vs_state(failover->hw, state->hw_state);
268
 
   state->sw_state = 0;
269
 
   state->hw_state = 0;
270
 
   FREE(state);
271
 
}
272
 
 
273
 
 
274
 
 
275
 
static void *
276
 
failover_create_vertex_elements_state( struct pipe_context *pipe,
277
 
                                       unsigned count,
278
 
                                       const struct pipe_vertex_element *velems )
279
 
{
280
 
   struct fo_state *state = MALLOC(sizeof(struct fo_state));
281
 
   struct failover_context *failover = failover_context(pipe);
282
 
 
283
 
   state->sw_state = failover->sw->create_vertex_elements_state(failover->sw, count, velems);
284
 
   state->hw_state = failover->hw->create_vertex_elements_state(failover->hw, count, velems);
285
 
 
286
 
   return state;
287
 
}
288
 
 
289
 
static void
290
 
failover_bind_vertex_elements_state(struct pipe_context *pipe,
291
 
                                    void *velems )
292
 
{
293
 
   struct failover_context *failover = failover_context(pipe);
294
 
   struct fo_state *state = (struct fo_state*)velems;
295
 
 
296
 
   failover->vertex_elements = state;
297
 
   failover->dirty |= FO_NEW_VERTEX_ELEMENT;
298
 
   failover->sw->bind_vertex_elements_state( failover->sw, velems );
299
 
   failover->hw->bind_vertex_elements_state( failover->hw, velems );
300
 
}
301
 
 
302
 
static void
303
 
failover_delete_vertex_elements_state( struct pipe_context *pipe,
304
 
                                       void *velems )
305
 
{
306
 
   struct fo_state *state = (struct fo_state*)velems;
307
 
   struct failover_context *failover = failover_context(pipe);
308
 
 
309
 
   failover->sw->delete_vertex_elements_state(failover->sw, state->sw_state);
310
 
   failover->hw->delete_vertex_elements_state(failover->hw, state->hw_state);
311
 
   state->sw_state = 0;
312
 
   state->hw_state = 0;
313
 
   FREE(state);
314
 
}
315
 
 
316
 
static void 
317
 
failover_set_polygon_stipple( struct pipe_context *pipe,
318
 
                              const struct pipe_poly_stipple *stipple )
319
 
{
320
 
   struct failover_context *failover = failover_context(pipe);
321
 
 
322
 
   failover->poly_stipple = *stipple;
323
 
   failover->dirty |= FO_NEW_STIPPLE;
324
 
   failover->sw->set_polygon_stipple( failover->sw, stipple );
325
 
   failover->hw->set_polygon_stipple( failover->hw, stipple );
326
 
}
327
 
 
328
 
 
329
 
static void *
330
 
failover_create_rasterizer_state(struct pipe_context *pipe,
331
 
                                 const struct pipe_rasterizer_state *templ)
332
 
{
333
 
   struct fo_state *state = MALLOC(sizeof(struct fo_state));
334
 
   struct failover_context *failover = failover_context(pipe);
335
 
 
336
 
   state->sw_state = failover->sw->create_rasterizer_state(failover->sw, templ);
337
 
   state->hw_state = failover->hw->create_rasterizer_state(failover->hw, templ);
338
 
 
339
 
   return state;
340
 
}
341
 
 
342
 
static void
343
 
failover_bind_rasterizer_state(struct pipe_context *pipe,
344
 
                               void *raster)
345
 
{
346
 
   struct failover_context *failover = failover_context(pipe);
347
 
 
348
 
   struct fo_state *state = (struct fo_state*)raster;
349
 
   failover->rasterizer = state;
350
 
   failover->dirty |= FO_NEW_RASTERIZER;
351
 
   failover->sw->bind_rasterizer_state(failover->sw, state->sw_state);
352
 
   failover->hw->bind_rasterizer_state(failover->hw, state->hw_state);
353
 
}
354
 
 
355
 
static void
356
 
failover_delete_rasterizer_state(struct pipe_context *pipe,
357
 
                                 void *raster)
358
 
{
359
 
   struct fo_state *state = (struct fo_state*)raster;
360
 
   struct failover_context *failover = failover_context(pipe);
361
 
 
362
 
   failover->sw->delete_rasterizer_state(failover->sw, state->sw_state);
363
 
   failover->hw->delete_rasterizer_state(failover->hw, state->hw_state);
364
 
   state->sw_state = 0;
365
 
   state->hw_state = 0;
366
 
   FREE(state);
367
 
}
368
 
 
369
 
 
370
 
static void 
371
 
failover_set_scissor_state( struct pipe_context *pipe,
372
 
                                 const struct pipe_scissor_state *scissor )
373
 
{
374
 
   struct failover_context *failover = failover_context(pipe);
375
 
 
376
 
   failover->scissor = *scissor;
377
 
   failover->dirty |= FO_NEW_SCISSOR;
378
 
   failover->sw->set_scissor_state( failover->sw, scissor );
379
 
   failover->hw->set_scissor_state( failover->hw, scissor );
380
 
}
381
 
 
382
 
 
383
 
static void *
384
 
failover_create_sampler_state(struct pipe_context *pipe,
385
 
                              const struct pipe_sampler_state *templ)
386
 
{
387
 
   struct fo_state *state = MALLOC(sizeof(struct fo_state));
388
 
   struct failover_context *failover = failover_context(pipe);
389
 
 
390
 
   state->sw_state = failover->sw->create_sampler_state(failover->sw, templ);
391
 
   state->hw_state = failover->hw->create_sampler_state(failover->hw, templ);
392
 
 
393
 
   return state;
394
 
}
395
 
 
396
 
static void
397
 
failover_bind_fragment_sampler_states(struct pipe_context *pipe,
398
 
                                      unsigned num,
399
 
                                      void **sampler)
400
 
{
401
 
   struct failover_context *failover = failover_context(pipe);
402
 
   struct fo_state *state = (struct fo_state*)sampler;
403
 
   uint i;
404
 
   assert(num <= PIPE_MAX_SAMPLERS);
405
 
   /* Check for no-op */
406
 
   if (num == failover->num_samplers &&
407
 
       !memcmp(failover->sampler, sampler, num * sizeof(void *)))
408
 
      return;
409
 
   for (i = 0; i < PIPE_MAX_SAMPLERS; i++) {
410
 
      failover->sw_sampler_state[i] = i < num ? state[i].sw_state : NULL;
411
 
      failover->hw_sampler_state[i] = i < num ? state[i].hw_state : NULL;
412
 
   }
413
 
   failover->dirty |= FO_NEW_SAMPLER;
414
 
   failover->num_samplers = num;
415
 
   failover->sw->bind_fragment_sampler_states(failover->sw, num,
416
 
                                              failover->sw_sampler_state);
417
 
   failover->hw->bind_fragment_sampler_states(failover->hw, num,
418
 
                                              failover->hw_sampler_state);
419
 
}
420
 
 
421
 
static void
422
 
failover_bind_vertex_sampler_states(struct pipe_context *pipe,
423
 
                                    unsigned num_samplers,
424
 
                                    void **samplers)
425
 
{
426
 
   struct failover_context *failover = failover_context(pipe);
427
 
   struct fo_state *state = (struct fo_state*)samplers;
428
 
   uint i;
429
 
 
430
 
   assert(num_samplers <= PIPE_MAX_VERTEX_SAMPLERS);
431
 
 
432
 
   /* Check for no-op */
433
 
   if (num_samplers == failover->num_vertex_samplers &&
434
 
       !memcmp(failover->vertex_samplers, samplers, num_samplers * sizeof(void *))) {
435
 
      return;
436
 
   }
437
 
   for (i = 0; i < PIPE_MAX_VERTEX_SAMPLERS; i++) {
438
 
      failover->sw_vertex_sampler_state[i] = i < num_samplers ? state[i].sw_state : NULL;
439
 
      failover->hw_vertex_sampler_state[i] = i < num_samplers ? state[i].hw_state : NULL;
440
 
   }
441
 
   failover->dirty |= FO_NEW_SAMPLER;
442
 
   failover->num_vertex_samplers = num_samplers;
443
 
   failover->sw->bind_vertex_sampler_states(failover->sw,
444
 
                                            num_samplers,
445
 
                                            failover->sw_vertex_sampler_state);
446
 
   failover->hw->bind_vertex_sampler_states(failover->hw,
447
 
                                            num_samplers,
448
 
                                            failover->hw_vertex_sampler_state);
449
 
}
450
 
 
451
 
static void
452
 
failover_delete_sampler_state(struct pipe_context *pipe, void *sampler)
453
 
{
454
 
   struct fo_state *state = (struct fo_state*)sampler;
455
 
   struct failover_context *failover = failover_context(pipe);
456
 
 
457
 
   failover->sw->delete_sampler_state(failover->sw, state->sw_state);
458
 
   failover->hw->delete_sampler_state(failover->hw, state->hw_state);
459
 
   state->sw_state = 0;
460
 
   state->hw_state = 0;
461
 
   FREE(state);
462
 
}
463
 
 
464
 
 
465
 
static struct pipe_sampler_view *
466
 
failover_create_sampler_view(struct pipe_context *pipe,
467
 
                             struct pipe_resource *texture,
468
 
                             const struct pipe_sampler_view *templ)
469
 
{
470
 
   struct fo_sampler_view *view = MALLOC(sizeof(struct fo_sampler_view));
471
 
   struct failover_context *failover = failover_context(pipe);
472
 
 
473
 
   view->sw = failover->sw->create_sampler_view(failover->sw, texture, templ);
474
 
   view->hw = failover->hw->create_sampler_view(failover->hw, texture, templ);
475
 
 
476
 
   view->base = *templ;
477
 
   view->base.reference.count = 1;
478
 
   view->base.texture = NULL;
479
 
   pipe_resource_reference(&view->base.texture, texture);
480
 
   view->base.context = pipe;
481
 
 
482
 
   return &view->base;
483
 
}
484
 
 
485
 
static void
486
 
failover_sampler_view_destroy(struct pipe_context *pipe,
487
 
                              struct pipe_sampler_view *view)
488
 
{
489
 
   struct fo_sampler_view *fo_view = (struct fo_sampler_view *)view;
490
 
   struct failover_context *failover = failover_context(pipe);
491
 
 
492
 
   failover->sw->sampler_view_destroy(failover->sw, fo_view->sw);
493
 
   failover->hw->sampler_view_destroy(failover->hw, fo_view->hw);
494
 
 
495
 
   pipe_resource_reference(&fo_view->base.texture, NULL);
496
 
   FREE(fo_view);
497
 
}
498
 
 
499
 
static void
500
 
failover_set_fragment_sampler_views(struct pipe_context *pipe,
501
 
                                    unsigned num,
502
 
                                    struct pipe_sampler_view **views)
503
 
{
504
 
   struct failover_context *failover = failover_context(pipe);
505
 
   struct pipe_sampler_view *hw_views[PIPE_MAX_SAMPLERS];
506
 
   uint i;
507
 
 
508
 
   assert(num <= PIPE_MAX_SAMPLERS);
509
 
 
510
 
   /* Check for no-op */
511
 
   if (num == failover->num_fragment_sampler_views &&
512
 
       !memcmp(failover->fragment_sampler_views, views, num * sizeof(struct pipe_sampler_view *)))
513
 
      return;
514
 
   for (i = 0; i < num; i++) {
515
 
      struct fo_sampler_view *fo_view = (struct fo_sampler_view *)views[i];
516
 
 
517
 
      pipe_sampler_view_reference((struct pipe_sampler_view **)&failover->fragment_sampler_views[i], views[i]);
518
 
      hw_views[i] = fo_view->hw;
519
 
   }
520
 
   for (i = num; i < failover->num_fragment_sampler_views; i++)
521
 
      pipe_sampler_view_reference((struct pipe_sampler_view **)&failover->fragment_sampler_views[i], NULL);
522
 
   failover->dirty |= FO_NEW_SAMPLER_VIEW;
523
 
   failover->num_fragment_sampler_views = num;
524
 
   failover->hw->set_fragment_sampler_views(failover->hw, num, hw_views);
525
 
}
526
 
 
527
 
 
528
 
static void
529
 
failover_set_vertex_sampler_views(struct pipe_context *pipe,
530
 
                                  unsigned num,
531
 
                                  struct pipe_sampler_view **views)
532
 
{
533
 
   struct failover_context *failover = failover_context(pipe);
534
 
   struct pipe_sampler_view *hw_views[PIPE_MAX_VERTEX_SAMPLERS];
535
 
   uint i;
536
 
 
537
 
   assert(num <= PIPE_MAX_VERTEX_SAMPLERS);
538
 
 
539
 
   /* Check for no-op */
540
 
   if (num == failover->num_vertex_sampler_views &&
541
 
       !memcmp(failover->vertex_sampler_views, views, num * sizeof(struct pipe_sampler_view *))) {
542
 
      return;
543
 
   }
544
 
   for (i = 0; i < num; i++) {
545
 
      struct fo_sampler_view *fo_view = (struct fo_sampler_view *)views[i];
546
 
 
547
 
      pipe_sampler_view_reference((struct pipe_sampler_view **)&failover->vertex_sampler_views[i], views[i]);
548
 
      hw_views[i] = fo_view->hw;
549
 
   }
550
 
   for (i = num; i < failover->num_vertex_sampler_views; i++)
551
 
      pipe_sampler_view_reference((struct pipe_sampler_view **)&failover->vertex_sampler_views[i], NULL);
552
 
   failover->dirty |= FO_NEW_SAMPLER_VIEW;
553
 
   failover->num_vertex_sampler_views = num;
554
 
   failover->hw->set_vertex_sampler_views(failover->hw, num, hw_views);
555
 
}
556
 
 
557
 
 
558
 
static void 
559
 
failover_set_viewport_state( struct pipe_context *pipe,
560
 
                             const struct pipe_viewport_state *viewport )
561
 
{
562
 
   struct failover_context *failover = failover_context(pipe);
563
 
 
564
 
   failover->viewport = *viewport; 
565
 
   failover->dirty |= FO_NEW_VIEWPORT;
566
 
   failover->sw->set_viewport_state( failover->sw, viewport );
567
 
   failover->hw->set_viewport_state( failover->hw, viewport );
568
 
}
569
 
 
570
 
 
571
 
static void
572
 
failover_set_vertex_buffers(struct pipe_context *pipe,
573
 
                            unsigned count,
574
 
                            const struct pipe_vertex_buffer *vertex_buffers)
575
 
{
576
 
   struct failover_context *failover = failover_context(pipe);
577
 
 
578
 
   util_copy_vertex_buffers(failover->vertex_buffers,
579
 
                            &failover->num_vertex_buffers,
580
 
                            vertex_buffers, count);
581
 
   failover->dirty |= FO_NEW_VERTEX_BUFFER;
582
 
   failover->sw->set_vertex_buffers( failover->sw, count, vertex_buffers );
583
 
   failover->hw->set_vertex_buffers( failover->hw, count, vertex_buffers );
584
 
}
585
 
 
586
 
 
587
 
static void
588
 
failover_set_index_buffer(struct pipe_context *pipe,
589
 
                          const struct pipe_index_buffer *ib)
590
 
{
591
 
   struct failover_context *failover = failover_context(pipe);
592
 
 
593
 
   if (ib)
594
 
      memcpy(&failover->index_buffer, ib, sizeof(failover->index_buffer));
595
 
   else
596
 
      memset(&failover->index_buffer, 0, sizeof(failover->index_buffer));
597
 
 
598
 
   failover->dirty |= FO_NEW_INDEX_BUFFER;
599
 
   failover->sw->set_index_buffer( failover->sw, ib );
600
 
   failover->hw->set_index_buffer( failover->hw, ib );
601
 
}
602
 
 
603
 
 
604
 
void
605
 
failover_set_constant_buffer(struct pipe_context *pipe,
606
 
                             uint shader, uint index,
607
 
                             struct pipe_resource *res)
608
 
{
609
 
   struct failover_context *failover = failover_context(pipe);
610
 
 
611
 
   assert(shader < PIPE_SHADER_TYPES);
612
 
   assert(index == 0);
613
 
 
614
 
   failover->sw->set_constant_buffer(failover->sw, shader, index, res);
615
 
   failover->hw->set_constant_buffer(failover->hw, shader, index, res);
616
 
}
617
 
 
618
 
 
619
 
void
620
 
failover_init_state_functions( struct failover_context *failover )
621
 
{
622
 
   failover->pipe.create_blend_state = failover_create_blend_state;
623
 
   failover->pipe.bind_blend_state   = failover_bind_blend_state;
624
 
   failover->pipe.delete_blend_state = failover_delete_blend_state;
625
 
   failover->pipe.create_sampler_state = failover_create_sampler_state;
626
 
   failover->pipe.bind_fragment_sampler_states  = failover_bind_fragment_sampler_states;
627
 
   failover->pipe.bind_vertex_sampler_states  = failover_bind_vertex_sampler_states;
628
 
   failover->pipe.delete_sampler_state = failover_delete_sampler_state;
629
 
   failover->pipe.create_depth_stencil_alpha_state = failover_create_depth_stencil_state;
630
 
   failover->pipe.bind_depth_stencil_alpha_state   = failover_bind_depth_stencil_state;
631
 
   failover->pipe.delete_depth_stencil_alpha_state = failover_delete_depth_stencil_state;
632
 
   failover->pipe.create_rasterizer_state = failover_create_rasterizer_state;
633
 
   failover->pipe.bind_rasterizer_state = failover_bind_rasterizer_state;
634
 
   failover->pipe.delete_rasterizer_state = failover_delete_rasterizer_state;
635
 
   failover->pipe.create_fs_state = failover_create_fs_state;
636
 
   failover->pipe.bind_fs_state   = failover_bind_fs_state;
637
 
   failover->pipe.delete_fs_state = failover_delete_fs_state;
638
 
   failover->pipe.create_vs_state = failover_create_vs_state;
639
 
   failover->pipe.bind_vs_state   = failover_bind_vs_state;
640
 
   failover->pipe.delete_vs_state = failover_delete_vs_state;
641
 
   failover->pipe.create_vertex_elements_state = failover_create_vertex_elements_state;
642
 
   failover->pipe.bind_vertex_elements_state = failover_bind_vertex_elements_state;
643
 
   failover->pipe.delete_vertex_elements_state = failover_delete_vertex_elements_state;
644
 
 
645
 
   failover->pipe.set_blend_color = failover_set_blend_color;
646
 
   failover->pipe.set_stencil_ref = failover_set_stencil_ref;
647
 
   failover->pipe.set_clip_state = failover_set_clip_state;
648
 
   failover->pipe.set_sample_mask = failover_set_sample_mask;
649
 
   failover->pipe.set_framebuffer_state = failover_set_framebuffer_state;
650
 
   failover->pipe.set_polygon_stipple = failover_set_polygon_stipple;
651
 
   failover->pipe.set_scissor_state = failover_set_scissor_state;
652
 
   failover->pipe.set_fragment_sampler_views = failover_set_fragment_sampler_views;
653
 
   failover->pipe.set_vertex_sampler_views = failover_set_vertex_sampler_views;
654
 
   failover->pipe.set_viewport_state = failover_set_viewport_state;
655
 
   failover->pipe.set_vertex_buffers = failover_set_vertex_buffers;
656
 
   failover->pipe.set_index_buffer = failover_set_index_buffer;
657
 
   failover->pipe.set_constant_buffer = failover_set_constant_buffer;
658
 
   failover->pipe.create_sampler_view = failover_create_sampler_view;
659
 
   failover->pipe.sampler_view_destroy = failover_sampler_view_destroy;
660
 
   failover->pipe.redefine_user_buffer = u_default_redefine_user_buffer;
661
 
}