all push

Author: shihabmuhtasim

Hello_openGL_Introduction.py

@@ -0,0 +1,39 @@
+from OpenGL.GL import *
+from OpenGL.GLUT import *
+from OpenGL.GLU import *
+
+
+def draw_points(x, y):
+    glPointSize(100) #pixel size. by default 1 thake
+    glBegin(GL_POINTS)
+    glVertex2f(x,y) #jekhane show korbe pixel
+    glEnd()
+
+
+def iterate():
+    glViewport(0, 0, 500, 500)
+    glMatrixMode(GL_PROJECTION)
+    glLoadIdentity()
+    glOrtho(0.0, 500, 0.0, 500, 0.0, 1.0)
+    glMatrixMode (GL_MODELVIEW)
+    glLoadIdentity()
+
+def showScreen():
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+    glLoadIdentity()
+    iterate()
+    glColor3f(0.0, 1.0, 0.0) #konokichur color set (RGB)
+    #call the draw methods here
+    draw_points(400, 300)
+    glutSwapBuffers()
+
+
+
+glutInit()
+#glutInitDisplayMode(GLUT_RGBA)
+glutInitWindowSize(1000, 1000) #window size
+#glutInitWindowPosition(100, 50)
+wind = glutCreateWindow(b"OpenGL Coding Practice") #window name
+glutDisplayFunc(showScreen)
+
+glutMainLoop()

Introduction_2.py

