opengl-registry 1.0.0

data/lib/opengl/registry/argument.rb

@@ -0,0 +1,60 @@
+module GL
+  class Registry
+
+    ##
+    # Describes an individual argument of an OpenGL function.
+    class Argument < Token
+
+      ##
+      # @return [String] the name of the argument
+      attr_reader :name
+
+      ##
+      # @return [NativeType] the type of the argument.
+      attr_reader :type
+
+      ##
+      # @return [String?] a hint for any length constraints of an argument, such as a C-style array,
+      # @note This may be a numerical value, reference to another "count" argument, etc.
+      attr_reader :length
+
+      ##
+      # Creates a new instance of the {Argument} class.
+      #
+      # @param node [Ox::Element] The XML element defining the instance.
+      def initialize(node)
+        super(node)
+
+        base = nil
+        buffer = ''
+        node.nodes.each do |child|
+
+          # Don't care about comments
+          next if child.is_a?(Ox::Comment)
+
+          # Raw text
+          if child.is_a?(String)
+            buffer << child
+            next
+          end
+
+          # Child node
+          case child.name
+          when Words::PTYPE
+            base = child.text
+            buffer << base
+          when Words::NAME
+            @name = child.text
+          else
+            next
+          end
+        end
+
+        @length = node[Words::LENGTH]
+        group = node[Words::GROUP]
+        @type = NativeType.new(buffer, base, group)
+
+      end
+    end
+  end
+end

data/lib/opengl/registry/enum.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+module GL
+
+  class Registry
+
+    ##
+    # Describes an OpenGL enumeration (constant) value.
+    class Enum < Token
+
+      ##
+      # @return [String] the name of the enumeration member.
+      attr_reader :name
+
+      ##
+      # @return [String] the value of the enumeration, always numerical, typically in hexadecimal format.
+      attr_reader :value
+
+      ##
+      # @return [String?] an alternative name for the value.
+      attr_reader :alias_name
+
+      ##
+      # @return [Symbol] a hint for the enumeration value type (i.e. GLenum, GLuint, GLuint64, etc)
+      attr_reader :type
+
+      ##
+      # @return [Symbol?] an API associated with this enumeration value.
+      attr_reader :api
+
+      ##
+      # @return [Array<String>] an array of names of the groups this enumeration is defined within.
+      attr_reader :groups
+
+      ##
+      # Creates a new instance of the {Enum} class.
+      #
+      # @param node [Ox::Element] The XML element defining the instance.
+      def initialize(node)
+        super(node)
+
+        # Required
+        @name = node[Words::NAME]
+        @value = node[Words::VALUE]
+
+        # Optional
+        @alias_name = node[Words::ALIAS]
+        @api = node[Words::API]&.to_sym
+        @groups = node[Words::GROUP]&.split(',') || []
+
+        @type = case node[Words::TYPE]
+        when Words::U_LONG then :GLuint
+        when Words::U_LONG_LONG then :GLuint64
+        else :GLenum
+        end
+      end
+
+      ##
+      # @return [Integer] the enumeration's value, as an integer.
+      def to_i
+        @value.start_with?('0x') ? @value.hex : @value.to_i
+      end
+    end
+  end
+end

data/lib/opengl/registry/extension.rb

@@ -0,0 +1,23 @@
+module GL
+  class Registry
+
+    ##
+    # Describes an OpenGL extension.
+    class Extension < FeatureProvider
+
+      ##
+      # @return [Array<Symbol>] an array of supported APIs this extension is associated with.
+      attr_reader :supported
+
+      ##
+      # Creates a new instance of the {Extension} class.
+      #
+      # @param node [Ox::Element] The XML element defining the instance.
+      def initialize(node)
+        super(node)
+        supported = node[Words::SUPPORTED]
+        @supported = supported ? supported.split('|').map(&:to_sym) : Array.new
+      end
+    end
+  end
+end

data/lib/opengl/registry/feature.rb

