scripts/tools/gdx-atlas-to-phaser-atlas.py

166 lines
4.6 KiB
Python
Executable File

#!/usr/bin/env python
"""
Archive extract script with sub-directory creation
"""
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
import io
import re
import sys
import json
class GdxAtlasFrame:
imageName = None
rotate = None
xy = None
size = None
orig = None
offset = None
index = None
class GdxAtlas:
imageName = None
size = None
format = None
filter = None
repeat = None
frames = []
def serialize(obj):
return (obj.__class__, obj.__dict__)
def main(input):
print(input)
# Read file to file_contents variable
lines = []
with open(input) as f:
for line in f:
lines.append(line)
f.closed
# Now we have the whole atlas file line-by-line in lines variable
# Atlas roughly follows the following format
# First non-empty line => name of the texture file
# size: w,h
# format: <format>
# filter: <filter>,<filter>
# repeat: none
# first non-parameter here is the name of the single image in atlas
# after that there is n parameters (usually the following)
# rotate: true/false
# xy: x,y
# size: w,h
# orig: w,h
# offset: x,y
# index: index
gdxAtlas = GdxAtlas()
state = 'getname'
paramRegex = re.compile('(.+):(.+)')
valueCommaRegex = re.compile('(.+),(.+)')
currentFrame = None
for line in lines:
line = line.rstrip()
if line == '':
continue
if state == 'getname':
gdxAtlas.imageName = line
state = 'getparams'
elif state == 'getparams':
res = paramRegex.findall(line)
if res:
key = res[0][0].strip()
value = res[0][1].strip()
isCommaSeparated = valueCommaRegex.findall(value)
if isCommaSeparated:
a = isCommaSeparated[0][0].strip()
b = isCommaSeparated[0][1].strip()
# header
if currentFrame is None:
if key == 'size':
gdxAtlas.size = (int(a), int(b))
if key == 'format':
gdxAtlas.format = value
if key == 'filter' or key == 'repeat':
print(key + ' is not supported')
# frames
if currentFrame is not None:
if key == 'rotate':
currentFrame.rotate = value
if key == 'xy':
currentFrame.xy = (int(a), int(b))
if key == 'size':
currentFrame.size = (int(a), int(b))
if key == 'orig':
currentFrame.orig = (int(a), int(b))
if key == 'offset':
currentFrame.offset = (int(a), int(b))
else:
# previous state ended!
if currentFrame is not None:
gdxAtlas.frames.append(currentFrame)
currentFrame = GdxAtlasFrame()
currentFrame.imageName = line
else:
print('unknown state')
if currentFrame is not None:
gdxAtlas.frames.append(currentFrame)
json_str = gdxAtlasToPhaserJson(gdxAtlas)
with io.open(input+'.json', 'w', encoding='utf8') as outfile:
outfile.write(str(json_str))
outfile.closed
print('wrote '+ input + '.json')
def printGdxAtlas(gdxAtlas):
print(serialize(gdxAtlas))
for frame in gdxAtlas.frames:
print(serialize(frame))
def gdxAtlasToPhaserJson(gdxAtlas):
print('Converting to json')
data = {
'frames': [],
'meta': {
'app': 'libgdx',
'version': 'latest',
'image': gdxAtlas.imageName,
'format': gdxAtlas.format,
'size': { 'w': gdxAtlas.size[0], 'h': gdxAtlas.size[1] },
'scale': 1
}
}
for frame in gdxAtlas.frames:
framedata = {
'filename': frame.imageName,
'frame': { 'x': frame.xy[0], 'y': frame.xy[1], 'w': frame.size[0], 'h': frame.size[1] },
'rotated': frame.rotate == 'true',
'trimmed': False,
'spriteSourceSize': { 'x': frame.offset[0], 'y': frame.offset[1], 'w': frame.orig[0], 'h': frame.orig[1] },
'sourceSize': { 'w': frame.orig[0], 'h': frame.orig[1] }
}
data['frames'].append(framedata)
json_str = json.dumps(data, indent=4, sort_keys=False, separators=(',', ': '), ensure_ascii=False)
return json_str
if __name__ == "__main__":
main(sys.argv[1])