games/roc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Integrated major improvements from shooter2 project, including slick UI module!

Browse source
This commit is contained in:
cecilkorik 2017-05-08 23:17:52 -07:00
parent a9ac67e6d6
commit 65019a5e43
25 changed files with 991 additions and 140 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
.hgignore
View file

@ -1,6 +1,6 @@
syntax: glob syntax: glob
*.pyc *.pyc
settings.cfg settings.cfg
lib lib
bin bin
include include

2
__init__.py
View file

@ -1,5 +1,5 @@
from roc_core import * from roc_core import *
import universe import roc_engine
import pipeline import pipeline
import inputs import inputs
import physics import physics

BIN
data/ui/button_bg_corner.png Executable file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 2.8 KiB

BIN
data/ui/button_bg_edge.png Executable file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 2.7 KiB

BIN
data/ui/button_corner.png Executable file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 2.7 KiB

BIN
data/ui/button_edge.png Executable file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 2.7 KiB

BIN
data/ui/frame_bg_corner.png Executable file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 2.7 KiB

BIN
data/ui/frame_bg_edge.png Executable file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 2.7 KiB

BIN
data/ui/frame_corner.png Executable file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 2.8 KiB

BIN
data/ui/frame_edge.png Executable file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 2.7 KiB

4
data/xml/constants.xml
View file

@ -1,6 +1,6 @@
<xml_binary_packing name="constants"> <xml_binary_packing name="constants">
<datatag name="planet_scale" data="float"/> <datatag name="planet_scale" data="float"/>
<datatag name="system_scale" data="float"/> <datatag name="system_scale" data="float"/>
<datatag name="ship_scale" data="float"/> <datatag name="ship_scale" data="float"/>
<datatag name=" <datatag name="xx" data="float"/>
</xml_binary_packing> </xml_binary_packing>

6
data/xml/def/models.xml
View file

@ -19,6 +19,12 @@
<attribute name="y" data="float" default="1.0"/> <attribute name="y" data="float" default="1.0"/>
<attribute name="z" data="float" default="1.0"/> <attribute name="z" data="float" default="1.0"/>
</datatag> </datatag>
<datatag name="scale_to_tex" data="bool" default=""/>
<datatag name="rot" optional="yes">
<attribute name="x" data="float" default="0.0"/>
<attribute name="y" data="float" default="0.0"/>
<attribute name="z" data="float" default="0.0"/>
</datatag>
</datatag> </datatag>
<datatag name="material"> <datatag name="material">
<datatag name="ref" data="string"/> <datatag name="ref" data="string"/>

185
data/xml/models.xml
View file

