FractalPark
Le langage de formules FRM

Écris des fractales avec FRM

Apprends le sous-ensemble FRM testé de FractalPark, comprends comment la source devient un shader GPU, et construis trois formules fonctionnelles à partir des mêmes exemples utilisés par l'éditeur.

01

Qu'est-ce que le FRM

FRM est un moyen compact et textuel de décrire une fractale itérative. Une formule nomme son état de départ, le calcul répété pour chaque orbite et la condition qui décide si l'itération continue.

Le format est issu de l'écosystème Fractint, où les fichiers de formules permettaient d'échanger des expériences sans reconstruire le programme de rendu. FractalPark transmet cette idée d'écriture dans un flux de travail navigateur, tout en documentant son propre sous-ensemble testé au lieu de revendiquer une compatibilité complète.

Pour les origines et l'histoire du projet au sens large, voir le site du projet Fractint.

02

Prise en charge du FRM dans FractalPark

FractalPark tokenise, analyse, valide et compile un sous-ensemble FRM délibéré. Le tableau sépare les constructions qui fonctionnent directement, celles qui ont une sémantique FractalPark documentée et celles que le flux de travail actuel ne peut pas préserver.

NiveauSignificationPérimètre vérifié
Pris en chargeCouvert par les tests du compilateur et utilisable sans qualification sémantique.
  • Une déclaration de formule par document source
  • les sections init, loop et bailout
  • les affectations et les variables utilisateur
  • les littéraux réels et complexes ; les expressions arithmétiques, de comparaison, logiques, unaires et de magnitude
  • les branches if / elseif / else / endif
  • z, c, pixel, zPrev, p1–p5, les constantes et les fonctions intégrées testées
  • les commentaires FRM
  • les diagnostics structurés et le mappage de source FRM vers GLSL
AdaptéAccepté avec une différence sémantique documentée ou en tant qu'extension FractalPark.
  • ismand correspond au mode d'exécution Mandelbrot/Julia actuel de FractalPark
  • fn1–fn4 utilisent la répartition des fonctions au moment de la compilation
  • @mode: native, @default-view et @default-coloring sont des extensions FractalPark ; les directives par défaut ne s'appliquent qu'en mode natif
Non pris en chargeNon préservé par le compilateur actuel ou le flux de travail de fichiers ; rejeté plutôt que réécrit silencieusement.
  • la sélection parmi plusieurs formules dans un même fichier
  • la conversion automatique des dialectes Fractint classiques
  • les directives de source arbitraires
  • les identifiants non ASCII
  • les fonctions ou macros définies par l'utilisateur
  • les fonctionnalités de préprocesseur
  • toute construction rejetée par le pipeline de compilation actuel

Il s'agit d'une base de compatibilité testée, et non d'une revendication de compatibilité totale avec Fractint. Lorsque le compilateur change, cette matrice et ses tests doivent changer ensemble.

Compatibilité vérifiée

Ces décomptes de capacités proviennent du manifeste versionné : 588 entrées cibles comprennent 579 validations strict-v2 et 9 dérogations documentées ; 117 entrées distinctes sont exclues pour des raisons stables.

Entrées cibles
588
Validations strict-v2
579
Dérogations documentées
9
Exclues avec justification
117
Types de descripteurs de bailout
4
Fonctions intégrées
20

Descripteurs de bailout

  • C1
  • C2
  • C4R
  • C5

Motifs de rejet stables

  • unknown-predicate
  • unknown-magnitude-form
  • threshold-not-loop-invariant
  • chained-logical

Fonctions intégrées

  • sin
  • cos
  • tan
  • sinh
  • cosh
  • tanh
  • exp
  • log
  • sqrt
  • abs
  • sqr
  • conj
  • flip
  • recip
  • cabs
  • real
  • imag
  • atan2
  • cosxx
  • cotanh

Paramètres : p1, p2, p3, p4, p5 · Emplacements de fonction : fn1, fn2, fn3, fn4

Manifeste de capacités v1 · Sémantique stricte v2

