_mesa_glsl_error(&loc, state, "align layout qualifier "
"is not a power of 2");
} else {
- fields[i].offset = glsl_align(offset, member_align);
+ fields[i].offset = align(offset, member_align);
next_offset = fields[i].offset + size;
}
}
} else {
- fields[i].offset = glsl_align(offset, expl_align);
+ fields[i].offset = align(offset, expl_align);
next_offset = fields[i].offset + size;
}
} else if (!qual->flags.q.explicit_offset) {
if (base_alignment != 0 && size != 0)
- next_offset = glsl_align(next_offset, base_alignment) + size;
+ next_offset = align(next_offset, base_alignment) + size;
}
/* From the ARB_enhanced_layouts spec:
} else {
if (layout && layout->flags.q.explicit_xfb_offset) {
unsigned base_alignment = field_type->is_64bit() ? 8 : 4;
- fields[i].offset = glsl_align(block_xfb_offset, base_alignment);
+ fields[i].offset = align(block_xfb_offset, base_alignment);
block_xfb_offset += 4 * field_type->component_slots();
}
}
#include "ir_uniform.h" /* for gl_uniform_storage */
#include "linker_util.h"
#include "main/shader_types.h"
+#include "util/u_math.h"
/**
* This file contains code to do a nir-based linking for uniform blocks. This
* or end-of-structure padding), adding one, and rounding up to the next
* multiple of the base alignment required for a vec4."
*/
- block->UniformBufferSize = glsl_align(block->UniformBufferSize, 16);
+ block->UniformBufferSize = align(block->UniformBufferSize, 16);
}
/*
#include "compiler/glsl/ir_uniform.h" /* for gl_uniform_storage */
#include "linker_util.h"
#include "util/u_dynarray.h"
+#include "util/u_math.h"
#include "main/consts_exts.h"
#include "main/shader_types.h"
use_std430);
if (packing == GLSL_INTERFACE_PACKING_STD430)
- state->offset = glsl_align(
+ state->offset = align(
state->offset, glsl_get_std430_base_alignment(type, row_major));
else
- state->offset = glsl_align(
+ state->offset = align(
state->offset, glsl_get_std140_base_alignment(type, row_major));
}
use_std430);
if (packing == GLSL_INTERFACE_PACKING_STD430)
- state->offset = glsl_align(
+ state->offset = align(
state->offset, glsl_get_std430_base_alignment(type, row_major));
else
- state->offset = glsl_align(
+ state->offset = align(
state->offset, glsl_get_std140_base_alignment(type, row_major));
}
alignment =
glsl_get_std430_base_alignment(type, uniform->row_major);
}
- state->offset = glsl_align(state->offset, alignment);
+ state->offset = align(state->offset, alignment);
}
}
#include "ir_uniform.h"
#include "link_uniform_block_active_visitor.h"
#include "util/hash_table.h"
+#include "util/u_math.h"
#include "program.h"
#include "main/errors.h"
#include "main/shader_types.h"
{
assert(type->is_struct());
if (packing == GLSL_INTERFACE_PACKING_STD430)
- this->offset = glsl_align(
+ this->offset = align(
this->offset, type->std430_base_alignment(row_major));
else
- this->offset = glsl_align(
+ this->offset = align(
this->offset, type->std140_base_alignment(row_major));
}
* multiple of the base alignment of the structure.
*/
if (packing == GLSL_INTERFACE_PACKING_STD430)
- this->offset = glsl_align(
+ this->offset = align(
this->offset, type->std430_base_alignment(row_major));
else
- this->offset = glsl_align(
+ this->offset = align(
this->offset, type->std140_base_alignment(row_major));
}
size = type_for_size->std140_size(v->RowMajor);
}
- this->offset = glsl_align(this->offset, alignment);
+ this->offset = align(this->offset, alignment);
v->Offset = this->offset;
this->offset += size;
* rounding up to the next multiple of the base alignment required
* for a vec4.
*/
- this->buffer_size = glsl_align(this->offset, 16);
+ this->buffer_size = align(this->offset, 16);
}
bool use_std430_as_default;
#include "main/shader_types.h"
#include "main/consts_exts.h"
#include "util/strndup.h"
+#include "util/u_math.h"
/**
* \file link_uniforms.cpp
* vec4.
*/
return packing == GLSL_INTERFACE_PACKING_STD430
- ? (items < 3 ? items * N : glsl_align(items * N, 16))
- : glsl_align(items * N, 16);
+ ? (items < 3 ? items * N : align(items * N, 16))
+ : align(items * N, 16);
}
if (field_type->is_unsized_array())
continue;
- size = glsl_align(size, base_alignment);
+ size = align(size, base_alignment);
size += field_type->std140_size(field_row_major);
max_align = MAX2(base_alignment, max_align);
if (field_type->is_struct() && (i + 1 < this->length))
- size = glsl_align(size, 16);
+ size = align(size, 16);
}
- size = glsl_align(size, MAX2(max_align, 16));
+ size = align(size, MAX2(max_align, 16));
return size;
}
else
vec_type = get_instance(this->base_type, this->vector_elements, 1);
unsigned elem_size = vec_type->std140_size(false);
- unsigned stride = glsl_align(elem_size, 16);
+ unsigned stride = align(elem_size, 16);
return get_instance(this->base_type, this->vector_elements,
this->matrix_columns, stride, row_major);
} else if (this->is_array()) {
unsigned elem_size = this->fields.array->std140_size(row_major);
const glsl_type *elem_type =
this->fields.array->get_explicit_std140_type(row_major);
- unsigned stride = glsl_align(elem_size, 16);
+ unsigned stride = align(elem_size, 16);
return get_array_instance(elem_type, this->length, stride);
} else if (this->is_struct() || this->is_interface()) {
glsl_struct_field *fields = new glsl_struct_field[this->length];
assert((unsigned)fields[i].offset >= offset);
offset = fields[i].offset;
}
- offset = glsl_align(offset, falign);
+ offset = align(offset, falign);
fields[i].offset = offset;
offset += fsize;
}
const struct glsl_type *field_type = this->fields.structure[i].type;
unsigned base_alignment = field_type->std430_base_alignment(field_row_major);
- size = glsl_align(size, base_alignment);
+ size = align(size, base_alignment);
size += field_type->std430_size(field_row_major);
max_align = MAX2(base_alignment, max_align);
}
- size = glsl_align(size, max_align);
+ size = align(size, max_align);
return size;
}
assert((unsigned)fields[i].offset >= offset);
offset = fields[i].offset;
}
- offset = glsl_align(offset, falign);
+ offset = align(offset, falign);
fields[i].offset = offset;
offset += fsize;
}
bool out;
};
-static inline unsigned int
-glsl_align(unsigned int a, unsigned int align)
-{
- return (a + align - 1) / align * align;
-}
-
#endif /* GLSL_TYPES_H */