@ -1,10 +1,14 @@
<models> <models>
<mesh id="mesh_sprite"> <mesh id="mesh_sprite">
<sprite/> <centered_sprite/>
</mesh> </mesh>
<mesh id="mesh_centered_sprite"> <mesh id="mesh_centered_sprite">
<centered_sprite/> <centered_sprite/>
</mesh> </mesh>
<mesh id="mesh_offset_sprite">
<sprite/>
</mesh>
<model id="m_test"> <model id="m_test">
<render layer="0"> <render layer="0">
<mesh><ref>mesh_sprite</ref><scale x="200" y="200"/></mesh> <mesh><ref>mesh_sprite</ref><scale x="200" y="200"/></mesh>
@ -31,10 +35,187 @@
</model> </model>
<model id="m_dralthi"> <model id="m_dralthi">
<render layer="0"> <render layer="0">
<mesh><ref>mesh_centered_sprite</ref><scale x="50" y="50"/></mesh> <mesh><ref>mesh_centered_sprite</ref><scale x="40" y="40"/></mesh>
<material><ref>mat_dralthi</ref></material> <material><ref>mat_dralthi</ref></material>
</render> </render>
</model> </model>
<model id="ui_frame_tl">
<render layer="0">
<mesh><ref>mesh_sprite</ref><scale_to_tex/></mesh>
<material><ref>mat_ui_frame_corner</ref></material>
</render>
<render layer="1">
<mesh><ref>mesh_sprite</ref><scale_to_tex/></mesh>
<material><ref>mat_ui_frame_bg_corner</ref></material>
</render>
</model>
<model id="ui_frame_tc">
<render layer="0">
<mesh><ref>mesh_sprite</ref><scale_to_tex/></mesh>
<material><ref>mat_ui_frame_edge</ref></material>
</render>
<render layer="1">
<mesh><ref>mesh_sprite</ref><scale_to_tex/></mesh>
<material><ref>mat_ui_frame_bg_edge</ref></material>
</render>
</model>
<model id="ui_frame_tr">
<render layer="0">
<mesh><ref>mesh_sprite</ref><scale_to_tex/><rot z="90.0"/></mesh>
<material><ref>mat_ui_frame_corner</ref></material>
</render>
<render layer="1">
<mesh><ref>mesh_sprite</ref><scale_to_tex/><rot z="90.0"/></mesh>
<material><ref>mat_ui_frame_bg_corner</ref></material>
</render>
</model>
<model id="ui_frame_cl">
<render layer="0">
<mesh><ref>mesh_sprite</ref><scale_to_tex/><rot z="270.0"/></mesh>
<material><ref>mat_ui_frame_edge</ref></material>
</render>
<render layer="1">
<mesh><ref>mesh_sprite</ref><scale_to_tex/><rot z="270.0"/></mesh>
<material><ref>mat_ui_frame_bg_edge</ref></material>
</render>
</model>
<model id="ui_frame_cc">
<render layer="0">
<mesh><ref>mesh_sprite</ref></mesh>
<material><ref>mat_blank</ref></material>
</render>
</model>
<model id="ui_frame_cr">
<render layer="0">
<mesh><ref>mesh_sprite</ref><scale_to_tex/><rot z="90.0"/></mesh>
<material><ref>mat_ui_frame_edge</ref></material>
</render>
<render layer="1">
<mesh><ref>mesh_sprite</ref><scale_to_tex/><rot z="90.0"/></mesh>
<material><ref>mat_ui_frame_bg_edge</ref></material>
</render>
</model>
<model id="ui_frame_bl">
<render layer="0">
<mesh><ref>mesh_sprite</ref><scale_to_tex/><rot z="270.0"/></mesh>
<material><ref>mat_ui_frame_corner</ref></material>
</render>
<render layer="1">
<mesh><ref>mesh_sprite</ref><scale_to_tex/><rot z="270.0"/></mesh>
<material><ref>mat_ui_frame_bg_corner</ref></material>
</render>
</model>
<model id="ui_frame_bc">
<render layer="0">
<mesh><ref>mesh_sprite</ref><scale_to_tex/><rot z="180.0"/></mesh>
<material><ref>mat_ui_frame_edge</ref></material>
</render>
<render layer="1">
<mesh><ref>mesh_sprite</ref><scale_to_tex/><rot z="180.0"/></mesh>
<material><ref>mat_ui_frame_bg_edge</ref></material>
</render>
</model>
<model id="ui_frame_br">
<render layer="0">
<mesh><ref>mesh_sprite</ref><scale_to_tex/><rot z="180.0"/></mesh>
<material><ref>mat_ui_frame_corner</ref></material>
</render>
<render layer="1">
<mesh><ref>mesh_sprite</ref><scale_to_tex/><rot z="180.0"/></mesh>
<material><ref>mat_ui_frame_bg_corner</ref></material>
</render>
</model>
<model id="ui_button_tl">
<render layer="0">
<mesh><ref>mesh_sprite</ref><scale_to_tex/></mesh>
<material><ref>mat_ui_button_corner</ref></material>
</render>
<render layer="1">
<mesh><ref>mesh_sprite</ref><scale_to_tex/></mesh>
<material><ref>mat_ui_button_bg_corner</ref></material>
</render>
</model>
<model id="ui_button_tc">
<render layer="0">
<mesh><ref>mesh_sprite</ref><scale_to_tex/></mesh>
<material><ref>mat_ui_button_edge</ref></material>
</render>
<render layer="1">
<mesh><ref>mesh_sprite</ref><scale_to_tex/></mesh>
<material><ref>mat_ui_button_bg_edge</ref></material>
</render>
</model>
<model id="ui_button_tr">
<render layer="0">
<mesh><ref>mesh_sprite</ref><scale_to_tex/><rot z="90.0"/></mesh>
<material><ref>mat_ui_button_corner</ref></material>
</render>
<render layer="1">
<mesh><ref>mesh_sprite</ref><scale_to_tex/><rot z="90.0"/></mesh>
<material><ref>mat_ui_button_bg_corner</ref></material>
</render>
</model>
<model id="ui_button_cl">
<render layer="0">
<mesh><ref>mesh_sprite</ref><scale_to_tex/><rot z="270.0"/></mesh>
<material><ref>mat_ui_button_edge</ref></material>
</render>
<render layer="1">
<mesh><ref>mesh_sprite</ref><scale_to_tex/><rot z="270.0"/></mesh>
<material><ref>mat_ui_button_bg_edge</ref></material>
</render>
</model>
<model id="ui_button_cc">
<render layer="0">
<mesh><ref>mesh_sprite</ref></mesh>
<material><ref>mat_blank</ref></material>
</render>
</model>
<model id="ui_button_cr">
<render layer="0">
<mesh><ref>mesh_sprite</ref><scale_to_tex/><rot z="90.0"/></mesh>
<material><ref>mat_ui_button_edge</ref></material>
</render>
<render layer="1">
<mesh><ref>mesh_sprite</ref><scale_to_tex/><rot z="90.0"/></mesh>
<material><ref>mat_ui_button_bg_edge</ref></material>
</render>
</model>
<model id="ui_button_bl">
<render layer="0">
<mesh><ref>mesh_sprite</ref><scale_to_tex/><rot z="270.0"/></mesh>
<material><ref>mat_ui_button_corner</ref></material>
</render>
<render layer="1">
<mesh><ref>mesh_sprite</ref><scale_to_tex/><rot z="270.0"/></mesh>
<material><ref>mat_ui_button_bg_corner</ref></material>
</render>
</model>
<model id="ui_button_bc">
<render layer="0">
<mesh><ref>mesh_sprite</ref><scale_to_tex/><rot z="180.0"/></mesh>
<material><ref>mat_ui_button_edge</ref></material>
</render>
<render layer="1">
<mesh><ref>mesh_sprite</ref><scale_to_tex/><rot z="180.0"/></mesh>
<material><ref>mat_ui_button_bg_edge</ref></material>
</render>
</model>
<model id="ui_button_br">
<render layer="0">
<mesh><ref>mesh_sprite</ref><scale_to_tex/><rot z="180.0"/></mesh>
<material><ref>mat_ui_button_corner</ref></material>
</render>
<render layer="1">
<mesh><ref>mesh_sprite</ref><scale_to_tex/><rot z="180.0"/></mesh>
<material><ref>mat_ui_button_bg_corner</ref></material>
</render>
</model>
</models> </models>

52
data/xml/textures.xml
View file

@ -13,7 +13,7 @@
<uniform/> <uniform/>
</texture> </texture>
<material id="mat_blank"> <material id="mat_blank">
<texture ref="t_white" type="diffuse"/> <texture ref="t_white" type="noaa"/>
<texture ref="tnm_flat" type="normal"/> <texture ref="tnm_flat" type="normal"/>
</material> </material>
<texture id="t_test"> <texture id="t_test">
@ -28,6 +28,56 @@
<texture id="t_dralthi"> <texture id="t_dralthi">
<file>tex/dralthi.png</file> <file>tex/dralthi.png</file>
</texture> </texture>
<texture id="t_ui_button_corner">
<file>ui/button_corner.png</file>
</texture>
<texture id="t_ui_button_edge">
<file>ui/button_edge.png</file>
</texture>
<texture id="t_ui_button_bg_corner">
<file>ui/button_bg_corner.png</file>
</texture>
<texture id="t_ui_button_bg_edge">
<file>ui/button_bg_edge.png</file>
</texture>
<texture id="t_ui_frame_corner">
<file>ui/frame_corner.png</file>
</texture>
<texture id="t_ui_frame_edge">
<file>ui/frame_edge.png</file>
</texture>
<texture id="t_ui_frame_bg_corner">
<file>ui/frame_bg_corner.png</file>
</texture>
<texture id="t_ui_frame_bg_edge">
<file>ui/frame_bg_edge.png</file>
</texture>
<material id="mat_ui_button_corner">
<texture ref="t_ui_button_corner" type="noaa"/>
</material>
<material id="mat_ui_button_edge">
<texture ref="t_ui_button_edge" type="noaa"/>
</material>
<material id="mat_ui_button_bg_corner">
<texture ref="t_ui_button_bg_corner" type="noaa"/>
</material>
<material id="mat_ui_button_bg_edge">
<texture ref="t_ui_button_bg_edge" type="noaa"/>
</material>
<material id="mat_ui_frame_corner">
<texture ref="t_ui_frame_corner" type="noaa"/>
</material>
<material id="mat_ui_frame_edge">
<texture ref="t_ui_frame_edge" type="noaa"/>
</material>
<material id="mat_ui_frame_bg_corner">
<texture ref="t_ui_frame_bg_corner" type="noaa"/>
</material>
<material id="mat_ui_frame_bg_edge">
<texture ref="t_ui_frame_bg_edge" type="noaa"/>
</material>
<texture id="t_test_plasma"> <texture id="t_test_plasma">
<file>tex/plasma1.png</file> <file>tex/plasma1.png</file>

