コード例 #1
0
ファイル: tools.py プロジェクト: yuhangwang/zeobuilder
 def _line(self, r1, r2):
     glColor(1, 1, 1)
     glLineWidth(1)
     glBegin(GL_LINES)
     glVertex3f(r1[0], r1[1], 0.0)
     glVertex3f(r2[0], r2[1], 0.0)
     glEnd()
コード例 #2
0
    def _paintGLGrid(self):
        resolutionMillimeters = 1
        griddedAreaSize = 100

        glLineWidth(1.0)

        glBegin(GL_LINES)

        glColor3f(1.0, 1.0, 1.0)

        glVertex3f(griddedAreaSize, 0, 0)
        glVertex3f(-griddedAreaSize, 0, 0)
        glVertex3f(0, griddedAreaSize, 0)
        glVertex3f(0, -griddedAreaSize, 0)

        numOfLines = int(griddedAreaSize / resolutionMillimeters)

        for i in range(numOfLines):
            glVertex3f(resolutionMillimeters * i, -griddedAreaSize, 0)
            glVertex3f(resolutionMillimeters * i, griddedAreaSize, 0)
            glVertex3f(griddedAreaSize, resolutionMillimeters * i, 0)
            glVertex3f(-griddedAreaSize, resolutionMillimeters * i, 0)

            glVertex3f(resolutionMillimeters * (-i), -griddedAreaSize, 0)
            glVertex3f(resolutionMillimeters * (-i), griddedAreaSize, 0)
            glVertex3f(griddedAreaSize, resolutionMillimeters * (-i), 0)
            glVertex3f(-griddedAreaSize, resolutionMillimeters * (-i), 0)

        glEnd()
コード例 #3
0
    def __init__(self, title='null'):
        #
        self.glview = gl.GLViewWidget()
        coord = gl.GLAxisItem()
        glLineWidth(1)
        coord.setSize(1, 1, 1)
        #self.glview.addItem(coord)
        self.glview.setMinimumSize(QtCore.QSize(600, 500))
        self.glview.pan(1, 0, 0)
        self.glview.setCameraPosition(azimuth=180)
        self.glview.setCameraPosition(elevation=0)
        self.glview.setCameraPosition(distance=5)
        self.items = []
        #
        self.view = QtGui.QWidget()
        self.view.window().setWindowTitle(title)
        hlayout = QtGui.QHBoxLayout()
        snap_btn = QtGui.QPushButton('&Snap')

        def take_snap():
            qimg = self.glview.readQImage()
            qimg.save('1.jpg')

        snap_btn.clicked.connect(take_snap)
        hlayout.addWidget(snap_btn)
        hlayout.addStretch()
        layout = QtGui.QVBoxLayout()
        #
        layout.addLayout(hlayout)
        layout.addWidget(self.glview)
        self.view.setLayout(layout)
コード例 #4
0
ファイル: tools.py プロジェクト: molmod/zeobuilder
 def _line(self, r1, r2):
     glColor(1, 1, 1)
     glLineWidth(1)
     glBegin(GL_LINES)
     glVertex3f(r1[0], r1[1], 0.0)
     glVertex3f(r2[0], r2[1], 0.0)
     glEnd()
コード例 #5
0
def drawline_worker(params):
    """
    Draw a line.  Receive parameters through a sequence so that this
    function and its parameters can be passed to another function for
    deferment.  Right now this is only ColorSorter.schedule (see below)
    """
    (endpt1, endpt2, dashEnabled, stipleFactor, width, isSmooth) = params

    ###glDisable(GL_LIGHTING)
    ###glColor3fv(color)
    if dashEnabled: 
        glLineStipple(stipleFactor, 0xAAAA)
        glEnable(GL_LINE_STIPPLE)
    if width != 1:
        glLineWidth(width)
    if isSmooth:
        glEnable(GL_LINE_SMOOTH)
    glBegin(GL_LINES)
    glVertex(endpt1[0], endpt1[1], endpt1[2])
    glVertex(endpt2[0], endpt2[1], endpt2[2])
    glEnd()
    if isSmooth:
        glDisable(GL_LINE_SMOOTH)
    if width != 1:
        glLineWidth(1.0) # restore default state
    if dashEnabled: 
        glDisable(GL_LINE_STIPPLE)
    ###glEnable(GL_LIGHTING)
    return
コード例 #6
0
ファイル: drawers.py プロジェクト: ematvey/NanoEngineer-1
def drawRotateSign(color, pos1, pos2, radius, rotation = 0.0):
    """Rotate sign on top of the caps of the cylinder """
    glPushMatrix()
    glColor3fv(color)
    vec = pos2-pos1
    axis = norm(vec)
    glTranslatef(pos1[0], pos1[1], pos1[2])

    ##Huaicai 1/17/05: To avoid rotate around (0, 0, 0), which causes 
    ## display problem on some platforms
    angle = -acos(axis[2])*180.0/pi
    if (axis[2]*axis[2] >= 1.0):
        glRotate(angle, 0.0, 1.0, 0.0)
    else:
        glRotate(angle, axis[1], -axis[0], 0.0)
    glRotate(rotation, 0.0, 0.0, 1.0) #bruce 050518
    glScale(radius,radius,Numeric.dot(vec,vec)**.5)

    glLineWidth(2.0)
    glDisable(GL_LIGHTING)
    glCallList(drawing_globals.rotSignList)
    glEnable(GL_LIGHTING)
    glLineWidth(1.0)

    glPopMatrix()
    return
コード例 #7
0
ファイル: drawers.py プロジェクト: vcsrc/nanoengineer
def drawRotateSign(color, pos1, pos2, radius, rotation=0.0):
    """Rotate sign on top of the caps of the cylinder """
    glPushMatrix()
    glColor3fv(color)
    vec = pos2 - pos1
    axis = norm(vec)
    glTranslatef(pos1[0], pos1[1], pos1[2])

    ##Huaicai 1/17/05: To avoid rotate around (0, 0, 0), which causes
    ## display problem on some platforms
    angle = -acos(axis[2]) * 180.0 / pi
    if (axis[2] * axis[2] >= 1.0):
        glRotate(angle, 0.0, 1.0, 0.0)
    else:
        glRotate(angle, axis[1], -axis[0], 0.0)
    glRotate(rotation, 0.0, 0.0, 1.0)  #bruce 050518
    glScale(radius, radius, Numeric.dot(vec, vec)**.5)

    glLineWidth(2.0)
    glDisable(GL_LIGHTING)
    glCallList(drawing_globals.rotSignList)
    glEnable(GL_LIGHTING)
    glLineWidth(1.0)

    glPopMatrix()
    return
