def __init__(
self, parent, name, text="", font=None, pt_size=None, color=None, pos=[0, 0], sub_theme="", options=BGUI_DEFAULT
):
"""
:param parent: the widget's parent
:param name: the name of the widget
:param text: the text to display (this can be changed later via the text property)
:param font: the font to use
:param pt_size: the point size of the text to draw (defaults to 30 if None)
:param color: the color to use when rendering the font
:param pos: a tuple containing the x and y position
:param sub_theme: name of a sub_theme defined in the theme file (similar to CSS classes)
:param options: various other options
"""
Widget.__init__(self, parent, name, None, [0, 0], pos, sub_theme, options)
if font:
self.fontid = blf.load(font)
else:
font = self.theme["Font"]
self.fontid = blf.load(font) if font else 0
if pt_size:
self.pt_size = pt_size
else:
self.pt_size = self.theme["Size"]
if color:
self.color = color
else:
self.color = self.theme["Color"]
self.text = text
def init():
"""init function - runs once"""
# create a new font object, use external ttf file
font_path = logic.expandPath('//text/Big_Bottom_Cartoon_AD.ttf')
italic_font_path = logic.expandPath('//text/Big_Bottom_Cartoon_Italic_AD.ttf')
# store the font indice - to use later
logic.font_id = blf.load(font_path)
logic.font_id_italic = blf.load(italic_font_path)
# set the font drawing routine to run every frame
scene = logic.getCurrentScene()
scene.post_draw = [write]
def __init__(self,
parent,
name,
text="",
font=None,
pt_size=None,
color=None,
pos=[0, 0],
offset=[0, 0],
sub_theme='',
options=BGUI_NONE):
"""
:param parent: the widget's parent
:param name: the name of the widget
:param text: the text to display (this can be changed later via the text property)
:param font: the font to use
:param pt_size: the point size of the text to draw (defaults to 30 if None)
:param color: the color to use when rendering the font
:param pos: a tuple containing the x and y position
:param sub_theme: name of a sub_theme defined in the theme file (similar to CSS classes)
:param options: various other options
"""
Widget.__init__(self, parent, name, [0, 0], pos, offset, sub_theme,
options)
if font:
path = os.path.join("ge", "themes", font)
path = logic.expandPath("//" + path)
self.fontid = blf.load(path)
#self.fontid = blf.load(font)
else:
font = self.theme['Font']
path = os.path.join("ge", "themes", font)
path = logic.expandPath("//" + path)
self.fontid = blf.load(path) if font else 0
#self.fontid = blf.load(font) if font else 0
if pt_size:
self.pt_size = pt_size
else:
self.pt_size = self.theme['Size']
if color:
self.color = color
else:
self.color = self.theme['Color']
self.text = text
self.dimension = 0.0
def draw_text_custom(text,
x,
y,
font_file_path,
shadow_on,
align="LEFT",
size=12,
color=(1.0, 1.0, 1.0, 1.0)):
font_path = font_file_path
font_id = blf.load(font_path)
font = font_id
blf.size(font, size, int(dpi))
glColor4f(*color)
if shadow_on == "ON":
blf.shadow(font, 5, 0.0, 0.0, 0.0, 1.0)
if align == "LEFT":
blf.position(font, x, y, 0)
else:
width, height = blf.dimensions(font, text)
if align == "RIGHT":
blf.position(font, x - width, y, 0)
blf.draw(font, text)
def load_font(self):
if self.font_id is not None:
return
try:
self.font_id = blf.load(self.font_path)
except:
raise Exception
def __init__(self):
# NB: libcode param doesn't work
self.shader = GPUShader(
vertexcode=self.VERT_GLSL,
fragcode=self.FRAG_GLSL,
geocode=self.LIB_GLSL + self.GEOM_GLSL,
defines=self.DEF_GLSL,
)
# Horrific prototype code to ensure bgl draws at drawing scales
# https://blender.stackexchange.com/questions/16493/is-there-a-way-to-fit-the-viewport-to-the-current-field-of-view
def is_landscape(render):
return render.resolution_x > render.resolution_y
def get_scale(camera):
if camera.data.BIMCameraProperties.diagram_scale == "CUSTOM":
human_scale, fraction = camera.data.BIMCameraProperties.custom_diagram_scale.split(
"|")
else:
human_scale, fraction = camera.data.BIMCameraProperties.diagram_scale.split(
"|")
numerator, denominator = fraction.split("/")
return float(numerator) / float(denominator)
camera = bpy.context.scene.camera
render = bpy.context.scene.render
if is_landscape(render):
camera_width_model = camera.data.ortho_scale
else:
camera_width_model = camera.data.ortho_scale / render.resolution_y * render.resolution_x
self.camera_width_mm = get_scale(camera) * camera_width_model
self.font_id = blf.load(
os.path.join(bpy.context.scene.BIMProperties.data_dir, "fonts",
"OpenGost Type B TT.ttf"))
def __init__(self, bounds=[0, 0, 100, 20], fontfile="", font_size=12):
PControl.new.__init__(self, bounds)
self.fid = blf.load(fontfile) if fontfile != "" else 0
self.fontSize = font_size
self._value = 0
self._max = 100.0
self._min = 0.0
self.decimalPlaces = 0
self.increment = 1
self.addb = PButton.new(text="", fontfile=fontfile, text_align=1)
self.decb = PButton.new(text="", fontfile=fontfile, text_align=1)
_this = self
def addf(s, d):
_this.value += self.increment
def decf(s, d):
_this.value -= self.increment
self.addb.on_mouse_click = addf
self.decb.on_mouse_click = decf
self.on_value_change = None
self.backColor = default["text_background"]
def invoke(self, context, event):
#self._time = str(time.strftime('%X %x %Z'))
# Clean lightmaps first?
bpy.ops.tlm.clean_lightmaps()
font_path = bpy.path.abspath('//Zeyada.ttf')
# Store the font indice - to use later.
if os.path.exists(font_path):
font_info["font_id"] = blf.load(font_path)
else:
# Default font.
font_info["font_id"] = 0
args = (context, event)
self._timer = context.window_manager.event_timer_add(
0.1, window=context.window)
context.window_manager.modal_handler_add(self)
self._handle = bpy.types.SpaceView3D.draw_handler_add(
self.draw_callback_px, args, 'WINDOW', 'POST_PIXEL')
# print("Invoked..")
return {'RUNNING_MODAL'}
def __init__(self, bounds = None, rounded = False, with_name = False):
""" constructor of morph class it can be called with no parameters or using the following keywords ->
bounds : bounds set the bounds of the morph. It can be created using the Rect and Point classes
eg. morph = Morph( bounds = Rect(Point(0,0),Point(100,100)) will create a morph with weight and width of 100 pixels
rounded : rounded is a boolean , if true will create a rounded morph
with_name : This one set a name for the morph for easy access """
super(Morph, self).__init__()
if bounds: #PKHG>???28jun and isinstance(bounds, Rectangle):
self.bounds = bounds
else:
self.bounds = Rectangle(Point(0, 0), Point(100,60))
#PKHG test 3jul self.color = (0.3, 0.3, 0.3, 1.0)
#sometimes working ???
self.color = (1, 1, 1, 1)
self.is_visible = True
self.is_draggable = True
self.fps = 0
self.rounded = rounded
# self.last_time = pygame.time.get_ticks()
self.with_name = with_name
self.path_to_local_fonts = self.get_local_font_path()
self.default_font = self.path_to_local_fonts + "/verdana.ttf"
self.font_id = blf.load(self.default_font)
self.my_name_size = 0
self.texture_path = bpy.utils.script_paths()[0] + \
"/addons/Ephestos/data/images/".replace("/",path_sep)
self.world = None
self.texture = None
self.is_textured = False
def __init__(self, bounds=[0, 0, 100, 20], fontfile="", font_size=12):
PControl.new.__init__(self, bounds)
self.fid = blf.load(fontfile) if fontfile != "" else 0
self.fontSize = font_size
self._value = 0
self._max = 100.0
self._min = 0.0
self.decimalPlaces = 0
self.increment = 1
self.addb = PButton.new(text="", fontfile=fontfile, text_align=1)
self.decb = PButton.new(text="", fontfile=fontfile, text_align=1)
_this = self
def addf(s, d):
_this.value += self.increment
def decf(s, d):
_this.value -= self.increment
self.addb.on_mouse_click = addf
self.decb.on_mouse_click = decf
self.on_value_change = None
self.backColor = default["text_background"]
def font_id_get(self):
U = bpy.context.user_preferences
path = U.system.font_path_ui
if path:
i = blf.load(path)
if i != -1:
return i
return 0
def font_id_get(self):
U = bpy.context.user_preferences
path = U.system.font_path_ui
if path:
i = blf.load(path)
if i != -1:
return i
return 0
def __init__(self, parent):
super(Splash, self).__init__(parent)
utils_path = os.path.join(os.path.dirname(blender_cave.__file__), '..', 'utils')
font_path = os.path.join(utils_path, 'font.ttf')
self._font_id = blf.load(font_path)
self._ecg_values = [2.2115759e+00, 1.9184524e+00, 1.6262298e+00, 1.3363817e+00, 1.0457467e+00, 8.7953729e-01,
8.0215353e-01, 7.2426229e-01, 6.5531316e-01, 7.2484014e-01, 8.0165860e-01, 8.7841227e-01,
8.9891580e-01, 8.9938683e-01, 9.0013088e-01, 9.0042507e-01, 8.9932180e-01, 9.4631408e-01,
1.0210519e+00, 1.0902796e+00, 1.1501810e+00, 1.1975850e+00, 1.2304606e+00, 1.2475264e+00,
1.2478137e+00, 1.2309090e+00, 1.1975449e+00, 1.1497013e+00, 1.0900498e+00, 1.0214188e+00,
9.4676607e-01, 8.9919702e-01, 8.9986325e-01, 8.9991225e-01, 8.9988388e-01, 8.9977460e-01,
8.9966892e-01, 8.9969241e-01, 8.9980904e-01, 8.9988400e-01, 9.0185543e-01, 9.2238531e-01,
9.3397361e-01, 9.3126973e-01, 9.1529574e-01, 8.9942898e-01, 8.9962413e-01, 8.9978944e-01,
8.9995322e-01, 8.9989238e-01, 8.9966710e-01, 8.9959321e-01, 8.9979372e-01, 8.9998970e-01,
8.9988168e-01, 8.9960574e-01, 8.9957540e-01, 8.9987410e-01, 9.0006866e-01, 8.9979595e-01,
8.9937733e-01, 8.9969153e-01, 9.1359251e-01, 9.9441355e-01, 1.0596300e+00, 1.1037278e+00,
1.1246771e+00, 1.1277361e+00, 1.1011566e+00, 1.0485388e+00, 9.7126260e-01, 8.9859989e-01,
8.9977939e-01, 9.0055926e-01, 8.9983003e-01, 8.9861560e-01, 8.9962911e-01, 9.4572544e-01,
1.2391061e+00, 1.5307464e+00, 1.8201066e+00, 2.1104914e+00, 2.4091746e+00, 2.3016856e+00]
self._message = ''
self._ecg_values_size = len(self._ecg_values)
self._repeat = 10
self._total_size = self._ecg_values_size * self._repeat
self._extinction = 3.0
self._official_splash = (bge.logic.getCurrentScene().name == "Blender Cave Splash Screen")
if self._official_splash:
return
logo_path = os.path.join(utils_path, 'bc.ppm')
file = open(logo_path, 'r')
magic = file.readline().strip()
if magic != 'P3':
self.getLogger().warning('Cannot load Blender Cave Logo !')
return
comment = file.readline()
format = file.readline().strip().split(' ')
self.getLogger().debug('Blender Cave Logo size: ' + str(format))
highest = float(file.readline())
texture_buffer = []
while 1:
line = file.readline().strip()
try:
value = float(line)
except ValueError:
break
texture_buffer.append(int(255 * (value / highest)))
texture_buffer = Buffer(GL_BYTE, len(texture_buffer), texture_buffer)
glEnable(GL_TEXTURE_2D)
texture_id_buffer = Buffer(GL_INT,1)
glGenTextures(1, texture_id_buffer)
self._texture_id = texture_id_buffer[0]
glBindTexture(GL_TEXTURE_2D, self._texture_id)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, int(format[0]), int(format[1]), 0, GL_RGB,GL_UNSIGNED_BYTE, texture_buffer)
glDisable(GL_TEXTURE_2D)
def init():
"""init function - runs once"""
# create a new font object
font_path = logic.expandPath('//fonts/CabinSketch.ttf')
logic.font_id = blf.load(font_path)
# set the font drawing routine to run
scene = logic.getCurrentScene()
scene.post_draw = [draw_names]
def __init__(self, parent, name, text="", font=None, pt_size=None, color=None,
outline_color=None, outline_size=None, outline_smoothing=None,
shadow=False, shadow_color=[0, 0, 0, 1], shadow_blur=5,
pos=[0, 0], sub_theme='', options=BGUI_DEFAULT):
"""
:param parent: the widget's parent
:param name: the name of the widget
:param text: the text to display (this can be changed later via the text property)
:param font: the font to use
:param pt_size: the point size of the text to draw (defaults to 30 if None)
:param color: the color to use when rendering the font
:param pos: a tuple containing the x and y position
:param sub_theme: name of a sub_theme defined in the theme file (similar to CSS classes)
:param options: various other options
"""
Widget.__init__(self, parent, name, None, [0, 0], pos, sub_theme, options)
if not font:
font = self.theme['Font']
if Theme.path != './' and font:
font = path.join(Theme.path, font)
self.fontid = blf.load(font) if font else 0
if pt_size:
self.pt_size = pt_size
else:
self.pt_size = self.theme['Size']
if color:
self.color = color
else:
self.color = self.theme['Color']
if outline_color:
self.outline_color = color
else:
self.outline_color = self.theme['OutlineColor']
if outline_size is not None:
self.outline_size = outline_size
else:
self.outline_size = self.theme['OutlineSize']
self.outline_size = int(self.outline_size)
if outline_smoothing is not None:
self.outline_smoothing = outline_smoothing
else:
self.outline_smoothing = self.theme['OutlineSmoothing']
self.text = text
self.shadow = shadow
self.shadow_color = shadow_color
self.shadow_blur = shadow_blur
def init():
"""init function - runs once"""
# create a new font object, use external ttf file
font_path = logic.expandPath('//Zeyada.ttf')
# store the font indice - to use later
logic.font_id = blf.load(font_path)
# set the font drawing routine to run every frame
scene = logic.getCurrentScene()
scene.post_draw = [write]
def test_font(self):
print("test_font")
import blf
import addon_utils
#PKHG.e.g. paths() check_contains(addon_utils,'addons')
addon_path = addon_utils.paths()[0]
local_font_path = addon_path +"/Ephestos/fonts"
verdana = local_font_path + "/verdana.ttf"
res = blf.load(verdana)
self.assertNotEqual(res, -1)
def init():
"""init function - runs once"""
# create a new font object, use external ttf file
font_path = logic.expandPath('//fonts/impact.ttf')
# store the font indice - to use later
logic.font_id = blf.load(font_path)
# set the font drawing routine to run every frame
scene = logic.getCurrentScene()
scene.post_draw = [write]
def __init__(self, parent):
super(Splash, self).__init__(parent)
utils_path = os.path.join(BlenderVR_root, 'utils')
font_path = os.path.join(utils_path, 'font.ttf')
self._font_id = blf.load(font_path)
self._ecg_values = ECG_VALUES
self._message = ''
self._ecg_values_size = len(self._ecg_values)
self._repeat = 8
self._total_size = self._ecg_values_size * self._repeat
self._extinction = 3.0
self._official_splash = (bge.logic.getCurrentScene().name ==
"BlenderVR Splash Screen")
if self._official_splash:
return
logo_path = os.path.join(utils_path, 'bvr-logo.ppm')
logofile = open(logo_path, 'r')
magic = logofile.readline().strip()
if magic != 'P3': # check for plain ppm format
self.logger.warning('Cannot load BlenderVR Logo (wrong .ppm format)')
return
comment = logofile.readline() # remove comment line (Gimp generated)
assert comment # avoid unused warning
if not comment[0] == '#': # if generated file doesn't have this comment line (varies between e.g. Gimp and MagickImage)
logoformat = comment
else:
logoformat = logofile.readline().strip().split(' ')
highest = float(logofile.readline())
texture_buffer = []
while 1:
line = logofile.readline().strip()
try:
value = [int(255 * (float(x) / highest)) for x in line.split(' ')]
except ValueError:
break
texture_buffer.append(value)
if type(texture_buffer[0]) is list:
# from list of list to list (in line of values (per lines) scenario)
texture_buffer = [item for sublist in texture_buffer for item in sublist]
texture_buffer = Buffer(GL_BYTE, len(texture_buffer), texture_buffer)
glEnable(GL_TEXTURE_2D)
texture_id_buffer = Buffer(GL_INT, 1)
glGenTextures(1, texture_id_buffer)
self._texture_id = texture_id_buffer[0]
glBindTexture(GL_TEXTURE_2D, self._texture_id)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, int(logoformat[0]),
int(logoformat[1]), 0, GL_RGB, GL_UNSIGNED_BYTE,
texture_buffer)
glDisable(GL_TEXTURE_2D)
def getFontID(self, font):
if font is None or font.filepath == "<builtin>":
self.raiseErrorMessage("BFont is not supported!")
fontID = blf.load(font.filepath)
if fontID == -1:
self.raiseErrorMessage("Can't load font!")
blf.size(fontID, 50, 72)
return fontID
def init():
# create a new font object, use external ttf file
font_path = logic.expandPath('//assets/fonts/LiberationMono-Regular.ttf')
# store the font indice - to use later
logic.font_id = blf.load(font_path)
# set the font drawing routine to run every frame
scene = logic.getCurrentScene()
scene.post_draw = [write]
logic.text_buffer = []
def font(self, v):
if self._fontname == v:
return
self._fontname = v
self._font = blf.load(self._fontname)
if self._font < 0:
self._font = 0
self.queue_resize()
def init():
# create a new font object, use external ttf file
font_path = logic.expandPath('//assets/fonts/LiberationMono-Regular.ttf')
# store the font indice - to use later
logic.font_id = blf.load(font_path)
# set the font drawing routine to run every frame
scene = logic.getCurrentScene()
scene.post_draw = [write]
logic.text_buffer = []
def __init__(self, parent, name, text="", font=None, pt_size=None, color=None,
pos=[0, 0], offset=[0,0], sub_theme='', options=BGUI_NONE):
"""
:param parent: the widget's parent
:param name: the name of the widget
:param text: the text to display (this can be changed later via the text property)
:param font: the font to use
:param pt_size: the point size of the text to draw (defaults to 30 if None)
:param color: the color to use when rendering the font
:param pos: a tuple containing the x and y position
:param sub_theme: name of a sub_theme defined in the theme file (similar to CSS classes)
:param options: various other options
"""
Widget.__init__(self, parent, name, [0,0], pos, offset, sub_theme, options)
if font:
path = os.path.join("ge", "themes", font)
path = logic.expandPath("//"+path)
self.fontid = blf.load(path)
#self.fontid = blf.load(font)
else:
font = self.theme['Font']
path = os.path.join("ge", "themes", font)
path = logic.expandPath("//"+path)
self.fontid = blf.load(path) if font else 0
#self.fontid = blf.load(font) if font else 0
if pt_size:
self.pt_size = pt_size
else:
self.pt_size = self.theme['Size']
if color:
self.color = color
else:
self.color = self.theme['Color']
self.text = text
self.dimension = 0.0
def __init__(self, font, type, size):
dir = '\\UI\\Fonts\\'
font1 = 'EXO2.0-'
font2 = 'bonn_'
bold = 'Bold'
extraBold = 'ExtraBold'
regular = 'Regular'
light = 'Light'
format = ['.otf', '.ttf']
self.font_info = {
'font_id': None,
'font_handler': None,
'loaded_font': None
}
filepath = None
if font == 'Exo':
if type == 'Bold':
filepath = parent[:-10] + dir + font1 + bold + format[0]
self.font_info['loaded_font'] = filepath
elif type == 'ExtraBold':
filepath = parent[:-10] + dir + font1 + extraBold + format[0]
self.font_info['loaded_font'] = filepath
elif type == 'Regular':
filepath = parent[:-10] + dir + font1 + regular + format[0]
self.font_info['loaded_font'] = filepath
elif type == 'Light':
filepath = parent[:-10] + dir + font1 + light + format[0]
self.font_info['loaded_font'] = filepath
elif font == 'Bonn':
if type == 'Bold':
filepath = parent[:-10] + dir + font2 + bold + format[1]
elif type == 'ExtraBold':
print('This font does not have Extra Bold')
filepath = None
elif type == 'Regular':
filepath = parent[:-10] + dir + font2 + regular + format[1]
elif type == 'Light':
filepath = parent[:-10] + dir + font2 + light + format[1]
self.parent = Vector3([0, 0, 0])
self.position = Vector3([0, 0, 0])
self.pos_pus_parent = Vector3([
self.parent.x + self.position.x,
self.parent.y + self.position.y,
self.parent.z + self.position.z,
])
self.font_info['font_id'] = blf.load(filepath)
blf.size(self.font_info['font_id'], size, 72)
blf.enable(self.font_info['font_id'], 1)
def __init__(self, bounds=[0, 0, 100, 20], text="", fontfile="", font_size=12, text_align=0, vertical_align=1, shadow=False):
PControl.new.__init__(self, bounds)
self._text = text
self.textAlign = text_align
self.verticalAlign = vertical_align
self.fontSize = font_size
self.fid = blf.load(fontfile) if fontfile != "" else 0
self.margin = 0
self.shadow = shadow
self.drawSelection = False
def __init__(self, bounds=[0, 0, 100, 100], fontname=""):
PControl.new.__init__(self, bounds)
self.items = ["Item 1", "Item 2", "Item 3", "Item 4", "Item 5", "Item 6", "Item 7"]
self._ibounds = {}
self.fid = blf.load(fontname) if fontname != "" else 0
self.itemHeight = 16
self.on_selected = None
self.on_draw_item = None
self.backColor = default["text_background"]
self._selected = -1
def init():
"""init function - runs once"""
# create a new font object
font_path = logic.expandPath('//fonts/Nunito.ttf')
logic.font_id = blf.load(font_path)
scene = logic.getCurrentScene()
# object that contains the dynamic text
logic.text = scene.objects["Scripts"]
# set the font drawing routine to run
scene.post_draw=[write]
def load_fonts():
''' Load fonts '''
loaded_fonts["main"] = {}
fonts_path = get_fonts_path()
# load fonts and create dictionary of Font Name : Font ID
for font_name, font_filename in font_names.items():
font_filepath = os.path.join(fonts_path, font_filename)
font_id = blf.load(font_filepath)
if font_id >= 0:
loaded_fonts["main"][font_name] = font_id
else: # font not found or could not load? => use blender default font
loaded_fonts["main"][font_name] = 0
def configure( self, scene=0, resourcescene=0, verbose=True ):
if self.configured:
return
self.verbose = verbose
self.framecount = 0
if scene is 0:
scenes = bge.logic.getSceneList()
for sc in scenes:
if sc.name == "render":
self.context = sc
break
else:
self.context = scene
if resourcescene is 0:
scenes = bge.logic.getSceneList()
for sc in scenes:
if sc.name == "resources":
self.resources = sc
break
else:
self.resources = resourcescene
if self.resources is 0 or self.context is 0:
print( "UNABLE TO LOCATE SCENES!" )
print( "Verify the scenes names (should be 'render' and 'resources')" )
print( "Or pass the scene object in args to this method!" )
print( "scenes:", bge.logic.getSceneList() )
return
self.configured = True
self.defaultLineColor = self.rgb2vector( 255,0,0 )
# setting default values in bge.render
self.background( 255,255,255 )
# not working in texture mode, wait a bug fix
bge.render.disableMist()
# loading default font
font_path = bge.logic.expandPath('//ProcessingBGE/resources/TitilliumWeb-Regular.ttf')
self.font_id = blf.load(font_path)
if ( self.verbose ):
print( "processing/blender inititalised" )
print( "ready to rock!" )
def configure(self, scene=0, resourcescene=0, verbose=True):
if self.configured:
return
self.verbose = verbose
self.framecount = 0
if scene is 0:
scenes = bge.logic.getSceneList()
for sc in scenes:
if sc.name == "render":
self.context = sc
break
else:
self.context = scene
if resourcescene is 0:
scenes = bge.logic.getSceneList()
for sc in scenes:
if sc.name == "resources":
self.resources = sc
break
else:
self.resources = resourcescene
if self.resources is 0 or self.context is 0:
print("UNABLE TO LOCATE SCENES!")
print("Verify the scenes names (should be 'render' and 'resources')")
print("Or pass the scene object in args to this method!")
print("scenes:", bge.logic.getSceneList())
return
self.configured = True
self.defaultLineColor = self.rgb2vector(255, 0, 0)
# setting default values in bge.render
self.background(255, 255, 255)
# not working in texture mode, wait a bug fix
bge.render.disableMist()
# loading default font
font_path = bge.logic.expandPath("//ProcessingBGE/resources/TitilliumWeb-Regular.ttf")
self.font_id = blf.load(font_path)
if self.verbose:
print("processing/blender inititalised")
print("ready to rock!")
def init():
"""init function - runs once"""
import os
# Create a new font object, use external ttf file.
font_path = bpy.path.abspath('//Zeyada.ttf')
# Store the font indice - to use later.
if os.path.exists(font_path):
font_info["font_id"] = blf.load(font_path)
else:
# Default font.
font_info["font_id"] = 0
# set the font drawing routine to run every frame
font_info["handler"] = bpy.types.SpaceView3D.draw_handler_add(
draw_callback_px, (None, None), 'WINDOW', 'POST_PIXEL')
def load(val):
if val is None:
fontid = FontManager._last_fontid
elif type(val) is int:
fontid = val
elif val in FontManager._cache:
fontid = FontManager._cache[val]
else:
# note: loading the same file multiple times is not a problem.
# blender is smart enough to cache
fontid = blf.load(val)
print('Loaded font "%s" as id %d' % (val, fontid))
FontManager._cache[val] = fontid
FontManager._last_fontid = fontid
return fontid
def load(val):
if val is None:
fontid = FontManager._last_fontid
elif type(val) is int:
fontid = val
elif val in FontManager._cache:
fontid = FontManager._cache[val]
else:
# note: loading the same file multiple times is not a problem.
# blender is smart enough to cache
fontid = blf.load(val)
print('Loaded font "%s" as id %d' % (val, fontid))
FontManager._cache[val] = fontid
FontManager._last_fontid = fontid
return fontid
def load(val, load_callback=None):
if val is None:
fontid = FontManager._last_fontid
else:
if val not in FontManager._cache:
# note: loading the same file multiple times is not a problem.
# blender is smart enough to cache
fontid = blf.load(val)
print(f'Addon Common: Loaded font "{val}" as id {fontid}')
FontManager._cache[val] = fontid
FontManager._cache[fontid] = fontid
if load_callback: load_callback(fontid)
fontid = FontManager._cache[val]
FontManager._last_fontid = fontid
return fontid
def __init__(self, bounds=[0, 0, 100, 100], fontname=""):
PControl.new.__init__(self, bounds)
self.items = [
"Item 1", "Item 2", "Item 3", "Item 4", "Item 5", "Item 6",
"Item 7"
]
self._ibounds = {}
self.fid = blf.load(fontname) if fontname != "" else 0
self.itemHeight = 16
self.on_selected = None
self.on_draw_item = None
self.backColor = default["text_background"]
self._selected = -1
def __init__(self, parent):
super(Splash, self).__init__(parent)
utils_path = os.path.join(BlenderVR_root, 'utils')
font_path = os.path.join(utils_path, 'font.ttf')
self._font_id = blf.load(font_path)
self._ecg_values = ECG_VALUES
self._message = ''
self._ecg_values_size = len(self._ecg_values)
self._repeat = 10
self._total_size = self._ecg_values_size * self._repeat
self._extinction = 3.0
self._official_splash = (
bge.logic.getCurrentScene().name == "BlenderVR Splash Screen")
if self._official_splash:
return
logo_path = os.path.join(utils_path, 'bc.ppm')
logofile = open(logo_path, 'r')
magic = logofile.readline().strip()
if magic != 'P3':
self.logger.warning('Cannot load BlenderVR Logo !')
return
comment = logofile.readline()
assert comment # avoid unused warning
logoformat = logofile.readline().strip().split(' ')
highest = float(logofile.readline())
texture_buffer = []
while 1:
line = logofile.readline().strip()
try:
value = float(line)
except ValueError:
break
texture_buffer.append(int(255 * (value / highest)))
texture_buffer = Buffer(GL_BYTE, len(texture_buffer), texture_buffer)
glEnable(GL_TEXTURE_2D)
texture_id_buffer = Buffer(GL_INT, 1)
glGenTextures(1, texture_id_buffer)
self._texture_id = texture_id_buffer[0]
glBindTexture(GL_TEXTURE_2D, self._texture_id)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, int(logoformat[0]),
int(logoformat[1]), 0, GL_RGB, GL_UNSIGNED_BYTE,
texture_buffer)
glDisable(GL_TEXTURE_2D)
def __init__(self, parent):
super(Splash, self).__init__(parent)
utils_path = os.path.join(BlenderVR_root, 'utils')
font_path = os.path.join(utils_path, 'font.ttf')
self._font_id = blf.load(font_path)
self._ecg_values = ECG_VALUES
self._message = ''
self._ecg_values_size = len(self._ecg_values)
self._repeat = 10
self._total_size = self._ecg_values_size * self._repeat
self._extinction = 3.0
self._official_splash = (bge.logic.getCurrentScene().name ==
"BlenderVR Splash Screen")
if self._official_splash:
return
logo_path = os.path.join(utils_path, 'bc.ppm')
logofile = open(logo_path, 'r')
magic = logofile.readline().strip()
if magic != 'P3':
self.logger.warning('Cannot load BlenderVR Logo !')
return
comment = logofile.readline()
assert comment # avoid unused warning
logoformat = logofile.readline().strip().split(' ')
highest = float(logofile.readline())
texture_buffer = []
while 1:
line = logofile.readline().strip()
try:
value = float(line)
except ValueError:
break
texture_buffer.append(int(255 * (value / highest)))
texture_buffer = Buffer(GL_BYTE, len(texture_buffer), texture_buffer)
glEnable(GL_TEXTURE_2D)
texture_id_buffer = Buffer(GL_INT, 1)
glGenTextures(1, texture_id_buffer)
self._texture_id = texture_id_buffer[0]
glBindTexture(GL_TEXTURE_2D, self._texture_id)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, int(logoformat[0]),
int(logoformat[1]), 0, GL_RGB, GL_UNSIGNED_BYTE,
texture_buffer)
glDisable(GL_TEXTURE_2D)
def init(cont):
"""init function - runs once"""
global active_camera, game_timer, bamboo_counter, panda, level
scene = logic.getCurrentScene()
active_camera = cont.owner
bamboo_counter = scene.objects["bambou_counter"]
panda = scene.objects["Panda"]
level = logic.globalDict["level"]
# create a new font object, use external ttf file
font_path = logic.expandPath('//text/Big_Bottom_Cartoon_AD.ttf')
# store the font indice - to use later
logic.font_id = blf.load(font_path)
# set the font drawing routine to run every frame
scene.post_draw = [write]
# initialize the timer at the start of the scene
active_camera["Timer"] = game_timer
def text_init(loc, rot):
import os
global fonting
global handle
font_path = bpy.path.abspath('//Zeyada.ttf')
if os.path.exists(font_path):
font_info["font_id"] = blf.load(font_path)
else:
font_info["font_id"] = 1
loc_2d = bpy_extras.view3d_utils.location_3d_to_region_2d(bpy.context.region, bpy.context.space_data.region_3d, loc)
handle = bpy.types.SpaceView3D.draw_handler_add(
draw_callback_px, (None, None, loc_2d, rot), 'WINDOW', 'POST_PIXEL'
)
fonting = True
def configure(self, verbose=True):
global pbgeversion
if self.configured:
return
self.verbose = verbose
self.framecount = 0
self.scene = bge.logic.getCurrentScene()
self.root = bge.logic.getCurrentController().owner
self.template_cube = 0
self.template_cylinder = 0
self.template_empty = 0
self.template_plane = 0
self.template_sphere = 0
self.template_spot = 0
self.template_2D_circle = 0
self.template_2D_square = 0
self.template_2D_triangle = 0
self.templates = {}
self.generatedObjects = {}
self.locateTemplates()
self.configured = True
# lines and text colors
self.lcolor = self.rgb2vector(255, 0, 0)
self.tcolor = self.rgb2vector(255, 255, 255)
self.tsize = 50
# setting default values in bge.render
self.background(255, 255, 255)
# not working in texture mode, wait a bug fix
bge.render.disableMist()
# loading default font
font_path = bge.logic.expandPath(
'//ProcessingBGE/resources/TitilliumWeb-Regular.ttf')
self.font = blf.load(font_path)
if (self.verbose):
print("processingBGE", pbgeversion, "started & ready to rock!")
def configure( self, verbose=True ):
global pbgeversion
if self.configured:
return
self.verbose = verbose
self.framecount = 0
self.scene = bge.logic.getCurrentScene()
self.root = bge.logic.getCurrentController().owner
self.template_cube = 0
self.template_cylinder = 0
self.template_empty = 0
self.template_plane = 0
self.template_sphere = 0
self.template_spot = 0
self.template_2D_circle = 0
self.template_2D_square = 0
self.template_2D_triangle = 0
self.templates = {}
self.generatedObjects = {}
self.locateTemplates()
self.configured = True
# lines and text colors
self.lcolor = self.rgb2vector( 255,0,0 )
self.tcolor = self.rgb2vector( 255,255,255 )
self.tsize = 50
# setting default values in bge.render
self.background( 255,255,255 )
# not working in texture mode, wait a bug fix
bge.render.disableMist()
# loading default font
font_path = bge.logic.expandPath('//ProcessingBGE/resources/TitilliumWeb-Regular.ttf')
self.font = blf.load(font_path)
if ( self.verbose ):
print( "processingBGE", pbgeversion, "started & ready to rock!" )
def draw_text_custom(text, x, y, font_file_path, shadow_on, align="LEFT", size=12, color=(1.0, 1.0, 1.0, 1.0)):
font_path = font_file_path
font_id = blf.load(font_path)
font = font_id
blf.size(font, size, int(dpi))
glColor4f(*color)
if shadow_on == "ON":
blf.shadow(font, 5, 0.0, 0.0, 0.0, 1.0)
if align == "LEFT":
blf.position(font, x, y, 0)
else:
width, height = blf.dimensions(font, text)
if align == "RIGHT":
blf.position(font, x - width, y, 0)
blf.draw(font, text)
def __init__(
self,
text,
fontname="arialbd.ttf",
fontsize=24,
bold=False,
italic=False,
alignment="left",
# PKHG.INFO a real Text needs a max_with > 0 !!!
max_width=200,
):
#### PKHG idea to make scrolling easy?
"""
max_nr_of_lines >= 1
show lines from startline >= 0
show_nr_of_lines
show_upto = min(startline + show_nr_of_lines, max_nr_of_lines)
==> range(startline,show_upto,1)
problem, if because of width lines were added?!
"""
super(Text, self).__init__()
tmp = addon_utils.paths()[0] + "/Ephestos/fonts/" + fontname
self.font = blf.load(tmp)
blf.size(self.font, fontsize, 72) # DPI = 72 !!
self.background_color = [0, 0, 0, 1]
# PKHG.??? if a of background_color not 1 strange things can happen
# 4jul12 show about use input move about =>strange behavior
self.text = text
self.words = []
self.lines = []
self.fontname = fontname
self.fontsize = fontsize
self.bold = bold
self.italic = italic
self.alignment = alignment
self.max_width = max(20, min(max_width, 800))
# self.color = (.0, 1.0, 1.0, 1.0) #PKHG 7jul12 white forced in draw
self.max_line_width = 0
self.adjust_text(text)
def __init__(self, font, toggle_key=None):
"""Console constructor
Arguments:
font - path to font file
toggle_key - keycode to enable/disable console"""
global SCROLLBACK, WRAP
self.toggle_key = toggle_key
self.active = False
# GUI
view_buf = Buffer(GL_INT, 4)
glGetIntegerv(GL_VIEWPORT, view_buf)
view = view_buf.to_list()
self.text_size = [None] * 2
self.text_fontid = blf.load(font) if font else 0
blf.size(self.text_fontid, 14, 72)
self.text_size[0], self.text_size[1] = blf.dimensions(
self.text_fontid, "W")
self._text = ''
SCROLLBACK = int(SCROLLBACK / (2 * self.text_size[1]))
WRAP = int(WRAP / (self.text_size[0]))
# Console
self.namespace = default_namespace()
self.console = InteractiveConsole(self.namespace)
self.cursor = 0
self.edit_text = ''
self.scrollback = []
self.history = ['']
self.is_multiline = False
message = """Interactive Console"""
self.add_scrollback(message)
def execute(self, context):
#print("Do Exec")
import os
# Create a new font object, use external ttf file.
font_path = bpy.path.abspath('//Zeyada.ttf')
# Store the font indice - to use later.
if os.path.exists(font_path):
font_info["font_id"] = blf.load(font_path)
else:
# Default font.
font_info["font_id"] = 0
# set the font drawing routine to run every frame
#font_info["handler"] = bpy.types.SpaceView3D.draw_handler_add(self.draw_callback_px, (None, None), 'WINDOW', 'POST_PIXEL')
context.window_manager.modal_handler_add(self)
self._updating = False
self._timer = context.window_manager.event_timer_add(
time_step=0.5, window=context.window)
args = (context, None)
self._handle = bpy.types.SpaceView3D.draw_handler_add(
self.draw_callback_px, args, 'WINDOW', 'POST_PIXEL')
return {'RUNNING_MODAL'}
def __init__(self, target=None,
action='nop', #PKHG.??? was None
label='trigger',
fontname="verdana.ttf",
fontsize=10,
bold=False,
italic=False):
#PKHG>??? once and for all that font stuff?
super(Trigger, self).__init__()
import addon_utils
path_to_local_fonts = addon_utils.paths()[0] + "/Ephestos/fonts"
font = path_to_local_fonts + "/" + fontname
font_id = blf.load(font)
blf.size(font_id, 16, 72) #pKHG needed to adjust text with!
dims_x,dims_y = blf.dimensions(font_id, label)
# self.my_name_size = dims_x
# mylabel_width = int(dims_x) + 75
# bounds = Rectangle(Point(0,0),Point(mylabel_width, int(dims_y) + 20))
# super(Trigger, self).__init__(bounds = bounds)
self.set_width(int(dims_x) + 2)
self.set_height(int(dims_y) + 15) #PKHG old: 20)
self.name = label
self.action = action
def font(self, font):
font_path = logic.expandPath('//gui/font/' + font + '.ttf')
if font not in Label._fontname_id: Label._fontname_id[font] = blf.load(font_path)
def __init__(self, path=None): self.id = 0 if path is None else blf.load(path) self.size = 14.0 self.shadowed = True self.shadow_offset = [0, -1]
def load(self, filename): return blf.load(filename)
def initializeExternalFontId():
font_file = r"C:\Users\tonton\Downloads\JetBrainsMono-1.0.3\JetBrainsMono-1.0.3\ttf\JetBrainsMono-Regular.ttf"
print("Font Loaded : " + font_file) #debug
font_info["font_id"] = blf.load(font_file)
def __init__(self, parent):
super(Splash, self).__init__(parent)
utils_path = "/".join((BlenderVR_root, 'utils'))
font_path = "/".join((utils_path, 'font.ttf'))
self._font_id = blf.load(font_path)
self._ecg_values = ECG_VALUES
self._message = ''
self._ecg_values_size = len(self._ecg_values)
self._repeat = 8
self._total_size = self._ecg_values_size * self._repeat
self._extinction = 3.0
self._official_splash = (
bge.logic.getCurrentScene().name == "BlenderVR Splash Screen")
if self._official_splash:
return
logo_path = "/".join((utils_path, 'bvr-logo.ppm'))
logofile = open(logo_path, 'r')
magic = logofile.readline().strip()
if magic != 'P3': # check for plain ppm format
self.logger.warning(
'Cannot load BlenderVR Logo (wrong .ppm format)')
return
comment = logofile.readline() # remove comment line (Gimp generated)
assert comment # avoid unused warning
if not comment[
0] == '#': # if generated file doesn't have this comment line (varies between e.g. Gimp and MagickImage)
logoformat = comment
else:
logoformat = logofile.readline().strip().split(' ')
highest = float(logofile.readline())
texture_buffer = []
while 1:
line = logofile.readline().strip()
try:
value = [
int(255 * (float(x) / highest)) for x in line.split(' ')
]
except ValueError:
break
texture_buffer.append(value)
if type(texture_buffer[0]) is list:
# from list of list to list (in line of values (per lines) scenario)
texture_buffer = [
item for sublist in texture_buffer for item in sublist
]
texture_buffer = Buffer(GL_BYTE, len(texture_buffer), texture_buffer)
glEnable(GL_TEXTURE_2D)
texture_id_buffer = Buffer(GL_INT, 1)
glGenTextures(1, texture_id_buffer)
self._texture_id = texture_id_buffer[0]
glBindTexture(GL_TEXTURE_2D, self._texture_id)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, int(logoformat[0]),
int(logoformat[1]), 0, GL_RGB, GL_UNSIGNED_BYTE,
texture_buffer)
glDisable(GL_TEXTURE_2D)
def init(controller):
font_path = bge.logic.expandPath('//fonts/DejaVuSans.ttf')
bge.logic.font_id = blf.load(font_path)
scene = bge.logic.getCurrentScene()
scene.post_draw = [write]
def load(self, filename):
return blf.load(filename)
def __init__(self, fileName=None):
self.id = blf.load(fileName) if fileName is not None else 0
self.size = 18.0
