def showClipVisKeep(self):
self.geom3D.setDraw(True)
self.state3DLines = self.state3DLines.setAttrib(
ColorAttrib.makeFlat(Vec4(1, 1, 0, 1)))
self.state2D = self.state2D.setAttrib(
ColorAttrib.makeFlat(Vec4(1, 1, 1, 1)))
self.solid.setFaceGeomState(self.geom3DLines, self.state3DLines)
self.solid.setFaceGeomState(self.geom2D, self.state2D)
def show(self, render):
"""
Reparents the root NodePath of this Map's World to the given NodePath.
"""
self.world.scene.setColorOff()
self.world.scene.node().setAttrib(ColorAttrib.makeVertex())
self.world.scene.reparent_to(render)
def __init__(self, id=0, plane=Plane(0, 0, 1, 0), solid=None):
MapWritable.__init__(self, base.document)
self.id = id
self.material = FaceMaterial()
self.vertices = []
self.isSelected = False
self.plane = plane
self.solid = solid
self.hasGeometry = False
self.vdata = None
# Different primitive representations of this face.
self.geom3D = None
self.geom3DLines = None
self.geom2D = None
# Index into the Solid's GeomNode of the Geoms we render for this face.
self.index3D = -1
self.index3DLines = -1
self.index2D = -1
# RenderState for each Geom we render for this face.
self.state3D = RenderState.makeEmpty()
self.state3DLines = RenderState.make(
AntialiasAttrib.make(AntialiasAttrib.MLine),
ColorAttrib.makeFlat(Vec4(1, 1, 0, 1)))
self.state2D = RenderState.makeEmpty()
if solid:
self.setColor(self.solid.color)
# Not None if face is a displacement.
self.dispInfo = None
def empty_node(prefix, color=False):
path = NodePath(prefix + '_path')
node = GeomNode(prefix + '_node')
path.attachNewNode(node)
if color:
path.setAttrib(ColorAttrib.makeVertex())
return (path, node)
def show(self, render):
"""
Reparents the root NodePath of this Map's World to the given NodePath.
"""
self.world.scene.setColorOff()
self.world.scene.node().setAttrib(ColorAttrib.makeVertex())
self.world.scene.reparent_to(render)
def _initModels(self):
models = []
for model in self.scene.scene.findAllMatches(
'**/objects/**/+ModelNode'):
models.append(model)
for model in self.scene.scene.findAllMatches(
'**/layouts/**/+ModelNode'):
models.append(model)
for model in models:
objectNp = model.getParent()
rendererNp = objectNp.attachNewNode('render-semantics')
model = model.copyTo(rendererNp)
# Set the model to be visible only to this camera
model.node().adjustDrawMask(self.cameraMask, self.cameraMask,
self.cameraMask)
model.show()
# Get semantic-related color of model
modelId = model.getNetTag('model-id')
if 'fr_' in modelId:
if modelId.endswith('c'):
catName = 'ceiling'
elif modelId.endswith('f'):
catName = 'floor'
elif modelId.endswith('w'):
catName = 'wall'
else:
pass
catName = self.categoryMapping.getFineGrainedCategoryForModelId(
modelId)
color = MODEL_CATEGORY_COLOR_MAPPING[catName]
# Clear all GeomNode render attributes and set a specified flat color
for nodePath in model.findAllMatches('**/+GeomNode'):
geomNode = nodePath.node()
for n in range(geomNode.getNumGeoms()):
geomNode.setGeomState(
n,
RenderState.make(
ColorAttrib.makeFlat(
LColor(color[0] / 255.0, color[1] / 255.0,
color[2] / 255.0, 1.0)), 1))
# Disable lights for this model
model.setLightOff(1)
# Enable antialiasing
model.setAntialias(AntialiasAttrib.MAuto)
# Reparent render node below the existing physic node (if any)
physicsNp = objectNp.find('**/physics')
if not physicsNp.isEmpty():
rendererNp.reparentTo(physicsNp)
def select(self):
self.state3D = self.state3D.setAttrib(ColorScaleAttrib.make(Vec4(1, 0.75, 0.75, 1)))
self.state2D = self.state2D.setAttrib(ColorAttrib.makeFlat(Vec4(1, 0, 0, 1)))
self.state2D = self.state2D.setAttrib(CullBinAttrib.make("fixed", LEGlobals.SelectedSort))
self.state2D = self.state2D.setAttrib(DepthWriteAttrib.make(False))
self.state2D = self.state2D.setAttrib(DepthTestAttrib.make(False))
self.solid.setFaceGeomState(self.geom3D, self.state3D)
self.solid.setFaceGeomState(self.geom2D, self.state2D)
self.show3DLines()
self.isSelected = True
def deselect(self):
self.state3D = self.state3D.removeAttrib(ColorScaleAttrib)
self.state2D = self.state2D.setAttrib(ColorAttrib.makeFlat(self.solid.color))
self.state2D = self.state2D.removeAttrib(DepthWriteAttrib)
self.state2D = self.state2D.removeAttrib(DepthTestAttrib)
self.state2D = self.state2D.removeAttrib(CullBinAttrib)
self.solid.setFaceGeomState(self.geom3D, self.state3D)
self.solid.setFaceGeomState(self.geom2D, self.state2D)
self.hide3DLines()
self.isSelected = False
def remapTextures(self):
# -------------------------------------------------------------------------------------
# ANIMATED TEXTURE SETUP AND TRANSPARENCY FOR ZONE GEOMETRY (NOT PLACEABLES etc!)
# trying to evaluate the scene graph structure under our root node here
# since flattenStrong() totally changes the structure of our scene from how we
# originally created it, we need to find a way to:
# - get a the geoms that the flatten process has produced
# - find their textures
# - map those back to our sprites
# - and finally set up the update process for texture animations based on the above
#
# NOTE this code will fail if there is more than one sprite useing a single texture!
# Not encountered this yet though.
self.world.consoleOut('setting up animated textures for zone geometry')
for child in self.rootNode.getChildren():
# print child
geom_node = child.node()
for geom_number in range(0, geom_node.getNumGeoms()):
geom_render_state = geom_node.getGeomState(geom_number)
attr = geom_render_state.getAttrib(26) # attrib 26 is the texture attribute (hope this is static)
if attr != None:
# print attr
tex = attr.getTexture()
# print tex # BINGO! now we have the texture for this GEOM, lets find the sprite
sprite = self.zone_wld_container.findSpriteUsing(tex)
if sprite != None:
# print sprite
# set general texture alpha based tansparency for masked textures
# if sprite.masked == 1:
# child.setTransparency(TransparencyAttrib.MAlpha)
if sprite.transparent == 1 or sprite.masked == 1:
# EXPERIMENTAL TRANSPARENCY SUPPORT ###############
# This is for semi-transparent polygons (water surfaces etc)
# we implement the transparency via the alpha component of the GEOM's ColorAttrib
ta = TransparencyAttrib.make(TransparencyAttrib.MAlpha)
geom_render_state = geom_render_state.setAttrib(ta, 1) # potentialy needs passing "int override" (=1?) as second param
if not sprite.masked == 1:
ca = ColorAttrib.makeFlat(Vec4(1, 1, 1, sprite.alpha))
geom_render_state = geom_render_state.setAttrib(ca, 1) # potentialy needs passing "int override" (=1?) as second param
geom_node.setGeomState(geom_number, geom_render_state)
# #####################################################
if sprite.anim_delay > 0:
# ANIMATED SPRITE
# sprite.addAnimGeomRenderState((geom_node, geom_number, geom_render_state))
sprite.addAnimGeomRenderState((geom_node, geom_number, geom_render_state))
else:
print 'could not find sprite for geom node, node texture cant be animated'
def remapTextures(self):
# -------------------------------------------------------------------------------------
# ANIMATED TEXTURE SETUP AND TRANSPARENCY FOR ZONE GEOMETRY (NOT PLACEABLES etc!)
# trying to evaluate the scene graph structure under our root node here
# since flattenStrong() totally changes the structure of our scene from how we
# originally created it, we need to find a way to:
# - get a the geoms that the flatten process has produced
# - find their textures
# - map those back to our sprites
# - and finally set up the update process for texture animations based on the above
#
# NOTE this code will fail if there is more than one sprite useing a single texture!
# Not encountered this yet though.
self.world.consoleOut('setting up animated textures for zone geometry')
for child in self.rootNode.getChildren():
# print child
geom_node = child.node()
for geom_number in range(0, geom_node.getNumGeoms()):
geom_render_state = geom_node.getGeomState(geom_number)
attr = geom_render_state.getAttrib(26) # attrib 26 is the texture attribute (hope this is static)
if attr != None:
# print attr
tex = attr.getTexture()
# print tex # BINGO! now we have the texture for this GEOM, lets find the sprite
sprite = self.zone_wld_container.findSpriteUsing(tex)
if sprite != None:
# print sprite
# set general texture alpha based tansparency for masked textures
# if sprite.masked == 1:
# child.setTransparency(TransparencyAttrib.MAlpha)
if sprite.transparent == 1 or sprite.masked == 1:
# EXPERIMENTAL TRANSPARENCY SUPPORT ###############
# This is for semi-transparent polygons (water surfaces etc)
# we implement the transparency via the alpha component of the GEOM's ColorAttrib
ta = TransparencyAttrib.make(TransparencyAttrib.MAlpha)
geom_render_state = geom_render_state.setAttrib(ta, 1) # potentialy needs passing "int override" (=1?) as second param
if not sprite.masked == 1:
ca = ColorAttrib.makeFlat(Vec4(1, 1, 1, sprite.alpha))
geom_render_state = geom_render_state.setAttrib(ca, 1) # potentialy needs passing "int override" (=1?) as second param
geom_node.setGeomState(geom_number, geom_render_state)
# #####################################################
if sprite.anim_delay > 0:
# ANIMATED SPRITE
# sprite.addAnimGeomRenderState((geom_node, geom_number, geom_render_state))
sprite.addAnimGeomRenderState((geom_node, geom_number, geom_render_state))
else:
print 'could not find sprite for geom node, node texture cant be animated'
def getColorAttributesFromModel(model):
# Calculate the net transformation
transform = model.getNetTransform()
transformMat = transform.getMat()
areas = []
rgbColors = []
textures = []
transparencies = []
for nodePath in model.findAllMatches('**/+GeomNode'):
geomNode = nodePath.node()
for n in range(geomNode.getNumGeoms()):
state = geomNode.getGeomState(n)
geom = geomNode.getGeom(n)
area = getSurfaceAreaFromGeom(geom, transformMat)
if state.hasAttrib(TextureAttrib.getClassType()):
# Get color from texture
texAttr = state.getAttrib(TextureAttrib.getClassType())
tex = texAttr.getTexture()
# Load texture image from file and compute average color
texFilename = str(tex.getFullpath())
img = scipy.ndimage.imread(texFilename)
texture = os.path.splitext(os.path.basename(texFilename))[0]
#TODO: handle black-and-white and RGBA texture
assert img.dtype == np.uint8
assert img.ndim == 3 and img.shape[-1] == 3
rgbColor = (np.mean(img, axis=(0,1)) / 255.0).tolist()
rgbColors.append(rgbColor)
transparencies.append(False)
areas.append(area)
textures.append(texture)
elif state.hasAttrib(ColorAttrib.getClassType()):
colorAttr = state.getAttrib(ColorAttrib.getClassType())
if (colorAttr.getColorType() == ColorAttrib.TFlat or colorAttr.getColorType() == ColorAttrib.TOff):
# Get flat color
color = colorAttr.getColor()
isTransparent = False
if isinstance(color, LVecBase4f):
rgbColor= [color[0], color[1], color[2]]
alpha = color[3]
if state.hasAttrib(TransparencyAttrib.getClassType()):
transAttr = state.getAttrib(TransparencyAttrib.getClassType())
if transAttr.getMode() != TransparencyAttrib.MNone and alpha < 1.0:
isTransparent = True
elif alpha < 1.0:
isTransparent = True
elif isinstance(color, LVecBase3f):
rgbColor= [color[0], color[1], color[2]]
else:
raise Exception('Unsupported color class type: %s' % (color.__class__.__name__))
rgbColors.append(rgbColor)
transparencies.append(isTransparent)
areas.append(area)
textures.append(None)
else:
# Get colors from vertex data
verAreas, verRgbColors, vertransparencies = getColorAttributesFromVertexData(geom, transformMat)
areas.extend(verAreas)
rgbColors.extend(verRgbColors)
transparencies.extend(vertransparencies)
textures.extend([None,]*len(vertransparencies))
areas = np.array(areas)
areas /= np.sum(areas)
return areas, rgbColors, transparencies, textures
from .MapWritable import MapWritable
from src.leveleditor import LEGlobals
from .TransformProperties import OriginProperty, AnglesProperty, ScaleProperty, ShearProperty
from . import MetaData
from .ObjectProperty import ObjectProperty
from src.leveleditor.math.Line import Line
from src.leveleditor.geometry.Box import Box
from src.leveleditor.geometry.GeomView import GeomView
from src.leveleditor.viewport.ViewportType import VIEWPORT_2D_MASK, VIEWPORT_3D_MASK
from enum import IntEnum
BoundsBox3DState = RenderState.make(
ColorAttrib.makeFlat(Vec4(1, 1, 0, 1))
)
BoundsBox2DState = RenderState.make(
ColorAttrib.makeFlat(Vec4(1, 0, 0, 1)),
CullBinAttrib.make("selected-foreground", 0)
)
MapObjectInit = PStatCollector("Arch:CreateSolid:MapObjInit")
# Base class for any object in the map (brush, entity, etc)
class MapObject(MapWritable):
ObjectName = "object"
def __init__(self, id):
from src.leveleditor.geometry.Box import Box
from src.leveleditor.geometry.GeomView import GeomView
from src.leveleditor.grid.GridSettings import GridSettings
from src.leveleditor.mapobject.Entity import Entity
from src.leveleditor import LEUtils, LEGlobals
from src.leveleditor.actions.Create import Create
from src.leveleditor.actions.Select import Deselect
from src.leveleditor.actions.ChangeSelectionMode import ChangeSelectionMode
from src.leveleditor.selection.SelectionType import SelectionType
from src.leveleditor.actions.Select import Select
from src.leveleditor.actions.ActionGroup import ActionGroup
from src.leveleditor.menu.KeyBind import KeyBind
import random
VisState = RenderState.make(ColorAttrib.makeFlat(Vec4(0, 1, 0, 1)),
LightAttrib.makeAllOff(), FogAttrib.makeOff())
class EntityToolOptions(ToolOptions):
GlobalPtr = None
@staticmethod
def getGlobalPtr():
self = EntityToolOptions
if not self.GlobalPtr:
self.GlobalPtr = EntityToolOptions()
return self.GlobalPtr
def __init__(self):
def setColor(self, color):
self.state2D = self.state2D.setAttrib(ColorAttrib.makeFlat(color))
if self.geom2D:
self.solid.setFaceGeomState(self.geom2D, self.state2D)
def _initModels(self):
models = []
for model in self.scene.scene.findAllMatches(
'**/objects/**/+ModelNode'):
models.append(model)
for model in self.scene.scene.findAllMatches(
'**/layouts/**/+ModelNode'):
models.append(model)
for model in models:
objectNp = model.getParent()
rendererNp = objectNp.attachNewNode('render-semantics')
model = model.copyTo(rendererNp)
# Set the model to be visible only to this camera
model.hide(BitMask32.allOn())
model.show(self.cameraMask)
# Get semantic-related color of model
modelId = model.getNetTag('model-id')
if self.segment_by_instance:
instance_id = objectNp.getTag('instance-id')
instance_color = None
if 'fr_' in modelId:
if modelId.endswith('c'):
catName = 'ceiling'
elif modelId.endswith('f'):
catName = 'floor'
elif modelId.endswith('w'):
catName = 'wall'
if self.segment_by_instance:
instance_color = self.instance_color_mapping[catName]
else:
catName = self.categoryMapping.getFineGrainedCategoryForModelId(
modelId)
color = MODEL_CATEGORY_COLOR_MAPPING[catName]
if self.segment_by_instance:
if not instance_color:
instance_color = list(np.random.choice(range(256), size=3))
self.instance_color_mapping[instance_id] = instance_color
color = instance_color
# Clear all GeomNode render attributes and set a specified flat color
for nodePath in model.findAllMatches('**/+GeomNode'):
geomNode = nodePath.node()
for n in range(geomNode.getNumGeoms()):
geomNode.setGeomState(
n,
RenderState.make(
ColorAttrib.makeFlat(
LColor(color[0] / 255.0, color[1] / 255.0,
color[2] / 255.0, 1.0)), 1))
self.color_instance_mapping = {
tuple(v): k
for k, v in self.instance_color_mapping.iteritems()
}
# Disable lights for this model
model.setLightOff(1)
# Enable antialiasing
model.setAntialias(AntialiasAttrib.MAuto)
# Reparent render node below the existing physic node (if any)
physicsNp = objectNp.find('**/physics')
if not physicsNp.isEmpty():
rendererNp.reparentTo(physicsNp)
def setPreviewState(self):
self.state3D = self.state3D.setAttrib(TransparencyAttrib.make(True))
self.state3D = self.state3D.setAttrib(ColorScaleAttrib.make(Vec4(1, 1, 1, PreviewAlpha)))
self.state2D = self.state2D.setAttrib(ColorAttrib.makeFlat(LEGlobals.PreviewBrush2DColor))
class ClipState(IntEnum):
Off = 0
Drawing = 1
Drawn = 2
MovingPoint1 = 3
MovingPoint2 = 4
MovingPoint3 = 5
class ClipSide(IntEnum):
Both = 0
Front = 1
Back = 2
PlaneVis3DState = RenderState.make(
ColorAttrib.makeFlat(Vec4(0, 1, 1, 0.5)),
TransparencyAttrib.make(TransparencyAttrib.MAlpha),
CullFaceAttrib.make(CullFaceAttrib.MCullNone)
)
PlaneVis2DState = RenderState.make(
ColorAttrib.makeFlat(Vec4(0, 1, 1, 1)),
CullBinAttrib.make("fixed", LEGlobals.BoxSort),
CullFaceAttrib.make(CullFaceAttrib.MCullNone)
)
# Draws the clip plane lines and move handles in each 2D viewport
class ClipToolViewport2D:
def __init__(self, tool, vp):
self.tool = tool
from src.leveleditor.actions.Delete import Delete
from src.leveleditor.actions.ChangeSelectionMode import ChangeSelectionMode
from src.leveleditor.DocObject import DocObject
from .GroupsMode import GroupsMode
from .ObjectMode import ObjectMode
from .FaceMode import FaceMode
from .VertexMode import VertexMode
from enum import IntEnum
from functools import partial
from PyQt5 import QtWidgets, QtCore
Bounds3DState = RenderState.make(
ColorAttrib.makeFlat(Vec4(1, 1, 0, 1))
)
Bounds2DState = RenderModes.DashedLineNoZ()
Bounds2DState = Bounds2DState.setAttrib(ColorAttrib.makeFlat(Vec4(1, 1, 0, 1)))
class SelectionManager(DocObject):
Modes = [
GroupsMode,
ObjectMode,
FaceMode,
VertexMode
]
def __init__(self, doc):
from panda3d.core import PStatCollector
from .MapWritable import MapWritable
from bsp.leveleditor import LEGlobals
from .TransformProperties import OriginProperty, AnglesProperty, ScaleProperty, ShearProperty, TransformProperty
from . import MetaData
from .ObjectProperty import ObjectProperty
from bsp.leveleditor.math.Line import Line
from bsp.leveleditor.geometry.Box import Box
from bsp.leveleditor.geometry.GeomView import GeomView
from bsp.leveleditor.viewport.ViewportType import VIEWPORT_2D_MASK, VIEWPORT_3D_MASK
from enum import IntEnum
BoundsBox3DState = RenderState.make(ColorAttrib.makeFlat(Vec4(1, 1, 0, 1)))
BoundsBox2DState = RenderState.make(
ColorAttrib.makeFlat(Vec4(1, 0, 0, 1)),
CullBinAttrib.make("selected-foreground", 0))
MapObjectInit = PStatCollector("Arch:CreateSolid:MapObjInit")
# Base class for any object in the map (brush, entity, etc)
class MapObject(MapWritable):
ObjectName = "object"
def __init__(self, id):
MapObjectInit.start()
