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 step(self):
self.rotate_light()
self.graphicsEngine.renderFrame()
image = self.get_camera_image()
TransformState.garbageCollect()
RenderState.garbageCollect()
return
def _clear_state_cache(self, task=None):
""" Task which repeatedly clears the state cache to avoid storing
unused states. """
task.delayTime = 2.0
TransformState.clear_cache()
RenderState.clear_cache()
return task.again
def _clear_state_cache(self, task=None):
""" Task which repeatedly clears the state cache to avoid storing
unused states. """
task.delayTime = 2.0
TransformState.clear_cache()
RenderState.clear_cache()
return task.again
def newGame():
global thickness
thickness=1
render.setState(RenderState.makeEmpty())
model.setState(RenderState.makeEmpty())
func5()
print('NEW GAME')
def step(self, action):
dt = 1/self.fps
self.framecount += 1
max_dist = 1.1
# Move finger
finger_max_speed = 2
finger_accel = 10.0
finger_deccel = 10.0
self.action_buffer.pop(0)
self.action_buffer.append(action)
action = self.action_buffer[0]
if action == 0:
self.finger_speed_mps += dt * finger_accel
if self.finger_speed_mps > finger_max_speed:
self.finger_speed_mps = 2
if action == 1:
if self.finger_speed_mps > 0.01:
self.finger_speed_mps -= finger_deccel * dt
if self.finger_speed_mps < -0.01:
self.finger_speed_mps += finger_deccel * dt
if action == 2:
self.finger_speed_mps -= dt * finger_accel
if self.finger_speed_mps < -finger_max_speed:
self.finger_speed_mps = -finger_max_speed
real_displacement = self.finger_speed_mps * dt
self.finger_np.setY(self.finger_np.getY() + real_displacement)
if self.finger_np.getY() > max_dist:
self.finger_np.setY(max_dist)
self.finger_speed_mps = 0
if self.finger_np.getY() < -max_dist:
self.finger_np.setY(-max_dist)
self.finger_speed_mps = 0
# self.world.doPhysics(dt, 5, 1.0/120.0)
self.world.doPhysics(dt, 20, 1.0/240.0)
self.reset_conv()
self.check_teleportable(blocks_per_minute=59)
# Keep the conveyor moving
self.conv_np.node().setLinearVelocity(Vec3(1.0, 0.0, 0.0))
if self.human_playable is False:
self.graphicsEngine.renderFrame()
TransformState.garbageCollect()
RenderState.garbageCollect()
image = self.get_camera_image()
else:
image = None
score = 0
score += self.check_rewards()
done = False
return image, score, done
def _checkForStateClear(self):
""" This method regulary clears the state cache """
if not hasattr(self, "lastStateClear"):
self.lastStateClear = 0
if Globals.clock.getFrameTime() - self.lastStateClear > self.settings.stateCacheClearInterval:
RenderState.clearCache()
TransformState.clearCache()
self.lastStateClear = Globals.clock.getFrameTime()
def _clear_state_cache(self, task=None):
""" Task which repeatedly clears the state cache to avoid storing
unused states. While running once a while, this task prevents over-polluting
the state-cache with unused states. This complements Panda3D's internal
state garbarge collector, which does a great job, but still cannot clear
up all states. """
task.delayTime = 2.0
TransformState.clear_cache()
RenderState.clear_cache()
return task.again
def _clear_state_cache(self, task=None):
""" Task which repeatedly clears the state cache to avoid storing
unused states. While running once a while, this task prevents over-polluting
the state-cache with unused states. This complements Panda3D's internal
state garbarge collector, which does a great job, but still cannot clear
up all states. """
task.delayTime = 2.0
TransformState.clear_cache()
RenderState.clear_cache()
return task.again
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 register_camera(self, container, source):
source.set_tag_state_key(container.tag_name)
source.set_camera_mask(container.mask)
state = RenderState.make_empty()
state = state.set_attrib(ColorWriteAttrib.make(ColorWriteAttrib.C_off), 10000)
source.set_initial_state(state)
container.cameras.append(source)
def _update_stats(self):
""" Updates the stats overlay """
clock = Globals.clock
self._debug_lines[0].set_text("{:3.0f} fps | {:3.1f} ms | {:3.1f} ms max".format(
clock.get_average_frame_rate(),
1000.0 / max(0.001, clock.get_average_frame_rate()),
clock.get_max_frame_duration() * 1000.0))
text = "{:4d} render states | {:4d} transforms"
text += " | {:4d} commands | {:6d} lights | {:5d} shadow sources"
self._debug_lines[1].set_text(text.format(
RenderState.get_num_states(), TransformState.get_num_states(),
self._pipeline.light_mgr.get_cmd_queue().get_num_processed_commands(),
self._pipeline.light_mgr.get_num_lights(),
self._pipeline.light_mgr.get_num_shadow_sources(),
))
text = "{:3.0f} MiB VRAM usage | {:5d} images | {:5d} textures | "
text += "{:5d} render targets | {:3d} plugins"
tex_info = self._buffer_viewer.get_stage_information()
self._debug_lines[2].set_text(text.format(
tex_info["memory"] / (1024**2) ,
Image._NUM_IMAGES,
tex_info["count"],
RenderTarget._NUM_BUFFERS_ALLOCATED,
self._pipeline.plugin_mgr.get_interface().get_active_plugin_count()
))
text = "{} ({:1.3f}) | {:3d} active constraints"
self._debug_lines[3].set_text(text.format(
self._pipeline.daytime_mgr.get_time_str(),
self._pipeline.daytime_mgr.get_time(),
self._pipeline.daytime_mgr.get_num_constraints()
))
def unregister_camera(self, container, source):
if source not in container.cameras:
print("Could not remove source, was never attached!")
return
container.cameras.remove(source)
source.clear_tag_states()
source.set_initial_state(RenderState.make_empty())
def addFace(self, meshVertices, state=RenderState.makeEmpty()):
row = self.vwriter.getWriteRow()
for vert in meshVertices:
self.vwriter.setData3f(vert.pos)
self.nwriter.setData3f(vert.normal)
self.twriter.setData2f(vert.texcoord)
for view in self.views:
view.generateIndices()
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 unregister_camera(self, container_name, source):
container = self.containers[container_name]
if source not in container.cameras:
print("Could not remove source, was never attached!")
return
container.cameras.remove(source)
source.clear_tag_states()
source.set_initial_state(RenderState.make_empty())
def update_serialized_material(self, data):
""" Internal method to update a material from a given serialized material """
name = data[0]
for i, material in enumerate(Globals.render.find_all_materials()):
if self._get_serialized_material_name(material, i) == name:
material.set_base_color(Vec4(float(data[1]), float(data[2]), float(data[3]), 1.0))
material.set_roughness(float(data[4]))
material.set_refractive_index(float(data[5]))
material.set_metallic(float(data[6]))
material.set_emission(Vec4(
float(data[7]),
float(data[8]),
float(data[9]),
float(data[10]),
))
RenderState.clear_cache()
def register_camera(self, container_name, source):
container = self.containers[container_name]
source.set_tag_state_key(container.tag_name)
source.set_camera_mask(container.mask)
state = RenderState.make_empty()
if not container.write_color:
state = state.set_attrib(
ColorWriteAttrib.make(ColorWriteAttrib.C_off), 10000)
source.set_initial_state(state)
container.cameras.append(source)
def apply_state(self, container, np, shader, name, sort):
state = RenderState.make_empty()
state = state.set_attrib(ColorWriteAttrib.make(ColorWriteAttrib.C_off), 10000)
state = state.set_attrib(ShaderAttrib.make(shader, sort), sort)
container.tag_states[name] = state
np.set_tag(container.tag_name, name)
for camera in container.cameras:
camera.set_tag_state(name, state)
def update_serialized_material(self, data):
""" Internal method to update a material from a given serialized material """
name = data[0]
for i, material in enumerate(Globals.render.find_all_materials()):
if self._get_serialized_material_name(material, i) == name:
material.set_base_color(
Vec4(float(data[1]), float(data[2]), float(data[3]), 1.0))
material.set_roughness(float(data[4]))
material.set_refractive_index(float(data[5]))
material.set_metallic(float(data[6]))
material.set_emission(
Vec4(
float(data[7]),
float(data[8]),
float(data[9]),
float(data[10]),
))
RenderState.clear_cache()
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):
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 removeEverything(self):
for task in self.taskMgr.getTasks():
if task.getName() not in ['dataLoop', 'igLoop']:
task.remove()
camera.reparentTo(render)
for tex in render.findAllTextures():
tex.releaseAll()
for tex in aspect2d.findAllTextures():
tex.releaseAll()
for tex in render2d.findAllTextures():
tex.releaseAll()
for tex in hidden.findAllTextures():
tex.releaseAll()
for node in render.findAllMatches("**;+s"):
node.removeNode()
for node in aspect2d.findAllMatches("**;+s"):
node.removeNode()
for node in render2d.findAllMatches("**;+s"):
node.removeNode()
for node in hidden.findAllMatches("**;+s"):
node.removeNode()
TexturePool.garbageCollect()
ModelPool.garbageCollect()
RenderState.garbageCollect()
RenderState.clearCache()
RenderState.clearMungerCache()
self.win.getGsg().getPreparedObjects().releaseAll()
self.graphicsEngine.renderFrame()
def _update_stats(self, task=None):
""" Updates the stats overlay """
clock = Globals.clock
self._debug_lines[0].text = "{:3.0f} fps | {:3.1f} ms | {:3.1f} ms max".format(
clock.get_average_frame_rate(),
1000.0 / max(0.001, clock.get_average_frame_rate()),
clock.get_max_frame_duration() * 1000.0)
text = "{:4d} render states | {:4d} transforms"
text += " | {:4d} commands | {:4d} lights | {:5d} shadow sources "
text += "| {:3.1f}% atlas usage"
self._debug_lines[1].text = text.format(
RenderState.get_num_states(), TransformState.get_num_states(),
self._pipeline.light_mgr.cmd_queue.num_processed_commands,
self._pipeline.light_mgr.num_lights,
self._pipeline.light_mgr.num_shadow_sources,
self._pipeline.light_mgr.shadow_atlas_coverage)
text = "Pipeline: {:3.0f} MiB VRAM | {:5d} images | {:5d} textures | "
text += "{:5d} render targets | {:3d} plugins"
tex_memory, tex_count = self._buffer_viewer.stage_information
self._debug_lines[2].text = text.format(
tex_memory / (1024**2), len(Image.REGISTERED_IMAGES), tex_count,
RenderTarget.NUM_ALLOCATED_BUFFERS,
len(self._pipeline.plugin_mgr.enabled_plugins))
text = "Scene: {:4.0f} MiB VRAM | {:3d} textures | {:4d} geoms "
text += "| {:4d} nodes | {:7,.0f} vertices | {:5.0f} MiB vTX data "
scene_tex_size = 0
for tex in TexturePool.find_all_textures():
scene_tex_size += tex.estimate_texture_memory()
self._debug_lines[3].text = text.format(
scene_tex_size / (1024**2),
len(TexturePool.find_all_textures()),
self._analyzer.get_num_geoms(),
self._analyzer.get_num_nodes(),
self._analyzer.get_num_vertices(),
self._analyzer.get_vertex_data_size() / (1024**2),
)
text = "{} ({:1.3f}) | {:3d} daytime settings | X {:3.1f} Y {:3.1f} Z {:3.1f}"
self._debug_lines[4].text = text.format(
self._pipeline.daytime_mgr.formatted_time,
self._pipeline.daytime_mgr.time,
len(self._pipeline.plugin_mgr.day_settings),
Globals.base.camera.get_x(Globals.base.render),
Globals.base.camera.get_y(Globals.base.render),
Globals.base.camera.get_z(Globals.base.render),)
if task:
return task.again
def apply_state(self, container_name, np, shader, name, sort):
assert shader
state = RenderState.make_empty()
container = self.containers[container_name]
if not container.write_color:
state = state.set_attrib(
ColorWriteAttrib.make(ColorWriteAttrib.C_off), 10000)
state = state.set_attrib(ShaderAttrib.make(shader, sort), sort)
container.tag_states[name] = state
np.set_tag(container.tag_name, name)
for camera in container.cameras:
camera.set_tag_state(name, state)
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 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 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_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 doSceneCleanup():
from panda3d.core import ModelPool, TexturePool, RenderState, RenderAttrib, TransformState, GeomCacheManager
ModelPool.garbageCollect()
TexturePool.garbageCollect()
RenderState.clearMungerCache()
RenderState.clearCache()
RenderState.garbageCollect()
RenderAttrib.garbageCollect()
TransformState.clearCache()
TransformState.garbageCollect()
GeomCacheManager.getGlobalPtr().flush()
base.graphicsEngine.renderFrame()
def update(self):
if self.memUsageText:
memstr = str(
round(MemoryMonitor.getEstimatedMemUsage() / 1024.0 / 1024.0,
2))
numTextureBytes = 0
renderTextures = Globals.render.findAllTextures()
for tex in renderTextures:
numTextureBytes += MemoryMonitor._calculateTexSize(tex)
texstr = str(round(numTextureBytes / 1024.0 / 1024.0, 2))
otherTextures = TexturePool.findAllTextures()
numOtherBytes = 0
for tex in otherTextures:
if tex not in renderTextures:
numOtherBytes += MemoryMonitor._calculateTexSize(tex)
otherstr = str(round(numOtherBytes / 1024.0 / 1024.0, 2))
self.memUsageText.setText("VRAM Usage: " + memstr +
" MB / Textures: " + texstr +
" MB / Other: " + otherstr + " MB")
if self.fpsText:
clock = Globals.clock
self.fpsText.setText(
"Frame time over {:3.1f}s Avg: {:3.2f} Max: {:3.2f} Deviation: {:3.2f}"
.format(clock.getAverageFrameRateInterval(),
1000.0 / clock.getAverageFrameRate(),
clock.getMaxFrameDuration() * 1000.0,
clock.calcFrameRateDeviation() * 1000.0))
if self.stateText:
self.stateText.setText(
"{:6d} Render States, {:6d} Transform States".format(
RenderState.getNumStates(), TransformState.getNumStates()))
if self.perfOverlay:
self.perfOverlay.update()
def make_cloud_node(pts, col=LColorf(1.0, 0.0, 0.0, 1.0)):
ptCloudData = GeomVertexData("PointCloudData", GeomVertexFormat.getV3c4(),
GeomEnums.UH_static)
vertexWriter = GeomVertexWriter(ptCloudData, Thread.getCurrentThread())
vertexWriter.setColumn("vertex")
colorWriter = GeomVertexWriter(ptCloudData, Thread.getCurrentThread())
colorWriter.setColumn("color")
for (x, y, z) in pts:
vertexWriter.addData3(x, y, z)
colorWriter.addData4(col)
geomPts = GeomPoints(GeomEnums.UH_static)
geomPts.addConsecutiveVertices(0, len(pts))
geomPts.closePrimitive()
geom = Geom(ptCloudData)
geom.addPrimitive(geomPts)
node = GeomNode("PointCloudNode")
node.addGeom(geom, RenderState.makeEmpty())
return node
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 getStateFromMaterial(prim_material, texture_cache, col_inst=None):
state = RenderState.makeEmpty()
mat = Material()
texattr = TextureAttrib.makeAllOff()
hasDiffuse = False
if prim_material and prim_material.effect:
diffuse = getattr(prim_material.effect, 'diffuse', None)
transparent = getattr(prim_material.effect, 'transparent', None)
if isinstance(diffuse, collada.material.Map) and isinstance(transparent, collada.material.Map):
if diffuse.sampler.surface.image == transparent.sampler.surface.image:
#some exporters put the same map in the diffuse channel
# and the transparent channel when they don't really mean to
transparent = None
if isinstance(diffuse, collada.material.Map) or isinstance(transparent, collada.material.Map):
diffuseMap = None
transparentMap = None
diffuseInitColor = None
if isinstance(diffuse, collada.material.Map):
diffuseMap = diffuse
else:
diffuseInitColor = v4fromtuple(diffuse)
if isinstance(transparent, collada.material.Map):
transparentMap = transparent
if diffuseMap == transparentMap:
transparentMap = None
diffuseTexture = getTexture(color=diffuseMap, alpha=transparentMap, texture_cache=texture_cache, diffuseinit=diffuseInitColor)
texattr = addTextureStage('tsDiff', TextureStage.MModulate, texattr, diffuseTexture)
hasDiffuse = True
if type(diffuse) is tuple:
mat.setDiffuse(v4fromtuple(diffuse))
# hack to look for sketchup version < 8 where transparency was exported flipped
# also ColladaMaya v2.03b had this same issue
flip_alpha = False
if col_inst and col_inst.assetInfo:
for contributor in col_inst.assetInfo.contributors:
tool_name = contributor.authoring_tool
if tool_name is None:
continue
split = tool_name.split()
if len(split) == 3 and \
split[0].strip().lower() == 'google' and \
split[1].strip().lower() == 'sketchup':
version = split[2].strip().split('.')
try:
major_version = int(version[0])
if major_version < 8:
flip_alpha = True
except (ValueError, TypeError):
continue
try:
collada_maya_idx = split.index('ColladaMaya')
if split[collada_maya_idx + 1] == 'v2.03b':
flip_alpha = True
except (ValueError, IndexError):
continue
if type(transparent) is tuple:
trR, trG, trB = transparent[0], transparent[1], transparent[2]
trA = transparent[3] if len(transparent) > 3 else 1.0
else:
trR, trG, trB = 1.0, 1.0, 1.0
trA = 1.0
transparency = getattr(prim_material.effect, 'transparency', 1.0)
if transparency is None:
transparency = 1.0
a_one = prim_material.effect.opaque_mode == collada.material.OPAQUE_MODE.A_ONE
if a_one:
alphaR = alphaG = alphaB = alphaA = transparency * trA
else:
alphaR = transparency * trR
alphaG = transparency * trG
alphaB = transparency * trB
alphaA = luminance([trR, trG, trB])
flip_alpha = not flip_alpha
if flip_alpha:
alphaR = 1.0 - alphaR
alphaG = 1.0 - alphaG
alphaB = 1.0 - alphaB
alphaA = 1.0 - alphaA
if alphaA < 1.0:
state = state.addAttrib(ColorScaleAttrib.make(VBase4(alphaR, alphaG, alphaB, alphaA)))
emission = getattr(prim_material.effect, 'emission', None)
if isinstance(emission, collada.material.Map):
emissionTexture = getTexture(alpha=emission, texture_cache=texture_cache)
texattr = addTextureStage('tsEmiss', TextureStage.MGlow, texattr, emissionTexture)
elif type(emission) is tuple:
mat.setEmission(v4fromtuple(emission))
ambient = getattr(prim_material.effect, 'ambient', None)
if type(ambient) is tuple:
mat.setAmbient(v4fromtuple(ambient))
specular = getattr(prim_material.effect, 'specular', None)
if isinstance(specular, collada.material.Map):
specularTexture = getTexture(color=specular, texture_cache=texture_cache)
texattr = addTextureStage('tsSpec', TextureStage.MGloss, texattr, specularTexture)
mat.setSpecular(VBase4(0.1, 0.1, 0.1, 1.0))
elif type(specular) is tuple:
mat.setSpecular(v4fromtuple(specular))
shininess = getattr(prim_material.effect, 'shininess', None)
#this sets a sane value for blinn shading
if shininess <= 1.0:
if shininess < 0.01:
shininess = 1.0
shininess = shininess * 128.0
mat.setShininess(shininess)
bumpmap = getattr(prim_material.effect, 'bumpmap', None)
if isinstance(bumpmap, collada.material.Map):
bumpTexture = getTexture(color=bumpmap, texture_cache=texture_cache)
texattr = addTextureStage('tsBump', TextureStage.MNormal, texattr, bumpTexture)
if prim_material.effect.double_sided:
state = state.addAttrib(CullFaceAttrib.make(CullFaceAttrib.MCullNone))
if hasDiffuse:
state = state.addAttrib(DepthOffsetAttrib.make(1))
state = state.addAttrib(MaterialAttrib.make(mat))
state = state.addAttrib(texattr)
return state
def update_stats(self, task=None):
""" Updates the stats overlay """
clock = Globals.clock
self.debug_lines[0].text = "{:3.0f} fps | {:3.1f} ms | {:3.1f} ms max".format(
clock.get_average_frame_rate(),
1000.0 / max(0.001, clock.get_average_frame_rate()),
clock.get_max_frame_duration() * 1000.0)
if not self.advanced_info:
return task.again if task else None
text = "{:4d} states | {:4d} transforms "
text += "| {:4d} cmds | {:4d} lights | {:4d} shadows "
text += "| {:5.1f}% atlas usage"
self.debug_lines[1].text = text.format(
RenderState.get_num_states(), TransformState.get_num_states(),
self.pipeline.light_mgr.cmd_queue.num_processed_commands,
self.pipeline.light_mgr.num_lights,
self.pipeline.light_mgr.num_shadow_sources,
self.pipeline.light_mgr.shadow_atlas_coverage)
text = "Internal: {:3.0f} MB VRAM | {:5d} img | {:5d} tex | "
text += "{:5d} fbos | {:3d} plugins | {:2d} views ({:2d} active)"
tex_memory, tex_count = self.buffer_viewer.stage_information
views, active_views = 0, 0
for target in RenderTarget.REGISTERED_TARGETS:
if not target.create_default_region:
num_regions = target.internal_buffer.get_num_display_regions()
for i, region in enumerate(target.internal_buffer.get_display_regions()):
# Skip overlay display region
if i == 0 and num_regions > 1:
continue
views += 1
active_views += 1 if target.active and region.active else 0
self.debug_lines[2].text = text.format(
tex_memory / (1024**2), len(Image.REGISTERED_IMAGES), tex_count,
RenderTarget.NUM_ALLOCATED_BUFFERS,
len(self.pipeline.plugin_mgr.enabled_plugins),
views, active_views)
text = "Scene: {:4.0f} MB VRAM | {:3d} tex | {:4d} geoms "
text += "| {:4d} nodes | {:7,.0f} vertices"
scene_tex_size = 0
for tex in TexturePool.find_all_textures():
scene_tex_size += tex.estimate_texture_memory()
self.debug_lines[3].text = text.format(
scene_tex_size / (1024**2),
len(TexturePool.find_all_textures()),
self.analyzer.get_num_geoms(),
self.analyzer.get_num_nodes(),
self.analyzer.get_num_vertices(),
)
sun_vector = Vec3(0)
if self.pipeline.plugin_mgr.is_plugin_enabled("scattering"):
sun_vector = self.pipeline.plugin_mgr.instances["scattering"].sun_vector
text = "Time: {} ({:1.3f}) | Sun {:0.2f} {:0.2f} {:0.2f}"
text += " | X {:3.1f} Y {:3.1f} Z {:3.1f}"
text += " | {:2d} tasks | scheduled: {:2d}"
self.debug_lines[4].text = text.format(
self.pipeline.daytime_mgr.formatted_time,
self.pipeline.daytime_mgr.time,
sun_vector.x, sun_vector.y, sun_vector.z,
Globals.base.camera.get_x(Globals.base.render),
Globals.base.camera.get_y(Globals.base.render),
Globals.base.camera.get_z(Globals.base.render),
self.pipeline.task_scheduler.num_tasks,
self.pipeline.task_scheduler.num_scheduled_tasks,)
text = "Scene shadows: "
if "pssm" in self.pipeline.plugin_mgr.enabled_plugins:
focus = self.pipeline.plugin_mgr.instances["pssm"].scene_shadow_stage.last_focus
if focus is not None:
text += "{:3.1f} {:3.1f} {:3.1f} r {:3.1f}".format(
focus[0].x, focus[0].y, focus[0].z, focus[1])
else:
text += "none"
else:
text += "inactive"
text += " | HPR ({:3.1f}, {:3.1f}, {:3.1f}) | {:4d} x {:4d} pixels @ {:3.1f} %"
text += " | {:3d} x {:3d} tiles"
self.debug_lines[5].text = text.format(
Globals.base.camera.get_h(Globals.base.render),
Globals.base.camera.get_p(Globals.base.render),
Globals.base.camera.get_r(Globals.base.render),
Globals.native_resolution.x,
Globals.native_resolution.y,
self.pipeline.settings["pipeline.resolution_scale"] * 100.0,
self.pipeline.light_mgr.num_tiles.x,
self.pipeline.light_mgr.num_tiles.y,)
if task:
return task.again
def getStateFromMaterial(prim_material):
state = RenderState.makeFullDefault()
emission = None
ambient = None
diffuse = None
specular = None
shininess = None
reflection = None
reflectivity = None
if prim_material:
for prop in prim_material.supported:
value = getattr(prim_material, prop)
if value is None:
continue
if type(value) is tuple:
val4 = value[3] if len(value) > 3 else 1.0
value = VBase4(value[0], value[1], value[2], val4)
if isinstance(value, collada.material.Map):
texture_file = value.sampler.surface.image.path
if not texture_file is None:
(root, leaf) = os.path.split(sys.argv[1])
tex_absolute = os.path.join(root, texture_file)
myImage = PNMImage()
myImage.read(Filename(tex_absolute))
myTexture = Texture(texture_file)
myTexture.load(myImage)
state = state.addAttrib(TextureAttrib.make(myTexture))
elif prop == 'emission':
emission = value
elif prop == 'ambient':
ambient = value
elif prop == 'diffuse':
diffuse = value
elif prop == 'specular':
specular = value
elif prop == 'shininess':
shininess = value
elif prop == 'reflective':
reflective = value
elif prop == 'reflectivity':
reflectivity = value
elif prop == 'transparent':
pass
elif prop == 'transparency':
pass
else:
raise
mat = Material()
if not emission is None:
mat.setEmission(emission)
if not ambient is None:
mat.setAmbient(ambient)
if not diffuse is None:
mat.setDiffuse(diffuse)
if not specular is None:
mat.setSpecular(specular)
if not shininess is None:
mat.setShininess(shininess)
state = state.addAttrib(MaterialAttrib.make(mat))
return state
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):
# Initialize the ShowBase class from which we inherit, which will
# create a window and set up everything we need for rendering into it.
ShowBase.__init__(self)
self.setBackgroundColor((0, 0, 0, 0))
# Preliminary capabilities check.
if not self.win.getGsg().getSupportsBasicShaders():
self.t = addTitle("Firefly Demo: Video driver reports that Cg "
"shaders are not supported.")
return
if not self.win.getGsg().getSupportsDepthTexture():
self.t = addTitle("Firefly Demo: Video driver reports that depth "
"textures are not supported.")
return
# This algorithm uses two offscreen buffers, one of which has
# an auxiliary bitplane, and the offscreen buffers share a single
# depth buffer. This is a heck of a complicated buffer setup.
self.modelbuffer = self.makeFBO("model buffer", 1)
self.lightbuffer = self.makeFBO("light buffer", 0)
# Creation of a high-powered buffer can fail, if the graphics card
# doesn't support the necessary OpenGL extensions.
if self.modelbuffer is None or self.lightbuffer is None:
self.t = addTitle("Toon Shader: Video driver does not support "
"multiple render targets")
return
# Create four render textures: depth, normal, albedo, and final.
# attach them to the various bitplanes of the offscreen buffers.
self.texDepth = Texture()
self.texDepth.setFormat(Texture.FDepthStencil)
self.texAlbedo = Texture()
self.texNormal = Texture()
self.texFinal = Texture()
self.modelbuffer.addRenderTexture(self.texDepth,
GraphicsOutput.RTMBindOrCopy, GraphicsOutput.RTPDepthStencil)
self.modelbuffer.addRenderTexture(self.texAlbedo,
GraphicsOutput.RTMBindOrCopy, GraphicsOutput.RTPColor)
self.modelbuffer.addRenderTexture(self.texNormal,
GraphicsOutput.RTMBindOrCopy, GraphicsOutput.RTPAuxRgba0)
self.lightbuffer.addRenderTexture(self.texFinal,
GraphicsOutput.RTMBindOrCopy, GraphicsOutput.RTPColor)
# Set the near and far clipping planes.
self.cam.node().getLens().setNear(50.0)
self.cam.node().getLens().setFar(500.0)
lens = self.cam.node().getLens()
# This algorithm uses three cameras: one to render the models into the
# model buffer, one to render the lights into the light buffer, and
# one to render "plain" stuff (non-deferred shaded) stuff into the
# light buffer. Each camera has a bitmask to identify it.
self.modelMask = 1
self.lightMask = 2
self.plainMask = 4
self.modelcam = self.makeCamera(self.modelbuffer,
lens=lens, scene=render, mask=self.modelMask)
self.lightcam = self.makeCamera(self.lightbuffer,
lens=lens, scene=render, mask=self.lightMask)
self.plaincam = self.makeCamera(self.lightbuffer,
lens=lens, scene=render, mask=self.plainMask)
# Panda's main camera is not used.
self.cam.node().setActive(0)
# Take explicit control over the order in which the three
# buffers are rendered.
self.modelbuffer.setSort(1)
self.lightbuffer.setSort(2)
self.win.setSort(3)
# Within the light buffer, control the order of the two cams.
self.lightcam.node().getDisplayRegion(0).setSort(1)
self.plaincam.node().getDisplayRegion(0).setSort(2)
# By default, panda usually clears the screen before every
# camera and before every window. Tell it not to do that.
# Then, tell it specifically when to clear and what to clear.
self.modelcam.node().getDisplayRegion(0).disableClears()
self.lightcam.node().getDisplayRegion(0).disableClears()
self.plaincam.node().getDisplayRegion(0).disableClears()
self.cam.node().getDisplayRegion(0).disableClears()
self.cam2d.node().getDisplayRegion(0).disableClears()
self.modelbuffer.disableClears()
self.win.disableClears()
self.modelbuffer.setClearColorActive(1)
self.modelbuffer.setClearDepthActive(1)
self.lightbuffer.setClearColorActive(1)
self.lightbuffer.setClearColor((0, 0, 0, 1))
# Miscellaneous stuff.
self.disableMouse()
self.camera.setPos(-9.112, -211.077, 46.951)
self.camera.setHpr(0, -7.5, 2.4)
random.seed()
# Calculate the projection parameters for the final shader.
# The math here is too complex to explain in an inline comment,
# I've put in a full explanation into the HTML intro.
proj = self.cam.node().getLens().getProjectionMat()
proj_x = 0.5 * proj.getCell(3, 2) / proj.getCell(0, 0)
proj_y = 0.5 * proj.getCell(3, 2)
proj_z = 0.5 * proj.getCell(3, 2) / proj.getCell(2, 1)
proj_w = -0.5 - 0.5 * proj.getCell(1, 2)
# Configure the render state of the model camera.
tempnode = NodePath(PandaNode("temp node"))
tempnode.setAttrib(
AlphaTestAttrib.make(RenderAttrib.MGreaterEqual, 0.5))
tempnode.setShader(loader.loadShader("model.sha"))
tempnode.setAttrib(DepthTestAttrib.make(RenderAttrib.MLessEqual))
self.modelcam.node().setInitialState(tempnode.getState())
# Configure the render state of the light camera.
tempnode = NodePath(PandaNode("temp node"))
tempnode.setShader(loader.loadShader("light.sha"))
tempnode.setShaderInput("texnormal", self.texNormal)
tempnode.setShaderInput("texalbedo", self.texAlbedo)
tempnode.setShaderInput("texdepth", self.texDepth)
tempnode.setShaderInput("proj", (proj_x, proj_y, proj_z, proj_w))
tempnode.setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd,
ColorBlendAttrib.OOne, ColorBlendAttrib.OOne))
tempnode.setAttrib(
CullFaceAttrib.make(CullFaceAttrib.MCullCounterClockwise))
# The next line causes problems on Linux.
# tempnode.setAttrib(DepthTestAttrib.make(RenderAttrib.MGreaterEqual))
tempnode.setAttrib(DepthWriteAttrib.make(DepthWriteAttrib.MOff))
self.lightcam.node().setInitialState(tempnode.getState())
# Configure the render state of the plain camera.
rs = RenderState.makeEmpty()
self.plaincam.node().setInitialState(rs)
# Clear any render attribs on the root node. This is necessary
# because by default, panda assigns some attribs to the root
# node. These default attribs will override the
# carefully-configured render attribs that we just attached
# to the cameras. The simplest solution is to just clear
# them all out.
render.setState(RenderState.makeEmpty())
# My artist created a model in which some of the polygons
# don't have textures. This confuses the shader I wrote.
# This little hack guarantees that everything has a texture.
white = loader.loadTexture("models/white.jpg")
render.setTexture(white, 0)
# Create two subroots, to help speed cull traversal.
self.lightroot = NodePath(PandaNode("lightroot"))
self.lightroot.reparentTo(render)
self.modelroot = NodePath(PandaNode("modelroot"))
self.modelroot.reparentTo(render)
self.lightroot.hide(BitMask32(self.modelMask))
self.modelroot.hide(BitMask32(self.lightMask))
self.modelroot.hide(BitMask32(self.plainMask))
# Load the model of a forest. Make it visible to the model camera.
# This is a big model, so we load it asynchronously while showing a
# load text. We do this by passing in a callback function.
self.loading = addTitle("Loading models...")
self.forest = NodePath(PandaNode("Forest Root"))
self.forest.reparentTo(render)
self.forest.hide(BitMask32(self.lightMask | self.plainMask))
loader.loadModel([
"models/background",
"models/foliage01",
"models/foliage02",
"models/foliage03",
"models/foliage04",
"models/foliage05",
"models/foliage06",
"models/foliage07",
"models/foliage08",
"models/foliage09"],
callback=self.finishLoading)
# Cause the final results to be rendered into the main window on a
# card.
self.card = self.lightbuffer.getTextureCard()
self.card.setTexture(self.texFinal)
self.card.reparentTo(render2d)
# Panda contains a built-in viewer that lets you view the results of
# your render-to-texture operations. This code configures the viewer.
self.bufferViewer.setPosition("llcorner")
self.bufferViewer.setCardSize(0, 0.40)
self.bufferViewer.setLayout("vline")
self.toggleCards()
self.toggleCards()
# Firefly parameters
self.fireflies = []
self.sequences = []
self.scaleseqs = []
self.glowspheres = []
self.fireflysize = 1.0
self.spheremodel = loader.loadModel("misc/sphere")
# Create the firefly model, a fuzzy dot
dotSize = 1.0
cm = CardMaker("firefly")
cm.setFrame(-dotSize, dotSize, -dotSize, dotSize)
self.firefly = NodePath(cm.generate())
self.firefly.setTexture(loader.loadTexture("models/firefly.png"))
self.firefly.setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.M_add,
ColorBlendAttrib.O_incoming_alpha, ColorBlendAttrib.O_one))
# these allow you to change parameters in realtime
self.accept("escape", sys.exit, [0])
self.accept("arrow_up", self.incFireflyCount, [1.1111111])
self.accept("arrow_down", self.decFireflyCount, [0.9000000])
self.accept("arrow_right", self.setFireflySize, [1.1111111])
self.accept("arrow_left", self.setFireflySize, [0.9000000])
self.accept("v", self.toggleCards)
self.accept("V", self.toggleCards)
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
def __init__(self,geomVertexFormat,renderState=RenderState.makeEmpty()):
self.geomVertexFormat=geomVertexFormat
self.renderState=renderState
def __init__(self,parentIndex,renderState=RenderState.makeEmpty()):
# parentIndex of -1 == root
self.renderState=renderState
self.parentIndex=parentIndex
def update(self):
if self.memUsageText:
memstr = str(round(MemoryMonitor.getEstimatedMemUsage() / 1024.0 / 1024.0, 2))
numTextureBytes = 0
renderTextures = Globals.render.findAllTextures()
for tex in renderTextures:
numTextureBytes += MemoryMonitor._calculateTexSize(tex)
texstr = str(round(numTextureBytes / 1024.0 / 1024.0, 2))
otherTextures = TexturePool.findAllTextures()
numOtherBytes = 0
for tex in otherTextures:
if tex not in renderTextures:
numOtherBytes += MemoryMonitor._calculateTexSize(tex)
otherstr = str(round(numOtherBytes / 1024.0 / 1024.0, 2))
self.memUsageText.setText("VRAM Usage: " + memstr + " MB / Textures: " + texstr + " MB / Other: " + otherstr + " MB")
if self.fpsText:
clock = Globals.clock
self.fpsText.setText("Frame time over {:3.1f}s Avg: {:3.2f} Max: {:3.2f} Deviation: {:3.2f}".format(
clock.getAverageFrameRateInterval(),
1000.0 / clock.getAverageFrameRate(),
clock.getMaxFrameDuration() * 1000.0,
clock.calcFrameRateDeviation() * 1000.0
))
if self.stateText:
self.stateText.setText("{:6d} Render States, {:6d} Transform States".format(RenderState.getNumStates(), TransformState.getNumStates()))
if self.perfOverlay:
self.perfOverlay.update()
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")
