示例#1
0
    def _draw_exception(self, context):
        """OpenGL drawing code for the EXCEPTION state."""

        import textwrap

        content_height, content_width = self._window_size(context)

        bgl.glEnable(bgl.GL_BLEND)
        bgl.glColor4f(0.2, 0.0, 0.0, 0.6)
        bgl.glRectf(0, 0, content_width, content_height)

        font_id = 0
        ex = self.async_task.exception()
        if isinstance(ex, pillar.UserNotLoggedInError):
            ex_msg = 'You are not logged in on Blender ID. Please log in at User Preferences, ' \
                     'System, Blender ID.'
        else:
            ex_msg = str(ex)
            if not ex_msg:
                ex_msg = str(type(ex))
        text = "An error occurred:\n%s" % ex_msg
        lines = textwrap.wrap(text)

        bgl.glColor4f(1.0, 1.0, 1.0, 1.0)
        blf.size(font_id, 20, 72)
        _, text_height = blf.dimensions(font_id, 'yhBp')

        def position(line_nr):
            blf.position(font_id, content_width * 0.1,
                         content_height * 0.8 - line_nr * text_height, 0)

        for line_idx, line in enumerate(lines):
            position(line_idx)
            blf.draw(font_id, line)
        bgl.glDisable(bgl.GL_BLEND)
示例#2
0
 def draw(self, context, render=False):
     if self.image is None:
         return
     bgl.glPushAttrib(bgl.GL_ENABLE_BIT)
     p0 = self.pts[0]
     p1 = self.pts[1]
     bgl.glEnable(bgl.GL_BLEND)
     bgl.glColor4f(*self.colour)
     bgl.glRectf(p0.x, p0.y, p1.x, p1.y)
     self.image.gl_load()
     bgl.glEnable(bgl.GL_BLEND)
     bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.image.bindcode[0])
     bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MIN_FILTER, bgl.GL_NEAREST)
     bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MAG_FILTER, bgl.GL_NEAREST)
     bgl.glEnable(bgl.GL_TEXTURE_2D)
     bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA)
     # bgl.glColor4f(1, 1, 1, 1)
     bgl.glBegin(bgl.GL_QUADS)
     bgl.glTexCoord2d(0, 0)
     bgl.glVertex2d(p0.x, p0.y)
     bgl.glTexCoord2d(0, 1)
     bgl.glVertex2d(p0.x, p1.y)
     bgl.glTexCoord2d(1, 1)
     bgl.glVertex2d(p1.x, p1.y)
     bgl.glTexCoord2d(1, 0)
     bgl.glVertex2d(p1.x, p0.y)
     bgl.glEnd()
     self.image.gl_free()
     bgl.glDisable(bgl.GL_TEXTURE_2D)