24
enums.py
View file

@ -1,5 +1,9 @@
class enum(object): class enum(object):
def __init__(self, names=[]):
for i, name in enumerate(names):
setattr(self, name, i)
def __len__(self): def __len__(self):
return len([x for x in dir(self) if x[0] != '_']) return len([x for x in dir(self) if x[0] != '_'])
@ -82,4 +86,22 @@ tt = enum()
tt.diffuse = 0 # the diffuse texture sets the colors and general brightness of the texture. if the same texture is used as the emissive texture, the model is effectively "fullbright" tt.diffuse = 0 # the diffuse texture sets the colors and general brightness of the texture. if the same texture is used as the emissive texture, the model is effectively "fullbright"
tt.emissive = 1 # this texture is blended with the diffuse texture as the light level drops (this can be used to add running lights or glow to a ship, or light up the dark side of a planet, otherwise pure "black" is a good choice) tt.emissive = 1 # this texture is blended with the diffuse texture as the light level drops (this can be used to add running lights or glow to a ship, or light up the dark side of a planet, otherwise pure "black" is a good choice)
tt.specular = 2 # adding a specular map allows you to add areas of low or high reflectivity to your texture tt.specular = 2 # adding a specular map allows you to add areas of low or high reflectivity to your texture
tt.normal = 3 # normal maps allow bump mapping and other tweaks, with each channel representing the direction of the normal (red = -1x to 1x, green = -1y to 1y, blue = 0z to 1z) tt.normal = 3 # normal maps allow bump mapping and other tweaks, with each channel representing the direction of the normal (red = -1x to 1x, green = -1y to 1y, blue = 0z to 1z)
tt.noaa = 4 # this replaces the diffuse texture, and is used for sprites that dont want to be antialiased
# UI stuff
ui_frametype = enum()
ui_frametype.grid = 0
ui_frametype.composite = 1
ui_frametype.model = 2
ui_postype = enum()
ui_postype.center = 0
ui_postype.relative = 1
ui_postype.absolute = 2
ui_filltype = enum()
ui_filltype.none = 0
ui_filltype.tile = 1
ui_filltype.stretch = 2

9
fonts.py
View file

@ -100,7 +100,14 @@ class TexFont(object):
else: else:
return self.charsizes[idx] return self.charsizes[idx]
def get_size(self, text):
total = 0
for i, letter in enumerate(text):
charidx = self.mapchar(letter)
x, y = self.charsize(charidx)
total += x
return (total, y)
def mapchar(self, char): def mapchar(self, char):
""" """

13
gameobj.py
View file

@ -1,5 +1,18 @@
import enums import enums
class datastorage(object):
def __init__(self, readonly=False):
self.__ro = readonly
def __setattr__(self, name, value):
if name in ('__ro',):
object.__setattr__(self, name, value)
if self.__ro:
raise ValueError("Unable to set read-only property")
else:
object.__setattr__(self, name, value)
class gameobj(object): class gameobj(object):
def __init__(self, self.pos): def __init__(self, self.pos):
self.pos = pos self.pos = pos

188
gametimer.py
View file

@ -1,104 +1,98 @@
import pygame import pygame
import collections import collections
def start_loop(): class GameTimer(object):
global g_timer, g_elapsed def __init__(self):
g_elapsed = 0 self.update_fps_count = None
g_elapsed_sec = 0.0
g_timer = pygame.time.get_ticks() def start_loop(self):
reset_fps_count() self.elapsed = 0
self.elapsed_sec = 0.0
def next_frame(skipping=False): self.timer = pygame.time.get_ticks()
global g_timer, g_elapsed, g_elapsed_sec self.reset_fps_count()
newticks = pygame.time.get_ticks() def next_frame(self, skipping=False):
#if skipping:
# # reset g_timer to it's value from the previous frame newticks = pygame.time.get_ticks()
# g_timer -= g_elapsed #if skipping:
g_elapsed = newticks - g_timer # # reset self.timer to it's value from the previous frame
g_timer = newticks # self.timer -= self.elapsed
g_elapsed_sec = float(g_elapsed) / 1000.0 self.elapsed = newticks - self.timer
self.timer = newticks
if g_elapsed != 0: self.elapsed_sec = float(self.elapsed) / 1000.0
update_fps_count(g_elapsed)
if self.elapsed != 0:
self.update_fps_count(self.elapsed)
def reset_fps_count():
global g_framelist, update_fps_count
g_framelist = collections.deque() def reset_fps_count(self):
update_fps_count = update_fps_count_empty self.framelist = collections.deque()
self.update_fps_count = self.update_fps_count_empty
def update_fps_count_empty(elapsed):
global g_framelist, update_fps_count def update_fps_count_empty(self, elapsed):
g_framelist.append(elapsed) self.framelist.append(elapsed)
if len(g_framelist) >= 25: if len(self.framelist) >= 25:
update_fps_count = update_fps_count_full self.update_fps_count = self.update_fps_count_full
def update_fps_count_full(elapsed): def update_fps_count_full(self, elapsed):
global g_framelist self.framelist.popleft()
g_framelist.popleft() self.framelist.append(elapsed)
g_framelist.append(elapsed)
def update_fps_count(elapsed): def elapsed(self):
"this is replaced with either the _empty or _full variant, depending on the situation" """
pass get the amount of time in milliseconds passed since the last frame was displayed
"""
def elapsed(): return self.elapsed
"""
get the amount of time in milliseconds passed since the last frame was displayed def elapsed_sec(self):
""" """
return g_elapsed get the amount of time in seconds passed since the last frame was displayed
"""
def elapsed_sec(): return self.elapsed_sec
"""
get the amount of time in seconds passed since the last frame was displayed def num_frames(self, delay, offset=0):
""" """
return g_elapsed_sec if you want something to occur every "delay" milliseconds,
this will return the number of times you should make it happen
def num_frames(delay, offset=0): in this particular frame (can be 0)
""" """
if you want something to occur every "delay" milliseconds, return int((self.timer - offset) / delay) - int((self.timer - self.elapsed - offset) / delay)
this will return the number of times you should make it happen
in this particular frame (can be 0) def loop_frames(self, delay, offset=0):
""" return range(num_frames(delay, offset))
global g_elapsed, g_timer
return int((g_timer - offset) / delay) - int((g_timer - g_elapsed - offset) / delay) def get_timer(self):
return self.timer
def loop_frames(delay, offset=0):
return range(num_frames(delay, offset)) def average(self, d):
#spf = (float(sum(self.framelist)) / (len(self.framelist) * 1000.0))
def get_timer(): if len(d) == 0:
return g_timer return 0.0
def average(d): smooth = 0.85
#spf = (float(sum(g_framelist)) / (len(g_framelist) * 1000.0)) #v2 = float(d[-1])
if len(d) == 0: #for i in xrange(len(d) - 2, 0, -1):
return 0.0 # pass
smooth = 0.85 v2 = float(d[0])
#v2 = float(d[-1]) for i in range(1, len(d)):
#for i in xrange(len(d) - 2, 0, -1): v1 = float(d[i])
# pass v2 = (smooth * v2) + ((1.0 - smooth) * v1)
return v2
def get_fps(self):
#return ",".join([str(x) for x in sorted(self.framelist)])
if len(self.framelist) == 0.0:
return 0.0
spf = self.average(self.framelist) / 1000.0
if spf == 0.0:
return 0.0
#print "%s < %s" % (1.0 / spf, self.framelist)
return 1.0 / spf
v2 = float(d[0])
for i in range(1, len(d)):
v1 = float(d[i])
v2 = (smooth * v2) + ((1.0 - smooth) * v1)
return v2
def get_fps():
global g_framelist
#return ",".join([str(x) for x in sorted(g_framelist)])
if len(g_framelist) == 0.0:
return 0.0
spf = average(g_framelist) / 1000.0
if spf == 0.0:
return 0.0
#print "%s < %s" % (1.0 / spf, g_framelist)
return 1.0 / spf

