def setFullscreen():
"""Helper function to set the window fullscreen
with width and height set to the screens size"""
# set window properties
# clear all properties not previously set
base.win.clearRejectedProperties()
# setup new window properties
props = WindowProperties()
# Fullscreen
props.setFullscreen(True)
# set the window size to the screen resolution
props.setSize(self.dispWidth, self.dispHeight)
# request the new properties
base.win.requestProperties(props)
# Set the config variables so we correctly store the
# new size and fullscreen setting later
winSize = ConfigVariableString("win-size")
winSize.setValue("{} {}".format(self.dispWidth, self.dispHeight))
fullscreen = ConfigVariableBool("fullscreen")
fullscreen.setValue(True)
# Render a frame to make sure the fullscreen is applied
# before we do anything else
self.taskMgr.step()
# make sure to propagate the new aspect ratio properly so
# the GUI and other things will be scaled appropriately
aspectRatio = self.dispWidth / self.dispHeight
self.adjustWindowAspectRatio(aspectRatio)
def render(self):
user32 = ctypes.windll.user32
screensize = user32.GetSystemMetrics(0), user32.GetSystemMetrics(1)
resolution = ConfigVariableString('win-size')
val = '{0} {1}'.format(*screensize)
resolution.setValue(val)
app = ShowBase()
self.env.render(render, base)
taskMgr.doMethodLater(0.01, self.update, 'update')
app.run()
# ConfigVariableManager.getGlobalPtr().listVariables()
import sys
from panda3d.core import ConfigVariableString, ConfigVariableManager
my_game_server = ConfigVariableString('my-game-server', '127.0.0.1')
print('Server specified in config file: ', my_game_server.getValue())
# Allow the user to change servers on the command-line
if sys.argv[1] == '--server':
my_game_server.setValue(sys.argv[2])
# end if
print('Server that we will user: ', my_game_server.getValue())
print(ConfigVariableString("my-game-server"))
cvMgr = ConfigVariableManager.get_global_ptr()
cvMgr.list_variables()
class graphica :
elements = None #drawing elements
map_zoom = 1
map_pos = (0, 0)
width = 0
height = 0
title_update_time = 0.5
p3d = None #Panda Engine
flat = None #floor of the world
screen = None #screen surface
def __init__(self, params, pipe, dir):
self.game_directory = dir
self.game_pipe = pipe
self.gs_window = ConfigVariableString('win-size')
self.gs_window.setValue(str(params.get('width', 800)) +' '+str(params.get('height', 600)))
self.gs_multi = ConfigVariableBool('framebuffer-multisample')
self.gs_multi.setValue(params.get('multisample', 1))
self.gs_sync = ConfigVariableBool('sync-video', str(params.get('sync', 1)))
self.gs_sync.setValue(params.get('sync', 1))
loadPrcFileData('', 'win-size '+ str(params.get('width', 800)) +' '+str(params.get('height', 600)))
loadPrcFileData('', 'win-fixed-size 1')
loadPrcFileData('', 'text-default-font data/HanZi.ttf')
loadPrcFileData('', 'multisamples ' + str(params.get('samples', 0)))
#loadPrcFileData('', 'fullscreen 1')
#loadPrcFileData('', 'textures-power-2 pad')
#loadPrcFileData('', 'notify-level spam')
#loadPrcFileData('', 'default-directnotify-level spam')
#loadPrcFileData('', 'notify-output I:\\Users\\User\\My Documents\\Aptana Studio 3 Workspace\\sg\\out2.txt')
#nout = MultiplexStream()
#Notify.ptr().setOstreamPtr(nout, 0)
#nout.addFile(Filename("out.txt"))
'''for i in xrange(ConfigVariableManager.getGlobalPtr().getNumVariables()):
if ConfigVariableManager.getGlobalPtr().isVariableUsed(i) :
name = ConfigVariableManager.getGlobalPtr().getVariableName(i)
v = ConfigVariable(name)
'''
self.p3d = ShowBase.ShowBase()
self.p3d.buttonThrowers[0].node().setButtonDownEvent('buttonDown')
self.p3d.buttonThrowers[0].node().setButtonRepeatEvent('buttonRep')
self.p3d.buttonThrowers[0].node().setButtonUpEvent('buttonUp')
self.p3d.accept('buttonDown', self.keyboard, [0,])
self.p3d.accept('buttonRep', self.keyboard, [2,])
self.p3d.accept('buttonUp', self.keyboard, [1,])
self.p3d.disableMouse() #Disable default mouse-based camera control
self.screen = render2d.attachNewNode("Screen Coord Node")
self.screen.setBin("fixed", 100)
self.flat = render.attachNewNode("2d Objects in 3d world")
self.flat.setBin('background', 0)
self.flat.setDepthTest(False)
self.flat.setDepthWrite(False)
render.setAntialias(AntialiasAttrib.MAuto)
self.props = WindowProperties(self.p3d.win.getProperties())
#Screen size
self.width = params['width']
self.height = params['height']
self.aratio = float(self.width)/self.height #aspect ratio
self.p3d.camera.setZ(1000)
self.p3d.camera.lookAt(0,0,0)
self.p3d.camLens.setFov(80)
#self.props.setSize(size[0],size[1])
self.screen.setScale(2.0/self.width,1,2.0/self.height)
self.dt = 0.0
self.fps = 0
self.title_last_update_time = 0
self.plane = Plane(Vec3(0, 0, 1), Point3(0, 0, 0))
self.elements = {}
#self.MModel = self.create_model_xt((0,0,0), 'models\\chinesegfx_city_1_1.x', 'models\\houses_chinesegfx.tga', (3,3))[1]
#self.MModel.reparentTo(hidden)
#sys.stdout.flush()
#self.p3d.taskMgr.run()
#self.myShader = Shader.load(Shader.SLGLSL, "modules\\myvertexshader.glsl", "modules\\myfragmentshader.glsl")
#self.plane2.setShader(self.myShader)
self.mouse_pos = (0, 0)
self.mouse_on_map_pos = (0, 0)
self.p3d.accept('wheel_up',self.zoom_in)
self.p3d.accept('wheel_down',self.zoom_out)
self.p3d.accept('mouse1',self.mouse_click_left)
self.p3d.accept('mouse3',self.mouse_click_right)
self.parents = {}
self.gui_surface = aspect2d.attachNewNode("GUI Node")
self.gui_surface.setScale(2.0/self.height,1,2.0/self.height)
self.gui_surface.setBin("fixed", 50)
self.map_node = self.add_node('map_node', 'background', 0, self.flat)
self.paths_node = self.add_node('paths_node', 'background', 3, self.flat)
self.paths_all_node = self.add_node('paths_all_node', 'background', 3, self.flat)
self.map_mode_node = self.add_node('map_mode_node', 'background', 1, self.map_node)
self.selecties_node = self.add_node('selecties_node', 'background', 2, self.map_node)
self.parents['render'] = render
self.parents['gui_surface'] = self.gui_surface
self.elements['city_map_model'] = self.create_model_xt(fname = 'models\\chinesegfx_city_1_1.x', texname = 'models\\houses_chinesegfx.tga', size = (3, 3), name = 'city_map_model')
self.minimap = Minimap(self.width, self.height, self)
def add_node(self, name, mode1, mode2, parent = None):
node = None
if parent == None :
node = render.attachNewNode(name)
else :
node = parent.attachNewNode(name)
if (mode1 <> None) and (mode2 <> None ): node.setBin(mode1, mode2)
self.parents[name] = node
self.elements[name] = node
return node
def get_parent(self, p):
if p in self.parents :
return self.parents[p]
elif p in self.elements :
return self.elements[p]
else :
return render
def gr_loop(self):
self.mouse_control()
self.frame()
def Start(self):
print 'Starting graphic loop'
sys.stdout.flush()
while(1):
#считывает отправленные данные
start_time = globalClock.getRealTime()
try:
while self.game_pipe.poll(False) and ((globalClock.getRealTime() - start_time) < 0.5) :
m = self.game_pipe.recv()
try:
if m[0] == 'setitem' :
if m[1]['key'] == 'pos' : self.elements[m[1]['name']].setPos(m[1]['value'])
elif m[1]['key'] == 'image' :
self.elements[m[1]['name']]['image'] = textures.get(m[1]['value'], None)
elif m[1]['key'] == 'scale' : self.elements[m[1]['name']].setScale(m[1]['value'])
else : self.elements[m[1]['name']][m[1]['key']] = m[1]['value']
elif m[0] == 'set_map_pos' : self.set_map_pos(m[1][0], m[1][1])
elif m[0] == 'set_map_zoom' : self.set_map_zoom(m[1])
elif m[0] == 'draw_image2d' : self.draw_image2d(**m[1])
elif m[0] == 'draw_image' : self.draw_image(**m[1])
elif m[0] == 'draw_line' :
self.draw_line(**m[1])
#continue
elif m[0] == 'draw_line2d' :
self.draw_line2d(**m[1])
elif m[0] == 'draw_circle' : self.draw_circle(**m[1])
elif m[0] == 'draw_triangles' : self.draw_triangles(**m[1])
elif m[0] == 'delete_el_mask' : self.delete_el_mask(m[1])
elif m[0] == 'delete_el' : self.delete_el(m[1])
elif m[0] == 'gui_hide' :
self.elements[m[1]].hide()
elif m[0] == 'gui_show' :
self.elements[m[1]].show()
elif m[0] == 'gui_removeAndDestroyAllItems' :
self.elements[m[1]].removeAndDestroyAllItems()
elif m[0] == 'reparentTo' :
self.elements[m[1]].reparentTo( self.elements[m[2]] )
elif m[0] == 'setTexture' :
self.elements[m[1]].setTexture(textures[m[2]])
elif m[0] == 'setPos' :
self.elements[m[1]].setPos(m[2][0], m[2][1], m[2][2])
elif m[0] == 'setHpr' :
self.elements[m[1]].setHpr(m[2][0], m[2][1], m[2][2])
elif m[0] == 'instanceTo' :
self.elements[m[2]] = render.attachNewNode('Placeholder')
self.elements[m[1]].instanceTo(self.elements[m[2]])
elif m[0] == 'resetFrameSize' :
self.elements[m[1]].resetFrameSize()
elif m[0] == 'setTransparency' :
self.elements[m[1]].setTransparency(TransparencyAttrib.MAlpha)
elif m[0] == 'RemoveGuiElement' :
try:
self.elements[m[1]].destroy()
except:
self.elements[m[1]].removeNode()
elif m[0] == 'removeNode' :
self.elements[m[1]].removeNode()
elif m[0] == 'removeAllChildren' :
self.elements[m[1]].node().removeAllChildren()
elif m[0] == 'gui_addItem' :
self.elements[m[1]].addItem(self.elements[m[2]])
elif m[0] == 'DirectLabel' :
params = dict(m[1])
params['parent'] = self.get_parent(params.get('parent', 'render') )
self.elements[m[2]['name']] = DirectLabel(**params)
elif m[0] == 'DirectButton' :
params = dict(m[1])
params['parent'] = self.get_parent(params.get('parent', 'render') )
params['command'] = self.GUI_pressed
params['extraArgs'] = (m[2]['name'],)
self.elements[m[2]['name']] = DirectButton(**params)
elif m[0] == 'DirectFrame' :
params = dict(m[1])
params['parent'] = self.get_parent( params.get('parent', 'render') )
self.elements[m[2]['name']] = DirectFrame(**params)
elif m[0] == 'DirectScrolledList' :
params = dict(m[1])
params['parent'] = self.get_parent( params.get('parent', 'render') )
self.elements[m[2]['name']] = DirectScrolledList(**params)
elif m[0] == 'DirectCheckButton' :
params = dict(m[1])
params['parent'] = self.get_parent( params.get('parent', 'render') )
self.elements[m[2]['name']] = DirectCheckButton(**params)
elif m[0] == 'DirectWaitBar' :
params = dict(m[1])
params['parent'] = self.get_parent( params.get('parent', 'render') )
self.elements[m[2]['name']] = DirectWaitBar(**params)
elif m[0] == 'create_actor_egg' :
self.create_actor_egg(**m[1])
elif m[0] == 'anim_loop' :
if len(m) == 3 :
m = list(m)
m.append({})
self.elements[m[1]].loop(m[2], **m[3])
elif m[0] == 'image_data_new' :
t = PNMImage()
#print 'RECV', m[2]
sys.stdout.flush()
if t.read(StringStream(m[2])) :
pass
else :
raise ValueError()
sys.stdout.flush()
tex = Texture()
tex.load(t)
textures[m[1]] = tex
elif m[0] == 'create_minimap' :
im = PNMImage()
self.elements['phyz'].getTexture().store(im)
self.minimap.create_minimap(im, m[1], m[2])
self.draw_image2d(pos = (self.width/2 - 200, -self.height/2), texname = 'minimap_tex', name = 'minimap_image', parent = 'gui_surface' )
else :
print 'Unknown command:', m
sys.stdout.flush()
#print m
#sys.stdout.flush()
except:
print m
print 'error1', sys.exc_info()
sys.stdout.flush()
except:
print 'error2', sys.exc_info()
sys.stdout.flush()
try:
self.gr_loop()
except Exception:
print 'error3', sys.exc_info()
sys.stdout.flush()
try:
pass
#if not(self.game_queue.full()):
# self.game_queue.put(('mouse_pos', self.mouse_pos))
# self.game_queue.put(('mouse_on_map_pos', self.mouse_on_map_pos))
#else :
# print 'game full'
# sys.stdout.flush()
except:
print 'error4', sys.exc_info()
sys.stdout.flush()
sys.stdout.flush()
#time.sleep(0.01)
def GUI_pressed(self, name):
self.game_pipe.send(('gui_pressed',name))
def mouse_control(self):
if self.p3d.mouseWatcherNode.hasMouse():
mp = (self.p3d.mouseWatcherNode.getMouse()[0], 0, self.p3d.mouseWatcherNode.getMouse()[1])
self.mouse_pos[0] = self.screen.getRelativePoint(render2d, mp)[0]
self.mouse_pos[1] = self.screen.getRelativePoint(render2d, mp)[2]
self.ttt = globalClock.getRealTime()
mpos = self.p3d.mouseWatcherNode.getMouse()
tmp = self.scr_to_map(mpos)
self.mouse_on_map_pos[0] = tmp[0]
self.mouse_on_map_pos[1] = tmp[1]
X_ = self.p3d.camera.getX()
Y_ = self.p3d.camera.getY()
C = 0.5*self.dt
if self.mouse_pos[0] < self.width * -0.47 :
X_ -= self.p3d.camera.getZ()*C
self.minimap.update_pos()
if self.mouse_pos[0] > self.width * 0.47 :
X_ += self.p3d.camera.getZ()*C
self.minimap.update_pos()
if self.mouse_pos[1] < self.height * -0.47 :
Y_ -= self.p3d.camera.getZ()*C
self.minimap.update_pos()
if self.mouse_pos[1] > self.height * 0.47 :
Y_ += self.p3d.camera.getZ()*C
self.minimap.update_pos()
self.p3d.camera.setX( X_ )
self.p3d.camera.setY( Y_ )
def mouse_click_left(self):
self.game_pipe.send(('mouse_click_left',))
def mouse_click_right(self):
self.game_pipe.send(('mouse_click_right',))
def frame(self):
self.p3d.taskMgr.step()
self.dt = globalClock.getDt()
if globalClock.getRealTime() - self.title_last_update_time > self.title_update_time :
self.props = WindowProperties(self.p3d.win.getProperties())
self.title_last_update_time = globalClock.getRealTime()
self.fps = globalClock.getAverageFrameRate()
title = str(self.fps) + str(self.mouse_pos[:]) + str(self.mouse_on_map_pos[:])
self.props.setTitle(title)
self.p3d.win.requestProperties(self.props)
def draw_line(self, **kwargs):
ps = kwargs.get('points',[])
name = ''
if 'name' in kwargs.keys() :
name = kwargs['name']
if self.check_name(name) :
#print 'draw_line name duplicated', name
return None
else :
name = self.generate_name()
ls = LineSegs()
if 'width' in kwargs.keys() : ls.setThickness( kwargs['width'] )
if 'color' in kwargs.keys() : ls.setColor( (kwargs['color'][0], kwargs['color'][1], kwargs['color'][2], kwargs['color'][3]) )
for i in ps :
ls.drawTo(i[0], i[1], i[2])
node = ls.create()
np = NodePath(node)
if 'parent' in kwargs.keys() and kwargs['parent'] <> None :
self.get_parent(kwargs['parent']).attachNewNode(np.node())
else :
render.attachNewNode(np.node())
self.elements[ name ] = np
return name, np
def draw_line2d(self, **kwargs):
ps = None
if 'points' in kwargs.keys():
ps = kwargs['points']
else :
return None
name = ''
if 'name' in kwargs.keys() :
name = kwargs['name']
if self.check_name(name) :
#print 'draw_line name duplicated', name
return None
else :
name = self.generate_name()
ls = LineSegs()
if 'width' in kwargs.keys() : ls.setThickness( kwargs['width'] )
if 'color' in kwargs.keys() : ls.setColor( Vec4(kwargs['color'][0], kwargs['color'][1], kwargs['color'][2], kwargs['color'][3]) )
for i in ps :
ls.drawTo(i[0], 0, i[1])
node = ls.create()
np = NodePath(node)
if 'parent' in kwargs.keys() and kwargs['parent'] <> None :
self.get_parent(kwargs['parent']).attachNewNode(np.node())
else :
self.screen.attachNewNode(np.node())
self.elements[ name ] = np
return name, np
def draw_circle(self, **kw):#x, color, r, width, name, prec = 10, parent = None, hpr = None):
x = kw.get('pos',(0,0,0))
color = kw.get('color',(0,0,0,255))
r = kw.get('radius',5)
width = kw.get('width',1)
prec = kw.get('prec', 10)
parent = self.get_parent(kw.get('parent', None))
hpr = kw.get('hpr', None)
name = kw.get('name', self.generate_name())
if self.check_name(name) :
#print 'draw_circle name duplicated', name
return None
ls = LineSegs()
ls.setThickness( width )
ls.setColor( Vec4(float(color[0])/256,float(color[1])/256,float(color[2])/256,float(color[3])/256) )
for i in xrange(prec) :
angle = math.pi*i*2/prec
ls.drawTo(x[0] + math.sin(angle) * r, x[1] + math.cos(angle) * r,0)
ls.drawTo(x[0] + math.sin(math.pi*i*2/1) * r, x[1] + math.cos(math.pi*i*2/1) * r, 0)
node = ls.create()
np = NodePath(node)
if color[3] <> 255 : np.setTransparency(TransparencyAttrib.MAlpha)
if hpr <> None : np.setHpr(hpr[0],hpr[1],hpr[2])
if parent == None :
self.flat.attachNewNode(np.node())
else :
parent.attachNewNode(np.node())
self.elements[name] = np
def draw_circle2d(self, x, color, r, width, name, prec = 10, parent = None):
ls = LineSegs()
ls.setThickness( width )
ls.setColor( Vec4(float(color[0])/256,float(color[1])/256,float(color[2])/256,float(color[3])/256) )
for i in xrange(prec) :
angle = math.pi*i*2/prec
ls.drawTo(x[0] + math.sin(angle) * r, 0, x[1] + math.cos(angle) * r)
ls.drawTo(x[0] + math.sin(math.pi*i*2/1) * r, 0, x[1] + math.cos(math.pi*i*2/1) * r)
node = ls.create()
np = NodePath(node)
if parent == None :
self.screen.attachNewNode(np.node())
else :
parent.attachNewNode(np.node())
self.elements[name] = np
def draw_text(self,msg,x,rgba,size,font = 'HanZi.ttf', surface = None):
pass
def draw_image(self,pos = (0,0,0), fname = '', name = None, scale = (1,1), size = None, parent = None, image = None, **kw):
if name == None :
name = self.generate_name()
tex = Texture()
texname = kw.get('texname', None)
if texname <> None :
if texname in textures.keys() :
tex.load(textures[texname])
else :
tex = loader.loadTexture(texname)
else : return None, None
xframe = tex.getXSize()
if tex.getOrigFileXSize() <> 0 : xframe = tex.getOrigFileXSize()
yframe = tex.getYSize()
if tex.getOrigFileYSize() <> 0 : yframe = tex.getOrigFileYSize()
if size <> None :
scale = (float(scale[0]) * size[0]/tex.getOrigFileXSize(), float(scale[1]) * size[1]/tex.getOrigFileYSize() )
cm = CardMaker('card')
cm.setFrame(0,xframe*scale[0],0,yframe*scale[1])
card = None
if parent == None :
card = render.attachNewNode(cm.generate())
else :
card = self.get_parent(parent).attachNewNode(cm.generate())
card.setTexture(tex)
card.setPos(pos[0],pos[1],pos[2])
card.setHpr(0,-90,0)
self.elements[name] = card
return name, card
def draw_polygon(self,ps,color,name):
color = ( float(color[0])/255, float(color[1])/255, float(color[2])/255, float(color[3])/255)
vdata = GeomVertexData('trig', GeomVertexFormat.getV3(), Geom.UHStatic)
vwriter = GeomVertexWriter(vdata, 'vertex')
#cwriter = GeomVertexWriter(vdata, 'color')
trig = Triangulator()
for i in ps :
vi = trig.addVertex(i[0], i[1])
vwriter.addData3f(i[0], i[2], i[1])
#cwriter.addData4f(color[0], color[1], color[2], color[3])
trig.addPolygonVertex(vi)
trig.triangulate()
prim = GeomTriangles(Geom.UHStatic)
for i in range(trig.getNumTriangles()):
prim.addVertices(trig.getTriangleV0(i),
trig.getTriangleV1(i),
trig.getTriangleV2(i))
prim.closePrimitive()
geom = Geom(vdata)
geom.addPrimitive(prim)
geomNode = GeomNode('trig')
geomNode.addGeom(geom)
np = NodePath(geomNode)
np.reparentTo(render)
#fill=self.screen.attachNewNode(geomNode)
#fill.analyze()
self.elements[name] = np
def draw_tristrips(self, ps, color, name, parent = None):
vdata = GeomVertexData('trig', GeomVertexFormat.getV3(), Geom.UHStatic)
vwriter = GeomVertexWriter(vdata, 'vertex')
for i in ps :
vwriter.addData3f(i[0], i[1], i[0])
prim = GeomTristrips(Geom.UHStatic)
for i in range(len(ps)) :
prim.addVertex(i)
prim.closePrimitive()
geom = Geom(vdata)
geom.addPrimitive(prim)
geomNode = GeomNode('trig')
geomNode.addGeom(geom)
np = NodePath(geomNode)
if parent == None :
render.attachNewNode(np.node())
else :
parent.attachNewNode(np.node())
#fill=self.screen.attachNewNode(geomNode)
#fill.analyze()
self.elements[name] = np
def draw_triangles(self, points = None, color = None, name = None, parent = None):
vdata = GeomVertexData('trig', GeomVertexFormat.getV3c4(), Geom.UHStatic)
vwriter = GeomVertexWriter(vdata, 'vertex')
cwriter = GeomVertexWriter(vdata, 'color')
for i in points :
vwriter.addData3f(i[0], i[1], i[2])
cwriter.addData4f(color[0], color[1], color[2], color[3])
geom = Geom(vdata)
prim = GeomTriangles(Geom.UHStatic)
for i in range(len(points)) :
prim.addVertex(i)
prim.closePrimitive()
geom.addPrimitive(prim)
geomNode = GeomNode('trig')
geomNode.addGeom(geom)
np = NodePath(geomNode)
if parent == None :
render.attachNewNode(np.node())
else :
self.get_parent(parent).attachNewNode(np.node())
np.setTransparency(TransparencyAttrib.MAlpha)
#fill=self.screen.attachNewNode(geomNode)
#fill.analyze()
self.elements[name] = np
return np
def draw_trianglefan(self, ps, color, name, parent = None):
vdata = GeomVertexData('trig', GeomVertexFormat.getV3(), Geom.UHStatic)
vwriter = GeomVertexWriter(vdata, 'vertex')
for i in ps :
vwriter.addData3f(i[0], i[1], i[2])
prim = GeomTrifans(Geom.UHStatic)
for i in range(len(ps)) :
prim.addVertex(i)
prim.closePrimitive()
geom = Geom(vdata)
geom.addPrimitive(prim)
geomNode = GeomNode('trig')
geomNode.addGeom(geom)
np = NodePath(geomNode)
if parent == None :
render.attachNewNode(np.node())
else :
parent.attachNewNode(np.node())
#fill=self.screen.attachNewNode(geomNode)
#fill.analyze()
self.elements[name] = np
def draw_polygon2d(self,ps,color,name):
vdata = GeomVertexData('trig', GeomVertexFormat.getV3(), Geom.UHStatic)
vwriter = GeomVertexWriter(vdata, 'vertex')
trig = Triangulator()
for i in ps :
vi = trig.addVertex(i[0], i[1])
vwriter.addData3f(i[0], 0, i[1])
trig.addPolygonVertex(vi)
trig.triangulate()
prim = GeomTriangles(Geom.UHStatic)
for i in range(trig.getNumTriangles()):
prim.addVertices(trig.getTriangleV0(i),
trig.getTriangleV1(i),
trig.getTriangleV2(i))
prim.closePrimitive()
geom = Geom(vdata)
geom.addPrimitive(prim)
geomNode = GeomNode('trig')
geomNode.addGeom(geom)
np = NodePath(geomNode)
np.reparentTo(self.screen)
#fill=self.screen.attachNewNode(geomNode)
#fill.analyze()
self.elements[name] = np
def draw_image2d(self, **kw):
'''
tex = loader.loadTexture(texname)
vdata = GeomVertexData('trig', GeomVertexFormat.getV3t2(), Geom.UHStatic)
vwriter = GeomVertexWriter(vdata, 'vertex')
twriter = GeomVertexWriter(vdata, 'texcoord')
vwriter.addData3f(i[0], 0, i[1])
vwriter.addData3f(i[0], 0, i[1])
twriter.addData2f(0, 0)
twriter.addData2f(0, 1)
twriter.addData2f(1, 1)
twriter.addData2f(1, 0)
geom = Geom(vdata)
tris = GeomTristrips(Geom.UHStatic)
tris.addVertex(0)
tris.addVertex(1)
tris.addVertex(3)
tris.addVertex(2)
tris.closePrimitive()
geom.addPrimitive(tris)
node = GeomNode(name)
node.addGeom(geom)
np = self.screen.attachNewNode(node)
np.setTexture(tex)
np.getTexture().setMinfilter(Texture.FTLinearMipmapLinear)
self.elements[name] = node
'''
pos = kw.get('pos', (0, 0))
size = kw.get('size', None)
texname = kw.get('texname', None)
scaleX = kw.get('scaleX', 1)
scaleY = kw.get('scaleY', 1)
parent = self.get_parent( kw.get('parent', 'gui_surface') )
name = kw.get('name', self.generate_name())
tex = Texture()
if texname <> None :
if texname in textures.keys() :
tex = textures[texname]
else :
tex = loader.loadTexture(texname)
cm = CardMaker('card')
xframe = tex.getXSize()
if tex.getOrigFileXSize() <> 0 : xframe = tex.getOrigFileXSize()
yframe = tex.getYSize()
if tex.getOrigFileYSize() <> 0 : yframe = tex.getOrigFileYSize()
if size == None :
size = (tex.getXSize(), tex.getYSize())
cm.setFrame(0,size[0]*scaleX,0,size[1]*scaleY)
card = None
if parent == None :
card = self.screen.attachNewNode(cm.generate())
else :
card = parent.attachNewNode(cm.generate())
if texname <> None :
card.setTexture(tex)
card.setDepthTest(False)
card.setPos(pos[0],0,pos[1])
#card.setHpr(0,-90,0)
self.elements[name] = card
return card
def create_image2d(self, **kwargs):
pos = kwargs.get('pos', (0, 0))
size = kwargs.get('size', None)
texname = kwargs.get('texname', None)
UVmap = kwargs.get('UVmap', 0)
name = kwargs.get('name', self.generate_name())
rotate = 0
for i in kwargs.keys() :
if i == 'rotate' : rotate = kwargs['rotate']
cm = CardMaker('card')
tex = None
if texname <> None :
tex = loader.loadTexture(texname)
if size == None and texname <> None :
size = (tex.getOrigFileXSize(), tex.getOrigFileYSize())
cm.setFrame(-float(size[0])/2,float(size[0])/2,-float(size[1])/2,float(size[1])/2)
if tex <> None and UVmap :
fU, fV = 1, 1
if UVmap == 3 or UVmap == 1: fU = float(size[0])/tex.getOrigFileXSize()
if UVmap == 3 or UVmap == 2: fV = float(size[1])/tex.getOrigFileYSize()
cm.setUvRange((0, 0),(fU, fV))
card = NodePath(cm.generate())
if texname <> None :
card.setTexture(tex)
card.setDepthTest(False)
card.setPos(pos[0]+float(size[0])/2,0,pos[1]+float(size[1])/2)
card.setHpr(0,0,rotate)
card.setTransparency(TransparencyAttrib.MAlpha)
return card
def create_model_xt(self, **kw):#pos, model, texture, size, name = None):
pos = kw.get('pos', (0, 0, 0))
model = kw.get('fname', None)
texture = kw.get('texname', None)
size = kw.get('size', (1, 1))
name = kw.get('name', self.generate_name())
if self.check_name(name) :
#print 'create_model_xt name duplicated', name
return None
model = self.game_directory + Filename.fromOsSpecific('\\' + model).getFullpath()
a = loader.loadModel(model)
texture = self.game_directory + Filename.fromOsSpecific('\\' + texture).getFullpath()
a.setTexture(loader.loadTexture(texture))
a.reparentTo(render)
cmin, cmax = a.getTightBounds()
smax = 0
sx = size[0]/(cmax[0] - cmin[0])
sy = size[1]/(cmax[1] - cmin[1])
if sx > sy : smax = sx
else : smax = sy
a.setScale(smax)
shiftx = ( (cmax[0] + cmin[0])/2 ) * smax
shifty = ( (cmax[1] + cmin[1])/2 ) * smax
a.setPos(pos[0] - shiftx,pos[1] - shifty,pos[2])
#m.flattenLight()
#a.analyze()
if name == None : name = self.generate_name()
self.elements[name] = a
return a
def create_model_egg(self, pos, model, texture, size, name = None):
model = self.game_directory + Filename.fromOsSpecific('\\' + model).getFullpath()
a = loader.loadModel(model)
a.reparentTo(render)
cmin, cmax = a.getTightBounds()
smax = 0
sx = size[0]/(cmax[0] - cmin[0])
sy = size[1]/(cmax[1] - cmin[1])
if sx > sy : smax = sx
else : smax = sy
a.setScale(smax)
shiftx = ( (cmax[0] + cmin[0])/2 ) * smax
shifty = ( (cmax[1] + cmin[1])/2 ) * smax
a.setPos(pos[0] - shiftx,pos[1] - shifty,pos[2])
#m.flattenLight()
#a.analyze()
if name == None : name = self.generate_name()
self.elements[name] = a
print '!!!'
return name
def create_actor_egg(self, **kw):
model = self.game_directory + Filename.fromOsSpecific('\\' + kw['model']).getFullpath()
m = loader.loadModel(model)
a = Actor(m, kw['anims'])
a.reparentTo(render)
cmin, cmax = a.getTightBounds()
smax = 0
size = kw['size']
sx = size[0]/(cmax[0] - cmin[0])
sy = size[1]/(cmax[1] - cmin[1])
if sx > sy : smax = sx
else : smax = sy
a.setScale(smax)
shiftx = ( (cmax[0] + cmin[0])/2 ) * smax
shifty = ( (cmax[1] + cmin[1])/2 ) * smax
pos = kw['pos']
a.setPos(pos[0] - shiftx,pos[1] - shifty,pos[2])
#m.flattenLight()
#a.analyze()
name = kw.get('name', None)
if name == None : name = self.generate_name()
self.elements[name] = a
return name
def map_to_scr(self, a):
#print 'mts', self.map_pos, a, [ (a[0] - self.map_pos[0])*self.map_zoom, (a[1] - self.map_pos[1])*self.map_zoom ], self.width, self.height
return [ (a[0] - self.map_pos[0])*self.map_zoom, (a[1] - self.map_pos[1])*self.map_zoom ]
def scr_to_map(self, a):
#a is (-1,-1) to (1,1)
pos3d = Point3()
nearPoint = Point3()
farPoint = Point3()
self.p3d.camLens.extrude(a, nearPoint, farPoint)
self.plane.intersectsLine(pos3d,
render.getRelativePoint(self.p3d.camera, nearPoint),
render.getRelativePoint(self.p3d.camera, farPoint))
return pos3d[0],pos3d[1]
def set_map_pos(self, posx, posy):
self.p3d.camera.setX(posx)
self.p3d.camera.setY(posy)
#self.gr.p3d.camera.lookAt(250,0,550)
self.map_pos = (posx, posy)
def set_map_zoom(self, zoom):
self.p3d.camera.setZ( zoom )
def zoom_in(self):
self.p3d.camera.setZ( self.p3d.camera.getZ()*0.9 )
self.minimap.update_pos(True)
if self.p3d.camera.getZ() < 200 :
self.paths_all_node.show()
def zoom_out(self):
self.p3d.camera.setZ( self.p3d.camera.getZ()*1.1 )
self.minimap.update_pos(True)
if self.p3d.camera.getZ() > 200 :
self.paths_all_node.hide()
def generate_name(self):
name = str(RANDINT(0,9))
while name in self.elements.keys() :
name += str(RANDINT(0,9))
return name
def delete_el(self, name):
if name in self.elements.keys() :
self.elements[name].removeNode()
self.elements.pop(name)
def delete_el_mask(self,mask):
for i in self.elements.keys() :
if mask in i :
self.delete_el(i)
def get_num_nodes_rec(self, a):
x = 0
l = len(a.getChildren())
if l == 0 :
return 1
else :
for c in a.getChildren() :
x += self.get_num_nodes_rec(c)
return x
def get_num_nodes(self):
a = self.get_num_nodes_rec(render)
b = self.get_num_nodes_rec(render2d)
c = self.get_num_nodes_rec(aspect2d)
print 'render', a, 'render2d', b, 'aspect2d', c
def check_name(self, name):
if name in self.elements.keys() : return True
else : return False
def keyboard(self, st, keyname):
if st == 0 : self.game_pipe.send(('key_down', keyname))
elif st == 1 : self.game_pipe.send(('key_up', keyname))
elif st == 2 : self.game_pipe.send(('key_rep', keyname))