示例#3
0
    def _draw_browser(self, context):
        """OpenGL drawing code for the BROWSING state."""

        window_region = self._window_region(context)
        content_width = window_region.width - ITEM_MARGIN_X * 2
        content_height = window_region.height - ITEM_MARGIN_Y * 2

        content_x = ITEM_MARGIN_X
        content_y = context.area.height - ITEM_MARGIN_Y - TARGET_ITEM_HEIGHT

        col_count = content_width // TARGET_ITEM_WIDTH

        item_width = (content_width - (col_count * ITEM_PADDING_X)) / col_count
        item_height = TARGET_ITEM_HEIGHT

        block_width = item_width + ITEM_PADDING_X
        block_height = item_height + ITEM_MARGIN_Y

        bgl.glEnable(bgl.GL_BLEND)
        bgl.glColor4f(0.0, 0.0, 0.0, 0.6)
        bgl.glRectf(0, 0, window_region.width, window_region.height)

        if self.current_display_content:
            bottom_y = float('inf')

            # The -1 / +2 are for extra rows that are drawn only half at the top/bottom.
            first_item_idx = max(0, int(-self.scroll_offset // block_height - 1) * col_count)
            items_per_page = int(content_height // item_height + 2) * col_count
            last_item_idx = first_item_idx + items_per_page

            for item_idx, item in enumerate(self.current_display_content):
                x = content_x + (item_idx % col_count) * block_width
                y = content_y - (item_idx // col_count) * block_height - self.scroll_offset

                item.update_placement(x, y, item_width, item_height)

                if first_item_idx <= item_idx < last_item_idx:
                    # Only draw if the item is actually on screen.
                    item.draw(highlighted=item.hits(self.mouse_x, self.mouse_y))

                bottom_y = min(y, bottom_y)
            self.scroll_offset_space_left = window_region.height - bottom_y
            self.scroll_offset_max = (self.scroll_offset -
                                      self.scroll_offset_space_left +
                                      0.25 * block_height)

        else:
            font_id = 0
            text = "Communicating with Blender Cloud"
            bgl.glColor4f(1.0, 1.0, 1.0, 1.0)
            blf.size(font_id, 20, 72)
            text_width, text_height = blf.dimensions(font_id, text)
            blf.position(font_id,
                         content_x + content_width * 0.5 - text_width * 0.5,
                         content_y - content_height * 0.3 + text_height * 0.5, 0)
            blf.draw(font_id, text)

        bgl.glDisable(bgl.GL_BLEND)
def drawCallbackMenu(self, context):

    global targetItemWidth
    global targetItemHeight

    marginX = 20
    marginY = 5
    paddingX = 5

    bgl.glEnable(bgl.GL_BLEND)
    bgl.glColor4f(0.0, 0.0, 0.0, 0.6)
    bgl.glRectf(0, 0, context.area.regions[4].width,
                context.area.regions[4].height)

    contentWidth = context.area.regions[4].width - marginX * 2
    contentHeight = context.area.regions[4].height - marginY * 2

    contentX = marginX
    contentY = context.area.height - marginY - targetItemHeight - 50

    colCount = int(contentWidth / targetItemWidth)

    itemWidth = (contentWidth - (colCount * paddingX)) / (colCount + 1)
    itemHeight = targetItemHeight

    col = 0
    row = 0
    x = contentX
    y = contentY

    if len(self.current_dir_content) == 0:
        font_id = 0
        text = "Folder doesn't contain any assets!"
        bgl.glColor4f(1.0, 1.0, 1.0, 1.0)
        blf.size(font_id, 20, 72)
        textWidth, textHeight = blf.dimensions(font_id, text)
        blf.position(font_id, contentX + contentWidth * 0.5 - textWidth * 0.5,
                     contentY - contentHeight * 0.5 + textHeight * 0.5, 0)
        blf.draw(font_id, text)
    else:
        for item in self.current_dir_content:
            if self.mouseX > x and self.mouseX < x + itemWidth and self.mouseY > y and self.mouseY < y + itemHeight:
                item['highlighted'] = True
            else:
                item['highlighted'] = False

            drawMenuItem(item, x, y, itemWidth, itemHeight)
            x = x + itemWidth + paddingX
            col += 1

            if col > colCount:
                col = 0
                x = contentX
                y = y - itemHeight - marginY
                row += 1

    bgl.glDisable(bgl.GL_BLEND)
    bgl.glDisable(bgl.GL_TEXTURE_2D)
示例#5
0
def drawCallbackMenu(self, context):

    global targetItemWidth
    global targetItemHeight

    marginX = 20
    marginY = 5
    paddingX = 5


    bgl.glEnable(bgl.GL_BLEND)
    bgl.glColor4f(0.0, 0.0, 0.0, 0.6)
    bgl.glRectf(0,0,context.area.regions[4].width,context.area.regions[4].height)

    contentWidth = context.area.regions[4].width - marginX * 2
    contentHeight = context.area.regions[4].height - marginY * 2

    contentX = marginX
    contentY = context.area.height - marginY - targetItemHeight - 50

    colCount = int(contentWidth / targetItemWidth)

    itemWidth = (contentWidth - (colCount * paddingX)) / (colCount + 1)
    itemHeight = targetItemHeight

    col = 0
    row = 0
    x = contentX
    y = contentY

    if len(self.current_dir_content ) == 0:
        font_id = 0
        text = "Folder doesn't contain any assets!"
        bgl.glColor4f(1.0, 1.0, 1.0, 1.0)
        blf.size(font_id, 20, 72)
        textWidth, textHeight = blf.dimensions(font_id, text)
        blf.position(font_id, contentX + contentWidth * 0.5 - textWidth * 0.5, contentY - contentHeight * 0.5 + textHeight * 0.5, 0)
        blf.draw(font_id, text)
    else:
        for item in self.current_dir_content:
            if self.mouseX > x and self.mouseX < x + itemWidth and self.mouseY > y and self.mouseY < y + itemHeight:
                item['highlighted'] = True
            else:
                item['highlighted'] = False

            drawMenuItem(item, x, y, itemWidth, itemHeight)
            x = x + itemWidth + paddingX
            col += 1

            if col > colCount:
                col = 0
                x = contentX
                y = y - itemHeight - marginY
                row += 1

    bgl.glDisable(bgl.GL_BLEND)
    bgl.glDisable(bgl.GL_TEXTURE_2D)
示例#6
0
 def draw_button_boarder(self, highlighted: bool):
     bgl.glEnable(bgl.GL_BLEND)
     if highlighted:
         bgl.glColor4f(0.555, 0.555, 0.555, 0.8)
     else:
         bgl.glColor4f(0.447, 0.447, 0.447, 0.8)
     bgl.glRectf(self.x_location, self.y_location,
                 self.width + self.x_location,
                 self.height + self.y_location)
     bgl.glDisable(bgl.GL_BLEND)
def drawMenuItem(item, x, y, width, height):
    global iconWidth
    global iconHeight

    iconMarginX = 4
    iconMarginY = 4
    textMarginX = 6

    textHeight = 16
    textWidth = 72

    bgl.glEnable(bgl.GL_BLEND)
    if item['highlighted']:
        bgl.glColor4f(0.555, 0.555, 0.555, 0.8)
    else:
        bgl.glColor4f(0.447, 0.447, 0.447, 0.8)

    bgl.glRectf(x, y, x + width, y + height)

    texture = item['icon']
    texture.gl_load()
    bgl.glColor4f(0.0, 0.0, 1.0, 0.5)
    #bgl.glLineWidth(1.5)

    #------ TEXTURE ---------#
    bgl.glEnable(bgl.GL_BLEND)
    bgl.glBindTexture(bgl.GL_TEXTURE_2D, texture.bindcode[0])
    bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MIN_FILTER,
                        bgl.GL_NEAREST)
    bgl.glTexParameteri(
        bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MAG_FILTER, bgl.GL_NEAREST
    )  #GL_LINEAR seems to be used in Blender for background images
    bgl.glEnable(bgl.GL_TEXTURE_2D)
    bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA)

    bgl.glColor4f(1, 1, 1, 1)
    bgl.glBegin(bgl.GL_QUADS)
    bgl.glTexCoord2d(0, 0)
    bgl.glVertex2d(x + iconMarginX, y)
    bgl.glTexCoord2d(0, 1)
    bgl.glVertex2d(x + iconMarginX, y + iconHeight)
    bgl.glTexCoord2d(1, 1)
    bgl.glVertex2d(x + iconMarginX + iconWidth, y + iconHeight)
    bgl.glTexCoord2d(1, 0)
    bgl.glVertex2d(x + iconMarginX + iconWidth, y)
    bgl.glEnd()

    texture.gl_free()

    # draw some text
    font_id = 0
    blf.position(font_id, x + iconMarginX + iconWidth + textMarginX,
                 y + iconHeight * 0.5 - 0.25 * textHeight, 0)
    blf.size(font_id, textHeight, textWidth)
    blf.draw(font_id, item['text'])
示例#8
0
 def draw(self, context, render=False):
     self.render = render
     bgl.glPushAttrib(bgl.GL_ENABLE_BIT)
     bgl.glEnable(bgl.GL_BLEND)
     if render:
         # enable anti-alias on polygons
         bgl.glEnable(bgl.GL_POLYGON_SMOOTH)
     bgl.glColor4f(*self.colour)
     p0 = self.pts[0]
     p1 = self.pts[1]
     bgl.glRectf(p0.x, p0.y, p1.x, p1.y)
     self._end()
示例#9
0
def drawMenuItem(item, x, y, width, height):
    global iconWidth
    global iconHeight

    iconMarginX = 4
    iconMarginY = 4
    textMarginX = 6

    textHeight = 16
    textWidth = 72

    bgl.glEnable(bgl.GL_BLEND)
    if item["highlighted"]:
        bgl.glColor4f(0.555, 0.555, 0.555, 0.8)
    else:
        bgl.glColor4f(0.447, 0.447, 0.447, 0.8)

    bgl.glRectf(x, y, x + width, y + height)

    texture = item["icon"]
    texture.gl_load()
    bgl.glColor4f(0.0, 0.0, 1.0, 0.5)
    # bgl.glLineWidth(1.5)

    # ------ TEXTURE ---------#
    bgl.glEnable(bgl.GL_BLEND)
    bgl.glBindTexture(bgl.GL_TEXTURE_2D, texture.bindcode)
    bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MIN_FILTER, bgl.GL_NEAREST)
    bgl.glTexParameteri(
        bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MAG_FILTER, bgl.GL_NEAREST
    )  # GL_LINEAR seems to be used in Blender for background images
    bgl.glEnable(bgl.GL_TEXTURE_2D)
    bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA)

    bgl.glColor4f(1, 1, 1, 1)
    bgl.glBegin(bgl.GL_QUADS)
    bgl.glTexCoord2d(0, 0)
    bgl.glVertex2d(x + iconMarginX, y)
    bgl.glTexCoord2d(0, 1)
    bgl.glVertex2d(x + iconMarginX, y + iconHeight)
    bgl.glTexCoord2d(1, 1)
    bgl.glVertex2d(x + iconMarginX + iconWidth, y + iconHeight)
    bgl.glTexCoord2d(1, 0)
    bgl.glVertex2d(x + iconMarginX + iconWidth, y)
    bgl.glEnd()

    texture.gl_free()

    # draw some text
    font_id = 0
    blf.position(font_id, x + iconMarginX + iconWidth + textMarginX, y + iconHeight * 0.5 - 0.25 * textHeight, 0)
    blf.size(font_id, textHeight, textWidth)
    blf.draw(font_id, item["text"])
