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 _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 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()