@@ -0,0 +1,48 @@
+module GL
+  class Registry
+
+    ##
+    # Describes a single definition of a item to add/remove from an OpenGL API.
+    #
+    # @note This is a reference for the item only, and is only used to look up the corresponding item's definition.
+    class Feature < Token
+
+      ##
+      # @return [String] the name of the entity.
+      attr_reader :name
+
+      ##
+      # @return [Symbol] the OpenGL API this item is associated with.
+      attr_reader :api
+
+      ##
+      # @return [Symbol] the OpenGL profile this item is associated with.
+      attr_reader :profile
+
+      ##
+      # @return [:enum,:function,:type] a symbol specifying the feature type.
+      attr_reader :type
+
+      ##
+      # Creates a new instance of the {Feature} class.
+      #
+      # @param node [Ox::Element] The XML element defining the instance.
+      # @param api [Symbol?] The OpenGL API this item is associated with.
+      # @param profile [Symbol?] The OpenGL profile this item is associated with.
+      def initialize(node, api, profile)
+        super(node)
+
+        @name = node[Words::NAME]
+        @api = api || :none
+        @profile = profile || :none
+
+        @type = case node.name
+        when Words::ENUM then :enum
+        when Words::COMMAND then :function
+        when Words::TYPE then :type
+        else :unknown
+        end
+      end
+    end
+  end
+end

data/lib/opengl/registry/feature_group.rb

@@ -0,0 +1,38 @@
+module GL
+  class Registry
+
+    ##
+    # Describes a logical grouping of features for an OpenGL API.
+    class FeatureGroup < FeatureProvider
+
+      ##
+      # @return [String] the OpenGL version this feature is associated with.
+      attr_reader :version
+
+      ##
+      # @return [Array<Feature>] an array of features that this instance removes.
+      attr_reader :removals
+
+      ##
+      # Creates a new instance of the {Feature} class.
+      #
+      # @param node [Ox::Element] The XML element defining the instance.
+      def initialize(node)
+        super(node)
+
+        @version = node[Words::NUMBER]
+        @removals = []
+        node.locate('remove').each do |child|
+
+          api = child[Words::API]&.to_sym || @api
+          profile = child[Words::PROFILE]&.to_sym
+
+          child.nodes.each do |item|
+            next unless item.is_a?(Ox::Element)
+            @removals << Feature.new(item, api, profile)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opengl/registry/feature_provider.rb

@@ -0,0 +1,45 @@
+module GL
+  class Registry
+
+    ##
+    # @abstract Base class for objects that add definitions to the API.
+    class FeatureProvider < Token
+
+      ##
+      # @return [Symbol] the name of the API this feature is defined within.
+      attr_reader :api
+
+      ##
+      # @return [String] the name of the feature set.
+      attr_reader :name
+
+      ##
+      # @return [Array<Feature>] an array of features that this instance provides.
+      attr_reader :additions
+
+      ##
+      # Creates a new instance of the {FeatureProvider} class.
+      #
+      # @param node [Ox::Element] The XML element defining the instance.
+      def initialize(node)
+        super(node)
+
+        @api = node[Words::API]&.to_sym || :none
+        @name = node[Words::NAME]
+
+        @additions = []
+        node.locate('require').each do |child|
+
+          api = child[Words::API]&.to_sym || @api
+          profile = child[Words::PROFILE]&.to_sym
+
+          child.nodes.each do |item|
+            next unless item.is_a?(Ox::Element)
+            @additions << Feature.new(item, api, profile)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/opengl/registry/function.rb

@@ -0,0 +1,86 @@
+module GL
+  class Registry
+
+    ##
+    # Describes an OpenGL function.
+    class Function < Token
+
+      ##
+      # @return [String] the name of the function.
+      attr_reader :name
+
+      ##
+      # @return [NativeType] the return type of function.
+      attr_reader :type
+
+      ##
+      # @return [Array<Argument>] an array of arguments for this function.
+      attr_reader :arguments
+
+      ##
+      # @return [String?] an alternative name associated with this function.
+      attr_reader :alias_name
+
+      ##
+      # @return [String?] a "vector equivalent" version of this function that does not use separate parameters.
+      attr_reader :vec_equiv
+
+      ##
+      # Creates a new instance of the {Function} class.
+      #
+      # @param node [Ox::Element] The XML element defining the instance.
+      def initialize(node)
+        super(node)
+
+        @arguments = []
+        node.nodes.each do |child|
+
+          case child.name
+          when Words::PROTO
+            parse_prototype(child)
+          when Words::PARAM
+            @arguments << Argument.new(child)
+          when Words::ALIAS
+            @alias_name = child[Words::NAME]
+          when Words::VECTOR_EQUIVALENT
+            @vec_equiv = child[Words::NAME]
+          else
+            next
+          end
+        end
+      end
+
+      private
+
+      def parse_prototype(node)
+        base = nil
+        buffer = ''
+        node.nodes.each do |child|
+
+          # Don't care about comments
+          next if child.is_a?(Ox::Comment)
+
+          # Raw text
+          if child.is_a?(String)
+            buffer << child
+            next
+          end
+
+          # Child node
+          case child.name
+          when Words::PTYPE
+            base = child.text
+            buffer << base
+          when Words::NAME
+            @name = child.text
+          else
+            next
+          end
+        end
+
+        group = node[Words::GROUP]
+        @type = NativeType.new(buffer, base, group)
+      end
+    end
+  end
+end