示例#10
0
    def draw(self, context, render=False):

        self.render = render
        bgl.glPushAttrib(bgl.GL_ENABLE_BIT)
        bgl.glEnable(bgl.GL_BLEND)
        if render:
            # enable anti-alias on polygons
            bgl.glEnable(bgl.GL_POLYGON_SMOOTH)
        bgl.glColor4f(*self.colour)
        p0 = self.pts[0]
        p1 = self.pts[1]
        bgl.glRectf(p0.x, p0.y, p1.x, p1.y)
        self._end()
示例#11
0
    def _draw_text_on_colour(self, context, text, bgcolour):
        content_height, content_width = self._window_size(context)
        bgl.glEnable(bgl.GL_BLEND)
        bgl.glColor4f(*bgcolour)
        bgl.glRectf(0, 0, content_width, content_height)

        font_id = 0
        bgl.glColor4f(1.0, 1.0, 1.0, 1.0)
        blf.size(font_id, 20, 72)
        text_width, text_height = blf.dimensions(font_id, text)

        blf.position(font_id, content_width * 0.5 - text_width * 0.5,
                     content_height * 0.7 + text_height * 0.5, 0)
        blf.draw(font_id, text)
        bgl.glDisable(bgl.GL_BLEND)
示例#12
0
    def draw(self, context, render=False):

        self.render = render
        bgl.glPushAttrib(bgl.GL_ENABLE_BIT)
        bgl.glEnable(bgl.GL_BLEND)
        if render:
            # enable anti-alias on polygons
            bgl.glEnable(bgl.GL_POLYGON_SMOOTH)
        bgl.glColor4f(*self.colour)
        pts = [
            self.position_2d_from_coord(context, pt, render)
            for pt in self.pts_3d
        ]
        p0 = pts[0]
        p1 = pts[1]
        bgl.glRectf(p0.x, p0.y, p1.x, p1.y)
        self._end()
