VectorType.cs

Go to the documentation of this file.

// Copyright (c) 2014 Silicon Studio Corp. (http://siliconstudio.co.jp)
// This file is distributed under GPL v3. See LICENSE.md for details.
using System;

namespace SiliconStudio.Shaders.Ast
{
    /// <summary>
    /// Base class for all vector types
    /// </summary>
    public class VectorType : GenericType<TypeBase, Literal>
    {
        #region Constants and Fields

        /// <summary>
        /// A Int2
        /// </summary>
        public static readonly VectorType Int2 = new VectorType(ScalarType.Int, 2);

        /// <summary>
        /// A Int3
        /// </summary>
        public static readonly VectorType Int3 = new VectorType(ScalarType.Int, 3);

        /// <summary>
        /// A Int4
        /// </summary>
        public static readonly VectorType Int4 = new VectorType(ScalarType.Int, 4);

        /// <summary>
        /// A UInt2
        /// </summary>
        public static readonly VectorType UInt2 = new VectorType(ScalarType.UInt, 2);

        /// <summary>
        /// A UInt3
        /// </summary>
        public static readonly VectorType UInt3 = new VectorType(ScalarType.UInt, 3);

        /// <summary>
        /// A UInt4
        /// </summary>
        public static readonly VectorType UInt4 = new VectorType(ScalarType.UInt, 4);

        /// <summary>
        /// A Float2
        /// </summary>
        public static readonly VectorType Float2 = new VectorType(ScalarType.Float, 2);

        /// <summary>
        /// A Float3
        /// </summary>
        public static readonly VectorType Float3 = new VectorType(ScalarType.Float, 3);

        /// <summary>
        /// A Float4
        /// </summary>
        public static readonly VectorType Float4 = new VectorType(ScalarType.Float, 4);

        /// <summary>
        /// A Double2
        /// </summary>
        public static readonly VectorType Double2 = new VectorType(ScalarType.Double, 2);

        /// <summary>
        /// A Double3
        /// </summary>
        public static readonly VectorType Double3 = new VectorType(ScalarType.Double, 3);

        /// <summary>
        /// A Double4
        /// </summary>
        public static readonly VectorType Double4 = new VectorType(ScalarType.Double, 4);


        #endregion

        #region Constructors and Destructors

        /// <summary>
        ///   Initializes a new instance of the <see cref = "VectorType" /> class.
        /// </summary>
        public VectorType()
            : base("vector")
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="VectorType"/> class.
        /// </summary>
        /// <param name="type">
        /// The type.
        /// </param>
        /// <param name="dimension">
        /// The dimension.
        /// </param>
        public VectorType(ScalarType type, int dimension)
            : this()
        {
            Type = type;
            Dimension = dimension;
        }

        #endregion

        #region Public Properties

        /// <summary>
        ///   Gets or sets the dimension.
        /// </summary>
        /// <value>
        ///   The dimension.
        /// </value>
        public int Dimension
        {
            get
            {
                return (int)((Literal)Parameters[1]).Value;
            }

            set
            {
                Parameters[1] = new Literal(value);
            }
        }

        /// <summary>
        ///   Gets or sets the type.
        /// </summary>
        /// <value>
        ///   The type.
        /// </value>
        public TypeBase Type
        {
            get
            {
                return (TypeBase)Parameters[0];
            }

            set
            {
                Parameters[0] = value;
            }
        }

        #endregion

        /// <inheritdoc/>
        public bool Equals(VectorType other)
        {
            return base.Equals(other);
        }

        /// <inheritdoc/>
        public override bool Equals(object obj)
        {
            if (ReferenceEquals(null, obj))
            {
                return false;
            }
            if (ReferenceEquals(this, obj))
            {
                return true;
            }
            return Equals(obj as VectorType);
        }

        /// <inheritdoc/>
        public override int GetHashCode()
        {
            return base.GetHashCode();
        }

        /// <summary>
        /// Implements the operator ==.
        /// </summary>
        /// <param name="left">The left.</param>
        /// <param name="right">The right.</param>
        /// <returns>
        /// The result of the operator.
        /// </returns>
        public static bool operator ==(VectorType left, VectorType right)
        {
            return Equals(left, right);
        }

        /// <summary>
        /// Implements the operator !=.
        /// </summary>
        /// <param name="left">The left.</param>
        /// <param name="right">The right.</param>
        /// <returns>
        /// The result of the operator.
        /// </returns>
        public static bool operator !=(VectorType left, VectorType right)
        {
            return !Equals(left, right);
        }
    }
}