The following individuals and groups are to be acknowledged for their
diff --git a/mesalib/docs/vmware-guest.html b/mesalib/docs/vmware-guest.html
index 833f06ceb..b5ea4e0be 100644
--- a/mesalib/docs/vmware-guest.html
+++ b/mesalib/docs/vmware-guest.html
@@ -27,9 +27,10 @@ MacOS are all supported.
-End users shouldn't have to go through all these steps once the driver is
-included in newer Linux distributions.
-Fedora 18 and Ubuntu 12.10 include the VMware guest GL driver, for example.
+Most modern Linux distros include the SVGA3D driver so end users shouldn't
+be concerned with this information.
+But if your distro lacks the driver or you want to update to the latest code
+these instructions explain what to do.
Mesa/gallium OpenGL driver: "svga"
+
+All of these components reside in the guest Linux virtual machine.
+On the host, all you're doing is running VMware
+Workstation or
+Fusion.
+
+
Prerequisites
diff --git a/mesalib/docs/xlibdriver.html b/mesalib/docs/xlibdriver.html
index ce1ff3b13..d3d8ab4db 100644
--- a/mesalib/docs/xlibdriver.html
+++ b/mesalib/docs/xlibdriver.html
@@ -107,7 +107,7 @@ for your application.
When using Mesa directly or with GLX, it's up to the application
writer to create a window with an appropriate colormap. The GLUT
-toolkit tris to minimize colormap flashing by sharing
+toolkit tries to minimize colormap flashing by sharing
colormaps when possible. Specifically, if the visual and depth of the
window matches that of the root window, the root window's colormap
will be shared by the Mesa window. Otherwise, a new, private colormap
diff --git a/mesalib/include/GL/glxext.h b/mesalib/include/GL/glxext.h
index cfabe8cc3..713238519 100644
--- a/mesalib/include/GL/glxext.h
+++ b/mesalib/include/GL/glxext.h
@@ -272,7 +272,6 @@ __GLXextFuncPtr glXGetProcAddressARB (const GLubyte *procName);
#ifndef GLX_EXT_import_context
#define GLX_EXT_import_context 1
-typedef XID GLXContextID;
#define GLX_SHARE_CONTEXT_EXT 0x800A
#define GLX_VISUAL_ID_EXT 0x800B
#define GLX_SCREEN_EXT 0x800C
diff --git a/mesalib/src/SConscript b/mesalib/src/SConscript
index 146591866..a24aceaea 100644
--- a/mesalib/src/SConscript
+++ b/mesalib/src/SConscript
@@ -18,6 +18,11 @@ if env['hostonly']:
# enable OpenGL ES support.
SConscript('mapi/glapi/gen/SConscript')
SConscript('mapi/glapi/SConscript')
+
+# Haiku C++ libGL dispatch (renderers depend on libgl)
+if env['platform'] in ['haiku']:
+ SConscript('hgl/SConscript')
+
SConscript('mesa/SConscript')
SConscript('mapi/vgapi/SConscript')
diff --git a/mesalib/src/gallium/SConscript b/mesalib/src/gallium/SConscript
index 6e27be2c0..32bbdbe56 100644
--- a/mesalib/src/gallium/SConscript
+++ b/mesalib/src/gallium/SConscript
@@ -119,7 +119,6 @@ if not env['embedded']:
if env['platform'] == 'haiku':
SConscript([
'targets/haiku-softpipe/SConscript',
- 'targets/libgl-haiku/SConscript',
])
if env['dri']:
diff --git a/mesalib/src/glsl/ast_to_hir.cpp b/mesalib/src/glsl/ast_to_hir.cpp
index 91810f985..ef8e699e0 100644
--- a/mesalib/src/glsl/ast_to_hir.cpp
+++ b/mesalib/src/glsl/ast_to_hir.cpp
@@ -1860,7 +1860,7 @@ ast_fully_specified_type::glsl_type(const char **name,
if (type->base_type == GLSL_TYPE_FLOAT
&& state->es_shader
- && state->target == MESA_SHADER_FRAGMENT
+ && state->stage == MESA_SHADER_FRAGMENT
&& this->qualifier.precision == ast_precision_none
&& state->symbols->get_variable("#default precision") == NULL) {
YYLTYPE loc = this->get_location();
@@ -1882,7 +1882,7 @@ ast_fully_specified_type::glsl_type(const char **name,
* this function will produce undefined results.
*/
static bool
-is_varying_var(ir_variable *var, gl_shader_type target)
+is_varying_var(ir_variable *var, gl_shader_stage target)
{
switch (target) {
case MESA_SHADER_VERTEX:
@@ -1983,18 +1983,7 @@ validate_binding_qualifier(struct _mesa_glsl_parse_state *state,
* with an array of size N, all elements of the array from binding
* through binding + N - 1 must be within this range."
*/
- unsigned limit = 0;
- switch (state->target) {
- case MESA_SHADER_VERTEX:
- limit = ctx->Const.VertexProgram.MaxTextureImageUnits;
- break;
- case MESA_SHADER_GEOMETRY:
- limit = ctx->Const.GeometryProgram.MaxTextureImageUnits;
- break;
- case MESA_SHADER_FRAGMENT:
- limit = ctx->Const.FragmentProgram.MaxTextureImageUnits;
- break;
- }
+ unsigned limit = ctx->Const.Program[state->stage].MaxTextureImageUnits;
if (max_index >= limit) {
_mesa_glsl_error(loc, state, "layout(binding = %d) for %d samplers "
@@ -2049,8 +2038,8 @@ interpret_interpolation_qualifier(const struct ast_type_qualifier *qual,
}
- if ((state->target == MESA_SHADER_VERTEX && mode == ir_var_shader_in) ||
- (state->target == MESA_SHADER_FRAGMENT && mode == ir_var_shader_out)) {
+ if ((state->stage == MESA_SHADER_VERTEX && mode == ir_var_shader_in) ||
+ (state->stage == MESA_SHADER_FRAGMENT && mode == ir_var_shader_out)) {
_mesa_glsl_error(loc, state,
"interpolation qualifier `%s' cannot be applied to "
"vertex shader inputs or fragment shader outputs",
@@ -2076,7 +2065,7 @@ validate_explicit_location(const struct ast_type_qualifier *qual,
* In the fragment shader only shader outputs can be given explicit
* locations.
*/
- switch (state->target) {
+ switch (state->stage) {
case MESA_SHADER_VERTEX:
if (var->data.mode == ir_var_shader_in) {
if (!state->check_explicit_attrib_location_allowed(loc, var))
@@ -2110,7 +2099,7 @@ validate_explicit_location(const struct ast_type_qualifier *qual,
_mesa_glsl_error(loc, state,
"%s cannot be given an explicit location in %s shader",
mode_string(var),
- _mesa_shader_type_to_string(state->target));
+ _mesa_shader_stage_to_string(state->stage));
} else {
var->data.explicit_location = true;
@@ -2122,7 +2111,7 @@ validate_explicit_location(const struct ast_type_qualifier *qual,
* ensures that negative values stay negative.
*/
if (qual->location >= 0) {
- var->data.location = (state->target == MESA_SHADER_VERTEX)
+ var->data.location = (state->stage == MESA_SHADER_VERTEX)
? (qual->location + VERT_ATTRIB_GENERIC0)
: (qual->location + FRAG_RESULT_DATA0);
} else {
@@ -2174,7 +2163,7 @@ apply_type_qualifier_to_variable(const struct ast_type_qualifier *qual,
if (qual->flags.q.constant || qual->flags.q.attribute
|| qual->flags.q.uniform
- || (qual->flags.q.varying && (state->target == MESA_SHADER_FRAGMENT)))
+ || (qual->flags.q.varying && (state->stage == MESA_SHADER_FRAGMENT)))
var->data.read_only = 1;
if (qual->flags.q.centroid)
@@ -2183,12 +2172,12 @@ apply_type_qualifier_to_variable(const struct ast_type_qualifier *qual,
if (qual->flags.q.sample)
var->data.sample = 1;
- if (qual->flags.q.attribute && state->target != MESA_SHADER_VERTEX) {
+ if (qual->flags.q.attribute && state->stage != MESA_SHADER_VERTEX) {
var->type = glsl_type::error_type;
_mesa_glsl_error(loc, state,
"`attribute' variables may not be declared in the "
"%s shader",
- _mesa_shader_type_to_string(state->target));
+ _mesa_shader_stage_to_string(state->stage));
}
/* Section 6.1.1 (Function Calling Conventions) of the GLSL 1.10 spec says:
@@ -2214,16 +2203,16 @@ apply_type_qualifier_to_variable(const struct ast_type_qualifier *qual,
else if (qual->flags.q.in)
var->data.mode = is_parameter ? ir_var_function_in : ir_var_shader_in;
else if (qual->flags.q.attribute
- || (qual->flags.q.varying && (state->target == MESA_SHADER_FRAGMENT)))
+ || (qual->flags.q.varying && (state->stage == MESA_SHADER_FRAGMENT)))
var->data.mode = ir_var_shader_in;
else if (qual->flags.q.out)
var->data.mode = is_parameter ? ir_var_function_out : ir_var_shader_out;
- else if (qual->flags.q.varying && (state->target == MESA_SHADER_VERTEX))
+ else if (qual->flags.q.varying && (state->stage == MESA_SHADER_VERTEX))
var->data.mode = ir_var_shader_out;
else if (qual->flags.q.uniform)
var->data.mode = ir_var_uniform;
- if (!is_parameter && is_varying_var(var, state->target)) {
+ if (!is_parameter && is_varying_var(var, state->stage)) {
/* This variable is being used to link data between shader stages (in
* pre-glsl-1.30 parlance, it's a "varying"). Check that it has a type
* that is allowed for such purposes.
@@ -2272,7 +2261,7 @@ apply_type_qualifier_to_variable(const struct ast_type_qualifier *qual,
}
if (state->all_invariant && (state->current_function == NULL)) {
- switch (state->target) {
+ switch (state->stage) {
case MESA_SHADER_VERTEX:
if (var->data.mode == ir_var_shader_out)
var->data.invariant = true;
@@ -2599,8 +2588,8 @@ process_initializer(ir_variable *var, ast_declaration *decl,
if ((var->data.mode == ir_var_shader_in) && (state->current_function == NULL)) {
_mesa_glsl_error(& initializer_loc, state,
"cannot initialize %s shader input / %s",
- _mesa_shader_type_to_string(state->target),
- (state->target == MESA_SHADER_VERTEX)
+ _mesa_shader_stage_to_string(state->stage),
+ (state->stage == MESA_SHADER_VERTEX)
? "attribute" : "varying");
}
@@ -2844,12 +2833,12 @@ ast_declarator_list::hir(exec_list *instructions,
_mesa_glsl_error(& loc, state,
"undeclared variable `%s' cannot be marked "
"invariant", decl->identifier);
- } else if ((state->target == MESA_SHADER_VERTEX)
+ } else if ((state->stage == MESA_SHADER_VERTEX)
&& (earlier->data.mode != ir_var_shader_out)) {
_mesa_glsl_error(& loc, state,
"`%s' cannot be marked invariant, vertex shader "
"outputs only", decl->identifier);
- } else if ((state->target == MESA_SHADER_FRAGMENT)
+ } else if ((state->stage == MESA_SHADER_FRAGMENT)
&& (earlier->data.mode != ir_var_shader_in)) {
_mesa_glsl_error(& loc, state,
"`%s' cannot be marked invariant, fragment shader "
@@ -3034,12 +3023,12 @@ ast_declarator_list::hir(exec_list *instructions,
& loc, false);
if (this->type->qualifier.flags.q.invariant) {
- if ((state->target == MESA_SHADER_VERTEX) &&
+ if ((state->stage == MESA_SHADER_VERTEX) &&
var->data.mode != ir_var_shader_out) {
_mesa_glsl_error(& loc, state,
"`%s' cannot be marked invariant, vertex shader "
"outputs only", var->name);
- } else if ((state->target == MESA_SHADER_FRAGMENT) &&
+ } else if ((state->stage == MESA_SHADER_FRAGMENT) &&
var->data.mode != ir_var_shader_in) {
/* FINISHME: Note that this doesn't work for invariant on
* a function signature inval
@@ -3080,7 +3069,7 @@ ast_declarator_list::hir(exec_list *instructions,
} else if (var->data.mode == ir_var_shader_in) {
var->data.read_only = true;
- if (state->target == MESA_SHADER_VERTEX) {
+ if (state->stage == MESA_SHADER_VERTEX) {
bool error_emitted = false;
/* From page 31 (page 37 of the PDF) of the GLSL 1.50 spec:
@@ -3135,7 +3124,7 @@ ast_declarator_list::hir(exec_list *instructions,
"cannot have array type")) {
error_emitted = true;
}
- } else if (state->target == MESA_SHADER_GEOMETRY) {
+ } else if (state->stage == MESA_SHADER_GEOMETRY) {
/* From section 4.3.4 (Inputs) of the GLSL 1.50 spec:
*
* Geometry shader input variables get the per-vertex values
@@ -3185,10 +3174,10 @@ ast_declarator_list::hir(exec_list *instructions,
if (state->is_version(130, 300) &&
var->type->contains_integer() &&
var->data.interpolation != INTERP_QUALIFIER_FLAT &&
- ((state->target == MESA_SHADER_FRAGMENT && var->data.mode == ir_var_shader_in)
- || (state->target == MESA_SHADER_VERTEX && var->data.mode == ir_var_shader_out
+ ((state->stage == MESA_SHADER_FRAGMENT && var->data.mode == ir_var_shader_in)
+ || (state->stage == MESA_SHADER_VERTEX && var->data.mode == ir_var_shader_out
&& state->es_shader))) {
- const char *var_type = (state->target == MESA_SHADER_VERTEX) ?
+ const char *var_type = (state->stage == MESA_SHADER_VERTEX) ?
"vertex output" : "fragment input";
_mesa_glsl_error(&loc, state, "if a %s is (or contains) "
"an integer, then it must be qualified with 'flat'",
@@ -3244,7 +3233,7 @@ ast_declarator_list::hir(exec_list *instructions,
const char *i = this->type->qualifier.interpolation_string();
assert(i != NULL);
- switch (state->target) {
+ switch (state->stage) {
case MESA_SHADER_VERTEX:
if (this->type->qualifier.flags.q.in) {
_mesa_glsl_error(&loc, state,
@@ -3275,13 +3264,13 @@ ast_declarator_list::hir(exec_list *instructions,
if (state->is_version(130, 300)
&& this->type->qualifier.flags.q.centroid
&& this->type->qualifier.flags.q.in
- && state->target == MESA_SHADER_VERTEX) {
+ && state->stage == MESA_SHADER_VERTEX) {
_mesa_glsl_error(&loc, state,
"'centroid in' cannot be used in a vertex shader");
}
- if (state->target == MESA_SHADER_VERTEX
+ if (state->stage == MESA_SHADER_VERTEX
&& this->type->qualifier.flags.q.sample
&& this->type->qualifier.flags.q.in) {
@@ -3296,7 +3285,7 @@ ast_declarator_list::hir(exec_list *instructions,
* "It is an error to use auxiliary storage qualifiers or interpolation
* qualifiers on an output in a fragment shader."
*/
- if (state->target == MESA_SHADER_FRAGMENT &&
+ if (state->stage == MESA_SHADER_FRAGMENT &&
this->type->qualifier.flags.q.out &&
this->type->qualifier.has_auxiliary_storage()) {
_mesa_glsl_error(&loc, state,
@@ -3954,7 +3943,7 @@ ast_jump_statement::hir(exec_list *instructions,
}
case ast_discard:
- if (state->target != MESA_SHADER_FRAGMENT) {
+ if (state->stage != MESA_SHADER_FRAGMENT) {
YYLTYPE loc = this->get_location();
_mesa_glsl_error(& loc, state,
@@ -4492,7 +4481,7 @@ ast_type_specifier::hir(exec_list *instructions,
if (type->base_type == GLSL_TYPE_FLOAT
&& state->es_shader
- && state->target == MESA_SHADER_FRAGMENT) {
+ && state->stage == MESA_SHADER_FRAGMENT) {
/* Section 4.5.3 (Default Precision Qualifiers) of the GLSL ES 1.00
* spec says:
*
@@ -4890,7 +4879,7 @@ ast_interface_block::hir(exec_list *instructions,
_mesa_glsl_error(&loc, state,
"redeclaration of gl_PerVertex input not allowed "
"in the %s shader",
- _mesa_shader_type_to_string(state->target));
+ _mesa_shader_stage_to_string(state->stage));
}
if (this->instance_name == NULL ||
strcmp(this->instance_name, "gl_in") != 0 || !this->is_array) {
@@ -4907,7 +4896,7 @@ ast_interface_block::hir(exec_list *instructions,
_mesa_glsl_error(&loc, state,
"redeclaration of gl_PerVertex output not "
"allowed in the %s shader",
- _mesa_shader_type_to_string(state->target));
+ _mesa_shader_stage_to_string(state->stage));
}
if (this->instance_name != NULL) {
_mesa_glsl_error(&loc, state,
@@ -4995,7 +4984,7 @@ ast_interface_block::hir(exec_list *instructions,
* variable (or input block, see interface blocks below) needs to be
* declared as an array.
*/
- if (state->target == MESA_SHADER_GEOMETRY && !this->is_array &&
+ if (state->stage == MESA_SHADER_GEOMETRY && !this->is_array &&
var_mode == ir_var_shader_in) {
_mesa_glsl_error(&loc, state, "geometry shader inputs must be arrays");
}
@@ -5050,7 +5039,7 @@ ast_interface_block::hir(exec_list *instructions,
* geometry shader input.
*/
if (this->array_size == NULL &&
- (state->target != MESA_SHADER_GEOMETRY || !this->layout.flags.q.in)) {
+ (state->stage != MESA_SHADER_GEOMETRY || !this->layout.flags.q.in)) {
_mesa_glsl_error(&loc, state,
"only geometry shader inputs may be unsized "
"instance block arrays");
@@ -5069,7 +5058,7 @@ ast_interface_block::hir(exec_list *instructions,
var_mode);
}
- if (state->target == MESA_SHADER_GEOMETRY && var_mode == ir_var_shader_in)
+ if (state->stage == MESA_SHADER_GEOMETRY && var_mode == ir_var_shader_in)
handle_geometry_shader_input_decl(state, loc, var);
if (ir_variable *earlier =
@@ -5265,7 +5254,7 @@ detect_conflicting_assignments(struct _mesa_glsl_parse_state *state,
else if (strcmp(var->name, "gl_FragData") == 0)
gl_FragData_assigned = true;
else if (strncmp(var->name, "gl_", 3) != 0) {
- if (state->target == MESA_SHADER_FRAGMENT &&
+ if (state->stage == MESA_SHADER_FRAGMENT &&
var->data.mode == ir_var_shader_out) {
user_defined_fs_output_assigned = true;
user_defined_fs_output = var;
diff --git a/mesalib/src/glsl/builtin_functions.cpp b/mesalib/src/glsl/builtin_functions.cpp
index 840a6c9a2..038e47363 100644
--- a/mesalib/src/glsl/builtin_functions.cpp
+++ b/mesalib/src/glsl/builtin_functions.cpp
@@ -77,7 +77,7 @@ always_available(const _mesa_glsl_parse_state *state)
static bool
compatibility_vs_only(const _mesa_glsl_parse_state *state)
{
- return state->target == MESA_SHADER_VERTEX &&
+ return state->stage == MESA_SHADER_VERTEX &&
state->language_version <= 130 &&
!state->es_shader;
}
@@ -85,13 +85,13 @@ compatibility_vs_only(const _mesa_glsl_parse_state *state)
static bool
fs_only(const _mesa_glsl_parse_state *state)
{
- return state->target == MESA_SHADER_FRAGMENT;
+ return state->stage == MESA_SHADER_FRAGMENT;
}
static bool
gs_only(const _mesa_glsl_parse_state *state)
{
- return state->target == MESA_SHADER_GEOMETRY;
+ return state->stage == MESA_SHADER_GEOMETRY;
}
static bool
@@ -103,7 +103,7 @@ v110(const _mesa_glsl_parse_state *state)
static bool
v110_fs_only(const _mesa_glsl_parse_state *state)
{
- return !state->es_shader && state->target == MESA_SHADER_FRAGMENT;
+ return !state->es_shader && state->stage == MESA_SHADER_FRAGMENT;
}
static bool
@@ -122,7 +122,7 @@ static bool
v130_fs_only(const _mesa_glsl_parse_state *state)
{
return state->is_version(130, 300) &&
- state->target == MESA_SHADER_FRAGMENT;
+ state->stage == MESA_SHADER_FRAGMENT;
}
static bool
@@ -155,7 +155,7 @@ lod_exists_in_stage(const _mesa_glsl_parse_state *state)
* Since ARB_shader_texture_lod can only be enabled on desktop GLSL, we
* don't need to explicitly check state->es_shader.
*/
- return state->target == MESA_SHADER_VERTEX ||
+ return state->stage == MESA_SHADER_VERTEX ||
state->is_version(130, 300) ||
state->ARB_shader_texture_lod_enable;
}
@@ -223,7 +223,7 @@ texture_array_lod(const _mesa_glsl_parse_state *state)
static bool
fs_texture_array(const _mesa_glsl_parse_state *state)
{
- return state->target == MESA_SHADER_FRAGMENT &&
+ return state->stage == MESA_SHADER_FRAGMENT &&
state->EXT_texture_array_enable;
}
@@ -243,7 +243,7 @@ texture_multisample(const _mesa_glsl_parse_state *state)
static bool
fs_texture_cube_map_array(const _mesa_glsl_parse_state *state)
{
- return state->target == MESA_SHADER_FRAGMENT &&
+ return state->stage == MESA_SHADER_FRAGMENT &&
(state->is_version(400, 0) ||
state->ARB_texture_cube_map_array_enable);
}
@@ -265,7 +265,7 @@ texture_query_levels(const _mesa_glsl_parse_state *state)
static bool
texture_query_lod(const _mesa_glsl_parse_state *state)
{
- return state->target == MESA_SHADER_FRAGMENT &&
+ return state->stage == MESA_SHADER_FRAGMENT &&
state->ARB_texture_query_lod_enable;
}
@@ -292,7 +292,7 @@ texture_gather_only(const _mesa_glsl_parse_state *state)
static bool
fs_oes_derivatives(const _mesa_glsl_parse_state *state)
{
- return state->target == MESA_SHADER_FRAGMENT &&
+ return state->stage == MESA_SHADER_FRAGMENT &&
(state->is_version(110, 300) ||
state->OES_standard_derivatives_enable);
}
@@ -318,7 +318,7 @@ tex3d(const _mesa_glsl_parse_state *state)
static bool
fs_tex3d(const _mesa_glsl_parse_state *state)
{
- return state->target == MESA_SHADER_FRAGMENT &&
+ return state->stage == MESA_SHADER_FRAGMENT &&
(!state->es_shader || state->OES_texture_3D_enable);
}
@@ -334,6 +334,12 @@ shader_atomic_counters(const _mesa_glsl_parse_state *state)
return state->ARB_shader_atomic_counters_enable;
}
+static bool
+shader_trinary_minmax(const _mesa_glsl_parse_state *state)
+{
+ return state->AMD_shader_trinary_minmax_enable;
+}
+
/** @} */
/******************************************************************************/
@@ -570,6 +576,21 @@ private:
ir_function_signature *_atomic_op(const char *intrinsic,
builtin_available_predicate avail);
+ ir_function_signature *_min3(builtin_available_predicate avail,
+ const glsl_type *x_type,
+ const glsl_type *y_type,
+ const glsl_type *z_type);
+
+ ir_function_signature *_max3(builtin_available_predicate avail,
+ const glsl_type *x_type,
+ const glsl_type *y_type,
+ const glsl_type *z_type);
+
+ ir_function_signature *_mid3(builtin_available_predicate avail,
+ const glsl_type *x_type,
+ const glsl_type *y_type,
+ const glsl_type *z_type);
+
#undef B0
#undef B1
#undef B2
@@ -2106,6 +2127,57 @@ builtin_builder::create_builtins()
shader_atomic_counters),
NULL);
+ add_function("min3",
+ _min3(shader_trinary_minmax, glsl_type::float_type, glsl_type::float_type, glsl_type::float_type),
+ _min3(shader_trinary_minmax, glsl_type::vec2_type, glsl_type::vec2_type, glsl_type::vec2_type),
+ _min3(shader_trinary_minmax, glsl_type::vec3_type, glsl_type::vec3_type, glsl_type::vec3_type),
+ _min3(shader_trinary_minmax, glsl_type::vec4_type, glsl_type::vec4_type, glsl_type::vec4_type),
+
+ _min3(shader_trinary_minmax, glsl_type::int_type, glsl_type::int_type, glsl_type::int_type),
+ _min3(shader_trinary_minmax, glsl_type::ivec2_type, glsl_type::ivec2_type, glsl_type::ivec2_type),
+ _min3(shader_trinary_minmax, glsl_type::ivec3_type, glsl_type::ivec3_type, glsl_type::ivec3_type),
+ _min3(shader_trinary_minmax, glsl_type::ivec4_type, glsl_type::ivec4_type, glsl_type::ivec4_type),
+
+ _min3(shader_trinary_minmax, glsl_type::uint_type, glsl_type::uint_type, glsl_type::uint_type),
+ _min3(shader_trinary_minmax, glsl_type::uvec2_type, glsl_type::uvec2_type, glsl_type::uvec2_type),
+ _min3(shader_trinary_minmax, glsl_type::uvec3_type, glsl_type::uvec3_type, glsl_type::uvec3_type),
+ _min3(shader_trinary_minmax, glsl_type::uvec4_type, glsl_type::uvec4_type, glsl_type::uvec4_type),
+ NULL);
+
+ add_function("max3",
+ _max3(shader_trinary_minmax, glsl_type::float_type, glsl_type::float_type, glsl_type::float_type),
+ _max3(shader_trinary_minmax, glsl_type::vec2_type, glsl_type::vec2_type, glsl_type::vec2_type),
+ _max3(shader_trinary_minmax, glsl_type::vec3_type, glsl_type::vec3_type, glsl_type::vec3_type),
+ _max3(shader_trinary_minmax, glsl_type::vec4_type, glsl_type::vec4_type, glsl_type::vec4_type),
+
+ _max3(shader_trinary_minmax, glsl_type::int_type, glsl_type::int_type, glsl_type::int_type),
+ _max3(shader_trinary_minmax, glsl_type::ivec2_type, glsl_type::ivec2_type, glsl_type::ivec2_type),
+ _max3(shader_trinary_minmax, glsl_type::ivec3_type, glsl_type::ivec3_type, glsl_type::ivec3_type),
+ _max3(shader_trinary_minmax, glsl_type::ivec4_type, glsl_type::ivec4_type, glsl_type::ivec4_type),
+
+ _max3(shader_trinary_minmax, glsl_type::uint_type, glsl_type::uint_type, glsl_type::uint_type),
+ _max3(shader_trinary_minmax, glsl_type::uvec2_type, glsl_type::uvec2_type, glsl_type::uvec2_type),
+ _max3(shader_trinary_minmax, glsl_type::uvec3_type, glsl_type::uvec3_type, glsl_type::uvec3_type),
+ _max3(shader_trinary_minmax, glsl_type::uvec4_type, glsl_type::uvec4_type, glsl_type::uvec4_type),
+ NULL);
+
+ add_function("mid3",
+ _mid3(shader_trinary_minmax, glsl_type::float_type, glsl_type::float_type, glsl_type::float_type),
+ _mid3(shader_trinary_minmax, glsl_type::vec2_type, glsl_type::vec2_type, glsl_type::vec2_type),
+ _mid3(shader_trinary_minmax, glsl_type::vec3_type, glsl_type::vec3_type, glsl_type::vec3_type),
+ _mid3(shader_trinary_minmax, glsl_type::vec4_type, glsl_type::vec4_type, glsl_type::vec4_type),
+
+ _mid3(shader_trinary_minmax, glsl_type::int_type, glsl_type::int_type, glsl_type::int_type),
+ _mid3(shader_trinary_minmax, glsl_type::ivec2_type, glsl_type::ivec2_type, glsl_type::ivec2_type),
+ _mid3(shader_trinary_minmax, glsl_type::ivec3_type, glsl_type::ivec3_type, glsl_type::ivec3_type),
+ _mid3(shader_trinary_minmax, glsl_type::ivec4_type, glsl_type::ivec4_type, glsl_type::ivec4_type),
+
+ _mid3(shader_trinary_minmax, glsl_type::uint_type, glsl_type::uint_type, glsl_type::uint_type),
+ _mid3(shader_trinary_minmax, glsl_type::uvec2_type, glsl_type::uvec2_type, glsl_type::uvec2_type),
+ _mid3(shader_trinary_minmax, glsl_type::uvec3_type, glsl_type::uvec3_type, glsl_type::uvec3_type),
+ _mid3(shader_trinary_minmax, glsl_type::uvec4_type, glsl_type::uvec4_type, glsl_type::uvec4_type),
+ NULL);
+
#undef F
#undef FI
#undef FIU
@@ -3864,7 +3936,7 @@ builtin_builder::_fma(const glsl_type *type)
ir_variable *c = in_var(type, "c");
MAKE_SIG(type, gpu_shader5, 3, a, b, c);
- body.emit(ret(fma(a, b, c)));
+ body.emit(ret(ir_builder::fma(a, b, c)));
return sig;
}
@@ -3991,6 +4063,54 @@ builtin_builder::_atomic_op(const char *intrinsic,
return sig;
}
+ir_function_signature *
+builtin_builder::_min3(builtin_available_predicate avail,
+ const glsl_type *x_type, const glsl_type *y_type,
+ const glsl_type *z_type)
+{
+ ir_variable *x = in_var(x_type, "x");
+ ir_variable *y = in_var(y_type, "y");
+ ir_variable *z = in_var(z_type, "z");
+ MAKE_SIG(x_type, avail, 3, x, y, z);
+
+ ir_expression *min3 = min2(x, min2(y,z));
+ body.emit(ret(min3));
+
+ return sig;
+}
+
+ir_function_signature *
+builtin_builder::_max3(builtin_available_predicate avail,
+ const glsl_type *x_type, const glsl_type *y_type,
+ const glsl_type *z_type)
+{
+ ir_variable *x = in_var(x_type, "x");
+ ir_variable *y = in_var(y_type, "y");
+ ir_variable *z = in_var(z_type, "z");
+ MAKE_SIG(x_type, avail, 3, x, y, z);
+
+ ir_expression *max3 = max2(x, max2(y,z));
+ body.emit(ret(max3));
+
+ return sig;
+}
+
+ir_function_signature *
+builtin_builder::_mid3(builtin_available_predicate avail,
+ const glsl_type *x_type, const glsl_type *y_type,
+ const glsl_type *z_type)
+{
+ ir_variable *x = in_var(x_type, "x");
+ ir_variable *y = in_var(y_type, "y");
+ ir_variable *z = in_var(z_type, "z");
+ MAKE_SIG(x_type, avail, 3, x, y, z);
+
+ ir_expression *mid3 = max2(min2(x, y), max2(min2(x, z), min2(y, z)));
+ body.emit(ret(mid3));
+
+ return sig;
+}
+
/** @} */
/******************************************************************************/
diff --git a/mesalib/src/glsl/builtin_variables.cpp b/mesalib/src/glsl/builtin_variables.cpp
index ff9acb8d0..f630923ed 100644
--- a/mesalib/src/glsl/builtin_variables.cpp
+++ b/mesalib/src/glsl/builtin_variables.cpp
@@ -554,9 +554,9 @@ builtin_variable_generator::generate_constants()
*/
if (state->is_version(0, 300)) {
add_const("gl_MaxVertexOutputVectors",
- state->ctx->Const.VertexProgram.MaxOutputComponents / 4);
+ state->ctx->Const.Program[MESA_SHADER_VERTEX].MaxOutputComponents / 4);
add_const("gl_MaxFragmentInputVectors",
- state->ctx->Const.FragmentProgram.MaxInputComponents / 4);
+ state->ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxInputComponents / 4);
} else {
add_const("gl_MaxVaryingVectors",
state->ctx->Const.MaxVarying);
@@ -876,7 +876,7 @@ builtin_variable_generator::add_varying(int slot, const glsl_type *type,
const char *name,
const char *name_as_gs_input)
{
- switch (state->target) {
+ switch (state->stage) {
case MESA_SHADER_GEOMETRY:
this->per_vertex_in.add_field(slot, type, name);
/* FALLTHROUGH */
@@ -901,7 +901,7 @@ builtin_variable_generator::generate_varyings()
add_varying(loc, type, name, name "In")
/* gl_Position and gl_PointSize are not visible from fragment shaders. */
- if (state->target != MESA_SHADER_FRAGMENT) {
+ if (state->stage != MESA_SHADER_FRAGMENT) {
ADD_VARYING(VARYING_SLOT_POS, vec4_t, "gl_Position");
ADD_VARYING(VARYING_SLOT_PSIZ, float_t, "gl_PointSize");
}
@@ -914,7 +914,7 @@ builtin_variable_generator::generate_varyings()
if (compatibility) {
ADD_VARYING(VARYING_SLOT_TEX0, array(vec4_t, 0), "gl_TexCoord");
ADD_VARYING(VARYING_SLOT_FOGC, float_t, "gl_FogFragCoord");
- if (state->target == MESA_SHADER_FRAGMENT) {
+ if (state->stage == MESA_SHADER_FRAGMENT) {
ADD_VARYING(VARYING_SLOT_COL0, vec4_t, "gl_Color");
ADD_VARYING(VARYING_SLOT_COL1, vec4_t, "gl_SecondaryColor");
} else {
@@ -926,13 +926,13 @@ builtin_variable_generator::generate_varyings()
}
}
- if (state->target == MESA_SHADER_GEOMETRY) {
+ if (state->stage == MESA_SHADER_GEOMETRY) {
const glsl_type *per_vertex_in_type =
this->per_vertex_in.construct_interface_instance();
add_variable("gl_in", array(per_vertex_in_type, 0),
ir_var_shader_in, -1);
}
- if (state->target == MESA_SHADER_VERTEX || state->target == MESA_SHADER_GEOMETRY) {
+ if (state->stage == MESA_SHADER_VERTEX || state->stage == MESA_SHADER_GEOMETRY) {
const glsl_type *per_vertex_out_type =
this->per_vertex_out.construct_interface_instance();
const glsl_struct_field *fields = per_vertex_out_type->fields.structure;
@@ -963,7 +963,7 @@ _mesa_glsl_initialize_variables(exec_list *instructions,
gen.generate_varyings();
- switch (state->target) {
+ switch (state->stage) {
case MESA_SHADER_VERTEX:
gen.generate_vs_special_vars();
break;
diff --git a/mesalib/src/glsl/glcpp/glcpp-parse.y b/mesalib/src/glsl/glcpp/glcpp-parse.y
index ef084b639..55c498195 100644
--- a/mesalib/src/glsl/glcpp/glcpp-parse.y
+++ b/mesalib/src/glsl/glcpp/glcpp-parse.y
@@ -1281,6 +1281,9 @@ glcpp_parser_create (const struct gl_extensions *extensions, int api)
if (extensions->ARB_shader_atomic_counters)
add_builtin_define(parser, "GL_ARB_shader_atomic_counters", 1);
+
+ if (extensions->AMD_shader_trinary_minmax)
+ add_builtin_define(parser, "GL_AMD_shader_trinary_minmax", 1);
}
}
diff --git a/mesalib/src/glsl/glsl_parser.yy b/mesalib/src/glsl/glsl_parser.yy
index 39767609d..1c56d6f14 100644
--- a/mesalib/src/glsl/glsl_parser.yy
+++ b/mesalib/src/glsl/glsl_parser.yy
@@ -2219,11 +2219,11 @@ basic_interface_block:
* "It is illegal to have an input block in a vertex shader
* or an output block in a fragment shader"
*/
- if ((state->target == MESA_SHADER_VERTEX) && $1.flags.q.in) {
+ if ((state->stage == MESA_SHADER_VERTEX) && $1.flags.q.in) {
_mesa_glsl_error(& @1, state,
"`in' interface block is not allowed for "
"a vertex shader");
- } else if ((state->target == MESA_SHADER_FRAGMENT) && $1.flags.q.out) {
+ } else if ((state->stage == MESA_SHADER_FRAGMENT) && $1.flags.q.out) {
_mesa_glsl_error(& @1, state,
"`out' interface block is not allowed for "
"a fragment shader");
@@ -2377,7 +2377,7 @@ layout_defaults:
{
void *ctx = state;
$$ = NULL;
- if (state->target != MESA_SHADER_GEOMETRY) {
+ if (state->stage != MESA_SHADER_GEOMETRY) {
_mesa_glsl_error(& @1, state,
"input layout qualifiers only valid in "
"geometry shaders");
@@ -2405,7 +2405,7 @@ layout_defaults:
| layout_qualifier OUT_TOK ';'
{
- if (state->target != MESA_SHADER_GEOMETRY) {
+ if (state->stage != MESA_SHADER_GEOMETRY) {
_mesa_glsl_error(& @1, state,
"out layout qualifiers only valid in "
"geometry shaders");
diff --git a/mesalib/src/glsl/glsl_parser_extras.cpp b/mesalib/src/glsl/glsl_parser_extras.cpp
index fc9a8b204..21dc3abd7 100644
--- a/mesalib/src/glsl/glsl_parser_extras.cpp
+++ b/mesalib/src/glsl/glsl_parser_extras.cpp
@@ -54,14 +54,12 @@ static unsigned known_desktop_glsl_versions[] =
_mesa_glsl_parse_state::_mesa_glsl_parse_state(struct gl_context *_ctx,
- GLenum target, void *mem_ctx)
+ gl_shader_stage stage,
+ void *mem_ctx)
: ctx(_ctx), switch_state()
{
- switch (target) {
- case GL_VERTEX_SHADER: this->target = MESA_SHADER_VERTEX; break;
- case GL_FRAGMENT_SHADER: this->target = MESA_SHADER_FRAGMENT; break;
- case GL_GEOMETRY_SHADER: this->target = MESA_SHADER_GEOMETRY; break;
- }
+ assert(stage < MESA_SHADER_STAGES);
+ this->stage = stage;
this->scanner = NULL;
this->translation_unit.make_empty();
@@ -98,30 +96,30 @@ _mesa_glsl_parse_state::_mesa_glsl_parse_state(struct gl_context *_ctx,
this->Const.MaxClipPlanes = ctx->Const.MaxClipPlanes;
this->Const.MaxTextureUnits = ctx->Const.MaxTextureUnits;
this->Const.MaxTextureCoords = ctx->Const.MaxTextureCoordUnits;
- this->Const.MaxVertexAttribs = ctx->Const.VertexProgram.MaxAttribs;
- this->Const.MaxVertexUniformComponents = ctx->Const.VertexProgram.MaxUniformComponents;
- this->Const.MaxVertexTextureImageUnits = ctx->Const.VertexProgram.MaxTextureImageUnits;
+ this->Const.MaxVertexAttribs = ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs;
+ this->Const.MaxVertexUniformComponents = ctx->Const.Program[MESA_SHADER_VERTEX].MaxUniformComponents;
+ this->Const.MaxVertexTextureImageUnits = ctx->Const.Program[MESA_SHADER_VERTEX].MaxTextureImageUnits;
this->Const.MaxCombinedTextureImageUnits = ctx->Const.MaxCombinedTextureImageUnits;
- this->Const.MaxTextureImageUnits = ctx->Const.FragmentProgram.MaxTextureImageUnits;
- this->Const.MaxFragmentUniformComponents = ctx->Const.FragmentProgram.MaxUniformComponents;
+ this->Const.MaxTextureImageUnits = ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits;
+ this->Const.MaxFragmentUniformComponents = ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxUniformComponents;
this->Const.MinProgramTexelOffset = ctx->Const.MinProgramTexelOffset;
this->Const.MaxProgramTexelOffset = ctx->Const.MaxProgramTexelOffset;
this->Const.MaxDrawBuffers = ctx->Const.MaxDrawBuffers;
/* 1.50 constants */
- this->Const.MaxVertexOutputComponents = ctx->Const.VertexProgram.MaxOutputComponents;
- this->Const.MaxGeometryInputComponents = ctx->Const.GeometryProgram.MaxInputComponents;
- this->Const.MaxGeometryOutputComponents = ctx->Const.GeometryProgram.MaxOutputComponents;
- this->Const.MaxFragmentInputComponents = ctx->Const.FragmentProgram.MaxInputComponents;
- this->Const.MaxGeometryTextureImageUnits = ctx->Const.GeometryProgram.MaxTextureImageUnits;
+ this->Const.MaxVertexOutputComponents = ctx->Const.Program[MESA_SHADER_VERTEX].MaxOutputComponents;
+ this->Const.MaxGeometryInputComponents = ctx->Const.Program[MESA_SHADER_GEOMETRY].MaxInputComponents;
+ this->Const.MaxGeometryOutputComponents = ctx->Const.Program[MESA_SHADER_GEOMETRY].MaxOutputComponents;
+ this->Const.MaxFragmentInputComponents = ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxInputComponents;
+ this->Const.MaxGeometryTextureImageUnits = ctx->Const.Program[MESA_SHADER_GEOMETRY].MaxTextureImageUnits;
this->Const.MaxGeometryOutputVertices = ctx->Const.MaxGeometryOutputVertices;
this->Const.MaxGeometryTotalOutputComponents = ctx->Const.MaxGeometryTotalOutputComponents;
- this->Const.MaxGeometryUniformComponents = ctx->Const.GeometryProgram.MaxUniformComponents;
+ this->Const.MaxGeometryUniformComponents = ctx->Const.Program[MESA_SHADER_GEOMETRY].MaxUniformComponents;
- this->Const.MaxVertexAtomicCounters = ctx->Const.VertexProgram.MaxAtomicCounters;
- this->Const.MaxGeometryAtomicCounters = ctx->Const.GeometryProgram.MaxAtomicCounters;
- this->Const.MaxFragmentAtomicCounters = ctx->Const.FragmentProgram.MaxAtomicCounters;
+ this->Const.MaxVertexAtomicCounters = ctx->Const.Program[MESA_SHADER_VERTEX].MaxAtomicCounters;
+ this->Const.MaxGeometryAtomicCounters = ctx->Const.Program[MESA_SHADER_GEOMETRY].MaxAtomicCounters;
+ this->Const.MaxFragmentAtomicCounters = ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxAtomicCounters;
this->Const.MaxCombinedAtomicCounters = ctx->Const.MaxCombinedAtomicCounters;
this->Const.MaxAtomicBufferBindings = ctx->Const.MaxAtomicBufferBindings;
@@ -331,44 +329,15 @@ _mesa_glsl_parse_state::process_version_directive(YYLTYPE *locp, int version,
}
}
-extern "C" {
-
-/**
- * Translate a GLenum to a short shader stage name for debug printouts and
- * error messages.
- *
- * It recognizes the PROGRAM variants of the names so it can be used
- * with a struct gl_program->Target, not just a struct
- * gl_shader->Type.
- */
-const char *
-_mesa_shader_enum_to_string(GLenum type)
-{
- switch (type) {
- case GL_VERTEX_SHADER:
- case GL_VERTEX_PROGRAM_ARB:
- return "vertex";
- case GL_FRAGMENT_SHADER:
- case GL_FRAGMENT_PROGRAM_ARB:
- return "fragment";
- case GL_GEOMETRY_SHADER:
- return "geometry";
- default:
- assert(!"Should not get here.");
- return "unknown";
- }
-}
-
-} /* extern "C" */
/**
- * Translate a gl_shader_type to a short shader stage name for debug printouts
- * and error messages.
+ * Translate a gl_shader_stage to a short shader stage name for debug
+ * printouts and error messages.
*/
const char *
-_mesa_shader_type_to_string(unsigned target)
+_mesa_shader_stage_to_string(unsigned stage)
{
- switch (target) {
+ switch (stage) {
case MESA_SHADER_VERTEX: return "vertex";
case MESA_SHADER_FRAGMENT: return "fragment";
case MESA_SHADER_GEOMETRY: return "geometry";
@@ -543,6 +512,7 @@ static const _mesa_glsl_extension _mesa_glsl_supported_extensions[] = {
EXT(ARB_texture_gather, true, false, ARB_texture_gather),
EXT(ARB_shader_atomic_counters, true, false, ARB_shader_atomic_counters),
EXT(ARB_sample_shading, true, false, ARB_sample_shading),
+ EXT(AMD_shader_trinary_minmax, true, false, dummy_true),
};
#undef EXT
@@ -650,11 +620,11 @@ _mesa_glsl_process_extension(const char *name, YYLTYPE *name_locp,
if (behavior == extension_require) {
_mesa_glsl_error(name_locp, state, fmt,
- name, _mesa_shader_type_to_string(state->target));
+ name, _mesa_shader_stage_to_string(state->stage));
return false;
} else {
_mesa_glsl_warning(name_locp, state, fmt,
- name, _mesa_shader_type_to_string(state->target));
+ name, _mesa_shader_stage_to_string(state->stage));
}
}
}
@@ -1447,7 +1417,7 @@ static void
set_shader_inout_layout(struct gl_shader *shader,
struct _mesa_glsl_parse_state *state)
{
- if (shader->Type != GL_GEOMETRY_SHADER) {
+ if (shader->Stage != MESA_SHADER_GEOMETRY) {
/* Should have been prevented by the parser. */
assert(!state->gs_input_prim_type_specified);
assert(!state->out_qualifier->flags.i);
@@ -1478,7 +1448,7 @@ _mesa_glsl_compile_shader(struct gl_context *ctx, struct gl_shader *shader,
bool dump_ast, bool dump_hir)
{
struct _mesa_glsl_parse_state *state =
- new(shader) _mesa_glsl_parse_state(ctx, shader->Type, shader);
+ new(shader) _mesa_glsl_parse_state(ctx, shader->Stage, shader);
const char *source = shader->Source;
state->error = glcpp_preprocess(state, &source, &state->info_log,
@@ -1515,7 +1485,7 @@ _mesa_glsl_compile_shader(struct gl_context *ctx, struct gl_shader *shader,
if (!state->error && !shader->ir->is_empty()) {
struct gl_shader_compiler_options *options =
- &ctx->ShaderCompilerOptions[_mesa_shader_type_to_index(shader->Type)];
+ &ctx->ShaderCompilerOptions[shader->Stage];
/* Do some optimization at compile time to reduce shader IR size
* and reduce later work if the same shader is linked multiple times
diff --git a/mesalib/src/glsl/glsl_parser_extras.h b/mesalib/src/glsl/glsl_parser_extras.h
index 7b013fa6d..2444a96ce 100644
--- a/mesalib/src/glsl/glsl_parser_extras.h
+++ b/mesalib/src/glsl/glsl_parser_extras.h
@@ -68,7 +68,7 @@ extern void _mesa_glsl_error(YYLTYPE *locp, _mesa_glsl_parse_state *state,
struct _mesa_glsl_parse_state {
- _mesa_glsl_parse_state(struct gl_context *_ctx, GLenum target,
+ _mesa_glsl_parse_state(struct gl_context *_ctx, gl_shader_stage stage,
void *mem_ctx);
DECLARE_RALLOC_CXX_OPERATORS(_mesa_glsl_parse_state);
@@ -165,7 +165,7 @@ struct _mesa_glsl_parse_state {
bool es_shader;
unsigned language_version;
- gl_shader_type target;
+ gl_shader_stage stage;
/**
* Number of nested struct_specifier levels
@@ -350,6 +350,8 @@ struct _mesa_glsl_parse_state {
bool EXT_shader_integer_mix_warn;
bool ARB_shader_atomic_counters_enable;
bool ARB_shader_atomic_counters_warn;
+ bool AMD_shader_trinary_minmax_enable;
+ bool AMD_shader_trinary_minmax_warn;
/*@}*/
/** Extensions supported by the OpenGL implementation. */
@@ -421,14 +423,6 @@ extern bool _mesa_glsl_process_extension(const char *name, YYLTYPE *name_locp,
YYLTYPE *behavior_locp,
_mesa_glsl_parse_state *state);
-/**
- * Get the textual name of the specified shader target (which is a
- * gl_shader_type).
- */
-extern const char *
-_mesa_shader_type_to_string(unsigned target);
-
-
#endif /* __cplusplus */
@@ -439,8 +433,12 @@ _mesa_shader_type_to_string(unsigned target);
extern "C" {
#endif
+/**
+ * Get the textual name of the specified shader stage (which is a
+ * gl_shader_stage).
+ */
extern const char *
-_mesa_shader_enum_to_string(GLenum type);
+_mesa_shader_stage_to_string(unsigned stage);
extern int glcpp_preprocess(void *ctx, const char **shader, char **info_log,
const struct gl_extensions *extensions, struct gl_context *gl_ctx);
diff --git a/mesalib/src/glsl/ir.cpp b/mesalib/src/glsl/ir.cpp
index 04a7b874a..ba6903d8a 100644
--- a/mesalib/src/glsl/ir.cpp
+++ b/mesalib/src/glsl/ir.cpp
@@ -1122,27 +1122,31 @@ ir_constant::has_value(const ir_constant *c) const
}
bool
-ir_constant::is_zero() const
+ir_constant::is_value(float f, int i) const
{
if (!this->type->is_scalar() && !this->type->is_vector())
return false;
+ /* Only accept boolean values for 0/1. */
+ if (int(bool(i)) != i && this->type->is_boolean())
+ return false;
+
for (unsigned c = 0; c < this->type->vector_elements; c++) {
switch (this->type->base_type) {
case GLSL_TYPE_FLOAT:
- if (this->value.f[c] != 0.0)
+ if (this->value.f[c] != f)
return false;
break;
case GLSL_TYPE_INT:
- if (this->value.i[c] != 0)
+ if (this->value.i[c] != i)
return false;
break;
case GLSL_TYPE_UINT:
- if (this->value.u[c] != 0)
+ if (this->value.u[c] != unsigned(i))
return false;
break;
case GLSL_TYPE_BOOL:
- if (this->value.b[c] != false)
+ if (this->value.b[c] != bool(i))
return false;
break;
default:
@@ -1159,76 +1163,21 @@ ir_constant::is_zero() const
}
bool
-ir_constant::is_one() const
+ir_constant::is_zero() const
{
- if (!this->type->is_scalar() && !this->type->is_vector())
- return false;
-
- for (unsigned c = 0; c < this->type->vector_elements; c++) {
- switch (this->type->base_type) {
- case GLSL_TYPE_FLOAT:
- if (this->value.f[c] != 1.0)
- return false;
- break;
- case GLSL_TYPE_INT:
- if (this->value.i[c] != 1)
- return false;
- break;
- case GLSL_TYPE_UINT:
- if (this->value.u[c] != 1)
- return false;
- break;
- case GLSL_TYPE_BOOL:
- if (this->value.b[c] != true)
- return false;
- break;
- default:
- /* The only other base types are structures, arrays, and samplers.
- * Samplers cannot be constants, and the others should have been
- * filtered out above.
- */
- assert(!"Should not get here.");
- return false;
- }
- }
+ return is_value(0.0, 0);
+}
- return true;
+bool
+ir_constant::is_one() const
+{
+ return is_value(1.0, 1);
}
bool
ir_constant::is_negative_one() const
{
- if (!this->type->is_scalar() && !this->type->is_vector())
- return false;
-
- if (this->type->is_boolean())
- return false;
-
- for (unsigned c = 0; c < this->type->vector_elements; c++) {
- switch (this->type->base_type) {
- case GLSL_TYPE_FLOAT:
- if (this->value.f[c] != -1.0)
- return false;
- break;
- case GLSL_TYPE_INT:
- if (this->value.i[c] != -1)
- return false;
- break;
- case GLSL_TYPE_UINT:
- if (int(this->value.u[c]) != -1)
- return false;
- break;
- default:
- /* The only other base types are structures, arrays, samplers, and
- * booleans. Samplers cannot be constants, and the others should
- * have been filtered out above.
- */
- assert(!"Should not get here.");
- return false;
- }
- }
-
- return true;
+ return is_value(-1.0, -1);
}
bool
diff --git a/mesalib/src/glsl/ir.h b/mesalib/src/glsl/ir.h
index 780959b73..aff679826 100644
--- a/mesalib/src/glsl/ir.h
+++ b/mesalib/src/glsl/ir.h
@@ -2186,6 +2186,12 @@ public:
*/
bool has_value(const ir_constant *) const;
+ /**
+ * Return true if this ir_constant represents the given value.
+ *
+ * For vectors, this checks that each component is the given value.
+ */
+ virtual bool is_value(float f, int i) const;
virtual bool is_zero() const;
virtual bool is_one() const;
virtual bool is_negative_one() const;
@@ -2345,7 +2351,7 @@ ir_has_call(ir_instruction *ir);
extern void
do_set_program_inouts(exec_list *instructions, struct gl_program *prog,
- GLenum shader_type);
+ gl_shader_stage shader_stage);
extern char *
prototype_string(const glsl_type *return_type, const char *name,
diff --git a/mesalib/src/glsl/ir_builder.cpp b/mesalib/src/glsl/ir_builder.cpp
index 6c49734be..7f41ed69e 100644
--- a/mesalib/src/glsl/ir_builder.cpp
+++ b/mesalib/src/glsl/ir_builder.cpp
@@ -211,6 +211,16 @@ ir_expression *sub(operand a, operand b)
return expr(ir_binop_sub, a, b);
}
+ir_expression *min2(operand a, operand b)
+{
+ return expr(ir_binop_min, a, b);
+}
+
+ir_expression *max2(operand a, operand b)
+{
+ return expr(ir_binop_max, a, b);
+}
+
ir_expression *mul(operand a, operand b)
{
return expr(ir_binop_mul, a, b);
diff --git a/mesalib/src/glsl/ir_builder.h b/mesalib/src/glsl/ir_builder.h
index 1f0778870..f00e6f3b3 100644
--- a/mesalib/src/glsl/ir_builder.h
+++ b/mesalib/src/glsl/ir_builder.h
@@ -184,6 +184,9 @@ ir_expression *i2b(operand a);
ir_expression *f2b(operand a);
ir_expression *b2f(operand a);
+ir_expression *min2(operand a, operand b);
+ir_expression *max2(operand a, operand b);
+
ir_expression *fma(operand a, operand b, operand c);
ir_expression *lrp(operand x, operand y, operand a);
ir_expression *csel(operand a, operand b, operand c);
diff --git a/mesalib/src/glsl/ir_constant_expression.cpp b/mesalib/src/glsl/ir_constant_expression.cpp
index 7ca865e22..f811fd138 100644
--- a/mesalib/src/glsl/ir_constant_expression.cpp
+++ b/mesalib/src/glsl/ir_constant_expression.cpp
@@ -1402,7 +1402,7 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
data.f[c] = ldexp(op[0]->value.f[c], op[1]->value.i[c]);
/* Flush subnormal values to zero. */
if (!isnormal(data.f[c]))
- data.f[c] = copysign(0.0, op[0]->value.f[c]);
+ data.f[c] = copysign(0.0f, op[0]->value.f[c]);
}
break;
diff --git a/mesalib/src/glsl/ir_set_program_inouts.cpp b/mesalib/src/glsl/ir_set_program_inouts.cpp
index 0b49eb2b6..5163eb215 100644
--- a/mesalib/src/glsl/ir_set_program_inouts.cpp
+++ b/mesalib/src/glsl/ir_set_program_inouts.cpp
@@ -46,10 +46,11 @@ namespace {
class ir_set_program_inouts_visitor : public ir_hierarchical_visitor {
public:
- ir_set_program_inouts_visitor(struct gl_program *prog, GLenum shader_type)
+ ir_set_program_inouts_visitor(struct gl_program *prog,
+ gl_shader_stage shader_stage)
{
this->prog = prog;
- this->shader_type = shader_type;
+ this->shader_stage = shader_stage;
}
~ir_set_program_inouts_visitor()
{
@@ -67,7 +68,7 @@ private:
bool try_mark_partial_variable(ir_variable *var, ir_rvalue *index);
struct gl_program *prog;
- GLenum shader_type;
+ gl_shader_stage shader_stage;
};
} /* anonymous namespace */
@@ -124,13 +125,13 @@ void
ir_set_program_inouts_visitor::mark_whole_variable(ir_variable *var)
{
const glsl_type *type = var->type;
- if (this->shader_type == GL_GEOMETRY_SHADER &&
+ if (this->shader_stage == MESA_SHADER_GEOMETRY &&
var->data.mode == ir_var_shader_in && type->is_array()) {
type = type->fields.array;
}
mark(this->prog, var, 0, type->count_attribute_slots(),
- this->shader_type == GL_FRAGMENT_SHADER);
+ this->shader_stage == MESA_SHADER_FRAGMENT);
}
/* Default handler: Mark all the locations in the variable as used. */
@@ -163,7 +164,7 @@ ir_set_program_inouts_visitor::try_mark_partial_variable(ir_variable *var,
{
const glsl_type *type = var->type;
- if (this->shader_type == GL_GEOMETRY_SHADER &&
+ if (this->shader_stage == MESA_SHADER_GEOMETRY &&
var->data.mode == ir_var_shader_in) {
/* The only geometry shader input that is not an array is
* gl_PrimitiveIDIn, and in that case, this code will never be reached,
@@ -227,7 +228,7 @@ ir_set_program_inouts_visitor::try_mark_partial_variable(ir_variable *var,
}
mark(this->prog, var, index_as_constant->value.u[0] * elem_width,
- elem_width, this->shader_type == GL_FRAGMENT_SHADER);
+ elem_width, this->shader_stage == MESA_SHADER_FRAGMENT);
return true;
}
@@ -245,7 +246,7 @@ ir_set_program_inouts_visitor::visit_enter(ir_dereference_array *ir)
*/
if (ir_dereference_variable * const deref_var =
inner_array->array->as_dereference_variable()) {
- if (this->shader_type == GL_GEOMETRY_SHADER &&
+ if (this->shader_stage == MESA_SHADER_GEOMETRY &&
deref_var->var->data.mode == ir_var_shader_in) {
/* foo is a geometry shader input, so i is the vertex, and j the
* part of the input we're accessing.
@@ -264,7 +265,7 @@ ir_set_program_inouts_visitor::visit_enter(ir_dereference_array *ir)
} else if (ir_dereference_variable * const deref_var =
ir->array->as_dereference_variable()) {
/* ir => foo[i], where foo is a variable. */
- if (this->shader_type == GL_GEOMETRY_SHADER &&
+ if (this->shader_stage == MESA_SHADER_GEOMETRY &&
deref_var->var->data.mode == ir_var_shader_in) {
/* foo is a geometry shader input, so i is the vertex, and we're
* accessing the entire input.
@@ -304,7 +305,7 @@ ir_set_program_inouts_visitor::visit_enter(ir_function_signature *ir)
ir_visitor_status
ir_set_program_inouts_visitor::visit_enter(ir_expression *ir)
{
- if (this->shader_type == GL_FRAGMENT_SHADER &&
+ if (this->shader_stage == MESA_SHADER_FRAGMENT &&
ir->operation == ir_unop_dFdy) {
gl_fragment_program *fprog = (gl_fragment_program *) prog;
fprog->UsesDFdy = true;
@@ -316,7 +317,7 @@ ir_visitor_status
ir_set_program_inouts_visitor::visit_enter(ir_discard *)
{
/* discards are only allowed in fragment shaders. */
- assert(this->shader_type == GL_FRAGMENT_SHADER);
+ assert(this->shader_stage == MESA_SHADER_FRAGMENT);
gl_fragment_program *fprog = (gl_fragment_program *) prog;
fprog->UsesKill = true;
@@ -334,14 +335,14 @@ ir_set_program_inouts_visitor::visit_enter(ir_texture *ir)
void
do_set_program_inouts(exec_list *instructions, struct gl_program *prog,
- GLenum shader_type)
+ gl_shader_stage shader_stage)
{
- ir_set_program_inouts_visitor v(prog, shader_type);
+ ir_set_program_inouts_visitor v(prog, shader_stage);
prog->InputsRead = 0;
prog->OutputsWritten = 0;
prog->SystemValuesRead = 0;
- if (shader_type == GL_FRAGMENT_SHADER) {
+ if (shader_stage == MESA_SHADER_FRAGMENT) {
gl_fragment_program *fprog = (gl_fragment_program *) prog;
memset(fprog->InterpQualifier, 0, sizeof(fprog->InterpQualifier));
fprog->IsCentroid = 0;
diff --git a/mesalib/src/glsl/ir_uniform.h b/mesalib/src/glsl/ir_uniform.h
index 13faab7c0..f678c2c5c 100644
--- a/mesalib/src/glsl/ir_uniform.h
+++ b/mesalib/src/glsl/ir_uniform.h
@@ -116,7 +116,7 @@ struct gl_uniform_storage {
* Whether this sampler is used in this shader stage.
*/
bool active;
- } sampler[MESA_SHADER_TYPES];
+ } sampler[MESA_SHADER_STAGES];
/**
* Storage used by the driver for the uniform
diff --git a/mesalib/src/glsl/link_atomics.cpp b/mesalib/src/glsl/link_atomics.cpp
index 603329c50..db9c53965 100644
--- a/mesalib/src/glsl/link_atomics.cpp
+++ b/mesalib/src/glsl/link_atomics.cpp
@@ -64,7 +64,7 @@ namespace {
active_atomic_counter *counters;
unsigned num_counters;
- unsigned stage_references[MESA_SHADER_TYPES];
+ unsigned stage_references[MESA_SHADER_STAGES];
unsigned size;
};
@@ -96,7 +96,7 @@ namespace {
*num_buffers = 0;
- for (unsigned i = 0; i < MESA_SHADER_TYPES; ++i) {
+ for (unsigned i = 0; i < MESA_SHADER_STAGES; ++i) {
struct gl_shader *sh = prog->_LinkedShaders[i];
if (sh == NULL)
continue;
@@ -199,7 +199,7 @@ link_assign_atomic_counter_resources(struct gl_context *ctx,
}
/* Assign stage-specific fields. */
- for (unsigned j = 0; j < MESA_SHADER_TYPES; ++j)
+ for (unsigned j = 0; j < MESA_SHADER_STAGES; ++j)
mab.StageReferences[j] =
(ab.stage_references[j] ? GL_TRUE : GL_FALSE);
@@ -214,23 +214,11 @@ void
link_check_atomic_counter_resources(struct gl_context *ctx,
struct gl_shader_program *prog)
{
- const unsigned max_atomic_counters[] = {
- ctx->Const.VertexProgram.MaxAtomicCounters,
- ctx->Const.GeometryProgram.MaxAtomicCounters,
- ctx->Const.FragmentProgram.MaxAtomicCounters
- };
- STATIC_ASSERT(Elements(max_atomic_counters) == MESA_SHADER_TYPES);
- const unsigned max_atomic_buffers[] = {
- ctx->Const.VertexProgram.MaxAtomicBuffers,
- ctx->Const.GeometryProgram.MaxAtomicBuffers,
- ctx->Const.FragmentProgram.MaxAtomicBuffers
- };
- STATIC_ASSERT(Elements(max_atomic_buffers) == MESA_SHADER_TYPES);
unsigned num_buffers;
active_atomic_buffer *const abs =
find_active_atomic_counters(ctx, prog, &num_buffers);
- unsigned atomic_counters[MESA_SHADER_TYPES] = {};
- unsigned atomic_buffers[MESA_SHADER_TYPES] = {};
+ unsigned atomic_counters[MESA_SHADER_STAGES] = {};
+ unsigned atomic_buffers[MESA_SHADER_STAGES] = {};
unsigned total_atomic_counters = 0;
unsigned total_atomic_buffers = 0;
@@ -243,7 +231,7 @@ link_check_atomic_counter_resources(struct gl_context *ctx,
if (abs[i].size == 0)
continue;
- for (unsigned j = 0; j < MESA_SHADER_TYPES; ++j) {
+ for (unsigned j = 0; j < MESA_SHADER_STAGES; ++j) {
const unsigned n = abs[i].stage_references[j];
if (n) {
@@ -256,14 +244,14 @@ link_check_atomic_counter_resources(struct gl_context *ctx,
}
/* Check that they are within the supported limits. */
- for (unsigned i = 0; i < MESA_SHADER_TYPES; i++) {
- if (atomic_counters[i] > max_atomic_counters[i])
+ for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
+ if (atomic_counters[i] > ctx->Const.Program[i].MaxAtomicCounters)
linker_error(prog, "Too many %s shader atomic counters",
- _mesa_shader_type_to_string(i));
+ _mesa_shader_stage_to_string(i));
- if (atomic_buffers[i] > max_atomic_buffers[i])
+ if (atomic_buffers[i] > ctx->Const.Program[i].MaxAtomicBuffers)
linker_error(prog, "Too many %s shader atomic counter buffers",
- _mesa_shader_type_to_string(i));
+ _mesa_shader_stage_to_string(i));
}
if (total_atomic_counters > ctx->Const.MaxCombinedAtomicCounters)
diff --git a/mesalib/src/glsl/link_interface_blocks.cpp b/mesalib/src/glsl/link_interface_blocks.cpp
index 476963642..52552cc68 100644
--- a/mesalib/src/glsl/link_interface_blocks.cpp
+++ b/mesalib/src/glsl/link_interface_blocks.cpp
@@ -313,7 +313,7 @@ validate_interstage_inout_blocks(struct gl_shader_program *prog,
const gl_shader *consumer)
{
interface_block_definitions definitions;
- const bool extra_array_level = consumer->Type == GL_GEOMETRY_SHADER;
+ const bool extra_array_level = consumer->Stage == MESA_SHADER_GEOMETRY;
/* Add input interfaces from the consumer to the symbol table. */
foreach_list(node, consumer->ir) {
diff --git a/mesalib/src/glsl/link_uniform_initializers.cpp b/mesalib/src/glsl/link_uniform_initializers.cpp
index 04daa1760..7d5c1472d 100644
--- a/mesalib/src/glsl/link_uniform_initializers.cpp
+++ b/mesalib/src/glsl/link_uniform_initializers.cpp
@@ -106,7 +106,7 @@ set_uniform_binding(void *mem_ctx, gl_shader_program *prog,
storage->storage[i].i = binding + i;
}
- for (int sh = 0; sh < MESA_SHADER_TYPES; sh++) {
+ for (int sh = 0; sh < MESA_SHADER_STAGES; sh++) {
gl_shader *shader = prog->_LinkedShaders[sh];
if (shader && storage->sampler[sh].active) {
@@ -119,7 +119,7 @@ set_uniform_binding(void *mem_ctx, gl_shader_program *prog,
}
} else if (storage->block_index != -1) {
/* This is a field of a UBO. val is the binding index. */
- for (int i = 0; i < MESA_SHADER_TYPES; i++) {
+ for (int i = 0; i < MESA_SHADER_STAGES; i++) {
int stage_index = prog->UniformBlockStageIndex[i][storage->block_index];
if (stage_index != -1) {
@@ -194,7 +194,7 @@ set_uniform_initializer(void *mem_ctx, gl_shader_program *prog,
val->type->components());
if (storage->type->is_sampler()) {
- for (int sh = 0; sh < MESA_SHADER_TYPES; sh++) {
+ for (int sh = 0; sh < MESA_SHADER_STAGES; sh++) {
gl_shader *shader = prog->_LinkedShaders[sh];
if (shader && storage->sampler[sh].active) {
@@ -215,7 +215,7 @@ link_set_uniform_initializers(struct gl_shader_program *prog)
{
void *mem_ctx = NULL;
- for (unsigned int i = 0; i < MESA_SHADER_TYPES; i++) {
+ for (unsigned int i = 0; i < MESA_SHADER_STAGES; i++) {
struct gl_shader *shader = prog->_LinkedShaders[i];
if (shader == NULL)
diff --git a/mesalib/src/glsl/link_uniforms.cpp b/mesalib/src/glsl/link_uniforms.cpp
index bda6e4ffb..1c97e1957 100644
--- a/mesalib/src/glsl/link_uniforms.cpp
+++ b/mesalib/src/glsl/link_uniforms.cpp
@@ -356,9 +356,9 @@ public:
{
}
- void start_shader(gl_shader_type shader_type)
+ void start_shader(gl_shader_stage shader_type)
{
- assert(shader_type < MESA_SHADER_TYPES);
+ assert(shader_type < MESA_SHADER_STAGES);
this->shader_type = shader_type;
this->shader_samplers_used = 0;
@@ -429,7 +429,7 @@ public:
int ubo_block_index;
int ubo_byte_offset;
bool ubo_row_major;
- gl_shader_type shader_type;
+ gl_shader_stage shader_type;
private:
void handle_samplers(const glsl_type *base_type,
@@ -741,7 +741,7 @@ link_assign_uniform_locations(struct gl_shader_program *prog)
* glGetUniformLocation.
*/
count_uniform_size uniform_size(prog->UniformHash);
- for (unsigned i = 0; i < MESA_SHADER_TYPES; i++) {
+ for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
struct gl_shader *sh = prog->_LinkedShaders[i];
if (sh == NULL)
@@ -809,11 +809,11 @@ link_assign_uniform_locations(struct gl_shader_program *prog)
parcel_out_uniform_storage parcel(prog->UniformHash, uniforms, data);
- for (unsigned i = 0; i < MESA_SHADER_TYPES; i++) {
+ for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
if (prog->_LinkedShaders[i] == NULL)
continue;
- parcel.start_shader((gl_shader_type)i);
+ parcel.start_shader((gl_shader_stage)i);
foreach_list(node, prog->_LinkedShaders[i]->ir) {
ir_variable *const var = ((ir_instruction *) node)->as_variable();
diff --git a/mesalib/src/glsl/link_varyings.cpp b/mesalib/src/glsl/link_varyings.cpp
index 98f902ca4..c925c00e3 100644
--- a/mesalib/src/glsl/link_varyings.cpp
+++ b/mesalib/src/glsl/link_varyings.cpp
@@ -48,13 +48,13 @@ static void
cross_validate_types_and_qualifiers(struct gl_shader_program *prog,
const ir_variable *input,
const ir_variable *output,
- GLenum consumer_type,
- GLenum producer_type)
+ gl_shader_stage consumer_stage,
+ gl_shader_stage producer_stage)
{
/* Check that the types match between stages.
*/
const glsl_type *type_to_match = input->type;
- if (consumer_type == GL_GEOMETRY_SHADER) {
+ if (consumer_stage == MESA_SHADER_GEOMETRY) {
assert(type_to_match->is_array()); /* Enforced by ast_to_hir */
type_to_match = type_to_match->element_type();
}
@@ -82,10 +82,10 @@ cross_validate_types_and_qualifiers(struct gl_shader_program *prog,
linker_error(prog,
"%s shader output `%s' declared as type `%s', "
"but %s shader input declared as type `%s'\n",
- _mesa_shader_enum_to_string(producer_type),
+ _mesa_shader_stage_to_string(producer_stage),
output->name,
output->type->name,
- _mesa_shader_enum_to_string(consumer_type),
+ _mesa_shader_stage_to_string(consumer_stage),
input->type->name);
return;
}
@@ -97,10 +97,10 @@ cross_validate_types_and_qualifiers(struct gl_shader_program *prog,
linker_error(prog,
"%s shader output `%s' %s centroid qualifier, "
"but %s shader input %s centroid qualifier\n",
- _mesa_shader_enum_to_string(producer_type),
+ _mesa_shader_stage_to_string(producer_stage),
output->name,
(output->data.centroid) ? "has" : "lacks",
- _mesa_shader_enum_to_string(consumer_type),
+ _mesa_shader_stage_to_string(consumer_stage),
(input->data.centroid) ? "has" : "lacks");
return;
}
@@ -109,10 +109,10 @@ cross_validate_types_and_qualifiers(struct gl_shader_program *prog,
linker_error(prog,
"%s shader output `%s' %s sample qualifier, "
"but %s shader input %s sample qualifier\n",
- _mesa_shader_enum_to_string(producer_type),
+ _mesa_shader_stage_to_string(producer_stage),
output->name,
(output->data.sample) ? "has" : "lacks",
- _mesa_shader_enum_to_string(consumer_type),
+ _mesa_shader_stage_to_string(consumer_stage),
(input->data.sample) ? "has" : "lacks");
return;
}
@@ -121,10 +121,10 @@ cross_validate_types_and_qualifiers(struct gl_shader_program *prog,
linker_error(prog,
"%s shader output `%s' %s invariant qualifier, "
"but %s shader input %s invariant qualifier\n",
- _mesa_shader_enum_to_string(producer_type),
+ _mesa_shader_stage_to_string(producer_stage),
output->name,
(output->data.invariant) ? "has" : "lacks",
- _mesa_shader_enum_to_string(consumer_type),
+ _mesa_shader_stage_to_string(consumer_stage),
(input->data.invariant) ? "has" : "lacks");
return;
}
@@ -135,10 +135,10 @@ cross_validate_types_and_qualifiers(struct gl_shader_program *prog,
"interpolation qualifier, "
"but %s shader input specifies %s "
"interpolation qualifier\n",
- _mesa_shader_enum_to_string(producer_type),
+ _mesa_shader_stage_to_string(producer_stage),
output->name,
interpolation_string(output->data.interpolation),
- _mesa_shader_enum_to_string(consumer_type),
+ _mesa_shader_stage_to_string(consumer_stage),
interpolation_string(input->data.interpolation));
return;
}
@@ -152,16 +152,16 @@ cross_validate_front_and_back_color(struct gl_shader_program *prog,
const ir_variable *input,
const ir_variable *front_color,
const ir_variable *back_color,
- GLenum consumer_type,
- GLenum producer_type)
+ gl_shader_stage consumer_stage,
+ gl_shader_stage producer_stage)
{
if (front_color != NULL && front_color->data.assigned)
cross_validate_types_and_qualifiers(prog, input, front_color,
- consumer_type, producer_type);
+ consumer_stage, producer_stage);
if (back_color != NULL && back_color->data.assigned)
cross_validate_types_and_qualifiers(prog, input, back_color,
- consumer_type, producer_type);
+ consumer_stage, producer_stage);
}
/**
@@ -208,7 +208,7 @@ cross_validate_outputs_to_inputs(struct gl_shader_program *prog,
cross_validate_front_and_back_color(prog, input,
front_color, back_color,
- consumer->Type, producer->Type);
+ consumer->Stage, producer->Stage);
} else if (strcmp(input->name, "gl_SecondaryColor") == 0 && input->data.used) {
const ir_variable *const front_color =
parameters.get_variable("gl_FrontSecondaryColor");
@@ -218,12 +218,12 @@ cross_validate_outputs_to_inputs(struct gl_shader_program *prog,
cross_validate_front_and_back_color(prog, input,
front_color, back_color,
- consumer->Type, producer->Type);
+ consumer->Stage, producer->Stage);
} else {
ir_variable *const output = parameters.get_variable(input->name);
if (output != NULL) {
cross_validate_types_and_qualifiers(prog, input, output,
- consumer->Type, producer->Type);
+ consumer->Stage, producer->Stage);
}
}
}
@@ -943,10 +943,10 @@ varying_matches::match_comparator(const void *x_generic, const void *y_generic)
* varyings, but excludes variables such as gl_FrontFacing and gl_FragCoord.
*/
static bool
-is_varying_var(GLenum shaderType, const ir_variable *var)
+is_varying_var(gl_shader_stage stage, const ir_variable *var)
{
/* Only fragment shaders will take a varying variable as an input */
- if (shaderType == GL_FRAGMENT_SHADER &&
+ if (stage == MESA_SHADER_FRAGMENT &&
var->data.mode == ir_var_shader_in) {
switch (var->data.location) {
case VARYING_SLOT_POS:
@@ -1072,7 +1072,7 @@ assign_varying_locations(struct gl_context *ctx,
const unsigned producer_base = VARYING_SLOT_VAR0;
const unsigned consumer_base = VARYING_SLOT_VAR0;
varying_matches matches(ctx->Const.DisableVaryingPacking,
- consumer && consumer->Type == GL_FRAGMENT_SHADER);
+ consumer && consumer->Stage == MESA_SHADER_FRAGMENT);
hash_table *tfeedback_candidates
= hash_table_ctor(0, hash_table_string_hash, hash_table_string_compare);
hash_table *consumer_inputs
@@ -1217,9 +1217,9 @@ assign_varying_locations(struct gl_context *ctx,
linker_error(prog, "%s shader varying %s not written "
"by %s shader\n.",
- _mesa_shader_enum_to_string(consumer->Type),
+ _mesa_shader_stage_to_string(consumer->Stage),
var->name,
- _mesa_shader_enum_to_string(producer->Type));
+ _mesa_shader_stage_to_string(producer->Stage));
}
/* An 'in' variable is only really a shader input if its
@@ -1244,24 +1244,14 @@ check_against_output_limit(struct gl_context *ctx,
ir_variable *const var = ((ir_instruction *) node)->as_variable();
if (var && var->data.mode == ir_var_shader_out &&
- is_varying_var(producer->Type, var)) {
+ is_varying_var(producer->Stage, var)) {
output_vectors += var->type->count_attribute_slots();
}
}
- unsigned max_output_components;
- switch (producer->Type) {
- case GL_VERTEX_SHADER:
- max_output_components = ctx->Const.VertexProgram.MaxOutputComponents;
- break;
- case GL_GEOMETRY_SHADER:
- max_output_components = ctx->Const.GeometryProgram.MaxOutputComponents;
- break;
- case GL_FRAGMENT_SHADER:
- default:
- assert(!"Should not get here.");
- return false;
- }
+ assert(producer->Stage != MESA_SHADER_FRAGMENT);
+ unsigned max_output_components =
+ ctx->Const.Program[producer->Stage].MaxOutputComponents;
const unsigned output_components = output_vectors * 4;
if (output_components > max_output_components) {
@@ -1293,24 +1283,14 @@ check_against_input_limit(struct gl_context *ctx,
ir_variable *const var = ((ir_instruction *) node)->as_variable();
if (var && var->data.mode == ir_var_shader_in &&
- is_varying_var(consumer->Type, var)) {
+ is_varying_var(consumer->Stage, var)) {
input_vectors += var->type->count_attribute_slots();
}
}
- unsigned max_input_components;
- switch (consumer->Type) {
- case GL_GEOMETRY_SHADER:
- max_input_components = ctx->Const.GeometryProgram.MaxInputComponents;
- break;
- case GL_FRAGMENT_SHADER:
- max_input_components = ctx->Const.FragmentProgram.MaxInputComponents;
- break;
- case GL_VERTEX_SHADER:
- default:
- assert(!"Should not get here.");
- return false;
- }
+ assert(consumer->Stage != MESA_SHADER_VERTEX);
+ unsigned max_input_components =
+ ctx->Const.Program[consumer->Stage].MaxInputComponents;
const unsigned input_components = input_vectors * 4;
if (input_components > max_input_components) {
diff --git a/mesalib/src/glsl/linker.cpp b/mesalib/src/glsl/linker.cpp
index a81e10737..e820f0f9f 100644
--- a/mesalib/src/glsl/linker.cpp
+++ b/mesalib/src/glsl/linker.cpp
@@ -438,7 +438,7 @@ analyze_clip_usage(struct gl_shader_program *prog,
if (clip_vertex.variable_found() && clip_distance.variable_found()) {
linker_error(prog, "%s shader writes to both `gl_ClipVertex' "
"and `gl_ClipDistance'\n",
- _mesa_shader_enum_to_string(shader->Type));
+ _mesa_shader_stage_to_string(shader->Stage));
return;
}
*UsesClipDistance = clip_distance.variable_found();
@@ -786,7 +786,7 @@ void
cross_validate_uniforms(struct gl_shader_program *prog)
{
cross_validate_globals(prog, prog->_LinkedShaders,
- MESA_SHADER_TYPES, true);
+ MESA_SHADER_STAGES, true);
}
/**
@@ -797,12 +797,12 @@ static bool
interstage_cross_validate_uniform_blocks(struct gl_shader_program *prog)
{
unsigned max_num_uniform_blocks = 0;
- for (unsigned i = 0; i < MESA_SHADER_TYPES; i++) {
+ for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
if (prog->_LinkedShaders[i])
max_num_uniform_blocks += prog->_LinkedShaders[i]->NumUniformBlocks;
}
- for (unsigned i = 0; i < MESA_SHADER_TYPES; i++) {
+ for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
struct gl_shader *sh = prog->_LinkedShaders[i];
prog->UniformBlockStageIndex[i] = ralloc_array(prog, int,
@@ -1209,7 +1209,7 @@ link_gs_inout_layout_qualifiers(struct gl_shader_program *prog,
/* No in/out qualifiers defined for anything but GLSL 1.50+
* geometry shaders so far.
*/
- if (linked_shader->Type != GL_GEOMETRY_SHADER || prog->Version < 150)
+ if (linked_shader->Stage != MESA_SHADER_GEOMETRY || prog->Version < 150)
return;
/* From the GLSL 1.50 spec, page 46:
@@ -1376,7 +1376,7 @@ link_intrastage_shaders(void *mem_ctx,
if (main == NULL) {
linker_error(prog, "%s shader lacks `main'\n",
- _mesa_shader_enum_to_string(shader_list[0]->Type));
+ _mesa_shader_stage_to_string(shader_list[0]->Stage));
return NULL;
}
@@ -1450,7 +1450,7 @@ link_intrastage_shaders(void *mem_ctx,
validate_ir_tree(linked->ir);
/* Set the size of geometry shader input arrays */
- if (linked->Type == GL_GEOMETRY_SHADER) {
+ if (linked->Stage == MESA_SHADER_GEOMETRY) {
unsigned num_vertices = vertices_per_prim(prog->Geom.InputType);
geom_array_resize_visitor input_resize_visitor(num_vertices, prog);
foreach_iter(exec_list_iterator, iter, *linked->ir) {
@@ -1488,7 +1488,7 @@ link_intrastage_shaders(void *mem_ctx,
static void
update_array_sizes(struct gl_shader_program *prog)
{
- for (unsigned i = 0; i < MESA_SHADER_TYPES; i++) {
+ for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
if (prog->_LinkedShaders[i] == NULL)
continue;
@@ -1511,7 +1511,7 @@ update_array_sizes(struct gl_shader_program *prog)
continue;
unsigned int size = var->data.max_array_access;
- for (unsigned j = 0; j < MESA_SHADER_TYPES; j++) {
+ for (unsigned j = 0; j < MESA_SHADER_STAGES; j++) {
if (prog->_LinkedShaders[j] == NULL)
continue;
@@ -1894,80 +1894,51 @@ store_fragdepth_layout(struct gl_shader_program *prog)
static void
check_resources(struct gl_context *ctx, struct gl_shader_program *prog)
{
- const unsigned max_samplers[] = {
- ctx->Const.VertexProgram.MaxTextureImageUnits,
- ctx->Const.GeometryProgram.MaxTextureImageUnits,
- ctx->Const.FragmentProgram.MaxTextureImageUnits
- };
- STATIC_ASSERT(Elements(max_samplers) == MESA_SHADER_TYPES);
-
- const unsigned max_default_uniform_components[] = {
- ctx->Const.VertexProgram.MaxUniformComponents,
- ctx->Const.GeometryProgram.MaxUniformComponents,
- ctx->Const.FragmentProgram.MaxUniformComponents
- };
- STATIC_ASSERT(Elements(max_default_uniform_components) ==
- MESA_SHADER_TYPES);
-
- const unsigned max_combined_uniform_components[] = {
- ctx->Const.VertexProgram.MaxCombinedUniformComponents,
- ctx->Const.GeometryProgram.MaxCombinedUniformComponents,
- ctx->Const.FragmentProgram.MaxCombinedUniformComponents
- };
- STATIC_ASSERT(Elements(max_combined_uniform_components) ==
- MESA_SHADER_TYPES);
-
- const unsigned max_uniform_blocks[] = {
- ctx->Const.VertexProgram.MaxUniformBlocks,
- ctx->Const.GeometryProgram.MaxUniformBlocks,
- ctx->Const.FragmentProgram.MaxUniformBlocks
- };
- STATIC_ASSERT(Elements(max_uniform_blocks) == MESA_SHADER_TYPES);
-
- for (unsigned i = 0; i < MESA_SHADER_TYPES; i++) {
+ for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
struct gl_shader *sh = prog->_LinkedShaders[i];
if (sh == NULL)
continue;
- if (sh->num_samplers > max_samplers[i]) {
+ if (sh->num_samplers > ctx->Const.Program[i].MaxTextureImageUnits) {
linker_error(prog, "Too many %s shader texture samplers",
- _mesa_shader_type_to_string(i));
+ _mesa_shader_stage_to_string(i));
}
- if (sh->num_uniform_components > max_default_uniform_components[i]) {
+ if (sh->num_uniform_components >
+ ctx->Const.Program[i].MaxUniformComponents) {
if (ctx->Const.GLSLSkipStrictMaxUniformLimitCheck) {
linker_warning(prog, "Too many %s shader default uniform block "
"components, but the driver will try to optimize "
"them out; this is non-portable out-of-spec "
"behavior\n",
- _mesa_shader_type_to_string(i));
+ _mesa_shader_stage_to_string(i));
} else {
linker_error(prog, "Too many %s shader default uniform block "
"components",
- _mesa_shader_type_to_string(i));
+ _mesa_shader_stage_to_string(i));
}
}
if (sh->num_combined_uniform_components >
- max_combined_uniform_components[i]) {
+ ctx->Const.Program[i].MaxCombinedUniformComponents) {
if (ctx->Const.GLSLSkipStrictMaxUniformLimitCheck) {
linker_warning(prog, "Too many %s shader uniform components, "
"but the driver will try to optimize them out; "
"this is non-portable out-of-spec behavior\n",
- _mesa_shader_type_to_string(i));
+ _mesa_shader_stage_to_string(i));
} else {
linker_error(prog, "Too many %s shader uniform components",
- _mesa_shader_type_to_string(i));
+ _mesa_shader_stage_to_string(i));
}
}
}
- unsigned blocks[MESA_SHADER_TYPES] = {0};
+ unsigned blocks[MESA_SHADER_STAGES] = {0};
unsigned total_uniform_blocks = 0;
for (unsigned i = 0; i < prog->NumUniformBlocks; i++) {
- for (unsigned j = 0; j < MESA_SHADER_TYPES; j++) {
+ for (unsigned j = 0; j < MESA_SHADER_STAGES; j++) {
if (prog->UniformBlockStageIndex[j][i] != -1) {
blocks[j]++;
total_uniform_blocks++;
@@ -1979,12 +1950,14 @@ check_resources(struct gl_context *ctx, struct gl_shader_program *prog)
prog->NumUniformBlocks,
ctx->Const.MaxCombinedUniformBlocks);
} else {
- for (unsigned i = 0; i < MESA_SHADER_TYPES; i++) {
- if (blocks[i] > max_uniform_blocks[i]) {
+ for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
+ const unsigned max_uniform_blocks =
+ ctx->Const.Program[i].MaxUniformBlocks;
+ if (blocks[i] > max_uniform_blocks) {
linker_error(prog, "Too many %s uniform blocks (%d/%d)",
- _mesa_shader_type_to_string(i),
+ _mesa_shader_stage_to_string(i),
blocks[i],
- max_uniform_blocks[i]);
+ max_uniform_blocks);
break;
}
}
@@ -2010,7 +1983,7 @@ link_shaders(struct gl_context *ctx, struct gl_shader_program *prog)
ralloc_free(prog->UniformBlocks);
prog->UniformBlocks = NULL;
prog->NumUniformBlocks = 0;
- for (int i = 0; i < MESA_SHADER_TYPES; i++) {
+ for (int i = 0; i < MESA_SHADER_STAGES; i++) {
ralloc_free(prog->UniformBlockStageIndex[i]);
prog->UniformBlockStageIndex[i] = NULL;
}
@@ -2049,16 +2022,16 @@ link_shaders(struct gl_context *ctx, struct gl_shader_program *prog)
goto done;
}
- switch (prog->Shaders[i]->Type) {
- case GL_VERTEX_SHADER:
+ switch (prog->Shaders[i]->Stage) {
+ case MESA_SHADER_VERTEX:
vert_shader_list[num_vert_shaders] = prog->Shaders[i];
num_vert_shaders++;
break;
- case GL_FRAGMENT_SHADER:
+ case MESA_SHADER_FRAGMENT:
frag_shader_list[num_frag_shaders] = prog->Shaders[i];
num_frag_shaders++;
break;
- case GL_GEOMETRY_SHADER:
+ case MESA_SHADER_GEOMETRY:
geom_shader_list[num_geom_shaders] = prog->Shaders[i];
num_geom_shaders++;
break;
@@ -2085,7 +2058,7 @@ link_shaders(struct gl_context *ctx, struct gl_shader_program *prog)
goto done;
}
- for (unsigned int i = 0; i < MESA_SHADER_TYPES; i++) {
+ for (unsigned int i = 0; i < MESA_SHADER_STAGES; i++) {
if (prog->_LinkedShaders[i] != NULL)
ctx->Driver.DeleteShader(ctx, prog->_LinkedShaders[i]);
@@ -2154,7 +2127,7 @@ link_shaders(struct gl_context *ctx, struct gl_shader_program *prog)
unsigned prev;
- for (prev = 0; prev < MESA_SHADER_TYPES; prev++) {
+ for (prev = 0; prev < MESA_SHADER_STAGES; prev++) {
if (prog->_LinkedShaders[prev] != NULL)
break;
}
@@ -2162,7 +2135,7 @@ link_shaders(struct gl_context *ctx, struct gl_shader_program *prog)
/* Validate the inputs of each stage with the output of the preceding
* stage.
*/
- for (unsigned i = prev + 1; i < MESA_SHADER_TYPES; i++) {
+ for (unsigned i = prev + 1; i < MESA_SHADER_STAGES; i++) {
if (prog->_LinkedShaders[i] == NULL)
continue;
@@ -2182,11 +2155,11 @@ link_shaders(struct gl_context *ctx, struct gl_shader_program *prog)
/* Cross-validate uniform blocks between shader stages */
validate_interstage_uniform_blocks(prog, prog->_LinkedShaders,
- MESA_SHADER_TYPES);
+ MESA_SHADER_STAGES);
if (!prog->LinkStatus)
goto done;
- for (unsigned int i = 0; i < MESA_SHADER_TYPES; i++) {
+ for (unsigned int i = 0; i < MESA_SHADER_STAGES; i++) {
if (prog->_LinkedShaders[i] != NULL)
lower_named_interface_blocks(mem_ctx, prog->_LinkedShaders[i]);
}
@@ -2211,7 +2184,7 @@ link_shaders(struct gl_context *ctx, struct gl_shader_program *prog)
* uniforms, and varyings. Later optimization could possibly make
* some of that unused.
*/
- for (unsigned i = 0; i < MESA_SHADER_TYPES; i++) {
+ for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
if (prog->_LinkedShaders[i] == NULL)
continue;
@@ -2257,7 +2230,7 @@ link_shaders(struct gl_context *ctx, struct gl_shader_program *prog)
}
unsigned first;
- for (first = 0; first < MESA_SHADER_TYPES; first++) {
+ for (first = 0; first < MESA_SHADER_STAGES; first++) {
if (prog->_LinkedShaders[first] != NULL)
break;
}
@@ -2289,7 +2262,7 @@ link_shaders(struct gl_context *ctx, struct gl_shader_program *prog)
* eliminated if they are (transitively) not used in a later stage.
*/
int last, next;
- for (last = MESA_SHADER_TYPES-1; last >= 0; last--) {
+ for (last = MESA_SHADER_STAGES-1; last >= 0; last--) {
if (prog->_LinkedShaders[last] != NULL)
break;
}
@@ -2404,7 +2377,7 @@ done:
free(frag_shader_list);
free(geom_shader_list);
- for (unsigned i = 0; i < MESA_SHADER_TYPES; i++) {
+ for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
if (prog->_LinkedShaders[i] == NULL)
continue;
diff --git a/mesalib/src/glsl/lower_clip_distance.cpp b/mesalib/src/glsl/lower_clip_distance.cpp
index bb4f6ab11..2d6138d5a 100644
--- a/mesalib/src/glsl/lower_clip_distance.cpp
+++ b/mesalib/src/glsl/lower_clip_distance.cpp
@@ -54,10 +54,10 @@ namespace {
class lower_clip_distance_visitor : public ir_rvalue_visitor {
public:
- explicit lower_clip_distance_visitor(GLenum shader_type)
+ explicit lower_clip_distance_visitor(gl_shader_stage shader_stage)
: progress(false), old_clip_distance_1d_var(NULL),
old_clip_distance_2d_var(NULL), new_clip_distance_1d_var(NULL),
- new_clip_distance_2d_var(NULL), shader_type(shader_type)
+ new_clip_distance_2d_var(NULL), shader_stage(shader_stage)
{
}
@@ -96,9 +96,9 @@ public:
ir_variable *new_clip_distance_2d_var;
/**
- * Type of shader we are compiling (e.g. GL_VERTEX_SHADER)
+ * Type of shader we are compiling (e.g. MESA_SHADER_VERTEX)
*/
- const GLenum shader_type;
+ const gl_shader_stage shader_stage;
};
} /* anonymous namespace */
@@ -142,7 +142,7 @@ lower_clip_distance_visitor::visit(ir_variable *ir)
} else {
/* 2D gl_ClipDistance (used for geometry input). */
assert(ir->data.mode == ir_var_shader_in &&
- this->shader_type == GL_GEOMETRY_SHADER_ARB);
+ this->shader_stage == MESA_SHADER_GEOMETRY);
if (this->old_clip_distance_2d_var)
return visit_continue;
@@ -253,7 +253,7 @@ lower_clip_distance_visitor::is_clip_distance_vec8(ir_rvalue *ir)
}
if (this->old_clip_distance_2d_var) {
/* 2D clip distance is only possible as a geometry input */
- assert(this->shader_type == GL_GEOMETRY_SHADER_ARB);
+ assert(this->shader_stage == MESA_SHADER_GEOMETRY);
ir_dereference_array *array_ref = ir->as_dereference_array();
if (array_ref) {
@@ -288,7 +288,7 @@ lower_clip_distance_visitor::lower_clip_distance_vec8(ir_rvalue *ir)
}
if (this->old_clip_distance_2d_var) {
/* 2D clip distance is only possible as a geometry input */
- assert(this->shader_type == GL_GEOMETRY_SHADER_ARB);
+ assert(this->shader_stage == MESA_SHADER_GEOMETRY);
ir_dereference_array *array_ref = ir->as_dereference_array();
if (array_ref) {
@@ -536,7 +536,7 @@ lower_clip_distance_visitor::visit_leave(ir_call *ir)
bool
lower_clip_distance(gl_shader *shader)
{
- lower_clip_distance_visitor v(shader->Type);
+ lower_clip_distance_visitor v(shader->Stage);
visit_list_elements(&v, shader->ir);
diff --git a/mesalib/src/glsl/lower_packed_varyings.cpp b/mesalib/src/glsl/lower_packed_varyings.cpp
index 9edef5d04..c23d1801b 100644
--- a/mesalib/src/glsl/lower_packed_varyings.cpp
+++ b/mesalib/src/glsl/lower_packed_varyings.cpp
@@ -669,7 +669,7 @@ lower_packed_varyings(void *mem_ctx, unsigned location_base,
gs_input_vertices, &new_instructions);
visitor.run(instructions);
if (mode == ir_var_shader_out) {
- if (shader->Type == GL_GEOMETRY_SHADER) {
+ if (shader->Stage == MESA_SHADER_GEOMETRY) {
/* For geometry shaders, outputs need to be lowered before each call
* to EmitVertex()
*/
diff --git a/mesalib/src/glsl/main.cpp b/mesalib/src/glsl/main.cpp
index aa188b1f1..03b7c786b 100644
--- a/mesalib/src/glsl/main.cpp
+++ b/mesalib/src/glsl/main.cpp
@@ -62,20 +62,20 @@ initialize_context(struct gl_context *ctx, gl_api api)
ctx->Const.MaxTextureCoordUnits = 0;
ctx->Const.MaxTextureUnits = 8;
- ctx->Const.VertexProgram.MaxAttribs = 8;
- ctx->Const.VertexProgram.MaxTextureImageUnits = 0;
- ctx->Const.VertexProgram.MaxUniformComponents = 128 * 4;
- ctx->Const.VertexProgram.MaxInputComponents = 0; /* not used */
- ctx->Const.VertexProgram.MaxOutputComponents = 32;
+ ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs = 8;
+ ctx->Const.Program[MESA_SHADER_VERTEX].MaxTextureImageUnits = 0;
+ ctx->Const.Program[MESA_SHADER_VERTEX].MaxUniformComponents = 128 * 4;
+ ctx->Const.Program[MESA_SHADER_VERTEX].MaxInputComponents = 0; /* not used */
+ ctx->Const.Program[MESA_SHADER_VERTEX].MaxOutputComponents = 32;
- ctx->Const.FragmentProgram.MaxTextureImageUnits =
+ ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits =
ctx->Const.MaxCombinedTextureImageUnits;
- ctx->Const.FragmentProgram.MaxUniformComponents = 16 * 4;
- ctx->Const.FragmentProgram.MaxInputComponents =
- ctx->Const.VertexProgram.MaxOutputComponents;
- ctx->Const.FragmentProgram.MaxOutputComponents = 0; /* not used */
+ ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxUniformComponents = 16 * 4;
+ ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxInputComponents =
+ ctx->Const.Program[MESA_SHADER_VERTEX].MaxOutputComponents;
+ ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxOutputComponents = 0; /* not used */
- ctx->Const.MaxVarying = ctx->Const.VertexProgram.MaxOutputComponents / 4;
+ ctx->Const.MaxVarying = ctx->Const.Program[MESA_SHADER_VERTEX].MaxOutputComponents / 4;
break;
case 110:
case 120:
@@ -88,20 +88,20 @@ initialize_context(struct gl_context *ctx, gl_api api)
ctx->Const.MaxTextureCoordUnits = 2;
ctx->Const.MaxTextureUnits = 2;
- ctx->Const.VertexProgram.MaxAttribs = 16;
- ctx->Const.VertexProgram.MaxTextureImageUnits = 0;
- ctx->Const.VertexProgram.MaxUniformComponents = 512;
- ctx->Const.VertexProgram.MaxInputComponents = 0; /* not used */
- ctx->Const.VertexProgram.MaxOutputComponents = 32;
+ ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs = 16;
+ ctx->Const.Program[MESA_SHADER_VERTEX].MaxTextureImageUnits = 0;
+ ctx->Const.Program[MESA_SHADER_VERTEX].MaxUniformComponents = 512;
+ ctx->Const.Program[MESA_SHADER_VERTEX].MaxInputComponents = 0; /* not used */
+ ctx->Const.Program[MESA_SHADER_VERTEX].MaxOutputComponents = 32;
- ctx->Const.FragmentProgram.MaxTextureImageUnits =
+ ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits =
ctx->Const.MaxCombinedTextureImageUnits;
- ctx->Const.FragmentProgram.MaxUniformComponents = 64;
- ctx->Const.FragmentProgram.MaxInputComponents =
- ctx->Const.VertexProgram.MaxOutputComponents;
- ctx->Const.FragmentProgram.MaxOutputComponents = 0; /* not used */
+ ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxUniformComponents = 64;
+ ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxInputComponents =
+ ctx->Const.Program[MESA_SHADER_VERTEX].MaxOutputComponents;
+ ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxOutputComponents = 0; /* not used */
- ctx->Const.MaxVarying = ctx->Const.VertexProgram.MaxOutputComponents / 4;
+ ctx->Const.MaxVarying = ctx->Const.Program[MESA_SHADER_VERTEX].MaxOutputComponents / 4;
break;
case 130:
case 140:
@@ -114,19 +114,19 @@ initialize_context(struct gl_context *ctx, gl_api api)
ctx->Const.MaxTextureCoordUnits = 8;
ctx->Const.MaxTextureUnits = 2;
- ctx->Const.VertexProgram.MaxAttribs = 16;
- ctx->Const.VertexProgram.MaxTextureImageUnits = 16;
- ctx->Const.VertexProgram.MaxUniformComponents = 1024;
- ctx->Const.VertexProgram.MaxInputComponents = 0; /* not used */
- ctx->Const.VertexProgram.MaxOutputComponents = 64;
+ ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs = 16;
+ ctx->Const.Program[MESA_SHADER_VERTEX].MaxTextureImageUnits = 16;
+ ctx->Const.Program[MESA_SHADER_VERTEX].MaxUniformComponents = 1024;
+ ctx->Const.Program[MESA_SHADER_VERTEX].MaxInputComponents = 0; /* not used */
+ ctx->Const.Program[MESA_SHADER_VERTEX].MaxOutputComponents = 64;
- ctx->Const.FragmentProgram.MaxTextureImageUnits = 16;
- ctx->Const.FragmentProgram.MaxUniformComponents = 1024;
- ctx->Const.FragmentProgram.MaxInputComponents =
- ctx->Const.VertexProgram.MaxOutputComponents;
- ctx->Const.FragmentProgram.MaxOutputComponents = 0; /* not used */
+ ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits = 16;
+ ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxUniformComponents = 1024;
+ ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxInputComponents =
+ ctx->Const.Program[MESA_SHADER_VERTEX].MaxOutputComponents;
+ ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxOutputComponents = 0; /* not used */
- ctx->Const.MaxVarying = ctx->Const.VertexProgram.MaxOutputComponents / 4;
+ ctx->Const.MaxVarying = ctx->Const.Program[MESA_SHADER_VERTEX].MaxOutputComponents / 4;
break;
case 150:
case 330:
@@ -138,28 +138,28 @@ initialize_context(struct gl_context *ctx, gl_api api)
ctx->Const.MaxTextureCoordUnits = 8;
ctx->Const.MaxTextureUnits = 2;
- ctx->Const.VertexProgram.MaxAttribs = 16;
- ctx->Const.VertexProgram.MaxTextureImageUnits = 16;
- ctx->Const.VertexProgram.MaxUniformComponents = 1024;
- ctx->Const.VertexProgram.MaxInputComponents = 0; /* not used */
- ctx->Const.VertexProgram.MaxOutputComponents = 64;
+ ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs = 16;
+ ctx->Const.Program[MESA_SHADER_VERTEX].MaxTextureImageUnits = 16;
+ ctx->Const.Program[MESA_SHADER_VERTEX].MaxUniformComponents = 1024;
+ ctx->Const.Program[MESA_SHADER_VERTEX].MaxInputComponents = 0; /* not used */
+ ctx->Const.Program[MESA_SHADER_VERTEX].MaxOutputComponents = 64;
- ctx->Const.GeometryProgram.MaxTextureImageUnits = 16;
- ctx->Const.GeometryProgram.MaxUniformComponents = 1024;
- ctx->Const.GeometryProgram.MaxInputComponents =
- ctx->Const.VertexProgram.MaxOutputComponents;
- ctx->Const.GeometryProgram.MaxOutputComponents = 128;
+ ctx->Const.Program[MESA_SHADER_GEOMETRY].MaxTextureImageUnits = 16;
+ ctx->Const.Program[MESA_SHADER_GEOMETRY].MaxUniformComponents = 1024;
+ ctx->Const.Program[MESA_SHADER_GEOMETRY].MaxInputComponents =
+ ctx->Const.Program[MESA_SHADER_VERTEX].MaxOutputComponents;
+ ctx->Const.Program[MESA_SHADER_GEOMETRY].MaxOutputComponents = 128;
- ctx->Const.FragmentProgram.MaxTextureImageUnits = 16;
- ctx->Const.FragmentProgram.MaxUniformComponents = 1024;
- ctx->Const.FragmentProgram.MaxInputComponents =
- ctx->Const.GeometryProgram.MaxOutputComponents;
- ctx->Const.FragmentProgram.MaxOutputComponents = 0; /* not used */
+ ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits = 16;
+ ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxUniformComponents = 1024;
+ ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxInputComponents =
+ ctx->Const.Program[MESA_SHADER_GEOMETRY].MaxOutputComponents;
+ ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxOutputComponents = 0; /* not used */
ctx->Const.MaxCombinedTextureImageUnits =
- ctx->Const.VertexProgram.MaxTextureImageUnits
- + ctx->Const.GeometryProgram.MaxTextureImageUnits
- + ctx->Const.FragmentProgram.MaxTextureImageUnits;
+ ctx->Const.Program[MESA_SHADER_VERTEX].MaxTextureImageUnits
+ + ctx->Const.Program[MESA_SHADER_GEOMETRY].MaxTextureImageUnits
+ + ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits;
ctx->Const.MaxGeometryOutputVertices = 256;
ctx->Const.MaxGeometryTotalOutputComponents = 1024;
@@ -178,18 +178,18 @@ initialize_context(struct gl_context *ctx, gl_api api)
ctx->Const.MaxTextureCoordUnits = 0;
ctx->Const.MaxTextureUnits = 0;
- ctx->Const.VertexProgram.MaxAttribs = 16;
- ctx->Const.VertexProgram.MaxTextureImageUnits = 16;
- ctx->Const.VertexProgram.MaxUniformComponents = 1024;
- ctx->Const.VertexProgram.MaxInputComponents = 0; /* not used */
- ctx->Const.VertexProgram.MaxOutputComponents = 16 * 4;
+ ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs = 16;
+ ctx->Const.Program[MESA_SHADER_VERTEX].MaxTextureImageUnits = 16;
+ ctx->Const.Program[MESA_SHADER_VERTEX].MaxUniformComponents = 1024;
+ ctx->Const.Program[MESA_SHADER_VERTEX].MaxInputComponents = 0; /* not used */
+ ctx->Const.Program[MESA_SHADER_VERTEX].MaxOutputComponents = 16 * 4;
- ctx->Const.FragmentProgram.MaxTextureImageUnits = 16;
- ctx->Const.FragmentProgram.MaxUniformComponents = 224;
- ctx->Const.FragmentProgram.MaxInputComponents = 15 * 4;
- ctx->Const.FragmentProgram.MaxOutputComponents = 0; /* not used */
+ ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits = 16;
+ ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxUniformComponents = 224;
+ ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxInputComponents = 15 * 4;
+ ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxOutputComponents = 0; /* not used */
- ctx->Const.MaxVarying = ctx->Const.FragmentProgram.MaxInputComponents / 4;
+ ctx->Const.MaxVarying = ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxInputComponents / 4;
break;
}
@@ -276,7 +276,7 @@ void
compile_shader(struct gl_context *ctx, struct gl_shader *shader)
{
struct _mesa_glsl_parse_state *state =
- new(shader) _mesa_glsl_parse_state(ctx, shader->Type, shader);
+ new(shader) _mesa_glsl_parse_state(ctx, shader->Stage, shader);
_mesa_glsl_compile_shader(ctx, shader, dump_ast, dump_hir);
@@ -362,6 +362,7 @@ main(int argc, char **argv)
shader->Type = GL_FRAGMENT_SHADER;
else
usage_fail(argv[0]);
+ shader->Stage = _mesa_shader_enum_to_shader_stage(shader->Type);
shader->Source = load_text_file(whole_program, argv[optind]);
if (shader->Source == NULL) {
@@ -388,7 +389,7 @@ main(int argc, char **argv)
printf("Info log for linking:\n%s\n", whole_program->InfoLog);
}
- for (unsigned i = 0; i < MESA_SHADER_TYPES; i++)
+ for (unsigned i = 0; i < MESA_SHADER_STAGES; i++)
ralloc_free(whole_program->_LinkedShaders[i]);
ralloc_free(whole_program);
diff --git a/mesalib/src/glsl/opt_algebraic.cpp b/mesalib/src/glsl/opt_algebraic.cpp
index 05a589989..332f0b77b 100644
--- a/mesalib/src/glsl/opt_algebraic.cpp
+++ b/mesalib/src/glsl/opt_algebraic.cpp
@@ -87,6 +87,12 @@ is_vec_one(ir_constant *ir)
return (ir == NULL) ? false : ir->is_one();
}
+static inline bool
+is_vec_two(ir_constant *ir)
+{
+ return (ir == NULL) ? false : ir->is_value(2.0, 2);
+}
+
static inline bool
is_vec_negative_one(ir_constant *ir)
{
@@ -416,6 +422,17 @@ ir_algebraic_visitor::handle_expression(ir_expression *ir)
}
break;
+ case ir_binop_pow:
+ /* 1^x == 1 */
+ if (is_vec_one(op_const[0]))
+ return op_const[0];
+
+ /* pow(2,x) == exp2(x) */
+ if (is_vec_two(op_const[0]))
+ return expr(ir_unop_exp2, ir->operands[1]);
+
+ break;
+
case ir_unop_rcp:
if (op_expr[0] && op_expr[0]->operation == ir_unop_rcp)
return op_expr[0]->operands[0];
diff --git a/mesalib/src/glsl/opt_dead_builtin_varyings.cpp b/mesalib/src/glsl/opt_dead_builtin_varyings.cpp
index a939a2b64..c2a306e7b 100644
--- a/mesalib/src/glsl/opt_dead_builtin_varyings.cpp
+++ b/mesalib/src/glsl/opt_dead_builtin_varyings.cpp
@@ -512,7 +512,7 @@ do_dead_builtin_varyings(struct gl_context *ctx,
tfeedback_decl *tfeedback_decls)
{
/* Lower the gl_FragData array to separate variables. */
- if (consumer && consumer->Type == GL_FRAGMENT_SHADER) {
+ if (consumer && consumer->Stage == MESA_SHADER_FRAGMENT) {
lower_fragdata_array(consumer->ir);
}
@@ -574,7 +574,7 @@ do_dead_builtin_varyings(struct gl_context *ctx,
* This doesn't prevent elimination of the gl_TexCoord elements which
* are not read by the fragment shader. We want to eliminate those anyway.
*/
- if (consumer->Type == GL_FRAGMENT_SHADER) {
+ if (consumer->Stage == MESA_SHADER_FRAGMENT) {
producer_info.texcoord_usage = (1 << MAX_TEXTURE_COORD_UNITS) - 1;
}
diff --git a/mesalib/src/glsl/standalone_scaffolding.cpp b/mesalib/src/glsl/standalone_scaffolding.cpp
index cbff6d182..257d2e7a9 100644
--- a/mesalib/src/glsl/standalone_scaffolding.cpp
+++ b/mesalib/src/glsl/standalone_scaffolding.cpp
@@ -76,6 +76,7 @@ _mesa_new_shader(struct gl_context *ctx, GLuint name, GLenum type)
shader = rzalloc(NULL, struct gl_shader);
if (shader) {
shader->Type = type;
+ shader->Stage = _mesa_shader_enum_to_shader_stage(type);
shader->Name = name;
shader->RefCount = 1;
}
@@ -126,16 +127,16 @@ void initialize_context_to_defaults(struct gl_context *ctx, gl_api api)
ctx->Const.MaxClipPlanes = 6;
ctx->Const.MaxTextureUnits = 2;
ctx->Const.MaxTextureCoordUnits = 2;
- ctx->Const.VertexProgram.MaxAttribs = 16;
+ ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs = 16;
- ctx->Const.VertexProgram.MaxUniformComponents = 512;
- ctx->Const.VertexProgram.MaxOutputComponents = 32;
+ ctx->Const.Program[MESA_SHADER_VERTEX].MaxUniformComponents = 512;
+ ctx->Const.Program[MESA_SHADER_VERTEX].MaxOutputComponents = 32;
ctx->Const.MaxVarying = 8; /* == gl_MaxVaryingFloats / 4 */
- ctx->Const.VertexProgram.MaxTextureImageUnits = 0;
+ ctx->Const.Program[MESA_SHADER_VERTEX].MaxTextureImageUnits = 0;
ctx->Const.MaxCombinedTextureImageUnits = 2;
- ctx->Const.FragmentProgram.MaxTextureImageUnits = 2;
- ctx->Const.FragmentProgram.MaxUniformComponents = 64;
- ctx->Const.FragmentProgram.MaxInputComponents = 32;
+ ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits = 2;
+ ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxUniformComponents = 64;
+ ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxInputComponents = 32;
ctx->Const.MaxDrawBuffers = 1;
@@ -148,6 +149,6 @@ void initialize_context_to_defaults(struct gl_context *ctx, gl_api api)
/* Default pragma settings */
options.DefaultPragmas.Optimize = true;
- for (int sh = 0; sh < MESA_SHADER_TYPES; ++sh)
+ for (int sh = 0; sh < MESA_SHADER_STAGES; ++sh)
memcpy(&ctx->ShaderCompilerOptions[sh], &options, sizeof(options));
}
diff --git a/mesalib/src/glsl/standalone_scaffolding.h b/mesalib/src/glsl/standalone_scaffolding.h
index 9f4818a8a..327fef2df 100644
--- a/mesalib/src/glsl/standalone_scaffolding.h
+++ b/mesalib/src/glsl/standalone_scaffolding.h
@@ -48,8 +48,8 @@ extern "C" void
_mesa_shader_debug(struct gl_context *ctx, GLenum type, GLuint *id,
const char *msg, int len);
-static inline gl_shader_type
-_mesa_shader_type_to_index(GLenum v)
+static inline gl_shader_stage
+_mesa_shader_enum_to_shader_stage(GLenum v)
{
switch (v) {
case GL_VERTEX_SHADER:
@@ -59,7 +59,7 @@ _mesa_shader_type_to_index(GLenum v)
case GL_GEOMETRY_SHADER:
return MESA_SHADER_GEOMETRY;
default:
- assert(!"bad value in _mesa_shader_type_to_index()");
+ assert(!"bad value in _mesa_shader_enum_to_shader_stage()");
return MESA_SHADER_VERTEX;
}
}
diff --git a/mesalib/src/glsl/test_optpass.cpp b/mesalib/src/glsl/test_optpass.cpp
index 67e2ab2b1..1a15f3c63 100644
--- a/mesalib/src/glsl/test_optpass.cpp
+++ b/mesalib/src/glsl/test_optpass.cpp
@@ -204,11 +204,12 @@ int test_optpass(int argc, char **argv)
struct gl_shader *shader = rzalloc(NULL, struct gl_shader);
shader->Type = shader_type;
+ shader->Stage = _mesa_shader_enum_to_shader_stage(shader_type);
string input = read_stdin_to_eof();
struct _mesa_glsl_parse_state *state
- = new(shader) _mesa_glsl_parse_state(ctx, shader->Type, shader);
+ = new(shader) _mesa_glsl_parse_state(ctx, shader->Stage, shader);
if (input_format_ir) {
shader->ir = new(shader) exec_list;
@@ -242,7 +243,7 @@ int test_optpass(int argc, char **argv)
if (!state->error) {
GLboolean progress;
const struct gl_shader_compiler_options *options =
- &ctx->ShaderCompilerOptions[_mesa_shader_type_to_index(shader_type)];
+ &ctx->ShaderCompilerOptions[_mesa_shader_enum_to_shader_stage(shader_type)];
do {
progress = do_optimization_passes(shader->ir, &argv[optind],
argc - optind, quiet != 0, options);
diff --git a/mesalib/src/hgl/GLDispatcher.cpp b/mesalib/src/hgl/GLDispatcher.cpp
new file mode 100644
index 000000000..46b91d57c
--- /dev/null
+++ b/mesalib/src/hgl/GLDispatcher.cpp
@@ -0,0 +1,72 @@
+/*
+ * Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
+ * Copyright 2000-2012 Haiku, Inc. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ *
+ * Authors:
+ * Brian Paul
+ * Philippe Houdoin
+ * Alexander von Gluck IV
+ */
+
+
+extern "C" {
+#include "glapi/glapi.h"
+#include "glapi/glapi_priv.h"
+
+/*
+ * NOTE: this file portion implements C-based dispatch of the OpenGL entrypoints
+ * (glAccum, glBegin, etc).
+ * This code IS NOT USED if we're compiling on an x86 system and using
+ * the glapi_x86.S assembly code.
+ */
+#if !(defined(USE_X86_ASM) || defined(USE_SPARC_ASM))
+
+#define KEYWORD1 PUBLIC
+#define KEYWORD2
+#define NAME(func) gl##func
+
+#define DISPATCH(func, args, msg) \
+ const struct _glapi_table* dispatch; \
+ dispatch = _glapi_Dispatch ? _glapi_Dispatch : _glapi_get_dispatch();\
+ (dispatch->func) args
+
+#define RETURN_DISPATCH(func, args, msg) \
+ const struct _glapi_table* dispatch; \
+ dispatch = _glapi_Dispatch ? _glapi_Dispatch : _glapi_get_dispatch();\
+ return (dispatch->func) args
+
+#endif
+}
+
+
+/* NOTE: this file portion implement a thin OpenGL entrypoints dispatching
+ C++ wrapper class
+ */
+
+#include "GLDispatcher.h"
+
+BGLDispatcher::BGLDispatcher()
+{
+}
+
+
+BGLDispatcher::~BGLDispatcher()
+{
+}
+
+
+status_t
+BGLDispatcher::CheckTable(const struct _glapi_table* table)
+{
+ _glapi_check_table(table ? table : _glapi_get_dispatch());
+ return B_OK;
+}
+
+
+status_t
+BGLDispatcher::SetTable(struct _glapi_table* table)
+{
+ _glapi_set_dispatch(table);
+ return B_OK;
+}
diff --git a/mesalib/src/hgl/GLDispatcher.h b/mesalib/src/hgl/GLDispatcher.h
new file mode 100644
index 000000000..44bca8ce5
--- /dev/null
+++ b/mesalib/src/hgl/GLDispatcher.h
@@ -0,0 +1,109 @@
+/*
+ * Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
+ * Copyright 2000-2012 Haiku, Inc. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ *
+ * Authors:
+ * Brian Paul
+ * Philippe Houdoin
+ */
+#ifndef GLDISPATCHER_H
+#define GLDISPATCHER_H
+
+
+#include
+#include
+#include
+
+#include "glheader.h"
+
+extern "C" {
+#include "glapi/glapi.h"
+}
+
+
+class BGLDispatcher
+{
+ // Private unimplemented copy constructors
+ BGLDispatcher(const BGLDispatcher &);
+ BGLDispatcher & operator=(const BGLDispatcher &);
+
+ public:
+ BGLDispatcher();
+ ~BGLDispatcher();
+
+ void SetCurrentContext(void* context);
+ void* CurrentContext();
+
+ struct _glapi_table* Table();
+ status_t CheckTable(
+ const struct _glapi_table* dispatch = NULL);
+ status_t SetTable(struct _glapi_table* dispatch);
+ uint32 TableSize();
+
+ const _glapi_proc operator[](const char* functionName);
+ const char* operator[](uint32 offset);
+
+ const _glapi_proc AddressOf(const char* functionName);
+ uint32 OffsetOf(const char* functionName);
+};
+
+
+// Inlines methods
+inline void
+BGLDispatcher::SetCurrentContext(void* context)
+{
+ _glapi_set_context(context);
+}
+
+
+inline void*
+BGLDispatcher::CurrentContext()
+{
+ return _glapi_get_context();
+}
+
+
+inline struct _glapi_table*
+BGLDispatcher::Table()
+{
+ return _glapi_get_dispatch();
+}
+
+
+inline uint32
+BGLDispatcher::TableSize()
+{
+ return _glapi_get_dispatch_table_size();
+}
+
+
+inline const _glapi_proc
+BGLDispatcher::operator[](const char* functionName)
+{
+ return _glapi_get_proc_address(functionName);
+}
+
+
+inline const char*
+BGLDispatcher::operator[](uint32 offset)
+{
+ return _glapi_get_proc_name((GLuint) offset);
+}
+
+
+inline const _glapi_proc
+BGLDispatcher::AddressOf(const char* functionName)
+{
+ return _glapi_get_proc_address(functionName);
+}
+
+
+inline uint32
+BGLDispatcher::OffsetOf(const char* functionName)
+{
+ return (uint32) _glapi_get_proc_offset(functionName);
+}
+
+
+#endif // GLDISPATCHER_H
diff --git a/mesalib/src/hgl/GLRenderer.cpp b/mesalib/src/hgl/GLRenderer.cpp
new file mode 100644
index 000000000..4573a64a3
--- /dev/null
+++ b/mesalib/src/hgl/GLRenderer.cpp
@@ -0,0 +1,106 @@
+/*
+ * Copyright 2006-2008, Philippe Houdoin. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+
+
+#include
+
+#include "GLRenderer.h"
+
+#include "GLDispatcher.h"
+
+
+BGLRenderer::BGLRenderer(BGLView* view, ulong glOptions,
+ BGLDispatcher* dispatcher)
+ :
+ fRefCount(1),
+ fView(view),
+ fOptions(glOptions),
+ fDispatcher(dispatcher)
+{
+}
+
+
+BGLRenderer::~BGLRenderer()
+{
+ delete fDispatcher;
+}
+
+
+void
+BGLRenderer::Acquire()
+{
+ atomic_add(&fRefCount, 1);
+}
+
+
+void
+BGLRenderer::Release()
+{
+ if (atomic_add(&fRefCount, -1) < 1)
+ delete this;
+}
+
+
+void
+BGLRenderer::LockGL()
+{
+}
+
+
+void
+BGLRenderer::UnlockGL()
+{
+}
+
+
+void
+BGLRenderer::SwapBuffers(bool VSync)
+{
+}
+
+
+void
+BGLRenderer::Draw(BRect updateRect)
+{
+}
+
+
+status_t
+BGLRenderer::CopyPixelsOut(BPoint source, BBitmap* dest)
+{
+ return B_ERROR;
+}
+
+
+status_t
+BGLRenderer::CopyPixelsIn(BBitmap* source, BPoint dest)
+{
+ return B_ERROR;
+}
+
+
+void
+BGLRenderer::FrameResized(float width, float height)
+{
+}
+
+
+void
+BGLRenderer::DirectConnected(direct_buffer_info* info)
+{
+}
+
+
+void
+BGLRenderer::EnableDirectMode(bool enabled)
+{
+}
+
+
+status_t BGLRenderer::_Reserved_Renderer_0(int32 n, void* p) { return B_ERROR; }
+status_t BGLRenderer::_Reserved_Renderer_1(int32 n, void* p) { return B_ERROR; }
+status_t BGLRenderer::_Reserved_Renderer_2(int32 n, void* p) { return B_ERROR; }
+status_t BGLRenderer::_Reserved_Renderer_3(int32 n, void* p) { return B_ERROR; }
+status_t BGLRenderer::_Reserved_Renderer_4(int32 n, void* p) { return B_ERROR; }
diff --git a/mesalib/src/hgl/GLRendererRoster.cpp b/mesalib/src/hgl/GLRendererRoster.cpp
new file mode 100644
index 000000000..1712a871c
--- /dev/null
+++ b/mesalib/src/hgl/GLRendererRoster.cpp
@@ -0,0 +1,224 @@
+/*
+ * Copyright 2006-2012 Haiku, Inc. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ *
+ * Authors:
+ * Philippe Houdoin
+ * Alexander von Gluck IV
+ */
+
+
+#include
+#include
+
+#include
+#include
+
+#include
+#include
+#include
+#include
+#include "GLDispatcher.h"
+#include "GLRendererRoster.h"
+
+#include
+#include
+
+
+extern "C" status_t _kern_get_safemode_option(const char* parameter,
+ char* buffer, size_t* _bufferSize);
+
+
+GLRendererRoster::GLRendererRoster(BGLView* view, ulong options)
+ :
+ fNextID(0),
+ fView(view),
+ fOptions(options),
+ fSafeMode(false),
+ fABISubDirectory(NULL)
+{
+ char parameter[32];
+ size_t parameterLength = sizeof(parameter);
+
+ if (_kern_get_safemode_option(B_SAFEMODE_SAFE_MODE,
+ parameter, ¶meterLength) == B_OK) {
+ if (!strcasecmp(parameter, "enabled") || !strcasecmp(parameter, "on")
+ || !strcasecmp(parameter, "true") || !strcasecmp(parameter, "yes")
+ || !strcasecmp(parameter, "enable") || !strcmp(parameter, "1"))
+ fSafeMode = true;
+ }
+
+ if (_kern_get_safemode_option(B_SAFEMODE_DISABLE_USER_ADD_ONS,
+ parameter, ¶meterLength) == B_OK) {
+ if (!strcasecmp(parameter, "enabled") || !strcasecmp(parameter, "on")
+ || !strcasecmp(parameter, "true") || !strcasecmp(parameter, "yes")
+ || !strcasecmp(parameter, "enable") || !strcmp(parameter, "1"))
+ fSafeMode = true;
+ }
+
+ // We might run in compatibility mode on a system with a different ABI. The
+ // renderers matching our ABI can usually be found in respective
+ // subdirectories of the opengl add-ons directories.
+ system_info info;
+ if (get_system_info(&info) == B_OK
+ && (info.abi & B_HAIKU_ABI_MAJOR)
+ != (B_HAIKU_ABI & B_HAIKU_ABI_MAJOR)) {
+ switch (B_HAIKU_ABI & B_HAIKU_ABI_MAJOR) {
+ case B_HAIKU_ABI_GCC_2:
+ fABISubDirectory = "gcc2";
+ break;
+ case B_HAIKU_ABI_GCC_4:
+ fABISubDirectory = "gcc4";
+ break;
+ }
+ }
+
+ AddDefaultPaths();
+}
+
+
+GLRendererRoster::~GLRendererRoster()
+{
+
+}
+
+
+BGLRenderer*
+GLRendererRoster::GetRenderer(int32 id)
+{
+ RendererMap::const_iterator iterator = fRenderers.find(id);
+ if (iterator == fRenderers.end())
+ return NULL;
+
+ struct renderer_item item = iterator->second;
+ return item.renderer;
+}
+
+
+void
+GLRendererRoster::AddDefaultPaths()
+{
+ // add user directories first, so that they can override system renderers
+ const directory_which paths[] = {
+ B_USER_NONPACKAGED_ADDONS_DIRECTORY,
+ B_USER_ADDONS_DIRECTORY,
+ B_SYSTEM_ADDONS_DIRECTORY,
+ };
+
+ for (uint32 i = fSafeMode ? 4 : 0;
+ i < sizeof(paths) / sizeof(paths[0]); i++) {
+ BPath path;
+ status_t status = find_directory(paths[i], &path, true);
+ if (status == B_OK && path.Append("opengl") == B_OK)
+ AddPath(path.Path());
+ }
+}
+
+
+status_t
+GLRendererRoster::AddPath(const char* path)
+{
+ BDirectory directory(path);
+ status_t status = directory.InitCheck();
+ if (status < B_OK)
+ return status;
+
+ // if a subdirectory for our ABI exists, use that instead
+ if (fABISubDirectory != NULL) {
+ BEntry entry(&directory, fABISubDirectory);
+ if (entry.IsDirectory()) {
+ status = directory.SetTo(&entry);
+ if (status != B_OK)
+ return status;
+ }
+ }
+
+ node_ref nodeRef;
+ status = directory.GetNodeRef(&nodeRef);
+ if (status < B_OK)
+ return status;
+
+ int32 count = 0;
+ int32 files = 0;
+
+ entry_ref ref;
+ BEntry entry;
+ while (directory.GetNextRef(&ref) == B_OK) {
+ entry.SetTo(&ref);
+ if (entry.InitCheck() == B_OK && !entry.IsFile())
+ continue;
+
+ if (CreateRenderer(ref) == B_OK)
+ count++;
+
+ files++;
+ }
+
+ if (files != 0 && count == 0)
+ return B_BAD_VALUE;
+
+ return B_OK;
+}
+
+
+status_t
+GLRendererRoster::AddRenderer(BGLRenderer* renderer,
+ image_id image, const entry_ref* ref, ino_t node)
+{
+ renderer_item item;
+ item.renderer = renderer;
+ item.image = image;
+ item.node = node;
+ if (ref != NULL)
+ item.ref = *ref;
+
+ try {
+ fRenderers[fNextID] = item;
+ } catch (...) {
+ return B_NO_MEMORY;
+ }
+
+ renderer->fOwningRoster = this;
+ renderer->fID = fNextID++;
+ return B_OK;
+}
+
+
+status_t
+GLRendererRoster::CreateRenderer(const entry_ref& ref)
+{
+ BEntry entry(&ref);
+ node_ref nodeRef;
+ status_t status = entry.GetNodeRef(&nodeRef);
+ if (status < B_OK)
+ return status;
+
+ BPath path(&ref);
+ image_id image = load_add_on(path.Path());
+ if (image < B_OK)
+ return image;
+
+ BGLRenderer* (*instantiate_renderer)
+ (BGLView* view, ulong options, BGLDispatcher* dispatcher);
+
+ status = get_image_symbol(image, "instantiate_gl_renderer",
+ B_SYMBOL_TYPE_TEXT, (void**)&instantiate_renderer);
+ if (status == B_OK) {
+ BGLRenderer* renderer
+ = instantiate_renderer(fView, fOptions, new BGLDispatcher());
+ if (!renderer) {
+ unload_add_on(image);
+ return B_UNSUPPORTED;
+ }
+
+ if (AddRenderer(renderer, image, &ref, nodeRef.node) != B_OK) {
+ renderer->Release();
+ // this will delete the renderer
+ unload_add_on(image);
+ }
+ return B_OK;
+ }
+ unload_add_on(image);
+
+ return status;
+}
diff --git a/mesalib/src/hgl/GLRendererRoster.h b/mesalib/src/hgl/GLRendererRoster.h
new file mode 100644
index 000000000..5c8da2711
--- /dev/null
+++ b/mesalib/src/hgl/GLRendererRoster.h
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2006-2012, Haiku, Inc. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ *
+ * Authors:
+ * Philippe Houdoin
+ */
+#ifndef _GLRENDERER_ROSTER_H
+#define _GLRENDERER_ROSTER_H
+
+
+#include
+
+#include