949 lines
39 KiB
PowerShell
949 lines
39 KiB
PowerShell
# Script to organize texture files by checksum with two-level duplicate detection
|
|
# Pass 1: Intra-blendfile duplicates → [blendfile]\common
|
|
# Pass 2: Inter-blendfile duplicates → \textures\common
|
|
# Usage: .\organize_textures.ps1
|
|
|
|
# Prompt user for texture folder path
|
|
$textureFolderPath = Read-Host "Enter texture folder path"
|
|
|
|
# Validate the input path
|
|
if ([string]::IsNullOrWhiteSpace($textureFolderPath)) {
|
|
Write-Host "Error: No path provided." -ForegroundColor Red
|
|
exit
|
|
}
|
|
|
|
if (-not (Test-Path -Path $textureFolderPath -PathType Container)) {
|
|
Write-Host "Error: Path does not exist or is not a directory: $textureFolderPath" -ForegroundColor Red
|
|
exit
|
|
}
|
|
|
|
# Resolve the full path
|
|
$textureFolderPath = (Resolve-Path $textureFolderPath).ProviderPath
|
|
Write-Host "Processing texture folder: $textureFolderPath" -ForegroundColor Cyan
|
|
|
|
# Add required .NET assemblies for image processing (for FlatColors standardization)
|
|
Add-Type -AssemblyName System.Drawing
|
|
|
|
# Function to calculate checksums for files
|
|
function Get-FilesWithChecksums {
|
|
param(
|
|
[array]$Files
|
|
)
|
|
|
|
$throttleLimit = [Math]::Max(1, [Environment]::ProcessorCount)
|
|
$parallelScriptBlock = {
|
|
try {
|
|
$hash = Get-FileHash -Path $_.FullName -Algorithm SHA256
|
|
[PSCustomObject]@{
|
|
File = $_
|
|
Hash = $hash.Hash
|
|
}
|
|
} catch {
|
|
Write-Warning "Failed to calculate checksum for: $($_.FullName) - $($_.Exception.Message)"
|
|
$null
|
|
}
|
|
}
|
|
|
|
return $Files | ForEach-Object -Parallel $parallelScriptBlock -ThrottleLimit $throttleLimit | Where-Object { $null -ne $_ }
|
|
}
|
|
|
|
# Function to move files to common folder
|
|
function Move-FilesToCommon {
|
|
param(
|
|
[array]$Files,
|
|
[string]$CommonPath,
|
|
[string]$DuplicatesPath,
|
|
[hashtable]$FilesInCommon
|
|
)
|
|
|
|
$movedCount = 0
|
|
$duplicateCount = 0
|
|
|
|
foreach ($fileObj in $Files) {
|
|
$fileName = $fileObj.Name
|
|
$destinationPath = Join-Path -Path $CommonPath -ChildPath $fileName
|
|
|
|
# Handle name conflicts
|
|
if ($FilesInCommon.ContainsKey($fileName)) {
|
|
$baseName = [System.IO.Path]::GetFileNameWithoutExtension($fileName)
|
|
$extension = [System.IO.Path]::GetExtension($fileName)
|
|
$counter = 1
|
|
do {
|
|
$newFileName = "${baseName}_${counter}${extension}"
|
|
$destinationPath = Join-Path -Path $CommonPath -ChildPath $newFileName
|
|
$counter++
|
|
} while ($FilesInCommon.ContainsKey($newFileName) -or (Test-Path -Path $destinationPath))
|
|
|
|
$fileName = $newFileName
|
|
}
|
|
|
|
try {
|
|
Move-Item -Path $fileObj.FullName -Destination $destinationPath -Force
|
|
$FilesInCommon[$fileName] = $true
|
|
$movedCount++
|
|
} catch {
|
|
Write-Warning "Failed to move file: $($fileObj.FullName) - $($_.Exception.Message)"
|
|
}
|
|
}
|
|
|
|
return @{
|
|
MovedCount = $movedCount
|
|
DuplicateCount = $duplicateCount
|
|
}
|
|
}
|
|
|
|
# Function to extract suffix after blendfile prefix (e.g., "Demarco_Std_Teeth_ao.jpg" -> "Std_Teeth_ao.jpg")
|
|
# Only strips prefixes that are in the $ValidPrefixes list
|
|
function Get-FileNameWithoutPrefix {
|
|
param(
|
|
[string]$FileName,
|
|
[string[]]$ValidPrefixes
|
|
)
|
|
|
|
# Validate input
|
|
if ([string]::IsNullOrWhiteSpace($FileName)) {
|
|
return $FileName
|
|
}
|
|
|
|
# If no valid prefixes provided, return original filename
|
|
if ($null -eq $ValidPrefixes -or $ValidPrefixes.Count -eq 0) {
|
|
return $FileName
|
|
}
|
|
|
|
# Use Split instead of regex for robustness (avoids $matches variable issues in loops)
|
|
# Split by the first underscore only (limit to 2 parts)
|
|
$parts = $FileName.Split('_', 2)
|
|
|
|
if ($parts.Length -eq 2) {
|
|
$prefix = $parts[0]
|
|
$suffix = $parts[1]
|
|
|
|
# Only strip if the prefix is in the valid prefixes list
|
|
if ($ValidPrefixes -contains $prefix -and -not [string]::IsNullOrWhiteSpace($suffix)) {
|
|
return $suffix
|
|
}
|
|
}
|
|
|
|
# No valid prefix found or suffix is empty, return original filename
|
|
return $FileName
|
|
}
|
|
|
|
# Function to process duplicate group
|
|
function Process-DuplicateGroup {
|
|
param(
|
|
[array]$Files,
|
|
[string]$CommonPath,
|
|
[hashtable]$FilesInCommon,
|
|
[switch]$StripPrefix,
|
|
[string[]]$ValidPrefixes = @(),
|
|
[System.Collections.ArrayList]$MoveLog = $null
|
|
)
|
|
|
|
$movedCount = 0
|
|
$duplicateCount = 0
|
|
|
|
if ($Files.Count -eq 1) {
|
|
# Single file - leave in place (will be processed in Pass 2)
|
|
return @{
|
|
MovedCount = 0
|
|
DuplicateCount = 0
|
|
}
|
|
}
|
|
|
|
# Validate files array
|
|
if ($null -eq $Files -or $Files.Count -eq 0) {
|
|
return @{
|
|
MovedCount = 0
|
|
DuplicateCount = 0
|
|
}
|
|
}
|
|
|
|
# Multiple files with same checksum (duplicates)
|
|
# Determine the filename to use
|
|
$firstFile = $Files[0].File
|
|
if ($null -eq $firstFile -or [string]::IsNullOrWhiteSpace($firstFile.Name)) {
|
|
Write-Warning "Invalid file object in duplicate group"
|
|
return @{
|
|
MovedCount = 0
|
|
DuplicateCount = 0
|
|
}
|
|
}
|
|
|
|
$fileName = $firstFile.Name
|
|
|
|
# If StripPrefix is enabled, always strip prefix from the filename
|
|
if ($StripPrefix) {
|
|
# Always try to strip prefix - if file has a prefix, it will be removed
|
|
$strippedName = Get-FileNameWithoutPrefix -FileName $firstFile.Name -ValidPrefixes $ValidPrefixes
|
|
|
|
# Use stripped name if it's different from original (prefix was removed)
|
|
# Otherwise keep original (file had no prefix to strip)
|
|
if ($strippedName -ne $firstFile.Name) {
|
|
$fileName = $strippedName
|
|
}
|
|
|
|
# If we have multiple files with same checksum, try to find common suffix
|
|
# This handles cases where files from different blendfiles share the same texture
|
|
if ($Files.Count -gt 1) {
|
|
$allSuffixes = @()
|
|
foreach ($fileObj in $Files) {
|
|
# $fileObj is a PSCustomObject with .File property, so access .File.Name
|
|
$suffix = Get-FileNameWithoutPrefix -FileName $fileObj.File.Name -ValidPrefixes $ValidPrefixes
|
|
$allSuffixes += $suffix
|
|
}
|
|
|
|
# If all files strip to the same suffix, use that
|
|
$uniqueSuffixes = @($allSuffixes | Select-Object -Unique)
|
|
if ($uniqueSuffixes.Count -eq 1 -and $uniqueSuffixes[0] -ne $firstFile.Name) {
|
|
$fileName = [string]$uniqueSuffixes[0]
|
|
}
|
|
}
|
|
}
|
|
|
|
# Ensure fileName is never null or empty
|
|
if ([string]::IsNullOrWhiteSpace($fileName)) {
|
|
$fileName = $firstFile.Name
|
|
}
|
|
|
|
$destinationPath = Join-Path -Path $CommonPath -ChildPath $fileName
|
|
|
|
# Handle name conflicts for the first file
|
|
if ($FilesInCommon.ContainsKey($fileName)) {
|
|
$baseName = [System.IO.Path]::GetFileNameWithoutExtension($fileName)
|
|
$extension = [System.IO.Path]::GetExtension($fileName)
|
|
$counter = 1
|
|
do {
|
|
$newFileName = "${baseName}_${counter}${extension}"
|
|
$destinationPath = Join-Path -Path $CommonPath -ChildPath $newFileName
|
|
$counter++
|
|
} while ($FilesInCommon.ContainsKey($newFileName) -or (Test-Path -Path $destinationPath))
|
|
|
|
$fileName = $newFileName
|
|
}
|
|
|
|
try {
|
|
Move-Item -Path $firstFile.FullName -Destination $destinationPath -Force
|
|
$FilesInCommon[$fileName] = $true
|
|
$movedCount++
|
|
|
|
# Log the move
|
|
if ($null -ne $MoveLog) {
|
|
$normalizedOriginal = [System.IO.Path]::GetFullPath($firstFile.FullName)
|
|
$normalizedNew = [System.IO.Path]::GetFullPath($destinationPath)
|
|
$null = $MoveLog.Add([PSCustomObject]@{
|
|
OriginalPath = $normalizedOriginal
|
|
NewPath = $normalizedNew
|
|
Type = "moved"
|
|
})
|
|
}
|
|
} catch {
|
|
Write-Warning "Failed to move first duplicate file: $($firstFile.FullName) - $($_.Exception.Message)"
|
|
}
|
|
|
|
# Delete remaining duplicate files (they're replaced by the common file)
|
|
for ($i = 1; $i -lt $Files.Count; $i++) {
|
|
$fileObj = $Files[$i].File
|
|
try {
|
|
$originalPath = $fileObj.FullName
|
|
Remove-Item -Path $originalPath -Force
|
|
$duplicateCount++
|
|
|
|
# Log the deletion (replaced by the moved file)
|
|
if ($null -ne $MoveLog) {
|
|
$normalizedOriginal = [System.IO.Path]::GetFullPath($originalPath)
|
|
$normalizedReplacement = [System.IO.Path]::GetFullPath($destinationPath)
|
|
$null = $MoveLog.Add([PSCustomObject]@{
|
|
OriginalPath = $normalizedOriginal
|
|
ReplacedBy = $normalizedReplacement
|
|
Type = "deleted"
|
|
})
|
|
}
|
|
} catch {
|
|
Write-Warning "Failed to delete duplicate file: $($fileObj.FullName) - $($_.Exception.Message)"
|
|
}
|
|
}
|
|
|
|
return @{
|
|
MovedCount = $movedCount
|
|
DuplicateCount = $duplicateCount
|
|
}
|
|
}
|
|
|
|
# Function to extract and normalize hex color code from filename (for FlatColors)
|
|
function Get-NormalizedColorCode {
|
|
param([string]$FileName)
|
|
|
|
# Remove extension
|
|
$baseName = [System.IO.Path]::GetFileNameWithoutExtension($FileName)
|
|
|
|
# Match hex color pattern: #RRGGBB or #RRGGBBAA (with optional suffix like _1, _2, etc.)
|
|
# Pattern matches: #RRGGBB, #RRGGBBAA, or just RRGGBB (without #)
|
|
# Also handles suffixes like _1, _2, etc.
|
|
if ($baseName -match '^(#?)([0-9A-Fa-f]{6})([0-9A-Fa-f]{2})?') {
|
|
$hasHash = $Matches[1] -eq "#"
|
|
$hexCode = $Matches[2].ToUpper()
|
|
# Return normalized format: #RRGGBB (always with #, always uppercase, no suffix)
|
|
return "#$hexCode"
|
|
}
|
|
|
|
return $null
|
|
}
|
|
|
|
# Function to convert and resize image to 16x16 JPG (for FlatColors)
|
|
function Convert-To16x16Jpg {
|
|
param(
|
|
[string]$SourcePath,
|
|
[string]$DestinationPath
|
|
)
|
|
|
|
try {
|
|
$image = [System.Drawing.Image]::FromFile($SourcePath)
|
|
|
|
# Create 16x16 bitmap
|
|
$bitmap = New-Object System.Drawing.Bitmap(16, 16)
|
|
$graphics = [System.Drawing.Graphics]::FromImage($bitmap)
|
|
$graphics.InterpolationMode = [System.Drawing.Drawing2D.InterpolationMode]::HighQualityBicubic
|
|
$graphics.SmoothingMode = [System.Drawing.Drawing2D.SmoothingMode]::HighQuality
|
|
$graphics.PixelOffsetMode = [System.Drawing.Drawing2D.PixelOffsetMode]::HighQuality
|
|
|
|
# Draw resized image
|
|
$graphics.DrawImage($image, 0, 0, 16, 16)
|
|
|
|
# Get JPEG codec
|
|
$jpegCodec = [System.Drawing.Imaging.ImageCodecInfo]::GetImageEncoders() | Where-Object { $_.MimeType -eq "image/jpeg" }
|
|
$encoderParams = New-Object System.Drawing.Imaging.EncoderParameters(1)
|
|
$encoderParams.Param[0] = New-Object System.Drawing.Imaging.EncoderParameter([System.Drawing.Imaging.Encoder]::Quality, 95)
|
|
|
|
# Save as JPG
|
|
$bitmap.Save($DestinationPath, $jpegCodec, $encoderParams)
|
|
|
|
# Cleanup
|
|
$graphics.Dispose()
|
|
$bitmap.Dispose()
|
|
$image.Dispose()
|
|
$encoderParams.Dispose()
|
|
|
|
return $true
|
|
} catch {
|
|
Write-Warning "Failed to convert image: $SourcePath - $($_.Exception.Message)"
|
|
return $false
|
|
}
|
|
}
|
|
|
|
# Function to check if image is 16x16 (for FlatColors)
|
|
function Test-ImageSize {
|
|
param([string]$ImagePath)
|
|
|
|
try {
|
|
$image = [System.Drawing.Image]::FromFile($ImagePath)
|
|
$is16x16 = ($image.Width -eq 16 -and $image.Height -eq 16)
|
|
$image.Dispose()
|
|
return $is16x16
|
|
} catch {
|
|
return $false
|
|
}
|
|
}
|
|
|
|
# ============================================================================
|
|
# PASS 1: Intra-Blendfile Processing
|
|
# ============================================================================
|
|
Write-Host ""
|
|
Write-Host "=== PASS 1: Intra-Blendfile Processing ===" -ForegroundColor Cyan
|
|
|
|
# Get all direct subdirectories of texture folder (blendfile folders)
|
|
$blendfileFolders = Get-ChildItem -Path $textureFolderPath -Directory | Where-Object { $_.Name -ne "common" }
|
|
|
|
if ($null -eq $blendfileFolders -or $blendfileFolders.Count -eq 0) {
|
|
Write-Host "No blendfile folders found. Skipping Pass 1." -ForegroundColor Yellow
|
|
} else {
|
|
Write-Host "Found $($blendfileFolders.Count) blendfile folder(s) to process." -ForegroundColor Green
|
|
|
|
$totalPass1Moved = 0
|
|
$totalPass1Duplicates = 0
|
|
$pass1MoveLog = [System.Collections.ArrayList]::new()
|
|
|
|
foreach ($blendfileFolder in $blendfileFolders) {
|
|
Write-Host ""
|
|
Write-Host "Processing blendfile: $($blendfileFolder.Name)" -ForegroundColor Yellow
|
|
|
|
# Get all files in this blendfile folder, excluding \common folders
|
|
$blendfileFiles = Get-ChildItem -Path $blendfileFolder.FullName -Recurse -File | Where-Object { $_.FullName -notlike "*\common\*" }
|
|
|
|
if ($null -eq $blendfileFiles -or $blendfileFiles.Count -eq 0) {
|
|
Write-Host " No files found in this blendfile folder." -ForegroundColor Gray
|
|
continue
|
|
}
|
|
|
|
Write-Host " Found $($blendfileFiles.Count) files." -ForegroundColor Gray
|
|
|
|
# Calculate checksums
|
|
Write-Host " Calculating checksums..." -ForegroundColor Gray
|
|
$filesWithChecksums = Get-FilesWithChecksums -Files $blendfileFiles
|
|
|
|
# Group by checksum
|
|
$groupedByChecksum = $filesWithChecksums | Group-Object -Property Hash
|
|
|
|
Write-Host " Found $($groupedByChecksum.Count) unique checksums." -ForegroundColor Gray
|
|
|
|
# Create [blendfile]\common directory
|
|
$blendfileCommonPath = Join-Path -Path $blendfileFolder.FullName -ChildPath "common"
|
|
|
|
if (-not (Test-Path -Path $blendfileCommonPath -PathType Container)) {
|
|
New-Item -ItemType Directory -Path $blendfileCommonPath | Out-Null
|
|
}
|
|
|
|
# Track filenames already in [blendfile]\common
|
|
$filesInBlendfileCommon = @{}
|
|
|
|
# Process each checksum group
|
|
$blendfileMoved = 0
|
|
$blendfileDuplicates = 0
|
|
|
|
foreach ($group in $groupedByChecksum) {
|
|
$result = Process-DuplicateGroup -Files $group.Group -CommonPath $blendfileCommonPath -FilesInCommon $filesInBlendfileCommon -MoveLog $pass1MoveLog
|
|
$blendfileMoved += $result.MovedCount
|
|
$blendfileDuplicates += $result.DuplicateCount
|
|
}
|
|
|
|
Write-Host " Moved $blendfileMoved file(s) to \common, deleted $blendfileDuplicates duplicate(s)" -ForegroundColor Green
|
|
$totalPass1Moved += $blendfileMoved
|
|
$totalPass1Duplicates += $blendfileDuplicates
|
|
}
|
|
|
|
Write-Host ""
|
|
Write-Host "Pass 1 complete: $totalPass1Moved file(s) moved, $totalPass1Duplicates duplicate(s) deleted" -ForegroundColor Green
|
|
}
|
|
|
|
# ============================================================================
|
|
# PASS 2: Inter-Blendfile Processing
|
|
# ============================================================================
|
|
Write-Host ""
|
|
Write-Host "=== PASS 2: Inter-Blendfile Processing ===" -ForegroundColor Cyan
|
|
|
|
# Build list of valid blendfile prefixes from folder names
|
|
$validBlendfilePrefixes = @()
|
|
$blendfileFoldersForPrefixes = Get-ChildItem -Path $textureFolderPath -Directory | Where-Object { $_.Name -ne "common" }
|
|
if ($null -ne $blendfileFoldersForPrefixes) {
|
|
$validBlendfilePrefixes = $blendfileFoldersForPrefixes | ForEach-Object { $_.Name }
|
|
Write-Host "Valid blendfile prefixes: $($validBlendfilePrefixes -join ', ')" -ForegroundColor Gray
|
|
}
|
|
|
|
# Collect FlatColors files separately (including those in \common\FlatColors folders, but not from root \common\FlatColors)
|
|
Write-Host "Collecting FlatColors files..." -ForegroundColor Yellow
|
|
$rootCommonFlatColorsPath = Join-Path -Path $textureFolderPath -ChildPath "common\FlatColors"
|
|
$allFlatColorsFiles = Get-ChildItem -Path $textureFolderPath -Recurse -File | Where-Object {
|
|
($_.FullName -like "*\FlatColors\*" -or $_.Name -like "*FlatColors*") -and
|
|
$_.FullName -notlike "$([regex]::Escape($rootCommonFlatColorsPath))\*"
|
|
}
|
|
|
|
# Get all remaining files (excluding all \common folders, but we'll handle FlatColors separately)
|
|
Write-Host "Collecting remaining files..." -ForegroundColor Yellow
|
|
$remainingFiles = Get-ChildItem -Path $textureFolderPath -Recurse -File | Where-Object { $_.FullName -notlike "*\common\*" }
|
|
|
|
if ($null -eq $remainingFiles -or $remainingFiles.Count -eq 0) {
|
|
Write-Host "No remaining files found to process." -ForegroundColor Yellow
|
|
} else {
|
|
Write-Host "Found $($remainingFiles.Count) remaining files to process." -ForegroundColor Green
|
|
|
|
# Calculate checksums
|
|
Write-Host "Calculating checksums using parallel processing (this may take a while)..." -ForegroundColor Yellow
|
|
$filesWithChecksums = Get-FilesWithChecksums -Files $remainingFiles
|
|
|
|
Write-Host "Checksum calculation complete." -ForegroundColor Green
|
|
|
|
# Separate FlatColors files from other files before processing
|
|
Write-Host "Identifying FlatColors files..." -ForegroundColor Yellow
|
|
$flatColorsFiles = $allFlatColorsFiles | Where-Object { (Test-Path -Path $_.FullName) }
|
|
$nonFlatColorsFiles = $remainingFiles | Where-Object { $_.Name -notlike "*FlatColors*" }
|
|
|
|
Write-Host "Found $($flatColorsFiles.Count) FlatColors file(s) (including from \common\FlatColors folders), $($nonFlatColorsFiles.Count) other file(s)" -ForegroundColor Gray
|
|
|
|
# Group non-FlatColors files by checksum
|
|
Write-Host "Grouping files by checksum..." -ForegroundColor Yellow
|
|
$nonFlatColorsWithChecksums = $filesWithChecksums | Where-Object { $_.File.Name -notlike "*FlatColors*" }
|
|
$groupedByChecksum = $nonFlatColorsWithChecksums | Group-Object -Property Hash
|
|
|
|
Write-Host "Found $($groupedByChecksum.Count) unique checksums." -ForegroundColor Green
|
|
|
|
# Create \textures\common directory
|
|
$rootCommonPath = Join-Path -Path $textureFolderPath -ChildPath "common"
|
|
|
|
if (-not (Test-Path -Path $rootCommonPath -PathType Container)) {
|
|
New-Item -ItemType Directory -Path $rootCommonPath | Out-Null
|
|
Write-Host "Created directory: $rootCommonPath" -ForegroundColor Green
|
|
}
|
|
|
|
# Track filenames already in \textures\common
|
|
$filesInRootCommon = @{}
|
|
|
|
# Process each checksum group (excluding FlatColors)
|
|
Write-Host "Moving files to \common and deleting duplicates..." -ForegroundColor Yellow
|
|
$pass2Moved = 0
|
|
$pass2Duplicates = 0
|
|
$pass2MoveLog = [System.Collections.ArrayList]::new()
|
|
|
|
foreach ($group in $groupedByChecksum) {
|
|
$files = $group.Group
|
|
|
|
if ($files.Count -eq 1) {
|
|
# Single file - leave in place (unique file)
|
|
continue
|
|
}
|
|
|
|
# Multiple files with same checksum (duplicates across blendfiles)
|
|
# Use StripPrefix to remove blendfile prefixes (e.g., "Demarco_", "Chan_") when all files share the same suffix
|
|
$result = Process-DuplicateGroup -Files $files -CommonPath $rootCommonPath -FilesInCommon $filesInRootCommon -StripPrefix -ValidPrefixes $validBlendfilePrefixes -MoveLog $pass2MoveLog
|
|
$pass2Moved += $result.MovedCount
|
|
$pass2Duplicates += $result.DuplicateCount
|
|
}
|
|
|
|
# Process FlatColors files: standardize to 16x16 JPG (except TGA), merge duplicates by color code
|
|
Write-Host "Processing FlatColors files (standardizing and merging duplicates)..." -ForegroundColor Yellow
|
|
|
|
if ($null -ne $flatColorsFiles -and $flatColorsFiles.Count -gt 0) {
|
|
Write-Host "Found $($flatColorsFiles.Count) FlatColors file(s) to process" -ForegroundColor Gray
|
|
|
|
# Group files by normalized color code (instead of checksum)
|
|
Write-Host "Grouping FlatColors files by color code..." -ForegroundColor Yellow
|
|
$filesByColor = @{}
|
|
|
|
foreach ($file in $flatColorsFiles) {
|
|
if (-not (Test-Path -Path $file.FullName)) {
|
|
continue
|
|
}
|
|
|
|
$colorCode = Get-NormalizedColorCode -FileName $file.Name
|
|
if ($null -eq $colorCode) {
|
|
Write-Warning "Could not extract color code from: $($file.Name)"
|
|
continue
|
|
}
|
|
|
|
if (-not $filesByColor.ContainsKey($colorCode)) {
|
|
$filesByColor[$colorCode] = @()
|
|
}
|
|
$filesByColor[$colorCode] += $file
|
|
}
|
|
|
|
Write-Host "Found $($filesByColor.Count) unique color code(s)" -ForegroundColor Gray
|
|
|
|
# Create \textures\common\FlatColors directory
|
|
$flatColorsPath = Join-Path -Path $rootCommonPath -ChildPath "FlatColors"
|
|
if (-not (Test-Path -Path $flatColorsPath -PathType Container)) {
|
|
New-Item -ItemType Directory -Path $flatColorsPath | Out-Null
|
|
Write-Host "Created directory: $flatColorsPath" -ForegroundColor Green
|
|
}
|
|
|
|
# Track filenames already in \common\FlatColors
|
|
$filesInFlatColors = @{}
|
|
$flatColorsMoved = 0
|
|
$flatColorsDuplicates = 0
|
|
$flatColorsConverted = 0
|
|
$flatColorsResized = 0
|
|
$flatColorsMoveLog = [System.Collections.ArrayList]::new()
|
|
|
|
foreach ($colorCode in $filesByColor.Keys) {
|
|
$files = $filesByColor[$colorCode]
|
|
|
|
# Find the best file to keep (prefer existing JPG, then TGA, then others)
|
|
$fileToKeep = $null
|
|
$targetExtension = ".jpg"
|
|
$targetFileName = "$colorCode.jpg"
|
|
|
|
# First, check if there's already a correct file in target location
|
|
$existingTarget = Join-Path -Path $flatColorsPath -ChildPath $targetFileName
|
|
if (Test-Path -Path $existingTarget) {
|
|
$existingFile = Get-Item -Path $existingTarget
|
|
# Check if it's already correct
|
|
if ($existingFile.Extension -eq ".jpg" -and (Test-ImageSize -ImagePath $existingFile.FullName)) {
|
|
$fileToKeep = $existingFile
|
|
}
|
|
}
|
|
|
|
# If no existing correct file, find best source file
|
|
if ($null -eq $fileToKeep) {
|
|
# Prefer existing JPG file
|
|
$jpgFile = $files | Where-Object {
|
|
($_.Extension -eq ".jpg" -or $_.Extension -eq ".jpeg") -and
|
|
(Test-Path -Path $_.FullName)
|
|
} | Select-Object -First 1
|
|
|
|
if ($jpgFile) {
|
|
$fileToKeep = $jpgFile
|
|
} else {
|
|
# If no JPG, prefer TGA
|
|
$tgaFile = $files | Where-Object {
|
|
$_.Extension -eq ".tga" -and
|
|
(Test-Path -Path $_.FullName)
|
|
} | Select-Object -First 1
|
|
|
|
if ($tgaFile) {
|
|
$fileToKeep = $tgaFile
|
|
$targetExtension = ".tga"
|
|
$targetFileName = "$colorCode.tga"
|
|
} else {
|
|
# Otherwise, use the first available file
|
|
$fileToKeep = $files | Where-Object { Test-Path -Path $_.FullName } | Select-Object -First 1
|
|
}
|
|
}
|
|
}
|
|
|
|
if ($null -eq $fileToKeep) {
|
|
Write-Warning " $colorCode: No valid file found to process"
|
|
continue
|
|
}
|
|
|
|
$targetPath = Join-Path -Path $flatColorsPath -ChildPath $targetFileName
|
|
|
|
# If target is TGA, preserve as-is (don't convert)
|
|
if ($targetExtension -eq ".tga") {
|
|
if ($fileToKeep.FullName -ne $targetPath) {
|
|
# Move TGA to target location
|
|
try {
|
|
if (Test-Path -Path $targetPath) {
|
|
Remove-Item -Path $targetPath -Force
|
|
}
|
|
$originalPath = $fileToKeep.FullName
|
|
Move-Item -Path $originalPath -Destination $targetPath -Force
|
|
$filesInFlatColors[$targetFileName] = $true
|
|
$flatColorsMoved++
|
|
|
|
# Log the move
|
|
$normalizedOriginal = [System.IO.Path]::GetFullPath($originalPath)
|
|
$normalizedNew = [System.IO.Path]::GetFullPath($targetPath)
|
|
$null = $flatColorsMoveLog.Add([PSCustomObject]@{
|
|
OriginalPath = $normalizedOriginal
|
|
NewPath = $normalizedNew
|
|
Type = "moved"
|
|
})
|
|
} catch {
|
|
Write-Warning " $colorCode: Failed to move TGA: $($_.Exception.Message)"
|
|
}
|
|
}
|
|
} else {
|
|
# Target is JPG - convert/resize if needed
|
|
$needsConversion = $false
|
|
$needsResize = $false
|
|
|
|
if ($fileToKeep.Extension -ne ".jpg" -and $fileToKeep.Extension -ne ".jpeg") {
|
|
$needsConversion = $true
|
|
}
|
|
|
|
if (-not (Test-ImageSize -ImagePath $fileToKeep.FullName)) {
|
|
$needsResize = $true
|
|
}
|
|
|
|
# Check if target already exists and is correct
|
|
if ((Test-Path -Path $targetPath) -and
|
|
(Get-Item -Path $targetPath).Extension -eq ".jpg" -and
|
|
(Test-ImageSize -ImagePath $targetPath)) {
|
|
# Target already exists and is correct, skip
|
|
} elseif ($needsConversion -or $needsResize -or $fileToKeep.FullName -ne $targetPath) {
|
|
# Convert/resize to target
|
|
if (Convert-To16x16Jpg -SourcePath $fileToKeep.FullName -DestinationPath $targetPath) {
|
|
if ($needsConversion -and $needsResize) {
|
|
$flatColorsConverted++
|
|
$flatColorsResized++
|
|
} elseif ($needsConversion) {
|
|
$flatColorsConverted++
|
|
} elseif ($needsResize) {
|
|
$flatColorsResized++
|
|
} else {
|
|
$flatColorsMoved++
|
|
}
|
|
|
|
$filesInFlatColors[$targetFileName] = $true
|
|
|
|
# Log the conversion/move
|
|
$normalizedOriginal = [System.IO.Path]::GetFullPath($fileToKeep.FullName)
|
|
$normalizedNew = [System.IO.Path]::GetFullPath($targetPath)
|
|
$null = $flatColorsMoveLog.Add([PSCustomObject]@{
|
|
OriginalPath = $normalizedOriginal
|
|
NewPath = $normalizedNew
|
|
Type = "moved"
|
|
})
|
|
} else {
|
|
Write-Warning " $colorCode: Failed to convert/resize"
|
|
continue
|
|
}
|
|
} else {
|
|
# File is already correct format and size
|
|
if ($fileToKeep.FullName -ne $targetPath) {
|
|
try {
|
|
if (Test-Path -Path $targetPath) {
|
|
Remove-Item -Path $targetPath -Force
|
|
}
|
|
$originalPath = $fileToKeep.FullName
|
|
Move-Item -Path $originalPath -Destination $targetPath -Force
|
|
$filesInFlatColors[$targetFileName] = $true
|
|
$flatColorsMoved++
|
|
|
|
# Log the move
|
|
$normalizedOriginal = [System.IO.Path]::GetFullPath($originalPath)
|
|
$normalizedNew = [System.IO.Path]::GetFullPath($targetPath)
|
|
$null = $flatColorsMoveLog.Add([PSCustomObject]@{
|
|
OriginalPath = $normalizedOriginal
|
|
NewPath = $normalizedNew
|
|
Type = "moved"
|
|
})
|
|
} catch {
|
|
Write-Warning " $colorCode: Failed to move: $($_.Exception.Message)"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
# Delete duplicate files (all files in the group except the target)
|
|
foreach ($file in $files) {
|
|
if ($file.FullName -ne $targetPath -and (Test-Path -Path $file.FullName)) {
|
|
try {
|
|
$originalPath = $file.FullName
|
|
Remove-Item -Path $originalPath -Force
|
|
$flatColorsDuplicates++
|
|
|
|
# Log the deletion
|
|
$normalizedOriginal = [System.IO.Path]::GetFullPath($originalPath)
|
|
$normalizedReplacement = [System.IO.Path]::GetFullPath($targetPath)
|
|
$null = $flatColorsMoveLog.Add([PSCustomObject]@{
|
|
OriginalPath = $normalizedOriginal
|
|
ReplacedBy = $normalizedReplacement
|
|
Type = "deleted"
|
|
})
|
|
} catch {
|
|
Write-Warning " Failed to delete duplicate: $($file.FullName) - $($_.Exception.Message)"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Write-Host "Processed FlatColors: $flatColorsMoved moved, $flatColorsConverted converted, $flatColorsResized resized, $flatColorsDuplicates duplicate(s) deleted" -ForegroundColor Green
|
|
} else {
|
|
Write-Host "No FlatColors files found to process." -ForegroundColor Gray
|
|
}
|
|
|
|
Write-Host ""
|
|
Write-Host "Pass 2 complete: $pass2Moved file(s) moved to \common, $pass2Duplicates duplicate(s) deleted" -ForegroundColor Green
|
|
}
|
|
|
|
# ============================================================================
|
|
# Save Move Log and Find Blend Files
|
|
# ============================================================================
|
|
Write-Host ""
|
|
Write-Host "Saving move log and finding blend files..." -ForegroundColor Yellow
|
|
|
|
# Combine all move logs
|
|
$allMoves = @()
|
|
if ($null -ne $pass1MoveLog -and $pass1MoveLog.Count -gt 0) {
|
|
$allMoves += $pass1MoveLog
|
|
}
|
|
if ($null -ne $pass2MoveLog -and $pass2MoveLog.Count -gt 0) {
|
|
$allMoves += $pass2MoveLog
|
|
}
|
|
if ($null -ne $flatColorsMoveLog -and $flatColorsMoveLog.Count -gt 0) {
|
|
$allMoves += $flatColorsMoveLog
|
|
}
|
|
|
|
# Get parent directory of texture folder
|
|
$blendFileParentDir = Split-Path -Path $textureFolderPath -Parent
|
|
|
|
# Find matching blend files
|
|
# Match logic: blendfile folder name (e.g., "Beth") should appear in blend file name (e.g., "AM_Beth_v3.2.blend")
|
|
$blendFileMappings = @()
|
|
if ($null -ne $blendfileFolders -and $blendfileFolders.Count -gt 0) {
|
|
# Get blendfile folder names
|
|
$blendfileFolderNames = $blendfileFolders | ForEach-Object { $_.Name }
|
|
|
|
# Find all .blend files in parent directory
|
|
$blendFiles = Get-ChildItem -Path $blendFileParentDir -Filter "*.blend" -File -ErrorAction SilentlyContinue
|
|
|
|
if ($null -ne $blendFiles -and $blendFiles.Count -gt 0) {
|
|
foreach ($blendFile in $blendFiles) {
|
|
$blendFileName = $blendFile.BaseName
|
|
|
|
# Check if any blendfile folder name appears in the blend file name
|
|
foreach ($folderName in $blendfileFolderNames) {
|
|
# Match folder name when surrounded by underscores, dots, hyphens, or at start/end
|
|
# This avoids partial matches (e.g., "Beth" in "Bethany") while allowing "Beth" in "AM_Beth_v3.2"
|
|
$escapedFolderName = [regex]::Escape($folderName)
|
|
if ($blendFileName -match "(^|[._-])$escapedFolderName([._-]|$)") {
|
|
$blendFileMappings += [PSCustomObject]@{
|
|
BlendFile = [System.IO.Path]::GetFullPath($blendFile.FullName)
|
|
BlendfileFolder = $folderName
|
|
}
|
|
Write-Host "Found matching blend file: $($blendFile.Name) -> $folderName" -ForegroundColor Gray
|
|
break # Only match once per blend file
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
# Create move log object
|
|
$moveLogData = [PSCustomObject]@{
|
|
TextureFolderPath = $textureFolderPath
|
|
Timestamp = (Get-Date -Format "yyyy-MM-ddTHH:mm:ssZ")
|
|
TotalMoves = ($allMoves | Where-Object { $_.Type -eq "moved" }).Count
|
|
TotalDeletes = ($allMoves | Where-Object { $_.Type -eq "deleted" }).Count
|
|
Moves = $allMoves
|
|
BlendFileMappings = $blendFileMappings
|
|
}
|
|
|
|
# Save to JSON file
|
|
$moveLogPath = Join-Path -Path $blendFileParentDir -ChildPath "texture_moves.json"
|
|
try {
|
|
$moveLogData | ConvertTo-Json -Depth 10 | Set-Content -Path $moveLogPath -Encoding UTF8
|
|
Write-Host "Move log saved to: $moveLogPath" -ForegroundColor Green
|
|
Write-Host " Total moves: $($moveLogData.TotalMoves), Total deletes: $($moveLogData.TotalDeletes)" -ForegroundColor Gray
|
|
Write-Host " Blend files found: $($blendFileMappings.Count)" -ForegroundColor Gray
|
|
} catch {
|
|
Write-Warning "Failed to save move log: $($_.Exception.Message)"
|
|
}
|
|
|
|
# ============================================================================
|
|
# Remap Texture Paths in Blend Files
|
|
# ============================================================================
|
|
if ($blendFileMappings.Count -gt 0 -and (Test-Path -Path $moveLogPath)) {
|
|
Write-Host ""
|
|
Write-Host "Remapping texture paths in blend files..." -ForegroundColor Yellow
|
|
|
|
# Find Blender executable from PATH
|
|
$blenderExe = $null
|
|
$blenderInPath = Get-Command blender -ErrorAction SilentlyContinue
|
|
if ($null -ne $blenderInPath) {
|
|
$blenderExe = $blenderInPath.Source
|
|
}
|
|
|
|
if ($null -eq $blenderExe) {
|
|
Write-Warning "Blender executable not found. Skipping texture path remapping."
|
|
Write-Host " Please install Blender or add it to your PATH." -ForegroundColor Yellow
|
|
} else {
|
|
Write-Host "Found Blender: $blenderExe" -ForegroundColor Gray
|
|
|
|
# Get the remap script path (should be in the same directory as this script)
|
|
$scriptDir = Split-Path -Path $MyInvocation.MyCommand.Path -Parent
|
|
$remapScriptPath = Join-Path -Path $scriptDir -ChildPath "remap_texture_paths.py"
|
|
|
|
if (-not (Test-Path -Path $remapScriptPath)) {
|
|
Write-Warning "Remap script not found: $remapScriptPath"
|
|
Write-Warning "Skipping texture path remapping."
|
|
} else {
|
|
$processedCount = 0
|
|
$failedCount = 0
|
|
|
|
Write-Host "Processing $($blendFileMappings.Count) blend file(s)..." -ForegroundColor Gray
|
|
|
|
foreach ($mapping in $blendFileMappings) {
|
|
$blendFilePath = $mapping.BlendFile
|
|
$blendFileName = Split-Path -Path $blendFilePath -Leaf
|
|
|
|
Write-Host " Processing: $blendFileName" -ForegroundColor Cyan
|
|
|
|
# Check if blend file exists
|
|
if (-not (Test-Path -Path $blendFilePath)) {
|
|
Write-Warning " Blend file not found: $blendFilePath"
|
|
$failedCount++
|
|
continue
|
|
}
|
|
|
|
# Run Blender with the remapping script (one file at a time)
|
|
# Delete old output file
|
|
Remove-Item -Path "blender_output.txt" -ErrorAction SilentlyContinue
|
|
|
|
try {
|
|
# Run Blender and capture output while displaying it (like compress_blend_files.bat)
|
|
# Build command with proper argument array
|
|
$blenderArgsArray = @(
|
|
"--background",
|
|
"--factory-startup",
|
|
"--python", $remapScriptPath,
|
|
"--",
|
|
$blendFilePath,
|
|
$moveLogPath
|
|
)
|
|
|
|
# Execute and pipe output through Tee-Object to display and save
|
|
& $blenderExe $blenderArgsArray 2>&1 | Tee-Object -FilePath "blender_output.txt" | ForEach-Object {
|
|
Write-Host " $_"
|
|
}
|
|
|
|
# Check exit code
|
|
$exitCode = $LASTEXITCODE
|
|
|
|
if ($exitCode -eq 0) {
|
|
Write-Host " Successfully remapped texture paths" -ForegroundColor Green
|
|
$processedCount++
|
|
} else {
|
|
Write-Warning " Failed to remap texture paths (exit code: $exitCode)"
|
|
$failedCount++
|
|
}
|
|
} catch {
|
|
Write-Warning " Exception while processing blend file: $($_.Exception.Message)"
|
|
$failedCount++
|
|
}
|
|
}
|
|
|
|
# Clean up temporary output files
|
|
Remove-Item -Path "blender_output.txt" -ErrorAction SilentlyContinue
|
|
Remove-Item -Path "blender_error.txt" -ErrorAction SilentlyContinue
|
|
|
|
Write-Host ""
|
|
if ($processedCount -gt 0 -or $failedCount -gt 0) {
|
|
Write-Host "Blend file remapping complete: $processedCount succeeded, $failedCount failed" -ForegroundColor $(if ($failedCount -eq 0) { "Green" } else { "Yellow" })
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
if ($blendFileMappings.Count -eq 0) {
|
|
Write-Host ""
|
|
Write-Host "No matching blend files found. Skipping texture path remapping." -ForegroundColor Gray
|
|
}
|
|
}
|
|
|
|
# Function to remove empty folders recursively
|
|
function Remove-EmptyFolders {
|
|
param(
|
|
[string]$Path,
|
|
[string]$RootPath
|
|
)
|
|
|
|
$removedCount = 0
|
|
|
|
# Get all subdirectories
|
|
$subdirs = Get-ChildItem -Path $Path -Directory -ErrorAction SilentlyContinue
|
|
|
|
if ($null -ne $subdirs) {
|
|
foreach ($subdir in $subdirs) {
|
|
# Recursively process subdirectories first
|
|
$removedCount += Remove-EmptyFolders -Path $subdir.FullName -RootPath $RootPath
|
|
|
|
# Check if this directory is now empty (after processing subdirectories)
|
|
$items = Get-ChildItem -Path $subdir.FullName -ErrorAction SilentlyContinue
|
|
if ($null -eq $items -or $items.Count -eq 0) {
|
|
# Don't remove the root path
|
|
if ($subdir.FullName -ne $RootPath) {
|
|
try {
|
|
Remove-Item -Path $subdir.FullName -Force -ErrorAction Stop
|
|
$removedCount++
|
|
} catch {
|
|
Write-Warning "Failed to remove empty folder: $($subdir.FullName) - $($_.Exception.Message)"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return $removedCount
|
|
}
|
|
|
|
# Remove empty folders
|
|
Write-Host ""
|
|
Write-Host "Removing empty folders..." -ForegroundColor Yellow
|
|
$emptyFoldersRemoved = Remove-EmptyFolders -Path $textureFolderPath -RootPath $textureFolderPath
|
|
if ($emptyFoldersRemoved -gt 0) {
|
|
Write-Host "Removed $emptyFoldersRemoved empty folder(s)" -ForegroundColor Green
|
|
} else {
|
|
Write-Host "No empty folders found to remove." -ForegroundColor Gray
|
|
}
|
|
|
|
Write-Host ""
|
|
Write-Host "File organization complete!" -ForegroundColor Green
|