コード例 #8
0
    def _paintGLGrid(self):
        resolutionMillimeters = 1
        griddedAreaSize = 100

        glLineWidth(1.0)

        glBegin(GL_LINES)

        glColor3f(1.0, 1.0, 1.0)

        glVertex3f(griddedAreaSize, 0, 0)
        glVertex3f(-griddedAreaSize, 0, 0)
        glVertex3f(0, griddedAreaSize, 0)
        glVertex3f(0, -griddedAreaSize, 0)

        numOfLines = int(griddedAreaSize / resolutionMillimeters)

        for i in range(numOfLines):
            glVertex3f(resolutionMillimeters * i, -griddedAreaSize, 0)
            glVertex3f(resolutionMillimeters * i, griddedAreaSize, 0)
            glVertex3f(griddedAreaSize, resolutionMillimeters * i, 0)
            glVertex3f(-griddedAreaSize, resolutionMillimeters * i, 0)

            glVertex3f(resolutionMillimeters * (-i), -griddedAreaSize, 0)
            glVertex3f(resolutionMillimeters * (-i), griddedAreaSize, 0)
            glVertex3f(griddedAreaSize, resolutionMillimeters * (-i), 0)
            glVertex3f(-griddedAreaSize, resolutionMillimeters * (-i), 0)

        glEnd()
コード例 #9
0
ファイル: draw.py プロジェクト: Zildj1an/bui
def draw_line(line_width, color, x1, y1, x2, y2):
    glLineWidth(line_width)
    set_color(color)
    
    with mode(GL_LINES):
        glVertex2f(x1, y1)
        glVertex2f(x2, y2)
コード例 #10
0
 def display(self,factor) :
   ''' Function to display the localview axes. '''
   
   right_arrow = self.right.add_vertex(self.pos,self.right.mult_vector(factor,self.right))
   up_arrow = self.up.add_vertex(self.pos,self.up.mult_vector(factor,self.up))
   sight_arrow = self.sight.add_vertex(self.pos,self.sight.mult_vector(factor,self.sight))
   
   glLineWidth(4)
   
   glColor(255,0,0)
   glBegin(GL_LINES)
   glVertex(self.pos.get_vertex())
   glVertex(right_arrow.get_vertex())
   glEnd()
   
   glColor(0,255,0)
   glBegin(GL_LINES)
   glVertex(self.pos.get_vertex())
   glVertex(up_arrow.get_vertex())
   glEnd()
   
   glColor(0,0,255)
   glBegin(GL_LINES)
   glVertex(self.pos.get_vertex())
   glVertex(sight_arrow.get_vertex())
   glEnd()
コード例 #11
0
ファイル: primtive.py プロジェクト: phantom2018/shiyanlou
def make_plane():
    glNewList(G_OBJ_PLANE, GL_COMPILE)
    glBegin(GL_LINES)
    glColor3f(0, 0, 0)
    for i in range(41):
        glVertex3f(-10.0 + 0.5* i, 0, -10)
        glVertex3f(-10.0 + 0.5* i, 0, 10)
        glVertex3f(-10.0, 0, -10+0.5*i)
        glVertex3f(10.0, 0, -10+0.5*i)

    #Axes
    glEnd()
    glLineWidth(5)

    glBegin(GL_LINES)
    glColor3f(0.5, 0.7, 0.5)
    glVertex3f(0.0, 0.0, 0.0)
    glVertex3f(5, 0.0, 0.0)
    glEnd()

    glBegin(GL_LINES)
    glColor3f(0.5, 0.7, 0.5)
    glVertex3f(0.0, 0.0, 0.0)
    glVertex3f(0.0, 5, 0.0)

    glBegin(GL_LINES)
    glColor3f(0.5, 0.7, 0.5)
    glVertex3f(0.0, 0.0, 0.0)
    glVertex3f(0.0, 0.0, 5)
コード例 #12
0
    def draw_lines(self):
        """
        draw our line segments, using our current style attrs [which are partly nim]
        """
        # find variables which determine our GL state
        color = self.fix_color(self.linecolor)
        dashEnabled = self.dashed
        width = self.linewidth

        # set temporary GL state (code copied from drawer.drawline)
        glDisable(GL_LIGHTING)
        glColor3fv(color)
        if dashEnabled:
            glLineStipple(1, 0xAAAA)
            glEnable(GL_LINE_STIPPLE)
        if width != 1:
            glLineWidth(width)
        # draw the lines
        if self._closed_state:
            glBegin(GL_LINE_LOOP)
        else:
            glBegin(GL_LINE_STRIP)
        for pos in self.points:
            glVertex3fv(pos) # [note from old code: could be pos + origin if that can matter]
        glEnd()
        # restore default GL state [some of this might be moved up to callers]
        if width != 1:
            glLineWidth(1.0)
        if dashEnabled:
            glDisable(GL_LINE_STIPPLE)
        glEnable(GL_LIGHTING)
        return
コード例 #13
0
    def draw_lines(self):
        "draw our line segments, using our current style attrs [which are partly nim]"
        # find variables which determine our GL state
        color = self.fix_color(self.linecolor)
        dashEnabled = self.dashed
        width = self.linewidth

        # set temporary GL state (code copied from drawer.drawline)
        glDisable(GL_LIGHTING)
        glColor3fv(color)
        if dashEnabled:
            glLineStipple(1, 0xAAAA)
            glEnable(GL_LINE_STIPPLE)
        if width != 1:
            glLineWidth(width)
        # draw the lines
        if self._closed_state:
            glBegin(GL_LINE_LOOP)
        else:
            glBegin(GL_LINE_STRIP)
        for pos in self.points:
            glVertex3fv(
                pos
            )  # [note from old code: could be pos + origin if that can matter]
        glEnd()
        # restore default GL state [some of this might be moved up to callers]
        if width != 1:
            glLineWidth(1.0)
        if dashEnabled:
            glDisable(GL_LINE_STIPPLE)
        glEnable(GL_LIGHTING)
        return
コード例 #14
0
    def draw_player(self):
        glLineWidth(2)
        glPushMatrix()

        if self.degree == 90:
            if not self.check_goal(self.player, self.board):
                direction = self.get_direction(self.player)
                self.draw_main_cube(self.player[0], direction)
                self.draw_secondary_cube(self.player[1], direction)
        else:
            direction = self.get_direction(self.previous)
            self.draw_secondary_cube(self.player[1], direction)
            if direction != Direction.none and self.get_direction(
                    self.player) == Direction.none:
                done = self.teleport_player(10, rotating_speed / 2)
                if self.rotate_before_swap():
                    if not done:
                        self.steps = 1
                        self.degree = 0
            elif self.check_goal(self.player, self.board):
                done = self.teleport_player(-10, rotating_speed / 5)
                if self.rotate_before_swap():
                    if not done:
                        self.steps = 1
                        self.degree = 0
            else:
                self.rotate_player()
            self.draw_main_cube(self.previous[0], direction)
        glPopMatrix()
        glLineWidth(1)
