def _make_buffer(self, width, height):
"""Make an offscreen buffer.
Arguments:
width {int} -- target buffer width
height {int} -- target buffer height
"""
fb_prop = p3d.FrameBufferProperties(
p3d.FrameBufferProperties.get_default())
fb_prop.set_multisamples(self._multisamples)
fb_prop.set_srgb_color(self._srgb_color)
self._buffer = self._engine.make_output(
self._pipe,
name="offscreen",
sort=0,
fb_prop=p3d.FrameBufferProperties.get_default(),
win_prop=p3d.WindowProperties(size=(width, height)),
flags=p3d.GraphicsPipe.BFRefuseWindow)
self._region = self._buffer.make_display_region()
self._depth_tex = p3d.Texture()
self._depth_tex.setFormat(p3d.Texture.FDepthComponent)
self._buffer.addRenderTexture(self._depth_tex,
p3d.GraphicsOutput.RTMCopyRam,
p3d.GraphicsOutput.RTPDepth)
self._color_tex = p3d.Texture()
self._color_tex.setFormat(p3d.Texture.FRgba8)
self._buffer.addRenderTexture(self._color_tex,
p3d.GraphicsOutput.RTMCopyRam,
p3d.GraphicsOutput.RTPColor)
def test_glsl_sampler(gsg):
tex1 = core.Texture("")
tex1.setup_1d_texture(1, core.Texture.T_unsigned_byte,
core.Texture.F_rgba8)
tex1.set_clear_color((0, 2 / 255.0, 1, 1))
tex2 = core.Texture("")
tex2.setup_2d_texture(1, 1, core.Texture.T_float, core.Texture.F_rgba32)
tex2.set_clear_color((1.0, 2.0, -3.14, 0.0))
tex3 = core.Texture("")
tex3.setup_3d_texture(1, 1, 1, core.Texture.T_float, core.Texture.F_r32)
tex3.set_clear_color((0.5, 0.0, 0.0, 1.0))
preamble = """
uniform sampler1D tex1;
uniform sampler2D tex2;
uniform sampler3D tex3;
"""
code = """
assert(texelFetch(tex1, 0, 0) == vec4(0, 2 / 255.0, 1, 1));
assert(texelFetch(tex2, ivec2(0, 0), 0) == vec4(1.0, 2.0, -3.14, 0.0));
assert(texelFetch(tex3, ivec3(0, 0, 0), 0) == vec4(0.5, 0.0, 0.0, 1.0));
"""
run_glsl_test(gsg, code, preamble, {
'tex1': tex1,
'tex2': tex2,
'tex3': tex3
})
def __init__(self, fafnir_np):
self._count_np = p3d.NodePath(p3d.ComputeNode('FDM_comp_count'))
self._count_np.reparent_to(fafnir_np)
count_shader = p3d.Shader.load_compute(
p3d.Shader.SL_GLSL,
'shaders/count_materials.cs'
)
self._count_np.set_shader(count_shader)
self._count_np.set_bin('fixed', 40)
self._call_np = p3d.NodePath(p3d.ComputeNode('FDM_comp_call'))
self._call_np.reparent_to(fafnir_np)
count_shader = p3d.Shader.load_compute(
p3d.Shader.SL_GLSL,
'shaders/create_draw_calls.cs'
)
self._call_np.set_shader(count_shader)
self._call_np.set_bin('fixed', 41)
self._sort_np = p3d.NodePath(p3d.ComputeNode('FDM_comp_sort'))
self._sort_np.reparent_to(fafnir_np)
count_shader = p3d.Shader.load_compute(
p3d.Shader.SL_GLSL,
'shaders/sort_intersections.cs'
)
self._sort_np.set_shader(count_shader)
self._sort_np.set_bin('fixed', 42)
self._indirect_buffer = p3d.Texture()
self.draw_count = 0
self._sorted_buffer = p3d.Texture()
self.ray_count = 0
self.ensure_sizes(1, 1)
def __init__(self, base):
# Load shader sources to avoid model path problems
for src_set in all_shader_sources:
for i, filename in enumerate(src_set):
with open(filename, 'r') as fin:
src_set[i] = fin.read()
base.render.set_shader_auto()
base.render.set_attrib(p3d.LightRampAttrib.make_identity())
pbr_shader = p3d.Shader.make(p3d.Shader.SL_GLSL, *material_shader_sources)
base.render.set_shader(pbr_shader)
manager = FilterManager(base.win, base.cam)
aa_tex = p3d.Texture()
self.post_tex = p3d.Texture()
self.post_tex.set_component_type(p3d.Texture.T_float)
aa_quad = manager.renderSceneInto(colortex=self.post_tex)
post_quad = manager.renderQuadInto(colortex=aa_tex)
aa_quad.set_shader(p3d.Shader.make(p3d.Shader.SL_GLSL, *antialias_shader_sources))
aa_quad.set_shader_input('source', aa_tex)
aa_quad.set_shader_input('viewport', base.win.get_size())
post_quad.set_shader(p3d.Shader.make(p3d.Shader.SL_GLSL, *post_shader_sources))
post_quad.set_shader_input('tex', self.post_tex)
def test_glsl_uimage(gsg):
from struct import pack
tex1 = core.Texture("")
tex1.setup_1d_texture(1, core.Texture.T_unsigned_byte,
core.Texture.F_rgba8i)
tex1.set_ram_image(pack('BBBB', 0, 1, 2, 3))
tex2 = core.Texture("")
tex2.setup_2d_texture(1, 1, core.Texture.T_unsigned_short,
core.Texture.F_r16i)
tex2.set_ram_image(pack('H', 4))
tex3 = core.Texture("")
tex3.setup_3d_texture(1, 1, 1, core.Texture.T_unsigned_int,
core.Texture.F_r32i)
tex3.set_ram_image(pack('I', 5))
preamble = """
layout(rgba8ui) uniform uimage1D tex1;
layout(r16ui) uniform uimage2D tex2;
layout(r32ui) uniform uimage3D tex3;
"""
code = """
assert(imageLoad(tex1, 0) == uvec4(0, 1, 2, 3));
assert(imageLoad(tex2, ivec2(0, 0)) == uvec4(4, 0, 0, 1));
assert(imageLoad(tex3, ivec3(0, 0, 0)) == uvec4(5, 0, 0, 1));
"""
run_glsl_test(gsg, code, preamble, {
'tex1': tex1,
'tex2': tex2,
'tex3': tex3
})
def test_glsl_usampler(gsg):
from struct import pack
tex1 = core.Texture("")
tex1.setup_1d_texture(1, core.Texture.T_unsigned_byte,
core.Texture.F_rgba8i)
tex1.set_ram_image(pack('BBBB', 0, 1, 2, 3))
tex2 = core.Texture("")
tex2.setup_2d_texture(1, 1, core.Texture.T_unsigned_short,
core.Texture.F_r16i)
tex2.set_ram_image(pack('H', 4))
tex3 = core.Texture("")
tex3.setup_3d_texture(1, 1, 1, core.Texture.T_unsigned_int,
core.Texture.F_r32i)
tex3.set_ram_image(pack('I', 5))
preamble = """
uniform usampler1D tex1;
uniform usampler2D tex2;
uniform usampler3D tex3;
"""
code = """
assert(texelFetch(tex1, 0, 0) == uvec4(0, 1, 2, 3));
assert(texelFetch(tex2, ivec2(0, 0), 0) == uvec4(4, 0, 0, 1));
assert(texelFetch(tex3, ivec3(0, 0, 0), 0) == uvec4(5, 0, 0, 1));
"""
run_glsl_test(gsg, code, preamble, {
'tex1': tex1,
'tex2': tex2,
'tex3': tex3
})
def test_glsl_write_extract_image_buffer(gsg):
# Tests that we can write to a buffer texture on the GPU, and then extract
# the data on the CPU. We test two textures since there was in the past a
# where it would only work correctly for one texture.
tex1 = core.Texture("tex1")
tex1.set_clear_color(0)
tex1.setup_buffer_texture(1, core.Texture.T_unsigned_int,
core.Texture.F_r32i, core.GeomEnums.UH_static)
tex2 = core.Texture("tex2")
tex2.set_clear_color(0)
tex2.setup_buffer_texture(1, core.Texture.T_int, core.Texture.F_r32i,
core.GeomEnums.UH_static)
preamble = """
layout(r32ui) uniform uimageBuffer tex1;
layout(r32i) uniform iimageBuffer tex2;
"""
code = """
assert(imageLoad(tex1, 0).r == 0u);
assert(imageLoad(tex2, 0).r == 0);
imageStore(tex1, 0, uvec4(123));
imageStore(tex2, 0, ivec4(-456));
memoryBarrier();
assert(imageLoad(tex1, 0).r == 123u);
assert(imageLoad(tex2, 0).r == -456);
"""
run_glsl_test(gsg, code, preamble, {'tex1': tex1, 'tex2': tex2})
engine = core.GraphicsEngine.get_global_ptr()
assert engine.extract_texture_data(tex1, gsg)
assert engine.extract_texture_data(tex2, gsg)
assert struct.unpack('I', tex1.get_ram_image()) == (123, )
assert struct.unpack('i', tex2.get_ram_image()) == (-456, )
def __init__(self, vert_count=2**20, tri_count=2**20):
self.max_vert_count = 0
self.max_tri_count = 0
self.vert_texture = p3d.Texture()
self.index_texture = p3d.Texture()
self.ensure_sizes(vert_count, tri_count)
def setup_shaders(self, render_node):
shader_dir = os.path.dirname(__file__)
# Do not force power-of-two textures
p3d.Texture.set_textures_power_2(p3d.ATS_none)
# PBR shader
pbrshader = p3d.Shader.load(
p3d.Shader.SL_GLSL,
vertex=os.path.join(shader_dir, 'simplepbr.vert'),
fragment=os.path.join(shader_dir, 'simplepbr.frag')
)
render_node.set_shader(pbrshader)
# Tonemapping
manager = FilterManager(base.win, base.cam)
tonemap_tex = p3d.Texture()
tonemap_tex.set_component_type(p3d.Texture.T_float)
tonemap_quad = manager.render_scene_into(colortex=tonemap_tex)
tonemap_shader = p3d.Shader.load(
p3d.Shader.SL_GLSL,
vertex=os.path.join(shader_dir, 'post.vert'),
fragment=os.path.join(shader_dir, 'tonemap.frag')
)
tonemap_quad.set_shader(tonemap_shader)
tonemap_quad.set_shader_input('tex', tonemap_tex)
def create_test_texture(angular_width, z_width, color, color_bg, size_phi,
size_z):
# generate bar texture
image = pcore.PNMImage(
size_phi, size_z
) # only 1 degree steps for the width of the window and 0.1 units steps for the height of the window
image.fill(color_bg / 255.)
# for i in range(0, 20):
# for j in range(int(size_z)-20, int(size_z)):
# image.setXelA(i,j,color/255.,color/255.,color/255.,1)
for i in range(0, size_phi):
image.setXelA(i, 0, color_bg / 255., color_bg / 255., color_bg / 255.,
1)
image.setXelA(i, size_z - 1, color / 255., color / 255., color / 255.,
1)
for i in range(0, size_z):
image.setXelA(0, i, color_bg / 255., color_bg / 255., color_bg / 255.,
1)
image.setXelA(size_phi - 1, i, color / 255., color / 255.,
color / 255., 1)
tex = pcore.Texture()
tex.load(image)
tex.setMagfilter(pcore.Texture.FTLinearMipmapLinear)
tex.setAnisotropicDegree(16)
return tex
def create_circular_window_texture(angular_width, color, color_bg):
# generate bar texture
image = pcore.PNMImage(
360 * 3, 260 * 2
) # only 1 degree steps for the width of the window and 0.1 units steps for the height of the window
#z_width = (angular_width/360. * 2 * math.pi*10) / 26 * (np.degrees(np.arctan(13/10.)) * 2)
z_width = np.radians(
angular_width
) * 10 # Kleinwinkelnaeherung / approximation for small angular widths
#print z_width
image.fill(color_bg / 255.)
for i in range(min([360 * 3, int(angular_width) * 3])):
for j in range(min([260 * 2, int(np.round(z_width / 0.1 * 2))])):
if (i - angular_width / 2. * 3)**2 / (
angular_width / 2. *
3)**2 + (j - z_width / 0.1 / 2. * 2)**2 / (z_width / 0.1 /
2. * 2)**2 <= 1:
image.setXelA(i, j, color / 255., color / 255., color / 255.,
1)
tex = pcore.Texture()
tex.load(image)
tex.setMagfilter(pcore.Texture.FTNearest)
tex.setBorderColor(
pcore.Vec4(color_bg / 255., color_bg / 255., color_bg / 255., 1))
tex.setWrapU(pcore.Texture.WM_border_color)
tex.setWrapV(pcore.Texture.WM_border_color)
tex.setAnisotropicDegree(16)
return tex
def create_window_texture_set_size(angular_width, z_width, color, color_bg,
size_phi, size_z):
# this creates a texture of size (size_phi X size_z) in pixels
# one subregion of the texture of size (angular_width X z_width) is colored with "color"
# the rest of the texture is colored with "color_bg"
# generate bar texture
image = pcore.PNMImage(
size_phi, size_z
) # only 1 degree steps for the width of the window and 0.1 units steps for the height of the window
image.fill(color_bg / 255.)
for i in range(int(angular_width)):
for j in range(int(np.round(z_width / 0.1))):
image.setXelA(i, j, color / 255., color / 255., color / 255., 1)
for i in range(int(angular_width), size_phi):
for j in range(int(np.round(z_width / 0.1))):
image.setXelA(i, 0, color_bg / 255., color_bg / 255.,
color_bg / 255., 1)
tex = pcore.Texture()
tex.load(image)
tex.setMagfilter(pcore.Texture.FTLinearMipmapLinear)
tex.setBorderColor(
pcore.Vec4(color_bg / 255., color_bg / 255., color_bg / 255., 1))
tex.setWrapU(pcore.Texture.WM_border_color)
tex.setWrapV(pcore.Texture.WM_border_color)
tex.setAnisotropicDegree(16)
return tex
def create_content_texture(content, color_bg):
# this creates a texture of size (360 X 260) in pixels
# this correspond to a precision of 1 degree in azimuth and 1mm in the z-axis in arena coordinates
# one subregion of the texture gets a given content
# the rest is filled with background
angular_width, z_width = content.shape
# generate bar texture
image = pcore.PNMImage(
360, 260
) # only 1 degree steps for the width of the window and 0.1 units steps for the height of the window
image.fill(color_bg / 255.)
for i in range(int(angular_width)):
for j in range(int(np.round(z_width))):
image.setXelA(i, j, content[i, j] / 255., content[i, j] / 255.,
content[i, j] / 255., 1)
#for i in range(int(angular_width), 360):
# for j in range(int(np.round(z_width/0.1))):
# image.setXelA(i, 0, color_bg/255., color_bg/255., color_bg/255., 1)
tex = pcore.Texture()
tex.load(image)
tex.setMagfilter(pcore.Texture.FTLinearMipmapLinear)
tex.setBorderColor(
pcore.Vec4(color_bg / 255., color_bg / 255., color_bg / 255., 1))
tex.setWrapU(pcore.Texture.WM_border_color)
tex.setWrapV(pcore.Texture.WM_border_color)
tex.setAnisotropicDegree(16)
return tex
def build(self):
# configure beamer
self.set_arena_mode('greenHDMI')
self.cylinder_height, self.cylinder_radius, self.cylinder = tools.standard_cylinder(
self.parent.mainNode)
self.cylinder.setScale(10, 10, 50)
self.cylinder_height = 50
self.cylinder_radius = 10
chess_image = pcore.PNMImage(2, 2)
chess_image.setXelA(0, 0, 0, 0, 0, 1)
chess_image.setXelA(1, 1, 0, 0, 0, 1)
chess_image.setXelA(0, 1, 1, 1, 1, 1)
chess_image.setXelA(1, 0, 1, 1, 1, 1)
chess_tex = pcore.Texture()
chess_tex.load(chess_image)
chess_tex.setMagfilter(pcore.Texture.FTNearest)
N_vertical = self.cylinder_height / (
2 * math.pi * self.cylinder_radius / self.N_horizontal
) #1./(2*math.pi/N_horizontal)
self.cylinder.setTexScale(pcore.TextureStage.getDefault(),
self.N_horizontal, N_vertical)
self.cylinder.setTexture(chess_tex)
self.v_tex_offset_count = 0
self.h_tex_offset_count = 0
self.fov_right_diff = [0.0, 0.0]
self.fov_left_diff = [0.0, 0.0]
self.T = self.duration
def generate(parent=None, texture=None, foreground=False):
bgnp = p3d.NodePath(p3d.CardMaker('bgimg').generate())
bgnp.set_shader(p3d.Shader.make(p3d.Shader.SL_GLSL, _BG_VERT, _BG_FRAG))
bgnp.set_shader_input('exposure_inv', 1.0 / base.render_pipeline.exposure)
bgnp.set_bin('fixed' if foreground else 'background', 0)
bgnp.set_depth_test(False)
bgnp.set_depth_write(False)
bgnp.node().set_bounds(p3d.OmniBoundingVolume())
bgnp.node().set_final(True)
if parent is not None:
bgnp.reparent_to(parent)
if texture is not None:
suffix = 'fg' if foreground else 'bg'
tex = base.loader.load_texture(f'backgrounds/{texture}{suffix}.png')
if tex.num_components == 4:
bgnp.set_transparency(p3d.TransparencyAttrib.M_alpha)
tex.set_format(p3d.Texture.F_srgb_alpha)
else:
tex.set_format(p3d.Texture.F_srgb)
else:
tex = p3d.Texture()
bgnp.set_shader_input('tex', tex)
return bgnp
def convert_npy_to_texture(self, image_npy):
'''
This function converts a 3D numpy array into a Panda3D texture that can be put onto the surface of an object
:param image_npy: the input 2D numpy array
:return: resulting Panda3D Texture
'''
tex = np.tile(image_npy,
(3, 1, 1)).swapaxes(0, 1).swapaxes(1, 2).astype(
np.uint8) # re-arrange axes and convert to 8-bit
texture = pcore.Texture("image") # setup 2D Pandas Texture
texture.setup2dTexture(tex.shape[1], tex.shape[0],
pcore.Texture.TUnsignedByte,
pcore.Texture.FRgb8)
p = pcore.PTAUchar.emptyArray(0) # cryptic Panda3D stuff
p.setData(tex.tostring())
texture.setRamImage(pcore.CPTAUchar(p))
texture.setMagfilter(
pcore.Texture.FTNearest
) # interpolation options for magnification and minification
texture.setMinfilter(pcore.Texture.FTNearest)
return texture
def __init__(self):
ShowBase.__init__(self)
self.accept('escape', sys.exit)
texture = p3d.Texture()
texture.setup_buffer_texture(10, p3d.Texture.T_unsigned_int,
p3d.Texture.F_rgba32,
p3d.GeomEnums.UH_dynamic)
gsg = self.win.get_gsg()
pobs = gsg.get_prepared_objects()
tex_ctx = texture.prepare_now(0, pobs, gsg)
compute_node = p3d.ComputeNode('compute_node')
compute_node.add_dispatch(10, 1, 1)
compute_np = p3d.NodePath(compute_node)
compute_np.reparent_to(self.render)
compute_shader = p3d.Shader.make_compute(p3d.Shader.SL_GLSL,
SHADER_SRC)
compute_np.set_shader(compute_shader)
compute_np.set_shader_input('test_buffer', texture, False, True, -1, 0)
def extract_texture(task):
self.graphics_engine.extract_texture_data(texture,
self.win.get_gsg())
view = memoryview(texture.get_ram_image()).cast('i')
for i in range(10):
print(view[i], end=' ')
print()
return task.cont
taskMgr.add(extract_texture, 'extract_texture', sort=55)
def generate_texture(self, current_frame):
noise_frame = np.floor_divide(current_frame, self.delta_s)
diff = self.framecount - noise_frame
#print(noise_frame, current_frame)
if diff > 0:
# if number of generated frames is more than number of displayed frames, wait one frame
#print("wait a frame")
return None
elif diff == 0:
# if number of generated frames equals number of displayes frames -> all good, generate next frame
# get new random numbers and apply 1st order LP filter
numbers = np.random.randint(0, 2,
self.bg_tex_shape) # get new numbers
self.framecount += 1
###
#self.shared.control_values[current_frame, :, :] = numbers
###
# transform random numbers to stimulus -> map 95% of the values to the range between 0 - 255
image = numbers
#image[image==1] = int(125 + self.contrast/2.)
#image[image==0] = int(125 - self.contrast/2.)
image = ((image - 0.5) * self.contrast + 125).astype(
np.int) # transform 0 and 1 to contrast values
# transform image into a Panda3D texture
tex = np.tile(image,
(3, 1, 1)).swapaxes(0,
1).swapaxes(1,
2).astype(np.uint8)
texture = pcore.Texture("image")
texture.setup2dTexture(tex.shape[1], tex.shape[0],
pcore.Texture.TUnsignedByte,
pcore.Texture.FRgb8)
p = pcore.PTAUchar.emptyArray(0)
p.setData(tex.tostring())
texture.setRamImage(pcore.CPTAUchar(p))
texture.setMagfilter(pcore.Texture.FTNearest)
texture.setMinfilter(pcore.Texture.FTNearest)
return texture
elif diff < 0:
# if number of generated frames is smaller than number of "should have been"-displayed frames
# -> jump the difference and continue generating frames from there
np.random.randint(0, 2, self.bg_tex_shape)
self.framecount += np.abs(diff)
#print("jump " + str(np.abs(diff)))
return self.generate_texture(current_frame)
def create_ellipse_window_texture_transparent_fg(angular_width, z_width, color,
color_bg):
# analogue to create_circular_window_texture, only width an additional z_width
# (used to account for perspective distortions when showing larger angles).
# generate bar texture
precision = 0.2
image = pcore.PNMImage(
360 * 3, 260 * 2
) # only 1 degree steps for the width of the window and 0.1 units steps for the height of the window
#z_width = (angular_width/360. * 2 * math.pi*10) / 26 * (np.degrees(np.arctan(13/10.)) * 2)
#z_width = np.radians(angular_width) * 10 # Kleinwinkelnaeherung / approximation for small angular widths
#print z_width
image.fill(color_bg / 255.)
image.alphaFillVal(255)
for i in range(min([360 * 3, int(angular_width) * 3])):
for j in range(min([260 * 2, int(np.round(z_width / precision * 2))])):
if (i - angular_width / 2. * 3)**2 / (
angular_width / 2. *
3)**2 + (j - z_width / precision / 2. * 2)**2 / (
z_width / precision / 2. * 2)**2 <= 1:
image.setXelA(i, j, color / 255., color / 255., color / 255.,
0)
#image.setAlphaVal(i,j,0.1)
print("zwidth")
print(z_width)
# SHOW BORDERS OF THE LOOP FROM ABOVE
#for i in range(0,360*3):
# image.setXelA(i,0,color/255.,color/255.,color/255.,1)
# image.setXelA(i,1,color/255.,color/255.,color/255.,1)
# image.setXelA(i,2,color/255.,color/255.,color/255.,1)
# image.setXelA(i,int(np.round(z_width/0.1*2))-1,color/255.,color/255.,color/255.,1)
# image.setXelA(i,int(np.round(z_width/0.1*2))-2,color/255.,color/255.,color/255.,1)
# image.setXelA(i,int(np.round(z_width/0.1*2))-3,color/255.,color/255.,color/255.,1)
#for j in range(0,260*2):
# image.setXelA(0,j,color/255.,color/255.,color/255.,1)
# image.setXelA(1,j,color/255.,color/255.,color/255.,1)
# image.setXelA(2,j,color/255.,color/255.,color/255.,1)
# image.setXelA(int(angular_width)*3-1,j,color/255.,color/255.,color/255.,1)
# image.setXelA(int(angular_width)*3-2,j,color/255.,color/255.,color/255.,1)
# image.setXelA(int(angular_width)*3-3,j,color/255.,color/255.,color/255.,1)
tex = pcore.Texture()
tex.load(image)
tex.setMagfilter(pcore.Texture.FTNearest)
tex.setBorderColor(
pcore.Vec4(color_bg / 255., color_bg / 255., color_bg / 255., 1))
tex.setWrapU(pcore.Texture.WM_border_color)
tex.setWrapV(pcore.Texture.WM_border_color)
tex.setAnisotropicDegree(16)
return tex
def test_glsl_image(gsg):
tex1 = core.Texture("")
tex1.setup_1d_texture(1, core.Texture.T_unsigned_byte, core.Texture.F_rgba8)
tex1.set_clear_color((0, 2 / 255.0, 1, 1))
tex2 = core.Texture("")
tex2.setup_2d_texture(1, 1, core.Texture.T_float, core.Texture.F_rgba32)
tex2.set_clear_color((1.0, 2.0, -3.14, 0.0))
preamble = """
layout(rgba8) uniform image1D tex1;
layout(rgba32f) uniform image2D tex2;
"""
code = """
assert(imageLoad(tex1, 0) == vec4(0, 2 / 255.0, 1, 1));
assert(imageLoad(tex2, ivec2(0, 0)) == vec4(1.0, 2.0, -3.14, 0.0));
"""
run_glsl_test(gsg, code, preamble, {'tex1': tex1, 'tex2': tex2})
def run_glsl_test(gsg, body, preamble="", inputs={}, version=430):
""" Runs a GLSL test on the given GSG. The given body is executed in the
main function and should call assert(). The preamble should contain all
of the shader inputs. """
if not gsg.supports_compute_shaders or not gsg.supports_glsl:
pytest.skip("compute shaders not supported")
if not gsg.supports_buffer_texture:
pytest.skip("buffer textures not supported")
__tracebackhide__ = True
preamble = preamble.strip()
body = body.rstrip().lstrip('\n')
code = GLSL_COMPUTE_TEMPLATE.format(version=version,
preamble=preamble,
body=body)
line_offset = code[:code.find(body)].count('\n') + 1
shader = core.Shader.make_compute(core.Shader.SL_GLSL, code)
assert shader, code
# Create a buffer to hold the results of the assertion. We use one byte
# per line of shader code, so we can show which lines triggered.
result = core.Texture("")
result.set_clear_color((0, 0, 0, 0))
result.setup_buffer_texture(code.count('\n'), core.Texture.T_unsigned_byte,
core.Texture.F_r8i, core.GeomEnums.UH_static)
# Build up the shader inputs
attrib = core.ShaderAttrib.make(shader)
for name, value in inputs.items():
attrib = attrib.set_shader_input(name, value)
attrib = attrib.set_shader_input('_triggered', result)
# Run the compute shader.
engine = core.GraphicsEngine.get_global_ptr()
try:
engine.dispatch_compute((1, 1, 1), attrib, gsg)
except AssertionError as exc:
assert False, "Error executing compute shader:\n" + code
# Download the texture to check whether the assertion triggered.
assert engine.extract_texture_data(result, gsg)
triggered = result.get_ram_image()
if any(triggered):
count = len(triggered) - triggered.count(0)
lines = body.split('\n')
formatted = ''
for i, line in enumerate(lines):
if triggered[i + line_offset]:
formatted += '=> ' + line + '\n'
else:
formatted += ' ' + line + '\n'
pytest.fail("{0} GLSL assertions triggered:\n{1}".format(
count, formatted))
def __setup_rings(self):
node_path, self.__rings, self.__symbol_cards = modelgen.three_rings()
node_path.reparent_to(self.__root)
node_path.set_pos(self.__pos)
self.__collision_handler.add(
collision.CollisionCircle(self.__pos, common.TR_RADII[0]))
self.__collision_handler.add(
collision.CollisionCircle(self.__pos,
common.TR_RADII[0] * 4,
(self.__found_event, ()),
ghost=True))
self.__collision_handler.add(
collision.CollisionCircle(self.__pos,
common.TR_RADII[0] * 2.2,
(self.__lever_hint_event, ()),
ghost=True))
for i, s in enumerate(self.__symbols):
n = self.__symbol_cards[i // 6][i % 6]
tex = core.Texture('symbol')
tex.setup_2d_texture(*common.NG_SYM_TEX_SIZE,
core.Texture.T_unsigned_byte,
core.Texture.F_rgba)
ta = np.ones(common.NG_SYM_TEX_SIZE + (4, ), dtype=np.uint8)
ta *= 255
tf = np.array(s) < 255
ta[tf, 0] = int(common.TR_COLORS[i // 6].x * 255)
ta[tf, 1] = int(common.TR_COLORS[i // 6].x * 255)
ta[tf, 2] = int(common.TR_COLORS[i // 6].x * 255)
ta[:, :, 3] = 255
# ta = np.flip(ta, 1)
tex.set_ram_image_as(ta, 'RGBA')
tex.reload()
n.set_texture(tex, 1)
# setup levers
rot = self.__root.attach_new_node('rot')
rot.set_pos(node_path.get_pos(self.__root))
self.__levers = []
for i in range(3):
node_path, lever = modelgen.lever(i)
self.__levers.append(lever)
node_path.reparent_to(rot)
node_path.set_y(common.TR_LEVER_Y)
rot.set_h(i * 90 + 90)
pos = node_path.get_pos(self.__root)
hpr = node_path.get_hpr(self.__root)
node_path.reparent_to(self.__root)
node_path.set_pos_hpr(pos, hpr)
node_path.set_z(node_path, 2.5)
self.__collision_handler.add(
collision.CollisionCircle(pos,
4, (self.__lever_act_range, (i, )),
ghost=True))
self.__collision_handler.add(collision.CollisionCircle(pos, 1))
def make_offscreen(self, sizex, sizey):
sizex = p3d.Texture.up_to_power_2(sizex)
sizey = p3d.Texture.up_to_power_2(sizey)
if self.win and self.win.get_size()[0] == sizex and self.win.get_size(
)[1] == sizey:
# The current window is good, don't waste time making a new one
return
use_frame_rate_meter = self.frameRateMeter is not None
self.setFrameRateMeter(False)
self.graphicsEngine.remove_all_windows()
self.win = None
self.view_region = None
# First try to create a 24bit buffer to minimize copy times
fbprops = p3d.FrameBufferProperties()
fbprops.set_rgba_bits(8, 8, 8, 0)
fbprops.set_depth_bits(24)
winprops = p3d.WindowProperties.size(sizex, sizey)
flags = p3d.GraphicsPipe.BF_refuse_window
#flags = p3d.GraphicsPipe.BF_require_window
self.win = self.graphicsEngine.make_output(self.pipe, 'window', 0,
fbprops, winprops, flags)
if self.win is None:
# Try again with an alpha channel this time (32bit buffer)
fbprops.set_rgba_bits(8, 8, 8, 8)
self.win = self.graphicsEngine.make_output(self.pipe, 'window', 0,
fbprops, winprops,
flags)
if self.win is None:
print('Unable to open window')
sys.exit(-1)
disp_region = self.win.make_mono_display_region()
disp_region.set_camera(self.cam)
disp_region.set_active(True)
disp_region.set_clear_color_active(True)
disp_region.set_clear_color(self.bg_color)
disp_region.set_clear_depth(1.0)
disp_region.set_clear_depth_active(True)
self.view_region = disp_region
self.graphicsEngine.open_windows()
self.setFrameRateMeter(use_frame_rate_meter)
self.update_rman()
self.texture = p3d.Texture()
self.win.addRenderTexture(self.texture,
p3d.GraphicsOutput.RTM_copy_ram)
def create_plain_texture(color):
image = pcore.PNMImage(1, 1)
image.setXelA(0, 0, color / 255., color / 255., color / 255., 1)
tex = pcore.Texture()
tex.load(image)
tex.setMagfilter(pcore.Texture.FTLinearMipmapLinear)
tex.setAnisotropicDegree(16)
return tex
def __init__(self, base):
self.base = base
self.base.render.set_shader_auto()
p3d.Texture.setTexturesPower2(p3d.ATS_none)
manager = FilterManager(base.win, base.cam)
self.post_tex = p3d.Texture()
post_quad = manager.renderSceneInto(colortex=self.post_tex)
post_quad.set_shader(
p3d.Shader.make(p3d.Shader.SL_GLSL, _SRGB_VERT, _SRGB_FRAG))
post_quad.set_shader_input('tex', self.post_tex)
def place_devils_tower(self):
self.devils_tower = self.render.attach_new_node(
shape.ShapeGen().elliptic_cone(a=(240, 70),
b=(200, 80),
h=250,
max_seg_len=20.0,
exp=2.5,
top_xy=(40, -20),
color=core.Vec4(
0.717, 0.635, 0.558, 1),
nac=False))
h = random.randint(0, 360)
self.collision.add(collision.CollisionCircle(
core.Vec2(0),
230,
))
self.devils_tower.set_h(h)
z = []
for x in (-220, 0, 220):
for y in (-220, 0, 220):
z.append(self.sample_terrain_z(x, y))
self.devils_tower.set_z(min(z) - 5)
self.noise.setup_fns(noise_type=fns.NoiseType.Value, )
y, x = common.DT_TEX_SHAPE
c = fns.empty_coords(y * x)
c[0, :] = np.tile(
np.cos(np.linspace(-np.pi, np.pi, x, False)) * common.DT_XY_RADIUS,
y)
c[1, :] = np.tile(
np.sin(np.linspace(-np.pi, np.pi, x, False)) * common.DT_XY_RADIUS,
y)
c[2, :] = np.repeat(
np.linspace(-np.pi, np.pi, x, False) * common.DT_Z_RADIUS, y)
a = self.noise.fns.genFromCoords(c).reshape((y, x))
normal_map = util.sobel(a, 0.15)
# Image.fromarray(normal_map).show()
tex = self.loader.load_texture('rock.jpg')
ts = core.TextureStage('ts')
tex.set_wrap_u(core.Texture.WM_clamp)
tex.set_wrap_v(core.Texture.WM_clamp)
self.devils_tower.set_texture(ts, tex)
self.devils_tower.set_tex_scale(ts, 1)
tex = core.Texture('dt_normal_map')
tex.setup_2d_texture(y, x, core.Texture.T_unsigned_byte,
core.Texture.F_rgb)
tex.set_ram_image_as(normal_map, 'RGB')
tex.set_wrap_u(core.Texture.WM_clamp)
tex.set_wrap_v(core.Texture.WM_clamp)
ts = core.TextureStage('ts')
ts.set_mode(core.TextureStage.M_normal)
tex.reload()
self.devils_tower.set_texture(ts, tex)
def __init__(self, base):
import panda3d.core as p3d
from direct.filter.FilterManager import FilterManager
self.base = base
self.base.render.set_shader_auto()
manager = FilterManager(base.win, base.cam)
self.post_tex = p3d.Texture()
post_quad = manager.renderSceneInto(colortex=self.post_tex)
post_quad.set_shader(
p3d.Shader.make(p3d.Shader.SL_GLSL, _srgb_vert, _srgb_frag))
post_quad.set_shader_input('tex', self.post_tex)
def _make_sdf_box():
sdfimg = p3d.PNMImage(_SDF_SIZE, _SDF_SIZE)
for imgx in range(_SDF_SIZE):
normx = abs((imgx / _SDF_SIZE) * 2.0 - 1.0)
for imgy in range(_SDF_SIZE):
normy = abs((imgy / _SDF_SIZE) * 2.0 - 1.0)
dist = _lin_remap(1 - max(normx, normy), 0, 1, 0.5, 1)
sdfimg.setXel(imgx, imgy, dist)
sdftex = p3d.Texture()
sdftex.load(sdfimg)
return sdftex
def _make_outputs(self, count):
outputs = [
p3d.Texture(f'{self.name}_output_{i}') for i in range(count)
]
for i, output in enumerate(outputs):
attach_point = p3d.GraphicsOutput.RTP_color
if i > 0:
attach_point = getattr(p3d.GraphicsOutput,
f'RTP_aux_rgba_{i - 1}')
self.buffer.add_render_texture(output,
p3d.GraphicsOutput.RTM_bind_or_copy,
attach_point)
return outputs
def __init__(self):
ShowBase.__init__(self)
pman.shim.init(self)
basic = core.Filename.expand_from(
'$MAIN_DIR/assets/textures/basic_1.exr')
basic = self.loader.load_texture(basic)
pipeline = simplematcap.init(basic,
render_node=self.render,
light_dir=core.Vec3(-1, -1,
0.5).normalized())
fog = core.Fog("Fog Name")
fog.set_color(0, 0, 0)
fog.set_exp_density(0.04)
self.render.set_fog(fog)
self.disable_mouse()
self.input = Input()
self.accept('escape', sys.exit)
self.accept('f1', self.toggle_wireframe)
self.world = World(pipeline)
self.set_background_color(util.srgb_color(0x000000))
self.manager = FilterManager(self.win, self.cam)
tex = core.Texture()
depth = core.Texture()
quad = self.manager.render_scene_into(colortex=tex, depthtex=depth)
post_vert_str = load_shader_str('post.vert')
post_frag_str = load_shader_str('post.frag')
postshader = core.Shader.make(
core.Shader.SL_GLSL,
vertex=post_vert_str,
fragment=post_frag_str,
)
quad.set_shader(postshader)
quad.set_shader_input('tex', tex)
quad.set_shader_input('blur', 2.5)
quad.set_shader_input('depth', depth)
