ya2/p3d/gfx.py

   1 import datetime
   2 from logging import info
   3 from os import getcwd
   4 from panda3d.core import AntialiasAttrib, PandaNode, LightRampAttrib, \
   5     NodePath, Point2, Point3, Texture, load_prc_file_data
   6 # from ya2.lib.p3d.p3d import LibP3d
   7
   8
   9 def set_srgb(model):
  10     for texture in model.find_all_textures():
  11         if texture.get_format() in [Texture.F_rgba, Texture.F_rgbm]:
  12             texture.set_format(Texture.F_srgb_alpha)
  13         elif texture.get_format() in [Texture.F_rgb]:
  14             texture.set_format(Texture.F_srgb)
  15
  16
  17 # class RenderToTexture:
  18
  19 #     def __init__(self, size=(256, 256)):
  20 #         self.__set_buffer(size)
  21 #         self.__set_display_region()
  22 #         self.__set_camera()
  23 #         self.__set_root()
  24 #         self.display_region.set_camera(self.camera)
  25
  26 #     def __set_buffer(self, size):
  27 #         self.buffer = base.win.make_texture_buffer('result buffer', size[0],
  28 #                                                    size[1])
  29 #         self.buffer.set_sort(-100)
  30
  31 #     def __set_display_region(self):
  32 #         self.display_region = self.buffer.make_display_region()
  33 #         self.display_region.set_sort(20)
  34
  35 #     def __set_camera(self):
  36 #         self.camera = NodePath(Camera('camera 2d'))
  37 #         lens = OrthographicLens()
  38 #         lens.set_film_size(1, 1)
  39 #         lens.set_near_far(-1000, 1000)
  40 #         self.camera.node().set_lens(lens)
  41
  42 #     def __set_root(self):
  43 #         self.root = NodePath('root')
  44 #         self.root.set_depth_test(False)
  45 #         self.root.set_depth_write(False)
  46 #         self.camera.reparent_to(self.root)
  47
  48 #     @property
  49 #     def texture(self): return self.buffer.get_texture()
  50
  51 #     def destroy(self):
  52 #         base.graphicsEngine.remove_window(self.buffer)
  53 #         if base.win:  # if you close the window during a race
  54 #             base.win.remove_display_region(self.display_region)
  55 #         list(map(lambda node: node.remove_node(), [self.camera, self.root]))
  56
  57
  58 class P3dGfxMgr:
  59
  60     # def __init__(self, model_path, antialiasing, shaders, srgb):
  61     #     self.root = P3dNode(render)
  62     #     self.__srgb = srgb
  63     #     self.callbacks = {}
  64     #     self.filters = None
  65     #     get_model_path().append_directory(model_path)
  66     #     if LibP3d.runtime():
  67     #         root_dir = LibP3d.p3dpath(dirname(__file__))
  68     #         paths = [root_dir + '/' + model_path, root_dir]
  69     #         list(map(get_model_path().append_directory, paths))
  70     #     render.set_shader_auto()
  71     #     # render.set_two_sided(True)  # it breaks shadows
  72     #     if antialiasing: render.set_antialias(AntialiasAttrib.MAuto)
  73     #     if shaders and base.win:
  74     #         self.filters = CommonFilters(base.win, base.cam)
  75
  76     # def load_model(self, filename, callback=None, anim=None):
  77     #     ext = '.bam' if exists(filename + '.bam') else ''
  78     #     if anim:
  79     #         anim_dct = {'anim': filename + '-Anim' + ext}
  80     #         node = P3dNode(self.set_srgb(Actor(filename + ext, anim_dct)))
  81     #     elif callback:
  82     #         callb = lambda model: callback(P3dNode(self.set_srgb(model)))
  83     #         node = loader.loadModel(filename + ext, callback=callb)
  84     #     else:
  85     #         node = P3dNode(self.set_srgb(
  86     #             loader.loadModel(LibP3d.p3dpath(filename + ext))))
  87     #     return node
  88
  89     def set_srgb(self, model):
  90         if self.__srgb:
  91             for texture in model.find_all_textures():
  92                 if texture.get_format() in [Texture.F_rgba, Texture.F_rgbm]:
  93                     texture.set_format(Texture.F_srgb_alpha)
  94                 elif texture.get_format() in [Texture.F_rgb]:
  95                     texture.set_format(Texture.F_srgb)
  96         return model
  97
  98     @staticmethod
  99     def no_window():
 100         load_prc_file_data('', 'window-type none')
 101
 102     @staticmethod
 103     def toggle_aa():
 104         aa_not_none = render.get_antialias() != AntialiasAttrib.MNone
 105         if render.has_antialias() and aa_not_none:
 106             render.clear_antialias()
 107         else:
 108             render.set_antialias(AntialiasAttrib.MAuto, 1)
 109
 110     def set_toon(self):
 111         tmp_node = NodePath(PandaNode('temp node'))
 112         tmp_node.set_attrib(LightRampAttrib.make_single_threshold(.5, .4))
 113         tmp_node.set_shader_auto()
 114         base.cam.node().set_initial_state(tmp_node.get_state())
 115         self.filters.set_cartoon_ink(separation=1)
 116
 117     def set_bloom(self):
 118         if not base.win:
 119             return
 120         self.filters.setBloom(
 121             blend=(.3, .4, .3, 0), mintrigger=.6, maxtrigger=1.0, desat=.6,
 122             intensity=1.0, size='medium')
 123         # default: (.3, .4, .3, 0), .6, 1, .6, 1, 'medium'
 124
 125     @staticmethod
 126     def pos2d(node):
 127         p3d = base.cam.get_relative_point(node, Point3(0, 0, 0))
 128         p2d = Point2()
 129         return p2d if base.camLens.project(p3d, p2d) else None
 130
 131     @staticmethod
 132     def pos2d_p2d(node):
 133         p3d = base.cam.get_relative_point(node, Point3(0, 0, 0))
 134         p2d = Point2()
 135         ret = p2d if base.camLens.project(p3d, p2d) else None
 136         if ret:
 137             n = NodePath('tmp')
 138             rpos = (ret[0], 0, ret[1])
 139             n.set_pos(rpos)
 140             pos = n.get_pos(pixel2d)
 141             return int(round(pos[0])), int(round(-pos[2]))
 142
 143     @staticmethod
 144     def screen_coord(pos):
 145         new_node = NodePath('temp')
 146         new_node.set_pos(pos)
 147         coord3d = new_node.get_pos(base.cam)
 148         new_node.remove_node()
 149         coord2d = Point2()
 150         base.camLens.project(coord3d, coord2d)
 151         coord_r2d = Point3(coord2d[0], 0, coord2d[1])
 152         coord_a2d = base.aspect2d.get_relative_point(
 153             render2d, coord_r2d)
 154         return coord_a2d[0], coord_a2d[2]
 155
 156     @staticmethod
 157     def world_from_to(pos):
 158         p_from, p_to = Point3(), Point3()    # in camera coordinates
 159         base.camLens.extrude(pos, p_from, p_to)
 160         p_from = render.get_relative_point(
 161             base.cam, p_from)  # global coords
 162         p_to = render.get_relative_point(
 163             base.cam, p_to)  # global coords
 164         return p_from, p_to
 165
 166     @property
 167     def shader_support(self):
 168         return base.win.get_gsg().get_supports_basic_shaders()
 169
 170     def screenshot(self, path=None):
 171         time = datetime.datetime.now().strftime('%y%m%d%H%M%S')
 172         # res = base.win.save_screenshot(
 173         #     Filename(path or ("yocto%s.png" % time)))
 174         # debug('screenshot %s (%s)' % (path or ("yocto%s.png" % time), res))
 175         res = base.screenshot(
 176             path or ("pmachines%s.png" % time), False)
 177         info('screenshot %s (%s; %s)' % (path or ("pmachines%s.png" % time),
 178                                          res, getcwd()))
 179
 180     @staticmethod
 181     def enable_shader():
 182         render.set_shader_auto()
 183
 184     @staticmethod
 185     def disable_shader():
 186         render.set_shader_off()
 187
 188     @staticmethod
 189     def print_stats(two_d=True, three_d=True, analyze=True, ls=True):
 190         '''Print graphics stats. They use standard output (from p3d).'''
 191         info = []
 192         if two_d and analyze:
 193             info += [('render2d.analyze', base.render2d.analyze)]
 194         if three_d and analyze:
 195             info += [('render.analyze', base.render.analyze)]
 196         if two_d and ls:
 197             info += [('render2d.ls', base.render2d.ls)]
 198         if three_d and ls:
 199             info += [('render.ls', base.render.ls)]
 200         for elm in info:
 201             print('\n\n#####\n%s()' % elm[0])
 202             elm[1]()
 203
 204
 205 # class P3dNode:
 206
 207 #     def __init__(self, nodepath):
 208 #         self.nodepath = nodepath
 209 #         self.node.set_python_tag('libnode', self)
 210
 211 #     def set_collide_mask(self, mask): return self.node.set_collide_mask(mask)
 212 #     def set_x(self, val): return self.node.set_x(val)
 213 #     def set_y(self, val): return self.node.set_y(val)
 214 #     def set_z(self, val): return self.node.set_z(val)
 215 #     def set_hpr(self, val): return self.node.set_hpr(val)
 216 #     def set_h(self, val): return self.node.set_h(val)
 217 #     def set_p(self, val): return self.node.set_p(val)
 218 #     def set_r(self, val): return self.node.set_r(val)
 219 #     def set_scale(self, val): return self.node.set_scale(val)
 220 #     def set_transparency(self, val): return self.node.set_transparency(val)
 221 #     def set_alpha_scale(self, val): return self.node.set_alpha_scale(val)
 222 #     def set_texture(self, texturestage, texture):
 223 #         return self.node.set_texture(texturestage, texture)
 224 #     def has_tag(self, name): return self.node.has_tag(name)
 225 #     def get_tag(self, name): return self.node.get_tag(name)
 226 #     def get_python_tag(self, name): return self.node.get_python_tag(name)
 227 #     def remove_node(self): return self.node.remove_node()
 228 #     def flatten_strong(self): return self.node.flatten_strong()
 229 #     def clear_model_nodes(self): return self.node.clear_model_nodes()
 230 #     def show(self): return self.node.show()
 231 #     def set_depth_offset(self, val): return self.node.set_depth_offset(val)
 232 #     def loop(self, val): return self.node.loop(val)
 233 #     def cleanup(self): return self.node.cleanup()
 234 #     def write_bam_file(self, fname): return self.node.write_bam_file(fname)
 235
 236 #     def attach_node(self, name):
 237 #         return P3dNode(self.node.attach_new_node(name))
 238
 239 #     def add_shape(self, shape):
 240 #         return self.node.node().add_shape(shape._mesh_shape)
 241 #         #TODO: don't access a protected member
 242
 243 #     @property
 244 #     def name(self): return self.node.get_name()
 245
 246 #     @property
 247 #     def node(self): return self.nodepath
 248
 249 #     @property
 250 #     def p3dnode(self): return self.node.node()
 251
 252 #     def set_pos(self, pos): return self.node.set_pos(pos._vec)
 253 #         #TODO: don't access a protected member
 254
 255 #     def get_pos(self, other=None):
 256 #         return self.node.get_pos(* [] if other is None else [other.node])
 257
 258 #     @property
 259 #     def x(self): return self.node.get_x()
 260
 261 #     @property
 262 #     def y(self): return self.node.get_y()
 263
 264 #     @property
 265 #     def z(self): return self.node.get_z()
 266
 267 #     @property
 268 #     def hpr(self): return self.node.get_hpr()
 269
 270 #     @property
 271 #     def h(self): return self.node.get_h()
 272
 273 #     @property
 274 #     def p(self): return self.node.get_p()
 275
 276 #     @property
 277 #     def r(self): return self.node.get_r()
 278
 279 #     @property
 280 #     def scale(self): return self.node.get_scale()
 281
 282 #     @property
 283 #     def is_empty(self): return self.node.is_empty()
 284
 285 #     def get_relative_vector(self, node, vec):
 286 #         return self.node.get_relative_vector(node.node, vec)
 287
 288 #     def set_material(self, mat): return self.node.set_material(mat, 1)
 289
 290 #     def set_python_tag(self, name, val):
 291 #         return self.node.set_python_tag(name, val)
 292
 293 #     def get_distance(self, other_node):
 294 #         return self.node.get_distance(other_node.node)
 295
 296 #     def reparent_to(self, parent): return self.node.reparent_to(parent.node)
 297
 298 #     def wrt_reparent_to(self, parent):
 299 #         return self.node.wrt_reparent_to(parent.node)
 300
 301 #     @staticmethod
 302 #     def __get_pandanode(nodepath):
 303 #         if nodepath.has_python_tag('libnode'):
 304 #             return nodepath.get_python_tag('libnode')
 305 #         return P3dNode(nodepath)
 306
 307 #     def find_all_matches(self, name):
 308 #         nodes = self.node.find_all_matches(name)
 309 #         return [self.__get_pandanode(node) for node in nodes]
 310
 311 #     def find(self, name):
 312 #         model = self.node.find(name)
 313 #         if model: return self.__get_pandanode(model)
 314
 315 #     def optimize(self):
 316 #         # crash with texture.set_format
 317 #         self.node.prepare_scene(base.win.get_gsg())
 318 #         self.node.premunge_scene(base.win.get_gsg())
 319
 320 #     def hide(self, mask=None):
 321 #         return self.node.hide(*[] if mask is None else [mask])
 322
 323 #     @property
 324 #     def tight_bounds(self): return self.node.get_tight_bounds()
 325
 326 #     @property
 327 #     def parent(self): return self.node.get_parent()
 328
 329 #     @property
 330 #     def children(self): return self.node.get_children()
 331
 332 #     def destroy(self): return self.node.remove_node()
 333
 334
 335 # class P3dAnimNode:
 336
 337 #     def __init__(self, filepath, anim_dct):
 338 #         self.node = Actor(filepath, anim_dct)
 339
 340 #     def loop(self, val): return self.node.loop(val)
 341
 342 #     def reparent_to(self, node): self.node.reparent_to(node)
 343
 344 #     @property
 345 #     def name(self): return self.node.get_name()
 346
 347 #     def optimize(self):
 348 #         self.node.prepare_scene(base.win.get_gsg())
 349 #         self.node.premunge_scene(base.win.get_gsg())
 350
 351 #     def set_omni(self):
 352 #         self.node.node().set_bounds(OmniBoundingVolume())
 353 #         self.node.node().set_final(True)
 354
 355 #     def destroy(self): self.node.cleanup()
 356
 357
 358 # class P3dAmbientLight:
 359
 360 #     def __init__(self, color):
 361 #         ambient_lgt = P3DAmbientLight('ambient light')
 362 #         ambient_lgt.set_color(color)
 363 #         self.ambient_np = render.attach_new_node(ambient_lgt)
 364 #         render.set_light(self.ambient_np)
 365
 366 #     def destroy(self):
 367 #         render.clear_light(self.ambient_np)
 368 #         self.ambient_np.remove_node()
 369
 370
 371 # class P3dSpotlight:
 372
 373 #     def __init__(self, mask=None):
 374 #         self.spot_lgt = render.attach_new_node(P3DSpotlight('spot'))
 375 #         snode = self.spot_lgt.node()
 376 #         snode.set_scene(render)
 377 #         snode.set_shadow_caster(True, 1024, 1024)
 378 #         snode.get_lens().set_fov(40)
 379 #         snode.get_lens().set_near_far(20, 200)
 380 #         if mask: snode.set_camera_mask(mask)
 381 #         render.set_light(self.spot_lgt)
 382
 383 #     def set_pos(self, pos): return self.spot_lgt.set_pos(*pos)
 384
 385 #     def look_at(self, pos): return self.spot_lgt.look_at(*pos)
 386
 387 #     def set_color(self, color): return self.spot_lgt.set_color(*color)
 388
 389 #     def destroy(self):
 390 #         render.clear_light(self.spot_lgt)
 391 #         self.spot_lgt.remove_node()