コード例 #15
0
def drawline_worker(params):
    """
    Draw a line.  Receive parameters through a sequence so that this
    function and its parameters can be passed to another function for
    deferment.  Right now this is only ColorSorter.schedule (see below)
    """
    (endpt1, endpt2, dashEnabled, stipleFactor, width, isSmooth) = params

    ###glDisable(GL_LIGHTING)
    ###glColor3fv(color)
    if dashEnabled:
        glLineStipple(stipleFactor, 0xAAAA)
        glEnable(GL_LINE_STIPPLE)
    if width != 1:
        glLineWidth(width)
    if isSmooth:
        glEnable(GL_LINE_SMOOTH)
    glBegin(GL_LINES)
    glVertex(endpt1[0], endpt1[1], endpt1[2])
    glVertex(endpt2[0], endpt2[1], endpt2[2])
    glEnd()
    if isSmooth:
        glDisable(GL_LINE_SMOOTH)
    if width != 1:
        glLineWidth(1.0)  # restore default state
    if dashEnabled:
        glDisable(GL_LINE_STIPPLE)
    ###glEnable(GL_LIGHTING)
    return
コード例 #16
0
ファイル: physics.py プロジェクト: leriomaggio/rainbowalga
    def draw(self, time, line_width=None):
        if self.hidden:
            return
        if time <= self.ts:
            return
        time = time * 1e-9

        pos_start = self.pos
        path = self.speed * (time - self.ts * 1e-9) * self.dir
        # max_end = self.pos + (self.speed * self.te * self.dir)
        # if not int(self.te) == 0 and time > self.te:
        #    pos_end = max_end
        # else:
        #    pos_end = self.pos + path
        pos_end = self.pos + path

        glPushMatrix()
        if line_width:
            glLineWidth(line_width)
        else:
            glLineWidth(self.line_width)
        glColor3f(*self.color)
        glBegin(GL_LINES)
        glVertex3f(*pos_start)
        glVertex3f(*pos_end)
        glEnd()
        glPopMatrix()
コード例 #17
0
ファイル: canvas3D.py プロジェクト: softtrainee/arlab
    def _init_GL(self):
        '''
        '''
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
        glEnable(GL_BLEND)
        glEnable(GL_LINE_SMOOTH)
        glLineWidth(2.0)
        glEnable(GL_DEPTH_TEST)

        # glEnable(GL_TEXTURE_2D)

        # set the lighting
        self._set_lighting()


        # set the background color
        # glClearColor(0.15, 0.15, 0.15, 1)
        glClearDepth(1.0)

        # set the camera
        glMatrixMode(GL_PROJECTION)
        # glPushMatrix()
        glLoadIdentity()
        self._set_view_volume()

        glMatrixMode(GL_MODELVIEW)
        return
コード例 #18
0
 def __init__(self):
     self.app = pg.mkQApp()
     self.view = gl.GLViewWidget()
     coord = gl.GLAxisItem()
     glLineWidth(3)
     coord.setSize(3,3,3)
     self.view.addItem(coord)
コード例 #19
0
 def paint(self):
     glColor3f(0.0, 0.0, 0.6)
     glLineWidth(1.0);
     glBegin(GL_LINES)
     glVertex3f(*self.obj_a.position)
     glVertex3f(*self.obj_b.position)
     glEnd()
コード例 #20
0
ファイル: tools.py プロジェクト: tamasgal/rainbowalga
 def draw(self, line_width=1, color=(1.0, 0.0, 0.0)):
     glEnable(GL_DEPTH_TEST)
     glEnable(GL_LINE_SMOOTH)
     glShadeModel(GL_FLAT)
     glPushMatrix()
     glLineWidth(line_width)
     glColor3f(*color)
     glBegin(GL_LINES)
     glVertex3f(-1.0, 0.0, 0.0)
     glVertex3f(1.0, 0.0, 0.0)
     glEnd()
     glPushMatrix()
     glTranslated(1.0, 0.0, 0.0)
     glRotated(90, 0.0, 1.0, 0.0)
     glutSolidCone(0.05, 0.2, 16, 16)
     glPopMatrix()
     glBegin(GL_LINES)
     glVertex3f(0.0, -1.0, 0.0)
     glVertex3f(0.0, 1.0, 0.0)
     glEnd()
     glPushMatrix()
     glTranslated(0.0, 1.0, 0.0)
     glRotated(-90, 1.0, 0.0, 0.0)
     glutSolidCone(0.05, 0.2, 16, 16)
     glPopMatrix()
     glBegin(GL_LINES)
     glVertex3f(0.0, 0.0, -1.0)
     glVertex3f(0.0, 0.0, 1.0)
     glEnd()
     glPushMatrix()
     glTranslated(0.0, 0.0, 1.0)
     glutSolidCone(0.05, 0.2, 16, 16)
     glPopMatrix()
     glPopMatrix()
コード例 #21
0
def make_plane():
    glNewList(G_OBJ_PLANE, GL_COMPILE)
    glBegin(GL_LINES)
    glColor3f(0, 0, 0)
    for i in xrange(41):
        glVertex3f(-10.0 + 0.5 * i, 0, -10)
        glVertex3f(-10.0 + 0.5 * i, 0, 10)
        glVertex3f(-10.0, 0, -10 + 0.5 * i)
        glVertex3f(10.0, 0, -10 + 0.5 * i)

    # Axes
    glEnd()
    glLineWidth(5)

    glBegin(GL_LINES)
    glColor3f(0.5, 0.7, 0.5)
    glVertex3f(0.0, 0.0, 0.0)
    glVertex3f(5, 0.0, 0.0)
    glEnd()

    glBegin(GL_LINES)
    glColor3f(0.5, 0.7, 0.5)
    glVertex3f(0.0, 0.0, 0.0)
    glVertex3f(0.0, 5, 0.0)
    glEnd()

    glBegin(GL_LINES)
    glColor3f(0.5, 0.7, 0.5)
    glVertex3f(0.0, 0.0, 0.0)
    glVertex3f(0.0, 0.0, 5)
    glEnd()

    # Draw the Y.
    glBegin(GL_LINES)
    glColor3f(0.0, 0.0, 0.0)
    glVertex3f(0.0, 5.0, 0.0)
    glVertex3f(0.0, 5.5, 0.0)
    glVertex3f(0.0, 5.5, 0.0)
    glVertex3f(-0.5, 6.0, 0.0)
    glVertex3f(0.0, 5.5, 0.0)
    glVertex3f(0.5, 6.0, 0.0)

    # Draw the Z.
    glVertex3f(-0.5, 0.0, 5.0)
    glVertex3f(0.5, 0.0, 5.0)
    glVertex3f(0.5, 0.0, 5.0)
    glVertex3f(-0.5, 0.0, 6.0)
    glVertex3f(-0.5, 0.0, 6.0)
    glVertex3f(0.5, 0.0, 6.0)

    # Draw the X.
    glVertex3f(5.0, 0.0, 0.5)
    glVertex3f(6.0, 0.0, -0.5)
    glVertex3f(5.0, 0.0, -0.5)
    glVertex3f(6.0, 0.0, 0.5)

    glEnd()
    glLineWidth(1)
    glEndList()
