def __init__(self, Δx=1.0, Δy=1.0, m=10, n=10):
self.Δx = Δx
self.Δy = Δy
self.m = m
self.n = n
self.width = Δx * m
self.height = Δy * n
if sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) != 0:
print(sdl2.SDL_GetError())
return
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_MAJOR_VERSION, 3)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_MINOR_VERSION, 3)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_PROFILE_MASK,
sdl2.SDL_GL_CONTEXT_PROFILE_CORE)
self.window = sdl2.SDL_CreateWindow(
b"Example 1", sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED, 640, 480,
sdl2.SDL_WINDOW_OPENGL | sdl2.SDL_WINDOW_ALWAYS_ON_TOP)
sdl2.SDL_SetWindowInputFocus(self.window)
self.context = sdl2.SDL_GL_CreateContext(self.window)
self.setupGL()
self.prepGrid()
self.prepBuffers()
sdl2.SDL_RaiseWindow(self.window)
def __init__(self, config):
"""Constructor.
Instantiates a window and sets up an OpenGL context for it, which is
immediately made active, using the given configuration data.
:param config: Renderer-specific configuration.
:type config: mapping-like interface.
"""
try:
width = int(config['width'])
height = int(config['height'])
gl_major, gl_minor = [
int(v) for v in config.get('openglversion', '3.3').split('.')
]
except (KeyError, TypeError, ValueError) as err:
raise ConfigError(err)
# create a SDL window
self.win = sdl.SDL_CreateWindow(b'Surviveler',
sdl.SDL_WINDOWPOS_CENTERED,
sdl.SDL_WINDOWPOS_CENTERED, width,
height, sdl.SDL_WINDOW_OPENGL)
if self.win is None:
raise RuntimeError('failed to create SDL window')
# create an OpenGL context
sdl.SDL_GL_SetAttribute(sdl.SDL_GL_CONTEXT_PROFILE_MASK,
sdl.SDL_GL_CONTEXT_PROFILE_CORE)
sdl.SDL_GL_SetAttribute(sdl.SDL_GL_CONTEXT_MAJOR_VERSION, gl_major)
sdl.SDL_GL_SetAttribute(sdl.SDL_GL_CONTEXT_MINOR_VERSION, gl_minor)
sdl.SDL_GL_SetAttribute(sdl.SDL_GL_DOUBLEBUFFER, 1)
sdl.SDL_GL_SetAttribute(sdl.SDL_GL_DEPTH_SIZE, 24)
self.ctx = sdl.SDL_GL_CreateContext(self.win)
if self.ctx is None:
sdl.SDL_DestroyWindow(self.win)
raise RuntimeError('failed to initialize OpenGL context')
# initialize renderer
renderer_init()
self._width = width
self._height = height
LOG.info('renderer initialized; created {}x{} window'.format(
width, height))
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 setup(title="SDL window", width=640, height=480):
''' creates and SDL window and context '''
if sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING):
print('\x1b[0;37;41m' + sdl2.SDL_GetError() + '\x1b[0m')
sdl2.SDL_Quit()
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_MAJOR_VERSION, 3)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_MINOR_VERSION, 3)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_PROFILE_MASK,
sdl2.SDL_GL_CONTEXT_PROFILE_CORE)
window = sdl2.SDL_CreateWindow(title, sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED, width, height,
sdl2.SDL_WINDOW_OPENGL)
context = sdl2.SDL_GL_CreateContext(window)
return window, context
def __buildWindow(self):
if sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) != 0:
raise Exception(sdl2.SDL_GetError())
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_MAJOR_VERSION, self.major)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_MINOR_VERSION, self.minor)
self.window = sdl2.SDL_CreateWindow(b'ETGG2801 Example',
sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED,
self.size[0], self.size[1],
sdl2.SDL_WINDOW_OPENGL)
self.glcontext = sdl2.SDL_GL_CreateContext(self.window)
if not self.glcontext:
sdl2.SDL_DestroyWindow(self.window)
raise Exception(sdl2.SDL_GetError())
# keep application from receiving text input events
sdl2.SDL_StopTextInput()
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_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 initialize(self):
""" Direct translation of the C++ code
"""
if sdl.SDL_Init(sdl.SDL_INIT_EVERYTHING) < 0:
return False
sdl.SDL_GL_SetAttribute(sdl.SDL_GL_DOUBLEBUFFER, 1)
self.window = sdl.SDL_CreateWindow('PySDL2 OpenGL',
sdl.SDL_WINDOWPOS_CENTERED,
sdl.SDL_WINDOWPOS_CENTERED,
WND_SIZE[0], WND_SIZE[1], WND_FLAGS)
if not self.window: return False
self.glcontect = sdl.SDL_GL_CreateContext(self.window)
# Open GL
self.init_gl()
return True
def __buildWindow(self):
if sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) != 0:
raise Exception(sdl2.SDL_GetError())
sdlimage.IMG_Init(sdlimage.IMG_INIT_PNG | sdlimage.IMG_INIT_JPG)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_PROFILE_MASK,
sdl2.SDL_GL_CONTEXT_PROFILE_CORE)
self.window = sdl2.SDL_CreateWindow(b'ETGG2801 Example', 0, 0,
self.size[0], self.size[1],
sdl2.SDL_WINDOW_OPENGL)
self.glcontext = sdl2.SDL_GL_CreateContext(self.window)
if not self.glcontext:
sdl2.SDL_DestroyWindow(self.window)
raise Exception(sdl2.SDL_GetError())
# keep application from receiving text input events
sdl2.SDL_StopTextInput()
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) 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]
phi += d_phi
glPopMatrix()
#Função desenvolvida com ajuda do código desenvolvido pelo Vispy Development Team, disponível no link <https://programtalk.com/vs2/python/13762/vispy/vispy/app/backends/_sdl2.py/>.
def getPosicaoPonteiro():
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)
def run(self) -> int:
"""
Run scene.
This is a complex function and needs some refactoring.
Here is the logic and flow behind this function:
1. Initialize SDL
2. Create SDL window with given parameters enabling OpenGL Pipeline
3. Create and set active context as OpenGL Context
4. Set running flag.
5. Fix aspect ratios of observers *aka cameras* in the scene.
6. Start scene loop.
1. Poll for SDL events
2. React to SDL events *(quit, key press, key up, mouse motion
etc)*
3. Render scene, turn to step 6.1 if not quit
7. Destroy objects and clear memory.
8. Destroy window and such.
"""
if sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) != 0:
return -1
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_MAJOR_VERSION, 3)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_MINOR_VERSION, 3)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_PROFILE_MASK,
sdl2.SDL_GL_CONTEXT_PROFILE_CORE)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_MULTISAMPLEBUFFERS, 1)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_MULTISAMPLESAMPLES, 16)
self.window = sdl2.SDL_CreateWindow(
b"Payton Scene",
sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED,
int(self.window_width),
int(self.window_height),
sdl2.SDL_WINDOW_OPENGL,
) # type: ignore
if not self.window:
return -1
self._context = sdl2.SDL_GL_CreateContext(self.window)
self.event = sdl2.SDL_Event()
self.running = True
# Fix aspect ratios of observers
for observer in self.observers:
observer.aspect_ratio = (self.window_width / self.window_height *
1.0)
for clock in self.clocks:
self.clocks[clock].start()
while self.running:
while sdl2.SDL_PollEvent(ctypes.byref(self.event)) != 0:
self.controller.keyboard(self.event, self)
self.controller.mouse(self.event, self)
self._render()
sdl2.SDL_GL_SwapWindow(self.window)
sdl2.SDL_Delay(1)
for obj in self.objects:
self.objects[obj].destroy()
for clock in self.clocks:
self.clocks[clock].kill()
sdl2.SDL_GL_DeleteContext(self._context)
sdl2.SDL_DestroyWindow(self.window)
self.window = None
sdl2.SDL_Quit()
return 0
def set_configuration(configuration):
""" Set gl configuration """
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_RED_SIZE, configuration.red_size)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_GREEN_SIZE, configuration.green_size)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_BLUE_SIZE, configuration.blue_size)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_ALPHA_SIZE, configuration.alpha_size)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_DEPTH_SIZE, configuration.depth_size)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_STENCIL_SIZE,
configuration.stencil_size)
if configuration.samples:
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_MULTISAMPLEBUFFERS, 1)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_MULTISAMPLESAMPLES,
configuration.samples)
else:
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_MULTISAMPLEBUFFERS, 0)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_MULTISAMPLESAMPLES, 0)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_STEREO, configuration.stereo)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_FRAMEBUFFER_SRGB_CAPABLE,
configuration.srgb)
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,
window_title='hienoi',
window_position=Vector2i(sdl2.SDL_WINDOWPOS_CENTERED,
sdl2.SDL_WINDOWPOS_CENTERED),
window_size=Vector2i(800, 600),
window_flags=sdl2.SDL_WINDOW_RESIZABLE,
view_aperture_x=100.0,
view_zoom_range=Vector2f(1e-6, 1e+6),
mouse_wheel_step=0.01,
grid_density=10.0,
grid_adaptive_threshold=3.0,
show_grid=True,
background_color=Vector4f(0.15, 0.15, 0.15, 1.0),
grid_color=Vector4f(0.85, 0.85, 0.85, 0.05),
grid_origin_color=Vector4f(0.85, 0.25, 0.25, 0.25),
particle_display=ParticleDisplay.DISC,
point_size=4,
edge_feather=2.0,
stroke_width=0.0,
initialize_callback=None,
on_event_callback=None,
renderer=None):
renderer = {} if renderer is None else renderer
if sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) != 0:
raise RuntimeError(sdl2.SDL_GetError().decode())
renderer_info = hienoi.renderer.get_info()
if renderer_info.api == GraphicsAPI.OPENGL:
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_MAJOR_VERSION,
renderer_info.major_version)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_MINOR_VERSION,
renderer_info.minor_version)
if renderer_info.profile == GLProfile.CORE:
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_PROFILE_MASK,
sdl2.SDL_GL_CONTEXT_PROFILE_CORE)
self._handles = _create_handles(window_title, window_position,
window_size, window_flags,
renderer_info)
self._renderer = hienoi.renderer.Renderer(**renderer)
self._initial_view_aperture_x = view_aperture_x
self._view_zoom_range = view_zoom_range
self._mouse_wheel_step = mouse_wheel_step
self._grid_adaptive_threshold = grid_adaptive_threshold
self._on_event_callback = on_event_callback
self._listen_for_navigation = False
self._is_view_manipulated = False
self.view_position = Vector2f(0.0, 0.0)
self._view_zoom = 1.0
self.grid_density = grid_density
self.show_grid = show_grid
self.background_color = background_color
self.grid_color = grid_color
self.grid_origin_color = grid_origin_color
self.particle_display = particle_display
self.point_size = point_size
self.edge_feather = edge_feather
self.stroke_width = stroke_width
self._navigation_action = NavigationAction.NONE
self.quit = False
self.user_data = UserData()
if initialize_callback:
initialize_callback(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) 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 __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 set_configuration(config):
""" Set gl configuration """
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_RED_SIZE, config.red_size)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_GREEN_SIZE, config.green_size)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_BLUE_SIZE, config.blue_size)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_ALPHA_SIZE, config.alpha_size)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_DEPTH_SIZE, config.depth_size)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_STENCIL_SIZE, config.stencil_size)
if config.samples:
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_MULTISAMPLEBUFFERS, 1)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_MULTISAMPLESAMPLES,
config.samples)
else:
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_MULTISAMPLEBUFFERS, 0)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_MULTISAMPLESAMPLES, 0)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_STEREO, config.stereo)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_FRAMEBUFFER_SRGB_CAPABLE, config.srgb)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_MAJOR_VERSION,
config.major_version)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_MINOR_VERSION,
config.minor_version)
if config.profile == "core":
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_PROFILE_MASK,
sdl2.SDL_GL_CONTEXT_PROFILE_CORE)
elif config.profile == "compatibility":
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_PROFILE_MASK,
sdl2.SDL_GL_CONTEXT_PROFILE_COMPATIBILITY)
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 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 __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]
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) 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
