Mostly nuking old system
This commit is contained in:
@@ -4,14 +4,4 @@
|
||||
# https://opensource.org/licenses/MIT
|
||||
|
||||
add_subdirectory(run_python)
|
||||
add_subdirectory(env_to_h)
|
||||
|
||||
# Function that adds an asset to be compiled
|
||||
function(add_asset ASSET_TYPE ASSET_PATH)
|
||||
set(FULL_ASSET_PATH "${CMAKE_CURRENT_LIST_DIR}/${ASSET_PATH}")
|
||||
string(JOIN "%" ASSETS_ARGS ${ARGN})
|
||||
list(APPEND DUSK_ASSETS
|
||||
"${ASSET_TYPE}#${FULL_ASSET_PATH}#${ASSETS_ARGS}"
|
||||
)
|
||||
set(DUSK_ASSETS ${DUSK_ASSETS} CACHE INTERNAL ${DUSK_CACHE_TARGET})
|
||||
endfunction()
|
||||
add_subdirectory(env_to_h)
|
||||
@@ -1,12 +0,0 @@
|
||||
import sys, os
|
||||
import argparse
|
||||
|
||||
# Check if the script is run with the correct arguments
|
||||
parser = argparse.ArgumentParser(description="Generate chunk header files")
|
||||
parser.add_argument('--assets', required=True, help='Dir to output built assets')
|
||||
parser.add_argument('--headers-dir', required=True, help='Directory to output individual asset headers (required for header build)')
|
||||
parser.add_argument('--output-headers', help='Output header file for built assets (required for header build)')
|
||||
parser.add_argument('--output-assets', required=True, help='Output directory for built assets')
|
||||
parser.add_argument('--output-file', required=True, help='Output file for built assets (required for wad build)')
|
||||
parser.add_argument('--input', required=True, help='Input assets to process', nargs='+')
|
||||
args = parser.parse_args()
|
||||
@@ -1,66 +0,0 @@
|
||||
import sys, os
|
||||
from tools.asset.args import args
|
||||
from tools.asset.process.asset import processAsset
|
||||
from tools.asset.process.palette import processPaletteList
|
||||
from tools.asset.process.tileset import processTilesetList
|
||||
from tools.asset.process.language import processLanguageList
|
||||
from tools.asset.path import getBuiltAssetsRelativePath
|
||||
import zipfile
|
||||
|
||||
# Parse input file args.
|
||||
inputAssets = []
|
||||
for inputArg in args.input:
|
||||
files = inputArg.split('$')
|
||||
for file in files:
|
||||
if str(file).strip() == '':
|
||||
continue
|
||||
|
||||
pieces = file.split('#')
|
||||
|
||||
if len(pieces) < 2:
|
||||
print(f"Error: Invalid input asset format '{file}'. Expected format: type#path[#option1%option2...]")
|
||||
sys.exit(1)
|
||||
|
||||
options = {}
|
||||
if len(pieces) > 2:
|
||||
optionParts = pieces[2].split('%')
|
||||
for part in optionParts:
|
||||
partSplit = part.split('=')
|
||||
|
||||
if len(partSplit) < 1:
|
||||
continue
|
||||
if len(partSplit) == 2:
|
||||
options[partSplit[0]] = partSplit[1]
|
||||
else:
|
||||
options[partSplit[0]] = True
|
||||
|
||||
inputAssets.append({
|
||||
'type': pieces[0],
|
||||
'path': pieces[1],
|
||||
'options': options
|
||||
})
|
||||
|
||||
if not inputAssets:
|
||||
print("Error: No input assets provided.")
|
||||
sys.exit(1)
|
||||
|
||||
# Process each asset.
|
||||
files = []
|
||||
for asset in inputAssets:
|
||||
asset = processAsset(asset)
|
||||
files.extend(asset['files'])
|
||||
|
||||
# Generate additional files
|
||||
files.extend(processLanguageList()['files'])
|
||||
|
||||
# Take assets and add to a zip archive.
|
||||
outputFileName = args.output_file
|
||||
print(f"Creating output file: {outputFileName}")
|
||||
with zipfile.ZipFile(outputFileName, 'w') as zipf:
|
||||
for file in files:
|
||||
relativeOutputPath = getBuiltAssetsRelativePath(file)
|
||||
zipf.write(file, arcname=relativeOutputPath)
|
||||
|
||||
# Generate additional headers.
|
||||
processPaletteList()
|
||||
processTilesetList()
|
||||
@@ -1,12 +0,0 @@
|
||||
processedAssets = {}
|
||||
|
||||
def assetGetCache(assetPath):
|
||||
if assetPath in processedAssets:
|
||||
return processedAssets[assetPath]
|
||||
return None
|
||||
|
||||
def assetCache(assetPath, processedData):
|
||||
if assetPath in processedAssets:
|
||||
return processedAssets[assetPath]
|
||||
processedAssets[assetPath] = processedData
|
||||
return processedData
|
||||
@@ -1,10 +0,0 @@
|
||||
import os
|
||||
from tools.asset.args import args
|
||||
|
||||
def getAssetRelativePath(fullPath):
|
||||
# Get the relative path to the asset
|
||||
return os.path.relpath(fullPath, start=args.assets).replace('\\', '/')
|
||||
|
||||
def getBuiltAssetsRelativePath(fullPath):
|
||||
# Get the relative path to the built asset
|
||||
return os.path.relpath(fullPath, start=args.output_assets).replace('\\', '/')
|
||||
@@ -1,33 +0,0 @@
|
||||
import sys
|
||||
# from processtileset import processTileset
|
||||
from tools.asset.process.image import processImage
|
||||
from tools.asset.process.palette import processPalette
|
||||
from tools.asset.process.tileset import processTileset
|
||||
from tools.asset.process.map import processMap
|
||||
from tools.asset.process.language import processLanguage
|
||||
from tools.asset.process.script import processScript
|
||||
|
||||
processedAssets = []
|
||||
|
||||
def processAsset(asset):
|
||||
if asset['path'] in processedAssets:
|
||||
return
|
||||
processedAssets.append(asset['path'])
|
||||
|
||||
# Handle tiled tilesets
|
||||
t = asset['type'].lower()
|
||||
if t == 'palette':
|
||||
return processPalette(asset)
|
||||
elif t == 'image':
|
||||
return processImage(asset)
|
||||
elif t == 'tileset':
|
||||
return processTileset(asset)
|
||||
elif t == 'map':
|
||||
return processMap(asset)
|
||||
elif t == 'language':
|
||||
return processLanguage(asset)
|
||||
elif t == 'script':
|
||||
return processScript(asset)
|
||||
else:
|
||||
print(f"Error: Unknown asset type '{asset['type']}' for path '{asset['path']}'")
|
||||
sys.exit(1)
|
||||
@@ -1,134 +0,0 @@
|
||||
import os
|
||||
import sys
|
||||
from PIL import Image
|
||||
from tools.asset.process.palette import extractPaletteFromImage, palettes
|
||||
from tools.asset.args import args
|
||||
from tools.asset.path import getAssetRelativePath
|
||||
from tools.asset.cache import assetGetCache, assetCache
|
||||
|
||||
images = []
|
||||
|
||||
def processImage(asset):
|
||||
cache = assetGetCache(asset['path'])
|
||||
if cache is not None:
|
||||
return cache
|
||||
|
||||
type = None
|
||||
if 'type' in asset['options']:
|
||||
type = asset['options'].get('type', 'PALETTIZED').upper()
|
||||
|
||||
if type == 'PALETTIZED' or type is None:
|
||||
return assetCache(asset['path'], processPalettizedImage(asset))
|
||||
elif type == 'ALPHA':
|
||||
return assetCache(asset['path'], processAlphaImage(asset))
|
||||
else:
|
||||
print(f"Error: Unknown image type {type} for asset {asset['path']}")
|
||||
sys.exit(1)
|
||||
|
||||
def processPalettizedImage(asset):
|
||||
assetPath = asset['path']
|
||||
cache = assetGetCache(assetPath)
|
||||
if cache is not None:
|
||||
return cache
|
||||
|
||||
image = Image.open(assetPath)
|
||||
imagePalette = extractPaletteFromImage(image)
|
||||
|
||||
# Find palette that contains every color
|
||||
palette = None
|
||||
for p in palettes:
|
||||
hasAllColors = True
|
||||
for color in imagePalette:
|
||||
for palColor in p['pixels']:
|
||||
if color[0] == palColor[0] and color[1] == palColor[1] and color[2] == palColor[2] and color[3] == palColor[3]:
|
||||
break
|
||||
elif color[3] == 0 and palColor[3] == 0:
|
||||
break
|
||||
else:
|
||||
print('Pallete {} does not contain color #{}'.format(p['paletteName'], '{:02x}{:02x}{:02x}{:02x}'.format(color[0], color[1], color[2], color[3])))
|
||||
hasAllColors = False
|
||||
break
|
||||
if hasAllColors:
|
||||
palette = p
|
||||
break
|
||||
|
||||
if palette is None:
|
||||
palette = palettes[0] # Just to avoid reference error
|
||||
print(f"No matching palette found for {assetPath}!")
|
||||
# Find which pixel is missing
|
||||
for color in imagePalette:
|
||||
if color in palette['pixels']:
|
||||
continue
|
||||
# Convert to hex (with alpha)
|
||||
hexColor = '#{:02x}{:02x}{:02x}{:02x}'.format(color[0], color[1], color[2], color[3])
|
||||
print(f"Missing color: {hexColor} in palette {palette['paletteName']}")
|
||||
sys.exit(1)
|
||||
|
||||
print(f"Converting image {assetPath} to use palette")
|
||||
|
||||
paletteIndexes = []
|
||||
for pixel in list(image.getdata()):
|
||||
if pixel[3] == 0:
|
||||
pixel = (0, 0, 0, 0)
|
||||
paletteIndex = palette['pixels'].index(pixel)
|
||||
paletteIndexes.append(paletteIndex)
|
||||
|
||||
data = bytearray()
|
||||
data.extend(b"DPI") # Dusk Palettized Image
|
||||
data.extend(image.width.to_bytes(4, 'little')) # Width
|
||||
data.extend(image.height.to_bytes(4, 'little')) # Height
|
||||
data.append(palette['paletteIndex']) # Palette index
|
||||
for paletteIndex in paletteIndexes:
|
||||
if paletteIndex > 255 or paletteIndex < 0:
|
||||
print(f"Error: Palette index {paletteIndex} exceeds 255!")
|
||||
sys.exit(1)
|
||||
data.append(paletteIndex.to_bytes(1, 'little')[0]) # Pixel index
|
||||
|
||||
relative = getAssetRelativePath(assetPath)
|
||||
fileNameWithoutExt = os.path.splitext(os.path.basename(assetPath))[0]
|
||||
outputFileRelative = os.path.join(os.path.dirname(relative), f"{fileNameWithoutExt}.dpi")
|
||||
outputFilePath = os.path.join(args.output_assets, outputFileRelative)
|
||||
os.makedirs(os.path.dirname(outputFilePath), exist_ok=True)
|
||||
with open(outputFilePath, "wb") as f:
|
||||
f.write(data)
|
||||
|
||||
outImage = {
|
||||
"imagePath": outputFileRelative,
|
||||
"files": [ outputFilePath ],
|
||||
'width': image.width,
|
||||
'height': image.height,
|
||||
}
|
||||
return assetCache(assetPath, outImage)
|
||||
|
||||
def processAlphaImage(asset):
|
||||
assetPath = asset['path']
|
||||
cache = assetGetCache(assetPath)
|
||||
if cache is not None:
|
||||
return cache
|
||||
|
||||
print(f"Processing alpha image: {assetPath}")
|
||||
|
||||
data = bytearray()
|
||||
data.extend(b"DAI") # Dusk Alpha Image
|
||||
image = Image.open(assetPath).convert("RGBA")
|
||||
data.extend(image.width.to_bytes(4, 'little')) # Width
|
||||
data.extend(image.height.to_bytes(4, 'little')) # Height
|
||||
for pixel in list(image.getdata()):
|
||||
# Only write alpha channel
|
||||
data.append(pixel[3].to_bytes(1, 'little')[0]) # Pixel alpha
|
||||
|
||||
relative = getAssetRelativePath(assetPath)
|
||||
fileNameWithoutExt = os.path.splitext(os.path.basename(assetPath))[0]
|
||||
outputFileRelative = os.path.join(os.path.dirname(relative), f"{fileNameWithoutExt}.dai")
|
||||
outputFilePath = os.path.join(args.output_assets, outputFileRelative)
|
||||
os.makedirs(os.path.dirname(outputFilePath), exist_ok=True)
|
||||
with open(outputFilePath, "wb") as f:
|
||||
f.write(data)
|
||||
|
||||
outImage = {
|
||||
"imagePath": outputFileRelative,
|
||||
"files": [ outputFilePath ],
|
||||
'width': image.width,
|
||||
'height': image.height,
|
||||
}
|
||||
return assetCache(assetPath, outImage)
|
||||
@@ -1,228 +0,0 @@
|
||||
import sys
|
||||
import os
|
||||
from tools.asset.args import args
|
||||
from tools.asset.cache import assetCache, assetGetCache
|
||||
from tools.asset.path import getAssetRelativePath
|
||||
from tools.dusk.defs import defs
|
||||
import polib
|
||||
import re
|
||||
|
||||
LANGUAGE_CHUNK_CHAR_COUNT = int(defs.get('ASSET_LANG_CHUNK_CHAR_COUNT'))
|
||||
|
||||
LANGUAGE_DATA = {}
|
||||
LANGUAGE_KEYS = []
|
||||
|
||||
def processLanguageList():
|
||||
# Language keys header data
|
||||
headerKeys = "// Auto-generated language keys header file.\n"
|
||||
headerKeys += "#pragma once\n"
|
||||
headerKeys += "#include \"dusk.h\"\n\n"
|
||||
|
||||
# This is the desired chunk groups list.. if a language key STARTS with any
|
||||
# of the keys in this list we would "like to" put it in that chunk group.
|
||||
# If there is no match, or the list is full then we will add it to the next
|
||||
# available chunk group (that isn't a 'desired' one). If the chunk becomes
|
||||
# full, then we attempt to make another chunk with the same prefix so that
|
||||
# a second batching can occur.
|
||||
desiredChunkGroups = {
|
||||
'ui': 0
|
||||
}
|
||||
|
||||
# Now, for each language key, create the header reference and index.
|
||||
keyIndex = 0
|
||||
languageKeyIndexes = {}
|
||||
languageKeyChunk = {}
|
||||
languageKeyChunkIndexes = {}
|
||||
languageKeyChunkOffsets = {}
|
||||
for key in LANGUAGE_KEYS:
|
||||
headerKeys += f"#define {getLanguageVariableName(key)} {keyIndex}\n"
|
||||
languageKeyIndexes[key] = keyIndex
|
||||
keyIndex += 1
|
||||
|
||||
# Find desired chunk group
|
||||
assignedChunk = None
|
||||
for desiredKey in desiredChunkGroups:
|
||||
if key.lower().startswith(desiredKey):
|
||||
assignedChunk = desiredChunkGroups[desiredKey]
|
||||
break
|
||||
# If no desired chunk group matched, assign to -1
|
||||
if assignedChunk is None:
|
||||
assignedChunk = -1
|
||||
languageKeyChunk[key] = assignedChunk
|
||||
|
||||
# Setup header.
|
||||
for lang in LANGUAGE_DATA:
|
||||
if key not in LANGUAGE_DATA[lang]:
|
||||
print(f"Warning: Missing translation for key '{key}' in language '{lang}'")
|
||||
sys.exit(1)
|
||||
|
||||
# Seal the header.
|
||||
headerKeys += f"\n#define LANG_KEY_COUNT {len(LANGUAGE_KEYS)}\n"
|
||||
|
||||
# Now we can generate the language string chunks.
|
||||
nextChunkIndex = max(desiredChunkGroups.values()) + 1
|
||||
files = []
|
||||
|
||||
for lang in LANGUAGE_DATA:
|
||||
langData = LANGUAGE_DATA[lang]
|
||||
|
||||
# Key = chunkIndex, value = chunkInfo
|
||||
languageChunks = {}
|
||||
for key in LANGUAGE_KEYS:
|
||||
keyIndex = languageKeyIndexes[key]
|
||||
chunkIndex = languageKeyChunk[key]
|
||||
wasSetChunk = chunkIndex != -1
|
||||
|
||||
# This will keep looping until we find a chunk
|
||||
while True:
|
||||
# Determine the next chunkIndex IF chunkIndex is -1
|
||||
if chunkIndex == -1:
|
||||
chunkIndex = nextChunkIndex
|
||||
|
||||
# Is the chunk full?
|
||||
curLen = languageChunks.get(chunkIndex, {'len': 0})['len']
|
||||
newLen = curLen + len(langData[key])
|
||||
if newLen > LANGUAGE_CHUNK_CHAR_COUNT:
|
||||
# Chunk is full, need to create a new chunk.
|
||||
chunkIndex = -1
|
||||
if wasSetChunk:
|
||||
wasSetChunk = False
|
||||
else:
|
||||
nextChunkIndex += 1
|
||||
continue
|
||||
|
||||
# Chunk is not full, we can use it.
|
||||
if chunkIndex not in languageChunks:
|
||||
languageChunks[chunkIndex] = {
|
||||
'len': 0,
|
||||
'keys': []
|
||||
}
|
||||
languageChunks[chunkIndex]['len'] = newLen
|
||||
languageChunks[chunkIndex]['keys'].append(key)
|
||||
languageKeyChunkIndexes[key] = chunkIndex
|
||||
languageKeyChunkOffsets[key] = curLen
|
||||
break
|
||||
|
||||
# We have now chunked all the keys for this language!
|
||||
langBuffer = b""
|
||||
|
||||
# Write header info
|
||||
langBuffer += b'DLF' # Dusk Language File
|
||||
|
||||
for key in LANGUAGE_KEYS:
|
||||
# Write the chunk that this key belongs to as uint32_t
|
||||
chunkIndex = languageKeyChunkIndexes[key]
|
||||
langBuffer += chunkIndex.to_bytes(4, byteorder='little')
|
||||
|
||||
# Write the offset for this key as uint32_t
|
||||
offset = languageKeyChunkOffsets[key]
|
||||
langBuffer += offset.to_bytes(4, byteorder='little')
|
||||
|
||||
# Write the length of the string as uint32_t
|
||||
strData = langData[key].encode('utf-8')
|
||||
langBuffer += len(strData).to_bytes(4, byteorder='little')
|
||||
|
||||
# Now write out each chunk's string data, packed tight and no null term.
|
||||
for chunkIndex in sorted(languageChunks.keys()):
|
||||
chunkInfo = languageChunks[chunkIndex]
|
||||
for key in chunkInfo['keys']:
|
||||
strData = langData[key].encode('utf-8')
|
||||
langBuffer += strData
|
||||
|
||||
# Now pad the chunk to full size
|
||||
curLen = chunkInfo['len']
|
||||
if curLen < LANGUAGE_CHUNK_CHAR_COUNT:
|
||||
padSize = LANGUAGE_CHUNK_CHAR_COUNT - curLen
|
||||
langBuffer += b'\0' * padSize
|
||||
|
||||
# Write out the language data file
|
||||
outputFile = os.path.join(args.output_assets, "language", f"{lang}.dlf")
|
||||
files.append(outputFile)
|
||||
os.makedirs(os.path.dirname(outputFile), exist_ok=True)
|
||||
with open(outputFile, "wb") as f:
|
||||
f.write(langBuffer)
|
||||
|
||||
# Write out the language keys header file
|
||||
outputFile = os.path.join(args.headers_dir, "locale", "language", "keys.h")
|
||||
os.makedirs(os.path.dirname(outputFile), exist_ok=True)
|
||||
with open(outputFile, "w") as f:
|
||||
f.write(headerKeys)
|
||||
|
||||
# Generate language list.
|
||||
langValues = {}
|
||||
headerLocale = "#pragma once\n#include \"locale/localeinfo.h\"\n\n"
|
||||
headerLocale += "typedef enum {\n"
|
||||
count = 0
|
||||
headerLocale += f" DUSK_LOCALE_NULL = {count},\n"
|
||||
count += 1
|
||||
for lang in LANGUAGE_DATA:
|
||||
langKey = lang.replace('-', '_').replace(' ', '_').upper()
|
||||
langValues[lang] = count
|
||||
headerLocale += f" DUSK_LOCALE_{langKey} = {count},\n"
|
||||
count += 1
|
||||
headerLocale += f" DUSK_LOCALE_COUNT = {count}\n"
|
||||
headerLocale += "} dusklocale_t;\n\n"
|
||||
|
||||
headerLocale += f"static const localeinfo_t LOCALE_INFOS[DUSK_LOCALE_COUNT] = {{\n"
|
||||
for lang in LANGUAGE_DATA:
|
||||
langKey = lang.replace('-', '_').replace(' ', '_').upper()
|
||||
headerLocale += f" [DUSK_LOCALE_{langKey}] = {{\n"
|
||||
headerLocale += f" .file = \"{lang}\"\n"
|
||||
headerLocale += f" }},\n"
|
||||
headerLocale += "};\n"
|
||||
|
||||
headerLocale += f"static const char_t *LOCALE_SCRIPT = \n"
|
||||
for lang in LANGUAGE_DATA:
|
||||
langKey = lang.replace('-', '_').replace(' ', '_').upper()
|
||||
langValue = langValues[lang]
|
||||
headerLocale += f" \"DUSK_LOCALE_{langKey} = {langValue}\\n\"\n"
|
||||
headerLocale += ";\n"
|
||||
|
||||
# Write out the locale enum header file
|
||||
outputFile = os.path.join(args.headers_dir, "locale", "locale.h")
|
||||
os.makedirs(os.path.dirname(outputFile), exist_ok=True)
|
||||
with open(outputFile, "w") as f:
|
||||
f.write(headerLocale)
|
||||
|
||||
return {
|
||||
'files': files
|
||||
}
|
||||
|
||||
def getLanguageVariableName(languageKey):
|
||||
# Take the language key, prepend LANG_, uppercase, replace any non symbols
|
||||
# with _
|
||||
key = languageKey.strip().upper()
|
||||
key = re.sub(r'[^A-Z0-9]', '_', key)
|
||||
return f"LANG_{key}"
|
||||
|
||||
def processLanguage(asset):
|
||||
cache = assetGetCache(asset['path'])
|
||||
if cache is not None:
|
||||
return cache
|
||||
|
||||
# Load PO File
|
||||
po = polib.pofile(asset['path'])
|
||||
|
||||
langName = po.metadata.get('Language')
|
||||
if langName not in LANGUAGE_DATA:
|
||||
LANGUAGE_DATA[langName] = {}
|
||||
|
||||
for entry in po:
|
||||
key = entry.msgid
|
||||
val = entry.msgstr
|
||||
|
||||
if key not in LANGUAGE_KEYS:
|
||||
LANGUAGE_KEYS.append(key)
|
||||
|
||||
if key not in LANGUAGE_DATA[langName]:
|
||||
LANGUAGE_DATA[langName][key] = val
|
||||
else:
|
||||
print(f"Error: Duplicate translation key '{key}' in language '{langName}'")
|
||||
sys.exit(1)
|
||||
|
||||
outLanguageData = {
|
||||
'data': po,
|
||||
'path': asset['path'],
|
||||
'files': []
|
||||
}
|
||||
return assetCache(asset['path'], outLanguageData)
|
||||
@@ -1,154 +0,0 @@
|
||||
import struct
|
||||
import sys
|
||||
import os
|
||||
import json
|
||||
from tools.asset.args import args
|
||||
from tools.asset.cache import assetCache, assetGetCache
|
||||
from tools.asset.path import getAssetRelativePath
|
||||
from tools.dusk.defs import TILE_WIDTH, TILE_HEIGHT, TILE_DEPTH, CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, CHUNK_TILE_COUNT
|
||||
from tools.dusk.map import Map
|
||||
from tools.dusk.chunk import Chunk
|
||||
|
||||
def convertModelData(modelData):
|
||||
# TLDR; Model data stores things efficiently with indices, but we buffer it
|
||||
# out to 6 vertex quads for simplicity.
|
||||
outVertices = []
|
||||
outUVs = []
|
||||
outColors = []
|
||||
for indice in modelData['indices']:
|
||||
vertex = modelData['vertices'][indice]
|
||||
uv = modelData['uvs'][indice]
|
||||
color = modelData['colors'][indice]
|
||||
outVertices.append(vertex)
|
||||
outUVs.append(uv)
|
||||
outColors.append(color)
|
||||
|
||||
return {
|
||||
'vertices': outVertices,
|
||||
'uvs': outUVs,
|
||||
'colors': outColors
|
||||
}
|
||||
|
||||
def processChunk(chunk):
|
||||
cache = assetGetCache(chunk.getFilename())
|
||||
if cache:
|
||||
return cache
|
||||
|
||||
baseModel = {
|
||||
'vertices': [],
|
||||
'colors': [],
|
||||
'uvs': []
|
||||
}
|
||||
models = [ baseModel ]
|
||||
|
||||
for tileIndex, tile in chunk.tiles.items():
|
||||
tileBase = tile.getBaseTileModel()
|
||||
|
||||
convertedBase = convertModelData(tileBase)
|
||||
baseModel['vertices'].extend(convertedBase['vertices'])
|
||||
baseModel['colors'].extend(convertedBase['colors'])
|
||||
baseModel['uvs'].extend(convertedBase['uvs'])
|
||||
|
||||
# Generate binary buffer for efficient output
|
||||
buffer = bytearray()
|
||||
buffer.extend(b'DMC')# Header
|
||||
buffer.extend(len(chunk.tiles).to_bytes(4, 'little')) # Number of tiles
|
||||
buffer.extend(len(models).to_bytes(1, 'little')) # Number of models
|
||||
buffer.extend(len(chunk.entities).to_bytes(1, 'little')) # Number of entities
|
||||
|
||||
# Buffer tile data as array of uint8_t
|
||||
for tileIndex, tile in chunk.tiles.items():
|
||||
buffer.extend(tile.shape.to_bytes(1, 'little'))
|
||||
|
||||
# # For each model
|
||||
for model in models:
|
||||
vertexCount = len(model['vertices'])
|
||||
buffer.extend(vertexCount.to_bytes(4, 'little'))
|
||||
for i in range(vertexCount):
|
||||
vertex = model['vertices'][i]
|
||||
uv = model['uvs'][i]
|
||||
color = model['colors'][i]
|
||||
|
||||
buffer.extend(color[0].to_bytes(1, 'little'))
|
||||
buffer.extend(color[1].to_bytes(1, 'little'))
|
||||
buffer.extend(color[2].to_bytes(1, 'little'))
|
||||
buffer.extend(color[3].to_bytes(1, 'little'))
|
||||
|
||||
buffer.extend(bytearray(struct.pack('<f', uv[0])))
|
||||
buffer.extend(bytearray(struct.pack('<f', uv[1])))
|
||||
|
||||
buffer.extend(bytearray(struct.pack('<f', vertex[0])))
|
||||
buffer.extend(bytearray(struct.pack('<f', vertex[1])))
|
||||
buffer.extend(bytearray(struct.pack('<f', vertex[2])))
|
||||
|
||||
# For each entity
|
||||
for entity in chunk.entities.values():
|
||||
buffer.extend(entity.type.to_bytes(1, 'little'))
|
||||
buffer.extend(entity.localX.to_bytes(1, 'little'))
|
||||
buffer.extend(entity.localY.to_bytes(1, 'little'))
|
||||
buffer.extend(entity.localZ.to_bytes(1, 'little'))
|
||||
pass
|
||||
|
||||
# Write out map file
|
||||
relative = getAssetRelativePath(chunk.getFilename())
|
||||
fileNameWithoutExt = os.path.splitext(os.path.basename(relative))[0]
|
||||
outputFileRelative = os.path.join(os.path.dirname(relative), f"{fileNameWithoutExt}.dmc")
|
||||
outputFilePath = os.path.join(args.output_assets, outputFileRelative)
|
||||
os.makedirs(os.path.dirname(outputFilePath), exist_ok=True)
|
||||
with open(outputFilePath, "wb") as f:
|
||||
f.write(buffer)
|
||||
|
||||
outChunk = {
|
||||
'files': [ outputFilePath ],
|
||||
'chunk': chunk
|
||||
}
|
||||
return assetCache(chunk.getFilename(), outChunk)
|
||||
|
||||
def processMap(asset):
|
||||
cache = assetGetCache(asset['path'])
|
||||
if cache is not None:
|
||||
return cache
|
||||
|
||||
map = Map(None)
|
||||
map.load(asset['path'])
|
||||
chunksDir = map.getChunkDirectory()
|
||||
|
||||
files = os.listdir(chunksDir)
|
||||
if len(files) == 0:
|
||||
print(f"Error: No chunk files found in {chunksDir}.")
|
||||
sys.exit(1)
|
||||
|
||||
chunkFiles = []
|
||||
for fileName in files:
|
||||
if not fileName.endswith('.json'):
|
||||
continue
|
||||
|
||||
fNameNoExt = os.path.splitext(fileName)[0]
|
||||
fnPieces = fNameNoExt.split('_')
|
||||
if len(fnPieces) != 3:
|
||||
print(f"Error: Chunk filename {fileName} does not contain valid chunk coordinates.")
|
||||
sys.exit(1)
|
||||
chunk = Chunk(map, int(fnPieces[0]), int(fnPieces[1]), int(fnPieces[2]))
|
||||
chunk.load()
|
||||
result = processChunk(chunk)
|
||||
chunkFiles.extend(result['files'])
|
||||
|
||||
# Map file
|
||||
outBuffer = bytearray()
|
||||
outBuffer.extend(b'DMF')
|
||||
outBuffer.extend(len(chunkFiles).to_bytes(4, 'little'))
|
||||
|
||||
# DMF (Dusk Map file)
|
||||
fileRelative = getAssetRelativePath(asset['path'])
|
||||
fileNameWithoutExt = os.path.splitext(os.path.basename(fileRelative))[0]
|
||||
outputMapRelative = os.path.join(os.path.dirname(fileRelative), f"{fileNameWithoutExt}.dmf")
|
||||
outputMapPath = os.path.join(args.output_assets, outputMapRelative)
|
||||
os.makedirs(os.path.dirname(outputMapPath), exist_ok=True)
|
||||
with open(outputMapPath, "wb") as f:
|
||||
f.write(outBuffer)
|
||||
|
||||
outMap = {
|
||||
'files': chunkFiles
|
||||
}
|
||||
outMap['files'].append(outputMapPath)
|
||||
return assetCache(asset['path'], outMap)
|
||||
@@ -1,96 +0,0 @@
|
||||
import json
|
||||
import os
|
||||
from PIL import Image
|
||||
import datetime
|
||||
from tools.asset.args import args
|
||||
from tools.asset.cache import assetCache, assetGetCache
|
||||
|
||||
palettes = []
|
||||
|
||||
def extractPaletteFromImage(image):
|
||||
# goes through and finds all unique colors in the image
|
||||
if image.mode != 'RGBA':
|
||||
image = image.convert('RGBA')
|
||||
pixels = list(image.getdata())
|
||||
uniqueColors = []
|
||||
for color in pixels:
|
||||
# We treat all alpha 0 as rgba(0,0,0,0) for palette purposes
|
||||
if color[3] == 0:
|
||||
color = (0, 0, 0, 0)
|
||||
if color not in uniqueColors:
|
||||
uniqueColors.append(color)
|
||||
return uniqueColors
|
||||
|
||||
def processPalette(asset):
|
||||
print(f"Processing palette: {asset['path']}")
|
||||
cache = assetGetCache(asset['path'])
|
||||
if cache is not None:
|
||||
return cache
|
||||
|
||||
paletteIndex = len(palettes)
|
||||
image = Image.open(asset['path'])
|
||||
pixels = extractPaletteFromImage(image)
|
||||
|
||||
fileNameWithoutExt = os.path.splitext(os.path.basename(asset['path']))[0]
|
||||
fileNameWithoutPalette = os.path.splitext(fileNameWithoutExt)[0]
|
||||
|
||||
# PSP requires that the palette size be a power of two, so we will pad the
|
||||
# palette with transparent colors if needed.
|
||||
def mathNextPowTwo(x):
|
||||
return 1 << (x - 1).bit_length()
|
||||
|
||||
nextPowTwo = mathNextPowTwo(len(pixels))
|
||||
while len(pixels) < nextPowTwo:
|
||||
pixels.append((0, 0, 0, 0))
|
||||
|
||||
# Header
|
||||
now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
|
||||
data = f"// Palette Generated for {asset['path']} at {now}\n"
|
||||
data += f"#include \"display/palette/palette.h\"\n\n"
|
||||
data += f"#define PALETTE_{paletteIndex}_COLOR_COUNT {len(pixels)}\n\n"
|
||||
data += f"#pragma pack(push, 1)\n"
|
||||
data += f"static const color_t PALETTE_{paletteIndex}_COLORS[PALETTE_{paletteIndex}_COLOR_COUNT] = {{\n"
|
||||
for pixel in pixels:
|
||||
data += f" {{ 0x{pixel[0]:02X}, 0x{pixel[1]:02X}, 0x{pixel[2]:02X}, 0x{pixel[3]:02X} }},\n"
|
||||
data += f"}};\n"
|
||||
data += f"#pragma pack(pop)\n\n"
|
||||
data += f"static const palette_t PALETTE_{paletteIndex} = {{\n"
|
||||
data += f" .colorCount = PALETTE_{paletteIndex}_COLOR_COUNT,\n"
|
||||
data += f" .colors = PALETTE_{paletteIndex}_COLORS,\n"
|
||||
data += f"}};\n"
|
||||
|
||||
# Write Header
|
||||
outputFile = os.path.join(args.headers_dir, "display", "palette", f"palette_{paletteIndex}.h")
|
||||
os.makedirs(os.path.dirname(outputFile), exist_ok=True)
|
||||
with open(outputFile, "w") as f:
|
||||
f.write(data)
|
||||
|
||||
palette = {
|
||||
"paletteIndex": paletteIndex,
|
||||
"paletteName": fileNameWithoutPalette,
|
||||
"pixels": pixels,
|
||||
"headerFile": os.path.relpath(outputFile, args.headers_dir),
|
||||
"asset": asset,
|
||||
"files": [ ],# No zippable files.
|
||||
}
|
||||
|
||||
palettes.append(palette)
|
||||
return assetCache(asset['path'], palette)
|
||||
|
||||
def processPaletteList():
|
||||
data = f"// Auto-generated palette list\n"
|
||||
print(f"Generating palette list with {len(palettes)} palettes.")
|
||||
for palette in palettes:
|
||||
data += f"#include \"{palette['headerFile']}\"\n"
|
||||
data += f"\n"
|
||||
data += f"#define PALETTE_LIST_COUNT {len(palettes)}\n\n"
|
||||
data += f"static const palette_t* PALETTE_LIST[PALETTE_LIST_COUNT] = {{\n"
|
||||
for palette in palettes:
|
||||
data += f" &PALETTE_{palette['paletteIndex']},\n"
|
||||
data += f"}};\n"
|
||||
|
||||
# Write the palette list to a header file
|
||||
outputFile = os.path.join(args.headers_dir, "display", "palette", "palettelist.h")
|
||||
os.makedirs(os.path.dirname(outputFile), exist_ok=True)
|
||||
with open(outputFile, "w") as f:
|
||||
f.write(data)
|
||||
@@ -1,43 +0,0 @@
|
||||
import sys
|
||||
import os
|
||||
from tools.asset.args import args
|
||||
from tools.asset.cache import assetCache, assetGetCache
|
||||
from tools.asset.path import getAssetRelativePath
|
||||
from tools.dusk.defs import fileDefs
|
||||
|
||||
def processScript(asset):
|
||||
cache = assetGetCache(asset['path'])
|
||||
if cache is not None:
|
||||
return cache
|
||||
|
||||
# Load the lua file as a string
|
||||
with open(asset['path'], 'r', encoding='utf-8') as f:
|
||||
luaCode = f.read()
|
||||
|
||||
# TODO: I will precompile or minify the Lua code here in the future
|
||||
|
||||
# Replace all definitions in the code
|
||||
for key, val in fileDefs.items():
|
||||
luaCode = luaCode.replace(key, str(val))
|
||||
|
||||
# Create output Dusk Script File (DSF) data
|
||||
data = ""
|
||||
data += "DSF"
|
||||
data += luaCode
|
||||
|
||||
# Write to relative output file path.
|
||||
relative = getAssetRelativePath(asset['path'])
|
||||
fileNameWithoutExt = os.path.splitext(os.path.basename(asset['path']))[0]
|
||||
outputFileRelative = os.path.join(os.path.dirname(relative), f"{fileNameWithoutExt}.dsf")
|
||||
outputFilePath = os.path.join(args.output_assets, outputFileRelative)
|
||||
os.makedirs(os.path.dirname(outputFilePath), exist_ok=True)
|
||||
with open(outputFilePath, "wb") as f:
|
||||
f.write(data.encode('utf-8'))
|
||||
|
||||
outScript = {
|
||||
'data': data,
|
||||
'path': asset['path'],
|
||||
'files': [ outputFilePath ],
|
||||
'scriptPath': outputFileRelative,
|
||||
}
|
||||
return assetCache(asset['path'], outScript)
|
||||
@@ -1,178 +0,0 @@
|
||||
import json
|
||||
import sys
|
||||
import os
|
||||
import datetime
|
||||
from xml.etree import ElementTree
|
||||
from tools.asset.process.image import processImage
|
||||
from tools.asset.path import getAssetRelativePath
|
||||
from tools.asset.args import args
|
||||
from tools.asset.cache import assetGetCache, assetCache
|
||||
|
||||
tilesets = []
|
||||
|
||||
def loadTilesetFromTSX(asset):
|
||||
# Load the TSX file
|
||||
tree = ElementTree.parse(asset['path'])
|
||||
root = tree.getroot()
|
||||
|
||||
# Expect tileheight, tilewidth, columns and tilecount attributes
|
||||
if 'tilewidth' not in root.attrib or 'tileheight' not in root.attrib or 'columns' not in root.attrib or 'tilecount' not in root.attrib:
|
||||
print(f"Error: TSX file {asset['path']} is missing required attributes (tilewidth, tileheight, columns, tilecount)")
|
||||
sys.exit(1)
|
||||
|
||||
tileWidth = int(root.attrib['tilewidth'])
|
||||
tileHeight = int(root.attrib['tileheight'])
|
||||
columns = int(root.attrib['columns'])
|
||||
tileCount = int(root.attrib['tilecount'])
|
||||
rows = (tileCount + columns - 1) // columns # Calculate rows based on tileCount and columns
|
||||
|
||||
# Find the image element
|
||||
imageElement = root.find('image')
|
||||
if imageElement is None or 'source' not in imageElement.attrib:
|
||||
print(f"Error: TSX file {asset['path']} is missing an image element with a source attribute")
|
||||
sys.exit(1)
|
||||
|
||||
imagePath = imageElement.attrib['source']
|
||||
|
||||
# Image is relative to the TSX file
|
||||
imageAssetPath = os.path.join(os.path.dirname(asset['path']), imagePath)
|
||||
|
||||
image = processImage({
|
||||
'path': imageAssetPath,
|
||||
'options': asset['options'],
|
||||
})
|
||||
|
||||
return {
|
||||
"image": image,
|
||||
"tileWidth": tileWidth,
|
||||
"tileHeight": tileHeight,
|
||||
"columns": columns,
|
||||
"rows": rows,
|
||||
"originalWidth": tileWidth * columns,
|
||||
"originalHeight": tileHeight * rows,
|
||||
}
|
||||
|
||||
def loadTilesetFromArgs(asset):
|
||||
# We need to determine how big each tile is. This can either be provided as
|
||||
# an arg of tileWidth/tileHeight or as a count of rows/columns.
|
||||
# Additionally, if the image has been factored, then the user can provide both
|
||||
# tile sizes AND cols/rows to indicate the original size of the image.
|
||||
image = processImage(asset)
|
||||
|
||||
tileWidth, tileHeight = None, None
|
||||
columns, rows = None, None
|
||||
originalWidth, originalHeight = image['width'], image['height']
|
||||
|
||||
if 'tileWidth' in asset['options'] and 'columns' in asset['options']:
|
||||
tileWidth = int(asset['options']['tileWidth'])
|
||||
columns = int(asset['options']['columns'])
|
||||
originalWidth = tileWidth * columns
|
||||
elif 'tileWidth' in asset['options']:
|
||||
tileWidth = int(asset['options']['tileWidth'])
|
||||
columns = image['width'] // tileWidth
|
||||
elif 'columns' in asset['options']:
|
||||
columns = int(asset['options']['columns'])
|
||||
tileWidth = image['width'] // columns
|
||||
else:
|
||||
print(f"Error: Tileset {asset['path']} must specify either tileWidth or columns")
|
||||
sys.exit(1)
|
||||
|
||||
if 'tileHeight' in asset['options'] and 'rows' in asset['options']:
|
||||
tileHeight = int(asset['options']['tileHeight'])
|
||||
rows = int(asset['options']['rows'])
|
||||
originalHeight = tileHeight * rows
|
||||
elif 'tileHeight' in asset['options']:
|
||||
tileHeight = int(asset['options']['tileHeight'])
|
||||
rows = image['height'] // tileHeight
|
||||
elif 'rows' in asset['options']:
|
||||
rows = int(asset['options']['rows'])
|
||||
tileHeight = image['height'] // rows
|
||||
else:
|
||||
print(f"Error: Tileset {asset['path']} must specify either tileHeight or rows")
|
||||
sys.exit(1)
|
||||
|
||||
return {
|
||||
"image": image,
|
||||
"tileWidth": tileWidth,
|
||||
"tileHeight": tileHeight,
|
||||
"columns": columns,
|
||||
"rows": rows,
|
||||
"originalWidth": originalWidth,
|
||||
"originalHeight": originalHeight,
|
||||
}
|
||||
|
||||
def processTileset(asset):
|
||||
cache = assetGetCache(asset['path'])
|
||||
if cache is not None:
|
||||
return cache
|
||||
|
||||
print(f"Processing tileset: {asset['path']}")
|
||||
tilesetData = None
|
||||
if asset['path'].endswith('.tsx'):
|
||||
tilesetData = loadTilesetFromTSX(asset)
|
||||
else:
|
||||
tilesetData = loadTilesetFromArgs(asset)
|
||||
|
||||
fileNameWithoutExtension = os.path.splitext(os.path.basename(asset['path']))[0]
|
||||
now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
|
||||
tilesetName = fileNameWithoutExtension
|
||||
tilesetNameUpper = tilesetName.upper()
|
||||
|
||||
widthScale = tilesetData['originalWidth'] / tilesetData['image']['width']
|
||||
heightScale = tilesetData['originalHeight'] / tilesetData['image']['height']
|
||||
|
||||
# Create header
|
||||
data = f"// Tileset Generated for {asset['path']} at {now}\n"
|
||||
data += f"#pragma once\n"
|
||||
data += f"#include \"display/tileset/tileset.h\"\n\n"
|
||||
data += f"static const tileset_t TILESET_{tilesetNameUpper} = {{\n"
|
||||
data += f" .name = {json.dumps(tilesetName)},\n"
|
||||
data += f" .tileWidth = {tilesetData['tileWidth']},\n"
|
||||
data += f" .tileHeight = {tilesetData['tileHeight']},\n"
|
||||
data += f" .tileCount = {tilesetData['columns'] * tilesetData['rows']},\n"
|
||||
data += f" .columns = {tilesetData['columns']},\n"
|
||||
data += f" .rows = {tilesetData['rows']},\n"
|
||||
data += f" .uv = {{ {widthScale / tilesetData['columns']}f, {heightScale / tilesetData['rows']}f }},\n"
|
||||
data += f" .image = {json.dumps(tilesetData['image']['imagePath'])},\n"
|
||||
data += f"}};\n"
|
||||
|
||||
|
||||
# Write Header
|
||||
outputFile = os.path.join(args.headers_dir, "display", "tileset", f"tileset_{tilesetName}.h")
|
||||
os.makedirs(os.path.dirname(outputFile), exist_ok=True)
|
||||
with open(outputFile, 'w') as f:
|
||||
f.write(data)
|
||||
|
||||
print(f"Write header for tileset: {outputFile}")
|
||||
|
||||
tileset = {
|
||||
"files": [],
|
||||
"image": tilesetData['image'],
|
||||
"headerFile": os.path.relpath(outputFile, args.headers_dir),
|
||||
"tilesetName": tilesetName,
|
||||
"tilesetNameUpper": tilesetNameUpper,
|
||||
"tilesetIndex": len(tilesets),
|
||||
"tilesetData": tilesetData,
|
||||
"files": tilesetData['image']['files'],
|
||||
}
|
||||
|
||||
tilesets.append(tileset)
|
||||
return assetCache(asset['path'], tileset)
|
||||
|
||||
def processTilesetList():
|
||||
data = f"// Tileset List Generated at {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n"
|
||||
data += f"#pragma once\n"
|
||||
for tileset in tilesets:
|
||||
data += f"#include \"{tileset['headerFile']}\"\n"
|
||||
data += f"\n"
|
||||
data += f"#define TILESET_LIST_COUNT {len(tilesets)}\n\n"
|
||||
data += f"static const tileset_t* TILESET_LIST[TILESET_LIST_COUNT] = {{\n"
|
||||
for tileset in tilesets:
|
||||
data += f" &TILESET_{tileset['tilesetNameUpper']},\n"
|
||||
data += f"}};\n"
|
||||
|
||||
# Write header.
|
||||
outputFile = os.path.join(args.headers_dir, "display", "tileset", f"tilesetlist.h")
|
||||
os.makedirs(os.path.dirname(outputFile), exist_ok=True)
|
||||
with open(outputFile, 'w') as f:
|
||||
f.write(data)
|
||||
@@ -1,7 +1,6 @@
|
||||
import argparse
|
||||
import os
|
||||
import csv
|
||||
from tools.util.type import detectType, stringToCType, typeToCType
|
||||
|
||||
parser = argparse.ArgumentParser(description="Color CSV to .h defines")
|
||||
parser.add_argument("--csv", required=True, help="Path to color CSV file")
|
||||
|
||||
@@ -1,158 +0,0 @@
|
||||
import json
|
||||
import os
|
||||
from tools.dusk.event import Event
|
||||
from tools.dusk.defs import CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, CHUNK_VERTEX_COUNT_MAX, TILE_SHAPE_NULL
|
||||
from tools.dusk.tile import Tile
|
||||
from tools.dusk.entity import Entity
|
||||
from tools.dusk.region import Region
|
||||
from tools.editor.map.vertexbuffer import VertexBuffer
|
||||
from OpenGL.GL import *
|
||||
|
||||
class Chunk:
|
||||
def __init__(self, map, x, y, z):
|
||||
self.map = map
|
||||
self.x = x
|
||||
self.y = y
|
||||
self.z = z
|
||||
self.current = {}
|
||||
self.original = {}
|
||||
self.entities = {}
|
||||
self.regions = {}
|
||||
self.onChunkData = Event()
|
||||
self.dirty = False
|
||||
|
||||
self.tiles = {}
|
||||
self.vertexBuffer = VertexBuffer()
|
||||
|
||||
# Test Region
|
||||
region = self.regions[0] = Region(self)
|
||||
region.minX = 0
|
||||
region.minY = 0
|
||||
region.minZ = 0
|
||||
region.maxX = 32
|
||||
region.maxY = 32
|
||||
region.maxZ = 32
|
||||
region.updateVertexs()
|
||||
|
||||
# Gen tiles.
|
||||
tileIndex = 0
|
||||
for tz in range(CHUNK_DEPTH):
|
||||
for ty in range(CHUNK_HEIGHT):
|
||||
for tx in range(CHUNK_WIDTH):
|
||||
self.tiles[tileIndex] = Tile(self, tx, ty, tz, tileIndex)
|
||||
tileIndex += 1
|
||||
|
||||
# Update vertices
|
||||
self.tileUpdateVertices()
|
||||
|
||||
def reload(self, newX, newY, newZ):
|
||||
self.x = newX
|
||||
self.y = newY
|
||||
self.z = newZ
|
||||
self.entities = {}
|
||||
for tile in self.tiles.values():
|
||||
tile.chunkReload(newX, newY, newZ)
|
||||
self.load()
|
||||
|
||||
def tileUpdateVertices(self):
|
||||
self.vertexBuffer.clear()
|
||||
for tile in self.tiles.values():
|
||||
tile.buffer(self.vertexBuffer)
|
||||
self.vertexBuffer.buildData()
|
||||
|
||||
def load(self):
|
||||
fname = self.getFilename()
|
||||
if not fname or not os.path.exists(fname):
|
||||
self.new()
|
||||
return
|
||||
try:
|
||||
with open(fname, 'r') as f:
|
||||
data = json.load(f)
|
||||
|
||||
if not 'shapes' in data:
|
||||
data['shapes'] = []
|
||||
|
||||
# For each tile.
|
||||
for tile in self.tiles.values():
|
||||
tile.load(data)
|
||||
|
||||
# For each entity.
|
||||
self.entities = {}
|
||||
if 'entities' in data:
|
||||
for id, entData in enumerate(data['entities']):
|
||||
ent = Entity(self)
|
||||
ent.load(entData)
|
||||
self.entities[id] = ent
|
||||
|
||||
self.tileUpdateVertices()
|
||||
self.dirty = False
|
||||
self.onChunkData.invoke(self)
|
||||
self.map.onEntityData.invoke()
|
||||
except Exception as e:
|
||||
raise RuntimeError(f"Failed to load chunk file: {e}")
|
||||
|
||||
def save(self):
|
||||
if not self.isDirty():
|
||||
return
|
||||
|
||||
dataOut = {
|
||||
'shapes': [],
|
||||
'entities': []
|
||||
}
|
||||
|
||||
for tile in self.tiles.values():
|
||||
dataOut['shapes'].append(tile.shape)
|
||||
|
||||
for ent in self.entities.values():
|
||||
entData = {}
|
||||
ent.save(entData)
|
||||
dataOut['entities'].append(entData)
|
||||
|
||||
fname = self.getFilename()
|
||||
if not fname:
|
||||
raise ValueError("No filename specified for saving chunk.")
|
||||
try:
|
||||
with open(fname, 'w') as f:
|
||||
json.dump(dataOut, f)
|
||||
self.dirty = False
|
||||
self.onChunkData.invoke(self)
|
||||
except Exception as e:
|
||||
raise RuntimeError(f"Failed to save chunk file: {e}")
|
||||
|
||||
def new(self):
|
||||
for tile in self.tiles.values():
|
||||
tile.shape = TILE_SHAPE_NULL
|
||||
|
||||
self.tileUpdateVertices()
|
||||
self.dirty = False
|
||||
self.onChunkData.invoke(self)
|
||||
|
||||
def isDirty(self):
|
||||
return self.dirty
|
||||
|
||||
def getFilename(self):
|
||||
if not self.map or not hasattr(self.map, 'getChunkDirectory'):
|
||||
return None
|
||||
dirPath = self.map.getChunkDirectory()
|
||||
if dirPath is None:
|
||||
return None
|
||||
return f"{dirPath}/{self.x}_{self.y}_{self.z}.json"
|
||||
|
||||
def draw(self):
|
||||
self.vertexBuffer.draw()
|
||||
|
||||
def addEntity(self, localX=0, localY=0, localZ=0):
|
||||
ent = Entity(self, localX, localY, localZ)
|
||||
self.entities[len(self.entities)] = ent
|
||||
self.map.onEntityData.invoke()
|
||||
self.dirty = True
|
||||
return ent
|
||||
|
||||
def removeEntity(self, entity):
|
||||
for key, val in list(self.entities.items()):
|
||||
if val == entity:
|
||||
del self.entities[key]
|
||||
self.map.onEntityData.invoke()
|
||||
self.dirty = True
|
||||
return True
|
||||
return False
|
||||
@@ -1,49 +0,0 @@
|
||||
from dotenv import load_dotenv, dotenv_values
|
||||
import os
|
||||
import sys
|
||||
|
||||
current_file_path = os.path.abspath(__file__)
|
||||
duskDefsPath = os.path.join(os.path.dirname(current_file_path), "..", "..", "src", "duskdefs.env")
|
||||
|
||||
# Ensure the .env file exists
|
||||
if not os.path.isfile(duskDefsPath):
|
||||
print(f"Error: .env file not found at {duskDefsPath}")
|
||||
sys.exit(1)
|
||||
|
||||
load_dotenv(dotenv_path=duskDefsPath)
|
||||
defs = {key: os.getenv(key) for key in os.environ.keys()}
|
||||
|
||||
fileDefs = dotenv_values(dotenv_path=duskDefsPath)
|
||||
|
||||
# Parsed out definitions
|
||||
CHUNK_WIDTH = int(defs.get('CHUNK_WIDTH'))
|
||||
CHUNK_HEIGHT = int(defs.get('CHUNK_HEIGHT'))
|
||||
CHUNK_DEPTH = int(defs.get('CHUNK_DEPTH'))
|
||||
CHUNK_TILE_COUNT = CHUNK_WIDTH * CHUNK_HEIGHT * CHUNK_DEPTH
|
||||
CHUNK_VERTEX_COUNT_MAX = int(defs.get('CHUNK_VERTEX_COUNT_MAX'))
|
||||
|
||||
TILE_WIDTH = float(defs.get('TILE_WIDTH'))
|
||||
TILE_HEIGHT = float(defs.get('TILE_HEIGHT'))
|
||||
TILE_DEPTH = float(defs.get('TILE_DEPTH'))
|
||||
|
||||
RPG_CAMERA_PIXELS_PER_UNIT = float(defs.get('RPG_CAMERA_PIXELS_PER_UNIT'))
|
||||
RPG_CAMERA_Z_OFFSET = float(defs.get('RPG_CAMERA_Z_OFFSET'))
|
||||
RPG_CAMERA_FOV = float(defs.get('RPG_CAMERA_FOV'))
|
||||
|
||||
MAP_WIDTH = 5
|
||||
MAP_HEIGHT = 5
|
||||
MAP_DEPTH = 3
|
||||
MAP_CHUNK_COUNT = MAP_WIDTH * MAP_HEIGHT * MAP_DEPTH
|
||||
|
||||
TILE_SHAPES = {}
|
||||
for key in defs.keys():
|
||||
if key.startswith('TILE_SHAPE_'):
|
||||
globals()[key] = int(defs.get(key))
|
||||
TILE_SHAPES[key] = int(defs.get(key))
|
||||
|
||||
ENTITY_TYPES = {}
|
||||
for key in defs.keys():
|
||||
if key.startswith('ENTITY_TYPE_'):
|
||||
globals()[key] = int(defs.get(key))
|
||||
if key != 'ENTITY_TYPE_COUNT':
|
||||
ENTITY_TYPES[key] = int(defs.get(key))
|
||||
@@ -1,90 +0,0 @@
|
||||
from tools.dusk.defs import ENTITY_TYPE_NULL, ENTITY_TYPE_NPC, CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, TILE_WIDTH, TILE_HEIGHT, TILE_DEPTH
|
||||
from tools.editor.map.vertexbuffer import VertexBuffer
|
||||
|
||||
class Entity:
|
||||
def __init__(self, chunk, localX=0, localY=0, localZ=0):
|
||||
self.type = ENTITY_TYPE_NPC
|
||||
self.name = "Unititled"
|
||||
self.localX = localX % CHUNK_WIDTH
|
||||
self.localY = localY % CHUNK_HEIGHT
|
||||
self.localZ = localZ % CHUNK_DEPTH
|
||||
|
||||
self.chunk = chunk
|
||||
self.vertexBuffer = VertexBuffer()
|
||||
pass
|
||||
|
||||
def load(self, obj):
|
||||
self.type = obj.get('type', ENTITY_TYPE_NULL)
|
||||
self.localX = obj.get('x', 0)
|
||||
self.localY = obj.get('y', 0)
|
||||
self.localZ = obj.get('z', 0)
|
||||
self.name = obj.get('name', "Untitled")
|
||||
pass
|
||||
|
||||
def save(self, obj):
|
||||
obj['type'] = self.type
|
||||
obj['name'] = self.name
|
||||
obj['x'] = self.localX
|
||||
obj['y'] = self.localY
|
||||
obj['z'] = self.localZ
|
||||
pass
|
||||
|
||||
def setType(self, entityType):
|
||||
if self.type == entityType:
|
||||
return
|
||||
self.type = entityType
|
||||
self.chunk.dirty = True
|
||||
self.chunk.map.onEntityData.invoke()
|
||||
|
||||
def setName(self, name):
|
||||
if self.name == name:
|
||||
return
|
||||
self.name = name
|
||||
self.chunk.dirty = True
|
||||
self.chunk.map.onEntityData.invoke()
|
||||
|
||||
def draw(self):
|
||||
self.vertexBuffer.clear()
|
||||
|
||||
startX = (self.chunk.x * CHUNK_WIDTH + self.localX) * TILE_WIDTH
|
||||
startY = (self.chunk.y * CHUNK_HEIGHT + self.localY) * TILE_HEIGHT
|
||||
startZ = (self.chunk.z * CHUNK_DEPTH + self.localZ) * TILE_DEPTH
|
||||
w = TILE_WIDTH
|
||||
h = TILE_HEIGHT
|
||||
d = TILE_DEPTH
|
||||
|
||||
# Center
|
||||
startX -= w / 2
|
||||
startY -= h / 2
|
||||
startZ -= d / 2
|
||||
|
||||
# Offset upwards a little
|
||||
startZ += 1
|
||||
|
||||
# Buffer simple quad at current position (need 6 positions)
|
||||
self.vertexBuffer.vertices = [
|
||||
startX, startY, startZ,
|
||||
startX + w, startY, startZ,
|
||||
startX + w, startY + h, startZ,
|
||||
startX, startY, startZ,
|
||||
startX + w, startY + h, startZ,
|
||||
startX, startY + h, startZ,
|
||||
]
|
||||
self.vertexBuffer.colors = [
|
||||
1.0, 0.0, 1.0, 1.0,
|
||||
1.0, 0.0, 1.0, 1.0,
|
||||
1.0, 0.0, 1.0, 1.0,
|
||||
1.0, 0.0, 1.0, 1.0,
|
||||
1.0, 0.0, 1.0, 1.0,
|
||||
1.0, 0.0, 1.0, 1.0,
|
||||
]
|
||||
self.vertexBuffer.uvs = [
|
||||
0.0, 0.0,
|
||||
1.0, 0.0,
|
||||
1.0, 1.0,
|
||||
0.0, 0.0,
|
||||
1.0, 1.0,
|
||||
0.0, 1.0,
|
||||
]
|
||||
self.vertexBuffer.buildData()
|
||||
self.vertexBuffer.draw()
|
||||
@@ -1,18 +0,0 @@
|
||||
class Event:
|
||||
def __init__(self):
|
||||
self._subscribers = []
|
||||
|
||||
def sub(self, callback):
|
||||
"""Subscribe a callback to the event."""
|
||||
if callback not in self._subscribers:
|
||||
self._subscribers.append(callback)
|
||||
|
||||
def unsub(self, callback):
|
||||
"""Unsubscribe a callback from the event."""
|
||||
if callback in self._subscribers:
|
||||
self._subscribers.remove(callback)
|
||||
|
||||
def invoke(self, *args, **kwargs):
|
||||
"""Invoke all subscribers with the given arguments."""
|
||||
for callback in self._subscribers:
|
||||
callback(*args, **kwargs)
|
||||
@@ -1,259 +0,0 @@
|
||||
import json
|
||||
import sys
|
||||
from tools.dusk.event import Event
|
||||
from PyQt5.QtWidgets import QFileDialog, QMessageBox
|
||||
from PyQt5.QtCore import QTimer
|
||||
import os
|
||||
from tools.dusk.chunk import Chunk
|
||||
from tools.dusk.defs import MAP_WIDTH, MAP_HEIGHT, MAP_DEPTH, CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH
|
||||
import traceback
|
||||
|
||||
MAP_DEFAULT_PATH = os.path.join(os.path.dirname(__file__), '../../assets/map/')
|
||||
EDITOR_CONFIG_PATH = os.path.join(os.path.dirname(__file__), '.editor')
|
||||
|
||||
class Map:
|
||||
def __init__(self, parent):
|
||||
self.parent = parent
|
||||
self.data = {}
|
||||
self.dataOriginal = {}
|
||||
self.position = [None, None, None] # x, y, z
|
||||
self.topLeftX = None
|
||||
self.topLeftY = None
|
||||
self.topLeftZ = None
|
||||
self.chunks = {}
|
||||
self.onMapData = Event()
|
||||
self.onPositionChange = Event()
|
||||
self.onEntityData = Event()
|
||||
self.mapFileName = None
|
||||
self.lastFile = None
|
||||
self.firstLoad = True
|
||||
|
||||
index = 0
|
||||
for x in range(MAP_WIDTH):
|
||||
for y in range(MAP_HEIGHT):
|
||||
for z in range(MAP_DEPTH):
|
||||
self.chunks[index] = Chunk(self, x, y, z)
|
||||
index += 1
|
||||
|
||||
# Only in editor instances:
|
||||
self.moveTo(0, 0, 0)
|
||||
if parent is not None:
|
||||
QTimer.singleShot(16, self.loadLastFile)
|
||||
|
||||
def loadLastFile(self):
|
||||
if not os.path.exists(EDITOR_CONFIG_PATH):
|
||||
return
|
||||
try:
|
||||
with open(EDITOR_CONFIG_PATH, 'r') as f:
|
||||
config = json.load(f)
|
||||
lastFile = config.get('lastFile')
|
||||
lastPosition = config.get('lastPosition')
|
||||
leftPanelIndex = config.get('leftPanelIndex')
|
||||
if lastFile and os.path.exists(lastFile):
|
||||
self.load(lastFile)
|
||||
if lastPosition and isinstance(lastPosition, list) and len(lastPosition) == 3:
|
||||
self.moveTo(*lastPosition)
|
||||
if leftPanelIndex is not None:
|
||||
self.parent.leftPanel.tabs.setCurrentIndex(leftPanelIndex)
|
||||
except Exception:
|
||||
traceback.print_exc()
|
||||
|
||||
def updateEditorConfig(self):
|
||||
if self.parent is None:
|
||||
return
|
||||
try:
|
||||
mapFileName = self.getMapFilename()
|
||||
config = {
|
||||
'lastFile': mapFileName if mapFileName else "",
|
||||
'lastPosition': self.position,
|
||||
'leftPanelIndex': self.parent.leftPanel.tabs.currentIndex()
|
||||
}
|
||||
config_dir = os.path.dirname(EDITOR_CONFIG_PATH)
|
||||
if not os.path.exists(config_dir):
|
||||
os.makedirs(config_dir, exist_ok=True)
|
||||
with open(EDITOR_CONFIG_PATH, 'w') as f:
|
||||
json.dump(config, f, indent=2)
|
||||
except Exception:
|
||||
traceback.print_exc()
|
||||
|
||||
def newFile(self):
|
||||
self.data = {}
|
||||
self.dataOriginal = {}
|
||||
self.mapFileName = None
|
||||
self.lastFile = None
|
||||
for chunk in self.chunks.values():
|
||||
chunk.new()
|
||||
self.moveTo(0, 0, 0)
|
||||
self.onMapData.invoke(self.data)
|
||||
self.updateEditorConfig()
|
||||
|
||||
def save(self, fname=None):
|
||||
if not self.getMapFilename() and fname is None:
|
||||
filePath, _ = QFileDialog.getSaveFileName(None, "Save Map File", MAP_DEFAULT_PATH, "Map Files (*.json)")
|
||||
if not filePath:
|
||||
return
|
||||
self.mapFileName = filePath
|
||||
if fname:
|
||||
self.mapFileName = fname
|
||||
try:
|
||||
with open(self.getMapFilename(), 'w') as f:
|
||||
json.dump(self.data, f, indent=2)
|
||||
self.dataOriginal = json.loads(json.dumps(self.data)) # Deep copy
|
||||
for chunk in self.chunks.values():
|
||||
chunk.save()
|
||||
self.updateEditorConfig()
|
||||
except Exception as e:
|
||||
traceback.print_exc()
|
||||
QMessageBox.critical(None, "Save Error", f"Failed to save map file:\n{e}")
|
||||
|
||||
def load(self, fileName):
|
||||
try:
|
||||
with open(fileName, 'r') as f:
|
||||
self.data = json.load(f)
|
||||
self.mapFileName = fileName
|
||||
self.dataOriginal = json.loads(json.dumps(self.data)) # Deep copy
|
||||
for chunk in self.chunks.values():
|
||||
chunk.load()
|
||||
self.onMapData.invoke(self.data)
|
||||
self.updateEditorConfig()
|
||||
except Exception as e:
|
||||
traceback.print_exc()
|
||||
QMessageBox.critical(None, "Load Error", f"Failed to load map file:\n{e}")
|
||||
|
||||
def isMapFileDirty(self):
|
||||
return json.dumps(self.data, sort_keys=True) != json.dumps(self.dataOriginal, sort_keys=True)
|
||||
|
||||
def isDirty(self):
|
||||
return self.isMapFileDirty() or self.anyChunksDirty()
|
||||
|
||||
def getMapFilename(self):
|
||||
return self.mapFileName if self.mapFileName and os.path.exists(self.mapFileName) else None
|
||||
|
||||
def getMapDirectory(self):
|
||||
if self.mapFileName is None:
|
||||
return None
|
||||
dirname = os.path.dirname(self.mapFileName)
|
||||
return dirname
|
||||
|
||||
def getChunkDirectory(self):
|
||||
dirName = self.getMapDirectory()
|
||||
if dirName is None:
|
||||
return None
|
||||
return os.path.join(dirName, 'chunks')
|
||||
|
||||
def anyChunksDirty(self):
|
||||
for chunk in self.chunks.values():
|
||||
if chunk.isDirty():
|
||||
return True
|
||||
return False
|
||||
|
||||
def moveTo(self, x, y, z):
|
||||
if self.position == [x, y, z]:
|
||||
return
|
||||
|
||||
# We need to decide if the chunks should be unloaded here or not.
|
||||
newTopLeftChunkX = x // CHUNK_WIDTH - (MAP_WIDTH // 2)
|
||||
newTopLeftChunkY = y // CHUNK_HEIGHT - (MAP_HEIGHT // 2)
|
||||
newTopLeftChunkZ = z // CHUNK_DEPTH - (MAP_DEPTH // 2)
|
||||
|
||||
if (newTopLeftChunkX != self.topLeftX or
|
||||
newTopLeftChunkY != self.topLeftY or
|
||||
newTopLeftChunkZ != self.topLeftZ):
|
||||
|
||||
chunksToUnload = []
|
||||
chunksToKeep = []
|
||||
for chunk in self.chunks.values():
|
||||
chunkWorldX = chunk.x
|
||||
chunkWorldY = chunk.y
|
||||
chunkWorldZ = chunk.z
|
||||
if (chunkWorldX < newTopLeftChunkX or
|
||||
chunkWorldX >= newTopLeftChunkX + MAP_WIDTH or
|
||||
chunkWorldY < newTopLeftChunkY or
|
||||
chunkWorldY >= newTopLeftChunkY + MAP_HEIGHT or
|
||||
chunkWorldZ < newTopLeftChunkZ or
|
||||
chunkWorldZ >= newTopLeftChunkZ + MAP_DEPTH):
|
||||
chunksToUnload.append(chunk)
|
||||
else:
|
||||
chunksToKeep.append(chunk)
|
||||
|
||||
# Unload chunks that are out of the new bounds.
|
||||
for chunk in chunksToUnload:
|
||||
if chunk.isDirty():
|
||||
print(f"Can't move map, some chunks are dirty: ({chunk.x}, {chunk.y}, {chunk.z})")
|
||||
return
|
||||
|
||||
# Now we can safely unload the chunks.
|
||||
chunkIndex = 0
|
||||
newChunks = {}
|
||||
for chunk in chunksToKeep:
|
||||
newChunks[chunkIndex] = chunk
|
||||
chunkIndex += 1
|
||||
|
||||
for xPos in range(newTopLeftChunkX, newTopLeftChunkX + MAP_WIDTH):
|
||||
for yPos in range(newTopLeftChunkY, newTopLeftChunkY + MAP_HEIGHT):
|
||||
for zPos in range(newTopLeftChunkZ, newTopLeftChunkZ + MAP_DEPTH):
|
||||
# Check if we already have this chunk.
|
||||
found = False
|
||||
for chunk in chunksToKeep:
|
||||
if chunk.x == xPos and chunk.y == yPos and chunk.z == zPos:
|
||||
found = True
|
||||
break
|
||||
if not found:
|
||||
# Create a new chunk.
|
||||
newChunk = chunksToUnload.pop()
|
||||
newChunk.reload(xPos, yPos, zPos)
|
||||
newChunks[chunkIndex] = newChunk
|
||||
chunkIndex += 1
|
||||
|
||||
self.chunks = newChunks
|
||||
self.topLeftX = newTopLeftChunkX
|
||||
self.topLeftY = newTopLeftChunkY
|
||||
self.topLeftZ = newTopLeftChunkZ
|
||||
|
||||
self.position = [x, y, z]
|
||||
self.onPositionChange.invoke(self.position)
|
||||
if not self.firstLoad:
|
||||
self.updateEditorConfig()
|
||||
self.firstLoad = False
|
||||
|
||||
def moveRelative(self, x, y, z):
|
||||
self.moveTo(
|
||||
self.position[0] + x,
|
||||
self.position[1] + y,
|
||||
self.position[2] + z
|
||||
)
|
||||
|
||||
def draw(self):
|
||||
for chunk in self.chunks.values():
|
||||
chunk.draw()
|
||||
|
||||
for chunk in self.chunks.values():
|
||||
for entity in chunk.entities.values():
|
||||
entity.draw()
|
||||
|
||||
# Only render on Region tab
|
||||
if self.parent.leftPanel.tabs.currentWidget() == self.parent.leftPanel.regionPanel:
|
||||
for chunk in self.chunks.values():
|
||||
for region in chunk.regions.values():
|
||||
region.draw()
|
||||
|
||||
def getChunkAtWorldPos(self, x, y, z):
|
||||
chunkX = x // CHUNK_WIDTH
|
||||
chunkY = y // CHUNK_HEIGHT
|
||||
chunkZ = z // CHUNK_DEPTH
|
||||
for chunk in self.chunks.values():
|
||||
if chunk.x == chunkX and chunk.y == chunkY and chunk.z == chunkZ:
|
||||
return chunk
|
||||
return None
|
||||
|
||||
def getTileAtWorldPos(self, x, y, z):
|
||||
chunk = self.getChunkAtWorldPos(x, y, z)
|
||||
if not chunk:
|
||||
print("No chunk found at position:", (x, y, z))
|
||||
return None
|
||||
|
||||
tileX = x % CHUNK_WIDTH
|
||||
tileY = y % CHUNK_HEIGHT
|
||||
tileZ = z % CHUNK_DEPTH
|
||||
tileIndex = tileX + tileY * CHUNK_WIDTH + tileZ * CHUNK_WIDTH * CHUNK_HEIGHT
|
||||
return chunk.tiles.get(tileIndex)
|
||||
@@ -1,141 +0,0 @@
|
||||
from tools.dusk.defs import CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, TILE_WIDTH, TILE_HEIGHT, TILE_DEPTH
|
||||
from tools.editor.map.vertexbuffer import VertexBuffer
|
||||
from OpenGL.GL import *
|
||||
from OpenGL.GLU import *
|
||||
|
||||
class Region:
|
||||
def __init__(self, chunk):
|
||||
self.minX = 0
|
||||
self.minY = 0
|
||||
self.minZ = 0
|
||||
self.maxX = 0
|
||||
self.maxY = 0
|
||||
self.maxZ = 0
|
||||
self.chunk = chunk
|
||||
self.vertexBuffer = VertexBuffer()
|
||||
self.color = (1.0, 0.0, 0.0)
|
||||
self.updateVertexs()
|
||||
pass
|
||||
|
||||
def updateVertexs(self):
|
||||
# Draw a quad, semi transparent with solid outlines
|
||||
vminX = (self.minX * CHUNK_WIDTH) * TILE_WIDTH
|
||||
vminY = (self.minY * CHUNK_HEIGHT) * TILE_HEIGHT
|
||||
vminZ = (self.minZ * CHUNK_DEPTH) * TILE_DEPTH
|
||||
vmaxX = (self.maxX * CHUNK_WIDTH) * TILE_WIDTH
|
||||
vmaxY = (self.maxY * CHUNK_HEIGHT) * TILE_HEIGHT
|
||||
vmaxZ = (self.maxZ * CHUNK_DEPTH) * TILE_DEPTH
|
||||
alpha = 0.25
|
||||
|
||||
# Move back half a tile width
|
||||
vminX -= TILE_WIDTH / 2
|
||||
vmaxX -= TILE_WIDTH / 2
|
||||
vminY -= TILE_HEIGHT / 2
|
||||
vmaxY -= TILE_HEIGHT / 2
|
||||
vminZ -= TILE_DEPTH / 2
|
||||
vmaxZ -= TILE_DEPTH / 2
|
||||
|
||||
# Cube (6 verts per face)
|
||||
self.vertexBuffer.vertices = [
|
||||
# Front face
|
||||
vminX, vminY, vmaxZ,
|
||||
vmaxX, vminY, vmaxZ,
|
||||
vmaxX, vmaxY, vmaxZ,
|
||||
vminX, vminY, vmaxZ,
|
||||
vmaxX, vmaxY, vmaxZ,
|
||||
vminX, vmaxY, vmaxZ,
|
||||
|
||||
# Back face
|
||||
vmaxX, vminY, vminZ,
|
||||
vminX, vminY, vminZ,
|
||||
vminX, vmaxY, vminZ,
|
||||
vmaxX, vminY, vminZ,
|
||||
vminX, vmaxY, vminZ,
|
||||
vmaxX, vmaxY, vminZ,
|
||||
|
||||
# Left face
|
||||
vminX, vminY, vminZ,
|
||||
vminX, vminY, vmaxZ,
|
||||
vminX, vmaxY, vmaxZ,
|
||||
vminX, vminY, vminZ,
|
||||
vminX, vmaxY, vmaxZ,
|
||||
vminX, vmaxY, vminZ,
|
||||
|
||||
# Right face
|
||||
vmaxX, vminY, vmaxZ,
|
||||
vmaxX, vminY, vminZ,
|
||||
vmaxX, vmaxY, vminZ,
|
||||
vmaxX, vminY, vmaxZ,
|
||||
vmaxX, vmaxY, vminZ,
|
||||
vmaxX, vmaxY, vmaxZ,
|
||||
|
||||
# Top face
|
||||
vminX, vmaxY, vmaxZ,
|
||||
vmaxX, vmaxY, vmaxZ,
|
||||
vmaxX, vmaxY, vminZ,
|
||||
vminX, vmaxY, vmaxZ,
|
||||
vmaxX, vmaxY, vminZ,
|
||||
vminX, vmaxY, vminZ,
|
||||
|
||||
# Bottom face
|
||||
vminX, vminY, vminZ,
|
||||
vmaxX, vminY, vminZ,
|
||||
vmaxX, vminY, vmaxZ,
|
||||
vminX, vminY, vminZ,
|
||||
vmaxX, vminY, vmaxZ,
|
||||
vminX, vminY, vmaxZ,
|
||||
]
|
||||
|
||||
self.vertexBuffer.colors = [
|
||||
# Front face
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
|
||||
# Back face
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
|
||||
# Left face
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
|
||||
# Right face
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
|
||||
# Top face
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
|
||||
# Bottom face
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
self.color[0], self.color[1], self.color[2], alpha,
|
||||
]
|
||||
self.vertexBuffer.buildData()
|
||||
|
||||
def draw(self):
|
||||
self.vertexBuffer.draw()
|
||||
@@ -1,206 +0,0 @@
|
||||
from OpenGL.GL import *
|
||||
from tools.dusk.defs import (
|
||||
TILE_WIDTH, TILE_HEIGHT, TILE_DEPTH,
|
||||
CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH,
|
||||
TILE_SHAPE_NULL, TILE_SHAPE_FLOOR,
|
||||
TILE_SHAPE_RAMP_NORTH, TILE_SHAPE_RAMP_SOUTH,
|
||||
TILE_SHAPE_RAMP_EAST, TILE_SHAPE_RAMP_WEST,
|
||||
TILE_SHAPE_RAMP_SOUTHWEST, TILE_SHAPE_RAMP_SOUTHEAST,
|
||||
TILE_SHAPE_RAMP_NORTHWEST, TILE_SHAPE_RAMP_NORTHEAST
|
||||
)
|
||||
|
||||
def getItem(arr, index, default):
|
||||
if index < len(arr):
|
||||
return arr[index]
|
||||
return default
|
||||
|
||||
class Tile:
|
||||
def __init__(self, chunk, x, y, z, tileIndex):
|
||||
self.shape = TILE_SHAPE_NULL
|
||||
|
||||
self.chunk = chunk
|
||||
self.x = x
|
||||
self.y = y
|
||||
self.z = z
|
||||
self.index = tileIndex
|
||||
|
||||
self.posX = x * TILE_WIDTH + chunk.x * CHUNK_WIDTH * TILE_WIDTH
|
||||
self.posY = y * TILE_HEIGHT + chunk.y * CHUNK_HEIGHT * TILE_HEIGHT
|
||||
self.posZ = z * TILE_DEPTH + chunk.z * CHUNK_DEPTH * TILE_DEPTH
|
||||
|
||||
def chunkReload(self, newX, newY, newZ):
|
||||
self.posX = self.x * TILE_WIDTH + newX * CHUNK_WIDTH * TILE_WIDTH
|
||||
self.posY = self.y * TILE_HEIGHT + newY * CHUNK_HEIGHT * TILE_HEIGHT
|
||||
self.posZ = self.z * TILE_DEPTH + newZ * CHUNK_DEPTH * TILE_DEPTH
|
||||
|
||||
def load(self, chunkData):
|
||||
self.shape = getItem(chunkData['shapes'], self.index, TILE_SHAPE_NULL)
|
||||
|
||||
def setShape(self, shape):
|
||||
if shape == self.shape:
|
||||
return
|
||||
|
||||
self.shape = shape
|
||||
self.chunk.dirty = True
|
||||
self.chunk.tileUpdateVertices()
|
||||
self.chunk.onChunkData.invoke(self.chunk)
|
||||
|
||||
def getBaseTileModel(self):
|
||||
vertices = []
|
||||
indices = []
|
||||
uvs = []
|
||||
colors = []
|
||||
|
||||
if self.shape == TILE_SHAPE_NULL:
|
||||
pass
|
||||
|
||||
elif self.shape == TILE_SHAPE_FLOOR:
|
||||
vertices = [
|
||||
(self.posX, self.posY, self.posZ),
|
||||
(self.posX + TILE_WIDTH, self.posY, self.posZ),
|
||||
(self.posX + TILE_WIDTH, self.posY + TILE_HEIGHT, self.posZ),
|
||||
(self.posX, self.posY + TILE_HEIGHT, self.posZ)
|
||||
]
|
||||
indices = [0, 1, 2, 0, 2, 3]
|
||||
uvs = [ (0, 0), (1, 0), (1, 1), (0, 1) ]
|
||||
colors = [ (255, 255, 255, 255) ] * 4
|
||||
|
||||
elif self.shape == TILE_SHAPE_RAMP_NORTH:
|
||||
vertices = [
|
||||
(self.posX, self.posY, self.posZ + TILE_DEPTH),
|
||||
(self.posX + TILE_WIDTH, self.posY, self.posZ + TILE_DEPTH),
|
||||
(self.posX + TILE_WIDTH, self.posY + TILE_HEIGHT, self.posZ),
|
||||
(self.posX, self.posY + TILE_HEIGHT, self.posZ)
|
||||
]
|
||||
indices = [0, 1, 2, 0, 2, 3]
|
||||
uvs = [ (0, 0), (1, 0), (1, 1), (0, 1) ]
|
||||
colors = [ (255, 0, 0, 255) ] * 4
|
||||
|
||||
elif self.shape == TILE_SHAPE_RAMP_SOUTH:
|
||||
vertices = [
|
||||
(self.posX, self.posY, self.posZ),
|
||||
(self.posX + TILE_WIDTH, self.posY, self.posZ),
|
||||
(self.posX + TILE_WIDTH, self.posY + TILE_HEIGHT, self.posZ + TILE_DEPTH),
|
||||
(self.posX, self.posY + TILE_HEIGHT, self.posZ + TILE_DEPTH)
|
||||
]
|
||||
indices = [0, 1, 2, 0, 2, 3]
|
||||
uvs = [ (0, 0), (1, 0), (1, 1), (0, 1) ]
|
||||
colors = [ (0, 255, 0, 255) ] * 4
|
||||
|
||||
elif self.shape == TILE_SHAPE_RAMP_EAST:
|
||||
vertices = [
|
||||
(self.posX, self.posY, self.posZ),
|
||||
(self.posX + TILE_WIDTH, self.posY, self.posZ + TILE_DEPTH),
|
||||
(self.posX + TILE_WIDTH, self.posY + TILE_HEIGHT, self.posZ + TILE_DEPTH),
|
||||
(self.posX, self.posY + TILE_HEIGHT, self.posZ)
|
||||
]
|
||||
indices = [0, 1, 2, 0, 2, 3]
|
||||
uvs = [ (0, 0), (1, 0), (1, 1), (0, 1) ]
|
||||
colors = [ (0, 0, 255, 255) ] * 4
|
||||
|
||||
elif self.shape == TILE_SHAPE_RAMP_WEST:
|
||||
vertices = [
|
||||
(self.posX, self.posY, self.posZ + TILE_DEPTH),
|
||||
(self.posX + TILE_WIDTH, self.posY, self.posZ),
|
||||
(self.posX + TILE_WIDTH, self.posY + TILE_HEIGHT, self.posZ),
|
||||
(self.posX, self.posY + TILE_HEIGHT, self.posZ + TILE_DEPTH)
|
||||
]
|
||||
indices = [0, 1, 2, 0, 2, 3]
|
||||
uvs = [ (0, 0), (1, 0), (1, 1), (0, 1) ]
|
||||
colors = [ (255, 255, 0, 255) ] * 4
|
||||
|
||||
elif self.shape == TILE_SHAPE_RAMP_SOUTHWEST:
|
||||
vertices = [
|
||||
(self.posX, self.posY, self.posZ + TILE_DEPTH),
|
||||
(self.posX + TILE_WIDTH, self.posY, self.posZ),
|
||||
(self.posX + TILE_WIDTH, self.posY + TILE_HEIGHT, self.posZ + TILE_DEPTH),
|
||||
(self.posX, self.posY + TILE_HEIGHT, self.posZ + TILE_DEPTH)
|
||||
]
|
||||
indices = [0, 1, 2, 0, 2, 3]
|
||||
uvs = [ (0, 0), (1, 0), (1, 1), (0, 1) ]
|
||||
colors = [ (255, 128, 0, 255) ] * 4
|
||||
|
||||
elif self.shape == TILE_SHAPE_RAMP_NORTHWEST:
|
||||
vertices = [
|
||||
(self.posX, self.posY, self.posZ + TILE_DEPTH),
|
||||
(self.posX + TILE_WIDTH, self.posY, self.posZ + TILE_DEPTH),
|
||||
(self.posX + TILE_WIDTH, self.posY + TILE_HEIGHT, self.posZ),
|
||||
(self.posX, self.posY + TILE_HEIGHT, self.posZ + TILE_DEPTH)
|
||||
]
|
||||
indices = [0, 1, 2, 0, 2, 3]
|
||||
uvs = [ (0, 0), (1, 0), (1, 1), (0, 1) ]
|
||||
colors = [ (128, 255, 0, 255) ] * 4
|
||||
|
||||
elif self.shape == TILE_SHAPE_RAMP_NORTHEAST:
|
||||
vertices = [
|
||||
(self.posX, self.posY, self.posZ + TILE_DEPTH),
|
||||
(self.posX + TILE_WIDTH, self.posY, self.posZ + TILE_DEPTH),
|
||||
(self.posX + TILE_WIDTH, self.posY + TILE_HEIGHT, self.posZ + TILE_DEPTH),
|
||||
(self.posX, self.posY + TILE_HEIGHT, self.posZ)
|
||||
]
|
||||
indices = [0, 1, 2, 0, 2, 3]
|
||||
uvs = [ (0, 0), (1, 0), (1, 1), (0, 1) ]
|
||||
colors = [ (0, 255, 128, 255) ] * 4
|
||||
|
||||
elif self.shape == TILE_SHAPE_RAMP_SOUTHEAST:
|
||||
vertices = [
|
||||
(self.posX, self.posY, self.posZ),
|
||||
(self.posX + TILE_WIDTH, self.posY, self.posZ + TILE_DEPTH),
|
||||
(self.posX + TILE_WIDTH, self.posY + TILE_HEIGHT, self.posZ + TILE_DEPTH),
|
||||
(self.posX, self.posY + TILE_HEIGHT, self.posZ + TILE_DEPTH)
|
||||
]
|
||||
indices = [0, 1, 2, 0, 2, 3]
|
||||
uvs = [ (0, 0), (1, 0), (1, 1), (0, 1) ]
|
||||
colors = [ (255, 128, 255, 255) ] * 4
|
||||
|
||||
else:
|
||||
# Solid black cube for unknown shape
|
||||
x0, y0, z0 = self.posX, self.posY, self.posZ
|
||||
x1, y1, z1 = self.posX + TILE_WIDTH, self.posY + TILE_HEIGHT, self.posZ + TILE_DEPTH
|
||||
vertices = [
|
||||
(x0, y0, z0), (x1, y0, z0), (x1, y1, z0), (x0, y1, z0), # bottom
|
||||
(x0, y0, z1), (x1, y0, z1), (x1, y1, z1), (x0, y1, z1) # top
|
||||
]
|
||||
indices = [
|
||||
0,1,2, 0,2,3, # bottom
|
||||
4,5,6, 4,6,7, # top
|
||||
0,1,5, 0,5,4, # front
|
||||
2,3,7, 2,7,6, # back
|
||||
1,2,6, 1,6,5, # right
|
||||
3,0,4, 3,4,7 # left
|
||||
]
|
||||
uvs = [ (0,0) ] * 8
|
||||
colors = [ (0,0,0,255) ] * 8
|
||||
|
||||
return {
|
||||
'vertices': vertices,
|
||||
'indices': indices,
|
||||
'uvs': uvs,
|
||||
'colors': colors
|
||||
}
|
||||
|
||||
def buffer(self, vertexBuffer):
|
||||
if self.shape == TILE_SHAPE_NULL:
|
||||
return
|
||||
|
||||
# New code:
|
||||
baseData = self.getBaseTileModel()
|
||||
|
||||
# Base data is indiced but we need to buffer unindiced data
|
||||
for index in baseData['indices']:
|
||||
verts = baseData['vertices'][index]
|
||||
uv = baseData['uvs'][index]
|
||||
color = baseData['colors'][index]
|
||||
|
||||
vertexBuffer.vertices.extend([
|
||||
verts[0] - (TILE_WIDTH / 2.0),
|
||||
verts[1] - (TILE_HEIGHT / 2.0),
|
||||
verts[2] - (TILE_DEPTH / 2.0)
|
||||
])
|
||||
|
||||
vertexBuffer.colors.extend([
|
||||
color[0] / 255.0,
|
||||
color[1] / 255.0,
|
||||
color[2] / 255.0,
|
||||
color[3] / 255.0
|
||||
])
|
||||
@@ -1,57 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
import sys
|
||||
from PyQt5.QtWidgets import (
|
||||
QApplication, QVBoxLayout, QPushButton,
|
||||
QDialog
|
||||
)
|
||||
from OpenGL.GL import *
|
||||
from OpenGL.GLU import *
|
||||
from tools.editor.maptool import MapWindow
|
||||
from tools.editor.langtool import LangToolWindow
|
||||
from tools.editor.cutscenetool import CutsceneToolWindow
|
||||
|
||||
DEFAULT_TOOL = None
|
||||
DEFAULT_TOOL = "map"
|
||||
# DEFAULT_TOOL = "cutscene"
|
||||
|
||||
TOOLS = [
|
||||
("Map Editor", "map", MapWindow),
|
||||
("Language Editor", "language", LangToolWindow),
|
||||
("Cutscene Editor", "cutscene", CutsceneToolWindow),
|
||||
]
|
||||
|
||||
class EditorChoiceDialog(QDialog):
|
||||
def __init__(self):
|
||||
super().__init__()
|
||||
self.setWindowTitle("Choose Tool")
|
||||
layout = QVBoxLayout(self)
|
||||
self.selected = None
|
||||
for label, key, win_cls in TOOLS:
|
||||
btn = QPushButton(label)
|
||||
btn.clicked.connect(lambda checked, w=win_cls: self.choose_tool(w))
|
||||
layout.addWidget(btn)
|
||||
|
||||
def choose_tool(self, win_cls):
|
||||
self.selected = win_cls
|
||||
self.accept()
|
||||
|
||||
def get_choice(self):
|
||||
return self.selected
|
||||
|
||||
def main():
|
||||
app = QApplication(sys.argv)
|
||||
tool_map = { key: win_cls for _, key, win_cls in TOOLS }
|
||||
if DEFAULT_TOOL in tool_map:
|
||||
win_cls = tool_map[DEFAULT_TOOL]
|
||||
else:
|
||||
choice_dialog = EditorChoiceDialog()
|
||||
if choice_dialog.exec_() == QDialog.Accepted:
|
||||
win_cls = choice_dialog.get_choice()
|
||||
else:
|
||||
sys.exit(0)
|
||||
win = win_cls()
|
||||
win.show()
|
||||
sys.exit(app.exec_())
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,58 +0,0 @@
|
||||
from PyQt5.QtWidgets import QWidget, QVBoxLayout, QLineEdit, QLabel, QSizePolicy, QComboBox, QHBoxLayout, QSpacerItem
|
||||
from PyQt5.QtCore import Qt, pyqtSignal
|
||||
from .cutscenewait import CutsceneWaitEditor
|
||||
from .cutscenetext import CutsceneTextEditor
|
||||
|
||||
EDITOR_MAP = (
|
||||
( "wait", "Wait", CutsceneWaitEditor ),
|
||||
( "text", "Text", CutsceneTextEditor )
|
||||
)
|
||||
|
||||
class CutsceneItemEditor(QWidget):
|
||||
def __init__(self, parent=None):
|
||||
super().__init__(parent)
|
||||
self.layout = QVBoxLayout(self)
|
||||
self.layout.setAlignment(Qt.AlignTop | Qt.AlignLeft)
|
||||
self.layout.addWidget(QLabel("Item Properties:"))
|
||||
|
||||
rowLayout = QHBoxLayout()
|
||||
rowLayout.setSpacing(8)
|
||||
|
||||
rowLayout.addWidget(QLabel("Name:"))
|
||||
self.nameInput = QLineEdit()
|
||||
rowLayout.addWidget(self.nameInput)
|
||||
|
||||
rowLayout.addWidget(QLabel("Type:"))
|
||||
self.typeDropdown = QComboBox()
|
||||
self.typeDropdown.addItems([typeName for typeKey, typeName, editorClass in EDITOR_MAP])
|
||||
rowLayout.addWidget(self.typeDropdown)
|
||||
self.layout.addLayout(rowLayout)
|
||||
|
||||
self.activeEditor = None
|
||||
|
||||
# Events
|
||||
self.nameInput.textChanged.connect(self.onNameChanged)
|
||||
self.typeDropdown.currentTextChanged.connect(self.onTypeChanged)
|
||||
|
||||
# First load
|
||||
self.onNameChanged(self.nameInput.text())
|
||||
self.onTypeChanged(self.typeDropdown.currentText())
|
||||
|
||||
def onNameChanged(self, nameText):
|
||||
pass
|
||||
|
||||
def onTypeChanged(self, typeText):
|
||||
typeKey = typeText.lower()
|
||||
|
||||
# Remove existing editor
|
||||
if self.activeEditor:
|
||||
self.layout.removeWidget(self.activeEditor)
|
||||
self.activeEditor.deleteLater()
|
||||
self.activeEditor = None
|
||||
|
||||
# Create new editor
|
||||
for key, name, editorClass in EDITOR_MAP:
|
||||
if key == typeKey:
|
||||
self.activeEditor = editorClass()
|
||||
self.layout.addWidget(self.activeEditor)
|
||||
break
|
||||
@@ -1,54 +0,0 @@
|
||||
from PyQt5.QtWidgets import QMenuBar, QAction, QFileDialog, QMessageBox
|
||||
from PyQt5.QtGui import QKeySequence
|
||||
|
||||
class CutsceneMenuBar(QMenuBar):
|
||||
def __init__(self, parent):
|
||||
super().__init__(parent)
|
||||
self.parent = parent
|
||||
fileMenu = self.addMenu("File")
|
||||
|
||||
self.newAction = QAction("New", self)
|
||||
self.newAction.setShortcut(QKeySequence.New)
|
||||
self.newAction.triggered.connect(self.newFile)
|
||||
fileMenu.addAction(self.newAction)
|
||||
|
||||
self.openAction = QAction("Open", self)
|
||||
self.openAction.setShortcut(QKeySequence.Open)
|
||||
self.openAction.triggered.connect(self.openFile)
|
||||
fileMenu.addAction(self.openAction)
|
||||
|
||||
self.saveAction = QAction("Save", self)
|
||||
self.saveAction.setShortcut(QKeySequence.Save)
|
||||
self.saveAction.triggered.connect(self.saveFile)
|
||||
fileMenu.addAction(self.saveAction)
|
||||
|
||||
self.saveAsAction = QAction("Save As", self)
|
||||
self.saveAsAction.setShortcut(QKeySequence.SaveAs)
|
||||
self.saveAsAction.triggered.connect(self.saveFileAs)
|
||||
fileMenu.addAction(self.saveAsAction)
|
||||
|
||||
def newFile(self):
|
||||
self.parent.clearCutscene()
|
||||
|
||||
def openFile(self):
|
||||
path, _ = QFileDialog.getOpenFileName(self.parent, "Open Cutscene File", "", "JSON Files (*.json);;All Files (*)")
|
||||
if not path:
|
||||
return
|
||||
|
||||
# TODO: Load file contents into timeline
|
||||
self.parent.currentFile = path
|
||||
pass
|
||||
|
||||
def saveFile(self):
|
||||
if not self.parent.currentFile:
|
||||
self.saveFileAs()
|
||||
return
|
||||
|
||||
# TODO: Save timeline to self.parent.currentFile
|
||||
pass
|
||||
|
||||
def saveFileAs(self):
|
||||
path, _ = QFileDialog.getSaveFileName(self.parent, "Save Cutscene File As", "", "JSON Files (*.json);;All Files (*)")
|
||||
if path:
|
||||
self.parent.currentFile = path
|
||||
self.saveFile()
|
||||
@@ -1,21 +0,0 @@
|
||||
from PyQt5.QtWidgets import QWidget, QVBoxLayout, QLabel, QTextEdit
|
||||
from PyQt5.QtCore import Qt
|
||||
|
||||
class CutsceneTextEditor(QWidget):
|
||||
def __init__(self, parent=None):
|
||||
super().__init__(parent)
|
||||
layout = QVBoxLayout(self)
|
||||
layout.setContentsMargins(0, 0, 0, 0)
|
||||
layout.setSpacing(0)
|
||||
label = QLabel("Text:")
|
||||
label.setSizePolicy(label.sizePolicy().Expanding, label.sizePolicy().Fixed)
|
||||
layout.addWidget(label)
|
||||
self.textInput = QTextEdit()
|
||||
self.textInput.setSizePolicy(self.textInput.sizePolicy().Expanding, self.textInput.sizePolicy().Expanding)
|
||||
layout.addWidget(self.textInput, stretch=1)
|
||||
|
||||
def setText(self, text):
|
||||
self.textInput.setPlainText(text)
|
||||
|
||||
def getText(self):
|
||||
return self.textInput.toPlainText()
|
||||
@@ -1,20 +0,0 @@
|
||||
from PyQt5.QtWidgets import QWidget, QFormLayout, QDoubleSpinBox, QLabel
|
||||
|
||||
class CutsceneWaitEditor(QWidget):
|
||||
def __init__(self, parent=None):
|
||||
super().__init__(parent)
|
||||
layout = QFormLayout(self)
|
||||
layout.setContentsMargins(0, 0, 0, 0)
|
||||
layout.setSpacing(0)
|
||||
self.waitTimeInput = QDoubleSpinBox()
|
||||
self.waitTimeInput.setMinimum(0.0)
|
||||
self.waitTimeInput.setMaximum(9999.0)
|
||||
self.waitTimeInput.setDecimals(2)
|
||||
self.waitTimeInput.setSingleStep(0.1)
|
||||
layout.addRow(QLabel("Wait Time (seconds):"), self.waitTimeInput)
|
||||
|
||||
def setWaitTime(self, value):
|
||||
self.waitTimeInput.setValue(value)
|
||||
|
||||
def getWaitTime(self):
|
||||
return self.waitTimeInput.value()
|
||||
@@ -1,101 +0,0 @@
|
||||
from PyQt5.QtWidgets import QMainWindow, QApplication, QWidget, QVBoxLayout, QHBoxLayout, QLabel, QPushButton, QListWidget, QListWidgetItem, QMenuBar, QAction, QFileDialog, QMessageBox
|
||||
from PyQt5.QtGui import QKeySequence
|
||||
from tools.editor.cutscene.cutsceneitemeditor import CutsceneItemEditor
|
||||
from tools.editor.cutscene.cutscenemenubar import CutsceneMenuBar
|
||||
import sys
|
||||
|
||||
class CutsceneToolWindow(QMainWindow):
|
||||
def __init__(self):
|
||||
super().__init__()
|
||||
self.setWindowTitle("Dusk Cutscene Editor")
|
||||
self.setGeometry(100, 100, 800, 600)
|
||||
self.nextItemNumber = 1 # Track next available number
|
||||
self.currentFile = None
|
||||
self.dirty = False # Track unsaved changes
|
||||
|
||||
# File menu (handled by CutsceneMenuBar)
|
||||
menubar = CutsceneMenuBar(self)
|
||||
self.setMenuBar(menubar)
|
||||
|
||||
# Main layout: horizontal split
|
||||
central = QWidget()
|
||||
mainLayout = QHBoxLayout(central)
|
||||
self.setCentralWidget(central)
|
||||
|
||||
# Timeline
|
||||
leftPanel = QWidget()
|
||||
leftLayout = QVBoxLayout(leftPanel)
|
||||
|
||||
self.timelineList = QListWidget()
|
||||
self.timelineList.setSelectionMode(QListWidget.SingleSelection)
|
||||
leftLayout.addWidget(QLabel("Cutscene Timeline"))
|
||||
leftLayout.addWidget(self.timelineList)
|
||||
|
||||
btnLayout = QHBoxLayout()
|
||||
self.addBtn = QPushButton("Add")
|
||||
self.removeBtn = QPushButton("Remove")
|
||||
btnLayout.addWidget(self.addBtn)
|
||||
btnLayout.addWidget(self.removeBtn)
|
||||
leftLayout.addLayout(btnLayout)
|
||||
mainLayout.addWidget(leftPanel, 2)
|
||||
|
||||
# Property editor
|
||||
self.editorPanel = QWidget()
|
||||
self.editorLayout = QVBoxLayout(self.editorPanel)
|
||||
self.itemEditor = None # Only create when needed
|
||||
mainLayout.addWidget(self.editorPanel, 3)
|
||||
|
||||
# Events
|
||||
self.timelineList.currentItemChanged.connect(self.onItemSelected)
|
||||
self.addBtn.clicked.connect(self.addCutsceneItem)
|
||||
self.removeBtn.clicked.connect(self.removeCutsceneItem)
|
||||
|
||||
def addCutsceneItem(self):
|
||||
name = f"Cutscene item {self.nextItemNumber}"
|
||||
timelineItem = QListWidgetItem(name)
|
||||
self.timelineList.addItem(timelineItem)
|
||||
self.timelineList.setCurrentItem(timelineItem)
|
||||
self.nextItemNumber += 1
|
||||
self.dirty = True
|
||||
|
||||
def removeCutsceneItem(self):
|
||||
row = self.timelineList.currentRow()
|
||||
if row < 0:
|
||||
return
|
||||
self.timelineList.takeItem(row)
|
||||
self.dirty = True
|
||||
|
||||
# Remove editor if nothing selected
|
||||
if self.timelineList.currentItem() is None or self.itemEditor is None:
|
||||
return
|
||||
|
||||
self.editorLayout.removeWidget(self.itemEditor)
|
||||
self.itemEditor.deleteLater()
|
||||
self.itemEditor = None
|
||||
|
||||
def clearCutscene(self):
|
||||
self.timelineList.clear()
|
||||
self.nextItemNumber = 1
|
||||
self.currentFile = None
|
||||
self.dirty = False
|
||||
if self.itemEditor:
|
||||
self.editorLayout.removeWidget(self.itemEditor)
|
||||
|
||||
def onItemSelected(self, current, previous):
|
||||
if current:
|
||||
if not self.itemEditor:
|
||||
self.itemEditor = CutsceneItemEditor()
|
||||
self.editorLayout.addWidget(self.itemEditor)
|
||||
return
|
||||
|
||||
if not self.itemEditor:
|
||||
return
|
||||
self.editorLayout.removeWidget(self.itemEditor)
|
||||
self.itemEditor.deleteLater()
|
||||
self.itemEditor = None
|
||||
|
||||
if __name__ == "__main__":
|
||||
app = QApplication(sys.argv)
|
||||
window = CutsceneToolWindow()
|
||||
window.show()
|
||||
sys.exit(app.exec_())
|
||||
@@ -1,202 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
from PyQt5.QtWidgets import QMainWindow, QApplication, QAction, QMenuBar, QMessageBox, QFileDialog, QWidget, QVBoxLayout, QHBoxLayout, QLabel, QLineEdit, QTableWidget, QTableWidgetItem, QHeaderView, QPushButton, QTabWidget, QFormLayout
|
||||
from PyQt5.QtCore import Qt
|
||||
import sys
|
||||
import os
|
||||
import polib
|
||||
|
||||
class LangToolWindow(QMainWindow):
|
||||
def __init__(self):
|
||||
super().__init__()
|
||||
self.setWindowTitle("Dusk Language Editor")
|
||||
self.setGeometry(100, 100, 800, 600)
|
||||
self.current_file = None
|
||||
self.dirty = False
|
||||
self.init_menu()
|
||||
self.init_ui()
|
||||
|
||||
def init_ui(self):
|
||||
central = QWidget()
|
||||
layout = QVBoxLayout(central)
|
||||
|
||||
tabs = QTabWidget()
|
||||
# Header Tab
|
||||
header_tab = QWidget()
|
||||
header_layout = QFormLayout(header_tab)
|
||||
self.language_edit = QLineEdit()
|
||||
self.language_edit.setMaximumWidth(220)
|
||||
header_layout.addRow(QLabel("Language:"), self.language_edit)
|
||||
self.plural_edit = QLineEdit()
|
||||
self.plural_edit.setMaximumWidth(320)
|
||||
header_layout.addRow(QLabel("Plural-Forms:"), self.plural_edit)
|
||||
self.content_type_edit = QLineEdit("text/plain; charset=UTF-8")
|
||||
self.content_type_edit.setMaximumWidth(320)
|
||||
header_layout.addRow(QLabel("Content-Type:"), self.content_type_edit)
|
||||
tabs.addTab(header_tab, "Header")
|
||||
|
||||
# Strings Tab
|
||||
strings_tab = QWidget()
|
||||
strings_layout = QVBoxLayout(strings_tab)
|
||||
self.po_table = QTableWidget()
|
||||
self.po_table.setColumnCount(2)
|
||||
self.po_table.setHorizontalHeaderLabels(["msgid", "msgstr"])
|
||||
self.po_table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
|
||||
self.po_table.verticalHeader().setMinimumWidth(22)
|
||||
self.po_table.verticalHeader().setDefaultAlignment(Qt.AlignRight | Qt.AlignVCenter)
|
||||
strings_layout.addWidget(self.po_table)
|
||||
row_btn_layout = QHBoxLayout()
|
||||
add_row_btn = QPushButton("Add Row")
|
||||
remove_row_btn = QPushButton("Remove Row")
|
||||
row_btn_layout.addWidget(add_row_btn)
|
||||
row_btn_layout.addWidget(remove_row_btn)
|
||||
strings_layout.addLayout(row_btn_layout)
|
||||
tabs.addTab(strings_tab, "Strings")
|
||||
|
||||
layout.addWidget(tabs)
|
||||
|
||||
add_row_btn.clicked.connect(self.add_row)
|
||||
remove_row_btn.clicked.connect(self.remove_row)
|
||||
self.add_row_btn = add_row_btn
|
||||
self.remove_row_btn = remove_row_btn
|
||||
|
||||
self.setCentralWidget(central)
|
||||
|
||||
# Connect edits to dirty flag
|
||||
self.language_edit.textChanged.connect(self.set_dirty)
|
||||
self.plural_edit.textChanged.connect(self.set_dirty)
|
||||
self.content_type_edit.textChanged.connect(self.set_dirty)
|
||||
self.po_table.itemChanged.connect(self.set_dirty)
|
||||
|
||||
def set_dirty(self):
|
||||
self.dirty = True
|
||||
self.update_save_action()
|
||||
|
||||
def init_menu(self):
|
||||
menubar = self.menuBar()
|
||||
file_menu = menubar.addMenu("File")
|
||||
|
||||
new_action = QAction("New", self)
|
||||
open_action = QAction("Open", self)
|
||||
save_action = QAction("Save", self)
|
||||
save_as_action = QAction("Save As", self)
|
||||
|
||||
new_action.triggered.connect(lambda: self.handle_file_action("new"))
|
||||
open_action.triggered.connect(lambda: self.handle_file_action("open"))
|
||||
save_action.triggered.connect(self.handle_save)
|
||||
save_as_action.triggered.connect(self.handle_save_as)
|
||||
|
||||
file_menu.addAction(new_action)
|
||||
file_menu.addAction(open_action)
|
||||
file_menu.addAction(save_action)
|
||||
file_menu.addAction(save_as_action)
|
||||
|
||||
self.save_action = save_action # Store reference for enabling/disabling
|
||||
self.update_save_action()
|
||||
|
||||
def update_save_action(self):
|
||||
self.save_action.setEnabled(self.current_file is not None)
|
||||
|
||||
def handle_file_action(self, action):
|
||||
if self.dirty:
|
||||
reply = QMessageBox.question(self, "Save Changes?", "Do you want to save changes before proceeding?", QMessageBox.Yes | QMessageBox.No | QMessageBox.Cancel)
|
||||
if reply == QMessageBox.Cancel:
|
||||
return
|
||||
elif reply == QMessageBox.Yes:
|
||||
self.handle_save()
|
||||
if action == "new":
|
||||
self.new_file()
|
||||
elif action == "open":
|
||||
default_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), "../../assets/locale"))
|
||||
file_path, _ = QFileDialog.getOpenFileName(self, "Open Language File", default_dir, "PO Files (*.po)")
|
||||
if file_path:
|
||||
self.open_file(file_path)
|
||||
|
||||
def new_file(self):
|
||||
self.current_file = None
|
||||
self.dirty = False
|
||||
self.language_edit.setText("")
|
||||
self.plural_edit.setText("")
|
||||
self.po_table.setRowCount(0)
|
||||
self.update_save_action()
|
||||
|
||||
def open_file(self, file_path):
|
||||
self.current_file = file_path
|
||||
self.dirty = False
|
||||
self.update_save_action()
|
||||
self.load_po_file(file_path)
|
||||
|
||||
def load_po_file(self, file_path):
|
||||
po = polib.pofile(file_path)
|
||||
language = po.metadata.get('Language', '')
|
||||
plural = po.metadata.get('Plural-Forms', '')
|
||||
content_type = po.metadata.get('Content-Type', 'text/plain; charset=UTF-8')
|
||||
self.language_edit.setText(language)
|
||||
self.plural_edit.setText(plural)
|
||||
self.content_type_edit.setText(content_type)
|
||||
self.po_table.setRowCount(len(po))
|
||||
for row, entry in enumerate(po):
|
||||
self.po_table.setItem(row, 0, QTableWidgetItem(entry.msgid))
|
||||
self.po_table.setItem(row, 1, QTableWidgetItem(entry.msgstr))
|
||||
|
||||
def save_file(self, file_path):
|
||||
po = polib.POFile()
|
||||
po.metadata = {
|
||||
'Language': self.language_edit.text(),
|
||||
'Content-Type': self.content_type_edit.text(),
|
||||
'Plural-Forms': self.plural_edit.text(),
|
||||
}
|
||||
for row in range(self.po_table.rowCount()):
|
||||
msgid_item = self.po_table.item(row, 0)
|
||||
msgstr_item = self.po_table.item(row, 1)
|
||||
msgid = msgid_item.text() if msgid_item else ''
|
||||
msgstr = msgstr_item.text() if msgstr_item else ''
|
||||
if msgid or msgstr:
|
||||
entry = polib.POEntry(msgid=msgid, msgstr=msgstr)
|
||||
po.append(entry)
|
||||
po.save(file_path)
|
||||
self.dirty = False
|
||||
self.update_save_action()
|
||||
|
||||
def handle_save(self):
|
||||
if self.current_file:
|
||||
self.save_file(self.current_file)
|
||||
else:
|
||||
self.handle_save_as()
|
||||
|
||||
def handle_save_as(self):
|
||||
default_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), "../../assets/locale"))
|
||||
file_path, _ = QFileDialog.getSaveFileName(self, "Save Language File As", default_dir, "PO Files (*.po)")
|
||||
if file_path:
|
||||
self.current_file = file_path
|
||||
self.update_save_action()
|
||||
self.save_file(file_path)
|
||||
|
||||
def add_row(self):
|
||||
row = self.po_table.rowCount()
|
||||
self.po_table.insertRow(row)
|
||||
self.po_table.setItem(row, 0, QTableWidgetItem(""))
|
||||
self.po_table.setItem(row, 1, QTableWidgetItem(""))
|
||||
self.po_table.setCurrentCell(row, 0)
|
||||
self.set_dirty()
|
||||
|
||||
def remove_row(self):
|
||||
row = self.po_table.currentRow()
|
||||
if row >= 0:
|
||||
self.po_table.removeRow(row)
|
||||
self.set_dirty()
|
||||
|
||||
def closeEvent(self, event):
|
||||
if self.dirty:
|
||||
reply = QMessageBox.question(self, "Save Changes?", "Do you want to save changes before exiting?", QMessageBox.Yes | QMessageBox.No | QMessageBox.Cancel)
|
||||
if reply == QMessageBox.Cancel:
|
||||
event.ignore()
|
||||
return
|
||||
elif reply == QMessageBox.Yes:
|
||||
self.handle_save()
|
||||
event.accept()
|
||||
|
||||
if __name__ == "__main__":
|
||||
app = QApplication(sys.argv)
|
||||
window = LangToolWindow()
|
||||
window.show()
|
||||
sys.exit(app.exec_())
|
||||
@@ -1,55 +0,0 @@
|
||||
import math
|
||||
import time
|
||||
from OpenGL.GL import *
|
||||
from OpenGL.GLU import *
|
||||
from tools.dusk.defs import TILE_WIDTH, TILE_HEIGHT, TILE_DEPTH, RPG_CAMERA_PIXELS_PER_UNIT, RPG_CAMERA_Z_OFFSET, RPG_CAMERA_FOV
|
||||
|
||||
class Camera:
|
||||
def __init__(self, parent):
|
||||
self.parent = parent
|
||||
self.pixelsPerUnit = RPG_CAMERA_PIXELS_PER_UNIT
|
||||
self.yOffset = RPG_CAMERA_Z_OFFSET
|
||||
self.fov = RPG_CAMERA_FOV
|
||||
self.scale = 8.0
|
||||
self.lastTime = time.time()
|
||||
self.lookAtTarget = [0.0, 0.0, 0.0]
|
||||
|
||||
def setup(self, vw, vh, duration=0.1):
|
||||
now = time.time()
|
||||
delta = now - self.lastTime
|
||||
self.lastTime = now
|
||||
# Calculate ease factor for exponential smoothing over 'duration' seconds
|
||||
ease = 1 - math.exp(-delta / duration)
|
||||
|
||||
z = (vh / 2.0) / (
|
||||
(self.pixelsPerUnit * self.scale) * math.tan(math.radians(self.fov / 2.0))
|
||||
)
|
||||
lookAt = [
|
||||
self.parent.map.position[0] * TILE_WIDTH,
|
||||
self.parent.map.position[1] * TILE_HEIGHT,
|
||||
self.parent.map.position[2] * TILE_DEPTH,
|
||||
]
|
||||
aspectRatio = vw / vh
|
||||
|
||||
# Ease the lookAt target
|
||||
for i in range(3):
|
||||
self.lookAtTarget[i] += (lookAt[i] - self.lookAtTarget[i]) * ease
|
||||
|
||||
# Camera position is now based on the eased lookAtTarget
|
||||
cameraPosition = (
|
||||
self.lookAtTarget[0],
|
||||
self.lookAtTarget[1] + self.yOffset,
|
||||
self.lookAtTarget[2] + z
|
||||
)
|
||||
|
||||
glMatrixMode(GL_PROJECTION)
|
||||
glLoadIdentity()
|
||||
gluPerspective(self.fov, aspectRatio, 0.1, 1000.0)
|
||||
glScalef(1.0, -1.0, 1.0) # Flip the projection matrix upside down
|
||||
glMatrixMode(GL_MODELVIEW)
|
||||
glLoadIdentity()
|
||||
gluLookAt(
|
||||
cameraPosition[0], cameraPosition[1], cameraPosition[2],
|
||||
self.lookAtTarget[0], self.lookAtTarget[1], self.lookAtTarget[2],
|
||||
0.0, 1.0, 0.0
|
||||
)
|
||||
@@ -1,80 +0,0 @@
|
||||
from PyQt5.QtWidgets import QWidget, QVBoxLayout, QLabel, QGridLayout, QTreeWidget, QTreeWidgetItem, QComboBox
|
||||
from tools.dusk.defs import CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, TILE_SHAPES
|
||||
|
||||
class ChunkPanel(QWidget):
|
||||
def __init__(self, parent):
|
||||
super().__init__(parent)
|
||||
self.parent = parent
|
||||
layout = QVBoxLayout(self)
|
||||
|
||||
# Tile shape dropdown
|
||||
self.tileShapeDropdown = QComboBox()
|
||||
self.tileShapeDropdown.addItems(TILE_SHAPES.keys())
|
||||
self.tileShapeDropdown.setToolTip("Tile Shape")
|
||||
layout.addWidget(self.tileShapeDropdown)
|
||||
|
||||
# Add expandable tree list
|
||||
self.tree = QTreeWidget()
|
||||
self.tree.setHeaderLabel("Chunks")
|
||||
self.tree.expandAll() # Expand by default, remove if you want collapsed
|
||||
layout.addWidget(self.tree) # Removed invalid stretch factor
|
||||
|
||||
# Add stretch so tree expands
|
||||
layout.setStretchFactor(self.tree, 1)
|
||||
|
||||
# Event subscriptions
|
||||
self.parent.map.onMapData.sub(self.onMapData)
|
||||
self.parent.map.onPositionChange.sub(self.onPositionChange)
|
||||
self.tileShapeDropdown.currentTextChanged.connect(self.onTileShapeChanged)
|
||||
|
||||
# For each chunk
|
||||
for chunk in self.parent.map.chunks.values():
|
||||
# Create tree element
|
||||
item = QTreeWidgetItem(self.tree, ["Chunk ({}, {}, {})".format(chunk.x, chunk.y, chunk.z)])
|
||||
chunk.chunkPanelTree = item
|
||||
chunk.chunkPanelTree.setExpanded(True)
|
||||
item.setData(0, 0, chunk) # Store chunk reference
|
||||
|
||||
chunk.onChunkData.sub(self.onChunkData)
|
||||
|
||||
def onMapData(self, data):
|
||||
pass
|
||||
|
||||
def onPositionChange(self, pos):
|
||||
self.updateChunkList()
|
||||
|
||||
tile = self.parent.map.getTileAtWorldPos(*self.parent.map.position)
|
||||
if tile is None:
|
||||
return
|
||||
|
||||
key = "TILE_SHAPE_NULL"
|
||||
for k, v in TILE_SHAPES.items():
|
||||
if v != tile.shape:
|
||||
continue
|
||||
key = k
|
||||
break
|
||||
self.tileShapeDropdown.setCurrentText(key)
|
||||
|
||||
def onTileShapeChanged(self, shape_key):
|
||||
tile = self.parent.map.getTileAtWorldPos(*self.parent.map.position)
|
||||
|
||||
if tile is None or shape_key not in TILE_SHAPES:
|
||||
return
|
||||
tile.setShape(TILE_SHAPES[shape_key])
|
||||
|
||||
def updateChunkList(self):
|
||||
# Clear existing items
|
||||
currentChunk = self.parent.map.getChunkAtWorldPos(*self.parent.map.position)
|
||||
|
||||
# Example tree items
|
||||
for chunk in self.parent.map.chunks.values():
|
||||
title = "Chunk ({}, {}, {})".format(chunk.x, chunk.y, chunk.z)
|
||||
if chunk == currentChunk:
|
||||
title += " [C]"
|
||||
if chunk.isDirty():
|
||||
title += " *"
|
||||
item = chunk.chunkPanelTree
|
||||
item.setText(0, title)
|
||||
|
||||
def onChunkData(self, chunk):
|
||||
self.updateChunkList()
|
||||
@@ -1,154 +0,0 @@
|
||||
from PyQt5.QtWidgets import QWidget, QVBoxLayout, QLabel, QComboBox, QHBoxLayout, QPushButton, QLineEdit, QListWidget, QListWidgetItem
|
||||
from PyQt5.QtCore import Qt
|
||||
from tools.dusk.entity import Entity
|
||||
from tools.dusk.defs import CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, ENTITY_TYPES, ENTITY_TYPE_NULL
|
||||
|
||||
class EntityPanel(QWidget):
|
||||
def __init__(self, parent):
|
||||
super().__init__(parent)
|
||||
self.parent = parent
|
||||
layout = QVBoxLayout(self)
|
||||
self.setLayout(layout)
|
||||
|
||||
# Top panel placeholder
|
||||
topWidget = QLabel("Entity Editor")
|
||||
layout.addWidget(topWidget)
|
||||
|
||||
# Name input
|
||||
nameLayout = QHBoxLayout()
|
||||
nameLabel = QLabel("Name:")
|
||||
self.nameInput = QLineEdit()
|
||||
nameLayout.addWidget(nameLabel)
|
||||
nameLayout.addWidget(self.nameInput)
|
||||
layout.addLayout(nameLayout)
|
||||
|
||||
# Entity Type dropdown (single selection)
|
||||
typeLayout = QHBoxLayout()
|
||||
typeLabel = QLabel("Type:")
|
||||
self.typeDropdown = QComboBox()
|
||||
self.typeDropdown.addItems(ENTITY_TYPES)
|
||||
typeLayout.addWidget(typeLabel)
|
||||
typeLayout.addWidget(self.typeDropdown)
|
||||
layout.addLayout(typeLayout)
|
||||
|
||||
# Entity list and buttons
|
||||
self.entityList = QListWidget()
|
||||
self.entityList.addItems([])
|
||||
layout.addWidget(self.entityList, stretch=1)
|
||||
|
||||
btnLayout = QHBoxLayout()
|
||||
self.btnAdd = QPushButton("Add")
|
||||
self.btnRemove = QPushButton("Remove")
|
||||
btnLayout.addWidget(self.btnAdd)
|
||||
btnLayout.addWidget(self.btnRemove)
|
||||
layout.addLayout(btnLayout)
|
||||
|
||||
# Events
|
||||
self.btnAdd.clicked.connect(self.onAddEntity)
|
||||
self.btnRemove.clicked.connect(self.onRemoveEntity)
|
||||
self.parent.map.onEntityData.sub(self.onEntityData)
|
||||
self.parent.map.onPositionChange.sub(self.onPositionChange)
|
||||
self.entityList.itemClicked.connect(self.onEntityClicked)
|
||||
self.entityList.itemDoubleClicked.connect(self.onEntityDoubleClicked)
|
||||
self.typeDropdown.currentIndexChanged.connect(self.onTypeSelected)
|
||||
self.nameInput.textChanged.connect(self.onNameChanged)
|
||||
|
||||
# Call once to populate
|
||||
self.onEntityData()
|
||||
self.onEntityUnselect()
|
||||
|
||||
def onEntityUnselect(self):
|
||||
self.entityList.setCurrentItem(None)
|
||||
self.nameInput.setText("")
|
||||
self.typeDropdown.setCurrentIndex(ENTITY_TYPE_NULL)
|
||||
|
||||
def onEntitySelect(self, entity):
|
||||
self.entityList.setCurrentItem(entity.item)
|
||||
self.nameInput.setText(entity.name)
|
||||
self.typeDropdown.setCurrentIndex(entity.type)
|
||||
|
||||
def onEntityDoubleClicked(self, item):
|
||||
entity = item.data(Qt.UserRole)
|
||||
chunk = entity.chunk
|
||||
worldX = (chunk.x * CHUNK_WIDTH) + entity.localX
|
||||
worldY = (chunk.y * CHUNK_HEIGHT) + entity.localY
|
||||
worldZ = (chunk.z * CHUNK_DEPTH) + entity.localZ
|
||||
self.parent.map.moveTo(worldX, worldY, worldZ)
|
||||
|
||||
def onEntityClicked(self, item):
|
||||
pass
|
||||
|
||||
def onAddEntity(self):
|
||||
chunk = self.parent.map.getChunkAtWorldPos(*self.parent.map.position)
|
||||
if chunk is None:
|
||||
return
|
||||
|
||||
localX = (self.parent.map.position[0] - (chunk.x * CHUNK_WIDTH)) % CHUNK_WIDTH
|
||||
localY = (self.parent.map.position[1] - (chunk.y * CHUNK_HEIGHT)) % CHUNK_HEIGHT
|
||||
localZ = (self.parent.map.position[2] - (chunk.z * CHUNK_DEPTH)) % CHUNK_DEPTH
|
||||
|
||||
# Make sure there's not already an entity here
|
||||
for ent in chunk.entities.values():
|
||||
if ent.localX == localX and ent.localY == localY and ent.localZ == localZ:
|
||||
print("Entity already exists at this location")
|
||||
return
|
||||
|
||||
ent = chunk.addEntity(localX, localY, localZ)
|
||||
|
||||
def onRemoveEntity(self):
|
||||
item = self.entityList.currentItem()
|
||||
if item is None:
|
||||
return
|
||||
entity = item.data(Qt.UserRole)
|
||||
if entity:
|
||||
chunk = entity.chunk
|
||||
chunk.removeEntity(entity)
|
||||
pass
|
||||
|
||||
def onEntityData(self):
|
||||
self.onEntityUnselect()
|
||||
self.entityList.clear()
|
||||
for chunk in self.parent.map.chunks.values():
|
||||
for id, entity in chunk.entities.items():
|
||||
item = QListWidgetItem(entity.name)
|
||||
item.setData(Qt.UserRole, entity) # Store the entity object
|
||||
entity.item = item
|
||||
self.entityList.addItem(item)
|
||||
|
||||
# Select if there is something at current position
|
||||
self.onPositionChange(self.parent.map.position)
|
||||
|
||||
def onPositionChange(self, position):
|
||||
self.onEntityUnselect()
|
||||
|
||||
# Get Entity at..
|
||||
chunk = self.parent.map.getChunkAtWorldPos(*position)
|
||||
if chunk is None:
|
||||
return
|
||||
|
||||
localX = (position[0] - (chunk.x * CHUNK_WIDTH)) % CHUNK_WIDTH
|
||||
localY = (position[1] - (chunk.y * CHUNK_HEIGHT)) % CHUNK_HEIGHT
|
||||
localZ = (position[2] - (chunk.z * CHUNK_DEPTH)) % CHUNK_DEPTH
|
||||
|
||||
for ent in chunk.entities.values():
|
||||
if ent.localX != localX or ent.localY != localY or ent.localZ != localZ:
|
||||
continue
|
||||
self.onEntitySelect(ent)
|
||||
self.entityList.setCurrentItem(ent.item)
|
||||
break
|
||||
|
||||
def onTypeSelected(self, index):
|
||||
item = self.entityList.currentItem()
|
||||
if item is None:
|
||||
return
|
||||
entity = item.data(Qt.UserRole)
|
||||
if entity:
|
||||
entity.setType(index)
|
||||
|
||||
def onNameChanged(self, text):
|
||||
item = self.entityList.currentItem()
|
||||
if item is None:
|
||||
return
|
||||
entity = item.data(Qt.UserRole)
|
||||
if entity:
|
||||
entity.setName(text)
|
||||
@@ -1,41 +0,0 @@
|
||||
from PyQt5.QtCore import QTimer
|
||||
from PyQt5.QtWidgets import QOpenGLWidget
|
||||
from OpenGL.GL import *
|
||||
from OpenGL.GLU import *
|
||||
|
||||
class GLWidget(QOpenGLWidget):
|
||||
def __init__(self, parent):
|
||||
super().__init__(parent)
|
||||
self.parent = parent
|
||||
self.timer = QTimer(self)
|
||||
self.timer.timeout.connect(self.update)
|
||||
self.timer.start(16) # ~60 FPS
|
||||
|
||||
def initializeGL(self):
|
||||
glClearColor(0.392, 0.584, 0.929, 1.0)
|
||||
glEnable(GL_DEPTH_TEST)
|
||||
glEnable(GL_BLEND)
|
||||
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
|
||||
glEnable(GL_POLYGON_OFFSET_FILL)
|
||||
glPolygonOffset(1.0, 1.0)
|
||||
glDisable(GL_POLYGON_OFFSET_FILL)
|
||||
|
||||
def resizeGL(self, w, h):
|
||||
pass
|
||||
|
||||
def paintGL(self):
|
||||
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
|
||||
glLoadIdentity()
|
||||
|
||||
w = self.width()
|
||||
h = self.height()
|
||||
if h <= 0:
|
||||
h = 1
|
||||
if w <= 0:
|
||||
w = 1
|
||||
|
||||
glViewport(0, 0, w, h)
|
||||
self.parent.camera.setup(w, h)
|
||||
self.parent.grid.draw()
|
||||
self.parent.map.draw()
|
||||
self.parent.selectBox.draw()
|
||||
@@ -1,46 +0,0 @@
|
||||
from OpenGL.GL import *
|
||||
from tools.dusk.defs import TILE_WIDTH, TILE_HEIGHT, TILE_DEPTH
|
||||
|
||||
class Grid:
|
||||
def __init__(self, lines=1000):
|
||||
self.cellWidth = TILE_WIDTH
|
||||
self.cellHeight = TILE_HEIGHT
|
||||
self.lines = lines
|
||||
self.enabled = True
|
||||
|
||||
def draw(self):
|
||||
if not self.enabled:
|
||||
return
|
||||
center = [0.01,0.01,0.01]
|
||||
halfWidth = self.cellWidth * self.lines // 2
|
||||
halfHeight = self.cellHeight * self.lines // 2
|
||||
# Draw origin axes
|
||||
glBegin(GL_LINES)
|
||||
|
||||
# X axis - RED
|
||||
glColor3f(1.0, 0.0, 0.0)
|
||||
glVertex3f(center[0] - halfWidth, center[1], center[2])
|
||||
glVertex3f(center[0] + halfWidth, center[1], center[2])
|
||||
|
||||
# Y axis - GREEN
|
||||
glColor3f(0.0, 1.0, 0.0)
|
||||
glVertex3f(center[0], center[1] - halfHeight, center[2])
|
||||
glVertex3f(center[0], center[1] + halfHeight, center[2])
|
||||
|
||||
# Z axis - BLUE
|
||||
glColor3f(0.0, 0.0, 1.0)
|
||||
glVertex3f(center[0], center[1], center[2] - halfWidth)
|
||||
glVertex3f(center[0], center[1], center[2] + halfWidth)
|
||||
glEnd()
|
||||
|
||||
# Draw grid
|
||||
glColor3f(0.8, 0.8, 0.8)
|
||||
glBegin(GL_LINES)
|
||||
for i in range(-self.lines // 2, self.lines // 2 + 1):
|
||||
# Vertical lines
|
||||
glVertex3f(center[0] + i * self.cellWidth, center[1] - halfHeight, center[2])
|
||||
glVertex3f(center[0] + i * self.cellWidth, center[1] + halfHeight, center[2])
|
||||
# Horizontal lines
|
||||
glVertex3f(center[0] - halfWidth, center[1] + i * self.cellHeight, center[2])
|
||||
glVertex3f(center[0] + halfWidth, center[1] + i * self.cellHeight, center[2])
|
||||
glEnd()
|
||||
@@ -1,83 +0,0 @@
|
||||
from PyQt5.QtWidgets import QWidget, QVBoxLayout, QLabel, QLineEdit, QPushButton, QHBoxLayout, QMessageBox
|
||||
from tools.dusk.defs import CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH
|
||||
|
||||
class MapInfoPanel(QWidget):
|
||||
def __init__(self, parent):
|
||||
super().__init__(parent)
|
||||
self.parent = parent
|
||||
|
||||
# Components
|
||||
layout = QVBoxLayout()
|
||||
|
||||
mapTitleLabel = QLabel("Map Title")
|
||||
self.mapTitleInput = QLineEdit()
|
||||
layout.addWidget(mapTitleLabel)
|
||||
layout.addWidget(self.mapTitleInput)
|
||||
|
||||
tilePositionLabel = QLabel("Tile Position")
|
||||
layout.addWidget(tilePositionLabel)
|
||||
tilePositionRow = QHBoxLayout()
|
||||
self.tileXInput = QLineEdit()
|
||||
self.tileXInput.setPlaceholderText("X")
|
||||
tilePositionRow.addWidget(self.tileXInput)
|
||||
self.tileYInput = QLineEdit()
|
||||
self.tileYInput.setPlaceholderText("Y")
|
||||
tilePositionRow.addWidget(self.tileYInput)
|
||||
self.tileZInput = QLineEdit()
|
||||
self.tileZInput.setPlaceholderText("Z")
|
||||
tilePositionRow.addWidget(self.tileZInput)
|
||||
self.tileGo = QPushButton("Go")
|
||||
tilePositionRow.addWidget(self.tileGo)
|
||||
layout.addLayout(tilePositionRow)
|
||||
|
||||
self.chunkPosLabel = QLabel()
|
||||
layout.addWidget(self.chunkPosLabel)
|
||||
self.chunkLabel = QLabel()
|
||||
layout.addWidget(self.chunkLabel)
|
||||
|
||||
layout.addStretch()
|
||||
self.setLayout(layout)
|
||||
|
||||
# Events
|
||||
self.tileGo.clicked.connect(self.goToPosition)
|
||||
self.tileXInput.returnPressed.connect(self.goToPosition)
|
||||
self.tileYInput.returnPressed.connect(self.goToPosition)
|
||||
self.tileZInput.returnPressed.connect(self.goToPosition)
|
||||
self.parent.map.onPositionChange.sub(self.updatePositionLabels)
|
||||
self.parent.map.onMapData.sub(self.onMapData)
|
||||
self.mapTitleInput.textChanged.connect(self.onMapNameChange)
|
||||
|
||||
# Initial label setting
|
||||
self.updatePositionLabels(self.parent.map.position)
|
||||
|
||||
def goToPosition(self):
|
||||
try:
|
||||
x = int(self.tileXInput.text())
|
||||
y = int(self.tileYInput.text())
|
||||
z = int(self.tileZInput.text())
|
||||
self.parent.map.moveTo(x, y, z)
|
||||
except ValueError:
|
||||
QMessageBox.warning(self, "Invalid Input", "Please enter valid integer coordinates.")
|
||||
|
||||
def updatePositionLabels(self, pos):
|
||||
self.tileXInput.setText(str(pos[0]))
|
||||
self.tileYInput.setText(str(pos[1]))
|
||||
self.tileZInput.setText(str(pos[2]))
|
||||
|
||||
chunkTileX = pos[0] % CHUNK_WIDTH
|
||||
chunkTileY = pos[1] % CHUNK_HEIGHT
|
||||
chunkTileZ = pos[2] % CHUNK_DEPTH
|
||||
chunkTileIndex = chunkTileX + chunkTileY * CHUNK_WIDTH + chunkTileZ * CHUNK_WIDTH * CHUNK_HEIGHT
|
||||
self.chunkPosLabel.setText(f"Chunk Position: {chunkTileX}, {chunkTileY}, {chunkTileZ} ({chunkTileIndex})")
|
||||
|
||||
chunkX = pos[0] // CHUNK_WIDTH
|
||||
chunkY = pos[1] // CHUNK_HEIGHT
|
||||
chunkZ = pos[2] // CHUNK_DEPTH
|
||||
self.chunkLabel.setText(f"Chunk: {chunkX}, {chunkY}, {chunkZ}")
|
||||
|
||||
def onMapData(self, data):
|
||||
self.updatePositionLabels(self.parent.map.position)
|
||||
self.mapTitleInput.setText(data.get("mapName", ""))
|
||||
|
||||
def onMapNameChange(self, text):
|
||||
self.parent.map.data['mapName'] = text
|
||||
@@ -1,51 +0,0 @@
|
||||
from PyQt5.QtWidgets import QWidget, QVBoxLayout, QGridLayout, QPushButton, QTabWidget, QLabel
|
||||
from tools.editor.map.chunkpanel import ChunkPanel
|
||||
from tools.editor.map.entitypanel import EntityPanel
|
||||
from tools.editor.map.regionpanel import RegionPanel
|
||||
|
||||
class MapLeftPanel(QWidget):
|
||||
def __init__(self, parent):
|
||||
super().__init__(parent)
|
||||
self.parent = parent
|
||||
layout = QVBoxLayout(self)
|
||||
self.setLayout(layout)
|
||||
|
||||
# Nav buttons
|
||||
self.chunkInfoLabel = QLabel("Tile Information")
|
||||
layout.addWidget(self.chunkInfoLabel)
|
||||
grid = QGridLayout()
|
||||
self.btnUp = QPushButton("U")
|
||||
self.btnN = QPushButton("N")
|
||||
self.btnDown = QPushButton("D")
|
||||
self.btnW = QPushButton("W")
|
||||
self.btnS = QPushButton("S")
|
||||
self.btnE = QPushButton("E")
|
||||
|
||||
grid.addWidget(self.btnUp, 0, 0)
|
||||
grid.addWidget(self.btnN, 0, 1)
|
||||
grid.addWidget(self.btnDown, 0, 2)
|
||||
grid.addWidget(self.btnW, 1, 0)
|
||||
grid.addWidget(self.btnS, 1, 1)
|
||||
grid.addWidget(self.btnE, 1, 2)
|
||||
layout.addLayout(grid)
|
||||
|
||||
# Panels
|
||||
self.chunkPanel = ChunkPanel(self.parent)
|
||||
self.entityPanel = EntityPanel(self.parent)
|
||||
self.regionPanel = RegionPanel(self.parent)
|
||||
|
||||
# Tabs
|
||||
self.tabs = QTabWidget()
|
||||
self.tabs.addTab(self.chunkPanel, "Tiles")
|
||||
self.tabs.addTab(self.entityPanel, "Entities")
|
||||
self.tabs.addTab(self.regionPanel, "Regions")
|
||||
self.tabs.addTab(None, "Triggers")
|
||||
layout.addWidget(self.tabs)
|
||||
|
||||
# Event subscriptions
|
||||
self.btnN.clicked.connect(lambda: self.parent.map.moveRelative(0, -1, 0))
|
||||
self.btnS.clicked.connect(lambda: self.parent.map.moveRelative(0, 1, 0))
|
||||
self.btnE.clicked.connect(lambda: self.parent.map.moveRelative(1, 0, 0))
|
||||
self.btnW.clicked.connect(lambda: self.parent.map.moveRelative(-1, 0, 0))
|
||||
self.btnUp.clicked.connect(lambda: self.parent.map.moveRelative(0, 0, 1))
|
||||
self.btnDown.clicked.connect(lambda: self.parent.map.moveRelative(0, 0, -1))
|
||||
@@ -1,46 +0,0 @@
|
||||
import os
|
||||
from PyQt5.QtWidgets import QAction, QMenuBar, QFileDialog
|
||||
from PyQt5.QtGui import QKeySequence
|
||||
from tools.dusk.map import MAP_DEFAULT_PATH
|
||||
|
||||
class MapMenubar:
|
||||
def __init__(self, parent):
|
||||
self.parent = parent
|
||||
self.menubar = QMenuBar(parent)
|
||||
parent.setMenuBar(self.menubar)
|
||||
|
||||
self.fileMenu = self.menubar.addMenu("File")
|
||||
self.actionNew = QAction("New", parent)
|
||||
self.actionOpen = QAction("Open", parent)
|
||||
self.actionSave = QAction("Save", parent)
|
||||
self.actionSaveAs = QAction("Save As", parent)
|
||||
|
||||
self.actionNew.setShortcut(QKeySequence("Ctrl+N"))
|
||||
self.actionOpen.setShortcut(QKeySequence("Ctrl+O"))
|
||||
self.actionSave.setShortcut(QKeySequence("Ctrl+S"))
|
||||
self.actionSaveAs.setShortcut(QKeySequence("Ctrl+Shift+S"))
|
||||
|
||||
self.actionNew.triggered.connect(self.newFile)
|
||||
self.actionOpen.triggered.connect(self.openFile)
|
||||
self.actionSave.triggered.connect(self.saveFile)
|
||||
self.actionSaveAs.triggered.connect(self.saveAsFile)
|
||||
self.fileMenu.addAction(self.actionNew)
|
||||
self.fileMenu.addAction(self.actionOpen)
|
||||
self.fileMenu.addAction(self.actionSave)
|
||||
self.fileMenu.addAction(self.actionSaveAs)
|
||||
|
||||
def newFile(self):
|
||||
self.parent.map.newFile()
|
||||
|
||||
def openFile(self):
|
||||
filePath, _ = QFileDialog.getOpenFileName(self.menubar, "Open Map File", MAP_DEFAULT_PATH, "Map Files (*.json)")
|
||||
if filePath:
|
||||
self.parent.map.load(filePath)
|
||||
|
||||
def saveFile(self):
|
||||
self.parent.map.save()
|
||||
|
||||
def saveAsFile(self):
|
||||
filePath, _ = QFileDialog.getSaveFileName(self.menubar, "Save Map File As", MAP_DEFAULT_PATH, "Map Files (*.json)")
|
||||
if filePath:
|
||||
self.parent.map.save(filePath)
|
||||
@@ -1,15 +0,0 @@
|
||||
from PyQt5.QtWidgets import QWidget, QVBoxLayout, QLabel, QComboBox, QHBoxLayout, QPushButton, QLineEdit, QListWidget, QListWidgetItem
|
||||
from PyQt5.QtCore import Qt
|
||||
from tools.dusk.entity import Entity
|
||||
from tools.dusk.defs import CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, ENTITY_TYPES, ENTITY_TYPE_NULL
|
||||
|
||||
class RegionPanel(QWidget):
|
||||
def __init__(self, parent):
|
||||
super().__init__(parent)
|
||||
self.parent = parent
|
||||
layout = QVBoxLayout(self)
|
||||
self.setLayout(layout)
|
||||
|
||||
# Top panel placeholder
|
||||
topWidget = QLabel("Region Editor")
|
||||
layout.addWidget(topWidget)
|
||||
@@ -1,44 +0,0 @@
|
||||
import OpenGL.GL as gl
|
||||
from tools.dusk.defs import defs
|
||||
import colorsys
|
||||
from tools.dusk.defs import TILE_WIDTH, TILE_HEIGHT, TILE_DEPTH
|
||||
|
||||
class SelectBox:
|
||||
def __init__(self, parent):
|
||||
self.parent = parent
|
||||
self.hue = 0.0
|
||||
|
||||
def draw(self):
|
||||
position = [
|
||||
self.parent.map.position[0] * TILE_WIDTH - (TILE_WIDTH / 2.0),
|
||||
self.parent.map.position[1] * TILE_HEIGHT - (TILE_HEIGHT / 2.0),
|
||||
self.parent.map.position[2] * TILE_DEPTH - (TILE_DEPTH / 2.0)
|
||||
]
|
||||
|
||||
vertices = [
|
||||
(position[0], position[1], position[2]),
|
||||
(position[0]+TILE_WIDTH, position[1], position[2]),
|
||||
(position[0]+TILE_WIDTH, position[1]+TILE_HEIGHT, position[2]),
|
||||
(position[0], position[1]+TILE_HEIGHT, position[2]),
|
||||
(position[0], position[1], position[2]+TILE_DEPTH),
|
||||
(position[0]+TILE_WIDTH, position[1], position[2]+TILE_DEPTH),
|
||||
(position[0]+TILE_WIDTH, position[1]+TILE_HEIGHT, position[2]+TILE_DEPTH),
|
||||
(position[0], position[1]+TILE_HEIGHT, position[2]+TILE_DEPTH)
|
||||
]
|
||||
edges = [
|
||||
(0, 1), (1, 2), (2, 3), (3, 0), # bottom face
|
||||
(4, 5), (5, 6), (6, 7), (7, 4), # top face
|
||||
(4, 5), (5, 6), (6, 7), (7, 4), # top face
|
||||
(0, 4), (1, 5), (2, 6), (3, 7) # vertical edges
|
||||
]
|
||||
|
||||
# Cycle hue
|
||||
self.hue = (self.hue + 0.01) % 1.0
|
||||
r, g, b = colorsys.hsv_to_rgb(self.hue, 1.0, 1.0)
|
||||
gl.glColor3f(r, g, b)
|
||||
gl.glLineWidth(2.0)
|
||||
gl.glBegin(gl.GL_LINES)
|
||||
for edge in edges:
|
||||
for vertex in edge:
|
||||
gl.glVertex3f(*vertices[vertex])
|
||||
gl.glEnd()
|
||||
@@ -1,18 +0,0 @@
|
||||
from PyQt5.QtWidgets import QStatusBar, QLabel
|
||||
|
||||
class StatusBar(QStatusBar):
|
||||
def __init__(self, parent=None):
|
||||
super().__init__(parent)
|
||||
self.parent = parent
|
||||
self.leftLabel = QLabel("")
|
||||
self.rightLabel = QLabel("")
|
||||
self.addWidget(self.leftLabel, 1)
|
||||
self.addPermanentWidget(self.rightLabel)
|
||||
|
||||
parent.map.onMapData.sub(self.onMapData)
|
||||
|
||||
def setStatus(self, message):
|
||||
self.leftLabel.setText(message)
|
||||
|
||||
def onMapData(self, data):
|
||||
self.rightLabel.setText(self.parent.map.mapFileName if self.parent.map.mapFileName else "Untitled.json")
|
||||
@@ -1,80 +0,0 @@
|
||||
from OpenGL.GL import *
|
||||
import array
|
||||
|
||||
class VertexBuffer:
|
||||
def __init__(self, componentsPerVertex=3):
|
||||
self.componentsPerVertex = componentsPerVertex
|
||||
self.vertices = []
|
||||
self.colors = []
|
||||
self.uvs = []
|
||||
self.data = None
|
||||
self.colorData = None
|
||||
self.uvData = None
|
||||
|
||||
def buildData(self):
|
||||
hasColors = len(self.colors) > 0
|
||||
hasUvs = len(self.uvs) > 0
|
||||
|
||||
vertexCount = len(self.vertices) // self.componentsPerVertex
|
||||
|
||||
dataList = []
|
||||
colorList = []
|
||||
uvList = []
|
||||
|
||||
for i in range(vertexCount):
|
||||
vStart = i * self.componentsPerVertex
|
||||
dataList.extend(self.vertices[vStart:vStart+self.componentsPerVertex])
|
||||
|
||||
if hasColors:
|
||||
cStart = i * 4 # Assuming RGBA
|
||||
colorList.extend(self.colors[cStart:cStart+4])
|
||||
|
||||
if hasUvs:
|
||||
uStart = i * 2 # Assuming UV
|
||||
uvList.extend(self.uvs[uStart:uStart+2])
|
||||
|
||||
self.data = array.array('f', dataList)
|
||||
|
||||
if hasColors:
|
||||
self.colorData = array.array('f', colorList)
|
||||
else:
|
||||
self.colorData = None
|
||||
|
||||
if hasUvs:
|
||||
self.uvData = array.array('f', uvList)
|
||||
else:
|
||||
self.uvData = None
|
||||
|
||||
def draw(self, mode=GL_TRIANGLES, count=-1):
|
||||
if count == -1:
|
||||
count = len(self.data) // self.componentsPerVertex
|
||||
|
||||
if count == 0:
|
||||
return
|
||||
|
||||
glEnableClientState(GL_VERTEX_ARRAY)
|
||||
glVertexPointer(self.componentsPerVertex, GL_FLOAT, 0, self.data.tobytes())
|
||||
|
||||
if self.colorData:
|
||||
glEnableClientState(GL_COLOR_ARRAY)
|
||||
glColorPointer(4, GL_FLOAT, 0, self.colorData.tobytes())
|
||||
|
||||
if self.uvData:
|
||||
glEnableClientState(GL_TEXTURE_COORD_ARRAY)
|
||||
glTexCoordPointer(2, GL_FLOAT, 0, self.uvData.tobytes())
|
||||
|
||||
glDrawArrays(mode, 0, count)
|
||||
|
||||
glDisableClientState(GL_VERTEX_ARRAY)
|
||||
if self.colorData:
|
||||
glDisableClientState(GL_COLOR_ARRAY)
|
||||
if self.uvData:
|
||||
glDisableClientState(GL_TEXTURE_COORD_ARRAY)
|
||||
|
||||
def clear(self):
|
||||
self.vertices = []
|
||||
self.colors = []
|
||||
self.uvs = []
|
||||
self.data = array.array('f')
|
||||
self.colorData = None
|
||||
self.uvData = None
|
||||
@@ -1,143 +0,0 @@
|
||||
import os
|
||||
from PyQt5.QtWidgets import QMainWindow, QWidget, QHBoxLayout, QMessageBox
|
||||
from PyQt5.QtCore import Qt
|
||||
from tools.editor.map.glwidget import GLWidget
|
||||
from tools.editor.map.mapleftpanel import MapLeftPanel
|
||||
from tools.editor.map.mapinfopanel import MapInfoPanel
|
||||
from tools.editor.map.menubar import MapMenubar
|
||||
from tools.editor.map.statusbar import StatusBar
|
||||
from tools.dusk.map import Map
|
||||
from tools.dusk.defs import CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, TILE_SHAPE_NULL, TILE_SHAPE_FLOOR
|
||||
from tools.editor.map.selectbox import SelectBox
|
||||
from tools.editor.map.camera import Camera
|
||||
from tools.editor.map.grid import Grid
|
||||
|
||||
class MapWindow(QMainWindow):
|
||||
def __init__(self):
|
||||
super().__init__()
|
||||
|
||||
self.insertPressed = False
|
||||
self.deletePressed = False
|
||||
|
||||
# Subclasses
|
||||
self.map = Map(self)
|
||||
self.camera = Camera(self)
|
||||
self.grid = Grid()
|
||||
self.selectBox = SelectBox(self)
|
||||
|
||||
# Window setup
|
||||
self.setWindowTitle("Dusk Map Editor")
|
||||
self.resize(1600, 900)
|
||||
|
||||
# Menubar (TESTING)
|
||||
self.menubar = MapMenubar(self)
|
||||
|
||||
central = QWidget()
|
||||
self.setCentralWidget(central)
|
||||
mainLayout = QHBoxLayout(central)
|
||||
|
||||
# Left panel (tabs + nav buttons)
|
||||
self.leftPanel = MapLeftPanel(self)
|
||||
self.leftPanel.setFixedWidth(350)
|
||||
mainLayout.addWidget(self.leftPanel)
|
||||
|
||||
# Center panel (GLWidget + controls)
|
||||
self.glWidget = GLWidget(self)
|
||||
mainLayout.addWidget(self.glWidget, stretch=3)
|
||||
|
||||
# Right panel (MapInfoPanel)
|
||||
self.mapInfoPanel = MapInfoPanel(self)
|
||||
rightWidget = self.mapInfoPanel
|
||||
rightWidget.setFixedWidth(250)
|
||||
mainLayout.addWidget(rightWidget)
|
||||
|
||||
# Status bar
|
||||
self.statusBar = StatusBar(self)
|
||||
self.setStatusBar(self.statusBar)
|
||||
|
||||
self.installEventFilter(self)
|
||||
self.installEventFilterRecursively(self)
|
||||
|
||||
def installEventFilterRecursively(self, widget):
|
||||
for child in widget.findChildren(QWidget):
|
||||
child.installEventFilter(self)
|
||||
self.installEventFilterRecursively(child)
|
||||
|
||||
def closeEvent(self, event):
|
||||
if not self.map.isDirty():
|
||||
event.accept()
|
||||
return
|
||||
|
||||
reply = QMessageBox.question(
|
||||
self,
|
||||
"Unsaved Changes",
|
||||
"You have unsaved changes. Do you want to save before closing?",
|
||||
QMessageBox.Save | QMessageBox.Discard | QMessageBox.Cancel,
|
||||
QMessageBox.Save
|
||||
)
|
||||
if reply == QMessageBox.Save:
|
||||
self.map.save()
|
||||
elif reply == QMessageBox.Cancel:
|
||||
event.ignore()
|
||||
return
|
||||
event.accept()
|
||||
|
||||
def eventFilter(self, obj, event):
|
||||
if event.type() == event.KeyPress:
|
||||
amtX, amtY, amtZ = 0, 0, 0
|
||||
|
||||
key = event.key()
|
||||
if key == Qt.Key_Left:
|
||||
amtX = -1
|
||||
elif key == Qt.Key_Right:
|
||||
amtX = 1
|
||||
elif key == Qt.Key_Up:
|
||||
amtY = -1
|
||||
elif key == Qt.Key_Down:
|
||||
amtY = 1
|
||||
elif key == Qt.Key_PageUp:
|
||||
amtZ = 1
|
||||
elif key == Qt.Key_PageDown:
|
||||
amtZ = -1
|
||||
|
||||
if event.modifiers() & Qt.ShiftModifier:
|
||||
amtX *= CHUNK_WIDTH
|
||||
amtY *= CHUNK_HEIGHT
|
||||
amtZ *= CHUNK_DEPTH
|
||||
|
||||
if amtX != 0 or amtY != 0 or amtZ != 0:
|
||||
self.map.moveRelative(amtX, amtY, amtZ)
|
||||
if self.insertPressed:
|
||||
tile = self.map.getTileAtWorldPos(*self.map.position)
|
||||
if tile is not None and tile.shape == TILE_SHAPE_NULL:
|
||||
tile.setShape(TILE_SHAPE_FLOOR)
|
||||
if self.deletePressed:
|
||||
tile = self.map.getTileAtWorldPos(*self.map.position)
|
||||
if tile is not None:
|
||||
tile.setShape(TILE_SHAPE_NULL)
|
||||
event.accept()
|
||||
return True
|
||||
|
||||
if key == Qt.Key_Delete:
|
||||
tile = self.map.getTileAtWorldPos(*self.map.position)
|
||||
self.deletePressed = True
|
||||
if tile is not None:
|
||||
tile.setShape(TILE_SHAPE_NULL)
|
||||
event.accept()
|
||||
return True
|
||||
if key == Qt.Key_Insert:
|
||||
tile = self.map.getTileAtWorldPos(*self.map.position)
|
||||
self.insertPressed = True
|
||||
if tile is not None and tile.shape == TILE_SHAPE_NULL:
|
||||
tile.setShape(TILE_SHAPE_FLOOR)
|
||||
event.accept()
|
||||
elif event.type() == event.KeyRelease:
|
||||
key = event.key()
|
||||
if key == Qt.Key_Delete:
|
||||
self.deletePressed = False
|
||||
event.accept()
|
||||
return True
|
||||
if key == Qt.Key_Insert:
|
||||
self.insertPressed = False
|
||||
event.accept()
|
||||
return super().eventFilter(obj, event)
|
||||
@@ -1,7 +1,6 @@
|
||||
import argparse
|
||||
import os
|
||||
import csv
|
||||
from tools.util.type import detectType, stringToCType, typeToCType
|
||||
|
||||
parser = argparse.ArgumentParser(description="Input CSV to .h defines")
|
||||
parser.add_argument("--csv", required=True, help="Path to Input CSV file")
|
||||
|
||||
@@ -1,7 +1,6 @@
|
||||
import argparse
|
||||
import os
|
||||
import csv
|
||||
from tools.util.type import detectType, stringToCType, typeToCType
|
||||
|
||||
parser = argparse.ArgumentParser(description="Item CSV to .h defines")
|
||||
parser.add_argument("--csv", required=True, help="Path to item CSV file")
|
||||
|
||||
698
tools/palette-indexer.html
Normal file
698
tools/palette-indexer.html
Normal file
@@ -0,0 +1,698 @@
|
||||
<!DOCTYPE html>
|
||||
<html lang="en">
|
||||
<head>
|
||||
<meta charset="UTF-8" />
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
|
||||
<title>Dusk Tools / Palette Indexer</title>
|
||||
|
||||
<style type="text/css">
|
||||
* {
|
||||
box-sizing: border-box;
|
||||
}
|
||||
|
||||
body {
|
||||
font-size: 16px;
|
||||
}
|
||||
|
||||
canvas {
|
||||
image-rendering: pixelated;
|
||||
}
|
||||
</style>
|
||||
</head>
|
||||
|
||||
<body>
|
||||
<h1>Dusk Palette Indexer</h1>
|
||||
<p>
|
||||
This tool takes an input image and creates a palettized version of it.
|
||||
You will get two files, a .dpf (Dusk Palette File) and a .dpt
|
||||
(Dusk Palettized Texture). The first being the palette, which I recommend
|
||||
reusing across multiple images, and the second being the indexed image,
|
||||
which uses the colors from the palette.
|
||||
</p>
|
||||
<p>
|
||||
Also, dusk previously supported Alpha textures, but due to so many little
|
||||
platform differences I realized it is simpler and about as much work to
|
||||
get palettized textures working instead. As a result I suggest creating a
|
||||
single palette for your alpha textures, and reusing that globally.
|
||||
</p>
|
||||
|
||||
<div>
|
||||
<h2>Input Image</h2>
|
||||
<div>
|
||||
<input type="file" data-file-input />
|
||||
</div>
|
||||
<p data-file-error style="color:red;display:none;"></p>
|
||||
<canvas data-input-preview style="border:1px solid black;"></canvas>
|
||||
</div>
|
||||
|
||||
<div>
|
||||
<h2>Palette</h2>
|
||||
<div>
|
||||
<button data-palette-add>Add Color</button>
|
||||
<button data-palette-append>Append Palette</button>
|
||||
<button data-palette-clear>Clear Palette</button>
|
||||
<button data-palette-optimize>Optimize Palette</button>
|
||||
</div>
|
||||
|
||||
<div data-palette-entries style="display:grid;grid-template-columns:repeat(auto-fill, minmax(400px, 1fr));gap:16px;margin-top:16px;"></div>
|
||||
</div>
|
||||
|
||||
<div>
|
||||
<label>
|
||||
Preview Background:
|
||||
<button data-page-bg-white>White</button>
|
||||
<button data-page-bg-transparent>Black</button>
|
||||
<button data-page-bg-checkerboard>Checkerboard</button>
|
||||
<button data-page-bg-magenta>Magenta</button>
|
||||
<button data-page-bg-blue>Blue</button>
|
||||
<button data-page-bg-green>Green</button>
|
||||
</label>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div>
|
||||
<h2>Palette Preview</h2>
|
||||
|
||||
<h3>Palette</h3>
|
||||
<div>
|
||||
<button data-palette-download>Download Palette</button>
|
||||
</div>
|
||||
<canvas data-palette-preview style="border:1px solid black;"></canvas>
|
||||
<p data-palette-information></p>
|
||||
|
||||
<h3>Indexed Image</h3>
|
||||
<div>
|
||||
<button data-indexed-download>Download Indexed Image</button>
|
||||
</div>
|
||||
<div data-output-error style="color:red;display:none;"></div>
|
||||
<div>
|
||||
<label>
|
||||
Preview Scale:
|
||||
<input type="number" value="2" data-indexed-preview-scale min="1" step="1" />
|
||||
</label>
|
||||
</div>
|
||||
<canvas data-output-preview style="border:1px solid black;"></canvas>
|
||||
</div>
|
||||
</body>
|
||||
|
||||
<script type="text/javascript">
|
||||
const elError = document.querySelector('[data-file-error]');
|
||||
const elFile = document.querySelector('[data-file-input]');
|
||||
const elInputPreview = document.querySelector('[data-input-preview]');
|
||||
const elPalettePreview = document.querySelector('[data-palette-preview]');
|
||||
const elOutputPreview = document.querySelector('[data-output-preview]');
|
||||
const elPaletteInformation = document.querySelector('[data-palette-information]');
|
||||
const elSourceFromInput = document.querySelector('[data-source-from-input]');
|
||||
const elPaletteAdd = document.querySelector('[data-palette-add]');
|
||||
const elPaletteEntries = document.querySelector('[data-palette-entries]');
|
||||
const elPreviewScale = document.querySelector('[data-indexed-preview-scale]');
|
||||
const elClearPalette = document.querySelector('[data-palette-clear]');
|
||||
const elAppendPalette = document.querySelector('[data-palette-append]');
|
||||
const elOutputError = document.querySelector('[data-output-error]');
|
||||
const elOptimizePalette = document.querySelector('[data-palette-optimize]');
|
||||
const btnBackgroundWhite = document.querySelector('[data-page-bg-white]');
|
||||
const btnBackgroundTransparent = document.querySelector('[data-page-bg-transparent]');
|
||||
const btnBackgroundCheckerboard = document.querySelector('[data-page-bg-checkerboard]');
|
||||
const btnBackgroundMagenta = document.querySelector('[data-page-bg-magenta]');
|
||||
const btnBackgroundBlue = document.querySelector('[data-page-bg-blue]');
|
||||
const btnBackgroundGreen = document.querySelector('[data-page-bg-green]');
|
||||
const btnDownloadPalette = document.querySelector('[data-palette-download]');
|
||||
const btnDownloadImage = document.querySelector('[data-indexed-download]');
|
||||
|
||||
let imageWidth = 0;
|
||||
let imageHeight = 0;
|
||||
let palette = [];// Array of [ r, g, b, a ]
|
||||
let indexedImage = [ ];// Array of indexes
|
||||
|
||||
const nextPowerOfTwo = (x) => {
|
||||
return Math.pow(2, Math.ceil(Math.log2(x)));
|
||||
}
|
||||
|
||||
const sourcePaletteFromImage = (image) => {
|
||||
// Get unique colors
|
||||
const elCanvas = document.createElement('canvas');
|
||||
elCanvas.width = image.width;
|
||||
elCanvas.height = image.height;
|
||||
const ctx = elCanvas.getContext('2d');
|
||||
ctx.drawImage(image, 0, 0);
|
||||
const imageData = ctx.getImageData(0, 0, image.width, image.height);
|
||||
const data = imageData.data;
|
||||
|
||||
const palette = [];
|
||||
for(let i = 0; i < data.length; i += 4) {
|
||||
const color = [ data[i], data[i + 1], data[i + 2], data[i + 3] ];
|
||||
if(!palette.some(c => c[0] === color[0] && c[1] === color[1] && c[2] === color[2] && c[3] === color[3])) {
|
||||
palette.push(color);
|
||||
}
|
||||
}
|
||||
return palette;
|
||||
}
|
||||
|
||||
const updateOutput = () => {
|
||||
elOutputError.style.display = 'none';
|
||||
|
||||
// Update palette preview
|
||||
const paletteScale = 8;
|
||||
const uniquePalette = palette.filter((color, index) => {
|
||||
if(color[3] === 0) {
|
||||
// Find any other fully transparent pixel.
|
||||
return index === palette.findIndex(c => c[3] === 0);
|
||||
}
|
||||
return index === palette.findIndex(c => c[0] === color[0] && c[1] === color[1] && c[2] === color[2] && c[3] === color[3]);
|
||||
});
|
||||
elPalettePreview.width = uniquePalette.length * paletteScale;
|
||||
elPalettePreview.height = paletteScale;
|
||||
const paletteCtx = elPalettePreview.getContext('2d');
|
||||
uniquePalette.forEach((color, index) => {
|
||||
paletteCtx.fillStyle = `rgba(${color[0]}, ${color[1]}, ${color[2]}, ${color[3] / 255})`;
|
||||
paletteCtx.fillRect(index * paletteScale, 0, paletteScale, paletteScale);
|
||||
});
|
||||
elPaletteInformation.textContent = `Palette contains ${uniquePalette.length} colors (${palette.length - uniquePalette.length} duplicates).`;
|
||||
|
||||
// Update palette entries
|
||||
elPaletteEntries.innerHTML = '';
|
||||
palette.forEach((color, index) => {
|
||||
const entry = document.createElement('div');
|
||||
|
||||
const epar = document.createElement('span');
|
||||
epar.textContent = `Index ${index}`;
|
||||
|
||||
const ecolor = document.createElement('span');
|
||||
ecolor.style.display = 'inline-block';
|
||||
ecolor.style.width = '16px';
|
||||
ecolor.style.height = '16px';
|
||||
ecolor.style.marginLeft = '8px';
|
||||
ecolor.style.backgroundColor = `rgba(${color[0]}, ${color[1]}, ${color[2]}, ${color[3] / 255})`;
|
||||
ecolor.style.border = '1px solid black';
|
||||
|
||||
const header = document.createElement('div');
|
||||
header.appendChild(epar);
|
||||
header.appendChild(ecolor);
|
||||
|
||||
const inputR = document.createElement('input');
|
||||
inputR.type = 'number';
|
||||
inputR.value = color[0];
|
||||
inputR.min = 0;
|
||||
inputR.max = 255;
|
||||
inputR.setAttribute('data-palette-index', index);
|
||||
inputR.setAttribute('data-palette-channel', '0');
|
||||
inputR.addEventListener('change', (event) => {
|
||||
const idx = parseInt(event.target.getAttribute('data-palette-index'));
|
||||
const channel = parseInt(event.target.getAttribute('data-palette-channel'));
|
||||
const value = parseInt(event.target.value);
|
||||
if(isNaN(value) || value < 0 || value > 255) {
|
||||
event.target.value = palette[idx][channel];
|
||||
return;
|
||||
}
|
||||
palette[idx][channel] = value;
|
||||
updateOutput();
|
||||
});
|
||||
|
||||
const inputG = document.createElement('input');
|
||||
inputG.type = 'number';
|
||||
inputG.value = color[1];
|
||||
inputG.min = 0;
|
||||
inputG.max = 255;
|
||||
inputG.setAttribute('data-palette-index', index);
|
||||
inputG.setAttribute('data-palette-channel', '1');
|
||||
inputG.addEventListener('change', (event) => {
|
||||
const idx = parseInt(event.target.getAttribute('data-palette-index'));
|
||||
const channel = parseInt(event.target.getAttribute('data-palette-channel'));
|
||||
const value = parseInt(event.target.value);
|
||||
if(isNaN(value) || value < 0 || value > 255) {
|
||||
event.target.value = palette[idx][channel];
|
||||
return;
|
||||
}
|
||||
palette[idx][channel] = value;
|
||||
updateOutput();
|
||||
});
|
||||
|
||||
const inputB = document.createElement('input');
|
||||
inputB.type = 'number';
|
||||
inputB.value = color[2];
|
||||
inputB.min = 0;
|
||||
inputB.max = 255;
|
||||
inputB.setAttribute('data-palette-index', index);
|
||||
inputB.setAttribute('data-palette-channel', '2');
|
||||
inputB.addEventListener('change', (event) => {
|
||||
const idx = parseInt(event.target.getAttribute('data-palette-index'));
|
||||
const channel = parseInt(event.target.getAttribute('data-palette-channel'));
|
||||
const value = parseInt(event.target.value);
|
||||
if(isNaN(value) || value < 0 || value > 255) {
|
||||
event.target.value = palette[idx][channel];
|
||||
return;
|
||||
}
|
||||
palette[idx][channel] = value;
|
||||
updateOutput();
|
||||
});
|
||||
|
||||
const inputA = document.createElement('input');
|
||||
inputA.type = 'number';
|
||||
inputA.value = color[3];
|
||||
inputA.min = 0;
|
||||
inputA.max = 255;
|
||||
inputA.setAttribute('data-palette-index', index);
|
||||
inputA.setAttribute('data-palette-channel', '3');
|
||||
inputA.addEventListener('change', (event) => {
|
||||
const idx = parseInt(event.target.getAttribute('data-palette-index'));
|
||||
const channel = parseInt(event.target.getAttribute('data-palette-channel'));
|
||||
const value = parseInt(event.target.value);
|
||||
if(isNaN(value) || value < 0 || value > 255) {
|
||||
event.target.value = palette[idx][channel];
|
||||
return;
|
||||
}
|
||||
palette[idx][channel] = value;
|
||||
updateOutput();
|
||||
});
|
||||
|
||||
const colorArea = document.createElement('div');
|
||||
colorArea.style.display = 'inline-block';
|
||||
colorArea.appendChild(inputR);
|
||||
colorArea.appendChild(inputG);
|
||||
colorArea.appendChild(inputB);
|
||||
colorArea.appendChild(inputA);
|
||||
|
||||
const buttonArea = document.createElement('div');
|
||||
buttonArea.style.display = 'inline-block';
|
||||
const btnRemove = document.createElement('button');
|
||||
btnRemove.textContent = '-';
|
||||
btnRemove.setAttribute('data-palette-index', index);
|
||||
btnRemove.addEventListener('click', () => {
|
||||
palette.splice(index, 1);
|
||||
updateOutput();
|
||||
});
|
||||
buttonArea.appendChild(btnRemove);
|
||||
|
||||
const btnUp = document.createElement('button');
|
||||
btnUp.textContent = '↑';
|
||||
btnUp.setAttribute('data-palette-index', index);
|
||||
btnUp.addEventListener('click', () => {
|
||||
if(index === 0) return;
|
||||
const temp = palette[index - 1];
|
||||
palette[index - 1] = palette[index];
|
||||
palette[index] = temp;
|
||||
updateOutput();
|
||||
});
|
||||
buttonArea.appendChild(btnUp);
|
||||
|
||||
const btnDown = document.createElement('button');
|
||||
btnDown.textContent = '↓';
|
||||
btnDown.setAttribute('data-palette-index', index);
|
||||
btnDown.addEventListener('click', () => {
|
||||
if(index === palette.length - 1) return;
|
||||
const temp = palette[index + 1];
|
||||
palette[index + 1] = palette[index];
|
||||
palette[index] = temp;
|
||||
updateOutput();
|
||||
});
|
||||
buttonArea.appendChild(btnDown);
|
||||
|
||||
const footer = document.createElement('div');
|
||||
footer.appendChild(colorArea);
|
||||
footer.appendChild(buttonArea);
|
||||
|
||||
entry.appendChild(header);
|
||||
entry.appendChild(footer);
|
||||
elPaletteEntries.appendChild(entry);
|
||||
});
|
||||
|
||||
// Image ready?
|
||||
if(!imageWidth || !imageHeight) return;
|
||||
|
||||
// Update indexed image preview
|
||||
elOutputPreview.width = imageWidth;
|
||||
elOutputPreview.height = imageHeight;
|
||||
const outputCtx = elOutputPreview.getContext('2d');
|
||||
const outputImageData = outputCtx.createImageData(imageWidth, imageHeight);
|
||||
const outputData = outputImageData.data;
|
||||
indexedImage.forEach((index, i) => {
|
||||
let color;
|
||||
if(palette.length <= index) {
|
||||
elOutputError.textContent = `Indexed image references non-existent palette index ${index}.`;
|
||||
elOutputError.style.display = 'block';
|
||||
color = [0, 0, 0, 0];
|
||||
} else {
|
||||
color = palette[index];
|
||||
}
|
||||
outputData[i * 4] = color[0];
|
||||
outputData[i * 4 + 1] = color[1];
|
||||
outputData[i * 4 + 2] = color[2];
|
||||
outputData[i * 4 + 3] = color[3];
|
||||
});
|
||||
outputCtx.putImageData(outputImageData, 0, 0);
|
||||
|
||||
if(elOutputError.style.display === 'none') {;
|
||||
const unusedPaletteIndexes = palette.map((color, index) => {
|
||||
return indexedImage.includes(index) ? null : index;
|
||||
}).filter(Boolean);
|
||||
if(unusedPaletteIndexes.length > 0) {
|
||||
elOutputError.textContent = `Image does not use palette colors; ${unusedPaletteIndexes.join(', ')}.`;
|
||||
elOutputError.style.display = 'block';
|
||||
}
|
||||
}
|
||||
|
||||
// Rescale canvas
|
||||
const scale = parseInt(elPreviewScale.value) || 1;
|
||||
elOutputPreview.style.width = `${imageWidth * scale}px`;
|
||||
elOutputPreview.style.height = `${imageHeight * scale}px`;
|
||||
}
|
||||
|
||||
const onImage = img => {
|
||||
if(!img) return onBadFile('Failed to load image');
|
||||
|
||||
elError.style.display = 'none';
|
||||
imageWidth = img.width;
|
||||
imageHeight = img.height;
|
||||
indexedImage = [];
|
||||
|
||||
// Update input preview
|
||||
elInputPreview.width = imageWidth;
|
||||
elInputPreview.height = imageHeight;
|
||||
const ctx = elInputPreview.getContext('2d');
|
||||
ctx.drawImage(img, 0, 0);
|
||||
|
||||
// Source palette from input image
|
||||
palette = sourcePaletteFromImage(img);
|
||||
|
||||
// Index the image
|
||||
const imageData = ctx.getImageData(0, 0, imageWidth, imageHeight);
|
||||
const data = imageData.data;
|
||||
for(let i = 0; i < data.length; i += 4) {
|
||||
const color = [ data[i], data[i + 1], data[i + 2], data[i + 3] ];
|
||||
const colorIndex = palette.findIndex(c => c[0] === color[0] && c[1] === color[1] && c[2] === color[2] && c[3] === color[3]);
|
||||
indexedImage.push(colorIndex);
|
||||
}
|
||||
|
||||
updateOutput();
|
||||
}
|
||||
|
||||
const onPalettizedImage = dataView => {
|
||||
if(!dataView) return onBadFile('Failed to load image');
|
||||
|
||||
// Ensure DPT and ver is 1
|
||||
if(dataView.getUint8(0) !== 0x44 || dataView.getUint8(1) !== 0x50 || dataView.getUint8(2) !== 0x54 || dataView.getUint8(3) !== 0x01) {
|
||||
return onBadFile('Invalid DPT file. Expected header "DPT" and version 1.');
|
||||
}
|
||||
|
||||
// Width and Height
|
||||
elError.style.display = 'none';
|
||||
imageWidth = dataView.getUint32(3);
|
||||
imageHeight = dataView.getUint32(7);
|
||||
|
||||
if(imageWidth <= 0 || imageHeight <= 0) {
|
||||
return onBadFile('Invalid image dimensions in DPT file.');
|
||||
}
|
||||
|
||||
if(dataView.byteLength < 11 + imageWidth * imageHeight) {
|
||||
return onBadFile('DPT file does not contain enough data for the specified dimensions.');
|
||||
}
|
||||
|
||||
const uniqueIndexes = []
|
||||
|
||||
// Image data
|
||||
indexedImage = [];
|
||||
for(let i = 11; i < dataView.byteLength; i++) {
|
||||
const index = dataView.getUint8(i);
|
||||
if(!uniqueIndexes.includes(index)) uniqueIndexes.push(index);
|
||||
indexedImage.push(index);
|
||||
}
|
||||
|
||||
const adhocPalette = [];
|
||||
for(let i = 0; i < uniqueIndexes.length; i++) {
|
||||
const index = uniqueIndexes[i];
|
||||
// Get the most different possible color for this index
|
||||
const color = [
|
||||
(index * 37) % 256,
|
||||
(index * 61) % 256,
|
||||
(index * 97) % 256,
|
||||
255
|
||||
];
|
||||
adhocPalette[index] = color;
|
||||
}
|
||||
|
||||
elInputPreview.width = imageWidth;
|
||||
elInputPreview.height = imageHeight;
|
||||
const ctx = elInputPreview.getContext('2d');
|
||||
const imageData = ctx.createImageData(imageWidth, imageHeight);
|
||||
const data = imageData.data;
|
||||
indexedImage.forEach((index, i) => {
|
||||
const color = adhocPalette[index] || [0, 0, 0, 0];
|
||||
data[i * 4] = color[0];
|
||||
data[i * 4 + 1] = color[1];
|
||||
data[i * 4 + 2] = color[2];
|
||||
data[i * 4 + 3] = color[3];
|
||||
});
|
||||
ctx.putImageData(imageData, 0, 0);
|
||||
|
||||
updateOutput();
|
||||
}
|
||||
|
||||
const onBadFile = err => {
|
||||
elError.textContent = err;
|
||||
elError.style.display = 'block';
|
||||
updateOutput();
|
||||
}
|
||||
|
||||
const onFile = file => {
|
||||
// Reset preview
|
||||
elInputPreview.width = 0;
|
||||
elInputPreview.height = 0;
|
||||
image = null;
|
||||
|
||||
if(!file) {
|
||||
onImage(null);
|
||||
return;
|
||||
}
|
||||
|
||||
// If file is image, load as image.
|
||||
if(file.type.startsWith('image/')) {
|
||||
elError.style.display = 'none';
|
||||
const reader = new FileReader();
|
||||
reader.onload = (event) => {
|
||||
const img = new Image();
|
||||
img.onload = () => onImage(img);
|
||||
img.onerror = () => onImage(null);
|
||||
img.src = event.target.result;
|
||||
};
|
||||
reader.onerror = () => onImage(null);
|
||||
reader.readAsDataURL(file);
|
||||
return;
|
||||
|
||||
} else if(file.name.endsWith('.dpt')) {
|
||||
elError.style.display = 'none';
|
||||
const reader = new FileReader();
|
||||
reader.onload = (event) => {
|
||||
const arrayBuffer = event.target.result;
|
||||
const dataView = new DataView(arrayBuffer);
|
||||
onPalettizedImage(dataView);
|
||||
};
|
||||
reader.onerror = () => onPalettizedImage(null);
|
||||
reader.readAsArrayBuffer(file);
|
||||
return;
|
||||
}
|
||||
|
||||
onBadFile('Selected file is not a supported image type.');
|
||||
return;
|
||||
}
|
||||
|
||||
// Listeners
|
||||
btnBackgroundWhite.addEventListener('click', () => {
|
||||
document.body.style.background = 'white';
|
||||
});
|
||||
btnBackgroundTransparent.addEventListener('click', () => {
|
||||
document.body.style.background = 'black';
|
||||
});
|
||||
btnBackgroundCheckerboard.addEventListener('click', () => {
|
||||
document.body.style.background = 'repeating-conic-gradient(#ccc 0% 25%, #eee 0% 50%) 50% / 20px 20px';
|
||||
});
|
||||
btnBackgroundMagenta.addEventListener('click', () => {
|
||||
document.body.style.background = 'magenta';
|
||||
});
|
||||
btnBackgroundBlue.addEventListener('click', () => {
|
||||
document.body.style.background = 'blue';
|
||||
});
|
||||
btnBackgroundGreen.addEventListener('click', () => {
|
||||
document.body.style.background = 'green';
|
||||
});
|
||||
|
||||
elFile.addEventListener('change', (event) => {
|
||||
onFile(event?.target?.files[0]);
|
||||
});
|
||||
elPaletteAdd.addEventListener('click', () => {
|
||||
// Add new random color to palette
|
||||
const newColor = [ Math.floor(Math.random() * 256), Math.floor(Math.random() * 256), Math.floor(Math.random() * 256), 255 ];
|
||||
palette.push(newColor);
|
||||
updateOutput();
|
||||
});
|
||||
elPreviewScale.addEventListener('change', () => {
|
||||
updateOutput();
|
||||
});
|
||||
elClearPalette.addEventListener('click', () => {
|
||||
palette = [];
|
||||
updateOutput();
|
||||
});
|
||||
|
||||
elOptimizePalette.addEventListener('click', () => {
|
||||
// Remove unused colors and duplicates from the palette. Treat A=0 as equal
|
||||
const newPalette = [];
|
||||
const indexMap = {};
|
||||
palette.forEach((color, index) => {
|
||||
// Check if color is already in new palette
|
||||
const existingIndex = newPalette.findIndex(c => {
|
||||
if(c[3] === 0 && color[3] === 0) return true;
|
||||
return c[0] === color[0] && c[1] === color[1] && c[2] === color[2] && c[3] === color[3];
|
||||
});
|
||||
if(existingIndex !== -1) {
|
||||
indexMap[index] = existingIndex;
|
||||
} else {
|
||||
indexMap[index] = newPalette.length;
|
||||
newPalette.push(color);
|
||||
}
|
||||
});
|
||||
|
||||
palette = newPalette;
|
||||
|
||||
updateOutput();
|
||||
});
|
||||
|
||||
elAppendPalette.addEventListener('click', () => {
|
||||
// Open file picker
|
||||
const input = document.createElement('input');
|
||||
input.type = 'file';
|
||||
input.addEventListener('change', (event) => {
|
||||
const file = event.target.files[0];
|
||||
if(!file) return;
|
||||
|
||||
// Accept either images or .dpf files
|
||||
if(file.type.startsWith('image/')) {
|
||||
const reader = new FileReader();
|
||||
reader.onload = (event) => {
|
||||
const img = new Image();
|
||||
img.onload = () => {
|
||||
const newColors = sourcePaletteFromImage(img);
|
||||
palette = palette.concat(newColors);
|
||||
updateOutput();
|
||||
};
|
||||
img.onerror = () => {
|
||||
alert('Failed to load image for palette appending.');
|
||||
};
|
||||
img.src = event.target.result;
|
||||
};
|
||||
reader.onerror = () => {
|
||||
alert('Failed to load image for palette appending.');
|
||||
};
|
||||
reader.readAsDataURL(file);
|
||||
return;
|
||||
} else if(file.name.endsWith('.dpf')) {
|
||||
const reader = new FileReader();
|
||||
reader.onload = (event) => {
|
||||
const arrayBuffer = event.target.result;
|
||||
const dataView = new DataView(arrayBuffer);
|
||||
|
||||
// Validate header
|
||||
if(dataView.getUint8(0) !== 0x44 || dataView.getUint8(1) !== 0x50 || dataView.getUint8(2) !== 0x46) {
|
||||
alert('Invalid DPF file.');
|
||||
return;
|
||||
}
|
||||
|
||||
const colorCount = dataView.getUint32(4);
|
||||
const expectedLength = 4 * colorCount + 8;// 3 DPF, 1 ver, 4 color count
|
||||
if(arrayBuffer.byteLength !== expectedLength) {
|
||||
alert('DPF file size does not match expected color count.');
|
||||
return;
|
||||
}
|
||||
|
||||
let offset = 8;
|
||||
for(let i = 0; i < colorCount; i++) {
|
||||
const r = dataView.getUint8(offset);
|
||||
const g = dataView.getUint8(offset + 1);
|
||||
const b = dataView.getUint8(offset + 2);
|
||||
const a = dataView.getUint8(offset + 3);
|
||||
palette.push([r, g, b, a]);
|
||||
offset += 4;
|
||||
}
|
||||
|
||||
updateOutput();
|
||||
};
|
||||
reader.onerror = () => {
|
||||
alert('Failed to load DPF file for palette appending.');
|
||||
};
|
||||
reader.readAsArrayBuffer(file);
|
||||
return;
|
||||
} else {
|
||||
alert('Unsupported file type for palette appending. Please use an image file.');
|
||||
}
|
||||
});
|
||||
|
||||
input.click();
|
||||
});
|
||||
|
||||
btnDownloadPalette.addEventListener('click', () => {
|
||||
// Create Dusk Palette File (.dpf)
|
||||
const header = new Uint8Array([0x44, 0x50, 0x46, 0x01]); // 'DPF' + version 1 + number of colors (4 bytes)
|
||||
|
||||
const colorCount = palette.length;
|
||||
const colorCountBytes = new Uint8Array(4);
|
||||
colorCountBytes[0] = (colorCount >> 24) & 0xFF;
|
||||
colorCountBytes[1] = (colorCount >> 16) & 0xFF;
|
||||
colorCountBytes[2] = (colorCount >> 8) & 0xFF;
|
||||
colorCountBytes[3] = colorCount & 0xFF;
|
||||
|
||||
// add color data (palette.length * 4 bytes)
|
||||
const colorData = new Uint8Array(palette.length * 4);
|
||||
palette.forEach((color, index) => {
|
||||
colorData[index * 4] = color[0];
|
||||
colorData[index * 4 + 1] = color[1];
|
||||
colorData[index * 4 + 2] = color[2];
|
||||
colorData[index * 4 + 3] = color[3];
|
||||
});
|
||||
|
||||
const blob = new Blob([header, colorCountBytes, colorData], { type: 'application/octet-stream' });
|
||||
const url = URL.createObjectURL(blob);
|
||||
const a = document.createElement('a');
|
||||
a.href = url;
|
||||
a.download = 'palette.dpf';
|
||||
document.body.appendChild(a);
|
||||
a.click();
|
||||
document.body.removeChild(a);
|
||||
URL.revokeObjectURL(url);
|
||||
});
|
||||
|
||||
btnDownloadImage.addEventListener('click', () => {
|
||||
const header = new Uint8Array([0x44, 0x50, 0x54, 0x01]); // 'DPT' + version 1
|
||||
|
||||
// Width
|
||||
const widthBytes = new Uint8Array(4);
|
||||
widthBytes[0] = (imageWidth >> 24) & 0xFF;
|
||||
widthBytes[1] = (imageWidth >> 16) & 0xFF;
|
||||
widthBytes[2] = (imageWidth >> 8) & 0xFF;
|
||||
widthBytes[3] = imageWidth & 0xFF;
|
||||
|
||||
// Height
|
||||
const heightBytes = new Uint8Array(4);
|
||||
heightBytes[0] = (imageHeight >> 24) & 0xFF;
|
||||
heightBytes[1] = (imageHeight >> 16) & 0xFF;
|
||||
heightBytes[2] = (imageHeight >> 8) & 0xFF;
|
||||
heightBytes[3] = imageHeight & 0xFF;
|
||||
|
||||
// add indexed image data (imageWidth * imageHeight bytes)
|
||||
const imageData = new Uint8Array(indexedImage.length);
|
||||
indexedImage.forEach((index, i) => {
|
||||
imageData[i] = index;
|
||||
});
|
||||
|
||||
const blob = new Blob([header, widthBytes, heightBytes, imageData], { type: 'application/octet-stream' });
|
||||
const url = URL.createObjectURL(blob);
|
||||
const a = document.createElement('a');
|
||||
a.href = url;
|
||||
a.download = 'indexed_image.dpt';
|
||||
document.body.appendChild(a);
|
||||
a.click();
|
||||
document.body.removeChild(a);
|
||||
URL.revokeObjectURL(url);
|
||||
});
|
||||
|
||||
updateOutput();
|
||||
btnBackgroundCheckerboard.click();
|
||||
</script>
|
||||
</html>
|
||||
@@ -1,7 +1,6 @@
|
||||
import argparse
|
||||
import os
|
||||
import csv
|
||||
from tools.util.type import detectType, stringToCType, typeToCType
|
||||
|
||||
parser = argparse.ArgumentParser(description="Story CSV to .h defines")
|
||||
parser.add_argument("--csv", required=True, help="Path to story CSV file")
|
||||
|
||||
223
tools/tile-joiner.html
Normal file
223
tools/tile-joiner.html
Normal file
@@ -0,0 +1,223 @@
|
||||
<!DOCTYPE html>
|
||||
<html lang="en">
|
||||
<head>
|
||||
<meta charset="UTF-8" />
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
|
||||
<title>Dusk Tools / Tile Joiner</title>
|
||||
|
||||
<style type="text/css">
|
||||
* {
|
||||
box-sizing: border-box;
|
||||
}
|
||||
|
||||
body {
|
||||
font-size: 16px;
|
||||
}
|
||||
|
||||
canvas {
|
||||
image-rendering: pixelated;
|
||||
}
|
||||
</style>
|
||||
</head>
|
||||
|
||||
<body>
|
||||
<h1>Dusk Tile Joiner</h1>
|
||||
<p>
|
||||
Joins multiple tiles together into a single tileset image. Optimizing and
|
||||
allowing it to work on multiple platforms. Output width and height will
|
||||
always be a power of two. This tool will take a while to process images,
|
||||
since all images need to be loaded into memory.
|
||||
</p>
|
||||
|
||||
<div>
|
||||
<div>
|
||||
<input type="file" data-file-input multiple />
|
||||
</div>
|
||||
<p data-file-error style="color:red;display:none;"></p>
|
||||
<textarea readonly data-input-information rows="10" style="width:500px"></textarea>
|
||||
</div>
|
||||
|
||||
<div>
|
||||
<h2>Settings</h2>
|
||||
|
||||
<div>
|
||||
<label>
|
||||
Preview Background:
|
||||
<button data-page-bg-white>White</button>
|
||||
<button data-page-bg-transparent>Black</button>
|
||||
<button data-page-bg-checkerboard>Checkerboard</button>
|
||||
<button data-page-bg-magenta>Magenta</button>
|
||||
<button data-page-bg-blue>Blue</button>
|
||||
<button data-page-bg-green>Green</button>
|
||||
</label>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div>
|
||||
<h2>Joined Preview</h2>
|
||||
<div>
|
||||
<button data-download>Download Joined Image</button>
|
||||
</div>
|
||||
<canvas data-preview-canvas style="border:1px solid black;"></canvas>
|
||||
</div>
|
||||
</body>
|
||||
|
||||
<script type="text/javascript">
|
||||
const elFileInput = document.querySelector('[data-file-input]');
|
||||
const elFileError = document.querySelector('[data-file-error]');
|
||||
const elInputInformation = document.querySelector('[data-input-information]');
|
||||
const elPreviewCanvas = document.querySelector('[data-preview-canvas]');
|
||||
const btnDownload = document.querySelector('[data-download]');
|
||||
const btnBackgroundWhite = document.querySelector('[data-page-bg-white]');
|
||||
const btnBackgroundTransparent = document.querySelector('[data-page-bg-transparent]');
|
||||
const btnBackgroundCheckerboard = document.querySelector('[data-page-bg-checkerboard]');
|
||||
const btnBackgroundMagenta = document.querySelector('[data-page-bg-magenta]');
|
||||
const btnBackgroundBlue = document.querySelector('[data-page-bg-blue]');
|
||||
const btnBackgroundGreen = document.querySelector('[data-page-bg-green]');
|
||||
|
||||
let images = {};
|
||||
|
||||
// Methods
|
||||
const nextPowerOfTwo = n => {
|
||||
if(n <= 0) return 1;
|
||||
return 2 ** Math.ceil(Math.log2(n));
|
||||
}
|
||||
|
||||
const onBadImages = error => {
|
||||
elInputInformation.value = '';
|
||||
elFileError.style.display = 'block';
|
||||
elFileError.textContent = error;
|
||||
}
|
||||
|
||||
const onImages = () => {
|
||||
if(!images || Object.keys(images).length <= 1) {
|
||||
return onBadImages('Please select 2 or more image images.');
|
||||
}
|
||||
|
||||
elFileError.style.display = 'none';
|
||||
|
||||
let strInfo = `Selected ${Object.keys(images).length} images:\n`;
|
||||
for(const [name, img] of Object.entries(images)) {
|
||||
strInfo += `- ${name}: ${img.width}x${img.height}\n`;
|
||||
}
|
||||
elInputInformation.value = strInfo;
|
||||
|
||||
// Determine output width and height to pack images together, must be a
|
||||
// power of two. If all images share a given axis (width/height) and that
|
||||
// axis is already a power of two, use that.
|
||||
const firstWidth = Object.values(images)[0].width;
|
||||
const firstHeight = Object.values(images)[0].height;
|
||||
let allImagesShareWidth = Object.values(images).every(img => img.width === firstWidth);
|
||||
let allImagesShareHeight = Object.values(images).every(img => img.height === firstHeight);
|
||||
|
||||
let outputHeight, outputWidth;
|
||||
|
||||
if(allImagesShareWidth && nextPowerOfTwo(firstWidth) === firstWidth) {
|
||||
outputWidth = firstWidth;
|
||||
outputHeight = nextPowerOfTwo(Object.values(images).reduce((sum, img) => sum + img.height, 0));
|
||||
} else if(allImagesShareHeight && nextPowerOfTwo(firstHeight) === firstHeight) {
|
||||
outputHeight = firstHeight;
|
||||
outputWidth = nextPowerOfTwo(Object.values(images).reduce((sum, img) => sum + img.width, 0));
|
||||
} else {
|
||||
onBadImages('All images must share the same width or height, and that dimension must be a power of two.');
|
||||
}
|
||||
|
||||
// Update preview
|
||||
elPreviewCanvas.width = outputWidth;
|
||||
elPreviewCanvas.height = outputHeight;
|
||||
const ctx = elPreviewCanvas.getContext('2d');
|
||||
let currentX = 0;
|
||||
let currentY = 0;
|
||||
for(const img of Object.values(images)) {
|
||||
ctx.drawImage(img, currentX, currentY);
|
||||
if(allImagesShareWidth) {
|
||||
currentY += img.height;
|
||||
} else {
|
||||
currentX += img.width;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const onFiles = async files => {
|
||||
images = {};
|
||||
|
||||
if(!files || files.length <= 1) {
|
||||
return onBadImages('Please select 2 or more image files.');
|
||||
}
|
||||
|
||||
let strError = '';
|
||||
for(const file of files) {
|
||||
if(!file.type.startsWith('image/')) {
|
||||
strError += `File is not an image: ${file.name}\n`;
|
||||
}
|
||||
}
|
||||
if(strError) {
|
||||
return onBadImages(strError);
|
||||
}
|
||||
|
||||
try {
|
||||
const fileImages = await Promise.all(Array.from(files).map(file => {
|
||||
return new Promise((resolve, reject) => {
|
||||
const reader = new FileReader();
|
||||
reader.onload = event => {
|
||||
const img = new Image();
|
||||
img.onload = () => {
|
||||
images[file.name] = img;
|
||||
resolve();
|
||||
}
|
||||
img.onerror = () => {
|
||||
reject(`Failed to load image: ${file.name}`);
|
||||
}
|
||||
img.src = event.target.result;
|
||||
}
|
||||
reader.onerror = () => {
|
||||
reject(`Failed to read file: ${file.name}`);
|
||||
}
|
||||
reader.readAsDataURL(file);
|
||||
});
|
||||
}));
|
||||
} catch(error) {
|
||||
return onBadImages(error);
|
||||
}
|
||||
|
||||
onImages();
|
||||
}
|
||||
|
||||
// Listeners
|
||||
elFileInput.addEventListener('change', event => {
|
||||
onFiles(event?.target?.files);
|
||||
});
|
||||
|
||||
btnBackgroundWhite.addEventListener('click', () => {
|
||||
document.body.style.background = 'white';
|
||||
});
|
||||
btnBackgroundTransparent.addEventListener('click', () => {
|
||||
document.body.style.background = 'black';
|
||||
});
|
||||
btnBackgroundCheckerboard.addEventListener('click', () => {
|
||||
document.body.style.background = 'repeating-conic-gradient(#ccc 0% 25%, #eee 0% 50%) 50% / 20px 20px';
|
||||
});
|
||||
btnBackgroundMagenta.addEventListener('click', () => {
|
||||
document.body.style.background = 'magenta';
|
||||
});
|
||||
btnBackgroundBlue.addEventListener('click', () => {
|
||||
document.body.style.background = 'blue';
|
||||
});
|
||||
btnBackgroundGreen.addEventListener('click', () => {
|
||||
document.body.style.background = 'green';
|
||||
});
|
||||
|
||||
btnDownload.addEventListener('click', () => {
|
||||
if(!images || Object.keys(images).length <= 1) {
|
||||
return onBadImages('Please select 2 or more image files before downloading.');
|
||||
}
|
||||
|
||||
const link = document.createElement('a');
|
||||
link.download = 'joined.png';
|
||||
link.href = elPreviewCanvas.toDataURL();
|
||||
link.click();
|
||||
});
|
||||
|
||||
btnBackgroundCheckerboard.click();
|
||||
</script>
|
||||
</html>
|
||||
391
tools/tile-slicer.html
Normal file
391
tools/tile-slicer.html
Normal file
File diff suppressed because one or more lines are too long
@@ -1,44 +0,0 @@
|
||||
def detectType(value: str) -> str:
|
||||
val = value.strip()
|
||||
# Boolean check
|
||||
if val.lower() in {'true', 'false'}:
|
||||
return 'Boolean'
|
||||
|
||||
# Int check
|
||||
try:
|
||||
int(val)
|
||||
return 'Int'
|
||||
except ValueError:
|
||||
pass
|
||||
|
||||
# Float check
|
||||
try:
|
||||
float(val)
|
||||
return 'Float'
|
||||
except ValueError:
|
||||
pass
|
||||
|
||||
# Default to String
|
||||
return 'String'
|
||||
|
||||
def typeToCType(valType: str) -> str:
|
||||
if valType == 'Int':
|
||||
return 'int'
|
||||
elif valType == 'Float':
|
||||
return 'float'
|
||||
elif valType == 'Boolean':
|
||||
return 'bool'
|
||||
else:
|
||||
return 'char_t*'
|
||||
|
||||
def stringToCType(value: str) -> str:
|
||||
valType = detectType(value)
|
||||
if valType == 'Int':
|
||||
return str(int(value))
|
||||
elif valType == 'Float':
|
||||
return str(float(value))
|
||||
elif valType == 'Boolean':
|
||||
return 'true' if value.lower() == 'true' else 'false'
|
||||
else:
|
||||
escaped = value.replace('\\', '\\\\').replace('"', '\\"')
|
||||
return f'"{escaped}"'
|
||||
Reference in New Issue
Block a user