Shader source from expressions: MathS.Shaders.Hlsl and Glsl

Ouverte
  • Quelque chose ne va pas ?
#2,293 1 commentaire 0 réactions 0 personnes assignées Voir sur GitHub

Les mainteneurs répondent en général sous 1 jour

Personne n'a encore pris cette issue.

Évaluation

Difficulté
5/5
Temps estimé
Plus d'une semaine
Accessibilité débutants
25/100
Type d'issue
Fonctionnalité
Clarté
Clairement spécifiée
Activité
Active
Stack technique
csharp
Domaine
computer-graphics

Piste de recherche

The payload names an existing implementation on feat/shader-source: start by reading Functions/Compilation/IntoSource/* and Convenience/MathS.Shaders.cs, then run Tests/UnitTests/Convenience/ShadersTest.cs. Done means the HLSL and GLSL printers meet the stated contract, including the documented unsupported cases and numerical comparisons; note that implementation work is already underway.

Rédigé par le modèle d'indexation à partir du texte de l'issue.

Description

What it is. Print expressions as straight-line HLSL or GLSL: one assignment per output, each repeated subexpression computed once into a local, sincos for a sin/cos pair in HLSL.

Entity r = "sqrt(x^2 + y^2)";
MathS.Shaders.Hlsl(new Dictionary<string, Entity> { ["g.x"] = r.Differentiate("x"), ["g.y"] = r.Differentiate("y") }.ToList(),
                   new Dictionary<Entity.Variable, string> { ["x"] = "p.x", ["y"] = "p.y" }).Code;
// float am0 = (0.5 * rsqrt(((p.x * p.x) + (p.y * p.y))));
// g.x = (am0 * (2.0 * p.x));
// g.y = (am0 * (2.0 * p.y));

Why. Exact gradients and Hessians of signed distance fields, and closed forms of physical laws, derived on the CPU and run on the GPU. Measured in practice: an exact SDF normal replaced a 4-sample finite difference at 1509 → 466 instructions, and a second one ran 1.23× faster while being exact where the finite difference was 30° off at creases. #552 (Unity) is the same audience.

Contract.

  • Computes the real-valued reading that Compile<double, …> computes. The tests hold it to that: the same printer writes C# against helpers named as HLSL's intrinsics, Roslyn compiles that text, and it is compared with Compile<double, double, double> at 200 points per case (28 cases).
  • One difference to agree on: if #2288 lands, Compile<double> answers NaN for a division by zero, where x / 0.0 on a GPU is ±inf. The printer writes / as is; guarding every division would cost a branch per quotient. The proposal is to document the difference rather than pay for it.
  • Declines, naming the node, what has no faithful form: complex constants, non-identifier names, Providedf (a shader cannot say "no value here"; Differentiate attaches one to tanh's exponential form, so the caller unwraps it where the condition cannot fail), piecewise without a final always-true case, Roundf (tie rules differ), factorial, sets.
  • Adds no referenced assembly: KernelDependenciesTest caught a first draft that used Regex.
  • Integer powers multiplied out to the 4th; higher as pow(abs(x), n) with the sign restored for odd n, because pow of a negative base is undefined in both languages.
  • mod printed floored, as Modf is (fmod truncates).
  • Nothing is simplified.

Packaging. No clause fires (pure managed, string output) → kernel, beside IntoLinq. Arguably (C) "consumes rather than composes"; the SymPy exporter is the precedent for an output format in the kernel.

Implementation, for judging the design against working code. Branch feat/shader-source, one commit on master 87a0eff: Functions/Compilation/IntoSource/*, Convenience/MathS.Shaders.cs, Tests/UnitTests/Convenience/ShadersTest.cs, +17 lines of PublicApi.txt. UnitTests 18332 passed / 13 skipped, FSharpWrapperUnitTests 134 passed. The pull request will follow Accepted.

Worked use, together with dimensional analysis (#2292). A water wave from ω² = g k tanh(k h): the emitted HLSL matches the library to 4e-16 in double, and to 3e-5 of the amplitude in fp32 out to k h = 300.

Milestone: 2.7.0 (additive).

Langage dominant
C#
Étoiles
831
Forks
79
Merge moyen
1 h 11 min
PR mergées (30 j)
523

Préparer son environnement

Par où commencer

  1. Lisez l'issue en entier, puis le guide de contribution du projet.
  2. Signalez en commentaire que vous la prenez — cela évite que deux personnes fassent le même travail.
  3. Forkez le dépôt et travaillez sur une branche.
  4. Ouvrez une pull request qui référence le numéro de l'issue.

Autres issues de ASC-Community/AngouriMath

Toutes les issues de ASC-Community/AngouriMath

Issues similaires

Plus d'issues C#

Recevez les nouvelles issues par e-mail

Un résumé court des issues GitHub adaptées aux débutants.