Support vertex attribute and uniform parsing with structured types, built-in attributes, conditional compilation, and variable expansion tracking at crates/jsbindings/webgl

crates/jsbindings/Cargo.toml

@@ -23,6 +23,8 @@ euclid = { workspace = true }
 lazy_static = "1.4.0"
 log = "0.4.21"
 once_cell = "1.17.1"
+serde = { workspace = true }
+serde_json = { workspace = true }
 surfman = "0.9.2"
 taffy = { workspace = true, features = ["default"] }
 gl = { version = "0.14.0" }

crates/jsbindings/bindings.webgl.hpp

@@ -2,6 +2,10 @@
 
 #include <iostream>
 #include <concepts>
+#include <vector>
+#include <string>
+#include <optional>
+#include <rapidjson/document.h>
 #include "./holocron_webgl.autogen.hpp"
 
 namespace crates::webgl
@@ -24,4 +28,108 @@ namespace crates::webgl
       return std::string(patched);
     }
   };
+
+  /**
+   * Represents a GLSL vertex attribute.
+   */
+  struct GLSLAttribute
+  {
+    std::string name;      ///< Attribute name (e.g., "position", "normal")
+    std::string type_name; ///< Attribute type (e.g., "vec3", "vec4")
+    int32_t location;      ///< Attribute location (0-based index)
+  };
+
+  /**
+   * GLSLAttributeParser parses vertex shader source code to extract attribute information.
+   * 
+   * This class provides a convenient C++ interface to parse GLSL vertex shaders and
+   * extract all attribute declarations, including their names, types, and assigned locations.
+   * 
+   * Features:
+   * - Supports both GLSL 100 ES (attribute) and GLSL 300 ES (in) qualifiers
+   * - Handles explicit layout(location = N) qualifiers
+   * - Auto-assigns locations based on declaration order when not explicitly specified
+   * - Compatible with WebGL 1.0 and WebGL 2.0 shaders
+   * 
+   * Example usage:
+   * @code
+   *   std::string vertexShader = R"(
+   *     #version 300 es
+   *     in vec3 position;
+   *     in vec3 normal;
+   *     void main() {
+   *       gl_Position = vec4(position, 1.0);
+   *     }
+   *   )";
+   *   
+   *   auto attributes = GLSLAttributeParser::ParseAttributes(vertexShader);
+   *   for (const auto& attr : attributes) {
+   *     std::cout << attr.name << " at location " << attr.location << std::endl;
+   *   }
+   *   
+   *   // Or get a specific attribute location
+   *   auto location = GLSLAttributeParser::GetAttribLocation(vertexShader, "position");
+   *   if (location.has_value()) {
+   *     std::cout << "position is at location " << location.value() << std::endl;
+   *   }
+   * @endcode
+   */
+  class GLSLAttributeParser
+  {
+  public:
+    /**
+     * Parse GLSL vertex shader source and extract all attribute declarations.
+     * 
+     * @param source The GLSL vertex shader source code as a string.
+     * @returns A vector of GLSLAttribute structs containing attribute metadata.
+     */
+    static inline std::vector<GLSLAttribute> ParseAttributes(const std::string &source)
+    {
+      auto json_str = holocron::webgl::parseGLSLAttributes(source.c_str());
+      std::vector<GLSLAttribute> attributes;
+
+      rapidjson::Document doc;
+      doc.Parse(std::string(json_str).c_str());
+
+      if (!doc.IsArray())
+      {
+        return attributes;
+      }
+
+      attributes.reserve(doc.Size());
+      for (rapidjson::SizeType i = 0; i < doc.Size(); i++)
+      {
+        const auto &attr = doc[i];
+        if (attr.IsObject() && attr.HasMember("name") && attr.HasMember("type_name") && attr.HasMember("location"))
+        {
+          attributes.push_back(GLSLAttribute{
+            attr["name"].GetString(),
+            attr["type_name"].GetString(),
+            attr["location"].GetInt()});
+        }
+      }
+
+      return attributes;
+    }
+
+    /**
+     * Get the location of a specific attribute by name.
+     * 
+     * @param source The GLSL vertex shader source code as a string.
+     * @param name The name of the attribute to look up.
+     * @returns An optional containing the attribute location if found, or std::nullopt if not found.
+     */
+    static inline std::optional<int32_t> GetAttribLocation(const std::string &source, const std::string &name)
+    {
+      auto attributes = ParseAttributes(source);
+      for (const auto &attr : attributes)
+      {
+        if (attr.name == name)
+        {
+          return attr.location;
+        }
+      }
+      return std::nullopt;
+    }
+  };
 }

crates/jsbindings/lib.rs

@@ -1,7 +1,6 @@
 #![allow(unused_variables)]
 #![allow(clippy::uninlined_format_args)]
 #![allow(deprecated)]
-#![feature(concat_idents)]
 
 extern crate ctor;
 extern crate jsar_jsbinding_macro;