shaderpipeline: Fixes for enum conventions

panda/src/dxgsg9/dxShaderContext9.cxx

@@ -49,7 +49,7 @@ TypeHandle DXShaderContext9::_type_handle;
 DXShaderContext9::
 DXShaderContext9(Shader *s, GSG *gsg) : ShaderContext(s) {
   DWORD *vs_data;
-  CPT(ShaderModule) vertex_module = s->get_module(Shader::Stage::vertex);
+  CPT(ShaderModule) vertex_module = s->get_module(Shader::Stage::VERTEX);
   if (compile_module(vertex_module, vs_data)) {
     HRESULT result = gsg->_d3d_device->CreateVertexShader(vs_data, &_vertex_shader);
     if (FAILED(result)) {
@@ -59,7 +59,7 @@ DXShaderContext9(Shader *s, GSG *gsg) : ShaderContext(s) {
   }
 
   DWORD *ps_data;
-  CPT(ShaderModule) fragment_module = s->get_module(Shader::Stage::fragment);
+  CPT(ShaderModule) fragment_module = s->get_module(Shader::Stage::FRAGMENT);
   if (compile_module(fragment_module, ps_data)) {
     HRESULT result = gsg->_d3d_device->CreatePixelShader(ps_data, &_pixel_shader);
     if (FAILED(result)) {
@@ -219,11 +219,11 @@ compile_module(const ShaderModule *module, DWORD *&data) {
 
   const char *profile;
   switch (spv->get_stage()) {
-  case Shader::Stage::vertex:
+  case Shader::Stage::VERTEX:
     profile = "vs_3_0";
     break;
 
-  case Shader::Stage::fragment:
+  case Shader::Stage::FRAGMENT:
     profile = "ps_3_0";
     break;
 
@@ -305,7 +305,7 @@ query_constants(const ShaderModule *module, DWORD *data) {
     // parameter index.
     const char *name = (const char *)(table_data + constant.Name);
     if (name[0] != 'p') {
-      if (stage == Shader::Stage::vertex && strcmp(name, "gl_HalfPixel") == 0) {
+      if (stage == Shader::Stage::VERTEX && strcmp(name, "gl_HalfPixel") == 0) {
         // This is a special input generated by spirv-cross.
         _half_pixel_register = constant.RegisterIndex;
         continue;
@@ -459,10 +459,10 @@ r_query_constants(Shader::Stage stage, const Shader::Parameter &param,
     // register, so we need to do an extra conversion step.
     reg.convert = (reg.set == D3DXRS_FLOAT4 && typeinfo.Type != D3DXPT_FLOAT);
 
-    if (stage == Shader::Stage::vertex) {
+    if (stage == Shader::Stage::VERTEX) {
       _vertex_constants.push_back(std::move(reg));
     }
-    if (stage == Shader::Stage::fragment) {
+    if (stage == Shader::Stage::FRAGMENT) {
       _pixel_constants.push_back(std::move(reg));
     }
 

panda/src/glstuff/glShaderContext_src.cxx

@@ -628,7 +628,7 @@ reflect_program(SparseArray &active_locations, LocationMap &locations, LocationM
 
       //TODO: write code to actually query the block variables.
       const ShaderType *struct_type = ShaderType::register_type(ShaderType::Struct());
-      const ShaderType *type = ShaderType::register_type(ShaderType::StorageBuffer(struct_type, ShaderType::Access::read_write));
+      const ShaderType *type = ShaderType::register_type(ShaderType::StorageBuffer(struct_type, ShaderType::Access::READ_WRITE));
 
       std::reverse(ssbo._array_sizes.begin(), ssbo._array_sizes.end());
       for (uint32_t count : ssbo._array_sizes) {
@@ -1219,77 +1219,77 @@ get_param_type(GLenum param_type) {
 
 #ifndef OPENGLES
   case GL_IMAGE_1D:
-    return ShaderType::register_type(ShaderType::Image(Texture::TT_1d_texture, ShaderType::ST_float, ShaderType::Access::read_write));
+    return ShaderType::register_type(ShaderType::Image(Texture::TT_1d_texture, ShaderType::ST_float, ShaderType::Access::READ_WRITE));
 
   case GL_INT_IMAGE_1D:
-    return ShaderType::register_type(ShaderType::Image(Texture::TT_1d_texture, ShaderType::ST_int, ShaderType::Access::read_write));
+    return ShaderType::register_type(ShaderType::Image(Texture::TT_1d_texture, ShaderType::ST_int, ShaderType::Access::READ_WRITE));
 
   case GL_UNSIGNED_INT_IMAGE_1D:
-    return ShaderType::register_type(ShaderType::Image(Texture::TT_1d_texture, ShaderType::ST_uint, ShaderType::Access::read_write));
+    return ShaderType::register_type(ShaderType::Image(Texture::TT_1d_texture, ShaderType::ST_uint, ShaderType::Access::READ_WRITE));
 
   case GL_IMAGE_1D_ARRAY:
-    return ShaderType::register_type(ShaderType::Image(Texture::TT_1d_texture_array, ShaderType::ST_float, ShaderType::Access::read_write));
+    return ShaderType::register_type(ShaderType::Image(Texture::TT_1d_texture_array, ShaderType::ST_float, ShaderType::Access::READ_WRITE));
 
   case GL_INT_IMAGE_1D_ARRAY:
-    return ShaderType::register_type(ShaderType::Image(Texture::TT_1d_texture_array, ShaderType::ST_int, ShaderType::Access::read_write));
+    return ShaderType::register_type(ShaderType::Image(Texture::TT_1d_texture_array, ShaderType::ST_int, ShaderType::Access::READ_WRITE));
 
   case GL_UNSIGNED_INT_IMAGE_1D_ARRAY:
-    return ShaderType::register_type(ShaderType::Image(Texture::TT_1d_texture_array, ShaderType::ST_uint, ShaderType::Access::read_write));
+    return ShaderType::register_type(ShaderType::Image(Texture::TT_1d_texture_array, ShaderType::ST_uint, ShaderType::Access::READ_WRITE));
 #endif
 
   case GL_IMAGE_2D:
-    return ShaderType::register_type(ShaderType::Image(Texture::TT_2d_texture, ShaderType::ST_float, ShaderType::Access::read_write));
+    return ShaderType::register_type(ShaderType::Image(Texture::TT_2d_texture, ShaderType::ST_float, ShaderType::Access::READ_WRITE));
 
   case GL_INT_IMAGE_2D:
-    return ShaderType::register_type(ShaderType::Image(Texture::TT_2d_texture, ShaderType::ST_int, ShaderType::Access::read_write));
+    return ShaderType::register_type(ShaderType::Image(Texture::TT_2d_texture, ShaderType::ST_int, ShaderType::Access::READ_WRITE));
 
   case GL_UNSIGNED_INT_IMAGE_2D:
-    return ShaderType::register_type(ShaderType::Image(Texture::TT_2d_texture, ShaderType::ST_uint, ShaderType::Access::read_write));
+    return ShaderType::register_type(ShaderType::Image(Texture::TT_2d_texture, ShaderType::ST_uint, ShaderType::Access::READ_WRITE));
 
   case GL_IMAGE_2D_ARRAY:
-    return ShaderType::register_type(ShaderType::Image(Texture::TT_2d_texture_array, ShaderType::ST_float, ShaderType::Access::read_write));
+    return ShaderType::register_type(ShaderType::Image(Texture::TT_2d_texture_array, ShaderType::ST_float, ShaderType::Access::READ_WRITE));
 
   case GL_INT_IMAGE_2D_ARRAY:
-    return ShaderType::register_type(ShaderType::Image(Texture::TT_2d_texture_array, ShaderType::ST_int, ShaderType::Access::read_write));
+    return ShaderType::register_type(ShaderType::Image(Texture::TT_2d_texture_array, ShaderType::ST_int, ShaderType::Access::READ_WRITE));
 
   case GL_UNSIGNED_INT_IMAGE_2D_ARRAY:
-    return ShaderType::register_type(ShaderType::Image(Texture::TT_2d_texture_array, ShaderType::ST_uint, ShaderType::Access::read_write));
+    return ShaderType::register_type(ShaderType::Image(Texture::TT_2d_texture_array, ShaderType::ST_uint, ShaderType::Access::READ_WRITE));
 
   case GL_IMAGE_3D:
-    return ShaderType::register_type(ShaderType::Image(Texture::TT_3d_texture, ShaderType::ST_float, ShaderType::Access::read_write));
+    return ShaderType::register_type(ShaderType::Image(Texture::TT_3d_texture, ShaderType::ST_float, ShaderType::Access::READ_WRITE));
 
   case GL_INT_IMAGE_3D:
-    return ShaderType::register_type(ShaderType::Image(Texture::TT_3d_texture, ShaderType::ST_int, ShaderType::Access::read_write));
+    return ShaderType::register_type(ShaderType::Image(Texture::TT_3d_texture, ShaderType::ST_int, ShaderType::Access::READ_WRITE));
 
   case GL_UNSIGNED_INT_IMAGE_3D:
-    return ShaderType::register_type(ShaderType::Image(Texture::TT_3d_texture, ShaderType::ST_uint, ShaderType::Access::read_write));
+    return ShaderType::register_type(ShaderType::Image(Texture::TT_3d_texture, ShaderType::ST_uint, ShaderType::Access::READ_WRITE));
 
   case GL_IMAGE_CUBE:
-    return ShaderType::register_type(ShaderType::Image(Texture::TT_cube_map, ShaderType::ST_float, ShaderType::Access::read_write));
+    return ShaderType::register_type(ShaderType::Image(Texture::TT_cube_map, ShaderType::ST_float, ShaderType::Access::READ_WRITE));
 
   case GL_INT_IMAGE_CUBE:
-    return ShaderType::register_type(ShaderType::Image(Texture::TT_cube_map, ShaderType::ST_int, ShaderType::Access::read_write));
+    return ShaderType::register_type(ShaderType::Image(Texture::TT_cube_map, ShaderType::ST_int, ShaderType::Access::READ_WRITE));
 
   case GL_UNSIGNED_INT_IMAGE_CUBE:
-    return ShaderType::register_type(ShaderType::Image(Texture::TT_cube_map, ShaderType::ST_uint, ShaderType::Access::read_write));
+    return ShaderType::register_type(ShaderType::Image(Texture::TT_cube_map, ShaderType::ST_uint, ShaderType::Access::READ_WRITE));
 
   case GL_IMAGE_CUBE_MAP_ARRAY:
-    return ShaderType::register_type(ShaderType::Image(Texture::TT_cube_map_array, ShaderType::ST_float, ShaderType::Access::read_write));
+    return ShaderType::register_type(ShaderType::Image(Texture::TT_cube_map_array, ShaderType::ST_float, ShaderType::Access::READ_WRITE));
 
   case GL_INT_IMAGE_CUBE_MAP_ARRAY:
-    return ShaderType::register_type(ShaderType::Image(Texture::TT_cube_map_array, ShaderType::ST_int, ShaderType::Access::read_write));
+    return ShaderType::register_type(ShaderType::Image(Texture::TT_cube_map_array, ShaderType::ST_int, ShaderType::Access::READ_WRITE));
 
   case GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY:
-    return ShaderType::register_type(ShaderType::Image(Texture::TT_cube_map_array, ShaderType::ST_uint, ShaderType::Access::read_write));
+    return ShaderType::register_type(ShaderType::Image(Texture::TT_cube_map_array, ShaderType::ST_uint, ShaderType::Access::READ_WRITE));
 
   case GL_IMAGE_BUFFER:
-    return ShaderType::register_type(ShaderType::Image(Texture::TT_buffer_texture, ShaderType::ST_float, ShaderType::Access::read_write));
+    return ShaderType::register_type(ShaderType::Image(Texture::TT_buffer_texture, ShaderType::ST_float, ShaderType::Access::READ_WRITE));
 
   case GL_INT_IMAGE_BUFFER:
-    return ShaderType::register_type(ShaderType::Image(Texture::TT_buffer_texture, ShaderType::ST_int, ShaderType::Access::read_write));
+    return ShaderType::register_type(ShaderType::Image(Texture::TT_buffer_texture, ShaderType::ST_int, ShaderType::Access::READ_WRITE));
 
   case GL_UNSIGNED_INT_IMAGE_BUFFER:
-    return ShaderType::register_type(ShaderType::Image(Texture::TT_buffer_texture, ShaderType::ST_uint, ShaderType::Access::read_write));
+    return ShaderType::register_type(ShaderType::Image(Texture::TT_buffer_texture, ShaderType::ST_uint, ShaderType::Access::READ_WRITE));
   }
 
   GLCAT.error()
@@ -1971,7 +1971,7 @@ update_shader_texture_bindings(ShaderContext *prev) {
     for (int i = 0; i < num_image_units; ++i) {
       ImageUnit &unit = _image_units[i];
 
-      ShaderType::Access access = ShaderType::Access::read_write;
+      ShaderType::Access access = ShaderType::Access::READ_WRITE;
       int z = -1;
       int n = 0;
       PT(Texture) tex = unit._binding->fetch_texture_image(state, unit._resource_id, access, z, n);
@@ -2025,7 +2025,7 @@ update_shader_texture_bindings(ShaderContext *prev) {
         }
 
         if (gl_force_image_bindings_writeonly) {
-          access = access & ShaderType::Access::write_only;
+          access = access & ShaderType::Access::WRITE_ONLY;
         }
 
         GLenum gl_access = GL_READ_WRITE;
@@ -2034,18 +2034,18 @@ update_shader_texture_bindings(ShaderContext *prev) {
         GLboolean layered = z < 0;
 
         switch (access) {
-        case ShaderType::Access::none:
+        case ShaderType::Access::NONE:
           gl_tex = 0;
-        case ShaderType::Access::read_only:
+        case ShaderType::Access::READ_ONLY:
           gl_access = GL_READ_ONLY;
           break;
 
-        case ShaderType::Access::write_only:
+        case ShaderType::Access::WRITE_ONLY:
           gl_access = GL_WRITE_ONLY;
           unit._written = true;
           break;
 
-        case ShaderType::Access::read_write:
+        case ShaderType::Access::READ_WRITE:
           gl_access = GL_READ_WRITE;
           unit._written = true;
           break;
@@ -2326,30 +2326,30 @@ attach_shader(const ShaderModule *module, Shader::ModuleSpecConstants &consts,
 
   GLuint handle = 0;
   switch (stage) {
-  case ShaderModule::Stage::vertex:
+  case ShaderModule::Stage::VERTEX:
     handle = _glgsg->_glCreateShader(GL_VERTEX_SHADER);
     break;
-  case ShaderModule::Stage::fragment:
+  case ShaderModule::Stage::FRAGMENT:
     handle = _glgsg->_glCreateShader(GL_FRAGMENT_SHADER);
     break;
 #ifndef OPENGLES
-  case ShaderModule::Stage::geometry:
+  case ShaderModule::Stage::GEOMETRY:
     if (_glgsg->get_supports_geometry_shaders()) {
       handle = _glgsg->_glCreateShader(GL_GEOMETRY_SHADER);
     }
     break;
-  case ShaderModule::Stage::tess_control:
+  case ShaderModule::Stage::TESS_CONTROL:
     if (_glgsg->get_supports_tessellation_shaders()) {
       handle = _glgsg->_glCreateShader(GL_TESS_CONTROL_SHADER);
     }
     break;
-  case ShaderModule::Stage::tess_evaluation:
+  case ShaderModule::Stage::TESS_EVALUATION:
     if (_glgsg->get_supports_tessellation_shaders()) {
       handle = _glgsg->_glCreateShader(GL_TESS_EVALUATION_SHADER);
     }
     break;
 #endif
-  case ShaderModule::Stage::compute:
+  case ShaderModule::Stage::COMPUTE:
     if (_glgsg->get_supports_compute_shaders()) {
       handle = _glgsg->_glCreateShader(GL_COMPUTE_SHADER);
     }
@@ -2550,7 +2550,7 @@ attach_shader(const ShaderModule *module, Shader::ModuleSpecConstants &consts,
           }
         }
         else if (sc == spv::StorageClassInput) {
-          if (stage == ShaderModule::Stage::vertex) {
+          if (stage == ShaderModule::Stage::VERTEX) {
             // Explicit attrib locations were added in GLSL 3.30, but we can
             // override the binding in older versions using the API.
             sprintf(buf, "a%u", loc);
@@ -2566,7 +2566,7 @@ attach_shader(const ShaderModule *module, Shader::ModuleSpecConstants &consts,
           compiler.set_name(id, buf);
         }
         else if (sc == spv::StorageClassOutput) {
-          if (stage == ShaderModule::Stage::fragment) {
+          if (stage == ShaderModule::Stage::FRAGMENT) {
             // Output of the last stage, same story as above.
             sprintf(buf, "o%u", loc);
             if (options.version < 330) {

panda/src/gobj/shader.cxx

@@ -178,27 +178,27 @@ read(const ShaderFile &sfile, BamCacheRecord *record) {
 
     // Read the various stages in order.
     if (!sfile._vertex.empty() &&
-        !do_read_source(Stage::vertex, sfile._vertex, record)) {
+        !do_read_source(Stage::VERTEX, sfile._vertex, record)) {
       return false;
     }
     if (!sfile._tess_control.empty() &&
-        !do_read_source(Stage::tess_control, sfile._tess_control, record)) {
+        !do_read_source(Stage::TESS_CONTROL, sfile._tess_control, record)) {
       return false;
     }
     if (!sfile._tess_evaluation.empty() &&
-        !do_read_source(Stage::tess_evaluation, sfile._tess_evaluation, record)) {
+        !do_read_source(Stage::TESS_EVALUATION, sfile._tess_evaluation, record)) {
       return false;
     }
     if (!sfile._geometry.empty() &&
-        !do_read_source(Stage::geometry, sfile._geometry, record)) {
+        !do_read_source(Stage::GEOMETRY, sfile._geometry, record)) {
       return false;
     }
     if (!sfile._fragment.empty() &&
-        !do_read_source(Stage::fragment, sfile._fragment, record)) {
+        !do_read_source(Stage::FRAGMENT, sfile._fragment, record)) {
       return false;
     }
     if (!sfile._compute.empty() &&
-        !do_read_source(Stage::compute, sfile._compute, record)) {
+        !do_read_source(Stage::COMPUTE, sfile._compute, record)) {
       return false;
     }
     _filename = sfile;
@@ -258,21 +258,21 @@ read(const ShaderFile &sfile, BamCacheRecord *record) {
 
     std::istringstream in(source);
 
-    PT(ShaderModule) vertex = compiler->compile_now(Stage::vertex, in, fullpath, record);
+    PT(ShaderModule) vertex = compiler->compile_now(Stage::VERTEX, in, fullpath, record);
     if (vertex == nullptr || !add_module(std::move(vertex))) {
       return false;
     }
     if (source.find("gshader") != string::npos) {
       in.clear();
       in.seekg(0);
-      PT(ShaderModule) geometry = compiler->compile_now(Stage::geometry, in, fullpath, record);
+      PT(ShaderModule) geometry = compiler->compile_now(Stage::GEOMETRY, in, fullpath, record);
       if (geometry == nullptr || !add_module(std::move(geometry))) {
         return false;
       }
     }
     in.clear();
     in.seekg(0);
-    PT(ShaderModule) fragment = compiler->compile_now(Stage::fragment, in, fullpath, record);
+    PT(ShaderModule) fragment = compiler->compile_now(Stage::FRAGMENT, in, fullpath, record);
     if (fragment == nullptr || !add_module(std::move(fragment))) {
       return false;
     }
@@ -320,27 +320,27 @@ load(const ShaderFile &sbody, BamCacheRecord *record) {
     }
 
     if (!sbody._vertex.empty() &&
-        !do_load_source(Stage::vertex, sbody._vertex, record)) {
+        !do_load_source(Stage::VERTEX, sbody._vertex, record)) {
       return false;
     }
     if (!sbody._tess_control.empty() &&
-        !do_load_source(Stage::tess_control, sbody._tess_control, record)) {
+        !do_load_source(Stage::TESS_CONTROL, sbody._tess_control, record)) {
       return false;
     }
     if (!sbody._tess_evaluation.empty() &&
-        !do_load_source(Stage::tess_evaluation, sbody._tess_evaluation, record)) {
+        !do_load_source(Stage::TESS_EVALUATION, sbody._tess_evaluation, record)) {
       return false;
     }
     if (!sbody._geometry.empty() &&
-        !do_load_source(Stage::geometry, sbody._geometry, record)) {
+        !do_load_source(Stage::GEOMETRY, sbody._geometry, record)) {
       return false;
     }
     if (!sbody._fragment.empty() &&
-        !do_load_source(Stage::fragment, sbody._fragment, record)) {
+        !do_load_source(Stage::FRAGMENT, sbody._fragment, record)) {
       return false;
     }
     if (!sbody._compute.empty() &&
-        !do_load_source(Stage::compute, sbody._compute, record)) {
+        !do_load_source(Stage::COMPUTE, sbody._compute, record)) {
       return false;
     }
 
@@ -352,14 +352,14 @@ load(const ShaderFile &sbody, BamCacheRecord *record) {
     }
     _language = SL_Cg;
 
-    if (!do_load_source(Stage::vertex, sbody._shared, record)) {
+    if (!do_load_source(Stage::VERTEX, sbody._shared, record)) {
       return false;
     }
-    if (!do_load_source(Stage::fragment, sbody._shared, record)) {
+    if (!do_load_source(Stage::FRAGMENT, sbody._shared, record)) {
       return false;
     }
     if (sbody._shared.find("gshader") != string::npos &&
-        !do_load_source(Stage::geometry, sbody._shared, record)) {
+        !do_load_source(Stage::GEOMETRY, sbody._shared, record)) {
       return false;
     }
 
@@ -801,7 +801,7 @@ load_compute(ShaderLanguage lang, const Filename &fn) {
   if (record != nullptr) {
     if (record->has_data()) {
       PT(Shader) shader = DCAST(Shader, record->get_data());
-      if (shader->_module_mask == (1 << (int)Stage::compute)) {
+      if (shader->_module_mask == (1 << (int)Stage::COMPUTE)) {
         shader_cat.info()
           << "Compute shader " << fn << " was found in disk cache.\n";
         return shader;
@@ -1028,7 +1028,7 @@ add_module(PT(ShaderModule) module) {
       module->remap_input_locations(location_remap);
     }
   }
-  else if (stage == Stage::vertex) {
+  else if (stage == Stage::VERTEX) {
     // Bind vertex inputs right away.
     CPT(ShaderModule) module = cow_module.get_read_pointer();
     bool success = true;

panda/src/gobj/shaderEnums.cxx

@@ -19,18 +19,18 @@
 std::string ShaderEnums::
 format_stage(Stage stage) {
   switch (stage) {
-  case Stage::vertex:
-    return "vertex";
-  case Stage::tess_control:
-    return "tess_control";
-  case Stage::tess_evaluation:
-    return "tess_evaluation";
-  case Stage::geometry:
-    return "geometry";
-  case Stage::fragment:
-    return "fragment";
-  case Stage::compute:
-    return "compute";
+  case Stage::VERTEX:
+    return "VERTEX";
+  case Stage::TESS_CONTROL:
+    return "TESS_CONTROL";
+  case Stage::TESS_EVALUATION:
+    return "TESS_EVALUATION";
+  case Stage::GEOMETRY:
+    return "GEOMETRY";
+  case Stage::FRAGMENT:
+    return "FRAGMENT";
+  case Stage::COMPUTE:
+    return "COMPUTE";
   }
 
   return "**invalid**";

panda/src/gobj/shaderEnums.h

@@ -26,12 +26,12 @@
 class EXPCL_PANDA_GOBJ ShaderEnums {
 PUBLISHED:
   enum class Stage {
-    vertex,
-    tess_control,
-    tess_evaluation,
-    geometry,
-    fragment,
-    compute,
+    VERTEX,
+    TESS_CONTROL,
+    TESS_EVALUATION,
+    GEOMETRY,
+    FRAGMENT,
+    COMPUTE,
   };
 
   enum ShaderLanguage {

panda/src/gobj/shaderModule.cxx

@@ -21,16 +21,16 @@ TypeHandle ShaderModule::_type_handle;
 ShaderModule::
 ShaderModule(Stage stage) : _stage(stage), _used_caps(C_basic_shader) {
   switch (stage) {
-  case Stage::tess_control:
-  case Stage::tess_evaluation:
+  case Stage::TESS_CONTROL:
+  case Stage::TESS_EVALUATION:
     _used_caps |= C_tessellation_shader;
     break;
 
-  case Stage::geometry:
+  case Stage::GEOMETRY:
     _used_caps |= C_geometry_shader;
     break;
 
-  case Stage::compute:
+  case Stage::COMPUTE:
     _used_caps |= C_compute_shader;
     break;
 

panda/src/gobj/shaderType.I

@@ -218,7 +218,7 @@ get_access() const {
  */
 INLINE bool ShaderType::Image::
 is_writable() const {
-  return ((int)_access & (int)Access::write_only) != 0;
+  return ((int)_access & (int)Access::WRITE_ONLY) != 0;
 }
 
 /**

panda/src/gobj/shaderType.cxx

@@ -993,10 +993,10 @@ make_from_bam(const FactoryParams &params) {
  */
 void ShaderType::Image::
 output(std::ostream &out) const {
-  if ((_access & Access::write_only) == Access::none) {
+  if ((_access & Access::WRITE_ONLY) == Access::NONE) {
     out << "readonly ";
   }
-  if ((_access & Access::read_only) == Access::none) {
+  if ((_access & Access::READ_ONLY) == Access::NONE) {
     out << "writeonly ";
   }
   if (_sampled_type == ST_int) {
@@ -1169,10 +1169,10 @@ make_from_bam(const FactoryParams &params) {
  */
 void ShaderType::StorageBuffer::
 output(std::ostream &out) const {
-  if ((_access & Access::write_only) == Access::none) {
+  if ((_access & Access::WRITE_ONLY) == Access::NONE) {
     out << "readonly ";
   }
-  if ((_access & Access::read_only) == Access::none) {
+  if ((_access & Access::READ_ONLY) == Access::NONE) {
     out << "writeonly ";
   }
   out << "buffer";

panda/src/gobj/shaderType.h

@@ -57,10 +57,10 @@ public:
   };
 
   enum class Access {
-    none = 0,
-    read_only = 1,
-    write_only = 2,
-    read_write = 3,
+    NONE = 0,
+    READ_ONLY = 1,
+    WRITE_ONLY = 2,
+    READ_WRITE = 3,
   };
 
 private:

panda/src/pgraph/shaderAttrib.cxx

@@ -550,7 +550,7 @@ get_shader_input_texture_image(const InternalName *id, ShaderType::Access &acces
       // People find it convenient to be able to pass a texture without
       // further ado.
       tex = p.get_texture();
-      access = ShaderType::Access::read_write;
+      access = ShaderType::Access::READ_WRITE;
       z = -1;
       n = 0;
       break;

panda/src/shaderpipeline/shaderCompilerGlslang.cxx

@@ -231,22 +231,22 @@ compile_now(ShaderModule::Stage stage, std::istream &in,
   EShMessages messages = (EShMessages)(EShMsgDefault | EShMsgSpvRules);
   EShLanguage language;
   switch (stage) {
-  case ShaderModule::Stage::vertex:
+  case ShaderModule::Stage::VERTEX:
     language = EShLangVertex;
     break;
-  case ShaderModule::Stage::tess_control:
+  case ShaderModule::Stage::TESS_CONTROL:
     language = EShLangTessControl;
     break;
-  case ShaderModule::Stage::tess_evaluation:
+  case ShaderModule::Stage::TESS_EVALUATION:
     language = EShLangTessEvaluation;
     break;
-  case ShaderModule::Stage::geometry:
+  case ShaderModule::Stage::GEOMETRY:
     language = EShLangGeometry;
     break;
-  case ShaderModule::Stage::fragment:
+  case ShaderModule::Stage::FRAGMENT:
     language = EShLangFragment;
     break;
-  case ShaderModule::Stage::compute:
+  case ShaderModule::Stage::COMPUTE:
     language = EShLangCompute;
     break;
   default:
@@ -269,13 +269,13 @@ compile_now(ShaderModule::Stage stage, std::istream &in,
 
     const char *source_entry_point;
     switch (stage) {
-    case ShaderModule::Stage::vertex:
+    case ShaderModule::Stage::VERTEX:
       source_entry_point = "vshader";
       break;
-    case ShaderModule::Stage::geometry:
+    case ShaderModule::Stage::GEOMETRY:
       source_entry_point = "gshader";
       break;
-    case ShaderModule::Stage::fragment:
+    case ShaderModule::Stage::FRAGMENT:
       source_entry_point = "fshader";
       break;
     default:

panda/src/shaderpipeline/shaderModuleSpirV.cxx

@@ -187,7 +187,7 @@ ShaderModuleSpirV(Stage stage, std::vector<uint32_t> words, BamCacheRecord *reco
       if (def._storage_class == spv::StorageClassInput) {
         _inputs.push_back(std::move(var));
 
-        if (stage == Stage::fragment) {
+        if (stage == Stage::FRAGMENT) {
           // Integer varyings require shader model 4.
           if (def._type->contains_scalar_type(ShaderType::ST_uint) ||
               def._type->contains_scalar_type(ShaderType::ST_int) ||
@@ -435,13 +435,13 @@ ShaderModuleSpirV(Stage stage, std::vector<uint32_t> words, BamCacheRecord *reco
 
     case spv::OpImageSampleExplicitLod:
     case spv::OpImageSampleProjExplicitLod:
-      if (stage != Stage::vertex) {
+      if (stage != Stage::VERTEX) {
         _used_caps |= C_texture_lod;
       }
       // fall through
     case spv::OpImageSampleImplicitLod:
     case spv::OpImageSampleProjImplicitLod:
-      if (stage == Stage::vertex) {
+      if (stage == Stage::VERTEX) {
         _used_caps |= C_vertex_texture;
       }
       if (op.nargs >= 5 && (op.args[4] & spv::ImageOperandsGradMask) != 0) {
@@ -451,7 +451,7 @@ ShaderModuleSpirV(Stage stage, std::vector<uint32_t> words, BamCacheRecord *reco
 
     case spv::OpImageSampleDrefExplicitLod:
     case spv::OpImageSampleProjDrefExplicitLod:
-      if (stage != Stage::vertex) {
+      if (stage != Stage::VERTEX) {
         _used_caps |= C_texture_lod;
       }
       // fall through
@@ -469,7 +469,7 @@ ShaderModuleSpirV(Stage stage, std::vector<uint32_t> words, BamCacheRecord *reco
           }
         }
       }
-      if (stage == Stage::vertex) {
+      if (stage == Stage::VERTEX) {
         _used_caps |= C_vertex_texture;
       }
       if (op.nargs >= 5 && (op.args[4] & spv::ImageOperandsGradMask) != 0) {

panda/src/shaderpipeline/spirVResultDatabase.cxx

@@ -287,17 +287,17 @@ parse_instruction(spv::Op opcode, const uint32_t *args, uint32_t nargs, uint32_t
         return;
       }
 
-      ShaderType::Access access = ShaderType::Access::read_write;
+      ShaderType::Access access = ShaderType::Access::READ_WRITE;
       if (nargs > 8) {
         switch ((spv::AccessQualifier)args[8]) {
         case spv::AccessQualifierReadOnly:
-          access = ShaderType::Access::read_only;
+          access = ShaderType::Access::READ_ONLY;
           break;
         case spv::AccessQualifierWriteOnly:
-          access = ShaderType::Access::write_only;
+          access = ShaderType::Access::WRITE_ONLY;
           break;
         case spv::AccessQualifierReadWrite:
-          access = ShaderType::Access::read_write;
+          access = ShaderType::Access::READ_WRITE;
           break;
         default:
           shader_cat.error()
@@ -306,10 +306,10 @@ parse_instruction(spv::Op opcode, const uint32_t *args, uint32_t nargs, uint32_t
         }
       }
       if (_defs[args[0]]._flags & DF_non_writable) {
-        access = (access & ShaderType::Access::read_only);
+        access = (access & ShaderType::Access::READ_ONLY);
       }
       if (_defs[args[0]]._flags & DF_non_readable) {
-        access = (access & ShaderType::Access::write_only);
+        access = (access & ShaderType::Access::WRITE_ONLY);
       }
 
       record_type(args[0], ShaderType::register_type(
@@ -384,10 +384,10 @@ parse_instruction(spv::Op opcode, const uint32_t *args, uint32_t nargs, uint32_t
           if (const ShaderType::Image *image = member_type->as_image()) {
             ShaderType::Access access = image->get_access();
             if (member_def._flags & DF_non_writable) {
-              access = (access & ShaderType::Access::read_only);
+              access = (access & ShaderType::Access::READ_ONLY);
             }
             if (member_def._flags & DF_non_readable) {
-              access = (access & ShaderType::Access::write_only);
+              access = (access & ShaderType::Access::WRITE_ONLY);
             }
             if (access != image->get_access()) {
               member_type = ShaderType::register_type(ShaderType::Image(
@@ -970,12 +970,12 @@ record_pointer_type(uint32_t id, spv::StorageClass storage_class, uint32_t type_
           storage_class = spv::StorageClassStorageBuffer;
         }
         if (storage_class == spv::StorageClassStorageBuffer) {
-          ShaderType::Access access = ShaderType::Access::read_write;
+          ShaderType::Access access = ShaderType::Access::READ_WRITE;
           if (block_type_def._flags & DF_non_writable) {
-            access = (access & ShaderType::Access::read_only);
+            access = (access & ShaderType::Access::READ_ONLY);
           }
           if (block_type_def._flags & DF_non_readable) {
-            access = (access & ShaderType::Access::write_only);
+            access = (access & ShaderType::Access::WRITE_ONLY);
           }
           const ShaderType *new_type = ShaderType::register_type(ShaderType::StorageBuffer(block_type_def._type, access));
           type = type->replace_type(block_type_def._type, new_type);
@@ -1039,10 +1039,10 @@ record_variable(uint32_t id, uint32_t pointer_type_id, spv::StorageClass storage
     if (const ShaderType::Image *image = unwrapped_type->as_image()) {
       ShaderType::Access access = image->get_access();
       if (def._flags & DF_non_writable) {
-        access = (access & ShaderType::Access::read_only);
+        access = (access & ShaderType::Access::READ_ONLY);
       }
       if (def._flags & DF_non_readable) {
-        access = (access & ShaderType::Access::write_only);
+        access = (access & ShaderType::Access::WRITE_ONLY);
       }
       if (access != image->get_access()) {
         new_type = ShaderType::register_type(ShaderType::Image(
@@ -1054,10 +1054,10 @@ record_variable(uint32_t id, uint32_t pointer_type_id, spv::StorageClass storage
     else if (const ShaderType::StorageBuffer *buffer = unwrapped_type->as_storage_buffer()) {
       ShaderType::Access access = buffer->get_access();
       if (def._flags & DF_non_writable) {
-        access = (access & ShaderType::Access::read_only);
+        access = (access & ShaderType::Access::READ_ONLY);
       }
       if (def._flags & DF_non_readable) {
-        access = (access & ShaderType::Access::write_only);
+        access = (access & ShaderType::Access::WRITE_ONLY);
       }
       if (access != buffer->get_access()) {
         new_type = ShaderType::register_type(ShaderType::StorageBuffer(

panda/src/shaderpipeline/spirVTransformPass.cxx

@@ -785,16 +785,16 @@ define_type(const ShaderType *type) {
 
     uint32_t nargs = 8;
     switch (image_type->get_access()) {
-    case ShaderType::Access::none:
-    case ShaderType::Access::read_only:
+    case ShaderType::Access::NONE:
+    case ShaderType::Access::READ_ONLY:
       args[8] = spv::AccessQualifierReadOnly;
       ++nargs;
       break;
-    case ShaderType::Access::write_only:
+    case ShaderType::Access::WRITE_ONLY:
       args[8] = spv::AccessQualifierWriteOnly;
       ++nargs;
       break;
-    case ShaderType::Access::read_write:
+    case ShaderType::Access::READ_WRITE:
       args[8] = spv::AccessQualifierReadWrite;
       ++nargs;
       break;

panda/src/shaderpipeline/spirVTransformer.cxx

@@ -190,10 +190,10 @@ assign_locations(ShaderModule::Stage stage) {
           continue;
         }
 
-        if (stage == ShaderModule::Stage::vertex && !input_locations.get_bit(0) &&
+        if (stage == ShaderModule::Stage::VERTEX && !input_locations.get_bit(0) &&
             def._name != "vertex" && def._name != "p3d_Vertex" &&
             def._name != "vtx_position") {
-          // Leave location 0 open for the vertex attribute.
+          // Leave location 0 open for the vertex position attribute.
           location = input_locations.find_off_range(num_locations, 1);
         } else {
           location = input_locations.find_off_range(num_locations);