68
models.py
View file

@ -46,7 +46,9 @@ class Model_Manager(object):
def load_textypes(self): def load_textypes(self):
self.textypes = {} self.textypes = {}
self.textypes[enums.tt.diffuse] = TextureType(GL_TEXTURE0, GL_TEXTURE_2D, GL_CLAMP, GL_CLAMP, GL_LINEAR, GL_LINEAR) self.textypes[enums.tt.diffuse] = TextureType(GL_TEXTURE0, GL_TEXTURE_2D, GL_CLAMP, GL_CLAMP, GL_LINEAR, GL_LINEAR)
self.textypes[enums.tt.noaa] = TextureType(GL_TEXTURE0, GL_TEXTURE_2D, GL_REPEAT, GL_REPEAT, GL_NEAREST, GL_NEAREST)
self.textypes[enums.tt.emissive] = TextureType(GL_TEXTURE1, GL_TEXTURE_2D) self.textypes[enums.tt.emissive] = TextureType(GL_TEXTURE1, GL_TEXTURE_2D)
self.textypes[enums.tt.specular] = TextureType(GL_TEXTURE2, GL_TEXTURE_2D) self.textypes[enums.tt.specular] = TextureType(GL_TEXTURE2, GL_TEXTURE_2D)
self.textypes[enums.tt.normal] = TextureType(GL_TEXTURE3, GL_TEXTURE_2D) self.textypes[enums.tt.normal] = TextureType(GL_TEXTURE3, GL_TEXTURE_2D)
@ -97,7 +99,8 @@ class Model_Manager(object):
self.models = {} self.models = {}
for meshdata in mdldata.mesh: for meshdata in mdldata.mesh:
if meshdata['sprite']: if meshdata['sprite']:
self.sprite_mesh = SpriteMesh() if self.sprite_mesh == None:
self.sprite_mesh = SpriteMesh()
mesh = self.sprite_mesh mesh = self.sprite_mesh
elif meshdata['centered_sprite']: elif meshdata['centered_sprite']:
if self.centered_sprite_mesh == None: if self.centered_sprite_mesh == None:
@ -266,14 +269,22 @@ class Material(object):
if texobj.uniform: if texobj.uniform:
if self.texcoords_uniform == self.texcoords_notimpl: if self.texcoords_uniform == self.texcoords_notimpl:
self.texcoords_uniform = texobj.texcoords self.texcoords_uniform = texobj.texcoords
self.texcoords = texobj.texcoords
else: else:
if prevtex: if prevtex:
assert texobj.texcoords(0.0, 0.0) == prevtex.texcoords(0.0, 0.0) and texobj.texcoords(1.0, 1.0) == prevtex.texcoords(1.0, 1.0) assert texobj.texcoords(0.0, 0.0) == prevtex.texcoords(0.0, 0.0) and texobj.texcoords(1.0, 1.0) == prevtex.texcoords(1.0, 1.0)
if self.texcoords == self.texcoords_notimpl: if self.texcoords == self.texcoords_notimpl:
self.texcoords = texobj.texcoords self.texcoords = texobj.texcoords
prevtex = texobj
prevtex = texobj
def get_base_texture(self):
if enums.tt.noaa in self.textures:
t = self.textures[enums.tt.noaa]
else:
t = self.textures[enums.tt.diffuse]
return t
class Mesh(object): class Mesh(object):
@ -333,6 +344,12 @@ class SpriteMeshCentered(SpriteMesh):
Vertex(vect(-0.5, 0.5, 0.0), vect(0.0, 0.0, 1.0), (0.0, 1.0), None), Vertex(vect(-0.5, 0.5, 0.0), vect(0.0, 0.0, 1.0), (0.0, 1.0), None),
Vertex(vect( 0.5, 0.5, 0.0), vect(0.0, 0.0, 1.0), (1.0, 1.0), None), Vertex(vect( 0.5, 0.5, 0.0), vect(0.0, 0.0, 1.0), (1.0, 1.0), None),
] ]
@staticmethod
def factory(meshdata):
s = SpriteMeshCentered()
s.scale
return s
class RenderLayer(object): class RenderLayer(object):
def __init__(self, layernum): def __init__(self, layernum):
@ -343,6 +360,8 @@ class RenderLayer(object):
self.scale = [1.0, 1.0, 1.0] self.scale = [1.0, 1.0, 1.0]
self.displaylist = None self.displaylist = None
self.anim = "idle" self.anim = "idle"
self.rotations = None
self.tile = False
def load(self, layerdata): def load(self, layerdata):
meshdata = layerdata.mesh meshdata = layerdata.mesh
@ -352,23 +371,46 @@ class RenderLayer(object):
self.color = [matdata.color['r'], matdata.color['g'], matdata.color['b'], matdata.color['a']] self.color = [matdata.color['r'], matdata.color['g'], matdata.color['b'], matdata.color['a']]
self.scale = [meshdata.scale['x'], meshdata.scale['y'], meshdata.scale['z']] self.scale = [meshdata.scale['x'], meshdata.scale['y'], meshdata.scale['z']]
self.scale = [x * meshdata['scale'] for x in self.scale] self.scale = [x * meshdata['scale'] for x in self.scale]
self.rotations = [meshdata.rot['x'], meshdata.rot['y'], meshdata.rot['z']]
if meshdata['scale_to_tex']:
t = self.material.get_base_texture()
self.scale = [float(t.w), float(t.h), 1.0]
def get_base_texture(self):
if enums.tt.noaa in self.material.textures:
t = self.material.textures[enums.tt.noaa]
else:
t = self.material.textures[enums.tt.diffuse]
return t
def render(self): def render(self):
self.material.bind() self.material.bind()
glPushMatrix() glPushMatrix()
glScalef(*self.scale) glScalef(*self.scale)
if self.color != None: if self.color != None:
glColor4f(*self.color) glColor4f(*self.color)
glRotatef(self.rotations[0], 1.0, 0.0, 0.0)
glRotatef(self.rotations[1], 0.0, 1.0, 0.0)
glRotatef(self.rotations[2], 0.0, 0.0, 1.0)
if self.displaylist == None: if self.displaylist == None:
self.displaylist = glGenLists(1) self.displaylist = glGenLists(1)
glNewList(self.displaylist, GL_COMPILE) glNewList(self.displaylist, GL_COMPILE)
self.mesh.draw(self.material.texcoords) if self.tile:
tcfunc = self.tile_texcoords
else:
tcfunc = self.material.texcoords
self.mesh.draw(tcfunc)
glEndList() glEndList()
#print "Drawing mesh %s" % ( self.displaylist, ) #print "Drawing mesh %s" % ( self.displaylist, )
glCallList(self.displaylist) glCallList(self.displaylist)
glPopMatrix() glPopMatrix()
def tile_texcoords(self, u, v):
t = self.material.get_base_texture()
u = u * self.scale[0] / t.w
v = v * self.scale[1] / t.h
return self.material.texcoords(u, v)
class ParticleLayer(RenderLayer): class ParticleLayer(RenderLayer):
def __init__(self, layernum): def __init__(self, layernum):
@ -383,6 +425,15 @@ class Model(object):
def __init__(self): def __init__(self):
self.layers = [] self.layers = []
def get_size(self):
if not self.layers:
return (0.0, 0.0, 0.0)
for layer in self.layers:
return [layer.scale[i] for i in range(0, len(layer.scale))]
def load(self, data): def load(self, data):
tmplayers = [] tmplayers = []
for rend in data.render: for rend in data.render:
@ -404,6 +455,7 @@ class Model(object):
class TextModel(Model): class TextModel(Model):
def __init__(self, fontname, text, color=None, scale=None): def __init__(self, fontname, text, color=None, scale=None):
Model.__init__(self)
self.displaylist = None self.displaylist = None
self.fontname = fontname self.fontname = fontname
self.text = text self.text = text
@ -418,6 +470,10 @@ class TextModel(Model):
def instance(self): def instance(self):
return self return self
def get_size(self):
font = mgr.get_font(self.fontname)
return font.get_size(self.text)
def render(self): def render(self):
glPushMatrix() glPushMatrix()
glScalef(*self.scale) glScalef(*self.scale)

