def make_star(name='star', scale=1, color=Vec3(1), texture_size=64, debug=False):
card_maker = CardMaker(name)
card_maker.set_frame(-1, 1, -1, 1)
node_path = NodePath(name)
node = card_maker.generate()
final_node_path = node_path.attach_new_node(node)
final_node_path.set_billboard_point_eye()
from panda3d.core import Filename
shaders = Shader.load(Shader.SL_GLSL,
Filename('Shader/Star/vertex.glsl'),
Filename('Shader/Star/fragment.glsl'),
Filename(''),
Filename(''),
Filename(''))
if not shaders:
print("WARNING. STAR SHADER FAILED TO LOAD", type(shaders))
else:
final_node_path.set_shader_input('cameraSpherePos', 1, 1, 1)
final_node_path.set_shader_input('sphereRadius', 1.0)
final_node_path.set_shader_input('myCamera', base.camera)
final_node_path.set_shader(shaders)
final_node_path.set_shader_input('blackbody', color)
material = Material()
material.set_emission(VBase4(color, 1.0))
final_node_path.set_material(material)
xn = PerlinNoise3(0.5, 0.5, 0.5)
#yn = PerlinNoise3(0.5, 0.5, 0.5)
texture = Texture('star')
texture.setup_3d_texture()
for z in range(texture_size):
p = PNMImage(texture_size, texture_size)
for y in range(texture_size):
for x in range(texture_size):
p.set_gray(x, y, abs(xn.noise(x, y, z)))
texture.load(p, z, 0)
diffuse = texture
diffuse.setMinfilter(Texture.FTLinearMipmapLinear)
diffuse.setAnisotropicDegree(4)
final_node_path.set_texture(diffuse)
normal = sandbox.base.loader.loadTexture('data/empty_textures/empty_normal.png')
normalts = TextureStage('normalts')
final_node_path.set_texture(normalts, normal)
specular = sandbox.base.loader.loadTexture('data/empty_textures/empty_specular.png')
spects = TextureStage('spects')
final_node_path.set_texture(spects, specular)
roughness = sandbox.base.loader.loadTexture('data/empty_textures/empty_roughness.png')
roughts= TextureStage('roughts')
final_node_path.set_texture(roughts, roughness)
return final_node_path
def make_star(name='star', scale=1, color=Vec3(1), texture_size=64, debug=False):
card_maker = CardMaker(name)
card_maker.set_frame(-1, 1, -1, 1)
node_path = NodePath(name)
node = card_maker.generate()
final_node_path = node_path.attach_new_node(node)
final_node_path.set_billboard_point_eye()
shaders = Shader.load(Shader.SLGLSL,
'Shader/Star/vertex.glsl',
'Shader/Star/fragment.glsl')
final_node_path.set_shader_input(b'cameraSpherePos', 1, 1, 1)
final_node_path.set_shader_input(b'sphereRadius', 1.0)
final_node_path.set_shader_input(b'myCamera', base.camera)
final_node_path.set_shader(shaders)
final_node_path.set_shader_input(b'blackbody', color)
material = Material()
material.set_emission(VBase4(color, 1.0))
final_node_path.set_material(material)
xn = PerlinNoise3(0.5, 0.5, 0.5)
#yn = PerlinNoise3(0.5, 0.5, 0.5)
texture = Texture('star')
texture.setup_3d_texture()
for z in range(texture_size):
p = PNMImage(texture_size, texture_size)
for y in range(texture_size):
for x in range(texture_size):
p.set_gray(x, y, abs(xn.noise(x, y, z)))
texture.load(p, z, 0)
diffuse = texture
diffuse.setMinfilter(Texture.FTLinearMipmapLinear)
diffuse.setAnisotropicDegree(4)
final_node_path.set_texture(diffuse)
normal = base.loader.loadTexture('Data/Textures/EmptyNormalTexture.png')
normalts = TextureStage('normalts')
final_node_path.set_texture(normalts, normal)
specular = base.loader.loadTexture('Data/Textures/EmptySpecularTexture.png')
spects = TextureStage('spects')
final_node_path.set_texture(spects, specular)
roughness = base.loader.loadTexture('Data/Textures/EmptyRoughnessTexture.png')
roughts= TextureStage('roughts')
final_node_path.set_texture(roughts, roughness)
return final_node_path
def load(self, pth):
""" Loads a .IES file from a given filename. """
self.debug("Loading ies profile from", pth)
try:
with open(pth, "r") as handle:
lines = handle.readlines()
except IOError as msg:
self.error("Failed to open", pth, ":", msg)
return None
lines = [i.strip() for i in lines]
# Parse version header
self._check_version_header(lines.pop(0))
# Parse arbitrary amount of keywords
keywords = self._extract_keywords(lines)
# Next line should be TILT=NONE according to the spec
if lines.pop(0) != "TILT=NONE":
raise IESLoaderException("Expected TILT=NONE line, but none found!")
# From now on, lines do not matter anymore, instead everything is
# space seperated
new_parts = (' '.join(lines)).replace(",", " ").split()
read_int = lambda: int(new_parts.pop(0))
read_float = lambda: float(new_parts.pop(0))
# Amount of Lamps
if read_int() != 1:
raise IESLoaderException("Only 1 Lamp supported!")
# Extract various properties
lumen_per_lamp = read_float()
candela_multiplier = read_float()
num_vertical_angles = read_int()
num_horizontal_angles = read_int()
if num_vertical_angles < 1 or num_horizontal_angles < 1:
raise IESLoaderException("Invalid of vertical/horizontal angles!")
photometric_type = read_int()
unit_type = read_int()
# Check for a correct unit type, should be 1 for meters and 2 for feet
if unit_type not in [1, 2]:
raise IESLoaderException("Invalid unit type")
width = read_float()
length = read_float()
height = read_float()
ballast_factor = read_float()
future_use = read_float() # Unused field for future usage
input_watts = read_float()
# Read vertical angles
vertical_angles = [read_float() for i in range(num_vertical_angles)]
horizontal_angles = [read_float() for i in range(num_horizontal_angles)]
candela_values = []
candela_scale = 0.0
for i in range(num_horizontal_angles):
vertical_data = [read_float() for i in range(num_vertical_angles)]
candela_scale = max(candela_scale, max(vertical_data))
candela_values += vertical_data
# Rescale values, divide by maximum
candela_values = [i / candela_scale for i in candela_values]
if len(new_parts) != 0:
self.warn("Unhandled data at file-end left:", new_parts)
# Dont abort here, some formats like those from ERCO Leuchten GmbH
# have an END keyword, just ignore everything after the data was
# read in.
dataset = IESDataset()
dataset.set_vertical_angles(self._list_to_pta(vertical_angles))
dataset.set_horizontal_angles(self._list_to_pta(horizontal_angles))
dataset.set_candela_values(self._list_to_pta(candela_values))
# Testing code to write out the LUT
if False:
from panda3d.core import Texture
tex = Texture("temp")
tex.setup_3d_texture(512, 512, 1, Texture.T_float, Texture.F_r16)
dataset.generate_dataset_texture_into(tex, 0)
tex.write("generated.png")
return dataset
class IESProfileManager(DebugObject):
""" Manager which handles the different IES profiles, and also handles
loading .IES files """
def __init__(self, pipeline):
DebugObject.__init__(self)
self._pipeline = pipeline
self._entries = []
self._loader = IESProfileLoader()
self._max_entries = 32
self._create_storage()
def _create_storage(self):
""" Internal method to create the storage for the profile dataset textures """
self._storage_tex = Texture("IESDatasets")
self._storage_tex.setup_3d_texture(
512, 512, self._max_entries, Texture.T_float, Texture.F_r16)
self._storage_tex.set_minfilter(SamplerState.FT_linear)
self._storage_tex.set_magfilter(SamplerState.FT_linear)
self._storage_tex.set_wrap_u(SamplerState.WM_clamp)
self._storage_tex.set_wrap_v(SamplerState.WM_repeat)
self._storage_tex.set_wrap_w(SamplerState.WM_clamp)
self._pipeline.stage_mgr.add_input("IESDatasetTex", self._storage_tex)
self._pipeline.stage_mgr.define("MAX_IES_PROFILES", self._max_entries)
def load(self, filename):
""" Loads a profile from a given filename """
# Make filename unique
fname = Filename.from_os_specific(filename)
if not VirtualFileSystem.get_global_ptr().resolve_filename(fname, get_model_path().get_value(), "ies"):
self.error("Could not resolve", filename)
return -1
fname = fname.get_fullpath()
# Check for cache entries
if fname in self._entries:
return self._entries.index(fname)
# Check for out of bounds
if len(self._entries) >= self._max_entries:
# TODO: Could remove unused profiles here or regenerate texture
self.warn("Cannot load IES Profile, too many loaded! (Maximum: 32)")
# Try loading the dataset, and see what happes
try:
dataset = self._loader.load(fname)
except IESLoaderException as msg:
self.warn("Failed to load profile from", filename, ":", msg)
return -1
if not dataset:
return -1
# Dataset was loaded successfully, now copy it
dataset.generate_dataset_texture_into(self._storage_tex, len(self._entries))
self._entries.append(fname)
return len(self._entries) - 1
