1/*
2 * Copyright (C) 2009-2010 Francisco Jerez.
3 * All Rights Reserved.
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining
6 * a copy of this software and associated documentation files (the
7 * "Software"), to deal in the Software without restriction, including
8 * without limitation the rights to use, copy, modify, merge, publish,
9 * distribute, sublicense, and/or sell copies of the Software, and to
10 * permit persons to whom the Software is furnished to do so, subject to
11 * the following conditions:
12 *
13 * The above copyright notice and this permission notice (including the
14 * next paragraph) shall be included in all copies or substantial
15 * portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
18 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
19 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
20 * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
21 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
22 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
23 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
24 *
25 */
26
27#include "nouveau_driver.h"
28#include "nouveau_bufferobj.h"
29#include "nouveau_util.h"
30
31#include "main/bufferobj.h"
32#include "main/glformats.h"
33#include "main/image.h"
34
35/* Arbitrary pushbuf length we can assume we can get with a single
36 * call to WAIT_RING. */
37#define PUSHBUF_DWORDS 65536
38
39/* Functions to turn GL arrays or index buffers into nouveau_array
40 * structures. */
41
42static int
43get_array_stride(struct gl_context *ctx, const struct gl_client_array *a)
44{
45	struct nouveau_render_state *render = to_render_state(ctx);
46
47	if (render->mode == VBO && !_mesa_is_bufferobj(a->BufferObj))
48		/* Pack client buffers. */
49		return align(_mesa_sizeof_type(a->Type) * a->Size, 4);
50	else
51		return a->StrideB;
52}
53
54static void
55vbo_init_arrays(struct gl_context *ctx, const struct _mesa_index_buffer *ib,
56		const struct gl_client_array **arrays)
57{
58	struct nouveau_render_state *render = to_render_state(ctx);
59	GLboolean imm = (render->mode == IMM);
60	int i, attr;
61
62	if (ib)
63		nouveau_init_array(&render->ib, 0, 0, ib->count, ib->type,
64				   ib->obj, ib->ptr, GL_TRUE, ctx);
65
66	FOR_EACH_BOUND_ATTR(render, i, attr) {
67		const struct gl_client_array *array = arrays[attr];
68
69		nouveau_init_array(&render->attrs[attr], attr,
70				   get_array_stride(ctx, array),
71				   array->Size, array->Type,
72				   imm ? array->BufferObj : NULL,
73				   array->Ptr, imm, ctx);
74	}
75}
76
77static void
78vbo_deinit_arrays(struct gl_context *ctx, const struct _mesa_index_buffer *ib,
79		  const struct gl_client_array **arrays)
80{
81	struct nouveau_render_state *render = to_render_state(ctx);
82	int i, attr;
83
84	if (ib)
85		nouveau_cleanup_array(&render->ib);
86
87	FOR_EACH_BOUND_ATTR(render, i, attr) {
88		struct nouveau_array *a = &render->attrs[attr];
89
90		if (render->mode == IMM)
91			nouveau_bo_ref(NULL, &a->bo);
92
93		nouveau_deinit_array(a);
94		render->map[i] = -1;
95	}
96
97	render->attr_count = 0;
98}
99
100/* Make some rendering decisions from the GL context. */
101
102static void
103vbo_choose_render_mode(struct gl_context *ctx, const struct gl_client_array **arrays)
104{
105	struct nouveau_render_state *render = to_render_state(ctx);
106	int i;
107
108	render->mode = VBO;
109
110	if (ctx->Light.Enabled) {
111		for (i = 0; i < MAT_ATTRIB_MAX; i++) {
112			if (arrays[VERT_ATTRIB_GENERIC0 + i]->StrideB) {
113				render->mode = IMM;
114				break;
115			}
116		}
117	}
118}
119
120static void
121vbo_emit_attr(struct gl_context *ctx, const struct gl_client_array **arrays,
122	      int attr)
123{
124	struct nouveau_pushbuf *push = context_push(ctx);
125	struct nouveau_render_state *render = to_render_state(ctx);
126	const struct gl_client_array *array = arrays[attr];
127	struct nouveau_array *a = &render->attrs[attr];
128	RENDER_LOCALS(ctx);
129
130	if (!array->StrideB) {
131		if (attr >= VERT_ATTRIB_GENERIC0)
132			/* nouveau_update_state takes care of materials. */
133			return;
134
135		/* Constant attribute. */
136		nouveau_init_array(a, attr, array->StrideB, array->Size,
137				   array->Type, array->BufferObj, array->Ptr,
138				   GL_TRUE, ctx);
139		EMIT_IMM(ctx, a, 0);
140		nouveau_deinit_array(a);
141
142	} else {
143		/* Varying attribute. */
144		struct nouveau_attr_info *info = &TAG(vertex_attrs)[attr];
145
146		if (render->mode == VBO) {
147			render->map[info->vbo_index] = attr;
148			render->vertex_size += array->_ElementSize;
149			render->attr_count = MAX2(render->attr_count,
150						  info->vbo_index + 1);
151		} else {
152			render->map[render->attr_count++] = attr;
153			render->vertex_size += 4 * info->imm_fields;
154		}
155	}
156}
157
158#define MAT(a) (VERT_ATTRIB_GENERIC0 + MAT_ATTRIB_##a)
159
160static void
161vbo_choose_attrs(struct gl_context *ctx, const struct gl_client_array **arrays)
162{
163	struct nouveau_render_state *render = to_render_state(ctx);
164	int i;
165
166	/* Reset the vertex size. */
167	render->vertex_size = 0;
168	render->attr_count = 0;
169
170	vbo_emit_attr(ctx, arrays, VERT_ATTRIB_COLOR0);
171	if (ctx->Fog.ColorSumEnabled && !ctx->Light.Enabled)
172		vbo_emit_attr(ctx, arrays, VERT_ATTRIB_COLOR1);
173
174	for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++) {
175		if (ctx->Texture._EnabledCoordUnits & (1 << i))
176			vbo_emit_attr(ctx, arrays, VERT_ATTRIB_TEX0 + i);
177	}
178
179	if (ctx->Fog.Enabled && ctx->Fog.FogCoordinateSource == GL_FOG_COORD)
180		vbo_emit_attr(ctx, arrays, VERT_ATTRIB_FOG);
181
182	if (ctx->Light.Enabled ||
183	    (ctx->Texture._GenFlags & TEXGEN_NEED_NORMALS))
184		vbo_emit_attr(ctx, arrays, VERT_ATTRIB_NORMAL);
185
186	if (ctx->Light.Enabled && render->mode == IMM) {
187		vbo_emit_attr(ctx, arrays, MAT(FRONT_AMBIENT));
188		vbo_emit_attr(ctx, arrays, MAT(FRONT_DIFFUSE));
189		vbo_emit_attr(ctx, arrays, MAT(FRONT_SPECULAR));
190		vbo_emit_attr(ctx, arrays, MAT(FRONT_SHININESS));
191
192		if (ctx->Light.Model.TwoSide) {
193			vbo_emit_attr(ctx, arrays, MAT(BACK_AMBIENT));
194			vbo_emit_attr(ctx, arrays, MAT(BACK_DIFFUSE));
195			vbo_emit_attr(ctx, arrays, MAT(BACK_SPECULAR));
196			vbo_emit_attr(ctx, arrays, MAT(BACK_SHININESS));
197		}
198	}
199
200	vbo_emit_attr(ctx, arrays, VERT_ATTRIB_POS);
201}
202
203static int
204get_max_client_stride(struct gl_context *ctx, const struct gl_client_array **arrays)
205{
206	struct nouveau_render_state *render = to_render_state(ctx);
207	int i, attr, s = 0;
208
209	FOR_EACH_BOUND_ATTR(render, i, attr) {
210		const struct gl_client_array *a = arrays[attr];
211
212		if (!_mesa_is_bufferobj(a->BufferObj))
213			s = MAX2(s, get_array_stride(ctx, a));
214	}
215
216	return s;
217}
218
219static void
220TAG(vbo_render_prims)(struct gl_context *ctx,
221		      const struct _mesa_prim *prims, GLuint nr_prims,
222		      const struct _mesa_index_buffer *ib,
223		      GLboolean index_bounds_valid,
224		      GLuint min_index, GLuint max_index,
225		      struct gl_transform_feedback_object *tfb_vertcount);
226
227static GLboolean
228vbo_maybe_split(struct gl_context *ctx, const struct gl_client_array **arrays,
229	    const struct _mesa_prim *prims, GLuint nr_prims,
230	    const struct _mesa_index_buffer *ib,
231	    GLuint min_index, GLuint max_index)
232{
233	struct nouveau_context *nctx = to_nouveau_context(ctx);
234	struct nouveau_render_state *render = to_render_state(ctx);
235	struct nouveau_bufctx *bufctx = nctx->hw.bufctx;
236	unsigned pushbuf_avail = PUSHBUF_DWORDS - 2 * (bufctx->relocs +
237						       render->attr_count),
238		vert_avail = get_max_vertices(ctx, NULL, pushbuf_avail),
239		idx_avail = get_max_vertices(ctx, ib, pushbuf_avail);
240	int stride;
241
242	/* Try to keep client buffers smaller than the scratch BOs. */
243	if (render->mode == VBO &&
244	    (stride = get_max_client_stride(ctx, arrays)))
245		    vert_avail = MIN2(vert_avail,
246				      NOUVEAU_SCRATCH_SIZE / stride);
247
248	if (max_index - min_index > vert_avail ||
249	    (ib && ib->count > idx_avail)) {
250		struct split_limits limits = {
251			.max_verts = vert_avail,
252			.max_indices = idx_avail,
253			.max_vb_size = ~0,
254		};
255
256		vbo_split_prims(ctx, arrays, prims, nr_prims, ib, min_index,
257				max_index, TAG(vbo_render_prims), &limits);
258		return GL_TRUE;
259	}
260
261	return GL_FALSE;
262}
263
264/* VBO rendering path. */
265
266static GLboolean
267check_update_array(struct nouveau_array *a, unsigned offset,
268		   struct nouveau_bo *bo, int *pdelta)
269{
270	int delta = *pdelta;
271	GLboolean dirty;
272
273	if (a->bo == bo) {
274		if (delta < 0)
275			delta = ((int)offset - (int)a->offset) / a->stride;
276
277		dirty = (delta < 0 ||
278			 offset != (a->offset + delta * a->stride));
279	} else {
280		dirty = GL_TRUE;
281	}
282
283	*pdelta = (dirty ? 0 : delta);
284	return dirty;
285}
286
287static void
288vbo_bind_vertices(struct gl_context *ctx, const struct gl_client_array **arrays,
289		  int base, unsigned min_index, unsigned max_index, int *pdelta)
290{
291	struct nouveau_render_state *render = to_render_state(ctx);
292	struct nouveau_pushbuf *push = context_push(ctx);
293	struct nouveau_bo *bo[NUM_VERTEX_ATTRS];
294	unsigned offset[NUM_VERTEX_ATTRS];
295	GLboolean dirty = GL_FALSE;
296	int i, j, attr;
297	RENDER_LOCALS(ctx);
298
299	*pdelta = -1;
300
301	FOR_EACH_BOUND_ATTR(render, i, attr) {
302		const struct gl_client_array *array = arrays[attr];
303		struct gl_buffer_object *obj = array->BufferObj;
304		struct nouveau_array *a = &render->attrs[attr];
305		unsigned delta = (base + min_index) * array->StrideB;
306
307		bo[i] = NULL;
308
309		if (nouveau_bufferobj_hw(obj)) {
310			/* Array in a buffer obj. */
311			nouveau_bo_ref(to_nouveau_bufferobj(obj)->bo, &bo[i]);
312			offset[i] = delta + (intptr_t)array->Ptr;
313
314		} else {
315			int n = max_index - min_index + 1;
316			char *sp = (char *)ADD_POINTERS(
317				nouveau_bufferobj_sys(obj), array->Ptr) + delta;
318			char *dp  = nouveau_get_scratch(ctx, n * a->stride,
319							&bo[i], &offset[i]);
320
321			/* Array in client memory, move it to a
322			 * scratch buffer obj. */
323			for (j = 0; j < n; j++)
324				memcpy(dp + j * a->stride,
325				       sp + j * array->StrideB,
326				       a->stride);
327		}
328
329		dirty |= check_update_array(a, offset[i], bo[i], pdelta);
330	}
331
332	*pdelta -= min_index;
333
334	if (dirty) {
335		/* Buffers changed, update the attribute binding. */
336		FOR_EACH_BOUND_ATTR(render, i, attr) {
337			struct nouveau_array *a = &render->attrs[attr];
338
339			nouveau_bo_ref(NULL, &a->bo);
340			a->offset = offset[i];
341			a->bo = bo[i];
342		}
343
344		TAG(render_release_vertices)(ctx);
345		TAG(render_bind_vertices)(ctx);
346	} else {
347		/* Just cleanup. */
348		FOR_EACH_BOUND_ATTR(render, i, attr)
349			nouveau_bo_ref(NULL, &bo[i]);
350	}
351
352	BATCH_VALIDATE();
353}
354
355static void
356vbo_draw_vbo(struct gl_context *ctx, const struct gl_client_array **arrays,
357	     const struct _mesa_prim *prims, GLuint nr_prims,
358	     const struct _mesa_index_buffer *ib, GLuint min_index,
359	     GLuint max_index)
360{
361	struct nouveau_context *nctx = to_nouveau_context(ctx);
362	struct nouveau_pushbuf *push = context_push(ctx);
363	dispatch_t dispatch = get_array_dispatch(&to_render_state(ctx)->ib);
364	int i, delta = 0, basevertex = 0;
365	RENDER_LOCALS(ctx);
366
367	TAG(render_set_format)(ctx);
368
369	for (i = 0; i < nr_prims; i++) {
370		unsigned start = prims[i].start,
371			count = prims[i].count;
372
373		if (i == 0 || basevertex != prims[i].basevertex) {
374			basevertex = prims[i].basevertex;
375			vbo_bind_vertices(ctx, arrays, basevertex, min_index,
376					  max_index, &delta);
377
378			nouveau_pushbuf_bufctx(push, nctx->hw.bufctx);
379			if (nouveau_pushbuf_validate(push)) {
380				nouveau_pushbuf_bufctx(push, NULL);
381				return;
382			}
383		}
384
385		if (count > get_max_vertices(ctx, ib, PUSH_AVAIL(push)))
386			PUSH_SPACE(push, PUSHBUF_DWORDS);
387
388		BATCH_BEGIN(nvgl_primitive(prims[i].mode));
389		dispatch(ctx, start, delta, count);
390		BATCH_END();
391	}
392
393	nouveau_pushbuf_bufctx(push, NULL);
394	TAG(render_release_vertices)(ctx);
395}
396
397/* Immediate rendering path. */
398
399static unsigned
400extract_id(struct nouveau_array *a, int i, int j)
401{
402	return j;
403}
404
405static void
406vbo_draw_imm(struct gl_context *ctx, const struct gl_client_array **arrays,
407	     const struct _mesa_prim *prims, GLuint nr_prims,
408	     const struct _mesa_index_buffer *ib, GLuint min_index,
409	     GLuint max_index)
410{
411	struct nouveau_render_state *render = to_render_state(ctx);
412	struct nouveau_context *nctx = to_nouveau_context(ctx);
413	struct nouveau_pushbuf *push = context_push(ctx);
414	extract_u_t extract = ib ? render->ib.extract_u : extract_id;
415	int i, j, k, attr;
416	RENDER_LOCALS(ctx);
417
418	nouveau_pushbuf_bufctx(push, nctx->hw.bufctx);
419	if (nouveau_pushbuf_validate(push)) {
420		nouveau_pushbuf_bufctx(push, NULL);
421		return;
422	}
423
424	for (i = 0; i < nr_prims; i++) {
425		unsigned start = prims[i].start,
426			end = start + prims[i].count;
427
428		if (prims[i].count > get_max_vertices(ctx, ib,
429						      PUSH_AVAIL(push)))
430			PUSH_SPACE(push, PUSHBUF_DWORDS);
431
432		BATCH_BEGIN(nvgl_primitive(prims[i].mode));
433
434		for (; start < end; start++) {
435			j = prims[i].basevertex +
436				extract(&render->ib, 0, start);
437
438			FOR_EACH_BOUND_ATTR(render, k, attr)
439				EMIT_IMM(ctx, &render->attrs[attr], j);
440		}
441
442		BATCH_END();
443	}
444
445	nouveau_pushbuf_bufctx(push, NULL);
446}
447
448/* draw_prims entry point when we're doing hw-tnl. */
449
450static void
451TAG(vbo_render_prims)(struct gl_context *ctx,
452		      const struct _mesa_prim *prims, GLuint nr_prims,
453		      const struct _mesa_index_buffer *ib,
454		      GLboolean index_bounds_valid,
455		      GLuint min_index, GLuint max_index,
456		      struct gl_transform_feedback_object *tfb_vertcount)
457{
458	struct nouveau_render_state *render = to_render_state(ctx);
459	const struct gl_client_array **arrays = ctx->Array._DrawArrays;
460
461	if (!index_bounds_valid)
462		vbo_get_minmax_indices(ctx, prims, ib, &min_index, &max_index,
463				       nr_prims);
464
465	vbo_choose_render_mode(ctx, arrays);
466	vbo_choose_attrs(ctx, arrays);
467
468	if (vbo_maybe_split(ctx, arrays, prims, nr_prims, ib, min_index,
469			    max_index))
470		return;
471
472	vbo_init_arrays(ctx, ib, arrays);
473
474	if (render->mode == VBO)
475		vbo_draw_vbo(ctx, arrays, prims, nr_prims, ib, min_index,
476			     max_index);
477	else
478		vbo_draw_imm(ctx, arrays, prims, nr_prims, ib, min_index,
479			     max_index);
480
481	vbo_deinit_arrays(ctx, ib, arrays);
482}
483
484/* VBO rendering entry points. */
485
486static void
487TAG(vbo_check_render_prims)(struct gl_context *ctx,
488			    const struct _mesa_prim *prims, GLuint nr_prims,
489			    const struct _mesa_index_buffer *ib,
490			    GLboolean index_bounds_valid,
491			    GLuint min_index, GLuint max_index,
492			    struct gl_transform_feedback_object *tfb_vertcount)
493{
494	struct nouveau_context *nctx = to_nouveau_context(ctx);
495
496	nouveau_validate_framebuffer(ctx);
497
498	if (nctx->fallback == HWTNL)
499		TAG(vbo_render_prims)(ctx, prims, nr_prims, ib,
500				      index_bounds_valid, min_index, max_index,
501				      tfb_vertcount);
502
503	if (nctx->fallback == SWTNL)
504		_tnl_vbo_draw_prims(ctx, prims, nr_prims, ib,
505				    index_bounds_valid, min_index, max_index,
506				    tfb_vertcount);
507}
508
509void
510TAG(vbo_init)(struct gl_context *ctx)
511{
512	struct nouveau_render_state *render = to_render_state(ctx);
513	int i;
514
515	for (i = 0; i < VERT_ATTRIB_MAX; i++)
516		render->map[i] = -1;
517
518	vbo_set_draw_func(ctx, TAG(vbo_check_render_prims));
519	vbo_use_buffer_objects(ctx);
520}
521
522void
523TAG(vbo_destroy)(struct gl_context *ctx)
524{
525}
526