8
roc_core.py
View file

@ -4,9 +4,9 @@ import video
import shader import shader
import models import models
import roc_main import roc_main
import universe import roc_engine
import config import config
base_universe = universe.base_universe base_engine = roc_engine.base_engine
def init2d(): def init2d():
init(videoinit=video.init2d) init(videoinit=video.init2d)
@ -29,8 +29,8 @@ def init(videoinit):
models.init() models.init()
def set_universe(new_universe): def set_engine(new_engine):
roc_main.set_universe(new_universe) roc_main.set_engine(new_engine)
def main(): def main():
roc_main.mainloop() roc_main.mainloop()

4
universe.py → roc_engine.py
View file

@ -4,7 +4,7 @@ import pygame
from OpenGL.GL import * from OpenGL.GL import *
from py3dutil import vect, quat from py3dutil import vect, quat
class base_universe(object): class base_engine(object):
def __init__(self): def __init__(self):
pass pass
@ -20,7 +20,7 @@ class base_universe(object):
def render(self): def render(self):
pass pass
class tiled_universe(base_universe): class tiled_engine(base_engine):
def __init__(self): def __init__(self):
pass pass

16
roc_main.py
View file

@ -10,20 +10,18 @@ import config
from OpenGL.GL import * from OpenGL.GL import *
def set_universe(new_universe): def set_engine(new_engine):
global g_universe global g_engine
g_universe = new_universe g_engine = new_engine
g_universe = None g_engine = None
def mainloop(): def mainloop():
global g_universe global g_engine
gametimer.start_loop()
while True: while True:
events = pygame.event.get() events = pygame.event.get()
gametimer.next_frame()
pygame.event.pump() pygame.event.pump()
for ev in events: for ev in events:
if ev.type == QUIT: if ev.type == QUIT:
@ -42,9 +40,9 @@ def mainloop():
video.predraw() video.predraw()
g_universe.frame(events) g_engine.frame(events)
video.next_frame() video.next_frame()
video.save_window_pos() video.save_window_pos()
config.mgr.save() config.mgr.save()

5
roc_test.py
View file

@ -1,7 +1,6 @@
#import roc #import roc
import os import os
import sys import sys
sys.path.append(os.path.abspath('..'))
import roc import roc
import pygame import pygame
from OpenGL.GL import * from OpenGL.GL import *
@ -60,7 +59,7 @@ class partycle(object):
self.yd *= 0.985 self.yd *= 0.985
self.rot += self.rotd self.rot += self.rotd
class test_universe(roc.universe.base_universe): class test_engine(roc.engine.base_engine):
def __init__(self): def __init__(self):
self.font = models.mgr.fontlib["micross20"] self.font = models.mgr.fontlib["micross20"]
self.text1 = models.TextModel("micross20", "#$% 0123 ,,,, Hello world!\xa8\xa8\xa8F", (1.0, 1.0, 0.5, 1.0)) self.text1 = models.TextModel("micross20", "#$% 0123 ,,,, Hello world!\xa8\xa8\xa8F", (1.0, 1.0, 0.5, 1.0))
@ -168,7 +167,7 @@ class test_universe(roc.universe.base_universe):
roc.video.width = 1024 roc.video.width = 1024
roc.video.height = 768 roc.video.height = 768
roc.init2d() roc.init2d()
roc.set_universe(test_universe()) roc.set_engine(test_engine())
roc.main() roc.main()

