Cleanup: replace attrib w/ attr
authorCampbell Barton <ideasman42@gmail.com>
Mon, 28 Jan 2019 20:46:25 +0000 (07:46 +1100)
committerCampbell Barton <ideasman42@gmail.com>
Mon, 28 Jan 2019 21:32:25 +0000 (08:32 +1100)
Also rename GPUVertexAttribs to GPUVertAttrLayers,
avoids confusion with GPUVertAttr which isn't closely related.

76 files changed:
source/blender/draw/engines/eevee/eevee_lightprobes.c
source/blender/draw/engines/eevee/eevee_render.c
source/blender/draw/engines/eevee/shaders/background_vert.glsl
source/blender/draw/engines/eevee/shaders/lightprobe_geom.glsl
source/blender/draw/engines/eevee/shaders/lit_surface_vert.glsl
source/blender/draw/engines/eevee/shaders/shadow_vert.glsl
source/blender/draw/engines/eevee/shaders/volumetric_geom.glsl
source/blender/draw/intern/DRW_render.h
source/blender/draw/intern/draw_cache_impl_curve.c
source/blender/draw/intern/draw_cache_impl_mesh.c
source/blender/draw/intern/draw_cache_impl_particles.c
source/blender/draw/intern/draw_common.c
source/blender/draw/intern/draw_instance_data.c
source/blender/draw/intern/draw_instance_data.h
source/blender/draw/intern/draw_manager.c
source/blender/draw/intern/draw_manager.h
source/blender/draw/intern/draw_manager_data.c
source/blender/draw/modes/object_mode.c
source/blender/draw/modes/shaders/armature_axes_vert.glsl
source/blender/draw/modes/shaders/armature_dof_vert.glsl
source/blender/draw/modes/shaders/armature_envelope_outline_vert.glsl
source/blender/draw/modes/shaders/armature_envelope_solid_vert.glsl
source/blender/draw/modes/shaders/armature_shape_outline_vert.glsl
source/blender/draw/modes/shaders/armature_shape_solid_vert.glsl
source/blender/draw/modes/shaders/armature_sphere_outline_vert.glsl
source/blender/draw/modes/shaders/armature_sphere_solid_vert.glsl
source/blender/draw/modes/shaders/armature_stick_vert.glsl
source/blender/draw/modes/shaders/common_hair_lib.glsl
source/blender/draw/modes/shaders/common_hair_refine_vert.glsl
source/blender/draw/modes/shaders/edit_mesh_overlay_geom_tri.glsl
source/blender/draw/modes/shaders/object_empty_axes_vert.glsl
source/blender/draw/modes/shaders/object_mball_handles_vert.glsl
source/blender/draw/modes/shaders/paint_vertex_frag.glsl
source/blender/draw/modes/shaders/paint_vertex_vert.glsl
source/blender/editors/interface/interface_draw.c
source/blender/editors/object/object_transform.c
source/blender/editors/sculpt_paint/paint_cursor.c
source/blender/gpu/GPU_attr_binding.h
source/blender/gpu/GPU_batch.h
source/blender/gpu/GPU_draw.h
source/blender/gpu/GPU_immediate.h
source/blender/gpu/GPU_material.h
source/blender/gpu/GPU_shader.h
source/blender/gpu/GPU_shader_interface.h
source/blender/gpu/GPU_vertex_buffer.h
source/blender/gpu/GPU_vertex_format.h
source/blender/gpu/intern/gpu_attr_binding.c
source/blender/gpu/intern/gpu_attr_binding_private.h
source/blender/gpu/intern/gpu_batch.c
source/blender/gpu/intern/gpu_codegen.c
source/blender/gpu/intern/gpu_codegen.h
source/blender/gpu/intern/gpu_draw.c
source/blender/gpu/intern/gpu_framebuffer.c
source/blender/gpu/intern/gpu_immediate.c
source/blender/gpu/intern/gpu_immediate_util.c
source/blender/gpu/intern/gpu_material.c
source/blender/gpu/intern/gpu_select_pick.c
source/blender/gpu/intern/gpu_select_sample_query.c
source/blender/gpu/intern/gpu_shader.c
source/blender/gpu/intern/gpu_shader_interface.c
source/blender/gpu/intern/gpu_shader_private.h
source/blender/gpu/intern/gpu_texture.c
source/blender/gpu/intern/gpu_vertex_buffer.c
source/blender/gpu/intern/gpu_vertex_format.c
source/blender/gpu/shaders/gpu_shader_2D_nodelink_vert.glsl
source/blender/gpu/shaders/gpu_shader_instance_camera_vert.glsl
source/blender/gpu/shaders/gpu_shader_instance_distance_line_vert.glsl
source/blender/gpu/shaders/gpu_shader_instance_edges_variying_color_vert.glsl
source/blender/gpu/shaders/gpu_shader_instance_objectspace_variying_color_vert.glsl
source/blender/gpu/shaders/gpu_shader_instance_screen_aligned_vert.glsl
source/blender/gpu/shaders/gpu_shader_instance_screenspace_variying_color_vert.glsl
source/blender/gpu/shaders/gpu_shader_instance_variying_size_variying_color_vert.glsl
source/blender/gpu/shaders/gpu_shader_instance_variying_size_variying_id_vert.glsl
source/blender/gpu/shaders/gpu_shader_instance_vert.glsl
source/blender/gpu/shaders/gpu_shader_material.glsl
source/blender/python/gpu/gpu_py_vertex_buffer.c