03

Anatomie d'une formule

Une formule FRM FractalPark comporte une déclaration nommée et trois sections explicites. Ensemble, elles définissent la transition d'état pour chaque pixel.

01

init:

S'exécute une fois par pixel. Définis ici la valeur d'orbite initiale et les éventuelles variables auxiliaires.

02

loop:

S'exécute une fois par itération. Mets à jour z et tout état nécessaire à la prochaine itération.

03

bailout:

Renvoie la condition pour continuer l'orbite. Lorsqu'elle devient fausse, le point s'est échappé.

Les noms de sections sont structurels, pas des commentaires : en omettre un ou l'écorcher produit un diagnostic.

04

Guide de syntaxe

Le langage reste volontairement restreint : les expressions décrivent l'arithmétique complexe, les instructions mettent à jour l'état de l'orbite et le flux de contrôle choisit parmi les mises à jour.

Déclaration et sections
Enveloppe une formule nommée entre accolades, puis écris init:, loop: et bailout: dans cet ordre.
Valeurs et variables
Utilise des nombres réels comme 0.15, des paires complexes comme (0.05, -0.02), des valeurs d'orbite intégrées ou tes propres variables affectées.
Expressions
L'arithmétique, les puissances, les comparaisons, les opérateurs logiques, les opérateurs unaires, la syntaxe de magnitude |z| et les fonctions complexes testées peuvent être combinés.
Flux de contrôle
Utilise if, elseif, else et endif lorsqu'une mise à jour d'orbite dépend d'une condition. Les blocs doivent être équilibrés.
Fonctions intégrées
Les noms de base incluent z, c, pixel, zPrev, p1–p5, pi, e, maxit, ismand, fn1–fn4 et les fonctions couvertes par les tests du compilateur.
Commentaires et directives
Les commentaires commençant par un point-virgule documentent la source. Les directives @ reconnues configurent le comportement natif de FractalPark ; les directives inconnues ne sont pas ignorées silencieusement.
05

Pipeline de FRM vers AST vers GLSL

FractalPark ne colle pas le texte FRM dans un shader. Il fait passer la source par un compilateur par étapes afin que la syntaxe, le sens, le code généré et les diagnostics restent liés.

  1. 1

    Source FRM

    Le texte exact provenant de l'éditeur, d'un collage ou d'un fichier local est l'entrée faisant autorité.

  2. 2

    Jetons du lexer

    Le lexer reconnaît les noms, les nombres, les opérateurs, les marqueurs de section, les commentaires et les directives tout en conservant les emplacements source.

  3. 3

    AST analysé

    L'analyseur construit un arbre de formule structuré et signale les déclarations, expressions et blocs de flux de contrôle mal formés.

  4. 4

    Validation et forme canonique

    Le validateur vérifie les noms, les types, les sections et la sémantique prise en charge avant qu'une formule canonique soit créée.

  5. 5

    GLSL et carte de source

    La génération de code émet des fonctions de shader et enregistre les correspondances du GLSL généré vers la source FRM.

  6. 6

    Plugin de formule

    Une compilation réussie devient le même contrat de plugin de formule utilisé par le moteur de rendu et le système d'assemblage de shaders.

Le contrat de compilateur partagé maintient l'Explorateur, l'éditeur autonome, les formules personnalisées enregistrées, les exemples et les tests sur un seul chemin d'implémentation.

06

Tutoriels progressifs

Ces exemples progressent de la plus petite formule quadratique aux paramètres et à la rétroaction avec état. Chaque bloc de source est tiré directement du registre d'exemples partagé et compilé pendant les tests.

Leçon 1

Mandelbrot de départ

La plus petite formule à temps d'échappement, idéale pour apprendre d'abord la structure init / boucle / sortie.

Objectif : la déclaration et la structure init / loop / bailout. Ne modifie l'exposant ou le seuil d'échappement qu'une fois cette version compilée.

starter-brot.frm
StarterBrot {
init:
  z = 0
loop:
  z = z^2 + c
bailout:
  |z| < 4
}