15
shader.py
View file

@ -122,17 +122,17 @@ class shader_manager(object):
try: try:
shaderinit() shaderinit()
except: except:
print("Shader type %s failed to initialize" % (shadername,)) print(("Shader type %s failed to initialize" % (shadername,)))
continue continue
try: try:
self.select("ffp") self.select("ffp")
except: except:
print("Shader type %s failed to access the fixed function pipeline" % (shadername,)) print(("Shader type %s failed to access the fixed function pipeline" % (shadername,)))
continue continue
try: try:
self.select("standard") self.select("standard")
except: except:
print("Shader type %s failed to load the \"standard\" vertex and fragment shaders" % (shadername,)) print(("Shader type %s failed to load the \"standard\" vertex and fragment shaders" % (shadername,)))
continue continue
workable_shaders.append(shadername) workable_shaders.append(shadername)
@ -171,28 +171,28 @@ class shader_manager(object):
except GLError: except GLError:
p = self.shaderlib[shader] p = self.shaderlib[shader]
v, f = self.shaderprograms[shader] v, f = self.shaderprograms[shader]
print("Shader failed to execute: %s" % (shader,)) print(("Shader failed to execute: %s" % (shader,)))
print("Vertex shader log:") print("Vertex shader log:")
lenarr = GLintArray.zeros(1) lenarr = GLintArray.zeros(1)
glGetShaderiv(v, GL_INFO_LOG_LENGTH, lenarr) glGetShaderiv(v, GL_INFO_LOG_LENGTH, lenarr)
infoarr = GLcharArray.zeros(lenarr[0]) infoarr = GLcharArray.zeros(lenarr[0])
outsize = GLsizeiArray.zeros(1) outsize = GLsizeiArray.zeros(1)
glGetShaderInfoLog(v, lenarr[0], outsize, infoarr) glGetShaderInfoLog(v, lenarr[0], outsize, infoarr)
print(''.join([chr(x) for x in infoarr[:outsize[0]]])) print((''.join([chr(x) for x in infoarr[:outsize[0]]])))
print("Fragment shader log:") print("Fragment shader log:")
lenarr = GLintArray.zeros(1) lenarr = GLintArray.zeros(1)
glGetShaderiv(f, GL_INFO_LOG_LENGTH, lenarr) glGetShaderiv(f, GL_INFO_LOG_LENGTH, lenarr)
infoarr = GLcharArray.zeros(lenarr[0]) infoarr = GLcharArray.zeros(lenarr[0])
outsize = GLsizeiArray.zeros(1) outsize = GLsizeiArray.zeros(1)
glGetShaderInfoLog(f, lenarr[0], outsize, infoarr) glGetShaderInfoLog(f, lenarr[0], outsize, infoarr)
print(''.join([chr(x) for x in infoarr[:outsize[0]]])) print((''.join([chr(x) for x in infoarr[:outsize[0]]])))
print("Program info log:") print("Program info log:")
lenarr = GLintArray.zeros(1) lenarr = GLintArray.zeros(1)
glGetProgramiv(p, GL_INFO_LOG_LENGTH, lenarr) glGetProgramiv(p, GL_INFO_LOG_LENGTH, lenarr)
infoarr = GLcharArray.zeros(lenarr[0]) infoarr = GLcharArray.zeros(lenarr[0])
outsize = GLsizeiArray.zeros(1) outsize = GLsizeiArray.zeros(1)
glGetProgramInfoLog(p, lenarr[0], outsize, infoarr) glGetProgramInfoLog(p, lenarr[0], outsize, infoarr)
print(''.join([chr(x) for x in infoarr[:outsize[0]]])) print((''.join([chr(x) for x in infoarr[:outsize[0]]])))
glDeleteShader(v) glDeleteShader(v)
glDeleteShader(f) glDeleteShader(f)
glDeleteProgram(p) glDeleteProgram(p)
@ -215,6 +215,5 @@ class shader_manager(object):
def init(): def init():
global mgr global mgr
mgr = shader_manager() mgr = shader_manager()
print("initiated shader mgr: %s" % (mgr,))
mgr = None mgr = None

526
ui.py Executable file
View file

