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