Cleanup: use eGPU prefix for GPU enum types
authorCampbell Barton <ideasman42@gmail.com>
Wed, 23 Jan 2019 03:15:43 +0000 (14:15 +1100)
committerCampbell Barton <ideasman42@gmail.com>
Wed, 23 Jan 2019 03:16:03 +0000 (14:16 +1100)
37 files changed:
source/blender/blenfont/intern/blf_font.c
source/blender/draw/engines/eevee/eevee_depth_of_field.c
source/blender/draw/engines/eevee/eevee_effects.c
source/blender/draw/engines/eevee/eevee_engine.c
source/blender/draw/engines/eevee/eevee_lightprobes.c
source/blender/draw/engines/eevee/eevee_lights.c
source/blender/draw/engines/eevee/eevee_materials.c
source/blender/draw/engines/eevee/eevee_screen_raytrace.c
source/blender/draw/engines/gpencil/gpencil_engine.c
source/blender/draw/engines/workbench/workbench_deferred.c
source/blender/draw/engines/workbench/workbench_effect_taa.c
source/blender/draw/intern/DRW_render.h
source/blender/draw/intern/draw_manager_shader.c
source/blender/draw/intern/draw_manager_texture.c
source/blender/editors/interface/interface_icons.c
source/blender/gpu/GPU_batch.h
source/blender/gpu/GPU_extensions.h
source/blender/gpu/GPU_framebuffer.h
source/blender/gpu/GPU_immediate.h
source/blender/gpu/GPU_material.h
source/blender/gpu/GPU_shader.h
source/blender/gpu/GPU_state.h
source/blender/gpu/GPU_texture.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_extensions.c
source/blender/gpu/intern/gpu_framebuffer.c
source/blender/gpu/intern/gpu_immediate.c
source/blender/gpu/intern/gpu_material.c
source/blender/gpu/intern/gpu_shader.c
source/blender/gpu/intern/gpu_state.c
source/blender/gpu/intern/gpu_texture.c
source/blender/gpu/intern/gpu_uniformbuffer.c
source/blender/python/gpu/gpu_py_shader.c
source/blender/windowmanager/intern/wm_stereo.c

index 3296fbd..3b7addd 100644 (file)
@@ -194,7 +194,7 @@ void blf_batch_draw(void)
        GPU_vertbuf_data_len_set(g_batch.verts, g_batch.glyph_len);
        GPU_vertbuf_use(g_batch.verts); /* send data */
 
-       GPUBuiltinShader shader = (g_batch.simple_shader) ? GPU_SHADER_TEXT_SIMPLE : GPU_SHADER_TEXT;
+       eGPUBuiltinShader shader = (g_batch.simple_shader) ? GPU_SHADER_TEXT_SIMPLE : GPU_SHADER_TEXT;
        GPU_batch_program_set_builtin(g_batch.batch, shader);
        GPU_batch_uniform_1i(g_batch.batch, "glyph", 0);
        GPU_batch_draw(g_batch.batch);
index 7cb6492..7c66a32 100644 (file)
@@ -114,7 +114,7 @@ int EEVEE_depth_of_field_init(EEVEE_ViewLayerData *UNUSED(sldata), EEVEE_Data *v
 
                        int buffer_size[2] = {(int)viewport_size[0] / 2, (int)viewport_size[1] / 2};
 
-                       GPUTextureFormat down_format = DRW_state_draw_background() ? GPU_R11F_G11F_B10F : GPU_RGBA16F;
+                       eGPUTextureFormat down_format = DRW_state_draw_background() ? GPU_R11F_G11F_B10F : GPU_RGBA16F;
 
                        effects->dof_down_near = DRW_texture_pool_query_2D(buffer_size[0], buffer_size[1], down_format,
                                                                           &draw_engine_eevee_type);
@@ -131,7 +131,7 @@ int EEVEE_depth_of_field_init(EEVEE_ViewLayerData *UNUSED(sldata), EEVEE_Data *v
                        });
 
                        /* Go full 32bits for rendering and reduce the color artifacts. */
-                       GPUTextureFormat fb_format = DRW_state_is_image_render() ? GPU_RGBA32F : GPU_RGBA16F;
+                       eGPUTextureFormat fb_format = DRW_state_is_image_render() ? GPU_RGBA32F : GPU_RGBA16F;
 
                        effects->dof_blur = DRW_texture_pool_query_2D(buffer_size[0] * 2, buffer_size[1], fb_format,
                                                                      &draw_engine_eevee_type);
index a707961..09f88fb 100644 (file)
@@ -117,7 +117,7 @@ static void eevee_create_shader_downsample(void)
 }
 
 #define SETUP_BUFFER(tex, fb, fb_color) { \
