YourWishes/Dawn
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

About to refactor all the tools to python.

Browse Source
This commit is contained in:
Dominic Masters
2023-10-22 00:59:04 -05:00
parent a511c5c908
commit 702e320f63
20 changed files with 366 additions and 334 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.gitmodules vendored
View File

@ -21,4 +21,4 @@
url = https://gitlab.freedesktop.org/freetype/freetype.git
[submodule "lib/libarchive"]
path = lib/libarchive
url = https://github.com/libarchive/libarchive
url = https://github.com/libarchive/libarchive

3
assets/games/liminal/scenes/prologue/CMakeLists.txt
View File

@ -11,4 +11,5 @@ tool_vnscene(${CMAKE_CURRENT_LIST_DIR}/ScenePrologue4.xml)
tool_vnscene(${CMAKE_CURRENT_LIST_DIR}/ScenePrologue5.xml)
tool_vnscene(${CMAKE_CURRENT_LIST_DIR}/ScenePrologueSportsField.xml)
tool_vnscene(${CMAKE_CURRENT_LIST_DIR}/ScenePrologueToilets.xml)
tool_vnscene(${CMAKE_CURRENT_LIST_DIR}/ScenePrologue7.xml)
tool_vnscene(${CMAKE_CURRENT_LIST_DIR}/ScenePrologue7.xml)
tool_vnscene(${CMAKE_CURRENT_LIST_DIR}/ScenePrologue9.xml)

10
assets/games/liminal/scenes/prologue/ScenePrologue9.xml Normal file
View File

@ -0,0 +1,10 @@
<vnscene name="ScenePrologue9" extend="scenes/SceneMonologue">
<events>
<set-font font="font_main" style="italics" size="32" />
<!-- May 29th Prom Day. -->
<text>
<string lang="en"><font style="italics">There is a bucket.</font></string>
</text>
</events>
</vnscene>

13
cmake/targets/target-liminal-emscripten/CMakeLists.txt Normal file
View File

@ -0,0 +1,13 @@
# Copyright (c) 2023 Dominic Masters
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
set(DAWN_BUILDING dawnliminal CACHE INTERNAL ${DAWN_CACHE_TARGET})
set(DAWN_BUILD_HOST_LIBS "" CACHE INTERNAL ${DAWN_CACHE_TARGET})
set(DAWN_TARGET_EMSCRIPTEN true CACHE INTERNAL ${DAWN_CACHE_TARGET})
set(DAWN_TARGET_GLFW true CACHE INTERNAL ${DAWN_CACHE_TARGET})
set(DAWN_TARGET_NAME "Liminal" CACHE INTERNAL ${DAWN_CACHE_TARGET})
set(DAWN_VISUAL_NOVEL true CACHE INTERNAL ${DAWN_CACHE_TARGET})
set(DAWN_EMSCRIPTEN_FLAGS "" CACHE INTERNAL ${DAWN_CACHE_TARGET})

21
lib/CMakeLists.txt
View File

@ -5,8 +5,12 @@
# GLFW
if(DAWN_TARGET_GLFW)
add_subdirectory(glad)
add_subdirectory(glfw)
if(${CMAKE_SYSTEM_NAME} MATCHES "Emscripten")
set(DAWN_EMSCRIPTEN_FLAGS "${DAWN_EMSCRIPTEN_FLAGS} -s USE_GLFW=3" CACHE INTERNAL ${DAWN_CACHE_TARGET})
else()
add_subdirectory(glad)
add_subdirectory(glfw)
endif()
endif()
# SDL
@ -23,7 +27,11 @@ add_library(stb INTERFACE)
target_include_directories(stb INTERFACE stb)
# FreeType
add_subdirectory(freetype)
if(${CMAKE_SYSTEM_NAME} MATCHES "Emscripten")
set(DAWN_EMSCRIPTEN_FLAGS "${DAWN_EMSCRIPTEN_FLAGS} -s USE_FREETYPE=1" CACHE INTERNAL ${DAWN_CACHE_TARGET})
else()
add_subdirectory(freetype)
endif()
# LibArchive
add_subdirectory(libarchive)
@ -36,4 +44,11 @@ if(DAWN_TARGET_OPENAL)
set(BUILD_TESTS OFF CACHE BOOL "Build tests" FORCE)
set(BUILD_EXAMPLES OFF CACHE BOOL "Build examples" FORCE)
add_subdirectory(AudioFile)
endif()
# Test
if(DEFINED DAWN_EMSCRIPTEN_FLAGS)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${DAWN_EMSCRIPTEN_FLAGS}" CACHE INTERNAL ${DAWN_CACHE_TARGET})
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${DAWN_EMSCRIPTEN_FLAGS}" CACHE INTERNAL ${DAWN_CACHE_TARGET})
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${DAWN_EMSCRIPTEN_FLAGS}" CACHE INTERNAL ${DAWN_CACHE_TARGET})
endif()

