def __init__(self, textureID, length, fragShaderNames):
'''
Constructor
texture - a texture object to reduce on TODO: OR A FBO???
fragShaderNames - an iterable container of fragment shader names to reduce on
'''
# Set up input texture
self._inputID = textureID
self._length = length
# Set up maximum buffer level (one below level of texture, where length = 2^level)
self._bufferLevel = int(math.log(length,2))
# Set up shaders
self._shaders = list()
for frag in fragShaderNames:
self._shaders.append(Shader(frag,"DoNothing"))
self._outputs = np.zeros((len(self._shaders),2))
# Generates a FBO handler
self._frameBuffer = c_uint(0)
glGenFramebuffers(1, self._frameBuffer)
# Make quad display list to draw to
self._quadList = glGenLists(1)
# Levels to use (leave empty for now)
self._levels = None
# Initialise (yes, I know, functional code in a constructor)
self._Init()
def init(self):
glClearColor(0.0, 0.0, 0.0, 1.0) # 设置画布背景色。注意：这里必须是4个参数
glEnable(GL_DEPTH_TEST) # 开启深度测试，实现遮挡关系
glDepthFunc(GL_LEQUAL) # 设置深度测试函数（GL_LEQUAL只是选项之一）
folderPath = os.path.dirname(os.path.abspath(__file__))
self.shader = Shader(os.path.join(folderPath, "vertex.glsl"),
os.path.join(folderPath, "fragment.glsl"))
def Build(self, points,pointSizes=None):
# Make billboarding shader
self._shader = Shader("Billboard")
# Make display list
self._points = points
self._displayList = glGenLists(1)
glNewList(self._displayList,GL_COMPILE)
c = 0.005
c0 = np.array([-c,-c,0])
c1 = np.array([-c,+c,0])
c2 = np.array([+c,+c,0])
c3 = np.array([+c,-c,0])
glBegin(GL_TRIANGLES)
for it in self._points:
glVertex3fv(it+c0)
glVertex3fv(it+c1)
glVertex3fv(it+c2)
glVertex3fv(it+c0)
glVertex3fv(it+c2)
glVertex3fv(it+c3)
glEnd()
glEndList()
def Build(self, points):
# Make billboarding shader
self._shader = Shader("PointSpriteScaler")
# Make the billboarding texture
texSize = 16
im = GaussianImage(texSize)
self._texture = glGenTextures(1)
glEnable(GL_TEXTURE_2D)
glBindTexture(GL_TEXTURE_2D, self._texture)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, texSize, texSize, 0,
GL_RGBA, GL_FLOAT, im)
glBindTexture(GL_TEXTURE_2D, 0)
glEnable(GL_POINT_SMOOTH)
glEnable(GL_PROGRAM_POINT_SIZE)
# Make display list
self._points = points
self._displayList = glGenLists(1)
glNewList(self._displayList, GL_COMPILE)
glBegin(GL_POINTS)
for it in self._points:
glVertex3fv(it)
glEnd()
glEndList()
def initializeGL(self):
glClearColor(0.0, 0.0, 0.0, 1.0)
glClearDepth(1.0)
domeStr = "CanvasModel.Dome"
self.shaders[domeStr + "_proj"] = Shader("shaders/dome_proj.vert",
"shaders/dome_4proj.frag")
self.shaders[domeStr + "_edgeblend"] = Shader(
"shaders/dome_edgeblend.vert", "shaders/dome_edgeblend_4proj.frag")
self.shaders[domeStr + "_inv_proj"] = Shader(
"shaders/dome_inv_proj.vert", "shaders/dome_inv_proj.frag")
# cycloramaStr = "CanvasModel.Cyclorama"
# self.shaders[cycloramaStr+"_proj"] = Shader("shaders/cyclorama_proj.vert","shaders/dome_proj.frag")
# self.shaders[cycloramaStr+"_edgeblend"] = Shader("shaders/cyclorama_edgeblend.vert","shaders/cyclorama_edgeblend.frag")
# self.shaders[cycloramaStr+"_inv_proj"] = Shader("shaders/dome_inv_proj.vert","shaders/dome_inv_proj.frag")
for textureFile in self.textureFiles:
texFile = os.path.join(TEXTURE_PATH, textureFile)
self.textures[textureFile[:-4]] = Texture(texFile)
def __init__(self, file_name):
global active_camera
self.models = None
self.cameras = None
self.lights = None
self.active_camera = active_camera
# shared resources
self.textures = {} # name -> tex lookup
self.shaders = {} # name -> tex lookup
self.meshes = {} # name -> tex lookup
with open(file_name, "r") as fp:
data = json.load(fp)
# models
self.models = {name: Model(m) for (name, m) in data["models"].items()}
for model in self.models.values():
vert_file = model.io['shader']['vert']
frag_file = model.io['shader']['frag']
shader_name = vert_file.split('.')[0]
shader = ResourceManager.get_shader(shader_name)
if not shader:
shader = Shader(vert_file, frag_file)
ResourceManager.add_shader(shader_name, shader)
model.shader = shader
mesh_name = model.io['mesh'] # contains relative path string
mesh = ResourceManager.get_mesh(mesh_name)
if not mesh:
mesh = Mesh(mesh_name)
ResourceManager.add_mesh(mesh_name, mesh)
model.mesh = mesh
tex_files = model.io['textures']
for (layer, tex_file) in tex_files.items():
tex = ResourceManager.get_texture(tex_file)
if not tex:
tex = Texture(tex_file)
ResourceManager.add_texture(tex_file, tex)
model.textures[layer] = tex
# cameras, set first camera to active
self.cameras = {
name: Camera(c)
for (name, c) in data["cameras"].items()
}
if len(self.cameras) > 0:
# get first items value
active_camera = next(iter(self.cameras.items()))[1]
logging.warn('camera needs to set shader uniforms')
# lights
self.lights = {name: Light(l) for (name, l) in data["lights"].items()}
logging.warn('light needs to set shader uniforms')
class PointRendererBillboard_Impl1(PointRenderer):
'''
classdocs
'''
def __init__(self):
'''
Constructor
'''
self._points = None
self._displayList = 0
self._name = "PointRenderBillboard"
self._shader = None
def Name(self):
return self._name
def Weight(self, weight):
self._weight = weight
def Build(self, points,pointSizes=None):
# Make billboarding shader
self._shader = Shader("Billboard")
# Make display list
self._points = points
self._displayList = glGenLists(1)
glNewList(self._displayList,GL_COMPILE)
c = 0.005
c0 = np.array([-c,-c,0])
c1 = np.array([-c,+c,0])
c2 = np.array([+c,+c,0])
c3 = np.array([+c,-c,0])
glBegin(GL_TRIANGLES)
for it in self._points:
glVertex3fv(it+c0)
glVertex3fv(it+c1)
glVertex3fv(it+c2)
glVertex3fv(it+c0)
glVertex3fv(it+c2)
glVertex3fv(it+c3)
glEnd()
glEndList()
def Draw(self):
glColor4f(1.0,0.0,1.0,0.4)
shaders.glUseProgram(self._shader.Shader())
glCallList(self._displayList)
shaders.glUseProgram(0)
def __init__(self, attributes, bone_nodes, bone_offsets, index=None):
# setup shader attributes for linear blend skinning shader
self.vertex_array = VertexArray(attributes, index)
# feel free to move this up in Viewer as shown in previous practicals
self.skinning_shader = Shader(SKINNING_VERT, COLOR_FRAG)
# store skinning data
self.bone_nodes = bone_nodes
self.bone_offsets = bone_offsets
def setup(self):
self.shader = Shader("vertex.vs", "fragment.fs")
self.object = OpenGLObject("box")
self.object.vbo.data = [ 0.5, 0.5, 0.0, -0.5, 0.5, 0.0, -0.5, -0.5, 0.0, 0.5, -0.5, 0.0 ]
self.object.ebo.data = [ 0, 1, 2, 0, 2, 3 ]
self.object.loadData()
def __init__(self):
self.vao = glGenVertexArrays(1)
glBindVertexArray(self.vao)
self.vertexSize = 15
self.NewBuffer = VertexBuffer(self.vertexSize)
self.buffer = self.NewBuffer.buffer
self.NewIndex = IndexBuffer()
self.ibo = self.NewIndex.buffer
self.NewShader = Shader()
self.program = ctypes.c_uint
self.Identity4 = numpy.array(
[1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1], dtype='float32')
def createShaders(self):
self.makeCurrent()
sh = Shader()
nSh = len(sh.shaderCodes)
for i in range(0, nSh):
prg = QGLShaderProgram(self.context())
prg.addShaderFromSourceCode(QGLShader.Fragment, sh.shaderCodes[i])
prg.link()
self.shadePrograms.append(prg)
self.doneCurrent()
def Init(self, frameBuffer):
if not self._prepared:
self._frameBuffer = frameBuffer
# Set up shaders
#self._incShader = Shader("IncrementBuffer")
self._logShader = Shader(self._shaderName)
size = max(self._frameBuffer.Width(), self._frameBuffer.Height())
size = 2.0**int(np.log2(size) + 1)
self._reduction = ReductionShader(self._frameBuffer.Texture(),
size, ["ReduceMaxMin"])
self._prepared = True
def __init__(self, lightDirection):
super().__init__()
# Tronc
cylindre = load("Utils/cylinder.obj")[0]
cylindre.shader = Shader(TRONC_VERT, TRONC_FRAG)
# self.add(cylindre)
# self.add(Rocher(lightDirection))
self.cylindre = cylindre
feuilles = Rocher(lightDirection,
complexite_rocher=3,
intensite_reduction_longueur=4,
taille_initiale_rayon=2,
color=[0.3, 0.7, 0.3],
borne_intensite=0.4)
noeud = Node(children=[feuilles],
transform=translate(feuilles.centre[0] - 1.5,
feuilles.centre[1] + 1.5,
feuilles.centre[2] - 3))
noeud2 = Node(children=[cylindre], transform=scale(0.2, 2, 0.2))
self.add(noeud)
self.add(noeud2)
self.shader = Shader(ARBRE_VERT, ARBRE_FRAG)
self.lightDirection = lightDirection
def __init__(self, texture, attributes, indices):
self.vertex_array = VertexArray(attributes, indices)
self.shader = Shader(TEXTURE_FILE_VERT, TEXTURE_FILE_FRAG)
# interactive toggles
self.wrap = cycle([GL.GL_REPEAT, GL.GL_MIRRORED_REPEAT,
GL.GL_CLAMP_TO_BORDER, GL.GL_CLAMP_TO_EDGE])
self.filter = cycle([(GL.GL_NEAREST, GL.GL_NEAREST),
(GL.GL_LINEAR, GL.GL_LINEAR),
(GL.GL_LINEAR, GL.GL_LINEAR_MIPMAP_LINEAR)])
self.wrap_mode, self.filter_mode = next(self.wrap), next(self.filter)
self.file = texture
# setup texture and upload it to GPU
self.texture = Texture(texture, self.wrap_mode, *self.filter_mode)
self.pressable = [False, False] #C MOI KI LA FE CLOCHETEU
def __init__(self,
lightDirection,
complexite_rocher=6,
seuilChangement=0,
taille_initiale_rayon=2,
intensite_reduction_longueur=3,
height_spike=0.5,
color=[0.4, 0.4, 0.4],
borne_intensite=0.2):
super().__init__()
rocher_array, normales, centre = createRandomRockIterative(
complexite_rocher, seuilChangement, taille_initiale_rayon,
intensite_reduction_longueur, borne_intensite)
self.vertex_array = VertexArray(attributes=[rocher_array, normales])
self.shader = Shader(ROCHER_VERT, ROCHER_FRAG)
self.lightDirection = lightDirection
self.centre = centre
self.color = color
def __init__(self):
# feel free to move this up in the viewer as per other practicals
self.shader = Shader(TEXTURE_VERT, TEXTURE_FRAG)
# triangle and face buffers
vertices = 100 * np.array(((-1, -1, 0), (1, -1, 0), (1, 1, 0), (-1, 1, 0)), np.float32)
faces = np.array(((0, 1, 2), (0, 2, 3)), np.uint32)
self.vertex_array = VertexArray([vertices], faces)
# interactive toggles
self.wrap = cycle([GL.GL_REPEAT, GL.GL_MIRRORED_REPEAT,
GL.GL_CLAMP_TO_BORDER, GL.GL_CLAMP_TO_EDGE])
self.filter = cycle([(GL.GL_NEAREST, GL.GL_NEAREST),
(GL.GL_LINEAR, GL.GL_LINEAR),
(GL.GL_LINEAR, GL.GL_LINEAR_MIPMAP_LINEAR)])
self.wrap_mode, self.filter_mode = next(self.wrap), next(self.filter)
# setup texture and upload it to GPU
self.texture = TexturePerlin(self.wrap_mode, *self.filter_mode)
self.pressable = [False, False] #C MOI KI LA FE CLOCHETEU
def __init__(self, width=640, height=480):
# version hints: create GL window with >= OpenGL 3.3 and core profile
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, GL.GL_TRUE)
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
glfw.window_hint(glfw.RESIZABLE, True)
self.win = glfw.create_window(width, height, 'Viewer', None, None)
# make win's OpenGL context current; no OpenGL calls can happen before
glfw.make_context_current(self.win)
# register event handlers
glfw.set_key_callback(self.win, self.on_key)
glfw.set_window_size_callback(self.win, self.on_resize)
# useful message to check OpenGL renderer characteristics
print(
'OpenGL',
GL.glGetString(GL.GL_VERSION).decode() + ', GLSL',
GL.glGetString(GL.GL_SHADING_LANGUAGE_VERSION).decode() +
', Renderer',
GL.glGetString(GL.GL_RENDERER).decode())
# initialize GL by setting viewport and default render characteristics
GL.glClearColor(0.1, 0.1, 0.1, 0.1)
GL.glEnable(GL.GL_DEPTH_TEST) # depth test now enabled (TP2)
GL.glEnable(GL.GL_CULL_FACE) # backface culling enabled (TP2)
# compile and initialize shader programs once globally
# self.color_shader = Shader(COLOR_VERT, COLOR_FRAG)
# print(COLOR_VERT)
self.lighting_shader = Shader(PHONG_VERT, PHONG_FRAG)
# initially empty list of object to draw
self.drawables = []
self.trackball = GLFWTrackball(self.win)
# cyclic iterator to easily toggle polygon rendering modes
self.fill_modes = cycle([GL.GL_LINE, GL.GL_POINT, GL.GL_FILL])
def __init__(self):
self.context = Context.getInstance() # NOTE must be initialized
self.logger = logging.getLogger(__name__)
self.windowWidth = 640
self.windowHeight = 480
self.initialize()
self.colorShader = Shader(
self.context.getResourcePath('shaders', 'ADS.vert'),
self.context.getResourcePath('shaders', 'ADS.frag'))
self.proj = hm.perspective(hm.identity(), 35,
float(self.windowWidth) / self.windowHeight,
1.0, 1000.0)
self.view = hm.lookat(
hm.identity(), np.array([0.0, 0.0, 0.0, 1.0], dtype=np.float32),
np.array([0.0, 0.0, 1.0, 1.0], dtype=np.float32),
np.array([0.0, -1.0, 0.0, 1.0], dtype=np.float32))
self.cameraMatrix = np.dot(self.proj, self.view)
self.setCameraMatrix(self.cameraMatrix)
def __init__(self,
nom_image,
light_direction,
longueur_arrete=0.5,
translate_x=0,
translate_y=0,
translate_z=0,
scale_total=1):
super().__init__()
matrice_image = misc.imread(nom_image)
self.terrain_array, self.normales = generateTerrainFromImage(
matrice_image, longueur_arrete, translate_x, translate_y,
translate_z, scale_total)
self.x_terrain = sorted([v[0] for v in self.terrain_array])
self.z_terrain = sorted([v[2] for v in self.terrain_array])
self.height_for_2d_position = {(v[0], v[2]): v[1]
for v in self.terrain_array}
self.vertex_array = VertexArray(
attributes=[self.terrain_array, self.normales])
self.shader = Shader(TERRAIN_VERT, TERRAIN_FRAG)
self.light_direction = light_direction
self.translation_y = translate_y
self.scale = scale_total
def __init__(self, lightDirection):
rocher_array, normales = essaiTriangleTriforce()
self.vertex_array = VertexArray(attributes=[rocher_array, normales])
self.shader = Shader(TRI_VERT, TRI_FRAG)
self.lightDirection = lightDirection
def set_shader_indirect(self, vert_shader, frag_shader):
self.shader = Shader(vert_shader, frag_shader)
def __init__(self, attributes, index=None):
self.vertex_array = VertexArray(attributes, index)
self.shader = Shader(COLOR_VERT_POS, COLOR_FRAG_POS)
def main():
res = (2600,1800)
n_particles = 1500 # Number of bodies. My computer runs 2000 pretty comfortably.
cam = Camera(fov=80,
aspect_ratio=res[0]/res[1],
xyz=(0,0,-10))
torch_nbody = torch_NBody(n_particles,
damping=0.10, # Prevent bodies from hitting lightspeed when they get too close
G=.05, # Gravity strength
spread=3.0, # Place bodies in a normal distribution with this standard deviation
mass_pareto=1.9, # The masses of the bodies follow this Pareto distribution
velocity_spread=0.5, # Initial velocity vectors are normally distributed with this standard deviation
dtype=torch.cuda.FloatTensor)
if not glfw.init():
return
window = glfw.create_window(res[0], res[1], "", None, None)
if not window:
glfw.terminate()
return
glfw.make_context_current(window)
glEnable(GL_DEPTH_TEST)
glClearColor(0.0,0.0,0.0,1.0)
shader = Shader()
shader.use()
shader.view = cam.matrix
model = Model("sphere.obj", center=True)
model.use(shader.position)
m = model.n_indices
buffer_translate = glGenBuffers(1)
buffer_scale = glGenBuffers(1)
buffer_brightness = glGenBuffers(1)
glBindBuffer(GL_SHADER_STORAGE_BUFFER, buffer_scale)
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, shader.obj_scale, buffer_scale)
scale = np.array(0.03 * (torch_nbody.mass.cpu().view(-1) * .75 / np.pi).pow(1/3).to(torch.float32).numpy())
glBufferData(GL_SHADER_STORAGE_BUFFER, 4 * n_particles, scale, GL_DYNAMIC_DRAW)
glBindBuffer(GL_SHADER_STORAGE_BUFFER, buffer_translate)
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, shader.obj_translate, buffer_translate)
exposure = 200.0
while not glfw.window_should_close(window):
glfw.poll_events()
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
torch_nbody.step(0.01)
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, shader.obj_translate, buffer_translate)
translate = torch_nbody.position.cpu().view(-1).to(torch.float32).numpy()
glBufferData(GL_SHADER_STORAGE_BUFFER, 4 * len(translate), translate, GL_DYNAMIC_DRAW)
# Example visualization
brightness = torch_nbody.a.norm(dim=1)
exposure = exposure * 0.98 + brightness.max() * 0.02
brightness /= exposure
brightness = 0.2 + 0.9 * brightness
brightness = brightness.cpu().view(-1).to(torch.float32).numpy()
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, shader.obj_brightness, buffer_brightness)
glBufferData(GL_SHADER_STORAGE_BUFFER, 4 * len(brightness), brightness, GL_DYNAMIC_DRAW)
glDrawElementsInstanced(GL_TRIANGLES, 3 * m, GL_UNSIGNED_INT, None, n_particles)
glfw.swap_buffers(window)
glfw.terminate()
def __init__(self, mesh):
self.mesh = mesh
self.mesh.shader = Shader(TEXTURE_VERT, TEXTURE_FRAG)
# setup texture and upload it to GPU
self.texture = TexturePerlin(GL.GL_REPEAT)
def Init(self):
if not self._prepared:
# Set up shaders
self._shader = Shader(self._shaderName)
self._prepared = True
if __name__ == "__main__":
import sys
sys.path.append("../")
# import models
from PIL import Image, ImageOps
import imageio
import torchvision.transforms
import os
decomposer = Decomposer()
decomposer.load_state_dict(torch.load("saved/decomposer/state.t7"))
shader = Shader()
shader.load_state_dict(torch.load("saved/shader/state.pth"))
composer_path = "/home/ab2383/intrinsics-network/saved/composer/state.t7"
composer = Composer(decomposer, shader)
composer = composer.cuda()
composer.load_state_dict(torch.load(composer_path))
print("Composer Built")
# folders = ["00277", "00339", "00267"]
# base_path = "/phoenix/S3/ab2383/data/TikTok_dataset/"
save_path = "/home/ab2383/intrinsics-network/"
# for folder in folders:
# imgs_path = base_path + folder + "/images/"
# masks_path = base_path + folder + "/masks/"
# for img in os.listdir(imgs_path):
current_second = glfw.GetTime()
elapsed_seconds = current_second - previous_second
if elapsed_seconds > 1.0:
previous_second = current_second
fps = float(frame_count) / float(elapsed_seconds)
glfw.SetWindowTitle(window, '%s @ FPS: %.2f' % (window_title, fps))
frame_count = 0.0
frame_count += 1.0
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE)
glDisable(GL_STENCIL_TEST)
glDisable(GL_BLEND)
glDisable(GL_CULL_FACE)
glClearColor(0.0, 0.0, 0.0, 0.0)
screen_shader = Shader('shader/screen_shader.vs', 'shader/screen_shader.frag')
screen_shader.compile(); screen_shader.use()
color_shader = Shader('shader/color_shader.vs', 'shader/color_shader.frag')
color_shader.compile(); color_shader.use()
raw_im = np.zeros((480,640,3), dtype=np.uint8)
def createFramebuffer(W, H, samples):
tex = np.empty(3, dtype=np.uint32)
if samples == 1:
glCreateTextures(GL_TEXTURE_2D, len(tex), tex)
glTextureStorage2D(tex[0], 1, GL_RGB8, W, H)
glTextureParameteri(tex[0], GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glTextureParameteri(tex[0], GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glTextureStorage2D(tex[1], 1, GL_DEPTH_COMPONENT32F, W, H)
def loadShader(self):
if self.vertexFile and self.fragmentFile:
self.shader = Shader(self.vertexFile, self.fragmentFile)
self.lastEdit = os.stat(self.fragmentFile).st_mtime
mesh1 = Mesh("resources/meshes/tetra3_p_n_uv1.ply")
mesh1.load()
mesh1.create()
mesh1_mat = pyrr.matrix44.create_from_translation(pyrr.Vector3([0, 0, 2]))
mesh2 = Mesh("resources/meshes/plane2_p_n_uv1.ply")
mesh2.load()
mesh2.create()
mesh2_mat = pyrr.matrix44.create_from_translation(pyrr.Vector3([0, 0, 0]))
# mesh3 = Mesh("resources/meshes/Dragon.ply")
# mesh3.load()
# mesh3.create()
# mesh3_mat = pyrr.matrix44.create_from_translation(pyrr.Vector3([2, 1, .5]))
shader1 = Shader("resources/shaders/shader1.vs", "resources/shaders/shader1.fs")
shader1.load()
shader1.create()
# shader1.use() # needed
tex1 = Texture("resources/images/marble.jpg")
tex1.load()
tex1.create()
tex2 = Texture("resources/images/brickwall.jpg")
tex2.load()
tex2.create()
tex3 = Texture("resources/images/StoneMarbleCalacatta004_COL_2K.jpg")
tex3.load()
tex3.create()
def Init(self, display):
if not self._prepared:
# Set up image
self._width, self._height = display.Window().get_size()
# Set up empty texture to draw to
#self._texture = glGenTextures(1)
self._texture = ctypes.c_uint(0)
glGenTextures(1, self._texture)
#self._texture = pyglet.image.Texture.create(self._width, self._height, rectangle=True,internalformat=GL_RGBA32F_ARB)
glEnable(GL_TEXTURE_2D)
glBindTexture(GL_TEXTURE_2D, self._texture)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
#glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0)
glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0)
glPixelStorei(GL_UNPACK_SKIP_ROWS, 0)
#glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, self._width, self._height, 0,\
# GL_RGBA, GL_FLOAT, 0)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F_ARB, self._width, self._height, 0,\
GL_RGBA, GL_FLOAT, 0)
glBindTexture(GL_TEXTURE_2D, 0)
# Set up the frame buffer object
self._frame = ctypes.c_uint(0)
glGenFramebuffers(1, self._frame)
#self._frame = glGenFramebuffers(1)
glBindFramebuffer(GL_FRAMEBUFFER, self._frame)
# Set up the depth buffer
#self._depth = glGenRenderbuffers(1)
self._depth = ctypes.c_uint(0)
glGenRenderbuffers(1, self._depth)
glBindRenderbuffer(GL_RENDERBUFFER, self._depth)
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT,
self._width, self._height)
glBindRenderbuffer(GL_RENDERBUFFER, 0)
# Attach texture and depth buffer
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_TEXTURE_2D, self._texture,
ctypes.c_int(0))
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
GL_RENDERBUFFER, self._depth)
# Unbind frame buffer for now
glBindFramebuffer(GL_FRAMEBUFFER, 0)
status = glCheckFramebufferStatus(GL_FRAMEBUFFER)
# Create shaders
self._incShader = Shader("IncrementBuffer")
self._logShader = Shader("LogBuffer")
self._reduction = ReductionShader(self._texture,
max(self._width, self._height),
["ReduceMaxMin"])
self._prepared = True
# Pass everything through since we want to make a projected density map
glEnable(GL_BLEND)
glBlendFunc(GL_ONE, GL_ONE)