コード例 #22
0
ファイル: primitive.py プロジェクト: 0x55aa/500lines
def make_plane():
    glNewList(G_OBJ_PLANE, GL_COMPILE)
    glBegin(GL_LINES)
    glColor3f(0, 0, 0)
    for i in xrange(41):
        glVertex3f(-10.0 + 0.5 * i, 0, -10)
        glVertex3f(-10.0 + 0.5 * i, 0, 10)
        glVertex3f(-10.0, 0, -10 + 0.5 * i)
        glVertex3f(10.0, 0, -10 + 0.5 * i)

    # Axes
    glEnd()
    glLineWidth(5)

    glBegin(GL_LINES)
    glColor3f(0.5, 0.7, 0.5)
    glVertex3f(0.0, 0.0, 0.0)
    glVertex3f(5, 0.0, 0.0)
    glEnd()

    glBegin(GL_LINES)
    glColor3f(0.5, 0.7, 0.5)
    glVertex3f(0.0, 0.0, 0.0)
    glVertex3f(0.0, 5, 0.0)
    glEnd()

    glBegin(GL_LINES)
    glColor3f(0.5, 0.7, 0.5)
    glVertex3f(0.0, 0.0, 0.0)
    glVertex3f(0.0, 0.0, 5)
    glEnd()

    # Draw the Y.
    glBegin(GL_LINES)
    glColor3f(0.0, 0.0, 0.0)
    glVertex3f(0.0, 5.0, 0.0)
    glVertex3f(0.0, 5.5, 0.0)
    glVertex3f(0.0, 5.5, 0.0)
    glVertex3f(-0.5, 6.0, 0.0)
    glVertex3f(0.0, 5.5, 0.0)
    glVertex3f(0.5, 6.0, 0.0)

    # Draw the Z.
    glVertex3f(-0.5, 0.0, 5.0)
    glVertex3f(0.5, 0.0, 5.0)
    glVertex3f(0.5, 0.0, 5.0)
    glVertex3f(-0.5, 0.0, 6.0)
    glVertex3f(-0.5, 0.0, 6.0)
    glVertex3f(0.5, 0.0, 6.0)

    # Draw the X.
    glVertex3f(5.0, 0.0, 0.5)
    glVertex3f(6.0, 0.0, -0.5)
    glVertex3f(5.0, 0.0, -0.5)
    glVertex3f(6.0, 0.0, 0.5)

    glEnd()
    glLineWidth(1)
    glEndList()
 def bordes_plano_horizontal(self):
     if self.programa.ajustes.ver_plano_horizontal.isChecked():
         glLineWidth(1)
         glColor(self.programa.ajustes.color_plano_horizontal)
         glBegin(GL_LINE_LOOP)
         for vertex in range(4):
             glVertex(self.vertices_borde_plano_horizontal[vertex])
         glEnd()
コード例 #24
0
ファイル: opengl_draw_2d.py プロジェクト: akuczala/4d-game
def draw_rectangle(width, height, color, line_width=2):
    glColor3f(*color)
    glLineWidth(line_width)
    glBegin(GL_LINE_LOOP)
    for coords in [[1, 1], [1, -1], [-1, -1], [-1, 1]]:
        glVertex2f(*shift_scale_point(
            vec.Vec([width / 2, height / 2]) * vec.Vec(coords)))
    glEnd()
コード例 #25
0
ファイル: tools.py プロジェクト: yuhangwang/zeobuilder
 def _rectangle(self, r1, r2):
     glColor(1, 1, 1)
     glLineWidth(1)
     glBegin(GL_LINE_LOOP)
     glVertex3f(r1[0], r1[1], 0.0)
     glVertex3f(r2[0], r1[1], 0.0)
     glVertex3f(r2[0], r2[1], 0.0)
     glVertex3f(r1[0], r2[1], 0.0)
     glEnd()
コード例 #26
0
ファイル: opengl_draw_2d.py プロジェクト: akuczala/4d-game
def draw_lines_2d(lines, color, line_width=2):

    glColor3f(*color)
    glLineWidth(line_width)
    glBegin(GL_LINES)
    for line in lines:
        for point in line:
            glVertex2f(*shift_scale_point(point))
    glEnd()
コード例 #27
0
ファイル: opengl_draw_2d.py プロジェクト: akuczala/4d-game
def draw_points_2d(points, color, line_width=2):
    glColor3f(*color)
    #draw each point as a line with (almost) identical start and end points
    glLineWidth(line_width)
    for point in points:
        glBegin(GL_LINES)
        glVertex2f(*shift_scale_point(point))
        glVertex2f(*(shift_scale_point(point) + vec.Vec([1, 0])))
        glEnd()
コード例 #28
0
ファイル: tools.py プロジェクト: molmod/zeobuilder
 def _rectangle(self, r1, r2):
     glColor(1, 1, 1)
     glLineWidth(1)
     glBegin(GL_LINE_LOOP)
     glVertex3f(r1[0], r1[1], 0.0)
     glVertex3f(r2[0], r1[1], 0.0)
     glVertex3f(r2[0], r2[1], 0.0)
     glVertex3f(r1[0], r2[1], 0.0)
     glEnd()
