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