324 lines
11 KiB
Python
324 lines
11 KiB
Python
# vim:ts=4:et
|
|
# ##### 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 #####
|
|
|
|
# <pep8 compliant>
|
|
|
|
import bpy, bgl, gpu
|
|
from gpu_extras.batch import batch_for_shader
|
|
from bpy.props import BoolProperty, FloatProperty, StringProperty, EnumProperty
|
|
from bpy.props import BoolVectorProperty, CollectionProperty, PointerProperty
|
|
from bpy.props import FloatVectorProperty, IntProperty
|
|
from mathutils import Vector
|
|
|
|
from .entityclass import EntityClass
|
|
|
|
|
|
def build_batch(qfmap):
|
|
def obj_location(obj):
|
|
ec = None
|
|
if obj.qfentity.classname in entity_classes:
|
|
ec = entity_classes[obj.qfentity.classname]
|
|
if not ec or ec.size:
|
|
return obj.location
|
|
loc = Vector()
|
|
for i in range(8):
|
|
loc += Vector(obj.bound_box[i])
|
|
return obj.location + loc/8.0
|
|
entity_classes = qfmap.entity_classes
|
|
entity_targets = qfmap.entity_targets
|
|
target_entities = qfmap.target_entities
|
|
ents = 0
|
|
targs = 0
|
|
verts = []
|
|
colors = []
|
|
for obj in target_entities:
|
|
#obj = bpy.data.objects[objname]
|
|
qfentity = obj.qfentity
|
|
if qfentity.classname not in entity_classes:
|
|
continue
|
|
ents += 1
|
|
ec = entity_classes[qfentity.classname]
|
|
target = None
|
|
killtarget = None
|
|
if "target" in qfentity.fields:
|
|
target = qfentity.fields["target"].value
|
|
if "killtarget" in qfentity.fields:
|
|
killtarget = qfentity.fields["killtarget"].value
|
|
targetlist = [target, killtarget]
|
|
if target == killtarget:
|
|
del targetlist[1]
|
|
for tname in targetlist:
|
|
if tname and tname in entity_targets:
|
|
targets = entity_targets[tname]
|
|
color = (ec.color[0], ec.color[1], ec.color[2], 1)
|
|
for ton in targets:
|
|
targs += 1
|
|
to = bpy.data.objects[ton]
|
|
start = obj_location(obj)
|
|
end = obj_location(to)
|
|
|
|
verts.append(start)
|
|
colors.append(color)
|
|
verts.append(end)
|
|
colors.append(color)
|
|
return {"pos": verts, "color": colors}
|
|
|
|
def draw_callback(self, context):
|
|
#FIXME horribly inefficient
|
|
qfmap = context.scene.qfmap
|
|
content = build_batch(qfmap)
|
|
shader = gpu.shader.from_builtin('3D_SMOOTH_COLOR')
|
|
batch = batch_for_shader(shader, 'LINES', content)
|
|
bgl.glLineWidth(3)
|
|
batch.draw(shader)
|
|
bgl.glLineWidth(1)
|
|
|
|
class VIEW3D_PT_QFEntityRelations(bpy.types.Panel):
|
|
bl_space_type = 'VIEW_3D'
|
|
bl_region_type = 'UI'
|
|
bl_label = "Register callback"
|
|
bl_default_closed = True
|
|
|
|
initDone = False
|
|
|
|
@classmethod
|
|
def poll(cls, context):
|
|
if cls.initDone:
|
|
return False
|
|
if context.area.type == 'VIEW_3D':
|
|
sv3d = bpy.types.SpaceView3D
|
|
sv3d.draw_handler_add (draw_callback, (cls, context), 'WINDOW',
|
|
'POST_VIEW')
|
|
cls.initDone = True
|
|
return False
|
|
def draw_header(self, context):
|
|
pass
|
|
def draw(self, context):
|
|
pass
|
|
|
|
class OBJECT_UL_EntityField_list(bpy.types.UIList):
|
|
def draw_item(self, context, layout, data, item, icon, active_data,
|
|
active_propname, index):
|
|
layout.label(text=item.name)
|
|
layout.label(text=item.value)
|
|
|
|
def qfentity_items(self, context):
|
|
qfmap = context.scene.qfmap
|
|
entclasses = qfmap.entity_classes
|
|
eclist = list(entclasses.keys())
|
|
eclist.sort()
|
|
enum = (('.', "--", ""),)
|
|
enum += tuple(map(lambda ec: (ec, ec, ""), eclist))
|
|
return enum
|
|
|
|
class QFEntityProp(bpy.types.PropertyGroup):
|
|
value: StringProperty(name="")
|
|
template_list_controls: StringProperty(default="value", options={'HIDDEN'})
|
|
|
|
class QFEntity(bpy.types.PropertyGroup):
|
|
classname: EnumProperty(items = qfentity_items, name = "Entity Class")
|
|
flags: BoolVectorProperty(size=12)
|
|
fields: CollectionProperty(type=QFEntityProp, name="Fields")
|
|
field_idx: IntProperty()
|
|
|
|
class QFEntpropAdd(bpy.types.Operator):
|
|
'''Add an entity field/value pair'''
|
|
bl_idname = "object.entprop_add"
|
|
bl_label = "Entprop Add"
|
|
def execute(self, context):
|
|
qfentity = context.active_object.qfentity
|
|
item = qfentity.fields.add()
|
|
item.name = ""
|
|
item.value = ""
|
|
return {'FINISHED'}
|
|
|
|
class QFEntpropRemove(bpy.types.Operator):
|
|
'''Remove an entity field/value pair'''
|
|
bl_idname = "object.entprop_remove"
|
|
bl_label = "Entprop Remove"
|
|
def execute(self, context):
|
|
qfentity = context.active_object.qfentity
|
|
if qfentity.field_idx >= 0:
|
|
qfentity.fields.remove(qfentity.field_idx)
|
|
return {'FINISHED'}
|
|
|
|
def reflow_text(text, max_width):
|
|
lines = []
|
|
for text_line in text.split("\n"):
|
|
if not text_line:
|
|
continue
|
|
words = text_line.split(" ")
|
|
flowed_line = ""
|
|
while words:
|
|
if len(flowed_line) + len(words[0]) > max_width:
|
|
lines.append(flowed_line)
|
|
flowed_line = ""
|
|
flowed_line += (" " if flowed_line else "") + words[0]
|
|
del words[0]
|
|
if flowed_line:
|
|
lines.append(flowed_line)
|
|
return lines
|
|
|
|
class OBJECT_PT_EntityPanel(bpy.types.Panel):
|
|
bl_space_type = 'PROPERTIES'
|
|
bl_region_type = 'WINDOW'
|
|
bl_context = 'object'
|
|
bl_label = 'QF Entity'
|
|
|
|
@classmethod
|
|
def poll(cls, context):
|
|
return True
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
qfentity = context.active_object.qfentity
|
|
qfmap = context.scene.qfmap
|
|
if qfentity.classname:
|
|
ec = qfmap.entity_classes[qfentity.classname]
|
|
else:
|
|
ec = EntityClass.null()
|
|
flags = ec.flagnames + ("",) * (8 - len(ec.flagnames))
|
|
flags += ("!easy", "!medium", "!hard", "!dm")
|
|
row = layout.row()
|
|
row.prop(qfentity, "classname")
|
|
box=layout.box()
|
|
lines = reflow_text(ec.comment, 40)
|
|
for l in lines:
|
|
box.label(text=l)
|
|
row = layout.row()
|
|
for c in range(3):
|
|
col = row.column()
|
|
sub = col.column(align=True)
|
|
for r in range(4):
|
|
idx = c * 4 + r
|
|
sub.prop(qfentity, "flags", text=flags[idx], index=idx)
|
|
row = layout.row()
|
|
col = row.column()
|
|
col.template_list("OBJECT_UL_EntityField_list", "", qfentity, "fields",
|
|
qfentity, "field_idx", rows=3)
|
|
col = row.column(align=True)
|
|
col.operator("object.entprop_add", icon='ADD', text="")
|
|
col.operator("object.entprop_remove", icon='REMOVE', text="")
|
|
if len(qfentity.fields) > qfentity.field_idx >= 0:
|
|
row = layout.row()
|
|
field = qfentity.fields[qfentity.field_idx]
|
|
row.prop(field, "name", text="Field Name")
|
|
row.prop(field, "value", text="Value")
|
|
|
|
def default_brush_entity(entityclass):
|
|
name = entityclass.name
|
|
verts = [(-8, -8, -8),
|
|
( 8, 8, -8),
|
|
(-8, 8, 8),
|
|
( 8, -8, 8)]
|
|
faces = [(0, 2, 1),
|
|
(0, 3, 2),
|
|
(0, 1, 3),
|
|
(1, 2, 3)]
|
|
mesh = bpy.data.meshes.new(name)
|
|
mesh.from_pydata(verts, [], faces)
|
|
return mesh
|
|
|
|
def entity_box(entityclass):
|
|
name = entityclass.name
|
|
size = entityclass.size
|
|
color = entityclass.color
|
|
if name in bpy.data.meshes:
|
|
return bpy.data.meshes[name]
|
|
verts = [(size[0][0], size[0][1], size[0][2]),
|
|
(size[0][0], size[0][1], size[1][2]),
|
|
(size[0][0], size[1][1], size[0][2]),
|
|
(size[0][0], size[1][1], size[1][2]),
|
|
(size[1][0], size[0][1], size[0][2]),
|
|
(size[1][0], size[0][1], size[1][2]),
|
|
(size[1][0], size[1][1], size[0][2]),
|
|
(size[1][0], size[1][1], size[1][2])]
|
|
faces = [(0, 1, 3, 2),
|
|
(0, 2, 6, 4),
|
|
(0, 4, 5, 1),
|
|
(4, 6, 7, 5),
|
|
(6, 2, 3, 7),
|
|
(1, 5, 7, 3)]
|
|
mesh = bpy.data.meshes.new(name)
|
|
mesh.from_pydata(verts, [], faces)
|
|
mat = bpy.data.materials.new(name)
|
|
mat.diffuse_color = color + (1,)
|
|
mesh.materials.append(mat)
|
|
return mesh
|
|
|
|
def set_entity_props(obj, ent):
|
|
qfe = obj.qfentity
|
|
if "classname" in ent.d:
|
|
try:
|
|
qfe.classname = ent.d["classname"]
|
|
except TypeError:
|
|
#FIXME hmm, maybe an enum wasn't the most brilliant idea?
|
|
qfe.classname = ''
|
|
if "spawnflags" in ent.d:
|
|
flags = int(float(ent.d["spawnflags"]))
|
|
for i in range(12):
|
|
qfe.flags[i] = (flags & (1 << i)) and True or False
|
|
if "target" in ent.d or "killtarget" in ent.d:
|
|
bpy.context.scene.qfmap.target_entities.append(obj)
|
|
if "targetname" in ent.d:
|
|
targetname = ent.d["targetname"]
|
|
entity_targets = bpy.context.scene.qfmap.entity_targets
|
|
if targetname not in entity_targets:
|
|
entity_targets[targetname] = []
|
|
entity_targets[targetname].append(obj.name)
|
|
for key in ent.d.keys():
|
|
if key in {"classname", "spawnflags", "origin"}:
|
|
continue
|
|
item = qfe.fields.add()
|
|
item.name = key
|
|
item.value = ent.d[key]
|
|
|
|
def add_entity(self, context, entclass):
|
|
entity_class = context.scene.qfmap.entity_classes[entclass]
|
|
context.user_preferences.edit.use_global_undo = False
|
|
for obj in bpy.data.objects:
|
|
obj.select = False
|
|
if entity_class.size:
|
|
mesh = entity_box(entity_class)
|
|
else:
|
|
mesh = default_brush_entity(entity_class)
|
|
obj = bpy.data.objects.new(entity_class.name, mesh)
|
|
obj.location = context.scene.cursor_location
|
|
obj.select = True
|
|
obj.qfentity.classname = entclass
|
|
context.scene.objects.link(obj)
|
|
bpy.context.scene.objects.active=obj
|
|
context.user_preferences.edit.use_global_undo = True
|
|
return {'FINISHED'}
|
|
|
|
classes_to_register = (
|
|
VIEW3D_PT_QFEntityRelations,
|
|
OBJECT_UL_EntityField_list,
|
|
QFEntityProp,
|
|
QFEntity,
|
|
QFEntpropAdd,
|
|
QFEntpropRemove,
|
|
OBJECT_PT_EntityPanel,
|
|
)
|
|
menus_to_register = (
|
|
)
|
|
custom_properties_to_register = (
|
|
(bpy.types.Object, "qfentity", QFEntity),
|
|
)
|