def setAttribute(self, attributeName, attributeValue, attribute_index):
if attributeName in self.macros and self.macros[
attributeName] != attributeValue:
new_macros = copy.deepcopy(self.macros)
new_macros[attributeName] = attributeValue
# if macro was changed then create a new material.
CoreManager.instance().resource_manager.getMaterial(
self.shader_name, new_macros)
def CreateUniformDataFromString(data_type, strValue=None):
""" return converted data from string or default data """
try:
if data_type == 'bool':
return np.bool(strValue) if strValue else np.bool(False)
elif data_type == 'float':
# return float(strValue) if strValue else 0.0
return np.float32(strValue) if strValue else np.float32(0)
elif data_type == 'int':
# return int(strValue) if strValue else 0
return np.int32(strValue) if strValue else np.int32(0)
elif data_type in ('vec2', 'vec3', 'vec4'):
componentCount = int(data_type[-1])
if strValue is not None:
vecValue = eval(
strValue) if type(strValue) is str else strValue
if len(vecValue) == componentCount:
return np.array(vecValue, dtype=np.float32)
else:
logger.error(
ValueError("%s need %d float members." %
(data_type, componentCount)))
raise ValueError
else:
return np.array([
1.0,
] * componentCount, dtype=np.float32)
elif data_type in ('mat2', 'mat3', 'mat4'):
componentCount = int(data_type[-1])
if strValue is not None:
vecValue = eval(
strValue) if type(strValue) is str else strValue
if len(vecValue) == componentCount:
return np.array(vecValue, dtype=np.float32)
else:
logger.error(
ValueError("%s need %d float members." %
(data_type, componentCount)))
raise ValueError
else:
return np.eye(componentCount, dtype=np.float32)
elif data_type == 'sampler2D':
texture = CoreManager.instance().resource_manager.getTexture(
strValue or 'empty')
return texture
elif data_type == 'sampler2DMS':
logger.warn('sampler2DMS need multisample texture.')
return CoreManager.instance().resource_manager.getTexture('empty')
elif data_type == 'sampler3D':
return CoreManager.instance().resource_manager.getTexture(
'default_3d')
elif data_type == 'samplerCube':
texture = CoreManager.instance().resource_manager.getTexture(
strValue or 'default_cube')
return texture
except ValueError:
logger.error(traceback.format_exc())
return None
def setAttribute(self, attributeName, attributeValue, attribute_index):
if attributeName == 'mesh':
mesh = CoreManager.instance().resource_manager.getMesh(
attributeValue)
if mesh and self.mesh != mesh:
self.set_mesh(mesh)
elif attributeName == 'material_instances':
material_instance = CoreManager.instance(
).resource_manager.getMaterialInstance(
attributeValue[attribute_index])
self.set_material_instance(material_instance, attribute_index)
def Init(self, num_scattering_orders=4):
resource_manager = CoreManager.instance().resource_manager
renderer = CoreManager.instance().renderer
if not self.precompute_illuminance:
lambdas = [kLambdaR, kLambdaG, kLambdaB]
luminance_from_radiance = Matrix3()
self.Precompute(lambdas,
luminance_from_radiance,
False,
num_scattering_orders)
else:
num_iterations = (self.num_precomputed_wavelengths + 2) / 3
dlambda = (kLambdaMax - kLambdaMin) / (3 * num_iterations)
def coeff(L, component):
x = CieColorMatchingFunctionTableValue(L, 1)
y = CieColorMatchingFunctionTableValue(L, 2)
z = CieColorMatchingFunctionTableValue(L, 3)
return (XYZ_TO_SRGB[component * 3] * x +
XYZ_TO_SRGB[component * 3 + 1] * y +
XYZ_TO_SRGB[component * 3 + 2] * z) * dlambda
for i in range(int(num_iterations)):
lambdas = [kLambdaMin + (3 * i + 0.5) * dlambda,
kLambdaMin + (3 * i + 1.5) * dlambda,
kLambdaMin + (3 * i + 2.5) * dlambda]
luminance_from_radiance = Matrix3()
luminance_from_radiance[0] = [coeff(lambdas[0], 0), coeff(lambdas[1], 0), coeff(lambdas[2], 0)]
luminance_from_radiance[1] = [coeff(lambdas[0], 1), coeff(lambdas[1], 1), coeff(lambdas[2], 1)]
luminance_from_radiance[2] = [coeff(lambdas[0], 2), coeff(lambdas[1], 2), coeff(lambdas[2], 2)]
self.Precompute(lambdas,
luminance_from_radiance,
0 < i,
num_scattering_orders)
# Note : recompute compute_transmittance
renderer.framebuffer.set_color_textures(self.transmittance_texture)
renderer.framebuffer.set_depth_texture(None)
renderer.framebuffer.bind_framebuffer()
recompute_transmittance_mi = resource_manager.getMaterialInstance(
'precomputed_atmosphere.recompute_transmittance',
macros=self.material_instance_macros)
recompute_transmittance_mi.use_program()
self.quad.bind_vertex_buffer()
self.quad.draw_elements()
def initialize(self):
self.core_manager = CoreManager.instance()
self.resource_manager = self.core_manager.resource_manager
self.renderer = self.core_manager.renderer
self.rendertarget_manager = self.core_manager.rendertarget_manager
self.quad = self.resource_manager.getMesh("Quad")
self.quad_geometry = self.quad.get_geometry()
self.bloom = self.resource_manager.getMaterialInstance("bloom")
self.bloom_highlight = self.resource_manager.getMaterialInstance("bloom_highlight")
# SSAO
self.ssao = self.resource_manager.getMaterialInstance("ssao")
for i in range(self.ssao_kernel_size):
scale = float(i) / float(self.ssao_kernel_size)
scale = min(max(0.1, scale * scale), 1.0)
self.ssao_kernel[i][0] = random.uniform(-1.0, 1.0)
self.ssao_kernel[i][1] = random.uniform(0.0, 1.0)
self.ssao_kernel[i][2] = random.uniform(-1.0, 1.0)
self.ssao_kernel[i][:] = normalize(self.ssao_kernel[i]) * scale
self.velocity = self.resource_manager.getMaterialInstance("velocity")
self.atmosphere = self.resource_manager.getMaterialInstance("atmosphere")
self.tonemapping = self.resource_manager.getMaterialInstance("tonemapping")
self.blur = self.resource_manager.getMaterialInstance("blur")
self.gaussian_blur = self.resource_manager.getMaterialInstance("gaussian_blur")
self.motion_blur = self.resource_manager.getMaterialInstance("motion_blur")
self.screeen_space_reflection = self.resource_manager.getMaterialInstance("screen_space_reflection")
self.linear_depth = self.resource_manager.getMaterialInstance("linear_depth")
self.deferred_shading = self.resource_manager.getMaterialInstance("deferred_shading")
self.copy_texture_mi = self.resource_manager.getMaterialInstance("copy_texture")
self.render_texture_2d = self.resource_manager.getMaterialInstance(name="render_texture_2d",
shader_name="render_texture",
macros={'GL_TEXTURE_2D': 1})
self.render_texture_3d = self.resource_manager.getMaterialInstance(name="render_texture_3d",
shader_name="render_texture",
macros={'GL_TEXTURE_3D': 1})
self.render_texture_cube = self.resource_manager.getMaterialInstance(name="render_texture_cube",
shader_name="render_texture",
macros={'GL_TEXTURE_CUBE_MAP': 1})
# TAA
self.temporal_antialiasing = self.resource_manager.getMaterialInstance("temporal_antialiasing")
def get_anti_aliasing_name(anti_aliasing):
anti_aliasing = str(anti_aliasing)
return anti_aliasing.split('.')[-1] if '.' in anti_aliasing else anti_aliasing
anti_aliasing_list = [get_anti_aliasing_name(AntiAliasing.convert_index_to_enum(x)) for x in
range(AntiAliasing.COUNT.value)]
# Send to GUI
self.core_manager.sendAntiAliasingList(anti_aliasing_list)
def setAttribute(self, attributeName, attributeValue, attribute_index):
if attributeName == 'shader_name':
if attributeValue != self.shader_name:
material = CoreManager.instance().resource_manager.getMaterial(
attributeValue, self.macros)
self.set_material(material)
elif attributeName in 'material_name':
if self.material:
material = CoreManager.instance().resource_manager.getMaterial(
self.material.shader_name)
self.set_material(material)
elif attributeName in self.linked_material_component_map:
self.set_uniform_data_from_string(attributeName, attributeValue)
elif attributeName in self.macros:
if self.macros[attributeName] != attributeValue:
self.macros[attributeName] = attributeValue
material = CoreManager.instance().resource_manager.getMaterial(
self.material.shader_name, self.macros)
self.set_material(material)
return self.Attributes
def set_mesh(self, mesh):
if mesh:
self.mesh = mesh
default_material_instance = CoreManager.instance(
).resource_manager.getDefaultMaterialInstance(
skeletal=mesh.has_bone())
material_instances = [
default_material_instance,
] * len(mesh.geometries)
for i in range(
min(len(self.material_instances),
len(material_instances))):
material_instances[i] = self.material_instances[i]
self.material_instances = material_instances
def __init__(self,
wavelengths,
solar_irradiance,
sun_angular_radius,
bottom_radius,
top_radius,
rayleigh_density,
rayleigh_scattering,
mie_density,
mie_scattering,
mie_extinction,
mie_phase_function_g,
absorption_density,
absorption_extinction,
ground_albedo,
max_sun_zenith_angle,
length_unit_in_meters,
use_luminance,
num_precomputed_wavelengths,
combine_scattering_textures):
self.wavelengths = wavelengths
self.solar_irradiance = solar_irradiance
self.sun_angular_radius = sun_angular_radius
self.bottom_radius = bottom_radius
self.top_radius = top_radius
self.rayleigh_density = rayleigh_density
self.rayleigh_scattering = rayleigh_scattering
self.mie_density = mie_density
self.mie_scattering = mie_scattering
self.mie_extinction = mie_extinction
self.mie_phase_function_g = mie_phase_function_g
self.absorption_density = absorption_density
self.absorption_extinction = absorption_extinction
self.ground_albedo = ground_albedo
self.max_sun_zenith_angle = max_sun_zenith_angle
self.length_unit_in_meters = length_unit_in_meters
self.num_precomputed_wavelengths = num_precomputed_wavelengths
self.combine_scattering_textures = combine_scattering_textures
self.precompute_illuminance = num_precomputed_wavelengths > 3
if self.precompute_illuminance:
self.kSky = [MAX_LUMINOUS_EFFICACY, MAX_LUMINOUS_EFFICACY, MAX_LUMINOUS_EFFICACY]
else:
self.kSky = ComputeSpectralRadianceToLuminanceFactors(self.wavelengths, self.solar_irradiance, -3)
self.kSun = ComputeSpectralRadianceToLuminanceFactors(self.wavelengths, self.solar_irradiance, 0)
self.material_instance_macros = {
'COMBINED_SCATTERING_TEXTURES': 1 if combine_scattering_textures else 0
}
# Atmosphere shader code
resource_manager = CoreManager.instance().resource_manager
shader_loader = resource_manager.shader_loader
shader_name = 'precomputed_atmosphere.atmosphere_predefine'
recompute_atmosphere_predefine = resource_manager.getShader(shader_name)
recompute_atmosphere_predefine.shader_code = self.glsl_header_factory([kLambdaR, kLambdaG, kLambdaB])
shader_loader.save_resource(shader_name)
shader_loader.load_resource(shader_name)
# create render targets
rendertarget_manager = CoreManager.instance().rendertarget_manager
self.transmittance_texture = rendertarget_manager.create_rendertarget(
"transmittance_texture",
texture_type=Texture2D,
width=TRANSMITTANCE_TEXTURE_WIDTH,
height=TRANSMITTANCE_TEXTURE_HEIGHT,
internal_format=GL_RGBA32F,
texture_format=GL_RGBA,
min_filter=GL_LINEAR,
mag_filter=GL_LINEAR,
data_type=GL_FLOAT,
wrap=GL_CLAMP_TO_EDGE
)
self.scattering_texture = rendertarget_manager.create_rendertarget(
"scattering_texture",
texture_type=Texture3D,
width=SCATTERING_TEXTURE_WIDTH,
height=SCATTERING_TEXTURE_HEIGHT,
depth=SCATTERING_TEXTURE_DEPTH,
internal_format=GL_RGBA32F,
texture_format=GL_RGBA,
min_filter=GL_LINEAR,
mag_filter=GL_LINEAR,
data_type=GL_FLOAT,
wrap=GL_CLAMP_TO_EDGE
)
self.optional_single_mie_scattering_texture = None
if not self.combine_scattering_textures:
self.optional_single_mie_scattering_texture = rendertarget_manager.create_rendertarget(
"optional_single_mie_scattering_texture",
texture_type=Texture3D,
width=SCATTERING_TEXTURE_WIDTH,
height=SCATTERING_TEXTURE_HEIGHT,
depth=SCATTERING_TEXTURE_DEPTH,
internal_format=GL_RGBA32F,
texture_format=GL_RGBA,
min_filter=GL_LINEAR,
mag_filter=GL_LINEAR,
data_type=GL_FLOAT,
wrap=GL_CLAMP
)
self.irradiance_texture = rendertarget_manager.create_rendertarget(
"irradiance_texture",
texture_type=Texture2D,
width=IRRADIANCE_TEXTURE_WIDTH,
height=IRRADIANCE_TEXTURE_HEIGHT,
internal_format=GL_RGBA32F,
texture_format=GL_RGBA,
min_filter=GL_LINEAR,
mag_filter=GL_LINEAR,
data_type=GL_FLOAT,
wrap=GL_CLAMP
)
self.delta_irradiance_texture = rendertarget_manager.create_rendertarget(
"delta_irradiance_texture",
texture_type=Texture2D,
width=IRRADIANCE_TEXTURE_WIDTH,
height=IRRADIANCE_TEXTURE_HEIGHT,
internal_format=GL_RGBA32F,
texture_format=GL_RGBA,
min_filter=GL_LINEAR,
mag_filter=GL_LINEAR,
data_type=GL_FLOAT,
wrap=GL_CLAMP
)
self.delta_rayleigh_scattering_texture = rendertarget_manager.create_rendertarget(
"delta_rayleigh_scattering_texture",
texture_type=Texture3D,
width=SCATTERING_TEXTURE_WIDTH,
height=SCATTERING_TEXTURE_HEIGHT,
depth=SCATTERING_TEXTURE_DEPTH,
internal_format=GL_RGBA32F,
texture_format=GL_RGBA,
min_filter=GL_LINEAR,
mag_filter=GL_LINEAR,
data_type=GL_FLOAT,
wrap=GL_CLAMP
)
self.delta_mie_scattering_texture = rendertarget_manager.create_rendertarget(
"delta_mie_scattering_texture",
texture_type=Texture3D,
width=SCATTERING_TEXTURE_WIDTH,
height=SCATTERING_TEXTURE_HEIGHT,
depth=SCATTERING_TEXTURE_DEPTH,
internal_format=GL_RGBA32F,
texture_format=GL_RGBA,
min_filter=GL_LINEAR,
mag_filter=GL_LINEAR,
data_type=GL_FLOAT,
wrap=GL_CLAMP
)
self.delta_scattering_density_texture = rendertarget_manager.create_rendertarget(
"delta_scattering_density_texture",
texture_type=Texture3D,
width=SCATTERING_TEXTURE_WIDTH,
height=SCATTERING_TEXTURE_HEIGHT,
depth=SCATTERING_TEXTURE_DEPTH,
internal_format=GL_RGBA32F,
texture_format=GL_RGBA,
min_filter=GL_LINEAR,
mag_filter=GL_LINEAR,
data_type=GL_FLOAT,
wrap=GL_CLAMP
)
self.delta_multiple_scattering_texture = self.delta_rayleigh_scattering_texture
positions = np.array([(-1, 1, 0, 1), (-1, -1, 0, 1), (1, -1, 0, 1), (1, 1, 0, 1)], dtype=np.float32)
indices = np.array([0, 1, 2, 0, 2, 3], dtype=np.uint32)
self.quad = VertexArrayBuffer(
name='precomputed atmosphere quad',
datas=[positions, ],
index_data=indices,
dtype=np.float32
)
def Precompute(self,
lambdas,
luminance_from_radiance,
blend,
num_scattering_orders):
resource_manager = CoreManager.instance().resource_manager
shader_loader = resource_manager.shader_loader
renderer = CoreManager.instance().renderer
shader_name = 'precomputed_atmosphere.compute_atmosphere_predefine'
compute_atmosphere_predefine = resource_manager.getShader(shader_name)
compute_atmosphere_predefine.shader_code = self.glsl_header_factory(lambdas)
shader_loader.save_resource(shader_name)
shader_loader.load_resource(shader_name)
glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD)
glBlendFuncSeparate(GL_ONE, GL_ONE, GL_ONE, GL_ONE)
self.quad.bind_vertex_buffer()
# compute_transmittance
renderer.framebuffer.set_color_textures(self.transmittance_texture)
renderer.framebuffer.set_depth_texture(None)
renderer.framebuffer.bind_framebuffer()
compute_transmittance_mi = resource_manager.getMaterialInstance(
'precomputed_atmosphere.compute_transmittance',
macros=self.material_instance_macros)
compute_transmittance_mi.use_program()
self.quad.draw_elements()
# compute_direct_irradiance
renderer.framebuffer.set_color_textures(self.delta_irradiance_texture, self.irradiance_texture)
renderer.framebuffer.set_depth_texture(None)
renderer.framebuffer.bind_framebuffer()
compute_direct_irradiance_mi = resource_manager.getMaterialInstance(
'precomputed_atmosphere.compute_direct_irradiance',
macros=self.material_instance_macros)
compute_direct_irradiance_mi.use_program()
compute_direct_irradiance_mi.bind_uniform_data('transmittance_texture', self.transmittance_texture)
if blend:
glEnablei(GL_BLEND, 1)
self.quad.draw_elements()
glDisablei(GL_BLEND, 0)
glDisablei(GL_BLEND, 1)
# compute_single_scattering
if self.optional_single_mie_scattering_texture is None:
renderer.framebuffer.set_color_textures(self.delta_rayleigh_scattering_texture,
self.delta_mie_scattering_texture,
self.scattering_texture)
renderer.framebuffer.set_depth_texture(None)
renderer.framebuffer.bind_framebuffer()
else:
renderer.framebuffer.set_color_textures(self.delta_rayleigh_scattering_texture,
self.delta_mie_scattering_texture,
self.scattering_texture,
self.optional_single_mie_scattering_texture)
renderer.framebuffer.set_depth_texture(None)
renderer.framebuffer.bind_framebuffer()
compute_single_scattering_mi = resource_manager.getMaterialInstance(
'precomputed_atmosphere.compute_single_scattering',
macros=self.material_instance_macros)
compute_single_scattering_mi.use_program()
compute_single_scattering_mi.bind_uniform_data('luminance_from_radiance', luminance_from_radiance)
compute_single_scattering_mi.bind_uniform_data('transmittance_texture', self.transmittance_texture)
for layer in range(SCATTERING_TEXTURE_DEPTH):
compute_single_scattering_mi.bind_uniform_data("layer", layer)
if blend:
glEnablei(GL_BLEND, 2)
glEnablei(GL_BLEND, 3)
self.quad.draw_elements()
glDisablei(GL_BLEND, 0)
glDisablei(GL_BLEND, 1)
glDisablei(GL_BLEND, 2)
glDisablei(GL_BLEND, 3)
return
for scattering_order in range(2, num_scattering_orders+1):
# compute_scattering_density
renderer.framebuffer.set_color_textures(self.delta_scattering_density_texture)
renderer.framebuffer.set_depth_texture(None)
renderer.framebuffer.bind_framebuffer()
compute_scattering_density_mi = resource_manager.getMaterialInstance(
'precomputed_atmosphere.compute_scattering_density',
macros=self.material_instance_macros)
compute_scattering_density_mi.use_program()
compute_scattering_density_mi.bind_uniform_data('transmittance_texture', self.transmittance_texture)
compute_scattering_density_mi.bind_uniform_data('single_rayleigh_scattering_texture',
self.delta_rayleigh_scattering_texture)
compute_scattering_density_mi.bind_uniform_data('single_mie_scattering_texture',
self.delta_mie_scattering_texture)
compute_scattering_density_mi.bind_uniform_data('multiple_scattering_texture',
self.delta_multiple_scattering_texture)
compute_scattering_density_mi.bind_uniform_data('irradiance_texture',
self.delta_irradiance_texture)
compute_scattering_density_mi.bind_uniform_data('scattering_order', scattering_order)
for layer in range(SCATTERING_TEXTURE_DEPTH):
compute_scattering_density_mi.bind_uniform_data('layer', layer)
self.quad.draw_elements()
# compute_indirect_irradiance
renderer.framebuffer.set_color_textures(self.delta_irradiance_texture,
self.irradiance_texture)
renderer.framebuffer.set_depth_texture(None)
renderer.framebuffer.bind_framebuffer()
compute_indirect_irradiance_mi = resource_manager.getMaterialInstance(
'precomputed_atmosphere.compute_indirect_irradiance',
macros=self.material_instance_macros)
compute_indirect_irradiance_mi.use_program()
compute_indirect_irradiance_mi.bind_uniform_data('luminance_from_radiance', luminance_from_radiance)
compute_indirect_irradiance_mi.bind_uniform_data('single_rayleigh_scattering_texture',
self.delta_rayleigh_scattering_texture)
compute_indirect_irradiance_mi.bind_uniform_data('single_mie_scattering_texture',
self.delta_mie_scattering_texture)
compute_indirect_irradiance_mi.bind_uniform_data('multiple_scattering_texture',
self.delta_multiple_scattering_texture)
compute_indirect_irradiance_mi.bind_uniform_data('scattering_order', scattering_order - 1)
if blend:
glEnablei(GL_BLEND, 1)
self.quad.draw_elements()
glDisablei(GL_BLEND, 0)
glDisablei(GL_BLEND, 1)
# compute_multiple_scattering
renderer.framebuffer.set_color_textures(self.delta_multiple_scattering_texture,
self.scattering_texture)
renderer.framebuffer.set_depth_texture(None)
renderer.framebuffer.bind_framebuffer()
compute_multiple_scattering_mi = resource_manager.getMaterialInstance(
'precomputed_atmosphere.compute_multiple_scattering',
macros=self.material_instance_macros)
compute_multiple_scattering_mi.use_program()
compute_multiple_scattering_mi.bind_uniform_data('luminance_from_radiance', luminance_from_radiance)
compute_multiple_scattering_mi.bind_uniform_data('transmittance_texture', self.transmittance_texture)
compute_multiple_scattering_mi.bind_uniform_data('scattering_density_texture',
self.delta_scattering_density_texture)
for layer in range(SCATTERING_TEXTURE_DEPTH):
compute_multiple_scattering_mi.bind_uniform_data('layer', layer)
if blend:
glEnablei(GL_BLEND, 1)
self.quad.draw_elements()
glDisablei(GL_BLEND, 0)
glDisablei(GL_BLEND, 1)
def glsl_header_factory(self, lambdas):
def to_string(v, lambdas, scale):
r = Interpolate(self.wavelengths, v, lambdas[0]) * scale
g = Interpolate(self.wavelengths, v, lambdas[1]) * scale
b = Interpolate(self.wavelengths, v, lambdas[2]) * scale
return "vec3(%f, %f, %f)" % (r, g, b)
def density_layer(layer):
return "DensityProfileLayer(%f, %f, %f, %f, %f)" % (layer.width / self.length_unit_in_meters,
layer.exp_term,
layer.exp_scale * self.length_unit_in_meters,
layer.linear_term * self.length_unit_in_meters,
layer.constant_term)
def density_profile(layers):
kLayerCount = 2
while len(layers) < kLayerCount:
layers.insert(0, DensityProfileLayer())
result = "DensityProfile(DensityProfileLayer[%d](" % kLayerCount
for i in range(kLayerCount):
result += density_layer(layers[i])
if i < kLayerCount - 1:
result += ","
else:
result += "))"
return result
sky_k_r, sky_k_g, sky_k_b = self.kSky[0], self.kSky[1], self.kSky[2]
sun_k_r, sun_k_g, sun_k_b = self.kSun[0], self.kSun[1], self.kSun[2]
resource_manager = CoreManager.instance().resource_manager
definitions_glsl = resource_manager.getShader('precomputed_atmosphere.definitions').shader_code
functions_glsl = resource_manager.getShader('precomputed_atmosphere.functions').shader_code
header = ["const int TRANSMITTANCE_TEXTURE_WIDTH = %d;" % TRANSMITTANCE_TEXTURE_WIDTH,
"const int TRANSMITTANCE_TEXTURE_HEIGHT = %d;" % TRANSMITTANCE_TEXTURE_HEIGHT,
"const int SCATTERING_TEXTURE_R_SIZE = %d;" % SCATTERING_TEXTURE_R_SIZE,
"const int SCATTERING_TEXTURE_MU_SIZE = %d;" % SCATTERING_TEXTURE_MU_SIZE,
"const int SCATTERING_TEXTURE_MU_S_SIZE = %d;" % SCATTERING_TEXTURE_MU_S_SIZE,
"const int SCATTERING_TEXTURE_NU_SIZE = %d;" % SCATTERING_TEXTURE_NU_SIZE,
"const int IRRADIANCE_TEXTURE_WIDTH = %d;" % IRRADIANCE_TEXTURE_WIDTH,
"const int IRRADIANCE_TEXTURE_HEIGHT = %d;" % IRRADIANCE_TEXTURE_HEIGHT,
definitions_glsl,
"const AtmosphereParameters ATMOSPHERE = AtmosphereParameters(",
to_string(self.solar_irradiance, lambdas, 1.0) + ",",
str(self.sun_angular_radius) + ",",
str(self.bottom_radius / self.length_unit_in_meters) + ",",
str(self.top_radius / self.length_unit_in_meters) + ",",
density_profile(self.rayleigh_density) + ",",
to_string(self.rayleigh_scattering, lambdas, self.length_unit_in_meters) + ",",
density_profile(self.mie_density) + ",",
to_string(self.mie_scattering, lambdas, self.length_unit_in_meters) + ",",
to_string(self.mie_extinction, lambdas, self.length_unit_in_meters) + ",",
str(self.mie_phase_function_g) + ",",
density_profile(self.absorption_density) + ",",
to_string(self.absorption_extinction, lambdas, self.length_unit_in_meters) + ",",
to_string(self.ground_albedo, lambdas, 1.0) + ",",
str(cos(self.max_sun_zenith_angle)) + ");",
"const vec3 SKY_SPECTRAL_RADIANCE_TO_LUMINANCE = vec3(%f, %f, %f);" % (sky_k_r, sky_k_g, sky_k_b),
"const vec3 SUN_SPECTRAL_RADIANCE_TO_LUMINANCE = vec3(%f, %f, %f);" % (sun_k_r, sun_k_g, sun_k_b),
functions_glsl]
return "\n".join(header)
def __parsing_final_code__(self,
shader_type_name,
shader_version,
external_macros={}):
if self.shader_code == "" or self.shader_code is None:
return ""
# remove comment block
shader_code = re.sub(reComment, "", self.shader_code)
code_lines = shader_code.splitlines()
# combine macro
combined_macros = OrderedDict()
# default macro
for macro in self.default_macros:
combined_macros[macro] = self.default_macros[macro]
# shader type macro
combined_macros[shader_type_name] = "1"
# external macro
if external_macros is None:
external_macros = {}
for macro in external_macros:
if external_macros[macro] is None or external_macros[macro] is '':
combined_macros[macro] = 0
else:
combined_macros[macro] = external_macros[macro]
# insert shader version - ex) #version 430 core
final_code_lines = [
shader_version,
]
# insert defines to final code
for macro in combined_macros:
final_code_lines.append("#define %s %s" %
(macro, str(combined_macros[macro])))
# insert version as comment
include_files = dict() # { 'filename': uuid }
resource_manager = CoreManager.instance().resource_manager
shader_file_dir = resource_manager.shader_loader.resource_path
# do parsing
line_num = 0
macro_depth = 0
macro_result = [
True,
]
macro_code_remove = True
while line_num < len(code_lines):
code = code_lines[line_num]
line_num += 1
# remove comment
if "//" in code:
code = code.split("//")[0]
# macro parsing
m = re.search(reMacroStart, code)
if m is not None:
macro, expression = m.groups()
expression = expression.strip()
if macro == 'define' or macro == 'undef':
define_expression = expression.split('(')[0].strip()
if ' ' in define_expression:
define_name, define_value = define_expression.split(
' ', 1)
else:
define_name, define_value = define_expression, None
# check external macro
if macro == 'define' and define_name in external_macros:
continue # ignore legacy macro
if macro == 'define' and define_name not in combined_macros:
combined_macros[define_name] = define_value
elif macro == 'undef' and define_name in combined_macros:
combined_macros.pop(define_name)
elif macro == 'ifdef':
macro_depth += 1
if expression in combined_macros:
macro_result.append(True)
else:
macro_result.append(False)
elif macro == 'ifndef':
macro_depth += 1
if expression not in combined_macros:
macro_result.append(True)
else:
macro_result.append(False)
elif macro == 'if' or macro == 'elif' and not macro_result[
macro_depth]:
variables = re.findall(reVariable, expression)
variables.sort(key=lambda x: len(x), reverse=True)
for variable in variables:
if variable in combined_macros:
while True:
final_value = combined_macros[variable]
if final_value not in combined_macros:
break
variable = final_value
expression = re.sub(reVariable, str(final_value),
expression, 1)
expression = expression.replace('&&', ' and ')
expression = expression.replace('||', ' or ')
# expression = re.sub('\!?!\=', 'not ', expression)
# Important : To avoid errors, convert the undecalred variables to zero.
expression = re.sub(reVariable, '0', expression)
result = True if eval(expression) else False
if macro == 'if':
macro_depth += 1
macro_result.append(result)
elif macro == 'elif':
macro_result[macro_depth] = result
elif macro == 'else':
macro_result[macro_depth] = not macro_result[macro_depth]
elif macro == 'endif':
macro_depth -= 1
macro_result.pop()
# be in failed macro block. continue
elif not macro_result[macro_depth]:
if not macro_code_remove:
# make comment
final_code_lines.append("// " + code)
continue
# is version code?
m = re.search(reVersion, code)
if m is not None:
version_code = m.groups()[0].strip()
if final_code_lines[
0] == "" or version_code > final_code_lines[0]:
final_code_lines[0] = version_code
continue
# find include block
m = re.search(reInclude, code)
if m is not None:
valid = True
include_file = os.path.join(shader_file_dir, m.groups()[0])
# insert include code
if os.path.exists(include_file):
try:
f = codecs.open(include_file,
mode='r',
encoding='utf-8')
include_source = f.read()
# remove comment block
include_source = re.sub(reComment, "", include_source)
include_code_lines = include_source.splitlines()
f.close()
except:
logger.error(traceback.format_exc())
valid = False
if valid:
if include_file in include_files:
unique_id = include_files[include_file]
else:
unique_id = "UUID_" + str(
uuid.uuid3(uuid.NAMESPACE_DNS,
include_file)).replace("-", "_")
include_files[include_file] = unique_id
if include_file not in self.include_files:
self.include_files.append(include_file)
# insert included code
final_code_lines.append(
"//------------ INCLUDE -------------//")
final_code_lines.append("// " +
code) # include comment
include_code_lines.insert(0, "#ifndef %s" % unique_id)
include_code_lines.insert(1, "#define %s" % unique_id)
include_code_lines.append("#endif /* %s */" %
unique_id)
code_lines = include_code_lines + code_lines[line_num:]
line_num = 0
if not valid:
logger.error("Cannot open %s file." % include_file)
continue
# append code block
final_code_lines.append(code)
return '\n'.join(final_code_lines)
def initialize(self):
core_manager = CoreManager.instance()
resource_manager = core_manager.resource_manager