144 lines
3.9 KiB
Go
144 lines
3.9 KiB
Go
package blender
|
|
|
|
import (
|
|
"compress/gzip"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"os/exec"
|
|
)
|
|
|
|
// ParseVersionFromFile parses the Blender version that a .blend file was saved with.
|
|
// Returns major and minor version numbers.
|
|
func ParseVersionFromFile(blendPath string) (major, minor int, err error) {
|
|
file, err := os.Open(blendPath)
|
|
if err != nil {
|
|
return 0, 0, fmt.Errorf("failed to open blend file: %w", err)
|
|
}
|
|
defer file.Close()
|
|
|
|
// Read the first 12 bytes of the blend file header
|
|
// Format: BLENDER-v<major><minor><patch> or BLENDER_v<major><minor><patch>
|
|
// The header is: "BLENDER" (7 bytes) + pointer size (1 byte: '-' for 64-bit, '_' for 32-bit)
|
|
// + endianness (1 byte: 'v' for little-endian, 'V' for big-endian)
|
|
// + version (3 bytes: e.g., "402" for 4.02)
|
|
header := make([]byte, 12)
|
|
n, err := file.Read(header)
|
|
if err != nil || n < 12 {
|
|
return 0, 0, fmt.Errorf("failed to read blend file header: %w", err)
|
|
}
|
|
|
|
// Check for BLENDER magic
|
|
if string(header[:7]) != "BLENDER" {
|
|
// Might be compressed - try to decompress
|
|
file.Seek(0, 0)
|
|
return parseCompressedVersion(file)
|
|
}
|
|
|
|
// Parse version from bytes 9-11 (3 digits)
|
|
versionStr := string(header[9:12])
|
|
|
|
// Version format changed in Blender 3.0
|
|
// Pre-3.0: "279" = 2.79, "280" = 2.80
|
|
// 3.0+: "300" = 3.0, "402" = 4.02, "410" = 4.10
|
|
if len(versionStr) == 3 {
|
|
// First digit is major version
|
|
fmt.Sscanf(string(versionStr[0]), "%d", &major)
|
|
// Next two digits are minor version
|
|
fmt.Sscanf(versionStr[1:3], "%d", &minor)
|
|
}
|
|
|
|
return major, minor, nil
|
|
}
|
|
|
|
// parseCompressedVersion handles gzip and zstd compressed blend files.
|
|
func parseCompressedVersion(file *os.File) (major, minor int, err error) {
|
|
magic := make([]byte, 4)
|
|
if _, err := file.Read(magic); err != nil {
|
|
return 0, 0, err
|
|
}
|
|
file.Seek(0, 0)
|
|
|
|
if magic[0] == 0x1f && magic[1] == 0x8b {
|
|
// gzip compressed
|
|
gzReader, err := gzip.NewReader(file)
|
|
if err != nil {
|
|
return 0, 0, fmt.Errorf("failed to create gzip reader: %w", err)
|
|
}
|
|
defer gzReader.Close()
|
|
|
|
header := make([]byte, 12)
|
|
n, err := gzReader.Read(header)
|
|
if err != nil || n < 12 {
|
|
return 0, 0, fmt.Errorf("failed to read compressed blend header: %w", err)
|
|
}
|
|
|
|
if string(header[:7]) != "BLENDER" {
|
|
return 0, 0, fmt.Errorf("invalid blend file format")
|
|
}
|
|
|
|
versionStr := string(header[9:12])
|
|
if len(versionStr) == 3 {
|
|
fmt.Sscanf(string(versionStr[0]), "%d", &major)
|
|
fmt.Sscanf(versionStr[1:3], "%d", &minor)
|
|
}
|
|
|
|
return major, minor, nil
|
|
}
|
|
|
|
// Check for zstd magic (Blender 3.0+): 0x28 0xB5 0x2F 0xFD
|
|
if magic[0] == 0x28 && magic[1] == 0xb5 && magic[2] == 0x2f && magic[3] == 0xfd {
|
|
return parseZstdVersion(file)
|
|
}
|
|
|
|
return 0, 0, fmt.Errorf("unknown blend file format")
|
|
}
|
|
|
|
// parseZstdVersion handles zstd-compressed blend files (Blender 3.0+).
|
|
// Uses zstd command line tool since Go doesn't have native zstd support.
|
|
func parseZstdVersion(file *os.File) (major, minor int, err error) {
|
|
file.Seek(0, 0)
|
|
|
|
cmd := exec.Command("zstd", "-d", "-c")
|
|
cmd.Stdin = file
|
|
|
|
stdout, err := cmd.StdoutPipe()
|
|
if err != nil {
|
|
return 0, 0, fmt.Errorf("failed to create zstd stdout pipe: %w", err)
|
|
}
|
|
|
|
if err := cmd.Start(); err != nil {
|
|
return 0, 0, fmt.Errorf("failed to start zstd decompression: %w", err)
|
|
}
|
|
|
|
// Read just the header (12 bytes)
|
|
header := make([]byte, 12)
|
|
n, readErr := io.ReadFull(stdout, header)
|
|
|
|
// Kill the process early - we only need the header
|
|
cmd.Process.Kill()
|
|
cmd.Wait()
|
|
|
|
if readErr != nil || n < 12 {
|
|
return 0, 0, fmt.Errorf("failed to read zstd compressed blend header: %v", readErr)
|
|
}
|
|
|
|
if string(header[:7]) != "BLENDER" {
|
|
return 0, 0, fmt.Errorf("invalid blend file format in zstd archive")
|
|
}
|
|
|
|
versionStr := string(header[9:12])
|
|
if len(versionStr) == 3 {
|
|
fmt.Sscanf(string(versionStr[0]), "%d", &major)
|
|
fmt.Sscanf(versionStr[1:3], "%d", &minor)
|
|
}
|
|
|
|
return major, minor, nil
|
|
}
|
|
|
|
// VersionString returns a formatted version string like "4.2".
|
|
func VersionString(major, minor int) string {
|
|
return fmt.Sprintf("%d.%d", major, minor)
|
|
}
|
|
|