-       GPUTextureFormat format = (DRW_state_is_scene_render()) ? GPU_RGBA32F : GPU_RGBA16F; \
+       eGPUTextureFormat format = (DRW_state_is_scene_render()) ? GPU_RGBA32F : GPU_RGBA16F; \
        DRW_texture_ensure_fullscreen_2D(&tex, format, DRW_TEX_FILTER | DRW_TEX_MIPMAP); \
        GPU_framebuffer_ensure_config(&fb, { \
                GPU_ATTACHMENT_TEXTURE(dtxl->depth), \
index 483220f..7f6f485 100644 (file)
@@ -256,7 +256,7 @@ static void eevee_draw_background(void *vedata)
                DRW_uniformbuffer_update(sldata->common_ubo, &sldata->common_data);
 
                GPU_framebuffer_bind(fbl->main_fb);
-               GPUFrameBufferBits clear_bits = GPU_DEPTH_BIT;
+               eGPUFrameBufferBits clear_bits = GPU_DEPTH_BIT;
                clear_bits |= (DRW_state_draw_background()) ? 0 : GPU_COLOR_BIT;
                clear_bits |= ((stl->effects->enabled_effects & EFFECT_SSS) != 0) ? GPU_STENCIL_BIT : 0;
                GPU_framebuffer_clear(fbl->main_fb, clear_bits, clear_col, clear_depth, clear_stencil);
index 008d458..3199fc4 100644 (file)
@@ -330,7 +330,7 @@ void EEVEE_lightprobes_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedat
                                static float error_col[3] = {1.0f, 0.0f, 1.0f};
                                struct GPUMaterial *gpumat = EEVEE_material_world_lightprobe_get(scene, wo);
 
-                               GPUMaterialStatus status = GPU_material_status(gpumat);
+                               eGPUMaterialStatus status = GPU_material_status(gpumat);
 
                                switch (status) {
                                        case GPU_MAT_SUCCESS:
index 820ead7..af3531e 100644 (file)
@@ -528,7 +528,7 @@ void EEVEE_lights_cache_shcaster_object_add(EEVEE_ViewLayerData *sldata, Object
 void EEVEE_lights_cache_finish(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
 {
        EEVEE_LampsInfo *linfo = sldata->lamps;
-       GPUTextureFormat shadow_pool_format = GPU_R32F;
+       eGPUTextureFormat shadow_pool_format = GPU_R32F;
 
        sldata->common_data.la_num_light = linfo->num_light;
 
index f0274ea..6786bf7 100644 (file)
@@ -1164,14 +1164,14 @@ static void material_opaque(
                        scene, ma, vedata, false, false, use_ssrefract,
                        use_sss, use_translucency, linfo->shadow_method);
 
-               GPUMaterialStatus status_mat_surface = GPU_material_status(*gpumat);
+               eGPUMaterialStatus status_mat_surface = GPU_material_status(*gpumat);
 
                /* Alpha CLipped : Discard pixel from depth pass, then
                 * fail the depth test for shading. */
                if (ELEM(ma->blend_method, MA_BM_CLIP, MA_BM_HASHED)) {
                        *gpumat_depth = EEVEE_material_mesh_depth_get(scene, ma, (ma->blend_method == MA_BM_HASHED), false);
 
-                       GPUMaterialStatus status_mat_depth = GPU_material_status(*gpumat_depth);
+                       eGPUMaterialStatus status_mat_depth = GPU_material_status(*gpumat_depth);
                        if (status_mat_depth != GPU_MAT_SUCCESS) {
                                /* Mixing both flags. If depth shader fails, show it to the user by not using
                                 * the surface shader. */
index a3a1128..440321b 100644 (file)
@@ -159,7 +159,7 @@ int EEVEE_screen_raytrace_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
                int tracing_res[2] = {(int)viewport_size[0] / divisor, (int)viewport_size[1] / divisor};
                int size_fs[2] = {(int)viewport_size[0], (int)viewport_size[1]};
                const bool high_qual_input = true; /* TODO dither low quality input */
-               const GPUTextureFormat format = (high_qual_input) ? GPU_RGBA16F : GPU_RGBA8;
+               const eGPUTextureFormat format = (high_qual_input) ? GPU_RGBA16F : GPU_RGBA8;
 
                /* MRT for the shading pass in order to output needed data for the SSR pass. */
                effects->ssr_specrough_input = DRW_texture_pool_query_2D(size_fs[0], size_fs[1], format,
index 6bb8c45..25cfaf1 100644 (file)
@@ -111,7 +111,7 @@ static void GPENCIL_create_framebuffers(void *vedata)
        GPENCIL_StorageList *stl = ((GPENCIL_Data *)vedata)->stl;
 
        /* Go full 32bits for rendering */
-       GPUTextureFormat fb_format = DRW_state_is_image_render() ? GPU_RGBA32F : GPU_RGBA16F;
+       eGPUTextureFormat fb_format = DRW_state_is_image_render() ? GPU_RGBA32F : GPU_RGBA16F;
 
        if (DRW_state_is_fbo()) {
                const float *viewport_size = DRW_viewport_size_get();
index ef401c6..af6b836 100644 (file)
@@ -409,9 +409,9 @@ void workbench_deferred_engine_init(WORKBENCH_Data *vedata)
        {
                const float *viewport_size = DRW_viewport_size_get();
                const int size[2] = {(int)viewport_size[0], (int)viewport_size[1]};
-               const GPUTextureFormat nor_tex_format = NORMAL_ENCODING_ENABLED() ? GPU_RG16 : GPU_RGBA32F;
-               const GPUTextureFormat comp_tex_format = DRW_state_is_image_render() ? GPU_RGBA16F : GPU_R11F_G11F_B10F;
-               const GPUTextureFormat id_tex_format = OBJECT_ID_PASS_ENABLED(wpd) ? GPU_R32UI : GPU_R8;
+               const eGPUTextureFormat nor_tex_format = NORMAL_ENCODING_ENABLED() ? GPU_RG16 : GPU_RGBA32F;
+               const eGPUTextureFormat comp_tex_format = DRW_state_is_image_render() ? GPU_RGBA16F : GPU_R11F_G11F_B10F;
+               const eGPUTextureFormat id_tex_format = OBJECT_ID_PASS_ENABLED(wpd) ? GPU_R32UI : GPU_R8;
 
                e_data.object_id_tx = NULL;
                e_data.color_buffer_tx = NULL;
index db20c96..c4421b9 100644 (file)
@@ -174,7 +174,7 @@ DRWPass *workbench_taa_create_pass(WORKBENCH_Data *vedata, GPUTexture **color_bu
        int previous_jitter_index = effect_info->jitter_index;
 
        {
-               const GPUTextureFormat hist_buffer_format = DRW_state_is_image_render() ? GPU_RGBA16F : GPU_RGBA8;
+               const eGPUTextureFormat hist_buffer_format = DRW_state_is_image_render() ? GPU_RGBA16F : GPU_RGBA8;
                DRW_texture_ensure_fullscreen_2D(&txl->history_buffer_tx, hist_buffer_format, 0);
                DRW_texture_ensure_fullscreen_2D(&txl->depth_buffer_tx, GPU_DEPTH24_STENCIL8, 0);
        }
index 72c5565..4280359 100644 (file)
@@ -200,23 +200,23 @@ typedef enum {
 /* Textures from DRW_texture_pool_query_* have the options
  * DRW_TEX_FILTER for color float textures, and no options
  * for depth textures and integer textures. */
-struct GPUTexture *DRW_texture_pool_query_2D(int w, int h, GPUTextureFormat format, DrawEngineType *engine_type);
+struct GPUTexture *DRW_texture_pool_query_2D(int w, int h, eGPUTextureFormat format, DrawEngineType *engine_type);
 
 struct GPUTexture *DRW_texture_create_1D(
-        int w, GPUTextureFormat format, DRWTextureFlag flags, const float *fpixels);
+        int w, eGPUTextureFormat format, DRWTextureFlag flags, const float *fpixels);
 struct GPUTexture *DRW_texture_create_2D(
-        int w, int h, GPUTextureFormat format, DRWTextureFlag flags, const float *fpixels);
+        int w, int h, eGPUTextureFormat format, DRWTextureFlag flags, const float *fpixels);
 struct GPUTexture *DRW_texture_create_2D_array(
-        int w, int h, int d, GPUTextureFormat format, DRWTextureFlag flags, const float *fpixels);
+        int w, int h, int d, eGPUTextureFormat format, DRWTextureFlag flags, const float *fpixels);
 struct GPUTexture *DRW_texture_create_3D(
-        int w, int h, int d, GPUTextureFormat format, DRWTextureFlag flags, const float *fpixels);
+        int w, int h, int d, eGPUTextureFormat format, DRWTextureFlag flags, const float *fpixels);
 struct GPUTexture *DRW_texture_create_cube(
-        int w, GPUTextureFormat format, DRWTextureFlag flags, const float *fpixels);
+        int w, eGPUTextureFormat format, DRWTextureFlag flags, const float *fpixels);
 
 void DRW_texture_ensure_fullscreen_2D(
-        struct GPUTexture **tex, GPUTextureFormat format, DRWTextureFlag flags);
+        struct GPUTexture **tex, eGPUTextureFormat format, DRWTextureFlag flags);
 void DRW_texture_ensure_2D(
-        struct GPUTexture **tex, int w, int h, GPUTextureFormat format, DRWTextureFlag flags);
+        struct GPUTexture **tex, int w, int h, eGPUTextureFormat format, DRWTextureFlag flags);
 
 void DRW_texture_generate_mipmaps(struct GPUTexture *tex);
 void DRW_texture_free(struct GPUTexture *tex);
@@ -255,7 +255,7 @@ struct GPUShader *DRW_shader_create_with_lib(
         const char *vert, const char *geom, const char *frag, const char *lib, const char *defines);
 struct GPUShader *DRW_shader_create_with_transform_feedback(
         const char *vert, const char *geom, const char *defines,
-        const GPUShaderTFBType prim_type, const char **varying_names, const int varying_count);
+        const eGPUShaderTFBType prim_type, const char **varying_names, const int varying_count);
 struct GPUShader *DRW_shader_create_2D(const char *frag, const char *defines);
 struct GPUShader *DRW_shader_create_3D(const char *frag, const char *defines);
 struct GPUShader *DRW_shader_create_fullscreen(const char *frag, const char *defines);
index 437e305..79717fc 100644 (file)
@@ -363,7 +363,7 @@ GPUShader *DRW_shader_create_with_lib(
 
 GPUShader *DRW_shader_create_with_transform_feedback(
         const char *vert, const char *geom, const char *defines,
-        const GPUShaderTFBType prim_type, const char **varying_names, const int varying_count)
+        const eGPUShaderTFBType prim_type, const char **varying_names, const int varying_count)
 {
        return GPU_shader_create_ex(vert,
                                    datatoc_gpu_shader_depth_only_frag_glsl,
index 6976b65..9d70a35 100644 (file)
@@ -30,7 +30,7 @@
 
 #ifndef NDEBUG
 /* Maybe gpu_texture.c is a better place for this. */
-static bool drw_texture_format_supports_framebuffer(GPUTextureFormat format)
+static bool drw_texture_format_supports_framebuffer(eGPUTextureFormat format)
 {
        /* Some formats do not work with framebuffers. */
        switch (format) {
@@ -79,7 +79,7 @@ void drw_texture_set_parameters(GPUTexture *tex, DRWTextureFlag flags)
        GPU_texture_unbind(tex);
 }
 
-GPUTexture *DRW_texture_create_1D(int w, GPUTextureFormat format, DRWTextureFlag flags, const float *fpixels)
+GPUTexture *DRW_texture_create_1D(int w, eGPUTextureFormat format, DRWTextureFlag flags, const float *fpixels)
 {
        GPUTexture *tex = GPU_texture_create_1D(w, format, fpixels, NULL);
        drw_texture_set_parameters(tex, flags);
@@ -87,7 +87,7 @@ GPUTexture *DRW_texture_create_1D(int w, GPUTextureFormat format, DRWTextureFlag
        return tex;
 }
 
-GPUTexture *DRW_texture_create_2D(int w, int h, GPUTextureFormat format, DRWTextureFlag flags, const float *fpixels)
+GPUTexture *DRW_texture_create_2D(int w, int h, eGPUTextureFormat format, DRWTextureFlag flags, const float *fpixels)
 {
        GPUTexture *tex = GPU_texture_create_2D(w, h, format, fpixels, NULL);
        drw_texture_set_parameters(tex, flags);
@@ -96,7 +96,7 @@ GPUTexture *DRW_texture_create_2D(int w, int h, GPUTextureFormat format, DRWText
 }
 
 GPUTexture *DRW_texture_create_2D_array(
-        int w, int h, int d, GPUTextureFormat format, DRWTextureFlag flags, const float *fpixels)
+        int w, int h, int d, eGPUTextureFormat format, DRWTextureFlag flags, const float *fpixels)
 {
        GPUTexture *tex = GPU_texture_create_2D_array(w, h, d, format, fpixels, NULL);
        drw_texture_set_parameters(tex, flags);
@@ -105,7 +105,7 @@ GPUTexture *DRW_texture_create_2D_array(
 }
 
 GPUTexture *DRW_texture_create_3D(
-        int w, int h, int d, GPUTextureFormat format, DRWTextureFlag flags, const float *fpixels)
+        int w, int h, int d, eGPUTextureFormat format, DRWTextureFlag flags, const float *fpixels)
 {
        GPUTexture *tex = GPU_texture_create_3D(w, h, d, format, fpixels, NULL);
        drw_texture_set_parameters(tex, flags);
@@ -113,7 +113,7 @@ GPUTexture *DRW_texture_create_3D(
        return tex;
 }
 
-GPUTexture *DRW_texture_create_cube(int w, GPUTextureFormat format, DRWTextureFlag flags, const float *fpixels)
+GPUTexture *DRW_texture_create_cube(int w, eGPUTextureFormat format, DRWTextureFlag flags, const float *fpixels)
 {
        GPUTexture *tex = GPU_texture_create_cube(w, format, fpixels, NULL);
        drw_texture_set_parameters(tex, flags);
@@ -121,7 +121,7 @@ GPUTexture *DRW_texture_create_cube(int w, GPUTextureFormat format, DRWTextureFl
        return tex;
 }
 
-GPUTexture *DRW_texture_pool_query_2D(int w, int h, GPUTextureFormat format, DrawEngineType *engine_type)
+GPUTexture *DRW_texture_pool_query_2D(int w, int h, eGPUTextureFormat format, DrawEngineType *engine_type)
 {
        BLI_assert(drw_texture_format_supports_framebuffer(format));
        GPUTexture *tex = GPU_viewport_texture_pool_query(DST.viewport, engine_type, w, h, format);
@@ -129,7 +129,7 @@ GPUTexture *DRW_texture_pool_query_2D(int w, int h, GPUTextureFormat format, Dra
        return tex;
 }
 
-void DRW_texture_ensure_fullscreen_2D(GPUTexture **tex, GPUTextureFormat format, DRWTextureFlag flags)
+void DRW_texture_ensure_fullscreen_2D(GPUTexture **tex, eGPUTextureFormat format, DRWTextureFlag flags)
 {
        if (*(tex) == NULL) {
                const float *size = DRW_viewport_size_get();
@@ -137,7 +137,7 @@ void DRW_texture_ensure_fullscreen_2D(GPUTexture **tex, GPUTextureFormat format,
        }
 }
 
-void DRW_texture_ensure_2D(GPUTexture **tex, int w, int h, GPUTextureFormat format, DRWTextureFlag flags)
+void DRW_texture_ensure_2D(GPUTexture **tex, int w, int h, eGPUTextureFormat format, DRWTextureFlag flags)
 {
        if (*(tex) == NULL) {
                *(tex) = DRW_texture_create_2D(w, h, format, flags, NULL);
index bc265ae..035bee2 100644 (file)
@@ -1311,7 +1311,7 @@ static void icon_draw_rect(float x, float y, int w, int h, float UNUSED(aspect),
        }
 
        /* draw */
-       GPUBuiltinShader shader;
+       eGPUBuiltinShader shader;
        if (desaturate != 0.0f) {
                shader = GPU_SHADER_2D_IMAGE_DESATURATE_COLOR;
        }
index f4911d1..0ef7e57 100644 (file)
@@ -123,7 +123,7 @@ int GPU_batch_vertbuf_add_ex(GPUBatch *, GPUVertBuf *, bool own_vbo);
 
 void GPU_batch_program_set_no_use(GPUBatch *, uint32_t program, const GPUShaderInterface *);
 void GPU_batch_program_set(GPUBatch *, uint32_t program, const GPUShaderInterface *);
-void GPU_batch_program_set_builtin(GPUBatch *batch, GPUBuiltinShader shader_id);
+void GPU_batch_program_set_builtin(GPUBatch *batch, eGPUBuiltinShader shader_id);
 /* Entire batch draws with one shader program, but can be redrawn later with another program. */
 /* Vertex shader's inputs must be compatible with the batch's vertex format. */
 
index b51363a..b659684 100644 (file)
@@ -63,7 +63,7 @@ void GPU_code_generate_glsl_lib(void);
 
 /* GPU Types */
 
-typedef enum GPUDeviceType {
+typedef enum eGPUDeviceType {
        GPU_DEVICE_NVIDIA =     (1 << 0),
        GPU_DEVICE_ATI =        (1 << 1),
        GPU_DEVICE_INTEL =      (1 << 2),
@@ -71,23 +71,23 @@ typedef enum GPUDeviceType {
        GPU_DEVICE_SOFTWARE =   (1 << 4),
        GPU_DEVICE_UNKNOWN =    (1 << 5),
        GPU_DEVICE_ANY =        (0xff),
-} GPUDeviceType;
+} eGPUDeviceType;
 
-typedef enum GPUOSType {
+typedef enum eGPUOSType {
        GPU_OS_WIN =            (1 << 8),
        GPU_OS_MAC =            (1 << 9),
        GPU_OS_UNIX =           (1 << 10),
        GPU_OS_ANY =            (0xff00),
-} GPUOSType;
+} eGPUOSType;
 
-typedef enum GPUDriverType {
+typedef enum eGPUDriverType {
        GPU_DRIVER_OFFICIAL =   (1 << 16),
        GPU_DRIVER_OPENSOURCE = (1 << 17),
        GPU_DRIVER_SOFTWARE =   (1 << 18),
        GPU_DRIVER_ANY =        (0xff0000),
-} GPUDriverType;
+} eGPUDriverType;
 
-bool GPU_type_matches(GPUDeviceType device, GPUOSType os, GPUDriverType driver);
+bool GPU_type_matches(eGPUDeviceType device, eGPUOSType os, eGPUDriverType driver);
 
 #ifdef __cplusplus
 }
index 3f01d51..3e52ff3 100644 (file)
@@ -43,11 +43,11 @@ typedef struct GPUAttachment {
        int mip, layer;
 } GPUAttachment;
 
-typedef enum GPUFrameBufferBits {
+typedef enum eGPUFrameBufferBits {
        GPU_COLOR_BIT    = (1 << 0),
        GPU_DEPTH_BIT    = (1 << 1),
        GPU_STENCIL_BIT  = (1 << 2),
-} GPUFrameBufferBits;
+} eGPUFrameBufferBits;
 
 typedef struct GPUFrameBuffer GPUFrameBuffer;
 typedef struct GPUOffScreen GPUOffScreen;
@@ -140,7 +140,7 @@ void GPU_framebuffer_config_array(GPUFrameBuffer *fb, const GPUAttachment *confi
 void GPU_framebuffer_viewport_set(GPUFrameBuffer *fb, int x, int y, int w, int h);
 
 void GPU_framebuffer_clear(
-        GPUFrameBuffer *fb, GPUFrameBufferBits buffers,
+        GPUFrameBuffer *fb, eGPUFrameBufferBits buffers,
         const float clear_col[4], float clear_depth, unsigned int clear_stencil);
 
 #define GPU_framebuffer_clear_color(fb, col) \
@@ -168,7 +168,7 @@ void GPU_framebuffer_read_color(
 void GPU_framebuffer_blit(
         GPUFrameBuffer *fb_read, int read_slot,
         GPUFrameBuffer *fb_write, int write_slot,
-        GPUFrameBufferBits blit_buffers);
+        eGPUFrameBufferBits blit_buffers);
 
 void GPU_framebuffer_recursive_downsample(
         GPUFrameBuffer *fb, int max_lvl,
@@ -195,7 +195,7 @@ void GPU_offscreen_viewport_data_get(
         GPUFrameBuffer **r_fb, struct GPUTexture **r_color, struct GPUTexture **r_depth);
 
 void GPU_clear_color(float red, float green, float blue, float alpha);
-void GPU_clear(GPUFrameBufferBits flags);
+void GPU_clear(eGPUFrameBufferBits flags);
 
 #ifdef __cplusplus
 }
index a57ce67..a04be7a 100644 (file)
@@ -128,7 +128,7 @@ void immUniformColor4ubv(const unsigned char rgba[4]);
 
 /* Extend immBindProgram to use Blender’s library of built-in shader programs.
  * Use immUnbindProgram() when done. */
-void immBindBuiltinProgram(GPUBuiltinShader shader_id);
+void immBindBuiltinProgram(eGPUBuiltinShader shader_id);
 
 /* Extend immUniformColor to take Blender's themes */
 void immUniformThemeColor(int color_id);
index 7e201cd..fee5b82 100644 (file)
@@ -68,7 +68,7 @@ typedef struct GPUParticleInfo GPUParticleInfo;
 
 /* Functions to create GPU Materials nodes */
 
-typedef enum GPUType {
+typedef enum eGPUType {
        /* Keep in sync with GPU_DATATYPE_STR */
        /* The value indicates the number of elements in each type */
        GPU_NONE = 0,
@@ -91,9 +91,9 @@ typedef enum GPUType {
 
        /* Opengl Attributes */
        GPU_ATTRIB = 3001,
-} GPUType;
+} eGPUType;
 
-typedef enum GPUBuiltin {
+typedef enum eGPUBuiltin {
        GPU_VIEW_MATRIX =           (1 << 0),
        GPU_OBJECT_MATRIX =         (1 << 1),
        GPU_INVERSE_VIEW_MATRIX =   (1 << 2),
@@ -115,26 +115,26 @@ typedef enum GPUBuiltin {
        GPU_VOLUME_TEMPERATURE =    (1 << 18),
        GPU_BARYCENTRIC_TEXCO =     (1 << 19),
        GPU_BARYCENTRIC_DIST =      (1 << 20),
-} GPUBuiltin;
+} eGPUBuiltin;
 
-typedef enum GPUMatFlag {
+typedef enum eGPUMatFlag {
        GPU_MATFLAG_DIFFUSE       = (1 << 0),
        GPU_MATFLAG_GLOSSY        = (1 << 1),
        GPU_MATFLAG_REFRACT       = (1 << 2),
        GPU_MATFLAG_SSS           = (1 << 3),
-} GPUMatFlag;
+} eGPUMatFlag;
 
-typedef enum GPUBlendMode {
+typedef enum eGPUBlendMode {
        GPU_BLEND_SOLID = 0,
        GPU_BLEND_ADD = 1,
        GPU_BLEND_ALPHA = 2,
        GPU_BLEND_CLIP = 4,
        GPU_BLEND_ALPHA_SORT = 8,
        GPU_BLEND_ALPHA_TO_COVERAGE = 16,
-} GPUBlendMode;
+} eGPUBlendMode;
 
 typedef struct GPUNodeStack {
-       GPUType type;
+       eGPUType type;
        float vec[4];
        struct GPUNodeLink *link;
        bool hasinput;
@@ -143,18 +143,18 @@ typedef struct GPUNodeStack {
        bool end;
 } GPUNodeStack;
 
-typedef enum GPUMaterialStatus {
+typedef enum eGPUMaterialStatus {
        GPU_MAT_FAILED = 0,
        GPU_MAT_QUEUED,
        GPU_MAT_SUCCESS,
-} GPUMaterialStatus;
+} eGPUMaterialStatus;
 
 GPUNodeLink *GPU_attribute(CustomDataType type, const char *name);
 GPUNodeLink *GPU_constant(float *num);
 GPUNodeLink *GPU_uniform(float *num);
 GPUNodeLink *GPU_image(struct Image *ima, struct ImageUser *iuser, bool is_data);
 GPUNodeLink *GPU_color_band(GPUMaterial *mat, int size, float *pixels, float *layer);
-GPUNodeLink *GPU_builtin(GPUBuiltin builtin);
+GPUNodeLink *GPU_builtin(eGPUBuiltin builtin);
 
 bool GPU_link(GPUMaterial *mat, const char *name, ...);
 bool GPU_stack_link(GPUMaterial *mat, struct bNode *node, const char *name, GPUNodeStack *in, GPUNodeStack *out, ...);
@@ -163,7 +163,7 @@ GPUNodeLink *GPU_uniformbuffer_link_out(
         struct GPUNodeStack *stack, const int index);
 
 void GPU_material_output_link(GPUMaterial *material, GPUNodeLink *link);
-GPUBuiltin GPU_get_material_builtins(GPUMaterial *material);
+eGPUBuiltin GPU_get_material_builtins(GPUMaterial *material);
 
 void GPU_material_sss_profile_create(GPUMaterial *material, float radii[3], short *falloff_type, float *sharpness);
 struct GPUUniformBuffer *GPU_material_sss_profile_get(
@@ -183,7 +183,7 @@ void GPU_materials_free(struct Main *bmain);
 struct Scene *GPU_material_scene(GPUMaterial *material);
 struct GPUPass *GPU_material_get_pass(GPUMaterial *material);
 struct ListBase *GPU_material_get_inputs(GPUMaterial *material);
-GPUMaterialStatus GPU_material_status(GPUMaterial *mat);
+eGPUMaterialStatus GPU_material_status(GPUMaterial *mat);
 
 struct GPUUniformBuffer *GPU_material_uniform_buffer_get(GPUMaterial *material);
 void GPU_material_uniform_buffer_create(GPUMaterial *material, ListBase *inputs);
@@ -197,8 +197,8 @@ bool GPU_material_do_color_management(GPUMaterial *mat);
 bool GPU_material_use_domain_surface(GPUMaterial *mat);
 bool GPU_material_use_domain_volume(GPUMaterial *mat);
 
-void GPU_material_flag_set(GPUMaterial *mat, GPUMatFlag flag);
-bool GPU_material_flag_get(GPUMaterial *mat, GPUMatFlag flag);
+void GPU_material_flag_set(GPUMaterial *mat, eGPUMatFlag flag);
+bool GPU_material_flag_get(GPUMaterial *mat, eGPUMatFlag flag);
 
 void GPU_pass_cache_init(void);
 void GPU_pass_cache_garbage_collect(void);
index 62e1101..d339d0a 100644 (file)
@@ -44,12 +44,12 @@ struct GPUUniformBuffer;
  * - only for fragment shaders now
  * - must call texture bind before setting a texture as uniform! */
 
-typedef enum GPUShaderTFBType {
+typedef enum eGPUShaderTFBType {
        GPU_SHADER_TFB_NONE         = 0, /* Transform feedback unsupported. */
        GPU_SHADER_TFB_POINTS       = 1,
        GPU_SHADER_TFB_LINES        = 2,
        GPU_SHADER_TFB_TRIANGLES    = 3,
-} GPUShaderTFBType;
+} eGPUShaderTFBType;
 
 GPUShader *GPU_shader_create(
         const char *vertexcode,
@@ -64,7 +64,7 @@ GPUShader *GPU_shader_create_ex(
         const char *geocode,
         const char *libcode,
         const char *defines,
-        const GPUShaderTFBType tf_type,
+        const eGPUShaderTFBType tf_type,
         const char **tf_names,
         const int tf_count,
         const char *shader_name);
@@ -100,7 +100,7 @@ void GPU_shader_uniform_int(GPUShader *shader, int location, int value);
 int GPU_shader_get_attribute(GPUShader *shader, const char *name);
 
 /* Builtin/Non-generated shaders */
-typedef enum GPUBuiltinShader {
+typedef enum eGPUBuiltinShader {
        /* specialized drawing */
        GPU_SHADER_TEXT,
        GPU_SHADER_TEXT_SIMPLE,
@@ -358,22 +358,22 @@ typedef enum GPUBuiltinShader {
        GPU_SHADER_3D_UNIFORM_SELECT_ID,
 
        GPU_NUM_BUILTIN_SHADERS /* (not an actual shader) */
-} GPUBuiltinShader;
+} eGPUBuiltinShader;
 
 /** Keep these in sync with:
  * - `gpu_shader_image_interlace_frag.glsl`
  * - `gpu_shader_image_rect_interlace_frag.glsl`
  */
-typedef enum GPUInterlaceShader {
+typedef enum eGPUInterlaceShader {
        GPU_SHADER_INTERLACE_ROW               = 0,
        GPU_SHADER_INTERLACE_COLUMN            = 1,
        GPU_SHADER_INTERLACE_CHECKER           = 2,
-} GPUInterlaceShader;
+} eGPUInterlaceShader;
 
-GPUShader *GPU_shader_get_builtin_shader(GPUBuiltinShader shader);
+GPUShader *GPU_shader_get_builtin_shader(eGPUBuiltinShader shader);
 
 void GPU_shader_get_builtin_shader_code(
-        GPUBuiltinShader shader,
+        eGPUBuiltinShader shader,
         const char **r_vert, const char **r_frag,
         const char **r_geom, const char **r_defines);
 
index 057caff..0dcd1a6 100644 (file)
 #define __GPU_STATE_H__
 
 /* These map directly to the GL_ blend functions, to minimize API add as needed*/
-typedef enum GPUBlendFunction {
+typedef enum eGPUBlendFunction {
        GPU_ONE,
        GPU_SRC_ALPHA,
        GPU_ONE_MINUS_SRC_ALPHA,
        GPU_DST_COLOR,
        GPU_ZERO,
-} GPUBlendFunction;
+} eGPUBlendFunction;
 
 /* These map directly to the GL_ filter functions, to minimize API add as needed*/
-typedef enum GPUFilterFunction {
+typedef enum eGPUFilterFunction {
        GPU_NEAREST,
        GPU_LINEAR
-} GPUFilterFunction;
+} eGPUFilterFunction;
 
 void GPU_blend(bool enable);
-void GPU_blend_set_func(GPUBlendFunction sfactor, GPUBlendFunction dfactor);
+void GPU_blend_set_func(eGPUBlendFunction sfactor, eGPUBlendFunction dfactor);
 void GPU_blend_set_func_separate(
-        GPUBlendFunction src_rgb, GPUBlendFunction dst_rgb,
-        GPUBlendFunction src_alpha, GPUBlendFunction dst_alpha);
+        eGPUBlendFunction src_rgb, eGPUBlendFunction dst_rgb,
+        eGPUBlendFunction src_alpha, eGPUBlendFunction dst_alpha);
 void GPU_depth_range(float near, float far);
 void GPU_depth_test(bool enable);
 bool GPU_depth_test_enabled(void);
index 7a10c2f..8286733 100644 (file)
@@ -63,7 +63,7 @@ typedef struct GPUTexture GPUTexture;
  * are not supported by renderbuffers. All of the following formats
  * are part of the OpenGL 3.3 core
  * specification. */
-typedef enum GPUTextureFormat {
+typedef enum eGPUTextureFormat {
        /* Formats texture & renderbuffer */
        GPU_RGBA8UI,
        GPU_RGBA8I,
@@ -142,57 +142,57 @@ typedef enum GPUTextureFormat {
        GPU_DEPTH_COMPONENT32F,
        GPU_DEPTH_COMPONENT24,
        GPU_DEPTH_COMPONENT16,
-} GPUTextureFormat;
+} eGPUTextureFormat;
 
-typedef enum GPUDataFormat {
+typedef enum eGPUDataFormat {
        GPU_DATA_FLOAT,
        GPU_DATA_INT,
        GPU_DATA_UNSIGNED_INT,
        GPU_DATA_UNSIGNED_BYTE,
        GPU_DATA_UNSIGNED_INT_24_8,
        GPU_DATA_10_11_11_REV,
-} GPUDataFormat;
+} eGPUDataFormat;
 
 unsigned int GPU_texture_memory_usage_get(void);
 
-/* TODO make it static function again. (create function with GPUDataFormat exposed) */
+/* TODO make it static function again. (create function with eGPUDataFormat exposed) */
 GPUTexture *GPU_texture_create_nD(
         int w, int h, int d, int n, const void *pixels,
-        GPUTextureFormat tex_format, GPUDataFormat gpu_data_format, int samples,
+        eGPUTextureFormat tex_format, eGPUDataFormat gpu_data_format, int samples,
         const bool can_rescale, char err_out[256]);
 
 GPUTexture *GPU_texture_create_1D(
-        int w, GPUTextureFormat data_type, const float *pixels, char err_out[256]);
+        int w, eGPUTextureFormat data_type, const float *pixels, char err_out[256]);
 GPUTexture *GPU_texture_create_1D_array(
-        int w, int h, GPUTextureFormat data_type, const float *pixels, char err_out[256]);
+        int w, int h, eGPUTextureFormat data_type, const float *pixels, char err_out[256]);
 GPUTexture *GPU_texture_create_2D(
-        int w, int h, GPUTextureFormat data_type, const float *pixels, char err_out[256]);
+        int w, int h, eGPUTextureFormat data_type, const float *pixels, char err_out[256]);
 GPUTexture *GPU_texture_create_2D_multisample(
-        int w, int h, GPUTextureFormat data_type, const float *pixels, int samples, char err_out[256]);
+        int w, int h, eGPUTextureFormat data_type, const float *pixels, int samples, char err_out[256]);
 GPUTexture *GPU_texture_create_2D_array(
-        int w, int h, int d, GPUTextureFormat data_type, const float *pixels, char err_out[256]);
+        int w, int h, int d, eGPUTextureFormat data_type, const float *pixels, char err_out[256]);
 GPUTexture *GPU_texture_create_3D(
-        int w, int h, int d, GPUTextureFormat data_type, const float *pixels, char err_out[256]);
+        int w, int h, int d, eGPUTextureFormat data_type, const float *pixels, char err_out[256]);
 GPUTexture *GPU_texture_create_cube(
-        int w, GPUTextureFormat data_type, const float *pixels, char err_out[256]);
+        int w, eGPUTextureFormat data_type, const float *pixels, char err_out[256]);
 GPUTexture *GPU_texture_create_from_vertbuf(
         struct GPUVertBuf *vert);
 GPUTexture *GPU_texture_create_buffer(
-        GPUTextureFormat data_type, const uint buffer);
+        eGPUTextureFormat data_type, const uint buffer);
 
 GPUTexture *GPU_texture_from_bindcode(int textarget, int bindcode);
 GPUTexture *GPU_texture_from_blender(
         struct Image *ima, struct ImageUser *iuser, int textarget, bool is_data, double time);
 GPUTexture *GPU_texture_from_preview(struct PreviewImage *prv, int mipmap);
 
-void GPU_texture_add_mipmap(GPUTexture *tex, GPUDataFormat gpu_data_format, int miplvl, const void *pixels);
+void GPU_texture_add_mipmap(GPUTexture *tex, eGPUDataFormat gpu_data_format, int miplvl, const void *pixels);
 
-void GPU_texture_update(GPUTexture *tex, GPUDataFormat data_format, const void *pixels);
+void GPU_texture_update(GPUTexture *tex, eGPUDataFormat data_format, const void *pixels);
 void GPU_texture_update_sub(
-        GPUTexture *tex, GPUDataFormat gpu_data_format, const void *pixels,
+        GPUTexture *tex, eGPUDataFormat gpu_data_format, const void *pixels,
         int offset_x, int offset_y, int offset_z, int width, int height, int depth);
 
-void *GPU_texture_read(GPUTexture *tex, GPUDataFormat gpu_data_format, int miplvl);
+void *GPU_texture_read(GPUTexture *tex, eGPUDataFormat gpu_data_format, int miplvl);
 
 void GPU_invalid_tex_init(void);
 void GPU_invalid_tex_bind(int mode);
@@ -210,7 +210,7 @@ void GPU_texture_compare_mode(GPUTexture *tex, bool use_compare);
 void GPU_texture_filter_mode(GPUTexture *tex, bool use_filter);
 void GPU_texture_mipmap_mode(GPUTexture *tex, bool use_mipmap, bool use_filter);
 void GPU_texture_wrap_mode(GPUTexture *tex, bool use_repeat);
-void GPU_texture_filters(GPUTexture *tex, GPUFilterFunction min_filter, GPUFilterFunction mag_filter);
+void GPU_texture_filters(GPUTexture *tex, eGPUFilterFunction min_filter, eGPUFilterFunction mag_filter);
 
 void GPU_texture_attach_framebuffer(GPUTexture *tex, struct GPUFrameBuffer *fb, int attachment);
 int GPU_texture_detach_framebuffer(GPUTexture *tex, struct GPUFrameBuffer *fb);
@@ -219,7 +219,7 @@ int GPU_texture_target(const GPUTexture *tex);
 int GPU_texture_width(const GPUTexture *tex);
 int GPU_texture_height(const GPUTexture *tex);
 int GPU_texture_layers(const GPUTexture *tex);
-GPUTextureFormat GPU_texture_format(const GPUTexture *tex);
+eGPUTextureFormat GPU_texture_format(const GPUTexture *tex);
 int GPU_texture_samples(const GPUTexture *tex);
 bool GPU_texture_cube(const GPUTexture *tex);
 bool GPU_texture_depth(const GPUTexture *tex);
index 30d38eb..8bd93b5 100644 (file)
@@ -670,7 +670,7 @@ void GPU_draw_primitive(GPUPrimType prim_type, int v_count)
 /** \name Utilities
  * \{ */
 
-void GPU_batch_program_set_builtin(GPUBatch *batch, GPUBuiltinShader shader_id)
+void GPU_batch_program_set_builtin(GPUBatch *batch, eGPUBuiltinShader shader_id)
 {
        GPUShader *shader = GPU_shader_get_builtin_shader(shader_id);
        GPU_batch_program_set(batch, shader->program, shader->interface);
index 7db51da..78dc0ce 100644 (file)
@@ -146,12 +146,12 @@ typedef enum {
 
 typedef struct GPUFunction {
        char name[MAX_FUNCTION_NAME];
-       GPUType paramtype[MAX_PARAMETER];
+       eGPUType paramtype[MAX_PARAMETER];
        GPUFunctionQual paramqual[MAX_PARAMETER];
        int totparam;
 } GPUFunction;
 
-/* Indices match the GPUType enum */
+/* Indices match the eGPUType enum */
 static const char *GPU_DATATYPE_STR[17] = {
        "", "float", "vec2", "vec3", "vec4",
        NULL, NULL, NULL, NULL, "mat3", NULL, NULL, NULL, NULL, NULL, NULL, "mat4"
@@ -215,7 +215,7 @@ static char *gpu_str_skip_token(char *str, char *token, int max)
 static void gpu_parse_functions_string(GHash *hash, char *code)
 {
        GPUFunction *function;
-       GPUType type;
+       eGPUType type;
        GPUFunctionQual qual;
        int i;
 
@@ -442,7 +442,7 @@ static void codegen_convert_datatype(DynStr *ds, int from, int to, const char *t
        }
 }
 
-static void codegen_print_datatype(DynStr *ds, const GPUType type, float *data)
+static void codegen_print_datatype(DynStr *ds, const eGPUType type, float *data)
 {
        int i;
 
@@ -465,7 +465,7 @@ static int codegen_input_has_texture(GPUInput *input)
                return (input->source == GPU_SOURCE_TEX);
 }
 
-const char *GPU_builtin_name(GPUBuiltin builtin)
+const char *GPU_builtin_name(eGPUBuiltin builtin)
 {
        if (builtin == GPU_VIEW_MATRIX)
                return "unfviewmat";
@@ -1321,7 +1321,7 @@ static GPUNode *GPU_node_begin(const char *name)
        return node;
 }
 
-static void gpu_node_input_link(GPUNode *node, GPUNodeLink *link, const GPUType type)
+static void gpu_node_input_link(GPUNode *node, GPUNodeLink *link, const eGPUType type)
 {
        GPUInput *input;
        GPUNode *outnode;
@@ -1474,7 +1474,7 @@ static void gpu_node_input_socket(GPUMaterial *material, bNode *bnode, GPUNode *
        }
 }
 
-static void gpu_node_output(GPUNode *node, const GPUType type, GPUNodeLink **link)
+static void gpu_node_output(GPUNode *node, const eGPUType type, GPUNodeLink **link)
 {
        GPUOutput *output = MEM_callocN(sizeof(GPUOutput), "GPUOutput");
 
@@ -1627,7 +1627,7 @@ GPUNodeLink *GPU_color_band(GPUMaterial *mat, int size, float *pixels, float *ro
        return link;
 }
 
-GPUNodeLink *GPU_builtin(GPUBuiltin builtin)
+GPUNodeLink *GPU_builtin(eGPUBuiltin builtin)
 {
        GPUNodeLink *link = GPU_node_link_create();
        link->link_type = GPU_NODE_LINK_BUILTIN;
index 82ee559..93eb84b 100644 (file)
@@ -51,7 +51,7 @@ struct PreviewImage;
  *   at the end if used.
  */
 
-typedef enum GPUDataSource {
+typedef enum eGPUDataSource {
        GPU_SOURCE_OUTPUT,
        GPU_SOURCE_CONSTANT,
        GPU_SOURCE_UNIFORM,
@@ -59,7 +59,7 @@ typedef enum GPUDataSource {
        GPU_SOURCE_BUILTIN,
        GPU_SOURCE_STRUCT,
        GPU_SOURCE_TEX,
-} GPUDataSource;
+} eGPUDataSource;
 
 typedef enum {
        GPU_NODE_LINK_NONE = 0,
@@ -94,7 +94,7 @@ struct GPUNodeLink {
                /* GPU_NODE_LINK_CONSTANT | GPU_NODE_LINK_UNIFORM */
                float *data;
                /* GPU_NODE_LINK_BUILTIN */
-               GPUBuiltin builtin;
+               eGPUBuiltin builtin;
                /* GPU_NODE_LINK_COLORBAND */
                struct GPUTexture **coba;
                /* GPU_NODE_LINK_OUTPUT */
@@ -117,7 +117,7 @@ typedef struct GPUOutput {
        struct GPUOutput *next, *prev;
 
        GPUNode *node;
-       GPUType type;      /* data type = length of vector/matrix */
+       eGPUType type;      /* data type = length of vector/matrix */
        GPUNodeLink *link; /* output link */
        int id;            /* unique id as created by code generator */
 } GPUOutput;
@@ -126,21 +126,21 @@ typedef struct GPUInput {
        struct GPUInput *next, *prev;
 
        GPUNode *node;
-       GPUType type;                /* datatype */
+       eGPUType type;                /* datatype */
        GPUNodeLink *link;
        int id;                      /* unique id as created by code generator */
 
-       GPUDataSource source;        /* data source */
+       eGPUDataSource source;        /* data source */
 
        int shaderloc;               /* id from opengl */
        char shadername[32];         /* name in shader */
 
-       /* Content based on GPUDataSource */
+       /* Content based on eGPUDataSource */
        union {
                /* GPU_SOURCE_CONSTANT | GPU_SOURCE_UNIFORM */
                float vec[16];                   /* vector data */
                /* GPU_SOURCE_BUILTIN */
-               GPUBuiltin builtin;              /* builtin uniform */
+               eGPUBuiltin builtin;              /* builtin uniform */
                /* GPU_SOURCE_TEX */
                struct {
                        struct GPUTexture **coba;    /* input texture, only set at runtime */
@@ -149,7 +149,7 @@ typedef struct GPUInput {
                        bool image_isdata;           /* image does not contain color data */
                        bool bindtex;                /* input is responsible for binding the texture? */
                        int texid;                   /* number for multitexture, starting from zero */
-                       GPUType textype;             /* texture type (2D, 1D Array ...) */
+                       eGPUType textype;             /* texture type (2D, 1D Array ...) */
                };
                /* GPU_SOURCE_ATTRIB */
                struct {
@@ -200,7 +200,7 @@ void gpu_codegen_exit(void);
 
 /* Material calls */
 
-const char *GPU_builtin_name(GPUBuiltin builtin);
+const char *GPU_builtin_name(eGPUBuiltin builtin);
 void gpu_material_add_node(struct GPUMaterial *material, struct GPUNode *node);
 struct GPUTexture **gpu_material_ramp_texture_row_set(GPUMaterial *mat, int size, float *pixels, float *row);
 
index a9e11c5..acc150e 100644 (file)
@@ -916,7 +916,7 @@ static GPUTexture *create_density_texture(SmokeDomainSettings *sds, int highres)
        int cell_count = (highres) ? smoke_turbulence_get_cells(sds->wt) : sds->total_cells;
        const bool has_color = (highres) ? smoke_turbulence_has_colors(sds->wt) : smoke_has_colors(sds->fluid);
        int *dim = (highres) ? sds->res_wt : sds->res;
-       GPUTextureFormat format = (has_color) ? GPU_RGBA8 : GPU_R8;
+       eGPUTextureFormat format = (has_color) ? GPU_RGBA8 : GPU_R8;
 
        if (has_color) {
                data = MEM_callocN(sizeof(float) * cell_count * 4, "smokeColorTexture");
index 9c00afb..901face 100644 (file)
@@ -77,9 +77,9 @@ static struct GPUGlobal {
        GLint maxubobinds;
        int colordepth;
        int samples_color_texture_max;
-       GPUDeviceType device;
-       GPUOSType os;
-       GPUDriverType driver;
+       eGPUDeviceType device;
+       eGPUOSType os;
+       eGPUDriverType driver;
        float line_width_range[2];
        /* workaround for different calculation of dfdy factors on GPUs. Some GPUs/drivers
         * calculate dfdy in shader differently when drawing to an offscreen buffer. First
@@ -132,7 +132,7 @@ static void gpu_detect_mip_render_workaround(void)
 
 /* GPU Types */
 
-bool GPU_type_matches(GPUDeviceType device, GPUOSType os, GPUDriverType driver)
+bool GPU_type_matches(eGPUDeviceType device, eGPUOSType os, eGPUDriverType driver)
 {
        return (GG.device & device) && (GG.os & os) && (GG.driver & driver);
 }
index 915a766..b6c8dae 100644 (file)
@@ -108,7 +108,7 @@ static GPUAttachmentType attachment_type_from_tex(GPUTexture *tex, int slot)
        }
 }
 
-static GLenum convert_buffer_bits_to_gl(GPUFrameBufferBits bits)
+static GLenum convert_buffer_bits_to_gl(eGPUFrameBufferBits bits)
 {
        GLbitfield mask = 0;
        mask |= (bits & GPU_DEPTH_BIT) ? GL_DEPTH_BUFFER_BIT : 0;
@@ -576,7 +576,7 @@ void GPU_framebuffer_viewport_set(GPUFrameBuffer *fb, int x, int y, int w, int h
 }
 
 void GPU_framebuffer_clear(
-        GPUFrameBuffer *fb, GPUFrameBufferBits buffers,
+        GPUFrameBuffer *fb, eGPUFrameBufferBits buffers,
         const float clear_col[4], float clear_depth, uint clear_stencil)
 {
        CHECK_FRAMEBUFFER_IS_BOUND(fb);
@@ -630,7 +630,7 @@ void GPU_framebuffer_read_color(
 void GPU_framebuffer_blit(
         GPUFrameBuffer *fb_read, int read_slot,
         GPUFrameBuffer *fb_write, int write_slot,
-        GPUFrameBufferBits blit_buffers)
+        eGPUFrameBufferBits blit_buffers)
 {
        BLI_assert(blit_buffers != 0);
 
@@ -967,7 +967,7 @@ void GPU_clear_color(float red, float green, float blue, float alpha)
        glClearColor(red, green, blue, alpha);
 }
 
-void GPU_clear(GPUFrameBufferBits flags)
+void GPU_clear(eGPUFrameBufferBits flags)
 {
        glClear(convert_buffer_bits_to_gl(flags));
 }
index 3e13b52..def75fd 100644 (file)
@@ -154,7 +154,7 @@ void immBindProgram(GLuint program, const GPUShaderInterface *shaderface)
        GPU_matrix_bind(shaderface);
 }
 
-void immBindBuiltinProgram(GPUBuiltinShader shader_id)
+void immBindBuiltinProgram(eGPUBuiltinShader shader_id)
 {
        GPUShader *shader = GPU_shader_get_builtin_shader(shader_id);
        immBindProgram(shader->program, shader->interface);
index 1137c38..d1062f7 100644 (file)
@@ -70,7 +70,7 @@ struct GPUMaterial {
        Scene *scene; /* DEPRECATED was only useful for lamps */
        Material *ma;
 
-       GPUMaterialStatus status;
+       eGPUMaterialStatus status;
 
        const void *engine_type;   /* attached engine type */
        int options;    /* to identify shader variations (shadow, probe, world background...) */
@@ -215,7 +215,7 @@ void GPU_material_free(ListBase *gpumaterial)
        BLI_freelistN(gpumaterial);
 }
 
-GPUBuiltin GPU_get_material_builtins(GPUMaterial *material)
+eGPUBuiltin GPU_get_material_builtins(GPUMaterial *material)
 {
        return material->builtins;
 }
@@ -586,7 +586,7 @@ void gpu_material_add_node(GPUMaterial *material, GPUNode *node)
 }
 
 /* Return true if the material compilation has not yet begin or begin. */
-GPUMaterialStatus GPU_material_status(GPUMaterial *mat)
+eGPUMaterialStatus GPU_material_status(GPUMaterial *mat)
 {
        return mat->status;
 }
@@ -611,12 +611,12 @@ bool GPU_material_use_domain_volume(GPUMaterial *mat)
        return (mat->domain & GPU_DOMAIN_VOLUME);
 }
 
-void GPU_material_flag_set(GPUMaterial *mat, GPUMatFlag flag)
+void GPU_material_flag_set(GPUMaterial *mat, eGPUMatFlag flag)
 {
        mat->flag |= flag;
 }
 
-bool GPU_material_flag_get(GPUMaterial *mat, GPUMatFlag flag)
+bool GPU_material_flag_get(GPUMaterial *mat, eGPUMatFlag flag)
 {
        return (mat->flag & flag);
 }
index 7739fea..c5a2c2e 100644 (file)
@@ -339,7 +339,7 @@ GPUShader *GPU_shader_create_ex(
         const char *geocode,
         const char *libcode,
         const char *defines,
-        const GPUShaderTFBType tf_type,
+        const eGPUShaderTFBType tf_type,
         const char **tf_names,
         const int tf_count,
         const char *shname)
@@ -971,7 +971,7 @@ static const GPUShaderStages builtin_shader_stages[GPU_NUM_BUILTIN_SHADERS] = {
 
 /* just a few special cases */
 static const char *gpu_shader_get_builtin_shader_defines(
-        GPUBuiltinShader shader)
+        eGPUBuiltinShader shader)
 {
        switch (shader) {
                case GPU_SHADER_2D_IMAGE_MULTISAMPLE_2:
@@ -1036,7 +1036,7 @@ static const char *gpu_shader_get_builtin_shader_defines(
        }
 }
 
-GPUShader *GPU_shader_get_builtin_shader(GPUBuiltinShader shader)
+GPUShader *GPU_shader_get_builtin_shader(eGPUBuiltinShader shader)
 {
        BLI_assert(shader != GPU_NUM_BUILTIN_SHADERS); /* don't be a troll */
 
@@ -1072,7 +1072,7 @@ GPUShader *GPU_shader_get_builtin_shader(GPUBuiltinShader shader)
 }
 
 void GPU_shader_get_builtin_shader_code(
-        GPUBuiltinShader shader,
+        eGPUBuiltinShader shader,
         const char **r_vert, const char **r_frag,
         const char **r_geom, const char **r_defines)
 {
index 767437a..133de52 100644 (file)
@@ -31,7 +31,7 @@
 #include "GPU_state.h"
 #include "GPU_extensions.h"
 
-static GLenum gpu_get_gl_blendfunction(GPUBlendFunction blend)
+static GLenum gpu_get_gl_blendfunction(eGPUBlendFunction blend)
 {
        switch (blend) {
                case GPU_ONE:
@@ -60,14 +60,14 @@ void GPU_blend(bool enable)
        }
 }
 
-void GPU_blend_set_func(GPUBlendFunction sfactor, GPUBlendFunction dfactor)
+void GPU_blend_set_func(eGPUBlendFunction sfactor, eGPUBlendFunction dfactor)
 {
        glBlendFunc(gpu_get_gl_blendfunction(sfactor), gpu_get_gl_blendfunction(dfactor));
 }
 
 void GPU_blend_set_func_separate(
-       GPUBlendFunction src_rgb, GPUBlendFunction dst_rgb,
-       GPUBlendFunction src_alpha, GPUBlendFunction dst_alpha)
+       eGPUBlendFunction src_rgb, eGPUBlendFunction dst_rgb,
+       eGPUBlendFunction src_alpha, eGPUBlendFunction dst_alpha)
 {
        glBlendFuncSeparate(
                gpu_get_gl_blendfunction(src_rgb),
index 6d9f009..028d1fe 100644 (file)
@@ -57,7 +57,7 @@ static struct GPUTextureGlobal {
 /* Maximum number of FBOs a texture can be attached to. */
 #define GPU_TEX_MAX_FBO_ATTACHED 10
 
-typedef enum GPUTextureFormatFlag {
+typedef enum eGPUTextureFormatFlag {
        GPU_FORMAT_DEPTH     = (1 << 0),
        GPU_FORMAT_STENCIL   = (1 << 1),
        GPU_FORMAT_INTEGER   = (1 << 2),
@@ -68,7 +68,7 @@ typedef enum GPUTextureFormatFlag {
        GPU_FORMAT_3D        = (1 << 12),
        GPU_FORMAT_CUBE      = (1 << 13),
        GPU_FORMAT_ARRAY     = (1 << 14),
-} GPUTextureFormatFlag;
+} eGPUTextureFormatFlag;
 
 /* GPUTexture */
 struct GPUTexture {
@@ -80,8 +80,8 @@ struct GPUTexture {
                             * use it for unbinding */
        GLuint bindcode;    /* opengl identifier for texture */
 
-       GPUTextureFormat format;
-       GPUTextureFormatFlag format_flag;
+       eGPUTextureFormat format;
+       eGPUTextureFormatFlag format_flag;
 
        uint bytesize;      /* number of byte for one pixel */
        int components;     /* number of color/alpha channels */
@@ -178,7 +178,7 @@ static const char *gl_enum_to_str(GLenum e)
        return enum_strings[e];
 }
 
-static int gpu_get_component_count(GPUTextureFormat format)
+static int gpu_get_component_count(eGPUTextureFormat format)
 {
        switch (format) {
                case GPU_RGBA8:
@@ -203,7 +203,7 @@ static int gpu_get_component_count(GPUTextureFormat format)
 }
 
 /* Definitely not complete, edit according to the gl specification. */
-static void gpu_validate_data_format(GPUTextureFormat tex_format, GPUDataFormat data_format)
+static void gpu_validate_data_format(eGPUTextureFormat tex_format, eGPUDataFormat data_format)
 {
        (void)data_format;
 
@@ -245,7 +245,7 @@ static void gpu_validate_data_format(GPUTextureFormat tex_format, GPUDataFormat
        }
 }
 
-static GPUDataFormat gpu_get_data_format_from_tex_format(GPUTextureFormat tex_format)
+static eGPUDataFormat gpu_get_data_format_from_tex_format(eGPUTextureFormat tex_format)
 {
        if (ELEM(tex_format,
                 GPU_DEPTH_COMPONENT24,
@@ -285,7 +285,7 @@ static GPUDataFormat gpu_get_data_format_from_tex_format(GPUTextureFormat tex_fo
 }
 
 /* Definitely not complete, edit according to the gl specification. */
-static GLenum gpu_get_gl_dataformat(GPUTextureFormat data_type, GPUTextureFormatFlag *format_flag)
+static GLenum gpu_get_gl_dataformat(eGPUTextureFormat data_type, eGPUTextureFormatFlag *format_flag)
 {
        if (ELEM(data_type,
                 GPU_DEPTH_COMPONENT24,
@@ -335,7 +335,7 @@ static GLenum gpu_get_gl_dataformat(GPUTextureFormat data_type, GPUTextureFormat
        return GL_RGBA;
 }
 
-static uint gpu_get_bytesize(GPUTextureFormat data_type)
+static uint gpu_get_bytesize(eGPUTextureFormat data_type)
 {
        switch (data_type) {
                case GPU_RGBA32F:
@@ -379,7 +379,7 @@ static uint gpu_get_bytesize(GPUTextureFormat data_type)
        }
 }
 
-static GLenum gpu_get_gl_internalformat(GPUTextureFormat format)
+static GLenum gpu_get_gl_internalformat(eGPUTextureFormat format)
 {
        /* You can add any of the available type to this list
         * For available types see GPU_texture.h */
@@ -424,7 +424,7 @@ static GLenum gpu_get_gl_internalformat(GPUTextureFormat format)
        }
 }
 
-static GLenum gpu_get_gl_datatype(GPUDataFormat format)
+static GLenum gpu_get_gl_datatype(eGPUDataFormat format)
 {
        switch (format) {
                case GPU_DATA_FLOAT:
@@ -592,7 +592,7 @@ static bool gpu_texture_try_alloc(
 
 GPUTexture *GPU_texture_create_nD(
         int w, int h, int d, int n, const void *pixels,
-        GPUTextureFormat tex_format, GPUDataFormat gpu_data_format, int samples,
+        eGPUTextureFormat tex_format, eGPUDataFormat gpu_data_format, int samples,
         const bool can_rescale, char err_out[256])
 {
        if (samples) {
@@ -765,7 +765,7 @@ static GPUTexture *GPU_texture_cube_create(
         int w, int d,
         const float *fpixels_px, const float *fpixels_py, const float *fpixels_pz,
         const float *fpixels_nx, const float *fpixels_ny, const float *fpixels_nz,
-        GPUTextureFormat tex_format, GPUDataFormat gpu_data_format,
+        eGPUTextureFormat tex_format, eGPUDataFormat gpu_data_format,
         char err_out[256])
 {
        GPUTexture *tex = MEM_callocN(sizeof(GPUTexture), "GPUTexture");
@@ -851,7 +851,7 @@ static GPUTexture *GPU_texture_cube_create(
 }
 
 /* Special buffer textures. tex_format must be compatible with the buffer content. */
-GPUTexture *GPU_texture_create_buffer(GPUTextureFormat tex_format, const GLuint buffer)
+GPUTexture *GPU_texture_create_buffer(eGPUTextureFormat tex_format, const GLuint buffer)
 {
        GPUTexture *tex = MEM_callocN(sizeof(GPUTexture), "GPUTexture");
        tex->number = -1;
@@ -992,49 +992,49 @@ GPUTexture *GPU_texture_from_preview(PreviewImage *prv, int mipmap)
 }
 
 GPUTexture *GPU_texture_create_1D(
-        int w, GPUTextureFormat tex_format, const float *pixels, char err_out[256])
+        int w, eGPUTextureFormat tex_format, const float *pixels, char err_out[256])
 {
-       GPUDataFormat data_format = gpu_get_data_format_from_tex_format(tex_format);
+       eGPUDataFormat data_format = gpu_get_data_format_from_tex_format(tex_format);
        return GPU_texture_create_nD(w, 0, 0, 1, pixels, tex_format, data_format, 0, false, err_out);
 }
 
 GPUTexture *GPU_texture_create_1D_array(
-        int w, int h, GPUTextureFormat tex_format, const float *pixels, char err_out[256])
+        int w, int h, eGPUTextureFormat tex_format, const float *pixels, char err_out[256])
 {
-       GPUDataFormat data_format = gpu_get_data_format_from_tex_format(tex_format);
+       eGPUDataFormat data_format = gpu_get_data_format_from_tex_format(tex_format);
        return GPU_texture_create_nD(w, h, 0, 1, pixels, tex_format, data_format, 0, false, err_out);
 }
 
 GPUTexture *GPU_texture_create_2D(
-        int w, int h, GPUTextureFormat tex_format, const float *pixels, char err_out[256])
+        int w, int h, eGPUTextureFormat tex_format, const float *pixels, char err_out[256])
 {
-       GPUDataFormat data_format = gpu_get_data_format_from_tex_format(tex_format);
+       eGPUDataFormat data_format = gpu_get_data_format_from_tex_format(tex_format);
        return GPU_texture_create_nD(w, h, 0, 2, pixels, tex_format, data_format, 0, false, err_out);
 }
 
 GPUTexture *GPU_texture_create_2D_multisample(
-        int w, int h, GPUTextureFormat tex_format, const float *pixels, int samples, char err_out[256])
+        int w, int h, eGPUTextureFormat tex_format, const float *pixels, int samples, char err_out[256])
 {
-       GPUDataFormat data_format = gpu_get_data_format_from_tex_format(tex_format);
+       eGPUDataFormat data_format = gpu_get_data_format_from_tex_format(tex_format);
        return GPU_texture_create_nD(w, h, 0, 2, pixels, tex_format, data_format, samples, false, err_out);
 }
 
 GPUTexture *GPU_texture_create_2D_array(
-        int w, int h, int d, GPUTextureFormat tex_format, const float *pixels, char err_out[256])
+        int w, int h, int d, eGPUTextureFormat tex_format, const float *pixels, char err_out[256])
 {
-       GPUDataFormat data_format = gpu_get_data_format_from_tex_format(tex_format);
+       eGPUDataFormat data_format = gpu_get_data_format_from_tex_format(tex_format);
        return GPU_texture_create_nD(w, h, d, 2, pixels, tex_format, data_format, 0, false, err_out);
 }
 
 GPUTexture *GPU_texture_create_3D(
-        int w, int h, int d, GPUTextureFormat tex_format, const float *pixels, char err_out[256])
+        int w, int h, int d, eGPUTextureFormat tex_format, const float *pixels, char err_out[256])
 {
-       GPUDataFormat data_format = gpu_get_data_format_from_tex_format(tex_format);
+       eGPUDataFormat data_format = gpu_get_data_format_from_tex_format(tex_format);
        return GPU_texture_create_nD(w, h, d, 3, pixels, tex_format, data_format, 0, true, err_out);
 }
 
 GPUTexture *GPU_texture_create_cube(
-        int w, GPUTextureFormat tex_format, const float *fpixels, char err_out[256])
+        int w, eGPUTextureFormat tex_format, const float *fpixels, char err_out[256])
 {
        const float *fpixels_px, *fpixels_py, *fpixels_pz, *fpixels_nx, *fpixels_ny, *fpixels_nz;
        const int channels = gpu_get_component_count(tex_format);
@@ -1075,7 +1075,7 @@ GPUTexture *GPU_texture_create_from_vertbuf(GPUVertBuf *vert)
                BLI_assert(is_uint || byte_per_comp <= 2);
        }
 
-       GPUTextureFormat data_type;
+       eGPUTextureFormat data_type;
        switch (attr->fetch_mode) {
                case GPU_FETCH_FLOAT:
                        switch (attr->comp_len) {
@@ -1126,7 +1126,7 @@ GPUTexture *GPU_texture_create_from_vertbuf(GPUVertBuf *vert)
 }
 
 void GPU_texture_add_mipmap(
-        GPUTexture *tex, GPUDataFormat gpu_data_format, int miplvl, const void *pixels)
+        GPUTexture *tex, eGPUDataFormat gpu_data_format, int miplvl, const void *pixels)
 {
        BLI_assert((int)tex->format > -1);
        BLI_assert(tex->components > -1);
@@ -1166,7 +1166,7 @@ void GPU_texture_add_mipmap(
 }
 
 void GPU_texture_update_sub(
-        GPUTexture *tex, GPUDataFormat gpu_data_format, const void *pixels,
+        GPUTexture *tex, eGPUDataFormat gpu_data_format, const void *pixels,
         int offset_x, int offset_y, int offset_z, int width, int height, int depth)
 {
        BLI_assert((int)tex->format > -1);
@@ -1211,7 +1211,7 @@ void GPU_texture_update_sub(
        glBindTexture(tex->target, 0);
 }
 
-void *GPU_texture_read(GPUTexture *tex, GPUDataFormat gpu_data_format, int miplvl)
+void *GPU_texture_read(GPUTexture *tex, eGPUDataFormat gpu_data_format, int miplvl)
 {
        int size[3] = {0, 0, 0};
        GPU_texture_get_mipmap_size(tex, miplvl, size);
@@ -1265,7 +1265,7 @@ void *GPU_texture_read(GPUTexture *tex, GPUDataFormat gpu_data_format, int miplv
        return buf;
 }
 
-void GPU_texture_update(GPUTexture *tex, GPUDataFormat data_format, const void *pixels)
+void GPU_texture_update(GPUTexture *tex, eGPUDataFormat data_format, const void *pixels)
 {
        GPU_texture_update_sub(tex, data_format, pixels, 0, 0, 0, tex->w, tex->h, tex->d);
 }
@@ -1370,7 +1370,7 @@ void GPU_texture_generate_mipmap(GPUTexture *tex)
                 * In this case we just create a complete texture with mipmaps manually without downsampling.
                 * You must initialize the texture levels using other methods like GPU_framebuffer_recursive_downsample(). */
                int levels = 1 + floor(log2(max_ii(tex->w, tex->h)));
-               GPUDataFormat data_format = gpu_get_data_format_from_tex_format(tex->format);
+               eGPUDataFormat data_format = gpu_get_data_format_from_tex_format(tex->format);
                for (int i = 1; i < levels; ++i) {
                        GPU_texture_add_mipmap(tex, data_format, i, NULL);
                }
@@ -1441,7 +1441,7 @@ void GPU_texture_wrap_mode(GPUTexture *tex, bool use_repeat)
                glTexParameteri(tex->target_base, GL_TEXTURE_WRAP_R, repeat);
 }
 
-static GLenum gpu_get_gl_filterfunction(GPUFilterFunction filter)
+static GLenum gpu_get_gl_filterfunction(eGPUFilterFunction filter)
 {
        switch (filter) {
                case GPU_NEAREST:
@@ -1454,7 +1454,7 @@ static GLenum gpu_get_gl_filterfunction(GPUFilterFunction filter)
        }
 }
 
-void GPU_texture_filters(GPUTexture *tex, GPUFilterFunction min_filter, GPUFilterFunction mag_filter)
+void GPU_texture_filters(GPUTexture *tex, eGPUFilterFunction min_filter, eGPUFilterFunction mag_filter)
 {
        WARN_NOT_BOUND(tex);
 
@@ -1515,7 +1515,7 @@ int GPU_texture_layers(const GPUTexture *tex)
        return tex->d;
 }
 
-GPUTextureFormat GPU_texture_format(const GPUTexture *tex)
+eGPUTextureFormat GPU_texture_format(const GPUTexture *tex)
 {
        return tex->format;
 }
index 97dc511..74ba917 100644 (file)
 #include "GPU_material.h"
 #include "GPU_uniformbuffer.h"
 
-typedef enum GPUUniformBufferFlag {
+typedef enum eGPUUniformBufferFlag {
        GPU_UBO_FLAG_INITIALIZED = (1 << 0),
        GPU_UBO_FLAG_DIRTY = (1 << 1),
-} GPUUniformBufferFlag;
+} eGPUUniformBufferFlag;
 
-typedef enum GPUUniformBufferType {
+typedef enum eGPUUniformBufferType {
        GPU_UBO_STATIC = 0,
        GPU_UBO_DYNAMIC = 1,
-} GPUUniformBufferType;
+} eGPUUniformBufferType;
 
 struct GPUUniformBuffer {
        int size;           /* in bytes */
        GLuint bindcode;    /* opengl identifier for UBO */
        int bindpoint;      /* current binding point */
-       GPUUniformBufferType type;
+       eGPUUniformBufferType type;
 };
 
 #define GPUUniformBufferStatic GPUUniformBuffer
@@ -68,7 +68,7 @@ typedef struct GPUUniformBufferDynamic {
 } GPUUniformBufferDynamic;
 
 /* Prototypes */
-static GPUType get_padded_gpu_type(struct LinkData *link);
+static eGPUType get_padded_gpu_type(struct LinkData *link);
 static void gpu_uniformbuffer_inputs_sort(struct ListBase *inputs);
 
 /* Only support up to this type, if you want to extend it, make sure the
@@ -148,7 +148,7 @@ GPUUniformBuffer *GPU_uniformbuffer_dynamic_create(ListBase *inputs, char err_ou
        gpu_uniformbuffer_inputs_sort(inputs);
 
        for (LinkData *link = inputs->first; link; link = link->next) {
-               const GPUType gputype = get_padded_gpu_type(link);
+               const eGPUType gputype = get_padded_gpu_type(link);
                ubo->buffer.size += gputype * sizeof(float);
        }
 
@@ -231,10 +231,10 @@ void GPU_uniformbuffer_dynamic_update(GPUUniformBuffer *ubo_)
  * We need to pad some data types (vec3) on the C side
  * To match the GPU expected memory block alignment.
  */
-static GPUType get_padded_gpu_type(LinkData *link)
+static eGPUType get_padded_gpu_type(LinkData *link)
 {
        GPUInput *input = link->data;
-       GPUType gputype = input->type;
+       eGPUType gputype = input->type;
 
        /* Unless the vec3 is followed by a float we need to treat it as a vec4. */
        if (gputype == GPU_VEC3 &&
@@ -269,7 +269,7 @@ static void gpu_uniformbuffer_inputs_sort(ListBase *inputs)
 
        /* Creates a lookup table for the different types; */
        LinkData *inputs_lookup[MAX_UBO_GPU_TYPE + 1] = {NULL};
-       GPUType cur_type = MAX_UBO_GPU_TYPE + 1;
+       eGPUType cur_type = MAX_UBO_GPU_TYPE + 1;
 
        for (LinkData *link = inputs->first; link; link = link->next) {
                GPUInput *input = link->data;
index 31e1ccf..e216d18 100644 (file)
@@ -64,7 +64,7 @@ static int bpygpu_ParseBultinShaderEnum(PyObject *o, void *p)
                } \
        } ((void)0)
 
-       GPUBuiltinShader mode;
+       eGPUBuiltinShader mode;
        MATCH_ID(2D_UNIFORM_COLOR);
        MATCH_ID(2D_FLAT_COLOR);
        MATCH_ID(2D_SMOOTH_COLOR);
@@ -80,7 +80,7 @@ static int bpygpu_ParseBultinShaderEnum(PyObject *o, void *p)
        return 0;
 
 success:
-       (*(GPUBuiltinShader *)p) = mode;
+       (*(eGPUBuiltinShader *)p) = mode;
        return 1;
 }
 
@@ -720,7 +720,7 @@ static PyObject *bpygpu_shader_from_builtin(PyObject *UNUSED(self), PyObject *ar
 {
        BPYGPU_IS_INIT_OR_ERROR_OBJ;
 
-       GPUBuiltinShader shader_id;
+       eGPUBuiltinShader shader_id;
 
        if (!bpygpu_ParseBultinShaderEnum(arg, &shader_id)) {
                return NULL;
@@ -750,7 +750,7 @@ PyDoc_STRVAR(bpygpu_shader_code_from_builtin_doc,
 );
 static PyObject *bpygpu_shader_code_from_builtin(BPyGPUShader *UNUSED(self), PyObject *arg)
 {
-       GPUBuiltinShader shader_id;
+       eGPUBuiltinShader shader_id;
 
        const char *vert;
        const char *frag;
index 6b6b3bc..c6b751e 100644 (file)
@@ -65,7 +65,7 @@
 #include "UI_interface.h"
 #include "UI_resources.h"
 
-static GPUInterlaceShader interlace_gpu_id_from_type(eStereo3dInterlaceType interlace_type)
+static eGPUInterlaceShader interlace_gpu_id_from_type(eStereo3dInterlaceType interlace_type)
 {
        switch (interlace_type) {
                case S3D_INTERLACE_ROW: