def initOpenGLMatrix(self):
# FROM http://code.activestate.com/recipes/325391-open-a-glut-window-and-draw-a-sphere-using-pythono/
glut.glutInit(sys.argv)
glut.glutInitDisplayMode(glut.GLUT_RGBA | glut.GLUT_DOUBLE | glut.GLUT_DEPTH)
glut.glutInitWindowSize(400, 400)
glut.glutCreateWindow(b'PyTowerDefense')
gl.glClearColor(0., 0., 0., 1.)
gl.glShadeModel(gl.GL_SMOOTH)
gl.glEnable(gl.GL_CULL_FACE)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_LIGHTING)
gl.lightZeroPosition = [100., 40., 100., 1.]
gl.lightZeroColor = [0.8, 1.0, 0.8, 1.0] #green tinged
gl.glLightfv(gl.GL_LIGHT0, gl.GL_POSITION, gl.lightZeroPosition)
gl.glLightfv(gl.GL_LIGHT0, gl.GL_DIFFUSE, gl.lightZeroColor)
gl.glLightf(gl.GL_LIGHT0, gl.GL_CONSTANT_ATTENUATION, 0.01)
gl.glLightf(gl.GL_LIGHT0, gl.GL_LINEAR_ATTENUATION, 0.005)
gl.glEnable(gl.GL_LIGHT0)
glut.glutDisplayFunc(self.paint)
glut.glutIdleFunc(self.repaint)
gl.glMatrixMode(gl.GL_PROJECTION)
glu.gluPerspective(30., 1., 1., 1000.)
gl.glMatrixMode(gl.GL_MODELVIEW)
self._eyePosition = Point3D("Camera Eye Location").translate(0, 0, 400)
self._watchingPosition = Point3D("Camera Watching Position")
self._upVector = Point3D("Camera Up Vector").translate(0, 1, 0)
glu.gluLookAt(self._eyePosition.x, self._eyePosition.y, self._eyePosition.z,
self._watchingPosition.x, self._watchingPosition.y, self._watchingPosition.z,
self._upVector.x, self._upVector.y, self._upVector.z)
gl.glPushMatrix()
return
def _main(argv):
GLUT.glutInit(argv)
GLUT.glutCreateWindow(str.encode(sys.argv[0]))
interaction_m = InteractionMatrix()
interaction_m.add_translation(1, 2, 3)
interaction_m.add_rotation(30, 0, 0, 1)
interaction_m.add_translation(1, 2, 3)
def __init__(self):
"""
Initialize and create GLUT window
"""
glut.glutInit(sys.argv)
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA
| glut.GLUT_DEPTH)
glut.glutCreateWindow("OpenGL")
glut.glutFullScreen()
gl.glEnable(gl.GL_TEXTURE_2D)
gl.glDisable(gl.GL_LIGHTING)
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
# Modify matrices for screen size
width = glut.glutGet(glut.GLUT_SCREEN_WIDTH)
height = glut.glutGet(glut.GLUT_SCREEN_HEIGHT)
gl.glViewport(0, 0, width, height)
gl.glMatrixMode(gl.GL_PROJECTION)
aspect = width / height
gl.glOrtho(-aspect, aspect, 1, -1, -1, 1)
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glLoadIdentity()
def main():
global calib, cyl
src_dir = os.path.split(os.path.abspath(__file__))[0]
data_dir = os.path.join(src_dir, '..', 'data')
pmat = np.loadtxt(os.path.join(data_dir, 'cameramatrix.txt'))
calib = decompose(pmat)
width = 752
height = 480
glut.glutInit()
glut.glutInitWindowSize(width, height)
glut.glutInitDisplayMode(glut.GLUT_RGBA | glut.GLUT_DEPTH | glut.GLUT_ACCUM
| glut.GLUT_DOUBLE)
glut.glutCreateWindow("calib_test_pyopengl")
cyl = PointCylinder()
if 1:
# compose view matrix
r = get_gluLookAt(pmat)
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glLoadIdentity()
glu.gluLookAt(*r['all_args'])
gl.glDisable(gl.GL_DEPTH_TEST)
glut.glutDisplayFunc(on_draw)
on_resize(width, height)
glut.glutMainLoop()
def __init__(self, width=640, height=480, fullscreen=False, aspect=None):
self.gl = gl
glut.glutInit(sys.argv)
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGB
| glut.GLUT_DEPTH)
glut.glutInitWindowPosition(0, 0)
glut.glutCreateWindow(b"BlitzLoop Karaoke")
if not fullscreen:
glut.glutReshapeWindow(width, height)
else:
glut.glutSetCursor(glut.GLUT_CURSOR_NONE)
BaseDisplay.__init__(self, width, height, fullscreen, aspect)
self._on_reshape(width, height)
if fullscreen:
self.saved_size = (width, height)
glut.glutFullScreen()
glut.glutDisplayFunc(self._render)
glut.glutIdleFunc(self._render)
glut.glutReshapeFunc(self._on_reshape)
glut.glutKeyboardFunc(self._on_keyboard)
glut.glutSpecialFunc(self._on_keyboard)
try:
glut.glutSetOption(glut.GLUT_ACTION_ON_WINDOW_CLOSE,
glut.GLUT_ACTION_GLUTMAINLOOP_RETURNS)
print("Using FreeGLUT mainloop return feature")
except:
pass
self._initialize()
def __init__(self,
world,
title='',
height=500,
width=500):
self.world = world
self.time_interval = 10
GLUT.glutInit(sys.argv)
self.lastTime = GLUT.glutGet(GLUT.GLUT_ELAPSED_TIME)
GLUT.glutInitDisplayMode(GLUT.GLUT_DOUBLE |
GLUT.GLUT_RGB |
GLUT.GLUT_DEPTH)
GLUT.glutInitWindowSize(height, width)
GLUT.glutCreateWindow(title)
GLUT.glutDisplayFunc(self.render)
GLUT.glutReshapeFunc(self.onSize)
self.init = False
#initialized to actual values in setupView
self.viewport_left = 0
self.viewport_bottom = 0
self.viewport_height = 0
self.viewport_width = 0
self.timeStep = 1
self.timeElapsed = self.time_interval / 1000.0
def main(self):
self.location = np.array([0.0,0.0,1500.0])
self.focus = np.array([0.0,0.0,0.0])
self.up = np.array([1.0,0.0,0.0])
self.mousex = 0
self.mousey = 0
self.mouse_drag = gl.GL_FALSE
# Wire up GL
glut.glutInit(sys.argv)
glut.glutInitDisplayMode(glut.GLUT_RGB | glut.GLUT_DOUBLE | glut.GLUT_DEPTH)
glut.glutInitWindowSize(500,500)
glut.glutInitWindowPosition(10,10)
glut.glutCreateWindow("Laspy+OpenGL Pointcloud")
glut.glutDisplayFunc(self.display)
glut.glutReshapeFunc(self.reshape)
glut.glutMouseFunc(self.mouse)
glut.glutMotionFunc(self.mouse_motion)
glut.glutKeyboardFunc(self.keyboard)
gl.glClearColor(0.0,0.0,0.0,1.0)
glut.glutTimerFunc(10,self.timerEvent,1)
glut.glutMainLoop()
return 0
def main():
global wmngr_glut
###################
# GLUT Window Initialization
glut.glutInit()
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGB
| glut.GLUT_DEPTH) # zBuffer
glut.glutInitWindowSize(600, 600)
glut.glutInitWindowPosition(100, 100)
glut.glutCreateWindow("Simple GLUT")
# Register callbacks
glut.glutReshapeFunc(reshape)
glut.glutDisplayFunc(display)
glut.glutMouseFunc(mouse)
glut.glutMotionFunc(motion)
glut.glutKeyboardFunc(keyboard)
glut.glutSpecialFunc(special)
glut.glutIdleFunc(idle)
wmngr_glut = dfm2.gl.glut.WindowManagerGLUT(0.3)
dfm2.gl.setSomeLighting()
####
# Turn the flow of control over to GLUT
glut.glutMainLoop()
def main():
glut.glutInit(sys.argv)
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGB | glut.GLUT_DEPTH)
glut.glutInitWindowSize(400,400)
glut.glutCreateWindow("teapot")
gl.glClearColor(0.,0.,0.,1.)
gl.glShadeModel(gl.GL_SMOOTH)
gl.glEnable(gl.GL_CULL_FACE)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_LIGHTING)
lightZeroPosition = [10.,4.,10.,1.]
lightZeroColor = [0.8,1.0,0.8,1.0] #green tinged
gl.glLightfv(gl.GL_LIGHT0, gl.GL_POSITION, lightZeroPosition)
gl.glLightfv(gl.GL_LIGHT0, gl.GL_DIFFUSE, lightZeroColor)
gl.glLightf(gl.GL_LIGHT0, gl.GL_CONSTANT_ATTENUATION, 0.1)
gl.glLightf(gl.GL_LIGHT0, gl.GL_LINEAR_ATTENUATION, 0.05)
gl.glEnable(gl.GL_LIGHT0)
glut.glutDisplayFunc(display)
gl.glMatrixMode(gl.GL_PROJECTION)
glu.gluPerspective(40.,1.,1.,40.)
gl.glMatrixMode(gl.GL_MODELVIEW)
glu.gluLookAt(0,0,10,
0,0,0,
0,1,0)
gl.glPushMatrix()
glut.glutMainLoop()
return
def visualizeGraph(V1,G1,C1,S1):
#Assign
global V
global G
global C
global S
V = V1
G = G1
C = C1
S = S1
#Take Log
S = numpy.log(S + 1)
#Init Glut
glut.glutInit(sys.argv)
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGB | glut.GLUT_DEPTH)
glut.glutInitWindowSize(1024,1024)
glut.glutCreateWindow("Visualize (GLUT)")
glut.glutDisplayFunc(on_display)
glut.glutKeyboardFunc(on_keyboard)
glut.glutReshapeFunc(on_reshape);
#Lookat
gluLookAt(0,12,0, 0,0,0, 0,0,1);
#Idle function
glut.glutIdleFunc(on_idle)
glut.glutFullScreen()
glut.glutMainLoop()
def __init__(self, width=640, height=480, fullscreen=False, aspect=None):
self.gl = gl
glut.glutInit(sys.argv)
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGB | glut.GLUT_DEPTH)
glut.glutInitWindowPosition(0, 0)
glut.glutCreateWindow(b"BlitzLoop Karaoke")
if not fullscreen:
glut.glutReshapeWindow(width, height)
else:
glut.glutSetCursor(glut.GLUT_CURSOR_NONE)
BaseDisplay.__init__(self, width, height, fullscreen, aspect)
self._on_reshape(width, height)
if fullscreen:
self.saved_size = (width, height)
glut.glutFullScreen()
glut.glutDisplayFunc(self._render)
glut.glutIdleFunc(self._render)
glut.glutReshapeFunc(self._on_reshape)
glut.glutKeyboardFunc(self._on_keyboard)
glut.glutSpecialFunc(self._on_keyboard)
try:
glut.glutSetOption(glut.GLUT_ACTION_ON_WINDOW_CLOSE, glut.GLUT_ACTION_GLUTMAINLOOP_RETURNS)
print("Using FreeGLUT mainloop return feature")
except:
pass
self._initialize()
def initGLUT(vertex_shade_code, fragment_shader_code, texture_image):
GLUT.glutInit(sys.argv) # argv,argcを渡す
# 表示モード
if texture_image.mode == 'RGB':
GLUT.glutInitDisplayMode(GLUT.GLUT_RGB | GLUT.GLUT_DOUBLE | GLUT.GLUT_DEPTH)
elif texture_image.mode == 'RGBA':
GLUT.glutInitDisplayMode(GLUT.GLUT_RGBA | GLUT.GLUT_DOUBLE | GLUT.GLUT_DEPTH)
else:
# 謎のモード
print(texture_image.mode)
exit()
window_width, window_height = texture_image.size # テクスチャサイズ = ウィンドウサイズ
GLUT.glutInitWindowSize( window_width, window_height )
# the window starts at the upper left corner of the screen
GLUT.glutInitWindowPosition(0, 0)
GLUT.glutCreateWindow( sys.argv[0] )
## The main drawing function.
def draw():
GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT)
GL.glEnable( GL.GL_TEXTURE_2D )
GL.glDrawElements( GL.GL_TRIANGLES, 6, GL.GL_UNSIGNED_SHORT, np.array( indices, np.uint16 ) )
GL.glDisable(GL.GL_TEXTURE_2D)
GLUT.glutSwapBuffers()
GLUT.glutDisplayFunc(draw)
GLUT.glutIdleFunc(drawGLScene) # When we are doing nothing, redraw the scene.
initGL( vertex_shade_code, fragment_shader_code, texture_image ) # Initialize our window.
GLUT.glutMainLoop() # Start Event Processing Engine
def __init__(self,
width: int,
height: int,
title: str,
camera: bool = False):
self.__Daytime = True
self.__enableCamera = camera
glut.glutInit()
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA)
glut.glutInitWindowSize(width, height)
glut.glutInitWindowPosition(0, 0)
glut.glutCreateWindow(title)
glut.glutReshapeFunc(self.__window_resize)
glut.glutDisplayFunc(self.__display)
glut.glutKeyboardFunc(self.__keyboardDown)
glut.glutKeyboardUpFunc(self.__keyboardUp)
glut.glutMotionFunc(self.__mouse_look_clb)
self._create_shader()
self.setSky(True)
glEnable(GL_DEPTH_TEST)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
self.__ElementsList = []
self.__camera = Camera()
self.__lastX = width / 2
self.__lastY = height / 2
self.__first_mouse = True
self.__left = False
self.__right = False
self.__forward = False
self.__backward = False
def main():
window_width = 600
window_height = 600
glut.glutInit(sys.argv)
glut.glutInitDisplayMode(
cast(int, glut.GLUT_RGB) | cast(int, glut.GLUT_SINGLE)
| cast(int, glut.GLUT_DEPTH))
glut.glutInitWindowSize(window_width, window_height) # window size
glut.glutInitWindowPosition(100, 100) # window position
glut.glutCreateWindow("mmdpy") # show window
glut.glutDisplayFunc(display) # draw callback function
# glut.glutIdleFunc(display)
glut.glutReshapeFunc(reshape) # resize callback function
parser = argparse.ArgumentParser(description="MMD model viewer sample.")
parser.add_argument("-p", type=str, help="MMD model file name.")
parser.add_argument("-v", type=str, help="MMD motion file name.")
parser.add_argument("--bone",
type=bool,
default=False,
help="Print bone informations.")
args = parser.parse_args()
model_name = args.p
motion_name = args.v
global bone_information
bone_information = args.bone
print(model_name)
print(motion_name)
init(window_width, window_height, model_name, motion_name)
glut.glutTimerFunc(1000 // FPS, event, 0)
glut.glutMainLoop()
def main():
global calib, cyl
src_dir = os.path.split(os.path.abspath(__file__))[0]
data_dir = os.path.join(src_dir,'..','data')
pmat = np.loadtxt( os.path.join(data_dir, 'cameramatrix.txt') )
calib = decompose(pmat)
width = 752
height = 480
glut.glutInit()
glut.glutInitWindowSize(width,height)
glut.glutInitDisplayMode(glut.GLUT_RGBA | glut.GLUT_DEPTH | glut.GLUT_ACCUM | glut.GLUT_DOUBLE)
glut.glutCreateWindow("calib_test_pyopengl");
cyl = PointCylinder()
if 1:
# compose view matrix
r = get_gluLookAt(pmat)
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glLoadIdentity()
glu.gluLookAt( *r['all_args'] )
gl.glDisable(gl.GL_DEPTH_TEST)
glut.glutDisplayFunc(on_draw)
on_resize(width,height)
glut.glutMainLoop()
def init(self):
if not self.__is_initialized:
self.__is_initialized = True
sys.argv = glut.glutInit(sys.argv)
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA | glut.GLUT_DEPTH)
self.__windowsize = (400,400)
glut.glutInitWindowSize(self.__windowsize[0],self.__windowsize[1])
glut.glutCreateWindow(self.__name)
gl.glShadeModel(gl.GL_SMOOTH)
gl.glEnable(gl.GL_CULL_FACE)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_LIGHTING)
glut.glutDisplayFunc(self.__display)
glut.glutMouseFunc(self.__onMouse)
glut.glutMotionFunc(self.__onMouseMotion)
glut.glutMouseWheelFunc(self.__onWheel)
glut.glutReshapeFunc(self.__onReshape)
self.__onReshape(400,400)
def sleep_forever():
self.__am_slow = False
if not self._window_closed:
print('program complete, but still running visualization...')
while True:
glut.glutMainLoopEvent()
atexit.register(sleep_forever)
def visualizeGraph(V1, G1, C1, S1):
#Assign
global V
global G
global C
global S
V = V1
G = G1
C = C1
S = S1
#Take Log
S = numpy.log(S + 1)
#Init Glut
glut.glutInit(sys.argv)
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGB
| glut.GLUT_DEPTH)
glut.glutInitWindowSize(1024, 1024)
glut.glutCreateWindow("Visualize (GLUT)")
glut.glutDisplayFunc(on_display)
glut.glutKeyboardFunc(on_keyboard)
glut.glutReshapeFunc(on_reshape)
#Lookat
gluLookAt(0, 12, 0, 0, 0, 0, 0, 0, 1)
#Idle function
glut.glutIdleFunc(on_idle)
glut.glutFullScreen()
glut.glutMainLoop()
def __init__(self):
"""
Basic GLUT init and glut function definition.
Notes
-----
`self.render_obj` is initialized here, which is then being used and drawn in `self.display`
"""
glut.glutInit()
glut.glutInitDisplayMode(glut.GLUT_RGBA | glut.GLUT_DOUBLE
| glut.GLUT_DEPTH | glut.GLUT_MULTISAMPLE)
glut.glutCreateWindow('Frightened Glut Rabbit')
glut.glutReshapeWindow(Global.WIDTH, Global.HEIGHT)
glut.glutReshapeFunc(self.reshape)
glut.glutDisplayFunc(self.display)
glut.glutKeyboardFunc(self.keyboard)
glut.glutMouseFunc(self.glutMousePressEvent)
glut.glutMotionFunc(self.glutMouseMoveEvent)
glut.glutTimerFunc(Global.REFRESH_TIMER, self.onTimer,
Global.REFRESH_TIMER)
self.buildProgram()
self.reshape(Global.WIDTH, Global.HEIGHT)
# set object to be rendered
self.render_obj = default_obj()
# For checking if need to swap
self.standalone = True
def main():
GLUT.glutInit(argv)
GLUT.glutInitDisplayMode(GLUT.GLUT_DOUBLE | GLUT.GLUT_RGBA | GLUT.GLUT_DEPTH | GLUT.GLUT_MULTISAMPLE)
larguraTela = GLUT.glutGet(GLUT.GLUT_SCREEN_WIDTH)
alturaTela = GLUT.glutGet(GLUT.GLUT_SCREEN_HEIGHT)
larguraJanela = round(2 * larguraTela / 3)
alturaJanela = round(2 * alturaTela / 3)
GLUT.glutInitWindowSize(larguraJanela, alturaJanela)
GLUT.glutInitWindowPosition(round((larguraTela - larguraJanela) / 2), round((alturaTela - alturaJanela) / 2))
GLUT.glutCreateWindow(janela)
GLUT.glutDisplayFunc(draw)
load()
GL.glEnable(GL.GL_MULTISAMPLE)
GL.glEnable(GL.GL_DEPTH_TEST)
GL.glEnable(GL.GL_TEXTURE_2D)
GL.glClearColor(*corFundo)
GL.glClearDepth(1.0)
GL.glDepthFunc(GL.GL_LESS)
GL.glShadeModel(GL.GL_SMOOTH)
GL.glMatrixMode(GL.GL_PROJECTION)
GLU.gluPerspective(-45, larguraJanela / alturaJanela, 0.1, 100.0)
GL.glTranslatef(0.0, 0.0, -10)
GL.glMatrixMode(GL.GL_MODELVIEW)
GLUT.glutTimerFunc(10, timer, 1)
GLUT.glutMainLoop()
def main():
light_position = (7, 2, 1)
GLUT.glutInit(argv)
GLUT.glutInitDisplayMode(GLUT.GLUT_DOUBLE | GLUT.GLUT_RGBA | GLUT.GLUT_DEPTH | GLUT.GLUT_MULTISAMPLE)
larguraTela = GLUT.glutGet(GLUT.GLUT_SCREEN_WIDTH)
alturaTela = GLUT.glutGet(GLUT.GLUT_SCREEN_HEIGHT)
larguraJanela = round(2 * larguraTela / 3)
alturaJanela = round(2 * alturaTela / 3)
GLUT.glutInitWindowSize(larguraJanela, alturaJanela)
GLUT.glutInitWindowPosition(round((larguraTela - larguraJanela) / 2), round((alturaTela - alturaJanela) / 2))
GLUT.glutCreateWindow(janela)
GLUT.glutReshapeFunc(reshape)
GLUT.glutDisplayFunc(draw)
GLUT.glutMouseFunc(clique)
GL.glShadeModel(GL.GL_SMOOTH)
GL.glMaterialfv(GL.GL_FRONT, GL.GL_AMBIENT, dados[0][0])
GL.glMaterialfv(GL.GL_FRONT, GL.GL_DIFFUSE, dados[0][1])
GL.glMaterialfv(GL.GL_FRONT, GL.GL_SPECULAR, dados[0][2])
GL.glMaterialfv(GL.GL_FRONT, GL.GL_SHININESS, dados[0][3])
GL.glEnable(GL.GL_LIGHTING)
GL.glEnable(GL.GL_LIGHT0)
GL.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION, light_position)
GL.glEnable(GL.GL_MULTISAMPLE)
GL.glEnable(GL.GL_DEPTH_TEST)
GL.glClearColor(*corFundo)
GLU.gluPerspective(45, larguraJanela / alturaJanela, 0.1, 50.0)
GLUT.glutTimerFunc(50, timer, 1)
GLUT.glutMainLoop()
def prepareGLUT(self):
glut.glutInit(sys.argv)
glut.glutInitWindowSize(self.width, self.height)
glut.glutCreateWindow('Sample Shader Heatmap')
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGB)
# glut.glutInitDisplayMode(glut.GLUT_RGB)
glut.glutDisplayFunc(self.display)
glut.glutKeyboardFunc(self.keyPressed)
def window(w=800,h=800,title='light',px=100,py=100):
#glut init
glut.glutInit(sys.argv)
glut.glutInitDisplayMode (glut.GLUT_DOUBLE | glut.GLUT_RGB)
glut.glutInitWindowSize (w, h)
glut.glutInitWindowPosition (px, py)
glut.glutCreateWindow (title)
def window(w=800, h=800, title='light', px=100, py=100):
#glut init
glut.glutInit(sys.argv)
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGB)
glut.glutInitWindowSize(w, h)
glut.glutInitWindowPosition(px, py)
glut.glutCreateWindow(title)
def __init__(self,view_height,winsize=(400,300)):
self.wm = WindowManagerGLUT(view_height)
self.draw_func = None
glut.glutInit()
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGB | glut.GLUT_DEPTH) # zBuffer
glut.glutInitWindowSize(winsize[0], winsize[1])
glut.glutInitWindowPosition(100, 100)
glut.glutCreateWindow("Visualizzatore_2.0")
def init_glut(self):
glut.glutInit()
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA)
glut.glutCreateWindow('')
glut.glutReshapeWindow(self.resolution[0], self.resolution[1])
glut.glutReshapeFunc(self.reshape)
glut.glutDisplayFunc(self.display)
glut.glutKeyboardFunc(self.keyboard)
glut.glutTimerFunc(0, self.timer, 0)
def init_glut():
glut.glutInit()
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA)
glut.glutCreateWindow('')
glut.glutReshapeWindow(RESOLUTION[0], RESOLUTION[1])
glut.glutReshapeFunc(reshape)
glut.glutDisplayFunc(display)
glut.glutKeyboardFunc(keyboard)
glut.glutTimerFunc(0, timer, 0)
def window(self):
glut.glutInit(sys.argv)
glut.glutInitDisplayMode (self.disp_mode)
w,h=self.win_size
glut.glutInitWindowSize (w,h)
px,py=self.win_pos
glut.glutInitWindowPosition (px,py)
glut.glutCreateWindow (self.win_title)
def main():
glut.glutInit()
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA)
glut.glutCreateWindow('Hello world!')
glut.glutReshapeWindow(512, 512)
glut.glutReshapeFunc(reshape)
glut.glutDisplayFunc(display)
glut.glutKeyboardFunc(keyboard)
glut.glutMainLoop()
def __init__(self, geos, vertex_code, fragment_code):
self.time = time.time()
num_vertices = np.sum([len(g) for g in geos])
data = np.zeros(num_vertices, [("position", np.float32, 2),
("color", np.float32, 4)])
cs = []
vs = []
for g in geos:
for c in g.colors:
cs.append(c)
for v in g.vertices:
vs.append(v)
data["color"] = cs
data["position"] = vs
data["position"] = 0.5 * data["position"]
self.data = data
glut.glutInit()
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA)
glut.glutCreateWindow("Hello world!")
glut.glutReshapeWindow(512, 512)
glut.glutReshapeFunc(self.reshape)
glut.glutDisplayFunc(self.display)
glut.glutIdleFunc(self.idle)
glut.glutKeyboardFunc(self.keyboard)
glut.glutMouseFunc(self.mouse)
program = gl.glCreateProgram()
vertex = gl.glCreateShader(gl.GL_VERTEX_SHADER)
fragment = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
gl.glShaderSource(vertex, vertex_code)
gl.glShaderSource(fragment, fragment_code)
gl.glCompileShader(vertex)
gl.glCompileShader(fragment)
gl.glAttachShader(program, vertex)
gl.glAttachShader(program, fragment)
gl.glLinkProgram(program)
gl.glDetachShader(program, vertex)
gl.glDetachShader(program, fragment)
gl.glUseProgram(program)
self.buffer = gl.glGenBuffers(1)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.buffer)
gl.glBufferData(gl.GL_ARRAY_BUFFER, self.data.nbytes, self.data,
gl.GL_DYNAMIC_DRAW)
stride = self.data.strides[0]
offset = ctypes.c_void_p(0)
loc = gl.glGetAttribLocation(program, "position")
gl.glEnableVertexAttribArray(loc)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.buffer)
gl.glVertexAttribPointer(loc, 2, gl.GL_FLOAT, False, stride, offset)
offset = ctypes.c_void_p(self.data.dtype["position"].itemsize)
loc = gl.glGetAttribLocation(program, "color")
gl.glEnableVertexAttribArray(loc)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.buffer)
gl.glVertexAttribPointer(loc, 4, gl.GL_FLOAT, False, stride, offset)
loc = gl.glGetUniformLocation(program, "scale")
gl.glUniform1f(loc, 1.0)
def window(self):
glut.glutInit(sys.argv)
glut.glutInitDisplayMode(self.disp_mode)
w, h = self.win_size
glut.glutInitWindowSize(w, h)
px, py = self.win_pos
glut.glutInitWindowPosition(px, py)
glut.glutCreateWindow(self.win_title)
def init(self):
# Initialize display
global global_init
if not global_init:
glut.glutInit()
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA
| glut.GLUT_DEPTH | glut.GLUT_ALPHA)
glut.glutCreateWindow(b'fbmatrix')
global_init = True
if self.preview or self.raw:
glut.glutReshapeWindow(512, 512)
elif self.emulate:
glut.glutReshapeWindow(1024, 512)
glut.glutReshapeFunc(lambda w, h: self.reshape(w, h))
glut.glutDisplayFunc(lambda: self.display())
glut.glutKeyboardFunc(lambda k, x, y: self.keyboard(k, x, y))
# Primary offscreen framebuffer
self.mainfbo = fbo.FBO(self.columns,
32,
mag_filter=gl.GL_NEAREST,
min_filter=gl.GL_NEAREST)
# Initialize display shader
layoutfile = 'layout.json'
if self.displaytype == 'ws2811':
self.signalgenerator = displays.ws2811.signalgenerator(
layoutfile, supersample=self.supersample)
self.signalgenerator.setTexture(self.mainfbo.getTexture())
elif self.displaytype == 'hub75e':
self.signalgenerator = displays.hub75e.signalgenerator(
columns=self.columns,
rows=self.rows,
supersample=self.supersample,
order=self.order,
oe=self.oe,
extract=self.extract)
self.signalgenerator.setTexture(self.mainfbo.getTexture())
# Emulation shader
if self.emulate or self.preview:
self.texquad = geometry.simple.texquad()
self.texquad.setTexture(self.mainfbo.getTexture())
# Tree emulator
if self.emulate:
self.tree = assembly.tree.tree(layoutfile)
self.tree.setTexture(self.mainfbo.getTexture())
# Render
glut.glutSetCursor(glut.GLUT_CURSOR_NONE)
if not self.raw and not self.preview and not self.emulate:
glut.glutFullScreen()
def __init__(self, geos, vertex_code, fragment_code):
self.time = time.time()
num_vertices = np.sum([len(g) for g in geos])
data = np.zeros(num_vertices, [("position", np.float32, 2),
("color", np.float32, 4)])
cs = []
vs = []
for g in geos:
for c in g.colors:
cs.append(c)
for v in g.vertices:
vs.append(v)
data["color"] = cs
data["position"] = vs
data["position"] = 0.5 * data["position"]
self.data = data
glut.glutInit()
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA)
glut.glutCreateWindow("Hello world!")
glut.glutReshapeWindow(512,512)
glut.glutReshapeFunc(self.reshape)
glut.glutDisplayFunc(self.display)
glut.glutIdleFunc(self.idle)
glut.glutKeyboardFunc(self.keyboard)
glut.glutMouseFunc(self.mouse)
program = gl.glCreateProgram()
vertex = gl.glCreateShader(gl.GL_VERTEX_SHADER)
fragment = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
gl.glShaderSource(vertex, vertex_code)
gl.glShaderSource(fragment, fragment_code)
gl.glCompileShader(vertex)
gl.glCompileShader(fragment)
gl.glAttachShader(program, vertex)
gl.glAttachShader(program, fragment)
gl.glLinkProgram(program)
gl.glDetachShader(program, vertex)
gl.glDetachShader(program, fragment)
gl.glUseProgram(program)
self.buffer = gl.glGenBuffers(1)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.buffer)
gl.glBufferData(gl.GL_ARRAY_BUFFER, self.data.nbytes, self.data, gl.GL_DYNAMIC_DRAW)
stride = self.data.strides[0]
offset = ctypes.c_void_p(0)
loc = gl.glGetAttribLocation(program, "position")
gl.glEnableVertexAttribArray(loc)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.buffer)
gl.glVertexAttribPointer(loc, 2, gl.GL_FLOAT, False, stride, offset)
offset = ctypes.c_void_p(self.data.dtype["position"].itemsize)
loc = gl.glGetAttribLocation(program, "color")
gl.glEnableVertexAttribArray(loc)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.buffer)
gl.glVertexAttribPointer(loc, 4, gl.GL_FLOAT, False, stride, offset)
loc = gl.glGetUniformLocation(program, "scale")
gl.glUniform1f(loc, 1.0)
def mainfunc(self):
glut.glutInit()
glut.glutInitDisplayMode(glut.GLUT_RGBA | glut.GLUT_3_2_CORE_PROFILE)
glut.glutInitWindowSize(512, 512)
#glut.glutInitContextVersion(4, 3)
#glut.glutInitContextProfile(glut.GLUT_CORE_PROFILE)
glut.glutCreateWindow('CH01_01')
self.init()
glut.glutDisplayFunc(self.disp)
glut.glutMainLoop()
def mainfunc(self):
glut.glutInit()
glut.glutInitDisplayMode(glut.GLUT_RGBA | glut.GLUT_3_2_CORE_PROFILE)
glut.glutInitWindowSize(512, 512)
#glut.glutInitContextVersion(4, 3)
#glut.glutInitContextProfile(glut.GLUT_CORE_PROFILE)
glut.glutCreateWindow('CH01_01')
self.init()
glut.glutDisplayFunc(self.disp)
glut.glutMainLoop()
def __glInit(self):
self.initTime = time.time()
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGB)
glut.glutInitWindowSize(1000, 1000)
glut.glutInitWindowPosition(50, 50)
glut.glutInit([])
glut.glutCreateWindow(b"OpenGL Fractal Renderer")
self.gpu_vendor = gl_v1.glGetString(gl.GL_VENDOR).decode("ascii")
self.gpu_model = gl_v1.glGetString(gl.GL_RENDERER).decode("ascii")
self.gpu_attrib_count = gl.glGetInteger(gl.GL_MAX_VERTEX_ATTRIBS)
print(f"Found {self.gpu_vendor} {self.gpu_model}")
print(f"GPU supports {self.gpu_attrib_count} vertex attributes")
self.shaderProgram = gl.glCreateProgram()
self.shaderVertex = self.__glCreateShader(
gl.GL_VERTEX_SHADER, """
#version 410
layout(location = 0) in vec4 vertexPosition;
//[0] - centerX, [1] - centerY, [2] - scaleH, [3] - width / height
layout(location = 1) in vec4 centerAndScale;
out mat2 pos;
void main() {
gl_Position = vertexPosition;
float x = centerAndScale[0] + vertexPosition[0] / 2.0
* centerAndScale[2] * centerAndScale[3];
float y = centerAndScale[1] + vertexPosition[1] / 2.0
* centerAndScale[2] ;
pos = mat2(x,y,-y,x);
}
""")
self.shaderSourceGenerator = GLFractalSourceGenerator()
self.shaderSourceGenerator.generateSource(self.fractal)
self.shaderSource = self.shaderSourceGenerator.getOneSourceString()
self.shaderFragment = self.__glCreateFragmentShader(self.shaderSource)
self.shaderSourceGenerator.printSource()
gl.glAttachShader(self.shaderProgram, self.shaderVertex)
gl.glAttachShader(self.shaderProgram, self.shaderFragment)
gl.glLinkProgram(self.shaderProgram)
linkStatus = gl.glGetProgramiv(self.shaderProgram, gl.GL_LINK_STATUS)
if linkStatus != gl.GL_TRUE:
error = gl.glGetProgramInfoLog(self.shaderProgram).decode("ascii")
raise GLShaderLinkError(error)
gl.glUseProgram(self.shaderProgram)
self.__glSetupVarloc()
glut.glutSpecialFunc(self.__glutSpecialKeyHandler)
glut.glutDisplayFunc(self.__glDraw)
glut.glutIdleFunc(self.__glDraw)
glut.glutMainLoop()
def on(self):
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGB)
glut.glutInitWindowSize(self.ww, self.hh)
glut.glutInitWindowPosition(300, 100)
glut.glutInit(sys.argv)
glut.glutCreateWindow(b"PCViewer")
glut.glutDisplayFunc(self.__draw__)
gl.glEnable(gl.GL_DEPTH_TEST)
glut.glutReshapeFunc(self.__reshape__)
glut.glutSpecialFunc(self.__specialkeys__)
glut.glutMainLoop()
def init():
glut.glutInit()
glut.glutInitDisplayMode(glut.GLUT_ALPHA)
glut.glutInitWindowSize(BUFFER_RESOLUTION, BUFFER_RESOLUTION)
glut.glutCreateWindow('')
gl.glDepthMask(gl.GL_FALSE)
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
def initAndRunDevice(templateGlutSystem):
glut.glutInit()
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA)
glut.glutCreateWindow(b'raVEngine_py')
glut.glutReshapeWindow(512, 512)
glut.glutReshapeFunc(reshape)
glut.glutDisplayFunc(templateGlutSystem.display)
glut.glutKeyboardFunc(keyboard)
glut.glutMotionFunc(mouse)
glut.glutIdleFunc(templateGlutSystem.combineUpdateAndDisplay)
glut.glutMainLoop()
def enable(self, app=None):
"""DEPRECATED since IPython 5.0
Enable event loop integration with GLUT.
Parameters
----------
app : ignored
Ignored, it's only a placeholder to keep the call signature of all
gui activation methods consistent, which simplifies the logic of
supporting magics.
Notes
-----
This methods sets the PyOS_InputHook for GLUT, which allows the GLUT to
integrate with terminal based applications like IPython. Due to GLUT
limitations, it is currently not possible to start the event loop
without first creating a window. You should thus not create another
window but use instead the created one. See 'gui-glut.py' in the
docs/examples/lib directory.
The default screen mode is set to:
glut.GLUT_DOUBLE | glut.GLUT_RGBA | glut.GLUT_DEPTH
"""
warn(
"This function is deprecated since IPython 5.0 and will be removed in future versions.",
DeprecationWarning,
stacklevel=2)
import OpenGL.GLUT as glut
from IPython.lib.inputhookglut import glut_display_mode, \
glut_close, glut_display, \
glut_idle, inputhook_glut
if GUI_GLUT not in self.manager.apps:
glut.glutInit(sys.argv)
glut.glutInitDisplayMode(glut_display_mode)
# This is specific to freeglut
if bool(glut.glutSetOption):
glut.glutSetOption(glut.GLUT_ACTION_ON_WINDOW_CLOSE,
glut.GLUT_ACTION_GLUTMAINLOOP_RETURNS)
glut.glutCreateWindow(sys.argv[0])
glut.glutReshapeWindow(1, 1)
glut.glutHideWindow()
glut.glutWMCloseFunc(glut_close)
glut.glutDisplayFunc(glut_display)
glut.glutIdleFunc(glut_idle)
else:
glut.glutWMCloseFunc(glut_close)
glut.glutDisplayFunc(glut_display)
glut.glutIdleFunc(glut_idle)
self.manager.set_inputhook(inputhook_glut)
def main():
glut.glutInit()
glut.glutInitWindowSize(100, 100)
glut.glutCreateWindow('Mehdi')
init()
glut.glutDisplayFunc(display)
glut.glutReshapeFunc(resize(100, 100))
glut.glutMainLoop()
def init_glut(self):
"""
Set up window and main callback functions
"""
GLUT.glutInit(['Galaxy Renderer'])
GLUT.glutInitDisplayMode(GLUT.GLUT_DOUBLE | GLUT.GLUT_RGB)
GLUT.glutInitWindowSize(_WINDOW_SIZE[0], _WINDOW_SIZE[1])
GLUT.glutInitWindowPosition(_WINDOW_POSITION[0], _WINDOW_POSITION[1])
GLUT.glutCreateWindow(str.encode("Galaxy Renderer"))
GLUT.glutDisplayFunc(self.render)
GLUT.glutIdleFunc(self.update_positions)
def _init_glut(self, time):
if type(time) != bytes:
raise TypeError
glut.glutInit()
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA)
glut.glutCreateWindow(time)
glut.glutReshapeWindow(700, 700)
glut.glutReshapeFunc(self.set_window_size)
glut.glutDisplayFunc(self._display)
glut.glutKeyboardFunc(self._keyboard)
def initGLWindow(width, height):
# init GL window
GLUT.glutInit(sys.argv)
GLUT.glutInitDisplayMode(GLUT.GLUT_RGBA | GLUT.GLUT_DOUBLE | GLUT.GLUT_ALPHA | GLUT.GLUT_DEPTH)
GLUT.glutInitWindowSize(width, height)
GLUT.glutInitWindowPosition(0, 0)
GLUT.glutCreateWindow("Hyper Dimensions v1.0 (beta)")
# set callback functions
GLUT.glutDisplayFunc(drawGLScene) # rendering function
GLUT.glutIdleFunc(drawGLScene) # idle function
GLUT.glutTimerFunc(10, updateScene, 1);
GLUT.glutPassiveMotionFunc(mousePassiveMotion)
def main():
GLUT.glutInit(sys.argv)
GLUT.glutInitDisplayMode(GLUT.GLUT_SINGLE | GLUT.GLUT_RGBA
| GLUT.GLUT_DEPTH)
GLUT.glutInitWindowSize(400, 400)
GLUT.glutInitWindowPosition(200, 200)
GLUT.glutCreateWindow("Grafica 2")
"""
GL.glLightfv(GL.GL_LIGHT0, GL.GL_AMBIENT, [0.2, 0.2, 0.2, 1.0])
GL.glLightfv(GL.GL_LIGHT0, GL.GL_DIFFUSE, [1.0, 1.0, 1.0, 1.0])
GL.glLightfv(GL.GL_LIGHT0, GL.GL_SPECULAR, [1.0, 1.0, 1.0, 1.0])
GL.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION, [1.0, 1.0, 1.0, 0.0])
GL.glEnable(GL.GL_NORMALIZE)
GL.glEnable(GL.GL_LIGHTING)
GL.glEnable(GL.GL_LIGHT0)
"""
GL.glDepthFunc(GL.GL_LEQUAL)
GL.glEnable(GL.GL_DEPTH_TEST)
GL.glClearDepth(1.0)
GL.glClearColor(0.650, 0.780, 0.8, 0)
GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT)
GL.glMatrixMode(GL.GL_PROJECTION)
GL.glLoadIdentity()
#GL.glOrtho(-20, 20, -20, 20, -20, 20)
GL.glMatrixMode(GL.GL_MODELVIEW)
GLU.gluPerspective(100, 1.0, 1.0, 100.0)
GL.glTranslatef(0.0, 0.0, 0.0)
GLU.gluLookAt(0, 10, 10, 0, 0, 0, 0, 1, 0)
grid = GR.grid_gen()
#grid.show()
kid.morph(youngold, 100, True)
while True:
GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT)
grid.plot()
########################################
kid.morph(youngold, 100)
########################################
GL.glFlush()
GLUT.glutPostRedisplay()
input("Pause")
GLUT.glutMainLoop()
def main():
GLUT.glutInit(sys.argv)
GLUT.glutInitDisplayMode(GLUT.GLUT_SINGLE | GLUT.GLUT_RGB)
GLUT.glutInitWindowSize(500, 500)
GLUT.glutInitWindowPosition(50, 50)
GLUT.glutCreateWindow("Plot points")
init()
GLUT.glutKeyboardFunc(keyPressed)
GLUT.glutDisplayFunc(plotpoints)
GLUT.glutMainLoop()
def enable(self, app=None):
"""DEPRECATED since IPython 5.0
Enable event loop integration with GLUT.
Parameters
----------
app : ignored
Ignored, it's only a placeholder to keep the call signature of all
gui activation methods consistent, which simplifies the logic of
supporting magics.
Notes
-----
This methods sets the PyOS_InputHook for GLUT, which allows the GLUT to
integrate with terminal based applications like IPython. Due to GLUT
limitations, it is currently not possible to start the event loop
without first creating a window. You should thus not create another
window but use instead the created one. See 'gui-glut.py' in the
docs/examples/lib directory.
The default screen mode is set to:
glut.GLUT_DOUBLE | glut.GLUT_RGBA | glut.GLUT_DEPTH
"""
warn(
"This function is deprecated since IPython 5.0 and will be removed in future versions.",
DeprecationWarning,
stacklevel=2,
)
import OpenGL.GLUT as glut
from IPython.lib.inputhookglut import glut_display_mode, glut_close, glut_display, glut_idle, inputhook_glut
if GUI_GLUT not in self.manager.apps:
glut.glutInit(sys.argv)
glut.glutInitDisplayMode(glut_display_mode)
# This is specific to freeglut
if bool(glut.glutSetOption):
glut.glutSetOption(glut.GLUT_ACTION_ON_WINDOW_CLOSE, glut.GLUT_ACTION_GLUTMAINLOOP_RETURNS)
glut.glutCreateWindow(sys.argv[0])
glut.glutReshapeWindow(1, 1)
glut.glutHideWindow()
glut.glutWMCloseFunc(glut_close)
glut.glutDisplayFunc(glut_display)
glut.glutIdleFunc(glut_idle)
else:
glut.glutWMCloseFunc(glut_close)
glut.glutDisplayFunc(glut_display)
glut.glutIdleFunc(glut_idle)
self.manager.set_inputhook(inputhook_glut)
def initialize(self):
glut.glutInit()
glut.glutInitDisplayMode(glut.GLUT_RGBA | glut.GLUT_DOUBLE | glut.GLUT_DEPTH)
glut.glutInitWindowSize(self.width,self.height)
glut.glutInitWindowPosition(300,300)
glut.glutCreateWindow("super black hole sunshine party")
glut.glutDisplayFunc(self.paintGL)
glut.glutIdleFunc(self.paintGL)
glut.glutReshapeFunc(self.resizeGL)
self.initGL()
self.inputHandler.attachGLUT()
glut.glutMainLoop()
def prepareGLUT(self):
glut.glutInit(sys.argv)
glut.glutInitWindowSize(self.width, self.height)
glut.glutCreateWindow('Sample Shader Heatmap')
# glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGB)
glut.glutInitDisplayMode(glut.GLUT_SINGLE, glut.GLUT_RGBA)
glut.glutDisplayFunc(self.display)
glut.glutKeyboardFunc(self.keyPressed)
# Render Flags
gl.glEnable(gl.GL_BLEND)
gl.glEnable(gl.GL_TEXTURE_1D)
gl.glEnable(gl.GL_TEXTURE_2D)
gl.glEnable(gl.GL_VERTEX_PROGRAM_POINT_SIZE)
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
def renderer(self, r):
# create proxy function accessing
# the render method to do things
# before and after every rendering step
def proxy():
r.render()
glt.glutSwapBuffers()
self._renderer = r
r.addHandler(self)
glt.glutInitWindowSize(r.dimension, r.dimension)
glt.glutCreateWindow(self.name)
glt.glutDisplayFunc(proxy)
def __init__(self, *args, **kwargs):
BaseCanvasBackend.__init__(self)
title, size, show, position = self._process_backend_kwargs(kwargs)
glut.glutInitWindowSize(size[0], size[1])
self._id = glut.glutCreateWindow(title.encode('ASCII'))
if not self._id:
raise RuntimeError('could not create window')
glut.glutSetWindow(self._id)
_VP_GLUT_ALL_WINDOWS.append(self)
# Cache of modifiers so we can send modifiers along with mouse motion
self._modifiers_cache = ()
self._closed = False # Keep track whether the widget is closed
# Register callbacks
glut.glutDisplayFunc(self.on_draw)
glut.glutReshapeFunc(self.on_resize)
# glut.glutVisibilityFunc(self.on_show)
glut.glutKeyboardFunc(self.on_key_press)
glut.glutSpecialFunc(self.on_key_press)
glut.glutKeyboardUpFunc(self.on_key_release)
glut.glutMouseFunc(self.on_mouse_action)
glut.glutMotionFunc(self.on_mouse_motion)
glut.glutPassiveMotionFunc(self.on_mouse_motion)
_set_close_fun(self._id, self.on_close)
self._vispy_canvas_ = None
if position is not None:
self._vispy_set_position(*position)
if not show:
glut.glutHideWindow()
def main():
GLUT.glutInit(sys.argv)
GLUT.glutInitDisplayMode(GLUT.GLUT_RGBA | GLUT.GLUT_DOUBLE | GLUT.GLUT_DEPTH)
GLUT.glutInitWindowSize(320, 240)
global window
window = GLUT.glutCreateWindow("Babal")
GLUT.glutDisplayFunc(display_cb)
GLUT.glutVisibilityFunc(visibility_cb)
GLUT.glutReshapeFunc(reshape_cb)
GLUT.glutIgnoreKeyRepeat(1)
GLUT.glutKeyboardFunc(keyboard_cb)
GLUT.glutKeyboardUpFunc(keyboard_up_cb)
GLUT.glutSpecialFunc(special_cb)
GLUT.glutSpecialUpFunc(special_up_cb)
GLUT.glutJoystickFunc(joystick_cb, 0)
map_file = None
if len(sys.argv) > 1:
map_file = open(sys.argv[1])
global game
game = Game(map_file)
gl_draw.init(GL, GLU, game)
# reshape_cb gets called when window is made visible
GLUT.glutMainLoop()
def main():
global window
# For now we just pass glutInit one empty argument. I wasn't sure what should or could be passed in (tuple, list, ...)
# Once I find out the right stuff based on reading the PyOpenGL source, I'll address this.
lutAsString = buildBitsLUT()
GLUT.glutInit([])
GLUT.glutInitDisplayMode(GLUT.GLUT_RGBA | GLUT.GLUT_DOUBLE | GLUT.GLUT_ALPHA | GLUT.GLUT_DEPTH)
# get a 640 x 480 window
GLUT.glutInitWindowSize(800, 600)
# the window starts at the upper left corner of the screen
GLUT.glutInitWindowPosition(0, 0)
window = GLUT.glutCreateWindow("Jeff Molofee's GL Code Tutorial ... NeHe '99")
# glutFullScreen()
#register callbacks
GLUT.glutIdleFunc(DrawGLScene)
GLUT.glutReshapeFunc(ReSizeGLScene)
GLUT.glutKeyboardFunc(keyPressed)
GLUT.glutDisplayFunc(DrawGLScene)
InitGL(800, 600)
GLUT.glutMainLoop()
def run(self, ):
print("\n")
print("space bar: simulation on/off")
print("' ': run/stop simulation")
print("'a': run/stop animation")
print("'[' and ']': play one frame backward and forward")
# Init glut
GLUT.glutInit(())
GLUT.glutInitDisplayMode(GLUT.GLUT_RGBA |
GLUT.GLUT_DOUBLE |
GLUT.GLUT_MULTISAMPLE |
GLUT.GLUT_ALPHA |
GLUT.GLUT_DEPTH)
GLUT.glutInitWindowSize(*self.window_size)
GLUT.glutInitWindowPosition(0, 0)
self.window = GLUT.glutCreateWindow(self.title)
# Init functions
# glutFullScreen()
GLUT.glutDisplayFunc(self.drawGL)
GLUT.glutIdleFunc(self.idle)
GLUT.glutReshapeFunc(self.resizeGL)
GLUT.glutKeyboardFunc(self.keyPressed)
GLUT.glutMouseFunc(self.mouseFunc)
GLUT.glutMotionFunc(self.motionFunc)
GLUT.glutTimerFunc(25, self.renderTimer, 1)
self.initGL(*self.window_size)
# Run
GLUT.glutMainLoop()
def setUpModule():
global window
if not window:
GLUT.glutInit(sys.argv)
GLUT.glutInitDisplayMode(GLUT.GLUT_DOUBLE | GLUT.GLUT_RGBA | GLUT.GLUT_DEPTH)
GLUT.glutInitWindowSize(1024, 768)
window = GLUT.glutCreateWindow("OMGL (GLUT)")
def run(self):
glut.glutInit(sys.argv)
glut.glutInitWindowSize(500, 500)
glut.glutInitDisplayMode(glut.GLUT_RGBA | glut.GLUT_DOUBLE | glut.GLUT_DEPTH)
self.win = glut.glutCreateWindow(b'Molecular visualizer')
glut.glutDisplayFunc(self.display)
glut.glutReshapeFunc(self.reshape)
glut.glutKeyboardFunc(self.keyboard)
glut.glutMotionFunc(self.rotate)
glut.glutMouseFunc(self.mouse)
gl.glClearColor(0, 0, 0, 1)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_LIGHTING)
gl.glEnable(gl.GL_LIGHT0)
gl.glColorMaterial(gl.GL_FRONT, gl.GL_DIFFUSE)
gl.glEnable(gl.GL_COLOR_MATERIAL)
# very diffuse and dark specular highlights, to make black visible
gl.glMaterial(gl.GL_FRONT, gl.GL_SPECULAR, (.1, .1, .1, 1))
gl.glMaterial(gl.GL_FRONT, gl.GL_SHININESS, 5)
self.displist = gl.glGenLists(1)
gl.glNewList(self.displist, gl.GL_COMPILE)
self.draw_atoms(self.molecule)
gl.glEndList()
glut.glutMainLoop()
def Visualization(title, drawScene=DrawGLScene, width=320, height=200,
handleKey=None):
global window, _DrawCurrentSceneFunc, _KeyHandlerFunc
GLUT.glutInit(sys.argv)
_DrawCurrentSceneFunc = drawScene
if handleKey:
_KeyHandlerFunc = handleKey
# Select type of Display mode:
# Double buffer
# RGBA color
# Alpha components supported
# Depth buffer
GLUT.glutInitDisplayMode(GLUT.GLUT_RGBA | GLUT.GLUT_DOUBLE \
| GLUT.GLUT_DEPTH)
# get a 640 x 480 window
GLUT.glutInitWindowSize(640, 480)
# the window starts at the upper left corner of the screen
GLUT.glutInitWindowPosition(0, 0)
# Okay, like the C version we retain the window id to use when closing, but
# for those of you new to Python (like myself), remember this assignment
# would make the variable local and not global if it weren't for the global
# declaration at the start of main.
window = GLUT.glutCreateWindow(title)
# Register the drawing function with glut, BUT in Python land, at least
# using PyOpenGL, we need to set the function pointer and invoke a function
# to actually register the callback, otherwise it would be very much like
# the C version of the code.
GLUT.glutDisplayFunc(DrawGLScene)
# Uncomment this line to get full screen.
# GLUT.glutFullScreen()
# When we are doing nothing, redraw the scene.
GLUT.glutIdleFunc(DrawGLScene)
# Register the function called when our window is resized.
GLUT.glutReshapeFunc(ReSizeGLScene)
# Register the function called when the keyboard is pressed.
GLUT.glutKeyboardFunc(keyPressed)
# Register the function called when the mouse is pressed.
GLUT.glutMouseFunc(mousePressed)
# Register the function called when the mouse is pressed.
GLUT.glutMotionFunc(mouseMoved)
# Initialize our window.
InitGL(640, 480)
# Start Event Processing Engine
GLUT.glutMainLoop()
def init():
glut.glutInit(sys.argv)
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGB | glut.GLUT_DEPTH)
glut.glutInitWindowSize(width, height)
glut.glutCreateWindow(name)
black = (0.0, 0.0, 0.0, 1.0)
gl.glClearColor(*black)
gl.glShadeModel(gl.GL_SMOOTH)
gl.glEnable(gl.GL_CULL_FACE)
gl.glEnable(gl.GL_DEPTH_TEST)
lights()
glut.glutDisplayFunc(display)
glut.glutKeyboardFunc(keyboard)
http_server.register('cam_x', cam_x)
http_server.register('cam_y', cam_y)
http_server.register('cam_z', cam_z)
http_server.start()
def __init__(self, app_id, fullscreen=False):
glut.glutInit()
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA)
if fullscreen:
glut.glutGameModeString('1920x1080:32@60')
glut.glutEnterGameMode()
else:
glut.glutInitWindowPosition(100, 100)
glut.glutInitWindowSize(1024, 768)
glut.glutCreateWindow('steampak demo')
glut.glutDisplayFunc(self.redraw)
glut.glutIdleFunc(self.redraw)
glut.glutKeyboardFunc(self.keypress)
self.api = SteamApi(LIBRARY_PATH, app_id=app_id)
