1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
|
from OpenGL.GL import *
from OpenGL.GLUT import *
from OpenGL.GLU import *
from time import time
from queue import Queue
from renderer import ImageRenderer, TransitionMix
from manager import PixMan
class PixDisplay:
def __init__(self, textures):
self.last_time = 0
self.start_time = 0
self.image_time = 0
self.paused = False
self.textures = textures
self.current_texture_index = 0
self.renderer = None
self.win_w = 0
self.win_h = 0
self.transition_reverse = False
self.text_prev = None
self.tex = None
self._force_redraw = False
self.queue = Queue()
self.update_config()
def update_config(self):
config = PixMan().config
self.max_framerate = config.max_framerate
self.image_duration = config.image_duration
self.transition_duration = config.transition_duration
self.auto_transition = config.auto_transition
def update_textures(self, textures):
self.textures = textures
self.current_texture_index = 0
@property
def max_framerate(self):
#return int(1000/int(1000/self.frame_time))
return self.frame_time
@max_framerate.setter
def max_framerate(self, max_fps):
self._max_fps = max_fps # This is just for the getter since otherwise e.g. int(1000/int(1000/60)) would round to 62
self.frame_time = int(1000 / max_fps) # In ms
def increment_texture_index(self, increment):
self.transition_reverse = increment < 0
self.tex_prev = self.textures[self.current_texture_index]
self.current_texture_index = (self.current_texture_index + increment) % len(self.textures)
self.tex = self.textures[self.current_texture_index]
if not self.tex.initialized or not self.tex_prev.initialized:
return
# Ensure textures are initialized for opengl
self.tex_prev.gl_init()
self.tex.gl_init()
# Main display function
def display(self):
# Calculate timings
current_time = time()
alive_time = current_time - self.start_time
delta_time = current_time - self.last_time
self.last_time = current_time
if not self.tex or not self.tex.initialized or not self.tex.id:
if self.textures.asset_count > 0:
self.increment_texture_index(0)
# Draw black window if no textures are available
if not self.tex or not self.tex.id:
glClearColor(0.0, 0.0, 0.0, 1.0)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
glutSwapBuffers()
return
# Run queue events
while not self.queue.empty():
f = self.queue.get() # Get the task and its data
f()
# Progress image time
if not self.paused:
self.image_time += delta_time
# Get window size
old_win_w, old_win_h = self.win_w, self.win_h
self.win_w, self.win_h = glutGet(GLUT_WINDOW_WIDTH), glutGet(GLUT_WINDOW_HEIGHT)
# Draw static image except during a transition
if self.image_time < self.image_duration:
# Avoid unforced-redraw unless window size has changed
if self._force_redraw or self.win_w != old_win_w or self.win_h != old_win_h:
self.renderer.draw_static(self.tex, self.win_w, self.win_h, 1.0)
self._force_redraw = False
return
# Start drawing transition once image_time >= image_duration
if self.auto_transition:
self.increment_texture_index(1)
self.auto_transition = False
transition_time = self.image_time - self.image_duration
self.renderer.draw_transition(self.tex_prev, self.tex, self.win_w, self.win_h, delta_time, transition_time, self.transition_duration, self.transition_reverse)
if transition_time >= self.transition_duration:
self.image_time = 0
self.auto_transition = True
# Limit framerate
def timer(self, value):
glutPostRedisplay()
glutTimerFunc(self.frame_time, self.timer, 0) # Schedule next frame
def seek(self, increment):
self.auto_transition = False
self.increment_texture_index(increment)
self.image_time = self.image_duration
def handle_special_key(self, key, x, y):
if key == GLUT_KEY_LEFT:
self.seek(-1)
elif key == GLUT_KEY_RIGHT:
self.seek(1)
def handle_visibility_change(self, state):
if state == GLUT_VISIBLE:
self._force_redraw = True
glutPostRedisplay()
# Initialization and main loop
def main(self, glut_args):
# Initialize the window
glutInit(glut_args)
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB)
glutCreateWindow("Image Viewer with Fade Transition")
glEnable(GL_TEXTURE_2D)
self.renderer = ImageRenderer()
self.renderer.set_transition(TransitionMix)
self.image_time = 0
self.start_time = time()
self.last_time = time()
# Set up the OpenGL viewport and projection
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
glOrtho(-1, 1, -1, 1, -1, 1)
glMatrixMode(GL_MODELVIEW)
# Enable alpha blending
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
# Run display
glutDisplayFunc(self.display)
glutTimerFunc(self.frame_time, self.timer, 0)
glutVisibilityFunc(self.handle_visibility_change) # Redraw in case framebuffer gets destroyed when window is obscured
glutSpecialFunc(self.handle_special_key)
glutMainLoop()
|