index 7232db4..4c98739 100644 (file)
@@ -408,8 +408,8 @@ void EEVEE_lightprobes_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedat
 
                /* Planar Display */
                DRW_shgroup_instance_format(e_data.format_probe_display_planar, {
-                   {"probe_id", DRW_ATTRIB_INT, 1},
-                   {"probe_mat", DRW_ATTRIB_FLOAT, 16},
+                   {"probe_id", DRW_ATTR_INT, 1},
+                   {"probe_mat", DRW_ATTR_FLOAT, 16},
                });
 
                DRWShadingGroup *grp = DRW_shgroup_instance_create(
index ac6f072..34eaa0f 100644 (file)
@@ -478,7 +478,7 @@ void EEVEE_render_draw(EEVEE_Data *vedata, RenderEngine *engine, RenderLayer *rl
        /* Sort transparents before the loop. */
        DRW_pass_sort_shgroup_z(psl->transparent_pass);
 
-       /* Push instances attribs to the GPU. */
+       /* Push instances attributes to the GPU. */
        DRW_render_instance_buffer_finish();
 
        /* Need to be called after DRW_render_instance_buffer_finish() */
index 380d6d9..8b4bc33 100644 (file)
@@ -21,7 +21,7 @@ void main()
        worldNormal = viewNormal = normalize(-viewPosition);
 #endif
 
-#ifdef ATTRIB
-       pass_attrib(viewPosition);
+#ifdef USE_ATTR
+       pass_attr(viewPosition);
 #endif
 }
index 2ce37d8..996b507 100644 (file)
@@ -24,8 +24,8 @@ void main() {
        for (int v = 0; v < 3; ++v) {
                gl_Position = vPos[v];
                worldPosition = x_axis[fFace] * vPos[v].x + y_axis[fFace] * vPos[v].y + maj_axes[fFace];
-#ifdef ATTRIB
-               pass_attrib(v);
+#ifdef USE_ATTR
+               pass_attr(v);
 #endif
                EmitVertex();
        }
index a6e6f1f..ef7213c 100644 (file)
@@ -2,7 +2,7 @@
 uniform mat4 ModelViewProjectionMatrix;
 uniform mat4 ModelViewMatrix;
 uniform mat3 WorldNormalMatrix;
-#ifndef ATTRIB
+#ifndef USE_ATTR
 uniform mat4 ModelMatrix;
 uniform mat3 NormalMatrix;
 uniform mat4 ModelMatrixInverse;
@@ -73,7 +73,7 @@ void main()
        /* Used for planar reflections */
        gl_ClipDistance[0] = dot(vec4(worldPosition, 1.0), ClipPlanes[0]);
 
-#ifdef ATTRIB
-       pass_attrib(pos);
+#ifdef USE_ATTR
+       pass_attr(pos);
 #endif
 }
index cfd24ae..2583c7c 100644 (file)
@@ -3,7 +3,7 @@ uniform mat4 ModelViewProjectionMatrix;
 #ifdef MESH_SHADER
 uniform mat4 ModelViewMatrix;
 uniform mat3 WorldNormalMatrix;
-#  ifndef ATTRIB
+#  ifndef USE_ATTR
 uniform mat4 ModelMatrix;
 uniform mat3 NormalMatrix;
 #  endif
@@ -26,8 +26,8 @@ void main() {
        worldPosition = (ModelMatrix * vec4(pos, 1.0)).xyz;
        viewNormal = normalize(NormalMatrix * nor);
        worldNormal = normalize(WorldNormalMatrix * nor);
-#ifdef ATTRIB
-       pass_attrib(pos);
+#ifdef USE_ATTR
+       pass_attr(pos);
 #endif
 #endif
 }
index d435bda..7254530 100644 (file)
@@ -17,20 +17,20 @@ flat out int slice;
 void main() {
        gl_Layer = slice = int(vPos[0].z);
 
-#ifdef ATTRIB
-       pass_attrib(0);
+#ifdef USE_ATTR
+       pass_attr(0);
 #endif
        gl_Position = vPos[0].xyww;
        EmitVertex();
 
-#ifdef ATTRIB
-       pass_attrib(1);
+#ifdef USE_ATTR
+       pass_attr(1);
 #endif
        gl_Position = vPos[1].xyww;
        EmitVertex();
 
-#ifdef ATTRIB
-       pass_attrib(2);
+#ifdef USE_ATTR
+       pass_attr(2);
 #endif
        gl_Position = vPos[2].xyww;
        EmitVertex();
@@ -46,20 +46,20 @@ void main() {
 void main() {
        gl_Layer = slice = int(vPos[0].z);
 
-#ifdef ATTRIB
-       pass_attrib(0);
+#ifdef USE_ATTR
+       pass_attr(0);
 #endif
        gl_Position = vPos[0].xyww;
        EmitVertex();
 
-#ifdef ATTRIB
-       pass_attrib(1);
+#ifdef USE_ATTR
+       pass_attr(1);
 #endif
        gl_Position = vPos[1].xyww;
        EmitVertex();
 
-#ifdef ATTRIB
-       pass_attrib(2);
+#ifdef USE_ATTR
+       pass_attr(2);
 #endif
        gl_Position = vPos[2].xyww;
        EmitVertex();
index 5bda5bc..1c55d0f 100644 (file)
@@ -319,21 +319,21 @@ typedef enum {
 #define DRW_STATE_DEFAULT (DRW_STATE_WRITE_DEPTH | DRW_STATE_WRITE_COLOR | DRW_STATE_DEPTH_LESS_EQUAL)
 
 typedef enum {
-       DRW_ATTRIB_INT,
-       DRW_ATTRIB_FLOAT,
-} DRWAttribType;
+       DRW_ATTR_INT,
+       DRW_ATTR_FLOAT,
+} eDRWAttrType;
 
-typedef struct DRWInstanceAttribFormat {
+typedef struct DRWInstanceAttrFormat {
        char name[32];
-       DRWAttribType type;
+       eDRWAttrType type;
        int components;
-} DRWInstanceAttribFormat;
+} DRWInstanceAttrFormat;
 
-struct GPUVertFormat *DRW_shgroup_instance_format_array(const DRWInstanceAttribFormat attribs[], int arraysize);
+struct GPUVertFormat *DRW_shgroup_instance_format_array(const DRWInstanceAttrFormat attrs[], int arraysize);
 #define DRW_shgroup_instance_format(format, ...) do { \
        if (format == NULL) { \
-               DRWInstanceAttribFormat drw_format[] = __VA_ARGS__;\
-               format = DRW_shgroup_instance_format_array(drw_format, (sizeof(drw_format) / sizeof(DRWInstanceAttribFormat))); \
+               DRWInstanceAttrFormat drw_format[] = __VA_ARGS__;\
+               format = DRW_shgroup_instance_format_array(drw_format, (sizeof(drw_format) / sizeof(DRWInstanceAttrFormat))); \
        } \
 } while (0)
 
@@ -383,7 +383,7 @@ void DRW_shgroup_call_object_add_ex(
 void DRW_shgroup_call_object_add_with_callback(
         DRWShadingGroup *shgroup, struct GPUBatch *geom, struct Object *ob, struct Material *ma,
         DRWCallVisibilityFn *callback, void *user_data);
-/* Used for drawing a batch with instancing without instance attribs. */
+/* Used for drawing a batch with instancing without instance attributes. */
 void DRW_shgroup_call_instances_add(
         DRWShadingGroup *shgroup, struct GPUBatch *geom, float (*obmat)[4], uint *count);
 void DRW_shgroup_call_object_instances_add(
index b18168a..742ca20 100644 (file)
@@ -304,16 +304,16 @@ static int curve_render_data_normal_len_get(const CurveRenderData *rdata)
 
 static void curve_cd_calc_used_gpu_layers(int *cd_layers, struct GPUMaterial **gpumat_array, int gpumat_array_len)
 {
-       GPUVertexAttribs gattribs = {{{0}}};
+       GPUVertAttrLayers gpu_attrs = {{{0}}};
        for (int i = 0; i < gpumat_array_len; i++) {
                struct GPUMaterial *gpumat = gpumat_array[i];
                if (gpumat == NULL) {
                        continue;
                }
-               GPU_material_vertex_attributes(gpumat, &gattribs);
-               for (int j = 0; j < gattribs.totlayer; j++) {
-                       const char *name = gattribs.layer[j].name;
-                       int type = gattribs.layer[j].type;
+               GPU_material_vertex_attrs(gpumat, &gpu_attrs);
+               for (int j = 0; j < gpu_attrs.totlayer; j++) {
+                       const char *name = gpu_attrs.layer[j].name;
+                       int type = gpu_attrs.layer[j].type;
 
                        /* Curves cannot have named layers.
                         * Note: We could relax this assumption later. */
@@ -662,7 +662,7 @@ static void curve_create_edit_curves_nor(CurveRenderData *rdata, GPUVertBuf *vbo
                        GPUPackedNormal pnor = GPU_normal_convert_i10_v3(nor);
                        GPUPackedNormal ptan = GPU_normal_convert_i10_v3(bevp->dir);
 
-                       /* Only set attribs for one vertex. */
+                       /* Only set attributes for one vertex. */
                        GPU_vertbuf_attr_set(vbo_curves_nor, attr_id.pos, vbo_len_used, bevp->vec);
                        GPU_vertbuf_attr_set(vbo_curves_nor, attr_id.rad, vbo_len_used, &bevp->radius);
                        GPU_vertbuf_attr_set(vbo_curves_nor, attr_id.nor, vbo_len_used, &pnor);
@@ -897,7 +897,7 @@ void DRW_curve_batch_cache_create_requested(Object *ob)
        Curve *cu = ob->data;
        CurveBatchCache *cache = curve_batch_cache_get(cu);
 
-       /* Verify that all surface batches have needed attrib layers. */
+       /* Verify that all surface batches have needed attribute layers. */
        /* TODO(fclem): We could be a bit smarter here and only do it per material. */
        for (int i = 0; i < cache->mat_len; ++i) {
                if ((cache->cd_used & cache->cd_needed) != cache->cd_needed) {
index 75ec4fa..94d5407 100644 (file)
@@ -376,15 +376,15 @@ static void mesh_cd_calc_used_gpu_layers(
        const CustomData *cd_ldata = (me->edit_btmesh) ? &me->edit_btmesh->bm->ldata : &me->ldata;
 
        /* See: DM_vertex_attributes_from_gpu for similar logic */
-       GPUVertexAttribs gattribs = {{{0}}};
+       GPUVertAttrLayers gpu_attrs = {{{0}}};
 
        for (int i = 0; i < gpumat_array_len; i++) {
                GPUMaterial *gpumat = gpumat_array[i];
                if (gpumat) {
-                       GPU_material_vertex_attributes(gpumat, &gattribs);
-                       for (int j = 0; j < gattribs.totlayer; j++) {
-                               const char *name = gattribs.layer[j].name;
-                               int type = gattribs.layer[j].type;
+                       GPU_material_vertex_attrs(gpumat, &gpu_attrs);
+                       for (int j = 0; j < gpu_attrs.totlayer; j++) {
+                               const char *name = gpu_attrs.layer[j].name;
+                               int type = gpu_attrs.layer[j].type;
                                int layer = -1;
 
                                if (type == CD_AUTO_FROM_NAME) {
@@ -2101,7 +2101,7 @@ typedef struct MeshBatchCache {
        GPUBatch **surf_per_mat;
 
        /* arrays of bool uniform names (and value) that will be use to
-        * set srgb conversion for auto attribs.*/
+        * set srgb conversion for auto attributes.*/
        char *auto_layer_names;
        int *auto_layer_is_srgb;
        int auto_layer_len;
@@ -3103,15 +3103,15 @@ static void mesh_create_loop_uv_and_tan(MeshRenderData *rdata, GPUVertBuf *vbo)
        GPUVertFormat format = { 0 };
 
        for (uint i = 0; i < uv_len; i++) {
-               const char *attrib_name = mesh_render_data_uv_layer_uuid_get(rdata, i);
+               const char *attr_name = mesh_render_data_uv_layer_uuid_get(rdata, i);
 #if 0 /* these are clamped. Maybe use them as an option in the future */
-               uv_id[i] = GPU_vertformat_attr_add(&format, attrib_name, GPU_COMP_I16, 2, GPU_FETCH_INT_TO_FLOAT_UNIT);
+               uv_id[i] = GPU_vertformat_attr_add(&format, attr_name, GPU_COMP_I16, 2, GPU_FETCH_INT_TO_FLOAT_UNIT);
 #else
-               uv_id[i] = GPU_vertformat_attr_add(&format, attrib_name, GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
+               uv_id[i] = GPU_vertformat_attr_add(&format, attr_name, GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
 #endif
                /* Auto Name */
-               attrib_name = mesh_render_data_uv_auto_layer_uuid_get(rdata, i);
-               GPU_vertformat_alias_add(&format, attrib_name);
+               attr_name = mesh_render_data_uv_auto_layer_uuid_get(rdata, i);
+               GPU_vertformat_alias_add(&format, attr_name);
 
                if (i == rdata->cd.layers.uv_active) {
                        GPU_vertformat_alias_add(&format, "u");
@@ -3119,18 +3119,18 @@ static void mesh_create_loop_uv_and_tan(MeshRenderData *rdata, GPUVertBuf *vbo)
        }
 
        for (uint i = 0; i < tangent_len; i++) {
-               const char *attrib_name = mesh_render_data_tangent_layer_uuid_get(rdata, i);
+               const char *attr_name = mesh_render_data_tangent_layer_uuid_get(rdata, i);
 #ifdef USE_COMP_MESH_DATA
-               tangent_id[i] = GPU_vertformat_attr_add(&format, attrib_name, GPU_COMP_I16, 4, GPU_FETCH_INT_TO_FLOAT_UNIT);
+               tangent_id[i] = GPU_vertformat_attr_add(&format, attr_name, GPU_COMP_I16, 4, GPU_FETCH_INT_TO_FLOAT_UNIT);
 #else
-               tangent_id[i] = GPU_vertformat_attr_add(&format, attrib_name, GPU_COMP_F32, 4, GPU_FETCH_FLOAT);
+               tangent_id[i] = GPU_vertformat_attr_add(&format, attr_name, GPU_COMP_F32, 4, GPU_FETCH_FLOAT);
 #endif
                if (i == rdata->cd.layers.tangent_active) {
                        GPU_vertformat_alias_add(&format, "t");
                }
        }
 
-       /* HACK: Create a dummy attrib in case there is no valid UV/tangent layer. */
+       /* HACK: Create a dummy attribute in case there is no valid UV/tangent layer. */
        if (layers_combined_len == 0) {
                GPU_vertformat_attr_add(&format, "dummy", GPU_COMP_U8, 1, GPU_FETCH_INT_TO_FLOAT_UNIT);
        }
@@ -3218,12 +3218,12 @@ static void mesh_create_loop_vcol(MeshRenderData *rdata, GPUVertBuf *vbo)
        GPUVertFormat format = { 0 };
 
        for (uint i = 0; i < vcol_len; i++) {
-               const char *attrib_name = mesh_render_data_vcol_layer_uuid_get(rdata, i);
-               vcol_id[i] = GPU_vertformat_attr_add(&format, attrib_name, GPU_COMP_U8, 3, GPU_FETCH_INT_TO_FLOAT_UNIT);
+               const char *attr_name = mesh_render_data_vcol_layer_uuid_get(rdata, i);
+               vcol_id[i] = GPU_vertformat_attr_add(&format, attr_name, GPU_COMP_U8, 3, GPU_FETCH_INT_TO_FLOAT_UNIT);
                /* Auto layer */
                if (rdata->cd.layers.auto_vcol[i]) {
-                       attrib_name = mesh_render_data_vcol_auto_layer_uuid_get(rdata, i);
-                       GPU_vertformat_alias_add(&format, attrib_name);
+                       attr_name = mesh_render_data_vcol_auto_layer_uuid_get(rdata, i);
+                       GPU_vertformat_alias_add(&format, attr_name);
                }
                if (i == rdata->cd.layers.vcol_active) {
                        GPU_vertformat_alias_add(&format, "c");
@@ -4980,7 +4980,7 @@ void DRW_mesh_batch_cache_create_requested(
                drw_mesh_weight_state_clear(&wstate);
        }
 
-       /* Verify that all surface batches have needed attrib layers. */
+       /* Verify that all surface batches have needed attribute layers. */
        /* TODO(fclem): We could be a bit smarter here and only do it per material. */
        bool cd_overlap = mesh_cd_layers_type_overlap(cache->cd_vused, cache->cd_lused,
                                                      cache->cd_vneeded, cache->cd_lneeded);
index 4a23bee..e6e262b 100644 (file)
@@ -1174,8 +1174,8 @@ static void particle_batch_cache_ensure_pos_and_seg(
        attr_id.ind = GPU_vertformat_attr_add(&format, "ind", GPU_COMP_I32, 1, GPU_FETCH_INT);
 
        if (psmd) {
-               uv_id = MEM_mallocN(sizeof(*uv_id) * num_uv_layers, "UV attrib format");
-               col_id = MEM_mallocN(sizeof(*col_id) * num_col_layers, "Col attrib format");
+               uv_id = MEM_mallocN(sizeof(*uv_id) * num_uv_layers, "UV attr format");
+               col_id = MEM_mallocN(sizeof(*col_id) * num_col_layers, "Col attr format");
 
                for (int i = 0; i < num_uv_layers; i++) {
                        const char *name = CustomData_get_layer_name(&psmd->mesh_final->ldata, CD_MLOOPUV, i);
index e54ad6c..28bd39e 100644 (file)
@@ -318,8 +318,8 @@ DRWShadingGroup *shgroup_dynlines_flat_color(DRWPass *pass)
        GPUShader *sh = GPU_shader_get_builtin_shader(GPU_SHADER_3D_FLAT_COLOR);
 
        DRW_shgroup_instance_format(g_formats.dynlines_color, {
-               {"pos",       DRW_ATTRIB_FLOAT, 3},
-               {"color",     DRW_ATTRIB_FLOAT, 4}
+               {"pos",       DRW_ATTR_FLOAT, 3},
+               {"color",     DRW_ATTR_FLOAT, 4}
        });
 
        DRWShadingGroup *grp = DRW_shgroup_line_batch_create_with_format(sh, pass, g_formats.dynlines_color);
@@ -385,8 +385,8 @@ DRWShadingGroup *shgroup_instance_screenspace(
        GPUShader *sh = DRW_shader_get_builtin_shader(GPU_SHADER_3D_SCREENSPACE_VARIYING_COLOR, shader_slot);
 
        DRW_shgroup_instance_format(g_formats.instance_screenspace, {
-               {"world_pos", DRW_ATTRIB_FLOAT, 3},
-               {"color",     DRW_ATTRIB_FLOAT, 3}
+               {"world_pos", DRW_ATTR_FLOAT, 3},
+               {"color",     DRW_ATTR_FLOAT, 3}
        });
 
        DRWShadingGroup *grp = DRW_shgroup_instance_create(sh, pass, geom, g_formats.instance_screenspace);
@@ -405,8 +405,8 @@ DRWShadingGroup *shgroup_instance_solid(DRWPass *pass, struct GPUBatch *geom)
        GPUShader *sh = GPU_shader_get_builtin_shader(GPU_SHADER_3D_OBJECTSPACE_SIMPLE_LIGHTING_VARIYING_COLOR);
 
        DRW_shgroup_instance_format(g_formats.instance_color, {
-               {"InstanceModelMatrix", DRW_ATTRIB_FLOAT, 16},
-               {"color",               DRW_ATTRIB_FLOAT, 4}
+               {"InstanceModelMatrix", DRW_ATTR_FLOAT, 16},
+               {"color",               DRW_ATTR_FLOAT, 4}
        });
 
        DRWShadingGroup *grp = DRW_shgroup_instance_create(sh, pass, geom, g_formats.instance_color);
@@ -420,8 +420,8 @@ DRWShadingGroup *shgroup_instance_wire(DRWPass *pass, struct GPUBatch *geom)
        GPUShader *sh = GPU_shader_get_builtin_shader(GPU_SHADER_3D_OBJECTSPACE_VARIYING_COLOR);
 
        DRW_shgroup_instance_format(g_formats.instance_color, {
-               {"InstanceModelMatrix", DRW_ATTRIB_FLOAT, 16},
-               {"color",               DRW_ATTRIB_FLOAT, 4}
+               {"InstanceModelMatrix", DRW_ATTR_FLOAT, 16},
+               {"color",               DRW_ATTR_FLOAT, 4}
        });
 
        DRWShadingGroup *grp = DRW_shgroup_instance_create(sh, pass, geom, g_formats.instance_color);
@@ -435,9 +435,9 @@ DRWShadingGroup *shgroup_instance_screen_aligned(
        GPUShader *sh = DRW_shader_get_builtin_shader(GPU_SHADER_3D_INSTANCE_SCREEN_ALIGNED, shader_slot);
 
        DRW_shgroup_instance_format(g_formats.instance_screen_aligned, {
-               {"color",               DRW_ATTRIB_FLOAT, 3},
-               {"size",                DRW_ATTRIB_FLOAT, 1},
-               {"InstanceModelMatrix", DRW_ATTRIB_FLOAT, 16}
+               {"color",               DRW_ATTR_FLOAT, 3},
+               {"size",                DRW_ATTR_FLOAT, 1},
+               {"InstanceModelMatrix", DRW_ATTR_FLOAT, 16}
        });
 
        DRWShadingGroup *grp = DRW_shgroup_instance_create(sh, pass, geom, g_formats.instance_screen_aligned);
@@ -453,9 +453,9 @@ DRWShadingGroup *shgroup_instance_scaled(DRWPass *pass, struct GPUBatch *geom, e
        GPUShader *sh_inst = DRW_shader_get_builtin_shader(GPU_SHADER_INSTANCE_VARIYING_COLOR_VARIYING_SCALE, shader_slot);
 
        DRW_shgroup_instance_format(g_formats.instance_scaled, {
-               {"color",               DRW_ATTRIB_FLOAT, 3},
-               {"size",                DRW_ATTRIB_FLOAT, 3},
-               {"InstanceModelMatrix", DRW_ATTRIB_FLOAT, 16}
+               {"color",               DRW_ATTR_FLOAT, 3},
+               {"size",                DRW_ATTR_FLOAT, 3},
+               {"InstanceModelMatrix", DRW_ATTR_FLOAT, 16}
        });
 
        DRWShadingGroup *grp = DRW_shgroup_instance_create(sh_inst, pass, geom, g_formats.instance_scaled);
@@ -470,9 +470,9 @@ DRWShadingGroup *shgroup_instance(DRWPass *pass, struct GPUBatch *geom, eDRW_Sha
        GPUShader *sh_inst = DRW_shader_get_builtin_shader(GPU_SHADER_INSTANCE_VARIYING_COLOR_VARIYING_SIZE, shader_slot);
 
        DRW_shgroup_instance_format(g_formats.instance_sized, {
-               {"color",               DRW_ATTRIB_FLOAT, 4},
-               {"size",                DRW_ATTRIB_FLOAT, 1},
-               {"InstanceModelMatrix", DRW_ATTRIB_FLOAT, 16}
+               {"color",               DRW_ATTR_FLOAT, 4},
+               {"size",                DRW_ATTR_FLOAT, 1},
+               {"InstanceModelMatrix", DRW_ATTR_FLOAT, 16}
        });
 
        DRWShadingGroup *grp = DRW_shgroup_instance_create(sh_inst, pass, geom, g_formats.instance_sized);
@@ -488,9 +488,9 @@ DRWShadingGroup *shgroup_instance_alpha(DRWPass *pass, struct GPUBatch *geom, eD
        GPUShader *sh_inst = DRW_shader_get_builtin_shader(GPU_SHADER_INSTANCE_VARIYING_COLOR_VARIYING_SIZE, shader_slot);
 
        DRW_shgroup_instance_format(g_formats.instance_sized, {
-               {"color",               DRW_ATTRIB_FLOAT, 4},
-               {"size",                DRW_ATTRIB_FLOAT, 1},
-               {"InstanceModelMatrix", DRW_ATTRIB_FLOAT, 16}
+               {"color",               DRW_ATTR_FLOAT, 4},
+               {"size",                DRW_ATTR_FLOAT, 1},
+               {"InstanceModelMatrix", DRW_ATTR_FLOAT, 16}
        });
 
        DRWShadingGroup *grp = DRW_shgroup_instance_create(sh_inst, pass, geom, g_formats.instance_sized);
@@ -513,9 +513,9 @@ DRWShadingGroup *shgroup_instance_empty_axes(DRWPass *pass, struct GPUBatch *geo
        }
 
        DRW_shgroup_instance_format(g_formats.instance_sized, {
-               {"color",               DRW_ATTRIB_FLOAT, 3},
-               {"size",                DRW_ATTRIB_FLOAT, 1},
-               {"InstanceModelMatrix", DRW_ATTRIB_FLOAT, 16}
+               {"color",               DRW_ATTR_FLOAT, 3},
+               {"size",                DRW_ATTR_FLOAT, 1},
+               {"InstanceModelMatrix", DRW_ATTR_FLOAT, 16}
        });
 
        DRWShadingGroup *grp = DRW_shgroup_instance_create(sh_data->empty_axes_sh, pass, geom, g_formats.instance_sized);
@@ -531,9 +531,9 @@ DRWShadingGroup *shgroup_instance_outline(DRWPass *pass, struct GPUBatch *geom,
        GPUShader *sh_inst = GPU_shader_get_builtin_shader(GPU_SHADER_INSTANCE_VARIYING_ID_VARIYING_SIZE);
 
        DRW_shgroup_instance_format(g_formats.instance_outline, {
-               {"callId",              DRW_ATTRIB_INT,   1},
-               {"size",                DRW_ATTRIB_FLOAT, 1},
-               {"InstanceModelMatrix", DRW_ATTRIB_FLOAT, 16}
+               {"callId",              DRW_ATTR_INT,   1},
+               {"size",                DRW_ATTR_FLOAT, 1},
+               {"InstanceModelMatrix", DRW_ATTR_FLOAT, 16}
        });
 
        DRWShadingGroup *grp = DRW_shgroup_instance_create(sh_inst, pass, geom, g_formats.instance_outline);
@@ -547,11 +547,11 @@ DRWShadingGroup *shgroup_camera_instance(DRWPass *pass, struct GPUBatch *geom, e
        GPUShader *sh_inst = DRW_shader_get_builtin_shader(GPU_SHADER_CAMERA, shader_slot);
 
        DRW_shgroup_instance_format(g_formats.instance_camera, {
-               {"color",               DRW_ATTRIB_FLOAT, 3},
-               {"corners",             DRW_ATTRIB_FLOAT, 8},
-               {"depth",               DRW_ATTRIB_FLOAT, 1},
-               {"tria",                DRW_ATTRIB_FLOAT, 4},
-               {"InstanceModelMatrix", DRW_ATTRIB_FLOAT, 16}
+               {"color",               DRW_ATTR_FLOAT, 3},
+               {"corners",             DRW_ATTR_FLOAT, 8},
+               {"depth",               DRW_ATTR_FLOAT, 1},
+               {"tria",                DRW_ATTR_FLOAT, 4},
+               {"InstanceModelMatrix", DRW_ATTR_FLOAT, 16}
        });
 
        DRWShadingGroup *grp = DRW_shgroup_instance_create(sh_inst, pass, geom, g_formats.instance_camera);
@@ -567,10 +567,10 @@ DRWShadingGroup *shgroup_distance_lines_instance(DRWPass *pass, struct GPUBatch
        static float point_size = 4.0f;
 
        DRW_shgroup_instance_format(g_formats.instance_distance_lines, {
-               {"color",               DRW_ATTRIB_FLOAT, 3},
-               {"start",               DRW_ATTRIB_FLOAT, 1},
-               {"end",                 DRW_ATTRIB_FLOAT, 1},
-               {"InstanceModelMatrix", DRW_ATTRIB_FLOAT, 16}
+               {"color",               DRW_ATTR_FLOAT, 3},
+               {"start",               DRW_ATTR_FLOAT, 1},
+               {"end",                 DRW_ATTR_FLOAT, 1},
+               {"InstanceModelMatrix", DRW_ATTR_FLOAT, 16}
        });
 
        DRWShadingGroup *grp = DRW_shgroup_instance_create(sh_inst, pass, geom, g_formats.instance_distance_lines);
@@ -586,8 +586,8 @@ DRWShadingGroup *shgroup_spot_instance(DRWPass *pass, struct GPUBatch *geom)
        static const int False = false;
 
        DRW_shgroup_instance_format(g_formats.instance_spot, {
-               {"color",               DRW_ATTRIB_FLOAT, 3},
-               {"InstanceModelMatrix", DRW_ATTRIB_FLOAT, 16}
+               {"color",               DRW_ATTR_FLOAT, 3},
+               {"InstanceModelMatrix", DRW_ATTR_FLOAT, 16}
        });
 
        DRWShadingGroup *grp = DRW_shgroup_instance_create(sh_inst, pass, geom, g_formats.instance_spot);
@@ -608,8 +608,8 @@ DRWShadingGroup *shgroup_instance_bone_axes(DRWPass *pass)
        }
 
        DRW_shgroup_instance_format(g_formats.instance_color, {
-               {"InstanceModelMatrix", DRW_ATTRIB_FLOAT, 16},
-               {"color",               DRW_ATTRIB_FLOAT, 4}
+               {"InstanceModelMatrix", DRW_ATTR_FLOAT, 16},
+               {"color",               DRW_ATTR_FLOAT, 4}
        });
 
        DRWShadingGroup *grp = DRW_shgroup_instance_create(
@@ -631,10 +631,10 @@ DRWShadingGroup *shgroup_instance_bone_envelope_outline(DRWPass *pass)
        }
 
        DRW_shgroup_instance_format(g_formats.instance_bone_envelope_outline, {
-               {"headSphere",           DRW_ATTRIB_FLOAT, 4},
-               {"tailSphere",           DRW_ATTRIB_FLOAT, 4},
-               {"outlineColorSize",     DRW_ATTRIB_FLOAT, 4},
-               {"xAxis",                DRW_ATTRIB_FLOAT, 3}
+               {"headSphere",           DRW_ATTR_FLOAT, 4},
+               {"tailSphere",           DRW_ATTR_FLOAT, 4},
+               {"outlineColorSize",     DRW_ATTR_FLOAT, 4},
+               {"xAxis",                DRW_ATTR_FLOAT, 3}
        });
 
        DRWShadingGroup *grp = DRW_shgroup_instance_create(
@@ -656,9 +656,9 @@ DRWShadingGroup *shgroup_instance_bone_envelope_distance(DRWPass *pass)
        }
 
        DRW_shgroup_instance_format(g_formats.instance_bone_envelope_distance, {
-               {"headSphere",           DRW_ATTRIB_FLOAT, 4},
-               {"tailSphere",           DRW_ATTRIB_FLOAT, 4},
-               {"xAxis",                DRW_ATTRIB_FLOAT, 3}
+               {"headSphere",           DRW_ATTR_FLOAT, 4},
+               {"tailSphere",           DRW_ATTR_FLOAT, 4},
+               {"xAxis",                DRW_ATTR_FLOAT, 3}
        });
 
        DRWShadingGroup *grp = DRW_shgroup_instance_create(
@@ -679,11 +679,11 @@ DRWShadingGroup *shgroup_instance_bone_envelope_solid(DRWPass *pass, bool transp
        }
 
        DRW_shgroup_instance_format(g_formats.instance_bone_envelope, {
-               {"headSphere",           DRW_ATTRIB_FLOAT, 4},
-               {"tailSphere",           DRW_ATTRIB_FLOAT, 4},
-               {"boneColor",            DRW_ATTRIB_FLOAT, 3},
-               {"stateColor",           DRW_ATTRIB_FLOAT, 3},
-               {"xAxis",                DRW_ATTRIB_FLOAT, 3}
+               {"headSphere",           DRW_ATTR_FLOAT, 4},
+               {"tailSphere",           DRW_ATTR_FLOAT, 4},
+               {"boneColor",            DRW_ATTR_FLOAT, 3},
+               {"stateColor",           DRW_ATTR_FLOAT, 3},
+               {"xAxis",                DRW_ATTR_FLOAT, 3}
        });
 
        DRWShadingGroup *grp = DRW_shgroup_instance_create(
@@ -705,9 +705,9 @@ DRWShadingGroup *shgroup_instance_mball_handles(DRWPass *pass)
        }
 
        DRW_shgroup_instance_format(g_formats.instance_mball_handles, {
-               {"ScaleTranslationMatrix",  DRW_ATTRIB_FLOAT, 12},
-               {"radius",                  DRW_ATTRIB_FLOAT, 1},
-               {"color",                   DRW_ATTRIB_FLOAT, 3}
+               {"ScaleTranslationMatrix",  DRW_ATTR_FLOAT, 12},
+               {"radius",                  DRW_ATTR_FLOAT, 1},
+               {"color",                   DRW_ATTR_FLOAT, 3}
        });
 
        DRWShadingGroup *grp = DRW_shgroup_instance_create(
@@ -732,8 +732,8 @@ DRWShadingGroup *shgroup_instance_bone_shape_outline(DRWPass *pass, struct GPUBa
        }
 
        DRW_shgroup_instance_format(g_formats.instance_bone_outline, {
-               {"InstanceModelMatrix", DRW_ATTRIB_FLOAT, 16},
-               {"outlineColorSize",    DRW_ATTRIB_FLOAT, 4}
+               {"InstanceModelMatrix", DRW_ATTR_FLOAT, 16},
+               {"outlineColorSize",    DRW_ATTR_FLOAT, 4}
        });
 
        DRWShadingGroup *grp = DRW_shgroup_instance_create(
@@ -754,9 +754,9 @@ DRWShadingGroup *shgroup_instance_bone_shape_solid(DRWPass *pass, struct GPUBatc
        }
 
        DRW_shgroup_instance_format(g_formats.instance_bone, {
-               {"InstanceModelMatrix", DRW_ATTRIB_FLOAT, 16},
-               {"boneColor",            DRW_ATTRIB_FLOAT, 3},
-               {"stateColor",           DRW_ATTRIB_FLOAT, 3}
+               {"InstanceModelMatrix", DRW_ATTR_FLOAT, 16},
+               {"boneColor",            DRW_ATTR_FLOAT, 3},
+               {"stateColor",           DRW_ATTR_FLOAT, 3}
        });
 
        DRWShadingGroup *grp = DRW_shgroup_instance_create(
@@ -777,9 +777,9 @@ DRWShadingGroup *shgroup_instance_bone_sphere_solid(DRWPass *pass, bool transp)
        }
 
        DRW_shgroup_instance_format(g_formats.instance_bone, {
-               {"InstanceModelMatrix", DRW_ATTRIB_FLOAT, 16},
-               {"boneColor",           DRW_ATTRIB_FLOAT, 3},
-               {"stateColor",          DRW_ATTRIB_FLOAT, 3}
+               {"InstanceModelMatrix", DRW_ATTR_FLOAT, 16},
+               {"boneColor",           DRW_ATTR_FLOAT, 3},
+               {"stateColor",          DRW_ATTR_FLOAT, 3}
        });
 
        DRWShadingGroup *grp = DRW_shgroup_instance_create(
@@ -801,8 +801,8 @@ DRWShadingGroup *shgroup_instance_bone_sphere_outline(DRWPass *pass)
        }
 
        DRW_shgroup_instance_format(g_formats.instance_bone_outline, {
-               {"InstanceModelMatrix", DRW_ATTRIB_FLOAT, 16},
-               {"outlineColorSize",    DRW_ATTRIB_FLOAT, 4}
+               {"InstanceModelMatrix", DRW_ATTR_FLOAT, 16},
+               {"outlineColorSize",    DRW_ATTR_FLOAT, 4}
        });
 
        DRWShadingGroup *grp = DRW_shgroup_instance_create(
@@ -824,12 +824,12 @@ DRWShadingGroup *shgroup_instance_bone_stick(DRWPass *pass)
        }
 
        DRW_shgroup_instance_format(g_formats.instance_bone_stick, {
-               {"boneStart", DRW_ATTRIB_FLOAT, 3},
-               {"boneEnd",   DRW_ATTRIB_FLOAT, 3},
-               {"wireColor", DRW_ATTRIB_FLOAT, 4}, /* TODO port theses to uchar color */
-               {"boneColor", DRW_ATTRIB_FLOAT, 4},
-               {"headColor", DRW_ATTRIB_FLOAT, 4},
-               {"tailColor", DRW_ATTRIB_FLOAT, 4}
+               {"boneStart", DRW_ATTR_FLOAT, 3},
+               {"boneEnd",   DRW_ATTR_FLOAT, 3},
+               {"wireColor", DRW_ATTR_FLOAT, 4}, /* TODO port theses to uchar color */
+               {"boneColor", DRW_ATTR_FLOAT, 4},
+               {"headColor", DRW_ATTR_FLOAT, 4},
+               {"tailColor", DRW_ATTR_FLOAT, 4}
        });
 
        DRWShadingGroup *grp = DRW_shgroup_instance_create(
@@ -852,10 +852,10 @@ struct DRWShadingGroup *shgroup_instance_bone_dof(struct DRWPass *pass, struct G
        }
 
        DRW_shgroup_instance_format(g_formats.instance_bone_dof, {
-               {"InstanceModelMatrix", DRW_ATTRIB_FLOAT, 16},
-               {"color",               DRW_ATTRIB_FLOAT, 4},
-               {"amin",                DRW_ATTRIB_FLOAT, 2},
-               {"amax",                DRW_ATTRIB_FLOAT, 2},
+               {"InstanceModelMatrix", DRW_ATTR_FLOAT, 16},
+               {"color",               DRW_ATTR_FLOAT, 4},
+               {"amin",                DRW_ATTR_FLOAT, 2},
+               {"amax",                DRW_ATTR_FLOAT, 2},
        });
 
        DRWShadingGroup *grp = DRW_shgroup_instance_create(
index f129235..8775c4f 100644 (file)
@@ -290,24 +290,24 @@ void DRW_instance_buffer_finish(DRWInstanceDataList *idatalist)
 /** \name Instance Data (DRWInstanceData)
  * \{ */
 
-static DRWInstanceData *drw_instance_data_create(DRWInstanceDataList *idatalist, uint attrib_size)
+static DRWInstanceData *drw_instance_data_create(DRWInstanceDataList *idatalist, uint attr_size)
 {
        DRWInstanceData *idata = MEM_callocN(sizeof(DRWInstanceData), "DRWInstanceData");
        idata->next = NULL;
        idata->used = true;
-       idata->data_size = attrib_size;
+       idata->data_size = attr_size;
        idata->mempool = BLI_mempool_create(sizeof(float) * idata->data_size, 0, 16, 0);
 
-       BLI_assert(attrib_size > 0);
+       BLI_assert(attr_size > 0);
 
        /* Push to linked list. */
-       if (idatalist->idata_head[attrib_size - 1] == NULL) {
-               idatalist->idata_head[attrib_size - 1] = idata;
+       if (idatalist->idata_head[attr_size - 1] == NULL) {
+               idatalist->idata_head[attr_size - 1] = idata;
        }
        else {
-               idatalist->idata_tail[attrib_size - 1]->next = idata;
+               idatalist->idata_tail[attr_size - 1]->next = idata;
        }
-       idatalist->idata_tail[attrib_size - 1] = idata;
+       idatalist->idata_tail[attr_size - 1] = idata;
 
        return idata;
 }
@@ -325,11 +325,11 @@ void *DRW_instance_data_next(DRWInstanceData *idata)
        return BLI_mempool_alloc(idata->mempool);
 }
 
-DRWInstanceData *DRW_instance_data_request(DRWInstanceDataList *idatalist, uint attrib_size)
+DRWInstanceData *DRW_instance_data_request(DRWInstanceDataList *idatalist, uint attr_size)
 {
-       BLI_assert(attrib_size > 0 && attrib_size <= MAX_INSTANCE_DATA_SIZE);
+       BLI_assert(attr_size > 0 && attr_size <= MAX_INSTANCE_DATA_SIZE);
 
-       DRWInstanceData *idata = idatalist->idata_head[attrib_size - 1];
+       DRWInstanceData *idata = idatalist->idata_head[attr_size - 1];
 
        /* Search for an unused data chunk. */
        for (; idata; idata = idata->next) {
@@ -339,7 +339,7 @@ DRWInstanceData *DRW_instance_data_request(DRWInstanceDataList *idatalist, uint
                }
        }
 
-       return drw_instance_data_create(idatalist, attrib_size);
+       return drw_instance_data_create(idatalist, attr_size);
 }
 
 /** \} */
index 8460d47..5a1cff5 100644 (file)
@@ -43,7 +43,7 @@ struct DRWShadingGroup;
 
 void *DRW_instance_data_next(DRWInstanceData *idata);
 DRWInstanceData *DRW_instance_data_request(
-        DRWInstanceDataList *idatalist, uint attrib_size);
+        DRWInstanceDataList *idatalist, uint attr_size);
 
 void DRW_batching_buffer_request(
         DRWInstanceDataList *idatalist, GPUVertFormat *format, GPUPrimType type, struct DRWShadingGroup *shgroup,
index 09809a4..9d85f95 100644 (file)
@@ -1765,7 +1765,7 @@ void DRW_render_gpencil(struct RenderEngine *engine, struct Depsgraph *depsgraph
        drw_viewport_var_init();
 
        /* set default viewport */
-       gpuPushAttrib(GPU_ENABLE_BIT | GPU_VIEWPORT_BIT);
+       gpuPushAttr(GPU_ENABLE_BIT | GPU_VIEWPORT_BIT);
        glDisable(GL_SCISSOR_TEST);
        glViewport(0, 0, size[0], size[1]);
 
@@ -1790,7 +1790,7 @@ void DRW_render_gpencil(struct RenderEngine *engine, struct Depsgraph *depsgraph
        glDisable(GL_DEPTH_TEST);
 
        /* Restore Drawing area. */
-       gpuPopAttrib();
+       gpuPopAttr();
        glEnable(GL_SCISSOR_TEST);
        GPU_framebuffer_restore();
 
index 8882421..6ff5672 100644 (file)
@@ -135,11 +135,16 @@ typedef struct DRWCallState {
 } DRWCallState;
 
 typedef enum {
-       DRW_CALL_SINGLE,                 /* A single batch */
-       DRW_CALL_RANGE,                  /* Like single but only draw a range of vertices/indices. */
-       DRW_CALL_INSTANCES,              /* Draw instances without any instancing attribs. */
-       DRW_CALL_GENERATE,               /* Uses a callback to draw with any number of batches. */
-       DRW_CALL_PROCEDURAL,             /* Generate a drawcall without any GPUBatch. */
+       /** A single batch. */
+       DRW_CALL_SINGLE,
+       /** Like single but only draw a range of vertices/indices. */
+       DRW_CALL_RANGE,
+       /** Draw instances without any instancing attributes. */
+       DRW_CALL_INSTANCES,
+       /** Uses a callback to draw with any number of batches. */
+       DRW_CALL_GENERATE,
+       /** Generate a drawcall without any #GPUBatch. */
+       DRW_CALL_PROCEDURAL,
 } DRWCallType;
 
 typedef struct DRWCall {
@@ -268,7 +273,7 @@ struct DRWShadingGroup {
 
        DRWPass *pass_parent; /* backlink to pass we're in */
 #ifndef NDEBUG
-       char attribs_count;
+       char attrs_count;
 #endif
 #ifdef USE_GPU_SELECT
        GPUVertBuf *inst_selectid;
index 00da942..5d5d36d 100644 (file)
@@ -608,7 +608,7 @@ void DRW_shgroup_call_dynamic_add_array(DRWShadingGroup *shgroup, const void *at
        }
 #endif
 
-       BLI_assert(attr_len == shgroup->attribs_count);
+       BLI_assert(attr_len == shgroup->attrs_count);
        UNUSED_VARS_NDEBUG(attr_len);
 
        for (int i = 0; i < attr_len; ++i) {
@@ -638,7 +638,7 @@ static void drw_shgroup_init(DRWShadingGroup *shgroup, GPUShader *shader)
        shgroup->override_selectid = -1;
 #endif
 #ifndef NDEBUG
-       shgroup->attribs_count = 0;
+       shgroup->attrs_count = 0;
 #endif
 
        int view_ubo_location = GPU_shader_get_uniform_block(shader, "viewBlock");
@@ -710,7 +710,7 @@ static void drw_shgroup_instance_init(
 
        shgroup->instance_geom = batch;
 #ifndef NDEBUG
-       shgroup->attribs_count = format->attr_len;
+       shgroup->attrs_count = format->attr_len;
 #endif
 
        DRW_instancing_buffer_request(DST.idatalist, format, batch, shgroup,
@@ -738,7 +738,7 @@ static void drw_shgroup_batching_init(
        drw_shgroup_init(shgroup, shader);
 
 #ifndef NDEBUG
-       shgroup->attribs_count = (format != NULL) ? format->attr_len : 0;
+       shgroup->attrs_count = (format != NULL) ? format->attr_len : 0;
 #endif
        BLI_assert(format != NULL);
 
@@ -844,15 +844,16 @@ static DRWShadingGroup *drw_shgroup_material_inputs(DRWShadingGroup *grp, struct
        return grp;
 }
 
-GPUVertFormat *DRW_shgroup_instance_format_array(const DRWInstanceAttribFormat attribs[], int arraysize)
+GPUVertFormat *DRW_shgroup_instance_format_array(const DRWInstanceAttrFormat attrs[], int arraysize)
 {
        GPUVertFormat *format = MEM_callocN(sizeof(GPUVertFormat), "GPUVertFormat");
 
        for (int i = 0; i < arraysize; ++i) {
-               GPU_vertformat_attr_add(format, attribs[i].name,
-                                       (attribs[i].type == DRW_ATTRIB_INT) ? GPU_COMP_I32 : GPU_COMP_F32,
-                                       attribs[i].components,
-                                       (attribs[i].type == DRW_ATTRIB_INT) ? GPU_FETCH_INT : GPU_FETCH_FLOAT);
+               GPU_vertformat_attr_add(
+                       format, attrs[i].name,
+                       (attrs[i].type == DRW_ATTR_INT) ? GPU_COMP_I32 : GPU_COMP_F32,
+                       attrs[i].components,
+                       (attrs[i].type == DRW_ATTR_INT) ? GPU_FETCH_INT : GPU_FETCH_FLOAT);
        }
        return format;
 }
@@ -929,7 +930,7 @@ DRWShadingGroup *DRW_shgroup_instance_create(
 
 DRWShadingGroup *DRW_shgroup_point_batch_create(struct GPUShader *shader, DRWPass *pass)
 {
-       DRW_shgroup_instance_format(g_pos_format, {{"pos", DRW_ATTRIB_FLOAT, 3}});
+       DRW_shgroup_instance_format(g_pos_format, {{"pos", DRW_ATTR_FLOAT, 3}});
 
        DRWShadingGroup *shgroup = drw_shgroup_create_ex(shader, pass);
        shgroup->type = DRW_SHG_POINT_BATCH;
@@ -952,14 +953,16 @@ DRWShadingGroup *DRW_shgroup_line_batch_create_with_format(
 
 DRWShadingGroup *DRW_shgroup_line_batch_create(struct GPUShader *shader, DRWPass *pass)
 {
-       DRW_shgroup_instance_format(g_pos_format, {{"pos", DRW_ATTRIB_FLOAT, 3}});
+       DRW_shgroup_instance_format(g_pos_format, {{"pos", DRW_ATTR_FLOAT, 3}});
 
        return DRW_shgroup_line_batch_create_with_format(shader, pass, g_pos_format);
 }
 
-/* Very special batch. Use this if you position
+/**
+ * Very special batch. Use this if you position
  * your vertices with the vertex shader
- * and dont need any VBO attrib */
+ * and dont need any VBO attribute.
+ */
 DRWShadingGroup *DRW_shgroup_empty_tri_batch_create(struct GPUShader *shader, DRWPass *pass, int tri_count)
 {
 #ifdef USE_GPU_SELECT
@@ -989,13 +992,15 @@ DRWShadingGroup *DRW_shgroup_transform_feedback_create(struct GPUShader *shader,
        return shgroup;
 }
 
-/* Specify an external batch instead of adding each attrib one by one. */
+/**
+ * Specify an external batch instead of adding each attribute one by one.
+ */
 void DRW_shgroup_instance_batch(DRWShadingGroup *shgroup, struct GPUBatch *batch)
 {
        BLI_assert(shgroup->type == DRW_SHG_INSTANCE);
        BLI_assert(shgroup->instance_count == 0);
        /* You cannot use external instancing batch without a dummy format. */
-       BLI_assert(shgroup->attribs_count != 0);
+       BLI_assert(shgroup->attrs_count != 0);
 
        shgroup->type = DRW_SHG_INSTANCE_EXTERNAL;
        drw_call_calc_orco(NULL, shgroup->instance_orcofac);
index 4c96a5d..ed047b9 100644 (file)
@@ -2832,7 +2832,7 @@ static void OBJECT_cache_populate_particles(
                        static float def_sec_col[3] = {1.0f, 1.0f, 1.0f};
 
                        /* Dummy particle format for instancing to work. */
-                       DRW_shgroup_instance_format(e_data.particle_format, {{"dummy", DRW_ATTRIB_FLOAT, 1}});
+                       DRW_shgroup_instance_format(e_data.particle_format, {{"dummy", DRW_ATTR_FLOAT, 1}});
 
                        Material *ma = give_current_material(ob, part->omat);
 
index 53b2a3d..137bcff 100644 (file)
@@ -2,12 +2,12 @@
 uniform mat4 ViewProjectionMatrix;
 uniform vec3 screenVecs[3];
 
-/* ---- Instantiated Attribs ---- */
+/* ---- Instantiated Attrs ---- */
 in float axis; /* position on the axis. [0.0-1.0] is X axis, [1.0-2.0] is Y, etc... */
 in vec2 screenPos;
 in vec3 colorAxis;
 
-/* ---- Per instance Attribs ---- */
+/* ---- Per instance Attrs ---- */
 in mat4 InstanceModelMatrix;
 in vec4 color;
 
index 5c89cf6..d9d5686 100644 (file)
@@ -1,10 +1,10 @@
 
 uniform mat4 ViewProjectionMatrix;
 
-/* ---- Instantiated Attribs ---- */
+/* ---- Instantiated Attrs ---- */
 in vec2 pos;
 
-/* ---- Per instance Attribs ---- */
+/* ---- Per instance Attrs ---- */
 /* Assumed to be in world coordinate already. */
 in mat4 InstanceModelMatrix;
 in vec4 color;
index 307c727..b170b4f 100644 (file)
@@ -7,12 +7,12 @@ uniform mat4 ProjectionMatrix;
 uniform vec2 viewportSize;
 uniform float lineThickness = 2.0;
 
-/* ---- Instantiated Attribs ---- */
+/* ---- Instantiated Attrs ---- */
 in vec2 pos0;
 in vec2 pos1;
 in vec2 pos2;
 
-/* ---- Per instance Attribs ---- */
+/* ---- Per instance Attrs ---- */
 /* Assumed to be in world coordinate already. */
 in vec4 headSphere;
 in vec4 tailSphere;
index 11935e9..01e7783 100644 (file)
@@ -3,10 +3,10 @@ uniform mat4 ViewMatrix;
 uniform mat4 ViewMatrixInverse;
 uniform mat4 ViewProjectionMatrix;
 
-/* ---- Instantiated Attribs ---- */
+/* ---- Instantiated Attrs ---- */
 in vec3 pos;
 
-/* ---- Per instance Attribs ---- */
+/* ---- Per instance Attrs ---- */
 /* Assumed to be in world coordinate already. */
 in vec4 headSphere;
 in vec4 tailSphere;
index 7619d80..27b7585 100644 (file)
@@ -5,11 +5,11 @@ uniform mat4 ViewMatrix;
 uniform mat4 ProjectionMatrix;
 uniform vec2 viewportSize;
 
-/* ---- Instantiated Attribs ---- */
+/* ---- Instantiated Attrs ---- */
 in vec3 pos;
 in vec3 snor;
 
-/* ---- Per instance Attribs ---- */
+/* ---- Per instance Attrs ---- */
 in mat4 InstanceModelMatrix;
 in vec4 outlineColorSize;
 
@@ -28,7 +28,7 @@ vec2 proj(vec4 pos)
 void main()
 {
        /* This is slow and run per vertex, but it's still faster than
-        * doing it per instance on CPU and sending it on via instance attrib */
+        * doing it per instance on CPU and sending it on via instance attribute. */
        mat3 NormalMatrix = transpose(inverse(mat3(ViewMatrix * InstanceModelMatrix)));
 
        vec4 viewpos = ViewMatrix * (InstanceModelMatrix * vec4(pos, 1.0));
index 7abbf7f..4dfd542 100644 (file)
@@ -6,11 +6,11 @@ uniform mat4 ViewProjectionMatrix;
 uniform mat4 ViewMatrix;
 uniform mat4 ProjectionMatrix;
 
-/* ---- Instantiated Attribs ---- */
+/* ---- Instantiated Attrs ---- */
 in vec3 pos;
 in vec3 nor;
 
-/* ---- Per instance Attribs ---- */
+/* ---- Per instance Attrs ---- */
 in mat4 InstanceModelMatrix;
 in vec3 boneColor;
 in vec3 stateColor;
index 0c1fefb..ea3cfc9 100644 (file)
@@ -4,11 +4,11 @@ uniform mat4 ProjectionMatrix;
 uniform vec2 viewportSize;
 uniform float lineThickness = 2.0;
 
-/* ---- Instantiated Attribs ---- */
+/* ---- Instantiated Attrs ---- */
 in vec2 pos0;
 in vec2 pos1;
 
-/* ---- Per instance Attribs ---- */
+/* ---- Per instance Attrs ---- */
 in mat4 InstanceModelMatrix;
 in vec4 outlineColorSize;
 
index 7cbc0c5..5ecc156 100644 (file)
@@ -2,10 +2,10 @@
 uniform mat4 ViewMatrix;
 uniform mat4 ProjectionMatrix;
 
-/* ---- Instantiated Attribs ---- */
+/* ---- Instantiated Attrs ---- */
 in vec2 pos;
 
-/* ---- Per instance Attribs ---- */
+/* ---- Per instance Attrs ---- */
 in mat4 InstanceModelMatrix;
 in vec3 stateColor;
 in vec3 boneColor;
index 58fc48e..c27b8d3 100644 (file)
@@ -4,7 +4,7 @@ uniform mat4 ViewProjectionMatrix;
 uniform mat4 ViewMatrix;
 uniform vec2 viewportSize;
 
-/* ---- Instantiated Attribs ---- */
+/* ---- Instantiated Attrs ---- */
 in vec2 pos; /* bone aligned screen space */
 in uint flag;
 
@@ -17,7 +17,7 @@ in uint flag;
 #define POS_TAIL 32u /* (1 << 5) */ /* UNUSED */
 #define POS_BONE 64u /* (1 << 6) */
 
-/* ---- Per instance Attribs ---- */
+/* ---- Per instance Attrs ---- */
 in vec3 boneStart;
 in vec3 boneEnd;
 in vec4 wireColor; /* alpha encode if we do wire. If 0.0 we dont. */
index 594a7b3..359e4d8 100644 (file)
@@ -71,7 +71,7 @@ int hair_get_base_id(float local_time, int strand_segments, out float interp_tim
        return int(ratio);
 }
 
-void hair_get_interp_attribs(out vec4 data0, out vec4 data1, out vec4 data2, out vec4 data3, out float interp_time)
+void hair_get_interp_attrs(out vec4 data0, out vec4 data1, out vec4 data2, out vec4 data3, out float interp_time)
 {
        float local_time = float(gl_VertexID % hairStrandsRes) / float(hairStrandsRes - 1);
 
index 9f412c5..7fe9fee 100644 (file)
@@ -48,7 +48,7 @@ void main(void)
 {
        float interp_time;
        vec4 data0, data1, data2, data3;
-       hair_get_interp_attribs(data0, data1, data2, data3, interp_time);
+       hair_get_interp_attrs(data0, data1, data2, data3, interp_time);
 
        vec4 weights = get_weights_cardinal(interp_time);
        outData = interp_data(data0, data1, data2, data3, weights);
index e4baa57..4909783 100644 (file)
@@ -182,7 +182,7 @@ void main()
 #endif
 
        /* Remember that we are assuming the last vertex
-        * of a triangle is the provoking vertex (decide what flat attribs are). */
+        * of a triangle is the provoking vertex (decide what flat attributes are). */
 
        if ((eflag[2] & EDGE_EXISTS) != 0) {
                /* Do 0 -> 1 edge strip */
index d4d7f9b..4aafcee 100644 (file)
@@ -4,11 +4,11 @@ uniform mat4 ModelMatrix;
 
 uniform vec3 screenVecs[3];
 
-/* ---- Instantiated Attribs ---- */
+/* ---- Instantiated Attrs ---- */
 in float axis; /* position on the axis. [0.0-1.0] is X axis, [1.0-2.0] is Y, etc... */
 in vec2 screenPos;
 
-/* ---- Per instance Attribs ---- */
+/* ---- Per instance Attrs ---- */
 in vec3 color;
 in float size;
 in mat4 InstanceModelMatrix;
index b1c10fe..294a95d 100644 (file)
@@ -7,10 +7,10 @@
 uniform mat4 ViewProjectionMatrix;
 uniform vec3 screen_vecs[2];
 
-/* ---- Instantiated Attribs ---- */
+/* ---- Instantiated Attrs ---- */
 in vec2 pos;
 
-/* ---- Per instance Attribs ---- */
+/* ---- Per instance Attrs ---- */
 in mat3x4 ScaleTranslationMatrix;
 in float radius;
 in vec3 color;
index 3ff264a..6dd97b3 100644 (file)
@@ -4,7 +4,7 @@ in vec3 finalColor;
 out vec4 fragColor;
 uniform float white_factor = 1.0;
 
-vec3 linear_to_srgb_attrib(vec3 c) {
+vec3 linear_to_srgb_attr(vec3 c) {
        c = max(c, vec3(0.0));
        vec3 c1 = c * 12.92;
        vec3 c2 = 1.055 * pow(c, vec3(1.0 / 2.4)) - 0.055;
@@ -13,6 +13,6 @@ vec3 linear_to_srgb_attrib(vec3 c) {
 
 void main()
 {
-       fragColor.rgb = mix(linear_to_srgb_attrib(finalColor), vec3(1.0), white_factor);
+       fragColor.rgb = mix(linear_to_srgb_attr(finalColor), vec3(1.0), white_factor);
        fragColor.a = 1.0;
 }
index 7d2a20a..39f59a2 100644 (file)
@@ -7,7 +7,7 @@ in vec3 c; /* active color */
 
 out vec3 finalColor;
 
-vec3 srgb_to_linear_attrib(vec3 c) {
+vec3 srgb_to_linear_attr(vec3 c) {
        c = max(c, vec3(0.0));
        vec3 c1 = c * (1.0 / 12.92);
        vec3 c2 = pow((c + 0.055) * (1.0 / 1.055), vec3(2.4));
@@ -18,7 +18,7 @@ void main()
 {
        gl_Position = ModelViewProjectionMatrix * vec4(pos, 1.0);
 
-       finalColor = srgb_to_linear_attrib(c);
+       finalColor = srgb_to_linear_attr(c);
 
 #ifdef USE_WORLD_CLIP_PLANES
        world_clip_planes_calc_clip_distance((ModelMatrix * vec4(pos, 1.0)).xyz);
index dab8dd3..3224acd 100644 (file)
@@ -251,7 +251,7 @@ void UI_draw_roundbox_4fv(bool filled, float minx, float miny, float maxx, float
 }
 
 #if 0
-static void round_box_shade_col(unsigned attrib, const float col1[3], float const col2[3], const float fac)
+static void round_box_shade_col(uint attr, const float col1[3], float const col2[3], const float fac)
 {
        float col[4] = {
                fac * col1[0] + (1.0f - fac) * col2[0],
@@ -259,7 +259,7 @@ static void round_box_shade_col(unsigned attrib, const float col1[3], float cons
                fac * col1[2] + (1.0f - fac) * col2[2],
                1.0f
        };
-       immAttr4fv(attrib, col);
+       immAttr4fv(attr, col);
 }
 #endif
 
@@ -686,8 +686,8 @@ void ui_draw_but_IMAGE(ARegion *UNUSED(ar), uiBut *but, const uiWidgetColors *UN
  *
  * \Note This functionn is to be used with the 2D dashed shader enabled.
  *
- * \param pos: is a PRIM_FLOAT, 2, GPU_FETCH_FLOAT vertex attrib
- * \param line_origin: is a PRIM_FLOAT, 2, GPU_FETCH_FLOAT vertex attrib
+ * \param pos: is a PRIM_FLOAT, 2, GPU_FETCH_FLOAT vertex attribute.
+ * \param line_origin: is a PRIM_FLOAT, 2, GPU_FETCH_FLOAT vertex attribute.
  *
  * The next 4 parameters are the offsets for the view, not the zones.
  */
@@ -733,7 +733,7 @@ static void draw_scope_end(const rctf *rect, GLint *scissor)
 static void histogram_draw_one(
         float r, float g, float b, float alpha,
         float x, float y, float w, float h, const float *data, int res, const bool is_line,
-        uint pos_attrib)
+        uint pos_attr)
 {
        float color[4] = {r, g, b, alpha};
 
@@ -753,19 +753,19 @@ static void histogram_draw_one(
                immBegin(GPU_PRIM_LINE_STRIP, res);
                for (int i = 0; i < res; i++) {
                        float x2 = x + i * (w / (float)res);
-                       immVertex2f(pos_attrib, x2, y + (data[i] * h));
+                       immVertex2f(pos_attr, x2, y + (data[i] * h));
                }
                immEnd();
        }
        else {
                /* under the curve */
                immBegin(GPU_PRIM_TRI_STRIP, res * 2);
-               immVertex2f(pos_attrib, x, y);
-               immVertex2f(pos_attrib, x, y + (data[0] * h));
+               immVertex2f(pos_attr, x, y);
+               immVertex2f(pos_attr, x, y + (data[0] * h));
                for (int i = 1; i < res; i++) {
                        float x2 = x + i * (w / (float)res);
-                       immVertex2f(pos_attrib, x2, y + (data[i] * h));
-                       immVertex2f(pos_attrib, x2, y);
+                       immVertex2f(pos_attr, x2, y + (data[i] * h));
+                       immVertex2f(pos_attr, x2, y);
                }
                immEnd();
 
@@ -776,7 +776,7 @@ static void histogram_draw_one(
                immBegin(GPU_PRIM_LINE_STRIP, res);
                for (int i = 0; i < res; i++) {
                        float x2 = x + i * (w / (float)res);
-                       immVertex2f(pos_attrib, x2, y + (data[i] * h));
+                       immVertex2f(pos_attr, x2, y + (data[i] * h));
                }
                immEnd();
        }
@@ -2078,7 +2078,7 @@ void ui_draw_but_NODESOCKET(ARegion *ar, uiBut *but, const uiWidgetColors *UNUSE
  * would replace / modify the following 3 functions  - merwin
  */
 
-static void ui_shadowbox(unsigned pos, unsigned color, float minx, float miny, float maxx, float maxy, float shadsize, uchar alpha)
+static void ui_shadowbox(uint pos, uint color, float minx, float miny, float maxx, float maxy, float shadsize, uchar alpha)
 {
        /**
         * <pre>
index 17011c6..7967e94 100644 (file)
@@ -1134,7 +1134,7 @@ static int object_origin_set_exec(bContext *C, wmOperator *op)
                                                float inverse_diff_mat[4][4];
 
                                                /* recalculate all strokes
-                                                * (all layers are considered without evaluating lock attributtes) */
+                                                * (all layers are considered without evaluating lock attributes) */
                                                for (bGPDlayer *gpl = gpd->layers.first; gpl; gpl = gpl->next) {
                                                        /* calculate difference matrix */
                                                        ED_gpencil_parent_location(depsgraph, obact, gpd, gpl, diff_mat);
index 44e29f6..d746bf7 100644 (file)
@@ -807,7 +807,7 @@ static void paint_draw_alpha_overlay(
         * secondary is used for alpha/mask control */
        bool col = ELEM(mode, PAINT_MODE_TEXTURE_3D, PAINT_MODE_TEXTURE_2D, PAINT_MODE_VERTEX) ? true : false;
        eOverlayControlFlags flags = BKE_paint_get_overlay_flags();
-       gpuPushAttrib(GPU_DEPTH_BUFFER_BIT | GPU_BLEND_BIT);
+       gpuPushAttr(GPU_DEPTH_BUFFER_BIT | GPU_BLEND_BIT);
 
        /* Translate to region. */
        GPU_matrix_push();
@@ -832,7 +832,7 @@ static void paint_draw_alpha_overlay(
        }
 
        GPU_matrix_pop();
-       gpuPopAttrib();
+       gpuPopAttr();
 }
 
 
index 186acac..0364e8c 100644 (file)
 #include "GPU_common.h"
 
 typedef struct GPUAttrBinding {
-       uint64_t loc_bits; /* store 4 bits for each of the 16 attribs */
-       uint16_t enabled_bits; /* 1 bit for each attrib */
+       /** Store 4 bits for each of the 16 attributes. */
+       uint64_t loc_bits;
+       /** 1 bit for each attribute. */
+       uint16_t enabled_bits;
 } GPUAttrBinding;
 
 #endif /* __GPU_ATTR_BINDING_H__ */
index 0ef7e57..73930cd 100644 (file)
@@ -51,9 +51,13 @@ typedef enum {
 
 typedef struct GPUBatch {
        /* geometry */
-       GPUVertBuf *verts[GPU_BATCH_VBO_MAX_LEN]; /* verts[0] is required, others can be NULL */
-       GPUVertBuf *inst; /* instance attribs */
-       GPUIndexBuf *elem; /* NULL if element list not needed */
+
+       /** verts[0] is required, others can be NULL */
+       GPUVertBuf *verts[GPU_BATCH_VBO_MAX_LEN];
+       /** Instance attributes. */
+       GPUVertBuf *inst;
+       /** NULL if element list not needed */
+       GPUIndexBuf *elem;
        uint32_t gl_prim_type;
 
        /* cached values (avoid dereferencing later) */
@@ -63,21 +67,22 @@ typedef struct GPUBatch {
 
        /* book-keeping */
        uint owns_flag;
-       struct GPUContext *context; /* used to free all vaos. this implies all vaos were created under the same context. */
+       /** used to free all vaos. this implies all vaos were created under the same context. */
+       struct GPUContext *context;
        GPUBatchPhase phase;
        bool program_in_use;
 
-       /* Vao management: remembers all geometry state (vertex attrib bindings & element buffer)
+       /* Vao management: remembers all geometry state (vertex attribute bindings & element buffer)
         * for each shader interface. Start with a static number of vaos and fallback to dynamic count
         * if necessary. Once a batch goes dynamic it does not go back. */
        bool is_dynamic_vao_count;
        union {
-               /* Static handle count */
+               /** Static handle count */
                struct {
                        const struct GPUShaderInterface *interfaces[GPU_BATCH_VAO_STATIC_LEN];
                        uint32_t vao_ids[GPU_BATCH_VAO_STATIC_LEN];
                } static_vaos;
-               /* Dynamic handle count */
+               /** Dynamic handle count */
                struct {
                        uint count;
                        const struct GPUShaderInterface **interfaces;
index 17fbebd..dc5f55c 100644 (file)
@@ -112,16 +112,16 @@ void      GPU_select_index_get(int index, int *r_col);
 int            GPU_select_to_index(unsigned int col);
 void   GPU_select_to_index_array(unsigned int *col, const unsigned int size);
 
-typedef enum eGPUAttribMask {
+typedef enum eGPUAttrMask {
        GPU_DEPTH_BUFFER_BIT = (1 << 0),
        GPU_ENABLE_BIT = (1 << 1),
        GPU_SCISSOR_BIT = (1 << 2),
        GPU_VIEWPORT_BIT = (1 << 3),
        GPU_BLEND_BIT = (1 << 4),
-} eGPUAttribMask;
+} eGPUAttrMask;
 
-void gpuPushAttrib(eGPUAttribMask mask);
-void gpuPopAttrib(void);
+void gpuPushAttr(eGPUAttrMask mask);
+void gpuPopAttr(void);
 
 #ifdef __cplusplus
 }
index a04be7a..90d9750 100644 (file)
 #include "GPU_immediate_util.h"
 #include "GPU_shader.h"
 
-GPUVertFormat *immVertexFormat(void); /* returns a cleared vertex format, ready for add_attrib. */
-
-void immBindProgram(uint32_t program, const GPUShaderInterface *); /* every immBegin must have a program bound first. */
-void immUnbindProgram(void); /* call after your last immEnd, or before binding another program. */
-
-void immBegin(GPUPrimType, uint vertex_len); /* must supply exactly vertex_len vertices. */
-void immBeginAtMost(GPUPrimType, uint max_vertex_len); /* can supply fewer vertices. */
+/** Returns a cleared vertex format, ready for #add_attr. */
+GPUVertFormat *immVertexFormat(void);
+
+/** Every immBegin must have a program bound first. */
+void immBindProgram(uint32_t program, const GPUShaderInterface *);
+/** Call after your last immEnd, or before binding another program. */
+void immUnbindProgram(void);
+
+/** Must supply exactly vertex_len vertices. */
+void immBegin(GPUPrimType, uint vertex_len);
+/** Can supply fewer vertices. */
+void immBeginAtMost(GPUPrimType, uint max_vertex_len);
 void immEnd(void); /* finishes and draws. */
 
 /* ImmBegin a batch, then use standard immFunctions as usual. */
index 58dec24..db88e65 100644 (file)
@@ -47,7 +47,7 @@ struct GPUNodeLink;
 struct GPUNodeStack;
 struct GPUTexture;
 struct GPUUniformBuffer;
-struct GPUVertexAttribs;
+struct GPUVertAttrLayers;
 struct Image;
 struct ImageUser;
 struct ListBase;
@@ -90,7 +90,7 @@ typedef enum eGPUType {
        GPU_CLOSURE = 1006,
 
        /* Opengl Attributes */
-       GPU_ATTRIB = 3001,
+       GPU_ATTR = 3001,
 } eGPUType;
 
 typedef enum eGPUBuiltin {
@@ -189,9 +189,9 @@ struct GPUUniformBuffer *GPU_material_uniform_buffer_get(GPUMaterial *material);
 void GPU_material_uniform_buffer_create(GPUMaterial *material, ListBase *inputs);
 struct GPUUniformBuffer *GPU_material_create_sss_profile_ubo(void);
 
-void GPU_material_vertex_attributes(
+void GPU_material_vertex_attrs(
         GPUMaterial *material,
-        struct GPUVertexAttribs *attrib);
+        struct GPUVertAttrLayers *attrs);
 
 bool GPU_material_do_color_management(GPUMaterial *mat);
 bool GPU_material_use_domain_surface(GPUMaterial *mat);
index 0004642..093f117 100644 (file)
@@ -383,20 +383,20 @@ void GPU_shader_free_builtin_shaders(void);
 
 /* Vertex attributes for shaders */
 
-#define GPU_MAX_ATTRIB 32
+#define GPU_MAX_ATTR 32
 
-typedef struct GPUVertexAttribs {
+typedef struct GPUVertAttrLayers {
        struct {
                int type;
                int glindex;
                int glinfoindoex;
                int gltexco;
-               int attribid;
+               int attr_id;
                char name[64];  /* MAX_CUSTOMDATA_LAYER_NAME */
-       } layer[GPU_MAX_ATTRIB];
+       } layer[GPU_MAX_ATTR];
 
        int totlayer;
-} GPUVertexAttribs;
+} GPUVertAttrLayers;
 
 #ifdef __cplusplus
 }
index 0559a72..8d94c07 100644 (file)
@@ -69,9 +69,12 @@ typedef struct GPUShaderInput {
        struct GPUShaderInput *next;
        uint32_t name_offset;
        uint name_hash;
-       GPUUniformBuiltin builtin_type; /* only for uniform inputs */
-       uint32_t gl_type; /* only for attrib inputs */
-       int32_t size; /* only for attrib inputs */
+       /** Only for uniform inputs. */
+       GPUUniformBuiltin builtin_type;
+       /** Only for attribute inputs. */
+       uint32_t gl_type;
+       /** Only for attribute inputs. */
+       int32_t size;
        int32_t location;
 } GPUShaderInput;
 
@@ -81,7 +84,7 @@ typedef struct GPUShaderInput {
 typedef struct GPUShaderInterface {
        int32_t program;
        uint32_t name_buffer_offset;
-       GPUShaderInput *attrib_buckets[GPU_NUM_SHADERINTERFACE_BUCKETS];
+       GPUShaderInput *attr_buckets[GPU_NUM_SHADERINTERFACE_BUCKETS];
        GPUShaderInput *uniform_buckets[GPU_NUM_SHADERINTERFACE_BUCKETS];
        GPUShaderInput *ubo_buckets[GPU_NUM_SHADERINTERFACE_BUCKETS];
        GPUShaderInput *builtin_uniforms[GPU_NUM_UNIFORMS];
index cc508de..721a455 100644 (file)
@@ -79,10 +79,10 @@ void GPU_vertbuf_data_alloc(GPUVertBuf *, uint v_len);
 void GPU_vertbuf_data_resize(GPUVertBuf *, uint v_len);
 void GPU_vertbuf_data_len_set(GPUVertBuf *, uint v_len);
 
-/* The most important set_attrib variant is the untyped one. Get it right first. */
-/* It takes a void* so the app developer is responsible for matching their app data types */
-/* to the vertex attribute's type and component count. They're in control of both, so this */
-/* should not be a problem. */
+/* The most important #set_attr variant is the untyped one. Get it right first.
+ * It takes a void* so the app developer is responsible for matching their app data types
+ * to the vertex attribute's type and component count. They're in control of both, so this
+ * should not be a problem. */
 
 void GPU_vertbuf_attr_set(GPUVertBuf *, uint a_idx, uint v_idx, const void *data);
 void GPU_vertbuf_attr_fill(GPUVertBuf *, uint a_idx, const void *data); /* tightly packed, non interleaved input data */
index 7a271ca..ed8feb1 100644 (file)
@@ -71,13 +71,17 @@ typedef struct GPUVertAttr {
 } GPUVertAttr;
 
 typedef struct GPUVertFormat {
-       uint attr_len; /* 0 to 16 (GPU_VERT_ATTR_MAX_LEN) */
-       uint name_len; /* total count of active vertex attrib */
-       uint stride; /* stride in bytes, 1 to 256 */
+       /** 0 to 16 (GPU_VERT_ATTR_MAX_LEN). */
+       uint attr_len;
+       /** Total count of active vertex attribute. */
+       uint name_len;
+       /** Stride in bytes, 1 to 256. */
+       uint stride;
        uint name_offset;
        bool packed;
        char names[GPU_VERT_ATTR_NAMES_BUF_LEN];
-       GPUVertAttr attribs[GPU_VERT_ATTR_MAX_LEN]; /* TODO: variable-size attribs array */
+       /** TODO: variable-size array */
+       GPUVertAttr attrs[GPU_VERT_ATTR_MAX_LEN];
 } GPUVertFormat;
 
 struct GPUShaderInterface;
@@ -93,7 +97,7 @@ void GPU_vertformat_alias_add(GPUVertFormat *, const char *alias);
 int GPU_vertformat_attr_id_get(const GPUVertFormat *, const char *name);
 
 /**
- * This makes the "virtual" attribs with suffixes "0", "1", "2" to access triangle data in the vertex
+ * This makes the "virtual" attributes with suffixes "0", "1", "2" to access triangle data in the vertex
  * shader.
  *
  * IMPORTANT:
index 398b97c..2cf6516 100644 (file)
 #include <stdlib.h>
 
 #if GPU_VERT_ATTR_MAX_LEN != 16
-#  error "attrib binding code assumes GPU_VERT_ATTR_MAX_LEN = 16"
+#  error "attribute binding code assumes GPU_VERT_ATTR_MAX_LEN = 16"
 #endif
 
-void AttribBinding_clear(GPUAttrBinding *binding)
+void AttrBinding_clear(GPUAttrBinding *binding)
 {
        binding->loc_bits = 0;
        binding->enabled_bits = 0;
 }
 
-uint read_attrib_location(const GPUAttrBinding *binding, uint a_idx)
+uint read_attr_location(const GPUAttrBinding *binding, uint a_idx)
 {
 #if TRUST_NO_ONE
        assert(a_idx < GPU_VERT_ATTR_MAX_LEN);
@@ -53,7 +53,7 @@ uint read_attrib_location(const GPUAttrBinding *binding, uint a_idx)
        return (binding->loc_bits >> (4 * a_idx)) & 0xF;
 }
 
-static void write_attrib_location(GPUAttrBinding *binding, uint a_idx, uint location)
+static void write_attr_location(GPUAttrBinding *binding, uint a_idx, uint location)
 {
 #if TRUST_NO_ONE
        assert(a_idx < GPU_VERT_ATTR_MAX_LEN);
@@ -61,25 +61,25 @@ static void write_attrib_location(GPUAttrBinding *binding, uint a_idx, uint loca
 #endif
        const uint shift = 4 * a_idx;
        const uint64_t mask = ((uint64_t)0xF) << shift;
-       /* overwrite this attrib's previous location */
+       /* overwrite this attr's previous location */
        binding->loc_bits = (binding->loc_bits & ~mask) | (location << shift);
-       /* mark this attrib as enabled */
+       /* mark this attr as enabled */
        binding->enabled_bits |= 1 << a_idx;
 }
 
-void get_attrib_locations(const GPUVertFormat *format, GPUAttrBinding *binding, const GPUShaderInterface *shaderface)
+void get_attr_locations(const GPUVertFormat *format, GPUAttrBinding *binding, const GPUShaderInterface *shaderface)
 {
-       AttribBinding_clear(binding);
+       AttrBinding_clear(binding);
 
        for (uint a_idx = 0; a_idx < format->attr_len; ++a_idx) {
-               const GPUVertAttr *a = format->attribs + a_idx;
+               const GPUVertAttr *a = &format->attrs[a_idx];
                for (uint n_idx = 0; n_idx < a->name_len; ++n_idx) {
                        const GPUShaderInput *input = GPU_shaderinterface_attr(shaderface, a->name[n_idx]);
 #if TRUST_NO_ONE
                        assert(input != NULL);
                        /* TODO: make this a recoverable runtime error? indicates mismatch between vertex format and program */
 #endif
-                       write_attrib_location(binding, a_idx, input->location);
+                       write_attr_location(binding, a_idx, input->location);
                }
        }
 }
index c545983..a42e80b 100644 (file)
 #include "GPU_vertex_format.h"
 #include "GPU_shader_interface.h"
 
-void AttribBinding_clear(GPUAttrBinding *binding);
+void AttrBinding_clear(GPUAttrBinding *binding);
 
-void get_attrib_locations(
+void get_attr_locations(
         const GPUVertFormat *format, GPUAttrBinding *binding, const GPUShaderInterface *shaderface);
-uint read_attrib_location(
+uint read_attr_location(
         const GPUAttrBinding *binding, uint a_idx);
 
 #endif /* __GPU_ATTR_BINDING_PRIVATE_H__ */
index 8bd93b5..eaa6182 100644 (file)
@@ -197,7 +197,7 @@ int GPU_batch_vertbuf_add_ex(
                        assert(verts->vertex_len == batch->verts[0]->vertex_len);
 #endif
                        batch->verts[v] = verts;
-                       /* TODO: mark dirty so we can keep attrib bindings up-to-date */
+                       /* TODO: mark dirty so we can keep attribute bindings up-to-date */
                        if (own_vbo)
                                batch->owns_flag |= (1 << v);
                        return v;
@@ -351,7 +351,7 @@ static void create_bindings(
        GPU_vertbuf_use(verts);
 
        for (uint a_idx = 0; a_idx < attr_len; ++a_idx) {
-               const GPUVertAttr *a = format->attribs + a_idx;
+               const GPUVertAttr *a = &format->attrs[a_idx];
                const GLvoid *pointer = (const GLubyte *)0 + a->offset + v_first * stride;
 
                for (uint n_idx = 0; n_idx < a->name_len; ++n_idx) {
index 78dc0ce..c216069 100644 (file)
@@ -78,14 +78,14 @@ static char *glsl_material_library = NULL;
 static GPUPass *pass_cache = NULL;
 static SpinLock pass_cache_spin;
 
-static uint32_t gpu_pass_hash(const char *frag_gen, const char *defs, GPUVertexAttribs *attribs)
+static uint32_t gpu_pass_hash(const char *frag_gen, const char *defs, GPUVertAttrLayers *attrs)
 {
        BLI_HashMurmur2A hm2a;
        BLI_hash_mm2a_init(&hm2a, 0);
        BLI_hash_mm2a_add(&hm2a, (uchar *)frag_gen, strlen(frag_gen));
-       if (attribs) {
-               for (int att_idx = 0; att_idx < attribs->totlayer; att_idx++) {
-                       char *name = attribs->layer[att_idx].name;
+       if (attrs) {
+               for (int att_idx = 0; att_idx < attrs->totlayer; att_idx++) {
+                       char *name = attrs->layer[att_idx].name;
                        BLI_hash_mm2a_add(&hm2a, (uchar *)name, strlen(name));
                }
        }
@@ -636,10 +636,10 @@ static int codegen_process_uniforms_functions(GPUMaterial *material, DynStr *ds,
                                codegen_print_datatype(ds, input->type, input->vec);
                                BLI_dynstr_append(ds, ";\n");
                        }
-                       else if (input->source == GPU_SOURCE_ATTRIB && input->attribfirst) {
+                       else if (input->source == GPU_SOURCE_ATTR && input->attr_first) {
                                BLI_dynstr_appendf(
                                        ds, "in %s var%d;\n",
-                                       GPU_DATATYPE_STR[input->type], input->attribid);
+                                       GPU_DATATYPE_STR[input->type], input->attr_id);
                        }
                }
        }
@@ -743,8 +743,8 @@ static void codegen_call_functions(DynStr *ds, ListBase *nodes, GPUOutput *final
                        else if (input->source == GPU_SOURCE_CONSTANT) {
                                BLI_dynstr_appendf(ds, "cons%d", input->id);
                        }
-                       else if (input->source == GPU_SOURCE_ATTRIB) {
-                               BLI_dynstr_appendf(ds, "var%d", input->attribid);
+                       else if (input->source == GPU_SOURCE_ATTR) {
+                               BLI_dynstr_appendf(ds, "var%d", input->attr_id);
                        }
 
                        BLI_dynstr_append(ds, ", ");
@@ -841,7 +841,7 @@ static char *code_generate_fragment(GPUMaterial *material, ListBase *nodes, GPUO
        return code;
 }
 
-static const char *attrib_prefix_get(CustomDataType type)
+static const char *attr_prefix_get(CustomDataType type)
 {
        switch (type) {
                case CD_ORCO:           return "orco";
@@ -861,13 +861,13 @@ static char *code_generate_vertex(ListBase *nodes, const char *vert_code, bool u
        char *code;
        int builtins = 0;
 
-       /* Hairs uv and col attribs are passed by bufferTextures. */
+       /* Hairs uv and col attributes are passed by bufferTextures. */
        BLI_dynstr_append(
                ds,
                "#ifdef HAIR_SHADER\n"
-               "#define DEFINE_ATTRIB(type, attr) uniform samplerBuffer attr\n"
+               "#define DEFINE_ATTR(type, attr) uniform samplerBuffer attr\n"
                "#else\n"
-               "#define DEFINE_ATTRIB(type, attr) in type attr\n"
+               "#define DEFINE_ATTR(type, attr) in type attr\n"
                "#endif\n"
        );
 
@@ -876,35 +876,35 @@ static char *code_generate_vertex(ListBase *nodes, const char *vert_code, bool u
                        if (input->source == GPU_SOURCE_BUILTIN) {
                                builtins |= input->builtin;
                        }
-                       if (input->source == GPU_SOURCE_ATTRIB && input->attribfirst) {
+                       if (input->source == GPU_SOURCE_ATTR && input->attr_first) {
                                /* XXX FIXME : see notes in mesh_render_data_create() */
                                /* NOTE : Replicate changes to mesh_render_data_create() in draw_cache_impl_mesh.c */
-                               if (input->attribtype == CD_ORCO) {
+                               if (input->attr_type == CD_ORCO) {
                                        /* orco is computed from local positions, see below */
                                        BLI_dynstr_appendf(ds, "uniform vec3 OrcoTexCoFactors[2];\n");
                                }
-                               else if (input->attribname[0] == '\0') {
-                                       BLI_dynstr_appendf(ds, "DEFINE_ATTRIB(%s, %s);\n", GPU_DATATYPE_STR[input->type], attrib_prefix_get(input->attribtype));
-                                       BLI_dynstr_appendf(ds, "#define att%d %s\n", input->attribid, attrib_prefix_get(input->attribtype));
+                               else if (input->attr_name[0] == '\0') {
+                                       BLI_dynstr_appendf(ds, "DEFINE_ATTR(%s, %s);\n", GPU_DATATYPE_STR[input->type], attr_prefix_get(input->attr_type));
+                                       BLI_dynstr_appendf(ds, "#define att%d %s\n", input->attr_id, attr_prefix_get(input->attr_type));
                                }
                                else {
-                                       uint hash = BLI_ghashutil_strhash_p(input->attribname);
+                                       uint hash = BLI_ghashutil_strhash_p(input->attr_name);
                                        BLI_dynstr_appendf(
-                                               ds, "DEFINE_ATTRIB(%s, %s%u);\n",
-                                               GPU_DATATYPE_STR[input->type], attrib_prefix_get(input->attribtype), hash);
+                                               ds, "DEFINE_ATTR(%s, %s%u);\n",
+                                               GPU_DATATYPE_STR[input->type], attr_prefix_get(input->attr_type), hash);
                                        BLI_dynstr_appendf(
                                                ds, "#define att%d %s%u\n",
-                                               input->attribid, attrib_prefix_get(input->attribtype), hash);
-                                       /* Auto attrib can be vertex color byte buffer.
+                                               input->attr_id, attr_prefix_get(input->attr_type), hash);
+                                       /* Auto attribute can be vertex color byte buffer.
                                         * We need to know and convert them to linear space in VS. */
-                                       if (!use_geom && input->attribtype == CD_AUTO_FROM_NAME) {
+                                       if (!use_geom && input->attr_type == CD_AUTO_FROM_NAME) {
                                                BLI_dynstr_appendf(ds, "uniform bool ba%u;\n", hash);
-                                               BLI_dynstr_appendf(ds, "#define att%d_is_srgb ba%u\n", input->attribid, hash);
+                                               BLI_dynstr_appendf(ds, "#define att%d_is_srgb ba%u\n", input->attr_id, hash);
                                        }
                                }
                                BLI_dynstr_appendf(
                                        ds, "out %s var%d%s;\n",
-                                       GPU_DATATYPE_STR[input->type], input->attribid, use_geom ? "g" : "");
+                                       GPU_DATATYPE_STR[input->type], input->attr_id, use_geom ? "g" : "");
                        }
                }
        }
@@ -924,11 +924,11 @@ static char *code_generate_vertex(ListBase *nodes, const char *vert_code, bool u
 
        BLI_dynstr_append(
                ds,
-               "#define ATTRIB\n"
+               "#define USE_ATTR\n"
                "uniform mat3 NormalMatrix;\n"
                "uniform mat4 ModelMatrixInverse;\n"
                "uniform mat4 ModelMatrix;\n"
-               "vec3 srgb_to_linear_attrib(vec3 c) {\n"
+               "vec3 srgb_to_linear_attr(vec3 c) {\n"
                "\tc = max(c, vec3(0.0));\n"
                "\tvec3 c1 = c * (1.0 / 12.92);\n"
                "\tvec3 c2 = pow((c + 0.055) * (1.0 / 1.055), vec3(2.4));\n"
@@ -947,7 +947,7 @@ static char *code_generate_vertex(ListBase *nodes, const char *vert_code, bool u
                "\n"
        );
 
-       BLI_dynstr_append(ds, "void pass_attrib(in vec3 position) {\n");
+       BLI_dynstr_append(ds, "void pass_attr(in vec3 position) {\n");
 
        BLI_dynstr_append(ds, "#ifdef HAIR_SHADER\n");
 
@@ -971,22 +971,22 @@ static char *code_generate_vertex(ListBase *nodes, const char *vert_code, bool u
 
        for (node = nodes->first; node; node = node->next) {
                for (input = node->inputs.first; input; input = input->next) {
-                       if (input->source == GPU_SOURCE_ATTRIB && input->attribfirst) {
-                               if (input->attribtype == CD_TANGENT) {
+                       if (input->source == GPU_SOURCE_ATTR && input->attr_first) {
+                               if (input->attr_type == CD_TANGENT) {
                                        /* Not supported by hairs */
                                        BLI_dynstr_appendf(
                                                ds, "\tvar%d%s = vec4(0.0);\n",
-                                               input->attribid, use_geom ? "g" : "");
+                                               input->attr_id, use_geom ? "g" : "");
                                }
-                               else if (input->attribtype == CD_ORCO) {
+                               else if (input->attr_type == CD_ORCO) {
                                        BLI_dynstr_appendf(
                                                ds, "\tvar%d%s = OrcoTexCoFactors[0] + (ModelMatrixInverse * vec4(hair_get_strand_pos(), 1.0)).xyz * OrcoTexCoFactors[1];\n",
-                                               input->attribid, use_geom ? "g" : "");
+                                               input->attr_id, use_geom ? "g" : "");
                                }
                                else {
                                        BLI_dynstr_appendf(
                                                ds, "\tvar%d%s = hair_get_customdata_%s(att%d);\n",
-                                               input->attribid, use_geom ? "g" : "", GPU_DATATYPE_STR[input->type], input->attribid);
+                                               input->attr_id, use_geom ? "g" : "", GPU_DATATYPE_STR[input->type], input->attr_id);
                                }
                        }
                }
@@ -1009,35 +1009,35 @@ static char *code_generate_vertex(ListBase *nodes, const char *vert_code, bool u
 
        for (node = nodes->first; node; node = node->next) {
                for (input = node->inputs.first; input; input = input->next) {
-                       if (input->source == GPU_SOURCE_ATTRIB && input->attribfirst) {
-                               if (input->attribtype == CD_TANGENT) { /* silly exception */
+                       if (input->source == GPU_SOURCE_ATTR && input->attr_first) {
+                               if (input->attr_type == CD_TANGENT) { /* silly exception */
                                        BLI_dynstr_appendf(
                                                ds, "\tvar%d%s.xyz = normalize(NormalMatrix * att%d.xyz);\n",
-                                               input->attribid, use_geom ? "g" : "", input->attribid);
+                                               input->attr_id, use_geom ? "g" : "", input->attr_id);
                                        BLI_dynstr_appendf(
                                                ds, "\tvar%d%s.w = att%d.w;\n",
-                                               input->attribid, use_geom ? "g" : "", input->attribid);
+                                               input->attr_id, use_geom ? "g" : "", input->attr_id);
                                }
-                               else if (input->attribtype == CD_ORCO) {
+                               else if (input->attr_type == CD_ORCO) {
                                        BLI_dynstr_appendf(
                                                ds, "\tvar%d%s = OrcoTexCoFactors[0] + position * OrcoTexCoFactors[1];\n",
-                                               input->attribid, use_geom ? "g" : "");
+                                               input->attr_id, use_geom ? "g" : "");
                                }
-                               else if (input->attribtype == CD_MCOL) {
+                               else if (input->attr_type == CD_MCOL) {
                                        BLI_dynstr_appendf(
-                                               ds, "\tvar%d%s = srgb_to_linear_attrib(att%d);\n",
-                                               input->attribid, use_geom ? "g" : "", input->attribid);
+                                               ds, "\tvar%d%s = srgb_to_linear_attr(att%d);\n",
+                                               input->attr_id, use_geom ? "g" : "", input->attr_id);
                                }
-                               else if (input->attribtype == CD_AUTO_FROM_NAME) {
+                               else if (input->attr_type == CD_AUTO_FROM_NAME) {
                                        BLI_dynstr_appendf(
-                                               ds, "\tvar%d%s = (att%d_is_srgb) ? srgb_to_linear_attrib(att%d) : att%d;\n",
-                                               input->attribid, use_geom ? "g" : "",
-                                               input->attribid, input->attribid, input->attribid);
+                                               ds, "\tvar%d%s = (att%d_is_srgb) ? srgb_to_linear_attr(att%d) : att%d;\n",
+                                               input->attr_id, use_geom ? "g" : "",
+                                               input->attr_id, input->attr_id, input->attr_id);
                                }
                                else {
                                        BLI_dynstr_appendf(
                                                ds, "\tvar%d%s = att%d;\n",
-                                               input->attribid, use_geom ? "g" : "", input->attribid);
+                                               input->attr_id, use_geom ? "g" : "", input->attr_id);
                                }
                        }
                }
@@ -1088,9 +1088,9 @@ static char *code_generate_geometry(ListBase *nodes, const char *geom_code)
        int builtins = 0;
 
        /* Create prototype because attributes cannot be declared before layout. */
-       BLI_dynstr_appendf(ds, "void pass_attrib(in int vert);\n");
+       BLI_dynstr_appendf(ds, "void pass_attr(in int vert);\n");
        BLI_dynstr_appendf(ds, "void calc_barycentric_distances(vec3 pos0, vec3 pos1, vec3 pos2);\n");
-       BLI_dynstr_append(ds, "#define ATTRIB\n");
+       BLI_dynstr_append(ds, "#define USE_ATTR\n");
 
        /* Generate varying declarations. */
        for (node = nodes->first; node; node = node->next) {
@@ -1098,15 +1098,15 @@ static char *code_generate_geometry(ListBase *nodes, const char *geom_code)
                        if (input->source == GPU_SOURCE_BUILTIN) {
                                builtins |= input->builtin;
                        }
-                       if (input->source == GPU_SOURCE_ATTRIB && input->attribfirst) {
+                       if (input->source == GPU_SOURCE_ATTR && input->attr_first) {
                                BLI_dynstr_appendf(
                                        ds, "in %s var%dg[];\n",
                                        GPU_DATATYPE_STR[input->type],
-                                       input->attribid);
+                                       input->attr_id);
                                BLI_dynstr_appendf(
                                        ds, "out %s var%d;\n",
                                        GPU_DATATYPE_STR[input->type],
-                                       input->attribid);
+                                       input->attr_id);
                        }
                }
        }
@@ -1150,15 +1150,15 @@ static char *code_generate_geometry(ListBase *nodes, const char *geom_code)
                        }
 
                        BLI_dynstr_appendf(ds, "\tgl_Position = gl_in[0].gl_Position;\n");
-                       BLI_dynstr_appendf(ds, "\tpass_attrib(0);\n");
+                       BLI_dynstr_appendf(ds, "\tpass_attr(0);\n");
                        BLI_dynstr_appendf(ds, "\tEmitVertex();\n");
 
                        BLI_dynstr_appendf(ds, "\tgl_Position = gl_in[1].gl_Position;\n");
-                       BLI_dynstr_appendf(ds, "\tpass_attrib(1);\n");
+                       BLI_dynstr_appendf(ds, "\tpass_attr(1);\n");
                        BLI_dynstr_appendf(ds, "\tEmitVertex();\n");
 
                        BLI_dynstr_appendf(ds, "\tgl_Position = gl_in[2].gl_Position;\n");
-                       BLI_dynstr_appendf(ds, "\tpass_attrib(2);\n");
+                       BLI_dynstr_appendf(ds, "\tpass_attr(2);\n");
                        BLI_dynstr_appendf(ds, "\tEmitVertex();\n");
                        BLI_dynstr_appendf(ds, "};\n");
                }
@@ -1186,7 +1186,7 @@ static char *code_generate_geometry(ListBase *nodes, const char *geom_code)
        }
 
        /* Generate varying assignments. */
-       BLI_dynstr_appendf(ds, "void pass_attrib(in int vert) {\n");
+       BLI_dynstr_appendf(ds, "void pass_attr(in int vert) {\n");
 
        /* XXX HACK: Eevee specific. */
        if (geom_code == NULL) {
@@ -1202,9 +1202,9 @@ static char *code_generate_geometry(ListBase *nodes, const char *geom_code)
 
        for (node = nodes->first; node; node = node->next) {
                for (input = node->inputs.first; input; input = input->next) {
-                       if (input->source == GPU_SOURCE_ATTRIB && input->attribfirst) {
-                               /* TODO let shader choose what to do depending on what the attrib is. */
-                               BLI_dynstr_appendf(ds, "\tvar%d = var%dg[vert];\n", input->attribid, input->attribid);
+                       if (input->source == GPU_SOURCE_ATTR && input->attr_first) {
+                               /* TODO let shader choose what to do depending on what the attribute is. */
+                               BLI_dynstr_appendf(ds, "\tvar%d = var%dg[vert];\n", input->attr_id, input->attr_id);
                        }
                }
        }
@@ -1262,7 +1262,7 @@ void GPU_nodes_extract_dynamic_inputs(GPUShader *shader, ListBase *inputs, ListB
                        /* attributes don't need to be bound, they already have
                         * an id that the drawing functions will use. Builtins have
                         * constant names. */
-                       if (ELEM(input->source, GPU_SOURCE_ATTRIB, GPU_SOURCE_BUILTIN)) {
+                       if (ELEM(input->source, GPU_SOURCE_ATTR, GPU_SOURCE_BUILTIN)) {
                                continue;
                        }
 
@@ -1367,10 +1367,10 @@ static void gpu_node_input_link(GPUNode *node, GPUNodeLink *link, const eGPUType
                        input->iuser = link->iuser;
                        input->image_isdata = link->image_isdata;
                        break;
-               case GPU_NODE_LINK_ATTRIB:
-                       input->source = GPU_SOURCE_ATTRIB;
-                       input->attribtype = link->attribtype;
-                       BLI_strncpy(input->attribname, link->attribname, sizeof(input->attribname));
+               case GPU_NODE_LINK_ATTR:
+                       input->source = GPU_SOURCE_ATTR;
+                       input->attr_type = link->attr_type;
+                       BLI_strncpy(input->attr_name, link->attr_name, sizeof(input->attr_name));
                        break;
                case GPU_NODE_LINK_CONSTANT:
                        input->source = (type == GPU_CLOSURE) ? GPU_SOURCE_STRUCT : GPU_SOURCE_CONSTANT;
@@ -1533,7 +1533,7 @@ static void gpu_nodes_free(ListBase *nodes)
 
 /* vertex attributes */
 
-void GPU_nodes_get_vertex_attributes(ListBase *nodes, GPUVertexAttribs *attribs)
+void GPU_nodes_get_vertex_attrs(ListBase *nodes, GPUVertAttrLayers *attrs)
 {
        GPUNode *node;
        GPUInput *input;
@@ -1542,32 +1542,32 @@ void GPU_nodes_get_vertex_attributes(ListBase *nodes, GPUVertexAttribs *attribs)
        /* convert attributes requested by node inputs to an array of layers,
         * checking for duplicates and assigning id's starting from zero. */
 
-       memset(attribs, 0, sizeof(*attribs));
+       memset(attrs, 0, sizeof(*attrs));
 
        for (node = nodes->first; node; node = node->next) {
                for (input = node->inputs.first; input; input = input->next) {
-                       if (input->source == GPU_SOURCE_ATTRIB) {
-                               for (a = 0; a < attribs->totlayer; a++) {
-                                       if (attribs->layer[a].type == input->attribtype &&
-                                           STREQ(attribs->layer[a].name, input->attribname))
+                       if (input->source == GPU_SOURCE_ATTR) {
+                               for (a = 0; a < attrs->totlayer; a++) {
+                                       if (attrs->layer[a].type == input->attr_type &&
+                                           STREQ(attrs->layer[a].name, input->attr_name))
                                        {
                                                break;
                                        }
                                }
 
-                               if (a < GPU_MAX_ATTRIB) {
-                                       if (a == attribs->totlayer) {
-                                               input->attribid = attribs->totlayer++;
-                                               input->attribfirst = true;
+                               if (a < GPU_MAX_ATTR) {
+                                       if (a == attrs->totlayer) {
+                                               input->attr_id = attrs->totlayer++;
+                                               input->attr_first = true;
 
-                                               attribs->layer[a].type = input->attribtype;
-                                               attribs->layer[a].attribid = input->attribid;
+                                               attrs->layer[a].type = input->attr_type;
+                                               attrs->layer[a].attr_id = input->attr_id;
                                                BLI_strncpy(
-                                                       attribs->layer[a].name, input->attribname,
-                                                       sizeof(attribs->layer[a].name));
+                                                       attrs->layer[a].name, input->attr_name,
+                                                       sizeof(attrs->layer[a].name));
                                        }
                                        else {
-                                               input->attribid = attribs->layer[a].attribid;
+                                               input->attr_id = attrs->layer[a].attr_id;
                                        }
                                }
                        }
@@ -1580,14 +1580,14 @@ void GPU_nodes_get_vertex_attributes(ListBase *nodes, GPUVertexAttribs *attribs)
 GPUNodeLink *GPU_attribute(const CustomDataType type, const char *name)
 {
        GPUNodeLink *link = GPU_node_link_create();
-       link->link_type = GPU_NODE_LINK_ATTRIB;
-       link->attribname = name;
+       link->link_type = GPU_NODE_LINK_ATTR;
+       link->attr_name = name;
        /* Fall back to the UV layer, which matches old behavior. */
        if (type == CD_AUTO_FROM_NAME && name[0] == '\0') {
-               link->attribtype = CD_MTFACE;
+               link->attr_type = CD_MTFACE;
        }
        else {
-               link->attribtype = type;
+               link->attr_type = type;
        }
        return link;
 }
@@ -1787,7 +1787,7 @@ static bool gpu_pass_is_valid(GPUPass *pass)
 GPUPass *GPU_generate_pass(
         GPUMaterial *material,
         GPUNodeLink *frag_outlink,
-        struct GPUVertexAttribs *attribs,
+        struct GPUVertAttrLayers *attrs,
         ListBase *nodes,
         int *builtins,
         const char *vert_code,
@@ -1801,13 +1801,13 @@ GPUPass *GPU_generate_pass(
        /* prune unused nodes */
        GPU_nodes_prune(nodes, frag_outlink);
 
-       GPU_nodes_get_vertex_attributes(nodes, attribs);
+       GPU_nodes_get_vertex_attrs(nodes, attrs);
 
        /* generate code */
        char *fragmentgen = code_generate_fragment(material, nodes, frag_outlink->output, builtins);
 
        /* Cache lookup: Reuse shaders already compiled */
-       uint32_t hash = gpu_pass_hash(fragmentgen, defines, attribs);
+       uint32_t hash = gpu_pass_hash(fragmentgen, defines, attrs);
        pass_hash = gpu_pass_cache_lookup(hash);
 
        if (pass_hash && (pass_hash->next == NULL || pass_hash->next->hash != hash)) {
index 2325fb5..9c306cb 100644 (file)
@@ -41,7 +41,7 @@
 struct GPUNode;
 struct GPUOutput;
 struct GPUShader;
-struct GPUVertexAttribs;
+struct GPUVertAttrLayers;
 struct ListBase;
 struct PreviewImage;
 
@@ -55,7 +55,7 @@ typedef enum eGPUDataSource {
        GPU_SOURCE_OUTPUT,
        GPU_SOURCE_CONSTANT,
        GPU_SOURCE_UNIFORM,
-       GPU_SOURCE_ATTRIB,
+       GPU_SOURCE_ATTR,
        GPU_SOURCE_BUILTIN,
        GPU_SOURCE_STRUCT,
        GPU_SOURCE_TEX,
@@ -63,7 +63,7 @@ typedef enum eGPUDataSource {
 
 typedef enum {
        GPU_NODE_LINK_NONE = 0,
-       GPU_NODE_LINK_ATTRIB,
+       GPU_NODE_LINK_ATTR,
        GPU_NODE_LINK_BUILTIN,
        GPU_NODE_LINK_COLORBAND,
        GPU_NODE_LINK_CONSTANT,
@@ -99,10 +99,10 @@ struct GPUNodeLink {
                struct GPUTexture **coba;
                /* GPU_NODE_LINK_OUTPUT */
                struct GPUOutput *output;
-               /* GPU_NODE_LINK_ATTRIB */
+               /* GPU_NODE_LINK_ATTR */
                struct {
-                       const char *attribname;
-                       CustomDataType attribtype;
+                       const char *attr_name;
+                       CustomDataType attr_type;
                };
                /* GPU_NODE_LINK_IMAGE_BLENDER */
                struct {
@@ -151,12 +151,16 @@ typedef struct GPUInput {
                        int texid;                   /* number for multitexture, starting from zero */
                        eGPUType textype;             /* texture type (2D, 1D Array ...) */
                };
-               /* GPU_SOURCE_ATTRIB */
+               /* GPU_SOURCE_ATTR */
                struct {
-                       char attribname[MAX_CUSTOMDATA_LAYER_NAME]; /* attribute name */
-                       int attribid;                /* id for vertex attributes */
-                       bool attribfirst;            /* this is the first one that is bound */
-                       CustomDataType attribtype;   /* attribute type */
+                       /** Attribute name. */
+                       char attr_name[MAX_CUSTOMDATA_LAYER_NAME];
+                       /** ID for vertex attributes. */
+                       int attr_id;
+                       /** This is the first one that is bound. */
+                       bool attr_first;
+                       /** Attribute type. */
+                       CustomDataType attr_type;
                };
        };
 } GPUInput;
@@ -178,7 +182,7 @@ typedef struct GPUPass GPUPass;
 
 GPUPass *GPU_generate_pass(
         GPUMaterial *material,
-        GPUNodeLink *frag_outlink, struct GPUVertexAttribs *attribs,
+        GPUNodeLink *frag_outlink, struct GPUVertAttrLayers *attrs,
         ListBase *nodes, int *builtins,
         const char *vert_code, const char *geom_code,
         const char *frag_lib, const char *defines);
@@ -186,7 +190,7 @@ GPUPass *GPU_generate_pass(
 struct GPUShader *GPU_pass_shader_get(GPUPass *pass);
 
 void GPU_nodes_extract_dynamic_inputs(struct GPUShader *shader, ListBase *inputs, ListBase *nodes);
-void GPU_nodes_get_vertex_attributes(ListBase *nodes, struct GPUVertexAttribs *attribs);
+void GPU_nodes_get_vertex_attrs(ListBase *nodes, struct GPUVertAttrLayers *attrs);
 void GPU_nodes_prune(ListBase *nodes, struct GPUNodeLink *outlink);
 
 void GPU_pass_compile(GPUPass *pass, const char *shname);
index 0937b60..4cbcaf5 100644 (file)
@@ -1423,7 +1423,7 @@ void GPU_select_to_index_array(uint *col, const uint size)
 #define STATE_STACK_DEPTH 16
 
 typedef struct {
-       eGPUAttribMask mask;
+       eGPUAttrMask mask;
 
        /* GL_ENABLE_BIT */
        uint is_blend : 1;
@@ -1456,19 +1456,19 @@ typedef struct {
        /* GL_VIEWPORT_BIT */
        int viewport[4];
        double near_far[2];
-}  GPUAttribValues;
+}  GPUAttrValues;
 
 typedef struct {
-       GPUAttribValues attrib_stack[STATE_STACK_DEPTH];
+       GPUAttrValues attr_stack[STATE_STACK_DEPTH];
        uint top;
-} GPUAttribStack;
+} GPUAttrStack;
 
-static GPUAttribStack state = {
+static GPUAttrStack state = {
        .top = 0,
 };
 
-#define AttribStack state
-#define Attrib state.attrib_stack[state.top]
+#define AttrStack state
+#define Attr state.attr_stack[state.top]
 
 /**
  * Replacement for glPush/PopAttributes
@@ -1476,54 +1476,54 @@ static GPUAttribStack state = {
  * We don't need to cover all the options of legacy OpenGL
  * but simply the ones used by Blender.
  */
-void gpuPushAttrib(eGPUAttribMask mask)
+void gpuPushAttr(eGPUAttrMask mask)
 {
-       Attrib.mask = mask;
+       Attr.mask = mask;
 
        if ((mask & GPU_DEPTH_BUFFER_BIT) != 0) {
-               Attrib.is_depth_test = glIsEnabled(GL_DEPTH_TEST);
-               glGetIntegerv(GL_DEPTH_FUNC, &Attrib.depth_func);
-               glGetDoublev(GL_DEPTH_CLEAR_VALUE, &Attrib.depth_clear_value);
-               glGetBooleanv(GL_DEPTH_WRITEMASK, (GLboolean *)&Attrib.depth_write_mask);
+               Attr.is_depth_test = glIsEnabled(GL_DEPTH_TEST);
+               glGetIntegerv(GL_DEPTH_FUNC, &Attr.depth_func);
+               glGetDoublev(GL_DEPTH_CLEAR_VALUE, &Attr.depth_clear_value);
+               glGetBooleanv(GL_DEPTH_WRITEMASK, (GLboolean *)&Attr.depth_write_mask);
        }
 
        if ((mask & GPU_ENABLE_BIT) != 0) {
-               Attrib.is_blend = glIsEnabled(GL_BLEND);
+               Attr.is_blend = glIsEnabled(GL_BLEND);
 
                for (int i = 0; i < 6; i++) {
-                       Attrib.is_clip_plane[i] = glIsEnabled(GL_CLIP_PLANE0 + i);
+                       Attr.is_clip_plane[i] = glIsEnabled(GL_CLIP_PLANE0 + i);
                }
 
-               Attrib.is_cull_face = glIsEnabled(GL_CULL_FACE);
-               Attrib.is_depth_test = glIsEnabled(GL_DEPTH_TEST);
-               Attrib.is_dither = glIsEnabled(GL_DITHER);
-               Attrib.is_line_smooth = glIsEnabled(GL_LINE_SMOOTH);
-               Attrib.is_color_logic_op = glIsEnabled(GL_COLOR_LOGIC_OP);
-               Attrib.is_multisample = glIsEnabled(GL_MULTISAMPLE);
-               Attrib.is_polygon_offset_line = glIsEnabled(GL_POLYGON_OFFSET_LINE);
-               Attrib.is_polygon_offset_fill = glIsEnabled(GL_POLYGON_OFFSET_FILL);
-               Attrib.is_polygon_smooth = glIsEnabled(GL_POLYGON_SMOOTH);
-               Attrib.is_sample_alpha_to_coverage = glIsEnabled(GL_SAMPLE_ALPHA_TO_COVERAGE);
-               Attrib.is_scissor_test = glIsEnabled(GL_SCISSOR_TEST);
-               Attrib.is_stencil_test = glIsEnabled(GL_STENCIL_TEST);
+               Attr.is_cull_face = glIsEnabled(GL_CULL_FACE);
+               Attr.is_depth_test = glIsEnabled(GL_DEPTH_TEST);
+               Attr.is_dither = glIsEnabled(GL_DITHER);
+               Attr.is_line_smooth = glIsEnabled(GL_LINE_SMOOTH);
+               Attr.is_color_logic_op = glIsEnabled(GL_COLOR_LOGIC_OP);
+               Attr.is_multisample = glIsEnabled(GL_MULTISAMPLE);
+               Attr.is_polygon_offset_line = glIsEnabled(GL_POLYGON_OFFSET_LINE);
+               Attr.is_polygon_offset_fill = glIsEnabled(GL_POLYGON_OFFSET_FILL);
+               Attr.is_polygon_smooth = glIsEnabled(GL_POLYGON_SMOOTH);
+               Attr.is_sample_alpha_to_coverage = glIsEnabled(GL_SAMPLE_ALPHA_TO_COVERAGE);
+               Attr.is_scissor_test = glIsEnabled(GL_SCISSOR_TEST);
+               Attr.is_stencil_test = glIsEnabled(GL_STENCIL_TEST);
        }
 
        if ((mask & GPU_SCISSOR_BIT) != 0) {
-               Attrib.is_scissor_test = glIsEnabled(GL_SCISSOR_TEST);
-               glGetIntegerv(GL_SCISSOR_BOX, (GLint *)&Attrib.scissor_box);
+               Attr.is_scissor_test = glIsEnabled(GL_SCISSOR_TEST);
+               glGetIntegerv(GL_SCISSOR_BOX, (GLint *)&Attr.scissor_box);
        }
 
        if ((mask & GPU_VIEWPORT_BIT) != 0) {
-               glGetDoublev(GL_DEPTH_RANGE, (GLdouble *)&Attrib.near_far);
-               glGetIntegerv(GL_VIEWPORT, (GLint *)&Attrib.viewport);
+               glGetDoublev(GL_DEPTH_RANGE, (GLdouble *)&Attr.near_far);
+               glGetIntegerv(GL_VIEWPORT, (GLint *)&Attr.viewport);
        }
 
        if ((mask & GPU_BLEND_BIT) != 0) {
-               Attrib.is_blend = glIsEnabled(GL_BLEND);
+               Attr.is_blend = glIsEnabled(GL_BLEND);
        }
 
-       BLI_assert(AttribStack.top < STATE_STACK_DEPTH);
-       AttribStack.top++;
+       BLI_assert(AttrStack.top < STATE_STACK_DEPTH);
+       AttrStack.top++;
 }
 
 static void restore_mask(GLenum cap, const bool value)
@@ -1536,57 +1536,57 @@ static void restore_mask(GLenum cap, const bool value)
        }
 }
 
-void gpuPopAttrib(void)
+void gpuPopAttr(void)
 {
-       BLI_assert(AttribStack.top > 0);
-       AttribStack.top--;
+       BLI_assert(AttrStack.top > 0);
+       AttrStack.top--;
 
-       GLint mask = Attrib.mask;
+       GLint mask = Attr.mask;
 
        if ((mask & GPU_DEPTH_BUFFER_BIT) != 0) {
-               restore_mask(GL_DEPTH_TEST, Attrib.is_depth_test);
-               glDepthFunc(Attrib.depth_func);
-               glClearDepth(Attrib.depth_clear_value);
-               glDepthMask(Attrib.depth_write_mask);
+               restore_mask(GL_DEPTH_TEST, Attr.is_depth_test);
+               glDepthFunc(Attr.depth_func);
+               glClearDepth(Attr.depth_clear_value);
+               glDepthMask(Attr.depth_write_mask);
        }
 
        if ((mask & GPU_ENABLE_BIT) != 0) {
-               restore_mask(GL_BLEND, Attrib.is_blend);
+               restore_mask(GL_BLEND, Attr.is_blend);
 
                for (int i = 0; i < 6; i++) {
-                       restore_mask(GL_CLIP_PLANE0 + i, Attrib.is_clip_plane[i]);
+                       restore_mask(GL_CLIP_PLANE0 + i, Attr.is_clip_plane[i]);
                }
 
-               restore_mask(GL_CULL_FACE, Attrib.is_cull_face);
-               restore_mask(GL_DEPTH_TEST, Attrib.is_depth_test);
-               restore_mask(GL_DITHER, Attrib.is_dither);
-               restore_mask(GL_LINE_SMOOTH, Attrib.is_line_smooth);
-               restore_mask(GL_COLOR_LOGIC_OP, Attrib.is_color_logic_op);
-               restore_mask(GL_MULTISAMPLE, Attrib.is_multisample);
-               restore_mask(GL_POLYGON_OFFSET_LINE, Attrib.is_polygon_offset_line);
-               restore_mask(GL_POLYGON_OFFSET_FILL, Attrib.is_polygon_offset_fill);
-               restore_mask(GL_POLYGON_SMOOTH, Attrib.is_polygon_smooth);
-               restore_mask(GL_SAMPLE_ALPHA_TO_COVERAGE, Attrib.is_sample_alpha_to_coverage);
-               restore_mask(GL_SCISSOR_TEST, Attrib.is_scissor_test);
-               restore_mask(GL_STENCIL_TEST, Attrib.is_stencil_test);
+               restore_mask(GL_CULL_FACE, Attr.is_cull_face);
+               restore_mask(GL_DEPTH_TEST, Attr.is_depth_test);
+               restore_mask(GL_DITHER, Attr.is_dither);
+               restore_mask(GL_LINE_SMOOTH, Attr.is_line_smooth);
+               restore_mask(GL_COLOR_LOGIC_OP, Attr.is_color_logic_op);
+               restore_mask(GL_MULTISAMPLE, Attr.is_multisample);
+               restore_mask(GL_POLYGON_OFFSET_LINE, Attr.is_polygon_offset_line);
+               restore_mask(GL_POLYGON_OFFSET_FILL, Attr.is_polygon_offset_fill);
+               restore_mask(GL_POLYGON_SMOOTH, Attr.is_polygon_smooth);
+               restore_mask(GL_SAMPLE_ALPHA_TO_COVERAGE, Attr.is_sample_alpha_to_coverage);
+               restore_mask(GL_SCISSOR_TEST, Attr.is_scissor_test);
+               restore_mask(GL_STENCIL_TEST, Attr.is_stencil_test);
        }
 
        if ((mask & GPU_VIEWPORT_BIT) != 0) {
-               glViewport(Attrib.viewport[0], Attrib.viewport[1], Attrib.viewport[2], Attrib.viewport[3]);
-               glDepthRange(Attrib.near_far[0], Attrib.near_far[1]);
+               glViewport(Attr.viewport[0], Attr.viewport[1], Attr.viewport[2], Attr.viewport[3]);
+               glDepthRange(Attr.near_far[0], Attr.near_far[1]);
        }
 
        if ((mask & GPU_SCISSOR_BIT) != 0) {
-               restore_mask(GL_SCISSOR_TEST, Attrib.is_scissor_test);
-               glScissor(Attrib.scissor_box[0], Attrib.scissor_box[1], Attrib.scissor_box[2], Attrib.scissor_box[3]);
+               restore_mask(GL_SCISSOR_TEST, Attr.is_scissor_test);
+               glScissor(Attr.scissor_box[0], Attr.scissor_box[1], Attr.scissor_box[2], Attr.scissor_box[3]);
        }
 
        if ((mask & GPU_BLEND_BIT) != 0) {
-               restore_mask(GL_BLEND, Attrib.is_blend);
+               restore_mask(GL_BLEND, Attr.is_blend);
        }
 }
 
-#undef Attrib
-#undef AttribStack
+#undef Attr
+#undef AttrStack
 
 /** \} */
index a3436b0..50eb0e8 100644 (file)
@@ -808,7 +808,7 @@ GPUOffScreen *GPU_offscreen_create(int width, int height, int samples, bool dept
                return NULL;
        }
 
-       gpuPushAttrib(GPU_VIEWPORT_BIT);
+       gpuPushAttr(GPU_VIEWPORT_BIT);
 
        GPU_framebuffer_ensure_config(&ofs->fb, {
                GPU_ATTACHMENT_TEXTURE(ofs->depth),
@@ -818,13 +818,13 @@ GPUOffScreen *GPU_offscreen_create(int width, int height, int samples, bool dept
        /* check validity at the very end! */
        if (!GPU_framebuffer_check_valid(ofs->fb, err_out)) {
                GPU_offscreen_free(ofs);
-               gpuPopAttrib();
+               gpuPopAttr();
                return NULL;
        }
 
        GPU_framebuffer_restore();
 
-       gpuPopAttrib();
+       gpuPopAttr();
 
        return ofs;
 }
@@ -844,7 +844,7 @@ void GPU_offscreen_free(GPUOffScreen *ofs)
 void GPU_offscreen_bind(GPUOffScreen *ofs, bool save)
 {
        if (save) {
-               gpuPushAttrib(GPU_SCISSOR_BIT | GPU_VIEWPORT_BIT);
+               gpuPushAttr(GPU_SCISSOR_BIT | GPU_VIEWPORT_BIT);
                GPUFrameBuffer *fb = GPU_framebuffer_active_get();
                gpuPushFrameBuffer(fb);
        }
@@ -857,7 +857,7 @@ void GPU_offscreen_unbind(GPUOffScreen *UNUSED(ofs), bool restore)
        GPUFrameBuffer *fb = NULL;
 
        if (restore) {
-               gpuPopAttrib();
+               gpuPopAttr();
                fb = gpuPopFrameBuffer();
        }
 
index def75fd..9a0b1e5 100644 (file)
@@ -66,15 +66,15 @@ typedef struct {
        /* current vertex */
        uint vertex_idx;
        GLubyte *vertex_data;
-       uint16_t unassigned_attrib_bits; /* which attributes of current vertex have not been given values? */
+       uint16_t unassigned_attr_bits; /* which attributes of current vertex have not been given values? */
 
        GLuint vbo_id;
        GLuint vao_id;
 
        GLuint bound_program;
        const GPUShaderInterface *shader_interface;
-       GPUAttrBinding attrib_binding;
-       uint16_t prev_enabled_attrib_bits; /* <-- only affects this VAO, so we're ok */
+       GPUAttrBinding attr_binding;
+       uint16_t prev_enabled_attr_bits; /* <-- only affects this VAO, so we're ok */
 } Immediate;
 
 /* size of internal buffer -- make this adjustable? */
@@ -121,7 +121,7 @@ void immDeactivate(void)
 #endif
        GPU_vao_free(imm.vao_id, imm.context);
        imm.vao_id = 0;
-       imm.prev_enabled_attrib_bits = 0;
+       imm.prev_enabled_attr_bits = 0;
 }
 
 void immDestroy(void)
@@ -150,7 +150,7 @@ void immBindProgram(GLuint program, const GPUShaderInterface *shaderface)
                VertexFormat_pack(&imm.vertex_format);
 
        glUseProgram(program);
-       get_attrib_locations(&imm.vertex_format, &imm.attrib_binding, shaderface);
+       get_attr_locations(&imm.vertex_format, &imm.attr_binding, shaderface);
        GPU_matrix_bind(shaderface);
 }
 
@@ -210,7 +210,7 @@ void immBegin(GPUPrimType prim_type, uint vertex_len)
        imm.prim_type = prim_type;
        imm.vertex_len = vertex_len;
        imm.vertex_idx = 0;
-       imm.unassigned_attrib_bits = imm.attrib_binding.enabled_bits;
+       imm.unassigned_attr_bits = imm.attr_binding.enabled_bits;
 
        /* how many bytes do we need for this draw call? */
        const uint bytes_needed = vertex_buffer_size(&imm.vertex_format, vertex_len);
@@ -270,7 +270,7 @@ GPUBatch *immBeginBatch(GPUPrimType prim_type, uint vertex_len)
        imm.prim_type = prim_type;
        imm.vertex_len = vertex_len;
        imm.vertex_idx = 0;
-       imm.unassigned_attrib_bits = imm.attrib_binding.enabled_bits;
+       imm.unassigned_attr_bits = imm.attr_binding.enabled_bits;
 
        GPUVertBuf *verts = GPU_vertbuf_create_with_format(&imm.vertex_format);
        GPU_vertbuf_data_alloc(verts, vertex_len);
@@ -295,11 +295,11 @@ static void immDrawSetup(void)
        /* set up VAO -- can be done during Begin or End really */
        glBindVertexArray(imm.vao_id);
 
-       /* enable/disable vertex attribs as needed */
-       if (imm.attrib_binding.enabled_bits != imm.prev_enabled_attrib_bits) {
+       /* Enable/Disable vertex attributes as needed. */
+       if (imm.attr_binding.enabled_bits != imm.prev_enabled_attr_bits) {
                for (uint loc = 0; loc < GPU_VERT_ATTR_MAX_LEN; ++loc) {
-                       bool is_enabled = imm.attrib_binding.enabled_bits & (1 << loc);
-                       bool was_enabled = imm.prev_enabled_attrib_bits & (1 << loc);
+                       bool is_enabled = imm.attr_binding.enabled_bits & (1 << loc);
+                       bool was_enabled = imm.prev_enabled_attr_bits & (1 << loc);
 
                        if (is_enabled && !was_enabled) {
                                glEnableVertexAttribArray(loc);
@@ -309,18 +309,18 @@ static void immDrawSetup(void)
                        }
                }
 
-               imm.prev_enabled_attrib_bits = imm.attrib_binding.enabled_bits;
+               imm.prev_enabled_attr_bits = imm.attr_binding.enabled_bits;
        }
 
        const uint stride = imm.vertex_format.stride;
 
        for (uint a_idx = 0; a_idx < imm.vertex_format.attr_len; ++a_idx) {
-               const GPUVertAttr *a = imm.vertex_format.attribs + a_idx;
+               const GPUVertAttr *a = &imm.vertex_format.attrs[a_idx];
 
                const uint offset = imm.buffer_offset + a->offset;
                const GLvoid *pointer = (const GLubyte *)0 + offset;
 
-               const uint loc = read_attrib_location(&imm.attrib_binding, a_idx);
+               const uint loc = read_attr_location(&imm.attr_binding, a_idx);
 
                switch (a->fetch_mode) {
                        case GPU_FETCH_FLOAT:
@@ -400,29 +400,29 @@ void immEnd(void)
        imm.strict_vertex_len = true;
 }
 
-static void setAttribValueBit(uint attrib_id)
+static void setAttrValueBit(uint attr_id)
 {
-       uint16_t mask = 1 << attrib_id;
+       uint16_t mask = 1 << attr_id;
 #if TRUST_NO_ONE
-       assert(imm.unassigned_attrib_bits & mask); /* not already set */
+       assert(imm.unassigned_attr_bits & mask); /* not already set */
 #endif
-       imm.unassigned_attrib_bits &= ~mask;
+       imm.unassigned_attr_bits &= ~mask;
 }
 
 
 /* --- generic attribute functions --- */
 
-void immAttr1f(uint attrib_id, float x)
+void immAttr1f(uint attr_id, float x)
 {
-       GPUVertAttr *attr = imm.vertex_format.attribs + attrib_id;
+       GPUVertAttr *attr = &imm.vertex_format.attrs[attr_id];
 #if TRUST_NO_ONE
-       assert(attrib_id < imm.vertex_format.attr_len);
+       assert(attr_id < imm.vertex_format.attr_len);
        assert(attr->comp_type == GPU_COMP_F32);
        assert(attr->comp_len == 1);
        assert(imm.vertex_idx < imm.vertex_len);
        assert(imm.prim_type != GPU_PRIM_NONE); /* make sure we're between a Begin/End pair */
 #endif
-       setAttribValueBit(attrib_id);
+       setAttrValueBit(attr_id);
 
        float *data = (float *)(imm.vertex_data + attr->offset);
 /*     printf("%s %td %p\n", __FUNCTION__, (GLubyte*)data - imm.buffer_data, data); */
@@ -430,17 +430,17 @@ void immAttr1f(uint attrib_id, float x)
        data[0] = x;
 }
 
-void immAttr2f(uint attrib_id, float x, float y)
+void immAttr2f(uint attr_id, float x, float y)
 {
-       GPUVertAttr *attr = imm.vertex_format.attribs + attrib_id;
+       GPUVertAttr *attr = &imm.vertex_format.attrs[attr_id];
 #if TRUST_NO_ONE
-       assert(attrib_id < imm.vertex_format.attr_len);
+       assert(attr_id < imm.vertex_format.attr_len);
        assert(attr->comp_type == GPU_COMP_F32);
        assert(attr->comp_len == 2);
        assert(imm.vertex_idx < imm.vertex_len);
        assert(imm.prim_type != GPU_PRIM_NONE); /* make sure we're between a Begin/End pair */
 #endif
-       setAttribValueBit(attrib_id);
+       setAttrValueBit(attr_id);
 
        float *data = (float *)(imm.vertex_data + attr->offset);
 /*     printf("%s %td %p\n", __FUNCTION__, (GLubyte*)data - imm.buffer_data, data); */
@@ -449,17 +449,17 @@ void immAttr2f(uint attrib_id, float x, float y)
        data[1] = y;
 }
 
-void immAttr3f(uint attrib_id, float x, float y, float z)
+void immAttr3f(uint attr_id, float x, float y, float z)
 {
-       GPUVertAttr *attr = imm.vertex_format.attribs + attrib_id;
+       GPUVertAttr *attr = &imm.vertex_format.attrs[attr_id];
 #if TRUST_NO_ONE
-       assert(attrib_id < imm.vertex_format.attr_len);
+       assert(attr_id < imm.vertex_format.attr_len);
        assert(attr->comp_type == GPU_COMP_F32);
        assert(attr->comp_len == 3);
        assert(imm.vertex_idx < imm.vertex_len);
        assert(imm.prim_type != GPU_PRIM_NONE); /* make sure we're between a Begin/End pair */
 #endif
-       setAttribValueBit(attrib_id);
+       setAttrValueBit(attr_id);
 
        float *data = (float *)(imm.vertex_data + attr->offset);
 /*     printf("%s %td %p\n", __FUNCTION__, (GLubyte*)data - imm.buffer_data, data); */
@@ -469,17 +469,17 @@ void immAttr3f(uint attrib_id, float x, float y, float z)
        data[2] = z;
 }
 
-void immAttr4f(uint attrib_id, float x, float y, float z, float w)
+void immAttr4f(uint attr_id, float x, float y, float z, float w)
 {
-       GPUVertAttr *attr = imm.vertex_format.attribs + attrib_id;
+       GPUVertAttr *attr = &imm.vertex_format.attrs[attr_id];
 #if TRUST_NO_ONE
-       assert(attrib_id < imm.vertex_format.attr_len);
+       assert(attr_id < imm.vertex_format.attr_len);
        assert(attr->comp_type == GPU_COMP_F32);
        assert(attr->comp_len == 4);
        assert(imm.vertex_idx < imm.vertex_len);
        assert(imm.prim_type != GPU_PRIM_NONE); /* make sure we're between a Begin/End pair */
 #endif
-       setAttribValueBit(attrib_id);
+       setAttrValueBit(attr_id);
 
        float *data = (float *)(imm.vertex_data + attr->offset);
 /*     printf("%s %td %p\n", __FUNCTION__, (GLubyte*)data - imm.buffer_data, data); */
@@ -490,34 +490,34 @@ void immAttr4f(uint attrib_id, float x, float y, float z, float w)
        data[3] = w;
 }
 
-void immAttr1u(uint attrib_id, uint x)
+void immAttr1u(uint attr_id, uint x)
 {
-       GPUVertAttr *attr = imm.vertex_format.attribs + attrib_id;
+       GPUVertAttr *attr = &imm.vertex_format.attrs[attr_id];
 #if TRUST_NO_ONE
-       assert(attrib_id < imm.vertex_format.attr_len);
+       assert(attr_id < imm.vertex_format.attr_len);
        assert(attr->comp_type == GPU_COMP_U32);
        assert(attr->comp_len == 1);
        assert(imm.vertex_idx < imm.vertex_len);
        assert(imm.prim_type != GPU_PRIM_NONE); /* make sure we're between a Begin/End pair */
 #endif
-       setAttribValueBit(attrib_id);
+       setAttrValueBit(attr_id);
 
        uint *data = (uint *)(imm.vertex_data + attr->offset);
 
        data[0] = x;
 }
 
-void immAttr2i(uint attrib_id, int x, int y)
+void immAttr2i(uint attr_id, int x, int y)
 {
-       GPUVertAttr *attr = imm.vertex_format.attribs + attrib_id;
+       GPUVertAttr *attr = &imm.vertex_format.attrs[attr_id];
 #if TRUST_NO_ONE
-       assert(attrib_id < imm.vertex_format.attr_len);
+       assert(attr_id < imm.vertex_format.attr_len);
        assert(attr->comp_type == GPU_COMP_I32);
        assert(attr->comp_len == 2);
        assert(imm.vertex_idx < imm.vertex_len);
        assert(imm.prim_type != GPU_PRIM_NONE); /* make sure we're between a Begin/End pair */
 #endif
-       setAttribValueBit(attrib_id);
+       setAttrValueBit(attr_id);
 
        int *data = (int *)(imm.vertex_data + attr->offset);
 
@@ -525,17 +525,17 @@ void immAttr2i(uint attrib_id, int x, int y)
        data[1] = y;
 }
 
-void immAttr2s(uint attrib_id, short x, short y)
+void immAttr2s(uint attr_id, short x, short y)
 {
-       GPUVertAttr *attr = imm.vertex_format.attribs + attrib_id;
+       GPUVertAttr *attr = &imm.vertex_format.attrs[attr_id];
 #if TRUST_NO_ONE
-       assert(attrib_id < imm.vertex_format.attr_len);
+       assert(attr_id < imm.vertex_format.attr_len);
        assert(attr->comp_type == GPU_COMP_I16);
        assert(attr->comp_len == 2);
        assert(imm.vertex_idx < imm.vertex_len);
        assert(imm.prim_type != GPU_PRIM_NONE); /* make sure we're between a Begin/End pair */
 #endif
-       setAttribValueBit(attrib_id);
+       setAttrValueBit(attr_id);
 
        short *data = (short *)(imm.vertex_data + attr->offset);
 
@@ -543,32 +543,32 @@ void immAttr2s(uint attrib_id, short x, short y)
        data[1] = y;
 }
 
-void immAttr2fv(uint attrib_id, const float data[2])
+void immAttr2fv(uint attr_id, const float data[2])
 {
-       immAttr2f(attrib_id, data[0], data[1]);
+       immAttr2f(attr_id, data[0], data[1]);
 }
 
-void immAttr3fv(uint attrib_id, const float data[3])
+void immAttr3fv(uint attr_id, const float data[3])
 {
-       immAttr3f(attrib_id, data[0], data[1], data[2]);
+       immAttr3f(attr_id, data[0], data[1], data[2]);
 }
 
-void immAttr4fv(uint attrib_id, const float data[4])
+void immAttr4fv(uint attr_id, const float data[4])
 {
-       immAttr4f(attrib_id, data[0], data[1], data[2], data[3]);
+       immAttr4f(attr_id, data[0], data[1], data[2], data[3]);
 }
 
-void immAttr3ub(uint attrib_id, uchar r, uchar g, uchar b)
+void immAttr3ub(uint attr_id, uchar r, uchar g, uchar b)
 {
-       GPUVertAttr *attr = imm.vertex_format.attribs + attrib_id;
+       GPUVertAttr *attr = &imm.vertex_format.attrs[attr_id];
 #if TRUST_NO_ONE
-       assert(attrib_id < imm.vertex_format.attr_len);
+       assert(attr_id < imm.vertex_format.attr_len);
        assert(attr->comp_type == GPU_COMP_U8);
        assert(attr->comp_len == 3);
        assert(imm.vertex_idx < imm.vertex_len);
        assert(imm.prim_type != GPU_PRIM_NONE); /* make sure we're between a Begin/End pair */
 #endif
-       setAttribValueBit(attrib_id);
+       setAttrValueBit(attr_id);
 
        GLubyte *data = imm.vertex_data + attr->offset;
 /*     printf("%s %td %p\n", __FUNCTION__, data - imm.buffer_data, data); */
@@ -578,17 +578,17 @@ void immAttr3ub(uint attrib_id, uchar r, uchar g, uchar b)
        data[2] = b;
 }
 
-void immAttr4ub(uint attrib_id, uchar r, uchar g, uchar b, uchar a)
+void immAttr4ub(uint attr_id, uchar r, uchar g, uchar b, uchar a)
 {
-       GPUVertAttr *attr = imm.vertex_format.attribs + attrib_id;
+       GPUVertAttr *attr = &imm.vertex_format.attrs[attr_id];
 #if TRUST_NO_ONE
-       assert(attrib_id < imm.vertex_format.attr_len);
+       assert(attr_id < imm.vertex_format.attr_len);
        assert(attr->comp_type == GPU_COMP_U8);
        assert(attr->comp_len == 4);
        assert(imm.vertex_idx < imm.vertex_len);
        assert(imm.prim_type != GPU_PRIM_NONE); /* make sure we're between a Begin/End pair */
 #endif
-       setAttribValueBit(attrib_id);
+       setAttrValueBit(attr_id);
 
        GLubyte *data = imm.vertex_data + attr->offset;
 /*     printf("%s %td %p\n", __FUNCTION__, data - imm.buffer_data, data); */
@@ -599,24 +599,24 @@ void immAttr4ub(uint attrib_id, uchar r, uchar g, uchar b, uchar a)
        data[3] = a;
 }
 
-void immAttr3ubv(uint attrib_id, const uchar data[3])
+void immAttr3ubv(uint attr_id, const uchar data[3])
 {
-       immAttr3ub(attrib_id, data[0], data[1], data[2]);
+       immAttr3ub(attr_id, data[0], data[1], data[2]);
 }
 
-void immAttr4ubv(uint attrib_id, const uchar data[4])
+void immAttr4ubv(uint attr_id, const uchar data[4])
 {
-       immAttr4ub(attrib_id, data[0], data[1], data[2], data[3]);
+       immAttr4ub(attr_id, data[0], data[1], data[2], data[3]);
 }
 
-void immAttrSkip(uint attrib_id)
+void immAttrSkip(uint attr_id)
 {
 #if TRUST_NO_ONE
-       assert(attrib_id < imm.vertex_format.attr_len);
+       assert(attr_id < imm.vertex_format.attr_len);
        assert(imm.vertex_idx < imm.vertex_len);
        assert(imm.prim_type != GPU_PRIM_NONE); /* make sure we're between a Begin/End pair */
 #endif
-       setAttribValueBit(attrib_id);
+       setAttrValueBit(attr_id);
 }
 
 static void immEndVertex(void) /* and move on to the next vertex */
@@ -626,15 +626,15 @@ static void immEndVertex(void) /* and move on to the next vertex */
        assert(imm.vertex_idx < imm.vertex_len);
 #endif
 
-       /* have all attribs been assigned values?
-        * if not, copy value from previous vertex */
-       if (imm.unassigned_attrib_bits) {
+       /* Have all attributes been assigned values?
+        * If not, copy value from previous vertex. */
+       if (imm.unassigned_attr_bits) {
 #if TRUST_NO_ONE
-               assert(imm.vertex_idx > 0); /* first vertex must have all attribs specified */
+               assert(imm.vertex_idx > 0); /* first vertex must have all attributes specified */
 #endif
                for (uint a_idx = 0; a_idx < imm.vertex_format.attr_len; ++a_idx) {
-                       if ((imm.unassigned_attrib_bits >> a_idx) & 1) {
-                               const GPUVertAttr *a = imm.vertex_format.attribs + a_idx;
+                       if ((imm.unassigned_attr_bits >> a_idx) & 1) {
+                               const GPUVertAttr *a = &imm.vertex_format.attrs[a_idx];
 
 /*                             printf("copying %s from vertex %u to %u\n", a->name, imm.vertex_idx - 1, imm.vertex_idx); */
 
@@ -647,54 +647,54 @@ static void immEndVertex(void) /* and move on to the next vertex */
 
        imm.vertex_idx++;
        imm.vertex_data += imm.vertex_format.stride;
-       imm.unassigned_attrib_bits = imm.attrib_binding.enabled_bits;
+       imm.unassigned_attr_bits = imm.attr_binding.enabled_bits;
 }
 
-void immVertex2f(uint attrib_id, float x, float y)
+void immVertex2f(uint attr_id, float x, float y)
 {
-       immAttr2f(attrib_id, x, y);
+       immAttr2f(attr_id, x, y);
        immEndVertex();
 }
 
-void immVertex3f(uint attrib_id, float x, float y, float z)
+void immVertex3f(uint attr_id, float x, float y, float z)
 {
-       immAttr3f(attrib_id, x, y, z);
+       immAttr3f(attr_id, x, y, z);
        immEndVertex();
 }
 
-void immVertex4f(uint attrib_id, float x, float y, float z, float w)
+void immVertex4f(uint attr_id, float x, float y, float z, float w)
 {
-       immAttr4f(attrib_id, x, y, z, w);
+       immAttr4f(attr_id, x, y, z, w);
        immEndVertex();
 }
 
-void immVertex2i(uint attrib_id, int x, int y)
+void immVertex2i(uint attr_id, int x, int y)
 {
-       immAttr2i(attrib_id, x, y);
+       immAttr2i(attr_id, x, y);
        immEndVertex();
 }
 
-void immVertex2s(uint attrib_id, short x, short y)
+void immVertex2s(uint attr_id, short x, short y)
 {
-       immAttr2s(attrib_id, x, y);
+       immAttr2s(attr_id, x, y);
        immEndVertex();
 }
 
-void immVertex2fv(uint attrib_id, const float data[2])
+void immVertex2fv(uint attr_id, const float data[2])
 {
-       immAttr2f(attrib_id, data[0], data[1]);
+       immAttr2f(attr_id, data[0], data[1]);
        immEndVertex();
 }
 
-void immVertex3fv(uint attrib_id, const float data[3])
+void immVertex3fv(uint attr_id, const float data[3])
 {
-       immAttr3f(attrib_id, data[0], data[1], data[2]);
+       immAttr3f(attr_id, data[0], data[1], data[2]);
        immEndVertex();
 }
 
-void immVertex2iv(uint attrib_id, const int data[2])
+void immVertex2iv(uint attr_id, const int data[2])
 {
-       immAttr2i(attrib_id, data[0], data[1]);
+       immAttr2i(attr_id, data[0], data[1]);
        immEndVertex();
 }
 
index a9e9831..6867835 100644 (file)
@@ -136,7 +136,7 @@ void immRecti_fast_with_color(uint pos, uint col, int x1, int y1, int x2, int y2
 void immRecti_complete(int x1, int y1, int x2, int y2, const float color[4])
 {
        GPUVertFormat *format = immVertexFormat();
-       uint pos = add_attrib(format, "pos", GPU_COMP_I32, 2, GPU_FETCH_INT_TO_FLOAT);
+       uint pos = add_attr(format, "pos", GPU_COMP_I32, 2, GPU_FETCH_INT_TO_FLOAT);
        immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
        immUniformColor4fv(color);
        immRecti(pos, x1, y1, x2, y2);
index d1062f7..91f50d9 100644 (file)
@@ -82,7 +82,7 @@ struct GPUMaterial {
        /* for binding the material */
        GPUPass *pass;
        ListBase inputs;  /* GPUInput */
-       GPUVertexAttribs attribs;
+       GPUVertAttrLayers attrs;
        int builtins;
        int alpha, obcolalpha;
        int dynproperty;
@@ -569,9 +569,9 @@ struct GPUUniformBuffer *GPU_material_create_sss_profile_ubo(void)
 #undef SSS_EXPONENT
 #undef SSS_SAMPLES
 
-void GPU_material_vertex_attributes(GPUMaterial *material, GPUVertexAttribs *attribs)
+void GPU_material_vertex_attrs(GPUMaterial *material, GPUVertAttrLayers *r_attrs)
 {
-       *attribs = material->attribs;
+       *r_attrs = material->attrs;
 }
 
 void GPU_material_output_link(GPUMaterial *material, GPUNodeLink *link)
@@ -676,15 +676,15 @@ GPUMaterial *GPU_material_from_nodetree(
        }
 
        if (mat->outlink) {
-               /* Prune the unused nodes and extract attribs before compiling so the
+               /* Prune the unused nodes and extract attributes before compiling so the
                 * generated VBOs are ready to accept the future shader. */
                GPU_nodes_prune(&mat->nodes, mat->outlink);
-               GPU_nodes_get_vertex_attributes(&mat->nodes, &mat->attribs);
+               GPU_nodes_get_vertex_attrs(&mat->nodes, &mat->attrs);
                /* Create source code and search pass cache for an already compiled version. */
                mat->pass = GPU_generate_pass(
                        mat,
                        mat->outlink,
-                       &mat->attribs,
+                       &mat->attrs,
                        &mat->nodes,
                        &mat->builtins,
                        vert_code,
index 363baa4..ecd49d3 100644 (file)
@@ -317,7 +317,7 @@ void gpu_select_pick_begin(
 
        /* Restrict OpenGL operations for when we don't have cache */
        if (ps->is_cached == false) {
-               gpuPushAttrib(GPU_DEPTH_BUFFER_BIT | GPU_VIEWPORT_BIT);
+               gpuPushAttr(GPU_DEPTH_BUFFER_BIT | GPU_VIEWPORT_BIT);
 
                /* disable writing to the framebuffer */
                glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
@@ -539,7 +539,7 @@ uint gpu_select_pick_end(void)
                        /* force finishing last pass */
                        gpu_select_pick_load_id(ps->gl.prev_id);
                }
-               gpuPopAttrib();
+               gpuPopAttr();
                glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
        }
 
index 4520025..e81e6f1 100644 (file)
@@ -98,7 +98,7 @@ void gpu_select_query_begin(
        g_query_state.id = MEM_mallocN(g_query_state.num_of_queries * sizeof(*g_query_state.id), "gpu selection ids");
        glGenQueries(g_query_state.num_of_queries, g_query_state.queries);
 
-       gpuPushAttrib(GPU_DEPTH_BUFFER_BIT | GPU_VIEWPORT_BIT | GPU_SCISSOR_BIT);
+       gpuPushAttr(GPU_DEPTH_BUFFER_BIT | GPU_VIEWPORT_BIT | GPU_SCISSOR_BIT);
        /* disable writing to the framebuffer */
        glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
 
@@ -219,7 +219,7 @@ uint gpu_select_query_end(void)
        glDeleteQueries(g_query_state.num_of_queries, g_query_state.queries);
        MEM_freeN(g_query_state.queries);
        MEM_freeN(g_query_state.id);
-       gpuPopAttrib();
+       gpuPopAttr();
        glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
 
        return hits;
index 6f6dbb0..24ee833 100644 (file)
@@ -674,8 +674,8 @@ void GPU_shader_uniform_texture(GPUShader *UNUSED(shader), int location, GPUText
 int GPU_shader_get_attribute(GPUShader *shader, const char *name)
 {
        BLI_assert(shader && shader->program);
-       const GPUShaderInput *attrib = GPU_shaderinterface_attr(shader->interface, name);
-       return attrib ? attrib->location : -1;
+       const GPUShaderInput *attr = GPU_shaderinterface_attr(shader->interface, name);
+       return attr ? attr->location : -1;
 }
 
 static const GPUShaderStages builtin_shader_stages[GPU_NUM_BUILTIN_SHADERS] = {
index 6e05609..65e9cf4 100644 (file)
@@ -221,15 +221,15 @@ GPUShaderInterface *GPU_shaderinterface_create(int32_t program)
        printf("GPUShaderInterface %p, program %d\n", shaderface, program);
 #endif
 
-       GLint max_attrib_name_len, attr_len;
-       glGetProgramiv(program, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &max_attrib_name_len);
+       GLint max_attr_name_len, attr_len;
+       glGetProgramiv(program, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &max_attr_name_len);
        glGetProgramiv(program, GL_ACTIVE_ATTRIBUTES, &attr_len);
 
        GLint max_ubo_name_len, ubo_len;
        glGetProgramiv(program, GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH, &max_ubo_name_len);
        glGetProgramiv(program, GL_ACTIVE_UNIFORM_BLOCKS, &ubo_len);
 
-       const uint32_t name_buffer_len = attr_len * max_attrib_name_len + ubo_len * max_ubo_name_len;
+       const uint32_t name_buffer_len = attr_len * max_attr_name_len + ubo_len * max_ubo_name_len;
        shaderface->name_buffer = MEM_mallocN(name_buffer_len, "name_buffer");
 
        /* Attributes */
@@ -253,10 +253,10 @@ GPUShaderInterface *GPU_shaderinterface_create(int32_t program)
 
                set_input_name(shaderface, input, name, name_len);
 
-               shader_input_to_bucket(input, shaderface->attrib_buckets);
+               shader_input_to_bucket(input, shaderface->attr_buckets);
 
 #if DEBUG_SHADER_INTERFACE
-               printf("attrib[%u] '%s' at location %d\n", i, name, input->location);
+               printf("attr[%u] '%s' at location %d\n", i, name, input->location);
 #endif
        }
        /* Uniform Blocks */
@@ -296,7 +296,7 @@ void GPU_shaderinterface_discard(GPUShaderInterface *shaderface)
 {
        /* Free memory used by buckets and has entries. */
        buckets_free(shaderface->uniform_buckets);
-       buckets_free(shaderface->attrib_buckets);
+       buckets_free(shaderface->attr_buckets);
        buckets_free(shaderface->ubo_buckets);
        /* Free memory used by name_buffer. */
        MEM_freeN(shaderface->name_buffer);
@@ -358,7 +358,7 @@ const GPUShaderInput *GPU_shaderinterface_ubo(const GPUShaderInterface *shaderfa
 
 const GPUShaderInput *GPU_shaderinterface_attr(const GPUShaderInterface *shaderface, const char *name)
 {
-       return buckets_lookup(shaderface->attrib_buckets, shaderface->name_buffer, name);
+       return buckets_lookup(shaderface->attr_buckets, shaderface->name_buffer, name);
 }
 
 void GPU_shaderinterface_add_batch_ref(GPUShaderInterface *shaderface, GPUBatch *batch)
index 69c0c41..01a7f38 100644 (file)
 #include "GPU_shader_interface.h"
 
 struct GPUShader {
-       GLuint program;  /* handle for full program (links shader stages below) */
-
-       GLuint vertex;   /* handle for vertex shader */
-       GLuint geometry; /* handle for geometry shader */
-       GLuint fragment; /* handle for fragment shader */
-
-       GPUShaderInterface *interface; /* cached uniform & attrib interface for shader */
+       /** Handle for full program (links shader stages below). */
+       GLuint program;
+
+       /** Handle for vertex shader. */
+       GLuint vertex;
+       /** Handle for geometry shader. */
+       GLuint geometry;
+       /** Handle for fragment shader. */
+       GLuint fragment;
+
+       /** Cached uniform & attribute interface for shader. */
+       GPUShaderInterface *interface;
 
        int feedback_transform_type;
 #ifndef NDEBUG
index 23e3519..453a851 100644 (file)
@@ -1064,7 +1064,7 @@ GPUTexture *GPU_texture_create_cube(
 GPUTexture *GPU_texture_create_from_vertbuf(GPUVertBuf *vert)
 {
        GPUVertFormat *format = &vert->format;
-       GPUVertAttr *attr = &format->attribs[0];
+       GPUVertAttr *attr = &format->attrs[0];
 
        /* Detect incompatible cases (not supported by texture buffers) */
        BLI_assert(format->attr_len == 1 && vert->vbo_id != 0);
index cf6ff17..371b250 100644 (file)
@@ -169,7 +169,7 @@ void GPU_vertbuf_data_len_set(GPUVertBuf *verts, uint v_len)
 void GPU_vertbuf_attr_set(GPUVertBuf *verts, uint a_idx, uint v_idx, const void *data)
 {
        const GPUVertFormat *format = &verts->format;
-       const GPUVertAttr *a = format->attribs + a_idx;
+       const GPUVertAttr *a = &format->attrs[a_idx];
 
 #if TRUST_NO_ONE
        assert(a_idx < format->attr_len);
@@ -183,7 +183,7 @@ void GPU_vertbuf_attr_set(GPUVertBuf *verts, uint a_idx, uint v_idx, const void
 void GPU_vertbuf_attr_fill(GPUVertBuf *verts, uint a_idx, const void *data)
 {
        const GPUVertFormat *format = &verts->format;
-       const GPUVertAttr *a = format->attribs + a_idx;
+       const GPUVertAttr *a = &format->attrs[a_idx];
 
 #if TRUST_NO_ONE
        assert(a_idx < format->attr_len);
@@ -196,7 +196,7 @@ void GPU_vertbuf_attr_fill(GPUVertBuf *verts, uint a_idx, const void *data)
 void GPU_vertbuf_attr_fill_stride(GPUVertBuf *verts, uint a_idx, uint stride, const void *data)
 {
        const GPUVertFormat *format = &verts->format;
-       const GPUVertAttr *a = format->attribs + a_idx;
+       const GPUVertAttr *a = &format->attrs[a_idx];
 
 #if TRUST_NO_ONE
        assert(a_idx < format->attr_len);
@@ -220,7 +220,7 @@ void GPU_vertbuf_attr_fill_stride(GPUVertBuf *verts, uint a_idx, uint stride, co
 void GPU_vertbuf_attr_get_raw_data(GPUVertBuf *verts, uint a_idx, GPUVertBufRaw *access)
 {
        const GPUVertFormat *format = &verts->format;
-       const GPUVertAttr *a = format->attribs + a_idx;
+       const GPUVertAttr *a = &format->attrs[a_idx];
 
 #if TRUST_NO_ONE
        assert(a_idx < format->attr_len);
index 91060fd..9c0da4f 100644 (file)
@@ -55,7 +55,7 @@ void GPU_vertformat_clear(GPUVertFormat *format)
        format->name_len = 0;
 
        for (uint i = 0; i < GPU_VERT_ATTR_MAX_LEN; i++) {
-               format->attribs[i].name_len = 0;
+               format->attrs[i].name_len = 0;
        }
 #endif
 }
@@ -66,8 +66,8 @@ void GPU_vertformat_copy(GPUVertFormat *dest, const GPUVertFormat *src)
        memcpy(dest, src, sizeof(GPUVertFormat));
 
        for (uint i = 0; i < dest->attr_len; i++) {
-               for (uint j = 0; j < dest->attribs[i].name_len; j++) {
-                       dest->attribs[i].name[j] = (char *)dest + (src->attribs[i].name[j] - ((char *)src));
+               for (uint j = 0; j < dest->attrs[i].name_len; j++) {
+                       dest->attrs[i].name[j] = (char *)dest + (src->attrs[i].name[j] - ((char *)src));
                }
        }
 }
@@ -98,7 +98,7 @@ static uint comp_sz(GPUVertCompType type)
        return sizes[type];
 }
 
-static uint attrib_sz(const GPUVertAttr *a)
+static uint attr_sz(const GPUVertAttr *a)
 {
        if (a->comp_type == GPU_COMP_I10) {
                return 4; /* always packed as 10_10_10_2 */
@@ -106,7 +106,7 @@ static uint attrib_sz(const GPUVertAttr *a)
        return a->comp_len * comp_sz(a->comp_type);
 }
 
-static uint attrib_align(const GPUVertAttr *a)
+static uint attr_align(const GPUVertAttr *a)
 {
        if (a->comp_type == GPU_COMP_I10) {
                return 4; /* always packed as 10_10_10_2 */
@@ -128,7 +128,7 @@ uint vertex_buffer_size(const GPUVertFormat *format, uint vertex_len)
        return format->stride * vertex_len;
 }
 
-static const char *copy_attrib_name(GPUVertFormat *format, const char *name, const char *suffix)
+static const char *copy_attr_name(GPUVertFormat *format, const char *name, const char *suffix)
 {
        /* strncpy does 110% of what we need; let's do exactly 100% */
        char *name_copy = format->names + format->name_offset;
@@ -196,37 +196,37 @@ uint GPU_vertformat_attr_add(
 #endif
        format->name_len++; /* multiname support */
 
-       const uint attrib_id = format->attr_len++;
-       GPUVertAttr *attrib = format->attribs + attrib_id;
+       const uint attr_id = format->attr_len++;
+       GPUVertAttr *attr = &format->attrs[attr_id];
 
-       attrib->name[attrib->name_len++] = copy_attrib_name(format, name, NULL);
-       attrib->comp_type = comp_type;
-       attrib->gl_comp_type = convert_comp_type_to_gl(comp_type);
-       attrib->comp_len = (comp_type == GPU_COMP_I10) ? 4 : comp_len; /* system needs 10_10_10_2 to be 4 or BGRA */
-       attrib->sz = attrib_sz(attrib);
-       attrib->offset = 0; /* offsets & stride are calculated later (during pack) */
-       attrib->fetch_mode = fetch_mode;
+       attr->name[attr->name_len++] = copy_attr_name(format, name, NULL);
+       attr->comp_type = comp_type;
+       attr->gl_comp_type = convert_comp_type_to_gl(comp_type);
+       attr->comp_len = (comp_type == GPU_COMP_I10) ? 4 : comp_len; /* system needs 10_10_10_2 to be 4 or BGRA */
+       attr->sz = attr_sz(attr);
+       attr->offset = 0; /* offsets & stride are calculated later (during pack) */
+       attr->fetch_mode = fetch_mode;
 
-       return attrib_id;
+       return attr_id;
 }
 
 void GPU_vertformat_alias_add(GPUVertFormat *format, const char *alias)
 {
-       GPUVertAttr *attrib = format->attribs + (format->attr_len - 1);
+       GPUVertAttr *attr = &format->attrs[format->attr_len - 1];
 #if TRUST_NO_ONE
        assert(format->name_len < GPU_VERT_ATTR_MAX_LEN); /* there's room for more */
-       assert(attrib->name_len < GPU_VERT_ATTR_MAX_NAMES);
+       assert(attr->name_len < GPU_VERT_ATTR_MAX_NAMES);
 #endif
        format->name_len++; /* multiname support */
-       attrib->name[attrib->name_len++] = copy_attrib_name(format, alias, NULL);
+       attr->name[attr->name_len++] = copy_attr_name(format, alias, NULL);
 }
 
 int GPU_vertformat_attr_id_get(const GPUVertFormat *format, const char *name)
 {
        for (int i = 0; i < format->attr_len; i++) {
-               const GPUVertAttr *attrib = format->attribs + i;
-               for (int j = 0; j < attrib->name_len; j++) {
-                       if (STREQ(name, attrib->name[j])) {
+               const GPUVertAttr *attr = &format->attrs[i];
+               for (int j = 0; j < attr->name_len; j++) {
+                       if (STREQ(name, attr->name[j])) {
                                return i;
                        }
                }
@@ -246,25 +246,25 @@ void GPU_vertformat_triple_load(GPUVertFormat *format)
 
        uint old_attr_len = format->attr_len;
        for (uint a_idx = 0; a_idx < old_attr_len; ++a_idx) {
-               GPUVertAttr *attrib = format->attribs + a_idx;
-               /* Duplicate attrib twice */
+               GPUVertAttr *attr = &format->attrs[a_idx];
+               /* Duplicate attr twice */
                for (int i = 1; i < 3; ++i) {
-                       GPUVertAttr *dst_attrib = format->attribs + format->attr_len;
-                       memcpy(dst_attrib, attrib, sizeof(GPUVertAttr));
+                       GPUVertAttr *dst_attr = &format->attrs[format->attr_len];
+                       memcpy(dst_attr, attr, sizeof(GPUVertAttr));
                        /* Increase offset to the next vertex. */
-                       dst_attrib->offset += format->stride * i;
+                       dst_attr->offset += format->stride * i;
                        /* Only copy first name for now. */
-                       dst_attrib->name_len = 0;
-                       dst_attrib->name[dst_attrib->name_len++] = copy_attrib_name(format, attrib->name[0], (i == 1) ? "1" : "2");
+                       dst_attr->name_len = 0;
+                       dst_attr->name[dst_attr->name_len++] = copy_attr_name(format, attr->name[0], (i == 1) ? "1" : "2");
                        format->attr_len++;
                }
 
 #if TRUST_NO_ONE
-               assert(attrib->name_len < GPU_VERT_ATTR_MAX_NAMES);
+               assert(attr->name_len < GPU_VERT_ATTR_MAX_NAMES);
 #endif
-               /* Add alias to first attrib. */
+               /* Add alias to first attr. */
                format->name_len++;
-               attrib->name[attrib->name_len++] = copy_attrib_name(format, attrib->name[0], "0");
+               attr->name[attr->name_len++] = copy_attr_name(format, attr->name[0], "0");
        }
 }
 
@@ -290,14 +290,14 @@ static void show_pack(uint a_idx, uint sz, uint pad)
 void VertexFormat_pack(GPUVertFormat *format)
 {
        /* For now, attributes are packed in the order they were added,
-        * making sure each attrib is naturally aligned (add padding where necessary)
+        * making sure each attribute is naturally aligned (add padding where necessary)
         * Later we can implement more efficient packing w/ reordering
-        * (keep attrib ID order, adjust their offsets to reorder in buffer). */
+        * (keep attribute ID order, adjust their offsets to reorder in buffer). */
 
        /* TODO: realloc just enough to hold the final combo string. And just enough to
-        * hold used attribs, not all 16. */
+        * hold used attributes, not all 16. */
 
-       GPUVertAttr *a0 = format->attribs + 0;
+       GPUVertAttr *a0 = &format->attrs[0];
        a0->offset = 0;
        uint offset = a0->sz;
 
@@ -306,8 +306,8 @@ void VertexFormat_pack(GPUVertFormat *format)
 #endif
 
        for (uint a_idx = 1; a_idx < format->attr_len; ++a_idx) {
-               GPUVertAttr *a = format->attribs + a_idx;
-               uint mid_padding = padding(offset, attrib_align(a));
+               GPUVertAttr *a = &format->attrs[a_idx];
+               uint mid_padding = padding(offset, attr_align(a));
                offset += mid_padding;
                a->offset = offset;
                offset += a->sz;
@@ -317,7 +317,7 @@ void VertexFormat_pack(GPUVertFormat *format)
 #endif
        }
 
-       uint end_padding = padding(offset, attrib_align(a0));
+       uint end_padding = padding(offset, attr_align(a0));
 
 #if PACK_DEBUG
        show_pack(0, 0, end_padding);
@@ -412,7 +412,7 @@ void GPU_vertformat_from_interface(GPUVertFormat *format, const GPUShaderInterfa
        const char *name_buffer = shaderface->name_buffer;
 
        for (int i = 0; i < GPU_NUM_SHADERINTERFACE_BUCKETS; i++) {
-               const GPUShaderInput *input = shaderface->attrib_buckets[i];
+               const GPUShaderInput *input = shaderface->attr_buckets[i];
                if (input == NULL) {
                        continue;
                }
@@ -425,13 +425,13 @@ void GPU_vertformat_from_interface(GPUVertFormat *format, const GPUShaderInterfa
                        format->name_len++; /* multiname support */
                        format->attr_len++;
 
-                       GPUVertAttr *attrib = format->attribs + input->location;
+                       GPUVertAttr *attr = &format->attrs[input->location];
 
-                       attrib->name[attrib->name_len++] = copy_attrib_name(format, name_buffer + input->name_offset, NULL);
-                       attrib->offset = 0; /* offsets & stride are calculated later (during pack) */
-                       attrib->comp_len = calc_input_component_size(input);
-                       attrib->sz = attrib->comp_len * 4;
-                       get_fetch_mode_and_comp_type(input->gl_type, &attrib->comp_type, &attrib->gl_comp_type, &attrib->fetch_mode);
+                       attr->name[attr->name_len++] = copy_attr_name(format, name_buffer + input->name_offset, NULL);
+                       attr->offset = 0; /* offsets & stride are calculated later (during pack) */
+                       attr->comp_len = calc_input_component_size(input);
+                       attr->sz = attr->comp_len * 4;
+                       get_fetch_mode_and_comp_type(input->gl_type, &attr->comp_type, &attr->gl_comp_type, &attr->fetch_mode);
                }
        }
 }
index 4a9f5f9..ea8d57b 100644 (file)
@@ -11,7 +11,7 @@ in vec2 pos; /* verts position in the curve tangent space */
 in vec2 expand;
 
 #ifdef USE_INSTANCE
-/* Instance attrib */
+/* Instance attrs. */
 in vec2 P0;
 in vec2 P1;
 in vec2 P2;
index 9a7815c..6a6da3d 100644 (file)
@@ -4,10 +4,10 @@ uniform mat4 ViewProjectionMatrix;
 uniform mat4 ModelMatrix;
 #endif
 
-/* ---- Instantiated Attribs ---- */
+/* ---- Instantiated Attrs ---- */
 in float pos;
 
-/* ---- Per instance Attribs ---- */
+/* ---- Per instance Attrs ---- */
 in vec3 color;
 in vec4 corners[2]; /* trouble fetching vec2 */
 in float depth;
index 255eeb9..432b6ca 100644 (file)
@@ -1,10 +1,10 @@
 
 uniform mat4 ViewProjectionMatrix;
 
-/* ---- Instantiated Attribs ---- */
+/* ---- Instantiated Attrs ---- */
 in vec3 pos;
 
-/* ---- Per instance Attribs ---- */
+/* ---- Per instance Attrs ---- */
 in vec3 color;
 in float start;
 in float end;
index fa30c9f..9de5024 100644 (file)
@@ -16,7 +16,7 @@ uniform mat4 ProjectionMatrix;
 in vec3 pos;
 in vec3 N1, N2; // normals of faces this edge joins (object coords)
 
-/* instance attrib */
+/* Instance attrs */
 in vec3 color;
 in mat4 InstanceModelMatrix;
 
index d2b6460..087fec8 100644 (file)
@@ -2,11 +2,11 @@
 uniform mat4 ViewMatrix;
 uniform mat4 ViewProjectionMatrix;
 
-/* ---- Instantiated Attribs ---- */
+/* ---- Instantiated Attrs ---- */
 in vec3 pos;
 in vec3 nor;
 
-/* ---- Per instance Attribs ---- */
+/* ---- Per instance Attrs ---- */
 in mat4 InstanceModelMatrix;
 in vec4 color;
 
@@ -17,7 +17,7 @@ void main()
 {
        mat4 ModelViewProjectionMatrix = ViewProjectionMatrix * InstanceModelMatrix;
        /* This is slow and run per vertex, but it's still faster than
-        * doing it per instance on CPU and sending it on via instance attrib */
+        * doing it per instance on CPU and sending it on via instance attr. */
        mat3 NormalMatrix = transpose(inverse(mat3(ViewMatrix * InstanceModelMatrix)));
 
        gl_Position = ModelViewProjectionMatrix * vec4(pos, 1.0);
index f4f5b26..1779928 100644 (file)
@@ -5,10 +5,10 @@ uniform mat4 ModelMatrix;
 #endif
 uniform vec3 screen_vecs[2];
 
-/* ---- Instantiated Attribs ---- */
+/* ---- Instantiated Attrs ---- */
 in vec3 pos; /* using Z as axis id */
 
-/* ---- Per instance Attribs ---- */
+/* ---- Per instance Attrs ---- */
 in mat4 InstanceModelMatrix;
 in vec3 color;
 in float size;
index 3baea76..d2b8597 100644 (file)
@@ -4,10 +4,10 @@ uniform vec3 screen_vecs[2];
 uniform float size;
 uniform float pixel_size;
 
-/* ---- Instantiated Attribs ---- */
+/* ---- Instantiated Attrs ---- */
 in vec2 pos;
 
-/* ---- Per instance Attribs ---- */
+/* ---- Per instance Attrs ---- */
 in vec3 world_pos;
 in vec3 color;
 
index fed0038..6a55684 100644 (file)
@@ -2,10 +2,10 @@
 uniform mat4 ViewProjectionMatrix;
 uniform mat4 ModelMatrix;
 
-/* ---- Instantiated Attribs ---- */
+/* ---- Instantiated Attrs ---- */
 in vec3 pos;
 
-/* ---- Per instance Attribs ---- */
+/* ---- Per instance Attrs ---- */
 in mat4 InstanceModelMatrix;
 in vec4 color;
 #ifdef UNIFORM_SCALE
index f265bf9..777c149 100644 (file)
@@ -2,10 +2,10 @@
 uniform mat4 ViewProjectionMatrix;
 uniform int baseId;
 
-/* ---- Instantiated Attribs ---- */
+/* ---- Instantiated Attrs ---- */
 in vec3 pos;
 
-/* ---- Per instance Attribs ---- */
+/* ---- Per instance Attrs ---- */
 in mat4 InstanceModelMatrix;
 #ifdef UNIFORM_SCALE
 in float size;
index a4facae..803dc4b 100644 (file)
@@ -1,10 +1,10 @@
 
 uniform mat4 ViewProjectionMatrix;
 
-/* ---- Instantiated Attribs ---- */
+/* ---- Instantiated Attrs ---- */
 in vec3 pos;
 
-/* ---- Per instance Attribs ---- */
+/* ---- Per instance Attrs ---- */
 in mat4 InstanceModelMatrix;
 
 void main()
index 26529dc..13b9808 100644 (file)
@@ -3,7 +3,7 @@ uniform mat4 ModelViewMatrix;
 uniform mat4 ModelViewMatrixInverse;
 uniform mat3 NormalMatrix;
 
-#ifndef ATTRIB
+#ifndef USE_ATTR
 uniform mat4 ModelMatrix;
 uniform mat4 ModelMatrixInverse;
 #endif
index 75fcfd1..ba1e61b 100644 (file)
@@ -101,7 +101,7 @@ static bool bpygpu_vertbuf_fill_impl(
        const char *exc_str_size_mismatch = "Expected a %s of size %d, got %u";
 
        bool ok = true;
-       const GPUVertAttr *attr = &vbo->format.attribs[data_id];
+       const GPUVertAttr *attr = &vbo->format.attrs[data_id];
 
        if (PyObject_CheckBuffer(seq)) {
                Py_buffer pybuffer;