Misaki.HighPerformance/Misaki.HighPerformance.Mathematics/float2.tt

<#@ template debug="false" hostspecific="false" language="C#" #>
<#@ assembly name="System.Core" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ include file="Utilities.ttinclude" #>
<#@ output extension=".gen.cs" #>
using System.Runtime.CompilerServices;

namespace Misaki.HighPerformance.Mathematics;

<#
var dimension = 2;
var components = new[] { "x", "y" };
var structName = $"float{dimension}";

#>
public struct <#= structName #>
{
<# for(int i = 0; i < dimension; i++) { #>
    public float <#= components[i] #>;
<# } #>

    public <#= structName #>(float value)
    {
<# for(int i = 0; i < dimension; i++) { #>
        this.<#= components[i] #> = value;
<# } #>
    }

    public <#= structName #>(<#= string.Join(", ", components.Take(dimension).Select(c => $"float {c}")) #>)
    {
<# for(int i = 0; i < dimension; i++) { #>
        this.<#= components[i] #> = <#= components[i] #>;
<# } #>
    }

<# foreach (var otherDim in dimensions.Where(d => d != dimension))
{
    string otherStructName = $"float{otherDim}";
        
    if (otherDim < dimension)
    {
#>
    public <#= structName #>(<#= otherStructName #> value)
    {
<# for(int i = 0; i < Math.Min(dimension, otherDim); i++) { #>
        this.<#= components[i] #> = value.<#= components[i] #>;
<# 
    }

    for(int i = otherDim; i < dimension; i++) { 
#>
        this.<#= components[i] #> = 0.0f;
<# } #>
    }

<# }
else
{ #>
    public <#= structName #>(<#= otherStructName #> value)
    {
<# 
    for(int i = 0; i < dimension; i++) { 
#>
        this.<#= components[i] #> = value.<#= components[i] #>;
<# } #>
    }
<# 
    }
}
#>

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static <#= structName #> operator +(<#= structName #> lhs, <#= structName #> rhs)
    {
        return (lhs.AsVector128() + rhs.AsVector128()).AsFloat<#= dimension #>();
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static <#= structName #> operator +(<#= structName #> lhs, float rhs)
    {
        return lhs + new <#= structName #>(rhs);
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static <#= structName #> operator -(<#= structName #> lhs, <#= structName #> rhs)
    {
        return (lhs.AsVector128() - rhs.AsVector128()).AsFloat<#= dimension #>();
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static <#= structName #> operator -(<#= structName #> lhs, float rhs)
    {
        return lhs - new <#= structName #>(rhs);
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static <#= structName #> operator *(<#= structName #> lhs, <#= structName #> rhs)
    {
        return (lhs.AsVector128() * rhs.AsVector128()).AsFloat<#= dimension #>();
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static <#= structName #> operator *(<#= structName #> lhs, float rhs)
    {
        return (lhs.AsVector128() * rhs).AsFloat<#= dimension #>();
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static <#= structName #> operator /(<#= structName #> lhs, <#= structName #> rhs)
    {
        return (lhs.AsVector128() / rhs.AsVector128()).AsFloat<#= dimension #>();
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static <#= structName #> operator /(<#= structName #> lhs, float rhs)
    {
        return (lhs.AsVector128() / rhs).AsFloat<#= dimension #>();
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static <#= structName #> operator -(<#= structName #> value)
    {
        return (-value.AsVector128()).AsFloat<#= dimension #>();
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static bool operator ==(<#= structName #> lhs, <#= structName #> rhs)
    {
        return lhs.AsVector128() == rhs.AsVector128();
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static bool operator !=(<#= structName #> lhs, <#= structName #> rhs)
    {
        return !(lhs == rhs);
    }

<#
var validComponents = components.Take(dimension).ToArray();
var swizzles = GenerateSwizzles(validComponents, 4);
foreach (var swizzle in swizzles)
{
    var targetDim = swizzle.Length;
    var targetStruct = $"float{targetDim}";
#>
    public readonly <#= targetStruct #> <#= swizzle #> 
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        get => new <#= targetStruct #>(<#= string.Join(", ", swizzle.Select(c => $"this.{c}")) #>);
    }

<#
}
#>
    public override readonly string ToString()
    {
        return $"(<#= string.Join(", ", components.Take(dimension).Select(c => $"{c}: {{this.{c}}}")) #>)";
    }
}