示例#13
0
    def draw(self, highlighted: bool):
        bgl.glEnable(bgl.GL_BLEND)
        if highlighted:
            bgl.glColor4f(0.555, 0.555, 0.555, 0.8)
        else:
            bgl.glColor4f(0.447, 0.447, 0.447, 0.8)

        bgl.glRectf(self.x, self.y, self.x + self.width, self.y + self.height)

        texture = self.icon
        err = texture.gl_load(filter=bgl.GL_NEAREST, mag=bgl.GL_NEAREST)
        assert not err, 'OpenGL error: %i' % err

        bgl.glColor4f(0.0, 0.0, 1.0, 0.5)
        # bgl.glLineWidth(1.5)

        # ------ TEXTURE ---------#
        bgl.glBindTexture(bgl.GL_TEXTURE_2D, texture.bindcode[0])
        bgl.glEnable(bgl.GL_TEXTURE_2D)
        bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA)

        bgl.glColor4f(1, 1, 1, 1)
        bgl.glBegin(bgl.GL_QUADS)
        bgl.glTexCoord2d(0, 0)
        bgl.glVertex2d(self.x + self.icon_margin_x, self.y)
        bgl.glTexCoord2d(0, 1)
        bgl.glVertex2d(self.x + self.icon_margin_x, self.y + ICON_HEIGHT)
        bgl.glTexCoord2d(1, 1)
        bgl.glVertex2d(self.x + self.icon_margin_x + ICON_WIDTH,
                       self.y + ICON_HEIGHT)
        bgl.glTexCoord2d(1, 0)
        bgl.glVertex2d(self.x + self.icon_margin_x + ICON_WIDTH, self.y)
        bgl.glEnd()
        bgl.glDisable(bgl.GL_TEXTURE_2D)
        bgl.glDisable(bgl.GL_BLEND)

        texture.gl_free()

        # draw some text
        font_id = 0
        blf.position(
            font_id,
            self.x + self.icon_margin_x + ICON_WIDTH + self.text_margin_x,
            self.y + ICON_HEIGHT * 0.5 - 0.25 * self.text_height, 0)
        blf.size(font_id, self.text_height, self.text_width)
        blf.draw(font_id, self.label_text)
示例#14
0
    def draw_panel(self):
        bgl.glEnable(bgl.GL_BLEND)
        #PANEL
        bgl.glColor4f(0.0, 0.0, 0.0, 0.1)
        bgl.glRectf(self.x_location, self.y_location, self.width, self.height)
        #HEADER
        bgl.glColor4f(0.1, 0.1, 0.1, 1)
        bgl.glRectf(self.x_location, self.height - self.header_height,
                    self.width, self.height)

        bgl.glDisable(bgl.GL_BLEND)

        #HEADER TEXT
        bgl.glColor4f(1, 1, 1, 1)
        font_id = 0
        blf.position(font_id, 20,
                     self.height - self.text_height - self.icon_margin_y, 0)
        blf.size(font_id, self.text_height, self.text_width)
        blf.draw(font_id, "hAndy Tool Library")
def draw_channel_color(scroller_width, channel_coords, curx, color):
    from bgl import glColor4f, glRectf, glEnable, glDisable, glBlendFunc, GL_BLEND, GL_ONE, GL_SRC_ALPHA

    context = bpy.context

    # Strip coords
    s_x1, s_y1, s_x2, s_y2 = channel_coords

    # Drawing coords
    x = 0
    d_y1 = s_y1
    d_y2 = s_y2
    d_x1 = s_x1
    d_x2 = s_x2

    # be careful not to override the current frame line
    cf_x = context.scene.frame_current_final
    y = 0

    r, g, b, a = color
    glColor4f(r, g, b, a)
    glEnable(GL_BLEND)
    # glBlendFunc(GL_SRC_ALPHA, GL_ONE);

    if d_x1 < cf_x and cf_x < d_x2:
        # current frame line over strip
        glRectf(d_x1, d_y1, cf_x - curx, d_y2)
        glRectf(cf_x + curx, d_y1, d_x2, d_y2)
    else:
        # Normal, full rectangle draw
        glRectf(d_x1, d_y1, d_x2, d_y2)

    glDisable(GL_BLEND)