@@ -0,0 +1,221 @@
+from OpenGL.GL import *
+from OpenGL.GLUT import *
+from OpenGL.GLU import *
+
+import math
+
+W_Width, W_Height = 500,500
+
+
+ballx = bally = 0
+speed = 0.01
+ball_size = 2
+create_new = False
+
+
+class point:
+    def __init__(self):
+        self.x=0
+        self.y=0
+        self.z=0
+
+
+def crossProduct(a, b):
+    result=point()
+    result.x = a.y * b.z - a.z * b.y
+    result.y = a.z * b.x - a.x * b.z
+    result.z = a.x * b.y - a.y * b.x
+
+    return result
+
+def convert_coordinate(x,y):
+    global W_Width, W_Height
+    a = x - (W_Width/2)
+    b = (W_Height/2) - y 
+    return a,b
+
+def draw_points(x, y, s):
+    glPointSize(s) #pixel size. by default 1 thake
+    glBegin(GL_POINTS)
+    glVertex2f(x,y) #jekhane show korbe pixel
+    glEnd()
+
+def drawAxes():
+    glLineWidth(1)
+    glBegin(GL_LINES)
+    glColor3f(1.0, 0.0, 0.0)
+    glVertex2f(250,0)
+    glVertex2f(-250,0)
+    glColor3f(0.0, 0.0, 1.0)
+    glVertex2f(0,250)
+    glVertex2f(0,-250)
+    glEnd()
+
+    glPointSize(5)
+    glBegin(GL_POINTS)
+    glColor3f(0, 1.0, 0.0)
+    glVertex2f(0,0)
+ 
+    glEnd()
+
+
+def drawShapes():
+    glBegin(GL_TRIANGLES)
+    glVertex2d(-170,170)
+    glColor3f(0, 1.0, 0.0)
+    glVertex2d(-180,150)
+    glColor3f(1,0, 0.0)
+    glVertex2d(-160,150)
+    glEnd()
+
+    glBegin(GL_QUADS)
+    glVertex2d(-170,120)
+    glColor3f(1,0, 1)
+    glVertex2d(-150,120)
+    glColor3f(0,0, 1)
+    glVertex2d(-150,140)
+    glColor3f(0,1,0)
+    glVertex2d(-170,140)
+    glEnd()
+
+
+def keyboardListener(key, x, y):
+
+    global ball_size
+    if key==b'w':
+        ball_size+=1
+        print("Size Increased")
+    if key==b's':
+        ball_size-=1
+        print("Size Decreased")
+    # if key==b's':
+    #    print(3)
+    # if key==b'd':
+    #     print(4)
+
+    glutPostRedisplay()
+
+def specialKeyListener(key, x, y):
+    global speed
+    if key=='w':
+        print(1)
+    if key==GLUT_KEY_UP:
+        speed *= 2
+        print("Speed Increased")
+    if key== GLUT_KEY_DOWN:		#// up arrow key
+        speed /= 2
+        print("Speed Decreased")
+    glutPostRedisplay()
+    # if key==GLUT_KEY_RIGHT:
+        
+    # if key==GLUT_KEY_LEFT:
+        
+
+    # if key==GLUT_KEY_PAGE_UP:
+       
+    # if key==GLUT_KEY_PAGE_DOWN:
+        
+    # case GLUT_KEY_INSERT:
+    #   
+    #
+    # case GLUT_KEY_HOME:
+    #     
+    # case GLUT_KEY_END:
+    #   
+
+
+def mouseListener(button, state, x, y):	#/#/x, y is the x-y of the screen (2D)
+    global ballx, bally, create_new
+    if button==GLUT_LEFT_BUTTON:
+        if(state == GLUT_DOWN):    # 		// 2 times?? in ONE click? -- solution is checking DOWN or UP
+            print(x,y)
+            c_X, c_y = convert_coordinate(x,y)
+            ballx, bally = c_X, c_y
+            
+        
+    if button==GLUT_RIGHT_BUTTON:
+        if state == GLUT_DOWN: 	
+            create_new = convert_coordinate(x,y)
+    # case GLUT_MIDDLE_BUTTON:
+    #     //........
+
+    glutPostRedisplay()
+
+
+def display():
+    #//clear the display
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+    glClearColor(0,0,0,0);	#//color black
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+    #//load the correct matrix -- MODEL-VIEW matrix
+    glMatrixMode(GL_MODELVIEW)
+    #//initialize the matrix
+    glLoadIdentity()
+    #//now give three info
+    #//1. where is the camera (viewer)?
+    #//2. where is the camera looking?
+    #//3. Which direction is the camera's UP direction?
+    gluLookAt(0,0,200,	0,0,0,	0,1,0)
+    glMatrixMode(GL_MODELVIEW)
+
+    drawAxes()
+    global ballx, bally, ball_size
+    draw_points(ballx, bally, ball_size)
+    drawShapes()
+
+    glBegin(GL_LINES)
+    glVertex2d(180,0)
+    glVertex2d(180,180)
+    glVertex2d(180,180)
+    glVertex2d(0,180)
+    glEnd()
+
+    if(create_new):
+        m,n = create_new
+        glBegin(GL_POINTS)
+        glColor3f(0.7, 0.8, 0.6)
+        glVertex2f(m,n)
+        glEnd()
+
+
+    glutSwapBuffers()
+
+
+def animate():
+    #//codes for any changes in Models, Camera
+    glutPostRedisplay()
+    global ballx, bally,speed
+    ballx=(ballx+speed)%180
+    bally=(bally+speed)%180
+
+def init():
+    #//clear the screen
+    glClearColor(0,0,0,0)
+    #//load the PROJECTION matrix
+    glMatrixMode(GL_PROJECTION)
+    #//initialize the matrix
+    glLoadIdentity()
+    #//give PERSPECTIVE parameters
+    gluPerspective(104,	1,	1,	1000.0)
+    # **(important)**aspect ratio that determines the field of view in the X direction (horizontally). The bigger this angle is, the more you can see of the world - but at the same time, the objects you can see will become smaller.
+    #//near distance
+    #//far distance
+
+
+glutInit()
+glutInitWindowSize(W_Width, W_Height)
+glutInitWindowPosition(0, 0)
+glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGB) #	//Depth, Double buffer, RGB color
+
+# glutCreateWindow("My OpenGL Program")
+wind = glutCreateWindow(b"OpenGL Coding Practice")
+init()
+
+glutDisplayFunc(display)	#display callback function
+glutIdleFunc(animate)	#what you want to do in the idle time (when no drawing is occuring)
+
+glutKeyboardFunc(keyboardListener)
+glutSpecialFunc(specialKeyListener)
+glutMouseFunc(mouseListener)
+
+glutMainLoop()		#The main loop of OpenGL

OpenGL/AGL/__init__.py

@@ -0,0 +1 @@
+"""OpenGL Extensions"""

OpenGL/DISABLED/NVX/__init__.py

@@ -0,0 +1,23 @@
+'''OpenGL extension NVX.cross_process_interop
+
+This module customises the behaviour of the 
+OpenGL.raw.DISABLED.NVX.cross_process_interop to provide a more 
+Python-friendly API
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/NVX/cross_process_interop.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.DISABLED import _types, _glgets
+from OpenGL.raw.DISABLED.NVX.cross_process_interop import *
+from OpenGL.raw.DISABLED.NVX.cross_process_interop import _EXTENSION_NAME
+
+def glInitCrossProcessInteropNVX():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

OpenGL/DISABLED/NVX/cross_process_interop.py

@@ -0,0 +1,6 @@
+This is a Win32 version of the GLE library
+compiled as a shared library (DLL) for use with
+e.g. Python's ctypes foreign-function interface.
+
+To install, copy the file gle32.dll to your system32
+directory.