Added SDK

2026-06-11 14:01:22 +12:00
commit c0395a49bd
2155 changed files with 451005 additions and 0 deletions
@@ -0,0 +1,176 @@
+cbuffer Uniforms : register(b0)
+{
+  float4 State;
+  matrix Transform;
+  float4 Scalar4[2];
+  float4 Vector[8];
+  uint ClipSize;
+  matrix Clip[8];
+};
+
+float Time() { return State[0]; }
+float ScreenWidth() { return State[1]; }
+float ScreenHeight() { return State[2]; }
+float ScreenScale() { return State[3]; }
+float Scalar(int i) { if (i < 4) return Scalar4[0][i]; else return Scalar4[1][i - 4]; }
+
+Texture2D texture0 : register(t0);
+SamplerState sampler0 : register(s0);
+
+struct VS_OUTPUT
+{
+  float4 Position    : SV_POSITION;
+  float4 Color       : COLOR0;
+  float2 ObjectCoord : TEXCOORD0;
+};
+
+float sdRect(float2 p, float2 size) {
+  float2 d = abs(p) - size;
+  return min(max(d.x, d.y), 0.0) + length(max(d, 0.0));
+}
+
+// The below function "sdEllipse" is MIT licensed with following text:
+//
+// The MIT License
+// Copyright 2013 Inigo Quilez
+// Permission is hereby granted, free of charge, to any person obtaining a 
+// copy of this software and associated documentation files (the "Software"),
+// to deal in the Software without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons to whom the Software
+// is furnished to do so, subject to the following conditions: The above copyright
+// notice and this permission notice shall be included in all copies or substantial
+// portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
+// EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+// OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+float sdEllipse(float2 p, float2 ab) {
+  if (abs(ab.x - ab.y) < 0.1)
+    return length(p) - ab.x;
+
+  p = abs(p); if (p.x > p.y) { p = p.yx; ab = ab.yx; }
+
+  float l = ab.y*ab.y - ab.x*ab.x;
+
+  float m = ab.x*p.x / l;
+  float n = ab.y*p.y / l;
+  float m2 = m*m;
+  float n2 = n*n;
+
+  float c = (m2 + n2 - 1.0) / 3.0;
+  float c3 = c*c*c;
+
+  float q = c3 + m2*n2*2.0;
+  float d = c3 + m2*n2;
+  float g = m + m*n2;
+
+  float co;
+
+  if (d < 0.0) {
+    float p = acos(q / c3) / 3.0;
+    float s = cos(p);
+    float t = sin(p)*sqrt(3.0);
+    float rx = sqrt(-c*(s + t + 2.0) + m2);
+    float ry = sqrt(-c*(s - t + 2.0) + m2);
+    co = (ry + sign(l)*rx + abs(g) / (rx*ry) - m) / 2.0;
+  } else {
+    float h = 2.0*m*n*sqrt(d);
+    float s = sign(q + h)*pow(abs(q + h), 1.0 / 3.0);
+    float u = sign(q - h)*pow(abs(q - h), 1.0 / 3.0);
+    float rx = -s - u - c*4.0 + 2.0*m2;
+    float ry = (s - u)*sqrt(3.0);
+    float rm = sqrt(rx*rx + ry*ry);
+    float p = ry / sqrt(rm - rx);
+    co = (p + 2.0*g / rm - m) / 2.0;
+  }
+
+  float si = sqrt(1.0 - co*co);
+
+  float2 r = float2(ab.x*co, ab.y*si);
+
+  return length(r - p) * sign(p.y - r.y);
+}
+
+// 1.0 = No softening, 0.1 = Max softening
+#define SOFTEN_ELLIPSE 1.0
+
+float sdRoundRect(float2 p, float2 size, float4 rx, float4 ry) {
+  size *= 0.5;
+  float2 corner;
+
+  corner = float2(-size.x + rx.x, -size.y + ry.x);  // Top-Left
+  float2 local = p - corner;
+  if (dot(rx.x, ry.x) > 0.0 && p.x < corner.x && p.y <= corner.y)
+    return sdEllipse(local, float2(rx.x, ry.x)) * SOFTEN_ELLIPSE;
+
+  corner = float2(size.x - rx.y, -size.y + ry.y);   // Top-Right
+  local = p - corner;
+  if (dot(rx.y, ry.y) > 0.0 && p.x >= corner.x && p.y <= corner.y)
+    return sdEllipse(local, float2(rx.y, ry.y)) * SOFTEN_ELLIPSE;
+
+  corner = float2(size.x - rx.z, size.y - ry.z);  // Bottom-Right
+  local = p - corner;
+  if (dot(rx.z, ry.z) > 0.0 && p.x >= corner.x && p.y >= corner.y)
+    return sdEllipse(local, float2(rx.z, ry.z)) * SOFTEN_ELLIPSE;
+
+  corner = float2(-size.x + rx.w, size.y - ry.w); // Bottom-Left
+  local = p - corner;
+  if (dot(rx.w, ry.w) > 0.0 && p.x < corner.x && p.y > corner.y)
+    return sdEllipse(local, float2(rx.w, ry.w)) * SOFTEN_ELLIPSE;
+
+  return sdRect(p, size);
+}
+
+float2 transformAffine(float2 val, float2 a, float2 b, float2 c) {
+  return val.x * a + val.y * b + c;
+}
+
+void Unpack(float4 x, out float4 a, out float4 b) {
+  const float s = 65536.0;
+  a = floor(x / s);
+  b = floor(x - a * s);
+}
+
+float antialias2(float d) {
+  return smoothstep(-0.6180469, 0.6180469, d/fwidth(d));
+}
+
+float4 GetCol(in matrix m, uint i) { return float4(m[0][i], m[1][i], m[2][i], m[3][i]); }
+
+#define VISUALIZE_CLIP 0
+
+void applyClip(VS_OUTPUT input, inout float4 outColor) {
+  for (uint i = 0; i < ClipSize; i++) {
+    matrix data = Clip[i];
+    float2 origin = GetCol(data, 0).xy;
+    float2 size = GetCol(data, 0).zw;
+    float4 radii_x, radii_y;
+    Unpack(GetCol(data, 1), radii_x, radii_y);
+    bool inverse = bool(GetCol(data, 3).z);
+
+    float2 p = input.ObjectCoord;
+    p = transformAffine(p, GetCol(data, 2).xy, GetCol(data, 2).zw, GetCol(data, 3).xy);
+    p -= origin;
+    float d_clip = sdRoundRect(p, size, radii_x, radii_y) * (inverse ? -1.0 : 1.0);
+
+#if VISUALIZE_CLIP
+    if (abs(d_clip) < 3.0)
+      outColor = float4(0.9, 1.0, 0.0, 1.0);
+#else
+    float alpha = antialias2(-d_clip);
+    outColor = float4(outColor.rgb * alpha, outColor.a * alpha);
+#endif
+  }
+}
+
+float4 PS(VS_OUTPUT input) : SV_Target
+{
+  float4 outColor = input.Color;
+  applyClip(input, outColor);
+
+  return outColor;
+}