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 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, ):
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 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,
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 gl_init(self):
# sys.stderr.write("Starting GLUTContext.gl_init\n")
if self is not GLUTContext._default_instance:
# sys.stderr.write("Making a GLUT window.\n")
GLUT.glutInitWindowSize(self._width, self._height)
GLUT.glutInitWindowPosition(0, 0)
self.window = GLUT.glutCreateWindow(
bytes(self._title, encoding="UTF-8"))
GLUT.glutSetWindow(self.window)
GLUT.glutMouseFunc(lambda button, state, x, y: self.
mouse_button_handler(button, state, x, y))
GLUT.glutReshapeFunc(
lambda width, height: self.resize2d(width, height))
GLUT.glutDisplayFunc(lambda: self.draw())
GLUT.glutVisibilityFunc(
lambda state: self.window_visibility_handler(state))
# Right now, the timer just prints FPS
GLUT.glutTimerFunc(0, lambda val: self.timer(val), 0)
GLUT.glutCloseFunc(lambda: self.cleanup())
for coltype in object_collection.GLObjectCollection.collection_classes:
self.object_collections.append(
object_collection.GLObjectCollection.
collection_classes[coltype](self))
# self.object_collections.append(object_collection.SimpleObjectCollection(self))
# self.object_collections.append(object_collection.CurveCollection(self))
self.window_is_initialized = True
GLUTContext._instances.append(self)
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 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():
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 __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 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 __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 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 __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 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 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 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 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 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 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 __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 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 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 main():
GLUT.glutInit(argv)
GLUT.glutInitDisplayMode(GLUT.GLUT_DOUBLE | GLUT.GLUT_RGBA
| GLUT.GLUT_DEPTH | GLUT.GLUT_MULTISAMPLE)
# Creating a screen with good resolution proportions
screen_width = GLUT.glutGet(GLUT.GLUT_SCREEN_WIDTH)
screen_height = GLUT.glutGet(GLUT.GLUT_SCREEN_HEIGHT)
window_width = round(2 * screen_width / 3)
window_height = round(2 * screen_height / 3)
GLUT.glutInitWindowSize(window_width, window_height)
GLUT.glutInitWindowPosition(round((screen_width - window_width) / 2),
round((screen_height - window_height) / 2))
GLUT.glutCreateWindow(window_name)
# Reshape Function
GLUT.glutReshapeFunc(reshape)
# Drawing Function
GLUT.glutDisplayFunc(draw)
# Input Functions
GLUT.glutSpecialFunc(special_key_pressed)
GLUT.glutKeyboardFunc(key_pressed)
GLUT.glutMouseFunc(mouse_click)
GLUT.glutMotionFunc(mouse_move)
#GL.glShadeModel(GL.GL_FLAT)
GL.glShadeModel(GL.GL_SMOOTH)
#First Material
GL.glMaterialfv(GL.GL_FRONT, GL.GL_AMBIENT, materials[0][0])
GL.glMaterialfv(GL.GL_FRONT, GL.GL_DIFFUSE, materials[0][1])
GL.glMaterialfv(GL.GL_FRONT, GL.GL_SPECULAR, materials[0][2])
GL.glMaterialfv(GL.GL_FRONT, GL.GL_SHININESS, materials[0][3])
light_position = (10, 0, 0)
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(*background_color)
# Pre-render camera positioning
GLU.gluPerspective(45, window_width / window_height, 0.1, 50.0)
GLUT.glutTimerFunc(50, timer, 1)
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 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 __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)
def _glut_init(self):
glut.glutInit(sys.argv)
glut.glutInitDisplayMode(glut.GLUT_RGB | glut.GLUT_SINGLE)
glut.glutInitWindowSize(self.window_size, self.window_size)
glut.glutInitWindowPosition(0, 0)
glut.glutCreateWindow(sys.argv[0])
glut.glutDisplayFunc(self._display)
glut.glutSpecialFunc(self._on_key_press)
glut.glutMouseFunc(self._on_mouse_click)
glut.glutMotionFunc(self._on_mouse_move)
glut.glutReshapeFunc(self._on_window_resize)
glut.glutIdleFunc(self._on_idle)
glut.glutMainLoop()
def initGlut():
glut.glutInit()
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA
| glut.GLUT_DEPTH)
glut.glutInitWindowSize(canvasWidth, canvasHeight)
glut.glutInitWindowPosition(100, 100)
glut.glutCreateWindow('Particles')
glut.glutDisplayFunc(displayCallback)
glut.glutIdleFunc(displayCallback)
glut.glutReshapeFunc(reshapeCallback)
glut.glutKeyboardFunc(keyboardCallback)
logging.info("Finished Setting Up Glut Loop")
glut.glutMainLoop()
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 createGLUTWindow(windowTitle):
GLUT.glutInit(sys.argv)
GLUT.glutInitDisplayMode(GLUT.GLUT_RGBA | GLUT.GLUT_DOUBLE | GLUT.GLUT_DEPTH)
GLUT.glutInitWindowSize(1024, 768)
GLUT.glutInitWindowPosition(120, 120)
GLUT.glutCreateWindow(windowTitle)
GLUT.glutDisplayFunc(onDrawGL)
GLUT.glutIdleFunc(onDrawGL)
GLUT.glutReshapeFunc(resizeGL)
GLUT.glutKeyboardFunc(keyPressed)
initGL()
createShaderGL()
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 run(self, ):
# Init glut
GLUT.glutInit(())
GLUT.glutInitDisplayMode(GLUT.GLUT_RGBA | GLUT.GLUT_DOUBLE
| GLUT.GLUT_ALPHA | GLUT.GLUT_DEPTH)
GLUT.glutInitWindowSize(*self.window_size)
GLUT.glutInitWindowPosition(0, 0)
self.window = GLUT.glutCreateWindow(self.title)
GLUT.glutDisplayFunc(self.drawGL)
GLUT.glutReshapeFunc(self.resizeGL)
GLUT.glutKeyboardFunc(self.mykeyboard)
GLUT.glutMouseFunc(self.mouseFunc)
GLUT.glutMotionFunc(self.motionFunc)
self.initGL(*self.window_size)
def main(self,
neuronObject,
displaysize=(800, 600),
radius=5,
poly=True,
fast=False,
multisample=True,
graph=True):
self.poly = poly
self.displaysize = displaysize
self.graph = graph
title = 'btmorph OpenGL Viewer'
GLUT.glutInit(sys.argv)
if multisample:
GLUT.glutInitDisplayMode(GLUT.GLUT_RGBA | GLUT.GLUT_DOUBLE)
else:
GLUT.glutInitDisplayMode(GLUT.GLUT_RGBA | GLUT.GLUT_DOUBLE
| GLUT.GLUT_MULTISAMPLE)
GLUT.glutInitWindowSize(self.displaysize[0], self.displaysize[1])
GLUT.glutInitWindowPosition(50, 50)
GLUT.glutCreateWindow(title)
GLUT.glutDisplayFunc(self.display)
GLUT.glutReshapeFunc(self.reshape)
GLUT.glutMouseFunc(self.mouse)
GLUT.glutMotionFunc(self.mouseMove)
GLUT.glutMouseWheelFunc(self.mouseWheel)
GLUT.glutKeyboardFunc(self.keyDown)
GLUT.glutKeyboardUpFunc(self.keyUp)
mb = modelbuilder()
self.root, self.vertices_gl, self.colors_gl, self.Neuron = \
mb.build(neuronObject, self.poly, 100, fast)
if graph:
self.gb = graphbuilder()
self.Graph, mid = \
self.gb.build(neuronObject, scalefactor=100)
self.initGL(multisample)
self.camera.rad = radius
self.camera.focus = mid
while self.running:
GLUT.glutMainLoopEvent()
GLUT.glutDestroyWindow(GLUT.glutGetWindow())
def __init__(self, size=(1200, 900), connected=False):
self.size = size
self.connected = connected
GLUT.glutInit([])
GLUT.glutInitDisplayMode(GLUT.GLUT_DOUBLE | GLUT.GLUT_RGB
| GLUT.GLUT_DEPTH)
GLUT.glutInitWindowSize(*size)
GLUT.glutInitWindowPosition(0, 0)
GLUT.glutCreateWindow("Render")
self.vertex_shader = shaders.compileShader(PLAIN_VERTEX_SHADER,
GL.GL_VERTEX_SHADER)
self.fragment_shader = shaders.compileShader(CUBEMAP_FRAGMENT_SHADER,
GL.GL_FRAGMENT_SHADER)
def init_window(self):
glut.glutInit(sys.argv)
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA | glut.GLUT_ALPHA | glut.GLUT_DEPTH)
glut.glutInitWindowPosition(
(glut.glutGet(glut.GLUT_SCREEN_WIDTH) - self.window_width) // 2,
(glut.glutGet(glut.GLUT_SCREEN_HEIGHT) - self.window_height) // 2,
)
glut.glutSetOption(glut.GLUT_ACTION_ON_WINDOW_CLOSE, glut.GLUT_ACTION_CONTINUE_EXECUTION)
glut.glutInitWindowSize(self.window_width, self.window_height)
self.window_handle = glut.glutCreateWindow(WINDOW_TITLE_PREFIX)
glut.glutDisplayFunc(self.render_func)
glut.glutReshapeFunc(self.resize_func)
glut.glutMouseFunc(self.mouse)
glut.glutMotionFunc(self.mouse_motion)
glut.glutKeyboardFunc(self.keyboard)
glut.glutSpecialFunc(self.keyboard_s)
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)
def init():
GLUT.glutInit(sys.argv)
GLUT.glutInitDisplayMode(GLUT.GLUT_SINGLE | GLUT.GLUT_RGB)
GLUT.glutInitWindowSize(800, 600)
GLUT.glutInitWindowPosition(100, 100)
GLUT.glutCreateWindow("Something!")
GL.glClearColor(0, 0, 0, 0)
GL.glMatrixMode(GL.GL_PROJECTION)
GL.glLoadIdentity()
GL.glLightfv(GL.GL_LIGHT0, GL.GL_AMBIENT, [0.0, 0.0, 0.0, 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_POSITION, [0.0, 3.0, 3.0, 0.0])
GL.glLightModelfv(GL.GL_LIGHT_MODEL_AMBIENT, [0.2, 0.2, 0.2, 1.0])
GL.glEnable(GL.GL_LIGHTING)
GL.glEnable(GL.GL_LIGHT0)
GLUT.glutDisplayFunc(update)
GLUT.glutMainLoop()
def glinit(self):
self._sock_thread = threading.Thread(target=self._comm_thread,args=(self,))
self._sock_thread.start()
GLUT.glutInit()
GLUT.glutSetOption(GLUT.GLUT_ACTION_ON_WINDOW_CLOSE,
GLUT.GLUT_ACTION_GLUTMAINLOOP_RETURNS)
# Some window attributes
GLUT.glutInitDisplayMode(GLUT.GLUT_RGBA | GLUT.GLUT_DOUBLE)
GLUT.glutInitWindowSize(self._width, self._height)
GLUT.glutInitWindowPosition(0, 0)
self._win = GLUT.glutCreateWindow(self.title)
# OpenGL callbacks
GLUT.glutDisplayFunc(self._draw(self._render_func))
GLUT.glutKeyboardFunc(self._on_key)
GLUT.glutMouseFunc(self._on_click)
GLUT.glutMotionFunc(self._on_mouse_motion)
GLUT.glutCloseFunc(self._on_exit)
GLUT.glutTimerFunc(self.refresh, self._timer, self.refresh)
#set up 2d or 3d viewport in nice orthographic projection
GL.glViewport(0, 0, self._width, self._height)
GL.glMatrixMode(GL.GL_PROJECTION)
GL.glLoadIdentity()
if self._dim==3:
GL.glOrtho(-1.,1.,-1,1.,-1000.,1000.)
GL.glMatrixMode(GL.GL_MODELVIEW)
else:
GL.glMatrixMode(GL.GL_PROJECTION)
GL.glLoadIdentity()
GLU.gluOrtho2D(-1.,1.,-1.,1.)
#smooth the crap out of everything
GL.glEnable(GL.GL_POINT_SMOOTH)
GL.glEnable(GL.GL_LINE_SMOOTH)
GL.glEnable(GL.GL_POLYGON_SMOOTH)
GL.glEnable(GL.GL_BLEND)
GL.glBlendFunc(GL.GL_ONE,GL.GL_ONE_MINUS_SRC_ALPHA)
GL.glHint(GL.GL_LINE_SMOOTH_HINT,GL.GL_NICEST)
GL.glHint(GL.GL_POINT_SMOOTH_HINT,GL.GL_NICEST)
GL.glHint(GL.GL_POLYGON_SMOOTH_HINT,GL.GL_NICEST)
#Clear Everything and call the main loop
GL.glClearColor(*self.background_color)
self._window_open =True
GLUT.glutMainLoop()
def init_glut(self, args):
"""Initialize the GLUT state."""
# Initialize GLUT.
GLUT.glutInit(args)
GLUT.glutInitContextVersion(
self.context_version[0], self.context_version[1])
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)
# Initialize and create the main window.
GLUT.glutInitDisplayMode(
GLUT.GLUT_DOUBLE | GLUT.GLUT_RGBA | GLUT.GLUT_DEPTH)
GLUT.glutInitWindowSize(
self.window_size[0], self.window_size[1])
GLUT.glutInitWindowPosition(
self.window_position[0], self.window_position[1])
GLUT.glutCreateWindow(self.window_title)
GLUT.glutDisplayFunc(self.render)
GLUT.glutIdleFunc(self.idle)
GLUT.glutReshapeFunc(self.resize)
GLUT.glutKeyboardFunc(self.keyboard)
GLUT.glutTimerFunc(0, self.timer, 0)
GLUT.glutMouseFunc(self.mouse)
GLUT.glutMotionFunc(self.motion)
GLUT.glutCloseFunc(self.cleanup)
aspects = [('Vendor', GL.GL_VENDOR),
('Renderer', GL.GL_RENDERER),
('Version', GL.GL_VERSION),]
if self.context_version[0] > 1:
aspects.append(('GLSL', GL.GL_SHADING_LANGUAGE_VERSION))
for i in aspects:
print('{}: {}'.format(i[0],
GL.glGetString(i[1]).decode()),
file=sys.stderr, flush=True)
def main(self, neuronObject, displaysize=(800, 600), radius=5, poly=True,
fast=False, multisample=True, graph=True):
self.poly = poly
self.displaysize = displaysize
self.graph = graph
title = 'btmorph OpenGL Viewer'
GLUT.glutInit(sys.argv)
if multisample:
GLUT.glutInitDisplayMode(GLUT.GLUT_RGBA | GLUT.GLUT_DOUBLE)
else:
GLUT.glutInitDisplayMode(GLUT.GLUT_RGBA |
GLUT.GLUT_DOUBLE |
GLUT.GLUT_MULTISAMPLE)
GLUT.glutInitWindowSize(self.displaysize[0], self.displaysize[1])
GLUT.glutInitWindowPosition(50, 50)
GLUT.glutCreateWindow(title)
GLUT.glutDisplayFunc(self.display)
GLUT.glutReshapeFunc(self.reshape)
GLUT.glutMouseFunc(self.mouse)
GLUT.glutMotionFunc(self.mouseMove)
GLUT.glutMouseWheelFunc(self.mouseWheel)
GLUT.glutKeyboardFunc(self.keyDown)
GLUT.glutKeyboardUpFunc(self.keyUp)
mb = modelbuilder()
self.root, self.vertices_gl, self.colors_gl, self.Neuron = \
mb.build(neuronObject, self.poly, 100, fast)
if graph:
self.gb = graphbuilder()
self.Graph, mid = \
self.gb.build(neuronObject, scalefactor=100)
self.initGL(multisample)
self.camera.rad = radius
self.camera.focus = mid
while self.running:
GLUT.glutMainLoopEvent()
GLUT.glutDestroyWindow(GLUT.glutGetWindow())
def __init__( self, mesh, width=1024, height=768 ) : # Initialise OpenGL / GLUT glut.glutInit() glut.glutInitDisplayMode( glut.GLUT_DOUBLE | glut.GLUT_RGBA | glut.GLUT_DEPTH | glut.GLUT_MULTISAMPLE ) glut.glutInitWindowSize( width, height ) glut.glutInitWindowPosition( 100, 100 ) glut.glutCreateWindow( mesh.name ) # Mesh viewer self.meshviewer = mtk.MeshViewer() self.meshviewer.InitialiseOpenGL( width, height ) self.meshviewer.LoadMesh( mesh ) self.antialiasing = True # GLUT function binding glut.glutCloseFunc( self.meshviewer.Close ) glut.glutDisplayFunc( self.Display ) glut.glutIdleFunc( self.Idle ) glut.glutKeyboardFunc( self.Keyboard ) glut.glutMouseFunc( self.Mouse ) glut.glutMotionFunc( self.meshviewer.trackball.MouseMove ) glut.glutReshapeFunc( self.meshviewer.Resize )
def main(argv):
# Initialize glut for a nice main window
glut.glutInit(argv)
glut.glutInitDisplayMode(glut.GLUT_DEPTH | glut.GLUT_RGB | glut.GLUT_DOUBLE)
glut.glutInitWindowSize(width, height)
glut.glutInitWindowPosition(winX, winY)
# Create the main window title
glut.glutCreateWindow("Rubik's Cube!")
# Initialize OpenGL
initGL()
size = globals()['size']
# Set up the size of the cube
if len(argv) == 1:
print "No size given, assuming 3"
elif len(argv) == 2:
size = int(argv[1])
globals()['size'] = size
print "Creating a cube of size %d*%d*%d" % (size, size, size)
else:
print "%s [size]" % argv[0]
# Create the cube
globals()['cube'] = Cube(size)
# Register callback functions
glut.glutDisplayFunc(drawGLScene)
glut.glutReshapeFunc(resizeGLScene)
glut.glutKeyboardFunc(keyboard)
glut.glutMouseFunc(mouseClick)
glut.glutMotionFunc(mouseMove)
print help
# Run the main event loop
glut.glutMainLoop()
def __init__(self, width=640, height=480, fullscreen=False, aspect=None):
self.kbd_handler = None
self.win_width = width
self.win_height = height
glut.glutInit(sys.argv)
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGB | glut.GLUT_DEPTH)
glut.glutInitWindowPosition(0, 0)
glut.glutCreateWindow("Karaoke")
if not fullscreen:
glut.glutReshapeWindow(width, height)
else:
glut.glutSetCursor(glut.GLUT_CURSOR_NONE)
self.win_width = width
self.win_height = height
self.set_aspect(aspect)
self._on_reshape(width, height)
if fullscreen:
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)
def __init__(self,layers,layers_lock):
""" Инициализирует экран и запускает его, потом всю программу """
Screen.__init__(self,"OpenGL",layers,layers_lock)
self.window = 0
self.quad = None
self.keypress = []
print("F**k")
# self.infoScreen = ScreenCursesInfo()
self.infoScreen = ScreenStandartInfo()
GLUT.glutInit(sys.argv)
GLUT.glutInitDisplayMode(GLUT.GLUT_RGBA | GLUT.GLUT_DOUBLE | GLUT.GLUT_ALPHA | GLUT.GLUT_DEPTH)
GLUT.glutInitWindowSize(640, 480)
GLUT.glutInitWindowPosition(400, 400)
self.window = GLUT.glutCreateWindow(b"Project Evoluo alpha")
GLUT.glutDisplayFunc(self._loop) # Функция, отвечающая за рисование
GLUT.glutIdleFunc(self._loop) # При простое перерисовывать
GLUT.glutReshapeFunc(self._resize) # изменяет размеры окна
GLUT.glutKeyboardFunc(self._keyPressed) # Обрабатывает нажатия
self._initGL(640, 480)
field_params(640, 480)
print("F**k")
def __init__(self):
self.makeMovie = False
self.mouse_down = False
self.mouse_old = [0., 0.]
self.rotate = [0., 0., 0.]
self.translate = [0., 0., 0.]
self.initrans = [0., 0., -2.]
self.dt = np.float32(.001)
self.size = 2
print self.size **3
size = self.size
self.randarr = np.random.rand(self.size, self.size, self.size)
self.randarr = np.require(self.randarr, 'f')
arr = [(float(x)/(size-1)-.5,float(y)/(size-1)-.5,float(z)/(size-1)-.5,1.0) for x in xrange(size) for y in xrange(size) for z in xrange(size)]
print len(arr)
self.arr = np.require(arr, 'f')
colarr = [(.5-float(x)/size+.2,float(y)/size-.5+.2,float(z)/size-.5+.2,1.0) for x in xrange(size) for y in xrange(size) for z in xrange(size)]
self.colarr = np.require(colarr, 'f')
if self.makeMovie:
self.curimage = np.zeros((self.height, self.width, 3),dtype=np.uint8)
self.curindex = 0
glut.glutInit()
glut.glutInitDisplayMode(glut.GLUT_RGBA | glut.GLUT_DOUBLE | glut.GLUT_DEPTH)
glut.glutInitWindowSize(self.width, self.height)
glut.glutInitWindowPosition(0, 0)
self.win = glut.glutCreateWindow("Testing...")
glut.glutDisplayFunc(self.draw)
glut.glutKeyboardFunc(self.on_key)
glut.glutMouseFunc(self.on_click)
glut.glutMotionFunc(self.on_mouse_motion)
glut.glutTimerFunc(10, self.timer, 10)
self.glinit()
self.clinit()
self.loadProgram("kernel.cl")
self.loadclData()
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 tiny_glut(args):
global vertex_code, fragment_code
scale = 0.01
def display():
CAMERA.render()
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
nonlocal scale
scale_location = gl.glGetUniformLocation(program, "gScale")
assert scale_location != 0xffffffff
world_location = gl.glGetUniformLocation(program, "gWorld")
assert world_location != 0xffffffff
scale += 0.01
pipeline = Pipeline(rotation=[0.0, 30*scale, 0.0],
# scaling=[math.sin(scale)] * 3,
translation=[0, 0, 6],
projection=ProjParams(WINDOW_WIDTH, WINDOW_HEIGHT, 1.0, 100.0, 60.0))
pipeline.set_camera(CAMERA)
gl.glUniformMatrix4fv(world_location, 1, gl.GL_TRUE, pipeline.get_wvp())
gl.glDrawElements(gl.GL_TRIANGLES, 18, gl.GL_UNSIGNED_INT, ctypes.c_void_p(0))
glut.glutSwapBuffers()
# glut.glutPostRedisplay()
def mouse(x, y):
CAMERA.mouse(x, y)
def keyboard(key, x, y):
if key == glut.GLUT_KEY_F1:
sys.exit(0)
elif key == glut.GLUT_KEY_HOME:
CAMERA.setup()
else:
CAMERA.keyboard(key)
glut.glutInit(args)
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA | glut.GLUT_3_2_CORE_PROFILE)
glut.glutInitWindowSize(WINDOW_WIDTH, WINDOW_HEIGHT)
glut.glutInitWindowPosition(400, 100)
# glut.glutCreateWindow("Camera Tutorial")
glut.glutGameModeString("1920x1200@32")
glut.glutEnterGameMode()
# callbacks initialization
glut.glutDisplayFunc(display)
glut.glutIdleFunc(display)
# glut.glutKeyboardFunc(keyboard)
glut.glutPassiveMotionFunc(mouse)
glut.glutSpecialFunc(keyboard)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glDepthFunc(gl.GL_LESS)
gl.glClearColor(0, 0, 0, 0)
vertices = np.array([
-1, -1, 0,
0, -1, -1,
1, -1, 0,
0, -1, 1,
0, 1, 0
], dtype=np.float32)
indexes = np.array([
0, 1, 2,
1, 2, 3,
0, 1, 4,
1, 2, 4,
2, 3, 4,
3, 0, 4
], dtype=np.uint32)
vertex_shader = gl.glCreateShader(gl.GL_VERTEX_SHADER)
gl.glShaderSource(vertex_shader, vertex_code)
gl.glCompileShader(vertex_shader)
if not gl.glGetShaderiv(vertex_shader, gl.GL_COMPILE_STATUS):
info = gl.glGetShaderInfoLog(vertex_shader)
print("vertex shader error occurred")
print(bytes.decode(info))
return
fragment_shader = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
gl.glShaderSource(fragment_shader, fragment_code)
gl.glCompileShader(fragment_shader)
if not gl.glGetShaderiv(fragment_shader, gl.GL_COMPILE_STATUS):
info = gl.glGetShaderInfoLog(fragment_shader)
print("fragment shader error occurred")
print(bytes.decode(info))
return
program = gl.glCreateProgram()
gl.glAttachShader(program, vertex_shader)
gl.glAttachShader(program, fragment_shader)
gl.glLinkProgram(program)
gl.glUseProgram(program)
vao = gl.glGenVertexArrays(1)
gl.glBindVertexArray(vao)
vbo = gl.glGenBuffers(1)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vbo)
gl.glBufferData(gl.GL_ARRAY_BUFFER, vertices.nbytes, vertices, gl.GL_STATIC_DRAW)
gl.glEnableVertexAttribArray(0)
gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, gl.GL_FALSE, 0, ctypes.c_void_p(0))
ibo = gl.glGenBuffers(1)
gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, ibo)
gl.glBufferData(gl.GL_ELEMENT_ARRAY_BUFFER, indexes.nbytes, indexes, gl.GL_STATIC_DRAW)
glut.glutMainLoop()
def __init__(self,
dim=3,
width=800,
height=800,
title="",
refresh=15,
background_color = (0.,0.,0.,0.),
render_func=lambda window: None,
rf_args=(),
rf_kwargs = {},
save_file='./',
save_file_type=None):
pid = os.fork() # Hack to get interpetor back
if not pid==0:
return None
self.mouse_down = False
self.mouse_old = [0., 0.]
self.rotate = [0., 0., 0.]
self.translate = [0., 0., 0.]
self.scale = 1.0
self.dim=dim
# grab the file extension if its there.
split_path_ext = os.path.splitext(save_file)
self.save_file = split_path_ext[0]
if save_file_type is None:
self.save_file_ext = split_path_ext[1]
if self.save_file_ext == '':
self.save_file_ext = '.png'
else:
self.save_file_ext = save_file_type
self.save_count = 0
self.width = width
self.height = height
self.lights = False
GLUT.glutInit()
# Some window attributes
GLUT.glutInitDisplayMode(GLUT.GLUT_RGBA | GLUT.GLUT_DOUBLE)
GLUT.glutInitWindowSize(self.width, self.height)
GLUT.glutInitWindowPosition(0, 0)
self.win = GLUT.glutCreateWindow(title)
# OpenGL callbacks
GLUT.glutDisplayFunc(self.draw(render_func,*rf_args,**rf_kwargs))
GLUT.glutKeyboardFunc(self.on_key)
GLUT.glutMouseFunc(self.on_click)
GLUT.glutMotionFunc(self.on_mouse_motion)
try:
GLUT.glutCloseFunc(self.on_exit)
# JJB - 6/6/12 --
except GLUT.error.NullFunctionError:
GLUT.glutWMCloseFunc(self.on_exit)
GLUT.glutTimerFunc(refresh, self.timer, refresh)
self.glinit()
# Clean the slate
GL.glClearColor(*background_color)
# and start
GLUT.glutMainLoop()
ratio = width / height
gl.glMatrixMode(gl.GL_PROJECTION)
gl.glLoadIdentity();
gl.glViewport(0,0,width,height)
if ratio >= 1:
gl.glOrtho (-2.0*ratio,2.0*ratio, -2.0,2.0, -1.0, 1.0)
else:
gl.glOrtho (-2.0,2.0, -2.0/ratio,2.0/ratio, -1.0, 1.0)
gl.glMatrixMode(gl.GL_MODELVIEW)
glut.glutInit()
# Indicamos como ha de ser la nueva ventana
glut.glutInitWindowPosition (100,100)
glut.glutInitWindowSize (W_WIDTH, W_HEIGHT)
glut.glutInitDisplayMode (glut.GLUT_RGBA | glut.GLUT_DOUBLE)
glut.glutCreateWindow ("Etapa 2")
# Indicamos cuales son las funciones de redibujado e idle
glut.glutDisplayFunc(Display)
glut.glutIdleFunc(Idle)
glut.glutReshapeFunc(Reshape)
#El color de fondo sera el negro (RGBA, RGB + Alpha channel)
gl.glClearColor (1.0, 1.0, 1.0, 1.0)
gl.glMatrixMode(gl.GL_PROJECTION)
gl.glLoadIdentity()
gl.glOrtho (-1.0, 1.0, -1.0, 1.0, -1.0, 1.0)
import OpenGL.GLUT as glut import OpenGL.GLU as glu """Woking gameloop implemented using glutDisplayFunc(). also initializes a opengl window. """ window =0 width,height = 800,500 name=b"test" def draw(): """skeleton function""" gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) #clear screen gl.glLoadIdentity() #reset postition glut.glutSwapBuffers() #allows doouble buffering #initialization glut.glutInit() glut.glutInitDisplayMode(glut.GLUT_RGBA | glut.GLUT_DOUBLE | glut.GLUT_ALPHA | glut.GLUT_DEPTH) glut.glutInitWindowSize(width,height) glut.glutInitWindowPosition(0,0) window = glut.glutCreateWindow(name) glut.glutDisplayFunc(draw) #calls function draw on user action, ie keyboard or mouseclick. glut.glutIdleFunc(draw) #substitute for gameloop. calls function draw all the time glut.glutMainLoop() #starts everything going.
#if now - self.lastPrinted > 5:
#self.lastPrinted = now
#print "FPS: %s" % self.fps
def resize(self, w, h):
glViewport(0,0,w,h)
super(MyStage, self).resize(w,h)
if __name__ == "__main__":
width, height = (640, 480)
GLUT.glutInit(sys.argv)
GLUT.glutInitDisplayMode(GLUT.GLUT_RGBA | GLUT.GLUT_DOUBLE | GLUT.GLUT_DEPTH)
GLUT.glutInitWindowSize(width, height)
GLUT.glutInitWindowPosition(0,0)
window = GLUT.glutCreateWindow("py2dgui Test Window")
stage = MyStage(width, height)
GLUT.glutDisplayFunc(stage.render)
GLUT.glutIdleFunc(stage.render)
GLUT.glutReshapeFunc(stage.resize)
# Make a shape
#shape = BorderedSquare(color=Color(0.3, 0.3, 0.3), border_width=2)
#shape.translate(Point(320, 240))
#shape.scale(Point(.2,.8,.2))
#shape.rotate(Point(z=15))
elif key == 'p':
running = not running
#the mouse is used to control the camera
def mouse(button, state, x, y):
if button == GLUT.GLUT_LEFT_BUTTON:
if (state == GLUT.GLUT_DOWN):
GLUT.glutIdleFunc(forward)
elif (state == GLUT.GLUT_UP):
GLUT.glutIdleFunc(Calculations)
elif button == GLUT.GLUT_RIGHT_BUTTON:
if (state == GLUT.GLUT_DOWN):
GLUT.glutIdleFunc(backward)
elif (state == GLUT.GLUT_UP):
GLUT.glutIdleFunc(Calculations)
GLUT.glutInit(sys.argv)
GLUT.glutInitDisplayMode (GLUT.GLUT_DOUBLE | GLUT.GLUT_RGB | GLUT.GLUT_DEPTH)
GLUT.glutInitWindowSize (1024, 576)
GLUT.glutInitWindowPosition (100, 100)
GLUT.glutCreateWindow('Lorentz Attractor')
init()
GL.glEnable(GL.GL_TEXTURE_2D)
GLUT.glutDisplayFunc(display)
GLUT.glutReshapeFunc(reshape)
GLUT.glutKeyboardFunc(keyboard)
GLUT.glutMouseFunc(mouse)
GLUT.glutPassiveMotionFunc(motion)
GLUT.glutMotionFunc(motion)
GLUT.glutIdleFunc(Calculations)
GLUT.glutMainLoop()
