def init(self):
"""
initialize the whole object
"""
self._font_renderer = FontRenderer(self.camera)
self._font_renderer.layouts['axis'] = AbsoluteLayout(
coord_system = AbsoluteLayout.UPPER_CENTER if self._axis == 0 \
else AbsoluteLayout.RIGHT_CENTER
)
self._font_renderer.init()
self._font_renderer.set_color(self.fontcolor)
self.init_shader()
self.init_capturing()
self.initialized = True
def init(self):
print('ich habe init gemacht')
fancy_font = ImageFont.truetype (FONT_RESOURCES_DIR+"/cmunui.ttf", 30)
self.font_renderer = FontRenderer(self.camera)
self.font_renderer.init()
text = Text("ich bin ein cooler font", fancy_font)
abs_layout = AbsoluteLayout()
abs_layout.add_text(text)
self.font_renderer.layouts['abs'] = abs_layout
Controller.init(self)
class MyCoolController(Controller):
def __init__(self, camera=None):
Controller.__init__(self, camera)
def init(self):
print('ich habe init gemacht')
fancy_font = ImageFont.truetype (FONT_RESOURCES_DIR+"/cmunui.ttf", 30)
self.font_renderer = FontRenderer(self.camera)
self.font_renderer.init()
text = Text("ich bin ein cooler font", fancy_font)
abs_layout = AbsoluteLayout()
abs_layout.add_text(text)
self.font_renderer.layouts['abs'] = abs_layout
Controller.init(self)
def prepare(self):
#print('ich mach prepare')
pass
# text = self.font_renderer.add_text('blablabla', [0,0])
# self.font_renderer.add_text('blalal', [text.x, 0]) # PREPARE
# self.font_renderer.add_text_right_of('blallla', text)
# text = (id 0..n, properties, ICH KENNE FONTRENDERER)
# text.set_text('BLALALALA') -> font_render.text_updated(text)
# # self.on_text_updated = Event()
# # self.on_tect_updated.append(self._text_updated)
# #
# # def _text_updated(self, text):
# # self.update_text(id, 'text', pos)
def run(self):
#print('RUNRUNRU')
glClearColor(*[1,1,1,1])
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)
#self.font_renderer.modelview.translate(1,1)
self.font_renderer.modelview_updated()
self.font_renderer.render()
class Scale():
def __init__(self,
camera,
scale_camera,
size,
axis=0,
unit=1,
subunits=9,
unit_symbol=u'',
bgcolor=[1,1,1,1],
linecolor=[1,1,1,1],
fontcolor=[1,1,1,1],
font=None):
self._font_renderer = None
self.unit = unit
self.subunits = subunits
self.size = size
self.initialized = False
self.modelview = ModelView()
self.camera = camera
self.linecolor = linecolor
self.fontcolor = fontcolor
self.density = 80
self.unit_symbol = unit_symbol or ''
self.bgcolor = bgcolor
self._last_screen_scaling = None
self._frame = None
self._axis = axis
self._translation = 0
self._font_size = 14
self._font = font or ImageFont.truetype(resource_path("fonts/arialbd.ttf"), 14, encoding='unic')
self._unit_f = 1
self._scale_camera = scale_camera
self._initial_size = [size[0],size[1]]
self.vao = None
self._labels = []
def unit_density_factor(self, capture_size):
density = self.density
size = capture_size
f = 1.0
last_diff = density - size
while True:
if last_diff < 0:
if size*f < 2*density:
f *= 0.5
break
f *= 0.5
else:
if 2*size*f > density:
break
f *= 2
return f
def init(self):
"""
initialize the whole object
"""
self._font_renderer = FontRenderer(self.camera)
self._font_renderer.layouts['axis'] = AbsoluteLayout(
coord_system = AbsoluteLayout.UPPER_CENTER if self._axis == 0 \
else AbsoluteLayout.RIGHT_CENTER
)
self._font_renderer.init()
self._font_renderer.set_color(self.fontcolor)
self.init_shader()
self.init_capturing()
self.initialized = True
def init_shader(self):
"""
initializes shader
"""
axis_program = Program()
vertex_shader = Shader(GL_VERTEX_SHADER, load_lib_file('glsl/plot2d/axis/marker_{}.vert.glsl'.format('x' if self._axis == 0 else 'y')))
geometry_shader = Shader(GL_GEOMETRY_SHADER, load_lib_file('glsl/plot2d/axis/marker_{}.geom.glsl'.format('x' if self._axis == 0 else 'y')))
fragment_shader = Shader(GL_FRAGMENT_SHADER, load_lib_file('glsl/plot2d/axis/marker.frag.glsl'))
axis_program.shaders.append(vertex_shader)
axis_program.shaders.append(geometry_shader)
axis_program.shaders.append(fragment_shader)
axis_program.link()
self.axis_program = axis_program
self.axis_program.use()
#self.axis_program.uniform('mat_modelview', numpy.array([1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1], dtype=numpy.float32))
self.axis_program.uniform('color', self.linecolor)
self.axis_program.unuse()
def init_capturing(self):
"""
initializes capturing of a unit
"""
# create framebuffer for one scale unit.
unit_size = float(self.unit)/self._scale_camera.get_scaling()[self._axis]
capture_size = [0,0]
capture_size[self._axis] = float(unit_size)*float(self._initial_size[self._axis])
capture_size[self._axis^1] = self.size[self._axis^1]
self._unit_f = self.unit_density_factor(capture_size[self._axis])
capture_size[self._axis] *= self.unit_density_factor(capture_size[self._axis])
#if self._frame is None:
frame = window.Framebuffer(
camera = self.camera,
screensize = self.size,
capture_size = capture_size,
screen_mode = window.Framebuffer.SCREEN_MODE_REPEAT,
clear_color = self.bgcolor,
multisampling= 1,
modelview = self.modelview,
)
frame.inner_camera.set_scaling(self.size)
self._frame = frame
self._frame.init()
# create a special scaling.
# in self._axis direction the scaling should be like unit scaling,
# on the perpendicular axis the scaling should be like the scaling
# from frame space.
scaling = [0,0]
scaling[self._axis] = self.unit
scaling[self._axis^1] = self._frame.inner_camera.get_scaling()[self._axis^1]
#scaling = capture_size
self._frame.inner_camera.set_scaling(scaling)
self._frame.inner_camera.set_screensize(capture_size)
if self._axis == 0:
self._frame.inner_camera.set_base_matrix(np.array([
1, 0, 0, 0,
0, -1, 0, 0,
0, 0, 1, 0,
0, 0, 0, 1,
], dtype=np.float32))
# update shader
self.axis_program.use()
self.axis_program.uniform('mat_camera', self._frame.inner_camera.get_matrix())
self.axis_program.uniform('mat_outer_camera', self.camera.get_matrix())
self.axis_program.unuse()
self.axis_program.uniform('border', 1.5*float(self.camera.screensize[self._axis])/capture_size[self._axis])
# create vao
if self.vao is None:
self._init_capturing_vbo()
# set init state
self._last_size = self.size[:]
self._last_screen_scaling = self._scale_camera.get_screen_scaling()
@property
def labels(self):
return self._labels
def _init_capturing_vbo(self):
data = numpy.zeros(self.subunits*2+2, dtype=numpy.float32)
if self._axis == 0:
subunit = float(self.unit)/self.subunits
data[0] = subunit/2
data[1] = 10
for i in range(1, self.subunits):
data[2*i+2] = subunit*i+subunit/2
data[2*i+3] = 3
else:
subunit = float(self.unit)/self.subunits
data[0] = subunit/2
data[1] = 10
for i in range(1, self.subunits):
data[2*i+2] = subunit*i+subunit/2
data[2*i+3] = 3
self.vao = glGenVertexArrays(1)
vbo = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, vbo)
glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(data), data, GL_STATIC_DRAW)
glBindBuffer(GL_ARRAY_BUFFER, 0)
glBindVertexArray(self.vao)
glBindBuffer(GL_ARRAY_BUFFER, vbo)
glVertexAttribPointer(self.axis_program.attributes['vertex_position'], 2, GL_FLOAT, GL_FALSE, 0, None)
glEnableVertexAttribArray(0)
glBindBuffer(GL_ARRAY_BUFFER, 0)
glBindVertexArray(0)
def prepare_fonts(self):
"""
prepares axis fonts
"""
self._labels = []
capture_size = self._frame.capture_size[self._axis]
translation = self._translation%self._frame.capture_size[self._axis]
size = self._last_size[self._axis] + translation
unit_count = int(numpy.floor(size/capture_size))
start_unit = numpy.floor(self._translation/capture_size)
axis_flayout = self._font_renderer.layouts['axis']
axis_flayout.clear_texts()
axis_flayout.modelview.set_position(*self._frame.modelview.position)
if self._axis == 0:
position = [translation,20]
for i in range(0, unit_count):
label = self.format_number(self._unit_f*(i-start_unit), self.unit_symbol)
self._labels.append((position[0], label))
position[self._axis] += capture_size
else:
position = [self.size[0]-15,size-capture_size]
for i in range(0, unit_count):
label = self.format_number(self._unit_f*(start_unit+i+1), self.unit_symbol)
# text = Text(label, self._font)
# axis_flayout.add_text(text, (position[0], position[1]))
self._labels.append((position[1], label))
position[self._axis] -= capture_size
def format_number(self, number, symbol):
if number == 0:
return '0'
if number == 1 and len(symbol):
return symbol
if number == -1 and len(symbol):
return '-' + symbol
if np.ceil(number) == number:
return '{:d}'.format(int(number))+symbol
return '{:.4g}'.format(number)+symbol
def update_camera(self, camera):
"""
updates the frame and capture camare to
adjust zooming and translation of the axis units and
position of the axis
"""
# scale the axis size to window size.
# no translation is done here. do translation (e.g. bottom fixed)
# from outside.
self._frame.update_camera(camera)
self.axis_program.use()
self.axis_program.uniform('mat_camera', self._frame.inner_camera.get_matrix())
self.axis_program.uniform('mat_outer_camera', self._frame.camera.get_matrix())
self.axis_program.unuse()
# if screen-scaling of the scale_camera has changed
# we need to initialize capturing of the axis for this size.
# this happens for example when the zoom changed.
if self._last_screen_scaling != self._scale_camera.get_screen_scaling():
self.init_capturing()
# translate the axis texture so it follows the scale_camera position.
position = self._scale_camera.get_position()
subunit = float(self.unit)/self.subunits
if self._axis == 1:
fix_translation = 0.5*self._frame.capture_size[1]/self.subunits
translation = self.size[1]*position[1]/self._last_screen_scaling[1]
self._translation = translation
self._frame.screen_translation[1] = self._translation%self._frame.capture_size[1] - fix_translation
self.prepare_fonts()
if self._axis == 0:
fix_translation = 0.5*self._frame.capture_size[0]/self.subunits
translation = self.size[0]*position[0]/self._last_screen_scaling[0]
self._translation = translation
self._frame.screen_translation[0] = -self._translation%self._frame.capture_size[0] + fix_translation
self.prepare_fonts()
def update_modelview(self):
"""
updates model view
"""
self._frame.update_modelview()
def render(self):
"""
renders the axis.
also checks whether there is a change in screensize or whether the
object was ininzialized.
"""
if not self.initialized:
self.init()
elif not self._last_size == self.size:
self._frame.screensize = self.size
self._frame.init_screen()
self._last_size = self.size
if not self._frame.has_captured():
self.prepare_fonts()
self._frame.use()
self._render_scale_element()
self._frame.unuse()
# render the object
self._frame.render()
self._font_renderer.render()
def _render_scale_element(self):
"""
renders one scale unit
"""
self.axis_program.use()
glBindVertexArray(self.vao)
glDrawArrays(GL_POINTS, 0, 2*self.subunits)
glBindVertexArray(0)
self.axis_program.unuse()
