def applyShape(self):
self._Quadric=GLU.gluNewQuadric()
GLU.gluQuadricNormals(self._Quadric, self.GL(self._normals))
GLU.gluQuadricTexture(self._Quadric, self.GL(self._texture))
GLU.gluCylinder(self._Quadric, self._base, self._top, self._height, self._subdiv, 1)
GLU.gluDeleteQuadric(self._Quadric)
self._Quadric = None
def gl_init( width, height ):
global __legocaptex,__quadratic
setviewport(width, height)
__legocaptex = layer_manager.load_2d_texture(pygame.image.tostring(__image, "RGBA"), LEGO_CAP_WIDTH, LEGO_CAP_HEIGHT)
__quadratic = GLU.gluNewQuadric()
GLU.gluQuadricTexture(__quadratic, GLU.GLU_TRUE)
GLU.gluQuadricDrawStyle(__quadratic,GLU.GLU_FILL)
GLU.gluQuadricOrientation(__quadratic, GLU.GLU_OUTSIDE)
GLU.gluQuadricNormals(__quadratic, GLU.GLU_SMOOTH)
GL.glClearColor( 0.0, 0.2, 0.5, 1.0 )
GL.glEnable(GL.GL_POINT_SMOOTH)
GL.glEnable(GL.GL_LINE_SMOOTH)
GL.glEnable(GL.GL_TEXTURE_2D)
GL.glEnable(GL.GL_ALPHA_TEST)
GL.glEnable(GL.GL_COLOR_MATERIAL)
GL.glDisable(GL.GL_CULL_FACE)
GL.glAlphaFunc(GL.GL_GREATER,0.1)
GL.glClearAccum(0.0, 0.0, 0.0, 1.0)
GL.glClear(GL.GL_ACCUM_BUFFER_BIT)
#GL.glGenLists(1)
draw_mode_3d()
def applyShape(self):
self._Quadric = GLU.gluNewQuadric()
GLU.gluQuadricNormals(self._Quadric, self.GL(self._normals))
GLU.gluQuadricTexture(self._Quadric, self.GL(self._texture))
GLU.gluCylinder(self._Quadric, self._base, self._top, self._height,
self._subdiv, 1)
GLU.gluDeleteQuadric(self._Quadric)
self._Quadric = None
def __init__(self, width: int, height: int):
"""
Arguments:
width {int} -- Window width in pixels
height {int} -- Window height in pixels
"""
self.resize(width, height)
self.quad = glu.gluNewQuadric()
glu.gluQuadricDrawStyle(self.quad, gl.GL_LINE)
glu.gluQuadricTexture(self.quad, gl.GL_TRUE)
def draw_nodes(pos,
nodelist,
node_color,
node_size,
node_border_size,
node_border_color,
scale,
fancy,
lights):
GL.glDisable(GL.GL_DEPTH_TEST)
i = 0
if fancy:
vp = GL.glGetIntegerv(GL.GL_VIEWPORT)
sphere_size_scale = 2./(vp[2]+vp[3])
for n in nodelist:
if fancy:
if lights:
GL.glEnable(GL.GL_LIGHTING)
GL.glPushMatrix()
if len(pos[n]) ==2:
position = tuple(list(pos[n]) + [0.])
else:
position = pos[n]
GL.glTranslate(*position)
GL.glScale(scale,scale,scale)
GL.glColor(*node_color[i])
sphere = GLU.gluNewQuadric()
GLU.gluQuadricNormals(sphere,GLU.GLU_SMOOTH)
GLU.gluQuadricTexture(sphere,GLU.GLU_TRUE)
GLU.gluSphere(sphere,
node_size[i]*sphere_size_scale,
32,
32)
GL.glPopMatrix()
if lights:
GL.glDisable(GL.GL_LIGHTING)
else:
GL.glPointSize(node_size[i]+node_border_size[i])
GL.glBegin(GL.GL_POINTS)
GL.glColor(*node_border_color[i])
GL.glVertex(*tuple(pos[n]))
GL.glEnd()
GL.glPointSize(node_size[i])
GL.glBegin(GL.GL_POINTS)
GL.glColor(*node_color[i])
GL.glVertex(*tuple(pos[n]))
GL.glEnd()
i+=1
GL.glEnable(GL.GL_DEPTH_TEST)
def _initGL(self,Width,Height):
GL.glShadeModel(GL.GL_SMOOTH);
GL.glClearColor(0.0, 0.0, 0.0, 0.0) # This Will Clear The Background Color To Black
GL.glClearDepth(1.0) # Enables Clearing Of The Depth Buffer
GL.glDepthFunc(GL.GL_LESS) # The Type Of Depth Test To Do
GL.glHint(GL.GL_LINE_SMOOTH_HINT, GL.GL_NICEST)
GL.glEnable(GL.GL_BLEND); # Enable Blending
GL.glLineWidth(1.);
GL.glDisable(GL.GL_LINE_SMOOTH)
GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA);
self.width = Width
self.height = Height
self.quad = GLU.gluNewQuadric()
GLU.gluQuadricNormals(self.quad, GLU.GLU_SMOOTH)
GLU.gluQuadricTexture(self.quad, GL.GL_TRUE)
def draw_arrows(pos,
edgelist,
edge_color,
arrow_points,
arrow_size,
scale,
lights,
fancy):
GL.glDisable(GL.GL_DEPTH_TEST)
if lights:
GL.glEnable(GL.GL_LIGHTING)
k = 0
for (i,j) in edgelist:
d = []
for r in range(len(pos[i])):
d.append(pos[i][r]-pos[j][r])
d = tuple(d + [0])
GL.glPushMatrix()
GL.glTranslate(arrow_points[k][0][0],
arrow_points[k][0][1],
arrow_points[k][0][2])
GL.glScale(scale,scale,scale)
GL.glRotate(arrow_points[k][1],-d[1],d[0],0)
GL.glColor(*edge_color[k])
vp = GL.glGetIntegerv(GL.GL_VIEWPORT)
arrow_size_scale = 2./(vp[2]+vp[3])
if fancy:
cone = GLU.gluNewQuadric()
GLU.gluQuadricNormals(cone,GLU.GLU_SMOOTH)
GLU.gluQuadricTexture(cone,GLU.GLU_TRUE)
GLU.gluCylinder(cone,
0,
arrow_size_scale*arrow_size[k]/3.,
arrow_size_scale*arrow_size[k],
32,
32)
else:
s1 = arrow_size[k]*arrow_size_scale
s2 = arrow_size_scale*arrow_size[k]/3.
GL.glBegin(GL.GL_POLYGON);
GL.glVertex3d(0, 0, 0);
GL.glVertex3d(-s2, s2, s1);
GL.glVertex3d(-s2, -s2, s1);
GL.glVertex3d(0, 0, 0);
GL.glVertex3d(-s2, s2, s1);
GL.glVertex3d(s2, s2, s1);
GL.glVertex3d(0, 0, 0);
GL.glVertex3d(s2, s2, s1);
GL.glVertex3d(s2, -s2, s1);
GL.glVertex3d(0, 0, 0);
GL.glVertex3d(s2, -s2, s1);
GL.glVertex3d(-s2, -s2, s1);
GL.glVertex3d(-s2, -s2, s1);
GL.glVertex3d(s2, -s2, s1);
GL.glVertex3d(s2, s2, s1);
GL.glVertex3d(-s2, s2, s1);
GL.glEnd();
GL.glPopMatrix()
k+=1
if lights:
GL.glDisable(GL.GL_LIGHTING)
GL.glEnable(GL.GL_DEPTH_TEST)
def applyShape(self):
Q = GLU.gluNewQuadric()
GLU.gluQuadricNormals(Q, self.GL(self._normals))
GLU.gluQuadricTexture(Q, self.GL(self._texture))
GLU.gluSphere(Q, self._radius, self._subdiv, self._subdiv / 2)
GLU.gluDeleteQuadric(Q)
def __init__(self):
self.sphere = GLU.gluNewQuadric()
GLU.gluQuadricNormals(self.sphere, GLU.GLU_NONE)
GLU.gluQuadricTexture(self.sphere, gl.GL_FALSE)
def __init__(self):
self.quadric = GLU.gluNewQuadric()
GLU.gluQuadricNormals(self.quadric,
GLU.GLU_SMOOTH) #Create Smooth Normals
GLU.gluQuadricTexture(self.quadric, gl.GL_TRUE) #Create Texture Coords
def applyShape(self):
Q=GLU.gluNewQuadric()
GLU.gluQuadricNormals(Q, self.GL(self._normals))
GLU.gluQuadricTexture(Q, self.GL(self._texture))
GLU.gluSphere(Q, self._radius, self._subdiv, self._subdiv/2)
GLU.gluDeleteQuadric( Q )
def __init__(self):
self.sphere = GLU.gluNewQuadric()
GLU.gluQuadricNormals(self.sphere, GLU.GLU_SMOOTH)
GLU.gluQuadricTexture(self.sphere, gl.GL_TRUE)
