1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
|
/*
* mesa 3-D graphics library
* Version: 6.5
*
* Copyright (C) 1999-2006 Brian Paul All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
* AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
/**
* \file vbo_context.h
* \brief VBO builder module datatypes and definitions.
* \author Keith Whitwell
*/
/**
* \mainpage The VBO builder module
*
* This module hooks into the GL dispatch table and catches all vertex
* building and drawing commands, such as glVertex3f, glBegin and
* glDrawArrays. The module stores all incoming vertex data as arrays
* in GL vertex buffer objects (VBOs), and translates all drawing
* commands into calls to a driver supplied DrawPrimitives() callback.
*
* The module captures both immediate mode and display list drawing,
* and manages the allocation, reference counting and deallocation of
* vertex buffer objects itself.
*
* The DrawPrimitives() callback can be either implemented by the
* driver itself or hooked to the tnl module's _tnl_draw_primitives()
* function for hardware without tnl capablilties or during fallbacks.
*/
#ifndef _VBO_CONTEXT_H
#define _VBO_CONTEXT_H
#include "main/mfeatures.h"
#include "vbo.h"
#include "vbo_attrib.h"
#include "vbo_exec.h"
#include "vbo_save.h"
/** Used to signal when transitioning from one kind of drawing method
* to another.
*/
enum draw_method
{
DRAW_NONE, /**< Initial value only */
DRAW_BEGIN_END,
DRAW_DISPLAY_LIST,
DRAW_ARRAYS
};
struct vbo_context {
struct gl_client_array currval[VBO_ATTRIB_MAX];
/** Map VERT_ATTRIB_x to VBO_ATTRIB_y */
GLuint map_vp_none[VERT_ATTRIB_MAX];
GLuint map_vp_arb[VERT_ATTRIB_MAX];
struct vbo_exec_context exec;
#if FEATURE_dlist
struct vbo_save_context save;
#endif
/* Callback into the driver. This must always succeed, the driver
* is responsible for initiating any fallback actions required:
*/
vbo_draw_func draw_prims;
enum draw_method last_draw_method;
};
static inline struct vbo_context *vbo_context(struct gl_context *ctx)
{
return (struct vbo_context *)(ctx->swtnl_im);
}
/**
* Return VP_x token to indicate whether we're running fixed-function
* vertex transformation, an NV vertex program or ARB vertex program/shader.
*/
static inline enum vp_mode
get_program_mode( struct gl_context *ctx )
{
if (!ctx->VertexProgram._Current)
return VP_NONE;
else if (ctx->VertexProgram._Current == ctx->VertexProgram._TnlProgram)
return VP_NONE;
else if (ctx->VertexProgram._Current->IsNVProgram)
return VP_NV;
else
return VP_ARB;
}
/**
* This is called by glBegin, glDrawArrays and glDrawElements (and
* variations of those calls). When we transition from immediate mode
* drawing to array drawing we need to invalidate the array state.
*
* glBegin/End builds vertex arrays. Those arrays may look identical
* to glDrawArrays arrays except that the position of the elements may
* be different. For example, arrays of (position3v, normal3f) vs. arrays
* of (normal3f, position3f). So we need to make sure we notify drivers
* that arrays may be changing.
*/
static inline void
vbo_draw_method(struct vbo_context *vbo, enum draw_method method)
{
if (vbo->last_draw_method != method) {
struct gl_context *ctx = vbo->exec.ctx;
switch (method) {
case DRAW_ARRAYS:
ctx->Array._DrawArrays = vbo->exec.array.inputs;
break;
case DRAW_BEGIN_END:
ctx->Array._DrawArrays = vbo->exec.vtx.inputs;
break;
case DRAW_DISPLAY_LIST:
ctx->Array._DrawArrays = vbo->save.inputs;
break;
default:
ASSERT(0);
}
ctx->NewDriverState |= ctx->DriverFlags.NewArray;
vbo->last_draw_method = method;
}
}
#endif
|
