def create(self):
winprops = WindowProperties.size(self.size, self.size)
props = FrameBufferProperties()
props.setRgbColor(0)
props.setAlphaBits(0)
props.setDepthBits(1)
self.buffer = base.graphicsEngine.makeOutput(
base.pipe, "shadowsBuffer", -2, props, winprops,
GraphicsPipe.BFRefuseWindow, base.win.getGsg(), base.win)
if not self.buffer:
print("Video driver cannot create an offscreen buffer.")
return
self.depthmap = Texture()
self.buffer.addRenderTexture(self.depthmap,
GraphicsOutput.RTMBindOrCopy,
GraphicsOutput.RTPDepthStencil)
self.depthmap.setMinfilter(Texture.FTShadow)
self.depthmap.setMagfilter(Texture.FTShadow)
self.depthmap.setBorderColor(LColor(1, 1, 1, 1))
self.depthmap.setWrapU(Texture.WMBorderColor)
self.depthmap.setWrapV(Texture.WMBorderColor)
self.cam = base.makeCamera(self.buffer, lens=OrthographicLens())
self.cam.reparent_to(render)
self.node = self.cam.node()
self.node.setInitialState(
RenderState.make(
CullFaceAttrib.make_reverse(),
ColorWriteAttrib.make(ColorWriteAttrib.M_none),
))
self.node.setScene(render)
if settings.debug_shadow_frustum:
self.node.showFrustum()
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 _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 DoubleSidedNoZ():
global _DoubleSidedNoZ
if not _DoubleSidedNoZ:
_DoubleSidedNoZ = RenderState.make(
CullFaceAttrib.make(CullFaceAttrib.MCullNone),
DepthTestAttrib.make(DepthTestAttrib.MOff),
DepthWriteAttrib.make(DepthWriteAttrib.MOff),
CullBinAttrib.make("fixed", LEGlobals.WidgetSort))
return _DoubleSidedNoZ
def __init__(self):
assert engine_initialized(
), "You should initialize engine before adding camera to vehicle"
config = get_global_config()["vehicle_config"]["depth_camera"]
self.BUFFER_W, self.BUFFER_H = config[0], config[1]
self.VIEW_GROUND = config[2]
super(DepthCamera, self).__init__()
cam = self.get_cam()
lens = self.get_lens()
cam.lookAt(0, 2.4, 1.3)
lens.setFov(60)
lens.setAspectRatio(2.0)
if get_engine(
).mode == RENDER_MODE_NONE or not AssetLoader.initialized():
return
# add shader for it
if get_global_config()["headless_machine_render"]:
vert_path = AssetLoader.file_path("shaders",
"depth_cam_gles.vert.glsl")
frag_path = AssetLoader.file_path("shaders",
"depth_cam_gles.frag.glsl")
else:
from pgdrive.utils import is_mac
if is_mac():
vert_path = AssetLoader.file_path("shaders",
"depth_cam_mac.vert.glsl")
frag_path = AssetLoader.file_path("shaders",
"depth_cam_mac.frag.glsl")
else:
vert_path = AssetLoader.file_path("shaders",
"depth_cam.vert.glsl")
frag_path = AssetLoader.file_path("shaders",
"depth_cam.frag.glsl")
custom_shader = Shader.load(Shader.SL_GLSL,
vertex=vert_path,
fragment=frag_path)
cam.node().setInitialState(
RenderState.make(ShaderAttrib.make(custom_shader, 1)))
if self.VIEW_GROUND:
self.GROUND = GeoMipTerrain("mySimpleTerrain")
self.GROUND.setHeightfield(
AssetLoader.file_path("textures", "height_map.png"))
# terrain.setBruteforce(True)
# # Since the terrain is a texture, shader will not calculate the depth information, we add a moving terrain
# # model to enable the depth information of terrain
self.GROUND_MODEL = self.GROUND.getRoot()
self.GROUND_MODEL.setPos(-128, 0, self.GROUND_HEIGHT)
self.GROUND_MODEL.hide(CamMask.AllOn)
self.GROUND_MODEL.show(CamMask.DepthCam)
self.GROUND.generate()
def DashedLineNoZ():
global _DashedLineNoZ
if not _DashedLineNoZ:
shattr = getStippleShader()
_DashedLineNoZ = RenderState.make(
shattr,
DepthTestAttrib.make(DepthTestAttrib.MOff),
DepthWriteAttrib.make(DepthWriteAttrib.MOff),
CullFaceAttrib.make(CullFaceAttrib.MCullNone),
)
_DashedLineNoZ = _DashedLineNoZ.setAttrib(CullBinAttrib.make("fixed", LEGlobals.BoxSort))
return _DashedLineNoZ
def __init__(self):
self.enabled = True
sMgr = CIGlobals.getSettingsMgr()
reso = sMgr.ReflectionQuality[sMgr.getSetting("refl").getValue()]
if reso == 0:
self.enabled = False
return
self.waterPlaneNP = None
self.waterNodes = []
# Buffer and reflection camera
buffer = base.win.makeTextureBuffer('waterBuffer', reso, reso)
buffer.setClearColor(Vec4(0, 0, 0, 1))
cfa = CullFaceAttrib.makeReverse()
rs = RenderState.make(cfa)
self.watercamNP = base.makeCamera(buffer)
self.watercamNP.reparentTo(render)
self.makePlane(0.0)
cam = self.watercamNP.node()
cam.getLens().setFov(base.camLens.getFov())
cam.getLens().setNear(1)
cam.getLens().setFar(5000)
cam.setInitialState(rs)
cam.setTagStateKey('Clipped')
self.ts0 = TextureStage("tex_0")
self.tex0 = buffer.getTexture()
self.tex0.setWrapU(Texture.WMClamp)
self.tex0.setWrapV(Texture.WMClamp)
self.ts1 = TextureStage("tex_1")
self.waterTex = loader.loadTexture('phase_3/maps/water_distort.png')
self.waterQuad = None
self.waterStage = TextureStage("waterStage")
image0 = OnscreenImage(image=self.tex0, scale=0.3, pos=(-0.5, 0, 0.7))
image1 = OnscreenImage(image=waterTex, scale=0.3, pos=(0.5, 0, 0.7))
taskMgr.add(self.update, "waterTask")
def gen_arc_left(self, left_side, radius, end_radius, orig_radius, arc, x3,
y3, z3, new_z1, new_z2, segment_shape):
left_surface = self.surfaces[left_side["surface"]]
start_width = left_side["start_width"]
end_width = left_side["end_width"]
left_section = geom.make_circle(
self.cur_x1, self.cur_y1, self.cur_z1,
self.cur_x1 + (x3 * start_width), self.cur_y1 + (y3 * start_width),
self.cur_z1 + (z3 * start_width), radius + orig_radius,
end_radius + orig_radius, arc, new_z1, new_z2, left_surface["len"],
left_surface["width"], end_width, False)[0]
tex_attr = TextureAttrib.make(left_surface["tex"])
state = RenderState.make(tex_attr)
self.snode.addGeom(left_section, state)
self.mesh.addGeom(left_section)
segment_shape.addGeom(left_section)
def create_cam(cls):
cls.create_buffer()
if cls.watercamNP is None:
cfa = CullFaceAttrib.makeReverse()
rs = RenderState.make(cfa)
cls.watercamNP = base.makeCamera(cls.buffer)
cls.watercamNP.reparentTo(render)
#sa = ShaderAttrib.make()
#sa = sa.setShader(loader.loadShader('shaders/splut3Clipped.sha') )
cam = cls.watercamNP.node()
cam.getLens().setFov(base.camLens.getFov())
cam.getLens().setNear(1)
cam.getLens().setFar(5000)
cam.setInitialState(rs)
cam.setTagStateKey('Clipped')
def gen_arc_right(self, right_side, radius, end_radius, orig_radius, arc,
x3, y3, z3, new_z1, new_z2, segment_shape):
right_surface = self.surfaces[right_side["surface"]]
start_width = right_side["start_width"]
end_width = right_side["end_width"]
right_section = \
geom.make_circle(self.cur_x2 - (x3 * start_width), self.cur_y2 - (y3 * start_width),
self.cur_z1 - (z3 * start_width),
self.cur_x2, self.cur_y2, self.cur_z2,
radius - orig_radius,
end_radius - orig_radius,
arc, new_z1, new_z2,
right_surface["len"], right_surface["width"], end_width, True)[0]
tex_attr = TextureAttrib.make(right_surface["tex"])
state = RenderState.make(tex_attr)
self.snode.addGeom(right_section, state)
self.mesh.addGeom(right_section)
segment_shape.addGeom(right_section)
def gen_str_left(self, segment, left_side, x3, y3, x4, y4, z4, new_z1,
segment_shape):
left_surface = self.surfaces[left_side["surface"]]
start_width = left_side["start_width"]
end_width = left_side["end_width"]
left_section = geom.make_square(
self.cur_x1 + (x4 * start_width), self.cur_y1 + (y4 * start_width),
self.cur_z1 + (z4 * start_width), self.cur_x1, self.cur_y1,
self.cur_z1, self.cur_x1 + (x3 * segment["length"]),
self.cur_y1 + (y3 * segment["length"]), new_z1,
self.cur_x1 + (x3 * segment["length"]) + (x4 * end_width),
self.cur_y1 + (y3 * segment["length"]) + (y4 * end_width),
new_z1 + (z4 * end_width), left_surface["len"],
left_surface["width"])
tex_attr = TextureAttrib.make(left_surface["tex"])
state = RenderState.make(tex_attr)
self.snode.addGeom(left_section, state)
self.mesh.addGeom(left_section)
segment_shape.addGeom(left_section)
def gen_str_right(self, segment, right_side, x3, y3, x4, y4, new_z2,
segment_shape):
right_surface = self.surfaces[right_side["surface"]]
start_width = right_side["start_width"]
end_width = right_side["end_width"]
right_section = geom.make_square(
self.cur_x2, self.cur_y2, self.cur_z2,
self.cur_x2 - (x4 * start_width), self.cur_y2 - (y4 * start_width),
self.cur_z2,
self.cur_x2 + (x3 * segment["length"]) - (x4 * end_width),
self.cur_y2 + (y3 * segment["length"]) - (y4 * end_width), new_z2,
self.cur_x2 + (x3 * segment["length"]),
self.cur_y2 + (y3 * segment["length"]), new_z2,
right_surface["len"], right_surface["width"])
tex_attr = TextureAttrib.make(right_surface["tex"])
state = RenderState.make(tex_attr)
self.snode.addGeom(right_section, state)
self.mesh.addGeom(right_section)
segment_shape.addGeom(right_section)
def __init__(self, base):
# Load texture
tex = Loader(base).loadTexture((Path(path.realpath(__file__)).parent.parent.parent / "res/images/checkerboard.png").absolute())
tex.setMagfilter(SamplerState.FT_nearest)
tex.setMinfilter(SamplerState.FT_nearest)
# Set up vertex data
vdata = GeomVertexData("floor_data", GeomVertexFormat.get_v3t2(), Geom.UHStatic)
vdata.setNumRows(6)
vertex = GeomVertexWriter(vdata, "vertex")
texcoord = GeomVertexWriter(vdata, "texcoord")
vertex.addData3(-5, -5, 0)
texcoord.addData3(0, 0, 0)
vertex.addData3(-5, 5, 0)
texcoord.addData3(0, 10, 0)
vertex.addData3(5, 5, 0)
texcoord.addData3(10, 10, 0)
vertex.addData3(5, 5, 0)
texcoord.addData3(10, 10, 0)
vertex.addData3(5, -5, 0)
texcoord.addData3(10, 0, 0)
vertex.addData3(-5, -5, 0)
texcoord.addData3(0, 0, 0)
# Create primitive
prim = GeomTriangles(Geom.UHStatic)
prim.addVertices(0, 1, 2)
prim.addVertices(3, 4, 5)
geom = Geom(vdata)
geom.add_primitive(prim)
# Initialize geometry node
GeomNode.__init__(self, "floor")
attrib = TextureAttrib.make(tex)
state = RenderState.make(attrib)
self.addGeom(geom, state)
def create_cam(cls):
cls.create_buffer()
if cls.watercamNP is None:
cfa = CullFaceAttrib.makeReverse()
rs = RenderState.make(cfa)
cls.watercamNP = base.makeCamera(cls.buffer, camName='waterCam')
cls.watercamNP.reparentTo(render)
#sa = ShaderAttrib.make()
#sa = sa.setShader(loader.loadShader('shaders/splut3Clipped.sha') )
cam = cls.watercamNP.node()
cam.set_camera_mask(BaseObject.WaterCameraMask)
cam.getLens().setFov(base.camLens.getFov())
cam.getLens().setNear(0.01)
cam.getLens().setFar(float("inf"))
cam.setInitialState(rs)
cam.setTagStateKey('Clipped')
#cam.setTagState('True', RenderState.make(sa))
#cam.showFrustum()
cls.task = taskMgr.add(cls.update, "waterTask")
def gen_segments(self):
i = 0
for segment in self.track_data["segments"]:
seg_type = segment["type"]
surface = self.surfaces[segment["surface"]]
gradient = segment.get("grade")
gradient = gradient if gradient is not None else 0
segment_mesh = BulletTriangleMesh()
if seg_type == "str":
section = self.gen_str_segment(segment, surface, gradient,
segment_mesh)
elif seg_type == "arc":
section = self.gen_arc_segment(segment, surface, gradient,
segment_mesh)
else:
continue
tex_attr = TextureAttrib.make(surface["tex"])
state = RenderState.make(tex_attr)
self.snode.addGeom(section, state)
self.mesh.addGeom(section)
segment_mesh.addGeom(section)
segment_shape = BulletTriangleMeshShape(segment_mesh,
dynamic=False)
segment_ghost = render.attachNewNode(
BulletGhostNode(f'track_segment_{i}'))
segment_ghost.node().addShape(segment_shape)
self.world.attachGhost(segment_ghost.node())
segment_ghost.setTwoSided(True)
self.segments.append(segment_ghost)
i += 1
def gen_geom(self, mesh_json):
# Create vertex format
geom_array = GeomVertexArrayFormat()
geom_array.add_column("vertex", 3, Geom.NTFloat32, Geom.CPoint)
has_normals = False
has_texcoords = False
has_weights = False
if "normals" in mesh_json:
geom_array.add_column("normal", 3, Geom.NTFloat32, Geom.CNormal)
has_normals = True
if "texcoords" in mesh_json:
geom_array.add_column("texcoord", 3, Geom.NTFloat32,
Geom.CTexcoord)
has_texcoords = True
if "weights" in mesh_json:
geom_array.add_column("joint", 4, Geom.NTUint8, Geom.CIndex)
geom_array.add_column("weight", 4, Geom.NTFloat32, Geom.COther)
has_weights = True
geom_format = GeomVertexFormat()
geom_format.add_array(geom_array)
geom_format = GeomVertexFormat.register_format(geom_format)
# Set up vertex data
vdata = GeomVertexData(
str(random.randint(0, 255)) + "_vdata", geom_format, Geom.UHStatic)
vcount = len(mesh_json["vertices"]) // 3
vdata.setNumRows(vcount)
vertex = GeomVertexWriter(vdata, "vertex")
for i in range(vcount):
vertex.addData3(mesh_json["vertices"][3 * i],
mesh_json["vertices"][3 * i + 1],
mesh_json["vertices"][3 * i + 2])
if has_normals:
normal = GeomVertexWriter(vdata, "normal")
for i in range(vcount):
normal.addData3(mesh_json["normals"][3 * i],
mesh_json["normals"][3 * i + 1],
mesh_json["normals"][3 * i + 2])
if has_texcoords:
texcoord = GeomVertexWriter(vdata, "texcoord")
for i in range(vcount):
texcoord.addData2(mesh_json["texcoords"][2 * i],
mesh_json["texcoords"][2 * i + 1])
if has_weights:
joint = GeomVertexWriter(vdata, "joint")
weight = GeomVertexWriter(vdata, "weight")
for i in range(vcount):
joint_count = len(mesh_json["joints"][i])
joint.addData4(
0 if joint_count < 1 else mesh_json["joints"][i][0],
0 if joint_count < 2 else mesh_json["joints"][i][1],
0 if joint_count < 3 else mesh_json["joints"][i][2],
0 if joint_count < 4 else mesh_json["joints"][i][3])
weight.addData4(
0 if joint_count < 1 else mesh_json["weights"][i][0],
0 if joint_count < 2 else mesh_json["weights"][i][1],
0 if joint_count < 3 else mesh_json["weights"][i][2],
0 if joint_count < 4 else mesh_json["weights"][i][3])
# Create primitive
prim = GeomTriangles(Geom.UHStatic)
for i in range(vcount // 3):
prim.addVertices(3 * i, 3 * i + 1, 3 * i + 2)
geom = Geom(vdata)
geom.add_primitive(prim)
# Load texture
tex = None
if "texture" in mesh_json:
tex = Loader(EComponent.base).loadTexture(
(Path("resources") / mesh_json["texture"]).absolute())
tex.setMagfilter(SamplerState.FT_nearest)
tex.setMinfilter(SamplerState.FT_nearest)
# Create new geometry node
geom_node = GeomNode(str(random.randint(0, 255)) + "_node")
if tex is None:
geom_node.addGeom(geom)
else:
attrib = TextureAttrib.make(tex)
state = RenderState.make(attrib)
geom_node.addGeom(geom, state)
if EComponent.panda_root_node is not None:
self.geom_path = EComponent.panda_root_node.attach_new_node(
geom_node)
self.geom_path.set_shader_input("object_id", self.object_id)
# Set shader
if has_weights and self.geom_path is not None:
self.geom_path.setTag("shader type", "skinned")
bone_mats = PTA_LMatrix4f()
for _ in range(100):
bone_mats.push_back(helper.np_mat4_to_panda(np.identity(4)))
self.geom_path.set_shader_input(f"boneMats", bone_mats)
# Disable culling
self.geom_path.node().setBounds(OmniBoundingVolume())
self.geom_path.node().setFinal(True)
def __init__(self, name, size=10000, resolution=1024):
"""Arguments:
size -- Edge length of the water square.
resolution -- Texture size of the rendered reflection buffer.
"""
# Uncomment to see the output of the refclection buffer.
base.bufferViewer.toggleEnable()
AssetBase.__init__(self)
self.name = name
self.cm = CardMaker("water surface")
self.cm.setFrame(-0.5 * size, 0.5 * size, -0.5 * size, 0.5 * size)
self.cm.setHasUvs(True)
self.node = NodePath(self.cm.generate())
self.node.setP(self.node, -90)
self.node.flattenLight()
self.node.hide(BitMask32.bit(1))
# self.node.setTwoSided(True)
self.node.setShaderOff()
# size of one texture tile in meters
self.tex_size = 100.0
diffuse = TexturePool.loadTexture("textures/water.diffuse.png")
diffuse.setWrapU(Texture.WMRepeat)
diffuse.setWrapV(Texture.WMRepeat)
diffuse.setMinfilter(Texture.FTLinearMipmapLinear)
diffuse.setMagfilter(Texture.FTLinearMipmapLinear)
self.diffuse_stage = TextureStage("diffuse")
self.diffuse_stage.setSort(2)
self.node.setTexture(self.diffuse_stage, diffuse)
self.node.setTexScale(self.diffuse_stage, size / self.tex_size, size / self.tex_size)
# Reflection camera renders to 'buffer' which is projected onto the
# water surface.
buffer = base.win.makeTextureBuffer("water reflection", resolution, resolution)
buffer.setClearColor(Vec4(0, 0, 0, 1))
self.refl_cam = base.makeCamera(buffer)
self.refl_cam.reparentTo(self.node)
self.refl_cam.node().setCameraMask(BitMask32.bit(1))
self.refl_cam.node().getLens().setFov(base.camLens.getFov())
self.refl_cam.node().getLens().setNearFar(1, 100000)
plane = PlaneNode("water culling plane", Plane(Vec3(0, 0, 1), Point3(0, 0, 0)))
cfa = CullFaceAttrib.makeReverse()
cpa = ClipPlaneAttrib.make(PlaneNode.CEVisible, plane)
rs = RenderState.make(cfa, cpa)
self.refl_cam.node().setInitialState(rs)
reflection = buffer.getTexture()
reflection.setMinfilter(Texture.FTLinear)
reflection.setMagfilter(Texture.FTLinear)
self.refl_stage = TextureStage("reflection")
self.refl_stage.setSort(1)
self.node.projectTexture(self.refl_stage, reflection, base.cam)
self.node.setTexture(self.refl_stage, reflection)
# Blend between diffuse and reflection.
self.diffuse_stage.setColor(VBase4(1, 1, 1, 0.2)) # opacity of 20%
self.diffuse_stage.setCombineRgb(
TextureStage.CMInterpolate,
TextureStage.CSTexture,
TextureStage.COSrcColor,
TextureStage.CSPrevious,
TextureStage.COSrcColor,
TextureStage.CSConstant,
TextureStage.COSrcAlpha,
)
self.addTask(self.update, name="water update", sort=1, taskChain="world")
def createBox(self):
"""
Create the skybox GeomNode
:return:
"""
obj = ''
obj += "# Skybox\n"
obj += 'mtllib skybox.mtl\n'
mtl = '# material for skybox\n'
fmt = GeomVertexFormat.getV3n3t2()
vdata = GeomVertexData('skybox', fmt, Geom.UHStatic)
vdata.setNumRows(24)
vertex = GeomVertexWriter(vdata, 'vertex')
normals = GeomVertexWriter(vdata, 'normal')
texcoord = GeomVertexWriter(vdata, 'texcoord')
node = GeomNode('skybox')
for normal in self.normals:
geom = Geom(vdata)
prim = GeomTriangles(Geom.UHStatic)
idx = vertex.getWriteRow()
verts = self.vertMappings[normal]
tcs = self.getFaceMapping(normal)
for v, t in zip(verts, tcs):
vertex.addData3f(v[0]*2, v[1]*2, v[2]*2)
normals.addData3f(normal)
texcoord.addData2f(t)
obj += 'v {0} {1} {2}\n'.format(v[0]*2, v[1]*2, v[2]*2)
obj += 'vn {0} {1} {2}\n'.format(*normal)
obj += 'vt {0} {1}\n'.format(*t)
tex = self.getFaceTexture(normal)
prim.addVertices(idx, idx + 1, idx + 3)
prim.closePrimitive()
obj += "usemtl {0}\n".format(tex.getName())
obj += 'f {0}/{0} {1}/{1} {2}/{2}\n'.format(1+idx, 1+idx+1, 1+idx+3)
prim.addVertices(idx + 1, idx + 2, idx + 3)
prim.closePrimitive()
obj += "usemtl {0}\n".format(tex.getName())
obj += 'f {0}/{0} {1}/{1} {2}/{2}\n'.format(1+idx+1, 1+idx+2, 1+idx+3)
geom.addPrimitive(prim)
tex.setWrapU(Texture.WMMirror)
tex.setWrapV(Texture.WMMirror)
node.addGeom(geom, RenderState.make(TextureAttrib.make(tex)))
mtl += "newmtl {0}\n".format(tex.getName())
mtl += "Ka 1 1 1\n"
mtl += "Kd 1 1 1\n"
mtl += "map_Kd {0}\n".format(tex.getFilename().toOsSpecific())
return node
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
self.vp = vp
def __init__(self, length: int, width: int, view_ground: bool,
chassis_np: NodePath, pg_world: PGWorld):
"""
:param length: Control resolution of this sensor
:param width: Control resolution of this sensor
:param view_ground: Lane line will be invisible when set to True
:param chassis_np: The vehicle chassis to place this sensor
:param pg_world: PG-World
"""
self.view_ground = view_ground
self.BUFFER_W = length
self.BUFFER_H = width
super(DepthCamera, self).__init__(self.BUFFER_W,
self.BUFFER_H,
Vec3(0.0, 0.8, 1.5),
self.BKG_COLOR,
pg_world=pg_world,
parent_node=chassis_np)
self.add_to_display(pg_world, self.default_region)
self.cam.lookAt(0, 2.4, 1.3)
self.lens.setFov(60)
self.lens.setAspectRatio(2.0)
# add shader for it
if pg_world.world_config["headless_image"]:
vert_path = AssetLoader.file_path("shaders",
"depth_cam_gles.vert.glsl")
frag_path = AssetLoader.file_path("shaders",
"depth_cam_gles.frag.glsl")
else:
if is_mac():
vert_path = AssetLoader.file_path("shaders",
"depth_cam_mac.vert.glsl")
frag_path = AssetLoader.file_path("shaders",
"depth_cam_mac.frag.glsl")
else:
vert_path = AssetLoader.file_path("shaders",
"depth_cam.vert.glsl")
frag_path = AssetLoader.file_path("shaders",
"depth_cam.frag.glsl")
custom_shader = Shader.load(Shader.SL_GLSL,
vertex=vert_path,
fragment=frag_path)
self.cam.node().setInitialState(
RenderState.make(ShaderAttrib.make(custom_shader, 1)))
if self.view_ground:
self.ground = GeoMipTerrain("mySimpleTerrain")
self.ground.setHeightfield(
AssetLoader.file_path("textures", "height_map.png"))
# terrain.setBruteforce(True)
# # Since the terrain is a texture, shader will not calculate the depth information, we add a moving terrain
# # model to enable the depth information of terrain
self.ground_model = self.ground.getRoot()
self.ground_model.reparentTo(chassis_np)
self.ground_model.setPos(-128, 0, self.GROUND)
self.ground_model.hide(BitMask32.allOn())
self.ground_model.show(CamMask.DepthCam)
self.ground.generate()
pg_world.taskMgr.add(self.renew_pos_of_ground_mode,
self.TASK_NAME,
extraArgs=[chassis_np],
appendTask=True)
def __init__(self, x1, y1, x2, y2, z, scale, parent):
# Water surface
maker = CardMaker('water')
maker.setFrame(x1, x2, y1, y2)
self.waterNP = parent.instance.attachNewNode(maker.generate())
self.waterNP.setHpr(0, -90, 0)
self.waterNP.setPos(0, 0, z)
self.waterNP.setTransparency(TransparencyAttrib.MAlpha)
self.waterNP.setShader(
Shader.load(
Shader.SL_GLSL,
vertex=defaultDirContext.find_shader('water-vertex.glsl'),
fragment=defaultDirContext.find_shader('water-fragment.glsl')))
self.waterNP.setShaderInput('wateranim',
Vec4(0.03, -0.015, scale,
0)) # vx, vy, scale, skip
# offset, strength, refraction factor (0=perfect mirror, 1=total refraction), refractivity
self.waterNP.setShaderInput('waterdistort', Vec4(0.4, 4.0, 0.25, 0.45))
self.waterNP.setShaderInput('time', 0)
# Reflection plane
self.waterPlane = Plane(Vec3(0, 0, z + 1), Point3(0, 0, z))
planeNode = PlaneNode('waterPlane')
planeNode.setPlane(self.waterPlane)
if self.watercamNP is None:
# Buffer and reflection camera
WaterNode.buffer = base.win.makeTextureBuffer(
'waterBuffer', 512, 512)
self.buffer.setClearColor(Vec4(0, 0, 0, 1))
cfa = CullFaceAttrib.makeReverse()
rs = RenderState.make(cfa)
WaterNode.watercamNP = base.makeCamera(self.buffer)
self.watercamNP.reparentTo(render)
#sa = ShaderAttrib.make()
#sa = sa.setShader(loader.loadShader('shaders/splut3Clipped.sha') )
cam = self.watercamNP.node()
cam.getLens().setFov(base.camLens.getFov())
cam.getLens().setNear(1)
cam.getLens().setFar(5000)
cam.setInitialState(rs)
cam.setTagStateKey('Clipped')
#cam.setTagState('True', RenderState.make(sa))
# ---- water textures ---------------------------------------------
# reflection texture, created in realtime by the 'water camera'
tex0 = self.buffer.getTexture()
tex0.setWrapU(Texture.WMClamp)
tex0.setWrapV(Texture.WMClamp)
ts0 = TextureStage('reflection')
self.waterNP.setTexture(ts0, tex0)
# distortion texture
tex1 = loader.loadTexture('textures/water.png')
ts1 = TextureStage('distortion')
self.waterNP.setTexture(ts1, tex1)
self.task = taskMgr.add(self.update, "waterTask")
def __init__(self, name, size=10000, resolution=1024):
"""Arguments:
size -- Edge length of the water square.
resolution -- Texture size of the rendered reflection buffer.
"""
# Uncomment to see the output of the refclection buffer.
base.bufferViewer.toggleEnable()
AssetBase.__init__(self)
self.name = name
self.cm = CardMaker("water surface")
self.cm.setFrame(-0.5 * size, 0.5 * size, -0.5 * size, 0.5 * size)
self.cm.setHasUvs(True)
self.node = NodePath(self.cm.generate())
self.node.setP(self.node, -90)
self.node.flattenLight()
self.node.hide(BitMask32.bit(1))
#self.node.setTwoSided(True)
self.node.setShaderOff()
# size of one texture tile in meters
self.tex_size = 100.0
diffuse = TexturePool.loadTexture("textures/water.diffuse.png")
diffuse.setWrapU(Texture.WMRepeat)
diffuse.setWrapV(Texture.WMRepeat)
diffuse.setMinfilter(Texture.FTLinearMipmapLinear)
diffuse.setMagfilter(Texture.FTLinearMipmapLinear)
self.diffuse_stage = TextureStage("diffuse")
self.diffuse_stage.setSort(2)
self.node.setTexture(self.diffuse_stage, diffuse)
self.node.setTexScale(self.diffuse_stage, size / self.tex_size,
size / self.tex_size)
# Reflection camera renders to 'buffer' which is projected onto the
# water surface.
buffer = base.win.makeTextureBuffer("water reflection", resolution,
resolution)
buffer.setClearColor(Vec4(0, 0, 0, 1))
self.refl_cam = base.makeCamera(buffer)
self.refl_cam.reparentTo(self.node)
self.refl_cam.node().setCameraMask(BitMask32.bit(1))
self.refl_cam.node().getLens().setFov(base.camLens.getFov())
self.refl_cam.node().getLens().setNearFar(1, 100000)
plane = PlaneNode("water culling plane",
Plane(Vec3(0, 0, 1), Point3(0, 0, 0)))
cfa = CullFaceAttrib.makeReverse()
cpa = ClipPlaneAttrib.make(PlaneNode.CEVisible, plane)
rs = RenderState.make(cfa, cpa)
self.refl_cam.node().setInitialState(rs)
reflection = buffer.getTexture()
reflection.setMinfilter(Texture.FTLinear)
reflection.setMagfilter(Texture.FTLinear)
self.refl_stage = TextureStage("reflection")
self.refl_stage.setSort(1)
self.node.projectTexture(self.refl_stage, reflection, base.cam)
self.node.setTexture(self.refl_stage, reflection)
# Blend between diffuse and reflection.
self.diffuse_stage.setColor(VBase4(1, 1, 1, 0.2)) # opacity of 20%
self.diffuse_stage.setCombineRgb(
TextureStage.CMInterpolate, TextureStage.CSTexture,
TextureStage.COSrcColor, TextureStage.CSPrevious,
TextureStage.COSrcColor, TextureStage.CSConstant,
TextureStage.COSrcAlpha)
self.addTask(self.update,
name="water update",
sort=1,
taskChain="world")
def __init__(self, pipeline):
""" Creates a new LightManager. It expects a RenderPipeline as parameter. """
DebugObject.__init__(self, "LightManager")
self._initArrays()
self.pipeline = pipeline
self.settings = pipeline.getSettings()
# Create arrays to store lights & shadow sources
self.lights = []
self.shadowSources = []
self.queuedShadowUpdates = []
self.allLightsArray = ShaderStructArray(Light, self.maxTotalLights)
self.cullBounds = None
self.shadowScene = Globals.render
# Create atlas
self.shadowAtlas = ShadowAtlas()
self.shadowAtlas.setSize(self.settings.shadowAtlasSize)
self.shadowAtlas.create()
self.maxShadowMaps = 24
self.maxShadowUpdatesPerFrame = self.settings.maxShadowUpdatesPerFrame
self.numShadowUpdatesPTA = PTAInt.emptyArray(1)
self.updateShadowsArray = ShaderStructArray(
ShadowSource, self.maxShadowUpdatesPerFrame)
self.allShadowsArray = ShaderStructArray(
ShadowSource, self.maxShadowMaps)
# Create shadow compute buffer
self._createShadowComputationBuffer()
# Create the initial shadow state
self.shadowComputeCamera.setTagStateKey("ShadowPassShader")
self.shadowComputeCamera.setInitialState(RenderState.make(
ColorWriteAttrib.make(ColorWriteAttrib.C_off),
DepthWriteAttrib.make(DepthWriteAttrib.M_on),
# CullFaceAttrib.make(CullFaceAttrib.MCullNone),
100))
self._createTagStates()
self.shadowScene.setTag("ShadowPassShader", "Default")
# Create debug overlay
self._createDebugTexts()
# Disable buffer on start
self.shadowComputeTarget.setActive(False)
# Bind arrays
self.updateShadowsArray.bindTo(self.shadowScene, "updateSources")
self.updateShadowsArray.bindTo(
self.shadowComputeTarget, "updateSources")
# Set initial inputs
for target in [self.shadowComputeTarget, self.shadowScene]:
target.setShaderInput("numUpdates", self.numShadowUpdatesPTA)
self.lightingComputator = None
self.lightCuller = None
def __init__(self):
DebugObject.__init__(self, "LightManager")
self._initArrays()
# create arrays to store lights & shadow sources
self.lights = []
self.shadowSources = []
self.allLightsArray = ShaderStructArray(Light, 30)
self.cullBounds = None
self.shadowScene = render
## SHADOW ATLAS ##
# todo: move to separate class
# When you change this, change also SHADOW_MAP_ATLAS_SIZE in configuration.include,
# and reduce the default shadow map resolution of point lights
self.shadowAtlasSize = 512
self.maxShadowMaps = 24
# When you change it , change also SHAODOW_GEOMETRY_MAX_VERTICES and
# SHADOW_MAX_UPDATES_PER_FRAME in configuration.include!
self.maxShadowUpdatesPerFrame = 2
self.tileSize = 128
self.tileCount = self.shadowAtlasSize / self.tileSize
self.tiles = []
self.updateShadowsArray = ShaderStructArray(
ShadowSource, self.maxShadowUpdatesPerFrame)
self.allShadowsArray = ShaderStructArray(ShadowSource,
self.maxShadowMaps)
# self.shadowAtlasTex = Texture("ShadowAtlas")
# self.shadowAtlasTex.setup2dTexture(
# self.shadowAtlasSize, self.shadowAtlasSize, Texture.TFloat, Texture.FRg16)
# self.shadowAtlasTex.setMinfilter(Texture.FTLinear)
# self.shadowAtlasTex.setMagfilter(Texture.FTLinear)
self.debug("Init shadow atlas with tileSize =", self.tileSize,
", tileCount =", self.tileCount)
for i in xrange(self.tileCount):
self.tiles.append([None for j in xrange(self.tileCount)])
# create shadow compute buffer
self.shadowComputeCamera = Camera("ShadowComputeCamera")
self.shadowComputeCameraNode = self.shadowScene.attachNewNode(
self.shadowComputeCamera)
self.shadowComputeCamera.getLens().setFov(90, 90)
self.shadowComputeCamera.getLens().setNearFar(10.0, 100000.0)
self.shadowComputeCameraNode.setPos(0, 0, 150)
self.shadowComputeCameraNode.lookAt(0, 0, 0)
self.shadowComputeTarget = RenderTarget("ShadowCompute")
self.shadowComputeTarget.setSize(self.shadowAtlasSize,
self.shadowAtlasSize)
# self.shadowComputeTarget.setLayers(self.maxShadowUpdatesPerFrame)
self.shadowComputeTarget.addRenderTexture(RenderTargetType.Depth)
self.shadowComputeTarget.setDepthBits(32)
self.shadowComputeTarget.setSource(self.shadowComputeCameraNode,
base.win)
self.shadowComputeTarget.prepareSceneRender()
self.shadowComputeTarget.getInternalRegion().setSort(3)
self.shadowComputeTarget.getRegion().setSort(3)
self.shadowComputeTarget.getInternalRegion().setNumRegions(
self.maxShadowUpdatesPerFrame + 1)
self.shadowComputeTarget.getInternalRegion().setDimensions(
0, (0, 1, 0, 1))
self.shadowComputeTarget.setClearDepth(False)
self.depthClearer = []
for i in xrange(self.maxShadowUpdatesPerFrame):
buff = self.shadowComputeTarget.getInternalBuffer()
dr = buff.makeDisplayRegion()
dr.setSort(2)
dr.setClearDepthActive(True)
dr.setClearDepth(1.0)
dr.setClearColorActive(False)
dr.setDimensions(0, 0, 0, 0)
self.depthClearer.append(dr)
self.queuedShadowUpdates = []
# Assign copy shader
self._setCopyShader()
# self.shadowComputeTarget.setShaderInput("atlas", self.shadowComputeTarget.getColorTexture())
# self.shadowComputeTarget.setShaderInput(
# "renderResult", self.shadowComputeTarget.getDepthTexture())
# self.shadowComputeTarget.setActive(False)
# Create shadow caster shader
self.shadowCasterShader = BetterShader.load(
"Shader/DefaultShadowCaster.vertex",
"Shader/DefaultShadowCaster.fragment",
"Shader/DefaultShadowCaster.geometry")
self.shadowComputeCamera.setTagStateKey("ShadowPass")
initialState = NodePath("ShadowCasterState")
initialState.setShader(self.shadowCasterShader, 30)
self.shadowComputeCamera.setInitialState(
RenderState.make(ColorWriteAttrib.make(ColorWriteAttrib.C_off),
DepthWriteAttrib.make(DepthWriteAttrib.M_on),
100))
self.shadowComputeCamera.setTagState("True", initialState.getState())
self.shadowScene.setTag("ShadowPass", "True")
self._createDebugTexts()
self.updateShadowsArray.bindTo(self.shadowScene, "updateSources")
self.updateShadowsArray.bindTo(self.shadowComputeTarget,
"updateSources")
self.numShadowUpdatesPTA = PTAInt.emptyArray(1)
# Set initial inputs
for target in [self.shadowComputeTarget, self.shadowScene]:
target.setShaderInput("numUpdates", self.numShadowUpdatesPTA)
self.lightingComputator = None
self.lightCuller = None
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):
ToolOptions.__init__(self)
def initialize(self):
Viewport.initialize(self)
self.gizmo.np.setHpr(self.getViewHpr())
self.camNode.setInitialState(
RenderState.make(FogAttrib.makeOff(), LightAttrib.makeAllOff()))
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):
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)
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):
