igeEffekseer 0.0.4

C++ extension Effekseer for 3D and 2D games.

igeEffekseer

C++ extension Effekseer for 3D and 2D games.

Before running this tutorial, you have to install igeEffekseer

[pip install igeEffekseer]

The Editor

Get from link : https://effekseer.github.io/en/download.html

Tutorial

https://github.com/indigames/pyxieTutorials/tree/dev/igeEffekseer

Support

• Effeck : .efk
• Texture : .pyxi

APIs

Functions

• static

  • texture_loader
    • set the texture loader callback
    • use igeCore as a helper to load the texture then give back the texture information (width, height, id, has_mipmap)

     textures = {}
     def f_texture_loader(name, type):
     	print('f_texture_loader - ' + name)
     	tex = core.texture(name)    
     	textures[name] = tex
     	return (tex.width, tex.height, tex.id, tex.numMips > 1)
    
     igeEffekseer.texture_loader(f_texture_loader)
    

• getset

   _particle = igeEffekseer.particle()
  

  • projection_ortho

    • projection is ortho or perspective
    • False as default

     _particle.projection_ortho = False
    

  • projection_viewport

    • the viewport for rendering.
    • Optional (-1.0, -1.0) as default => the viewport set to full size

     _particle.projection_viewport = (_w, _h)
    

  • projection_viewsize

    • the viewsize used for detecting (ortho width and height in Ortho mode) or (aspect ratio in Perspective mode)
    • (480.0, 640.0) as default

     _particle.projection_ortho = True
     _particle.projection_viewsize = (_w / 10, _h / 10)
    

  • projection_near

    • projection near
    • 1.0 as default

     _particle.projection_near = 1.0
    

  • projection_far

    • projection far
    • 1000 as default

     _particle.projection_near = 1.0
    

  • projection_fov

    • projection fov for perspective view
    • 90 degree as default

     _particle.projection_fov = 90.0
    

  • camera_eye

    • the camera eye position
    • (0.0, 0.0, -20.0) as default

     _particle.camera_eye = (10.0, 5.0, -20.0)
    

  • camera_at

    • the camera target position
    • (0.0, 0.0, 0.0) as default

     _particle.camera_at = (0.0, 0.0, 0.0)
    

  • camera_up

    • the camera up
    • (0.0, 1.0, 0.0) as default

     _particle.camera_up = (0.0, 1.0, 0.0)
    

  • framerate

    • the desired framerate
    • 60 fps as default

     _particle.framerate = 60.0
    

• particle

   _particle = igeEffekseer.particle()
  

  • shoot
    • update then render the effekseer system
    • shoot(delta_time, clean_screen)
      • delta_time : float
      • clean_screen : bool optional

     _particle.shoot(core.getElapsedTime())
    

  • add
    • add the effect to the effekseer system
    • handle = _particle.add(name, loop, position)
      • name : string
        • the effect string path
      • loop : bool optional
        • is looping or not
      • position : tuple
        • the position optional

     _distortion_handle = _particle.add(name='Simple_Distortion.efk', loop=True, position=(0.0, 0.0, 0.0))
    

  • remove
    • remove the effect from effekseer system
    • _particle.remove(handle)
      • handle : int
        • the effect handle

     _particle.remove(_distortion_hd)
    

  • stop_all_effects
    • remove | stop all the effect from effekseer system

     _particle.stop_all_effects()
    

  • set_target_location
    • set target location for the effect handle
    • _particle.set_target_location(handle, x, y, z)
      • handle : int
        • the effect handle
      • x, y, z : float location
  • get_location
    • get location from the effect handle
    • result = _particle.get_location(handle)
      • handle : int
        • the effect handle
      • result : tuple location
  • set_location
    • set location for the effect handle
    • _particle.set_location(handle, x, y, z)
      • handle : int
        • the effect handle
      • x, y, z : float location
  • set_rotation
    • set rotation for the effect handle
    • _particle.set_rotation(handle, x, y, z)
      • handle : int
        • the effect handle
      • x, y, z : float rotation
  • set_scale
    • set scale for the effect handle
    • _particle.set_scale(handle, x, y, z)
      • handle : int
        • the effect handle
      • x, y, z : float scale
  • set_color
    • set scale for the effect handle
    • _particle.set_scale(handle, red, green, blue, alpha)
      • handle : int
        • the effect handle
      • red, green, blue, alpha : int value channel (0-255)
  • get_speed
    • get speed from the effect handle
    • result = _particle.get_speed(handle)
      • handle : int
        • the effect handle
      • result : float speed
  • set_speed
    • set speed for the effect handle
    • _particle.set_speed(handle, speed)
      • handle : int
        • the effect handle
      • speed : float value
  • is_playing
    • checking the effect is playing
    • result = _particle.is_playing(handle)
      • handle : int
        • the effect handle
      • result : bool. True if the effect is playing
  • set_pause
    • pause the effect handle
    • _particle.set_pause(handle, paused)
      • handle : int
        • the effect handle
      • paused : bool value
  • get_pause
    • get the pause status from the effect handle
    • result = _particle.get_pause(handle)
      • handle : int
        • the effect handle
      • result : bool value
  • set_shown
    • switch between show or hide of the effect handle
    • _particle.set_shown(handle, shown)
      • handle : int
        • the effect handle
      • shown : bool value
  • get_shown
    • get the show status from the effect handle
    • result = _particle.get_shown(handle)
      • handle : int
        • the effect handle
      • result : bool value
  • set_loop
    • loop (true / false)
    • _particle.set_loop(handle, loop)
      • handle : int
        • the effect handle
      • loop : bool value
  • get_loop
    • get the loop status from the effect handle
    • result = _particle.get_loop(handle)
      • handle : int
        • the effect handle
      • result : bool value

• statistic

  • drawcall_count
    • return the drawcall count
    • count = _particle.drawcall_count()
  • vertex_count
    • return the draw vertex count
    • count = _particle.vertex_count()
  • update_time
    • return the update time take
    • time = _particle.update_time()
    • time : int (micro second)
  • draw_time
    • return the draw time take
    • time = _particle.draw_time()
    • time : int (micro second)