public static VertexAttribPointerType GLTypeFromLayout(ShaderDataType type)
{
switch (type)
{
case ShaderDataType.None:
throw new Exception("ShaderDataType is none in vertex array.");
case ShaderDataType.Float:
case ShaderDataType.Float2:
case ShaderDataType.Float3:
case ShaderDataType.Float4:
case ShaderDataType.Mat3:
case ShaderDataType.Mat4:
return(VertexAttribPointerType.Float);
case ShaderDataType.Int:
case ShaderDataType.Int2:
case ShaderDataType.Int3:
case ShaderDataType.Int4:
return(VertexAttribPointerType.Int);
case ShaderDataType.UnsignedByte:
case ShaderDataType.UnsignedByte4:
return(VertexAttribPointerType.UnsignedByte);
case ShaderDataType.Bool:
throw new Exception("ShaderDataType is bool in vertex array.");
default:
throw new Exception("ShaderDataType is null in vertex array.");
}
}
private static uint GetSizeForType(ShaderDataType type)
{
switch (type)
{
case ShaderDataType.Float: return(4);
case ShaderDataType.Float2: return(4 * 2);
case ShaderDataType.Float3: return(4 * 3);
case ShaderDataType.Float4: return(4 * 4);
case ShaderDataType.Mat3: return(4 * 3 * 3);
case ShaderDataType.Mat4: return(4 * 4 * 4);
case ShaderDataType.Int: return(4);
case ShaderDataType.Int2: return(4 * 2);
case ShaderDataType.Int3: return(4 * 3);
case ShaderDataType.Int4: return(4 * 4);
case ShaderDataType.Bool: return(1);
}
// THIS SHOULD NEVER HAPPEN
return(0);
}
private static object _parseUniformValue(YamlNode node, ShaderDataType dataType)
{
switch (dataType)
{
case ShaderDataType.Bool:
return node.AsBool();
case ShaderDataType.Int:
return node.AsInt();
case ShaderDataType.IVec2:
return node.AsVector2i();
case ShaderDataType.Float:
return node.AsFloat();
case ShaderDataType.Vec2:
return node.AsVector2();
case ShaderDataType.Vec3:
return node.AsVector3();
case ShaderDataType.Vec4:
try
{
return node.AsColor();
}
catch
{
return node.AsVector4();
}
default:
throw new NotSupportedException("Unsupported uniform type.");
}
}
private VertexAttribType ShaderDataTypeToOpenGLBaseType(ShaderDataType type)
{
switch (type)
{
case ShaderDataType.None:
return(0);
case ShaderDataType.Float:
case ShaderDataType.Float2:
case ShaderDataType.Float3:
case ShaderDataType.Float4:
case ShaderDataType.Mat3:
case ShaderDataType.Mat4:
return(VertexAttribType.Float);
case ShaderDataType.Int:
case ShaderDataType.Int2:
case ShaderDataType.Int3:
case ShaderDataType.Int4:
return(VertexAttribType.Int);
default:
throw new ArgumentOutOfRangeException(nameof(type), type, null);
}
}
public static uint ToOpenGL(this ShaderDataType dataType)
{
switch (dataType)
{
case ShaderDataType.Float: return(GL.FLOAT);
case ShaderDataType.Float2: return(GL.FLOAT);
case ShaderDataType.Float3: return(GL.FLOAT);
case ShaderDataType.Float4: return(GL.FLOAT);
case ShaderDataType.Mat3: return(GL.FLOAT);
case ShaderDataType.Mat4: return(GL.FLOAT);
case ShaderDataType.Int: return(GL.UNSIGNED_INT);
case ShaderDataType.Int2: return(GL.UNSIGNED_INT);
case ShaderDataType.Int3: return(GL.UNSIGNED_INT);
case ShaderDataType.Int4: return(GL.UNSIGNED_INT);
case ShaderDataType.Bool: return(GL.UNSIGNED_INT);
}
return(0);
}
public ShaderAttribute(ShaderAttributeName nameParam, ShaderDataType dataTypeParam)
{
name = nameParam;
dataType = dataTypeParam;
location = -1;
elementSize = -1;
}
/// <summary>
/// Converts to OpenGL data type.
/// </summary>
/// <param name="type">The type.</param>
/// <returns>VertexAttribType.</returns>
public static VertexAttribType ToOpenGLDataType(ShaderDataType type)
{
switch (type)
{
case ShaderDataType.Float:
case ShaderDataType.Float2:
case ShaderDataType.Float3:
case ShaderDataType.Float4:
case ShaderDataType.Mat3:
case ShaderDataType.Mat4:
return(VertexAttribType.Float);
case ShaderDataType.Int:
case ShaderDataType.Int2:
case ShaderDataType.Int3:
case ShaderDataType.Int4:
return(VertexAttribType.Int);
case ShaderDataType.Bool:
return(VertexAttribType.Byte);
default:
Log.Instance.Error("Unknown ShaderDataType");
return(0);
}
}
public static uint Size(this ShaderDataType dataType)
{
return(dataType switch
{
ShaderDataType.Int => sizeof(int),
ShaderDataType.IVec2 => 2 * sizeof(int),
ShaderDataType.IVec3 => 3 * sizeof(int),
ShaderDataType.IVec4 => 4 * sizeof(int),
ShaderDataType.UInt => sizeof(uint),
ShaderDataType.UVec2 => 2 * sizeof(uint),
ShaderDataType.UVec3 => 3 * sizeof(uint),
ShaderDataType.UVec4 => 4 * sizeof(uint),
ShaderDataType.Float => sizeof(float),
ShaderDataType.Vec2 => 2 * sizeof(float),
ShaderDataType.Vec3 => 3 * sizeof(float),
ShaderDataType.Vec4 => 4 * sizeof(float),
ShaderDataType.Mat2 => 2 * 2 * sizeof(float),
ShaderDataType.Mat3 => 3 * 3 * sizeof(float),
ShaderDataType.Mat4 => 4 * 4 * sizeof(float),
ShaderDataType.Double => sizeof(double),
ShaderDataType.DVec2 => 2 * sizeof(double),
ShaderDataType.DVec3 => 3 * sizeof(double),
ShaderDataType.DVec4 => 4 * sizeof(double),
_ => throw new FormatException($"Unrecognized data type {dataType}")
});
public static uint ShaderDataTypeSize(ShaderDataType type)
{
switch (type)
{
case ShaderDataType.Float: return(sizeof(float));
case ShaderDataType.Float2: return(sizeof(float) * 2);
case ShaderDataType.Float3: return(sizeof(float) * 3);
case ShaderDataType.Float4: return(sizeof(float) * 4);
case ShaderDataType.Mat3: return(sizeof(float) * 3 * 3);
case ShaderDataType.Mat4: return(sizeof(float) * 4 * 4);
case ShaderDataType.Int: return(sizeof(float));
case ShaderDataType.Int2: return(sizeof(float) * 2);
case ShaderDataType.Int3: return(sizeof(float) * 3);
case ShaderDataType.Int4: return(sizeof(float) * 4);
case ShaderDataType.Bool: return(sizeof(bool));
case ShaderDataType.None: return(0);
default:
Logger.Assert(false, "Unknown ShaderDataType");
return(0);
}
}
public ShaderAttribute(ShaderAttributeName nameParam, ShaderDataType dataTypeParam, int locationParam, int elementSizeParam)
{
name = nameParam;
dataType = dataTypeParam;
location = locationParam;
elementSize = elementSizeParam;
}
BufferElement(string name, ShaderDataType type)
{
Name = name;
Type = type;
Size = GetSizeForType(type);
Offset = 0;
}
public string GetDataTypeString(ShaderDataType type)
{
switch (type)
{
case ShaderDataType.Float:
return("Float");
case ShaderDataType.Float2:
return("Float2");
case ShaderDataType.Float3:
return("Float3");
case ShaderDataType.Float4:
return("Float4");
case ShaderDataType.Mat4:
return("Mat4");
case ShaderDataType.Texture2D:
return("Texture2D");
case ShaderDataType.TextureCube:
return("TextureCubeMap");
case ShaderDataType.InvalidType:
return("Invalid");
default:
return("(No name for this data type)");
}
}
public static GLEnum ShaderDataTypeToOpenGLBaseType(ShaderDataType type)
{
switch (type)
{
case ShaderDataType.Float:
case ShaderDataType.Float2:
case ShaderDataType.Float3:
case ShaderDataType.Float4:
case ShaderDataType.Mat3:
case ShaderDataType.Mat4:
return(GLEnum.Float);
case ShaderDataType.Int:
case ShaderDataType.Int2:
case ShaderDataType.Int3:
case ShaderDataType.Int4:
return(GLEnum.Int);
case ShaderDataType.Bool:
return(GLEnum.Bool);
default:
break;
}
return(0);
}
/// <summary>
/// Gets the size of the shader data type.
/// </summary>
/// <param name="type">The shader type.</param>
/// <returns>System.Int32.</returns>
public static int ShaderDataTypeSize(ShaderDataType type)
{
switch (type)
{
case ShaderDataType.Int:
case ShaderDataType.Float:
return(4);
case ShaderDataType.Int2:
case ShaderDataType.Float2:
return(4 * 2);
case ShaderDataType.Int3:
case ShaderDataType.Float3:
return(4 * 3);
case ShaderDataType.Int4:
case ShaderDataType.Float4:
return(4 * 4);
case ShaderDataType.Mat3:
return(4 * 3 * 3);
case ShaderDataType.Mat4:
return(4 * 4 * 4);
case ShaderDataType.Bool:
return(1);
default:
Log.Instance.Error("Unknown ShaderDataType");
return(0);
}
}
public ShaderSizeInfo GetTypeSizeInfo(ShaderDataType type)
{
int bt = MeshData.BytesPerFloat;
ShaderSizeInfo result;
switch (type)
{
case ShaderDataType.Float:
result = new ShaderSizeInfo(bt, 1);
break;
case ShaderDataType.Float2:
result = new ShaderSizeInfo(bt * 2, 2);
break;
case ShaderDataType.Float3:
result = new ShaderSizeInfo(bt * 3, 3);
break;
case ShaderDataType.Float4:
result = new ShaderSizeInfo(bt * 4, 4);
break;
case ShaderDataType.Mat4:
result = new ShaderSizeInfo(bt * 16, 16);
break;
default:
result = new ShaderSizeInfo(0, 0);
break;
}
return(result);
}
// kinda useless
public static int ShaderDataTypeToBaseType(ShaderDataType type)
{
switch (type)
{
case ShaderDataType.Float: return(GL_FLOAT);
case ShaderDataType.Float2: return(GL_FLOAT);
case ShaderDataType.Float3: return(GL_FLOAT);
case ShaderDataType.Float4: return(GL_FLOAT);
case ShaderDataType.Mat3: return(GL_FLOAT);
case ShaderDataType.Mat4: return(GL_FLOAT);
case ShaderDataType.Int: return(GL_INT);
case ShaderDataType.Int2: return(GL_INT);
case ShaderDataType.Int3: return(GL_INT);
case ShaderDataType.Int4: return(GL_INT);
case ShaderDataType.Bool: return(GL_BOOL);
}
Log.Core.Error("unknown shader data type");
return(0);
}
private static UniformType ShaderDataTypeToUniformTypeMapper(ShaderDataType shaderDataType)
{
switch (shaderDataType)
{
case ShaderDataType.None: return(0);
case ShaderDataType.Float: return(UniformType.Float);
case ShaderDataType.Float2: return(UniformType.FloatVec2);
case ShaderDataType.Float3: return(UniformType.FloatVec3);
case ShaderDataType.Float4: return(UniformType.FloatVec4);
case ShaderDataType.Mat3: return(UniformType.FloatMat3);
case ShaderDataType.Mat4: return(UniformType.FloatMat4);
case ShaderDataType.Int: return(UniformType.Int);
case ShaderDataType.Int2: return(UniformType.IntVec2);
case ShaderDataType.Int3: return(UniformType.IntVec3);
case ShaderDataType.Int4: return(UniformType.IntVec4);
case ShaderDataType.IntSamplerArr: return(UniformType.Sampler2D);
case ShaderDataType.Bool: return(UniformType.Bool);
default:
Logger.Assert(false, "Unknown ShaderDataType");
return(0);
}
}
public static uint ShaderDataTypeSize(ShaderDataType type)
{
switch (type)
{
case ShaderDataType.Float:
case ShaderDataType.Int: return(4);
case ShaderDataType.Float2:
case ShaderDataType.Int2: return(4 * 2);
case ShaderDataType.Float3:
case ShaderDataType.Int3: return(4 * 3);
case ShaderDataType.Float4:
case ShaderDataType.Int4: return(4 * 4);
case ShaderDataType.Mat3: return(4 * 3 * 3);
case ShaderDataType.Mat4: return(4 * 4 * 4);
case ShaderDataType.Bool: return(1);
default:
Debug.Assert(false, "Unknown shader data type");
break;
}
return(0);
}
private static uint ShaderDataTypeSize(ShaderDataType type)
{
switch (type)
{
case ShaderDataType.Float: return(4);
case ShaderDataType.Float2: return(4 * 2);
case ShaderDataType.Float3: return(4 * 3);
case ShaderDataType.Float4: return(4 * 4);
case ShaderDataType.Mat3: return(4 * 3 * 3);
case ShaderDataType.Mat4: return(4 * 4 * 4);
case ShaderDataType.Int: return(4);
case ShaderDataType.Int2: return(4 * 2);
case ShaderDataType.Int3: return(4 * 3);
case ShaderDataType.Int4: return(4 * 4);
case ShaderDataType.Bool: return(1);
}
Log.Core.Error("unknown shader data type given to buffer element");
return(0);
}
private static VertexAttribPointerType ShaderDataTypeToOpenGLBaseType(ShaderDataType type)
{
switch (type)
{
case ShaderDataType.Float:
case ShaderDataType.Float2:
case ShaderDataType.Float3:
case ShaderDataType.Float4:
case ShaderDataType.Mat3:
case ShaderDataType.Mat4: return(VertexAttribPointerType.Float);
case ShaderDataType.Int:
case ShaderDataType.Int2:
case ShaderDataType.Int3:
case ShaderDataType.Int4: return(VertexAttribPointerType.Int);
case ShaderDataType.Bool: return(VertexAttribPointerType.Byte);
case ShaderDataType.None: return(0);
default:
Logger.Assert(false, "Unknown ShaderDataType");
return(0);
}
}
private int GetShaderDataTypeSize(ShaderDataType datatype)
{
switch (datatype)
{
case ShaderDataType.Float: return(4);
case ShaderDataType.Float2: return(4 * 2);
case ShaderDataType.Float3: return(4 * 3);
case ShaderDataType.Float4: return(4 * 4);
case ShaderDataType.Mat3: return(4 * 3 * 3);
case ShaderDataType.Mat4: return(4 * 4 * 4);
case ShaderDataType.Int: return(4);
case ShaderDataType.Int2: return(4 * 2);
case ShaderDataType.Int3: return(4 * 3);
case ShaderDataType.Int4: return(4 * 4);
case ShaderDataType.Bool: return(1);
}
return(0);
}
public ShaderAttribute(int index, string name, ShaderAttributeDirection direction, ShaderDataType dataType, ShaderLayoutQualifier[] qualifiers)
{
Name = name;
Direction = direction;
DataType = dataType;
layout = new ShaderLayout(index, qualifiers);
}
/// <summary>
/// Initializes a new instance of the <see cref="BufferElement"/> struct.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="name">The name.</param>
/// <param name="normalized">if set to <c>true</c> [normalized].</param>
/// <exception cref="ArgumentNullException"></exception>
public BufferElement(ShaderDataType type, string name, bool normalized = false)
{
Name = name ?? throw new ArgumentNullException();
Type = type;
Size = ShaderDataTypeSize(type);
Offset = 0;
Normalized = normalized;
}
public BufferElement(ShaderDataType type, string name, bool normalized = false)
{
Name = name;
Type = type;
Size = ShaderDataTypeHelper.ShaderDataTypeSize(type);
Offset = 0;
Normalized = normalized;
}
public BufferElement(string name, ShaderDataType type, uint offset, bool normalized = false)
{
Name = name;
Type = type;
Size = ShaderDataTypeSize(type);
Offset = offset;
Normalized = normalized;
}
public void CreateBufferElement(ShaderDataType type, int size)
{
var bufferElement = new BufferElement(type, "Test");
Assert.Equal(size, bufferElement.Size);
Assert.Equal("Test", bufferElement.Name);
Assert.False(bufferElement.Normalized);
}
public ShaderFunctionDefinition(string name, ShaderDataType returnType,
IReadOnlyList <ShaderFunctionParameter> parameters, string body)
{
Name = name;
ReturnType = returnType;
Parameters = parameters;
Body = body;
}
public BufferElement(string name, ShaderDataType type)
{
Name = name;
Type = type;
Size = ShaderDataTypeSize(type);
Offset = 0;
Normalized = false;
}
public ShaderElementInfo(ShaderDataType dataType, List <int> dimensions, int size, int subElementCount, int subElementSize, ShaderStructureType strucType)
{
DataType = dataType;
Dimensions = dimensions.AsReadOnly();
SizeOf = size;
SubElementCount = subElementCount;
SubElementSizeOf = subElementSize;
StructureType = strucType;
}
public BufferElement(ShaderDataType type, string name, bool normalized = false, uint divisor = 0)
{
this.name = name;
this.type = type;
this.size = ShaderDataTypeSize(type);
this.offset = 0;
this.normalized = normalized;
this.divisor = divisor;
}
