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, *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, stimDisplayRes,
stimDisplayPosition): #,stimDisplayMirrorChild):
self.stimDisplayRes = stimDisplayRes
# self.stimDisplayMirrorChild = stimDisplayMirrorChild
sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO)
self.stimDisplayRes = stimDisplayRes
self.stimDisplayPosition = stimDisplayPosition
self.Window = sdl2.video.SDL_CreateWindow(
byteify('stimDisplay', "utf-8"), self.stimDisplayPosition[0],
self.stimDisplayPosition[1], self.stimDisplayRes[0],
self.stimDisplayRes[1],
sdl2.SDL_WINDOW_OPENGL | sdl2.SDL_WINDOW_SHOWN
| sdl2.SDL_RENDERER_ACCELERATED | sdl2.SDL_RENDERER_PRESENTVSYNC)
self.glContext = sdl2.SDL_GL_CreateContext(self.Window)
gl.glMatrixMode(gl.GL_PROJECTION)
gl.glLoadIdentity()
gl.glOrtho(0, stimDisplayRes[0], stimDisplayRes[1], 0, 0, 1)
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glDisable(gl.GL_DEPTH_TEST)
gl.glReadBuffer(gl.GL_FRONT)
gl.glClearColor(0, 0, 0, 1)
start = time.time()
while time.time() < (start + 2):
sdl2.SDL_PumpEvents()
self.refresh()
self.refresh()
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, Δ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, shader_programs=None, version=(3, 3)):
if sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) != 0:
print(sdl2.SDL_GetError())
return -1
self.window = sdl2.SDL_CreateWindow(b"SDL2 OpenGL Context",
sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED,
self.viewport[2], self.viewport[3],
sdl2.SDL_WINDOW_OPENGL)
if not self.window:
print(sdl2.SDL_GetError())
return -1
# Force OpenGL 3.3 'core' context.
# Must set *before* creating GL context!
video.SDL_GL_SetAttribute(video.SDL_GL_CONTEXT_MAJOR_VERSION,
version[0])
video.SDL_GL_SetAttribute(video.SDL_GL_CONTEXT_MINOR_VERSION,
version[1])
video.SDL_GL_SetAttribute(video.SDL_GL_CONTEXT_PROFILE_MASK,
video.SDL_GL_CONTEXT_PROFILE_CORE)
self.context = sdl2.SDL_GL_CreateContext(self.window)
self.update()
def __init__(self, width, height, title):
self.width, self.height = width, height
self.title = title
if sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) != 0:
print(sdl2.SDL_GetError())
exit(-1)
self.window = sdl2.SDL_CreateWindow(
str.encode(self.title), sdl2.SDL_WINDOWPOS_CENTERED,
sdl2.SDL_WINDOWPOS_CENTERED, self.width, self.height,
sdl2.SDL_WINDOW_OPENGL | sdl2.SDL_WINDOW_SHOWN)
if not self.window:
print(sdl2.SDL_GetError())
exit(-1)
# Force OpenGL 4.3 'core' context. This is needed for compute shader support.
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4)
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3)
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK,
SDL_GL_CONTEXT_PROFILE_CORE)
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8)
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8)
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8)
SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8)
SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 32)
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24)
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1)
self._context = sdl2.SDL_GL_CreateContext(self.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) 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, **kwargs):
super().__init__(**kwargs)
if sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) != 0:
raise ValueError("Failed to initialize sdl2")
# Configure OpenGL context
sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_MAJOR_VERSION,
self.gl_version[0])
sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_MINOR_VERSION,
self.gl_version[1])
sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_PROFILE_MASK,
sdl2.SDL_GL_CONTEXT_PROFILE_CORE)
sdl2.video.SDL_GL_SetAttribute(
sdl2.SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG, 1)
sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_DOUBLEBUFFER, 1)
sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_DEPTH_SIZE, 24)
# Display/hide mouse cursor
sdl2.SDL_ShowCursor(
sdl2.SDL_ENABLE if self.cursor else sdl2.SDL_DISABLE)
# Configure multisampling
if self.samples > 1:
sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_MULTISAMPLEBUFFERS, 1)
sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_MULTISAMPLESAMPLES,
self.samples)
# Built the window flags
flags = sdl2.SDL_WINDOW_OPENGL
if self.fullscreen:
# Use primary desktop screen resolution
flags |= sdl2.SDL_WINDOW_FULLSCREEN_DESKTOP
else:
if self.resizable:
flags |= sdl2.SDL_WINDOW_RESIZABLE
# Create the window
self.window = sdl2.SDL_CreateWindow(
self.title.encode(),
sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED,
self.width,
self.height,
flags,
)
if not self.window:
raise ValueError("Failed to create window:", sdl2.SDL_GetError())
self.context = sdl2.SDL_GL_CreateContext(self.window)
sdl2.video.SDL_GL_SetSwapInterval(1 if self.vsync else 0)
self.ctx = moderngl.create_context(require=self.gl_version_code)
self.set_default_viewport()
self.print_context_info()
def __init__(self):
"""
Initializes sdl2, sets up key and mouse events and
creates a ``moderngl.Context`` using the context sdl2 createad.
Using the sdl2 window requires sdl binaries and PySDL2.
"""
super().__init__()
self.window_closing = False
self.tmp_size_x = c_int()
self.tmp_size_y = c_int()
print("Using sdl2 library version:", self.get_library_version())
if sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) != 0:
raise ValueError("Failed to initialize sdl2")
sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_MAJOR_VERSION,
self.gl_version.major)
sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_MINOR_VERSION,
self.gl_version.minor)
sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_PROFILE_MASK,
sdl2.SDL_GL_CONTEXT_PROFILE_CORE)
sdl2.video.SDL_GL_SetAttribute(
sdl2.SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG, 1)
sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_DOUBLEBUFFER, 1)
sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_DEPTH_SIZE, 24)
sdl2.SDL_ShowCursor(
sdl2.SDL_ENABLE if self.cursor else sdl2.SDL_DISABLE)
if self.samples > 1:
sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_MULTISAMPLEBUFFERS, 1)
sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_MULTISAMPLESAMPLES,
self.samples)
flags = sdl2.SDL_WINDOW_OPENGL
if self.fullscreen:
flags |= sdl2.SDL_WINDOW_FULLSCREEN_DESKTOP
else:
if self.resizable:
flags |= sdl2.SDL_WINDOW_RESIZABLE
self.window = sdl2.SDL_CreateWindow(self.title.encode(),
sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED,
self.width, self.height, flags)
if not self.window:
raise ValueError("Failed to create window:", sdl2.SDL_GetError())
self.context = sdl2.SDL_GL_CreateContext(self.window)
sdl2.video.SDL_GL_SetSwapInterval(1 if self.vsync else 0)
self.ctx = moderngl.create_context(require=self.gl_version.code)
context.WINDOW = self
self.fbo = self.ctx.screen
self.set_default_viewport()
def __init__(self, **kwargs):
super().__init__(**kwargs)
if sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) != 0:
raise ValueError("Failed to initialize sdl2")
sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_MAJOR_VERSION,
self.gl_version[0])
sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_MINOR_VERSION,
self.gl_version[1])
sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_PROFILE_MASK,
sdl2.SDL_GL_CONTEXT_PROFILE_CORE)
sdl2.video.SDL_GL_SetAttribute(
sdl2.SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG, 1)
sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_DOUBLEBUFFER, 1)
sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_DEPTH_SIZE, 24)
sdl2.SDL_ShowCursor(
sdl2.SDL_ENABLE if self.cursor else sdl2.SDL_DISABLE)
if self.samples > 1:
sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_MULTISAMPLEBUFFERS, 1)
sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_MULTISAMPLESAMPLES,
self.samples)
flags = sdl2.SDL_WINDOW_OPENGL
if self.fullscreen:
flags |= sdl2.SDL_WINDOW_FULLSCREEN_DESKTOP
else:
if self.resizable:
flags |= sdl2.SDL_WINDOW_RESIZABLE
self._window = sdl2.SDL_CreateWindow(
self.title.encode(),
sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED,
self.width,
self.height,
flags,
)
if not self._window:
raise ValueError("Failed to create window:", sdl2.SDL_GetError())
self._context = sdl2.SDL_GL_CreateContext(self._window)
sdl2.video.SDL_GL_SetSwapInterval(1 if self.vsync else 0)
if self._create_mgl_context:
self.init_mgl_context()
self.set_default_viewport()
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 __init__(self):
self.shaderID = 0
self.vaoID = 0
if sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) != 0:
print(sdl2.SDL_GetError())
return -1
self.window = sdl2.SDL_CreateWindow(b"OpenGL demo",
sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED, 1024,
720, sdl2.SDL_WINDOW_OPENGL)
if not self.window:
print(sdl2.SDL_GetError())
return -1
# Force OpenGL 4.1 'core' context.
sdl2.video.SDL_GL_SetAttribute(sdl2.video.SDL_GL_CONTEXT_MAJOR_VERSION,
4)
sdl2.video.SDL_GL_SetAttribute(sdl2.video.SDL_GL_CONTEXT_MINOR_VERSION,
1)
sdl2.video.SDL_GL_SetAttribute(sdl2.video.SDL_GL_CONTEXT_PROFILE_MASK,
sdl2.video.SDL_GL_CONTEXT_PROFILE_CORE)
self.context = sdl2.SDL_GL_CreateContext(self.window)
glClearColor(0.4, 0.4, 0.4, 1.0)
glEnable(GL_DEPTH_TEST)
glEnable(GL_MULTISAMPLE)
self.createTriangle(0.8)
vertex = """#version 400 core
layout (location = 0) in vec3 inPosition;
layout (location = 1) in vec3 inColour;
out vec3 vertColour;
void main()
{
gl_Position = vec4(inPosition, 1.0);
vertColour = inColour;
}"""
fragment = """#version 400 core
in vec3 vertColour;
out vec4 fragColour;
void main()
{
fragColour = vec4(vertColour,1.0);
}
"""
self.loadShaderFromStrings(vertex, fragment)
self.width = 1024
self.height = 720
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 __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 run():
if sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) != 0:
print(sdl2.SDL_GetError())
return -1
window = sdl2.SDL_CreateWindow(b"OpenGL demo",
sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED, 800, 600,
sdl2.SDL_WINDOW_OPENGL)
if not window:
print(sdl2.SDL_GetError())
return -1
context = sdl2.SDL_GL_CreateContext(window)
GL.glMatrixMode(GL.GL_PROJECTION | GL.GL_MODELVIEW)
GL.glLoadIdentity()
GL.glOrtho(-400, 400, 300, -300, 0, 1)
x = 0.0
y = 30.0
event = sdl2.SDL_Event()
running = True
while running:
while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0:
if event.type == sdl2.SDL_QUIT:
running = False
GL.glClearColor(0, 0, 0, 1)
GL.glClear(GL.GL_COLOR_BUFFER_BIT)
GL.glRotatef(10.0, 0.0, 0.0, 1.0)
GL.glBegin(GL.GL_TRIANGLES)
GL.glColor3f(1.0, 0.0, 0.0)
GL.glVertex2f(x, y + 90.0)
GL.glColor3f(0.0, 1.0, 0.0)
GL.glVertex2f(x + 90.0, y - 90.0)
GL.glColor3f(0.0, 0.0, 1.0)
GL.glVertex2f(x - 90.0, y - 90.0)
GL.glEnd()
sdl2.SDL_GL_SwapWindow(window)
sdl2.SDL_Delay(10)
sdl2.SDL_GL_DeleteContext(context)
sdl2.SDL_DestroyWindow(window)
sdl2.SDL_Quit()
return 0
def __enter__(self):
sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO)
self.window = sdl2.SDL_CreateWindow(
b'Shadertest',
sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED,
1,
1,
sdl2.SDL_WINDOW_OPENGL,
)
sdl2.video.SDL_GL_SetAttribute(sdl2.video.SDL_GL_CONTEXT_MAJOR_VERSION, 4)
sdl2.video.SDL_GL_SetAttribute(sdl2.video.SDL_GL_CONTEXT_MINOR_VERSION, 2)
sdl2.video.SDL_GL_SetAttribute(
sdl2.video.SDL_GL_CONTEXT_PROFILE_MASK,
sdl2.video.SDL_GL_CONTEXT_PROFILE_CORE,
)
self.context = sdl2.SDL_GL_CreateContext(self.window)
def main():
global rend
if sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) != 0:
print(sdl2.SDL_GetError())
return 0
x, y = 0, 0
# window = sdl2.ext.Window("ekkek", 600,600, sdl2.SDL_WINDOW_OPENGL)
window = sdl2.SDL_CreateWindow(TITLE, sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED, 600, 600,
sdl2.SDL_WINDOW_OPENGL)
context = sdl2.SDL_GL_CreateContext(window)
rend = Renderer()
time = sdl2.SDL_GetTicks()
prev_time = sdl2.SDL_GetTicks()
frame_time = 0
e = ioproc(sdl2.SDL_Event())
dt = 1000. / 60.
#while sdl2.SDL_WaitEvent(ctypes.byref(sdl2.SDL_QUIT)):
while e.checkEvents():
# time = sdl2.SDL_GetTicks()
# frame_time = time - prev_time
# prev_time = time
# while sdl2.SDL_PollEvent(ctypes.byref(e)) !=0:
# if(e.type == sdl2.SDL_QUIT):
# running = False
time += dt
frame_time = time - sdl2.SDL_GetTicks()
if (frame_time <= 0):
frame_time = 1
tms.sleep(frame_time / 1000.)
# update shit here
# ...
rend.doShit()
rend.draw()
sdl2.SDL_GL_SwapWindow(window)
# rend.unload() #Unload assimp imports
sdl2.SDL_GL_DeleteContext(context)
sdl2.SDL_Quit()
def __init__(self,
width,
height,
title='Window',
alpha_blending=True,
full_screen=False,
gl_major=4,
gl_minor=1):
self._width = width
self._height = height
self._aspect_ratio = float(width) / float(height)
self._viewport = Rect(0, 0, width, height)
self._full_screen = full_screen
# Create the window
if sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) != 0:
print(sdl2.SDL_GetError())
self._window = sdl2.SDL_CreateWindow(str.encode(title),
sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED,
width, height,
sdl2.SDL_WINDOW_OPENGL)
if not self._window:
print(sdl2.SDL_GetError())
return
# Set up OpenGL
video.SDL_GL_SetAttribute(video.SDL_GL_CONTEXT_MAJOR_VERSION, gl_major)
video.SDL_GL_SetAttribute(video.SDL_GL_CONTEXT_MINOR_VERSION, gl_minor)
video.SDL_GL_SetAttribute(video.SDL_GL_CONTEXT_PROFILE_MASK,
video.SDL_GL_CONTEXT_PROFILE_CORE)
self._context = sdl2.SDL_GL_CreateContext(self._window)
self._projection_matrix = self._ortho_projection()
if alpha_blending:
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
if full_screen:
self.full_screen = True
# Post processing steps
self._pp_steps = []
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 run():
if sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) != 0:
print(sdl2.SDL_GetError())
return -1
window = sdl2.SDL_CreateWindow(b"OpenGL demo",
sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED, 800, 600,
sdl2.SDL_WINDOW_OPENGL)
if not window:
print(sdl2.SDL_GetError())
return -1
# Force OpenGL 3.3 'core' context.
# Must set *before* creating GL context!
video.SDL_GL_SetAttribute(video.SDL_GL_CONTEXT_MAJOR_VERSION, 3)
video.SDL_GL_SetAttribute(video.SDL_GL_CONTEXT_MINOR_VERSION, 3)
video.SDL_GL_SetAttribute(video.SDL_GL_CONTEXT_PROFILE_MASK,
video.SDL_GL_CONTEXT_PROFILE_CORE)
context = sdl2.SDL_GL_CreateContext(window)
# Setup GL shaders, data, etc.
initialize()
event = sdl2.SDL_Event()
running = True
while running:
while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0:
if event.type == sdl2.SDL_QUIT:
running = False
elif (event.type == sdl2.SDL_KEYDOWN
and event.key.keysym.sym == sdl2.SDLK_ESCAPE):
running = False
render()
sdl2.SDL_GL_SwapWindow(window)
sdl2.SDL_Delay(10)
sdl2.SDL_GL_DeleteContext(context)
sdl2.SDL_DestroyWindow(window)
sdl2.SDL_Quit()
return 0
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 __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 _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_gl(self):
"""Set up OpenGL."""
sdl2.video.SDL_GL_SetAttribute(sdl2.video.SDL_GL_CONTEXT_MAJOR_VERSION,
3)
sdl2.video.SDL_GL_SetAttribute(sdl2.video.SDL_GL_CONTEXT_MINOR_VERSION,
1)
sdl2.video.SDL_GL_SetAttribute(sdl2.video.SDL_GL_CONTEXT_PROFILE_MASK,
sdl2.video.SDL_GL_CONTEXT_PROFILE_CORE)
sdl2.video.SDL_GL_SetAttribute(sdl2.video.SDL_GL_DOUBLEBUFFER, 1)
self._gl_context = sdl2.SDL_GL_CreateContext(self._window.window)
GL.glClearColor(0, 0, 0, 1)
GL.glEnable(GL.GL_DEPTH_TEST)
GL.glDepthMask(GL.GL_TRUE)
GL.glDepthFunc(GL.GL_LEQUAL)
GL.glDepthRange(0, 1)
GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)
GL.glEnable(GL.GL_BLEND)
GL.glEnable(GL.GL_CULL_FACE)
GL.glCullFace(GL.GL_BACK)
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 main():
if len(sys.argv) != 2:
print("usage: 3dwf.py REMOTE_ADDRESS", file=sys.stderr)
sys.exit(1)
nbins = 256
overlap = 192
rem_address = (sys.argv[1], 3731)
conn = socket.create_connection(rem_address)
sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO | sdl2.SDL_INIT_AUDIO)
window = sdl2.SDL_CreateWindow(b"3D Waterfall", sdl2.SDL_WINDOWPOS_CENTERED,
sdl2.SDL_WINDOWPOS_CENTERED, 800, 600,
sdl2.SDL_WINDOW_RESIZABLE | sdl2.SDL_WINDOW_OPENGL)
context = sdl2.SDL_GL_CreateContext(window)
wf = WFViewer(nbins)
wf.init(800, 600)
wf.shift = 0
filt = interp_fir_filter(lowpass(np.pi / 4, 512) * np.hamming(512), 4)
freqx = freq_translator((0.8/8.0) * np.pi)
headlen = max(filt.nhistory, overlap)
ringbuf = RingBuf(headlen, np.zeros(headlen + (nbins - overlap) * 512, dtype=np.complex64))
# FIXME
global audio_edge
audio_edge = 0
def callback(unused, buf, buflen):
global audio_edge
bufbuf = pybuf_from_memory(buf, buflen, 0x200) # PyBUF_WRITE
array = np.frombuffer(bufbuf, np.float32)
assert len(array) % filt.interp == 0 # TODO
nreqframes = len(array) // filt.interp
loc_ringbuf_edge = ringbuf.fill_edge
if loc_ringbuf_edge < 0 or (loc_ringbuf_edge - audio_edge) % len(ringbuf) < nreqframes:
print("audio underrun", file=sys.stderr)
array.fill(0)
return
# TODO
if audio_edge + nreqframes > len(ringbuf):
audio_edge = 0
slic = ringbuf.slice(audio_edge - filt.nhistory, audio_edge + nreqframes)
array[:] = np.real(freqx(filt(slic))) * wf.volume
audio_edge += nreqframes
sdl2.SDL_PushEvent(UPDATE_EVENT)
audio_spec = sdl2.SDL_AudioSpec(8000,
sdl2.AUDIO_F32,
1,
512,
sdl2.SDL_AudioCallback(callback))
audio_dev = sdl2.SDL_OpenAudioDevice(None, 0, audio_spec, None, 0)
if audio_dev == 0:
raise Error('could not open audio device')
err_queue = queue.Queue()
def readfunc(nbytes):
bytes = b''
while len(bytes) < nbytes:
ret = conn.recv(nbytes - len(bytes))
if not ret:
raise Exception('end of stream')
bytes += ret
return bytes
def thread_target():
try:
input_thread(readfunc, ringbuf, nbins, overlap, wf)
except Exception as e:
err_queue.put(e)
event = sdl2.SDL_Event()
event.type = sdl2.SDL_QUIT
sdl2.SDL_PushEvent(event)
other_thread = threading.Thread(target=thread_target)
other_thread.setDaemon(True)
other_thread.start()
sdl2.SDL_PauseAudioDevice(audio_dev, 0)
running = True
event = sdl2.SDL_Event()
while running:
sdl2.SDL_WaitEvent(ctypes.byref(event))
while True:
if event.type == sdl2.SDL_QUIT:
running = False
break
wf.event(event)
if sdl2.SDL_PollEvent(ctypes.byref(event)) == 0:
break
# FIXME
wf.shift = ((ringbuf.fill_edge - audio_edge) % len(ringbuf)) / (nbins - overlap)
wf.draw()
sdl2.SDL_GL_SwapWindow(window)
try:
for exc in iter(err_queue.get_nowait, None):
sdl2.SDL_ShowSimpleMessageBox(sdl2.SDL_MESSAGEBOX_ERROR, b"Exception", str(exc).encode("ascii"), None)
except queue.Empty:
pass
sdl2.SDL_CloseAudioDevice(audio_dev)
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) 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 run():
if sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) != 0:
print(sdl2.SDL_GetError())
return -1
window = sdl2.SDL_CreateWindow(b"OpenGL demo",
sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED, 800, 600,
sdl2.SDL_WINDOW_OPENGL)
if not window:
print(sdl2.SDL_GetError())
return -1
# Force OpenGL 3.3 'core' context.
# Must set *before* creating GL context!
video.SDL_GL_SetAttribute(video.SDL_GL_CONTEXT_MAJOR_VERSION, 3)
video.SDL_GL_SetAttribute(video.SDL_GL_CONTEXT_MINOR_VERSION, 3)
video.SDL_GL_SetAttribute(video.SDL_GL_CONTEXT_PROFILE_MASK,
video.SDL_GL_CONTEXT_PROFILE_CORE)
context = sdl2.SDL_GL_CreateContext(window)
quad = [
-0.5, -0.5, 0.0, 1.0, 0.0, 0.0, 0.5, -0.5, 0.0, 0.0, 1.0, 0.0, 0.5,
0.5, 0.0, 0.0, 0.0, 1.0, -0.5, 0.5, 0.0, 1.0, 1.0, 1.0
]
quad = numpy.array(quad, dtype=numpy.float32)
indices = [0, 1, 2, 2, 3, 0]
indices = numpy.array(indices, dtype=numpy.uint32)
# Setup GL shaders, data, etc.
vertex_shader = shaders.compileShader(
"""
#version 330
in vec3 position;
in vec3 color;
out vec3 newColor;
void main()
{
gl_Position = vec4(position, 1.0f);
newColor = color;
}
""", GL.GL_VERTEX_SHADER)
fragment_shader = shaders.compileShader(
"""
#version 330
in vec3 newColor;
out vec4 outColor;
void main()
{
outColor = vec4(newColor, 1.0f);
}
""", GL.GL_FRAGMENT_SHADER)
shaderProgram = shaders.compileProgram(vertex_shader, fragment_shader)
GL.glUseProgram(shaderProgram)
VAO = GL.glGenVertexArrays(1)
GL.glBindVertexArray(VAO)
# Need VBO for triangle vertices and colours
VBO = GL.glGenBuffers(1)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, VBO)
GL.glBufferData(GL.GL_ARRAY_BUFFER, 96, quad, GL.GL_STATIC_DRAW)
EBO = GL.glGenBuffers(1)
GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, EBO)
GL.glBufferData(GL.GL_ELEMENT_ARRAY_BUFFER, 24, indices, GL.GL_STATIC_DRAW)
position = GL.glGetAttribLocation(shaderProgram, "position")
GL.glVertexAttribPointer(position, 3, GL.GL_FLOAT, GL.GL_FALSE, 24,
ctypes.c_void_p(0))
GL.glEnableVertexAttribArray(position)
color = GL.glGetAttribLocation(shaderProgram, "color")
GL.glVertexAttribPointer(color, 3, GL.GL_FLOAT, GL.GL_FALSE, 24,
ctypes.c_void_p(12))
GL.glEnableVertexAttribArray(color)
event = sdl2.SDL_Event()
running = True
GL.glClearColor(0, 0, 0, 1)
while running:
while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0:
if event.type == sdl2.SDL_QUIT:
running = False
try:
GL.glClear(GL.GL_COLOR_BUFFER_BIT)
GL.glDrawElements(GL.GL_TRIANGLES, 6, GL.GL_UNSIGNED_INT, None)
finally:
GL.glUseProgram(0)
sdl2.SDL_GL_SwapWindow(window)
sdl2.SDL_Delay(10)
sdl2.SDL_GL_DeleteContext(context)
sdl2.SDL_DestroyWindow(window)
sdl2.SDL_Quit()
return 0
