#define VBO_PRIVATE_H
-#include "vbo/vbo_context.h"
#include "vbo/vbo_attrib.h"
#include "vbo/vbo_exec.h"
#include "vbo/vbo_save.h"
-#include "main/mtypes.h"
+#include "main/varray.h"
struct _glapi_table;
struct vbo_context {
- struct gl_vertex_array currval[VBO_ATTRIB_MAX];
+ struct gl_vertex_buffer_binding binding;
+ struct gl_array_attributes current[VBO_ATTRIB_MAX];
- /** Map VERT_ATTRIB_x to VBO_ATTRIB_y */
- GLubyte map_vp_none[VERT_ATTRIB_MAX];
- GLubyte map_vp_arb[VERT_ATTRIB_MAX];
+ struct gl_vertex_array_object *VAO;
struct vbo_exec_context exec;
struct vbo_save_context save;
-
- /* Callback into the driver. This must always succeed, the driver
- * is responsible for initiating any fallback actions required:
- */
- vbo_draw_func draw_prims;
-
- /* Optional callback for indirect draws. This allows multidraws to not be
- * broken up, as well as for the actual count to be passed in as a separate
- * indirect parameter.
- */
- vbo_indirect_draw_func draw_indirect_prims;
};
}
-/**
- * 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 )
+static inline const struct vbo_context *
+vbo_context_const(const struct gl_context *ctx)
{
- if (!ctx->VertexProgram._Current)
- return VP_NONE;
- else if (ctx->VertexProgram._Current == ctx->VertexProgram._TnlProgram)
- return VP_NONE;
- else
- return VP_ARB;
+ return ctx->vbo_context;
}
/**
- * 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.
+ * Array to apply the fixed function material aliasing map to
+ * an attribute value used in vbo processing inputs to an attribute
+ * as they appear in the vao.
*/
-static inline void
-vbo_draw_method(struct vbo_context *vbo, gl_draw_method method)
-{
- struct gl_context *ctx = vbo->exec.ctx;
-
- if (ctx->Array.DrawMethod != method) {
- 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:
- unreachable("Bad VBO drawing method");
- }
-
- ctx->NewDriverState |= ctx->DriverFlags.NewArray;
- ctx->Array.DrawMethod = method;
- }
-}
+extern const GLubyte
+_vbo_attribute_alias_map[VP_MODE_MAX][VERT_ATTRIB_MAX];
/**
case GL_FLOAT:
case GL_INT:
case GL_UNSIGNED_INT:
- case GL_UNSIGNED_INT64_ARB:
return GL_FALSE;
+ case GL_UNSIGNED_INT64_ARB:
case GL_DOUBLE:
return GL_TRUE;
default:
}
+static inline void
+vbo_set_vertex_format(struct gl_vertex_format* vertex_format,
+ GLubyte size, GLenum16 type)
+{
+ _mesa_set_vertex_format(vertex_format, size, type, GL_RGBA, GL_FALSE,
+ vbo_attrtype_to_integer_flag(type),
+ vbo_attrtype_to_double_flag(type));
+}
+
+
/**
* Return default component values for the given format.
* The return type is an array of fi_types, because that's how we declare
{
static const GLfloat default_float[4] = { 0, 0, 0, 1 };
static const GLint default_int[4] = { 0, 0, 0, 1 };
+ static const GLdouble default_double[4] = { 0, 0, 0, 1 };
+ static const uint64_t default_uint64[4] = { 0, 0, 0, 1 };
switch (format) {
case GL_FLOAT:
case GL_INT:
case GL_UNSIGNED_INT:
return (fi_type *)default_int;
+ case GL_DOUBLE:
+ return (fi_type *)default_double;
+ case GL_UNSIGNED_INT64_ARB:
+ return (fi_type *)default_uint64;
default:
unreachable("Bad vertex format");
return NULL;
vbo_merge_prims(struct _mesa_prim *p0, const struct _mesa_prim *p1);
+/**
+ * Get the filter mask for vbo draws depending on the vertex_processing_mode.
+ */
+static inline GLbitfield
+_vbo_get_vao_filter(gl_vertex_processing_mode vertex_processing_mode)
+{
+ if (vertex_processing_mode == VP_MODE_FF) {
+ /* The materials mapped into the generic arrays */
+ return VERT_BIT_FF_ALL | VERT_BIT_MAT_ALL;
+ } else {
+ return VERT_BIT_ALL;
+ }
+}
+
+
+/**
+ * Translate the bitmask of VBO_ATTRIB_BITs to VERT_ATTRIB_BITS.
+ * Note that position/generic0 attribute aliasing is done
+ * generically in the VAO.
+ */
+static inline GLbitfield
+_vbo_get_vao_enabled_from_vbo(gl_vertex_processing_mode vertex_processing_mode,
+ GLbitfield64 enabled)
+{
+ if (vertex_processing_mode == VP_MODE_FF) {
+ /* The materials mapped into the generic arrays */
+ return (((GLbitfield)enabled) & VERT_BIT_FF_ALL)
+ | (((GLbitfield)(enabled >> VBO_MATERIAL_SHIFT)) & VERT_BIT_MAT_ALL);
+ } else {
+ return ((GLbitfield)enabled) & VERT_BIT_ALL;
+ }
+}
+
+
+/**
+ * Set the vertex attrib for vbo draw use.
+ */
+static inline void
+_vbo_set_attrib_format(struct gl_context *ctx,
+ struct gl_vertex_array_object *vao,
+ gl_vert_attrib attr, GLintptr buffer_offset,
+ GLubyte size, GLenum16 type, GLuint offset)
+{
+ const GLboolean integer = vbo_attrtype_to_integer_flag(type);
+ const GLboolean doubles = vbo_attrtype_to_double_flag(type);
+
+ if (doubles)
+ size /= 2;
+ _mesa_update_array_format(ctx, vao, attr, size, type, GL_RGBA,
+ GL_FALSE, integer, doubles, offset);
+ /* Ptr for userspace arrays.
+ * For updating the pointer we would need to add the vao->NewArrays flag
+ * to the VAO. But but that is done already unconditionally in
+ * _mesa_update_array_format called above.
+ */
+ assert((vao->NewArrays | ~vao->Enabled) & VERT_BIT(attr));
+ vao->VertexAttrib[attr].Ptr = ADD_POINTERS(buffer_offset, offset);
+}
+
+
#endif /* VBO_PRIVATE_H */
projects / mesa.git / blobdiff