class SimplePhysShader(object):
'''
Simple shader to project images in log space
'''
def __init__(self, shaderName="SimplePhysBuffer"):
'''
Constructor
'''
#self._incShader = 0
self._shaderName = shaderName
self._prepared = False # Has the shader been initialised?
self._frameBuffer = None
# Do this when the program is loaded
def Init(self):
if not self._prepared:
# Set up shaders
self._shader = Shader(self._shaderName)
self._prepared = True
# Do this before the objects are rendered
def Begin(self):
self._shader.Bind()
# Do this after the objects are rendered
def End(self):
self._shader.Unbind()
def Reset(self):
'''
Reset the shader; make it run the pre-load operation again
NOTE: THIS IS PROBABLY UNNEEDED, DELETE TO CLEAN UP INTERFACE
'''
self._preloaded = False
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 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 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):
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 __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 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 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):
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)
class myApp(Snowball):
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 loop(self, dt):
glClearColor(0.2, 0.3, 0.8, 1.0)
glClear(GL_COLOR_BUFFER_BIT)
self.shader.use()
self.object.draw()
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):
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,
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,
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
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()
class Renderer:
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 setCameraMatrix(self, cameraMatrix):
self.colorShader.setUniformMat4('view', self.view)
self.colorShader.setUniformMat4('proj', self.proj)
def setModelMatrix(self, model):
self.colorShader.setUniformMat4('model', model)
def setLightPos(self, lightPos):
self.colorShader.setUniformVec4('lightPosition', lightPos)
def setDiffCol(self, diffCol):
self.colorShader.setUniformVec3('diffuseColor', diffCol)
def windowOpen(self):
return glfw.GetWindowParam(glfw.OPENED)
def startDraw(self):
glClearColor(0.0, 0.0, 0.0, 1.0)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
def endDraw(self):
glfw.SwapBuffers()
def initialize(self):
glfw.Init()
glfw.OpenWindowHint(glfw.FSAA_SAMPLES, 4)
glfw.OpenWindowHint(glfw.OPENGL_VERSION_MAJOR, 3)
glfw.OpenWindowHint(glfw.OPENGL_VERSION_MINOR, 2) # 3.2
glfw.OpenWindowHint(glfw.OPENGL_PROFILE,
glfw.OPENGL_CORE_PROFILE) # 3.2
glfw.OpenWindowHint(glfw.OPENGL_FORWARD_COMPAT, GL_TRUE) # 3.2
glfw.OpenWindowHint(glfw.WINDOW_NO_RESIZE, GL_TRUE)
try: # in case we fail to init this version
glfw.OpenWindow(self.windowWidth, self.windowHeight, 0, 0, 0, 0,
24, 8, glfw.WINDOW)
except Exception as e:
self.logger.warn("Failed to initialize OpenGL: {}".format(str(e)))
self.logger.warn("Trying lower version...")
glfw.OpenWindowHint(glfw.OPENGL_VERSION_MINOR, 0) # 3.0
glfw.OpenWindowHint(glfw.OPENGL_PROFILE, 0) # 3.0
glfw.OpenWindowHint(glfw.OPENGL_FORWARD_COMPAT, GL_FALSE) # 3.0
glfw.OpenWindow(self.windowWidth, self.windowHeight, 0, 0, 0, 0,
24, 8, glfw.WINDOW)
self.logger.warn("OpenGL fallback to lower version worked")
glfw.SetWindowTitle("TANG")
glfw.SetWindowCloseCallback(self.onWindowClose)
glEnable(GL_DEPTH_TEST)
glEnable(GL_CULL_FACE)
# Find out OpenGL version, and store for future use
self.context.GL_version_string = glGetString(GL_VERSION).split(
' '
)[0] # must have version at the beginning, e.g. "3.0 Mesa 9.x.x" to extract "3.0"
self.context.GL_version_major, self.context.GL_version_minor = list(
int(x) for x in self.context.GL_version_string.split('.'))[
0:2] # must have only MAJOR.MINOR
self.logger.info("OpenGL version {}.{}".format(
self.context.GL_version_major, self.context.GL_version_minor))
self.context.GLSL_version_string = glGetString(
GL_SHADING_LANGUAGE_VERSION).split(' ')[0].replace(
'.', '') # "1.50" => "150"
self.logger.info("GLSL version {}".format(
self.context.GLSL_version_string))
def quit(self):
glfw.CloseWindow() # NOTE does not generate onWindowClose callback
#glfw.Terminate()
def onWindowClose(self):
#self.logger.debug("Renderer.onWindowClose()")
return True # nothing more needs to be done; but an event could be generated
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)
class ColourShader(object):
'''
Simple shader to project images in log space
'''
def __init__(self):
'''
Constructor
'''
self._x, self._y = (0, 0)
self._width, self._height = (0, 0)
self._depth = 0 #ctypes.c_int(0)
self._frame = 0 #ctypes.c_int(0)
self._texture = 0 #ctypes.c_int(0)
self._image = 0
self._incShader = 0
self._logShader = 0
self._recalcMaxMin = 0 # Counter to recalculate max/min
self._logmin = -16.11 # = ln(1e-7)
self._invlogrng = 0.135 # Arbitrary value
self._prepared = False
self._reduction = None # Reduction shader for calculating min/max
def ViewPos(self, x, y):
'''
Set the view position of the outputted shader
'''
self._x = x
self._y = y
# Do this when the program is loaded
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)
# Do this before the objects are rendered
def Begin(self, display):
# Re-bind frame buffer
glBindFramebuffer(GL_FRAMEBUFFER, self._frame)
# Clear frame buffer
glClearColor(0, 0, 0, 1)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
glDisable(GL_TEXTURE_2D)
glDisable(GL_DEPTH_TEST)
glEnable(GL_BLEND)
glBlendFunc(GL_ONE, GL_ONE)
#self._incShader.Bind()
# At this point we draw...
# Do this after the objects are rendered
def End(self, display):
# Take out the shader currently in use
#self._incShader.Unbind()
# Unbind frame buffer
glBindFramebuffer(GL_FRAMEBUFFER, 0)
# TEST REDUCTION
reduce = self._reduction.Run()
maxval = reduce[0, 0]
minval = reduce[0, 1]
# Get the max/min value in the texture to pass to the shader
self._recalcMaxMin -= 1
properScale = self._recalcMaxMin <= 0
properScale = True
if properScale:
#data = glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_FLOAT)
#red = data[:,:,0]
#minval = np.min(red[np.nonzero(red)])
#maxval = np.max(red)
if minval == maxval:
dmin = 0.0
dmax = 0.0
invrng = 1.0
else:
dmin = float(np.log(minval))
dmax = float(np.log(maxval))
#dmin = dmax - 10.0
try:
invrng = 1.0 / (dmax - dmin)
except:
invrng = 1.0
#print "Image min, range, max:", dmin, 1.0/invrng, dmax
#newrng = np.min([10.0,1.0/invrng]) # HACK - stops weird hard circle effect
#dmin = dmax - newrng
#invrng = 1.0/newrng
dmax = 3.0
dmin = -3.0
self._logmin = dmin
self._invlogrng = invrng
self._recalcMaxMin = 10
#print self._logmin, self._invlogrng
#del(data)
# HACK
#data = glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_FLOAT)
#import scipy
#scipy.misc.imsave('outfile.jpg', data)
# HACK END
def DrawTexture(self):
logshade = True
if logshade:
self._logShader.Bind()
self._logShader.AddFloat(self._logmin, "texmin")
self._logShader.AddFloat(self._invlogrng, "texinvrng")
#shaders.glUseProgram(self._logShader.Shader())
#minloc = glGetUniformLocation( self._logShader.Shader(), 'texmin' )
#invrngloc = glGetUniformLocation( self._logShader.Shader(), 'texinvrng' )
#glUniform1f( minloc,self._logmin)
#glUniform1f( invrngloc,self._invlogrng)
#shaders.glUseProgram(0)
glLoadIdentity()
glViewport(self._x, self._y, self._width, self._height)
# Now we need to plot the texture to screen
# Set up an orthogonal projection
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
glOrtho(0, 1, 0, 1, -10, 10)
glMatrixMode(GL_MODELVIEW)
glLoadIdentity()
#glDrawPixels(self._width, self._height, GL_RGBA, GL_FLOAT, self._texture)
# Now draw the texture with the log shader
# Draw the texture onto a flat plane
glColor4f(1.0, 1.0, 1.0, 1.0)
glEnable(GL_TEXTURE_2D)
#glDisable(GL_TEXTURE_GEN_S)
#glDisable(GL_TEXTURE_GEN_T)
glBindTexture(GL_TEXTURE_2D, self._texture)
glBegin(GL_TRIANGLES)
glTexCoord2d(0.0, 0.0)
glVertex3f(0.0, 0.0, 0.0)
glTexCoord2d(1.0, 0.0)
glVertex3f(1.0, 0.0, 0.0)
glTexCoord2d(1.0, 1.0)
glVertex3f(1.0, 1.0, 0.0)
glTexCoord2d(1.0, 1.0)
glVertex3f(1.0, 1.0, 0.0)
glTexCoord2d(0.0, 1.0)
glVertex3f(0.0, 1.0, 0.0)
glTexCoord2d(0.0, 0.0)
glVertex3f(0.0, 0.0, 0.0)
glEnd()
if logshade:
self._logShader.Unbind()
glBindTexture(GL_TEXTURE_2D, 0)
class LogShader(object):
'''
Simple shader to project images in log space
'''
def __init__(self, shaderName="LogBuffer"):
'''
Constructor
'''
#self._incShader = 0
self._logShader = 0
self._shaderName = shaderName
self._recalcMaxMin = 0 # Counter to recalculate max/min
self._logmin = -16.5 # = ln(1e-7)
self._invlogrng = 0.1 # arbitrary guess
self._prepared = False # Has the shader been initialised?
self._preloaded = False # Have we found the min/max value of the image?
self._reduction = None # Reduction shader for calculating min/max
self._frameBuffer = None
# Do this when the program is loaded
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
# Do this before the objects are rendered
def Begin(self):
# Reduce the image
# Get the max/min value in the texture to pass to the shader
self._recalcMaxMin -= 1
properScale = self._recalcMaxMin <= 0
# HACK - turn off properscale counter; turn back on if it runs slowly
properScale = True # HACK - always run
if properScale:
reduce = self._reduction.Run()
maxval = reduce[0, 0]
minval = reduce[0, 1]
if minval == maxval:
dmin = 0.0
dmax = 0.0
invrng = 1.0
else:
dmin = float(np.log(minval))
dmax = float(np.log(maxval))
try:
invrng = 1.0 / (dmax - dmin)
except:
invrng = 1.0
self._logmin = dmin
self._invlogrng = invrng
self._recalcMaxMin = 10
# Reset view
x, y = self._frameBuffer.Pos()
width = self._frameBuffer.Width()
height = self._frameBuffer.Height()
glViewport(x, y, width, height)
self._logShader.Bind()
self._logShader.AddFloat(self._logmin, "texmin")
self._logShader.AddFloat(self._invlogrng, "texinvrng")
# Do this after the objects are rendered
def End(self):
self._logShader.Unbind()
def Reset(self):
'''
Reset the shader; make it run the pre-load operation again
'''
self._preloaded = False
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)
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
class Renderer:
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 setCameraMatrix(self, cameraMatrix):
self.colorShader.setUniformMat4('view', self.view)
self.colorShader.setUniformMat4('proj', self.proj)
def setModelMatrix(self, model):
self.colorShader.setUniformMat4('model', model)
def setLightPos(self, lightPos):
self.colorShader.setUniformVec4('lightPosition', lightPos)
def setDiffCol(self, diffCol):
self.colorShader.setUniformVec3('diffuseColor', diffCol)
def windowOpen(self):
return glfw.GetWindowParam(glfw.OPENED)
def startDraw(self):
glClearColor(0.0, 0.0, 0.0, 1.0)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
def endDraw(self):
glfw.SwapBuffers()
def initialize(self):
glfw.Init()
glfw.OpenWindowHint(glfw.FSAA_SAMPLES, 4)
glfw.OpenWindowHint(glfw.OPENGL_VERSION_MAJOR, 3)
glfw.OpenWindowHint(glfw.OPENGL_VERSION_MINOR, 2) # 3.2
glfw.OpenWindowHint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE) # 3.2
glfw.OpenWindowHint(glfw.OPENGL_FORWARD_COMPAT, GL_TRUE) # 3.2
glfw.OpenWindowHint(glfw.WINDOW_NO_RESIZE, GL_TRUE)
try: # in case we fail to init this version
glfw.OpenWindow(self.windowWidth, self.windowHeight, 0, 0, 0, 0, 24, 8, glfw.WINDOW)
except Exception as e:
self.logger.warn("Failed to initialize OpenGL: {}".format(str(e)))
self.logger.warn("Trying lower version...")
glfw.OpenWindowHint(glfw.OPENGL_VERSION_MINOR, 0) # 3.0
glfw.OpenWindowHint(glfw.OPENGL_PROFILE, 0) # 3.0
glfw.OpenWindowHint(glfw.OPENGL_FORWARD_COMPAT, GL_FALSE) # 3.0
glfw.OpenWindow(self.windowWidth, self.windowHeight, 0, 0, 0, 0, 24, 8, glfw.WINDOW)
self.logger.warn("OpenGL fallback to lower version worked")
glfw.SetWindowTitle("TANG")
glfw.SetWindowCloseCallback(self.onWindowClose)
glEnable(GL_DEPTH_TEST)
glEnable(GL_CULL_FACE)
# Find out OpenGL version, and store for future use
self.context.GL_version_string = glGetString(GL_VERSION).split(' ')[0] # must have version at the beginning, e.g. "3.0 Mesa 9.x.x" to extract "3.0"
self.context.GL_version_major, self.context.GL_version_minor = list(int(x) for x in self.context.GL_version_string.split('.'))[0:2] # must have only MAJOR.MINOR
self.logger.info("OpenGL version {}.{}".format(self.context.GL_version_major, self.context.GL_version_minor))
self.context.GLSL_version_string = glGetString(GL_SHADING_LANGUAGE_VERSION).split(' ')[0].replace('.', '') # "1.50" => "150"
self.logger.info("GLSL version {}".format(self.context.GLSL_version_string))
def quit(self):
glfw.CloseWindow() # NOTE does not generate onWindowClose callback
#glfw.Terminate()
def onWindowClose(self):
#self.logger.debug("Renderer.onWindowClose()")
return True # nothing more needs to be done; but an event could be generated
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):
