brw_vs_surface_state.c revision 118a47623a11a374df371d52ed0294224e6a62dc 
1/*
2 Copyright (C) Intel Corp.  2006.  All Rights Reserved.
3 Intel funded Tungsten Graphics (http://www.tungstengraphics.com) to
4 develop this 3D driver.
5
6 Permission is hereby granted, free of charge, to any person obtaining
7 a 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, sublicense, 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
16 portions of the Software.
17
18 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
19 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
21 IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
22 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
23 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
24 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25
26 **********************************************************************/
27 /*
28  * Authors:
29  *   Keith Whitwell <keith@tungstengraphics.com>
30  */
31
32#include "main/mtypes.h"
33#include "main/texstore.h"
34#include "shader/prog_parameter.h"
35
36#include "brw_context.h"
37#include "brw_state.h"
38
39/* Creates a new VS constant buffer reflecting the current VS program's
40 * constants, if needed by the VS program.
41 *
42 * Otherwise, constants go through the CURBEs using the brw_constant_buffer
43 * state atom.
44 */
45static void
46prepare_vs_constants(struct brw_context *brw)
47{
48   GLcontext *ctx = &brw->intel.ctx;
49   struct intel_context *intel = &brw->intel;
50   struct brw_vertex_program *vp =
51      (struct brw_vertex_program *) brw->vertex_program;
52   const struct gl_program_parameter_list *params = vp->program.Base.Parameters;
53   const int size = params->NumParameters * 4 * sizeof(GLfloat);
54   int i;
55
56   if (vp->program.IsNVProgram)
57      _mesa_load_tracked_matrices(ctx);
58
59   /* Updates the ParamaterValues[i] pointers for all parameters of the
60    * basic type of PROGRAM_STATE_VAR.
61    */
62   _mesa_load_state_parameters(&brw->intel.ctx, vp->program.Base.Parameters);
63
64   /* BRW_NEW_VERTEX_PROGRAM */
65   if (!vp->use_const_buffer) {
66      if (brw->vs.const_bo) {
67	 drm_intel_bo_unreference(brw->vs.const_bo);
68	 brw->vs.const_bo = NULL;
69	 brw->state.dirty.brw |= BRW_NEW_VS_CONSTBUF;
70      }
71      return;
72   }
73
74   /* _NEW_PROGRAM_CONSTANTS */
75   drm_intel_bo_unreference(brw->vs.const_bo);
76   brw->vs.const_bo = drm_intel_bo_alloc(intel->bufmgr, "vp_const_buffer",
77					 size, 64);
78
79   drm_intel_gem_bo_map_gtt(brw->vs.const_bo);
80   for (i = 0; i < params->NumParameters; i++) {
81      memcpy(brw->vs.const_bo->virtual + i * 4 * sizeof(float),
82	     params->ParameterValues[i],
83	     4 * sizeof(float));
84   }
85   drm_intel_gem_bo_unmap_gtt(brw->vs.const_bo);
86   brw->state.dirty.brw |= BRW_NEW_VS_CONSTBUF;
87}
88
89const struct brw_tracked_state brw_vs_constants = {
90   .dirty = {
91      .mesa = (_NEW_PROGRAM_CONSTANTS),
92      .brw = (BRW_NEW_VERTEX_PROGRAM),
93      .cache = 0
94   },
95   .prepare = prepare_vs_constants,
96};
97
98/**
99 * Update the surface state for a VS constant buffer.
100 *
101 * Sets brw->vs.surf_bo[surf] and brw->vp->const_buffer.
102 */
103static void
104brw_update_vs_constant_surface( GLcontext *ctx,
105                                GLuint surf)
106{
107   struct brw_context *brw = brw_context(ctx);
108   struct brw_surface_key key;
109   struct brw_vertex_program *vp =
110      (struct brw_vertex_program *) brw->vertex_program;
111   const struct gl_program_parameter_list *params = vp->program.Base.Parameters;
112
113   assert(surf == 0);
114
115   /* If there's no constant buffer, then no surface BO is needed to point at
116    * it.
117    */
118   if (brw->vs.const_bo == NULL) {
119      drm_intel_bo_unreference(brw->vs.surf_bo[surf]);
120      brw->vs.surf_bo[surf] = NULL;
121      return;
122   }
123
124   memset(&key, 0, sizeof(key));
125
126   key.format = MESA_FORMAT_RGBA_FLOAT32;
127   key.internal_format = GL_RGBA;
128   key.bo = brw->vs.const_bo;
129   key.depthmode = GL_NONE;
130   key.pitch = params->NumParameters;
131   key.width = params->NumParameters;
132   key.height = 1;
133   key.depth = 1;
134   key.cpp = 16;
135
136   /*
137   printf("%s:\n", __FUNCTION__);
138   printf("  width %d  height %d  depth %d  cpp %d  pitch %d\n",
139          key.width, key.height, key.depth, key.cpp, key.pitch);
140   */
141
142   drm_intel_bo_unreference(brw->vs.surf_bo[surf]);
143   brw->vs.surf_bo[surf] = brw_search_cache(&brw->surface_cache,
144                                            BRW_SS_SURFACE,
145                                            &key, sizeof(key),
146                                            &key.bo, 1,
147                                            NULL);
148   if (brw->vs.surf_bo[surf] == NULL) {
149      brw->vs.surf_bo[surf] = brw_create_constant_surface(brw, &key);
150   }
151}
152
153
154/**
155 * Constructs the binding table for the VS surface state.
156 */
157static drm_intel_bo *
158brw_vs_get_binding_table(struct brw_context *brw)
159{
160   drm_intel_bo *bind_bo;
161
162   bind_bo = brw_search_cache(&brw->surface_cache, BRW_SS_SURF_BIND,
163			      NULL, 0,
164			      brw->vs.surf_bo, BRW_VS_MAX_SURF,
165			      NULL);
166
167   if (bind_bo == NULL) {
168      GLuint data_size = BRW_VS_MAX_SURF * sizeof(GLuint);
169      uint32_t data[BRW_VS_MAX_SURF];
170      int i;
171
172      for (i = 0; i < BRW_VS_MAX_SURF; i++)
173         if (brw->vs.surf_bo[i])
174            data[i] = brw->vs.surf_bo[i]->offset;
175         else
176            data[i] = 0;
177
178      bind_bo = brw_upload_cache( &brw->surface_cache, BRW_SS_SURF_BIND,
179				  NULL, 0,
180				  brw->vs.surf_bo, BRW_VS_MAX_SURF,
181				  data, data_size);
182
183      /* Emit binding table relocations to surface state */
184      for (i = 0; i < BRW_VS_MAX_SURF; i++) {
185	 if (brw->vs.surf_bo[i] != NULL) {
186	    /* The presumed offsets were set in the data values for
187	     * brw_upload_cache.
188	     */
189	    drm_intel_bo_emit_reloc(bind_bo, i * 4,
190				    brw->vs.surf_bo[i], 0,
191				    I915_GEM_DOMAIN_INSTRUCTION, 0);
192	 }
193      }
194   }
195
196   return bind_bo;
197}
198
199/**
200 * Vertex shader surfaces (constant buffer).
201 *
202 * This consumes the state updates for the constant buffer needing
203 * to be updated, and produces BRW_NEW_NR_VS_SURFACES for the VS unit and
204 * CACHE_NEW_SURF_BIND for the binding table upload.
205 */
206static void prepare_vs_surfaces(struct brw_context *brw )
207{
208   GLcontext *ctx = &brw->intel.ctx;
209   int i;
210   int nr_surfaces = 0;
211
212   brw_update_vs_constant_surface(ctx, SURF_INDEX_VERT_CONST_BUFFER);
213
214   for (i = 0; i < BRW_VS_MAX_SURF; i++) {
215      if (brw->vs.surf_bo[i] != NULL) {
216	 nr_surfaces = i + 1;
217      }
218   }
219
220   if (brw->vs.nr_surfaces != nr_surfaces) {
221      brw->state.dirty.brw |= BRW_NEW_NR_VS_SURFACES;
222      brw->vs.nr_surfaces = nr_surfaces;
223   }
224
225   /* Note that we don't end up updating the bind_bo if we don't have a
226    * surface to be pointing at.  This should be relatively harmless, as it
227    * just slightly increases our working set size.
228    */
229   if (brw->vs.nr_surfaces != 0) {
230      drm_intel_bo_unreference(brw->vs.bind_bo);
231      brw->vs.bind_bo = brw_vs_get_binding_table(brw);
232   }
233}
234
235const struct brw_tracked_state brw_vs_surfaces = {
236   .dirty = {
237      .mesa = 0,
238      .brw = (BRW_NEW_VS_CONSTBUF),
239      .cache = 0
240   },
241   .prepare = prepare_vs_surfaces,
242};
243
244
245
246