@ -0,0 +1,526 @@
import enums
from enums import ui_frametype, ui_postype, ui_filltype
from pygame.locals import *
import models
import video
from OpenGL.GL import *
import inputs
class UIFrame(object):
def __init__(self, content, contentdata):
self.func = None
self.content = content
self.data = contentdata
self.parent = None
self.minsize = None
self.maxsize = None
self.size = None
self.gridsize = None
self.pos = None
self.postype = ui_postype.relative
self.posset = None
self.fill = ui_filltype.stretch
self.draggable = False
self.padding = (0, 0)
self.color = None
self.stretchiness = None
def constrain_size(self, x, y):
if self.content == ui_frametype.grid:
x += self.padding[0] * len(self.data) * 2
y += self.padding[1] * len(self.data[0]) * 2
else:
x += self.padding[0] * 2
y += self.padding[1] * 2
if self.minsize:
x = max(self.minsize[0], x)
y = max(self.minsize[1], y)
if self.maxsize:
x = min(self.maxsize[0], x)
y = min(self.maxsize[1], y)
return (x, y)
def get_parent_size(self):
if self.parent == None:
return video.get_res()
else:
#return self.parent.get_child_size(self)
return self.parent.size
def get_child_size(self, child):
if self.content == ui_frametype.grid:
for i, row in enumerate(self.data):
for j, col in enumerate(row):
if col == child:
x = self.gridsize[0][j]
y = self.gridsize[1][i]
if False and self.stretchiness:
xlo = self.size[0] - sum(self.gridsize[0])
ylo = self.size[1] - sum(self.gridsize[1])
if xlo > 0:
xs = self.stretchiness[0][j]
xst = sum(self.stretchiness[0])
x += int(float(xlo) * float(xs) / float(xst))
if ylo > 0:
ys = self.stretchiness[1][i]
yst = sum(self.stretchiness[1])
y += int(float(ylo) * float(ys) / float(yst))
return (x, y)
else:
return self.size
def get_parent_pos(self):
if self.parent == None:
return (0, 0)
else:
#return self.parent.get_child_pos(self)
return self.parent.pos
def get_child_pos(self, child):
if self.content == ui_frametype.grid:
for i, row in enumerate(self.data):
for j, col in enumerate(row):
if col == child:
#x = sum(self.gridsize[0][:j])+self.padding[0]
#y = sum(self.gridsize[1][:i])+self.padding[1]
x = sum(self.gridsize[0][:j])
y = sum(self.gridsize[1][:i])
return (x, y)
else:
return (0, 0)
def autopos(self):
if self.postype == ui_postype.center:
ppos = self.get_parent_pos()
psize = self.get_parent_size()
self.pos = (ppos[0] + (psize[0]//2) - (self.size[0]//2), ppos[1] + (psize[1]//2) - (self.size[1]//2))
elif self.postype == ui_postype.relative:
if not self.posset:
self.posset = self.parent.get_child_pos(self)
ppos = self.get_parent_pos()
psize = self.get_parent_size()
if self.posset[0] >= 0:
x = self.posset[0] + ppos[0]
else:
x = self.posset[0] - ppos[0] - psize[0] + self.size[0]
if self.posset[1] >= 0:
y = self.posset[1] + ppos[1]
else:
y = self.posset[1] - ppos[1] - psize[1] + self.size[1]
self.pos = (x, y)
elif self.postype == ui_postype.absolute:
"This is bad. Don't do this. Asshole."
self.pos = self.posset
alist = [x for x in self.ancestors()]
if mgr.debugobj in alist:
print(("FUCK. OK DUDER. I AM YOUR DEBUG OBJECT: %s" % (alist.index(mgr.debugobj),)))
print((self.parent.pos))
print((self.get_parent_pos()))
print((self.parent.get_child_pos(self)))
#print self.fill == ui_filltype.none
#print self.postype == ui_postype.center
print((self.pos))
#print self.gridsize
print("END DEBUG OBJECT")
"""calculate position top-down, since child's position will depend on having an accurate parent position?"""
for child in self:
child.autopos()
def autosize(self):
if self.content == ui_frametype.model:
self.size = self.constrain_size(int(self.data.get_size()[0]), int(self.data.get_size()[1]))
elif self.content == ui_frametype.grid:
if not self.data:
self.size = self.constrain_size(0, 0)
self.gridsize = [[], []]
return
self.gridsize = [[0] * len(self.data[0]), [0] * len(self.data)]
for ir, row in enumerate(self.data):
for ic, col in enumerate(row):
col.autosize()
self.gridsize[0][ic] = max(self.gridsize[0][ic], col.size[0])
self.gridsize[1][ir] = max(self.gridsize[1][ir], col.size[1])
self.size = self.constrain_size(sum(self.gridsize[0]), sum(self.gridsize[1]))
print(("grid CONSTRAINED: %s - %s" % (self.size, self.padding)))
elif self.content == ui_frametype.composite:
x = 0
y = 0
for child in self:
child.autosize()
x = max(child.size[0], x)
y = max(child.size[1], y)
self.size = self.constrain_size(x, y)
print(("composite CONSTRAINED: %s - %s" % (self.size, self.padding)))
def autofillsize(self):
""" autosize calculates absolute minimum sizes. """
""" autofillsize then pads those as needed (particularly for grid cells) """
if self.parent != None and self.fill != ui_filltype.none and self.postype != ui_postype.center:
self.size = self.parent.get_child_size(self)
if self.fill != ui_filltype.none and self.content == ui_frametype.grid:
print(("Hello I am grid %s, and my size is %s" % (self.gridsize, self.size)))
if self.stretchiness:
for ir, row in enumerate(self.data):
for ic, col in enumerate(row):
xlo = self.size[0] - sum(self.gridsize[0])
ylo = self.size[1] - sum(self.gridsize[1])
print(("Stretching cell %s from %s to %s" % ((ic, ir), self.size, (self.size[0]+xlo, self.size[1]+ylo))))
x = 0
y = 0
if xlo > 0:
xs = self.stretchiness[0][ic]
xst = sum(self.stretchiness[0])
x = int(float(xlo) * float(xs) / float(xst))
if ylo > 0:
ys = self.stretchiness[1][ir]
yst = sum(self.stretchiness[1])
y = int(float(ylo) * float(ys) / float(yst))
self.gridsize[0][ic] += x
self.gridsize[1][ir] += y
for child in self:
child.autofillsize()
def autoparent(self, parent=None):
if parent != None:
#print "Setting parent on %s to %s" % (self, parent)
self.parent = parent
for child in self:
child.autoparent(self)
def auto(self):
self.autoparent()
self.autosize()
self.autofillsize()
self.autopos()
def ancestors(self):
p = self.parent
while True:
if p == None:
raise StopIteration()
yield p
p = p.parent
def __iter__(self):
if self.content == ui_frametype.model:
return
if self.content == ui_frametype.grid:
for row in self.data:
for col in row:
yield col
elif self.content == ui_frametype.composite:
for child in self.data:
yield child
def __len__(self):
if self.content == ui_frametype.model:
return 0
if self.content == ui_frametype.grid:
if len(self.data) == 0:
return 0
return len(self.data) * len(self.data[0])
elif self.content == ui_frametype.composite:
return len(self.data)
def handle_keypress(self, ev):
return False
def handle_event(self, ev):
for child in self:
handled = child.handle_event(ev)
if handled:
return True
if self.relevant_event(ev):
if ev.type == MOUSEBUTTONDOWN:
self.set_focus()
if self.draggable:
self.drag_offset = (self.pos[0] - ev.pos[0], self.pos[1] - ev.pos[1])
for p in self.ancestors():
pass
p
mgr.drag_hook = p.move_drag
elif ev.type == MOUSEBUTTONUP:
if mgr.mousedown:
#print "Mouseclick detected... %s %s ------ %s %s" % (mgr.mousedown, mgr.mousedown.pos if mgr.mousedown else None, self.contains_pos(mgr.mousedown.pos), self.func)
if self.contains_pos(mgr.mousedown.pos):
""" welp, this is a valid click -- down was inside us, and so is up """
if self.func != None:
self.func(ev)
return True
elif ev.type == KEYUP:
if self.is_focus():
return self.handle_keypress(ev)
elif ev.type == VIDEORESIZE:
if self.parent == None:
self.autosize()
self.autopos()
return False
def convert_coords(self, pos, postype, newtype):
if postype == newtype:
return pos
ppos = self.get_parent_pos()
psize = self.get_parent_size()
anchorx = False
anchory = False
if postype == ui_postype.relative:
if pos[0] >= 0:
x = pos[0] + ppos[0]
else:
x = pos[0] + ppos[0] + psize[0] - self.size[0]
if pos[1] >= 0:
y = pos[1] + ppos[1]
else:
y = pos[1] + ppos[1] + psize[1] - self.size[1]
pos = (x, y)
elif postype == ui_postype.center:
pos = (ppos[0] + (psize[0]//2) - (self.size[0]//2), ppos[1] + (psize[1]//2) - (self.size[1]//2))
if newtype == ui_postype.center:
pos = (ppos[0] + (psize[0]//2) - (self.size[0]//2), ppos[1] + (psize[1]//2) - (self.size[1]//2))
elif newtype == ui_postype.relative:
if self.posset[0] >= 0:
x = pos[0] - ppos[0]
else:
x = pos[0] - ppos[0] - psize[0] + self.size[0]
if self.posset[1] >= 0:
y = pos[1] - ppos[1]
else:
y = pos[1] - ppos[1] - psize[1] + self.size[1]
elif newtype == ui_postype.absolute:
pass
return pos
def move_drag(self, ev):
newpos = (ev.pos[0] + self.drag_offset[0], ev.pos[1] + self.drag_offset[1])
rel_newpos = self.convert_coords(pos, ui_postype.absolute, self.postype)
self.posset = rel_newpos
self.autopos()
def contains_pos(self, pos):
if pos[0] >= self.pos[0] and pos[0] < (self.pos[0] + self.size[0]):
if pos[1] >= self.pos[1] and pos[1] < (self.pos[1] + self.size[1]):
return True
return False
def relevant_event(self, ev):
if ev.type == MOUSEMOTION:
return self.contains_pos(ev.pos)
elif ev.type == MOUSEBUTTONDOWN:
return self.contains_pos(ev.pos)
elif ev.type == MOUSEBUTTONUP:
return self.contains_pos(ev.pos)
elif ev.type == KEYDOWN:
return self.is_focus()
elif ev.type == KEYUP:
return self.is_focus()
else:
return True
def is_focus(self):
return mgr.focus == self
def set_focus(self):
mgr.set_focus(self)
def render(self):
for child in self:
child.render()
if self.content == ui_frametype.model:
if mgr.debug < 0:
mgr.debug += 1
if isinstance(self.data, models.TextModel):
print(("%s - %s - TEXT %s" % (self.pos, self.size, self.data.text)))
else:
for l in self.data.layers:
print(("%s - %s - %s" % (self.pos, self.size, l.material.id)))
glPushMatrix()
if isinstance(self.data, models.TextModel):
glTranslate(self.pos[0], self.pos[1], 10.0)
else:
glTranslate(float(self.pos[0]) + (float(self.size[0]) / 2.0), float(self.pos[1]) + (float(self.size[1]) / 2.0), 10.0)
newscale = [float(self.size[0]), float(self.size[1]), 1.0]
for layer in self.data.layers:
#if newscale != layer.scale:
# print "Changing scale on %s %s from %s to %s" % (layer.material.id, self.size, layer.scale, newscale)
layer.scale = newscale
#if "_bg_" in layer.material.id:
#layer.color = self.color
self.data.render()
glPopMatrix()
def make_box(sprite, center, color):
l = [['tl', 'tc', 'tr'], ['cl', 'cc', 'cr'], ['bl', 'bc', 'br']]
for i, r in enumerate(l):
for j, c in enumerate(r):
mdl = models.mgr.create("%s_%s" % (sprite, c))
l[i][j] = UIFrame(ui_frametype.model, mdl)
#if len(mdl.layers) > 1:
mdl.layers[-1].color = color
if c == 'cc':
l[i][j] = UIFrame(ui_frametype.composite, [l[i][j], center])
elif 'c' in c:
"""Border edges should be repeated to fill!"""
l[i][j].fill = ui_filltype.tile
#l[i] = tuple(l[i])
#l = tuple(l)
uf = UIFrame(ui_frametype.grid, l)
uf.stretchiness = [[0, 1, 0], [0, 1, 0]]
return uf
def make_button(text, clickfunc):
text = models.TextModel("micross20", text)
textframe = UIFrame(ui_frametype.model, text)
textframe.postype = ui_postype.center
btnframe = make_box("ui_button", textframe, (0.3, 0.3, 1.0, 1.0))
btnframe.func = clickfunc
return btnframe
def startgame(ev):
mgr.remove("mainmenu")
def clicktest(ev):
print("I'm an event!")
def exitgame(ev):
inputs.add_command('exit')
def make_mainmenu():
b1 = make_button("Start", startgame)
b2 = make_button("Options", clicktest)
b3 = make_button("Exit", exitgame)
b1.padding = (20,0)
b2.padding = (20,0)
b3.padding = (20,0)
buttongrid = UIFrame(ui_frametype.grid, [[b1], [b2], [b3]])
buttongrid.postype = ui_postype.center
buttongrid.fill = ui_filltype.stretch
buttongrid.stretchiness = [[1], [1, 1, 1]]
mgr.debugobj = b1
buttongrid = UIFrame(ui_frametype.composite, [buttongrid])
buttongrid.padding = (20, 30)
mainframe = make_box("ui_frame", buttongrid, (0.0, 0.0, 1.0, 0.35))
mainframe.postype = ui_postype.center
return mainframe
class UIManager(object):
def __init__(self):
self.frames = []
self.framenames = {}
self.focus = None
self.last_mousedown = None
self.mousemove_hook = None
self.debug = 0
def set_focus(self, frame):
self.focus = frame
def add(self, frame, name):
assert name not in self.framenames
self.framenames[name] = frame
frame.index = len(self.frames)
frame.auto()
print((frame.pos))
for child in frame:
print(("%s-%s" % (child.pos, child.size)))
"""
print "Ok"
print frame.data[1][1].data[1].gridsize
btngrid = frame.data[1][1].data[1]
btn3 = btngrid.data[2][0]
print "btn3"
print btn3.pos
print btngrid.get_child_pos(btn3)
"""
self.frames.append(frame)
def remove(self, frame):
fdel = self.framenames[frame]
for i, f in enumerate(self.frames):
if f is fdel:
del self.frames[i]
def render(self):
for frame in self.frames:
frame.render()
def handle_event(self, ev):
if ev.type == MOUSEMOTION and self.mousemove_hook != None:
self.drag_hook(ev)
return True
handled = False
for fr in self.frames:
handled = fr.handle_event(ev)
if handled:
break
if not handled:
self.set_focus(None)
if ev.type == MOUSEBUTTONDOWN:
print(("MOUSECLICK: %s" % (ev.pos,)))
self.mousedown = ev
if ev.type == MOUSEBUTTONUP:
self.drag_hook = None
self.mousedown = None
mgr = UIManager()