示例#16
0
def draw_channel_color(scroller_width, channel_coords, curx, color):
    from bgl import glColor4f, glRectf, glEnable, glDisable, glBlendFunc, GL_BLEND, GL_ONE, GL_SRC_ALPHA

    context = bpy.context

    # Strip coords
    s_x1, s_y1, s_x2, s_y2 = channel_coords

    # Drawing coords
    x = 0
    d_y1 = s_y1
    d_y2 = s_y2
    d_x1 = s_x1
    d_x2 = s_x2

    # be careful not to override the current frame line
    cf_x = context.scene.frame_current_final
    y = 0

    r, g, b, a = color
    glColor4f(r, g, b, a)
    glEnable(GL_BLEND)
    # glBlendFunc(GL_SRC_ALPHA, GL_ONE);

    if d_x1 < cf_x and cf_x < d_x2:
        # current frame line over strip
        glRectf(d_x1, d_y1, cf_x - curx, d_y2)
        glRectf(cf_x + curx, d_y1, d_x2, d_y2)
    else:
        # Normal, full rectangle draw
        glRectf(d_x1, d_y1, d_x2, d_y2)

    glDisable(GL_BLEND)
示例#17
0
 def draw_exp_strings(self, font_id, ofsx, ofsy, minwidth=40, \
                      pertition=',  ', start='', end='',
                      col=None, errcol=None):
     if start:
         if col:
             bgl.glColor4f(*col)
         blf.position(font_id, ofsx, ofsy, 0)
         blf.draw(font_id, start)
         text_width, text_height = blf.dimensions(font_id, start)
         ofsx += text_width
     for i, string in enumerate(self.exp_strings):
         value = self.get_exp_value(i)
         if col and value is not None:
             bgl.glColor4f(*col)
         elif errcol and value is None:
             bgl.glColor4f(*errcol)
         name = self.exp_names[i]
         text = name.format(exp=string)
         if len(self.exp_strings) > 1 and 0 < i < len(exp_strings) - 1:
             text = text + pertition
         blf.position(font_id, ofsx, ofsy, 0)
         blf.draw(font_id, text)
         text_width, text_height = blf.dimensions(font_id, text)
         text_width = max(minwidth, text_width)
         # caret
         if i == self.caret[0]:
             if col:
                 bgl.glColor4f(*col)
             t = name.split('{')[0] + string[:self.caret[1]]
             t_width, t_height = blf.dimensions(font_id, t)
             x = ofsx + t_width
             glRectf(x, ofsy - 4, x + 1, ofsy + 14)
         ofsx += text_width
         if end and i == len(self.exp_strings) - 1:
             if col:
                 bgl.glColor4f(*col)
             blf.position(font_id, ofsx, ofsy, 0)
             blf.draw(font_id, end)
示例#18
0
    def draw_image(self, image, x, y, w, h, color=(0, 0, 0, 0.1)):
        bgl.glColor4f(0.5, 0.0, 0.5, 0.7)

        # draw main line and handles
        # bgl.glBegin(bgl.GL_LINES)
        bgl.glRectf(x, y, x + w, y + h)
        # bgl.glEnd()
        x1 = x
        y1 = y
        x2 = x + w
        y2 = y + h
        color = [0.5, 0.5, 0.5, 1]

        idx = image.gl_load(bgl.GL_NEAREST, bgl.GL_NEAREST)
        print([i for i in image.bindcode])

        bgl.glBindTexture(bgl.GL_TEXTURE_2D, image.bindcode[0])
        bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MIN_FILTER,
                            bgl.GL_NEAREST)

        bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MAG_FILTER,
                            bgl.GL_NEAREST)
        bgl.glEnable(bgl.GL_TEXTURE_2D)
        bgl.glEnable(bgl.GL_BLEND)
        #bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA)
        bgl.glColor4f(color[0], color[1], color[2], color[3])
        bgl.glBegin(bgl.GL_QUADS)
        bgl.glTexCoord2f(0, 0)
        bgl.glVertex2f(x1, y1)
        bgl.glTexCoord2f(0, 1)
        bgl.glVertex2f(x1, y2)
        bgl.glTexCoord2f(1, 1)
        bgl.glVertex2f(x2, y2)
        bgl.glTexCoord2f(1, 0)
        bgl.glVertex2f(x2, y1)
        bgl.glEnd()
        bgl.glDisable(bgl.GL_BLEND)
        bgl.glDisable(bgl.GL_TEXTURE_2D)
示例#19
0
 def draw_exp_strings(self, font_id, ofsx, ofsy, minwidth=40, \
                      pertition=',  ', start='', end='',
                      col=None, errcol=None):
     if start:
         if col:
             bgl.glColor4f(*col)
         blf.position(font_id, ofsx, ofsy, 0)
         blf.draw(font_id, start)
         text_width, text_height = blf.dimensions(font_id, start)
         ofsx += text_width
     for i, string in enumerate(self.exp_strings):
         value = self.get_exp_value(i)
         if col and value is not None:
             bgl.glColor4f(*col)
         elif errcol and value is None:
             bgl.glColor4f(*errcol)
         name = self.exp_names[i]
         text = name.format(exp=string)
         if len(self.exp_strings) > 1 and 0 < i < len(exp_strings) - 1:
             text = text + pertition
         blf.position(font_id, ofsx, ofsy, 0)
         blf.draw(font_id, text)
         text_width, text_height = blf.dimensions(font_id, text)
         text_width = max(minwidth, text_width)
         # caret
         if i == self.caret[0]:
             if col:
                 bgl.glColor4f(*col)
             t = name.split('{')[0] + string[:self.caret[1]]
             t_width, t_height = blf.dimensions(font_id, t)
             x = ofsx + t_width
             glRectf(x, ofsy - 4, x + 1, ofsy + 14)
         ofsx += text_width
         if end and i == len(self.exp_strings) - 1:
             if col:
                 bgl.glColor4f(*col)
             blf.position(font_id, ofsx, ofsy, 0)
             blf.draw(font_id, end)
    def draw_image(self, image, x, y, w, h, color=(0, 0, 0, 0.1)):
        bgl.glColor4f(0.5, 0.0, 0.5, 0.7)

        # draw main line and handles
        # bgl.glBegin(bgl.GL_LINES)
        bgl.glRectf(x, y, x + w, y + h)
        # bgl.glEnd()
        x1 = x
        y1 = y
        x2 = x + w
        y2 = y + h
        color = [0.5, 0.5, 0.5, 1]

        idx = image.gl_load(bgl.GL_NEAREST, bgl.GL_NEAREST)
        print([i for i in image.bindcode])

        bgl.glBindTexture(bgl.GL_TEXTURE_2D, image.bindcode[0])
        bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MIN_FILTER, bgl.GL_NEAREST)

        bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MAG_FILTER, bgl.GL_NEAREST)
        bgl.glEnable(bgl.GL_TEXTURE_2D)
        bgl.glEnable(bgl.GL_BLEND)
        # bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA)
        bgl.glColor4f(color[0], color[1], color[2], color[3])
        bgl.glBegin(bgl.GL_QUADS)
        bgl.glTexCoord2f(0, 0)
        bgl.glVertex2f(x1, y1)
        bgl.glTexCoord2f(0, 1)
        bgl.glVertex2f(x1, y2)
        bgl.glTexCoord2f(1, 1)
        bgl.glVertex2f(x2, y2)
        bgl.glTexCoord2f(1, 0)
        bgl.glVertex2f(x2, y1)
        bgl.glEnd()
        bgl.glDisable(bgl.GL_BLEND)
        bgl.glDisable(bgl.GL_TEXTURE_2D)
示例#21
0
def draw_underline_in_strip(scroller_width, strip_coords, curx, color):
    from bgl import glColor4f, glRectf, glEnable, glDisable, GL_BLEND

    context = bpy.context

    # Strip coords
    s_x1, s_y1, s_x2, s_y2 = strip_coords

    # Drawing coords
    x = 0
    d_y1 = s_y1
    d_y2 = s_y2
    d_x1 = s_x1
    d_x2 = s_x2

    # be careful not to override the current frame line
    cf_x = context.scene.frame_current_final
    y = 0

    r, g, b, a = color
    glColor4f(r, g, b, a)
    glEnable(GL_BLEND)

    # // this checks if the strip range overlaps the current f. label range
    # // then it would need a polygon? to draw around it
    # // TODO: check also if label display is ON
    # Check if the current frame label overlaps the strip
    # label_height = scroller_width * 2
    # if d_y1 < label_height:
    #    if cf_x < d_x2 and d_x1 < cf_x + label_height:
    #        print("ALARM!!")

    if d_x1 < cf_x and cf_x < d_x2:
        # Bad luck, the line passes our strip
        glRectf(d_x1, d_y1, cf_x - curx, d_y2)
        glRectf(cf_x + curx, d_y1, d_x2, d_y2)
    else:
        # Normal, full rectangle draw
        glRectf(d_x1, d_y1, d_x2, d_y2)

    glDisable(GL_BLEND)
def draw_underline_in_strip(scroller_width, strip_coords, curx, color):
    from bgl import glColor4f, glRectf, glEnable, glDisable, GL_BLEND

    context = bpy.context

    # Strip coords
    s_x1, s_y1, s_x2, s_y2 = strip_coords

    # Drawing coords
    x = 0
    d_y1 = s_y1
    d_y2 = s_y2
    d_x1 = s_x1
    d_x2 = s_x2

    # be careful not to override the current frame line
    cf_x = context.scene.frame_current_final
    y = 0

    r, g, b, a = color
    glColor4f(r, g, b, a)
    glEnable(GL_BLEND)

    # // this checks if the strip range overlaps the current f. label range
    # // then it would need a polygon? to draw around it
    # // TODO: check also if label display is ON
    # Check if the current frame label overlaps the strip
    # label_height = scroller_width * 2
    # if d_y1 < label_height:
    #    if cf_x < d_x2 and d_x1 < cf_x + label_height:
    #        print("ALARM!!")

    if d_x1 < cf_x and cf_x < d_x2:
        # Bad luck, the line passes our strip
        glRectf(d_x1, d_y1, cf_x - curx, d_y2)
        glRectf(cf_x + curx, d_y1, d_x2, d_y2)
    else:
        # Normal, full rectangle draw
        glRectf(d_x1, d_y1, d_x2, d_y2)

    glDisable(GL_BLEND)
示例#23
0
def aabox(v1: Float2, v2: Float2, rgba: Float4):
    """Draw an axis-aligned box."""

    bgl.glColor4f(*rgba)
    bgl.glRectf(*v1, *v2)