コード例 #29
0
def draw_arrowhead(x1,
                   y1,
                   x2,
                   y2,
                   noderadius,
                   arrowwidth=20,
                   angle=20,
                   trans=1.0):
    '''
    Draws an arrow head on the line segment between the coordinate pairs
    (x1,y1) and (x2,y2). The arrow head is placed in the (x2,y2)-end.
    '''
    if x1 - x2 == 0:
        if y2 <= y1:
            LineAngle = math.pi / 2
        else:
            LineAngle = 3 * math.pi / 2
    else:
        LineAngle = math.atan((y2 - y1) / (x2 - x1))

    EndAngle1 = LineAngle + angle * math.pi / 180
    EndAngle2 = LineAngle - angle * math.pi / 180

    xOffset = noderadius * math.cos(LineAngle)
    yOffset = noderadius * math.sin(LineAngle)
    if x1 < x2:
        Y3 = y2 - arrowwidth * math.sin(EndAngle1)
        Y4 = y2 - arrowwidth * math.sin(EndAngle2)
        X3 = x2 - arrowwidth * math.cos(EndAngle1)
        X4 = x2 - arrowwidth * math.cos(EndAngle2)

        x2 -= xOffset
        y2 -= yOffset
        Y3 -= yOffset
        Y4 -= yOffset
        X3 -= xOffset
        X4 -= xOffset
    else:
        Y3 = y2 + arrowwidth * math.sin(EndAngle1)
        Y4 = y2 + arrowwidth * math.sin(EndAngle2)
        X3 = x2 + arrowwidth * math.cos(EndAngle1)
        X4 = x2 + arrowwidth * math.cos(EndAngle2)
        x2 += xOffset
        y2 += yOffset
        Y3 += yOffset
        Y4 += yOffset
        X3 += xOffset
        X4 += xOffset

    glLineWidth(1.0)
    glColor4f(arrow_color()[0], arrow_color()[1], arrow_color()[2], trans)
    glBegin(GL_TRIANGLES)
    glVertex2f(x2, y2)
    glVertex2f(X3, Y3)
    glVertex2f(X4, Y4)
    glEnd()
コード例 #30
0
 def draw_border(self):
     bw, bh = self.size
     #double size since half the line will be off-screen
     log("draw_border: %s", self.border)
     glLineWidth(self.border.size*2)
     glBegin(GL_LINE_LOOP)
     glColor4f(self.border.red, self.border.green, self.border.blue, self.border.alpha)
     for px,py in ((0, 0), (bw, 0), (bw, bh), (0, bh)):
         glVertex2i(px, py)
     glEnd()
コード例 #31
0
    def _draw(self):
        glLineWidth(4.0)

        glBegin(GL_LINES)

        glColor3f(119, 25, 25)
        for path in list(self._path_queue):
            glVertex3f(path[0] * self._resolution_meter -4,path[1] * self._resolution_meter,5)
            glVertex3f(path[0]* self._resolution_meter+4,path[1] * self._resolution_meter,5)

        glEnd()
コード例 #32
0
    def draw_Dierkes_lines(self, result):

        glPushMatrix()
        glMatrixMode(GL_MODELVIEW)
        glColor4f(1.0, 0.0, 0.0, 0.1)
        glLineWidth(1.0)
        for line in result["debug_info"]["Dierkes_lines"][::4]:
            glBegin(GL_LINES)
            glVertex3f(line[0], line[1], line[2])
            glVertex3f(line[3], line[4], line[5])
            glEnd()
        glPopMatrix()
コード例 #33
0
ファイル: hardware.py プロジェクト: leriomaggio/rainbowalga
 def draw_lines(self, line_width=1):
     glEnable(GL_DEPTH_TEST)
     glShadeModel(GL_FLAT)
     for position in self.line_positions:
         glPushMatrix()
         glTranslated(position[0], position[1], 0)
         glLineWidth(line_width)
         glBegin(GL_LINES)
         glVertex3f(0.0, 0.0, self.z_min)
         glVertex3f(0.0, 0.0, self.z_max)
         glEnd()
         glPopMatrix()
コード例 #34
0
ファイル: hardware.py プロジェクト: leriomaggio/rainbowalga
 def draw(self, line_width=2):
     glEnable(GL_DEPTH_TEST)
     glShadeModel(GL_FLAT)
     glPushMatrix()
     glTranslated(self.x, self.y, self.z)
     glLineWidth(line_width)
     glColor3f(1.0, 1.0, 1.0)
     glBegin(GL_LINES)
     glVertex3f(0.0, 0.0, 0.0)
     glVertex3f(0.0, 0.0, self.length)
     glEnd()
     glPopMatrix()
コード例 #35
0
ファイル: drawers.py プロジェクト: vcsrc/nanoengineer
def drawLineLoop(color, lines, width=1):
    glDisable(GL_LIGHTING)
    glColor3fv(color)
    glLineWidth(width)
    glBegin(GL_LINE_LOOP)
    for v in lines:
        glVertex3fv(v)
    glEnd()
    glEnable(GL_LIGHTING)
    #reset the glLineWidth to 1
    if width != 1:
        glLineWidth(1)
    return
コード例 #36
0
ファイル: drawers.py プロジェクト: ematvey/NanoEngineer-1
def drawLineLoop(color,lines, width = 1):
    glDisable(GL_LIGHTING)
    glColor3fv(color)
    glLineWidth(width)
    glBegin(GL_LINE_LOOP)
    for v in lines:
        glVertex3fv(v)
    glEnd()
    glEnable(GL_LIGHTING)  
    #reset the glLineWidth to 1
    if width!=1:
        glLineWidth(1)
    return
コード例 #37
0
ファイル: opengl_draw_2d.py プロジェクト: akuczala/4d-game
def draw_circle_2d(radius,
                   color,
                   n_points=60,
                   line_width=2,
                   draw_origin=vec.zero_vec(2)):
    glColor3f(*color)
    glLineWidth(line_width)
    glBegin(GL_LINE_LOOP)
    for i in range(n_points):
        x = math.cos(math.pi * 2 * i / n_points) * radius
        y = math.sin(math.pi * 2 * i / n_points) * radius
        p = vec.Vec([x, y]) + draw_origin
        glVertex2f(*shift_scale_point(p))
    glEnd()
コード例 #38
0
    def _draw(self):
        if self._cross is None:
            return

        glLineWidth(3.0)
        glBegin(GL_LINES)

        glColor3f(1.0, 0.0, 0.0)
        glVertex3f(self._cross[0] - 20, self._cross[1] - 20, 10)
        glVertex3f(self._cross[0] + 20, self._cross[1] + 20, 10)
        glVertex3f(self._cross[0] - 20, self._cross[1] + 20, 10)
        glVertex3f(self._cross[0] + 20, self._cross[1] - 20, 10)

        glEnd()
コード例 #39
0
 def render_border(self):
     from OpenGL.GL import glColor3f, glLineWidth, glBegin, glEnd, glVertex3f, GL_LINE_LOOP
     for border_loop in self.border_loop_list:
         scale = 1.001
         glColor3f(0.0, 0.0, 0.0)
         glLineWidth(4.0)
         glBegin(GL_LINE_LOOP)
         try:
             for i in border_loop:
                 point = self.vertex_list[i].clone()
                 point *= scale      # This idea won't work in all cases.
                 glVertex3f(point.x, point.y, point.z)
         finally:
             glEnd()
