shaderpipeline: API tweaks

panda/src/gobj/shader.I

@@ -134,7 +134,7 @@ get_error_flag() const {
 /**
  * Returns the shader language in which this shader was written.
  */
-INLINE Shader::ShaderLanguage Shader::
+INLINE Shader::SourceLanguage Shader::
 get_language() const {
   return _language;
 }

panda/src/gobj/shader.cxx

@@ -49,7 +49,7 @@ static bool has_cg_header(const std::string &shader_text) {
  * Construct a Shader that will be filled in using fillin() or read() later.
  */
 Shader::
-Shader(ShaderLanguage lang) :
+Shader(SourceLanguage lang) :
   _error_flag(false),
   _language(lang),
   _cache_compiled_shader(false)
@@ -252,7 +252,8 @@ read(const ShaderFile &sfile, BamCacheRecord *record) {
     shader_cat.info()
       << "Compiling Cg shader: " << fn << "\n";
 
-    ShaderCompiler *compiler = get_compiler(SL_Cg);
+    ShaderCompilerRegistry *registry = ShaderCompilerRegistry::get_global_ptr();
+    ShaderCompiler *compiler = registry->get_compiler_for_language(SL_Cg);
     nassertr(compiler != nullptr, false);
 
     std::istringstream in(source);
@@ -387,7 +388,8 @@ load(const ShaderFile &sbody, BamCacheRecord *record) {
  */
 bool Shader::
 do_read_source(Stage stage, const Filename &fn, BamCacheRecord *record) {
-  ShaderCompiler *compiler = get_compiler(_language);
+  ShaderCompilerRegistry *registry = ShaderCompilerRegistry::get_global_ptr();
+  ShaderCompiler *compiler = registry->get_compiler_for_language(_language);
   nassertr(compiler != nullptr, false);
 
   PT(ShaderModule) module = compiler->compile_now(stage, fn, record);
@@ -418,7 +420,8 @@ do_read_source(Stage stage, const Filename &fn, BamCacheRecord *record) {
 bool Shader::
 do_read_source(ShaderModule::Stage stage, std::istream &in,
                const Filename &fullpath, BamCacheRecord *record) {
-  ShaderCompiler *compiler = get_compiler(_language);
+  ShaderCompilerRegistry *registry = ShaderCompilerRegistry::get_global_ptr();
+  ShaderCompiler *compiler = registry->get_compiler_for_language(_language);
   nassertr(compiler != nullptr, false);
 
   PT(ShaderModule) module = compiler->compile_now(stage, in, fullpath, record);
@@ -670,20 +673,11 @@ check_modified() const {
   return false;
 }
 
-/**
- * Find a ShaderCompiler in the global registry that makes the supplied language
- */
-ShaderCompiler *Shader::
-get_compiler(ShaderLanguage lang) const {
-  ShaderCompilerRegistry *registry = ShaderCompilerRegistry::get_global_ptr();
-  return registry->get_compiler_from_language(lang);
-}
-
 /**
  * Loads the shader with the given filename.
  */
 PT(Shader) Shader::
-load(const Filename &file, ShaderLanguage lang) {
+load(const Filename &file, SourceLanguage lang) {
   ShaderFile sfile(file);
   ShaderTable::const_iterator i = _load_table.find(sfile);
   if (i != _load_table.end() && (lang == SL_none || lang == i->second->_language)) {
@@ -721,7 +715,7 @@ load(const Filename &file, ShaderLanguage lang) {
  * This variant of Shader::load loads all shader programs separately.
  */
 PT(Shader) Shader::
-load(ShaderLanguage lang, const Filename &vertex,
+load(SourceLanguage lang, const Filename &vertex,
      const Filename &fragment, const Filename &geometry,
      const Filename &tess_control, const Filename &tess_evaluation) {
   ShaderFile sfile(vertex, fragment, geometry, tess_control, tess_evaluation);
@@ -761,7 +755,7 @@ load(ShaderLanguage lang, const Filename &vertex,
  * Loads a compute shader.
  */
 PT(Shader) Shader::
-load_compute(ShaderLanguage lang, const Filename &fn) {
+load_compute(SourceLanguage lang, const Filename &fn) {
   if (lang != SL_GLSL) {
     shader_cat.error()
       << "Only GLSL compute shaders are currently supported.\n";
@@ -835,7 +829,7 @@ load_compute(ShaderLanguage lang, const Filename &fn) {
  * Loads the shader, using the string as shader body.
  */
 PT(Shader) Shader::
-make(string body, ShaderLanguage lang) {
+make(string body, SourceLanguage lang) {
   if (lang == SL_GLSL) {
     shader_cat.error()
       << "GLSL shaders must have separate shader bodies!\n";
@@ -893,7 +887,7 @@ make(string body, ShaderLanguage lang) {
  * Loads the shader, using the strings as shader bodies.
  */
 PT(Shader) Shader::
-make(ShaderLanguage lang, string vertex, string fragment, string geometry,
+make(SourceLanguage lang, string vertex, string fragment, string geometry,
      string tess_control, string tess_evaluation) {
   if (lang == SL_none) {
     shader_cat.error()
@@ -937,7 +931,7 @@ make(ShaderLanguage lang, string vertex, string fragment, string geometry,
  * Loads the compute shader from the given string.
  */
 PT(Shader) Shader::
-make_compute(ShaderLanguage lang, string body) {
+make_compute(SourceLanguage lang, string body) {
   if (lang != SL_GLSL) {
     shader_cat.error()
       << "Only GLSL compute shaders are currently supported.\n";
@@ -1340,7 +1334,7 @@ finalize(BamReader *manager) {
  */
 void Shader::
 fillin(DatagramIterator &scan, BamReader *manager) {
-  _language = (ShaderLanguage)scan.get_uint8();
+  _language = (SourceLanguage)scan.get_uint8();
   _debug_name = std::string();
   _module_mask = 0u;
   _modules.clear();

panda/src/gobj/shader.h

@@ -79,28 +79,28 @@ PUBLISHED:
   };
 
 PUBLISHED:
-  Shader(ShaderLanguage lang);
+  Shader(SourceLanguage lang);
 
-  static PT(Shader) load(const Filename &file, ShaderLanguage lang = SL_none);
-  static PT(Shader) make(std::string body, ShaderLanguage lang = SL_none);
-  static PT(Shader) load(ShaderLanguage lang,
+  static PT(Shader) load(const Filename &file, SourceLanguage lang = SL_none);
+  static PT(Shader) make(std::string body, SourceLanguage lang = SL_none);
+  static PT(Shader) load(SourceLanguage lang,
                          const Filename &vertex, const Filename &fragment,
                          const Filename &geometry = "",
                          const Filename &tess_control = "",
                          const Filename &tess_evaluation = "");
-  static PT(Shader) load_compute(ShaderLanguage lang, const Filename &fn);
-  static PT(Shader) make(ShaderLanguage lang,
+  static PT(Shader) load_compute(SourceLanguage lang, const Filename &fn);
+  static PT(Shader) make(SourceLanguage lang,
                          std::string vertex, std::string fragment,
                          std::string geometry = "",
                          std::string tess_control = "",
                          std::string tess_evaluation = "");
-  static PT(Shader) make_compute(ShaderLanguage lang, std::string body);
+  static PT(Shader) make_compute(SourceLanguage lang, std::string body);
 
   INLINE Filename get_filename(DeprecatedShaderType type = ST_none) const;
   INLINE void set_filename(DeprecatedShaderType type, const Filename &filename);
   INLINE const std::string &get_text(DeprecatedShaderType type = ST_none) const;
   INLINE bool get_error_flag() const;
-  INLINE ShaderLanguage get_language() const;
+  INLINE SourceLanguage get_language() const;
   INLINE uint64_t get_used_capabilities() const;
 
   INLINE bool has_fullpath() const;
@@ -297,7 +297,7 @@ public:
 protected:
   ShaderFile _filename;
   Filename _fullpath;
-  ShaderLanguage _language;
+  SourceLanguage _language;
 
   typedef pvector<Filename> Filenames;
 
@@ -337,7 +337,6 @@ public:
   bool bind_vertex_input(const InternalName *name, const ShaderType *type, int location);
 
   bool check_modified() const;
-  ShaderCompiler *get_compiler(ShaderLanguage lang) const;
 
   ~Shader();
 

panda/src/gobj/shaderCompiler.h

@@ -21,8 +21,6 @@
 #include "shader.h"
 #include "shaderModule.h"
 
-typedef pvector<Shader::Shader::ShaderLanguage> ShaderLanguages;
-
 /**
  * This is the base class for objects to compile various types of shader code.
  */
@@ -35,7 +33,7 @@ public:
 
 PUBLISHED:
   virtual std::string get_name() const=0;
-  virtual ShaderLanguages get_languages() const=0;
+  virtual SourceLanguages get_languages() const=0;
   virtual PT(ShaderModule) compile_now(Stage stage, const Filename &path,
                                        BamCacheRecord *record = nullptr) const;
   virtual PT(ShaderModule) compile_now(Stage stage, std::istream &in,

panda/src/gobj/shaderCompilerRegistry.cxx

@@ -57,7 +57,7 @@ register_compiler(ShaderCompiler *compiler) {
 
   _compilers.push_back(compiler);
 
-  ShaderLanguages langs = compiler->get_languages();
+  SourceLanguages langs = compiler->get_languages();
   for (auto langit = langs.begin(); langit != langs.end(); ++langit) {
     record_language(*langit, compiler);
   }
@@ -70,7 +70,7 @@ register_compiler(ShaderCompiler *compiler) {
  * register_compiler() when it initializes, thus making the language loadable.
  */
 void ShaderCompilerRegistry::
-register_deferred_compiler(Shader::ShaderLanguage language, const string &library) {
+register_deferred_compiler(SourceLanguage language, const string &library) {
   Languages::const_iterator li;
   li = _languages.find(language);
   if (li != _languages.end()) {
@@ -129,7 +129,7 @@ get_compiler(int n) const {
  * shader compilers.
  */
 ShaderCompiler *ShaderCompilerRegistry::
-get_compiler_from_language(Shader::ShaderLanguage language) {
+get_compiler_for_language(SourceLanguage language) {
   Languages::const_iterator li;
   li = _languages.find(language);
   if (li == _languages.end()) {
@@ -189,7 +189,7 @@ write(std::ostream &out, int indent_level) const {
       indent(out, std::max(30 - (int)name.length(), 0)) << " ";
 
       bool comma = false;
-      ShaderLanguages langs = compiler->get_languages();
+      SourceLanguages langs = compiler->get_languages();
       for (auto li = langs.begin(); li != langs.end(); ++li) {
         if (comma) {
           out << ",";
@@ -206,7 +206,7 @@ write(std::ostream &out, int indent_level) const {
     indent(out, indent_level) << "Also available:";
     DeferredCompilers::const_iterator di;
     for (di = _deferred_compilers.begin(); di != _deferred_compilers.end(); ++di) {
-        Shader::ShaderLanguage language = (*di).first;
+        SourceLanguage language = (*di).first;
       out << " ." << language;
     }
     out << "\n";
@@ -225,10 +225,10 @@ get_global_ptr() {
 }
 
 /**
- * Records a Shader::ShaderLanguage recognized by a shader compiler.
+ * Records a SourceLanguage recognized by a shader compiler.
  */
 void ShaderCompilerRegistry::
-record_language(Shader::ShaderLanguage language, ShaderCompiler *compiler) {
+record_language(SourceLanguage language, ShaderCompiler *compiler) {
   Languages::const_iterator li;
   li = _languages.find(language);
   if (li != _languages.end()) {

panda/src/gobj/shaderCompilerRegistry.h

@@ -18,7 +18,7 @@
 
 #include "pvector.h"
 #include "pmap.h"
-#include "shader.h"
+#include "shaderEnums.h"
 
 class ShaderCompiler;
 
@@ -32,31 +32,34 @@ protected:
 public:
   ~ShaderCompilerRegistry();
 
+  using SourceLanguage = ShaderEnums::SourceLanguage;
+  using SourceLanguages = ShaderEnums::SourceLanguages;
+
   void register_compiler(ShaderCompiler *compiler);
-  void register_deferred_compiler(Shader::ShaderLanguage language, const std::string &library);
+  void register_deferred_compiler(SourceLanguage language, const std::string &library);
 
 PUBLISHED:
   int get_num_compilers() const;
   ShaderCompiler *get_compiler(int n) const;
   MAKE_SEQ(get_compilers, get_num_compilers, get_compiler);
   MAKE_SEQ_PROPERTY(compilers, get_num_compilers, get_compiler);
-  ShaderCompiler *get_compiler_from_language(Shader::ShaderLanguage language);
+  ShaderCompiler *get_compiler_for_language(SourceLanguage language);
 
   void write(std::ostream &out, int indent_level = 0) const;
 
   static ShaderCompilerRegistry *get_global_ptr();
 
 private:
-  void record_language(Shader::ShaderLanguage language, ShaderCompiler *compiler);
+  void record_language(SourceLanguage language, ShaderCompiler *compiler);
 
 private:
   typedef pvector<ShaderCompiler *> Compilers;
   Compilers _compilers;
 
-  typedef pmap<Shader::ShaderLanguage, ShaderCompiler *> Languages;
+  typedef pmap<SourceLanguage, ShaderCompiler *> Languages;
   Languages _languages;
 
-  typedef pmap<Shader::ShaderLanguage, std::string> DeferredCompilers;
+  typedef pmap<SourceLanguage, std::string> DeferredCompilers;
   DeferredCompilers _deferred_compilers;
 
   static ShaderCompilerRegistry *_global_ptr;

panda/src/gobj/shaderEnums.h

@@ -34,13 +34,13 @@ PUBLISHED:
     COMPUTE,
   };
 
-  enum ShaderLanguage {
+  enum SourceLanguage {
     SL_none,
     SL_Cg,
     SL_GLSL,
     SL_HLSL,
-    SL_SPIR_V,
   };
+  typedef pvector<SourceLanguage> SourceLanguages;
 
   /**
    * Indicates which features are used by the shader, which can be used by the

panda/src/gobj/shaderInputBinding.cxx

@@ -19,7 +19,7 @@ small_vector<ShaderInputBinding::BinderDef, 2> ShaderInputBinding::_binders;
  * Creates the appropriate binding for the input with the given name and type.
  */
 ShaderInputBinding *ShaderInputBinding::
-make(Shader::ShaderLanguage language,
+make(ShaderEnums::SourceLanguage language,
      const InternalName *name, const ShaderType *type) {
 
   for (const BinderDef &def : _binders) {
@@ -41,7 +41,7 @@ make(Shader::ShaderLanguage language,
 int ShaderInputBinding::
 get_state_dep() const {
   // Normally we respecify everything per frame.
-  return Shader::D_frame;
+  return ShaderEnums::D_frame;
 }
 
 /**
@@ -99,7 +99,7 @@ fetch_shader_buffer(const State &state, ResourceId resource_id) const {
  * Registers a factory function to create a binding.
  */
 void ShaderInputBinding::
-register_binder(ShaderEnums::ShaderLanguage language, int sort, Binder binder) {
+register_binder(ShaderEnums::SourceLanguage language, int sort, Binder binder) {
   _binders.push_back({language, sort, binder});
   std::sort(_binders.begin(), _binders.end());
 }

panda/src/gobj/shaderInputBinding.h

@@ -33,7 +33,7 @@ protected:
   ShaderInputBinding() = default;
 
 public:
-  static ShaderInputBinding *make(ShaderEnums::ShaderLanguage language,
+  static ShaderInputBinding *make(ShaderEnums::SourceLanguage language,
                                   const InternalName *name, const ShaderType *type);
 
   template<class Callable>
@@ -71,11 +71,11 @@ public:
   // All the binders are defined in display, we provide this mechanism so that
   // we don't get a dependency on display here.
   typedef ShaderInputBinding *(*Binder)(const InternalName *name, const ShaderType *type);
-  static void register_binder(ShaderEnums::ShaderLanguage language, int sort, Binder binder);
+  static void register_binder(ShaderEnums::SourceLanguage language, int sort, Binder binder);
 
 private:
   struct BinderDef {
-    ShaderEnums::ShaderLanguage _lang;
+    ShaderEnums::SourceLanguage _lang;
     int _sort;
     Binder _func;
 

panda/src/pgraph/shaderPool.cxx

@@ -71,7 +71,7 @@ ns_load_shader(const Filename &orig_filename) {
   gobj_cat.info()
     << "Loading shader " << filename << "\n";
 
-  Shader::ShaderLanguage lang = Shader::SL_none;
+  Shader::SourceLanguage lang = Shader::SL_none;
 
   // Do some guesswork to see if we can figure out the shader language from
   // the file extension.  This is really just guesswork - there are no

panda/src/shaderpipeline/shaderCompilerGlslPreProc.cxx

@@ -64,9 +64,9 @@ get_name() const {
 /**
  *
  */
-ShaderLanguages ShaderCompilerGlslPreProc::
+ShaderCompiler::SourceLanguages ShaderCompilerGlslPreProc::
 get_languages() const {
-  //return ShaderLanguages();
+  //return SourceLanguages();
   return {
     Shader::SL_GLSL
   };

panda/src/shaderpipeline/shaderCompilerGlslPreProc.h

@@ -28,7 +28,7 @@ public:
   ShaderCompilerGlslPreProc();
 
   virtual std::string get_name() const override;
-  virtual ShaderLanguages get_languages() const override;
+  virtual SourceLanguages get_languages() const override;
   virtual PT(ShaderModule) compile_now(Stage stage, std::istream &in,
                                        const Filename &fullpath,
                                        BamCacheRecord *record = nullptr) const override;

panda/src/shaderpipeline/shaderCompilerGlslang.cxx

@@ -154,7 +154,7 @@ get_name() const {
 /**
  *
  */
-ShaderLanguages ShaderCompilerGlslang::
+ShaderCompiler::SourceLanguages ShaderCompilerGlslang::
 get_languages() const {
   return {
     Shader::SL_GLSL,

panda/src/shaderpipeline/shaderCompilerGlslang.h

@@ -28,7 +28,7 @@ public:
   ShaderCompilerGlslang();
 
   virtual std::string get_name() const override;
-  virtual ShaderLanguages get_languages() const override;
+  virtual SourceLanguages get_languages() const override;
   virtual PT(ShaderModule) compile_now(Stage stage, std::istream &in,
                                        const Filename &fullpath,
                                        BamCacheRecord *record = nullptr) const override;

tests/shaderpipeline/conftest.py

@@ -10,4 +10,4 @@ def registry():
 @pytest.fixture
 def compiler_glsl(registry):
     from panda3d.core import Shader
-    return registry.get_compiler_from_language(Shader.SL_GLSL)
+    return registry.get_compiler_for_language(Shader.SL_GLSL)

tests/shaderpipeline/test_glsl_caps.py

@@ -6,7 +6,7 @@ Stage = core.Shader.Stage
 
 def compile_and_get_caps(stage, code):
     registry = core.ShaderCompilerRegistry.get_global_ptr()
-    compiler = registry.get_compiler_from_language(Shader.SL_GLSL)
+    compiler = registry.get_compiler_for_language(Shader.SL_GLSL)
     stream = core.StringStream(code.encode('ascii'))
     module = compiler.compile_now(stage, stream, 'test-shader')
     assert module

tests/shaderpipeline/test_shadercompilerregistry.py

@@ -7,8 +7,8 @@ def test_shadercompilerregistry_exists(registry):
 
 #def test_shadercompilerregistry_glslpreproc_loaded(registry):
 #    assert core.ShaderCompilerGlslPreProc in [type(i) for i in registry.compilers]
-#    assert registry.get_compiler_from_language(core.Shader.SL_GLSL) is not None
+#    assert registry.get_compiler_for_language(core.Shader.SL_GLSL) is not None
 
 #def test_shadercompilerregistry_missing_lang(registry):
 #    assert core.ShaderCompilerGlslPreProc in [type(i) for i in registry.compilers]
-#    assert registry.get_compiler_from_language(core.Shader.SL_none) is None
+#    assert registry.get_compiler_for_language(core.Shader.SL_none) is None