data/lib/opengl/registry/group.rb

@@ -0,0 +1,62 @@
+module GL
+  class Registry
+
+    ##
+    # Describes a logical grouping of enumerated values.
+    class Group < Token
+
+      ##
+      # @return [String] the namespace this group belongs within.
+      attr_reader :namespace
+
+      ##
+      # @return [Array<Enum>] an array of enum values that are associated with this group.
+      attr_reader :members
+
+      ##
+      # @return [String?] the name of this grouping.
+      # @note Not all groups are named, and this value may be `nil`.
+      attr_reader :name
+
+      ##
+      # @return [String?] the name of the vendor that defines this value.
+      attr_reader :vendor
+
+      ##
+      # @return [Range?] an end-inclusive range of values this group covers.
+      attr_reader :range
+
+      ##
+      # Creates a new instance of the {Group} class.
+      #
+      # @param node [Ox::Element] The XML element defining the instance.
+      def initialize(node)
+        super(node)
+
+        @namespace = node[Words::NAMESPACE]
+        @name = node[Words::GROUP]
+        type = node[Words::TYPE]
+        @bitmask = type && type == Words::BITMASK
+        @vendor = node[Words::VENDOR]
+
+        first = node[Words::RANGE_START]
+        if first
+          last = node[Words::RANGE_END]
+          @range = Range.new(first.hex, last.hex, false) if last
+        end
+
+        @members = []
+        node.locate('enum').each do |enum|
+          next unless enum.is_a?(Ox::Element)
+          @members << Enum.new(enum)
+        end
+      end
+
+      ##
+      # @return [Boolean] `true` if group members are flags that can be bitwise OR'ed together, otherwise `false`.
+      def bitmask?
+        @bitmask
+      end
+    end
+  end
+end

data/lib/opengl/registry/native_type.rb

@@ -0,0 +1,59 @@
+
+module GL
+  class Registry
+
+    ##
+    # Describes the native type for a return or parameter value.
+    class NativeType
+
+      ##
+      # @return [String] the full native type, including constant constraints, pointer symbols, etc.
+      # @note This is essentially the "raw" and fully-qualified type as it would appear in the C language.
+      attr_reader :type
+
+      ##
+      # @return [Symbol] the basic type, excluding any constant constraints, pointer symbols, etc. as a Symbol.
+      attr_reader :base
+
+      ##
+      # @return [String?] a group that is associated with this type.
+      attr_reader :group
+
+      ##
+      # Creates a new instance fo the {NativeType} class.
+      #
+      # @param type [String] The full native type, including constant constraints, pointer symbols, etc.
+      # @param base [String?] The basic type, excluding any constant constraints, pointer symbols, etc.
+      # @param group [String?] A group that is associated with this type.
+      def initialize(type, base, group)
+        @type = type.strip
+        @base = base ? base.to_sym : :GLvoid
+        @group = group
+      end
+
+      ##
+      # @return [Boolean] `true` if this a C-style pointer type, otherwise `false`.
+      def pointer?
+        @type.include?('*')
+      end
+
+      ##
+      # @return [Boolean] `true` if value is a C-style pointer that can not be modified, otherwise `false`.
+      def const?
+        /^const /.match?(@type)
+      end
+
+      ##
+      # @return [Boolean] `true` if value is a C-style pointer that may be modified, otherwise `false`.
+      def out?
+        @type.include?('*') && !/\bconst\b/.match?(@type)
+      end
+
+      ##
+      # @return [String] the string representation of this object.
+      def to_s
+        @type
+      end
+    end
+  end
+end