mirror of
https://github.com/LucasDower/ObjToSchematic.git
synced 2024-12-03 02:39:59 +08:00
425 lines
16 KiB
TypeScript
425 lines
16 KiB
TypeScript
import AdmZip from 'adm-zip';
|
|
import chalk from 'chalk';
|
|
import fs from 'fs';
|
|
import path from 'path';
|
|
import { PNG } from 'pngjs';
|
|
import prompt from 'prompt';
|
|
import * as sharp from 'sharp';
|
|
const copydir = require('copy-dir');
|
|
|
|
import { RGBA } from '../src/colour';
|
|
import { UV } from '../src/util';
|
|
import { AppPaths, PathUtil } from '../src/util/path_util';
|
|
import { log, LogStyle } from './logging';
|
|
import { ASSERT, getAverageColour, getMinecraftDir, getPermission, isDirSetup } from './misc';
|
|
|
|
const BLOCKS_DIR = PathUtil.join(AppPaths.Get.tools, '/blocks');
|
|
const MODELS_DIR = PathUtil.join(AppPaths.Get.tools, '/models');
|
|
|
|
void async function main() {
|
|
AppPaths.Get.setBaseDir(PathUtil.join(__dirname, '../..'));
|
|
|
|
await getPermission();
|
|
checkMinecraftInstallation();
|
|
cleanupDirectories();
|
|
await fetchModelsAndTextures();
|
|
await buildAtlas();
|
|
cleanupDirectories();
|
|
}();
|
|
|
|
function checkMinecraftInstallation() {
|
|
const dir = getMinecraftDir();
|
|
if (!fs.existsSync(dir)) {
|
|
log(LogStyle.Failure, `Could not find ${dir}`);
|
|
log(LogStyle.Failure, 'To use this tool you need to install Minecraft Java Edition');
|
|
process.exit(1);
|
|
} else {
|
|
log(LogStyle.Success, `Found Minecraft Java Edition installation at ${dir}`);
|
|
}
|
|
}
|
|
|
|
function cleanupDirectories() {
|
|
fs.rmSync(BLOCKS_DIR, { recursive: true, force: true });
|
|
fs.rmSync(MODELS_DIR, { recursive: true, force: true });
|
|
}
|
|
|
|
async function getResourcePack() {
|
|
const resourcePacksDir = path.join(getMinecraftDir(), './resourcepacks');
|
|
if (!fs.existsSync(resourcePacksDir)) {
|
|
log(LogStyle.Failure, 'Could not find .minecraft/resourcepacks\n');
|
|
process.exit(1);
|
|
}
|
|
|
|
log(LogStyle.Info, 'Looking for resource packs...');
|
|
const resourcePacks = fs.readdirSync(resourcePacksDir);
|
|
log(LogStyle.None, `1) Vanilla`);
|
|
for (let i = 0; i < resourcePacks.length; ++i) {
|
|
log(LogStyle.None, `${i + 2}) ${resourcePacks[i]}`);
|
|
}
|
|
|
|
const { packChoice } = await prompt.get({
|
|
properties: {
|
|
packChoice: {
|
|
description: `Which resource pack do you want to build an atlas for? (1-${resourcePacks.length + 1})`,
|
|
message: `Response must be between 1 and ${resourcePacks.length + 1}`,
|
|
required: true,
|
|
conform: (value) => {
|
|
return value >= 1 && value <= resourcePacks.length + 1;
|
|
},
|
|
},
|
|
},
|
|
});
|
|
if (<number>packChoice == 1) {
|
|
return 'Vanilla';
|
|
}
|
|
return resourcePacks[(<number>packChoice) - 2];
|
|
}
|
|
|
|
function fetchVanillModelsAndTextures(fetchTextures: boolean) {
|
|
const versionsDir = path.join(getMinecraftDir(), './versions');
|
|
ASSERT(fs.existsSync(versionsDir), 'Could not find .minecraft/versions');
|
|
log(LogStyle.Info, '.minecraft/versions found successfully');
|
|
|
|
const versions = fs.readdirSync(versionsDir)
|
|
.filter((file) => fs.lstatSync(path.join(versionsDir, file)).isDirectory())
|
|
.map((file) => ({ file, birthtime: fs.lstatSync(path.join(versionsDir, file)).birthtime }))
|
|
.sort((a, b) => b.birthtime.getTime() - a.birthtime.getTime());
|
|
|
|
for (let i = 0; i < versions.length; ++i) {
|
|
const versionName = versions[i].file;
|
|
log(LogStyle.Info, `Searching in ${versionName} for ${versionName}.jar`);
|
|
|
|
const versionDir = path.join(versionsDir, versionName);
|
|
const versionFiles = fs.readdirSync(versionDir);
|
|
if (!versionFiles.includes(versionName + '.jar')) {
|
|
continue;
|
|
}
|
|
log(LogStyle.Success, `Found ${versionName}.jar successfully\n`);
|
|
|
|
const versionJarPath = path.join(versionDir, `${versionName}.jar`);
|
|
|
|
log(LogStyle.Info, `Upzipping ${versionName}.jar...`);
|
|
const zip = new AdmZip(versionJarPath);
|
|
const zipEntries = zip.getEntries();
|
|
zipEntries.forEach((zipEntry: any) => {
|
|
if (fetchTextures && zipEntry.entryName.startsWith('assets/minecraft/textures/block')) {
|
|
zip.extractEntryTo(zipEntry.entryName, BLOCKS_DIR, false, true);
|
|
} else if (zipEntry.entryName.startsWith('assets/minecraft/models/block')) {
|
|
zip.extractEntryTo(zipEntry.entryName, MODELS_DIR, false, true);
|
|
}
|
|
});
|
|
log(LogStyle.Success, `Extracted textures and models successfully\n`);
|
|
return;
|
|
}
|
|
}
|
|
|
|
async function fetchModelsAndTextures() {
|
|
const resourcePack = await getResourcePack();
|
|
await fetchVanillModelsAndTextures(true);
|
|
if (resourcePack === 'Vanilla') {
|
|
return;
|
|
}
|
|
|
|
log(LogStyle.Warning, 'Non-16x16 texture packs are not supported');
|
|
|
|
const resourcePackDir = path.join(getMinecraftDir(), './resourcepacks', resourcePack);
|
|
if (fs.lstatSync(resourcePackDir).isDirectory()) {
|
|
log(LogStyle.Info, `Resource pack '${resourcePack}' is a directory`);
|
|
const blockTexturesSrc = path.join(resourcePackDir, 'assets/minecraft/textures/block');
|
|
const blockTexturesDst = BLOCKS_DIR;
|
|
log(LogStyle.Info, `Copying ${blockTexturesSrc} to ${blockTexturesDst}`);
|
|
copydir(blockTexturesSrc, blockTexturesDst, {
|
|
utimes: true,
|
|
mode: true,
|
|
cover: true,
|
|
});
|
|
log(LogStyle.Success, `Copied block textures successfully`);
|
|
} else {
|
|
log(LogStyle.Info, `Resource pack '${resourcePack}' is not a directory, expecting to be a .zip`);
|
|
|
|
const zip = new AdmZip(resourcePackDir);
|
|
const zipEntries = zip.getEntries();
|
|
zipEntries.forEach((zipEntry: any) => {
|
|
if (zipEntry.entryName.startsWith('assets/minecraft/textures/block')) {
|
|
zip.extractEntryTo(zipEntry.entryName, BLOCKS_DIR, false, true);
|
|
}
|
|
});
|
|
log(LogStyle.Success, `Copied block textures successfully`);
|
|
return;
|
|
}
|
|
}
|
|
|
|
async function buildAtlas() {
|
|
// Check /blocks and /models is setup correctly
|
|
log(LogStyle.Info, 'Checking assets are provided...');
|
|
|
|
const texturesDirSetup = isDirSetup('./blocks', 'assets/minecraft/textures/block');
|
|
ASSERT(texturesDirSetup, '/blocks is not setup correctly');
|
|
log(LogStyle.Success, '/tools/blocks/ setup correctly');
|
|
|
|
const modelsDirSetup = isDirSetup('./models', 'assets/minecraft/models/block');
|
|
ASSERT(modelsDirSetup, '/models is not setup correctly');
|
|
log(LogStyle.Success, '/tools/models/ setup correctly');
|
|
|
|
// Load the ignore list
|
|
log(LogStyle.Info, 'Loading ignore list...');
|
|
let ignoreList: Array<string> = [];
|
|
const ignoreListPath = path.join(AppPaths.Get.tools, './ignore-list.txt');
|
|
if (fs.existsSync(ignoreListPath)) {
|
|
log(LogStyle.Success, 'Found ignore list');
|
|
ignoreList = fs.readFileSync(ignoreListPath, 'utf-8').replace(/\r/g, '').split('\n');
|
|
} else {
|
|
log(LogStyle.Warning, 'No ignore list found, looked for ignore-list.txt');
|
|
}
|
|
log(LogStyle.Success, `${ignoreList.length} blocks found in ignore list\n`);
|
|
|
|
/* eslint-disable */
|
|
enum parentModel {
|
|
Cube = 'minecraft:block/cube',
|
|
CubeAll = 'minecraft:block/cube_all',
|
|
CubeColumn = 'minecraft:block/cube_column',
|
|
CubeColumnHorizontal = 'minecraft:block/cube_column_horizontal',
|
|
CubeBottomTop = 'minecraft:block/cube_bottom_top',
|
|
TemplateSingleFace = 'minecraft:block/template_single_face',
|
|
TemplateGlazedTerracotta = 'minecraft:block/template_glazed_terracotta',
|
|
Leaves = 'minecraft:block/leaves',
|
|
}
|
|
/* eslint-enable */
|
|
|
|
interface Model {
|
|
name: string,
|
|
colour?: RGBA,
|
|
faces: {
|
|
[face: string]: Texture
|
|
}
|
|
}
|
|
|
|
interface Texture {
|
|
name: string,
|
|
texcoord?: UV,
|
|
colour?: RGBA
|
|
}
|
|
|
|
log(LogStyle.Info, 'Loading block models...');
|
|
const faces = ['north', 'south', 'up', 'down', 'east', 'west'];
|
|
const allModels: Array<Model> = [];
|
|
const allBlockNames: Set<string> = new Set();
|
|
const usedTextures: Set<string> = new Set();
|
|
fs.readdirSync(MODELS_DIR).forEach((filename) => {
|
|
if (path.extname(filename) !== '.json') {
|
|
return;
|
|
};
|
|
|
|
const filePath = path.join(MODELS_DIR, filename);
|
|
const fileData = fs.readFileSync(filePath, 'utf8');
|
|
const modelData = JSON.parse(fileData);
|
|
const parsedPath = path.parse(filePath);
|
|
const modelName = parsedPath.name;
|
|
|
|
if (ignoreList.includes(filename)) {
|
|
return;
|
|
}
|
|
|
|
let faceData: { [face: string]: Texture } = {};
|
|
switch (modelData.parent) {
|
|
case parentModel.CubeAll:
|
|
faceData = {
|
|
up: { name: modelData.textures.all },
|
|
down: { name: modelData.textures.all },
|
|
north: { name: modelData.textures.all },
|
|
south: { name: modelData.textures.all },
|
|
east: { name: modelData.textures.all },
|
|
west: { name: modelData.textures.all },
|
|
};
|
|
break;
|
|
case parentModel.CubeColumn:
|
|
faceData = {
|
|
up: { name: modelData.textures.end },
|
|
down: { name: modelData.textures.end },
|
|
north: { name: modelData.textures.side },
|
|
south: { name: modelData.textures.side },
|
|
east: { name: modelData.textures.side },
|
|
west: { name: modelData.textures.side },
|
|
};
|
|
break;
|
|
case parentModel.CubeBottomTop:
|
|
faceData = {
|
|
up: { name: modelData.textures.top },
|
|
down: { name: modelData.textures.bottom },
|
|
north: { name: modelData.textures.side },
|
|
south: { name: modelData.textures.side },
|
|
east: { name: modelData.textures.side },
|
|
west: { name: modelData.textures.side },
|
|
};
|
|
break;
|
|
case parentModel.Cube:
|
|
faceData = {
|
|
up: { name: modelData.textures.up },
|
|
down: { name: modelData.textures.down },
|
|
north: { name: modelData.textures.north },
|
|
south: { name: modelData.textures.south },
|
|
east: { name: modelData.textures.east },
|
|
west: { name: modelData.textures.west },
|
|
};
|
|
break;
|
|
case parentModel.TemplateSingleFace:
|
|
faceData = {
|
|
up: { name: modelData.textures.texture },
|
|
down: { name: modelData.textures.texture },
|
|
north: { name: modelData.textures.texture },
|
|
south: { name: modelData.textures.texture },
|
|
east: { name: modelData.textures.texture },
|
|
west: { name: modelData.textures.texture },
|
|
};
|
|
break;
|
|
case parentModel.TemplateGlazedTerracotta:
|
|
faceData = {
|
|
up: { name: modelData.textures.pattern },
|
|
down: { name: modelData.textures.pattern },
|
|
north: { name: modelData.textures.pattern },
|
|
south: { name: modelData.textures.pattern },
|
|
east: { name: modelData.textures.pattern },
|
|
west: { name: modelData.textures.pattern },
|
|
};
|
|
break;
|
|
case parentModel.Leaves:
|
|
faceData = {
|
|
up: { name: modelData.textures.all },
|
|
down: { name: modelData.textures.all },
|
|
north: { name: modelData.textures.all },
|
|
south: { name: modelData.textures.all },
|
|
east: { name: modelData.textures.all },
|
|
west: { name: modelData.textures.all },
|
|
};
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
|
|
for (const face of faces) {
|
|
usedTextures.add(faceData[face].name);
|
|
}
|
|
|
|
allModels.push({
|
|
name: modelName,
|
|
faces: faceData,
|
|
});
|
|
allBlockNames.add(modelName);
|
|
});
|
|
if (allModels.length === 0) {
|
|
log(LogStyle.Failure, 'No blocks loaded');
|
|
process.exit(0);
|
|
}
|
|
log(LogStyle.Success, `${allModels.length} blocks loaded\n`);
|
|
|
|
const atlasSize = Math.ceil(Math.sqrt(usedTextures.size));
|
|
const atlasWidthPixels = atlasSize * 16 * 3;
|
|
|
|
let offsetX = 0;
|
|
let offsetY = 0;
|
|
|
|
const textureDetails: { [textureName: string]: { texcoord: UV, colour: RGBA } } = {};
|
|
|
|
const { atlasName } = await prompt.get({
|
|
properties: {
|
|
atlasName: {
|
|
pattern: /^[a-zA-Z\-]+$/,
|
|
description: 'What do you want to call this texture atlas?',
|
|
message: 'Name must only be letters or dash',
|
|
required: true,
|
|
},
|
|
},
|
|
});
|
|
|
|
//const tiles: mergeImages.ImageSource[] = [];
|
|
let outputImage = sharp.default({
|
|
create: {
|
|
width: atlasWidthPixels,
|
|
height: atlasWidthPixels,
|
|
channels: 4,
|
|
background: { r: 255, g: 255, b: 255, alpha: 0.0 },
|
|
},
|
|
});
|
|
|
|
const composites: sharp.OverlayOptions[] = [];
|
|
|
|
log(LogStyle.Info, `Building ${atlasName}.png...`);
|
|
usedTextures.forEach((textureName) => {
|
|
const shortName = textureName.split('/')[1]; // Eww
|
|
const absolutePath = path.join(BLOCKS_DIR, shortName + '.png');
|
|
|
|
for (let x = 0; x < 3; ++x) {
|
|
for (let y = 0; y < 3; ++y) {
|
|
composites.push({
|
|
input: absolutePath,
|
|
left: 16 * (3 * offsetX + x),
|
|
top: 16 * (3 * offsetY + y),
|
|
});
|
|
}
|
|
}
|
|
|
|
const fileData = fs.readFileSync(absolutePath);
|
|
const pngData = PNG.sync.read(fileData);
|
|
|
|
textureDetails[textureName] = {
|
|
texcoord: new UV(
|
|
16 * (3 * offsetX + 1) / atlasWidthPixels,
|
|
16 * (3 * offsetY + 1) / atlasWidthPixels,
|
|
),
|
|
colour: getAverageColour(pngData),
|
|
};
|
|
|
|
++offsetX;
|
|
if (offsetX >= atlasSize) {
|
|
++offsetY;
|
|
offsetX = 0;
|
|
}
|
|
});
|
|
|
|
outputImage = outputImage.composite(composites);
|
|
|
|
|
|
// Build up the output JSON
|
|
log(LogStyle.Info, `Building ${atlasName}.atlas...\n`);
|
|
for (const model of allModels) {
|
|
const blockColour: RGBA = {
|
|
r: 0.0, g: 0.0, b: 0.0, a: 0.0,
|
|
};
|
|
for (const face of faces) {
|
|
const faceTexture = textureDetails[model.faces[face].name];
|
|
const faceColour = faceTexture.colour;
|
|
blockColour.r += faceColour.r;
|
|
blockColour.g += faceColour.g;
|
|
blockColour.b += faceColour.b;
|
|
blockColour.a += faceColour.a;
|
|
model.faces[face].texcoord = faceTexture.texcoord;
|
|
model.faces[face].colour = faceTexture.colour;
|
|
}
|
|
blockColour.r /= 6;
|
|
blockColour.g /= 6;
|
|
blockColour.b /= 6;
|
|
blockColour.a /= 6;
|
|
model.colour = blockColour;
|
|
}
|
|
|
|
|
|
log(LogStyle.Info, 'Exporting...');
|
|
const atlasTextureDir = path.join(AppPaths.Get.atlases, `./${atlasName}.png`);
|
|
await outputImage.toFile(atlasTextureDir);
|
|
//ASSERT(success, 'Unsuccess save');
|
|
|
|
log(LogStyle.Success, `${atlasName}.png exported to /resources/atlases/`);
|
|
const outputJSON = {
|
|
version: 2,
|
|
atlasSize: atlasSize,
|
|
blocks: allModels,
|
|
supportedBlockNames: Array.from(allBlockNames),
|
|
};
|
|
fs.writeFileSync(path.join(AppPaths.Get.atlases, `./${atlasName}.atlas`), JSON.stringify(outputJSON, null, 4));
|
|
log(LogStyle.Success, `${atlasName}.atlas exported to /resources/atlases/\n`);
|
|
|
|
/* eslint-disable */
|
|
console.log(chalk.cyanBright(chalk.inverse('DONE') + ' Now run ' + chalk.inverse(' npm start ') + ' and the new texture atlas can be used'));
|
|
/* eslint-enable */
|
|
}
|