def on_texture_path(self,instance,value):
self.particle_builder.demo_particle.texture_path = value
self.particle_builder.demo_particle.texture = Image(value).texture
def _enter(self):
super(MouseCursor, self)._enter()
self.__pos_ref = self._exp.screen.mouse_pos
texture = Image(self._filename).texture
self.__instruction = kivy.graphics.Rectangle(texture=texture,
size=texture.size)
def initialize_game(self, difficulty):
self.canvas.clear()
self.state = "game"
self.difficulty = difficulty
self.audio_controller = AudioController(self.difficulty)
self.audio_controller.toggle()
self.notes_down = [
] # an array that keeps track of all notes that are currently being played on midi keyboard
# The display for the gems, now bar, and bar lines
self.canvas.add(Color(1, 1, 1))
rect = Rectangle(pos=(0, 0),
size=(Window.width, Window.height),
texture=Image('assets/bg_c.png').texture)
self.canvas.add(rect)
self.lane_manager = LaneManager()
# Display the status of the game through the text labels
self.canvas.add(Color(1, 1, 1))
self.hud = Rectangle(pos=(0, Window.height / 1.12),
size=(Window.width / 4, Window.height / 9),
texture=Image('assets/tophub.png').texture)
self.canvas.add(self.hud)
self.canvas.add(Color(1, 1, 1))
self.hud_score = Rectangle(
pos=(Window.width / 1.4, Window.height / 1.12),
size=(Window.width / 3.5, Window.height / 9),
texture=Image('assets/topscore.png').texture)
self.canvas.add(self.hud_score)
self.score_label = score_label()
self.add_widget(self.score_label)
self.hp_label = hp_label()
self.add_widget(self.hp_label)
self.enemy_times = []
self.enemy_lanes = []
self.enemy_types = []
self.enemy_chords = []
self.enemy_manager = EnemyManager()
self.canvas.add(self.enemy_manager)
if difficulty == "easy":
read_data("song_annotations/hallelujah_left_hand_test.txt", None,
self.enemy_times, self.enemy_lanes, self.enemy_types,
self.enemy_chords)
self.song_length = 140
elif difficulty == "medium":
read_data("song_annotations/falling_left_hand_test.txt",
"song_annotations/falling_right_hand_test.txt",
self.enemy_times, self.enemy_lanes, self.enemy_types,
self.enemy_chords)
self.song_length = 44
elif difficulty == "hard":
read_data("song_annotations/hallelujah_left_hand_test.txt",
"song_annotations/hallelujah_right_hand_test.txt",
self.enemy_times,
self.enemy_lanes,
self.enemy_types,
self.enemy_chords,
inversions=True)
self.song_length = 140
self.prev_time = time.time()
self.elapsed_time = 0
self.note_index = 0
window_size = 4 # 4 seconds of notes are displayed
x_scale = Window.width / window_size # pixels / sec
# Create the player object which will store and control the state of the game
self.player = Player(self.hp_label, self.score_label, self.enemy_times,
self.enemy_lanes, self.enemy_types,
self.enemy_chords, self.enemy_manager,
self.audio_controller)
self.canvas.add(self.player)
self.player.toggle()
from time import time
from penta_color import penta_schemes
from penta_common import PentaListContainer
from kivy.uix.widget import Widget
from kivy.core.image import Image
from kivy.utils import get_color_from_hex
from kivy.core.window import Window
from kivy.graphics import Color, BorderImage, Rectangle
TIMER = 60 * 2
PENTAMINOS_SIZE = 5, 3
PENTAMINOS_SIZE2 = 6, 5
PENTAMINOS_COUNT_BY_USERS = 3
background = Image(join(dirname(__file__), 'background.png'))
background.texture.wrap = 'repeat'
btnbg = Image(join(dirname(__file__), 'buttonbackground.png')).texture
class Pentaminos(KalScenarioServer):
resources = ('penta-background.png', 'penta-background-bottom.png',
'penta-square.png', 'penta-square-shadow.png',
'background.png', 'client.py', 'penta_color.py',
'pentaminos.kv', 'penta_common.py')
def __init__(self, *largs):
super(Pentaminos, self).__init__(*largs)
self.timeout = 0
self.timemsg = 0
self.c1 = get_color_from_hex('#96be25aa')
def __init__(self, norm, pos, callback):
super(InstrumentSelect, self).__init__()
self.norm = norm
self.selected = 'piano'
self.callback = callback
self.pos = pos
self.margin = self.norm.nv(20)
self.button_length = self.norm.nv(64)
self.title_height = self.norm.nv(50) # height of the word 'instrument'
self.size = ((5 * self.button_length) + (6 * self.margin),
self.button_length + (2 * self.margin) +
self.title_height)
self.white = (239 / 255, 226 / 255, 222 / 255)
self.red = (201 / 255, 108 / 255, 130 / 255)
self.border_color = Color(147 / 255, 127 / 255, 159 / 255) # purple
self.border = Line(rectangle=(*self.pos, *self.size), width=2)
self.add(self.border_color)
self.add(self.border)
button_size = (self.button_length, self.button_length)
self.instruments = {
'piano':
Rectangle(size=button_size,
texture=Image('images/piano.png').texture),
'violin':
Rectangle(size=button_size,
texture=Image('images/violin.png').texture),
'trumpet':
Rectangle(size=button_size,
texture=Image('images/trumpet.png').texture),
'ocarina':
Rectangle(size=button_size,
texture=Image('images/ocarina.png').texture),
'choir':
Rectangle(size=button_size,
texture=Image('images/choir.png').texture)
}
self.instrument_bgs = {
'piano': Rectangle(size=button_size),
'violin': Rectangle(size=button_size),
'trumpet': Rectangle(size=button_size),
'ocarina': Rectangle(size=button_size),
'choir': Rectangle(size=button_size)
}
self.instrument_colors = {
'piano': Color(*self.red), # default selected timbre
'violin': Color(*self.white),
'trumpet': Color(*self.white),
'ocarina': Color(*self.white),
'choir': Color(*self.white)
}
x, y = self.pos
piano_pos = (x + self.margin, y + self.margin)
violin_pos = (x + 2 * self.margin + self.button_length,
y + self.margin)
trumpet_pos = (x + 3 * self.margin + 2 * self.button_length,
y + self.margin)
ocarina_pos = (x + 4 * self.margin + 3 * self.button_length,
y + self.margin)
choir_pos = (x + 5 * self.margin + 4 * self.button_length,
y + self.margin)
for instrument, instrument_pos in zip(
('piano', 'violin', 'trumpet', 'ocarina', 'choir'),
(piano_pos, violin_pos, trumpet_pos, ocarina_pos, choir_pos)):
self.instruments[instrument].pos = self.instrument_bgs[
instrument].pos = instrument_pos
self.add(self.instrument_colors[instrument])
self.add(self.instrument_bgs[instrument])
self.add(self.instruments[instrument])
title_pos = (x + self.size[0] / 2, y + self.size[1] -
self.title_height / 2 - self.margin / 2)
self.title = CLabelRect(cpos=title_pos,
text='instrument',
font_size='18')
self.add(Color(*self.white))
self.add(self.title)
def cached_texture(path, _cache={}):
tex = _cache.get(path)
if not tex:
tex = _cache[path] = Image(resource_find(path)).texture
return tex
def saveImg(tex, event):
img = Image(tex)
#img.save("capture.png")
print("Would have captured")
def change_texture(self, new_texture_path):
if new_texture_path != self.texture_path:
self.texture_path = new_texture_path
if self.texture_path != "":
self.shape.texture = Image(self.texture_path).texture
def __init__(self, norm, pos, callback):
super(BounceSelect, self).__init__()
self.norm = norm
self.bounces = 5
self.callback = callback
self.pos = pos
self.margin = self.norm.nv(20)
self.size = self.norm.nt((210, 130))
self.border_color = Color(170/255, 220/255, 206/255) # green
self.border = Line(rectangle=(*self.pos, *self.size), width=2)
self.add(self.border_color)
self.add(self.border)
self.arrow_size = self.norm.nt((50, 50))
self.left_pos = (
self.pos[0] + self.margin,
self.pos[1] + self.margin
)
self.left_off = Rectangle(
pos=self.left_pos,
size=self.arrow_size,
texture=Image('ui/buttons/left_arrow.png').texture
)
self.left_on = Rectangle(
pos=self.left_pos,
size=self.arrow_size,
texture=Image('ui/buttons/left_arrow_clicked.png').texture
)
self.right_pos = (
self.pos[0] + self.size[0] - self.margin - self.arrow_size[0],
self.pos[1] + self.margin
)
self.right_off = Rectangle(
pos=self.right_pos,
size=self.arrow_size,
texture=Image('ui/buttons/right_arrow.png').texture
)
self.right_on = Rectangle(
pos=self.right_pos,
size=self.arrow_size,
texture=Image('ui/buttons/right_arrow_clicked.png').texture
)
# left_off and right_off are always drawn, but when user mouses over an arrow,
# left_on and right_on are drawn over left_off and right_off
self.add(Color(1, 1, 1))
self.add(self.left_off)
self.add(self.right_off)
title_pos = (self.pos[0] + self.size[0]/2, self.pos[1] + self.size[1] - self.norm.nv(30))
self.title = CLabelRect(cpos=title_pos, text='bounces', font_size='18')
self.add(self.title)
bounce_text_pos = (
self.pos[0] + self.size[0]/2,
self.pos[1] + self.margin + self.arrow_size[1]/2
)
self.bounce_text = CLabelRect(cpos=bounce_text_pos, text=str(self.bounces), font_size='18')
self.add(self.bounce_text)
def getTexture(name, size=(CELL_SIZE, CELL_SIZE)):
filename = spritePath.format(name)
texture = Image(filename).texture
texture.wrap = 'repeat'
texture.uvsize = size
return texture
def load_tileable(self, name):
t = Image('images/{}.png'.format(name)).texture
t.wrap = 'repeat'
setattr(self, 'tx_{}'.format(name), t)
def _parse_config(self, config):
self._config = parse_xml(config)
texture_path = self._parse_data('texture', 'name')
config_dir_path = os.path.dirname(os.path.abspath(config))
path = os.path.join(config_dir_path, texture_path)
if os.path.exists(path):
self.texture_path = path
else:
self.texture_path = texture_path
self.texture = Image(self.texture_path).texture
self.emitter_x = float(self._parse_data('sourcePosition', 'x'))
self.emitter_y = float(self._parse_data('sourcePosition', 'y'))
self.emitter_x_variance = float(
self._parse_data('sourcePositionVariance', 'x'))
self.emitter_y_variance = float(
self._parse_data('sourcePositionVariance', 'y'))
self.gravity_x = float(self._parse_data('gravity', 'x'))
self.gravity_y = float(self._parse_data('gravity', 'y'))
self.emitter_type = int(self._parse_data('emitterType'))
self.max_num_particles = int(float(self._parse_data('maxParticles')))
self.life_span = max(0.01, float(self._parse_data('particleLifeSpan')))
self.life_span_variance = float(
self._parse_data('particleLifespanVariance'))
self.start_size = float(self._parse_data('startParticleSize'))
self.start_size_variance = float(
self._parse_data('startParticleSizeVariance'))
self.end_size = float(self._parse_data('finishParticleSize'))
self.end_size_variance = float(
self._parse_data('FinishParticleSizeVariance'))
self.emit_angle = math.radians(float(self._parse_data('angle')))
self.emit_angle_variance = math.radians(
float(self._parse_data('angleVariance')))
self.start_rotation = math.radians(
float(self._parse_data('rotationStart')))
self.start_rotation_variance = math.radians(
float(self._parse_data('rotationStartVariance')))
self.end_rotation = math.radians(float(
self._parse_data('rotationEnd')))
self.end_rotation_variance = math.radians(
float(self._parse_data('rotationEndVariance')))
self.speed = float(self._parse_data('speed'))
self.speed_variance = float(self._parse_data('speedVariance'))
self.radial_acceleration = float(
self._parse_data('radialAcceleration'))
self.radial_acceleration_variance = float(
self._parse_data('radialAccelVariance'))
self.tangential_acceleration = float(
self._parse_data('tangentialAcceleration'))
self.tangential_acceleration_variance = float(
self._parse_data('tangentialAccelVariance'))
self.max_radius = float(self._parse_data('maxRadius'))
self.max_radius_variance = float(self._parse_data('maxRadiusVariance'))
self.min_radius = float(self._parse_data('minRadius'))
self.rotate_per_second = math.radians(
float(self._parse_data('rotatePerSecond')))
self.rotate_per_second_variance = math.radians(
float(self._parse_data('rotatePerSecondVariance')))
self.start_color = self._parse_color('startColor')
self.start_color_variance = self._parse_color('startColorVariance')
self.end_color = self._parse_color('finishColor')
self.end_color_variance = self._parse_color('finishColorVariance')
self.blend_factor_source = self._parse_blend('blendFuncSource')
self.blend_factor_dest = self._parse_blend('blendFuncDestination')
def on_icon_src(self, instance, value):
self.icon = Image(value)
def set_background(self):
texture = Image('resources/interface/modal-background.png').texture
texture.wrap = 'repeat'
texture.uvsize = (2, 1)
with self.canvas.before:
Rectangle(texture=texture, size=self.size, pos=self.pos)
def start(self, current_callback):
if self.init == 0:
self.current_callback = current_callback
Color(1, 1, 1, 1)
normal_map_value = 0
if len(self._normal_map) > 0:
normal_map_value = 1
image = Image(self._normal_map)
bind_texture = BindTexture(texture=image.texture, index=2)
self._instruction_group = InstructionGroup()
self._instruction_group.add(Callback(self.update_params))
self.state = ChangeState( #enabled_shadow=(float(self.receive_shadows)),
lighting=(float(self.lighting)),
light_intensity=self.light_intensity,
flip_coords=(float(self.flip_coords)),
#alpha=(float(self.alpha)),
#pitch=(float(self.pitch)),
#yaw=self.yaw,
#roll=(float(self.roll)),
#shadows_bias = (float(self.shadows_bias)),
normal_map_enabled=(float(normal_map_value)),
#specular_intensity = (float(self.specular_intensity)),
#specular_power = (float(self.specular_power)),
#min_light_intensity=(float(self.min_light_intensity))
)
self._instruction_group.add(self.state)
self._translate = Translate(*self.translate)
self._rotate = Rotate(*self.rotate)
self._scale = Scale(*self.scale)
self._instructions.append(self.state)
self._instructions.append(self._translate)
self._instructions.append(self._rotate)
self._instructions.append(self._scale)
self._instructions.append(self._instruction_group)
self._instructions.append(Callback(self.before_render))
elif self.init == 1:
self.current_callback_fbo = current_callback
self._shadow_instructions.append(Callback(self.update_params_fbo))
#state = ChangeState(cast_shadows=(float(self.cast_shadows)))
self._shadow_translate = Translate(*self.translate)
self._shadow_rotate = Rotate(*self.rotate)
self._shadow_scale = Scale(*self.scale)
self._shadow_instructions.append(self._shadow_translate)
self._shadow_instructions.append(self._shadow_rotate)
self._shadow_instructions.append(self._shadow_scale)
elif self.init == 2:
self.current_callback_picking_fbo = current_callback
mrange = 0
if self.effect:
mrange = 0.50
self._picking_instructions.append(
Callback(self.update_params_picking_fbo))
state = ChangeState(id_color=(round(self.pick_id + mrange, 2),
float(self.effect), 0.0))
self._picking_translate = Translate(*self.translate)
self._picking_rotate = Rotate(*self.rotate)
self._picking_scale = Scale(*self.scale)
self._picking_instructions.append(state)
self._picking_instructions.append(self._picking_translate)
self._picking_instructions.append(self._picking_rotate)
self._picking_instructions.append(self._picking_scale)
self._instructions.append(Callback(self.before_render))
elif self.init == 3:
state = ChangeState(id=(self.motion_id))
self._motion_blur_translate = Translate(*self.translate)
self._motion_blur_rotate = Rotate(*self.rotate)
self._motion_blur_scale = Scale(*self.scale)
self._blur_instructions.append(state)
self._blur_instructions.append(self._motion_blur_translate)
self._blur_instructions.append(self._motion_blur_rotate)
self._blur_instructions.append(self._motion_blur_scale)
self._instructions.append(Callback(self.before_render))
UpdateNormalMatrix()
for e in self._objs:
_vertices = []
_indices = []
if ".obj" in e:
filename = resource_find(e)
if not filename:
raise IOError("File: '{0}' not found".format(e))
m = ObjFile(resource_find(e))
m = list(m.objects.values())[0]
res = []
count = 0
for i, o in enumerate(m.vertices):
res.append(o)
if (i + 1) % 8 == 0:
count += 1
res.append(0.0)
res.append(0.0)
res.append(0.0)
res.append(i // 8)
res.append(i // 8)
if count >= 3:
l = len(res)
v0 = [
res[l - 13 * 3], res[l - 13 * 3 + 1],
res[l - 13 * 3 + 2]
]
v1 = [
res[l - 13 * 2], res[l - 13 * 2 + 1],
res[l - 13 * 2 + 2]
]
v2 = [
res[l - 13 * 1], res[l - 13 * 1 + 1],
res[l - 13 * 1 + 2]
]
t0xy = [res[l - 13 * 3 + 6], res[l - 13 * 3 + 7]]
t1xy = [res[l - 13 * 2 + 6], res[l - 13 * 2 + 7]]
t2xy = [res[l - 13 + 6], res[l - 13 + 7]]
edge1 = min_vector(v1, v0)
edge2 = min_vector(v2, v0)
delta_u1 = t1xy[0] - t0xy[0]
delta_v1 = t1xy[1] - t0xy[1]
delta_u2 = t2xy[0] - t0xy[0]
delta_v2 = t2xy[1] - t0xy[1]
d = (delta_u1 * delta_v2 - delta_u2 * delta_v1)
if d == 0:
d = 0.01
f = 1.0 / d
tangent_x = f * (delta_v2 * edge1[0] -
delta_v1 * edge2[0])
tangent_y = f * (delta_v2 * edge1[1] -
delta_v1 * edge2[1])
tangent_z = f * (delta_v2 * edge1[2] -
delta_v1 * edge2[2])
for _i in range(1, 4):
res[l - 13 * _i + 8] += tangent_x
res[l - 13 * _i + 9] += tangent_y
res[l - 13 * _i + 10] += tangent_z
count = 0
for i in range(len(res)):
if (i + 1) % 13 == 0:
vec = [
res[i - 12 + 8], res[i - 12 + 9], res[i - 12 + 10]
]
n_vec = normalize(vec)
res[i - 12 + 8] = n_vec[0]
res[i - 12 + 9] = n_vec[1]
res[i - 12 + 10] = n_vec[2]
m.vertices = res
_vertices = m.vertices
_indices = m.indices
if self.init != 3:
mesh = Mesh(
vertices=_vertices,
indices=_indices,
fmt=[(b'v_pos', 3, 'float'), (b'v_normal', 3, 'float'),
(b'v_tc0', 2, 'float'), (b'tangent', 3, 'float'),
(b'vert_pos', 2, 'float')],
mode='triangles',
source=e + ".png",
)
self.objs.append(mesh)
if self.init == 0:
self._instructions.append(mesh)
if self.init == 1:
self._shadow_instructions.append(mesh)
if self.init == 2:
self._picking_instructions.append(mesh)
if self.init == 3:
self._blur_instructions.append(mesh)
if (".dae" in e) or ('.xml' in e and not ".mesh.xml" in e):
raise Exception("Collada not yet implemented")
for o in load_dae_scene(e):
self.objs.append(o)
if self.init == 0:
self.mesh = o
if ".mesh.xml" in e:
for o, ba, skel, vert in load_ogre(e):
self.skeletons = skel
self.objs.append(o)
self.bones_data.append(ba)
self.vertices = vert[:]
if self.init == 0:
self.mesh = o
if ".md5mesh" in e:
raise Exception("MD5 not implemented")
for o in load_md5(e, self._anims):
self.objs.append(o)
if self.init == 0:
self.mesh = o
self._instructions.append(Callback(self.after_render))
self.init += 1
def __init__(self, norm, pos, callback):
super(TimbreSelect, self).__init__()
self.norm = norm
self.selected = 'sine' # the actual important variable: which timbre is selected!
self.callback = callback
self.pos = pos
self.margin = self.norm.nv(20)
self.button_length = self.norm.nv(64)
self.title_height = self.norm.nv(50) # height of the word 'timbre'
self.size = (
(4 * self.button_length) + (5 * self.margin),
self.button_length + (2 * self.margin) + self.title_height
)
self.white = (239/255, 226/255, 222/255)
self.red = (201/255, 108/255, 130/255)
self.border_color = Color(147/255, 127/255, 159/255) # purple
self.border = Line(rectangle=(*self.pos, *self.size), width=2)
self.add(self.border_color)
self.add(self.border)
button_size = (self.button_length, self.button_length)
self.timbres = {
'sine': Rectangle(size=button_size, texture=Image('images/sine.png').texture),
'square': Rectangle(size=button_size, texture=Image('images/square.png').texture),
'triangle': Rectangle(size=button_size, texture=Image('images/triangle.png').texture),
'sawtooth': Rectangle(size=button_size, texture=Image('images/sawtooth.png').texture)
}
self.timbre_bgs = {
'sine': Rectangle(size=button_size),
'square': Rectangle(size=button_size),
'triangle': Rectangle(size=button_size),
'sawtooth': Rectangle(size=button_size)
}
self.timbre_colors = {
'sine': Color(*self.red), # default selected timbre
'square': Color(*self.white),
'triangle': Color(*self.white),
'sawtooth': Color(*self.white)
}
x, y = self.pos
sine_pos = (x + self.margin, y + self.margin)
square_pos = (x + 2*self.margin + self.button_length, y + self.margin)
triangle_pos = (x + 3*self.margin + 2*self.button_length, y + self.margin)
sawtooth_pos = (x + 4*self.margin + 3*self.button_length, y + self.margin)
for timbre, timbre_pos in zip(
('sine', 'square', 'triangle', 'sawtooth'),
(sine_pos, square_pos, triangle_pos, sawtooth_pos)
):
self.timbres[timbre].pos = self.timbre_bgs[timbre].pos = timbre_pos
self.add(self.timbre_colors[timbre])
self.add(self.timbre_bgs[timbre])
self.add(self.timbres[timbre])
title_pos = (x + self.size[0]/2, y + self.size[1] - self.title_height/2 - self.margin/2)
self.title = CLabelRect(cpos=title_pos, text='timbre', font_size='18')
self.add(Color(*self.white))
self.add(self.title)
def convert_to_mesh(
self,
vertex_format=None
): # Ripped from kivy3/loaders/objloader.py and edited by GJ
"""Converts data gotten from the ._obj definition
file and create Kivy3 Mesh object which may be used
for drawing object in the scene
"""
geometry = Geometry()
material = Material()
mtl_dirname = abspath(
dirname(self.loader.mtl_source
)) # We don't need this as we arnt loading any images
# but just in case we keep it
v_idx = 0
# create geometry for mesh
for f in self.faces:
verts = f[0]
norms = f[1]
tcs = f[2]
face3 = Face3(0, 0, 0)
for i, e in enumerate(['a', 'b', 'c']):
# get normal components
n = (0.0, 0.0, 0.0)
if norms[i] != -1:
n = self.loader.normals[norms[i] - 1]
face3.vertex_normals.append(n)
# get vertex components
v = self.loader.vertices[verts[i] - 1]
geometry.vertices.append(v)
setattr(face3, e, v_idx)
v_idx += 1
# get texture coordinate components
t = (0.0, 0.0)
if tcs[i] != -1:
t = self.loader.texcoords[tcs[i] - 1]
tc = Vector2(t[0], 1. - t[1])
geometry.face_vertex_uvs[0].append(tc)
geometry.faces.append(face3)
# apply material for object
if self.mtl_name in self.loader.mtl_contents:
raw_material = self.loader.mtl_contents[self.mtl_name]
# shader ignores values
zeros = [
'0', '0.0', '0.00', '0.000', '0.0000', '0.00000', '0.000000'
]
for k, v in raw_material.items():
_k = self._mtl_map.get(k, None)
if k in [
"map_Kd",
]:
self.log_warning(
"the tag map_kd should not be used as a material, use map_id and give the texture"
" type (ini section and option)")
map_path = join(mtl_dirname, v[0])
if not exists(map_path):
msg = u'Texture not found <{}>'
self.log_warning(msg.format(map_path))
continue
tex = Image(map_path).texture
material.map = tex
continue
if k in [
"map_id",
]:
tex = self.textures.get("Materials", str(v[0]))
material.map = tex
if _k:
if len(v) == 1:
v[0] = '0.000001' if v[0] in zeros else v[0]
v = float(v[0])
if k == 'Tr':
v = 1. - v
setattr(material, _k, v)
else:
v = list(map(lambda x: float(x), v))
setattr(material, _k, v)
if not material.map:
self.log_warning(
"No material given or used wrong name -", self.mtl_name,
"(if nothing here then you "
"provided no mtl file)")
material.map = Image(objLoader_folder + '/empty.png').texture
material.texture_ratio = 0.0
mesh = Mesh(geometry, material)
return mesh
def _get_source_data(self, source, scale):
texture = Image(source).texture
orig_size = get_normal_tex_size(texture)
size = Vector(*orig_size) * scale
return texture, size, orig_size
# assyncriona imagem
aimg = AsyncImage(source='http://mywebsite.com/logo.png')
# carregar uma imagem com um nome de um arquivo
from kivy.core.image import Image
im = Image("image.png")
# carregar os dados da imagem diretamente de um bloco da memória
import io
from kivy.core.image import Image
data = io.BytesIO(open("image.png", "rb").read())
im = Image(data, ext="png")
# para imagem ficar salva em cache informe o filename
im = Image(data, ext="png", filename="image.png")
# Savar imagem
from kivy.core.image import Image
img = Image('hello.png')
img.save('hello2.png')
# salvar textura
texture = Texture.create(...)
img = Image(texture)
img.save('hello3.png')
# for example, load a 128x128 image that contain 4 64x64 images
from kivy.core.image import Image
def load_tileable(self, name):
t = Image('images/%s.png' % name).texture
t.wrap = 'repeat'
setattr(self, 'tx_%s' % name, t)
def __init__(self,cords,world):
super(Animal,self).__init__(cords, world, 9, 5)
self._texture = Image("./world/animals/graphics/wolf.png").texture
def change_texture(self, new_texture_path):
if isinstance(self.shape, Rectangle):
if new_texture_path != self.texture_path:
self.texture_path = new_texture_path
if self.texture_path != "":
self.shape.texture = Image(self.texture_path).texture
def __init__(self, norm, pos, callback):
super(DrumSelect, self).__init__()
self.norm = norm
self.selected = 'snare'
self.callback = callback
self.pos = pos
self.margin = self.norm.nv(20)
self.button_length = self.norm.nv(64)
self.title_height = self.norm.nv(50) # height of the word 'drumset'
self.size = ((5 * self.button_length) + (6 * self.margin),
self.button_length + (2 * self.margin) +
self.title_height)
self.white = (239 / 255, 226 / 255, 222 / 255)
self.red = (201 / 255, 108 / 255, 130 / 255)
self.border_color = Color(214 / 255, 152 / 255, 142 / 255) #orange
self.border = Line(rectangle=(*self.pos, *self.size), width=2)
self.add(self.border_color)
self.add(self.border)
button_size = (self.button_length, self.button_length)
self.instruments = {
'snare':
Rectangle(size=button_size,
texture=Image('images/snare.png').texture),
'crash':
Rectangle(size=button_size,
texture=Image('images/crash.png').texture),
'bass':
Rectangle(size=button_size,
texture=Image('images/bass.png').texture),
'hihat':
Rectangle(size=button_size,
texture=Image('images/hihat.png').texture),
'triangle':
Rectangle(size=button_size,
texture=Image('images/triangle_instr.png').texture)
}
self.instrument_bgs = {
'snare': Rectangle(size=button_size),
'crash': Rectangle(size=button_size),
'bass': Rectangle(size=button_size),
'hihat': Rectangle(size=button_size),
'triangle': Rectangle(size=button_size)
}
self.instrument_colors = {
'snare': Color(*self.red), # default selected timbre
'crash': Color(*self.white),
'bass': Color(*self.white),
'hihat': Color(*self.white),
'triangle': Color(*self.white)
}
x, y = self.pos
snare_pos = (x + self.margin, y + self.margin)
crash_pos = (x + 2 * self.margin + self.button_length, y + self.margin)
bass_pos = (x + 3 * self.margin + 2 * self.button_length,
y + self.margin)
hihat_pos = (x + 4 * self.margin + 3 * self.button_length,
y + self.margin)
triangle_pos = (x + 5 * self.margin + 4 * self.button_length,
y + self.margin)
for instrument, instrument_pos in zip(
('snare', 'crash', 'bass', 'hihat', 'triangle'),
(snare_pos, crash_pos, bass_pos, hihat_pos, triangle_pos)):
self.instruments[instrument].pos = self.instrument_bgs[
instrument].pos = instrument_pos
self.add(self.instrument_colors[instrument])
self.add(self.instrument_bgs[instrument])
self.add(self.instruments[instrument])
title_pos = (x + self.size[0] / 2, y + self.size[1] -
self.title_height / 2 - self.margin / 2)
self.title = CLabelRect(cpos=title_pos, text='drumkit', font_size='18')
self.add(Color(*self.white))
self.add(self.title)
def cube(self, tile):
DEFAULT_VERTEX_FORMAT = [(b'v_tc0', 2, 'float'),
(b'v_normal', 3, 'float'),
(b'v_pos', 3, 'float')]
obj = self.blocks[tile].obj
T()
obj = pywave.Wavefront('tex/block.obj', collect_faces=True)
material = obj.materials['grass']
cube = obj.meshes['Cube']
vertices = obj.vertices
faces = cube.faces
grass = obj.materials['grass']
dirt = obj.materials['dirt']
vertices = grass.vertices + dirt.vertices
#indices = np.array(faces).ravel().tolist()
indices = np.arange(36).astype(int).tolist()
#vertices = np.array(vertices).ravel().tolist()
tex = Image('tex/grass.png').texture
mat = Material(tex)
kw = {
"vertices": vertices,
"indices": indices,
"fmt": DEFAULT_VERTEX_FORMAT,
"mode": "triangles",
'texture': tex
}
#if self.material.map:
# kw["texture"] = self.material.map
mesh = KivyMesh(**kw)
class Meshy(Object3D):
def __init__(self, mesh, material):
super().__init__()
self._mesh = mesh
self.material = material
self.mtl = material
self.vertex_format = DEFAULT_VERTEX_FORMAT
cube = Meshy(mesh, tex)
#cube.material = orig.material
#cube.geometry = orig.geometry
orig._mesh = cube._mesh
orig.material = mat
cube = orig
#cube = kivy3.Mesh([], material)
if tile == 'lava':
cube.pos.y = -0.5
elif tile == 'stone':
cube.pos.y = 1
elif tile == 'grass':
pass
elif tile == 'forest':
pass
elif tile == 'water':
cube.pos.y = -0.33
#cube.material.color = 0., .7, 0. # green
#cube.material.diffuse = 0., .7, 0. # green
return cube
def __init__(self, norm, pos, callback):
super(PitchSelect, self).__init__()
self.norm = norm
self.selected_key = 0
self.root_pitch = 60
self.pitch = 60 # default pitch
self.green = (144 / 255, 238 / 255, 144 / 255)
self.white = (239 / 255, 226 / 255, 222 / 255)
self.black = (.2, .2, .2)
self.color_names = [
'red', 'orange', 'yellow', 'green', 'teal', 'blue', 'indigo',
'violet', 'turquoise', 'pink', 'peach', 'magenta', 'grey'
]
self.callback = callback
self.pos = pos
self.margin = self.norm.nv(20)
self.white_key_size = self.norm.nt((50, 150))
self.black_key_size = self.norm.nt((40, 100))
self.key_margin = self.norm.nv(2) # pixels of space between keys
self.size = (8 * self.white_key_size[0] + 7 * self.key_margin +
2 * self.margin, self.white_key_size[1] +
2 * self.margin + self.norm.nv(60))
self.border_color = Color(238 / 255, 234 / 255, 202 / 255) # yellow
self.border = Line(rectangle=(*self.pos, *self.size), width=2)
self.add(self.border_color)
self.add(self.border)
self.keys = [None] * 13
self.white_keys = [0, 2, 4, 5, 7, 9, 11, 12]
self.black_keys = [1, 3, 6, 8, 10]
key_start = (self.pos[0] + self.margin, self.pos[1] + self.margin)
unit = self.white_key_size[0] + self.key_margin
black_key_units = [1, 2, 4, 5, 6]
for i, m in zip(self.white_keys, range(8)):
self.keys[i] = Rectangle(size=self.white_key_size,
pos=(key_start[0] + m * unit,
key_start[1]))
for i, m in zip(self.black_keys, black_key_units):
self.keys[i] = CRectangle(csize=self.black_key_size,
cpos=(key_start[0] + m * unit,
key_start[1] + self.norm.nv(100)))
self.key_colors = [None] * 13
for i in self.white_keys:
self.key_colors[i] = Color(*self.white)
self.add(self.key_colors[i])
self.add(self.keys[i])
for i in self.black_keys:
self.key_colors[i] = Color(*self.black)
self.add(self.key_colors[i])
self.add(self.keys[i])
self.key_colors[0].rgb = self.green
self.arrow_size = self.norm.nt((50, 50))
self.left_pos = (self.pos[0] + self.margin, self.pos[1] +
self.size[1] - self.arrow_size[1] - self.norm.nv(10))
self.left_off = Rectangle(
pos=self.left_pos,
size=self.arrow_size,
texture=Image('ui/buttons/left_arrow.png').texture)
self.left_on = Rectangle(
pos=self.left_pos,
size=self.arrow_size,
texture=Image('ui/buttons/left_arrow_clicked.png').texture)
self.right_pos = (self.pos[0] + self.size[0] - self.margin -
self.arrow_size[0], self.pos[1] + self.size[1] -
self.arrow_size[1] - self.norm.nv(10))
self.right_off = Rectangle(
pos=self.right_pos,
size=self.arrow_size,
texture=Image('ui/buttons/right_arrow.png').texture)
self.right_on = Rectangle(
pos=self.right_pos,
size=self.arrow_size,
texture=Image('ui/buttons/right_arrow_clicked.png').texture)
# left_off and right_off are always drawn, but when user mouses over an arrow,
# left_on and right_on are drawn over left_off and right_off
self.add(Color(1, 1, 1))
self.add(self.left_off)
self.add(self.right_off)
title_pos = (self.pos[0] + self.size[0] / 2, self.pos[1] +
self.size[1] - self.margin - self.norm.nv(20))
self.title = CLabelRect(cpos=title_pos,
text='pitch: {}'.format(
midi_pitch_to_note_name(self.pitch)),
font_size='18')
self.add(Color(1, 1, 1))
self.add(self.title)
def getBase(self):
self.basename = self.baseNames[self.SPEC_LINEWIDTH][0]
self.basewidth = self.baseNames[self.SPEC_LINEWIDTH][1]
self.texture_base = Image(self.basename).texture
def __init__(self, cords, world):
super(Plant, self).__init__(cords, world, 0, 0)
self._texture = Image("./world/plants/graphics/guarana.png").texture
def getTexture(name, size):
filename = join('art', name+'.png')
texture = Image(filename).texture
texture.wrap = 'repeat'
texture.uvsize = size
return texture
from kivy.clock import Clock
from kivy.core.window import Window
from kivy.core.image import Image
from kivy.graphics import *
from actor import *
from bounce import *
arena = Arena(320, 240)
Ball(arena, 40, 80)
Ball(arena, 80, 40)
Ghost(arena, 120, 80)
turtle = Turtle(arena, 80, 80)
sprites = Image('sprites.png').texture
class GameWidget(Widget):
def __init__(self):
Widget.__init__(self)
Window.size = arena.size()
self._touch_orig = None
Clock.schedule_interval(self.advance_game, 1 / 30)
def on_touch_down(self, touch):
self._touch_orig = touch.x, touch.y
def on_touch_up(self, touch):
turtle.stay()
self._touch_orig = None
def draw_mesh(self, star_list):
filename = 'background_objects.atlas'
star_tex = Image('background_objects-0.png').texture
size_tex = (float(star_tex.size[0]), float(star_tex.size[1]))
uv_dict = self.return_uv_coordinates(filename,
'background_objects-0.png',
size_tex)
choices = [x for x in uv_dict]
vertex_format = [('vPosition', 2, 'float'),
('vTexCoords0', 2, 'float'),
('vRotation', 1, 'float'), ('vCenter', 2, 'float')]
indices = []
ie = indices.extend
for quad_n in xrange(len(star_list)):
offset = 4 * quad_n
ie([
0 + offset, 1 + offset, 2 + offset, 2 + offset, 3 + offset,
0 + offset
])
vertices = []
e = vertices.extend
for star in star_list:
tex_choice = choice(choices)
uv = uv_dict[tex_choice]
w, h = uv[4], uv[5]
x0, y0 = uv[0], uv[1]
x1, y1 = uv[2], uv[3]
e([
-w,
-h,
x0,
y0,
star[2],
star[0],
star[1],
w,
-h,
x1,
y0,
star[2],
star[0],
star[1],
w,
h,
x1,
y1,
star[2],
star[0],
star[1],
-w,
h,
x0,
y1,
star[2],
star[0],
star[1],
])
with self.canvas:
self.mesh = Mesh(indices=indices,
vertices=vertices,
fmt=vertex_format,
mode='triangles',
texture=star_tex)