Leçon 2

Dérive de paramètres

Montre les emplacements de paramètres p1 / p2 et la différence entre cabs et |z|.

Objectif : les emplacements de paramètres p1 et p2, un littéral complexe et cabs(z) comme fonction de magnitude explicite.

parameter-drift.frm
ParameterDrift {
init:
  z = 0
loop:
  z = z^2 + c + p1 * 0.15 + p2 * (0.05, -0.02)
bailout:
  cabs(z) < 8
}

Leçon 3

Écho d'orbite

Utilise zPrev comme mémoire de rétroaction et se marie bien avec la colorisation orbitEcho pour les enveloppes d'orbite.

Objectif : zPrev comme état d'orbite précédent. La rétroaction ajoute de la mémoire sans introduire une seconde variable d'état gérée manuellement.

orbit-echo.frm
OrbitEcho {
init:
  z = pixel
loop:
  z = sqr(z) + zPrev * (0.30, -0.12) + pixel * (0.85, 0.0)
bailout:
  |z| < 48
}

L’Éditeur FRM ouvre ces mêmes exemples vérifiés à la compilation grâce à un ID stable. Le code source de la formule reste uniquement dans l’onglet actuel jusqu’à ce que tu l’enregistres dans ta bibliothèque de formules cloud, et n’est jamais intégré à l’URL.

07

Erreurs et diagnostics

La compilation s'arrête au premier stade non sûr et signale des messages orientés source. Une construction rejetée n'est jamais réécrite en quelque chose qui lui ressemble simplement.

Erreurs lexicales

Les caractères inattendus et les identifiants non pris en charge sont signalés avec leur ligne et leur colonne.

Erreurs d'analyse

Les sections, expressions ou blocs de flux de contrôle mal formés sont diagnostiqués avant la validation sémantique.

Erreurs de validation

Les variables inconnues, les affectations invalides, les incompatibilités de types et la sémantique non prise en charge empêchent la génération de code.

Mappage de source du shader

Le GLSL généré conserve des correspondances qui peuvent ramener un échec de compilation du shader à l'emplacement FRM d'origine.

Lorsque tu corriges une erreur, commence par le premier message signalé : les diagnostics suivants peuvent être les conséquences du même jeton manquant ou de la même expression invalide.

08

Partage et publication

Une formule que tu écris est privée jusqu'à ce que tu choisisses autrement. Il existe trois façons de la faire circuler — chacune explicite, aucune silencieuse.

  • Privé par défaut

    Les formules vivent dans ta bibliothèque cloud, visibles uniquement par toi. Les œuvres que tu enregistres contiennent une copie de la source de la formule dans le brouillon, afin qu'elles s'ouvrent toujours telles que tu les as laissées.

  • Télécharger le fichier .frm

    Ta formule est du texte brut. Télécharge-la depuis Mes formules à tout moment et conserve ta propre copie — aucune demande d'export, aucune attente.

  • Publier une œuvre, partager la source

    Publier une œuvre qui utilise ta formule rend la source de la formule publique sous licence MIT : chacun peut la lire, la copier et s'en inspirer. La page communautaire affiche le nom de la formule d'après ses métadonnées et propose la source en téléchargement. Cela ne peut pas être annulé pour cette publication.

Le texte intégral de la licence MIT se trouve sur opensource.org.

09

Exemples, prochaines étapes et références

Voir le moteur de rendu en contexte

Ouvre l'Explorateur pour comparer le comportement des formules intégrées, la colorisation, les transformations, l'animation et les contrôles d'export avant d'écrire une formule personnalisée.

Ouvrir l'Explorateur

Utilise l’Éditeur FRM dédié pour compiler, prévisualiser, importer et télécharger des formules ; connecte-toi pour en enregistrer une dans ta bibliothèque de formules cloud avant de la transmettre à l’Explorateur.

Références

Le contexte historique et les détails d'implémentation sont liés séparément afin que le guide puisse distinguer la lignée Fractint du contrat de compilateur actuel de FractalPark.