コード例 #40
0
ファイル: physics.py プロジェクト: leriomaggio/rainbowalga
    def draw(self, time, line_width=None):
        if self.hidden:
            return
        time = time * 1e-9
        if time <= self.time:
            return

        pos_start = self.pos + (self.speed * (-self.time) * self.dir)
        path = self.speed * (time - self.time) * self.dir
        if self.length:
            max_path = self.length * self.dir
            if np.linalg.norm(max_path) <= np.linalg.norm(path):
                path = max_path
        pos_end = self.pos + path

        glPushMatrix()
        if line_width:
            glLineWidth(line_width)
        else:
            glLineWidth(self.line_width)
        glColor3f(*self.color)
        glBegin(GL_LINES)
        glVertex3f(*pos_start)
        glVertex3f(*pos_end)
        glEnd()
        glPopMatrix()

        if self.cherenkov_cone_enabled and self.colourist.cherenkov_cone_enabled:

            height = np.linalg.norm(pos_end - pos_start)
            position = pos_end - self.dir * height

            glEnable(GL_LIGHTING)
            glEnable(GL_DEPTH_TEST)
            glShadeModel(GL_FLAT)
            glColor4f(0.0, 0.0, 0.8, 0.3)

            glPushMatrix()
            glTranslated(*position)
            glPushMatrix()

            v = np.array(self.dir)
            glMultMatrixf(transform(v))

            glutSolidCone(0.6691 * height, height, 128, 64)
            glPopMatrix()
            glPopMatrix()

            glDisable(GL_LIGHTING)
コード例 #41
0
    def _render_highlighted(self) -> None:
        """Render cube outline on face that is hovered."""
        if not self._hovered:
            return

        glDisable(GL_DEPTH_TEST)
        glLineWidth(2.0)
        glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)

        glBindVertexArray(self._vao_outline)
        glDrawArrays(GL_QUADS, self._hover_id * 4, 4)

        glEnable(GL_DEPTH_TEST)
        glLineWidth(1.0)
        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
コード例 #42
0
ファイル: opengl_draw_3d.py プロジェクト: akuczala/4d-game
def draw_points_3d(points, color, draw_origin, draw_angles, line_width=2):
    gl.glLoadIdentity()  # reset position
    gl.glTranslatef(*draw_origin)
    #origin of plotting
    gl.glRotatef(draw_angles[1], 1, 0, 0)
    gl.glRotatef(draw_angles[0], 0, 1, 0)

    glColor3f(*color)
    #draw each point as a line with (almost) identical start and end points
    glLineWidth(line_width)
    for point in points:
        glBegin(GL_LINES)
        glVertex3f(*point)
        glVertex3f(*(point + vec.Vec([0.01, 0, 0])))
        glEnd()
コード例 #43
0
    def _draw(self):
        glLineWidth(4.0)

        glBegin(GL_LINES)

        glColor3f(0.5, 0.5, 0.5)
        glVertex3f(0.0, 0.0, 0.0)
        glVertex3f(50.0, 0.0, 1.0)

        glVertex3f(0.0, 0.0, 0.0)
        glVertex3f(0.0, 50.0, 1.0)

        glVertex3f(0.0, 0.0, 0.0)
        glVertex3f(0.0, 0.0, 50.0)

        glEnd()
コード例 #44
0
ファイル: vis.py プロジェクト: branchvincent/arc-reactor
    def draw(self):
        glDisable(GL_LIGHTING)

        glLineWidth(self._width)
        glColor(*self._color)

        glEnableClientState(GL_VERTEX_ARRAY)

        if self._vbo:
            with self._vbo:
                glVertexPointerf(self._vbo)
                glDrawArrays(GL_LINE_STRIP, 0, len(self._vbo))

        glDisableClientState(GL_VERTEX_ARRAY)

        glEnable(GL_LIGHTING)
コード例 #45
0
ファイル: basicgui.py プロジェクト: reims/wesen
 def _initGL(self, extraArgs):
     """initializes OpenGL and creates the Window"""
     glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB)
     glutInitWindowSize(self.size, self.size)
     glutInitWindowPosition(self.initx, self.inity)
     glutInit(extraArgs.split(" "))
     glutCreateWindow(VERSIONSTRING.encode("ascii"))
     glutDisplayFunc(self.Draw)
     glutIdleFunc(glutPostRedisplay)
     glutReshapeFunc(self.Reshape)
     glutKeyboardFunc(self.HandleKeys)
     glutSpecialFunc(self.HandleKeys)
     glutMouseFunc(self.HandleMouse)
     glClearColor(*(self.bgcolor + [0.0]))
     glEnable(GL_LINE_SMOOTH)
     glLineWidth(1.3)
コード例 #46
0
ファイル: desktop-multi.py プロジェクト: gavine199/pymt
    def draw(self):
        # draw gestures
        set_color(1, 1, 1, .6)
        for touch in getCurrentTouches():
            if not 'desktop.gesture' in touch.userdata:
                continue
            drawLine(touch.userdata['desktop.gesture'], width=5.)

        if len(getCurrentTouches()):
            self.inactivity = 0
            return
        self.inactivity += getFrameDt()
        if self.inactivity < self.inactivity_timeout:
            return
        alpha = (self.inactivity - self.inactivity_timeout) / 3.
        alpha = boundary(alpha, 0, 1.)

        w = self.get_parent_window()
        s2 = Vector(w.size) / 2.
        self.dt += getFrameDt() * 2

        step = math.pi / 20.
        radius = 50
        i = 0
        with DO(gx_attrib(GL_LINE_BIT), gx_blending):
            glLineWidth(3)
            with gx_begin(GL_LINE_STRIP):
                while i < math.pi * 2:
                    x, y = math.cos(self.dt - i) * radius, math.sin(self.dt -
                                                                    i) * radius
                    glColor4f(1, 1, 1, min(alpha, i / math.pi))
                    glVertex2f(x + s2.x, y + s2.y - 70)
                    i += step

            set_color(1, 1, 1, alpha)
            drawCircle(pos=(x + s2.x, y + s2.y - 70), radius=4)
            drawCircle(pos=(x + s2.x, y + s2.y - 70), radius=20, linewidth=2)

        label = 'Draw a circle to make the menu appear'
        k = {'font_size': 24, 'bold': True}
        pos = Vector(w.size) / 2. + Vector(0, 10)
        drawLabel(label=label,
                  pos=pos,
                  color=(.5, .5, .5, min(alpha, .5)),
                  **k)
        pos += Vector(1, -1)
        drawLabel(label=label, pos=pos, color=(1, 1, 2, alpha), **k)
