-
Vilem Duha authored
BlenderKit add-on is the official addon of the BlenderKit service for Blender 3d. (www.blenderkit.com) It enables users to upload, search, download, and rate different assets for blender. It works together with BlenderKit server.
Vilem Duha authoredBlenderKit add-on is the official addon of the BlenderKit service for Blender 3d. (www.blenderkit.com) It enables users to upload, search, download, and rate different assets for blender. It works together with BlenderKit server.
ui.py 58.88 KiB
# ##### BEGIN GPL LICENSE BLOCK #####
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#
# ##### END GPL LICENSE BLOCK #####
if "bpy" in locals():
import imp
imp.reload(paths)
imp.reload(ratings)
imp.reload(utils)
imp.reload(search)
imp.reload(upload)
else:
from blenderkit import paths, ratings, utils, search, upload, ui_bgl, download, bg_blender
import bpy
import math, random
from bpy.props import (
BoolProperty,
StringProperty
)
from bpy_extras import view3d_utils
import mathutils
from mathutils import Vector
import time
import os
mappingdict = {
'MODEL': 'model',
'SCENE': 'scene',
'MATERIAL': 'material',
'TEXTURE': 'texture',
'BRUSH': 'brush'
}
verification_icons = {
'ready': 'vs_ready.png',
'deleted': 'vs_deleted.png',
'uploaded': 'vs_uploaded.png',
'uploading': None,
'on_hold': 'vs_on_hold.png',
'validated': None
}
# class UI_region():
# def _init__(self, parent = None, x = 10,y = 10 , width = 10, height = 10, img = None, col = None):
def get_approximate_text_width(st):
size = 10
for s in st:
if s in 'i|':
size += 2
elif s in ' ':
size += 4
elif s in 'sfrt':
size += 5
elif s in 'ceghkou':
size += 6
elif s in 'PadnBCST3E':
size += 7
elif s in 'GMODVXYZ':
size += 8
elif s in 'w':
size += 9
elif s in 'm':
size += 10
else:
size += 7
return size # Convert to picas
def get_asset_under_mouse(mousex, mousey):
s = bpy.context.scene
ui_props = bpy.context.scene.blenderkitUI
r = bpy.context.region
search_results = s.get('search results')
if search_results is not None:
h_draw = min(ui_props.hcount, math.ceil(len(search_results) / ui_props.wcount))
for b in range(0, h_draw):
w_draw = min(ui_props.wcount, len(search_results) - b * ui_props.wcount - ui_props.scrolloffset)
for a in range(0, w_draw):
x = ui_props.bar_x + a * (ui_props.margin + ui_props.thumb_size) + ui_props.margin + ui_props.drawoffset
y = ui_props.bar_y - ui_props.margin - (ui_props.thumb_size + ui_props.margin) * (b + 1)
w = ui_props.thumb_size
h = ui_props.thumb_size
if x < mousex < x + w and y < mousey < y + h:
return a + ui_props.wcount * b + ui_props.scrolloffset
# return search_results[a]
return -3
def draw_bbox(location, rotation, bbox_min, bbox_max, progress=None, color=(0, 1, 0, 1)):
ui_props = bpy.context.scene.blenderkitUI
rotation = mathutils.Euler(rotation)
smin = Vector(bbox_min)
smax = Vector(bbox_max)
v0 = Vector(smin)
v1 = Vector((smax.x, smin.y, smin.z))
v2 = Vector((smax.x, smax.y, smin.z))
v3 = Vector((smin.x, smax.y, smin.z))
v4 = Vector((smin.x, smin.y, smax.z))
v5 = Vector((smax.x, smin.y, smax.z))
v6 = Vector((smax.x, smax.y, smax.z))
v7 = Vector((smin.x, smax.y, smax.z))
arrowx = smin.x + (smax.x - smin.x) / 2
arrowy = smin.y - (smax.x - smin.x) / 2
v8 = Vector((arrowx, arrowy, smin.z))
vertices = [v0, v1, v2, v3, v4, v5, v6, v7, v8]
for v in vertices:
v.rotate(rotation)
v += Vector(location)
lines = [[0, 1], [1, 2], [2, 3], [3, 0], [4, 5], [5, 6], [6, 7], [7, 4], [0, 4], [1, 5],
[2, 6], [3, 7], [0, 8], [1, 8]]
ui_bgl.draw_lines(vertices, lines, color)
if progress != None:
color = (color[0], color[1], color[2], .2)
progress = progress * .01
vz0 = (v4 - v0) * progress + v0
vz1 = (v5 - v1) * progress + v1
vz2 = (v6 - v2) * progress + v2
vz3 = (v7 - v3) * progress + v3
rects = (
(v0, v1, vz1, vz0),
(v1, v2, vz2, vz1),
(v2, v3, vz3, vz2),
(v3, v0, vz0, vz3))
for r in rects:
ui_bgl.draw_rect_3d(r, color)
def get_rating_scalevalues(asset_type):
xs = []
if asset_type == 'model':
scalevalues = (0.5, 1, 2, 5, 10, 25, 50, 100, 250)
for v in scalevalues:
a = math.log2(v)
x = (a + 1) * (1. / 9.)
xs.append(x)
else:
scalevalues = (0.2, 1, 2, 3, 4, 5)
for v in scalevalues:
a = v
x = v / 5.
xs.append(x)
return scalevalues, xs
def draw_ratings_bgl():
# return;
ui = bpy.context.scene.blenderkitUI
rating_possible, rated, asset, asset_data = is_rating_possible()
if rating_possible: # (not rated or ui_props.rating_menu_on):
bkit_ratings = asset.bkit_ratings
bgcol = bpy.context.preferences.themes[0].user_interface.wcol_tooltip.inner
textcol = (1, 1, 1, 1)
r = bpy.context.region
font_size = int(ui.rating_ui_scale * 20)
if ui.rating_button_on:
img = utils.get_thumbnail('star_white.png')
ui_bgl.draw_image(ui.rating_x,
ui.rating_y - ui.rating_button_width,
ui.rating_button_width,
ui.rating_button_width,
img, 1)
# if ui_props.asset_type != 'BRUSH':
# thumbnail_image = props.thumbnail
# else:
# b = utils.get_active_brush()
# thumbnail_image = b.icon_filepath
directory = paths.get_temp_dir('%s_search' % asset_data['asset_type'])
tpath = os.path.join(directory, asset_data['thumbnail_small'])
img = utils.get_hidden_image(tpath, 'rating_preview')
ui_bgl.draw_image(ui.rating_x + ui.rating_button_width,
ui.rating_y - ui.rating_button_width,
ui.rating_button_width,
ui.rating_button_width,
img, 1)
# ui_bgl.draw_text( 'rate asset %s' % asset_data['name'],r.width - rating_button_width + margin, margin, font_size)
return
ui_bgl.draw_rect(ui.rating_x,
ui.rating_y - ui.rating_ui_height - 2 * ui.margin - font_size,
ui.rating_ui_width + ui.margin,
ui.rating_ui_height + 2 * ui.margin + font_size,
bgcol)
img = utils.get_thumbnail('rating_ui.png')
ui_bgl.draw_image(ui.rating_x,
ui.rating_y - ui.rating_ui_height - 2 * ui.margin,
ui.rating_ui_width,
ui.rating_ui_height,
img, 1)
img = utils.get_thumbnail('star_white.png')
quality = bkit_ratings.rating_quality
work_hours = bkit_ratings.rating_work_hours
for a in range(0, quality):
ui_bgl.draw_image(ui.rating_x + ui.quality_stars_x + a * ui.star_size,
ui.rating_y - ui.rating_ui_height + ui.quality_stars_y,
ui.star_size,
ui.star_size,
img, 1)
img = utils.get_thumbnail('bar_slider.png')
# for a in range(0,11):
if work_hours > 0.2:
if asset_data['asset_type'] == 'model':
complexity = math.log2(work_hours) + 2 # real complexity
complexity = (1. / 9.) * (complexity - 1) * ui.workhours_bar_x_max
else:
complexity = work_hours / 5 * ui.workhours_bar_x_max
ui_bgl.draw_image(
ui.rating_x + ui.workhours_bar_x + int(
complexity),
ui.rating_y - ui.rating_ui_height + ui.workhours_bar_y,
ui.workhours_bar_slider_size,
ui.workhours_bar_slider_size, img, 1)
ui_bgl.draw_text(
str(round(work_hours, 1)),
ui.rating_x + ui.workhours_bar_x - 50,
ui.rating_y - ui.rating_ui_height + ui.workhours_bar_y + 10, font_size)
# (0.5,1,2,4,8,16,32,64,128,256)
# ratings have to be different for models and brushes+materials.
scalevalues, xs = get_rating_scalevalues(asset_data['asset_type'])
for v, x in zip(scalevalues, xs):
ui_bgl.draw_rect(ui.rating_x + ui.workhours_bar_x + int(
x * ui.workhours_bar_x_max) - 1 + ui.workhours_bar_slider_size / 2,
ui.rating_y - ui.rating_ui_height + ui.workhours_bar_y,
2,
5,
textcol)
ui_bgl.draw_text(str(v),
ui.rating_x + ui.workhours_bar_x + int(
x * ui.workhours_bar_x_max),
ui.rating_y - ui.rating_ui_height + ui.workhours_bar_y - 30,
font_size)
if work_hours > 0.2 and quality > 0.2:
text = 'Thanks for rating asset %s' % asset_data['name']
else:
text = 'Rate asset %s.' % asset_data['name']
ui_bgl.draw_text(text,
ui.rating_x,
ui.rating_y - ui.margin - font_size,
font_size)
def draw_tooltip(x, y, text, img):
region = bpy.context.region
scale = bpy.context.preferences.view.ui_scale
t = time.time()
ttipmargin = 10
font_height = int(12 * scale)
line_height = int(15 * scale)
nameline_height = int(23 * scale)
lines = text.split('\n')
ncolumns = 2
nlines = math.ceil((len(lines) - 1) / ncolumns)
texth = line_height * nlines + nameline_height
isizex = int(512 * scale * img.size[0] / max(img.size[0], img.size[1]))
isizey = int(512 * scale * img.size[1] / max(img.size[0], img.size[1]))
estimated_height = texth + 3 * ttipmargin + isizey
if estimated_height > y:
scaledown = y / (estimated_height)
scale *= scaledown
# we need to scale these down to have correct size if the tooltip wouldn't fit.
font_height = int(12 * scale)
line_height = int(15 * scale)
nameline_height = int(23 * scale)
lines = text.split('\n')
ncolumns = 2
nlines = math.ceil((len(lines) - 1) / ncolumns)
texth = line_height * nlines + nameline_height
isizex = int(512 * scale * img.size[0] / max(img.size[0], img.size[1]))
isizey = int(512 * scale * img.size[1] / max(img.size[0], img.size[1]))
name_height = int(18 * scale)
x += 2 * ttipmargin
y -= 2 * ttipmargin
width = isizex + 2 * ttipmargin
x = min(x + width, region.width) - width
bgcol = bpy.context.preferences.themes[0].user_interface.wcol_tooltip.inner
textcol = bpy.context.preferences.themes[0].user_interface.wcol_tooltip.text
textcol = (textcol[0], textcol[1], textcol[2], 1)
textcol1 = (textcol[0] * .8, textcol[1] * .8, textcol[2] * .8, 1)
white = (1, 1, 1, .1)
ui_bgl.draw_rect(x - ttipmargin,
y - texth - 2 * ttipmargin - isizey,
isizex + ttipmargin * 2,
texth + 3 * ttipmargin + isizey,
bgcol)
i = 0
column_break = -1 # start minus one for the name
xtext = x
fsize = name_height
tcol = textcol
for l in lines:
if column_break >= nlines:
xtext += int(isizex / ncolumns)
column_break = 0
ytext = y - column_break * line_height - nameline_height - ttipmargin
if i == 0:
ytext = y - name_height + 5
elif i == len(lines) - 1:
ytext = y - (nlines - 1) * line_height - nameline_height - ttipmargin
tcol = textcol
tsize = font_height
else:
if l[:5] == 'tags:':
tcol = textcol1
fsize = font_height
i += 1
column_break += 1
ui_bgl.draw_text(l, xtext, ytext, fsize, tcol)
t = time.time()
ui_bgl.draw_image(x, y - texth - isizey - ttipmargin, isizex, isizey, img, 1)
def draw_callback_2d(self, context):
a = context.area
try:
# self.area might throw error just by itself.
a1 = self.area
go = True
except:
# bpy.types.SpaceView3D.draw_handler_remove(self._handle_2d, 'WINDOW')
# bpy.types.SpaceView3D.draw_handler_remove(self._handle_3d, 'WINDOW')
go = False
if go and a == a1:
props = context.scene.blenderkitUI
if props.down_up == 'SEARCH':
draw_ratings_bgl()
draw_callback_2d_search(self, context)
elif props.down_up == 'UPLOAD':
draw_callback_2d_upload_preview(self, context)
def draw_downloader(x, y, percent=0, img=None):
if img is not None:
ui_bgl.draw_image(x, y, 50, 50, img, .5)
ui_bgl.draw_rect(x, y, 50, int(0.5 * percent), (.2, 1, .2, .3))
ui_bgl.draw_rect(x - 3, y - 3, 6, 6, (1, 0, 0, .3))
def draw_progress(x, y, text='', percent=None, color=(.2, 1, .2, .3)):
ui_bgl.draw_rect(x, y, percent, 5, color)
ui_bgl.draw_text(text, x, y + 8, 10, color)
def draw_callback_3d_progress(self, context):
# 'star trek' mode gets here, blocked by now ;)
for threaddata in download.download_threads:
asset_data = threaddata[1]
tcom = threaddata[2]
if tcom.passargs.get('downloaders'):
for d in tcom.passargs['downloaders']:
if asset_data['asset_type'] == 'model':
draw_bbox(d['location'], d['rotation'], asset_data['bbox_min'], asset_data['bbox_max'],
progress=tcom.progress)
def draw_callback_2d_progress(self, context):
green = (.2, 1, .2, .3)
offset = 0
row_height = 35
ui = bpy.context.scene.blenderkitUI
x = ui.reports_x
y = ui.reports_y
index = 0
for threaddata in download.download_threads:
asset_data = threaddata[1]
tcom = threaddata[2]
if tcom.passargs.get('downloaders'):
for d in tcom.passargs['downloaders']:
directory = paths.get_temp_dir('%s_search' % asset_data['asset_type'])
tpath = os.path.join(directory, asset_data['thumbnail_small'])
img = utils.get_hidden_image(tpath, 'rating_preview')
loc = view3d_utils.location_3d_to_region_2d(bpy.context.region, bpy.context.space_data.region_3d,
d['location'])
if asset_data['asset_type'] == 'model':
# models now draw with star trek mode, no need to draw percent for the image.
draw_downloader(loc[0], loc[1], percent=tcom.progress, img=img)
else:
draw_downloader(loc[0], loc[1], percent=tcom.progress, img=img)
else:
draw_progress(x, y - index * 30, text='downloading %s' % asset_data['name'],
percent=tcom.progress)
index += 1
for process in bg_blender.bg_processes:
tcom = process[1]
draw_progress(x, y - index * 30, '%s' % tcom.lasttext,
tcom.progress)
index += 1
def draw_callback_2d_upload_preview(self, context):
ui_props = context.scene.blenderkitUI
props = utils.get_upload_props()
if props != None and ui_props.draw_tooltip:
if ui_props.asset_type != 'BRUSH':
ui_props.thumbnail_image = props.thumbnail
else:
b = utils.get_active_brush()
ui_props.thumbnail_image = b.icon_filepath
img = utils.get_hidden_image(ui_props.thumbnail_image, 'upload_preview')
draw_tooltip(ui_props.bar_x, ui_props.bar_y, ui_props.tooltip, img)
def draw_callback_2d_search(self, context):
s = bpy.context.scene
ui_props = context.scene.blenderkitUI
user_preferences = bpy.context.preferences.addons['blenderkit'].preferences
r = self.region
# hc = bpy.context.preferences.themes[0].view_3d.space.header
# hc = bpy.context.preferences.themes[0].user_interface.wcol_menu_back.inner
# hc = (hc[0], hc[1], hc[2], .2)
hc = (1, 1, 1, .07)
# grey1 = (hc.r * .55, hc.g * .55, hc.b * .55, 1)
grey2 = (hc[0] * .8, hc[1] * .8, hc[2] * .8, .5)
# grey1 = (hc.r, hc.g, hc.b, 1)
white = (1, 1, 1, 0.2)
green = (.2, 1, .2, .7)
highlight = bpy.context.preferences.themes[0].user_interface.wcol_menu_item.inner_sel
highlight = (1, 1, 1, .2)
# highlight = (1, 1, 1, 0.8)
# background of asset bar
if not ui_props.dragging:
search_results = s.get('search results')
if search_results == None:
return
h_draw = min(ui_props.hcount, math.ceil(len(search_results) / ui_props.wcount))
if ui_props.wcount > len(search_results):
bar_width = len(search_results) * (ui_props.thumb_size + ui_props.margin) + ui_props.margin
else:
bar_width = ui_props.bar_width
row_height = ui_props.thumb_size + ui_props.margin
ui_bgl.draw_rect(ui_props.bar_x, ui_props.bar_y - ui_props.bar_height, bar_width,
ui_props.bar_height, hc)
if search_results is not None:
if ui_props.scrolloffset > 0 or ui_props.wcount * ui_props.hcount < len(search_results):
ui_props.drawoffset = 35
else:
ui_props.drawoffset = 0
if ui_props.wcount * ui_props.hcount < len(search_results):
# arrows
arrow_y = ui_props.bar_y - int((ui_props.bar_height + ui_props.thumb_size) / 2) + ui_props.margin
if ui_props.scrolloffset > 0:
if ui_props.active_index == -2:
ui_bgl.draw_rect(ui_props.bar_x, ui_props.bar_y - ui_props.bar_height, 25,
ui_props.bar_height, highlight)
img = utils.get_thumbnail('arrow_left.png')
ui_bgl.draw_image(ui_props.bar_x, arrow_y, 25,
ui_props.thumb_size,
img,
1)
if len(search_results) - ui_props.scrolloffset > (ui_props.wcount * ui_props.hcount):
if ui_props.active_index == -1:
ui_bgl.draw_rect(ui_props.bar_x + ui_props.bar_width - 25,
ui_props.bar_y - ui_props.bar_height, 25,
ui_props.bar_height,
highlight)
img1 = utils.get_thumbnail('arrow_right.png')
ui_bgl.draw_image(ui_props.bar_x + ui_props.bar_width - 25,
arrow_y, 25,
ui_props.thumb_size, img1, 1)
for b in range(0, h_draw):
w_draw = min(ui_props.wcount, len(search_results) - b * ui_props.wcount - ui_props.scrolloffset)
y = ui_props.bar_y - (b + 1) * (row_height)
for a in range(0, w_draw):
x = ui_props.bar_x + a * (
ui_props.margin + ui_props.thumb_size) + ui_props.margin + ui_props.drawoffset
#
index = a + ui_props.scrolloffset + b * ui_props.wcount
iname = utils.previmg_name(index)
img = bpy.data.images.get(iname)
w = int(ui_props.thumb_size * img.size[0] / max(img.size[0], img.size[1]))
h = int(ui_props.thumb_size * img.size[1] / max(img.size[0], img.size[1]))
crop = (0, 0, 1, 1)
if img.size[0] > img.size[1]:
offset = (1 - img.size[1] / img.size[0]) / 2
crop = (offset, 0, 1 - offset, 1)
if img is not None:
ui_bgl.draw_image(x, y, w, w, img, 1,
crop=crop)
if index == ui_props.active_index:
ui_bgl.draw_rect(x - ui_props.highlight_margin, y - ui_props.highlight_margin,
w + 2 * ui_props.highlight_margin, w + 2 * ui_props.highlight_margin,
highlight)
# if index == ui_props.active_index:
# ui_bgl.draw_rect(x - highlight_margin, y - highlight_margin,
# w + 2*highlight_margin, h + 2*highlight_margin , highlight)
else:
ui_bgl.draw_rect(x, y, w, h, white)
result = search_results[index]
if result['downloaded'] > 0:
ui_bgl.draw_rect(x, y - 2, int(w * result['downloaded'] / 100.0), 2, green)
# object type icons - just a test..., adds clutter/ not so userfull:
# icons = ('type_finished.png', 'type_template.png', 'type_particle_system.png')
if not result.get('can_download', True) == True or user_preferences.api_key == '':
img = utils.get_thumbnail('locked.png')
ui_bgl.draw_image(x + 2, y + 2, 24, 24, img, 1)
v_icon = verification_icons[result.get('verification_status', 'validated')]
if v_icon is not None:
img = utils.get_thumbnail(v_icon)
ui_bgl.draw_image(x + ui_props.thumb_size - 26, y + 2, 24, 24, img, 1)
if user_preferences.api_key == '':
report = 'Please register on BlenderKit website to use the free content.'
ui_bgl.draw_text(report, ui_props.bar_x + ui_props.margin,
ui_props.bar_y - 25 - ui_props.margin - ui_props.bar_height, 15)
elif len(search_results) == 0:
report = 'BlenderKit - No matching results found.'
ui_bgl.draw_text(report, ui_props.bar_x + ui_props.margin,
ui_props.bar_y - 25 - ui_props.margin, 15)
s = bpy.context.scene
props = utils.get_search_props()
if props.report != '' and props.is_searching or props.search_error:
ui_bgl.draw_text(props.report, ui_props.bar_x,
ui_props.bar_y - 15 - ui_props.margin - ui_props.bar_height, 15)
props = s.blenderkitUI
if props.draw_tooltip:
# TODO move this lazy loading into a function and don't duplicate through the code
iname = utils.previmg_name(ui_props.active_index, fullsize=True)
directory = paths.get_temp_dir('%s_search' % mappingdict[props.asset_type])
sr = s.get('search results')
if sr != None and ui_props.active_index != -3:
r = sr[ui_props.active_index]
tpath = os.path.join(directory, r['thumbnail'])
img = bpy.data.images.get(iname)
if img == None or img.filepath != tpath:
if os.path.exists(tpath): # sometimes we are unlucky...
if img is None:
img = bpy.data.images.load(tpath)
img.name = iname
else:
if img.filepath != tpath:
# todo replace imgs reloads with a method that forces unpack for thumbs.
if img.packed_file is not None:
img.unpack(method='USE_ORIGINAL')
img.filepath = tpath
img.reload()
img.name = iname
else:
iname = utils.previmg_name(ui_props.active_index)
img = bpy.data.images.get(iname)
draw_tooltip(ui_props.mouse_x, ui_props.mouse_y, ui_props.tooltip, img)
if ui_props.dragging and (
ui_props.draw_drag_image or ui_props.draw_snapped_bounds) and ui_props.active_index > -1:
iname = utils.previmg_name(ui_props.active_index)
img = bpy.data.images.get(iname)
linelength = 35
ui_bgl.draw_image(ui_props.mouse_x + linelength, ui_props.mouse_y - linelength - ui_props.thumb_size,
ui_props.thumb_size, ui_props.thumb_size, img, 1)
ui_bgl.draw_line2d(ui_props.mouse_x, ui_props.mouse_y, ui_props.mouse_x + linelength,
ui_props.mouse_y - linelength, 2, white)
def draw_callback_3d(self, context):
''' Draw snapped bbox while dragging and in the future other blenderkit related stuff. '''
ui = context.scene.blenderkitUI
if ui.dragging and ui.asset_type == 'MODEL':
if ui.draw_snapped_bounds:
draw_bbox(ui.snapped_location, ui.snapped_rotation, ui.snapped_bbox_min, ui.snapped_bbox_max)
def mouse_raycast(context, mx, my):
r = context.region
rv3d = context.region_data
coord = mx, my
# get the ray from the viewport and mouse
view_vector = view3d_utils.region_2d_to_vector_3d(r, rv3d, coord)
ray_origin = view3d_utils.region_2d_to_origin_3d(r, rv3d, coord)
ray_target = ray_origin + (view_vector * 1000000000)
vec = ray_target - ray_origin
has_hit, snapped_location, snapped_normal, face_index, object, matrix = bpy.context.scene.ray_cast(
bpy.context.view_layer, ray_origin, vec)
# rote = mathutils.Euler((0, 0, math.pi))
randoffset = math.pi
if has_hit:
snapped_rotation = snapped_normal.to_track_quat('Z', 'Y').to_euler()
up = Vector((0, 0, 1))
props = bpy.context.scene.blenderkit_models
if props.randomize_rotation and snapped_normal.angle(up) < math.radians(10.0):
randoffset = props.offset_rotation_amount + math.pi + (
random.random() - 0.5) * props.randomize_rotation_amount
else:
randoffset = props.offset_rotation_amount # we don't rotate this way on walls and ceilings. + math.pi
# snapped_rotation.z += math.pi + (random.random() - 0.5) * .2
else:
snapped_rotation = mathutils.Quaternion((0, 0, 0, 0)).to_euler()
snapped_rotation.rotate_axis('Z', randoffset)
return has_hit, snapped_location, snapped_normal, snapped_rotation, face_index, object, matrix
def floor_raycast(context, mx, my):
r = context.region
rv3d = context.region_data
coord = mx, my
# get the ray from the viewport and mouse
view_vector = view3d_utils.region_2d_to_vector_3d(r, rv3d, coord)
ray_origin = view3d_utils.region_2d_to_origin_3d(r, rv3d, coord)
ray_target = ray_origin + (view_vector * 1000)
# various intersection plane normals are needed for corner cases that might actually happen quite often - in front and side view.
# default plane normal is scene floor.
plane_normal = (0, 0, 1)
if math.isclose(view_vector.x, 0, abs_tol=1e-4) and math.isclose(view_vector.z, 0, abs_tol=1e-4):
plane_normal = (0, 1, 0)
elif math.isclose(view_vector.z, 0, abs_tol=1e-4):
plane_normal = (1, 0, 0)
snapped_location = mathutils.geometry.intersect_line_plane(ray_origin, ray_target, (0, 0, 0), plane_normal,
False)
if snapped_location != None:
has_hit = True
snapped_normal = Vector((0, 0, 1))
face_index = None
object = None
matrix = None
snapped_rotation = snapped_normal.to_track_quat('Z', 'Y').to_euler()
props = bpy.context.scene.blenderkit_models
if props.randomize_rotation:
randoffset = props.offset_rotation_amount + math.pi + (
random.random() - 0.5) * props.randomize_rotation_amount
else:
randoffset = props.offset_rotation_amount + math.pi
snapped_rotation.rotate_axis('Z', randoffset)
return has_hit, snapped_location, snapped_normal, snapped_rotation, face_index, object, matrix
def is_rating_possible():
ao = bpy.context.active_object
ui = bpy.context.scene.blenderkitUI
if bpy.context.scene.get('assets rated') is not None and ui.down_up == 'SEARCH':
if bpy.context.mode in ('SCULPT', 'PAINT_TEXTURE'):
b = utils.get_active_brush()
ad = b.get('asset_data')
if ad is not None:
rated = bpy.context.scene['assets rated'].get(ad['asset_base_id'])
return True, rated, b, ad
if ao is not None:
# TODO ADD BRUSHES HERE
ad = ao.get('asset_data')
if ad is not None:
rated = bpy.context.scene['assets rated'].get(ad['asset_base_id'])
# originally hidden for allready rated assets
return True, rated, ao, ad
# check also materials
m = ao.active_material
if m is not None:
ad = m.get('asset_data')
if ad is not None:
rated = bpy.context.scene['assets rated'].get(ad['asset_base_id'])
return True, rated, m, ad
# if t>2 and t<2.5:
# ui_props.rating_on = False
return False, False, None, None
def interact_rating(r, mx, my, event):
ui = bpy.context.scene.blenderkitUI
rating_possible, rated, asset, asset_data = is_rating_possible()
if rating_possible:
bkit_ratings = asset.bkit_ratings
t = time.time() - ui.last_rating_time
# if t>2:
# if rated:
# ui_props.rating_button_on = True
# ui_props.rating_menu_on = False
if ui.rating_button_on and event.type == 'LEFTMOUSE' and event.value == 'RELEASE':
if mouse_in_area(mx, my,
ui.rating_x,
ui.rating_y - ui.rating_button_width,
ui.rating_button_width * 2,
ui.rating_button_width):
ui.rating_menu_on = True
ui.rating_button_on = False
return True
if ui.rating_menu_on:
if mouse_in_area(mx, my,
ui.rating_x,
ui.rating_y - ui.rating_ui_height,
ui.rating_ui_width,
ui.rating_ui_height + 25):
rmx = mx - (ui.rating_x)
rmy = my - (ui.rating_y - ui.rating_ui_height)
# quality
upload_rating = False
if (ui.quality_stars_x < rmx and rmx < ui.quality_stars_x + 10 * ui.star_size and \
ui.quality_stars_y < rmy and rmy < ui.quality_stars_y + ui.star_size and event.type == 'LEFTMOUSE' and event.value == 'PRESS') or \
ui.dragging_rating_quality:
if event.type == 'LEFTMOUSE':
if event.value == 'PRESS':
ui.dragging_rating = True
ui.dragging_rating_quality = True
elif event.value == 'RELEASE':
ui.dragging_rating = False
ui.dragging_rating_quality = False
if ui.dragging_rating_quality:
q = math.ceil((rmx - ui.quality_stars_x) / (float(ui.star_size)))
bkit_ratings.rating_quality = q
# work hours
if (
ui.workhours_bar_x < rmx and rmx < ui.workhours_bar_x + ui.workhours_bar_x_max + ui.workhours_bar_slider_size and \
ui.workhours_bar_y < rmy and rmy < ui.workhours_bar_y + ui.workhours_bar_slider_size and event.type == 'LEFTMOUSE' and event.value == 'PRESS') \
or (ui.dragging_rating_work_hours):
if event.value == 'PRESS':
ui.dragging_rating = True
ui.dragging_rating_work_hours = True
elif event.value == 'RELEASE':
ui.dragging_rating = False
ui.dragging_rating_work_hours = False
if ui.dragging_rating_work_hours:
xv = rmx - ui.workhours_bar_x - ui.workhours_bar_slider_size / 2
ratio = xv / ui.workhours_bar_x_max
if asset_data['asset_type'] == 'model':
wh_log2 = ratio * 9 - 1
wh = 2 ** wh_log2
else:
wh = 5 * ratio
bkit_ratings.rating_work_hours = wh
if event.type == 'LEFTMOUSE' and event.value == 'RELEASE':
if bkit_ratings.rating_quality > 0.1 or bkit_ratings.rating_work_hours > 0.1:
ratings.upload_rating(asset)
ui.last_rating_time = time.time()
return True
else:
ui.rating_button_on = True
ui.rating_menu_on = False
return False
def mouse_in_area(mx, my, x, y, w, h):
if x < mx < x + w and y < my < y + h:
return True
else:
return False
def mouse_in_asset_bar(mx, my):
ui_props = bpy.context.scene.blenderkitUI
if ui_props.bar_y - ui_props.bar_height < my < ui_props.bar_y \
and mx > ui_props.bar_x and mx < ui_props.bar_x + ui_props.bar_width:
return True
else:
return False
def mouse_in_region(r, mx, my):
if 0 < my < r.height and 0 < mx < r.width:
return True
else:
return False
def update_ui_size(area, region):
ui = bpy.context.scene.blenderkitUI
user_preferences = bpy.context.preferences.addons['blenderkit'].preferences
ui_scale = bpy.context.preferences.view.ui_scale
ui.margin = ui.bl_rna.properties['margin'].default * ui_scale
ui.thumb_size = ui.bl_rna.properties['thumb_size'].default * ui_scale
reg_multiplier = 1
if not bpy.context.preferences.system.use_region_overlap:
reg_multiplier = 0
for r in area.regions:
if r.type == 'TOOLS':
ui.bar_x = r.width * reg_multiplier + ui.margin + ui.bar_x_offset * ui_scale
elif r.type == 'UI':
ui.bar_end = r.width * reg_multiplier + 100 * ui_scale
ui.bar_width = region.width - ui.bar_x - ui.bar_end
ui.wcount = math.floor(
(ui.bar_width - 2 * ui.drawoffset) / (ui.thumb_size + ui.margin))
search_results = bpy.context.scene.get('search results')
if search_results != None:
ui.hcount = min(user_preferences.max_assetbar_rows, math.ceil(len(search_results) / ui.wcount))
else:
ui.hcount = 1
ui.bar_height = (ui.thumb_size + ui.margin) * ui.hcount + ui.margin
ui.bar_y = region.height - ui.bar_y_offset * ui_scale
if ui.down_up == 'UPLOAD':
ui.reports_y = ui.bar_y + 800
ui.reports_x = ui.bar_x
else:
ui.reports_y = ui.bar_y + ui.bar_height
ui.reports_x = ui.bar_x
ui.rating_x = ui.bar_x
ui.rating_y = ui.bar_y - ui.bar_height
class AssetBarOperator(bpy.types.Operator):
'''runs search and displays the asset bar at the same time'''
bl_idname = "view3d.blenderkit_asset_bar"
bl_label = "BlenderKit Asset Bar UI"
bl_options = {'REGISTER', 'UNDO'}
do_search: BoolProperty(name="Run Search", description='', default=True, options={'SKIP_SAVE'})
keep_running: BoolProperty(name="Keep Running", description='', default=True, options={'SKIP_SAVE'})
free_only: BoolProperty(name="Free Only", description='', default=False, options={'SKIP_SAVE'})
category: StringProperty(
name="Category",
description="search only subtree of this category",
default="", options={'SKIP_SAVE'})
def search_more(self):
sro = bpy.context.scene.get('search results orig', {})
if sro.get('next') != None:
search.search(get_next=True)
def exit_modal(self):
try:
bpy.types.SpaceView3D.draw_handler_remove(self._handle_2d, 'WINDOW')
bpy.types.SpaceView3D.draw_handler_remove(self._handle_3d, 'WINDOW')
except:
pass;
ui_props = bpy.context.scene.blenderkitUI
ui_props.dragging = False
ui_props.tooltip = ''
ui_props.active_index = -3
ui_props.draw_drag_image = False
ui_props.draw_snapped_bounds = False
ui_props.has_hit = False
ui_props.assetbar_on = False
def modal(self, context, event):
# This is for case of closing the area or changing type:
ui_props = context.scene.blenderkitUI
user_preferences = bpy.context.preferences.addons['blenderkit'].preferences
areas = []
for w in context.window_manager.windows:
areas.extend(w.screen.areas)
if bpy.context.scene != self.scene:
self.exit_modal()
ui_props.assetbar_on = False
return {'CANCELLED'}
if self.area not in areas or self.area.type != 'VIEW_3D':
print('search areas')
# stopping here model by now - because of:
# switching layouts or maximizing area now fails to assign new area throwing the bug
# internal error: modal gizmo-map handler has invalid area
self.exit_modal()
ui_props.assetbar_on = False
return {'CANCELLED'}
newarea = None
for a in context.window.screen.areas:
if a.type == 'VIEW_3D':
self.area = a
for r in a.regions:
if r.type == 'WINDOW':
self.region = r
newarea = a
break;
# context.area = a
# we check again and quit if things weren't fixed this way.
if newarea == None:
self.exit_modal()
ui_props.assetbar_on = False
return {'CANCELLED'}
update_ui_size(self.area, self.region)
search.timer_update()
download.timer_update()
bg_blender.bg_update()
if context.region != self.region:
return {'PASS_THROUGH'}
# this was here to check if sculpt stroke is running, but obviously that didn't help,
# since the RELEASE event is cought by operator and thus there is no way to detect a stroke has ended...
if bpy.context.mode in ('SCULPT', 'PAINT_TEXTURE'):
if event.type == 'MOUSEMOVE': # ASSUME THAT SCULPT OPERATOR ACTUALLY STEALS THESE EVENTS,
# SO WHEN THERE ARE SOME WE CAN APPEND BRUSH...
bpy.context.window_manager['appendable'] = True
if event.type == 'LEFTMOUSE':
if event.value == 'PRESS':
bpy.context.window_manager['appendable'] = False
self.area.tag_redraw()
s = context.scene
if ui_props.turn_off:
ui_props.assetbar_on = False
ui_props.turn_off = False
self.exit_modal()
ui_props.draw_tooltip = False
return {'CANCELLED'}
if ui_props.down_up == 'UPLOAD':
ui_props.mouse_x = 0
ui_props.mouse_y = self.region.height
mx = event.mouse_x
my = event.mouse_y
ui_props.draw_tooltip = True
# only generate tooltip once in a while
if (
event.type == 'LEFTMOUSE' or event.type == 'RIGHTMOUSE') and event.value == 'RELEASE' or event.type == 'ENTER' or ui_props.tooltip == '':
ao = bpy.context.active_object
if ui_props.asset_type == 'MODEL' and ao != None \
or ui_props.asset_type == 'MATERIAL' and ao != None and ao.active_material != None \
or ui_props.asset_type == 'BRUSH':
export_data, upload_data, eval_path_computing, eval_path_state, eval_path, props = upload.get_upload_data(
self,
context,
ui_props.asset_type)
ui_props.tooltip = search.generate_tooltip(upload_data)
return {'PASS_THROUGH'}
# TODO add one more condition here to take less performance.
r = self.region
s = bpy.context.scene
sr = s.get('search results')
# If there aren't any results, we need no interaction(yet)
if sr is None:
return {'PASS_THROUGH'}
if len(sr) - ui_props.scrolloffset < (ui_props.wcount * ui_props.hcount) + 10:
self.search_more()
if event.type == 'WHEELUPMOUSE' or event.type == 'WHEELDOWNMOUSE' or event.type == 'TRACKPADPAN':
# scrolling
mx = event.mouse_region_x
my = event.mouse_region_y
if ui_props.dragging and not mouse_in_asset_bar(mx, my): # and my < r.height - ui_props.bar_height \
# and mx > 0 and mx < r.width and my > 0:
sprops = bpy.context.scene.blenderkit_models
if event.type == 'WHEELUPMOUSE':
sprops.offset_rotation_amount += sprops.offset_rotation_step
elif event.type == 'WHEELDOWNMOUSE':
sprops.offset_rotation_amount -= sprops.offset_rotation_step
#### TODO - this snapping code below is 3x in this file.... refactor it.
ui_props.has_hit, ui_props.snapped_location, ui_props.snapped_normal, ui_props.snapped_rotation, face_index, object, matrix = mouse_raycast(
context, mx, my)
# MODELS can be dragged on scene floor
if not ui_props.has_hit and ui_props.asset_type == 'MODEL':
ui_props.has_hit, ui_props.snapped_location, ui_props.snapped_normal, ui_props.snapped_rotation, face_index, object, matrix = floor_raycast(
context,
mx, my)
return {'RUNNING_MODAL'}
if not mouse_in_asset_bar(mx, my):
return {'PASS_THROUGH'}
# note - TRACKPADPAN is unsupported in blender by now.
# if event.type == 'TRACKPADPAN' :
# print(dir(event))
# print(event.value, event.oskey, event.)
if (event.type == 'WHEELDOWNMOUSE') and len(sr) - ui_props.scrolloffset > ui_props.wcount:
ui_props.scrolloffset += 1
if event.type == 'WHEELUPMOUSE' and ui_props.scrolloffset > 0:
ui_props.scrolloffset -= 1
return {'RUNNING_MODAL'}
if event.type == 'MOUSEMOVE': # Apply
r = self.region
mx = event.mouse_region_x
my = event.mouse_region_y
ui_props.mouse_x = mx
ui_props.mouse_y = my
if ui_props.dragging_rating or ui_props.rating_menu_on:
res = interact_rating(r, mx, my, event)
if res == True:
return {'RUNNING_MODAL'}
if ui_props.drag_init:
ui_props.drag_length += 1
if ui_props.drag_length > 0:
ui_props.dragging = True
ui_props.drag_init = False
if not (ui_props.dragging and mouse_in_region(r, mx, my)) and not mouse_in_asset_bar(mx, my):
ui_props.active_index = -3
ui_props.draw_tooltip = False
bpy.context.window.cursor_set("DEFAULT")
return {'PASS_THROUGH'}
sr = bpy.context.scene['search results']
if not ui_props.dragging:
bpy.context.window.cursor_set("DEFAULT")
if sr != None and ui_props.wcount * ui_props.hcount > len(sr) and ui_props.scrolloffset > 0:
ui_props.scrolloffset = 0
asset_search_index = get_asset_under_mouse(mx, my)
ui_props.active_index = asset_search_index
if asset_search_index > -1:
asset_data = sr[asset_search_index]
ui_props.draw_tooltip = True
ui_props.tooltip = asset_data['tooltip']
else:
ui_props.draw_tooltip = False
if mx > ui_props.bar_x + ui_props.bar_width - 50 and len(sr) - ui_props.scrolloffset > (
ui_props.wcount * ui_props.hcount):
ui_props.active_index = -1
return {'RUNNING_MODAL'}
if mx < ui_props.bar_x + 50 and ui_props.scrolloffset > 0:
ui_props.active_index = -2
return {'RUNNING_MODAL'}
else:
result = False
if ui_props.dragging and not mouse_in_asset_bar(mx, my) and mouse_in_region(r, mx, my):
ui_props.has_hit, ui_props.snapped_location, ui_props.snapped_normal, ui_props.snapped_rotation, face_index, object, matrix = mouse_raycast(
context, mx, my)
# MODELS can be dragged on scene floor
if not ui_props.has_hit and ui_props.asset_type == 'MODEL':
ui_props.has_hit, ui_props.snapped_location, ui_props.snapped_normal, ui_props.snapped_rotation, face_index, object, matrix = floor_raycast(
context,
mx, my)
if ui_props.has_hit and ui_props.asset_type == 'MODEL':
# this condition is here to fix a bug for a scene submitted by a user, so this situation shouldn't
# happen anymore, but there might exists scenes which have this problem for some reason.
if ui_props.active_index<len(sr) and ui_props.active_index>-1:
ui_props.draw_snapped_bounds = True
active_mod = sr[ui_props.active_index]
ui_props.snapped_bbox_min = Vector(active_mod['bbox_min'])
ui_props.snapped_bbox_max = Vector(active_mod['bbox_max'])
else:
ui_props.draw_snapped_bounds = False
ui_props.draw_drag_image = True
return {'RUNNING_MODAL'}
if event.type == 'LEFTMOUSE':
r = self.region
mx = event.mouse_x - r.x
my = event.mouse_y - r.y
ui_props = context.scene.blenderkitUI
if event.value == 'PRESS' and ui_props.active_index > -1:
if ui_props.asset_type == 'MODEL' or ui_props.asset_type == 'MATERIAL':
ui_props.drag_init = True
bpy.context.window.cursor_set("NONE")
ui_props.draw_tooltip = False
ui_props.drag_length = 0
if ui_props.rating_on:
res = interact_rating(r, mx, my, event)
if res:
return {'RUNNING_MODAL'}
if not ui_props.dragging and not mouse_in_asset_bar(mx, my):
return {'PASS_THROUGH'}
# this can happen by switching result asset types - length of search result changes
if ui_props.scrolloffset > 0 and (ui_props.wcount * ui_props.hcount) > len(sr) - ui_props.scrolloffset:
ui_props.scrolloffset = len(sr) - (ui_props.wcount * ui_props.hcount)
if event.value == 'RELEASE': # Confirm
ui_props.drag_init = False
# scroll by a whole page
if mx > ui_props.bar_x + ui_props.bar_width - 50 and len(
sr) - ui_props.scrolloffset > ui_props.wcount * ui_props.hcount:
ui_props.scrolloffset = min(
ui_props.scrolloffset + (ui_props.wcount * ui_props.hcount),
len(sr) - ui_props.wcount * ui_props.hcount)
return {'RUNNING_MODAL'}
if mx < ui_props.bar_x + 50 and ui_props.scrolloffset > 0:
ui_props.scrolloffset = max(0, ui_props.scrolloffset - ui_props.wcount * ui_props.hcount)
return {'RUNNING_MODAL'}
# Drag-drop interaction
if ui_props.dragging and mouse_in_region(r, mx, my):
asset_search_index = ui_props.active_index
# raycast here
ui_props.active_index = -3
if ui_props.asset_type == 'MODEL':
ui_props.has_hit, ui_props.snapped_location, ui_props.snapped_normal, ui_props.snapped_rotation, face_index, object, matrix = mouse_raycast(
context, mx, my)
# MODELS can be dragged on scene floor
if not ui_props.has_hit and ui_props.asset_type == 'MODEL':
ui_props.has_hit, ui_props.snapped_location, ui_props.snapped_normal, ui_props.snapped_rotation, face_index, object, matrix = floor_raycast(
context,
mx, my)
if not ui_props.has_hit:
return {'RUNNING_MODAL'}
target_object = ''
if object is not None:
target_object = object.name
target_slot = ''
if ui_props.asset_type == 'MATERIAL':
ui_props.has_hit, ui_props.snapped_location, ui_props.snapped_normal, ui_props.snapped_rotation, face_index, object, matrix = mouse_raycast(
context, mx, my)
if not ui_props.has_hit:
# this is last attempt to get object under mouse - for curves and other objects than mesh.
ui_props.dragging = False
sel = utils.selection_get()
bpy.ops.view3d.select(location=(event.mouse_region_x, event.mouse_region_y))
sel1 = utils.selection_get()
if sel[0] != sel1[0] and sel1[0].type != 'MESH':
object = sel1[0]
target_slot = sel1[0].active_material_index
ui_props.has_hit = True
utils.selection_set(sel)
if not ui_props.has_hit:
print('select fun')
return {'RUNNING_MODAL'}
else:
# first, test if object can have material applied.
if object is not None and not object.is_library_indirect:
target_object = object.name
# create final mesh to extract correct material slot
temp_mesh = object.to_mesh(depsgraph=bpy.context.depsgraph, apply_modifiers=True,
calc_undeformed=False)
target_slot = temp_mesh.polygons[face_index].material_index
else:
self.report({'WARNING'}, "Invalid or library object as input:")
target_object = ''
target_slot = ''
# Click interaction
else:
asset_search_index = get_asset_under_mouse(mx, my)
if ui_props.asset_type in ('MATERIAL',
'MODEL'): # this was meant for particles, commenting for now or ui_props.asset_type == 'MODEL':
ao = bpy.context.active_object
if ao != None and not ao.is_library_indirect:
target_object = bpy.context.active_object.name
target_slot = bpy.context.active_object.active_material_index
else:
target_object = ''
target_slot = ''
# FIRST START SEARCH
if asset_search_index == -3:
return {'RUNNING_MODAL'}
if asset_search_index > -3:
if ui_props.asset_type == 'MATERIAL':
if target_object != '':
# position is for downloader:
loc = ui_props.snapped_location
rotation = (0, 0, 0)
asset_data = sr[asset_search_index]
utils.automap(target_object, target_slot=target_slot,
tex_size=asset_data.get('texture_size_meters', 1.0))
bpy.ops.scene.blenderkit_download(True,
asset_type=ui_props.asset_type,
asset_index=asset_search_index,
model_location=loc,
model_rotation=rotation,
target_object=target_object,
material_target_slot=target_slot)
elif ui_props.asset_type == 'MODEL':
if ui_props.has_hit and ui_props.dragging:
loc = ui_props.snapped_location
rotation = ui_props.snapped_rotation
else:
loc = s.cursor.location
rotation = s.cursor.rotation_euler
bpy.ops.scene.blenderkit_download(True,
asset_type=ui_props.asset_type,
asset_index=asset_search_index,
model_location=loc,
model_rotation=rotation,
target_object=target_object)
else:
bpy.ops.scene.blenderkit_download(asset_type=ui_props.asset_type,
asset_index=asset_search_index)
ui_props.dragging = False
return {'RUNNING_MODAL'}
else:
return {'RUNNING_MODAL'}
if event.type == 'X' and ui_props.active_index != -3:
sr = bpy.context.scene['search results']
asset_data = sr[ui_props.active_index]
print(asset_data['name'])
print('delete')
paths.delete_asset_debug(asset_data)
asset_data['downloaded'] = 0
return {'RUNNING_MODAL'}
return {'PASS_THROUGH'}
def invoke(self, context, event):
# FIRST START SEARCH
ui_props = context.scene.blenderkitUI
if self.do_search:
# we erase search keywords for cateogry search now, since these combinations usually return nothing now.
# when the db gets bigger, this can be deleted.
if self.category != '':
sprops = utils.get_search_props()
sprops.search_keywords = ''
search.search(category=self.category, free_only=self.free_only)
if ui_props.assetbar_on:
# we don't want to run the assetbar many times, that's why it has a switch on/off behaviour,
# unless being called with 'keep_running' prop.
if not self.keep_running:
# this sends message to the originally running operator, so it quits, and then it ends this one too.
# If it initiated a search, the search will finish in a thread. The switch off procedure is run
# by the 'original' operator, since if we get here, it means
# same operator is allready running.
ui_props.turn_off = True
# if there was an error, we need to turn off these props so we can restart after 2 clicks
ui_props.assetbar_on = False
else:
pass
return {'FINISHED'}
ui_props.dragging = False #only for cases where assetbar ended with an error.
ui_props.assetbar_on = True
ui_props.turn_off = False
sr = bpy.context.scene.get('search results')
if sr is None:
bpy.context.scene['search results'] = []
if context.area.type == 'VIEW_3D':
# the arguments we pass the the callback
args = (self, context)
self.area = context.area
self.scene = bpy.context.scene
for r in self.area.regions:
if r.type == 'WINDOW':
self.region = r
update_ui_size(self.area, self.region)
self._handle_2d = bpy.types.SpaceView3D.draw_handler_add(draw_callback_2d, args, 'WINDOW', 'POST_PIXEL')
self._handle_3d = bpy.types.SpaceView3D.draw_handler_add(draw_callback_3d, args, 'WINDOW', 'POST_VIEW')
context.window_manager.modal_handler_add(self)
ui_props.assetbar_on = True
return {'RUNNING_MODAL'}
else:
self.report({'WARNING'}, "View3D not found, cannot run operator")
return {'CANCELLED'}
def execute(self, context):
return {'RUNNING_MODAL'}
classess = (
AssetBarOperator,
)
# store keymaps here to access after registration
addon_keymaps = []
def register_ui():
for c in classess:
bpy.utils.register_class(c)
args = (None, bpy.context)
bpy.types.SpaceView3D.draw_handler_add(draw_callback_2d_progress, args, 'WINDOW', 'POST_PIXEL')
bpy.types.SpaceView3D.draw_handler_add(draw_callback_3d_progress, args, 'WINDOW', 'POST_VIEW')
wm = bpy.context.window_manager
# spaces solved by registering shortcut to Window. Couldn't register object mode before somehow.
if not wm.keyconfigs.addon:
return
km = wm.keyconfigs.addon.keymaps.new(name="Window", space_type='EMPTY')
kmi = km.keymap_items.new(AssetBarOperator.bl_idname, 'SEMI_COLON', 'PRESS', ctrl=False, shift=False)
kmi.properties.keep_running = False
kmi.properties.do_search = False
addon_keymaps.append(km)
def unregister_ui():
for c in classess:
bpy.utils.unregister_class(c)
args = (None, bpy.context)
try:
bpy.types.SpaceView3D.draw_handler_remove(draw_callback_2d_progress, args, 'WINDOW', 'POST_PIXEL')
bpy.types.SpaceView3D.draw_handler_remove(draw_callback_3d_progress, args, 'WINDOW', 'POST_VIEW')
except:
print('handlers allready removed')
wm = bpy.context.window_manager
if not wm.keyconfigs.addon:
return
for km in addon_keymaps:
wm.keyconfigs.addon.keymaps.remove(km)
del addon_keymaps[:]