vbo_exec.c revision b8e80941 
1/*
2 * Mesa 3-D graphics library
3 *
4 * Copyright (C) 1999-2005  Brian Paul   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 "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included
14 * in all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
17 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
20 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
21 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22 * OTHER DEALINGS IN THE SOFTWARE.
23 *
24 * Authors:
25 *    Keith Whitwell <keithw@vmware.com>
26 */
27
28
29#include "main/glheader.h"
30#include "main/arrayobj.h"
31#include "main/api_arrayelt.h"
32#include "main/vtxfmt.h"
33#include "vbo_private.h"
34
35const GLubyte
36_vbo_attribute_alias_map[VP_MODE_MAX][VERT_ATTRIB_MAX] = {
37   /* VP_MODE_FF: */
38   {
39      VBO_ATTRIB_POS,                 /* VERT_ATTRIB_POS */
40      VBO_ATTRIB_NORMAL,              /* VERT_ATTRIB_NORMAL */
41      VBO_ATTRIB_COLOR0,              /* VERT_ATTRIB_COLOR0 */
42      VBO_ATTRIB_COLOR1,              /* VERT_ATTRIB_COLOR1 */
43      VBO_ATTRIB_FOG,                 /* VERT_ATTRIB_FOG */
44      VBO_ATTRIB_COLOR_INDEX,         /* VERT_ATTRIB_COLOR_INDEX */
45      VBO_ATTRIB_EDGEFLAG,            /* VERT_ATTRIB_EDGEFLAG */
46      VBO_ATTRIB_TEX0,                /* VERT_ATTRIB_TEX0 */
47      VBO_ATTRIB_TEX1,                /* VERT_ATTRIB_TEX1 */
48      VBO_ATTRIB_TEX2,                /* VERT_ATTRIB_TEX2 */
49      VBO_ATTRIB_TEX3,                /* VERT_ATTRIB_TEX3 */
50      VBO_ATTRIB_TEX4,                /* VERT_ATTRIB_TEX4 */
51      VBO_ATTRIB_TEX5,                /* VERT_ATTRIB_TEX5 */
52      VBO_ATTRIB_TEX6,                /* VERT_ATTRIB_TEX6 */
53      VBO_ATTRIB_TEX7,                /* VERT_ATTRIB_TEX7 */
54      VBO_ATTRIB_POINT_SIZE,          /* VERT_ATTRIB_POINT_SIZE */
55      VBO_ATTRIB_GENERIC0,            /* VERT_ATTRIB_GENERIC0 */
56      VBO_ATTRIB_GENERIC1,            /* VERT_ATTRIB_GENERIC1 */
57      VBO_ATTRIB_GENERIC2,            /* VERT_ATTRIB_GENERIC2 */
58      VBO_ATTRIB_GENERIC3,            /* VERT_ATTRIB_GENERIC3 */
59      VBO_ATTRIB_MAT_FRONT_AMBIENT,   /* VERT_ATTRIB_GENERIC4 */
60      VBO_ATTRIB_MAT_BACK_AMBIENT,    /* VERT_ATTRIB_GENERIC5 */
61      VBO_ATTRIB_MAT_FRONT_DIFFUSE,   /* VERT_ATTRIB_GENERIC6 */
62      VBO_ATTRIB_MAT_BACK_DIFFUSE,    /* VERT_ATTRIB_GENERIC7 */
63      VBO_ATTRIB_MAT_FRONT_SPECULAR,  /* VERT_ATTRIB_GENERIC8 */
64      VBO_ATTRIB_MAT_BACK_SPECULAR,   /* VERT_ATTRIB_GENERIC9 */
65      VBO_ATTRIB_MAT_FRONT_EMISSION,  /* VERT_ATTRIB_GENERIC10 */
66      VBO_ATTRIB_MAT_BACK_EMISSION,   /* VERT_ATTRIB_GENERIC11 */
67      VBO_ATTRIB_MAT_FRONT_SHININESS, /* VERT_ATTRIB_GENERIC12 */
68      VBO_ATTRIB_MAT_BACK_SHININESS,  /* VERT_ATTRIB_GENERIC13 */
69      VBO_ATTRIB_MAT_FRONT_INDEXES,   /* VERT_ATTRIB_GENERIC14 */
70      VBO_ATTRIB_MAT_BACK_INDEXES     /* VERT_ATTRIB_GENERIC15 */
71   },
72
73   /* VP_MODE_SHADER: */
74   {
75      VBO_ATTRIB_POS,                 /* VERT_ATTRIB_POS */
76      VBO_ATTRIB_NORMAL,              /* VERT_ATTRIB_NORMAL */
77      VBO_ATTRIB_COLOR0,              /* VERT_ATTRIB_COLOR0 */
78      VBO_ATTRIB_COLOR1,              /* VERT_ATTRIB_COLOR1 */
79      VBO_ATTRIB_FOG,                 /* VERT_ATTRIB_FOG */
80      VBO_ATTRIB_COLOR_INDEX,         /* VERT_ATTRIB_COLOR_INDEX */
81      VBO_ATTRIB_EDGEFLAG,            /* VERT_ATTRIB_EDGEFLAG */
82      VBO_ATTRIB_TEX0,                /* VERT_ATTRIB_TEX0 */
83      VBO_ATTRIB_TEX1,                /* VERT_ATTRIB_TEX1 */
84      VBO_ATTRIB_TEX2,                /* VERT_ATTRIB_TEX2 */
85      VBO_ATTRIB_TEX3,                /* VERT_ATTRIB_TEX3 */
86      VBO_ATTRIB_TEX4,                /* VERT_ATTRIB_TEX4 */
87      VBO_ATTRIB_TEX5,                /* VERT_ATTRIB_TEX5 */
88      VBO_ATTRIB_TEX6,                /* VERT_ATTRIB_TEX6 */
89      VBO_ATTRIB_TEX7,                /* VERT_ATTRIB_TEX7 */
90      VBO_ATTRIB_POINT_SIZE,          /* VERT_ATTRIB_POINT_SIZE */
91      VBO_ATTRIB_GENERIC0,            /* VERT_ATTRIB_GENERIC0 */
92      VBO_ATTRIB_GENERIC1,            /* VERT_ATTRIB_GENERIC1 */
93      VBO_ATTRIB_GENERIC2,            /* VERT_ATTRIB_GENERIC2 */
94      VBO_ATTRIB_GENERIC3,            /* VERT_ATTRIB_GENERIC3 */
95      VBO_ATTRIB_GENERIC4,            /* VERT_ATTRIB_GENERIC4 */
96      VBO_ATTRIB_GENERIC5,            /* VERT_ATTRIB_GENERIC5 */
97      VBO_ATTRIB_GENERIC6,            /* VERT_ATTRIB_GENERIC6 */
98      VBO_ATTRIB_GENERIC7,            /* VERT_ATTRIB_GENERIC7 */
99      VBO_ATTRIB_GENERIC8,            /* VERT_ATTRIB_GENERIC8 */
100      VBO_ATTRIB_GENERIC9,            /* VERT_ATTRIB_GENERIC9 */
101      VBO_ATTRIB_GENERIC10,           /* VERT_ATTRIB_GENERIC10 */
102      VBO_ATTRIB_GENERIC11,           /* VERT_ATTRIB_GENERIC11 */
103      VBO_ATTRIB_GENERIC12,           /* VERT_ATTRIB_GENERIC12 */
104      VBO_ATTRIB_GENERIC13,           /* VERT_ATTRIB_GENERIC13 */
105      VBO_ATTRIB_GENERIC14,           /* VERT_ATTRIB_GENERIC14 */
106      VBO_ATTRIB_GENERIC15            /* VERT_ATTRIB_GENERIC15 */
107   }
108};
109
110
111void
112vbo_exec_init(struct gl_context *ctx)
113{
114   struct vbo_exec_context *exec = &vbo_context(ctx)->exec;
115
116   exec->ctx = ctx;
117
118   vbo_exec_vtx_init(exec);
119
120   ctx->Driver.NeedFlush = 0;
121   ctx->Driver.CurrentExecPrimitive = PRIM_OUTSIDE_BEGIN_END;
122
123   exec->eval.recalculate_maps = GL_TRUE;
124}
125
126
127void vbo_exec_destroy( struct gl_context *ctx )
128{
129   struct vbo_exec_context *exec = &vbo_context(ctx)->exec;
130
131   vbo_exec_vtx_destroy( exec );
132}
133
134
135/**
136 * In some degenarate cases we can improve our ability to merge
137 * consecutive primitives.  For example:
138 * glBegin(GL_LINE_STRIP);
139 * glVertex(1);
140 * glVertex(1);
141 * glEnd();
142 * glBegin(GL_LINE_STRIP);
143 * glVertex(1);
144 * glVertex(1);
145 * glEnd();
146 * Can be merged as a GL_LINES prim with four vertices.
147 *
148 * This function converts 2-vertex line strips/loops into GL_LINES, etc.
149 */
150void
151vbo_try_prim_conversion(struct _mesa_prim *p)
152{
153   if (p->mode == GL_LINE_STRIP && p->count == 2) {
154      /* convert 2-vertex line strip to a separate line */
155      p->mode = GL_LINES;
156   }
157   else if ((p->mode == GL_TRIANGLE_STRIP || p->mode == GL_TRIANGLE_FAN)
158       && p->count == 3) {
159      /* convert 3-vertex tri strip or fan to a separate triangle */
160      p->mode = GL_TRIANGLES;
161   }
162
163   /* Note: we can't convert a 4-vertex quad strip to a separate quad
164    * because the vertex ordering is different.  We'd have to muck
165    * around in the vertex data to make it work.
166    */
167}
168
169
170/**
171 * Helper function for determining if two subsequent glBegin/glEnd
172 * primitives can be combined.  This is only possible for GL_POINTS,
173 * GL_LINES, GL_TRIANGLES and GL_QUADS.
174 * If we return true, it means that we can concatenate p1 onto p0 (and
175 * discard p1).
176 */
177bool
178vbo_can_merge_prims(const struct _mesa_prim *p0, const struct _mesa_prim *p1)
179{
180   if (!p0->begin ||
181       !p1->begin ||
182       !p0->end ||
183       !p1->end)
184      return false;
185
186   /* The prim mode must match (ex: both GL_TRIANGLES) */
187   if (p0->mode != p1->mode)
188      return false;
189
190   /* p1's vertices must come right after p0 */
191   if (p0->start + p0->count != p1->start)
192      return false;
193
194   if (p0->basevertex != p1->basevertex ||
195       p0->num_instances != p1->num_instances ||
196       p0->base_instance != p1->base_instance)
197      return false;
198
199   /* can always merge subsequent GL_POINTS primitives */
200   if (p0->mode == GL_POINTS)
201      return true;
202
203   /* independent lines with no extra vertices */
204   if (p0->mode == GL_LINES && p0->count % 2 == 0 && p1->count % 2 == 0)
205      return true;
206
207   /* independent tris */
208   if (p0->mode == GL_TRIANGLES && p0->count % 3 == 0 && p1->count % 3 == 0)
209      return true;
210
211   /* independent quads */
212   if (p0->mode == GL_QUADS && p0->count % 4 == 0 && p1->count % 4 == 0)
213      return true;
214
215   return false;
216}
217
218
219/**
220 * If we've determined that p0 and p1 can be merged, this function
221 * concatenates p1 onto p0.
222 */
223void
224vbo_merge_prims(struct _mesa_prim *p0, const struct _mesa_prim *p1)
225{
226   assert(vbo_can_merge_prims(p0, p1));
227
228   p0->count += p1->count;
229   p0->end = p1->end;
230}
231