コード例 #47
0
 def paint_box(self, encoding, is_delta, x, y, w, h):
     #show region being painted if debug paint box is enabled only:
     if self.paint_box_line_width<=0:
         return
     glLineWidth(self.paint_box_line_width+0.5+int(encoding=="scroll")*2)
     if is_delta:
         glLineStipple(1, 0xaaaa)
         glEnable(GL_LINE_STIPPLE)
     glBegin(GL_LINE_LOOP)
     color = get_paint_box_color(encoding)
     log("Painting colored box around %s screen update using: %s (delta=%s)", encoding, color, is_delta)
     glColor4f(*color)
     for px,py in ((x, y), (x+w, y), (x+w, y+h), (x, y+h)):
         glVertex2i(px, py)
     glEnd()
     if is_delta:
         glDisable(GL_LINE_STIPPLE)
コード例 #48
0
    def display(self):
        self.world.drawGL()

        glDisable(GL_LIGHTING)
        glLineWidth(2.0)

        glEnableClientState(GL_VERTEX_ARRAY)

        for (color, vbo) in self.trace_vbos:
            glColor(*color)
            with vbo:
                glVertexPointerf(vbo)
                glDrawArrays(GL_LINE_STRIP, 0, len(vbo))

        glDisableClientState(GL_VERTEX_ARRAY)

        glEnable(GL_LIGHTING)
コード例 #49
0
ファイル: tip.py プロジェクト: sehoonha/pydart_private
 def render(self):
     glLineWidth(3.0)
     glColor(0.7, 0.0, 0.0, 1.0)
     gltools.glMove([0.0, 0.0, 0.0])
     glBegin(GL_LINE_STRIP)
     for p in [self.p1, self.C, self.p2]:
         glVertex(p)
     glEnd()
     glColor(0.545, 0.000, 0.000, 1.0)
     gltools.glMove(self.p1)
     glutSolidSphere(0.03, 4, 2)
     glColor(1.000, 0.843, 0.000, 1.0)
     gltools.glMove(self.C)
     glutSolidSphere(0.03, 4, 2)
     glColor(0.294, 0.000, 0.510, 1.0)
     gltools.glMove(self.p2)
     glutSolidSphere(0.03, 4, 2)
     glLineWidth(1.0)
コード例 #50
0
    def _paintGLCoorsystem(self):
        glLineWidth(10.0)

        glBegin(GL_LINES)

        glColor3f(1.0, 0.0, 0.0)
        glVertex3f(0.0, 0.0, 0.0)
        glVertex3f(1.0, 0.0, 0.0)

        glColor3f(0.0, 1.0, 0.0)
        glVertex3f(0.0, 0.0, 0.0)
        glVertex3f(0.0, 1.0, 0.0)

        glColor3f(0.0, 0.0, 1.0)
        glVertex3f(0.0, 0.0, 0.0)
        glVertex3f(0.0, 0.0, 1.0)

        glEnd()
コード例 #51
0
    def _draw(self):
        try:

            self._lock.acquire()
            gridded_area_size = 1500

            glLineWidth(1.0)

            num_of_lines = int(gridded_area_size / self._resolution_meters)
            glBegin(GL_LINES)

            glColor3f(0.188, 0.188, 0.188)

            glVertex3f(gridded_area_size, 0, 0)
            glVertex3f(-gridded_area_size, 0, 0)
            glVertex3f(0, gridded_area_size, 0)
            glVertex3f(0, -gridded_area_size, 0)


            for i in range(num_of_lines):
                glVertex3f(self._resolution_meters * i, -gridded_area_size, 0)
                glVertex3f(self._resolution_meters * i, gridded_area_size, 0)
                glVertex3f(gridded_area_size, self._resolution_meters * i, 0)
                glVertex3f(-gridded_area_size, self._resolution_meters * i, 0)

                glVertex3f(self._resolution_meters * (-i), -gridded_area_size, 0)
                glVertex3f(self._resolution_meters * (-i), gridded_area_size, 0)
                glVertex3f(gridded_area_size, self._resolution_meters * (-i), 0)
                glVertex3f(-gridded_area_size, self._resolution_meters * (-i), 0)

            glEnd()

            glLineWidth(3.0)
            glBegin(GL_LINES)

            glVertex3f(0, -gridded_area_size, 0)
            glVertex3f(0, gridded_area_size, 0)

            glVertex3f(gridded_area_size, 0, 0)
            glVertex3f(-gridded_area_size, 0, 0)

            glEnd()
        finally:
            self._lock.release()
コード例 #52
0
ファイル: gui_widgets.py プロジェクト: xDMxosiris/hekate
 def __draw(self, widget, event):
     x = self.__distance * sin(self.__angle)
     z = self.__distance * cos(self.__angle)
     gldrawable = widget.get_gl_drawable()
     glcontext = widget.get_gl_context()
     # OpenGL begin.
     if not gldrawable.gl_begin(glcontext):
         return
     glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
     glLoadIdentity ()
     gluLookAt(x, 0.0, z, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0)  
     #==========================
     glPushMatrix()
     glLineWidth(3)
     glRotatef(self.__arm_angles[0], 1., 0., 0.)
     glRotatef(self.__arm_angles[1], 0., 1., 0.)
     glRotatef(self.__arm_angles[2], 0., 0., 1.)
     glTranslatef(self.__upper_arm, 0., 0.)
     #==========================
     glPushMatrix()
     glColor3f(30./255., 126./255., 30./255.)
     glScalef(self.__upper_arm, 0.4, 1.0)
     self.__draw_cube()       # shoulder
     glPopMatrix()
     #==========================
     glTranslatef(self.__upper_arm, 0., 0.)
     glRotatef(self.__arm_angles[3] , 0., 0., 1.)
     glTranslatef(self.__forearm, 0., 0.)
     glPushMatrix()
     #==========================
     glScalef(self.__forearm, 0.3, 0.75)
     glColor3f(126./255., 30./255., 30./255.)
     self.__draw_cube()      # elbow
     glPopMatrix()
     glPopMatrix()
     #==========================
     if gldrawable.is_double_buffered():
         gldrawable.swap_buffers()
     else:
         glFlush()
     gldrawable.gl_end()
     # OpenGL end
     return
コード例 #53
0
ファイル: speechbubble.py プロジェクト: Markitox/pymt
    def draw(self):

        # extract relative position
        rx, ry = self.relpos

        # calculate triangle
        mx = self.x + rx + self.width * 0.5 + self.trirelpos[0]
        my = self.y + ry + self.height * 0.5 + self.trirelpos[1]
        angle = Vector(1, 0).angle(Vector(mx - self.x, my - self.y))
        vpos = Vector(mx, my)
        v1 = Vector(self.trisize, 0).rotate(angle) + vpos
        v2 = Vector(-self.trisize, 0).rotate(angle) + vpos

        # draw border
        if self.bordersize > 0:
            drawRoundedRectangle(
                pos=(self.x - self.padding - self.bordersize + rx,
                     self.y - self.padding - self.bordersize + ry),
                size=(self.width + self.padding * 2 + self.bordersize * 2,
                      self.height + self.padding * 2 + self.bordersize * 2),
                radius=self.radius,
                color=self.bordercolor
            )

            glEnable(GL_LINE_SMOOTH)
            glLineWidth(self.bordersize * 2)
            drawPolygon((self.x, self.y, v1.x, v1.y, v2.x, v2.y), style=GL_LINE_LOOP)

        # draw background
        drawRoundedRectangle(
            pos=(self.x - self.padding + rx,
                 self.y - self.padding + ry),
            size=(self.width + self.padding * 2,
                  self.height + self.padding * 2),
            radius=self.radius,
            color=self.bgcolor
        )
        drawPolygon((self.x, self.y, v1.x, v1.y, v2.x, v2.y))

        # hack to translate label position
        with gx_matrix:
            glTranslatef(rx, ry, 0)
            super(MTSpeechBubble, self).draw()
