186 lignes
8.0 KiB
PowerShell
186 lignes
8.0 KiB
PowerShell
# ---------------------------------------------------------------------------
|
|
# Generateur d'assets .obj de test pour la Phase 3 (loader de mesh).
|
|
#
|
|
# Produit deux fichiers dans assets/ , volontairement minuscules (quelques Ko) :
|
|
#
|
|
# icosphere.obj - icosphere subdivisee 1 fois : 42 sommets / 80 triangles,
|
|
# normales LISSES (normale = position normalisee) + UV
|
|
# spheriques. Teste le cas "beaucoup de faces, normales et
|
|
# UV presents, indices v/vt/vn identiques".
|
|
#
|
|
# octahedron.obj - octaedre a facettes PLATES : 6 positions seulement mais 8
|
|
# normales distinctes. Chaque position est donc reutilisee
|
|
# par plusieurs faces avec des normales differentes -> teste
|
|
# la deduplication du loader sur le triplet (v, vt, vn),
|
|
# cas que l'icosphere ne couvre pas.
|
|
#
|
|
# Usage : powershell -ExecutionPolicy Bypass -File tools\gen_test_meshes.ps1
|
|
# ---------------------------------------------------------------------------
|
|
|
|
$ErrorActionPreference = 'Stop'
|
|
|
|
$assetsDir = Join-Path (Split-Path -Parent $PSScriptRoot) 'assets'
|
|
if (-not (Test-Path $assetsDir)) {
|
|
New-Item -ItemType Directory -Path $assetsDir | Out-Null
|
|
}
|
|
|
|
# Culture invariante : sur une machine en locale FR, "{0:F6}" produirait des
|
|
# virgules decimales, illisibles pour un parseur .obj.
|
|
$inv = [System.Globalization.CultureInfo]::InvariantCulture
|
|
function Fmt([double]$v) { return $v.ToString('F6', $inv) }
|
|
|
|
function Write-ObjFile([string]$path, [string[]]$lines) {
|
|
# UTF8 sans BOM : un BOM en tete de fichier n'est pas garanti d'etre tolere
|
|
# par tous les parseurs .obj.
|
|
$enc = New-Object System.Text.UTF8Encoding($false)
|
|
[System.IO.File]::WriteAllLines($path, $lines, $enc)
|
|
Write-Host ("Ecrit : {0} ({1} lignes)" -f $path, $lines.Count)
|
|
}
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# 1. Icosphere (icosaedre + 1 subdivision, projetee sur la sphere unite)
|
|
# ---------------------------------------------------------------------------
|
|
$positions = New-Object System.Collections.ArrayList
|
|
$midCache = @{} # cle "i_j" -> index du milieu deja cree
|
|
|
|
function Add-Normalized([double]$x, [double]$y, [double]$z) {
|
|
$len = [math]::Sqrt($x * $x + $y * $y + $z * $z)
|
|
# Parentheses obligatoires autour de chaque element : dans un @(...), la
|
|
# virgule de PowerShell est PLUS prioritaire que les operateurs arithmetiques,
|
|
# donc "@($x / $len, $y / $len)" se lirait "$x / ($len, $y) / $len".
|
|
[void]$positions.Add(@(($x / $len), ($y / $len), ($z / $len)))
|
|
return $positions.Count - 1
|
|
}
|
|
|
|
# Milieu de l'arete (a,b), projete sur la sphere. Mis en cache pour que les
|
|
# deux triangles partageant l'arete reutilisent le meme sommet (mesh soude).
|
|
function Get-Midpoint([int]$a, [int]$b) {
|
|
$key = if ($a -lt $b) { "$($a)_$($b)" } else { "$($b)_$($a)" }
|
|
if ($midCache.ContainsKey($key)) { return $midCache[$key] }
|
|
|
|
$pa = $positions[$a]
|
|
$pb = $positions[$b]
|
|
$idx = Add-Normalized (($pa[0] + $pb[0]) / 2) (($pa[1] + $pb[1]) / 2) (($pa[2] + $pb[2]) / 2)
|
|
$midCache[$key] = $idx
|
|
return $idx
|
|
}
|
|
|
|
# Nombre d'or : les 12 sommets de l'icosaedre sont 3 rectangles d'or orthogonaux.
|
|
$t = (1.0 + [math]::Sqrt(5.0)) / 2.0
|
|
|
|
$icoVerts = @(
|
|
@(-1, $t, 0), @( 1, $t, 0), @(-1, -$t, 0), @( 1, -$t, 0),
|
|
@( 0, -1, $t), @( 0, 1, $t), @( 0, -1, -$t), @( 0, 1, -$t),
|
|
@( $t, 0, -1), @( $t, 0, 1), @(-$t, 0, -1), @(-$t, 0, 1)
|
|
)
|
|
foreach ($v in $icoVerts) {
|
|
# Variables intermediaires : "[double]$v[0]" se lit "([double]$v)[0]" en
|
|
# PowerShell, ce qui casserait le cast.
|
|
$vx = [double]$v[0]
|
|
$vy = [double]$v[1]
|
|
$vz = [double]$v[2]
|
|
[void](Add-Normalized $vx $vy $vz)
|
|
}
|
|
|
|
# 20 faces de l'icosaedre, enroulement anti-horaire vu de l'exterieur.
|
|
$faces = @(
|
|
@(0, 11, 5), @(0, 5, 1), @(0, 1, 7), @(0, 7, 10), @(0, 10, 11),
|
|
@(1, 5, 9), @(5, 11, 4), @(11, 10, 2), @(10, 7, 6), @(7, 1, 8),
|
|
@(3, 9, 4), @(3, 4, 2), @(3, 2, 6), @(3, 6, 8), @(3, 8, 9),
|
|
@(4, 9, 5), @(2, 4, 11), @(6, 2, 10), @(8, 6, 7), @(9, 8, 1)
|
|
)
|
|
|
|
# Une passe de subdivision : chaque triangle -> 4 triangles.
|
|
$subdivided = New-Object System.Collections.ArrayList
|
|
foreach ($f in $faces) {
|
|
$a = Get-Midpoint $f[0] $f[1]
|
|
$b = Get-Midpoint $f[1] $f[2]
|
|
$c = Get-Midpoint $f[2] $f[0]
|
|
[void]$subdivided.Add(@($f[0], $a, $c))
|
|
[void]$subdivided.Add(@($f[1], $b, $a))
|
|
[void]$subdivided.Add(@($f[2], $c, $b))
|
|
[void]$subdivided.Add(@($a, $b, $c))
|
|
}
|
|
|
|
$lines = New-Object System.Collections.ArrayList
|
|
[void]$lines.Add('# Vercora - asset de test Phase 3 : icosphere (1 subdivision)')
|
|
[void]$lines.Add(('# {0} sommets, {1} triangles, normales lissees + UV spheriques' -f $positions.Count, $subdivided.Count))
|
|
[void]$lines.Add('# Genere par tools/gen_test_meshes.ps1 - ne pas editer a la main')
|
|
[void]$lines.Add('o Icosphere')
|
|
|
|
# Note : la chaine est construite dans une variable avant l'appel a .Add().
|
|
# Dans les parentheses d'un appel de methode .NET, la virgule separe les
|
|
# ARGUMENTS de la methode : ecrire .Add('{0} {1}' -f $a, $b) appellerait
|
|
# Add() avec 2 arguments au lieu de formater 2 valeurs.
|
|
foreach ($p in $positions) {
|
|
$line = 'v {0} {1} {2}' -f (Fmt $p[0]), (Fmt $p[1]), (Fmt $p[2])
|
|
[void]$lines.Add($line)
|
|
}
|
|
# Sphere unite centree sur l'origine : la normale d'un sommet EST sa position.
|
|
foreach ($p in $positions) {
|
|
$line = 'vn {0} {1} {2}' -f (Fmt $p[0]), (Fmt $p[1]), (Fmt $p[2])
|
|
[void]$lines.Add($line)
|
|
}
|
|
# Mapping equirectangulaire (longitude/latitude). Pas encore utilise par le
|
|
# shader, mais present pour verifier que le loader lit bien les UV.
|
|
foreach ($p in $positions) {
|
|
$u = 0.5 + [math]::Atan2($p[2], $p[0]) / (2.0 * [math]::PI)
|
|
$vv = 0.5 - [math]::Asin([math]::Max(-1.0, [math]::Min(1.0, $p[1]))) / [math]::PI
|
|
$line = 'vt {0} {1}' -f (Fmt $u), (Fmt $vv)
|
|
[void]$lines.Add($line)
|
|
}
|
|
foreach ($f in $subdivided) {
|
|
$i = $f[0] + 1; $j = $f[1] + 1; $k = $f[2] + 1
|
|
[void]$lines.Add("f $i/$i/$i $j/$j/$j $k/$k/$k")
|
|
}
|
|
|
|
Write-ObjFile (Join-Path $assetsDir 'icosphere.obj') $lines.ToArray()
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# 2. Octaedre a facettes plates
|
|
# ---------------------------------------------------------------------------
|
|
# 6 positions (les pointes sur les axes), 8 faces triangulaires. La normale de
|
|
# chaque face est (+/-1, +/-1, +/-1) normalisee : les 3 sommets d'une face
|
|
# partagent SA normale, et chaque position apparait dans 4 faces avec 4
|
|
# normales differentes.
|
|
$octPos = @(
|
|
@( 1, 0, 0), @(-1, 0, 0), # 1, 2 : +X, -X
|
|
@( 0, 1, 0), @( 0,-1, 0), # 3, 4 : +Y, -Y
|
|
@( 0, 0, 1), @( 0, 0,-1) # 5, 6 : +Z, -Z
|
|
)
|
|
# Chaque face : les 3 positions (indices .obj 1-based) + le signe de sa normale.
|
|
$octFaces = @(
|
|
@(1, 3, 5, 1, 1, 1), @(3, 2, 5, -1, 1, 1),
|
|
@(2, 4, 5, -1, -1, 1), @(4, 1, 5, 1, -1, 1),
|
|
@(3, 1, 6, 1, 1, -1), @(2, 3, 6, -1, 1, -1),
|
|
@(4, 2, 6, -1, -1, -1), @(1, 4, 6, 1, -1, -1)
|
|
)
|
|
|
|
$lines = New-Object System.Collections.ArrayList
|
|
[void]$lines.Add('# Vercora - asset de test Phase 3 : octaedre a facettes plates')
|
|
[void]$lines.Add('# 6 positions / 8 normales distinctes / 8 triangles')
|
|
[void]$lines.Add('# Chaque position est reutilisee avec plusieurs normales : teste la')
|
|
[void]$lines.Add('# deduplication du loader sur le triplet (position, uv, normale).')
|
|
[void]$lines.Add('# Genere par tools/gen_test_meshes.ps1 - ne pas editer a la main')
|
|
[void]$lines.Add('o OctahedronFlat')
|
|
|
|
foreach ($p in $octPos) {
|
|
$line = 'v {0} {1} {2}' -f (Fmt $p[0]), (Fmt $p[1]), (Fmt $p[2])
|
|
[void]$lines.Add($line)
|
|
}
|
|
$invSqrt3 = 1.0 / [math]::Sqrt(3.0)
|
|
foreach ($f in $octFaces) {
|
|
$line = 'vn {0} {1} {2}' -f (Fmt ($f[3] * $invSqrt3)), (Fmt ($f[4] * $invSqrt3)), (Fmt ($f[5] * $invSqrt3))
|
|
[void]$lines.Add($line)
|
|
}
|
|
# Pas de 'vt' ici : verifie aussi que le loader accepte un .obj SANS UV
|
|
# (format "f v//vn").
|
|
$n = 0
|
|
foreach ($f in $octFaces) {
|
|
$n++
|
|
$line = 'f {0}//{3} {1}//{3} {2}//{3}' -f $f[0], $f[1], $f[2], $n
|
|
[void]$lines.Add($line)
|
|
}
|
|
|
|
Write-ObjFile (Join-Path $assetsDir 'octahedron.obj') $lines.ToArray()
|