def __init__(self, width, height):
super().__init__(width, height)
self.environment_image = assets.imread(
'hdri/Tropical_Beach_3k.hdr').astype(np.float32)
self.environment_image = assets.to_linear(self.environment_image)
# init passes
self.geometry_pass = GeometryPass(self.width, self.height)
self.environment_pass = EnvironmentPass(512, 512)
self.irradiance_pass = IrradiancePass(32, 32)
self.prefilter_pass = PrefilterPass(128, 128)
self.brdf_pass = BRDFPass(512, 512)
self.lighting_pass = PBRLightingPass(self.width, self.height)
self.tonemapping_pass = TonemappingPass(self.width, self.height)
self.clamp_pass = ClampPass(self.width, self.height)
self.gaussianblur_pass = GaussianblurPass(self.width, self.height)
self.add_pass = AddPass(self.width, self.height)
self.skybox_pass = SkyboxPass(self.width, self.height)
self.environment_texture = None
self.environment_cubemap = None
self.irradiance_cubemap = None
self.prefilter_cubemap = None
self.brdf_texture = None
def __init__(self):
self.width = 1024
self.height = 768
self.window = GLFWViewer(self.width, self.height, (0.2, 0.2, 0.2, 1.0))
self.matcap_img = assets.imread("matcap/jeepster_skinmat2.jpg").astype(
np.float32) / 255
# self.matcap_img = assets.imread("container2_axis.png").astype(np.float32)[...,[0,1,2]]/255
self.matcap_img = np.flip(self.matcap_img, 0)
def __init__(self, scene):
# window
self.width = 1024
self.height = 768
self.window = GLFWViewer(self.width, self.height, (0.2, 0.2, 0.2, 1.0))
self.camera = PerspectiveCamera(glm.inverse(self.window.view_matrix),
glm.radians(60),
self.width / self.height, 1, 30)
self.scene = scene
# assets
self.environment_image = assets.imread('hdri/Tropical_Beach_3k.hdr')
self.environment_image = assets.to_linear(self.environment_image)
# render passes
self.environment_pass = EnvironmentPass(512, 512)
self.irradiance_pass = IrradiancePass(32, 32)
self.prefilter_pass = PrefilterPass()
self.brdf_pass = BRDFPass(512, 512)
self.tonemapping_pass = TonemappingPass(self.width, self.height)
self.geometry_pass = GeometryPass(self.width, self.height,
self.draw_scene_for_geometry)
dirlight.shadowpass = DepthPass(1024, 1024, GL_FRONT,
self.draw_scene_for_shadows)
spotlight.shadowpass = DepthPass(1024, 1024, GL_FRONT,
self.draw_scene_for_shadows)
pointlight.shadowpass = CubeDepthPass(
512,
512,
GL_FRONT,
near=1,
far=15,
draw_scene=self.draw_scene_for_shadows)
self.lighting_pass = LightingPass(
self.width, self.height, lights=[dirlight, spotlight, pointlight])
imdraw.quad(self.program)
if first_iteration:
first_iteration = False
glBindFramebuffer(GL_FRAMEBUFFER, 0)
return self.bloom_blur_texs[1]
if __name__ == "__main__":
from editor.render.graphics.examples.viewer import Viewer
from editor.render import assets
import glm
import numpy as np
# load assets
img = (assets.imread("container2.png")[..., :3] / 255).astype(np.float32)
h, w, c = img.shape
# create viewer
viewer = Viewer(1024, 512, "GaussianBlur example")
blurpass = GaussianblurPass(viewer.width, viewer.height)
@viewer.event
def on_setup():
global tex
tex = glGenTextures(1)
glBindTexture(GL_TEXTURE_2D, tex)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB32F, w, h, 0, GL_RGB, GL_FLOAT,
img)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glGenerateMipmap(GL_TEXTURE_2D)
color=glm.vec3(0.04, 0.6, 1.0),
intensity=150.0,
fov=60,
near=1,
far=15)
scene.add_child(spotlight)
pointlight = PointLight(position=glm.vec3(2.5, 1.3, 2.5),
color=glm.vec3(1, 0.7, 0.1),
intensity=50.0,
near=0.1,
far=10)
scene.add_child(pointlight)
environment_image = assets.to_linear(
assets.imread("hdri/Tropical_Beach_3k.hdr"))
# Create Viewer
viewer = Viewer(title="Simple PBR with Shadows Example")
# Create render pipeline
geometry_pass = GeometryPass(viewer.width, viewer.height)
environment_pass = EnvironmentPass(512, 512)
irradiance_pass = IrradiancePass(32, 32)
prefilter_pass = PrefilterPass(128, 128)
brdf_pass = BRDFPass(512, 512)
lighting_pass = PBRLightingPass(viewer.width, viewer.height)
skybox_pass = SkyboxPass(viewer.width, viewer.height)
tonemapping_pass = TonemappingPass(viewer.width, viewer.height)
clamp_pass = ClampPass(viewer.width, viewer.height)
gaussianblur_pass = GaussianblurPass(viewer.width, viewer.height)
return self.texture
if __name__ == "__main__":
from editor.render.graphics.passes import GeometryPass
from editor.render.graphics.passes import EnvironmentPass
from editor.render.graphics.passes import IrradiancePass, PrefilterPass, BRDFPass
import glm
from editor.render.graphics import Scene, Mesh, Geometry, Material
from editor.render.graphics.examples.viewer import Viewer
viewer = Viewer()
# assets
environment_image = assets.imread('hdri/Tropical_Beach_3k.hdr').astype(
np.float32)
# scene
scene = Scene()
scene.add_child(
Mesh(transform=glm.translate(glm.mat4(1), (0.0, 0.5, 0.0)),
geometry=Geometry(*imdraw.geo.sphere()),
material=Material(albedo=glm.vec3(0.5),
emission=(0, 0, 0),
roughness=glm.pow(0.5, 2),
metallic=0.0)))
scene.add_child(Mesh(geometry=Geometry(*imdraw.geo.plane())))
dirlight = DirectionalLight(direction=glm.vec3(1, -6, -2),
color=glm.vec3(1.0),
intensity=1.0,
glActiveTexture(GL_TEXTURE0 + 1)
glBindTexture(GL_TEXTURE_2D, inputB)
puregl.program.set_uniform(prog, 'inputA', 0)
puregl.program.set_uniform(prog, 'inputB', 1)
imdraw.quad(prog)
return self.output_texture
if __name__ == "__main__":
import numpy as np
from editor.render import assets
from editor.render.graphics.examples.viewer import Viewer
imgA = assets.imread("peppers.png").astype(np.float32)[..., :3] / 255
imgB = assets.imread("Sailboat on lake.png").astype(
np.float32)[..., :3] / 255
addpass = AddPass(512, 512)
viewer = Viewer()
@viewer.event
def on_setup():
global texA
texA = glGenTextures(1)
glBindTexture(GL_TEXTURE_2D, texA)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB32F, imgA.shape[1], imgA.shape[0],
0, GL_RGB, GL_FLOAT, imgA)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
glActiveTexture(GL_TEXTURE0+0)
glBindTexture(GL_TEXTURE_2D, input_texture)
puregl.program.set_uniform(prog, 'screenTexture', 0)
puregl.program.set_uniform(prog, 'minimum', float(minimum))
puregl.program.set_uniform(prog, 'maximum', float(maximum))
imdraw.quad(prog)
return self.output_texture
if __name__ == "__main__":
import numpy as np
from editor.render import assets
from editor.render.graphics.examples.viewer import Viewer
imgA = assets.imread("peppers.png").astype(np.float32)[...,:3]/255
clamppass = ClampPass(512, 512)
viewer = Viewer()
@viewer.event
def on_setup():
global texA
texA = glGenTextures(1)
glBindTexture(GL_TEXTURE_2D, texA)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB32F, imgA.shape[1], imgA.shape[0], 0, GL_RGB, GL_FLOAT, imgA)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
glBindTexture(GL_TEXTURE_2D, 0)
@viewer.event
#
# read assets
#
assets_folder = "../assets"
def to_srgb(img, gamma=2.2):
return np.power(img, (1 / gamma, 1 / gamma, 1 / gamma))
def to_linear(img, gamma=2.2):
return np.power(img, (gamma, gamma, gamma))
# textures
diffuse_data = assets.imread('container2_axis.png')[..., [2, 1, 0]] / 255
specular_data = assets.imread('container2_specular.png')[..., [2, 1, 0]] / 255
diffuse_data = to_linear(diffuse_data)
specular_data = to_linear(specular_data)
# environment
environment_data = assets.imread('hdri/fin4_Ref.hdr')
environment_data *= 1
with window:
glEnable(GL_PROGRAM_POINT_SIZE)
glEnable(GL_DEPTH_TEST)
glEnable(GL_CULL_FACE)
# Create shading programs
# =======================
# attach cubemap to fbo depth attachment
with fbo.bind(pointlight_shadowfbo):
glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
pointlight_shadowcube, 0)
glDrawBuffer(GL_NONE)
glReadBuffer(GL_NONE)
assert glCheckFramebufferStatus(
GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE
# create shader
point_shadow_program = program.create(*glsl.read("point_shadow"))
# Environment pass
# ----------------
## Create environment texture
environment_data = assets.imread('hdri/Tropical_Beach_3k.hdr')
environment_data = assets.to_linear(environment_data)
env_height, env_width, env_channels = environment_data.shape
environment_tex = glGenTextures(1)
glBindTexture(GL_TEXTURE_2D, environment_tex)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB32F, env_width, env_height, 0, GL_RGB,
GL_FLOAT, environment_data)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
## Capture environment map to cubemap
# create cubemap texture
env_cubemap = glGenTextures(1)
puregl.program.set_uniform(prog, 'screenTexture', 0)
puregl.program.set_uniform(prog, 'bloomBlur', 1)
puregl.program.set_uniform(prog, 'exposure', exposure)
puregl.program.set_uniform(prog, 'gamma', gamma)
imdraw.quad(prog)
return self.texture
if __name__ == "__main__":
from editor.render.graphics.examples.viewer import Viewer
from editor.render import assets, imdraw
viewer = Viewer(1024, 512)
img = assets.imread("house.png")[...,:3]/255
h,w,c = img.shape
tonepass = TonemappingPass(w, h)
@viewer.event
def on_setup():
global tex
tex = glGenTextures(1)
glBindTexture(GL_TEXTURE_2D, tex)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB32F, h, w, 0, GL_RGB, GL_FLOAT, img)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
glBindTexture(GL_TEXTURE_2D, 0)
@viewer.event
def __init__(self, width, height):
super().__init__(width, height, True, GL_BACK)
self.geometry_pass = GeometryPass(self.width, self.height)
self.matcap_pass = MatcapLightingPass(self.width, self.height)
self.matcap_image = assets.imread("matcap/jeepster_skinmat2.jpg").astype(np.float32)[..., :3]/255
self.matcap_texture = None