コード例 #54
0
 def paint_box(self, encoding, is_delta, x, y, w, h):
     #show region being painted if debug paint box is enabled only:
     if not OPENGL_PAINT_BOX>0:
         return
     glDisable(GL_TEXTURE_RECTANGLE_ARB)
     glDisable(GL_FRAGMENT_PROGRAM_ARB)
     glLineWidth(OPENGL_PAINT_BOX+0.5)
     if is_delta:
         glLineStipple(1, 0xaaaa)
         glEnable(GL_LINE_STIPPLE)
     glBegin(GL_LINE_LOOP)
     color = BOX_COLORS.get(encoding, _DEFAULT_BOX_COLOR)
     log("Painting colored box around %s screen update using: %s (delta=%s)", encoding, color, is_delta)
     glColor4f(*color)
     for px,py in ((x, y), (x+w, y), (x+w, y+h), (x, y+h)):
         glVertex2i(px, py)
     glEnd()
     if is_delta:
         glDisable(GL_LINE_STIPPLE)
コード例 #55
0
ファイル: desktop-multi.py プロジェクト: hansent/pymt
    def draw(self):
        # draw gestures
        set_color(1, 1, 1, 0.6)
        for touch in getCurrentTouches():
            if not "desktop.gesture" in touch.userdata:
                continue
            drawLine(touch.userdata["desktop.gesture"], width=5.0)

        if len(getCurrentTouches()):
            self.inactivity = 0
            return
        self.inactivity += getFrameDt()
        if self.inactivity < self.inactivity_timeout:
            return
        alpha = (self.inactivity - self.inactivity_timeout) / 3.0
        alpha = boundary(alpha, 0, 1.0)

        w = self.get_parent_window()
        s2 = Vector(w.size) / 2.0
        self.dt += getFrameDt() * 2

        step = math.pi / 20.0
        radius = 50
        i = 0
        with DO(gx_attrib(GL_LINE_BIT), gx_blending):
            glLineWidth(3)
            with gx_begin(GL_LINE_STRIP):
                while i < math.pi * 2:
                    x, y = math.cos(self.dt - i) * radius, math.sin(self.dt - i) * radius
                    glColor4f(1, 1, 1, min(alpha, i / math.pi))
                    glVertex2f(x + s2.x, y + s2.y - 70)
                    i += step

            set_color(1, 1, 1, alpha)
            drawCircle(pos=(x + s2.x, y + s2.y - 70), radius=4)
            drawCircle(pos=(x + s2.x, y + s2.y - 70), radius=20, linewidth=2)

        label = "Draw a circle to make the menu appear"
        k = {"font_size": 24, "bold": True}
        pos = Vector(w.size) / 2.0 + Vector(0, 10)
        drawLabel(label=label, pos=pos, color=(0.5, 0.5, 0.5, min(alpha, 0.5)), **k)
        pos += Vector(1, -1)
        drawLabel(label=label, pos=pos, color=(1, 1, 2, alpha), **k)
コード例 #56
0
ファイル: physics.py プロジェクト: leriomaggio/rainbowalga
    def draw(self, time, line_width=None):
        if self.hidden:
            return
        time = time * 1e-9

        pos_start = self.start_pos + (constants.c * (-self.time) * self.dir)
        if time >= self.time:
            pos_end = self.pos
        else:
            path = constants.c * (time - self.time) * self.dir
            pos_end = self.pos + path

        glPushMatrix()
        glLineWidth(self.line_width)
        glColor3f(*self.color)
        glBegin(GL_LINES)
        glVertex3f(*pos_start)
        glVertex3f(*pos_end)
        glEnd()
        glPopMatrix()
コード例 #57
0
def startPatternedDrawing(highlight = False, select = False):
    """
    Start drawing with a patterned style, if either highlight or select is
    passed as True, and the corresponding preference is set to select a
    patterned drawing style.

    This is common code for two different prefs keys, each of which has its own
    set of settings constants...

    Return value is True if one of the patterned styles is selected.
    """
    (key, style, solid, pattern, edges, halos) = \
          _decodePatternPrefs(highlight, select)

    if solid:
        # Nothing to do here for solid colors.
        return False

    # Set up stipple-patterned drawing styles.
    if pattern is not None:
        glEnable(GL_POLYGON_STIPPLE)
        glPolygonStipple(pattern)
        return True

    # Both polygon edges and halos are drawn in line-mode.
    if edges or halos:
        glPolygonMode(GL_FRONT, GL_LINE)
        glPolygonMode(GL_BACK, GL_LINE)

        if halos:
            # Draw wide, unshaded lines, offset a little bit away from the
            # viewer so that only the silhouette edges are visible.
            glDisable(GL_LIGHTING)
            glLineWidth(env.prefs[haloWidth_prefs_key])
            glEnable(GL_POLYGON_OFFSET_LINE)
            glPolygonOffset(0.0, 5.e4) # Constant offset.
            pass

        pass
    return True
コード例 #58
0
ファイル: drawers.py プロジェクト: ematvey/NanoEngineer-1
def drawAxis(color, pos1, pos2, width = 2): #Ninad 060907
    """
    Draw chunk or jig axis
    """
    #ninad060907 Note that this is different than draw 
    # I may need this function to draw axis line. see its current implementation
    # in branch "ninad_060908_drawAxis_notAsAPropOfObject"
    glDisable(GL_LIGHTING)
    glColor3fv(color)
    glLineStipple(3, 0x1C47) # dash-dot-dash line
    glEnable(GL_LINE_STIPPLE)
    if width != 1:
        glLineWidth(width)
    glBegin(GL_LINES)
    glVertex(pos1[0], pos1[1], pos1[2])
    glVertex(pos2[0], pos2[1], pos2[2])
    glEnd()
    if width != 1:
        glLineWidth(1.0) # restore default state
    glDisable(GL_LINE_STIPPLE)
    glEnable(GL_LIGHTING)
    return