#pragma region CPL License
/*
Nuclex Native Framework
Copyright (C) 2002-2013 Nuclex Development Labs

This library is free software; you can redistribute it and/or
modify it under the terms of the IBM Common Public License as
published by the IBM Corporation; either version 1.0 of the
License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
IBM Common Public License for more details.

You should have received a copy of the IBM Common Public
License along with this library
*/
#pragma endregion // CPL License

#ifndef NUCLEX_GRAPHICS_INTROSPECTION_INPUTPARAMETER_H
#define NUCLEX_GRAPHICS_INTROSPECTION_INPUTPARAMETER_H

#include "Nuclex/Graphics/Config.h"
#include "BuiltInSemantic.h"
#include "ParameterType.h"

#include <cstddef>
#include <string>

namespace Nuclex { namespace Graphics { namespace Introspection {

  // ------------------------------------------------------------------------------------------- //

  /// <summary>Describes an input parameter the shader is expecting</summary>
  struct InputParameter {

    /// <summary>Indicates how the input parameter is going to be used</summary>
    /// <remarks>
    ///   This is used for mapping of vertex elements to shader parameters. Commonly
    ///   used semantics are &quot;POSITION&quot; or &quot;COLOR&quot;. The semantic
    ///   name is merely used for lookup purposes and could really be anything.
    /// </remarks>
    public: std::string Semantic;

    /// <summary>Used to differentiate between parameters with the same semantic</summary>
    /// <remarks>
    ///   It may happen that there are multiple parameters with the same semantic, such
    ///   as when working with multiple texture coordinate pairs. Via the index it is
    ///   possible to differentiate between these parameters. Shaders usually declare
    ///   such inputs as &quot;TEXTURECOORDINATES0&quot;, &quot;TEXTURECOORDINATES1&quot;
    ///   and so on.
    /// </remarks>
    public: std::size_t SemanticIndex;

    /// <summary>Index of the register that is holding this parameter</summary>
    /// <remarks>
    ///   Which shader register this input parameter will be stored in. On the machine
    ///   code level, shaders have a number of &quot;slots&quot; in which inputs are
    ///   stored. Shader model 2.0 requires 16 such slots to be available.
    /// </remarks>
    public: std::size_t RegisterIndex;

    /// <summary>Semantic of the parameter in a machine-understandable format</summary>
    /// <remarks>
    ///   This is a special indication of the parameter's semantic for the pipeline which
    ///   can be used to adjust the behavior accordingly (whereas the semantic name
    ///   stored as a string is free of any interpretation).
    /// </remarks>
    public: BuiltInSemantic::Enum BuiltInSemantic;

    /// <summary>The type of the parameter</summary>
    /// <remarks>
    ///   <para>
    ///     Each shader parameter consists of 4 components, each holding a separate value
    ///     (though not all components may be used). A 3D position wouldn't be passed as
    ///     3 separate parameters but as one parameter with 3 components (x, y, z).
    ///     Similarly a color would be passed as 1 parameter with 4 components (r, g, b, a).
    ///   </para>
    ///   <para>
    ///     All components are required to be of the same type. Mixing integers and
    ///     floating point values in the components of a single parameter is not
    ///     allowed, thus the type is a property of the parameter, not the component.
    ///   </para>
    /// </remarks>
    public: ParameterType::Enum Type;

    /// <summary>Which components of this parameter get used</summary>
    /// <remarks>
    ///   As described in the <see cref="Type" /> field, each parameter can carry up
    ///   to 4 distinct values usually used to transport either x, y, z, w for positions
    ///   or r, g, b, a for colors. Not all of the components may be used all the time,
    ///   however, so this mask indicates which components the shader actually consumes.
    /// </remarks>
    public: std::size_t UsedComponents;

  };

  // ------------------------------------------------------------------------------------------- //

}}} // namespace Nuclex::Graphics::Introspection

#endif // NUCLEX_GRAPHICS_INTROSPECTION_INPUTPARAMETER_H