Gottfried/glitchy-engine-beef
1
0
Fork 0
mirror of https://github.com/aharabada/glitchy-engine-beef.git synced 2026-09-05 13:01:52 +00:00
Code Issues Packages Projects Releases Wiki Activity

Transitioned from VectorX to floatX

Browse Source 
And some trying to update Rigidbody when transform changes
This commit is contained in:
Simon Lübeß
2023-06-25 02:47:33 +02:00
parent 5f5da2ed35
commit 9e1f648aa0
49 changed files with 1281 additions and 871 deletions
Download Patch File Download Diff File Expand all files Collapse all files
GlitchyEditor/src/Assets/MaterialAssetLoader.bf
+24 -24
View File
@@ -113,25 +113,25 @@ class MaterialAssetPropertiesEditor : AssetPropertiesEditor
if (variable.Columns == 3)
{
material.GetVariable<Vector3>(variable.Name, var value);
material.GetVariable<float3>(variable.Name, var value);
value = (Vector3)ColorRGB.LinearToSRGB((ColorRGB)value);
value = (float3)ColorRGB.LinearToSRGB((ColorRGB)value);
if (ImGui.ColorEdit3(displayName.Ptr, *(float[3]*)&value))
{
value = (Vector3)ColorRGB.SRgbToLinear((ColorRGB)value);
value = (float3)ColorRGB.SRgbToLinear((ColorRGB)value);
material.SetVariable(variable.Name, value);
}
}
else if (variable.Columns == 4)
{
material.GetVariable<Vector4>(variable.Name, var value);
material.GetVariable<float4>(variable.Name, var value);
value = (Vector4)ColorRGBA.LinearToSRGB((ColorRGBA)value);
value = (float4)ColorRGBA.LinearToSRGB((ColorRGBA)value);
if (ImGui.ColorEdit4(displayName.Ptr, *(float[4]*)&value))
{
value = (Vector4)ColorRGBA.SRgbToLinear((ColorRGBA)value);
value = (float4)ColorRGBA.SRgbToLinear((ColorRGBA)value);
material.SetVariable(variable.Name, value);
}
}
@@ -154,28 +154,28 @@ class MaterialAssetPropertiesEditor : AssetPropertiesEditor
if (ImGui.EditVector<1>(displayName, ref *(float[1]*)&value, .(), 0.1f, 100.0f, minV, maxV))
material.SetVariable(variable.Name, value);
case 2:
material.GetVariable<Vector2>(variable.Name, var value);
material.GetVariable<float2>(variable.Name, var value);
Vector2 minV = hasMin ? min.Get<Vector2>() : .(float.MinValue);
Vector2 maxV = hasMax ? max.Get<Vector2>() : .(float.MaxValue);
float2 minV = hasMin ? min.Get<float2>() : (float2)float.MinValue;
float2 maxV = hasMax ? max.Get<float2>() : (float2)float.MaxValue;
if (ImGui.EditVector2(displayName, ref value, .Zero, 0.1f, 100.0f, minV, maxV))
if (ImGui.Editfloat2(displayName, ref value, .Zero, 0.1f, 100.0f, minV, maxV))
material.SetVariable(variable.Name, value);
case 3:
material.GetVariable<Vector3>(variable.Name, var value);
material.GetVariable<float3>(variable.Name, var value);
Vector3 minV = hasMin ? min.Get<Vector3>() : .(float.MinValue);
Vector3 maxV = hasMax ? max.Get<Vector3>() : .(float.MaxValue);
float3 minV = hasMin ? min.Get<float3>() : (float3)float.MinValue;
float3 maxV = hasMax ? max.Get<float3>() : (float3)float.MaxValue;
if (ImGui.EditVector3(displayName, ref value, .Zero, 0.1f, 100.0f, minV, maxV))
if (ImGui.Editfloat3(displayName, ref value, .Zero, 0.1f, 100.0f, minV, maxV))
material.SetVariable(variable.Name, value);
case 4:
material.GetVariable<Vector4>(variable.Name, var value);
material.GetVariable<float4>(variable.Name, var value);
Vector4 minV = hasMin ? min.Get<Vector4>() : .(float.MinValue);
Vector4 maxV = hasMax ? max.Get<Vector4>() : .(float.MaxValue);
float4 minV = hasMin ? min.Get<float4>() : (float4)float.MinValue;
float4 maxV = hasMax ? max.Get<float4>() : (float4)float.MaxValue;
if (ImGui.EditVector4(displayName, ref value, .Zero, 0.1f, 100.0f, minV, maxV))
if (ImGui.Editfloat4(displayName, ref value, .Zero, 0.1f, 100.0f, minV, maxV))
material.SetVariable(variable.Name, value);
}
}
@@ -199,9 +199,9 @@ class MaterialAssetLoaderConfig : AssetLoaderConfig
public enum VariableValue
{
case Float(float Value);
case Float2(Vector2 Value);
case Float3(Vector3 Value);
case Float4(Vector4 Value);
case Float2(float2 Value);
case Float3(float3 Value);
case Float4(float4 Value);
case Int(int Value);
case Int2(Int2 Value);
case Int3(Int3 Value);
@@ -450,13 +450,13 @@ class MaterialAssetLoader : IAssetLoader, IAssetSaver //, IReloadingAssetLoader
material.GetVariable<float>(variable.Name, let value);
variableValue = .Float(value);
case 2:
material.GetVariable<Vector2>(variable.Name, let value);
material.GetVariable<float2>(variable.Name, let value);
variableValue = .Float2(value);
case 3:
material.GetVariable<Vector3>(variable.Name, let value);
material.GetVariable<float3>(variable.Name, let value);
variableValue = .Float3(value);
case 4:
material.GetVariable<Vector4>(variable.Name, let value);
material.GetVariable<float4>(variable.Name, let value);
variableValue = .Float4(value);
}
}
GlitchyEditor/src/EditWindows/ComponentEditWindow.bf
+37 -21
View File
@@ -160,16 +160,32 @@ namespace GlitchyEditor.EditWindows
textWidth += ImGui.GetStyle().FramePadding.x * 3.0f;
Vector3 position = transform.Position;
if (ImGui.EditVector3("Position", ref position, .Zero, 0.1f, textWidth))
float3 position = transform.Position;
if (ImGui.Editfloat3("Position", ref position, .Zero, 0.1f, textWidth))
{
transform.Position = position;
Vector3 rotationEuler = MathHelper.ToDegrees(transform.EditorRotationEuler);
if (ImGui.EditVector3("Rotation", ref rotationEuler, .Zero, 0.1f, textWidth))
// if necessary reposition Rigidbody2D
if (entity.TryGetComponent<Rigidbody2DComponent>(let rigidbody2D))
{
rigidbody2D.SetPosition(position.XY);
}
}
float3 rotationEuler = MathHelper.ToDegrees(transform.EditorRotationEuler);
if (ImGui.Editfloat3("Rotation", ref rotationEuler, .Zero, 0.1f, textWidth))
{
transform.EditorRotationEuler = MathHelper.ToRadians(rotationEuler);
Vector3 scale = transform.Scale;
if (ImGui.EditVector3("Scale", ref scale, .One, 0.1f, textWidth))
// if necessary reposition Rigidbody2D
if (entity.TryGetComponent<Rigidbody2DComponent>(let rigidbody2D))
{
rigidbody2D.SetAngle(rotationEuler.Z);
}
}
float3 scale = transform.Scale;
if (ImGui.Editfloat3("Scale", ref scale, .One, 0.1f, textWidth))
transform.Scale = scale;
}
@@ -375,12 +391,12 @@ namespace GlitchyEditor.EditWindows
textWidth += ImGui.GetStyle().FramePadding.x * 3.0f;
Vector2 offset = boxCollider.Offset;
if (ImGui.EditVector2("Offset", ref offset, .Zero, 0.1f, textWidth))
float2 offset = boxCollider.Offset;
if (ImGui.Editfloat2("Offset", ref offset, .Zero, 0.1f, textWidth))
boxCollider.Offset = offset;
Vector2 size = boxCollider.Size;
if (ImGui.EditVector2("Size", ref size, .Zero, 0.1f, textWidth))
float2 size = boxCollider.Size;
if (ImGui.Editfloat2("Size", ref size, .Zero, 0.1f, textWidth))
boxCollider.Size = size;
float density = boxCollider.Density;
@@ -406,8 +422,8 @@ namespace GlitchyEditor.EditWindows
textWidth += ImGui.GetStyle().FramePadding.x * 3.0f;
Vector2 offset = circleCollider.Offset;
if (ImGui.EditVector2("Offset", ref offset, .Zero, 0.1f, textWidth))
float2 offset = circleCollider.Offset;
if (ImGui.Editfloat2("Offset", ref offset, .Zero, 0.1f, textWidth))
circleCollider.Offset = offset;
float radius = circleCollider.Radius;
@@ -542,17 +558,17 @@ namespace GlitchyEditor.EditWindows
if (ImGui.DragScalar(fieldName.ToScopeCStr!(), .Float, &value))
SetFieldValue(scriptInstance, scriptField, value);
case .Vector2:
GetFieldValue<Vector2>(scriptInstance, scriptField, var value);
if (ImGui.EditVector2(fieldName, ref value))
case .float2:
GetFieldValue<float2>(scriptInstance, scriptField, var value);
if (ImGui.Editfloat2(fieldName, ref value))
SetFieldValue(scriptInstance, scriptField, value);
case .Vector3:
GetFieldValue<Vector3>(scriptInstance, scriptField, var value);
if (ImGui.EditVector3(fieldName, ref value))
case .float3:
GetFieldValue<float3>(scriptInstance, scriptField, var value);
if (ImGui.Editfloat3(fieldName, ref value))
SetFieldValue(scriptInstance, scriptField, value);
case .Vector4:
GetFieldValue<Vector4>(scriptInstance, scriptField, var value);
if (ImGui.EditVector4(fieldName, ref value))
case .float4:
GetFieldValue<float4>(scriptInstance, scriptField, var value);
if (ImGui.Editfloat4(fieldName, ref value))
SetFieldValue(scriptInstance, scriptField, value);
case .Double:
GlitchyEditor/src/EditWindows/ContentBrowserWindow.bf
+2 -2
View File
@@ -132,9 +132,9 @@ namespace GlitchyEditor.EditWindows
}
}
private static Vector2 DirectoryItemSize = .(110, 110);
private static float2 DirectoryItemSize = .(110, 110);
const Vector2 padding = .(24, 24);
const float2 padding = .(24, 24);
/// Renders the contents of _currentDirectory.
private void DrawCurrentDirectory()
GlitchyEditor/src/EditWindows/EditorViewportWindow.bf
+12 -12
View File
@@ -32,9 +32,9 @@ namespace GlitchyEditor.EditWindows
public uint32 SelectedEntityId {get; private set; }
public bool SelectionChanged { get; private set; }
public Vector2 ViewportSize => (Vector2)_oldViewportSize;
public float2 ViewportSize => (float2)_oldViewportSize;
// Occurs when the viewport is resized.
public Event<EventHandler<Vector2>> ViewportSizeChanged ~ _.Dispose();
public Event<EventHandler<float2>> ViewportSizeChanged ~ _.Dispose();
// Occurs when an entity was clicked.
public Event<EventHandler<uint32>> EntityClicked ~ _.Dispose();
@@ -126,7 +126,7 @@ namespace GlitchyEditor.EditWindows
if(_oldViewportSize != viewportSize)
{
ViewportSizeChanged.Invoke(this, (Vector2)viewportSize);
ViewportSizeChanged.Invoke(this, (float2)viewportSize);
_viewPortChanged = true;
_oldViewportSize = viewportSize;
}
@@ -154,14 +154,14 @@ namespace GlitchyEditor.EditWindows
{
_wrappedCursor = false;
let mousePos = (Vector2)ImGui.GetMousePos();
let winPos = (Vector2)ImGui.GetWindowPos();
let regionMin = winPos + (Vector2)ImGui.GetWindowContentRegionMin();
let regionMax = winPos + (Vector2)ImGui.GetWindowContentRegionMax();
let mousePos = (float2)ImGui.GetMousePos();
let winPos = (float2)ImGui.GetWindowPos();
let regionMin = winPos + (float2)ImGui.GetWindowContentRegionMin();
let regionMax = winPos + (float2)ImGui.GetWindowContentRegionMax();
ImGui.DrawRect((.)regionMin, (.)regionMax, .(0, 255, 0));
Vector2 newMousePos = mousePos;
float2 newMousePos = mousePos;
if (mousePos.X < regionMin.X + 1)
{
@@ -181,7 +181,7 @@ namespace GlitchyEditor.EditWindows
newMousePos.Y = regionMin.Y + 10;
}
if (newMousePos != mousePos)
if (any(newMousePos != mousePos))
{
Input.SetMousePosition((Int2)newMousePos);
// After wrapping the cursor the the other side, the camera controller must not compare the positions,
@@ -195,7 +195,7 @@ namespace GlitchyEditor.EditWindows
/// If the user clicks, the entity beneath the cursor will be selected.
private void MousePicking(ImGui.Vec2 viewportSize, bool gizmoUsed)
{
Vector2 relativeMouse = (Vector2)ImGui.GetMousePos() - (Vector2)ImGui.GetItemRectMin();
float2 relativeMouse = (float2)ImGui.GetMousePos() - (float2)ImGui.GetItemRectMin();
int rtWidth = _editor.EditorSceneRenderer.CompositeTarget.Width;
int rtHeight = _editor.EditorSceneRenderer.CompositeTarget.Height;
@@ -316,9 +316,9 @@ namespace GlitchyEditor.EditWindows
parentView = parentTransformCmp.WorldTransform.Invert();
}
Vector3 snap = .(_snap);
float3 snap = (float3)_snap;
if (_gizmoType.HasFlag(.ROTATE))
snap = .(_angleSnap);
snap = (float3)_angleSnap;
if (ImGuizmo.Manipulate((.)&view, (.)&projection, _gizmoType, _gizmoMode, (.)&worldTransform, null, _doSnap ? (.)&snap : null))
{
GlitchyEditor/src/EditWindows/GameViewportWindow.bf
+3 -3
View File
@@ -20,9 +20,9 @@ namespace GlitchyEditor.EditWindows
private RenderTargetGroup _renderTarget ~ _?.ReleaseRef();
public Vector2 ViewportSize => (Vector2)_oldViewportSize;
public float2 ViewportSize => (float2)_oldViewportSize;
// Occurs when the viewport is resized.
public Event<EventHandler<Vector2>> ViewportSizeChanged ~ _.Dispose();
public Event<EventHandler<float2>> ViewportSizeChanged ~ _.Dispose();
// Occurs when an entity was clicked.
public Event<EventHandler<uint32>> EntityClicked ~ _.Dispose();
@@ -80,7 +80,7 @@ namespace GlitchyEditor.EditWindows
if(_oldViewportSize != viewportSize)
{
ViewportSizeChanged.Invoke(this, (Vector2)viewportSize);
ViewportSizeChanged.Invoke(this, (float2)viewportSize);
_viewPortChanged = true;
_oldViewportSize = viewportSize;
}
GlitchyEditor/src/EditorIcons.bf
+3 -3
View File
@@ -25,11 +25,11 @@ namespace GlitchyEditor
set => _texture.Get().SamplerState = value;
}
public this(String texturePath, Vector2 iconSize)
public this(String texturePath, float2 iconSize)
{
_texture = Content.LoadAsset(texturePath, null, true);
Vector2 pen = .();
float2 pen = .();
DirectionalLight = GetNextGridTexture(ref pen, iconSize);
Camera = GetNextGridTexture(ref pen, iconSize);
@@ -41,7 +41,7 @@ namespace GlitchyEditor
Pause = GetNextGridTexture(ref pen, iconSize);
}
private SubTexture2D GetNextGridTexture(ref Vector2 pen, Vector2 iconSize)
private SubTexture2D GetNextGridTexture(ref float2 pen, float2 iconSize)
{
SubTexture2D subTexture = .CreateFromGrid(_texture, pen, iconSize);
GlitchyEditor/src/EditorLayer.bf
+12 -12
View File
@@ -105,7 +105,7 @@ namespace GlitchyEditor
_gameSceneRenderer = new SceneRenderer();
_editorSceneRenderer = new SceneRenderer();
_camera = EditorCamera(Vector3(3.5f, 1.25f, 2.75f), Quaternion.FromEulerAngles(MathHelper.ToRadians(40), MathHelper.ToRadians(25), 0), MathHelper.ToRadians(75), 0.1f, 1);
_camera = EditorCamera(float3(3.5f, 1.25f, 2.75f), Quaternion.FromEulerAngles(MathHelper.ToRadians(40), MathHelper.ToRadians(25), 0), MathHelper.ToRadians(75), 0.1f, 1);
_camera.RenderTarget = _cameraTarget;
InitEditor();
@@ -256,14 +256,14 @@ namespace GlitchyEditor
Matrix Billboard(Matrix transform)
{
Vector3 worldPos = transform.Translation;
float3 worldPos = transform.Translation;
return Matrix.Translation(worldPos) * billboard;
}
float CalculateAlpha(Vector3 pos)
float CalculateAlpha(float3 pos)
{
return Math.Clamp(1.5f - Vector3.Distance(_editor.CurrentCamera.Position, pos) / 50, 0, 1);
return Math.Clamp(1.5f - distance(_editor.CurrentCamera.Position, pos) / 50, 0, 1);
}
for (var (entity, transform, camera) in _activeScene.GetEntities<TransformComponent, CameraComponent>())
@@ -288,7 +288,7 @@ namespace GlitchyEditor
for (float angle = 0; angle < MathHelper.TwoPi; angle += MathHelper.TwoPi / 5.0f)
{
Vector2 pos = MathHelper.CirclePoint(angle, 0.5f);
float2 pos = MathHelper.CirclePoint(angle, 0.5f);
Renderer.DrawRay(.(pos, 0), .(pos, 20), .White, transform.WorldTransform);
}
@@ -540,8 +540,8 @@ namespace GlitchyEditor
{
let cameraEntity = newScene.CreateEntity("Camera");
let transform = cameraEntity.Transform;
transform.Position = Vector3(0, 2, -5);
transform.RotationEuler = Vector3(0, MathHelper.ToRadians(25), 0);
transform.Position = float3(0, 2, -5);
transform.RotationEuler = float3(0, MathHelper.ToRadians(25), 0);
let camera = cameraEntity.AddComponent<CameraComponent>();
camera.Primary = true;
@@ -717,14 +717,14 @@ namespace GlitchyEditor
return false;
}
private void EditorViewportSizeChanged(Object sender, Vector2 viewportSize)
private void EditorViewportSizeChanged(Object sender, float2 viewportSize)
{
if(viewportSize.X <= 0 || viewportSize.Y <= 0)
return;
uint32 sizeX = (uint32)viewportSize.X;
uint32 sizeY = (uint32)viewportSize.Y;
if(sizeX == 0 || sizeY == 0)
return;
_editorViewportTarget.Resize(sizeX, sizeY);
_cameraTarget.Resize(sizeX, sizeY);
@@ -733,7 +733,7 @@ namespace GlitchyEditor
_editorSceneRenderer.OnViewportResize(sizeX, sizeY);
}
private void GameViewportSizeChanged(Object sender, Vector2 viewportSize)
private void GameViewportSizeChanged(Object sender, float2 viewportSize)
{
if(viewportSize.X <= 0 || viewportSize.Y <= 0)
return;
GlitchyEditor/src/TextureViewer.bf
+10 -10
View File
@@ -64,7 +64,7 @@ namespace GlitchyEditor
_samplerPoint = SamplerStateManager.GetSampler(desc);
}
Vector2 _position;
float2 _position;
bool _moving;
@@ -124,7 +124,7 @@ namespace GlitchyEditor
{
var windowPos = ImGui.GetWindowPos();
var mousePos = ImGui.GetIO().MousePos;
Vector2 mouseInWindow = .(mousePos.x - windowPos.x, mousePos.y - windowPos.y);
float2 mouseInWindow = .(mousePos.x - windowPos.x, mousePos.y - windowPos.y);
bool windowHovered = ImGui.IsWindowHovered();
@@ -181,10 +181,10 @@ namespace GlitchyEditor
_context.SetDepthStencilTarget(_depth);
_context.BindRenderTargets();
Vector2 textureSize = Vector2(viewedTexture.Width, viewedTexture.Height);
Vector2 zoomedTextureSize = textureSize * _zoom;
float2 textureSize = float2(viewedTexture.Width, viewedTexture.Height);
float2 zoomedTextureSize = textureSize * _zoom;
Vector2 targetSize = Vector2(_target.Width, _target.Height);
float2 targetSize = float2(_target.Width, _target.Height);
_effect.Variables["ColorOffset"].SetData(_colorOffset);
_effect.Variables["ColorScale"].SetData(_colorScale);
@@ -204,19 +204,19 @@ namespace GlitchyEditor
switch(_backgroundMode)
{
case .Black:
Renderer2D.DrawQuadPivotCorner(Vector3(0, 0, 1), targetSize, 0, .Black);
Renderer2D.DrawQuadPivotCorner(float3(0, 0, 1), targetSize, 0, .Black);
case .White:
Renderer2D.DrawQuadPivotCorner(Vector3(0, 0, 1), targetSize, 0, .White);
Renderer2D.DrawQuadPivotCorner(float3(0, 0, 1), targetSize, 0, .White);
case .Checkerboard:
float quadSize = 50.0f;
Vector2 numQuads = (targetSize / 500f) * 10f;
float2 numQuads = (targetSize / 500f) * 10f;
for(float x = 0; x < numQuads.X; x++)
{
for(float y = 0; y < numQuads.Y; y++)
{
Renderer2D.DrawQuadPivotCorner(Vector3(x * quadSize, -y * quadSize, 1), quadSize.XX, 0, ((x + y) % 2 == 0) ? .White : .Gray);
Renderer2D.DrawQuadPivotCorner(float3(x * quadSize, -y * quadSize, 1), quadSize.XX, 0, ((x + y) % 2 == 0) ? .White : .Gray);
}
}
break;
@@ -236,7 +236,7 @@ namespace GlitchyEditor
Renderer2D.BeginScene(_camera, .SortByTexture, _effect);
Renderer2D.DrawQuad(Vector3(_position * .(1, -1), 0), zoomedTextureSize, 0, viewedTexture);
Renderer2D.DrawQuad(float3(_position * .(1, -1), 0), zoomedTextureSize, 0, viewedTexture);
Renderer2D.EndScene();
GlitchyEngine/BeefProj.toml
+16
View File
@@ -25,3 +25,19 @@ PreprocessorMacros = ["TEST", "GE_WINDOWS"]
[Configs.Debug.Win64]
PreprocessorMacros = ["DEBUG", "GE_PROFILE", "GE_PROFILE_RENDERER", "GE_PROFILE_RESOURCES", "IMGUI"]
[[ProjectFolder.Items]]
Type = "AutoFolder"
Name = "Math"
[[ProjectFolder.Items.Items]]
Type = "IgnoreSource"
Name = "Vector2.bf"
[[ProjectFolder.Items.Items]]
Type = "IgnoreSource"
Name = "Vector3.bf"
[[ProjectFolder.Items.Items]]
Type = "IgnoreSource"
Name = "Vector4.bf"
GlitchyEngine/src/Content/ModelLoader.bf
+22 -22
View File
@@ -367,15 +367,15 @@ namespace GlitchyEngine.Content
Log.EngineLogger.AssertDebug(positions != null, "The model appears to have no position data?!");
Vector3[] normals = new Vector3[positions.Count];
float3[] normals = new float3[positions.Count];
if(primitive.Indices != null)
GenerateNormals(primitive.Indices, positions, normals);
else
GenerateNormals(positions, normals);
VertexBuffer vertexBuffer = new VertexBuffer((uint32)sizeof(Vector3), (uint32)normals.Count, .Immutable);
vertexBuffer.SetData<Vector3>(normals);
VertexBuffer vertexBuffer = new VertexBuffer((uint32)sizeof(float3), (uint32)normals.Count, .Immutable);
vertexBuffer.SetData<float3>(normals);
bindings.Add(vertexBuffer.Binding);
@@ -405,20 +405,20 @@ namespace GlitchyEngine.Content
}
/// Generates the normals for one triangle
static mixin GenerateTriangleNormals(int index0, int index1, int index2, CGLTF.Accessor* positions, Vector3[] normals)
static mixin GenerateTriangleNormals(int index0, int index1, int index2, CGLTF.Accessor* positions, float3[] normals)
{
Vector3 position0 = GetEntry<Vector3>(positions, (.)index0);
Vector3 position1 = GetEntry<Vector3>(positions, (.)index1);
Vector3 position2 = GetEntry<Vector3>(positions, (.)index2);
float3 position0 = GetEntry<float3>(positions, (.)index0);
float3 position1 = GetEntry<float3>(positions, (.)index1);
float3 position2 = GetEntry<float3>(positions, (.)index2);
ref Vector3 normal0 = ref normals[(.)index0];
ref Vector3 normal1 = ref normals[(.)index1];
ref Vector3 normal2 = ref normals[(.)index2];
ref float3 normal0 = ref normals[(.)index0];
ref float3 normal1 = ref normals[(.)index1];
ref float3 normal2 = ref normals[(.)index2];
Vector3 e0 = position1 - position0;
Vector3 e1 = position2 - position0;
float3 e0 = position1 - position0;
float3 e1 = position2 - position0;
Vector3 normal = Vector3.Cross(e0, e1);
float3 normal = cross(e0, e1);
normal0 += normal;
normal1 += normal;
@@ -426,16 +426,16 @@ namespace GlitchyEngine.Content
}
[Inline]
static void NormalizeNormals(Vector3[] normals)
static void NormalizeNormals(float3[] normals)
{
for(int i < normals.Count)
{
normals[i].Normalize();
normalize(normals[i]);
}
}
/// Generates normals for the given model using indexed geometry
static void GenerateNormals(CGLTF.Accessor* indices, CGLTF.Accessor* positions, Vector3[] normals)
static void GenerateNormals(CGLTF.Accessor* indices, CGLTF.Accessor* positions, float3[] normals)
{
/// Enumerate triangle-wise
for(uint t = 0; t < indices.Count; t += 3)
@@ -451,7 +451,7 @@ namespace GlitchyEngine.Content
}
/// Generates normals for the given model using nonindexed geometry
static void GenerateNormals(CGLTF.Accessor* positions, Vector3[] normals)
static void GenerateNormals(CGLTF.Accessor* positions, float3[] normals)
{
/// Enumerate triangle-wise
for(int i = 0; i < (.)positions.Count; i += 3)
@@ -554,7 +554,7 @@ namespace GlitchyEngine.Content
for(int i < samples)
{
float timeStamp = GetEntry<float>(channel.Sampler.Input, i);
Vector3 sample = GetEntry<Vector3>(channel.Sampler.Output, i);
float3 sample = GetEntry<float3>(channel.Sampler.Output, i);
jointAnimation.TranslationChannel.TimeStamps[i] = timeStamp;
jointAnimation.TranslationChannel.Values[i] = sample;
@@ -582,7 +582,7 @@ namespace GlitchyEngine.Content
for(int i < samples)
{
float timeStamp = GetEntry<float>(channel.Sampler.Input, i);
Vector3 sample = GetEntry<Vector3>(channel.Sampler.Output, i);
float3 sample = GetEntry<float3>(channel.Sampler.Output, i);
jointAnimation.ScaleChannel.TimeStamps[i] = timeStamp;
jointAnimation.ScaleChannel.Values[i] = sample;
@@ -606,11 +606,11 @@ namespace GlitchyEngine.Content
{
case typeof(float):
CGLTF.AccessorReadFloat(accessor, (uint)index, (float*)&result, 1);
case typeof(Vector2):
case typeof(float2):
CGLTF.AccessorReadFloat(accessor, (uint)index, (float*)&result, 2);
case typeof(Vector3):
case typeof(float3):
CGLTF.AccessorReadFloat(accessor, (uint)index, (float*)&result, 3);
case typeof(Vector4), typeof(Quaternion):
case typeof(float4), typeof(Quaternion):
CGLTF.AccessorReadFloat(accessor, (uint)index, (float*)&result, 4);
case typeof(Matrix):
CGLTF.AccessorReadFloat(accessor, (uint)index, (float*)&result, 16);
GlitchyEngine/src/ImGui/ImGuiExtension.bf
+10 -10
View File
@@ -8,7 +8,7 @@ namespace GlitchyEngine.Math
{
extension ColorRGBA
{
internal uint32 ImGuiU32 => ImGui.ImGui.ColorConvertFloat4ToU32((.)(Vector4)this);
internal uint32 ImGuiU32 => ImGui.ImGui.ColorConvertFloat4ToU32((.)(float4)this);
}
}
@@ -20,14 +20,14 @@ namespace ImGui
{
extension Vec2
{
public static explicit operator Vector2(Vec2 v) => .(v.x, v.y);
public static explicit operator Vec2(Vector2 v) => .(v.X, v.Y);
public static explicit operator float2(Vec2 v) => .(v.x, v.y);
public static explicit operator Vec2(float2 v) => .(v.X, v.Y);
}
extension Vec4
{
public static explicit operator Vector4(Vec4 v) => .(v.x, v.y, v.z, v.w);
public static explicit operator Vec4(Vector4 v) => .(v.X, v.Y, v.Z, v.W);
public static explicit operator float4(Vec4 v) => .(v.x, v.y, v.z, v.w);
public static explicit operator Vec4(float4 v) => .(v.X, v.Y, v.Z, v.W);
}
/*public static bool IsItemJustDeactivated()
@@ -75,7 +75,7 @@ namespace ImGui
if (uv0 != .Zero || uv1 != .Ones)
Runtime.NotImplemented();
Vector2 v = (.)subTexture.TexCoords.XY + subTexture.TexCoords.ZW;
float2 v = (.)subTexture.TexCoords.XY + subTexture.TexCoords.ZW;
Image(subTexture.Texture.GetViewBinding(), size, (.)subTexture.TexCoords.XY, (.)v, tint_col, border_col);
}
@@ -92,7 +92,7 @@ namespace ImGui
if (uv0 != .Zero || uv1 != .Ones)
Runtime.NotImplemented();
Vector2 v = (.)subTexture.TexCoords.XY + subTexture.TexCoords.ZW;
float2 v = (.)subTexture.TexCoords.XY + subTexture.TexCoords.ZW;
return ImageButton(subTexture.Texture.GetViewBinding(), size, (.)subTexture.TexCoords.XY, (.)v, frame_padding, bg_col, tint_col);
}
@@ -107,19 +107,19 @@ namespace ImGui
protected internal static extern void CleanupFrame();
/// Control to edit a vector 2 with drag functionality and reset buttons
public static bool EditVector2(StringView label, ref Vector2 value, Vector2 resetValues = .Zero, float dragSpeed = 0.1f, float columnWidth = 100f, Vector2 minValue = .Zero, Vector2 maxValue = .Zero)
public static bool Editfloat2(StringView label, ref float2 value, float2 resetValues = .Zero, float dragSpeed = 0.1f, float columnWidth = 100f, float2 minValue = .Zero, float2 maxValue = .Zero)
{
return EditVector<2>(label, ref *(float[2]*)&value, (float[2])resetValues, dragSpeed, columnWidth, (float[2])minValue, (float[2])maxValue);
}
/// Control to edit a vector 3 with drag functionality and reset buttons
public static bool EditVector3(StringView label, ref Vector3 value, Vector3 resetValues = .Zero, float dragSpeed = 0.1f, float columnWidth = 100f, Vector3 minValue = .Zero, Vector3 maxValue = .Zero)
public static bool Editfloat3(StringView label, ref float3 value, float3 resetValues = .Zero, float dragSpeed = 0.1f, float columnWidth = 100f, float3 minValue = .Zero, float3 maxValue = .Zero)
{
return EditVector<3>(label, ref *(float[3]*)&value, (float[3])resetValues, dragSpeed, columnWidth, (float[3])minValue, (float[3])maxValue);
}
/// Control to edit a vector 4 with drag functionality and reset buttons
public static bool EditVector4(StringView label, ref Vector4 value, Vector4 resetValues = .Zero, float dragSpeed = 0.1f, float columnWidth = 100f, Vector4 minValue = .Zero, Vector4 maxValue = .Zero)
public static bool Editfloat4(StringView label, ref float4 value, float4 resetValues = .Zero, float dragSpeed = 0.1f, float columnWidth = 100f, float4 minValue = .Zero, float4 maxValue = .Zero)
{
return EditVector<4>(label, ref *(float[4]*)&value, (float[4])resetValues, dragSpeed, columnWidth, (float[4])minValue, (float[4])maxValue);
}
GlitchyEngine/src/Math/ColorRGB.bf
+2 -2
View File
@@ -53,10 +53,10 @@ namespace GlitchyEngine.Math
[Inline]
#unwarn
public static explicit operator Vector3(ColorRGB color) => *(Vector3*)&color;
public static explicit operator float3(ColorRGB color) => *(float3*)&color;
[Inline]
#unwarn
public static explicit operator ColorRGB(Vector3 color) => *(ColorRGB*)&color;
public static explicit operator ColorRGB(float3 color) => *(ColorRGB*)&color;
}
}
GlitchyEngine/src/Math/ColorRGBA.bf
+2 -2
View File
@@ -329,10 +329,10 @@ namespace GlitchyEngine.Math
[Inline]
#unwarn
public static explicit operator Vector4(ColorRGBA color) => *(Vector4*)&color;
public static explicit operator float4(ColorRGBA color) => *(float4*)&color;
[Inline]
#unwarn
public static explicit operator ColorRGBA(Vector4 color) => *(ColorRGBA*)&color;
public static explicit operator ColorRGBA(float4 color) => *(ColorRGBA*)&color;
}
}
GlitchyEngine/src/Math/FloatExtension.bf
+3 -3
View File
@@ -13,12 +13,12 @@ namespace System
}
[Inline]
public Vector2 XX => Vector2((float)this);
public float2 XX => (float2)this;
[Inline]
public Vector3 XXX => Vector3((float)this);
public float3 XXX => (float3)this;
[Inline]
public Vector4 XXXX => Vector4((float)this);
public float4 XXXX => (float4)this;
}
}
GlitchyEngine/src/Math/Math.bf
+554 -253
View File
@@ -1,8 +1,13 @@
using System;
namespace GlitchyEngine.Math.FancyMath;
static class FancyMath
namespace GlitchyEngine.Math;
// TODO: Not all functions are available for scalars yet
static
{
/// Returns true if at least one of the components is true.
public static bool any(bool value) => value;
/// Returns true if at least one of the components is true.
public static bool any(bool2 value) => value.X || value.Y;
/// Returns true if at least one of the components is true.
@@ -10,6 +15,8 @@ static class FancyMath
/// Returns true if at least one of the components is true.
public static bool any(bool4 value) => value.X || value.Y || value.Z || value.W;
/// Returns true if all of the components are true.
public static bool all(bool value) => value;
/// Returns true if all of the components are true.
public static bool all(bool2 value) => value.X && value.Y;
/// Returns true if all of the components are true.
@@ -19,6 +26,11 @@ static class FancyMath
#region abs
public static float abs(float value)
{
return Math.Abs(value);
}
public static float2 abs(float2 value)
{
return float2(Math.Abs(value.X), Math.Abs(value.Y));
@@ -34,6 +46,11 @@ static class FancyMath
return float4(Math.Abs(value.X), Math.Abs(value.Y), Math.Abs(value.Z), Math.Abs(value.W));
}
public static int abs(int value)
{
return Math.Abs(value);
}
public static int2 abs(int2 value)
{
return int2(Math.Abs(value.X), Math.Abs(value.Y));
@@ -51,244 +68,6 @@ static class FancyMath
#endregion
#region ceil / floor
public static float2 ceil(float2 value)
{
return float2(Math.Ceiling(value.X), Math.Ceiling(value.Y));
}
public static float3 ceil(float3 value)
{
return float3(Math.Ceiling(value.X), Math.Ceiling(value.Y), Math.Ceiling(value.Z));
}
public static float4 ceil(float4 value)
{
return float4(Math.Ceiling(value.X), Math.Ceiling(value.Y), Math.Ceiling(value.Z), Math.Ceiling(value.W));
}
public static float2 floor(float2 value)
{
return float2(Math.Floor(value.X), Math.Floor(value.Y));
}
public static float3 floor(float3 value)
{
return float3(Math.Floor(value.X), Math.Floor(value.Y), Math.Floor(value.Z));
}
public static float4 floor(float4 value)
{
return float4(Math.Floor(value.X), Math.Floor(value.Y), Math.Floor(value.Z), Math.Floor(value.W));
}
#endregion
#region Clamp
public static float2 clamp(float2 value, float2 min, float2 max)
{
return float2(Math.Clamp(value.X, min.X, max.X), Math.Clamp(value.Y, min.Y, max.Y));
}
public static float3 clamp(float3 value, float3 min, float3 max)
{
return float3(Math.Clamp(value.X, min.X, max.X), Math.Clamp(value.Y, min.Y, max.Y), Math.Clamp(value.Z, min.Z, max.Z));
}
public static float4 clamp(float4 value, float4 min, float4 max)
{
return float4(Math.Clamp(value.X, min.X, max.X), Math.Clamp(value.Y, min.Y, max.Y), Math.Clamp(value.Z, min.Z, max.Z), Math.Clamp(value.W, min.W, max.W));
}
public static int2 clamp(int2 value, int2 min, int2 max)
{
return int2(Math.Clamp(value.X, min.X, max.X), Math.Clamp(value.Y, min.Y, max.Y));
}
public static int3 clamp(int3 value, int3 min, int3 max)
{
return int3(Math.Clamp(value.X, min.X, max.X), Math.Clamp(value.Y, min.Y, max.Y), Math.Clamp(value.Z, min.Z, max.Z));
}
public static int4 clamp(int4 value, int4 min, int4 max)
{
return int4(Math.Clamp(value.X, min.X, max.X), Math.Clamp(value.Y, min.Y, max.Y), Math.Clamp(value.Z, min.Z, max.Z), Math.Clamp(value.W, min.W, max.W));
}
#endregion
#region Lerp
/// Performs a linear interpolation.
// @param x The first vector value.
// @param y The second vector value.
// @param y A value that linearly interpolates between x and y.
public static float2 lerp(float2 x, float2 y, float s)
{
return x + s * (y - x);
}
/// Performs a linear interpolation.
// @param x The first vector value.
// @param y The second vector value.
// @param y A value that linearly interpolates between x and y.
public static float3 lerp(float3 x, float3 y, float s)
{
return x + s * (y - x);
}
/// Performs a linear interpolation.
// @param x The first vector value.
// @param y The second vector value.
// @param y A value that linearly interpolates between x and y.
public static float4 lerp(float4 x, float4 y, float s)
{
return x + s * (y - x);
}
#endregion
// log, log10, log2
#region min / max
public static float2 min(float2 x, float2 y)
{
return float2(Math.Min(x.X, y.X), Math.Min(x.Y, y.Y));
}
public static float3 min(float3 x, float3 y)
{
return float3(Math.Min(x.X, y.X), Math.Min(x.Y, y.Y), Math.Min(x.Z, y.Z));
}
public static float4 min(float4 x, float4 y)
{
return float4(Math.Min(x.X, y.X), Math.Min(x.Y, y.Y), Math.Min(x.Z, y.Z), Math.Min(x.W, y.W));
}
public static float2 max(float2 x, float2 y)
{
return float2(Math.Max(x.X, y.X), Math.Max(x.Y, y.Y));
}
public static float3 max(float3 x, float3 y)
{
return float3(Math.Max(x.X, y.X), Math.Max(x.Y, y.Y), Math.Max(x.Z, y.Z));
}
public static float4 max(float4 x, float4 y)
{
return float4(Math.Max(x.X, y.X), Math.Max(x.Y, y.Y), Math.Max(x.Z, y.Z), Math.Max(x.W, y.W));
}
#endregion
// mul
public static float2 normalize(float2 value) => value / length(value);
public static float3 normalize(float3 value) => value / length(value);
public static float4 normalize(float4 value) => value / length(value);
// pow
// rcp??? (reciprocal)
// reflect and refract?
// round
// rsqrt?
// sqrt
// saturate
// sign
// step and smoothstep
// transpose
#region exp
/// Returns the base-e exponential, or e^x, of the specified value.
public static float2 exp(float2 x)
{
return float2(Math.Exp(x.X), Math.Exp(x.Y));
}
/// Returns the base-e exponential, or e^x, of the specified value.
public static float3 exp(float3 x)
{
return float3(Math.Exp(x.X), Math.Exp(x.Y), Math.Exp(x.Z));
}
/// Returns the base-e exponential, or e^x, of the specified value.
public static float4 exp(float4 x)
{
return float4(Math.Exp(x.X), Math.Exp(x.Y), Math.Exp(x.Z), Math.Exp(x.W));
}
// Exp2?
#endregion
#region Reject / Project
/**
* Calculates the projection of a onto b
*/
public static float2 project(float2 a, float2 b)
{
return (b * (dot(a, b) / dot(b, b)));
}
/**
* Calculates the projection of a onto b
*/
public static float3 project(float3 a, float3 b)
{
return (b * (dot(a, b) / dot(b, b)));
}
/**
* Calculates the projection of a onto b
*/
public static float4 project(float4 a, float4 b)
{
return (b * (dot(a, b) / dot(b, b)));
}
/**
* Calculates the rejection of a from b
*/
public static float2 reject(float2 a, float2 b)
{
return (a - b * (dot(a, b) / dot(b, b)));
}
/**
* Calculates the rejection of a from b
*/
public static float3 reject(float3 a, float3 b)
{
return (a - b * (dot(a, b) / dot(b, b)));
}
/**
* Calculates the rejection of a from b
*/
public static float4 reject(float4 a, float4 b)
{
return (a - b * (dot(a, b) / dot(b, b)));
}
#endregion
#region modf / frac / trunc
// Splits the value x into fractional and integer parts, each of which has the same sign as x.
@@ -416,6 +195,541 @@ static class FancyMath
#endregion
#region Sign
/// Returns the sign of x.
public static int32 sign(float x)
{
return (int32)Math.Sign(x);
}
/// Returns the sign of x.
public static int2 sign(float2 x)
{
return int2((int32)Math.Sign(x.X), (int32)Math.Sign(x.Y));
}
/// Returns the sign of x.
public static int3 sign(float3 x)
{
return int3((int32)Math.Sign(x.X), (int32)Math.Sign(x.Y), (int32)Math.Sign(x.Z));
}
/// Returns the sign of x.
public static int4 sign(float4 x)
{
return int4((int32)Math.Sign(x.X), (int32)Math.Sign(x.Y), (int32)Math.Sign(x.Z), (int32)Math.Sign(x.W));
}
/// Returns the sign of x.
public static int32 sign(int x)
{
return (int32)Math.Sign(x);
}
/// Returns the sign of x.
public static int2 sign(int2 x)
{
return int2((int32)Math.Sign(x.X), (int32)Math.Sign(x.Y));
}
/// Returns the sign of x.
public static int3 sign(int3 x)
{
return int3((int32)Math.Sign(x.X), (int32)Math.Sign(x.Y), (int32)Math.Sign(x.Z));
}
/// Returns the sign of x.
public static int4 sign(int4 x)
{
return int4((int32)Math.Sign(x.X), (int32)Math.Sign(x.Y), (int32)Math.Sign(x.Z), (int32)Math.Sign(x.W));
}
#endregion
#region ceil / floor / round
public static float ceil(float value)
{
return Math.Ceiling(value);
}
public static float2 ceil(float2 value)
{
return float2(Math.Ceiling(value.X), Math.Ceiling(value.Y));
}
public static float3 ceil(float3 value)
{
return float3(Math.Ceiling(value.X), Math.Ceiling(value.Y), Math.Ceiling(value.Z));
}
public static float4 ceil(float4 value)
{
return float4(Math.Ceiling(value.X), Math.Ceiling(value.Y), Math.Ceiling(value.Z), Math.Ceiling(value.W));
}
public static float floor(float value)
{
return Math.Floor(value);
}
public static float2 floor(float2 value)
{
return float2(Math.Floor(value.X), Math.Floor(value.Y));
}
public static float3 floor(float3 value)
{
return float3(Math.Floor(value.X), Math.Floor(value.Y), Math.Floor(value.Z));
}
public static float4 floor(float4 value)
{
return float4(Math.Floor(value.X), Math.Floor(value.Y), Math.Floor(value.Z), Math.Floor(value.W));
}
/// Rounds the specified value to the nearest integer.
public static float round(float value)
{
return Math.Round(value);
}
/// Rounds the specified value to the nearest integer.
public static float2 round(float2 value)
{
return float2(Math.Round(value.X), Math.Round(value.Y));
}
/// Rounds the specified value to the nearest integer.
public static float3 round(float3 value)
{
return float3(Math.Round(value.X), Math.Round(value.Y), Math.Round(value.Z));
}
/// Rounds the specified value to the nearest integer.
public static float4 round(float4 value)
{
return float4(Math.Round(value.X), Math.Round(value.Y), Math.Round(value.Z), Math.Round(value.W));
}
#endregion
#region min / max
public static float2 min(float2 x, float2 y)
{
return float2(Math.Min(x.X, y.X), Math.Min(x.Y, y.Y));
}
public static float3 min(float3 x, float3 y)
{
return float3(Math.Min(x.X, y.X), Math.Min(x.Y, y.Y), Math.Min(x.Z, y.Z));
}
public static float4 min(float4 x, float4 y)
{
return float4(Math.Min(x.X, y.X), Math.Min(x.Y, y.Y), Math.Min(x.Z, y.Z), Math.Min(x.W, y.W));
}
public static float2 max(float2 x, float2 y)
{
return float2(Math.Max(x.X, y.X), Math.Max(x.Y, y.Y));
}
public static float3 max(float3 x, float3 y)
{
return float3(Math.Max(x.X, y.X), Math.Max(x.Y, y.Y), Math.Max(x.Z, y.Z));
}
public static float4 max(float4 x, float4 y)
{
return float4(Math.Max(x.X, y.X), Math.Max(x.Y, y.Y), Math.Max(x.Z, y.Z), Math.Max(x.W, y.W));
}
#endregion
#region exp, pow, log
// TODO: log, log10, log2
/// Returns x raised to the power of y.
public static float pow(float x, float y)
{
return Math.Pow(x, y);
}
/// Returns x raised to the power of y.
public static float2 pow(float2 x, float2 y)
{
return float2(Math.Pow(x.X, y.X), Math.Pow(x.Y, y.Y));
}
/// Returns x raised to the power of y.
public static float3 pow(float3 x, float3 y)
{
return float3(Math.Pow(x.X, y.X), Math.Pow(x.Y, y.Y), Math.Pow(x.Z, y.Z));
}
/// Returns x raised to the power of y.
public static float4 pow(float4 x, float4 y)
{
return float4(Math.Pow(x.X, y.X), Math.Pow(x.Y, y.Y), Math.Pow(x.Z, y.Z), Math.Pow(x.W, y.W));
}
/// Returns the base-e exponential, or e^x, of the specified value.
public static float exp(float x)
{
return Math.Exp(x);
}
/// Returns the base-e exponential, or e^x, of the specified value.
public static float2 exp(float2 x)
{
return float2(Math.Exp(x.X), Math.Exp(x.Y));
}
/// Returns the base-e exponential, or e^x, of the specified value.
public static float3 exp(float3 x)
{
return float3(Math.Exp(x.X), Math.Exp(x.Y), Math.Exp(x.Z));
}
/// Returns the base-e exponential, or e^x, of the specified value.
public static float4 exp(float4 x)
{
return float4(Math.Exp(x.X), Math.Exp(x.Y), Math.Exp(x.Z), Math.Exp(x.W));
}
/// Returns the base 2 exponential, or 2^x, of the specified value.
public static float exp2(float x)
{
return Math.Pow(2, x);
}
/// Returns the base 2 exponential, or 2^x, of the specified value.
public static float2 exp2(float2 x)
{
return float2(Math.Pow(2, x.X), Math.Pow(2, x.Y));
}
/// Returns the base 2 exponential, or 2^x, of the specified value.
public static float3 exp2(float3 x)
{
return float3(Math.Pow(2, x.X), Math.Pow(2, x.Y), Math.Pow(2, x.Z));
}
/// Returns the base 2 exponential, or 2^x, of the specified value.
public static float4 exp2(float4 x)
{
return float4(Math.Pow(2, x.X), Math.Pow(2, x.Y), Math.Pow(2, x.Z), Math.Pow(2, x.W));
}
#endregion
#region Degrees / Radians
public static float toDegrees(float radians) => radians * MathHelper.RadToDeg;
public static float2 toDegrees(float2 radians) => radians * MathHelper.RadToDeg;
public static float3 toDegrees(float3 radians) => radians * MathHelper.RadToDeg;
public static float4 toDegrees(float4 radians) => radians * MathHelper.RadToDeg;
public static float toRadians(float degrees) => degrees * MathHelper.DegToRad;
public static float2 toRadians(float2 degrees) => degrees * MathHelper.DegToRad;
public static float3 toRadians(float3 degrees) => degrees * MathHelper.DegToRad;
public static float4 toRadians(float4 degrees) => degrees * MathHelper.DegToRad;
#endregion
#region Clamp
public static float clamp(float value, float min, float max)
{
return Math.Clamp(value.X, min.X, max.X);
}
public static float2 clamp(float2 value, float2 min, float2 max)
{
return float2(Math.Clamp(value.X, min.X, max.X), Math.Clamp(value.Y, min.Y, max.Y));
}
public static float3 clamp(float3 value, float3 min, float3 max)
{
return float3(Math.Clamp(value.X, min.X, max.X), Math.Clamp(value.Y, min.Y, max.Y), Math.Clamp(value.Z, min.Z, max.Z));
}
public static float4 clamp(float4 value, float4 min, float4 max)
{
return float4(Math.Clamp(value.X, min.X, max.X), Math.Clamp(value.Y, min.Y, max.Y), Math.Clamp(value.Z, min.Z, max.Z), Math.Clamp(value.W, min.W, max.W));
}
public static int2 clamp(int2 value, int2 min, int2 max)
{
return int2(Math.Clamp(value.X, min.X, max.X), Math.Clamp(value.Y, min.Y, max.Y));
}
public static int3 clamp(int3 value, int3 min, int3 max)
{
return int3(Math.Clamp(value.X, min.X, max.X), Math.Clamp(value.Y, min.Y, max.Y), Math.Clamp(value.Z, min.Z, max.Z));
}
public static int4 clamp(int4 value, int4 min, int4 max)
{
return int4(Math.Clamp(value.X, min.X, max.X), Math.Clamp(value.Y, min.Y, max.Y), Math.Clamp(value.Z, min.Z, max.Z), Math.Clamp(value.W, min.W, max.W));
}
#endregion
#region Lerp
/// Performs a linear interpolation.
// @param x The first vector value.
// @param y The second vector value.
// @param y A value that linearly interpolates between x and y.
public static float lerp(float x, float y, float s)
{
return x + s * (y - x);
}
/// Performs a linear interpolation.
// @param x The first vector value.
// @param y The second vector value.
// @param y A value that linearly interpolates between x and y.
public static float2 lerp(float2 x, float2 y, float s)
{
return x + s * (y - x);
}
/// Performs a linear interpolation.
// @param x The first vector value.
// @param y The second vector value.
// @param y A value that linearly interpolates between x and y.
public static float3 lerp(float3 x, float3 y, float s)
{
return x + s * (y - x);
}
/// Performs a linear interpolation.
// @param x The first vector value.
// @param y The second vector value.
// @param y A value that linearly interpolates between x and y.
public static float4 lerp(float4 x, float4 y, float s)
{
return x + s * (y - x);
}
#endregion
// mul? hlsl has like 280 overloads...
public static float normalize(float value) => 1.0f;
public static float2 normalize(float2 value) => value / length(value);
public static float3 normalize(float3 value) => value / length(value);
public static float4 normalize(float4 value) => value / length(value);
// pow
#region Reflect and Refract
/// Returns a reflection vector using an incident ray and a surface normal.
public static float2 reflect(float2 incident, float2 normal) => incident - 2 * normal * dot(incident, normal);
/// Returns a reflection vector using an incident ray and a surface normal.
public static float3 reflect(float3 incident, float3 normal) => incident - 2 * normal * dot(incident, normal);
/// Returns a reflection vector using an incident ray and a surface normal.
public static float4 reflect(float4 incident, float4 normal) => incident - 2 * normal * dot(incident, normal);
// Source: https://thebookofshaders.com/glossary/?search=refract
/// Returns a refraction vector using an entering ray, a surface normal, and a refraction index.
public static float2 refract(float2 incident, float2 normal, float refractionIndex)
{
float dot_n_i = dot(normal, incident);
float k = 1.0f - refractionIndex * refractionIndex * (1.0f - dot_n_i * dot_n_i);
if (k < 0.0f)
return 0.0f;
else
return refractionIndex * incident - (refractionIndex * dot_n_i + sqrt(k));
}
/// Returns a refraction vector using an entering ray, a surface normal, and a refraction index.
public static float3 refract(float3 incident, float3 normal, float refractionIndex)
{
float dot_n_i = dot(normal, incident);
float k = 1.0f - refractionIndex * refractionIndex * (1.0f - dot_n_i * dot_n_i);
if (k < 0.0f)
return 0.0f;
else
return refractionIndex * incident - (refractionIndex * dot_n_i + sqrt(k));
}
/// Returns a refraction vector using an entering ray, a surface normal, and a refraction index.
public static float4 refract(float4 incident, float4 normal, float refractionIndex)
{
float dot_n_i = dot(normal, incident);
float k = 1.0f - refractionIndex * refractionIndex * (1.0f - dot_n_i * dot_n_i);
if (k < 0.0f)
return 0.0f;
else
return refractionIndex * incident - (refractionIndex * dot_n_i + sqrt(k));
}
#endregion
/// Calculates the per component square root of the given value.
public static float sqrt(float value)
{
return Math.Sqrt(value);
}
/// Calculates the per component square root of the given value.
public static float2 sqrt(float2 value)
{
return float2(Math.Sqrt(value.X), Math.Sqrt(value.Y));
}
/// Calculates the per component square root of the given value.
public static float3 sqrt(float3 value)
{
return float3(Math.Sqrt(value.X), Math.Sqrt(value.Y), Math.Sqrt(value.Z));
}
/// Calculates the per component square root of the given value.
public static float4 sqrt(float4 value)
{
return float4(Math.Sqrt(value.X), Math.Sqrt(value.Y), Math.Sqrt(value.Z), Math.Sqrt(value.W));
}
// saturate (I don't think there is a faster way than simply using clamp, so simply use clamp...)
#region Step / Smoothstep
/// Compares two values, returning 0 or 1 based on which value is greater.
/// @returns 1 if the x parameter is greater than or equal to the y parameter; otherwise, 0.
public static float step(float y, float x)
{
return (x >= y) ? 1.0f : 0.0f;
}
/// Compares two values, returning 0 or 1 based on which value is greater.
/// @returns 1 if the x parameter is greater than or equal to the y parameter; otherwise, 0.
public static float2 step(float2 y, float2 x)
{
bool2 b = (x >= y);
return float2(b.X ? 1.0f : 0.0f, b.Y ? 1.0f : 0.0f);
}
/// Compares two values, returning 0 or 1 based on which value is greater.
/// @returns 1 if the x parameter is greater than or equal to the y parameter; otherwise, 0.
public static float3 step(float3 y, float3 x)
{
bool3 b = (x >= y);
return float3(b.X ? 1.0f : 0.0f, b.Y ? 1.0f : 0.0f, b.Z ? 1.0f : 0.0f);
}
/// Compares two values, returning 0 or 1 based on which value is greater.
/// @returns 1 if the x parameter is greater than or equal to the y parameter; otherwise, 0.
public static float4 step(float4 y, float4 x)
{
bool4 b = (x >= y);
return float4(b.X ? 1.0f : 0.0f, b.Y ? 1.0f : 0.0f, b.Z ? 1.0f : 0.0f, b.W ? 1.0f : 0.0f);
}
// Source: https://thebookofshaders.com/glossary/?search=smoothstep
/// Returns a smooth Hermite interpolation between 0 and 1, if x is in the range [min, max].
/// @returns Returns 0 if x is less than min; 1 if x is greater than max; otherwise, a value between 0 and 1 if x is in the range [min, max].
public static float smoothstep(float min, float max, float x)
{
float t = clamp((x - min) / (max - min), 0.0f, 1.0f);
return t * t * (3.0f - 2.0f * t);
}
/// Returns a smooth Hermite interpolation between 0 and 1, if x is in the range [min, max].
/// @returns Returns 0 if x is less than min; 1 if x is greater than max; otherwise, a value between 0 and 1 if x is in the range [min, max].
public static float2 smoothstep(float2 min, float2 max, float2 x)
{
float2 t = clamp((x - min) / (max - min), 0.0f, 1.0f);
return t * t * (3.0f - 2.0f * t);
}
/// Returns a smooth Hermite interpolation between 0 and 1, if x is in the range [min, max].
/// @returns Returns 0 if x is less than min; 1 if x is greater than max; otherwise, a value between 0 and 1 if x is in the range [min, max].
public static float3 smoothstep(float3 min, float3 max, float3 x)
{
float3 t = clamp((x - min) / (max - min), 0.0f, 1.0f);
return t * t * (3.0f - 2.0f * t);
}
/// Returns a smooth Hermite interpolation between 0 and 1, if x is in the range [min, max].
/// @returns Returns 0 if x is less than min; 1 if x is greater than max; otherwise, a value between 0 and 1 if x is in the range [min, max].
public static float4 smoothstep(float4 min, float4 max, float4 x)
{
float4 t = clamp((x - min) / (max - min), 0.0f, 1.0f);
return t * t * (3.0f - 2.0f * t);
}
#endregion
#region Reject / Project
/**
* Calculates the projection of a onto b
*/
public static float2 project(float2 a, float2 b)
{
return (b * (dot(a, b) / dot(b, b)));
}
/**
* Calculates the projection of a onto b
*/
public static float3 project(float3 a, float3 b)
{
return (b * (dot(a, b) / dot(b, b)));
}
/**
* Calculates the projection of a onto b
*/
public static float4 project(float4 a, float4 b)
{
return (b * (dot(a, b) / dot(b, b)));
}
/**
* Calculates the rejection of a from b
*/
public static float2 reject(float2 a, float2 b)
{
return (a - b * (dot(a, b) / dot(b, b)));
}
/**
* Calculates the rejection of a from b
*/
public static float3 reject(float3 a, float3 b)
{
return (a - b * (dot(a, b) / dot(b, b)));
}
/**
* Calculates the rejection of a from b
*/
public static float4 reject(float4 a, float4 b)
{
return (a - b * (dot(a, b) / dot(b, b)));
}
#endregion
#region dot
@@ -495,20 +809,7 @@ static class FancyMath
left.X * right.Y - left.Y * right.X);
}
#region Degrees / Radians
public static float2 toDegrees(float2 radians) => radians * MathHelper.RadToDeg;
public static float3 toDegrees(float3 radians) => radians * MathHelper.RadToDeg;
public static float4 toDegrees(float4 radians) => radians * MathHelper.RadToDeg;
public static float2 toRadians(float2 degrees) => degrees * MathHelper.DegToRad;
public static float3 toRadians(float3 degrees) => degrees * MathHelper.DegToRad;
public static float4 toRadians(float4 degrees) => degrees * MathHelper.DegToRad;
#endregion
// transpose und determinante für Matrizen
// sin, cos, tan, asin, acos, atan, atan2, cosh, sinh, tanh
}
GlitchyEngine/src/Math/MathHelper.bf
+13 -13
View File
@@ -30,19 +30,19 @@ namespace GlitchyEngine.Math
}
// Converts the given radians to degrees
public static Vector2 ToDegrees(Vector2 radians)
public static float2 ToDegrees(float2 radians)
{
return radians * RadToDeg;
}
// Converts the given radians to degrees
public static Vector3 ToDegrees(Vector3 radians)
public static float3 ToDegrees(float3 radians)
{
return radians * RadToDeg;
}
// Converts the given radians to degrees
public static Vector4 ToDegrees(Vector4 radians)
public static float4 ToDegrees(float4 radians)
{
return radians * RadToDeg;
}
@@ -54,19 +54,19 @@ namespace GlitchyEngine.Math
}
// Converts the given degrees to radians
public static Vector2 ToRadians(Vector2 degrees)
public static float2 ToRadians(float2 degrees)
{
return degrees * DegToRad;
}
// Converts the given degrees to radians
public static Vector3 ToRadians(Vector3 degrees)
public static float3 ToRadians(float3 degrees)
{
return degrees * DegToRad;
}
// Converts the given degrees to radians
public static Vector4 ToRadians(Vector4 degrees)
public static float4 ToRadians(float4 degrees)
{
return degrees * DegToRad;
}
@@ -79,24 +79,24 @@ namespace GlitchyEngine.Math
}
/// Returns the point that lies on the unit circle at the specified angle.
public static Vector2 CirclePoint(float angle, float radius = 1.0f)
public static float2 CirclePoint(float angle, float radius = 1.0f)
{
return .(Math.Cos(angle), Math.Sin(angle)) * radius;
}
public static Vector2 Pow(Vector2 v, float p)
public static float2 Pow(float2 v, float p)
{
return Vector2(Math.Pow(v.X, p), Math.Pow(v.Y, p));
return float2(Math.Pow(v.X, p), Math.Pow(v.Y, p));
}
public static Vector3 Pow(Vector3 v, float p)
public static float3 Pow(float3 v, float p)
{
return Vector3(Math.Pow(v.X, p), Math.Pow(v.Y, p), Math.Pow(v.Z, p));
return float3(Math.Pow(v.X, p), Math.Pow(v.Y, p), Math.Pow(v.Z, p));
}
public static Vector4 Pow(Vector4 v, float p)
public static float4 Pow(float4 v, float p)
{
return Vector4(Math.Pow(v.X, p), Math.Pow(v.Y, p), Math.Pow(v.Z, p), Math.Pow(v.W, p));
return float4(Math.Pow(v.X, p), Math.Pow(v.Y, p), Math.Pow(v.Z, p), Math.Pow(v.W, p));
}
}
}
GlitchyEngine/src/Math/Matrix.bf
+81 -84
View File
@@ -21,7 +21,7 @@ public struct Matrix
public using Values V;
public float[4][4] Values;
public Vector4[4] Columns;
public float4[4] Columns;
/// Creates a new zero-matrix.
public this() => this = default;
@@ -53,7 +53,7 @@ public struct Matrix
}
/// Creates a new matrix and initializes it with the given column-vectors.
public this(Vector4 c0, Vector4 c1, Vector4 c2, Vector4 c3)
public this(float4 c0, float4 c1, float4 c2, float4 c3)
{
Columns[0] = c0;
Columns[1] = c1;
@@ -61,47 +61,47 @@ public struct Matrix
Columns[3] = c3;
}
public ref Vector3 Right
public ref float3 Right
{
[Inline]
get
{
#unwarn
return ref *(Vector3*)&Columns[0];
return ref *(float3*)&Columns[0];
}
}
public ref Vector3 Up
public ref float3 Up
{
[Inline]
get
{
#unwarn
return ref *(Vector3*)&Columns[1];
return ref *(float3*)&Columns[1];
}
}
public ref Vector3 Forward
public ref float3 Forward
{
[Inline]
get
{
#unwarn
return ref *(Vector3*)&Columns[2];
return ref *(float3*)&Columns[2];
}
}
public ref Vector3 Translation
public ref float3 Translation
{
[Inline]
get
{
#unwarn
return ref *(Vector3*)&Columns[3];
return ref *(float3*)&Columns[3];
}
}
public Vector3 Scale
public float3 Scale
{
[Inline]
get => .(_11, _22, _33);
@@ -134,12 +134,12 @@ public struct Matrix
}
}
public ref Vector4 this[int column]
public ref float4 this[int column]
{
get
{
#unwarn
return ref *(Vector4*)&Columns[column];
return ref *(float4*)&Columns[column];
}
@@ -150,7 +150,7 @@ public struct Matrix
Internal.ThrowIndexOutOfRange();
#unwarn
return ref *(Vector4*)&Columns[column];
return ref *(float4*)&Columns[column];
}
}
@@ -351,12 +351,12 @@ public struct Matrix
/**
* Multiplies a matrix and a column-vector resulting in a column vector.
*/
public static Vector4 operator *(Matrix matrix, Vector4 columnVector)
public static float4 operator *(Matrix matrix, float4 columnVector)
{
#unwarn
var m = &matrix.V;
Vector4 result = ?;
float4 result = ?;
result.X = (m._11 * columnVector.X) + (m._12 * columnVector.Y) + (m._13 * columnVector.Z) + (m._14 * columnVector.W);
result.Y = (m._21 * columnVector.X) + (m._22 * columnVector.Y) + (m._23 * columnVector.Z) + (m._24 * columnVector.W);
result.Z = (m._31 * columnVector.X) + (m._32 * columnVector.Y) + (m._33 * columnVector.Z) + (m._34 * columnVector.W);
@@ -367,12 +367,12 @@ public struct Matrix
/**
* Multiplies a row-vector and a matrix resulting in a row vector.
*/
public static Vector4 operator *(Vector4 rowVector, Matrix matrix)
public static float4 operator *(float4 rowVector, Matrix matrix)
{
#unwarn
var m = &matrix.V;
Vector4 result = ?;
float4 result = ?;
result.X = (rowVector.X * m._11) + (rowVector.Y * m._21) + (rowVector.Z * m._31) + (rowVector.W * m._41);
result.Y = (rowVector.X * m._12) + (rowVector.Y * m._22) + (rowVector.Z * m._32) + (rowVector.W * m._42);
result.Z = (rowVector.X * m._13) + (rowVector.Y * m._23) + (rowVector.Z * m._33) + (rowVector.W * m._43);
@@ -406,7 +406,7 @@ public struct Matrix
0, 0, 0, 1);
}
public static Matrix Scaling(Vector3 scale)
public static Matrix Scaling(float3 scale)
{
return .(scale.X, 0, 0, 0,
0, scale.Y, 0, 0,
@@ -422,7 +422,7 @@ public struct Matrix
0, 0, 0, 1);
}
public static Matrix Translation(Vector3 translation)
public static Matrix Translation(float3 translation)
{
return .(1, 0, 0, translation.X,
0, 1, 0, translation.Y,
@@ -470,25 +470,22 @@ public struct Matrix
* @param up A vector defining the up direction of the camera.
* @returns a view matrix.
*/
public static Matrix LookAt(Vector3 position, Vector3 target, Vector3 up)
public static Matrix LookAt(float3 position, float3 target, float3 up)
{
Vector3 forward = target - position;
forward.Normalize();
float3 forward = normalize(target - position);
Vector3 right = Vector3.Cross(up, forward);
right.Normalize();
float3 right = normalize(cross(up, forward));
Vector3 newUp = Vector3.Cross(forward, right);
newUp.Normalize();
float3 newUp = normalize(cross(forward, right));
Matrix result = .Identity;
result.Forward = forward;
result.Up = up;
result.Right = right;
result.Translation.X = -Vector3.Dot(position, right);
result.Translation.Y = -Vector3.Dot(position, up);
result.Translation.Z = -Vector3.Dot(position, forward);
result.Translation.X = -dot(position, right);
result.Translation.Y = -dot(position, up);
result.Translation.Z = -dot(position, forward);
return result;
}
@@ -511,22 +508,22 @@ public struct Matrix
{
// From: Lengyel, Eric. Foundations of Game Engine Development, Volume 1: Mathematics (S.61). Kindle-Version.
Vector3 a = *(Vector3*)&Columns[0];
Vector3 b = *(Vector3*)&Columns[1];
Vector3 c = *(Vector3*)&Columns[2];
Vector3 d = *(Vector3*)&Columns[3];
float3 a = *(float3*)&Columns[0];
float3 b = *(float3*)&Columns[1];
float3 c = *(float3*)&Columns[2];
float3 d = *(float3*)&Columns[3];
float x = this[3, 0];
float y = this[3, 1];
float z = this[3, 2];
float w = this[3, 3];
Vector3 s = Vector3.Cross(a, b);
Vector3 t = Vector3.Cross(c, d);
Vector3 u = y * a - x * b;
Vector3 v = w * c - z * d;
float3 s = cross(a, b);
float3 t = cross(c, d);
float3 u = y * a - x * b;
float3 v = w * c - z * d;
return Vector3.Dot(s, v) + Vector3.Dot(t, u);
return dot(s, v) + dot(t, u);
}
/**
@@ -537,39 +534,39 @@ public struct Matrix
// From: Lengyel, Eric. Foundations of Game Engine Development, Volume 1: Mathematics (S.61). Kindle-Version.
#unwarn
Vector3 a = *(Vector3*)&Columns[0];
float3 a = *(float3*)&Columns[0];
#unwarn
Vector3 b = *(Vector3*)&Columns[1];
float3 b = *(float3*)&Columns[1];
#unwarn
Vector3 c = *(Vector3*)&Columns[2];
float3 c = *(float3*)&Columns[2];
#unwarn
Vector3 d = *(Vector3*)&Columns[3];
float3 d = *(float3*)&Columns[3];
float x = this[3, 0];
float y = this[3, 1];
float z = this[3, 2];
float w = this[3, 3];
Vector3 s = Vector3.Cross(a, b);
Vector3 t = Vector3.Cross(c, d);
Vector3 u = y * a - x * b;
Vector3 v = w * c - z * d;
float3 s = cross(a, b);
float3 t = cross(c, d);
float3 u = y * a - x * b;
float3 v = w * c - z * d;
float invDet = 1.0f / (Vector3.Dot(s, v) + Vector3.Dot(t, u));
float invDet = 1.0f / (dot(s, v) + dot(t, u));
s *= invDet;
t *= invDet;
u *= invDet;
v *= invDet;
Vector3 r0 = Vector3.Cross(b, v) + t * y;
Vector3 r1 = Vector3.Cross(v, a) - t * x;
Vector3 r2 = Vector3.Cross(d, u) + s * w;
Vector3 r3 = Vector3.Cross(u, c) - s * z;
return .(r0.X, r0.Y, r0.Z, -Vector3.Dot(b, t),
r1.X, r1.Y, r1.Z, Vector3.Dot(a, t),
r2.X, r2.Y, r2.Z, -Vector3.Dot(d, s),
r3.X, r3.Y, r3.Z, Vector3.Dot(c, s));
float3 r0 = cross(b, v) + t * y;
float3 r1 = cross(v, a) - t * x;
float3 r2 = cross(d, u) + s * w;
float3 r3 = cross(u, c) - s * z;
return .(r0.X, r0.Y, r0.Z, -dot(b, t),
r1.X, r1.Y, r1.Z, dot(a, t),
r2.X, r2.Y, r2.Z, -dot(d, s),
r3.X, r3.Y, r3.Z, dot(c, s));
}
/// Calculates the inverse of the matrix.
@@ -578,39 +575,39 @@ public struct Matrix
// From: Lengyel, Eric. Foundations of Game Engine Development, Volume 1: Mathematics (S.61). Kindle-Version.
#unwarn
Vector3 a = *(Vector3*)&matrix.Columns[0];
float3 a = *(float3*)&matrix.Columns[0];
#unwarn
Vector3 b = *(Vector3*)&matrix.Columns[1];
float3 b = *(float3*)&matrix.Columns[1];
#unwarn
Vector3 c = *(Vector3*)&matrix.Columns[2];
float3 c = *(float3*)&matrix.Columns[2];
#unwarn
Vector3 d = *(Vector3*)&matrix.Columns[3];
float3 d = *(float3*)&matrix.Columns[3];
float x = matrix[3, 0];
float y = matrix[3, 1];
float z = matrix[3, 2];
float w = matrix[3, 3];
Vector3 s = Vector3.Cross(a, b);
Vector3 t = Vector3.Cross(c, d);
Vector3 u = y * a - x * b;
Vector3 v = w * c - z * d;
float3 s = cross(a, b);
float3 t = cross(c, d);
float3 u = y * a - x * b;
float3 v = w * c - z * d;
float invDet = 1.0f / (Vector3.Dot(s, v) + Vector3.Dot(t, u));
float invDet = 1.0f / (dot(s, v) + dot(t, u));
s *= invDet;
t *= invDet;
u *= invDet;
v *= invDet;
Vector3 r0 = Vector3.Cross(b, v) + t * y;
Vector3 r1 = Vector3.Cross(v, a) - t * x;
Vector3 r2 = Vector3.Cross(d, u) + s * w;
Vector3 r3 = Vector3.Cross(u, c) - s * z;
return .(r0.X, r0.Y, r0.Z, -Vector3.Dot(b, t),
r1.X, r1.Y, r1.Z, Vector3.Dot(a, t),
r2.X, r2.Y, r2.Z, -Vector3.Dot(d, s),
r3.X, r3.Y, r3.Z, Vector3.Dot(c, s));
float3 r0 = cross(b, v) + t * y;
float3 r1 = cross(v, a) - t * x;
float3 r2 = cross(d, u) + s * w;
float3 r3 = cross(u, c) - s * z;
return .(r0.X, r0.Y, r0.Z, -dot(b, t),
r1.X, r1.Y, r1.Z, dot(a, t),
r2.X, r2.Y, r2.Z, -dot(d, s),
r3.X, r3.Y, r3.Z, dot(c, s));
}
/**
@@ -792,9 +789,9 @@ public struct Matrix
*/
public void Orthogonalize() mut
{
Columns[1] -= .Project(Columns[1], Columns[0]);
Columns[2] -= .Project(Columns[2], Columns[0]) + .Project(Columns[2], Columns[1]);
Columns[3] -= .Project(Columns[3], Columns[0]) + .Project(Columns[3], Columns[1]) + .Project(Columns[3], Columns[2]);
Columns[1] -= project(Columns[1], Columns[0]);
Columns[2] -= project(Columns[2], Columns[0]) + project(Columns[2], Columns[1]);
Columns[3] -= project(Columns[3], Columns[0]) + project(Columns[3], Columns[1]) + project(Columns[3], Columns[2]);
}
/**
@@ -802,10 +799,10 @@ public struct Matrix
*/
public void Orthonormalize() mut
{
Columns[0].Normalize();
Columns[1] = .Normalize(.Reject(Columns[1], Columns[0]));
Columns[2] = .Normalize(.Reject(.Reject(Columns[2], Columns[0]), Columns[1]));
Columns[3] = .Normalize(.Reject(.Reject(.Reject(Columns[2], Columns[0]), Columns[1]), Columns[2]));
Columns[0] = normalize(Columns[0]);
Columns[1] = normalize(reject(Columns[1], Columns[0]));
Columns[2] = normalize(reject(reject(Columns[2], Columns[0]), Columns[1]));
Columns[3] = normalize(reject(reject(reject(Columns[2], Columns[0]), Columns[1]), Columns[2]));
}
public static Self RotationQuaternion(Quaternion rotation)
{
@@ -845,7 +842,7 @@ public struct Matrix
return result;
}
public static void Decompose(Self matrix, out Vector3 position, out Quaternion rotation, out Vector3 scale)
public static void Decompose(Self matrix, out float3 position, out Quaternion rotation, out float3 scale)
{
var matrix;
@@ -857,9 +854,9 @@ public struct Matrix
// TODO: this doesn't detect mirroring
// Extract scaling from matrix
scale.X = (*(Vector3*)&matrix.Columns[0]).Magnitude();
scale.Y = (*(Vector3*)&matrix.Columns[1]).Magnitude();
scale.Z = (*(Vector3*)&matrix.Columns[2]).Magnitude();
scale.X = length(*(float3*)&matrix.Columns[0]);
scale.Y = length(*(float3*)&matrix.Columns[1]);
scale.Z = length(*(float3*)&matrix.Columns[2]);
if(MathHelper.IsZero(scale.X) || MathHelper.IsZero(scale.Y) || MathHelper.IsZero(scale.Z))
{
GlitchyEngine/src/Math/Quaternion.bf
+17 -17
View File
@@ -22,7 +22,7 @@ namespace GlitchyEngine.Math
W = w;
}
public this(Vector3 xy, float z, float w)
public this(float3 xy, float z, float w)
{
X = xy.X;
Y = xy.Y;
@@ -30,7 +30,7 @@ namespace GlitchyEngine.Math
W = w;
}
public this(Vector3 xyz, float w)
public this(float3 xyz, float w)
{
X = xyz.X;
Y = xyz.Y;
@@ -38,7 +38,7 @@ namespace GlitchyEngine.Math
W = w;
}
public this(Vector4 vector)
public this(float4 vector)
{
X = vector.X;
Y = vector.Y;
@@ -46,7 +46,7 @@ namespace GlitchyEngine.Math
W = vector.W;
}
public Vector3 Vector
public float3 Vector
{
get => .(X, Y, Z);
set mut
@@ -195,11 +195,11 @@ namespace GlitchyEngine.Math
{
Quaternion result;
Vector3 v = l.Vector * r.Vector + (l.W * r.Vector) + (r.W * l.Vector);
float3 v = l.Vector * r.Vector + (l.W * r.Vector) + (r.W * l.Vector);
result.X = v.X;
result.Y = v.Y;
result.Z = v.Z;
result.W = (l.W * r.W) - Vector3.Dot(l.Vector, r.Vector);
result.W = (l.W * r.W) - dot(l.Vector, r.Vector);
return result;
}
@@ -220,11 +220,11 @@ namespace GlitchyEngine.Math
[Inline]
#unwarn
public static implicit operator Vector4(in Self value) => *(Vector4*)&value;
public static implicit operator float4(in Self value) => *(float4*)&value;
[Inline]
#unwarn
public static implicit operator Quaternion(in Vector4 value) => *(Quaternion*)&value;
public static implicit operator Quaternion(in float4 value) => *(Quaternion*)&value;
public static bool operator ==(Quaternion l, Quaternion r)
{
@@ -236,7 +236,7 @@ namespace GlitchyEngine.Math
return l.X != r.X && l.Y != r.Y && l.Z != r.Z && l.W != r.W;
}
public (Vector3 Axis, float Angle) ToAxisAngle()
public (float3 Axis, float Angle) ToAxisAngle()
{
// scalar part = cos(θ/2)
// So, we can extract the angle directly.
@@ -247,12 +247,12 @@ namespace GlitchyEngine.Math
// We assume quaternion is unit length, so subtracting w^2 gives us length of just vector part (aka sin(θ/2)).
float length = Math.Sqrt(1.0f - (W * W));
Vector3 axis;
float3 axis;
// Normalize vector part to get the axis!
if(length == 0)
{
axis = Vector3.Zero;
axis = float3.Zero;
}
else
{
@@ -265,9 +265,9 @@ namespace GlitchyEngine.Math
return (axis, angle);
}
public static Quaternion FromAxisAngle(Vector3 axis, float angle)
public static Quaternion FromAxisAngle(float3 axis, float angle)
{
float lengthSq = axis.MagnitudeSquared();
float lengthSq = lengthSq(axis);
if(lengthSq == 0)
{
@@ -316,11 +316,11 @@ namespace GlitchyEngine.Math
return result;
}
public static Vector3 ToEulerAngles(Quaternion q)
public static float3 ToEulerAngles(Quaternion q)
{
// http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToEuler/
Vector3 result;
float3 result;
float sqw = q.W*q.W;
float sqx = q.X*q.X;
@@ -354,7 +354,7 @@ namespace GlitchyEngine.Math
float y = 2.0f * (Y * Z + W * X);
float x = W * W - X * X - Y * Y + Z * Z;
if (Vector2(x, y).Equals(.Zero)) //avoid atan2(0,0) - handle singularity - Matiis
if (float2(x, y).Equals(.Zero)) //avoid atan2(0,0) - handle singularity - Matiis
return 2.0f * Math.Atan2(X, W);
return Math.Atan2(y, x);
@@ -370,7 +370,7 @@ namespace GlitchyEngine.Math
float y = 2.0f * (X * Y + W * Z);
float x = W * W + X * X - Y * Y - Z * Z;
if (Vector2(x, y).Equals(.Zero)) //avoid atan2(0,0) - handle singularity - Matiis
if (float2(x, y).Equals(.Zero)) //avoid atan2(0,0) - handle singularity - Matiis
return 0;
return Math.Atan2(y, x);
GlitchyEngine/src/Math/Vector3.bf
+55 -55
View File
@@ -5,20 +5,20 @@ namespace GlitchyEngine.Math
{
[BonTarget]
[SwizzleVector(3, "GlitchyEngine.Math.Vector")]
public struct Vector3
public struct float3
{
public const Vector3 Zero = .(0f, 0f, 0f);
public const Vector3 UnitX = .(1f, 0f, 0f);
public const Vector3 UnitY = .(0f, 1f, 0f);
public const Vector3 UnitZ = .(0f, 0f, 1f);
public const Vector3 One = .(1f, 1f, 1f);
public const float3 Zero = .(0f, 0f, 0f);
public const float3 UnitX = .(1f, 0f, 0f);
public const float3 UnitY = .(0f, 1f, 0f);
public const float3 UnitZ = .(0f, 0f, 1f);
public const float3 One = .(1f, 1f, 1f);
public const Vector3 Forward = .(0f, 0f, 1f);
public const Vector3 Backward = .(0f, 0f, -1f);
public const Vector3 Left = .(-1f, 0f, 0f);
public const Vector3 Right = .(1f, 0f, 0f);
public const Vector3 Up = .(0f, 1f, 0f);
public const Vector3 Down = .(0f, -1f, 0f);
public const float3 Forward = .(0f, 0f, 1f);
public const float3 Backward = .(0f, 0f, -1f);
public const float3 Left = .(-1f, 0f, 0f);
public const float3 Right = .(1f, 0f, 0f);
public const float3 Up = .(0f, 1f, 0f);
public const float3 Down = .(0f, -1f, 0f);
public const int ComponentCount = 3;
@@ -47,14 +47,14 @@ namespace GlitchyEngine.Math
Z = z;
}
public this(Vector3 value)
public this(float3 value)
{
X = value.X;
Y = value.Y;
Z = value.Z;
}
public this(Vector4 value)
public this(float4 value)
{
X = value.X;
Y = value.Y;
@@ -131,7 +131,7 @@ namespace GlitchyEngine.Math
/// Returns a copy of this Vector with a magnitude of 1.
[Checked]
public Vector3 Normalized()
public float3 Normalized()
{
if(this == .Zero)
return .Zero;
@@ -140,28 +140,28 @@ namespace GlitchyEngine.Math
}
/// Returns a copy of this Vector with a magnitude of 1.
public Vector3 Normalized()
public float3 Normalized()
{
return this / Magnitude();
}
/// Returns a copy of the given Vector with a magnitude of 1.
public static Vector3 Normalize(Vector3 v)
public static float3 Normalize(float3 v)
{
return v / v.Magnitude();
}
/// Calculates the dot product of two vectors.
public static float Dot(Vector3 l, Vector3 r) => l.X * r.X + l.Y * r.Y + l.Z * r.Z;
public static float Dot(float3 l, float3 r) => l.X * r.X + l.Y * r.Y + l.Z * r.Z;
/// Calculates the distance between two vectors.
public static float Distance(Vector3 a, Vector3 b) => (a - b).[Inline]Magnitude();
public static float Distance(float3 a, float3 b) => (a - b).[Inline]Magnitude();
/// Calculates the squared distance between two vectors.
public static float DistanceSquared(Vector3 a, Vector3 b) => (a - b).[Inline]MagnitudeSquared();
public static float DistanceSquared(float3 a, float3 b) => (a - b).[Inline]MagnitudeSquared();
/// Calculates the cross product of two vectors.
public static Vector3 Cross(Vector3 l, Vector3 r)
public static float3 Cross(float3 l, float3 r)
{
return .(l.Y * r.Z - l.Z * r.Y,
l.Z * r.X - l.X * r.Z,
@@ -169,20 +169,20 @@ namespace GlitchyEngine.Math
}
/// Calculates the projection of a onto b.
public static Vector3 Project(Vector3 a, Vector3 b)
public static float3 Project(float3 a, float3 b)
{
return (b * (Dot(a, b) / Dot(b, b)));
}
/// Calculates the rejection of a from b.
public static Vector3 Reject(Vector3 a, Vector3 b)
public static float3 Reject(float3 a, float3 b)
{
return (a - b * (Dot(a, b) / Dot(b, b)));
}
public static Vector3 Floor(Vector3 value) => .(Math.Floor(value.X), Math.Floor(value.Y), Math.Floor(value.Z));
public static float3 Floor(float3 value) => .(Math.Floor(value.X), Math.Floor(value.Y), Math.Floor(value.Z));
public static Vector3 Ceiling(Vector3 value) => .(Math.Ceiling(value.X), Math.Ceiling(value.Y), Math.Ceiling(value.Z));
public static float3 Ceiling(float3 value) => .(Math.Ceiling(value.X), Math.Ceiling(value.Y), Math.Ceiling(value.Z));
/**
* Interpolates linearly between two given vectors.
@@ -192,18 +192,18 @@ namespace GlitchyEngine.Math
* (0 means a will be returned, 1 means b will be returned.)
* @returns The resulting linear interpolation.
*/
public static Vector3 Lerp(Vector3 a, Vector3 b, float interpolationValue)
public static float3 Lerp(float3 a, float3 b, float interpolationValue)
{
return a + interpolationValue * (b - a);
}
public static Vector3 Min(Vector3 a, Vector3 b) => .(Math.Min(a.X, b.X), Math.Min(a.Y, b.Y), Math.Min(a.Z, b.Z));
public static float3 Min(float3 a, float3 b) => .(Math.Min(a.X, b.X), Math.Min(a.Y, b.Y), Math.Min(a.Z, b.Z));
public static Vector3 Max(Vector3 a, Vector3 b) => .(Math.Max(a.X, b.X), Math.Max(a.Y, b.Y), Math.Min(a.Z, b.Z));
public static float3 Max(float3 a, float3 b) => .(Math.Max(a.X, b.X), Math.Max(a.Y, b.Y), Math.Min(a.Z, b.Z));
public static Vector3 Abs(Vector3 v) => .(Math.Abs(v.X), Math.Abs(v.Y), Math.Abs(v.Z));
public static float3 Abs(float3 v) => .(Math.Abs(v.X), Math.Abs(v.Y), Math.Abs(v.Z));
public static Vector3 Clamp(Vector3 v, Vector3 min, Vector3 max)
public static float3 Clamp(float3 v, float3 min, float3 max)
{
return .(Math.Clamp(v.X, min.X, max.X),
Math.Clamp(v.Y, min.Y, max.Y),
@@ -216,7 +216,7 @@ namespace GlitchyEngine.Math
// Addition
public void operator +=(Vector3 value) mut
public void operator +=(float3 value) mut
{
X += value.X;
Y += value.Y;
@@ -232,7 +232,7 @@ namespace GlitchyEngine.Math
// Subtraction
public void operator -=(Vector3 value) mut
public void operator -=(float3 value) mut
{
X -= value.X;
Y -= value.Y;
@@ -248,7 +248,7 @@ namespace GlitchyEngine.Math
// Multiplication
public void operator *=(Vector3 value) mut
public void operator *=(float3 value) mut
{
X *= value.X;
Y *= value.Y;
@@ -264,7 +264,7 @@ namespace GlitchyEngine.Math
// Division
public void operator /=(Vector3 value) mut
public void operator /=(float3 value) mut
{
X /= value.X;
Y /= value.Y;
@@ -285,57 +285,57 @@ namespace GlitchyEngine.Math
// Addition
public static Vector3 operator +(Vector3 left, Vector3 right) => Vector3(left.X + right.X, left.Y + right.Y, left.Z + right.Z);
public static float3 operator +(float3 left, float3 right) => float3(left.X + right.X, left.Y + right.Y, left.Z + right.Z);
public static Vector3 operator +(Vector3 value, float scalar) => Vector3(value.X + scalar, value.Y + scalar, value.Z + scalar);
public static float3 operator +(float3 value, float scalar) => float3(value.X + scalar, value.Y + scalar, value.Z + scalar);
public static Vector3 operator +(float scalar, Vector3 value) => Vector3(scalar + value.X, scalar + value.Y, scalar + value.Z);
public static float3 operator +(float scalar, float3 value) => float3(scalar + value.X, scalar + value.Y, scalar + value.Z);
public static Vector3 operator +(Vector3 value) => value;
public static float3 operator +(float3 value) => value;
// Subtraction
public static Vector3 operator -(Vector3 left, Vector3 right) => Vector3(left.X - right.X, left.Y - right.Y, left.Z - right.Z);
public static float3 operator -(float3 left, float3 right) => float3(left.X - right.X, left.Y - right.Y, left.Z - right.Z);
public static Vector3 operator -(Vector3 value, float scalar) => Vector3(value.X - scalar, value.Y - scalar, value.Z - scalar);
public static float3 operator -(float3 value, float scalar) => float3(value.X - scalar, value.Y - scalar, value.Z - scalar);
public static Vector3 operator -(float scalar, Vector3 value) => Vector3(scalar - value.X, scalar - value.Y, scalar - value.Z);
public static float3 operator -(float scalar, float3 value) => float3(scalar - value.X, scalar - value.Y, scalar - value.Z);
public static Vector3 operator -(Vector3 value) => Vector3(-value.X, -value.Y, -value.Z);
public static float3 operator -(float3 value) => float3(-value.X, -value.Y, -value.Z);
// Multiplication
public static Vector3 operator *(Vector3 left, Vector3 right) => Vector3(left.X * right.X, left.Y * right.Y, left.Z * right.Z);
public static float3 operator *(float3 left, float3 right) => float3(left.X * right.X, left.Y * right.Y, left.Z * right.Z);
public static Vector3 operator *(Vector3 value, float scalar) => Vector3(value.X * scalar, value.Y * scalar, value.Z * scalar);
public static float3 operator *(float3 value, float scalar) => float3(value.X * scalar, value.Y * scalar, value.Z * scalar);
public static Vector3 operator *(float scalar, Vector3 value) => Vector3(scalar * value.X, scalar * value.Y, scalar * value.Z);
public static float3 operator *(float scalar, float3 value) => float3(scalar * value.X, scalar * value.Y, scalar * value.Z);
// Division
public static Vector3 operator /(Vector3 left, Vector3 right) => Vector3(left.X / right.X, left.Y / right.Y, left.Z / right.Z);
public static float3 operator /(float3 left, float3 right) => float3(left.X / right.X, left.Y / right.Y, left.Z / right.Z);
public static Vector3 operator /(Vector3 value, float scalar)
public static float3 operator /(float3 value, float scalar)
{
float inv = 1.0f / scalar;
return Vector3(value.X * inv, value.Y * inv, value.Z * inv);
return float3(value.X * inv, value.Y * inv, value.Z * inv);
}
public static Vector3 operator /(float scalar, Vector3 value) => Vector3(scalar / value.X, scalar / value.Y, scalar / value.Z);
public static float3 operator /(float scalar, float3 value) => float3(scalar / value.X, scalar / value.Y, scalar / value.Z);
// Modulo
public static Vector3 operator %(Vector3 left, Vector3 right) => Vector3(left.X % right.X, left.Y % right.Y, left.Z % right.Z);
public static float3 operator %(float3 left, float3 right) => float3(left.X % right.X, left.Y % right.Y, left.Z % right.Z);
public static Vector3 operator %(Vector3 value, float scalar) => Vector3(value.X % scalar, value.Y % scalar, value.Z % scalar);
public static float3 operator %(float3 value, float scalar) => float3(value.X % scalar, value.Y % scalar, value.Z % scalar);
public static Vector3 operator %(float scalar, Vector3 value) => Vector3(scalar % value.X, scalar % value.Y, scalar % value.Z);
public static float3 operator %(float scalar, float3 value) => float3(scalar % value.X, scalar % value.Y, scalar % value.Z);
// Equality
public static bool operator ==(Vector3 left, Vector3 right) => left.X == right.X && left.Y == right.Y && left.Z == right.Z;
public static bool operator ==(float3 left, float3 right) => left.X == right.X && left.Y == right.Y && left.Z == right.Z;
public static bool operator !=(Vector3 left, Vector3 right) => left.X != right.X || left.Y != right.Y || left.Z != right.Z;
public static bool operator !=(float3 left, float3 right) => left.X != right.X || left.Y != right.Y || left.Z != right.Z;
public override void ToString(String strBuffer) => strBuffer.AppendF("X:{0} Y:{1} Z:{2}", X, Y, Z);
@@ -344,6 +344,6 @@ namespace GlitchyEngine.Math
[Inline]
#unwarn
public static explicit operator float[3](Vector3 value) => *(float[3]*)&value;
public static explicit operator float[3](float3 value) => *(float[3]*)&value;
}
}
GlitchyEngine/src/Math/Vector4.bf
+38 -38
View File
@@ -5,14 +5,14 @@ namespace GlitchyEngine.Math
{
[BonTarget]
[SwizzleVector(4, "GlitchyEngine.Math.Vector")]
public struct Vector4
public struct float4
{
public const Vector4 Zero = .(0f, 0f, 0f, 0f);
public const Vector4 UnitX = .(1f, 0f, 0f, 0f);
public const Vector4 UnitY = .(0f, 1f, 0f, 0f);
public const Vector4 UnitZ = .(0f, 0f, 1f, 0f);
public const Vector4 UnitW = .(0f, 0f, 0f, 1f);
public const Vector4 One = .(1f, 1f, 1f, 1f);
public const float4 Zero = .(0f, 0f, 0f, 0f);
public const float4 UnitX = .(1f, 0f, 0f, 0f);
public const float4 UnitY = .(0f, 1f, 0f, 0f);
public const float4 UnitZ = .(0f, 0f, 1f, 0f);
public const float4 UnitW = .(0f, 0f, 0f, 1f);
public const float4 One = .(1f, 1f, 1f, 1f);
public const int ComponentCount = 4;
@@ -44,7 +44,7 @@ namespace GlitchyEngine.Math
W = value2.Y;
}
public this(Vector3 value, float w)
public this(float3 value, float w)
{
X = value.X;
Y = value.Y;
@@ -133,7 +133,7 @@ namespace GlitchyEngine.Math
this /= Magnitude();
}
public static Vector4 Normalize(Vector4 v)
public static float4 Normalize(float4 v)
{
if(v == .Zero)
return .Zero;
@@ -142,12 +142,12 @@ namespace GlitchyEngine.Math
}
[Unchecked]
public static Vector4 Normalize(Vector4 v)
public static float4 Normalize(float4 v)
{
return v / v.Magnitude();
}
public static float Dot(Vector4 l, Vector4 r)
public static float Dot(float4 l, float4 r)
{
return l.X * r.X + l.Y * r.Y + l.Z * r.Z + l.W * r.W;
}
@@ -155,7 +155,7 @@ namespace GlitchyEngine.Math
/**
* Calculates the projection of a onto b
*/
public static Vector4 Project(Vector4 a, Vector4 b)
public static float4 Project(float4 a, float4 b)
{
return (b * (Dot(a, b) / Dot(b, b)));
}
@@ -163,7 +163,7 @@ namespace GlitchyEngine.Math
/**
* Calculates the rejection of a from b
*/
public static Vector4 Reject(Vector4 a, Vector4 b)
public static float4 Reject(float4 a, float4 b)
{
return (a - b * (Dot(a, b) / Dot(b, b)));
}
@@ -176,17 +176,17 @@ namespace GlitchyEngine.Math
* (0 means a will be returned, 1 means b will be returned.)
* @returns The resulting linear interpolation.
*/
public static Vector4 Lerp(Vector4 a, Vector4 b, float interpolationValue)
public static float4 Lerp(float4 a, float4 b, float interpolationValue)
{
return a + interpolationValue * (b - a);
}
public static Vector4 Min(Vector4 a, Vector4 b)
public static float4 Min(float4 a, float4 b)
{
return .(Math.Min(a.X, b.X), Math.Min(a.Y, b.Y), Math.Min(a.Z, b.Z), Math.Min(a.W, b.W));
}
public static Vector4 Max(Vector4 a, Vector4 b)
public static float4 Max(float4 a, float4 b)
{
return .(Math.Max(a.X, b.X), Math.Max(a.Y, b.Y), Math.Min(a.Z, b.Z), Math.Min(a.W, b.W));
}
@@ -197,7 +197,7 @@ namespace GlitchyEngine.Math
// Addition
public void operator +=(Vector4 value) mut
public void operator +=(float4 value) mut
{
X += value.X;
Y += value.Y;
@@ -215,7 +215,7 @@ namespace GlitchyEngine.Math
// Subtraction
public void operator -=(Vector4 value) mut
public void operator -=(float4 value) mut
{
X -= value.X;
Y -= value.Y;
@@ -233,7 +233,7 @@ namespace GlitchyEngine.Math
// Multiplication
public void operator *=(Vector4 value) mut
public void operator *=(float4 value) mut
{
X *= value.X;
Y *= value.Y;
@@ -260,7 +260,7 @@ namespace GlitchyEngine.Math
W *= f;
}
public void operator /=(Vector4 value) mut
public void operator /=(float4 value) mut
{
X /= value.X;
Y /= value.Y;
@@ -274,49 +274,49 @@ namespace GlitchyEngine.Math
// Addition
public static Vector4 operator +(Vector4 left, Vector4 right) => Vector4(left.X + right.X, left.Y + right.Y, left.Z + right.Z, left.W + right.W);
public static float4 operator +(float4 left, float4 right) => float4(left.X + right.X, left.Y + right.Y, left.Z + right.Z, left.W + right.W);
public static Vector4 operator +(Vector4 value, float scalar) => Vector4(value.X + scalar, value.Y + scalar, value.Z + scalar, value.W + scalar);
public static float4 operator +(float4 value, float scalar) => float4(value.X + scalar, value.Y + scalar, value.Z + scalar, value.W + scalar);
public static Vector4 operator +(float scalar, Vector4 value) => Vector4(scalar + value.X, scalar + value.Y, scalar + value.Z, scalar + value.W);
public static float4 operator +(float scalar, float4 value) => float4(scalar + value.X, scalar + value.Y, scalar + value.Z, scalar + value.W);
public static Vector4 operator +(Vector4 value) => value;
public static float4 operator +(float4 value) => value;
// Subtraction
public static Vector4 operator -(Vector4 left, Vector4 right) => Vector4(left.X - right.X, left.Y - right.Y, left.Z - right.Z, left.W - right.W);
public static float4 operator -(float4 left, float4 right) => float4(left.X - right.X, left.Y - right.Y, left.Z - right.Z, left.W - right.W);
public static Vector4 operator -(Vector4 value, float scalar) => Vector4(value.X - scalar, value.Y - scalar, value.Z - scalar, value.W - scalar);
public static float4 operator -(float4 value, float scalar) => float4(value.X - scalar, value.Y - scalar, value.Z - scalar, value.W - scalar);
public static Vector4 operator -(float scalar, Vector4 value) => Vector4(scalar - value.X, scalar - value.Y, scalar - value.Z, scalar - value.W);
public static float4 operator -(float scalar, float4 value) => float4(scalar - value.X, scalar - value.Y, scalar - value.Z, scalar - value.W);
public static Vector4 operator -(Vector4 value) => Vector4(-value.X, -value.Y, -value.Z, -value.W);
public static float4 operator -(float4 value) => float4(-value.X, -value.Y, -value.Z, -value.W);
// Multiplication
public static Vector4 operator *(Vector4 left, Vector4 right) => Vector4(left.X * right.X, left.Y * right.Y, left.Z * right.Z, left.W * right.W);
public static float4 operator *(float4 left, float4 right) => float4(left.X * right.X, left.Y * right.Y, left.Z * right.Z, left.W * right.W);
public static Vector4 operator *(Vector4 value, float scalar) => Vector4(value.X * scalar, value.Y * scalar, value.Z * scalar, value.W * scalar);
public static float4 operator *(float4 value, float scalar) => float4(value.X * scalar, value.Y * scalar, value.Z * scalar, value.W * scalar);
public static Vector4 operator *(float scalar, Vector4 value) => Vector4(scalar * value.X, scalar * value.Y, scalar * value.Z, scalar * value.W);
public static float4 operator *(float scalar, float4 value) => float4(scalar * value.X, scalar * value.Y, scalar * value.Z, scalar * value.W);
// Division
public static Vector4 operator /(Vector4 left, Vector4 right) => Vector4(left.X / right.X, left.Y / right.Y, left.Z / right.Z, left.W / right.W);
public static float4 operator /(float4 left, float4 right) => float4(left.X / right.X, left.Y / right.Y, left.Z / right.Z, left.W / right.W);
public static Vector4 operator /(Vector4 value, float scalar)
public static float4 operator /(float4 value, float scalar)
{
float inv = 1.0f / scalar;
return Vector4(value.X * inv, value.Y * inv, value.Z * inv, value.W * inv);
return float4(value.X * inv, value.Y * inv, value.Z * inv, value.W * inv);
}
public static Vector4 operator /(float scalar, Vector4 value) => Vector4(scalar / value.X, scalar / value.Y, scalar / value.Z, scalar / value.W);
public static float4 operator /(float scalar, float4 value) => float4(scalar / value.X, scalar / value.Y, scalar / value.Z, scalar / value.W);
// Equality
public static bool operator ==(Vector4 left, Vector4 right) => left.X == right.X && left.Y == right.Y && left.Z == right.Z && left.W == right.W;
public static bool operator ==(float4 left, float4 right) => left.X == right.X && left.Y == right.Y && left.Z == right.Z && left.W == right.W;
public static bool operator !=(Vector4 left, Vector4 right) => left.X != right.X || left.Y != right.Y || left.Z != right.Z || left.W != right.W;
public static bool operator !=(float4 left, float4 right) => left.X != right.X || left.Y != right.Y || left.Z != right.Z || left.W != right.W;
public override void ToString(String strBuffer) => strBuffer.AppendF("X:{0} Y:{1} Z:{2} W:{3}", X, Y, Z, W);
@@ -325,6 +325,6 @@ namespace GlitchyEngine.Math
[Inline]
#unwarn
public static explicit operator float[4](Vector4 value) => *(float[4]*)&value;
public static explicit operator float[4](float4 value) => *(float[4]*)&value;
}
}
GlitchyEngine/src/Math/VectorAttribute.bf
+18 -4
View File
@@ -87,11 +87,11 @@ struct VectorAttribute<T, ComponentCount> : Attribute, IComptimeTypeApply where
if (ComponentCount == 3)
{
GenerateVector3Constructors(type);
Generatefloat3Constructors(type);
}
else if (ComponentCount == 4)
{
GenerateVector4Constructors(type);
Generatefloat4Constructors(type);
}
}
@@ -128,7 +128,7 @@ struct VectorAttribute<T, ComponentCount> : Attribute, IComptimeTypeApply where
}
[Comptime]
private void GenerateVector3Constructors(Type type)
private void Generatefloat3Constructors(Type type)
{
String baseName = type.GetName(.. scope String());
@@ -161,13 +161,27 @@ struct VectorAttribute<T, ComponentCount> : Attribute, IComptimeTypeApply where
}
[Comptime]
private void GenerateVector4Constructors(Type type)
private void Generatefloat4Constructors(Type type)
{
String baseName = type.GetName(.. scope String());
// Remove number from name
baseName.RemoveFromEnd(1);
String constructor = scope $"""
public this({baseName}2 xy, {baseName}2 zw)
{{
X = xy.X;
Y = xy.Y;
Z = zw.X;
W = zw.Y;
}}
""";
Compiler.EmitTypeBody(type, constructor);
String constructor1 = scope $"""
public this({baseName}2 xy, {typeof(T)} z, {typeof(T)} w)
{{
GlitchyEngine/src/Math/Vectors/Int2.bf
+2 -2
View File
@@ -150,9 +150,9 @@ namespace GlitchyEngine.Math
public override void ToString(String strBuffer) => strBuffer.AppendF($"X:{X} Y:{Y}");
public static explicit operator Vector2(Int2 point) => .(point.X, point.Y);
public static explicit operator float2(Int2 point) => .(point.X, point.Y);
public static explicit operator Int2(Vector2 point) => .((int32)point.X, (int32)point.Y);
public static explicit operator Int2(float2 point) => .((int32)point.X, (int32)point.Y);
public int GetHashCode()
{
GlitchyEngine/src/Math/Vectors/Int3.bf
+2 -2
View File
@@ -191,9 +191,9 @@ namespace GlitchyEngine.Math
public override void ToString(String strBuffer) => strBuffer.AppendF($"X:{X} Y:{Y} Z:{Z}");
public static explicit operator Vector3(Int3 point) => .(point.X, point.Y, point.Z);
public static explicit operator float3(Int3 point) => .(point.X, point.Y, point.Z);
public static explicit operator Int3(Vector3 point) => .((int32)point.X, (int32)point.Y, (int32)point.Z);
public static explicit operator Int3(float3 point) => .((int32)point.X, (int32)point.Y, (int32)point.Z);
[Inline]
public static explicit operator Int2(in Int3 point) => *(Int2*)&point;
GlitchyEngine/src/Math/Vectors/Int4.bf
+2 -2
View File
@@ -216,9 +216,9 @@ namespace GlitchyEngine.Math
public override void ToString(String strBuffer) => strBuffer.AppendF($"X:{X} Y:{Y} Z:{Z} W:{W}");
public static explicit operator Vector4(Int4 point) => .(point.X, point.Y, point.Z, point.W);
public static explicit operator float4(Int4 point) => .(point.X, point.Y, point.Z, point.W);
public static explicit operator Int4(Vector4 point) => .((int32)point.X, (int32)point.Y, (int32)point.Z, (int32)point.W);
public static explicit operator Int4(float4 point) => .((int32)point.X, (int32)point.Y, (int32)point.Z, (int32)point.W);
[Inline]
public static explicit operator Int2(in Int4 point) => *(Int2*)&point;
GlitchyEngine/src/OrthographicCameraController.bf
+4 -4
View File
@@ -14,7 +14,7 @@ namespace GlitchyEngine
private bool _rotation;
private Vector3 _cameraPosition;
private float3 _cameraPosition;
private float _cameraRotation;
private float _cameraTranslationSpeed = 1.0f;
private float _cameraRotationSpeed = 1.0f;
@@ -41,7 +41,7 @@ namespace GlitchyEngine
if(Application.Get().Window.IsActive)
{
Vector3 movement = .();
float3 movement = .();
if(Input.IsKeyPressed(Key.W))
{
@@ -61,8 +61,8 @@ namespace GlitchyEngine
movement.X += 1;
}
if(movement != .Zero)
movement.Normalize();
if(any(movement != .Zero))
movement = normalize(movement);
movement *= (float)(gameTime.FrameTime.TotalSeconds) * _cameraTranslationSpeed * _zoomLevel;
GlitchyEngine/src/PerspectiveCameraController.bf
+10 -10
View File
@@ -12,8 +12,8 @@ namespace GlitchyEngine
private float _aspectRatio;
private float _fovY = Math.PI_f / 4;
private Vector3 _cameraPosition;
private Vector3 _cameraRotation;
private float3 _cameraPosition;
private float3 _cameraRotation;
private float _cameraTranslationSpeed = 1.0f;
private float _cameraRotationSpeedX = 0.001f;
@@ -27,7 +27,7 @@ namespace GlitchyEngine
set => _cameraTranslationSpeed = value;
}
public Vector2 RotationSpeed
public float2 RotationSpeed
{
get => .(_cameraRotationSpeedX, _cameraRotationSpeedY);
set
@@ -37,7 +37,7 @@ namespace GlitchyEngine
}
}
public Vector3 CameraPosition
public float3 CameraPosition
{
get => _cameraPosition;
set
@@ -48,7 +48,7 @@ namespace GlitchyEngine
}
}
public Vector3 CameraRotation
public float3 CameraRotation
{
get => _cameraRotation;
set
@@ -100,7 +100,7 @@ namespace GlitchyEngine
if(Application.Get().Window.IsActive)
{
Vector3 movement = .();
float3 movement = .();
if(Input.IsKeyPressed(Key.W))
{
@@ -129,14 +129,14 @@ namespace GlitchyEngine
movement.Y -= 1;
}
if(movement != .Zero)
movement.Normalize();
if(any(movement != .Zero))
normalize(movement);
movement *= (float)(gameTime.FrameTime.TotalSeconds) * _cameraTranslationSpeed;
Vector4 delta = Vector4(movement, 1.0f) * _camera.View;
float4 delta = float4(movement, 1.0f) * _camera.View;
_cameraPosition += Vector3(delta.X, delta.Y, delta.Z);
_cameraPosition += float3(delta.X, delta.Y, delta.Z);
//_cameraPosition += movement;
// Camera rotation
GlitchyEngine/src/Platform/DX11/Math/Vector.bf
+3 -3
View File
@@ -8,7 +8,7 @@ using Bon;
namespace GlitchyEngine.Math
{
extension Vector2
extension float2
{
[Inline]
public static implicit operator DirectX.Math.Vector2(in Self value) => *(DirectX.Math.Vector2*)&value;
@@ -17,7 +17,7 @@ namespace GlitchyEngine.Math
public static implicit operator Self(in DirectX.Math.Vector2 value) => *(Self*)&value;
}
extension Vector3
extension float3
{
[Inline]
public static implicit operator DirectX.Math.Vector3(in Self value) => *(DirectX.Math.Vector3*)&value;
@@ -26,7 +26,7 @@ namespace GlitchyEngine.Math
public static implicit operator Self(in DirectX.Math.Vector3 value) => *(Self*)&value;
}
extension Vector4
extension float4
{
[Inline]
public static implicit operator DirectX.Math.Vector4(in Self value) => *(DirectX.Math.Vector4*)&value;
GlitchyEngine/src/Renderer/Animation/AnimationClip.bf
+4 -4
View File
@@ -188,9 +188,9 @@ namespace GlitchyEngine.Renderer.Animation
class JointAnimation// : IDisposable
{
public JointAnimationChannel<Vector3> TranslationChannel ~ delete _;
public JointAnimationChannel<float3> TranslationChannel ~ delete _;
public JointAnimationChannel<Quaternion> RotationChannel ~ delete _;
public JointAnimationChannel<Vector3> ScaleChannel ~ delete _;
public JointAnimationChannel<float3> ScaleChannel ~ delete _;
public float Duration
{
@@ -221,7 +221,7 @@ namespace GlitchyEngine.Renderer.Animation
case .Step:
result.Translation = previous;
case .Linear:
result.Translation = Vector3.Lerp(previous, next, interpolationValue);
result.Translation = lerp(previous, next, interpolationValue);
default:
result.Rotation = ?;
Runtime.NotImplemented();
@@ -262,7 +262,7 @@ namespace GlitchyEngine.Renderer.Animation
case .Step:
result.Scale = previous;
case .Linear:
result.Scale = Vector3.Lerp(previous, next, interpolationValue);
result.Scale = lerp(previous, next, interpolationValue);
default:
result.Rotation = ?;
Runtime.NotImplemented();
GlitchyEngine/src/Renderer/Animation/Joint.bf
+2 -2
View File
@@ -14,7 +14,7 @@ namespace GlitchyEngine.Renderer.Animation
public struct JointPose
{
public Quaternion Rotation;
public Vector3 Translation;
public Vector3 Scale;
public float3 Translation;
public float3 Scale;
}
}
GlitchyEngine/src/Renderer/BufferVariable.bf
+6 -6
View File
@@ -80,11 +80,11 @@ namespace GlitchyEngine.Renderer
case typeof(float):
EnsureTypeMatch(1, 1, .Float);
case typeof(Vector2):
case typeof(float2):
EnsureTypeMatch(1, 2, .Float);
case typeof(Vector3):
case typeof(float3):
EnsureTypeMatch(1, 3, .Float);
case typeof(Vector4):
case typeof(float4):
EnsureTypeMatch(1, 4, .Float);
case typeof(int32):
@@ -132,9 +132,9 @@ namespace GlitchyEngine.Renderer
public void SetData(bool value) => SetData<bool>(value);
public void SetData(float value) => SetData<float>(value);
public void SetData(Vector2 value) => SetData<Vector2>(value);
public void SetData(Vector3 value) => SetData<Vector3>(value);
public void SetData(Vector4 value) => SetData<Vector4>(value);
public void SetData(float2 value) => SetData<float2>(value);
public void SetData(float3 value) => SetData<float3>(value);
public void SetData(float4 value) => SetData<float4>(value);
public void SetData(int32 value) => SetData<int32>(value);
public void SetData(Int2 value) => SetData<Int2>(value);
GlitchyEngine/src/Renderer/Camera.bf
+6 -6
View File
@@ -31,8 +31,8 @@ namespace GlitchyEngine.Renderer
protected float _nearPlane;
protected float _farPlane;
protected Vector3 _position;
protected Vector3 _rotation;
protected float3 _position;
protected float3 _rotation;
/// If true the transform matrix is outdated and needs to be recalculated.
protected bool _transformOutdated = true;
@@ -76,12 +76,12 @@ namespace GlitchyEngine.Renderer
}
}
public Vector3 Position
public float3 Position
{
get => _position;
set
{
if(_position == value)
if(all(_position == value))
return;
_position = value;
@@ -89,12 +89,12 @@ namespace GlitchyEngine.Renderer
}
}
public Vector3 Rotation
public float3 Rotation
{
get => _rotation;
set
{
if(_rotation == value)
if(all(_rotation == value))
return;
_rotation = value;
GlitchyEngine/src/Renderer/DebugRenderer.bf
+7 -7
View File
@@ -39,9 +39,9 @@ namespace GlitchyEngine.Renderer
if(length != 0.0f)
{
transform.Columns[0]..Normalize() *= length;
transform.Columns[1]..Normalize() *= length;
transform.Columns[2]..Normalize() *= length;
transform.Columns[0] = normalize(transform.Columns[0]) * length;
transform.Columns[1] = normalize(transform.Columns[1]) * length;
transform.Columns[2] = normalize(transform.Columns[2]) * length;
}
Renderer.DrawLine(.Zero, .Right, .Red, transform);
@@ -66,7 +66,7 @@ namespace GlitchyEngine.Renderer
_frustumGeometry = new GeometryBinding();
_frustumGeometry.SetPrimitiveTopology(.LineList);
_frustumVertices = new VertexBuffer(typeof(Vector4), 8, .Dynamic, .Write);
_frustumVertices = new VertexBuffer(typeof(float4), 8, .Dynamic, .Write);
_frustumGeometry.SetVertexBufferSlot(_frustumVertices, 0);
using (IndexBuffer indexBuffer = new IndexBuffer(24, .Immutable))
@@ -109,7 +109,7 @@ namespace GlitchyEngine.Renderer
2, 6,
3, 7);
Vector4[8] corners;
float4[8] corners;
// Perspective
if(projection._43 != 0.0f)
{
@@ -121,7 +121,7 @@ namespace GlitchyEngine.Renderer
float gOverS = projection._11;
float g = projection._22;
//var corners = //(Vector4*)&_vbFrustum.Data;
//var corners = //(float4*)&_vbFrustum.Data;
if(Math.Abs(d1) >= 10000)
{
@@ -167,7 +167,7 @@ namespace GlitchyEngine.Renderer
float n = -projection._34 / projection._33;
float f = (1 - projection._34) / projection._33;
//var corners = (Vector4*)&_vbFrustum.Data;
//var corners = (float4*)&_vbFrustum.Data;
corners[0] = .(r, t, n, 1.0f);
corners[1] = .(r, b, n, 1.0f);
corners[2] = .(l, b, n, 1.0f);
GlitchyEngine/src/Renderer/Effect.bf
+3 -3
View File
@@ -602,11 +602,11 @@ public class Effect : Asset
}
if (numComponents == 2)
return Variant.Create(*(Vector2*)floats.Ptr);
return Variant.Create(*(float2*)floats.Ptr);
else if (numComponents == 3)
return Variant.Create(*(Vector3*)floats.Ptr);
return Variant.Create(*(float3*)floats.Ptr);
else if (numComponents == 4)
return Variant.Create(*(Vector4*)floats.Ptr);
return Variant.Create(*(float4*)floats.Ptr);
}
else
{
GlitchyEngine/src/Renderer/FullscreenQuad.bf
+2 -2
View File
@@ -11,9 +11,9 @@ namespace GlitchyEngine.Renderer
s_fullscreenQuadGeometry = new GeometryBinding();
s_fullscreenQuadGeometry.SetPrimitiveTopology(.TriangleList);
using(var quadVertices = new VertexBuffer(typeof(Vector4), 3, .Immutable))
using(var quadVertices = new VertexBuffer(typeof(float4), 3, .Immutable))
{
Vector4[4] vertices = .(
float4[4] vertices = .(
.(-1, 1, 0, 0),
.( 3, 1, 2, 0),
.(-1,-3, 0, 2),
GlitchyEngine/src/Renderer/Material.bf
+3 -3
View File
@@ -119,9 +119,9 @@ public class Material : Asset
}
public void SetVariable(String name, float value) => SetVariable<float>(name, value);
public void SetVariable(String name, Vector2 value) => SetVariable<Vector2>(name, value);
public void SetVariable(String name, Vector3 value) => SetVariable<Vector3>(name, value);
public void SetVariable(String name, Vector4 value) => SetVariable<Vector4>(name, value);
public void SetVariable(String name, float2 value) => SetVariable<float2>(name, value);
public void SetVariable(String name, float3 value) => SetVariable<float3>(name, value);
public void SetVariable(String name, float4 value) => SetVariable<float4>(name, value);
public void SetVariable(String name, int32 value) => SetVariable<int32>(name, value);
public void SetVariable(String name, Int2 value) => SetVariable<Int2>(name, value);
GlitchyEngine/src/Renderer/Renderer.bf
+16 -16
View File
@@ -11,7 +11,7 @@ namespace GlitchyEngine.Renderer
struct SceneConstants
{
public Matrix ViewProjection;
public Vector3 CameraPosition;
public float3 CameraPosition;
public RenderTargetGroup CameraTarget;
public RenderTargetGroup CompositionTarget;
}
@@ -102,7 +102,7 @@ namespace GlitchyEngine.Renderer
public Matrix4x3 Transform_InvT;
public uint32 EntityId;
private Vector3 _padding;
private float3 _padding;
}
public static void Init()
@@ -138,9 +138,9 @@ namespace GlitchyEngine.Renderer
LineGeometry = new GeometryBinding();
LineGeometry.SetPrimitiveTopology(.LineList);
Vector4[2] vertices = .(.Zero, .Zero);
LineVertices = new VertexBuffer(sizeof(Vector4), 2, .Dynamic, .Write);
LineVertices.SetData<Vector4>(vertices, 0, .WriteDiscard);
float4[2] vertices = .(.Zero, .Zero);
LineVertices = new VertexBuffer(sizeof(float4), 2, .Dynamic, .Write);
LineVertices.SetData<float4>(vertices, 0, .WriteDiscard);
LineGeometry.SetVertexBufferSlot(LineVertices, 0);
uint16[2] indices = .(0, 1);
@@ -254,8 +254,8 @@ namespace GlitchyEngine.Renderer
// Material and Mesh equal: sort by distance
if (cmp == 0)
{
float distLeftSq = Vector3.DistanceSquared(_sceneConstants.CameraPosition, left.Transform.Translation);
float distRightSq = Vector3.DistanceSquared(_sceneConstants.CameraPosition, right.Transform.Translation);
float distLeftSq = distanceSq(_sceneConstants.CameraPosition, left.Transform.Translation);
float distRightSq = distanceSq(_sceneConstants.CameraPosition, right.Transform.Translation);
// Whether or not the values are squared doesn't affect the order (because square(root) is a monotonic function)
cmp = distLeftSq <=> distRightSq;
@@ -335,13 +335,13 @@ namespace GlitchyEngine.Renderer
RenderCommand.SetDepthStencilState(_fullscreenDepthState);
// Scaling to make sure that only the part of the gbuffer that we actually used gets rendered into the viewport.
Vector2 scaling = Vector2(_sceneConstants.CameraTarget.Width, _sceneConstants.CameraTarget.Height) / (Vector2)_gBuffer.Size;
float2 scaling = float2(_sceneConstants.CameraTarget.Width, _sceneConstants.CameraTarget.Height) / (float2)_gBuffer.Size;
for (SubmittedLight light in _lights)
{
Debug.Profiler.ProfileRendererScope!("Draw Light");
Vector3 lightDir = -light.Transform.Forward;
float3 lightDir = -light.Transform.Forward;
Effect fsEffect = TestFullscreenEffect.Get();
fsEffect.SetTexture("GBuffer_Albedo", _gBuffer.Target, 0);
@@ -487,10 +487,10 @@ namespace GlitchyEngine.Renderer
* @param end The end point of the line.
* @param color The color of the line.
*/
public static void DrawLine(Vector3 start, Vector3 end, ColorRGBA color)
public static void DrawLine(float3 start, float3 end, ColorRGBA color)
{
Renderer2D.DrawLine(start, end, color);
//DrawLine(Vector4(start, 1.0f), Vector4(end, 1.0f), (ColorRGBA)color, .Identity);
//DrawLine(float4(start, 1.0f), float4(end, 1.0f), (ColorRGBA)color, .Identity);
}
/** @brief Draws a line.
@@ -499,9 +499,9 @@ namespace GlitchyEngine.Renderer
* @param color The color of the line.
* @param transform A transform matrix transforming the line.
*/
public static void DrawLine(Vector3 start, Vector3 end, ColorRGBA color, Matrix transform)
public static void DrawLine(float3 start, float3 end, ColorRGBA color, Matrix transform)
{
Renderer2D.DrawLine(transform * Vector4(start, 1.0f), transform * Vector4(end, 1.0f), color);
Renderer2D.DrawLine(transform * float4(start, 1.0f), transform * float4(end, 1.0f), color);
}
/** @brief Draws a ray.
@@ -509,7 +509,7 @@ namespace GlitchyEngine.Renderer
* @param direction The direction of the ray.
* @param color The color of the ray.
*/
public static void DrawRay(Vector3 start, Vector3 direction, ColorRGBA color)
public static void DrawRay(float3 start, float3 direction, ColorRGBA color)
{
Renderer2D.DrawRay(start, direction, color);
}
@@ -520,9 +520,9 @@ namespace GlitchyEngine.Renderer
* @param color The color of the ray.
* @param transform A transform matrix transforming the ray.
*/
public static void DrawRay(Vector3 start, Vector3 direction, ColorRGBA color, Matrix transform)
public static void DrawRay(float3 start, float3 direction, ColorRGBA color, Matrix transform)
{
Renderer2D.DrawLine(transform * Vector4(start, 1.0f), transform * Vector4(direction, 0.0f), color);
Renderer2D.DrawLine(transform * float4(start, 1.0f), transform * float4(direction, 0.0f), color);
}
}
}
GlitchyEngine/src/Renderer/Renderer2D.bf
+64 -64
View File
@@ -14,10 +14,10 @@ namespace GlitchyEngine.Renderer
[CRepr]
struct QuadVertex : IVertexData
{
public Vector2 Position;
public Vector2 Texcoord;
public float2 Position;
public float2 Texcoord;
public this(Vector2 position, Vector2 texcoord)
public this(float2 position, float2 texcoord)
{
Position = position;
Texcoord = texcoord;
@@ -46,12 +46,12 @@ namespace GlitchyEngine.Renderer
[CRepr]
struct LineBatchVertex
{
public Vector4 Position;
public float4 Position;
public ColorRGBA Color;
public uint32 EntityId;
public this(Vector4 position, ColorRGBA color, uint32 entityId)
public this(float4 position, ColorRGBA color, uint32 entityId)
{
Position = position;
Color = color;
@@ -64,11 +64,11 @@ namespace GlitchyEngine.Renderer
{
public Matrix Transform;
public ColorRGBA Color;
public Vector4 UVTransform;
public float4 UVTransform;
public uint32 EntityId;
public this(Matrix transform, ColorRGBA color, Vector4 uvTransform, uint32 entityId)
public this(Matrix transform, ColorRGBA color, float4 uvTransform, uint32 entityId)
{
Transform = transform;
Color = color;
@@ -82,7 +82,7 @@ namespace GlitchyEngine.Renderer
{
public float InnerRadius;
public this(Matrix transform, ColorRGBA color, Vector4 uvTransform, float innerRadius, uint32 entityId)
public this(Matrix transform, ColorRGBA color, float4 uvTransform, float innerRadius, uint32 entityId)
: base(transform, color, uvTransform, entityId)
{
InnerRadius = innerRadius;
@@ -110,15 +110,15 @@ namespace GlitchyEngine.Renderer
FrontToBack
}
struct QueueLine: this(Vector4 Start, Vector4 End, ColorRGBA Color, float Depth, uint32 entityId = uint32.MaxValue) { }
struct QueueLine: this(float4 Start, float4 End, ColorRGBA Color, float Depth, uint32 entityId = uint32.MaxValue) { }
struct QueueQuad: this(Matrix Transform, ColorRGBA Color, Texture Texture, float Depth, Vector4 uvTransform, uint32 entityId = uint32.MaxValue) { }
struct QueueQuad: this(Matrix Transform, ColorRGBA Color, Texture Texture, float Depth, float4 uvTransform, uint32 entityId = uint32.MaxValue) { }
struct QueueCircle : QueueQuad
{
public float InnerRadius;
public this(Matrix Transform, ColorRGBA Color, Texture Texture, float Depth, Vector4 uvTransform, float innerRadius, uint32 entityId = uint32.MaxValue)
public this(Matrix Transform, ColorRGBA Color, Texture Texture, float Depth, float4 uvTransform, float innerRadius, uint32 entityId = uint32.MaxValue)
: base(Transform, Color, Texture, Depth, uvTransform, entityId)
{
InnerRadius = innerRadius;
@@ -632,7 +632,7 @@ namespace GlitchyEngine.Renderer
/// Adds a quad instance to the instance queue.
[Inline]
private static void QueueQuadInstance(Matrix transform, ColorRGBA color, Texture texture, float depth, Vector4 uvTransform, uint32 id = uint32.MaxValue)
private static void QueueQuadInstance(Matrix transform, ColorRGBA color, Texture texture, float depth, float4 uvTransform, uint32 id = uint32.MaxValue)
{
s_QuadinstanceQueue.Add(QueueQuad(transform, color, texture ?? s_whiteTexture, depth, uvTransform, id));
s_statistics.QuadCount++;
@@ -640,7 +640,7 @@ namespace GlitchyEngine.Renderer
/// Adds a circle instance to the instance queue.
[Inline]
private static void QueueCircleInstance(Matrix transform, ColorRGBA color, Texture2D texture, float depth, Vector4 uvTransform, float innerRadius, uint32 id = uint32.MaxValue)
private static void QueueCircleInstance(Matrix transform, ColorRGBA color, Texture2D texture, float depth, float4 uvTransform, float innerRadius, uint32 id = uint32.MaxValue)
{
s_circleInstanceQueue.Add(QueueCircle(transform, color, texture ?? s_whiteTexture, depth, uvTransform, innerRadius, id));
s_statistics.CircleCount++;
@@ -648,7 +648,7 @@ namespace GlitchyEngine.Renderer
/// Adds a line instance to the instance queue.
[Inline]
private static void QueueLineInstance(Vector4 start, Vector4 end, ColorRGBA color, uint32 id = uint32.MaxValue)
private static void QueueLineInstance(float4 start, float4 end, ColorRGBA color, uint32 id = uint32.MaxValue)
{
s_lineInstanceQueue.Add(QueueLine(start, end, color, id));
s_statistics.LineCount++;
@@ -908,7 +908,7 @@ namespace GlitchyEngine.Renderer
}
/// A specialized function that calculates the 2D transform matrix
private static Matrix Calculate2DTransform(Vector3 translation, Vector2 scale, float rotation)
private static Matrix Calculate2DTransform(float3 translation, float2 scale, float rotation)
{
float sin = 0.0f;
float cos = 1.0f;
@@ -933,9 +933,9 @@ namespace GlitchyEngine.Renderer
* @param color The color of the line.
* @param entityId The optional ID of the entity that belongs to this line (for picking).
*/
public static void DrawLine(Vector3 start, Vector3 end, ColorRGBA color = .White, uint32 entityId = uint32.MaxValue)
public static void DrawLine(float3 start, float3 end, ColorRGBA color = .White, uint32 entityId = uint32.MaxValue)
{
DrawLine(Vector4(start, 1.0f), Vector4(end, 1.0f), color, entityId);
DrawLine(float4(start, 1.0f), float4(end, 1.0f), color, entityId);
}
/** @brief Draws a ray.
@@ -944,9 +944,9 @@ namespace GlitchyEngine.Renderer
* @param color The color of the ray.
* @param entityId The optional ID of the entity that belongs to this ray (for picking).
*/
public static void DrawRay(Vector3 start, Vector3 direction, ColorRGBA color = .White, uint32 entityId = uint32.MaxValue)
public static void DrawRay(float3 start, float3 direction, ColorRGBA color = .White, uint32 entityId = uint32.MaxValue)
{
DrawLine(Vector4(start, 1.0f), Vector4(direction, 0.0f), color, entityId);
DrawLine(float4(start, 1.0f), float4(direction, 0.0f), color, entityId);
}
/** @brief Draws a rectangle.
@@ -955,14 +955,14 @@ namespace GlitchyEngine.Renderer
* @param color The color of the rectangle.
* @param entityId The optional ID of the entity that belongs to this rectangle (for picking).
*/
public static void DrawRect(Vector2 position, Vector2 size, ColorRGBA color = .White, uint32 entityId = uint32.MaxValue)
public static void DrawRect(float2 position, float2 size, ColorRGBA color = .White, uint32 entityId = uint32.MaxValue)
{
Vector2 halfSize = size / 2;
float2 halfSize = size / 2;
Vector4 p0 = Vector4(position + Vector2(-halfSize.X, -halfSize.Y), 0.0f, 1.0f);
Vector4 p1 = Vector4(position + Vector2(halfSize.X, -halfSize.Y), 0.0f, 1.0f);
Vector4 p2 = Vector4(position + Vector2(halfSize.X, halfSize.Y), 0.0f, 1.0f);
Vector4 p3 = Vector4(position + Vector2(-halfSize.X, halfSize.Y), 0.0f, 1.0f);
float4 p0 = float4(position + float2(-halfSize.X, -halfSize.Y), 0.0f, 1.0f);
float4 p1 = float4(position + float2(halfSize.X, -halfSize.Y), 0.0f, 1.0f);
float4 p2 = float4(position + float2(halfSize.X, halfSize.Y), 0.0f, 1.0f);
float4 p3 = float4(position + float2(-halfSize.X, halfSize.Y), 0.0f, 1.0f);
DrawLine(p0, p1, color, entityId);
DrawLine(p1, p2, color, entityId);
@@ -977,12 +977,12 @@ namespace GlitchyEngine.Renderer
*/
public static void DrawRect(Matrix transform, ColorRGBA color = .White, uint32 entityId = uint32.MaxValue)
{
Vector2 halfSize = Vector2.One / 2.0f;
float2 halfSize = float2.One / 2.0f;
Vector4 p0 = transform * Vector4(-halfSize.X, -halfSize.Y, 0.0f, 1.0f);
Vector4 p1 = transform * Vector4(halfSize.X, -halfSize.Y, 0.0f, 1.0f);
Vector4 p2 = transform * Vector4(halfSize.X, halfSize.Y, 0.0f, 1.0f);
Vector4 p3 = transform * Vector4(-halfSize.X, halfSize.Y, 0.0f, 1.0f);
float4 p0 = transform * float4(-halfSize.X, -halfSize.Y, 0.0f, 1.0f);
float4 p1 = transform * float4(halfSize.X, -halfSize.Y, 0.0f, 1.0f);
float4 p2 = transform * float4(halfSize.X, halfSize.Y, 0.0f, 1.0f);
float4 p3 = transform * float4(-halfSize.X, halfSize.Y, 0.0f, 1.0f);
DrawLine(p0, p1, color, entityId);
DrawLine(p1, p2, color, entityId);
@@ -990,7 +990,7 @@ namespace GlitchyEngine.Renderer
DrawLine(p3, p0, color, entityId);
}
public static void DrawLine(Vector4 start, Vector4 end, ColorRGBA color = .White, uint32 entityId = uint32.MaxValue)
public static void DrawLine(float4 start, float4 end, ColorRGBA color = .White, uint32 entityId = uint32.MaxValue)
{
Debug.Profiler.ProfileRendererFunction!();
@@ -1008,23 +1008,23 @@ namespace GlitchyEngine.Renderer
// Colored Quad
public static void DrawQuad(Vector2 position, Vector2 size, float rotation, ColorRGBA color)
public static void DrawQuad(float2 position, float2 size, float rotation, ColorRGBA color)
{
DrawQuad(Vector3(position, 0.0f), size, rotation, s_whiteTexture, color);
DrawQuad(float3(position, 0.0f), size, rotation, s_whiteTexture, color);
}
/// Like DrawQuad but the pivot point is the top left corner
public static void DrawQuadPivotCorner(Vector2 position, Vector2 size, float rotation, ColorRGBA color)
public static void DrawQuadPivotCorner(float2 position, float2 size, float rotation, ColorRGBA color)
{
DrawQuadPivotCorner(Vector3(position, 0.0f), size, rotation, s_whiteTexture, color);
DrawQuadPivotCorner(float3(position, 0.0f), size, rotation, s_whiteTexture, color);
}
public static void DrawQuad(Vector3 position, Vector2 size, float rotation, ColorRGBA color)
public static void DrawQuad(float3 position, float2 size, float rotation, ColorRGBA color)
{
DrawQuad(position, size, rotation, s_whiteTexture, color);
}
public static void DrawQuadPivotCorner(Vector3 position, Vector2 size, float rotation, ColorRGBA color)
public static void DrawQuadPivotCorner(float3 position, float2 size, float rotation, ColorRGBA color)
{
DrawQuadPivotCorner(position, size, rotation, s_whiteTexture, color);
}
@@ -1037,9 +1037,9 @@ namespace GlitchyEngine.Renderer
// Quad Subtexture
[Inline]
private static Vector4 CalculateSubTexcoords(Vector4 texCoords, Vector4 innerTexcoords)
private static float4 CalculateSubTexcoords(float4 texCoords, float4 innerTexcoords)
{
Vector4 uv = texCoords;
float4 uv = texCoords;
uv.XY += innerTexcoords.XY * uv.ZW;
uv.ZW *= innerTexcoords.ZW;
@@ -1048,12 +1048,12 @@ namespace GlitchyEngine.Renderer
// Subtex only
public static void DrawQuad(Vector2 position, Vector2 size, float rotation, SubTexture2D texture, ColorRGBA color = .White)
public static void DrawQuad(float2 position, float2 size, float rotation, SubTexture2D texture, ColorRGBA color = .White)
{
DrawQuad(Vector3(position, 0.0f), size, rotation, texture.Texture, .White, texture.TexCoords);
DrawQuad(float3(position, 0.0f), size, rotation, texture.Texture, .White, texture.TexCoords);
}
public static void DrawQuad(Vector3 position, Vector2 size, float rotation, SubTexture2D texture, ColorRGBA color = .White)
public static void DrawQuad(float3 position, float2 size, float rotation, SubTexture2D texture, ColorRGBA color = .White)
{
DrawQuad(position, size, rotation, texture.Texture, .White, texture.TexCoords);
}
@@ -1065,42 +1065,42 @@ namespace GlitchyEngine.Renderer
// Subtex + Texcoords
public static void DrawQuad(Vector2 position, Vector2 size, float rotation, SubTexture2D subtexture, ColorRGBA color = .White, Vector4 uvTransform = .(0, 0, 1, 1))
public static void DrawQuad(float2 position, float2 size, float rotation, SubTexture2D subtexture, ColorRGBA color = .White, float4 uvTransform = .(0, 0, 1, 1))
{
Vector4 uv = CalculateSubTexcoords(subtexture.TexCoords, uvTransform);
float4 uv = CalculateSubTexcoords(subtexture.TexCoords, uvTransform);
DrawQuad(Vector3(position, 0.0f), size, rotation, subtexture.Texture, .White, uv);
DrawQuad(float3(position, 0.0f), size, rotation, subtexture.Texture, .White, uv);
}
public static void DrawQuad(Vector3 position, Vector2 size, float rotation, SubTexture2D subtexture, ColorRGBA color = .White, Vector4 uvTransform = .(0, 0, 1, 1))
public static void DrawQuad(float3 position, float2 size, float rotation, SubTexture2D subtexture, ColorRGBA color = .White, float4 uvTransform = .(0, 0, 1, 1))
{
Vector4 uv = CalculateSubTexcoords(subtexture.TexCoords, uvTransform);
float4 uv = CalculateSubTexcoords(subtexture.TexCoords, uvTransform);
DrawQuad(position, size, rotation, subtexture.Texture, .White, uv);
}
public static void DrawQuad(Matrix transform, SubTexture2D subtexture, ColorRGBA color = .White, Vector4 uvTransform = .(0, 0, 1, 1), uint32 entityId = uint32.MaxValue)
public static void DrawQuad(Matrix transform, SubTexture2D subtexture, ColorRGBA color = .White, float4 uvTransform = .(0, 0, 1, 1), uint32 entityId = uint32.MaxValue)
{
Vector4 uv = CalculateSubTexcoords(subtexture.TexCoords, uvTransform);
float4 uv = CalculateSubTexcoords(subtexture.TexCoords, uvTransform);
DrawQuad(transform, subtexture.Texture, color, uv, entityId);
}
// Textured Quad
public static void DrawQuad(Vector2 position, Vector2 size, float rotation, Texture texture, ColorRGBA color = .White, Vector4 uvTransform = .(0, 0, 1, 1))
public static void DrawQuad(float2 position, float2 size, float rotation, Texture texture, ColorRGBA color = .White, float4 uvTransform = .(0, 0, 1, 1))
{
DrawQuad(Vector3(position, 0.0f), size, rotation, texture, color, uvTransform);
DrawQuad(float3(position, 0.0f), size, rotation, texture, color, uvTransform);
}
public static void DrawQuad(Vector3 position, Vector2 size, float rotation, Texture texture, ColorRGBA color = .White, Vector4 uvTransform = .(0, 0, 1, 1))
public static void DrawQuad(float3 position, float2 size, float rotation, Texture texture, ColorRGBA color = .White, float4 uvTransform = .(0, 0, 1, 1))
{
Matrix transform = Calculate2DTransform(position, size, rotation);
DrawQuad(transform, texture, color, uvTransform);
}
public static void DrawQuad(Matrix transform, Texture texture, ColorRGBA color = .White, Vector4 uvTransform = .(0, 0, 1, 1), uint32 entityId = uint32.MaxValue)
public static void DrawQuad(Matrix transform, Texture texture, ColorRGBA color = .White, float4 uvTransform = .(0, 0, 1, 1), uint32 entityId = uint32.MaxValue)
{
Debug.Profiler.ProfileRendererFunction!();
@@ -1128,41 +1128,41 @@ namespace GlitchyEngine.Renderer
// Textured quad pivot
public static void DrawQuadPivotCorner(Vector2 position, Vector2 size, float rotation, Texture2D texture, ColorRGBA color = .White, Vector4 uvTransform = .(0, 0, 1, 1))
public static void DrawQuadPivotCorner(float2 position, float2 size, float rotation, Texture2D texture, ColorRGBA color = .White, float4 uvTransform = .(0, 0, 1, 1))
{
DrawQuadPivotCorner(Vector3(position, 0.0f), size, rotation, texture, color, uvTransform);
DrawQuadPivotCorner(float3(position, 0.0f), size, rotation, texture, color, uvTransform);
}
public static void DrawQuadPivotCorner(Vector3 position, Vector2 size, float rotation, Texture2D texture, ColorRGBA color = .White, Vector4 uvTransform = .(0, 0, 1, 1))
public static void DrawQuadPivotCorner(float3 position, float2 size, float rotation, Texture2D texture, ColorRGBA color = .White, float4 uvTransform = .(0, 0, 1, 1))
{
DrawQuad(position + Vector3(size.X / 2, size.Y / -2, 0), size, rotation, texture, color, uvTransform);
DrawQuad(position + float3(size.X / 2, size.Y / -2, 0), size, rotation, texture, color, uvTransform);
}
// Circle
public static void DrawCircle(Vector2 position, Vector2 size, ColorRGBA color, float innerRadius = 1.0f)
public static void DrawCircle(float2 position, float2 size, ColorRGBA color, float innerRadius = 1.0f)
{
DrawCircle(Vector3(position, 0.0f), size, 0, s_whiteTexture, color, innerRadius);
DrawCircle(float3(position, 0.0f), size, 0, s_whiteTexture, color, innerRadius);
}
public static void DrawCircle(Vector3 position, Vector2 size, ColorRGBA color, float innerRadius = 1.0f)
public static void DrawCircle(float3 position, float2 size, ColorRGBA color, float innerRadius = 1.0f)
{
DrawCircle(position, size, 0, s_whiteTexture, color, innerRadius);
}
public static void DrawCircle(Vector2 position, Vector2 size, float rotation, Texture2D texture, ColorRGBA color = .White, float innerRadius = 1.0f, Vector4 uvTransform = .(0, 0, 1, 1))
public static void DrawCircle(float2 position, float2 size, float rotation, Texture2D texture, ColorRGBA color = .White, float innerRadius = 1.0f, float4 uvTransform = .(0, 0, 1, 1))
{
DrawCircle(Vector3(position, 0.0f), size, rotation, texture, color, innerRadius, uvTransform);
DrawCircle(float3(position, 0.0f), size, rotation, texture, color, innerRadius, uvTransform);
}
public static void DrawCircle(Vector3 position, Vector2 size, float rotation, Texture2D texture, ColorRGBA color = .White, float innerRadius = 1.0f, Vector4 uvTransform = .(0, 0, 1, 1))
public static void DrawCircle(float3 position, float2 size, float rotation, Texture2D texture, ColorRGBA color = .White, float innerRadius = 1.0f, float4 uvTransform = .(0, 0, 1, 1))
{
Matrix transform = Calculate2DTransform(position, size, rotation);
DrawCircle(transform, texture, color, innerRadius, uvTransform);
}
public static void DrawCircle(Matrix transform, Texture2D texture, ColorRGBA color = .White, float innerRadius = 1.0f, Vector4 uvTransform = .(0, 0, 1, 1), uint32 entityId = uint32.MaxValue)
public static void DrawCircle(Matrix transform, Texture2D texture, ColorRGBA color = .White, float innerRadius = 1.0f, float4 uvTransform = .(0, 0, 1, 1), uint32 entityId = uint32.MaxValue)
{
Debug.Profiler.ProfileRendererFunction!();
GlitchyEngine/src/Renderer/SubTexture.bf
+9 -9
View File
@@ -6,34 +6,34 @@ namespace GlitchyEngine.Renderer
class SubTexture2D : RefCounter
{
protected Texture2D _texture ~ _.ReleaseRef();
protected Vector4 _texCoords;
protected float4 _texCoords;
public Texture2D Texture => _texture;
public Vector4 TexCoords => _texCoords;
public float4 TexCoords => _texCoords;
public this(Texture2D texture) : this(_texture, .(0, 0, 1, 1)) { }
public this(Texture2D texture, Int2 topLeft, Int2 size) :
this(texture,
{
Vector2 texSize = Vector2(texture.Width, texture.Height);
Vector4 texCoords = Vector4((Vector2)topLeft, (Vector2)size) / texSize.XYXY;
float2 texSize = float2(texture.Width, texture.Height);
float4 texCoords = float4((float2)topLeft, (float2)size) / texSize.XYXY;
texCoords
}) { }
public this(Texture2D texture, Vector2 topLeft, Vector2 size) : this(texture, Vector4(topLeft, size)) { }
public this(Texture2D texture, float2 topLeft, float2 size) : this(texture, float4(topLeft, size)) { }
public this(Texture2D texture, Vector4 texCoords)
public this(Texture2D texture, float4 texCoords)
{
_texture = texture..AddRef();
_texCoords = texCoords;
}
public static SubTexture2D CreateFromGrid(Texture2D texture, Vector2 coords, Vector2 gridSize, Vector2 spriteSize = .One)
public static SubTexture2D CreateFromGrid(Texture2D texture, float2 coords, float2 gridSize, float2 spriteSize = .One)
{
Vector2 textureSize = .(texture.Width, texture.Height);
float2 textureSize = .(texture.Width, texture.Height);
Vector4 uv = .(coords * gridSize, gridSize * spriteSize) / textureSize.XYXY;
float4 uv = .(coords * gridSize, gridSize * spriteSize) / textureSize.XYXY;
return new SubTexture2D(texture, uv);
}
GlitchyEngine/src/Renderer/Text/FontRenderer.bf
+24 -24
View File
@@ -103,12 +103,12 @@ namespace GlitchyEngine.Renderer.Text
{
public Font Font;
public uint32 GlyphId;
public Vector2 Position;
public float2 Position;
public float Scale;
//public float AdvanceX;
//public float AdvanceY;
public this(Font font, uint32 glyphId, Vector2 position, float scale)//, float advanceX, float advanceY)
public this(Font font, uint32 glyphId, float2 position, float scale)//, float advanceX, float advanceY)
{
Font = font;
GlyphId = glyphId;
@@ -341,7 +341,7 @@ namespace GlitchyEngine.Renderer.Text
_msdfEffect.Variables["ViewProjection"].SetData(viewProjection);
// TODO: this doesn't really work with fallback fonts
Vector2 unitRange = Vector2((float)text.Font._range) / Vector2(text.Font._atlas.Width, text.Font._atlas.Height);
float2 unitRange = ((float)text.Font._range) / float2(text.Font._atlas.Width, text.Font._atlas.Height);
_msdfEffect.Variables["UnitRange"].SetData(unitRange);
List<Texture2D> atlasses = scope .();
@@ -366,7 +366,7 @@ namespace GlitchyEngine.Renderer.Text
atlasses.Add(atlas..AddRef());
}
Vector2 atlasSize = .(atlas.Width, atlas.Height);
float2 atlasSize = .(atlas.Width, atlas.Height);
float adjustToPenX = glyphDesc.AdjustToPen;
//adjustToPenX *= glyphFontScale;
@@ -377,7 +377,7 @@ namespace GlitchyEngine.Renderer.Text
adjustToBaseline *= glyph.Scale;
// Rectangle on the screen
Vector4 viewportRect = .(
float4 viewportRect = .(
// TODO: merge adjustToPenX and adjustToBaseline into Position
glyph.Position.X + adjustToPenX,
glyph.Position.Y + adjustToBaseline,
@@ -385,24 +385,24 @@ namespace GlitchyEngine.Renderer.Text
glyphDesc.Height * glyph.Scale);
// Rectangle on the font atlas
Vector4 texRect = .(glyphDesc.MapCoord.X, glyphDesc.MapCoord.Y, glyphDesc.Width, glyphDesc.Height);
float4 texRect = .(glyphDesc.MapCoord.X, glyphDesc.MapCoord.Y, glyphDesc.Width, glyphDesc.Height);
Color glyphColor = fontColor;//Color.White;// TODO: glyphDesc.IsBitmap ? bitmapColor : fontColor;
texRect /= Vector4(atlasSize, atlasSize);
texRect /= float4(atlasSize, atlasSize);
// Show quads
// Renderer2D.DrawQuad(Vector3(viewportRect.X + viewportRect.Z / 2, viewportRect.Y + viewportRect.W / 2, 1), .(viewportRect.Z, viewportRect.W), 0, .Red);
// Renderer2D.DrawQuad(float3(viewportRect.X + viewportRect.Z / 2, viewportRect.Y + viewportRect.W / 2, 1), .(viewportRect.Z, viewportRect.W), 0, .Red);
Vector3 position = .(viewportRect.X + viewportRect.Z / 2, viewportRect.Y + viewportRect.W / 2, 0);
float3 position = .(viewportRect.X + viewportRect.Z / 2, viewportRect.Y + viewportRect.W / 2, 0);
Matrix glyphTransform = transform * Matrix.Translation(position) * Matrix.Scaling(viewportRect.Z, viewportRect.W, 1.0f);
Renderer2D.DrawQuad(glyphTransform, atlas, (ColorRGBA)glyphColor, texRect);
//Renderer2D.DrawQuad(Vector2(viewportRect.X + viewportRect.Z / 2, viewportRect.Y + viewportRect.W / 2), .(viewportRect.Z, viewportRect.W), 0, atlas, glyphColor, texRect);
//Renderer2D.DrawQuad(float2(viewportRect.X + viewportRect.Z / 2, viewportRect.Y + viewportRect.W / 2), .(viewportRect.Z, viewportRect.W), 0, atlas, glyphColor, texRect);
// Show pen positions
// Renderer2D.DrawQuad(Vector3(Vector2(x, y) + glyph.Position, -1), .(1), 0, .Green);
// Renderer2D.DrawQuad(float3(float2(x, y) + glyph.Position, -1), .(1), 0, .Green);
}
Renderer2D.Flush();
@@ -451,7 +451,7 @@ namespace GlitchyEngine.Renderer.Text
_msdfEffect.Variables["screenPixelRange"].SetData(scale * 4.0f);
// TODO: this doesn't really work with fallback fonts
Vector2 unitRange = Vector2((float)font._range) / Vector2(font._atlas.Width, font._atlas.Height);
float2 unitRange = ((float)font._range) / float2(font._atlas.Width, font._atlas.Height);
_msdfEffect.Variables["UnitRange"].SetData(unitRange);
// Space between two baselines
@@ -550,7 +550,7 @@ namespace GlitchyEngine.Renderer.Text
atlasses.Add(atlas..AddRef());
}
Vector2 atlasSize = .(atlas.Width, atlas.Height);
float2 atlasSize = .(atlas.Width, atlas.Height);
float adjustToPenX = glyphDesc.AdjustToPen;
adjustToPenX *= glyphFontScale;
@@ -559,26 +559,26 @@ namespace GlitchyEngine.Renderer.Text
adjustToBaseline *= glyphFontScale;
// Rectangle on the screen
Vector4 viewportRect = .(
float4 viewportRect = .(
penPosition + adjustToPenX,
baseline + adjustToBaseline,
glyphDesc.Width * glyphFontScale,
glyphDesc.Height * glyphFontScale);
// Rectangle on the font atlas
Vector4 texRect = .(glyphDesc.MapCoord.X, glyphDesc.MapCoord.Y, glyphDesc.Width, glyphDesc.Height);
float4 texRect = .(glyphDesc.MapCoord.X, glyphDesc.MapCoord.Y, glyphDesc.Width, glyphDesc.Height);
Color glyphColor = glyphDesc.IsBitmap ? bitmapColor : fontColor;
texRect /= Vector4(atlasSize, atlasSize);
texRect /= float4(atlasSize, atlasSize);
// Show quads
// Renderer2D.DrawQuad(Vector3(viewportRect.X + viewportRect.Z / 2, viewportRect.Y + viewportRect.W / 2, 1), .(viewportRect.Z, viewportRect.W), 0, .Red);
// Renderer2D.DrawQuad(float3(viewportRect.X + viewportRect.Z / 2, viewportRect.Y + viewportRect.W / 2, 1), .(viewportRect.Z, viewportRect.W), 0, .Red);
Renderer2D.DrawQuad(Vector2(viewportRect.X + viewportRect.Z / 2, viewportRect.Y + viewportRect.W / 2), .(viewportRect.Z, viewportRect.W), 0, atlas, glyphColor, texRect);
Renderer2D.DrawQuad(float2(viewportRect.X + viewportRect.Z / 2, viewportRect.Y + viewportRect.W / 2), .(viewportRect.Z, viewportRect.W), 0, atlas, glyphColor, texRect);
// Show pen positions
// Renderer2D.DrawQuad(Vector3(penPosition, baseline, -1), .(1), 0, .Green);
// Renderer2D.DrawQuad(float3(penPosition, baseline, -1), .(1), 0, .Green);
penPosition += (x_advance / 64) * glyphFontScale;
baseline += (y_advance / 64) * glyphFontScale;
@@ -627,7 +627,7 @@ namespace GlitchyEngine.Renderer.Text
atlasses.Add(atlas..AddRef());
}
Vector2 atlasSize = .(atlas.Width, atlas.Height);
float2 atlasSize = .(atlas.Width, atlas.Height);
float adjustToPenX = glyphDesc.AdjustToPen;
adjustToPenX *= glyphFontScale;
@@ -636,20 +636,20 @@ namespace GlitchyEngine.Renderer.Text
adjustToBaseline *= glyphFontScale;
// Rectangle on the screen
Vector4 viewportRect = .(
float4 viewportRect = .(
penPosition + adjustToPenX,
baseline + adjustToBaseline,
glyphDesc.Width * glyphFontScale,
glyphDesc.Height * glyphFontScale);
// Rectangle on the font atlas
Vector4 texRect = .(glyphDesc.MapCoord.X, glyphDesc.MapCoord.Y, glyphDesc.Width, glyphDesc.Height);
float4 texRect = .(glyphDesc.MapCoord.X, glyphDesc.MapCoord.Y, glyphDesc.Width, glyphDesc.Height);
Color glyphColor = glyphDesc.IsBitmap ? bitmapColor : fontColor;
texRect /= Vector4(atlasSize, atlasSize);
texRect /= float4(atlasSize, atlasSize);
Renderer2D.DrawQuad(Vector2(viewportRect.X + viewportRect.Z / 2, viewportRect.Y + viewportRect.W / 2), .(viewportRect.Z, viewportRect.W), 0, atlas, (ColorRGBA)glyphColor, texRect);
Renderer2D.DrawQuad(float2(viewportRect.X + viewportRect.Z / 2, viewportRect.Y + viewportRect.W / 2), .(viewportRect.Z, viewportRect.W), 0, atlas, (ColorRGBA)glyphColor, texRect);
//renderer.Draw(atlas, viewportRect.X, viewportRect.Y, viewportRect.Z, viewportRect.W, glyphColor, *(float*)(&depthInt), texRect);
GlitchyEngine/src/Scripting/ScriptEngine.bf
+7 -7
View File
@@ -30,7 +30,7 @@ enum ScriptFieldType
UInt, // UInt2, UInt3, UInt4,
ULong,
// Half, Half2, Half3, Half4,
Float, Vector2, Vector3, Vector4,
Float, float2, float3, float4,
Double, // Double2, Double3, Double4,
Entity
@@ -53,9 +53,9 @@ static sealed class ScriptEngineHelper
("System.UInt64", .ULong),
("System.Single", .Float),
("GlitchyEngine.Math.Vector2", .Vector2),
("GlitchyEngine.Math.Vector3", .Vector3),
("GlitchyEngine.Math.Vector4", .Vector4),
("GlitchyEngine.Math.float2", .float2),
("GlitchyEngine.Math.float3", .float3),
("GlitchyEngine.Math.float4", .float4),
("System.Double", .Double),
@@ -314,9 +314,9 @@ static class ScriptEngine
Mono.mono_add_internal_call("GlitchyEngine.CSharpTesting::Sample", v);
function void(in Vector3, in Vector3, out Vector3) v2 = => Add;
function void(in float3, in float3, out float3) v2 = => Add;
Mono.mono_add_internal_call("GlitchyEngine.Vector3::Add_Internal", v2);
Mono.mono_add_internal_call("GlitchyEngine.float3::Add_Internal", v2);
// Create object
ScriptClass myClass = scope .("GlitchyEngine", "CSharpTesting");
@@ -342,7 +342,7 @@ static class ScriptEngine
}
[LinkName(.C), AlwaysInclude, Export]
public static void Add(in Vector3 a, in Vector3 b, out Vector3 c)
public static void Add(in float3 a, in float3 b, out float3 c)
{
c = a + b;
}
GlitchyEngine/src/Scripting/ScriptGlue.bf
+13 -7
View File
@@ -187,7 +187,7 @@ static class ScriptGlue
#region TransformComponent
[RegisterCall("ScriptGlue::Transform_GetTranslation")]
static void Transform_GetTranslation(UUID entityId, ref Vector3 translation)
static void Transform_GetTranslation(UUID entityId, ref float3 translation)
{
Scene scene = ScriptEngine.Context;
Entity entity = scene.GetEntityByID(entityId);
@@ -196,12 +196,18 @@ static class ScriptGlue
}
[RegisterCall("ScriptGlue::Transform_SetTranslation")]
static void Transform_SetTranslation(UUID entityId, ref Vector3 translation)
static void Transform_SetTranslation(UUID entityId, ref float3 translation)
{
Scene scene = ScriptEngine.Context;
Entity entity = scene.GetEntityByID(entityId);
entity.Transform.Position = translation;
// if necessary reposition Rigidbody2D
if (entity.TryGetComponent<Rigidbody2DComponent>(let rigidbody2D))
{
rigidbody2D.SetPosition(translation.XY);
}
}
#endregion TransformComponent
@@ -209,7 +215,7 @@ static class ScriptGlue
#region RigidBody2D
[RegisterCall("ScriptGlue::RigidBody2D_ApplyForce")]
static void RigidBody2D_ApplyForce(UUID entityId, ref Vector2 force, ref Vector2 point, bool wakeUp)
static void RigidBody2D_ApplyForce(UUID entityId, ref float2 force, ref float2 point, bool wakeUp)
{
Scene scene = ScriptEngine.Context;
Entity entity = scene.GetEntityByID(entityId);
@@ -219,7 +225,7 @@ static class ScriptGlue
}
[RegisterCall("ScriptGlue::RigidBody2D_ApplyForceToCenter")]
static void RigidBody2D_ApplyForceToCenter(UUID entityId, ref Vector2 force, bool wakeUp)
static void RigidBody2D_ApplyForceToCenter(UUID entityId, ref float2 force, bool wakeUp)
{
Scene scene = ScriptEngine.Context;
Entity entity = scene.GetEntityByID(entityId);
@@ -235,16 +241,16 @@ static class ScriptGlue
// TODO: We need a wrapper class!
[RegisterCall("ScriptGlue::Physics2D_GetGravity")]
static void Physics2D_GetGravity(ref Vector2 gravity)
static void Physics2D_GetGravity(ref float2 gravity)
{
Scene scene = ScriptEngine.Context;
var box2DGravity = Box2D.World.GetGravity(scene.[Friend]_physicsWorld2D);
gravity = *(Vector2*)&box2DGravity;
gravity = *(float2*)&box2DGravity;
}
[RegisterCall("ScriptGlue::Physics2D_SetGravity")]
static void Physics2D_SetGravity(ref Vector2 gravity)
static void Physics2D_SetGravity(ref float2 gravity)
{
Scene scene = ScriptEngine.Context;
GlitchyEngine/src/Scripting/ScriptInstance.bf
+9 -9
View File
@@ -109,17 +109,17 @@ class ScriptInstance : RefCounter
var value = GetFieldValue<float>(field);
target.SetFieldValue(field, value);
/*case .Vector2:
GetFieldValue<Vector2>(field, var value);
if (ImGui.EditVector2(fieldName, ref value))
/*case .float2:
GetFieldValue<float2>(field, var value);
if (ImGui.Editfloat2(fieldName, ref value))
SetFieldValue(field, value);
case .Vector3:
GetFieldValue<Vector3>(field, var value);
if (ImGui.EditVector3(fieldName, ref value))
case .float3:
GetFieldValue<float3>(field, var value);
if (ImGui.Editfloat3(fieldName, ref value))
SetFieldValue(field, value);
case .Vector4:
GetFieldValue<Vector4>(field, var value);
if (ImGui.EditVector4(fieldName, ref value))
case .float4:
GetFieldValue<float4>(field, var value);
if (ImGui.Editfloat4(fieldName, ref value))
SetFieldValue(field, value);
case .Double:
GlitchyEngine/src/World/Components/Components.bf
+66 -6
View File
@@ -52,7 +52,7 @@ namespace GlitchyEngine.World
public AssetHandle<Texture2D> Sprite = .Invalid;
public ColorRGBA Color = .White;
public Vector4 UvTransform = .(0, 0, 1, 1);
public float4 UvTransform = .(0, 0, 1, 1);
public this()
{
@@ -70,7 +70,7 @@ namespace GlitchyEngine.World
public AssetHandle<Texture2D> Sprite = .Invalid;
public ColorRGBA Color = .White;
public Vector4 UvTransform = .(0, 0, 1, 1);
public float4 UvTransform = .(0, 0, 1, 1);
public float InnerRadius = 0.0f;
@@ -385,19 +385,79 @@ namespace GlitchyEngine.World
private int _runtimeBody = 0;
internal b2Body* RuntimeBody
protected internal b2Body* RuntimeBody
{
[Inline]
get => (b2Body*)(void*)_runtimeBody;
[Inline]
set mut => _runtimeBody = (int)(void*)value;
}
public float2 GetPosition()
{
if (RuntimeBody != null)
{
Box2D.b2Vec2 vec = Box2D.Body.GetPosition(RuntimeBody);
return *(float2*)&vec;
}
return .Zero;
}
public void SetPosition(float2 position)
{
var position;
if (RuntimeBody != null)
{
float angle = Box2D.Body.GetAngle(RuntimeBody);
Box2D.Body.SetTransform(RuntimeBody, ref *(Box2D.b2Vec2*)&position, angle);
}
}
public float GetAngle()
{
if (RuntimeBody != null)
{
return Box2D.Body.GetAngle(RuntimeBody);
}
return float.NaN;
}
public void SetAngle(float angle)
{
if (RuntimeBody != null)
{
var pos = Box2D.Body.GetPosition(RuntimeBody);
Box2D.Body.SetTransform(RuntimeBody, ref pos, angle);
}
}
}
/*struct InternalBug
{
private int i;
internal int MyInt
{
get => i;
set mut => i = value;
}
public void Bla()
{
MyInt = 5;
}
}*/
struct BoxCollider2DComponent
{
public Vector2 Offset = .(0.0f, 0.0f);
public Vector2 Size = .(0.5f, 0.5f);
public float2 Offset = .(0.0f, 0.0f);
public float2 Size = .(0.5f, 0.5f);
// TODO: move into 2D physics material
public float Density = 1.0f;
@@ -421,7 +481,7 @@ namespace GlitchyEngine.World
struct CircleCollider2DComponent
{
public Vector2 Offset = .(0.0f, 0.0f);
public float2 Offset = .(0.0f, 0.0f);
public float Radius = 0.5f;
GlitchyEngine/src/World/Components/TransformComponent.bf
+11 -11
View File
@@ -6,11 +6,11 @@ namespace GlitchyEngine.World
{
EcsEntity _parent = .InvalidEntity;
Vector3 _position = .(0, 0, 0);
float3 _position = .(0, 0, 0);
Quaternion _rotation = .(0, 0, 0, 1);
Vector3 _scale = .(1, 1, 1);
float3 _scale = .(1, 1, 1);
Vector3 _editorRotationEuler = .Zero;
float3 _editorRotationEuler = .Zero;
Matrix _localTransform = .Identity;
public bool IsDirty = false;
@@ -52,12 +52,12 @@ namespace GlitchyEngine.World
}
}
public Vector3 Position
public float3 Position
{
get => _position;
set mut
{
if(_position == value)
if(all(_position == value))
return;
_position = value;
@@ -82,12 +82,12 @@ namespace GlitchyEngine.World
}
/// Allows the user to edit the euler angles in the editor without rotations getting funky because of singularities or ambiguity of angles.
internal Vector3 EditorRotationEuler
internal float3 EditorRotationEuler
{
get => _editorRotationEuler;
set mut
{
if (_editorRotationEuler == value)
if (all(_editorRotationEuler == value))
return;
_editorRotationEuler = value;
@@ -101,7 +101,7 @@ namespace GlitchyEngine.World
* Gets or sets the rotation using euler angles.
* @Note The rotations will be applied in the following order: YZX (the order in the vector is still XYZ!)
*/
public Vector3 RotationEuler
public float3 RotationEuler
{
get => Quaternion.ToEulerAngles(_rotation);
set mut => Rotation = Quaternion.FromEulerAngles(value.Y, value.X, value.Z);
@@ -111,7 +111,7 @@ namespace GlitchyEngine.World
* Gets or sets the rotation using axis angle, where Axis is the axis around which will be rotated and angle is the angle
* that was rotated around the axis in radians.
*/
public (Vector3 Axis, float Angle) RotationAxisAngle
public (float3 Axis, float Angle) RotationAxisAngle
{
get => _rotation.ToAxisAngle();
set mut
@@ -126,12 +126,12 @@ namespace GlitchyEngine.World
}
}
public Vector3 Scale
public float3 Scale
{
get => _scale;
set mut
{
if(_scale == value)
if(all(_scale == value))
return;
_scale = value;
GlitchyEngine/src/World/EditorCamera.bf
+16 -16
View File
@@ -8,10 +8,10 @@ namespace GlitchyEngine.World
{
struct EditorCamera : Camera, IDisposable
{
private Vector3 _position;
private float3 _position;
private Quaternion _rotation;
private Vector3 _focalPosition = .Zero;
private float3 _focalPosition = .Zero;
private float _focalDistance = 5.0f;
private float _cameraTranslationSpeed = 2.0f;
@@ -52,12 +52,12 @@ namespace GlitchyEngine.World
}
}
public Vector3 Position
public float3 Position
{
get => _position;
set mut
{
if (_position == value)
if (all(_position == value))
return;
_position = value;
@@ -78,7 +78,7 @@ namespace GlitchyEngine.World
}
}
public Vector3 RotationEuler
public float3 RotationEuler
{
get => Quaternion.ToEulerAngles(_rotation);
set mut
@@ -92,7 +92,7 @@ namespace GlitchyEngine.World
}
}
public (Vector3 Axis, float Angle) RotationAxisAngle
public (float3 Axis, float Angle) RotationAxisAngle
{
get => _rotation.ToAxisAngle();
set mut
@@ -145,7 +145,7 @@ namespace GlitchyEngine.World
}
}
public this(Vector3 position, Quaternion rotation, float fovY, float nearPlane, float aspectRatio)
public this(float3 position, Quaternion rotation, float fovY, float nearPlane, float aspectRatio)
{
_position = position;
_rotation = rotation;
@@ -190,7 +190,7 @@ namespace GlitchyEngine.World
bool transformChanged = false;
Vector3 movement = .();
float3 movement = .();
if(Input.IsKeyPressed(Key.W))
movement.Z += 1;
@@ -207,16 +207,16 @@ namespace GlitchyEngine.World
if(Input.IsKeyPressed(Key.Control))
movement.Y -= 1;
if(movement != .Zero)
if(any(movement != .Zero))
{
movement.Normalize();
normalize(movement);
if(Input.IsKeyPressed(Key.Shift))
movement *= _cameraFastFactor;
movement *= (float)(gameTime.DeltaTime) * _cameraTranslationSpeed;
Vector4 delta = Vector4(movement, 1.0f) * _view;
float4 delta = float4(movement, 1.0f) * _view;
_position += delta.XYZ;
@@ -231,7 +231,7 @@ namespace GlitchyEngine.World
if (MouseCooldown == 0)
{
Vector3 rotationEuler = RotationEuler + Vector3(rotX, rotY, 0);
float3 rotationEuler = RotationEuler + float3(rotX, rotY, 0);
_rotation = Quaternion.FromEulerAngles(rotationEuler.Y, rotationEuler.X, rotationEuler.Z);
transformChanged = true;
@@ -262,13 +262,13 @@ namespace GlitchyEngine.World
if (MouseCooldown == 0 && Input.IsMouseButtonPressed(.LeftButton) && mouseDelta != .())
{
Vector2 movement = .(
float2 movement = .(
-mouseDelta.X,
mouseDelta.Y);
movement *= (float)(gameTime.DeltaTime) * _cameraTranslationSpeed * GetZoomSpeed();
Vector4 delta = Vector4(movement, 0.0f, 1.0f) * _view;
float4 delta = float4(movement, 0.0f, 1.0f) * _view;
_focalPosition += delta.XYZ;
@@ -280,7 +280,7 @@ namespace GlitchyEngine.World
float rotY = mouseDelta.X * _cameraRotationSpeedX;
float rotX = mouseDelta.Y * _cameraRotationSpeedY;
Vector3 rotationEuler = RotationEuler + Vector3(rotX, rotY, 0);
float3 rotationEuler = RotationEuler + float3(rotX, rotY, 0);
_rotation = Quaternion.FromEulerAngles(rotationEuler.Y, rotationEuler.X, rotationEuler.Z);
transformChanged = true;
@@ -294,7 +294,7 @@ namespace GlitchyEngine.World
{
Matrix viewRotation = Matrix.RotationQuaternion(Quaternion.Inverse(_rotation));
Vector4 offset = Vector4(0, 0, -_focalDistance, 1.0f) * viewRotation;
float4 offset = float4(0, 0, -_focalDistance, 1.0f) * viewRotation;
if (_isAltMode)
_position = _focalPosition + offset.XYZ;
else
Sandbox/src/ExampleLayer.bf
+13 -13
View File
@@ -17,20 +17,20 @@ namespace Sandbox
[Ordered]
struct VertexColorTexture : IVertexData
{
public Vector3 Position;
public float3 Position;
public Color Color;
public Vector2 TexCoord;
public float2 TexCoord;
public this() => this = default;
public this(Vector3 pos, Color color)
public this(float3 pos, Color color)
{
Position = pos;
Color = color;
TexCoord = .();
}
public this(Vector3 pos, Color color, Vector2 texCoord)
public this(float3 pos, Color color, float2 texCoord)
{
Position = pos;
Color = color;
@@ -73,7 +73,7 @@ namespace Sandbox
PerspectiveCameraController _cameraController ~ delete _;
private Vector3 CircleCoord(float angle)
private float3 CircleCoord(float angle)
{
return .(Math.Cos(angle), Math.Sin(angle), 0);
}
@@ -144,10 +144,10 @@ namespace Sandbox
_quadGeometryBinding.SetVertexLayout(vertexLayout);
VertexColorTexture[?] vertices = .(
VertexColorTexture(Vector3(-0.75f, 0.75f, 0), Color.White, .(0, 0)),
VertexColorTexture(Vector3(-0.75f, -0.75f, 0), Color.White, .(0, 1)),
VertexColorTexture(Vector3(0.75f, -0.75f, 0), Color.White, .(1, 1)),
VertexColorTexture(Vector3(0.75f, 0.75f, 0), Color.White, .(1, 0)),
VertexColorTexture(float3(-0.75f, 0.75f, 0), Color.White, .(0, 0)),
VertexColorTexture(float3(-0.75f, -0.75f, 0), Color.White, .(0, 1)),
VertexColorTexture(float3(0.75f, -0.75f, 0), Color.White, .(1, 1)),
VertexColorTexture(float3(0.75f, 0.75f, 0), Color.White, .(1, 0)),
);
let qvb = new VertexBuffer(typeof(VertexColorTexture), (.)vertices.Count, .Immutable);
@@ -234,7 +234,7 @@ namespace Sandbox
materialTestMaterial.SetVariable("InvTransSkinningMatrices", matrices2);
materialTestMaterial.SetVariable("BaseColor", Color.White);
materialTestMaterial.SetVariable("LightDir", Vector3(1, 1, -0.5f).Normalized());
materialTestMaterial.SetVariable("LightDir", float3(1, 1, -0.5f).Normalized());
ModelLoader.LoadModel("content\\Models\\RiggedFigure\\RiggedFigure.glb", materialTestMaterial, _world, Clips);
@@ -434,7 +434,7 @@ namespace Sandbox
if(parentId != uint8.MaxValue)
{
Vector3 start = mat.Translation;
float3 start = mat.Translation;
Joint parent = meshRenderer.Skeleton.Joints[parentId];
@@ -442,7 +442,7 @@ namespace Sandbox
Matrix parentMatrix = pose.SkinningMatricies[parentId] * parentBindPose;
Vector3 end = parentMatrix.Translation;
float3 end = parentMatrix.Translation;
Renderer.DrawLine(start, end, .Black, transform.WorldTransform);
}
@@ -457,7 +457,7 @@ namespace Sandbox
// non engine
material.SetVariable("BaseColor", Color.White);
material.SetVariable("LightDir", Vector3(1, 1, -0.5f).Normalized());
material.SetVariable("LightDir", float3(1, 1, -0.5f).Normalized());
Renderer.Submit(mesh.Mesh, material, transform.WorldTransform);
}
Sandbox/src/ExampleLayer2D.bf
+15 -15
View File
@@ -129,12 +129,12 @@ namespace Sandbox
_spriteSheet = Content.LoadAsset<Texture2D>("content/Rpg/textures/spritesheet.png");//new Texture2D("content/Rpg/textures/spritesheet.png");
_spriteSheet.SamplerState = SamplerStateManager.PointClamp;
_treeSprite = SubTexture2D.CreateFromGrid(_spriteSheet, Vector2(5, 10), Vector2(128), .(1, 2));
_barrelSprite = SubTexture2D.CreateFromGrid(_spriteSheet, Vector2(9, 11), Vector2(128));
_treeSprite = SubTexture2D.CreateFromGrid(_spriteSheet, float2(5, 10), float2(128), .(1, 2));
_barrelSprite = SubTexture2D.CreateFromGrid(_spriteSheet, float2(9, 11), float2(128));
_grassSprite = SubTexture2D.CreateFromGrid(_spriteSheet, Vector2(1, 1), Vector2(128));
_dirtSprite = SubTexture2D.CreateFromGrid(_spriteSheet, Vector2(6, 1), Vector2(128));
_waterSprite = SubTexture2D.CreateFromGrid(_spriteSheet, Vector2(11, 1), Vector2(128));
_grassSprite = SubTexture2D.CreateFromGrid(_spriteSheet, float2(1, 1), float2(128));
_dirtSprite = SubTexture2D.CreateFromGrid(_spriteSheet, float2(6, 1), float2(128));
_waterSprite = SubTexture2D.CreateFromGrid(_spriteSheet, float2(11, 1), float2(128));
_mapMap = new Dictionary<char8, SubTexture2D>();
_mapMap['W'] = _waterSprite..AddRef();
@@ -166,13 +166,13 @@ namespace Sandbox
float rotation = (float)gameTime.TotalTime.TotalSeconds;
Renderer2D.DrawQuad(Vector3(0, 0, 1), Vector2(20), 0, _checkerTexture, .White, .(0, 0, 10, 10));
Renderer2D.DrawQuad(float3(0, 0, 1), float2(20), 0, _checkerTexture, .White, .(0, 0, 10, 10));
Renderer2D.DrawCircle(Vector3(0, 0, 0f), Vector2(5), rotation, _checkerTexture, .LightBlue, innerRadius, .(0, 0, 1, 1));
Renderer2D.DrawCircle(float3(0, 0, 0f), float2(5), rotation, _checkerTexture, .LightBlue, innerRadius, .(0, 0, 1, 1));
Renderer2D.DrawQuad(Vector3(0, -7, 1), Vector2(2), -rotation, _checkerTexture, .White, .(0, 0, 10, 10));
Renderer2D.DrawQuad(float3(0, -7, 1), float2(2), -rotation, _checkerTexture, .White, .(0, 0, 10, 10));
Renderer2D.DrawCircle(Vector3(-2, -2, -2f), Vector2(1), .GreenYellow);
Renderer2D.DrawCircle(float3(-2, -2, -2f), float2(1), .GreenYellow);
Renderer2D.EndScene();
Renderer2D.BeginScene(cameraController.Camera, .BackToFront);
@@ -181,7 +181,7 @@ namespace Sandbox
for(float y = -5.0f; y < 5.0f; y += 0.1f)
{
ColorRGBA color = .((x + 5.0f) / 10.0f, 0.4f, (y + 5.0f) / 10.0f, 0.6f);
Renderer2D.DrawQuad(Vector3(x, y, 0.75f), Vector2(0.098f), 0, color);
Renderer2D.DrawQuad(float3(x, y, 0.75f), float2(0.098f), 0, color);
}
for(int x < 10)
@@ -189,7 +189,7 @@ namespace Sandbox
{
int i = (x + y) % 2;
Renderer2D.DrawQuad(Vector3(2 * x, 2 * y, 0.5f), Vector2(1.5f, 1), MathHelper.PiOverFour, (i == 0) ? _squareColor0 : _squareColor1);
Renderer2D.DrawQuad(float3(2 * x, 2 * y, 0.5f), float2(1.5f, 1), MathHelper.PiOverFour, (i == 0) ? _squareColor0 : _squareColor1);
}
//var prepared = FontRenderer.PrepareText(fonty, text, 64, .White, .White);
@@ -201,10 +201,10 @@ namespace Sandbox
Renderer2D.BeginScene(cameraController.Camera, .BackToFront);
Renderer2D.DrawQuad(Vector3(0, 0, 1), Vector2(1, 2), 0, _treeSprite);
Renderer2D.DrawQuad(Vector3(1, 0, 1), Vector2(1, 1), 0, _grassSprite);
Renderer2D.DrawQuad(float3(0, 0, 1), float2(1, 2), 0, _treeSprite);
Renderer2D.DrawQuad(float3(1, 0, 1), float2(1, 1), 0, _grassSprite);
Vector2 position = Vector2.Zero;
float2 position = float2.Zero;
for(char8 c in s_MapTiles.RawChars)
{
@@ -217,7 +217,7 @@ namespace Sandbox
SubTexture2D tile = _mapMap[c];
Renderer2D.DrawQuad(Vector3(position, -5), Vector2.One, 0, tile);
Renderer2D.DrawQuad(float3(position, -5), float2.One, 0, tile);
position.X += 1.0f;
}
Sandbox/src/GammaTestLayer.bf
+12 -12
View File
@@ -111,30 +111,30 @@ namespace Sandbox
RenderCommand.SetBlendState(_alphaBlendState);
RenderCommand.SetDepthStencilState(_depthStencilState);
//Renderer2D.DrawQuad(Vector3(0, 0, 1), Vector2(8), 0, _checkerTexture, .White, .(0, 0, 1, 1));
//Renderer2D.DrawQuad(Vector3(0, 0, 0), Vector2(_smallLines.Width, _smallLines.Height), 0, _smallLines, .White, .(0, 0, 1, 1));
//Renderer2D.DrawQuad(float3(0, 0, 1), float2(8), 0, _checkerTexture, .White, .(0, 0, 1, 1));
//Renderer2D.DrawQuad(float3(0, 0, 0), float2(_smallLines.Width, _smallLines.Height), 0, _smallLines, .White, .(0, 0, 1, 1));
Renderer2D.DrawQuad(Vector3(_smallLines.Width / 2, _smallLines.Height / 2, 0), Vector2(_smallLines.Width, _smallLines.Height), 0, _smallLines, .White, .(0, 0, 1, 1));
Renderer2D.DrawQuad(float3(_smallLines.Width / 2, _smallLines.Height / 2, 0), float2(_smallLines.Width, _smallLines.Height), 0, _smallLines, .White, .(0, 0, 1, 1));
FontRenderer.DrawText(_smallLinesInfo, 0, _smallLines.Height);
float f = _smallLines.Height / 2;
Renderer2D.DrawQuad(Vector3(_smallLines.Width * 2, f / 2, 0), Vector2(f, f), 0, .(0.5f, 0.5f, 0.5f));
Renderer2D.DrawQuad(Vector3(_smallLines.Width * 2, 3 * f / 2 + 1, 0), Vector2(f, f), 0, _zeroPointFive);
//Renderer2D.DrawQuad(Vector3(_smallLines.Width + f / 2, 3 * f / 2, 0), Vector2(f, f), 0, .(0.25f, 0.25f, 0.25f));
Renderer2D.DrawQuad(float3(_smallLines.Width * 2, f / 2, 0), float2(f, f), 0, .(0.5f, 0.5f, 0.5f));
Renderer2D.DrawQuad(float3(_smallLines.Width * 2, 3 * f / 2 + 1, 0), float2(f, f), 0, _zeroPointFive);
//Renderer2D.DrawQuad(float3(_smallLines.Width + f / 2, 3 * f / 2, 0), float2(f, f), 0, .(0.25f, 0.25f, 0.25f));
//FontRenderer.DrawText(_halfQuadInfo, _smallLines.Width + f, f / 2);
//Renderer2D.DrawQuad(Vector3(_gammaCorrectionBrightness.Width / 2, _smallLines.Height * 1.5f, 0), Vector2(_gammaCorrectionBrightness.Width, _gammaCorrectionBrightness.Height), 0, _gammaCorrectionBrightness, .White, .(0, 0, 1, 1));
//Renderer2D.DrawQuad(float3(_gammaCorrectionBrightness.Width / 2, _smallLines.Height * 1.5f, 0), float2(_gammaCorrectionBrightness.Width, _gammaCorrectionBrightness.Height), 0, _gammaCorrectionBrightness, .White, .(0, 0, 1, 1));
//Renderer2D.DrawQuad(Vector3(_smallLines.Width + f / 2, 500, 0), Vector2(f, f), 0, .(0.1f, 0.1f, 0.1f));
//Renderer2D.DrawQuad(Vector3(_gammaCorrectionBrightness.Width / 2, 0, 0), Vector2(_gammaCorrectionBrightness.Width, _gammaCorrectionBrightness.Height), 0, _gammaCorrectionBrightness, .White, .(0, 0, 1, 1));
//Renderer2D.DrawQuad(float3(_smallLines.Width + f / 2, 500, 0), float2(f, f), 0, .(0.1f, 0.1f, 0.1f));
//Renderer2D.DrawQuad(float3(_gammaCorrectionBrightness.Width / 2, 0, 0), float2(_gammaCorrectionBrightness.Width, _gammaCorrectionBrightness.Height), 0, _gammaCorrectionBrightness, .White, .(0, 0, 1, 1));
//Renderer2D.DrawQuad(Vector3(0, -200, 0), Vector2(100, 100), 0, .(0.5f, 0.5f, 0.5f));
//Renderer2D.DrawQuad(Vector3(0, -300, 0), Vector2(100, 100), 0, .(0.25f, 0.25f, 0.25f));
//Renderer2D.DrawQuad(float3(0, -200, 0), float2(100, 100), 0, .(0.5f, 0.5f, 0.5f));
//Renderer2D.DrawQuad(float3(0, -300, 0), float2(100, 100), 0, .(0.25f, 0.25f, 0.25f));
//Renderer2D.DrawQuad(Vector3(0, _gammaCorrectionBrightness.Height, 0), Vector2(_gammaCorrectionBrightness.Width, _gammaCorrectionBrightness.Height), 0, _gammaCorrectionBrightness, .(2, 2, 2), .(0, 0, 1, 1));
//Renderer2D.DrawQuad(float3(0, _gammaCorrectionBrightness.Height, 0), float2(_gammaCorrectionBrightness.Width, _gammaCorrectionBrightness.Height), 0, _gammaCorrectionBrightness, .(2, 2, 2), .(0, 0, 1, 1));
Renderer2D.EndScene();
}
Sandbox/src/TextureViewer.bf
+10 -10
View File
@@ -63,7 +63,7 @@ namespace Sandbox
_samplerPoint = SamplerStateManager.GetSampler(desc);
}
Vector2 _position;
float2 _position;
bool _moving;
@@ -123,7 +123,7 @@ namespace Sandbox
{
var windowPos = ImGui.GetWindowPos();
var mousePos = ImGui.GetIO().MousePos;
Vector2 mouseInWindow = .(mousePos.x - windowPos.x, mousePos.y - windowPos.y);
float2 mouseInWindow = .(mousePos.x - windowPos.x, mousePos.y - windowPos.y);
bool windowHovered = ImGui.IsWindowHovered();
@@ -180,10 +180,10 @@ namespace Sandbox
_context.SetDepthStencilTarget(_depth);
_context.BindRenderTargets();
Vector2 textureSize = Vector2(viewedTexture.Width, viewedTexture.Height);
Vector2 zoomedTextureSize = textureSize * _zoom;
float2 textureSize = float2(viewedTexture.Width, viewedTexture.Height);
float2 zoomedTextureSize = textureSize * _zoom;
Vector2 targetSize = Vector2(_target.Width, _target.Height);
float2 targetSize = float2(_target.Width, _target.Height);
_effect.Variables["ColorOffset"].SetData(_colorOffset);
_effect.Variables["ColorScale"].SetData(_colorScale);
@@ -203,19 +203,19 @@ namespace Sandbox
switch(_backgroundMode)
{
case .Black:
Renderer2D.DrawQuadPivotCorner(Vector3(0, 0, 1), targetSize, 0, .Black);
Renderer2D.DrawQuadPivotCorner(float3(0, 0, 1), targetSize, 0, .Black);
case .White:
Renderer2D.DrawQuadPivotCorner(Vector3(0, 0, 1), targetSize, 0, .White);
Renderer2D.DrawQuadPivotCorner(float3(0, 0, 1), targetSize, 0, .White);
case .Checkerboard:
float quadSize = 50.0f;
Vector2 numQuads = (targetSize / 500f) * 10f;
float2 numQuads = (targetSize / 500f) * 10f;
for(float x = 0; x < numQuads.X; x++)
{
for(float y = 0; y < numQuads.Y; y++)
{
Renderer2D.DrawQuadPivotCorner(Vector3(x * quadSize, -y * quadSize, 1), quadSize.XX, 0, ((x + y) % 2 == 0) ? .White : .Gray);
Renderer2D.DrawQuadPivotCorner(float3(x * quadSize, -y * quadSize, 1), quadSize.XX, 0, ((x + y) % 2 == 0) ? .White : .Gray);
}
}
break;
@@ -235,7 +235,7 @@ namespace Sandbox
Renderer2D.BeginScene(_camera, .SortByTexture, _effect);
Renderer2D.DrawQuadPivotCorner(Vector3(_position * .(1, -1), 0), zoomedTextureSize, 0, viewedTexture);
Renderer2D.DrawQuadPivotCorner(float3(_position * .(1, -1), 0), zoomedTextureSize, 0, viewedTexture);
Renderer2D.EndScene();