2
src/CMakeLists.txt
View File

@ -37,6 +37,8 @@ if(DEFINED DAWN_TARGET_NAME)
add_subdirectory(dawnosx)
elseif(DAWN_TARGET_VITA)
add_subdirectory(dawnvita)
elseif(DAWN_TARGET_EMSCRIPTEN)
add_subdirectory(dawnemscripten)
else()
message(FATAL_ERROR "You need to define an entry target")
endif()

1
src/dawn/asset/assets/TextureAsset.cpp
View File

@ -37,7 +37,6 @@ void TextureAsset::updateSync() {
void TextureAsset::updateAsync() {
if(this->state != 0x00) return;
this->state = 0x01;
std::cout << "Update texture tool" << std::endl;
this->loader.open();
this->buffer = (uint8_t*)memoryAllocate(this->loader.getSize());
this->loader.read(this->buffer, this->loader.getSize());

22
src/dawnemscripten/CMakeLists.txt Normal file
View File

@ -0,0 +1,22 @@
# Copyright (c) 2022 Dominic Masters
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
# Includes
target_include_directories(${DAWN_TARGET_NAME}
PUBLIC
${CMAKE_CURRENT_LIST_DIR}
)
# Platform variables
target_compile_definitions(${DAWN_TARGET_NAME}
PUBLIC
DAWN_ASSET_LOCATION="../../assets.tar"
)
# Subdirs
add_subdirectory(host)
# Ensures a .HTML file is generated.
set(CMAKE_EXECUTABLE_SUFFIX ".html" CACHE INTERNAL ${DAWN_CACHE_TARGET})

10
src/dawnemscripten/host/CMakeLists.txt Normal file
View File

@ -0,0 +1,10 @@
# Copyright (c) 2023 Dominic Masters
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
# Sources
target_sources(${DAWN_TARGET_NAME}
PRIVATE
DawnEmscripten.cpp
)

11
src/dawnemscripten/host/DawnEmscripten.cpp Normal file
View File

@ -0,0 +1,11 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "host/DawnEmscripten.hpp"
int main() {
printf("Hello Emscripten\n");
return 0;
}

9
src/dawnemscripten/host/DawnEmscripten.hpp Normal file
View File

@ -0,0 +1,9 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include <stdio.h>
int main();

1
src/dawnliminal/CMakeLists.txt
View File

@ -15,6 +15,7 @@ target_include_directories(${DAWN_TARGET_NAME}
# Subdirs
add_subdirectory(game)
add_subdirectory(save)
add_subdirectory(vnscenes)
# Assets
include("${DAWN_ASSETS_SOURCE_DIR}/games/liminal/CMakeLists.txt")

10
src/dawnliminal/vnscenes/CMakeLists.txt Normal file
View File

@ -0,0 +1,10 @@
# Copyright (c) 2023 Dominic Masters
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
# Sources
target_sources(${DAWN_TARGET_NAME}
PRIVATE
ScenePrologue8.cpp
)

117
src/dawnliminal/vnscenes/ScenePrologue8.cpp Normal file
View File

@ -0,0 +1,117 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "ScenePrologue8.hpp"
using namespace Dawn;
void ScenePrologue8CustomEventForChoiceSet::onStart() {
auto scene = dynamic_cast<ScenePrologue8*>(this->manager->getScene());
assertNotNull(scene, "ScenePrologue8CustomEventForChoiceSet - Scene is null?");
this->choices = scene->remainingChoices;
this->key = "killer";
this->text = "It is...";
VNChoiceEvent::onStart();
}
void ScenePrologue8CustomEventForAfterChoice::onStart() {
auto prev = dynamic_cast<ScenePrologue8CustomEventForChoiceSet*>(this->previous);
assertNotNull(prev, "ScenePrologue8CustomEventForAfterChoice - Previous is null?");
auto scene = dynamic_cast<ScenePrologue8*>(this->manager->getScene());
assertNotNull(scene, "ScenePrologue8CustomEventForAfterChoice - Scene is null?");
auto key = prev->getChoiceKey();
scene->remainingChoices.erase(key);
this->next();
}
void ScenePrologue8CustomEventForAfterCharacterFollowup::onStart() {
auto scene = dynamic_cast<ScenePrologue8*>(this->manager->getScene());
assertNotNull(scene, "ScenePrologue8CustomEventForAfterChoice - Scene is null?");
if(scene->remainingChoices.empty()) {
auto sceneChange = this->manager->createEvent<VNSceneChangeEvent<ScenePrologue9>>();
this->then(sceneChange);
} else {
auto choiceSet = this->manager->createEvent<ScenePrologue8CustomEventForChoiceSet>();
this->then(choiceSet);
}
}
ScenePrologue8::ScenePrologue8(DawnGame *game) : SceneMonologue(game) {
}
std::vector<Asset*> ScenePrologue8::getRequiredAssets() {
auto man = &this->game->assetManager;
std::vector<Asset*> assets = SceneMonologue::getRequiredAssets();
return assets;
}
void ScenePrologue8::stage() {
SceneMonologue::stage();
remainingChoices["ave"] = "Ave?";
remainingChoices["ronin"] = "Ronin?";
remainingChoices["craig"] = "Craig?";
auto man = &this->game->assetManager;
assertNotNull(vnManager, "VNSceneGenInit - VN Manager is null?");
VNEvent *previous = vnManager->createEvent<VNDummyEvent>();
auto eventStart = previous;
auto event0 = vnManager->createEvent<VNSetDefaultFontEvent>();
event0->font = "<font font=\"font_main\" size=\"32.0f\">{{ text }}</font>";
auto eventChoice = vnManager->createEvent<ScenePrologue8CustomEventForChoiceSet>();
auto eventAfterChoice = vnManager->createEvent<ScenePrologue8CustomEventForAfterChoice>();
auto eventFollowUp = vnManager->createEvent<ScenePrologue8CustomEventForAfterCharacterFollowup>();
// Ave
auto eventIfAve = vnManager->createEvent<VNIfEvent>();
eventIfAve->key = "killer";
eventIfAve->value = "ave";
auto eventTestAve = vnManager->createEvent<VNTextEvent>();
eventTestAve->text = "Ave?";
eventIfAve->ifTrue = eventTestAve;
eventIfAve->ifEnd = eventTestAve;
// Craig
auto eventIfCraig = vnManager->createEvent<VNIfEvent>();
eventIfCraig->key = "killer";
eventIfCraig->value = "craig";
auto eventTestCraig = vnManager->createEvent<VNTextEvent>();
eventTestCraig->text = "Craig?";
eventIfCraig->ifTrue = eventTestCraig;
eventIfCraig->ifEnd = eventTestCraig;
// Ronin
auto eventIfRonin = vnManager->createEvent<VNIfEvent>();
eventIfRonin->key = "killer";
eventIfRonin->value = "ronin";
auto eventTestRonin = vnManager->createEvent<VNTextEvent>();
eventTestRonin->text = "Ronin?";
eventIfRonin->ifTrue = eventTestRonin;
eventIfRonin->ifEnd = eventTestRonin;
// End
eventStart->then(event0);
event0->then(eventChoice);
eventChoice->then(eventAfterChoice);
eventAfterChoice->then(eventIfAve);
eventIfAve->then(eventIfCraig);
eventIfCraig->then(eventIfRonin);
eventIfRonin->then(eventFollowUp);
vnManager->setEvent(eventStart);
}

71
src/dawnliminal/vnscenes/ScenePrologue8.hpp
View File

@ -1,5 +1,9 @@
#pragma once
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "scenes/SceneMonologue.hpp"
#include "games/vn/events/VNDummyEvent.hpp"
#include "games/vn/events/VNSetDefaultFontEvent.hpp"
@ -13,70 +17,27 @@
namespace Dawn {
class ScenePrologue8CustomEventForChoiceSet : public VNChoiceEvent {
protected:
void onStart() override {
auto scene = dynamic_cast<ScenePrologue8*>this->manager->getScene();
assertNotNull(scene, "ScenePrologue8CustomEventForChoiceSet - Scene is null?");
this->choices = scene->remainingChoices;
this->key = "killer";
this->text = "It is...";
VNChoiceSetEvent::onStart();
}
void onStart() override;
};
class ScenePrologue8CustomEventForAfterChoice : public VNEvent {
protected:
void onStart() override {
auto prev = dynamic_cast<ScenePrologue8CustomEventForChoiceSet*>(this->previous);
assertNotNull(prev, "ScenePrologue8CustomEventForAfterChoice - Previous is null?");
auto scene = dynamic_cast<ScenePrologue8*>this->manager->getScene();
assertNotNull(scene, "ScenePrologue8CustomEventForAfterChoice - Scene is null?");
auto key = prev->getChoiceKey();
scene->remainingChoices.erase(key);
this->next();
}
void onStart() override;
};
class ScenePrologue8CustomEventForAfterCharacterFollowup : public VNEvent {
protected:
void onStart() override;
};
class ScenePrologue8 : public SceneMonologue {
public:
std::map<std::string, std::string> remainingChoices;
ScenePrologue8(DawnGame *game) : SceneMonologue(game) {
}
ScenePrologue8(DawnGame *game);
std::vector<Asset*> getRequiredAssets() override {
auto man = &this->game->assetManager;
std::vector<Asset*> assets = SceneMonologue::getRequiredAssets();
return assets;
}
std::vector<Asset*> getRequiredAssets() override;
void stage() override {
SceneMonologue::stage();
remainingChoices["ave"] = "Ave?";
remainingChoices["ronin"] = "Ronin?";
remainingChoices["craig"] = "Craig?";
auto man = &this->game->assetManager;
assertNotNull(vnManager, "VNSceneGenInit - VN Manager is null?");
VNEvent *previous = vnManager->createEvent<VNDummyEvent>();
auto eventStart = previous;
auto event0 = vnManager->createEvent<VNSetDefaultFontEvent>();
event0->font = "<font font=\"font_main\" size=\"32.0f\">{{ text }}</font>";
auto event1 = vnManager->createEvent<ScenePrologue8CustomEventForChoiceSet>();
auto event2 = vnManager->createEvent<ScenePrologue8CustomEventForAfterChoice>();
auto sceneChange = vnManager->createEvent<VNSceneChangeEvent<ScenePrologue9>>();
eventStart->then(event0);
event0->then(event1);
event1->then(event2);
event2->then(sceneChange);
vnManager->setEvent(eventStart);
}
void stage() override;
};
}
}

8
src/dawnshared/util/memory.cpp
View File

@ -6,14 +6,6 @@
#include "memory.hpp"
#include "assert/assert.hpp"
void * operator new(size_t size) noexcept {
return memoryAllocate(size);
}
void operator delete (void *p) noexcept {
return memoryFree(p);
}
void * memoryAllocate(const size_t size) {
assertTrue(size >= 0, "memoryAllocate: size must be greater than 0 or equal to.");
void *x = (void *)memoryCallMalloc(size);

63
src/dawntools/texturetool/CMakeLists.txt
View File

@ -3,40 +3,6 @@
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
# Texture Build Tool
project(texturetool VERSION 1.0)
add_executable(texturetool)
target_sources(texturetool
PRIVATE
${DAWN_SHARED_SOURCES}
${DAWN_TOOL_SOURCES}
TextureTool.cpp
../util/Image.cpp
)
target_include_directories(texturetool
PUBLIC
${DAWN_SHARED_INCLUDES}
${DAWN_TOOL_INCLUDES}
${CMAKE_CURRENT_LIST_DIR}
)
# Definitions
target_compile_definitions(texturetool
PUBLIC
${DAWN_SHARED_DEFINITIONS}
DAWN_TOOL_INSTANCE=TextureTool
DAWN_TOOL_HEADER="TextureTool.hpp"
)
# Libraries
target_link_libraries(texturetool
PUBLIC
${DAWN_BUILD_HOST_LIBS}
stb
)
# Tool Function
function(tool_texture target)
# Defaults
@ -64,28 +30,21 @@ function(tool_texture target)
if(NOT DEFINED FILE)
message(FATAL_ERROR "Missing FILE input")
endif()
set(DEPS "")
if(DAWN_BUILD_TOOLS)
set(DEPS texturetool)
endif()
add_custom_target(${target}
COMMAND texturetool
COMMAND ${DAWN_TOOLS_DIR}/texturetool/texturetool.py
--input="${FILE}"
--output="${DAWN_ASSETS_BUILD_DIR}/${target}"
--wrapX="${WRAP_X}"
--wrapY="${WRAP_Y}"
--filterMin="${FILTER_MIN}"
--filterMag="${FILTER_MIN}"
--output="${DAWN_ASSETS_BUILD_DIR}/${target}.texture"
--wrap-x="${WRAP_X}"
--wrap-y="${WRAP_Y}"
--filter-min="${FILTER_MIN}"
--filter-mag="${FILTER_MIN}"
--scale="${SCALE}"
--cropStartX="${CROP_START_X}"
--cropStartY="${CROP_START_Y}"
--cropEndX="${CROP_END_X}"
--cropEndY="${CROP_END_Y}"
--preview="${DAWN_BUILD_DIR}/preview/${target}"
--crop-start-x="${CROP_START_X}"
--crop-start-y="${CROP_START_Y}"
--crop-end-x="${CROP_END_X}"
--crop-end-y="${CROP_END_Y}"
COMMENT "Generating texture ${target} from ${FILE}"
DEPENDS ${DEPS}
)
add_dependencies(dawnassets ${target})
endfunction()

193
src/dawntools/texturetool/TextureTool.cpp
View File

@ -1,193 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "TextureTool.hpp"
using namespace Dawn;
std::vector<std::string> TextureTool::getRequiredFlags() {
return std::vector<std::string>{ "input", "output" };
}
std::map<std::string, std::string> TextureTool::getOptionalFlags() {
return {
{ "wrapX", "clamp" },
{ "wrapY", "clamp" },
{ "filterMin", "linear" },
{ "filterMax", "linear" },
{ "scale", "" },
{ "scaleWrapX", "clamp" },
{ "scaleWrapY", "clamp" },
{ "scaleFilterX", "nearest" },
{ "scaleFilterY", "nearest" },
{ "cropStartX", "" },
{ "cropStartY", "" },
{ "cropEndX", "" },
{ "cropEndY", "" },
{ "preview", "" }
};
}
int32_t TextureTool::start() {
// Finished with XML data, now we can write data out.
File fileOut(flags["output"] + ".texture");
if(fileOut.exists()) return 0;
// Load input file
File in(flags["input"]);
if(!in.open(FILE_MODE_READ)) {
std::cout << "Failed to open input file " << in.filename << std::endl;
return 1;
}
int32_t originalWidth, originalHeight, channels;
auto bufferCurrent = stbi_load_from_file(
in.file,
&originalWidth,
&originalHeight,
&channels,
STBI_rgb_alpha
);
if(bufferCurrent == NULL) {
std::cout << "Failed to load input texture!" << std::endl;
return 1;
}
in.close();
// Create a temporary buffer to hold pixels.
size_t len = STBI_rgb_alpha * originalWidth * originalHeight;
uint8_t *bufferTemporary = (uint8_t*)malloc(sizeof(uint8_t) * len);
int32_t currentWidth = originalWidth;
int32_t currentHeight = originalHeight;
// Crop
int32_t cropStartX = 0;
int32_t cropStartY = 0;
int32_t cropEndX = 0;
int32_t cropEndY = 0;
if(!flags["cropStartX"].empty()) cropStartX = std::stoi(flags["cropStartX"]);
if(!flags["cropStartY"].empty()) cropStartY = std::stoi(flags["cropStartY"]);
if(!flags["cropEndX"].empty()) cropEndX = std::stoi(flags["cropEndX"]);
if(!flags["cropEndY"].empty()) cropEndY = std::stoi(flags["cropEndY"]);
if(cropStartX > 0 || cropStartY > 0 || cropEndX > 0 || cropEndY > 0) {
int32_t cropWidth = (cropEndX == 0 ? originalWidth : cropEndX) - cropStartX;
int32_t cropHeight = (cropEndY == 0 ? originalHeight : cropEndY) - cropStartY;
float_t s0, t0, s1, t1;
s0 = (float_t)cropStartX / (float_t)originalWidth;
t0 = (float_t)cropStartY / (float_t)originalHeight;
s1 = ((float_t)(cropEndX == 0 ? originalWidth : cropEndX) / (float_t)originalWidth);
t1 = ((float_t)(cropEndY == 0 ? originalHeight : cropEndY) / (float_t)originalHeight);
stbir_resize_region(
bufferCurrent, currentWidth, currentHeight, 0,
bufferTemporary, cropWidth, cropHeight, 0,
STBIR_TYPE_UINT8,
STBI_rgb_alpha, -1, 0,
STBIR_EDGE_CLAMP, STBIR_EDGE_CLAMP,
STBIR_FILTER_DEFAULT, STBIR_FILTER_DEFAULT,
STBIR_COLORSPACE_LINEAR, NULL,
s0, t0, s1, t1
);
memcpy(bufferCurrent, bufferTemporary, sizeof(uint8_t) * len);
currentWidth = cropWidth;
currentHeight = cropHeight;
}
// Scale
if(!flags["scale"].empty()) {
float_t scale = std::stof(flags["scale"]);
int32_t scaleWidth = currentWidth * scale;
int32_t scaleHeight = currentHeight * scale;
stbir_resize_uint8_generic(
bufferCurrent, currentWidth, currentHeight, 0,
bufferTemporary, scaleWidth, scaleHeight, 0,
STBI_rgb_alpha, -1, 0,
STBIR_EDGE_CLAMP, STBIR_FILTER_DEFAULT, STBIR_COLORSPACE_LINEAR,
NULL
);
memcpy(bufferCurrent, bufferTemporary, sizeof(uint8_t) * len);
currentWidth = scaleWidth;
currentHeight = scaleHeight;
}
// Wrapping Settings
std::function<int32_t(std::string)> wrapFromString = [&](std::string wr) {
if(wr == "repeat") return 0;
if(wr == "mirror") return 1;
if(wr == "clamp") return 2;
if(wr == "border") return 3;
return -1;
};
int32_t wrapX = wrapFromString(flags["wrapX"]);
if(wrapX == -1) {
std::cout << "Invalid wrapX value " << flags["wrapX"] << std::endl;
return 1;
}
int32_t wrapY = wrapFromString(flags["wrapY"]);
if(wrapY == -1) {
std::cout << "Invalid wrapY value " << flags["wrapY"] << std::endl;
return 1;
}
// Write info
char headerBuffer[256];
size_t headerBufferLength = sprintf((char *)headerBuffer, "DT_2.00|%i|%i|%i|%i|%i|%i|%i|",
currentWidth,
currentHeight,
4, // RGBA,
wrapX, // WRAPX
wrapY, // WRAPY
flags["filterMin"] == "nearest" ? 0 : 1,
flags["filterMag"] == "nearest" ? 0 : 1
);
// Open and create output
File out(flags["output"] + ".texture");
if(!out.mkdirp()) {
std::cout << "Failed to make output dir " << out.filename << std::endl;
return 1;
}
if(!out.open(FILE_MODE_WRITE)) {
std::cout << "Failed to open texture file for writing " << out.filename << std::endl;
return 1;
}
if(!out.writeRaw(headerBuffer, headerBufferLength)) {
std::cout << "Failed to write texture header for " << out.filename << std::endl;
return 1;
}
// Write preview
File preview(flags["preview"] + ".png");
if(!preview.mkdirp()) {
std::cout << "Failed to make preview dir " << preview.filename << std::endl;
return 1;
}
stbi_write_png(
preview.filename.c_str(),
currentWidth,
currentHeight,
STBI_rgb_alpha,
bufferCurrent,
0
);
// Write texture
if(!out.writeRaw((char*)bufferCurrent, sizeof(uint8_t) * len)) {
std::cout << "Failed to write texture data for " << out.filename << std::endl;
return 1;
}
free(bufferCurrent);
free(bufferTemporary);
return 0;
}

20
src/dawntools/texturetool/TextureTool.hpp
View File

@ -1,20 +0,0 @@
// Copyright (c) 2023 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "util/DawnTool.hpp"
#include "util/File.hpp"
#include "util/Image.hpp"
namespace Dawn {
class TextureTool : public DawnTool {
protected:
std::vector<std::string> getRequiredFlags() override;
std::map<std::string, std::string> getOptionalFlags() override;
public:
int32_t start();
};
}

113
src/dawntools/texturetool/texturetool.py Executable file
View File

@ -0,0 +1,113 @@
#!/usr/bin/env python
# Copyright (c) 2023 Dominic Masters
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
from PIL import Image
import argparse
import os
# Args
parser = argparse.ArgumentParser(description='Converts image textures to internal game data format.')
parser.add_argument('-i', '--input');
parser.add_argument('-o', '--output');
parser.add_argument('-s', '--scale');
parser.add_argument('-sf', '--scale-filter');
parser.add_argument('-wx', '--wrap-x');
parser.add_argument('-wy', '--wrap-y');
parser.add_argument('-fi', '--filter-min')
parser.add_argument('-fg', '--filter-mag')
parser.add_argument('-csx', '--crop-start-x');
parser.add_argument('-csy', '--crop-start-y');
parser.add_argument('-cex', '--crop-end-x');
parser.add_argument('-cey', '--crop-end-y');
args = parser.parse_args()
# Ensure input exists
if not os.path.exists(args.input):
print(f"Input file '{args.input}' does not exist.")
exit(1)
# Open image
img = Image.open(args.input)
# Normalize the image
hasAlpha = img.mode == 'RGBA' or img.mode == 'LA'
# Convert the image to RGB or RGBA mode based on alpha channel
if hasAlpha:
img = img.convert('RGBA')
else:
img = img.convert('RGB')
# Apply cropping
crop_box = [
int(args.crop_start_x) if args.crop_start_x not in (None, "") else 0,
int(args.crop_start_y) if args.crop_start_y not in (None, "") else 0,
int(args.crop_end_x) if args.crop_end_x not in (None, "") else img.width,
int(args.crop_end_y) if args.crop_end_y not in (None, "") else img.height
]
img = img.crop(crop_box)
# Apply scaling
if args.scale not in (None, ""):
scale = float(args.scale)
newSize = (int(img.width * scale), int(img.height * scale))
if args.scale_filter == 'NEAREST':
img = img.resize(newSize, Image.NEAREST)
elif args.scale_filter == 'BILINEAR':
img = img.resize(newSize, Image.BILINEAR)
elif args.scale_filter == 'BICUBIC':
img = img.resize(newSize, Image.BICUBIC)
elif args.scale_filter == 'LANCZOS':
img = img.resize(newSize, Image.LANCZOS)
else:
img = img.resize(newSize)
# Filter
if args.filter_min.lower() == 'NEAREST':
filterMin = 0
else:
filterMin = 1
if args.filter_mag.lower() == 'NEAREST':
filterMag = 0
else:
filterMag = 1
# Wrap
if args.wrap_x.lower() == 'repeat':
wrapX = 0
elif args.wrap_x.lower() == 'mirror':
wrapX = 1
elif args.wrap_x.lower() == 'clamp':
wrapX = 2
elif args.wrap_x.lower() == 'border':
wrapX = 3
else:
wrapX = 2
if args.wrap_y.lower() == 'repeat':
wrapY = 0
elif args.wrap_y.lower() == 'mirror':
wrapY = 1
elif args.wrap_y.lower() == 'clamp':
wrapY = 2
elif args.wrap_y.lower() == 'border':
wrapY = 3
else:
wrapY = 2
# Get raw pixel data
buffer = img.tobytes()
# Create the output directory if it doesn't exist
os.makedirs(os.path.dirname(args.output), exist_ok=True)
# Write the image metadata and pixel data to the output file
with open(args.output, 'wb') as f:
header = f"DT_2.00|{img.width}|{img.height}|{4 if hasAlpha else 3}|{wrapX}|{wrapY}|{filterMin}|{filterMag}|"
f.write(header.encode())
f.write(buffer)