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 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 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 __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):
"""
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 __init__(self, parent):
self.MakeCurrent()
self.V = viewer.Viewer3D()
glut.glutInitDisplayMode(glut.GLUT_RGBA|glut.GLUT_DOUBLE|glut.GLUT_DEPTH)
#glut.glutInitWindowSize(self.V.get_width(), self.V.get_height())# window should go to Frame class instead.
#glut.glutCreateWindow("viewer")
self._needs_update = False
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():
global _projection, _rotation, _time_dif, _aspect_ratio
# OpenGL initialization.
glut.glutInit(sys.argv)
# Initialize buffer and OpenGL settings.
glut.glutInitDisplayMode(glut.GLUT_SINGLE | glut.GLUT_RGB
| glut.GLUT_DEPTH)
init_window()
# Initialize shaders.
success = init_shaders()
if not success:
print('Failed to compile and link shader program.')
# Initialize and create window, and set GLUT callback functions
gl.glEnable(gl.GL_TEXTURE_2D)
gl.glEnable(gl.GL_DEPTH_TEST)
# gl.glEnable(gl.GL_LIGHTING) # TODO: Leave light disabled for now
# gl.glShadeModel(gl.GL_SMOOTH) #
# set display callback function
glut.glutDisplayFunc(draw)
# set mouse motion callback funciton
# glut.glutPassiveMotionFunc(mouse_motion_handler)
# set idle callback function
# glut.glutIdleFunc(idle)
# create perspective transformation matrix
_projection = glm.perspective(glm.radians(45.0), _aspect_ratio, 0.1, 100.0)
euler = glm.vec3(-45.0, 0.0, 0.0, dtype=c_float)
_rotation = quat.tquat(euler, dtype=c_float)
init_test_object()
# _time_dif = datetime.now()
_time_dif = time.time()
# Begin main loop.
glut.glutMainLoop()
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 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 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, wWidth, wHeight, filename):
global g_rs, g_nx, g_ny, g_msecs
g_rs = PVReadSparse(filename)
g_nx = g_rs.nx
g_ny = g_rs.ny
glut.glutInit(sys.argv)
glut.glutInitDisplayMode(glut.GLUT_RGBA | glut.GLUT_DOUBLE
| glut.GLUT_DEPTH)
glut.glutInitWindowSize(wWidth, wHeight)
glut.glutInitWindowPosition(0, 0)
window = glut.glutCreateWindow("PetaVision Activity")
gl.glTranslatef(-1.0, 1.0, -2.5)
# register callbacks
glut.glutReshapeFunc(reSizeGLScene)
glut.glutTimerFunc(g_msecs, getNextRecord, 1)
glut.glutDisplayFunc(drawGLScene)
glut.glutKeyboardFunc(keyPressed)
print "nx==", g_nx
print "ny==", g_ny
self.initGL(wWidth, wHeight)
def glInit(): OGLUT.glutInit() # initialize the GLUT library. OGLUT.glutInitDisplayMode(OGLUT.GLUT_DOUBLE | OGLUT.GLUT_RGB |OGLUT.GLUT_DEPTH) # initial display mode OGL.glShadeModel(OGL.GL_SMOOTH) # Enable Smooth Shading OGL.glClearColor(0.0, 0.0, 0.0, 0.0) # Black Background OGL.glClearDepth(1.0) # Depth Buffer Setup OGL.glEnable(OGL.GL_DEPTH_TEST) # Enables Depth Testing OGL.glDepthFunc(OGL.GL_LEQUAL) # The Type Of Depth Testing To Do OGL.glHint(OGL.GL_PERSPECTIVE_CORRECTION_HINT, OGL.GL_NICEST) # Really Nice Perspective Calculations objCamera.Position_Camera(10, 4, 12, 9, 4, 12, 0, 1, 0) # Set Camera Position LoadVertices() OGL.glViewport(0,0,SCREEN_SIZE[0],SCREEN_SIZE[1]) # Reset The Current Viewport OGL.glMatrixMode(OGL.GL_PROJECTION) OGL.glLoadIdentity() # Calculate The Aspect Ratio Of The Window OGLU.gluPerspective(45.0, SCREEN_SIZE[0]/SCREEN_SIZE[1], 0.1, 100.0) OGL.glMatrixMode(OGL.GL_MODELVIEW) OGL.glCullFace(OGL.GL_BACK) # Don't draw the back sides of polygons OGL.glEnable(OGL.GL_CULL_FACE) # Turn on culling
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 run(self):
GLUT.glutInit()
GLUT.glutSetOption(GLUT.GLUT_MULTISAMPLE, 4)
GLUT.glutInitDisplayMode(GLUT.GLUT_DOUBLE | GLUT.GLUT_DEPTH
| GLUT.GLUT_MULTISAMPLE)
self.width = 1200
self.height = 720
GLUT.glutInitWindowSize(self.width, self.height)
GLUT.glutInitWindowPosition(100, 100)
self.window = GLUT.glutCreateWindow(self.title)
self.init_program()
self.clear()
self.show_loading_screen()
self.init_line_buffer()
self.load_line_buffer()
GLUT.glutDisplayFunc(self.display)
GLUT.glutIdleFunc(self.idle)
GLUT.glutReshapeFunc(self.reshape)
GLUT.glutKeyboardFunc(self.keyboard)
GLUT.glutSpecialFunc(self.special)
GLUT.glutMouseFunc(self.mouse)
GLUT.glutMotionFunc(self.motion)
GLUT.glutPassiveMotionFunc(self.motion)
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():
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 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 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 __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 run_sim_with_window(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 __init__(self, cam_model_files: Tuple[str, str],
tracked_cam_parameters: data3d.CameraParameters,
tracked_cam_track: List[data3d.Pose],
point_cloud: data3d.PointCloud):
"""
Initialize CameraTrackRenderer. Load camera model, create buffer objects, load textures,
compile shaders, e.t.c.
:param cam_model_files: path to camera model obj file and texture. The model consists of
triangles with per-point uv and normal attributes
:param tracked_cam_parameters: tracked camera field of view and aspect ratio. To be used
for building tracked camera frustrum
:param point_cloud: colored point cloud
"""
self._point_cloud_renderer = _PointCloudRenderer(point_cloud)
self._cam_track_line_renderer = _CameraTrackLineRenderer(
tracked_cam_track)
self._cam_renderer = _CameraRenderer(cam_model_files,
tracked_cam_parameters,
tracked_cam_track)
GLUT.glutInitDisplayMode(GLUT.GLUT_RGBA | GLUT.GLUT_DOUBLE
| GLUT.GLUT_DEPTH)
GL.glEnable(GL.GL_DEPTH_TEST)
GL.glEnable(GL.GL_PROGRAM_POINT_SIZE)
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():
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 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 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 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 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 __init__(self, cam_model_files: Tuple[str, str],
tracked_cam_parameters: data3d.CameraParameters,
tracked_cam_track: List[data3d.Pose],
point_cloud: data3d.PointCloud):
"""
Initialize CameraTrackRenderer. Load camera model, create buffer objects, load textures,
compile shaders, e.t.c.
:param cam_model_files: path to camera model obj file and texture. The model consists of
triangles with per-point uv and normal attributes
:param tracked_cam_parameters: tracked camera field of view and aspect ratio. To be used
for building tracked camera frustrum
:param point_cloud: colored point cloud
"""
self._program = _build_program()
self._objects_program = _build_objects_program()
self._tracked_cam_parameters = tracked_cam_parameters
self._tracked_cam_track = tracked_cam_track
self._cam_points = np.array(
[point.t_vec for point in tracked_cam_track], dtype=np.float32)
self._points_size = len(point_cloud.ids)
self._points = vbo.VBO(
point_cloud.points.reshape(-1).astype(np.float32))
self._colors = vbo.VBO(
point_cloud.colors.reshape(-1).astype(np.float32))
GLUT.glutInitDisplayMode(GLUT.GLUT_RGBA | GLUT.GLUT_DOUBLE
| GLUT.GLUT_DEPTH)
GL.glEnable(GL.GL_DEPTH_TEST)
def thread_main(instance):
# sys.stderr.write("Starting thread_main\n")
GLUT.glutInit(sys.argv)
GLUT.glutInitContextVersion(3, 3)
GLUT.glutInitContextFlags(GLUT.GLUT_FORWARD_COMPATIBLE)
GLUT.glutInitContextProfile(GLUT.GLUT_CORE_PROFILE)
GLUT.glutSetOption(GLUT.GLUT_ACTION_ON_WINDOW_CLOSE,
GLUT.GLUT_ACTION_GLUTMAINLOOP_RETURNS)
GLUT.glutInitDisplayMode(GLUT.GLUT_RGBA | GLUT.GLUT_DOUBLE
| GLUT.GLUT_DEPTH)
# sys.stderr.write("Making default GLUT window.\n")
GLUT.glutInitWindowSize(instance.width, instance.height)
GLUT.glutInitWindowPosition(0, 0)
instance.window = GLUT.glutCreateWindow(
bytes(instance._title, encoding='UTF-8'))
# Urgh.... according to the docs, I'm MUST register a display function
# for any GLUT window I create. But... I don't want to do this until
# later (in self.__init__). So, register a null function now,
# and hope that registering a new function is an OK thing to do.
GLUT.glutDisplayFunc(lambda: None)
# Not sure if I want this as a timer or an idle func
GLUT.glutIdleFunc(lambda: GLUTContext.class_idle())
# GLUT.glutTimerFunc(10, lambda val : GLUTContext.class_idle(), 0)
sys.stderr.write("Going into GLUT.GLUT main loop.\n")
GLUTContext._class_init = True
GLUT.glutMainLoop()
def __init__(self,
cam_model_files: Tuple[str, str],
tracked_cam_parameters: data3d.CameraParameters,
tracked_cam_track: List[data3d.Pose],
point_cloud: data3d.PointCloud):
"""
Initialize CameraTrackRenderer. Load camera model, create buffer objects, load textures,
compile shaders, e.t.c.
:param cam_model_files: path to camera model obj file and texture. The model consists of
triangles with per-point uv and normal attributes
:param tracked_cam_parameters: tracked camera field of view and aspect ratio. To be used
for building tracked camera frustrum
:param point_cloud: colored point cloud
"""
self._camera_parameters = tracked_cam_parameters
self._camera_track_positions = np.array([pose.t_vec for pose in tracked_cam_track], dtype=np.float32)
self._camera_track_rotations = np.array([pose.r_mat for pose in tracked_cam_track], dtype=np.float32)
self._cloud_ids = point_cloud.ids
self._n_cloud_points = len(point_cloud.ids)
self._cloud_points_buffer = self._bufferize(point_cloud.points)
self._cloud_colors_buffer = self._bufferize(point_cloud.colors)
self._vertex_program = _build_vertex_color_program()
self._fragment_program = _build_fragment_color_program()
camera_vertices = self._load_obj_file(cam_model_files[0])
self._camera_vertices = camera_vertices
self._n_camera_vertices = len(camera_vertices)
GLUT.glutInitDisplayMode(GLUT.GLUT_RGBA | GLUT.GLUT_DOUBLE | GLUT.GLUT_DEPTH)
GL.glEnable(GL.GL_DEPTH_TEST)
def _init_glut():
# HiDPI support for retina display
# This requires glut from
# http://iihm.imag.fr/blanch/software/glut-macosx/
if sys.platform == 'darwin':
try:
glutInitDisplayString = platform.createBaseFunction(
'glutInitDisplayString', dll=platform.GLUT,
resultType=None, argTypes=[ctypes.c_char_p],
doc='glutInitDisplayString( ) -> None', argNames=())
text = ctypes.c_char_p("rgba stencil double samples=8 hidpi")
glutInitDisplayString(text)
except Exception:
pass
glut.glutInit(['vispy'.encode('ASCII')]) # todo: allow user to give args?
mode = (glut.GLUT_RGBA | glut.GLUT_DOUBLE |
glut.GLUT_STENCIL | glut.GLUT_DEPTH)
if bool(glut.glutInitDisplayMode):
glut.glutInitDisplayMode(mode)
# Prevent exit when closing window
try:
glut.glutSetOption(glut.GLUT_ACTION_ON_WINDOW_CLOSE,
glut.GLUT_ACTION_CONTINUE_EXECUTION)
except Exception:
pass
return glut
def setUp(self):
glut.glutInit()
glut.glutInitDisplayMode(glut.GLUT_RGBA | glut.GLUT_DOUBLE
| glut.GLUT_DEPTH)
glut.glutInitWindowSize(20, 20)
self.window_id = glut.glutCreateWindow(self.__class__.__name__)
self.test_data_path = os.path.join(testDir, 'test_data')
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(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 _vispy_get_native_app(self):
# HiDPI support for retina display
# This requires glut from
# http://iihm.imag.fr/blanch/software/glut-macosx/
if sys.platform == 'darwin':
try:
glutInitDisplayString = platform.createBaseFunction(
'glutInitDisplayString',
dll=platform.GLUT,
resultType=None,
argTypes=[
ctypes.c_char_p],
doc='glutInitDisplayString( ) -> None',
argNames=())
text = ctypes.c_char_p("rgba stencil double samples=8 hidpi")
glutInitDisplayString(text)
except:
pass
if not self._initialized:
glut.glutInit() # todo: maybe allow user to give args?
glut.glutInitDisplayMode(glut.GLUT_RGBA |
glut.GLUT_DOUBLE |
glut.GLUT_STENCIL |
glut.GLUT_DEPTH)
self._initialized = True
return glut
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 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__(self, name, width, height):
self.name = name
self.width = width
self.height = height
# Setup window:
GLUT.glutInit()
GLUT.glutInitDisplayMode(GLUT.GLUT_RGBA | GLUT.GLUT_DOUBLE | GLUT.GLUT_DEPTH)
GLUT.glutInitWindowSize(self.width, self.height)
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 __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 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 setUp(self):
self.window_size = (400, 400)
GLUT.glutInit()
GLUT.glutInitContextVersion(3, 3)
GLUT.glutInitContextProfile(GLUT.GLUT_CORE_PROFILE)
GLUT.glutInitDisplayMode(GLUT.GLUT_RGBA)
GLUT.glutInitWindowSize(*self.window_size)
self.window = GLUT.glutCreateWindow("GLPy Test")
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_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 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, 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 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 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 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 __init__(self, limit_fps=100, show_fps=True, window_name='GlutWindow', size=np.asarray([768, 512])):
self.limit_fps = limit_fps
self.show_fps = show_fps
self.window_name = window_name
self.window_size = size
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA)
glut.glutInitWindowPosition(*GlutWindow.allocate_window_position(self.window_size))
self.window_handle = glut.glutCreateWindow(self.window_name)
glut.glutReshapeWindow(*self.window_size)
glut.glutReshapeFunc(self.reshape)
glut.glutDisplayFunc(self.display)
glut.glutKeyboardFunc(self.keyboard)
