def _create_handles(window_title, window_position, window_size, window_flags,
renderer_info):
"""Create the SDL2 handles."""
window_flags = sdl2.SDL_WINDOW_SHOWN | window_flags
if renderer_info.api == GraphicsAPI.OPENGL:
window_flags |= sdl2.SDL_WINDOW_OPENGL
window = sdl2.SDL_CreateWindow(
window_title.encode(),
window_position.x, window_position.y,
window_size.x, window_size.y,
window_flags)
if not window:
raise RuntimeError(sdl2.SDL_GetError().decode())
context = sdl2.SDL_GL_CreateContext(window)
if not context:
raise RuntimeError(sdl2.SDL_GetError().decode())
# Try to disable the vertical synchronization. It applies to the active
# context and thus needs to be called after `SDL_GL_CreateContext`.
sdl2.SDL_GL_SetSwapInterval(0)
return _Handles(
window=window,
renderer=_GLHandles(context=context))
def __init__(self, window):
self.window = window
self.world = sdl2.ext.World()
self.sdl_renderer = sdl2.SDL_CreateRenderer(
window, -1, sdl2.SDL_RENDERER_ACCELERATED)
sdl2.SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN_DESKTOP)
sdl2.SDL_GL_SetSwapInterval(1)
def __init__(self, width, height):
self.width = width
self.height = height
# init SDL
sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_DOUBLEBUFFER, 1)
self.window = sdl2.SDL_CreateWindow(
b"SPARK(&pyspk) Fireworks Demo",
sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED,
width, height,
sdl2.SDL_WINDOW_SHOWN | sdl2.SDL_WINDOW_OPENGL)
sdl2.SDL_CaptureMouse(True)
# init OpenGL
self.context = sdl2.SDL_GL_CreateContext(self.window)
sdl2.SDL_GL_SetSwapInterval(0)
gl.glClearColor(0.0, 0.0, 0.0, 1.0)
surface = sdl2.SDL_GetWindowSurface(self.window)
gl.glViewport(0, 0, surface.contents.w, surface.contents.h)
# load Textures
texture = loadTexture(b'res/flare.bmp', gl.GL_ALPHA, gl.GL_REPEAT)
# init FTGL
if not notext:
font = FTGL.TextureFont('res/font.ttf')
font.FaceSize(24)
self.font = font
# init SPARK(pyspk)
# random seed initialization
spk.setRandomSeed(int(time.time()))
# step configuration
spk.System.setClampStep(True, 0.1) # clamp the step to 100 ms
spk.System.useAdaptiveStep(0.001, 0.01) # use an adaptive step from 1ms to 10ms (1000fps to 100fps)
# the base system
self.basesystem = BaseSystem(self.height, texture)
print('SPARK FACTORY AFTER INIT :')
spk.Factory.getInstance().traceAll()
# init Variables
self.running = True
self.paused = False
self.deltaTime = 0
self.step = 0
self.text = 2
self.renderValue = 0
self.angleY = 0.0
self.camPosZ = 5.0
self.spacePressed = -1.0
self.systems = []
self.nbParticles = ''
self.fps = ''
self.frames = [sdl2.SDL_GetTicks()-1]
self.lasttime = self.frames[-1]
def __init__(self, *args, **kwargs):
BaseCanvasBackend.__init__(self, *args)
title, size, position, show, vsync, resize, dec, fs, parent, context, \
= self._process_backend_kwargs(kwargs)
self._initialized = False
# Deal with context
if not context.istaken:
context.take('sdl2', self)
_set_config(context.config)
share = None
elif context.istaken == 'sdl2':
other = context.backend_canvas
share = other._id.window, other._native_context
sdl2.SDL_GL_MakeCurrent(*share)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_SHARE_WITH_CURRENT_CONTEXT, 1)
else:
raise RuntimeError('Different backends cannot share a context.')
sdl2.SDL_GL_SetSwapInterval(1 if vsync else 0)
flags = sdl2.SDL_WINDOW_OPENGL
flags |= sdl2.SDL_WINDOW_SHOWN # start out shown
flags |= sdl2.SDL_WINDOW_ALLOW_HIGHDPI
flags |= sdl2.SDL_WINDOW_RESIZABLE if resize else 0
flags |= sdl2.SDL_WINDOW_BORDERLESS if not dec else 0
if fs is not False:
self._fullscreen = True
if fs is not True:
logger.warning('Cannot specify monitor number for SDL2 '
'fullscreen, using default')
flags |= sdl2.SDL_WINDOW_FULLSCREEN_DESKTOP
else:
self._fullscreen = False
self._mods = list()
if position is None:
position = [sdl2.SDL_WINDOWPOS_UNDEFINED] * 2
self._id = sdl2.ext.Window(title, size, position, flags)
if not self._id.window:
raise RuntimeError('Could not create window')
if share is None:
self._native_context = sdl2.SDL_GL_CreateContext(self._id.window)
else:
self._native_context = sdl2.SDL_GL_CreateContext(share[0])
self._sdl_id = sdl2.SDL_GetWindowID(self._id.window)
_VP_SDL2_ALL_WINDOWS[self._sdl_id] = self
# Init
self._initialized = True
self._needs_draw = False
self._vispy_set_current()
self._vispy_canvas.events.initialize()
if not show:
self._vispy_set_visible(False)
def __init__(self, *args, **kwargs):
BaseCanvasBackend.__init__(self, *args)
p = self._process_backend_kwargs(kwargs)
self._initialized = False
# Deal with config
_set_config(p.context.config)
# Deal with context
p.context.shared.add_ref('sdl2', self)
if p.context.shared.ref is self:
share = None
else:
other = p.context.shared.ref
share = other._id.window, other._native_context
sdl2.SDL_GL_MakeCurrent(*share)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_SHARE_WITH_CURRENT_CONTEXT, 1)
sdl2.SDL_GL_SetSwapInterval(1 if p.vsync else 0)
flags = sdl2.SDL_WINDOW_OPENGL
flags |= sdl2.SDL_WINDOW_SHOWN # start out shown
flags |= sdl2.SDL_WINDOW_ALLOW_HIGHDPI
flags |= sdl2.SDL_WINDOW_RESIZABLE if p.resizable else 0
flags |= sdl2.SDL_WINDOW_BORDERLESS if not p.decorate else 0
if p.fullscreen is not False:
self._fullscreen = True
if p.fullscreen is not True:
logger.warning('Cannot specify monitor number for SDL2 '
'fullscreen, using default')
flags |= sdl2.SDL_WINDOW_FULLSCREEN_DESKTOP
else:
self._fullscreen = False
self._mods = list()
if p.position is None:
position = [sdl2.SDL_WINDOWPOS_UNDEFINED] * 2
else:
position = None
self._id = sdl2.ext.Window(p.title, p.size, position, flags)
if not self._id.window:
raise RuntimeError('Could not create window')
if share is None:
self._native_context = sdl2.SDL_GL_CreateContext(self._id.window)
else:
self._native_context = sdl2.SDL_GL_CreateContext(share[0])
self._sdl_id = sdl2.SDL_GetWindowID(self._id.window)
_VP_SDL2_ALL_WINDOWS[self._sdl_id] = self
# Init
self._initialized = True
self._needs_draw = False
self._vispy_canvas.set_current()
self._vispy_canvas.events.initialize()
if not p.show:
self._vispy_set_visible(False)
def __init__( self, width=256, height=256, title=None, visible=True, aspect=None,
decoration=True, fullscreen=False, config=None, context=None, color=(0,0,0,1)):
""" """
window.Window.__init__(self, width=width,
height=height,
title=title,
visible=visible,
aspect=aspect,
decoration=decoration,
fullscreen=fullscreen,
config=config,
context=context,
color=color)
if config is None:
config = configuration.Configuration()
set_configuration(config)
flags = sdl2.SDL_WINDOW_SHOWN
# flags |= sdl2.SDL_WINDOW_ALLOW_HIGHDPI
flags |= sdl2.SDL_WINDOW_RESIZABLE
flags |= sdl2.SDL_WINDOW_OPENGL
if visible:
flags |= sdl2.SDL_WINDOW_SHOWN
else:
flags |= SDL_WINDOW_HIDDEN
if not decoration:
flags |= sdl2.SDL_WINDOW_BORDERLESS
self._native_window = sdl2.SDL_CreateWindow(self._title,
sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED,
width, height, flags)
self._native_context = sdl2.SDL_GL_CreateContext(self._native_window)
self._native_id = sdl2.SDL_GetWindowID(self._native_window)
sdl2.SDL_GL_SetSwapInterval(0)
# OSX: check framebuffer size / window size. On retina display, they
# can be different so we try to correct window size such as having
# the framebuffer size of the right size
# w,h = ctypes.c_int(),ctypes.c_int()
# sdl2.SDL_GL_GetDrawableSize(self._native_window, w, h)
# w,h = w.value(), h.value()
# if w != width or h!= height:
# width = width/2
# height= height/2
# sdl2.SDL_SetWindowSize(self._native_window, int(width), int(height))
self._height = height
self._width = width
__windows__[self._native_id] = self
def _async_init(self):
# Create an SDL2 window
sdl2.ext.init()
if sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) != 0:
raise RuntimeError(sdl2.SDL_GetError())
self._window = sdl2.SDL_CreateWindow(
self._window_title.encode(),
sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED,
self.width,
self.height,
sdl2.SDL_WINDOW_OPENGL
| sdl2.SDL_WINDOW_RESIZABLE
| sdl2.SDL_WINDOW_UTILITY,
)
# Create an OpenGL context
sdl2.video.SDL_GL_SetAttribute(sdl2.video.SDL_GL_CONTEXT_MAJOR_VERSION,
self.OPENGL_VERSION[0])
sdl2.video.SDL_GL_SetAttribute(sdl2.video.SDL_GL_CONTEXT_MINOR_VERSION,
self.OPENGL_VERSION[1])
sdl2.video.SDL_GL_SetAttribute(
sdl2.video.SDL_GL_CONTEXT_PROFILE_MASK,
sdl2.video.SDL_GL_CONTEXT_PROFILE_CORE,
)
self._glcontext = sdl2.SDL_GL_CreateContext(self._window)
sdl2.SDL_GL_MakeCurrent(self._window, self._glcontext)
# Activate vertical synchronization
sdl2.SDL_GL_SetSwapInterval(1)
# Set the GLX context
GLX.glXMakeCurrent(self.x11display, self.x11window, self.glx_context)
# Call subclass custom initialization
self.init(**self._init_kwds)
# Start rendering
sdl2.SDL_ShowWindow(self._window)
self._timer = self._loop.create_timer(self._on_update)
self._loop.set_timer(self._timer, 1, int(1000.0 / 60.0))
def init_sdl(self):
"""
Create a window and initialize opengl
"""
sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_MAJOR_VERSION, 3)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_MINOR_VERSION, 2)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_PROFILE_MASK,
sdl2.SDL_GL_CONTEXT_PROFILE_CORE)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_DOUBLEBUFFER, 1)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_DEPTH_SIZE, 24)
sdl2.SDL_GL_SetSwapInterval(0) # 0 = no vsync
self.window = sdl2.SDL_CreateWindow(
"DPT GLITCH GUY", sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED, DEF_WINDOW_WIDTH, DEF_WINDOW_HEIGHT,
sdl2.SDL_WINDOW_OPENGL | sdl2.SDL_WINDOW_SHOWN)
assert self.window, "Error: Could not create window"
sdl2.SDL_SetWindowResizable(self.window, True)
glcontext = sdl2.SDL_GL_CreateContext(self.window)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glEnable(gl.GL_CULL_FACE)
gl.glEnable(gl.GL_BLEND)
gl.glClearColor(0.6, 0.6, 0.6, 0.0)
def __init__(self,
width=256,
height=256,
title=None,
visible=True,
decoration=True,
fullscreen=False,
config=None,
context=None):
""" """
window.Window.__init__(self, width, height, title, visible, decoration,
fullscreen, config, context)
if config is None:
config = configuration.Configuration()
set_configuration(config)
flags = sdl2.SDL_WINDOW_SHOWN
flags |= sdl2.SDL_WINDOW_ALLOW_HIGHDPI
flags |= sdl2.SDL_WINDOW_RESIZABLE
flags |= sdl2.SDL_WINDOW_OPENGL
if visible:
flags |= sdl2.SDL_WINDOW_SHOWN
else:
flags |= SDL_WINDOW_HIDDEN
if not decoration:
flags |= sdl2.SDL_WINDOW_BORDERLESS
self._native_window = sdl2.SDL_CreateWindow(
self._title, sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED, width, height, flags)
self._native_context = sdl2.SDL_GL_CreateContext(self._native_window)
self._native_id = sdl2.SDL_GetWindowID(self._native_window)
sdl2.SDL_GL_SetSwapInterval(0)
__windows__[self._native_id] = self
def __init__(self, width, height):
self.width = width
self.height = height
# init SDL
sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_DOUBLEBUFFER, 1)
self.window = sdl2.SDL_CreateWindow(
b"SPARK(&pyspk) Collision Demo", sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED, width, height,
sdl2.SDL_WINDOW_SHOWN | sdl2.SDL_WINDOW_OPENGL)
sdl2.SDL_CaptureMouse(True)
# init OpenGL
self.context = sdl2.SDL_GL_CreateContext(self.window)
sdl2.SDL_GL_SetSwapInterval(0)
gl.glClearColor(0.0, 0.0, 0.0, 1.0)
surface = sdl2.SDL_GetWindowSurface(self.window)
gl.glViewport(0, 0, surface.contents.w, surface.contents.h)
# load Texture
txParticle = loadTexture(b'res/ball2.bmp', gl.GL_RGBA, gl.GL_CLAMP)
self.txCrate = loadTexture(b'res/crate.bmp', gl.GL_RGB, gl.GL_REPEAT)
self.txFloor = loadTexture(b'res/floor.bmp', gl.GL_RGB, gl.GL_REPEAT)
self.txWall = loadTexture(b'res/wall.bmp', gl.GL_RGB, gl.GL_REPEAT)
# init FTGL
if not notext:
font = FTGL.TextureFont('res/font.ttf')
font.FaceSize(24)
self.font = font
# init SPARK(pyspk)
# create Renderer
spk.setRandomSeed(int(time.time()))
renderer = GLPointRenderer.create(1.0) # type: GLPointRenderer
renderer.setType(
spk.POINT_SPRITE) # using Point Sprite(require >=OpenGL2.0)
renderer.setTexture(txParticle) # use the texture on drawing
renderer.enableWorldSize(
True
) # true: unit is adjusted with the screen, false: unit is pixel(fixed)
GLPointRenderer.setPixelPerUnit(45.0 * math.pi / 180.0, self.height)
renderer.setSize(0.05)
renderer.setBlending(
spk.BLENDING_NONE
) # blending method between particles(no blending)
renderer.enableRenderingHint(spk.ALPHA_TEST,
True) # notifying not to use depth info
renderer.setAlphaTestThreshold(0.8)
self.renderer = renderer
self.basicRenderer = GLPointRenderer.create(
1.0) # bare renderer for comparison(F4)
# create Model
model_enable = spk.FLAG_RED | spk.FLAG_GREEN | spk.FLAG_BLUE # use color channels(RGB)
model = spk.Model.create(model_enable) # type: spk.Model
model.setLifeTime(10.0, 10.0) # particle's life time is 10[sec]
self.model = model
# create Emitter
emit_dir = spk.Vector3D(0.0, 0.0, -1.0)
emit_center = spk.Vector3D(0.0, 2.0, 4.475)
minangle = 0.0 * math.pi # zenith angle(min)
maxangle = 0.5 * math.pi # zenith angle(max)
emitter = spk.SphericEmitter.create(
emit_dir, minangle, maxangle) # type: spk.SphericEmitter
emitter.setZone(
spk.Point.create(emit_center),
True) # particles are randomly placed in the specified zone
emitter.setFlow(300) # max number of particles
emitter.setForce(1.5, 2.5) # emittion power
# create Group
maxparticle = 3100 # upper limit number of particles
group = spk.Group.create(model, maxparticle) # type: spk.Group
group.addEmitter(emitter)
group.setRenderer(renderer)
group.setCustomBirth(self.assignColor)
group.setGravity(spk.Vector3D(0.0, -0.8, 0.0))
group.setFriction(0.2)
self.group = group
# create Room objects
self.ROOM_X = 7.0
self.ROOM_Y = 3.0
self.ROOM_Z = 9.0
self.boxes = []
self.partitions = []
self.initRoom(group) # obstacles
self.createDisplayLists() # display list for OpenGL drawing
# create System
system = spk.System.create() # type: spk.System
system.addGroup(group)
self.system = system
print('SPARK FACTORY AFTER INIT :')
spk.Factory.getInstance().traceAll()
# init Variables
self.running = True
self.enableBoxDrawing = False
self.paused = False
self.deltaTime = 0
self.step = 0
self.text = 2
self.renderValue = 0
self.renderEnv = True
self.angleY = 90.0
self.angleX = 45.0
self.camPosZ = 10.0
self.nbParticles = ''
self.fps = ''
self.frames = [sdl2.SDL_GetTicks() - 1]
self.lasttime = self.frames[-1]
def __init__(self, width, height):
self.width = width
self.height = height
# init SDL
sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_DOUBLEBUFFER, 1)
self.window = sdl2.SDL_CreateWindow(
b"SPARK(&pyspk) Flakes Demo", sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED, width, height,
sdl2.SDL_WINDOW_SHOWN | sdl2.SDL_WINDOW_OPENGL)
sdl2.SDL_CaptureMouse(True)
# init OpenGL
self.context = sdl2.SDL_GL_CreateContext(self.window)
sdl2.SDL_GL_SetSwapInterval(0)
gl.glClearColor(0.0, 0.0, 0.0, 1.0)
surface = sdl2.SDL_GetWindowSurface(self.window)
gl.glViewport(0, 0, surface.contents.w, surface.contents.h)
# init FTGL
if not notext:
font = FTGL.TextureFont('res/font.ttf')
font.FaceSize(24)
self.font = font
# init SPARK(pyspk)
# random seed initialization
spk.setRandomSeed(int(time.time()))
# step configuration
spk.System.setClampStep(True, 0.1) # clamp the step to 100 ms
spk.System.useAdaptiveStep(
0.001,
0.01) # use an adaptive step from 1ms to 10ms (1000fps to 100fps)
# create Renderer
renderer = GLPointRenderer.create(1.0) # type: GLPointRenderer
renderer.setBlending(
spk.BLENDING_ADD
) # blending method between particles(additive blending)
renderer.enableRenderingHint(spk.DEPTH_TEST,
False) # notifying not to use depth info
renderer.setAlphaTestThreshold(0.8)
self.renderer = renderer
self.basicRenderer = GLPointRenderer.create(
1.0) # bare renderer for comparison(F4)
# create Model
model_enable = spk.FLAG_RED | spk.FLAG_GREEN | spk.FLAG_BLUE | spk.FLAG_ALPHA # use color channels(RGBA)
model = spk.Model.create(model_enable) # type: spk.Model
model.setParam(spk.PARAM_RED, 1.0)
model.setParam(spk.PARAM_GREEN, 0.8)
model.setParam(spk.PARAM_BLUE, 0.3)
model.setParam(spk.PARAM_ALPHA, 0.4)
model.setImmortal(True) # particle is immortal
self.model = model
# no Emitter
# create Modifier
self.sphere = spk.Sphere.create(spk.Vector3D(), 1.0)
obstacle = spk.Obstacle.create(self.sphere) # type: spk.Obstacle
obstacle.setFriction(0.9)
obstacle.setBouncingRatio(0.9)
self.obstacle = obstacle
# create Group
self.NB_PARTICLES = [10000, 25000, 50000, 100000, 200000, 500000]
group = spk.Group.create(model,
self.NB_PARTICLES[-1]) # type: spk.Group
group.addModifier(obstacle)
group.setRenderer(renderer)
group.setGravity(spk.Vector3D(0.0, -0.5, 0.0))
group.setFriction(0.2)
self.group = group
# create System
system = spk.System.create() # type: spk.System
system.addGroup(group)
self.system = system
print('SPARK FACTORY AFTER INIT :')
spk.Factory.getInstance().traceAll()
# init Variables
self.running = True
self.paused = False
self.deltaTime = 0
self.step = 0
self.text = 2
self.renderValue = 0
self.angleX = 0.0
self.angleZ = 0.0
self.camPosZ = 2.75
self.particleIndex = 2
self.nbParticles = ''
self.fps = ''
self.frames = [sdl2.SDL_GetTicks() - 1]
self.lasttime = self.frames[-1]
def display_init(diagonal_in):
"""Initializes the display and rendering backend, calculating and assigning the values
of runtime KLParams variables related to the screen (e.g. P.screen_c, P.refresh_rate,
P.pixels_per_degree). Called by 'klibs run' on launch, for internal use only.
Args:
diagonal_in (float): The size of the monitor in diagonal inches (e.g. 13 for a
13-inch MacBook Pro).
"""
if os.name == 'nt':
# set video driver explicitly on Windows to avoid misdetection problems
os.environ['SDL_VIDEODRIVER'] = 'windows'
sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO)
sdl2.mouse.SDL_ShowCursor(sdl2.SDL_DISABLE)
sdl2.SDL_PumpEvents()
display_mode = sdl2.video.SDL_DisplayMode()
sdl2.SDL_GetCurrentDisplayMode(0, display_mode)
P.screen_x = display_mode.w
P.screen_y = display_mode.h
P.screen_c = (P.screen_x // 2, P.screen_y // 2)
P.screen_x_y = (P.screen_x, P.screen_y)
P.refresh_rate = float(display_mode.refresh_rate)
if P.refresh_rate == 0:
P.refresh_rate = 60.0
print(
"\tWarning: Unable to detect your monitor's refresh rate, defaulting to 60Hz."
)
elif P.refresh_rate == 59:
P.refresh_rate = 59.94 # fix for some Windows monitors
P.refresh_time = 1000.0 / P.refresh_rate
#TODO: figure out what's actually needed for multi-monitor support
for d in P.additional_displays:
if d[2]:
P.screen_x_y = list(d[1])
P.screen_x = d[1][0]
P.screen_y = d[1][1]
if P.screen_origin is None:
P.screen_origin = (0, 0)
# Get conversion factor for pixels to degrees of visual angle based on viewing distance,
# screen resolution, and given diagonal screen size
P.screen_diagonal_in = diagonal_in
P.screen_diagonal_px = sqrt(P.screen_x**2.0 + P.screen_y**2.0)
P.ppi = P.screen_diagonal_px / diagonal_in
P.monitor_height = P.screen_y / P.ppi
P.monitor_width = P.screen_x / P.ppi
P.screen_degrees_x = degrees(2 * atan(
(2.54 * P.monitor_width / 2.0) / P.view_distance))
P.screen_degrees_y = degrees(2 * atan(
(2.54 * P.monitor_height / 2.0) / P.view_distance))
P.pixels_per_degree = P.screen_x / P.screen_degrees_x
P.ppd = P.pixels_per_degree # alias for convenience
# Create the SDL window object and configure it properly for OpenGL (code from Mike)
SCREEN_FLAGS = (sdl2.SDL_WINDOW_SHOWN | sdl2.SDL_WINDOW_FULLSCREEN_DESKTOP
| sdl2.SDL_WINDOW_OPENGL | sdl2.SDL_WINDOW_ALLOW_HIGHDPI)
window = sdl2.ext.Window(P.project_name, P.screen_x_y, P.screen_origin,
SCREEN_FLAGS)
sdl2.SDL_GL_CreateContext(window.window)
sdl2.SDL_GL_SetSwapInterval(1) # enforce vsync
gl.glMatrixMode(gl.GL_PROJECTION)
gl.glLoadIdentity()
gl.glOrtho(0, P.screen_x, P.screen_y, 0, 0, 1)
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glDisable(gl.GL_DEPTH_TEST)
# Clear the SDL event queue and open the window, returning the window object
sdl2.SDL_PumpEvents()
sdl2.mouse.SDL_ShowCursor(sdl2.SDL_DISABLE)
window.show()
P.display_initialized = True
return window
def main():
args = argparse.ArgumentParser(description="Run " + TITLE)
args.add_argument('-i', '--midi-input', help="connect to specified MIDI input port")
args.add_argument('-o', '--midi-output', help="connect to specified MIDI output port")
args.add_argument('-c', '--debug-camera', action='store_true', help="use a controllable camera")
args.add_argument('-s', '--vsync', action='store_true', help="use vsync")
args.add_argument('-v', '--verbose', action='store_true', help="increase verbosity")
args.add_argument('-w', '--windowed', action='store_true', help="run in a window")
args.add_argument('-3', '--stereoscopy', choices=[scene.STEREOSCOPY_OFF, scene.STEREOSCOPY_ANAGLYPH], help="stereoscopy mode")
args.add_argument('-e', '--eye-separation', type=float, help="stereoscopic eye separation")
opts = args.parse_args(sys.argv[1:])
if opts.verbose:
logging.basicConfig(level=logging.DEBUG)
else:
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
logger.info("Initializing")
sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO)
dm = sdl2.SDL_DisplayMode()
sdl2.SDL_GetDesktopDisplayMode(0, dm)
if not opts.windowed:
width = dm.w
height = dm.h
else:
width = round(dm.w * .8)
height = round(dm.h * .8)
window_flags = sdl2.SDL_WINDOW_OPENGL | (sdl2.SDL_WINDOW_FULLSCREEN if not opts.windowed else 0)
window = sdl2.SDL_CreateWindow(TITLE.encode('utf-8'), sdl2.SDL_WINDOWPOS_UNDEFINED, sdl2.SDL_WINDOWPOS_UNDEFINED, width, height, window_flags)
context = sdl2.SDL_GL_CreateContext(window)
fbo = create_multisampled_fbo(width, height, 0)
if opts.vsync:
if sdl2.SDL_GL_SetSwapInterval(-1) == -1:
logger.warning("Adaptive vsync not available")
sdl2.SDL_GL_SetSwapInterval(1)
else:
sdl2.SDL_GL_SetSwapInterval(0)
midi_handler = midi.MidiHandler(opts.midi_input, opts.midi_output)
main_scene = scene.Scene((width, height), midi_handler, debug_camera=opts.debug_camera)
if opts.stereoscopy is not None:
main_scene.set_stereoscopy(opts.stereoscopy)
if opts.eye_separation is not None:
main_scene.stereoscopy_eye_separation = opts.eye_separation
frames = 0
frame_count_time = time.monotonic()
ev = sdl2.SDL_Event()
running = True
while running:
while True:
if (sdl2.SDL_PollEvent(ev) == 0):
break
if ev.type == sdl2.SDL_QUIT:
running = False
elif ev.type == sdl2.SDL_KEYUP and ev.key.keysym.sym == sdl2.SDLK_ESCAPE:
running = False
elif ev.type == sdl2.SDL_KEYDOWN and ev.key.repeat == 0:
main_scene.key_down(sdl2.SDL_GetKeyName(ev.key.keysym.sym).decode('ascii').lower())
elif ev.type == sdl2.SDL_KEYUP and ev.key.repeat == 0:
main_scene.key_up(sdl2.SDL_GetKeyName(ev.key.keysym.sym).decode('ascii').lower())
elif ev.type == sdl2.SDL_MOUSEBUTTONDOWN:
main_scene.mouse_down(ev.button.button, (ev.button.x / width, ev.button.y / height))
elif ev.type == sdl2.SDL_MOUSEBUTTONUP:
main_scene.mouse_up(ev.button.button, (ev.button.x / width, ev.button.y / height))
main_scene.update()
main_scene.render()
blit_multisampled_fbo(width, height, fbo)
sdl2.SDL_GL_SwapWindow(window)
frames += 1
now = time.monotonic()
if now - frame_count_time > FPS_PRINT_TIME:
fps = frames / (now - frame_count_time)
frames = 0
frame_count_time = now
logger.debug("%.3f FPS", fps)
main_scene.shutdown()
sdl2.SDL_GL_DeleteContext(context)
sdl2.SDL_DestroyWindow(window)
sdl2.SDL_Quit()
def __init__(self, width, height):
self.width = width
self.height = height
# init SDL
sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_DOUBLEBUFFER, 1)
self.window = sdl2.SDL_CreateWindow(
b"SPARK(&pyspk) Galaxy Demo", sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED, width, height,
sdl2.SDL_WINDOW_SHOWN | sdl2.SDL_WINDOW_OPENGL)
sdl2.SDL_CaptureMouse(True)
# init OpenGL
self.context = sdl2.SDL_GL_CreateContext(self.window)
sdl2.SDL_GL_SetSwapInterval(0)
gl.glClearColor(0.0, 0.0, 0.0, 1.0)
surface = sdl2.SDL_GetWindowSurface(self.window)
gl.glViewport(0, 0, surface.contents.w, surface.contents.h)
gl.glEnable(gl.GL_DEPTH_TEST)
# load Textures
texture = loadTexture(b'res/flare.bmp', gl.GL_ALPHA, gl.GL_CLAMP)
# init FTGL
if not notext:
font = FTGL.TextureFont('res/font.ttf')
font.FaceSize(24)
self.font = font
# init SPARK(pyspk)
# step configuration
spk.System.setClampStep(True, 0.1) # clamp the step to 100 ms
spk.System.useRealStep() # no adjustment
# create Renderer
renderer = GLQuadRenderer.create() # type: GLQuadRenderer
renderer.setTexturingMode(spk.TEXTURE_2D)
renderer.setTexture(texture)
renderer.setTextureBlending(gl.GL_MODULATE)
renderer.setScale(0.05, 0.05)
renderer.setBlending(spk.BLENDING_ADD)
renderer.enableRenderingHint(spk.DEPTH_WRITE, False)
self.renderer = renderer
self.basicRenderer = GLPointRenderer.create(
1.0) # bare renderer for comparison(F4)
# create Model
galaxy_enable = spk.FLAG_RED | spk.FLAG_GREEN | spk.FLAG_BLUE | spk.FLAG_ALPHA | spk.FLAG_SIZE
galaxy_mutable = spk.FLAG_RED | spk.FLAG_GREEN | spk.FLAG_BLUE
galaxy_random = spk.FLAG_RED | spk.FLAG_GREEN | spk.FLAG_SIZE
galaxy_interpolated = spk.FLAG_ALPHA
galaxyModel = spk.Model.create(galaxy_enable, galaxy_mutable,
galaxy_random,
galaxy_interpolated) # type: spk.Model
galaxyModel.setParam(spk.PARAM_RED, 0.0, 0.3, 0.5, 0.5)
galaxyModel.setParam(spk.PARAM_GREEN, 0.0, 0.3, 0.5, 0.5)
galaxyModel.setParam(spk.PARAM_BLUE, 1.0, 0.1)
galaxyModel.setParam(spk.PARAM_SIZE, 0.1, 5.0)
galaxyModel.setLifeTime(35.0, 40.0)
ip_alpha = galaxyModel.getInterpolator(spk.PARAM_ALPHA)
ip_alpha.addEntry(0.0, 0.0)
ip_alpha.addEntry(0.95, 0.6, 1.0)
ip_alpha.addEntry(1.0, 0.0)
star_enable = spk.FLAG_RED | spk.FLAG_GREEN | spk.FLAG_BLUE | spk.FLAG_ALPHA | spk.FLAG_SIZE
star_mutable = spk.FLAG_NONE
star_random = spk.FLAG_RED | spk.FLAG_GREEN | spk.FLAG_ALPHA | spk.FLAG_SIZE
starModel = spk.Model.create(star_enable, star_mutable,
star_random) # type: spk.Model
starModel.setParam(spk.PARAM_RED, 0.8, 1.0)
starModel.setParam(spk.PARAM_GREEN, 0.4, 1.0)
starModel.setParam(spk.PARAM_BLUE, 0.8, 1.0)
starModel.setParam(spk.PARAM_ALPHA, 0.2, 1.0)
starModel.setParam(spk.PARAM_SIZE, 0.1, 5.0)
starModel.setImmortal(True)
# create Emitter
# 2 emitters in diagonal lines on Y=0 plane
lineEmitter1 = spk.RandomEmitter.create() # type: spk.RandomEmitter
lineEmitter1.setZone(
spk.Line.create(spk.Vector3D(-2.5, 0.0, -2.5),
spk.Vector3D(2.5, 0.0, 2.5)))
lineEmitter1.setFlow(100)
lineEmitter1.setForce(0.0, 0.01)
lineEmitter2 = spk.RandomEmitter.create()
lineEmitter2.setZone(
spk.Line.create(spk.Vector3D(-2.5, 0.0, 2.5),
spk.Vector3D(2.5, 0.0, -2.5)))
lineEmitter2.setFlow(100)
lineEmitter2.setForce(0.0, 0.01)
# create Modifier
vortex = spk.Vortex.create() # type: spk.Vortex
vortex.setRotationSpeed(0.4,
False) # True->[rad/sec], False->[unit/src]
vortex.setAttractionSpeed(0.04, True)
vortex.setEyeRadius(0.05)
vortex.enableParticleKilling(True) # kill attracted particles
# create Group
galaxyGroup = spk.Group.create(galaxyModel, 8000) # type: spk.Group
galaxyGroup.addEmitter(lineEmitter1)
galaxyGroup.addEmitter(lineEmitter2)
galaxyGroup.setRenderer(renderer)
galaxyGroup.addModifier(vortex)
self.galaxyGroup = galaxyGroup
starGroup = spk.Group.create(starModel, 1000)
starGroup.setRenderer(renderer)
skySphere = spk.Sphere(spk.Vector3D(), 16.0)
starGroup.addParticles(1000,
zone=skySphere,
velocity=spk.Vector3D(),
full=False)
starGroup.flushAddedParticles()
# create System
galaxySystem = spk.System.create() # type: spk.System
galaxySystem.addGroup(galaxyGroup)
self.galaxySystem = galaxySystem
starSystem = spk.System.create()
starSystem.addGroup(starGroup)
self.starSystem = starSystem
print('SPARK FACTORY AFTER INIT :')
spk.Factory.getInstance().traceAll()
# init Variables
self.running = True
self.paused = False
self.deltaTime = 0
self.step = 0
self.text = 2
self.renderValue = 0
self.renderEnv = True
self.angleY = 0.0
self.angleX = 45.0
self.camPosZ = 5.0
self.nbParticles = ''
self.fps = ''
self.frames = [sdl2.SDL_GetTicks() - 1]
self.lasttime = self.frames[-1]
def __init__(self, width, height):
self.width = width
self.height = height
# init SDL
sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_DOUBLEBUFFER, 1)
self.window = sdl2.SDL_CreateWindow(
b"SPARK(&pyspk) Basic Demo", sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED, width, height,
sdl2.SDL_WINDOW_SHOWN | sdl2.SDL_WINDOW_OPENGL)
sdl2.SDL_CaptureMouse(True)
# init OpenGL
self.context = sdl2.SDL_GL_CreateContext(self.window)
sdl2.SDL_GL_SetSwapInterval(0)
gl.glClearColor(0.0, 0.0, 0.0, 1.0)
surface = sdl2.SDL_GetWindowSurface(self.window)
gl.glViewport(0, 0, surface.contents.w, surface.contents.h)
# load Texture
texture = loadTexture(b'res/point.bmp', gl.GL_ALPHA, gl.GL_CLAMP)
# init FTGL
if not notext:
font = FTGL.TextureFont('res/font.ttf')
font.FaceSize(24)
self.font = font
# init SPARK(pyspk)
# step configuration
spk.System.setClampStep(True, 0.1) # clamp the step to 100 ms
spk.System.useAdaptiveStep(
0.001,
0.01) # use an adaptive step from 1ms to 10ms (1000fps to 100fps)
# create Renderer
renderer = GLPointRenderer.create(1.0) # type: GLPointRenderer
renderer.setType(
spk.POINT_SPRITE) # using Point Sprite(require >=OpenGL2.0)
renderer.setTexture(texture) # use the texture on drawing
renderer.setTextureBlending(gl.GL_MODULATE)
renderer.enableWorldSize(
True
) # true: unit is adjusted with the screen, false: unit is pixel(fixed)
GLPointRenderer.setPixelPerUnit(45.0 * math.pi / 180.0, self.height)
renderer.setSize(0.05)
renderer.setBlending(
spk.BLENDING_ADD
) # blending method between particles(additive blending)
renderer.enableRenderingHint(spk.DEPTH_WRITE,
False) # notifying not to use depth info
self.renderer = renderer
self.basicRenderer = GLPointRenderer.create(
1.0) # bare renderer for comparison(F4)
# create Model
model_enable = spk.FLAG_RED | spk.FLAG_GREEN | spk.FLAG_BLUE | spk.FLAG_ALPHA # use color channels(RGBA)
model = spk.Model.create(model_enable) # type: spk.Model
model.setParam(spk.PARAM_ALPHA,
1.0) # alpha is fixed(RGB are changed later)
model.setLifeTime(8.0, 8.0) # particle's life time is 8.0[sec]
self.model = model
# create Emitter
emit_dir = spk.Vector3D(0.0, 1.0, 0.0)
emit_center = spk.Vector3D(0.0, 0.015, 0.0)
minangle = 0.1 * math.pi # zenith angle(min)
maxangle = 0.1 * math.pi # zenith angle(max)
emitter = spk.SphericEmitter.create(
emit_dir, minangle, maxangle) # type: spk.SphericEmitter
emitter.setZone(
spk.Point.create(emit_center),
True) # particles are randomly placed in the specified zone
emitter.setFlow(1000) # max number of particles
emitter.setForce(1.5, 1.5) # emittion power
# create Modifier
groundplane = spk.Plane.create()
bouncing = 0.6 # bouncing ratio(coefficient of restitution)
friction = 1.0 # coefficient of friction
obstacle = spk.Obstacle.create(groundplane, spk.INTERSECT_ZONE,
bouncing, friction)
# create Group
maxparticle = 5000 # upper limit number of particles
group = spk.Group.create(model, maxparticle) # type: spk.Group
group.addEmitter(emitter)
group.addModifier(obstacle)
group.setRenderer(renderer)
group.setGravity(spk.Vector3D(0.0, -0.8, 0.0))
self.group = group
# create System
system = spk.System.create() # type: spk.System
system.addGroup(group)
self.system = system
print('SPARK FACTORY AFTER INIT :')
spk.Factory.getInstance().traceAll()
# init Variables
self.running = True
self.paused = False
self.deltaTime = 0
self.step = 0
self.text = 2
self.renderValue = 0
self.angleY = 0.0
self.angleX = 45.0
self.camPosZ = 5.0
self.nbParticles = ''
self.fps = ''
self.frames = [sdl2.SDL_GetTicks() - 1]
self.lasttime = self.frames[-1]
def main():
########################
class Opts(object):
pass
opts = Opts()
opts.verbose = True
opts.windowed = True
opts.vsync = False
########################
if opts.verbose:
logging.basicConfig(level=logging.DEBUG)
else:
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
logger.info("Initializing")
sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO)
dm = sdl2.SDL_DisplayMode()
sdl2.SDL_GetDesktopDisplayMode(0, dm)
if not opts.windowed:
width = dm.w
height = dm.h
else:
width = round(dm.w * .8)
height = round(dm.h * .8)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_PROFILE_MASK,
sdl2.SDL_GL_CONTEXT_PROFILE_ES)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_MAJOR_VERSION, 3)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_MINOR_VERSION, 0)
window_flags = sdl2.SDL_WINDOW_OPENGL | (sdl2.SDL_WINDOW_FULLSCREEN
if not opts.windowed else 0)
window = sdl2.SDL_CreateWindow(TITLE.encode('utf-8'),
sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED, width, height,
window_flags)
context = sdl2.SDL_GL_CreateContext(window)
fbo = None
# fbo = gllib.framebuffer.MultisampledFramebuffer(8, (width, height))
if opts.vsync:
if sdl2.SDL_GL_SetSwapInterval(-1) == -1:
logger.warning("Adaptive vsync not available")
sdl2.SDL_GL_SetSwapInterval(1)
else:
sdl2.SDL_GL_SetSwapInterval(0)
main_scene = scene.Scene((width, height))
frames = 0
frame_count_time = time.monotonic()
ev = sdl2.SDL_Event()
running = True
while running:
while True:
if (sdl2.SDL_PollEvent(ev) == 0):
break
if ev.type == sdl2.SDL_QUIT:
running = False
elif ev.type == sdl2.SDL_KEYUP and ev.key.keysym.sym == sdl2.SDLK_ESCAPE:
running = False
main_scene.update()
if fbo is not None:
with fbo:
main_scene.render()
fbo.activate_for_read()
fbo.blit()
else:
main_scene.render()
sdl2.SDL_GL_SwapWindow(window)
frames += 1
now = time.monotonic()
if now - frame_count_time > FPS_PRINT_TIME:
fps = frames / (now - frame_count_time)
frames = 0
frame_count_time = now
logger.debug("%.3f FPS", fps)
main_scene.shutdown()
sdl2.SDL_GL_DeleteContext(context)
sdl2.SDL_DestroyWindow(window)
sdl2.SDL_Quit()
def show_model(tsdf):
WINDOW_WIDTH = 640
WINDOW_HEIGHT = 480
# Init
sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_MAJOR_VERSION, 3)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_MINOR_VERSION, 2)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_PROFILE_MASK,
sdl2.SDL_GL_CONTEXT_PROFILE_CORE)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_DOUBLEBUFFER, 1)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_DEPTH_SIZE, 24)
sdl2.SDL_GL_SetSwapInterval(1)
window = sdl2.SDL_CreateWindow(
b"Python/SDL2/OpenGL", sdl2.SDL_WINDOWPOS_CENTERED,
sdl2.SDL_WINDOWPOS_CENTERED, WINDOW_WIDTH, WINDOW_HEIGHT,
sdl2.SDL_WINDOW_OPENGL | sdl2.SDL_WINDOW_SHOWN)
if not window:
sys.stderr.write("Error: Could not create window\n")
exit(1)
glcontext = sdl2.SDL_GL_CreateContext(window)
# gl.glClampColor(gl.GL_CLAMP_FRAGMENT_COLOR, False)
# gl.glClampColor(gl.GL_CLAMP_VERTEX_COLOR, False)
# gl.glClampColor(gl.GL_CLAMP_READ_COLOR, False)
viewer = Viewer()
viewer.set_s2w(tsdf.intrinsic_inv)
viewer.set_c(np.zeros([3]))
viewer.set_vol_dim(tsdf.vol_dim)
viewer.set_vol_start(tsdf.vol_start)
viewer.set_vol_end(tsdf.vol_end)
tex = gl.glGenTextures(2)
gl.glBindTexture(gl.GL_TEXTURE_2D, tex[0])
# print(tsdf.tsdf_color.dtype)
fused = np.concatenate([tsdf.tsdf_color.astype(np.float32) / 255, np.expand_dims(tsdf.tsdf_diff, -1)], axis=-1)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_NEAREST)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA32F, fused.shape[1], fused.shape[0], 0, gl.GL_RGBA, gl.GL_FLOAT, fused)
gl.glBindTexture(gl.GL_TEXTURE_2D, 0)
gl.glBindTexture(gl.GL_TEXTURE_2D, tex[1])
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_NEAREST)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_R16I, tsdf.tsdf_cls.shape[1], tsdf.tsdf_cls.shape[0], 0, gl.GL_RED_INTEGER, gl.GL_INT,
tsdf.tsdf_cls)
gl.glBindTexture(gl.GL_TEXTURE_2D, 0)
running = True
event = sdl2.SDL_Event()
angle = 0
while running:
angle += 0.01
while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0:
if event.type == sdl2.SDL_QUIT:
running = False
if event.type == sdl2.events.SDL_KEYDOWN:
print("SDL_KEYDOWN")
if event.key.keysym.sym == sdl2.SDLK_ESCAPE:
running = False
# if event.type == sdl2.SDL_MOUSEMOTION:
# print("SDL_MOUSEMOTION")
# if event.type == sdl2.SDL_MOUSEBUTTONDOWN:
# print("SDL_MOUSEBUTTONDOWN")
mean_depth = tsdf.mean_depth
rot = np.array([[math.cos(angle), 0, -math.sin(angle), mean_depth * math.sin(angle)],
[0, 1, 0, 0],
[math.sin(angle), 0, math.cos(angle), mean_depth - mean_depth * math.cos(angle)],
[0, 0, 0, 1]])
viewer.set_s2w(np.matmul(rot, tsdf.intrinsic_inv))
viewer.set_c(np.array([(mean_depth + 0.5) * math.sin(angle), 0, (mean_depth + 0.5) - (mean_depth + 0.5) * math.cos(angle)]))
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glViewport(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT)
gl.glUseProgram(viewer.program)
gl.glBindVertexArray(viewer.vao)
gl.glActiveTexture(gl.GL_TEXTURE0)
gl.glBindTexture(gl.GL_TEXTURE_2D, tex[0])
gl.glActiveTexture(gl.GL_TEXTURE1)
gl.glBindTexture(gl.GL_TEXTURE_2D, tex[1])
gl.glDrawArrays(gl.GL_TRIANGLE_STRIP, 0, 4)
# gl.glBindTexture(gl.GL_TEXTURE_2D, 0)
gl.glUseProgram(0)
sdl2.SDL_GL_SwapWindow(window)
def __init__(self, width, height):
self.width = width
self.height = height
# init SDL
sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_DOUBLEBUFFER, 1)
self.window = sdl2.SDL_CreateWindow(
b"SPARK(&pyspk) Fountain Demo", sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED, width, height,
sdl2.SDL_WINDOW_SHOWN | sdl2.SDL_WINDOW_OPENGL)
sdl2.SDL_CaptureMouse(True)
# init OpenGL
self.context = sdl2.SDL_GL_CreateContext(self.window)
sdl2.SDL_GL_SetSwapInterval(0)
gl.glClearColor(0.0, 0.68, 0.85, 1.0)
surface = sdl2.SDL_GetWindowSurface(self.window)
gl.glViewport(0, 0, surface.contents.w, surface.contents.h)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
# init fog
gl.glEnable(gl.GL_FOG)
gl.glFogi(gl.GL_FOG_MODE, gl.GL_EXP2)
gl.glFogfv(gl.GL_FOG_COLOR, [0.0, 0.68, 0.85, 1.0])
gl.glFogf(gl.GL_FOG_DENSITY, 0.04)
gl.glHint(gl.GL_PERSPECTIVE_CORRECTION_HINT, gl.GL_NICEST)
# load Textures
self.txGrass = loadTexture(b'res/grass.bmp',
gl.GL_RGB,
gl.GL_REPEAT,
mipmap=True)
self.txFountain = loadTexture(b'res/tile.bmp',
gl.GL_RGB,
gl.GL_REPEAT,
mipmap=True)
self.txWater = loadTexture(b'res/water.bmp',
gl.GL_RGB,
gl.GL_REPEAT,
mipmap=True)
txSplash = loadTexture(b'res/waterdrops.bmp', gl.GL_ALPHA, gl.GL_CLAMP)
# create display lists
self.createDisplayLists()
# init FTGL
if not notext:
font = FTGL.TextureFont('res/font.ttf')
font.FaceSize(24)
self.font = font
# init SPARK(pyspk)
# random seed initialization
spk.setRandomSeed(int(time.time()))
# step configuration
spk.System.setClampStep(True, 0.1) # clamp the step to 100 ms
spk.System.useAdaptiveStep(
0.001,
0.01) # use an adaptive step from 1ms to 10ms (1000fps to 100fps)
# create Renderer
renderer = GLQuadRenderer.create(1.0) # type: GLQuadRenderer
renderer.setScale(0.06, 0.06)
renderer.setTexturingMode(spk.TEXTURE_2D)
renderer.setTexture(txSplash)
renderer.setBlending(spk.BLENDING_ALPHA)
renderer.enableRenderingHint(spk.DEPTH_WRITE, False)
self.renderer = renderer
self.basicRenderer = GLPointRenderer.create(
1.0) # bare renderer for comparison(F4)
# create Model
model_enable = spk.FLAG_ALPHA | spk.FLAG_SIZE | spk.FLAG_ANGLE
model_mutable = spk.FLAG_ALPHA | spk.FLAG_SIZE | spk.FLAG_ANGLE
model_random = spk.FLAG_SIZE | spk.FLAG_ANGLE
model = spk.Model.create(model_enable, model_mutable,
model_random) # type: spk.Model
model.setParam(spk.PARAM_ALPHA, 0.2, 0.0)
model.setParam(spk.PARAM_SIZE, 1.0, 1.0, 2.0, 8.0)
model.setParam(spk.PARAM_ANGLE, 0.0, 4.0 * math.pi, 0.0, 4.0 * math.pi)
model.setLifeTime(1.6, 2.2)
self.model = model
# create Emitter
self.emitterZones = []
self.emitters = []
# splash to just above(x1)
self.emitterZones.append(spk.Point.create(spk.Vector3D(0.0, 0.1, 0.0)))
self.emitters.append(
spk.StraightEmitter.create(spk.Vector3D(0.0, 1.0, 0.0)))
# splash from center of fountain(x4)
self.emitterZones.append(spk.Point.create(spk.Vector3D(0.0, 0.1, 0.0)))
self.emitterZones.append(spk.Point.create(spk.Vector3D(0.0, 0.1, 0.0)))
self.emitterZones.append(spk.Point.create(spk.Vector3D(0.0, 0.1, 0.0)))
self.emitterZones.append(spk.Point.create(spk.Vector3D(0.0, 0.1, 0.0)))
self.emitters.append(
spk.StraightEmitter.create(spk.Vector3D(1.0, 3.0, 1.0)))
self.emitters.append(
spk.StraightEmitter.create(spk.Vector3D(-1.0, 3.0, -1.0)))
self.emitters.append(
spk.StraightEmitter.create(spk.Vector3D(-1.0, 3.0, 1.0)))
self.emitters.append(
spk.StraightEmitter.create(spk.Vector3D(1.0, 3.0, -1.0)))
# splash from the side of fountain(x8)
self.emitterZones.append(
spk.Point.create(spk.Vector3D(-1.6, 0.1, -1.6)))
self.emitterZones.append(spk.Point.create(spk.Vector3D(1.6, 0.1, 1.6)))
self.emitterZones.append(spk.Point.create(spk.Vector3D(1.6, 0.1,
-1.6)))
self.emitterZones.append(spk.Point.create(spk.Vector3D(-1.6, 0.1,
1.6)))
self.emitterZones.append(
spk.Point.create(spk.Vector3D(-2.26, 0.1, 0.0)))
self.emitterZones.append(spk.Point.create(spk.Vector3D(2.26, 0.1,
0.0)))
self.emitterZones.append(
spk.Point.create(spk.Vector3D(0.0, 0.1, -2.26)))
self.emitterZones.append(spk.Point.create(spk.Vector3D(0.0, 0.1,
2.26)))
self.emitters.append(
spk.StraightEmitter.create(spk.Vector3D(1.0, 2.0, 1.0)))
self.emitters.append(
spk.StraightEmitter.create(spk.Vector3D(-1.0, 2.0, -1.0)))
self.emitters.append(
spk.StraightEmitter.create(spk.Vector3D(-1.0, 2.0, 1.0)))
self.emitters.append(
spk.StraightEmitter.create(spk.Vector3D(1.0, 2.0, -1.0)))
self.emitters.append(
spk.StraightEmitter.create(spk.Vector3D(1.41, 2.0, 0.0)))
self.emitters.append(
spk.StraightEmitter.create(spk.Vector3D(-1.41, 2.0, 0.0)))
self.emitters.append(
spk.StraightEmitter.create(spk.Vector3D(0.0, 2.0, 1.41)))
self.emitters.append(
spk.StraightEmitter.create(spk.Vector3D(0.0, 2.0, -1.41)))
self.flow = [
500.0, 600.0, 600.0, 600.0, 600.0, 900.0, 900.0, 900.0, 900.0,
900.0, 900.0, 900.0, 900.0
]
self.flowLow = [
150.0, 200.0, 200.0, 200.0, 200.0, 250.0, 250.0, 250.0, 250.0,
250.0, 250.0, 250.0, 250.0
]
for i in range(len(self.emitters)):
self.emitters[i].setZone(self.emitterZones[i])
self.emitters[i].setFlow(self.flow[i])
self.emitters[i].setForce(2.5, 4.0)
self.emitters[0].setForce(3.0, 3.5)
# no Modifier
# create Group
group = spk.Group.create(model, 20000) # type: spk.Group
for emitter in self.emitters:
group.addEmitter(emitter)
group.setRenderer(renderer)
group.setCustomUpdate(self.splash)
group.setGravity(spk.Vector3D(0.0, -2.2, 0.0))
group.setFriction(0.7)
self.group = group
# create System
system = spk.System.create() # type: spk.System
system.addGroup(group)
self.system = system
print('SPARK FACTORY AFTER INIT :')
spk.Factory.getInstance().traceAll()
# init Variables
self.running = True
self.paused = False
self.deltaTime = 0
self.totalTime = 0
self.step = 0
self.text = 2
self.renderValue = 0
self.renderEnv = True
self.highGraphics = True
self.angleY = 25.0
self.angleX = 25.0
self.camPosZ = 8.0
self.nbParticles = ''
self.fps = ''
self.frames = [sdl2.SDL_GetTicks() - 1]
self.lasttime = self.frames[-1]
def __init__(self, width, height):
self.width = width
self.height = height
# init SDL
sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_DOUBLEBUFFER, 1)
self.window = sdl2.SDL_CreateWindow(
b"SPARK(&pyspk) Fire Demo", sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED, width, height,
sdl2.SDL_WINDOW_SHOWN | sdl2.SDL_WINDOW_OPENGL)
sdl2.SDL_CaptureMouse(True)
# init OpenGL
self.context = sdl2.SDL_GL_CreateContext(self.window)
sdl2.SDL_GL_SetSwapInterval(0)
gl.glClearColor(0.0, 0.0, 0.0, 1.0)
surface = sdl2.SDL_GetWindowSurface(self.window)
gl.glViewport(0, 0, surface.contents.w, surface.contents.h)
# load textures
txFire = loadTexture(b'res/fire2.bmp',
gl.GL_ALPHA,
gl.GL_CLAMP,
mipmap=True)
txSmoke = loadTexture(b'res/explosion.bmp', gl.GL_ALPHA, gl.GL_CLAMP)
# lighting
light_ambient = [0.15, 0.15, 0.25, 1.0]
light_diffuse = [1.0, 0.75, 0.25, 1.0]
gl.glLightfv(gl.GL_LIGHT0, gl.GL_AMBIENT, light_ambient)
gl.glLightfv(gl.GL_LIGHT0, gl.GL_DIFFUSE, light_diffuse)
gl.glLightf(gl.GL_LIGHT0, gl.GL_QUADRATIC_ATTENUATION, 20.0)
mat_ambient = [0.2, 0.2, 0.2, 1.0]
mat_diffuse = [1.0, 1.0, 1.0, 1.0]
gl.glMaterialfv(gl.GL_FRONT_AND_BACK, gl.GL_AMBIENT, mat_ambient)
gl.glMaterialfv(gl.GL_FRONT_AND_BACK, gl.GL_DIFFUSE, mat_diffuse)
gl.glLightModelfv(gl.GL_LIGHT_MODEL_AMBIENT, light_ambient)
gl.glLightModelf(gl.GL_LIGHT_MODEL_LOCAL_VIEWER, 1.0)
# init FTGL
if not notext:
font = FTGL.TextureFont('res/font.ttf')
font.FaceSize(24)
self.font = font
# init PyWavefront
self.scene = pywavefront.Wavefront('./res/SceneFireCamp.obj')
# init SPARK(pyspk)
# random seed initialization
spk.setRandomSeed(int(time.time()))
# step configuration
spk.System.setClampStep(True, 0.1) # clamp the step to 100 ms
spk.System.useAdaptiveStep(
0.001,
0.01) # use an adaptive step from 1ms to 10ms (1000fps to 100fps)
# create Renderer
fireRenderer = GLQuadRenderer.create() # type: GLQuadRenderer
fireRenderer.setScale(0.3, 0.3)
fireRenderer.setTexturingMode(spk.TEXTURE_2D)
fireRenderer.setTexture(txFire)
fireRenderer.setTextureBlending(gl.GL_MODULATE)
fireRenderer.setBlending(spk.BLENDING_ADD)
fireRenderer.enableRenderingHint(spk.DEPTH_WRITE, False)
fireRenderer.setAtlasDimensions(2, 2)
self.fireRenderer = fireRenderer
smokeRenderer = GLQuadRenderer.create() # type: GLQuadRenderer
smokeRenderer.setScale(0.3, 0.3)
smokeRenderer.setTexturingMode(spk.TEXTURE_2D)
smokeRenderer.setTexture(txSmoke)
smokeRenderer.setTextureBlending(gl.GL_MODULATE)
smokeRenderer.setBlending(spk.BLENDING_ALPHA)
smokeRenderer.enableRenderingHint(spk.DEPTH_WRITE, False)
smokeRenderer.setAtlasDimensions(2, 2)
self.smokeRenderer = smokeRenderer
self.basicRenderer = GLPointRenderer.create(
1.0) # bare renderer for comparison(F4)
# create Model
fire_enable = spk.FLAG_RED | spk.FLAG_GREEN | spk.FLAG_BLUE | spk.FLAG_ALPHA | \
spk.FLAG_SIZE | spk.FLAG_ANGLE | spk.FLAG_TEXTURE_INDEX
fire_mutable = spk.FLAG_RED | spk.FLAG_GREEN | spk.FLAG_ALPHA | spk.FLAG_ANGLE
fire_random = spk.FLAG_RED | spk.FLAG_GREEN | spk.FLAG_TEXTURE_INDEX | spk.FLAG_ANGLE
fire_interpolated = spk.FLAG_SIZE
fireModel = spk.Model.create(fire_enable, fire_mutable, fire_random,
fire_interpolated) # type: spk.Model
fireModel.setParam(spk.PARAM_RED, 0.8, 0.9, 0.8,
0.9) # [min,max]on birth, [min,max]on death
fireModel.setParam(spk.PARAM_GREEN, 0.5, 0.6, 0.5, 0.6)
fireModel.setParam(spk.PARAM_BLUE, 0.3)
fireModel.setParam(spk.PARAM_ALPHA, 0.4, 0.0) # on birth, on death
minAngle, maxAngle = 0.0, 2.0 * math.pi
fireModel.setParam(spk.PARAM_ANGLE, minAngle, maxAngle, minAngle,
maxAngle)
fireModel.setParam(spk.PARAM_TEXTURE_INDEX, 0.0, 4.0)
fireModel.setLifeTime(1.0, 1.5)
ip_size = fireModel.getInterpolator(spk.PARAM_SIZE)
ip_size.addEntry(0.5, 2.0, 5.0)
ip_size.addEntry(1.0, 0.0)
self.fireModel = fireModel
smoke_enable = spk.FLAG_RED | spk.FLAG_GREEN | spk.FLAG_BLUE | spk.FLAG_ALPHA | \
spk.FLAG_SIZE | spk.FLAG_ANGLE | spk.FLAG_TEXTURE_INDEX
smoke_mutable = spk.FLAG_RED | spk.FLAG_GREEN | spk.FLAG_SIZE | spk.FLAG_ANGLE
smoke_random = spk.FLAG_TEXTURE_INDEX | spk.FLAG_ANGLE
smoke_interpolated = spk.FLAG_ALPHA
smokeModel = spk.Model.create(smoke_enable, smoke_mutable,
smoke_random,
smoke_interpolated) # type: spk.Model
smokeModel.setParam(spk.PARAM_RED, 0.3, 0.2)
smokeModel.setParam(spk.PARAM_GREEN, 0.25, 0.2)
smokeModel.setParam(spk.PARAM_BLUE, 0.2)
smokeModel.setParam(spk.PARAM_ALPHA, 0.2, 0.0)
smokeModel.setParam(spk.PARAM_SIZE, 5.0, 10.0)
smokeModel.setParam(spk.PARAM_TEXTURE_INDEX, 0.0, 4.0)
smokeModel.setParam(spk.PARAM_ANGLE, 0.0, 2.0 * math.pi, 0.0,
2.0 * math.pi)
smokeModel.setLifeTime(5.0, 5.0)
ip_alpha = smokeModel.getInterpolator(spk.PARAM_ALPHA)
ip_alpha.addEntry(0.0, 0.0)
ip_alpha.addEntry(0.2, 0.2)
ip_alpha.addEntry(1.0, 0.0)
self.smokeModel = smokeModel
# create Emitter
fireEmitter1 = spk.StraightEmitter.create(spk.Vector3D(0.0, 1.0, 0.0))
fireEmitter1.setZone(
spk.Sphere.create(spk.Vector3D(0.0, -1.0, 0.0), 0.5))
fireEmitter1.setFlow(40)
fireEmitter1.setForce(1.0, 2.5)
fireEmitter2 = spk.StraightEmitter.create(spk.Vector3D(1.0, 0.6, 0.0))
fireEmitter2.setZone(
spk.Sphere.create(spk.Vector3D(0.15, -1.2, 0.075), 0.1))
fireEmitter2.setFlow(15)
fireEmitter2.setForce(0.5, 1.5)
fireEmitter3 = spk.StraightEmitter.create(spk.Vector3D(
-0.6, 0.8, -0.8))
fireEmitter3.setZone(
spk.Sphere.create(spk.Vector3D(-0.375, -1.15, -0.375), 0.3))
fireEmitter3.setFlow(15)
fireEmitter3.setForce(0.5, 1.5)
fireEmitter4 = spk.StraightEmitter.create(spk.Vector3D(-0.8, 0.5, 0.2))
fireEmitter4.setZone(
spk.Sphere.create(spk.Vector3D(-0.255, -1.2, 0.225), 0.2))
fireEmitter4.setFlow(10)
fireEmitter4.setForce(0.5, 1.5)
fireEmitter5 = spk.StraightEmitter.create(spk.Vector3D(0.1, 0.8, -1.0))
fireEmitter5.setZone(
spk.Sphere.create(spk.Vector3D(-0.075, -1.2, -0.3), 0.2))
fireEmitter5.setFlow(10)
fireEmitter5.setForce(0.5, 1.5)
smokeEmitter = spk.SphericEmitter.create(spk.Vector3D(0.0, 1.0, 0.0),
0.0, 0.5 * math.pi)
smokeEmitter.setZone(spk.Sphere.create(spk.Vector3D(), 1.2))
smokeEmitter.setFlow(25)
smokeEmitter.setForce(0.5, 1.0)
# no Modifier
# create Group
fireGroup = spk.Group.create(fireModel, 135) # type: spk.Group
fireGroup.addEmitter(fireEmitter1)
fireGroup.addEmitter(fireEmitter2)
fireGroup.addEmitter(fireEmitter3)
fireGroup.addEmitter(fireEmitter4)
fireGroup.addEmitter(fireEmitter5)
fireGroup.setRenderer(fireRenderer)
fireGroup.setGravity(spk.Vector3D(0.0, 3.0, 0.0))
self.fireGroup = fireGroup
smokeGroup = spk.Group.create(smokeModel, 135) # type: spk.Group
smokeGroup.addEmitter(smokeEmitter)
smokeGroup.setRenderer(smokeRenderer)
smokeGroup.setGravity(spk.Vector3D(0.0, 0.4, 0.0))
self.smokeGroup = smokeGroup
# create System
system = spk.System.create() # type: spk.System
system.addGroup(fireGroup)
system.addGroup(smokeGroup)
self.system = system
print('SPARK FACTORY AFTER INIT :')
spk.Factory.getInstance().traceAll()
# init Variables
self.running = True
self.paused = False
self.deltaTime = 0
self.step = 0
self.text = 2
self.renderValue = 0
self.renderEnv = True
self.angleY = 30.0
self.angleX = 25.0
self.camPosZ = 12.0
self.smoke = True
self.lightTime = 0
self.nbParticles = ''
self.fps = ''
self.strSmoke = 'SMOKE: ON'
self.frames = [sdl2.SDL_GetTicks() - 1]
self.lasttime = self.frames[-1]
x, y = ctypes.c_int(), ctypes.c_int()
sdl2.SDL_GetMouseState(ctypes.byref(x), ctypes.byref(y))
return y.value, x.value
geraMapa()
WINDOW_WIDTH = 800
WINDOW_HEIGHT = 600
sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_MAJOR_VERSION, 2)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_MINOR_VERSION, 0)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_PROFILE_MASK,sdl2.SDL_GL_CONTEXT_PROFILE_CORE)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_DOUBLEBUFFER, 1)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_DEPTH_SIZE, 24)
sdl2.SDL_GL_SetSwapInterval(1)
window = sdl2.SDL_CreateWindow(b"Mapa de Calor", sdl2.SDL_WINDOWPOS_CENTERED, sdl2.SDL_WINDOWPOS_CENTERED, WINDOW_WIDTH, WINDOW_HEIGHT, sdl2.SDL_WINDOW_OPENGL | sdl2.SDL_WINDOW_SHOWN)
if not window:
sys.stderr.write("Error: Could not create window\n")
exit(1)
glcontext = sdl2.SDL_GL_CreateContext(window)
LoadTextures()
glEnable(GL_TEXTURE_2D)
glEnable(GL_MULTISAMPLE)
glEnable(GL_DEPTH_TEST)
glShadeModel(GL_SMOOTH)
glClearColor(0.,0.,0.,1.)
gluPerspective(45,800.0/600.0,0.1,200.0)
glTranslatef(0.0,0.0,-60)
running = True
def __init__(self, width, height):
self.width = width
self.height = height
# init SDL
sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_DOUBLEBUFFER, 1)
self.window = sdl2.SDL_CreateWindow(
b"SPARK(&pyspk) Collision Demo2", sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED, width, height,
sdl2.SDL_WINDOW_SHOWN | sdl2.SDL_WINDOW_OPENGL)
sdl2.SDL_CaptureMouse(True)
# init OpenGL
self.context = sdl2.SDL_GL_CreateContext(self.window)
sdl2.SDL_GL_SetSwapInterval(0)
gl.glClearColor(0.0, 0.0, 0.0, 1.0)
surface = sdl2.SDL_GetWindowSurface(self.window)
gl.glViewport(0, 0, surface.contents.w, surface.contents.h)
# load Texture
texture = loadTexture(b'res/ball.bmp', gl.GL_RGBA, gl.GL_CLAMP)
# init FTGL
if not notext:
font = FTGL.TextureFont('res/font.ttf')
font.FaceSize(24)
self.font = font
# init SPARK(pyspk)
# step configuration
spk.System.setClampStep(True, 0.1) # clamp the step to 100 ms
spk.System.useAdaptiveStep(
0.001,
0.01) # use an adaptive step from 1ms to 10ms (1000fps to 100fps)
# create Renderer
renderer = GLPointRenderer.create(1.0) # type: GLPointRenderer
renderer.setType(
spk.POINT_SPRITE) # using Point Sprite(require >=OpenGL2.0)
renderer.setTexture(texture) # use the texture on drawing
renderer.enableWorldSize(
True
) # true: unit is adjusted with the screen, false: unit is pixel(fixed)
GLPointRenderer.setPixelPerUnit(45.0 * math.pi / 180.0, self.height)
renderer.setSize(0.15)
renderer.setBlending(
spk.BLENDING_NONE
) # blending method between particles(no blending)
renderer.enableRenderingHint(spk.ALPHA_TEST, True)
renderer.setAlphaTestThreshold(0.8)
self.renderer = renderer
self.basicRenderer = GLPointRenderer.create(
1.0) # bare renderer for comparison(F4)
# create Model
model_enable = spk.FLAG_RED | spk.FLAG_GREEN | spk.FLAG_BLUE | spk.FLAG_ALPHA # use color channels(RGBA)
model = spk.Model.create(model_enable) # type: spk.Model
model.setImmortal(True) # particle is immortal
self.model = model
# no Emitter
# create Modifier
self.sphere = spk.Sphere.create(spk.Vector3D(), 1.0 - 0.15 / 2.0)
self.cube = spk.AABox.create(spk.Vector3D(),
spk.Vector3D(1.2, 1.2, 1.2))
self.obstacle = spk.Obstacle.create(self.sphere, spk.EXIT_ZONE, 0.9,
0.9) # type: spk.Obstacle
self.obstacle.setZone(self.sphere)
collision = spk.Collision.create(0.15, 0.9)
# create Group
self.NB_PARTICLES = 250
group = spk.Group.create(model, self.NB_PARTICLES) # type: spk.Group
group.addModifier(self.obstacle)
group.addModifier(collision)
group.setRenderer(renderer)
group.setGravity(spk.Vector3D())
group.setFriction(0.1)
self.group = group
# create System
system = spk.System.create() # type: spk.System
system.addGroup(group)
self.system = system
print('SPARK FACTORY AFTER INIT :')
spk.Factory.getInstance().traceAll()
# init Variables
self.running = True
self.paused = False
self.deltaTime = 0
self.step = 0
self.text = 2
self.renderValue = 0
self.angleX = 0.0
self.angleZ = 0.0
self.camPosZ = 2.75
self.nbParticles = ''
self.fps = ''
self.strZone = 'ZONE: SPHERE'
self.frames = [sdl2.SDL_GetTicks() - 1]
self.lasttime = self.frames[-1]
def __init__(self, width, height):
self.width = width
self.height = height
# init SDL
sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_DOUBLEBUFFER, 1)
self.window = sdl2.SDL_CreateWindow(
b"SPARK(&pyspk) Rain Demo", sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED, width, height,
sdl2.SDL_WINDOW_SHOWN | sdl2.SDL_WINDOW_OPENGL)
sdl2.SDL_CaptureMouse(True)
# init OpenGL
self.context = sdl2.SDL_GL_CreateContext(self.window)
sdl2.SDL_GL_SetSwapInterval(0)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_MULTISAMPLEBUFFERS, 1)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_MULTISAMPLESAMPLES, 4)
gl.glClearColor(0.8, 0.8, 0.8, 0.0)
surface = sdl2.SDL_GetWindowSurface(self.window)
gl.glViewport(0, 0, surface.contents.w, surface.contents.h)
# gl.glDisable(gl.GL_DEPTH)
gl.glDisable(gl.GL_DEPTH_TEST)
# load Textures
self.txPaving = loadTexture(b'res/paving.bmp',
gl.GL_RGB,
gl.GL_REPEAT,
mipmap=True)
txSplash = loadTexture(b'res/waterdrops.bmp', gl.GL_ALPHA, gl.GL_CLAMP)
# init fog
gl.glEnable(gl.GL_FOG)
gl.glFogi(gl.GL_FOG_MODE, gl.GL_EXP2)
# init FTGL
if not notext:
font = FTGL.TextureFont('res/font.ttf')
font.FaceSize(24)
self.font = font
# init SPARK(pyspk)
# random seed initialization
spk.setRandomSeed(int(time.time()))
# step configuration
spk.System.setClampStep(True, 0.1) # clamp the step to 100 ms
spk.System.useAdaptiveStep(
0.001,
0.01) # use an adaptive step from 1ms to 10ms (1000fps to 100fps)
# create Renderer
self.sizeRatio = self.width / 1440
self.basicRenderer = GLPointRenderer.create(
1.0) # bare renderer for comparison(F4)
dropRenderer = GLPointRenderer.create()
dropRenderer.setType(spk.POINT_CIRCLE)
dropRenderer.setSize(2.0 * self.sizeRatio)
dropRenderer.enableBlending(True)
self.dropRenderer = dropRenderer
rainRenderer = GLLineRenderer.create()
rainRenderer.setLength(-0.1)
rainRenderer.enableBlending(True)
self.rainRenderer = rainRenderer
splashRenderer = GLQuadRenderer.create()
splashRenderer.setScale(0.05, 0.05)
splashRenderer.setTexturingMode(spk.TEXTURE_2D)
splashRenderer.setTexture(txSplash)
splashRenderer.enableBlending(True)
splashRenderer.enableRenderingHint(spk.DEPTH_WRITE, False)
self.splashRenderer = splashRenderer
# create Model
rain_enable = spk.FLAG_RED | spk.FLAG_GREEN | spk.FLAG_BLUE | spk.FLAG_ALPHA | spk.FLAG_MASS
rain_mutable = spk.FLAG_NONE
rain_random = spk.FLAG_MASS
rainModel = spk.Model.create(rain_enable, rain_mutable, rain_random)
rainModel.setParam(spk.PARAM_ALPHA, 0.2)
rainModel.setImmortal(True)
self.rainModel = rainModel
dropModel = spk.Model.create(rain_enable, rain_mutable,
rain_random) # same as rain
dropModel.setParam(spk.PARAM_ALPHA, 0.6)
self.dropModel = dropModel
splash_enable = spk.FLAG_RED | spk.FLAG_GREEN | spk.FLAG_BLUE | spk.FLAG_ALPHA | spk.FLAG_SIZE | spk.FLAG_ANGLE
splash_mutable = spk.FLAG_SIZE | spk.FLAG_ALPHA
splash_random = spk.FLAG_SIZE | spk.FLAG_ANGLE
splashModel = spk.Model.create(splash_enable, splash_mutable,
splash_random)
splashModel.setParam(spk.PARAM_ANGLE, 0.0, 2.0 * math.pi)
splashModel.setParam(spk.PARAM_ALPHA, 1.0, 0.0)
self.splashModel = splashModel
# create Emitter
rainZone = spk.Ring.create(spk.Vector3D(0.0, 5.0, 0.0))
self.rainZone = rainZone
rainEmitter = spk.SphericEmitter.create(spk.Vector3D(0.0, -1.0, 0.0),
0.0, 0.03 * math.pi)
rainEmitter.setZone(rainZone)
self.rainEmitter = rainEmitter
self.dropEmitter = spk.SphericEmitter.create(
spk.Vector3D(0.0, 1.0, 0.0), 0.0, 0.2 * math.pi)
# create Group
gravity = spk.Vector3D(0.0, -2.0, 0.0)
rainGroup = spk.Group.create(rainModel, 8000)
rainGroup.setCustomUpdate(lambda p, t: self.killRain(p, t))
rainGroup.setRenderer(rainRenderer)
rainGroup.addEmitter(rainEmitter)
rainGroup.setFriction(0.7)
rainGroup.setGravity(gravity)
self.rainGroup = rainGroup
dropGroup = spk.Group.create(dropModel, 16000)
dropGroup.setRenderer(dropRenderer)
dropGroup.setFriction(0.7)
dropGroup.setGravity(gravity)
self.dropGroup = dropGroup
splashGroup = spk.Group.create(splashModel, 2400)
splashGroup.setRenderer(splashRenderer)
self.splashGroup = splashGroup
# create System
system = spk.System.create()
system.addGroup(splashGroup)
system.addGroup(dropGroup)
system.addGroup(rainGroup)
self.system = system
print('SPARK FACTORY AFTER INIT :')
spk.Factory.getInstance().traceAll()
# init Variables
self.running = True
self.paused = False
self.deltaTime = 0
self.step = 0
self.text = 2
self.renderValue = 0
self.renderEnv = True
self.angleY = 0.0
self.angleX = 12.0
self.posX = 0.0
self.posZ = 0.0
self.rainRatio = 0.5
self.recompute = True
self.nbParticles = ''
self.fps = ''
self.strRainRate = ''
self.frames = [sdl2.SDL_GetTicks() - 1]
self.lasttime = self.frames[-1]
def __init__(self, width, height):
self.width = width
self.height = height
# init SDL
sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_DOUBLEBUFFER, 1)
self.window = sdl2.SDL_CreateWindow(
b"SPARK(&pyspk) Writing Demo", sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED, width, height,
sdl2.SDL_WINDOW_SHOWN | sdl2.SDL_WINDOW_OPENGL)
sdl2.SDL_CaptureMouse(True)
# init OpenGL
self.context = sdl2.SDL_GL_CreateContext(self.window)
sdl2.SDL_GL_SetSwapInterval(0)
gl.glClearColor(0.0, 0.0, 0.0, 1.0)
surface = sdl2.SDL_GetWindowSurface(self.window)
gl.glViewport(0, 0, surface.contents.w, surface.contents.h)
# load texture
texture = loadTexture(b'res/point.bmp', gl.GL_ALPHA, gl.GL_CLAMP)
# init FTGL
if not notext:
font = FTGL.TextureFont('res/font.ttf')
font.FaceSize(24)
self.font = font
# init SPARK(pyspk)
# random seed initialization
spk.setRandomSeed(int(time.time()))
# step configuration
spk.System.setClampStep(True, 0.1) # clamp the step to 100 ms
spk.System.useAdaptiveStep(
0.001,
0.01) # use an adaptive step from 1ms to 10ms (1000fps to 100fps)
# create Renderer
renderer = GLQuadRenderer.create(1.0) # type: GLQuadRenderer
renderer.enableBlending(True)
renderer.setBlendingFunctions(gl.GL_SRC_ALPHA, gl.GL_ONE)
renderer.setTexturingMode(spk.TEXTURE_2D)
renderer.setTexture(texture)
renderer.setTextureBlending(gl.GL_MODULATE)
renderer.setScale(0.05, 0.05)
renderer.enableRenderingHint(spk.DEPTH_TEST, False)
self.renderer = renderer
self.basicRenderer = GLPointRenderer.create(
1.0) # bare renderer for comparison(F4)
# create Model
model_enable = spk.FLAG_RED | spk.FLAG_GREEN | spk.FLAG_BLUE | spk.FLAG_ALPHA | spk.FLAG_SIZE
model_mutable = spk.FLAG_ALPHA | spk.FLAG_SIZE
model = spk.Model.create(model_enable,
model_mutable) # type: spk.Model
model.setParam(spk.PARAM_ALPHA, 5.0,
0.0) # the particles will fade as the die
model.setParam(spk.PARAM_SIZE, 1.0,
15.0) # the particles will enlarge over time
model.setLifeTime(5.0, 6.0)
self.model = model
# create Emitter
# We set up a spheric emitter that emits in all direction with a very small force
# in order to slightly displace the particles
emitter = spk.RandomEmitter.create()
emitter.setForce(0.01, 0.01)
self.emitter = emitter # uses it at later directly
# create Group
group = spk.Group.create(model, 14000) # type: spk.Group
group.setRenderer(renderer)
group.setFriction(
-0.3) # negative friction: The particles will accelerate over time
self.group = group
# create System
system = spk.System.create() # type: spk.System
system.addGroup(group)
self.system = system
print('SPARK FACTORY AFTER INIT :')
spk.Factory.getInstance().traceAll()
# init Variables
self.running = True
self.paused = False
self.deltaTime = 0
self.step = 0
self.text = 2
self.renderValue = 0
self.angleY = 0.0
self.angleX = 0.0
self.camPosZ = 5.0
self.add = False
self.oldX = 0
self.oldY = 0
self.oldZ = 0
self.offset = 0.0
self.nbParticles = ''
self.fps = ''
self.frames = [sdl2.SDL_GetTicks() - 1]
self.lasttime = self.frames[-1]
# This computes the ratio to go from screen coordinates to universe coordinates
self.screenToUniverse = 2.0 * self.camPosZ * math.tan(
45.0 * 0.5 * math.pi / 180.0) / self.height