示例#24
0
    def draw_callback(self, context):
        """
        :type context: bpy.types.Context
        """

        prefs = QuickBooleanPreferences.get_instance()
        color = prefs.color
        snap_color = prefs.snap_color

        region = context.region

        glsettings = vagl.GLSettings(context)
        glsettings.push()

        bgl.glEnable(bgl.GL_BLEND)
        bgl.glColor4f(*color)

        show_reversed = False
        if self.reverse:
            if self.mode == 'POLYGON':
                if len(self.mouse_coords) >= 3:
                    show_reversed = True
            else:
                if len(self.mouse_coords) >= 2:
                    if self.mouse_coords[0] != self.mouse_coords[1]:
                        show_reversed = True
        if show_reversed:
            bgl.glEnable(bgl.GL_DEPTH_TEST)
            bgl.glClearDepth(1.0)
            bgl.glClear(bgl.GL_DEPTH_BUFFER_BIT)
            bgl.glDepthMask(1)
            bgl.glColorMask(0, 0, 0, 0)

        lines = []
        if self.mouse_coords:
            if self.mode == 'LINE':
                w = region.width
                h = region.height
                p1, p2 = self.mouse_coords
                line = (p2 - p1).normalized()
                normal = Vector([-line[1], line[0]])
                corners = [Vector([0, 0]), Vector([w, 0]), Vector([w, h]),
                           Vector([0, h])]
                corners_ofs = [v - p1 for v in corners]
                dists = [v.project(line).dot(line) for v in corners_ofs]
                i = dists.index(min(dists))
                line_min = corners_ofs[i].project(line) + p1
                i = dists.index(max(dists))
                line_max = corners_ofs[i].project(line) + p1
                dists = [v.project(normal).dot(normal) for v in corners_ofs]
                i = dists.index(max(dists))
                normal_max_f = corners_ofs[i].project(normal).dot(normal)
                vec = normal * normal_max_f
                coords = [line_min, line_max, line_max + vec, line_min + vec]
                bgl.glBegin(bgl.GL_QUADS)
                for co in coords:
                    bgl.glVertex2f(*co)
                bgl.glEnd()
                lines = self.mouse_coords

            elif self.mode == 'BOX':
                p1, p2 = self.mouse_coords
                bgl.glRectf(p1[0], p1[1], p2[0], p2[1])
                lines = [p1,
                         Vector((p2[0], p1[1])),
                         Vector((p2[0], p2[1])),
                         Vector((p1[0], p2[1])),
                         p1]
            elif self.mode == 'CIRCLE':
                p1, p2 = self.mouse_coords
                bgl.glBegin(bgl.GL_TRIANGLE_FAN)
                bgl.glVertex2f(*p1)
                r = (p2 - p1).length
                coords = calc_circle_coords(p1, r, self.circle_segments,
                                            self.circle_direction)
                for co in coords:
                    bgl.glVertex2f(*co)
                bgl.glVertex2f(*coords[0])
                bgl.glEnd()
                lines = coords + [coords[0]]
            elif self.mode == 'POLYGON':
                if len(self.mouse_coords) >= 3:
                    tris = mathutils.geometry.tessellate_polygon(
                        [[co.to_3d() for co in self.mouse_coords]])

                    bgl.glBegin(bgl.GL_TRIANGLES)
                    for tri in tris:
                        for i in tri:
                            bgl.glVertex2f(*self.mouse_coords[i])
                    bgl.glEnd()
                if len(self.mouse_coords) > 1:
                    lines = self.mouse_coords + [self.mouse_coords[0]]

        if show_reversed:
            bgl.glColorMask(1, 1, 1, 1)
            bgl.glBegin(bgl.GL_QUADS)
            bgl.glVertex3f(0, 0, -1)
            bgl.glVertex3f(region.width, 0, -1)
            bgl.glVertex3f(region.width, region.height, -1)
            bgl.glVertex3f(0, region.height, -1)
            bgl.glEnd()
            bgl.glDisable(bgl.GL_DEPTH_TEST)

        bgl.glColor4f(*color[:3], 1.0)
        bgl.glPointSize(1)
        bgl.glLineWidth(1)
        if len(lines) > 1:
            bgl.glBegin(bgl.GL_LINE_STRIP)
            for co in lines:
                bgl.glVertex2f(*co)
            bgl.glEnd()
        if self.mode == 'POLYGON':
            if len(self.mouse_coords) == 1:
                bgl.glPointSize(5)
                bgl.glBegin(bgl.GL_POINTS)
                for co in self.mouse_coords:
                    bgl.glVertex2f(*co)
                bgl.glEnd()
                bgl.glPointSize(1)
                bgl.glLineWidth(1)

        if self.mco_ctrl:
            SIZE = 12
            bgl.glColor4f(*snap_color)
            bgl.glBegin(bgl.GL_LINE_LOOP)
            v = self.mco_mod
            x = v[0] - SIZE / 2
            y = v[1] - SIZE / 2
            bgl.glVertex2f(x, y)
            bgl.glVertex2f(x + SIZE, y)
            bgl.glVertex2f(x + SIZE, y + SIZE)
            bgl.glVertex2f(x, y + SIZE)
            bgl.glEnd()

        glsettings.pop()
        glsettings.font_size()
示例#25
0
 def renderRect(color, x, y, width, height):
     bgl.glEnable(bgl.GL_BLEND)
     bgl.glColor4f(color[0], color[1], color[2], color[3])
     bgl.glRectf(x, y, x + width, y + height)
