Mercurial > touhou

comparison stageviewer.py @ 4:787d2eb13c2d

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Add buggy stageviewer!
author Thibaut Girka <thib@sitedethib.com>
date Mon, 01 Aug 2011 17:17:22 +0200
parents
children aa201d8cfc19
comparison
equal deleted inserted replaced
3:ffe0283c27de 4:787d2eb13c2d
1 #!/usr/bin/env python
2
3 import sys
4 import os
5
6 import struct
7 from math import degrees, radians
8 from io import BytesIO
9 from itertools import chain
10
11 import pygame
12
13 import OpenGL
14 OpenGL.FORWARD_COMPATIBLE_ONLY = True
15 from OpenGL.GL import *
16 from OpenGL.GLU import *
17
18 from pytouhou.formats.pbg3 import PBG3
19 from pytouhou.formats.std import Stage
20 from pytouhou.formats.anm0 import Animations
21
22 from pytouhou.utils.matrix import Matrix
23
24
25 def load_texture(image, alpha_image=None):
26 textureSurface = pygame.image.load(image).convert_alpha()
27
28 if alpha_image:
29 alphaSurface = pygame.image.load(alpha_image)
30 assert textureSurface.get_size() == alphaSurface.get_size()
31 for x in range(alphaSurface.get_width()):
32 for y in range(alphaSurface.get_height()):
33 r, g, b, a = textureSurface.get_at((x, y))
34 color2 = alphaSurface.get_at((x, y))
35 textureSurface.set_at((x, y), (r, g, b, color2[0]))
36
37 textureData = pygame.image.tostring(textureSurface, 'RGBA', 1)
38
39 width = textureSurface.get_width()
40 height = textureSurface.get_height()
41
42 texture = glGenTextures(1)
43 glBindTexture(GL_TEXTURE_2D, texture)
44
45 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA,
46 GL_UNSIGNED_BYTE, textureData)
47
48 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
49 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
50
51 return texture, width, height
52
53
54
55 def build_objects_faces(stage, anim):
56 objects_faces = []
57 for i, obj in enumerate(stage.objects):
58 faces = []
59 for script_index, x, y, z, width_override, height_override in obj.quads:
60 #TODO: move mof of it elsewhere
61 vertices = []
62 uvs = []
63 vertmat = Matrix()
64 vertmat.data[0][0] = -.5
65 vertmat.data[1][0] = -.5
66
67 vertmat.data[0][1] = .5
68 vertmat.data[1][1] = -.5
69
70 vertmat.data[0][2] = .5
71 vertmat.data[1][2] = .5
72
73 vertmat.data[0][3] = -.5
74 vertmat.data[1][3] = .5
75
76 for i in range(4):
77 vertmat.data[2][i] = 0.
78 vertmat.data[3][i] = 1.
79
80 properties = {}
81 for time, instr_type, data in anim.scripts[script_index]:
82 if instr_type == 15:
83 properties[15] = b''
84 break
85 elif time == 0: #TODO
86 properties[instr_type] = data
87 #if 15 not in properties: #TODO: Skip properties
88 # continue
89
90 #TODO: properties 3 and 4
91 if 1 in properties:
92 tx, ty, tw, th = anim.sprites[struct.unpack('<I', properties[1])[0]]
93 width, height = 1., 1.
94 if 2 in properties:
95 width, height = struct.unpack('<ff', properties[2])
96 width = width_override or width * 16.
97 height = height_override or height * 16.
98 transform = Matrix.get_scaling_matrix(width, height, 1.)
99 if 7 in properties:
100 transform = Matrix.get_scaling_matrix(-1., 1., 1.).mult(transform)
101 if 9 in properties:
102 rx, ry, rz = struct.unpack('<fff', properties[9])
103 transform = Matrix.get_rotation_matrix(-rx, 'x').mult(transform)
104 transform = Matrix.get_rotation_matrix(ry, 'y').mult(transform)
105 transform = Matrix.get_rotation_matrix(-rz, 'z').mult(transform) #TODO: minus, really?
106 if 23 in properties: # Reposition
107 transform = Matrix.get_translation_matrix(width / 2., height / 2., 0.).mult(transform)
108
109 transform = Matrix.get_translation_matrix(x, y, z).mult(transform)
110 vertmat = transform.mult(vertmat)
111
112 uvs = [(tx / 256., 1. - (ty / 256.)),
113 ((tx + tw) / 256., 1. - (ty / 256.)),
114 ((tx + tw) / 256., 1. - ((ty + th) / 256.)),
115 (tx / 256., 1. - ((ty + th) / 256.))]
116
117 for i in xrange(4):
118 w = vertmat.data[3][i]
119 vertices.append((vertmat.data[0][i] / w, vertmat.data[1][i] / w, vertmat.data[2][i] / w))
120 faces.append((vertices, uvs))
121 objects_faces.append(faces)
122 return objects_faces
123
124
125
126 def objects_faces_to_vertices_uvs(objects):
127 vertices = tuple(vertex for obj in objects for face in obj for vertex in face[0]) #TODO: check
128 uvs = tuple(uv for obj in objects for face in obj for uv in face[1]) #TODO: check
129 return vertices, uvs
130
131
132
133 def main(path, stage_num):
134 # Initialize pygame
135 pygame.init()
136 window = pygame.display.set_mode((384, 448), pygame.OPENGL | pygame.DOUBLEBUF)
137
138 # Initialize OpenGL
139 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST)
140 glEnable(GL_DEPTH_TEST)
141 glEnable(GL_BLEND)
142 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
143 glEnable(GL_TEXTURE_2D)
144 glEnableClientState(GL_VERTEX_ARRAY)
145 glEnableClientState(GL_TEXTURE_COORD_ARRAY)
146
147 # Load data
148 with open(path, 'rb') as file:
149 archive = PBG3.read(file)
150 stage = Stage.read(BytesIO(archive.extract('stage%d.std' % stage_num)))
151 anim = Animations.read(BytesIO(archive.extract('stg%dbg.anm' % stage_num)))
152 textures_components = [None, None]
153 for i, component_name in enumerate((anim.first_name, anim.secondary_name)):
154 if component_name:
155 textures_components[i] = BytesIO(archive.extract(os.path.basename(component_name)))
156 texture = load_texture(*textures_components)
157
158 print(stage.name)
159
160 uvs = []
161 vertices = []
162 objects_faces = build_objects_faces(stage, anim)
163 objects_instances_faces = []
164 for obj, ox, oy, oz in stage.object_instances:
165 obj_id = stage.objects.index(obj)
166
167 obj_instance = []
168 for face_vertices, face_uvs in objects_faces[obj_id]:
169 obj_instance.append((tuple((x + ox, y + oy, z + oz) for x, y, z in face_vertices),
170 face_uvs))
171 objects_instances_faces.append(obj_instance)
172
173 vertices, uvs = objects_faces_to_vertices_uvs(objects_instances_faces)
174 nb_vertices = len(vertices)
175 vertices_format = 'f' * (3 * nb_vertices)
176 uvs_format = 'f' * (2 * nb_vertices)
177 vertices, uvs = objects_faces_to_vertices_uvs(objects_instances_faces)
178 glVertexPointer(3, GL_FLOAT, 0, struct.pack(vertices_format, *chain(*vertices)))
179 glTexCoordPointer(2, GL_FLOAT, 0, struct.pack(uvs_format, *chain(*uvs)))
180
181 x, y, z = 0, 0, 0
182 frame = 0
183 interpolation = 0, 0, 0
184
185 # Main loop
186 clock = pygame.time.Clock()
187 while True:
188 for event in pygame.event.get():
189 if event.type == pygame.QUIT or (event.type == pygame.KEYDOWN and event.key in (pygame.K_ESCAPE, pygame.K_q)):
190 sys.exit(0)
191 elif event.type == pygame.KEYDOWN:
192 if event.key == pygame.K_RETURN and event.mod & pygame.KMOD_ALT:
193 pygame.display.toggle_fullscreen()
194
195 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
196
197 for frame_num, message_type, data in stage.script:
198 if frame_num == frame and message_type == 3:
199 duration, junk1, junk2 = struct.unpack('<III', data)
200 interpolation = frame_num, duration, frame_num + duration
201 old_unknownx, old_dy, old_fov = unknownx, dy, fov
202 if frame_num <= frame and message_type == 0:
203 last_message = frame_num, message_type, data
204 if frame_num <= frame and message_type == 2:
205 next_unknownx, next_dy, next_fov = struct.unpack('<fff', data)
206 if frame_num > frame and message_type == 0:
207 next_message = frame_num, message_type, data
208 break
209
210 if frame < interpolation[2]:
211 truc = float(frame - interpolation[0]) / interpolation[1]
212 unknownx = old_unknownx + (next_unknownx - old_unknownx) * truc
213 dy = old_dy + (next_dy - old_dy) * truc
214 fov = old_fov + (next_fov - old_fov) * truc
215 else:
216 unknownx, dy, fov = next_unknownx, next_dy, next_fov
217
218 x1, y1, z1 = struct.unpack('<fff', last_message[2])
219 x2, y2, z2 = struct.unpack('<fff', next_message[2])
220
221 truc = (float(frame) - last_message[0]) / (next_message[0] - last_message[0])
222
223 #TODO: find proper coordinates (get rid of arbitrary values)
224 x = x1 + (x2 - x1) * truc + 170.
225 y = y1 + (y2 - y1) * truc
226 z = z1 + (z2 - z1) * truc - 720.
227
228 glMatrixMode(GL_PROJECTION)
229 glLoadIdentity()
230 gluPerspective(degrees(fov), float(window.get_width())/window.get_height(), 20, 2000)
231
232 glMatrixMode(GL_MODELVIEW)
233 glLoadIdentity()
234 gluLookAt(x, y, z, x, y - dy, 0., 0., -1., 0.)
235
236 glDrawArrays(GL_QUADS, 0, nb_vertices)
237
238 pygame.display.flip()
239 clock.tick(120)
240 frame += 1
241
242
243
244 try:
245 file_path, stage_num = sys.argv[1:]
246 stage_num = int(stage_num)
247 except ValueError:
248 print('Usage: %s std_dat_path stage_num' % sys.argv[0])
249 else:
250 main(file_path, stage_num)
251