示例#26
0
    def draw_callback(self, context):
        """
        :type context: bpy.types.Context
        """

        prefs = QuickBooleanPreferences.get_instance()
        color = prefs.color
        snap_color = prefs.snap_color

        region = context.region

        glsettings = vagl.GLSettings(context)
        glsettings.push()

        bgl.glEnable(bgl.GL_BLEND)
        bgl.glColor4f(*color)

        show_reversed = False
        if self.reverse:
            if self.mode == 'POLYGON':
                if len(self.mouse_coords) >= 3:
                    show_reversed = True
            else:
                if len(self.mouse_coords) >= 2:
                    if self.mouse_coords[0] != self.mouse_coords[1]:
                        show_reversed = True
        if show_reversed:
            bgl.glEnable(bgl.GL_DEPTH_TEST)
            bgl.glClearDepth(1.0)
            bgl.glClear(bgl.GL_DEPTH_BUFFER_BIT)
            bgl.glDepthMask(1)
            bgl.glColorMask(0, 0, 0, 0)

        lines = []
        if self.mouse_coords:
            if self.mode == 'LINE':
                w = region.width
                h = region.height
                p1, p2 = self.mouse_coords
                line = (p2 - p1).normalized()
                normal = Vector([-line[1], line[0]])
                corners = [
                    Vector([0, 0]),
                    Vector([w, 0]),
                    Vector([w, h]),
                    Vector([0, h])
                ]
                corners_ofs = [v - p1 for v in corners]
                dists = [v.project(line).dot(line) for v in corners_ofs]
                i = dists.index(min(dists))
                line_min = corners_ofs[i].project(line) + p1
                i = dists.index(max(dists))
                line_max = corners_ofs[i].project(line) + p1
                dists = [v.project(normal).dot(normal) for v in corners_ofs]
                i = dists.index(max(dists))
                normal_max_f = corners_ofs[i].project(normal).dot(normal)
                vec = normal * normal_max_f
                coords = [line_min, line_max, line_max + vec, line_min + vec]
                bgl.glBegin(bgl.GL_QUADS)
                for co in coords:
                    bgl.glVertex2f(*co)
                bgl.glEnd()
                lines = self.mouse_coords

            elif self.mode == 'BOX':
                p1, p2 = self.mouse_coords
                bgl.glRectf(p1[0], p1[1], p2[0], p2[1])
                lines = [
                    p1,
                    Vector((p2[0], p1[1])),
                    Vector((p2[0], p2[1])),
                    Vector((p1[0], p2[1])), p1
                ]
            elif self.mode == 'CIRCLE':
                p1, p2 = self.mouse_coords
                bgl.glBegin(bgl.GL_TRIANGLE_FAN)
                bgl.glVertex2f(*p1)
                r = (p2 - p1).length
                coords = calc_circle_coords(p1, r, self.circle_segments,
                                            self.circle_direction)
                for co in coords:
                    bgl.glVertex2f(*co)
                bgl.glVertex2f(*coords[0])
                bgl.glEnd()
                lines = coords + [coords[0]]
            elif self.mode == 'POLYGON':
                if len(self.mouse_coords) >= 3:
                    tris = mathutils.geometry.tessellate_polygon(
                        [[co.to_3d() for co in self.mouse_coords]])

                    bgl.glBegin(bgl.GL_TRIANGLES)
                    for tri in tris:
                        for i in tri:
                            bgl.glVertex2f(*self.mouse_coords[i])
                    bgl.glEnd()
                if len(self.mouse_coords) > 1:
                    lines = self.mouse_coords + [self.mouse_coords[0]]

        if show_reversed:
            bgl.glColorMask(1, 1, 1, 1)
            bgl.glBegin(bgl.GL_QUADS)
            bgl.glVertex3f(0, 0, -1)
            bgl.glVertex3f(region.width, 0, -1)
            bgl.glVertex3f(region.width, region.height, -1)
            bgl.glVertex3f(0, region.height, -1)
            bgl.glEnd()
            bgl.glDisable(bgl.GL_DEPTH_TEST)

        bgl.glColor4f(*color[:3], 1.0)
        bgl.glPointSize(1)
        bgl.glLineWidth(1)
        if len(lines) > 1:
            bgl.glBegin(bgl.GL_LINE_STRIP)
            for co in lines:
                bgl.glVertex2f(*co)
            bgl.glEnd()
        if self.mode == 'POLYGON':
            if len(self.mouse_coords) == 1:
                bgl.glPointSize(5)
                bgl.glBegin(bgl.GL_POINTS)
                for co in self.mouse_coords:
                    bgl.glVertex2f(*co)
                bgl.glEnd()
                bgl.glPointSize(1)
                bgl.glLineWidth(1)

        if self.mco_ctrl:
            SIZE = 12
            bgl.glColor4f(*snap_color)
            bgl.glBegin(bgl.GL_LINE_LOOP)
            v = self.mco_mod
            x = v[0] - SIZE / 2
            y = v[1] - SIZE / 2
            bgl.glVertex2f(x, y)
            bgl.glVertex2f(x + SIZE, y)
            bgl.glVertex2f(x + SIZE, y + SIZE)
            bgl.glVertex2f(x, y + SIZE)
            bgl.glEnd()

        glsettings.pop()
        glsettings.font_size()
示例#27
0
 def renderRect(color, x, y, width, height):
     bgl.glEnable(bgl.GL_BLEND)
     bgl.glColor4f(color[0], color[1], color[2], color[3])
     bgl.glRectf(x, y, x + width, y + height)