def draw_a_triangle():
if not glfw.init():
return -1;
# Create a windowed mode window and its OpenGL context
glfw.window_hint(glfw.SAMPLES, 4)
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, GL_TRUE)
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
window = glfw.create_window(1024, 768, "Triangle", None, None);
if window == None:
glfw.terminate()
return -1
# Make the window's context current
glfw.make_context_current(window)
# glfw.Experimental = True
glClearColor(0.0, 0.1, 0.2, 1.0)
flatten = lambda l: [u for t in l for u in t]
vertices = [(-1.0, -1.0, 0.0),
(1.0, -1.0, 0.0),
(0.0, 1.0, 0.0)]
indices = range(3)
vao_handle = glGenVertexArrays(1)
glBindVertexArray(vao_handle)
program_handle = tools.load_program("../shader/simple.v.glsl",
"../shader/simple.f.glsl")
f_vertices = flatten(vertices)
c_vertices = (c_float*len(f_vertices))(*f_vertices)
v_buffer = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, v_buffer)
glBufferData(GL_ARRAY_BUFFER, c_vertices, GL_STATIC_DRAW)
glEnableVertexAttribArray(0)
glBindBuffer(GL_ARRAY_BUFFER, v_buffer)
glVertexAttribPointer(0,
#glGetAttribLocation(program_handle, "vertexPosition_modelspace"),
3, GL_FLOAT, False, 0, None)
# Loop until the user closes the window
while not glfw.window_should_close(window):
# Render here
glClear(GL_COLOR_BUFFER_BIT)
glUseProgram(program_handle)
glDrawArrays(GL_TRIANGLES, 0, 3)
glDisableVertexAttribArray(vao_handle)
# Swap front and back buffers
glfw.swap_buffers(window)
# Poll for and process events
glfw.poll_events()
glfw.terminate();
pass
def draw_a_white_cube():
flatten = lambda l: [u for t in l for u in t]
c_array = lambda c_type: lambda l: (c_type*len(l))(*l)
if not glfw.init():
return -1;
# Create a windowed mode window and its OpenGL context
window = glfw.create_window(640, 480, "white cube", None, None);
if window == None:
glfw.terminate()
return -1
# Make the window's context current
glfw.make_context_current(window)
# Loop until the user closes the window
glClearColor(0.0, 0.0, 0.2, 1.0)
program_handle = tools.load_program("../shader/cube.v.glsl", "../shader/cube.f.glsl")
glUseProgram(program_handle)
cube_obj = Object("../obj/cube.obj")
# initialize VAO
vao_handle = glGenVertexArrays(1)
glBindVertexArray(vao_handle)
# bind buffers
# indices buffer
i_buffer = glGenBuffers(1)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, i_buffer)
glBufferData(GL_ELEMENT_ARRAY_BUFFER,
(c_ushort * len(cube_obj.indices))(*cube_obj.indices),
GL_STATIC_DRAW)
# vertices buffer
v_buffer = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, v_buffer)
v_flatten = flatten(cube_obj.vertices)
glBufferData(GL_ARRAY_BUFFER,
(c_float * len(v_flatten))(*v_flatten),
GL_STATIC_DRAW)
# normals buffer
n_buffer = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, n_buffer)
n_flatten = flatten(cube_obj.normals)
glBufferData(GL_ARRAY_BUFFER,
(c_float * len(n_flatten))(*n_flatten),
GL_STATIC_DRAW)
# attributes initializing
glEnableVertexAttribArray(1)
glBindBuffer(GL_ARRAY_BUFFER, v_buffer)
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, None)
# uniforms
c_mat4 = lambda mat4: (c_float * 16)(*(mat4.toList()))
model_mat = mat4(1.0)
model_mat.scale(vec3(0.5))
model_mat.rotate(pi / 3, vec3(1.0, 1.0, 0))
model_mat.translate((0.5, 0, 0))
view_mat = mat4.lookAt(vec3(0, 0, -5),
vec3(0, 0, 0))
proj_mat = mat4.perspective(45, 4./3, 0.1, 100)
mvp = proj_mat * view_mat * model_mat
c_mvp = c_mat4(mvp)
mvp_id = glGetUniformLocation(program_handle, "mvp")
glUniformMatrix4fv(mvp_id, 1, GL_FALSE, c_mvp)
# initializing other stuff
glEnable(GL_DEPTH_TEST)
glDepthFunc(GL_LESS)
while not glfw.window_should_close(window):
# Render here
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
# Swap front and back buffers
# bind buffer to vao
# glEnableVertexAttribArray(n_buffer)
# glBindBuffer(GL_ARRAY_BUFFER, n_buffer)
# glVertexAttribPointer(v_buffer, 3, GL_FLOAT, GL_FALSE, 0, 0)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, i_buffer)
glDrawElements(GL_TRIANGLES, len(cube_obj.indices),
GL_UNSIGNED_SHORT, None);
glfw.swap_buffers(window)
# Poll for and process events
glfw.poll_events()
glfw.terminate();
def draw_projected_shadows():
flatten = lambda l: [u for t in l for u in t]
c_array = lambda c_type: lambda l: (c_type*len(l))(*l)
look_at = lambda eye, at, up: mat4.lookAt(eye, 2*eye - at, up).inverse()
def shadow_proj_mat(plane_normal, plane_point, light_pos):
if type(plane_normal) == vec3:
plane_normal = plane_normal.normalize()
elif type(plane_normal) == np.array:
plane_normal = plane_normal / np.linalg.norm(plane_normal)
else:
raise TypeError("What the hell did you put in here as a normal??")
n_t = np.array(plane_normal).reshape((1,3))
L = np.array(light_pos).reshape((3,1))
D = - plane_normal * plane_point
ntL = np.dot(n_t, L)
shad_mat = np.identity(4, float)
shad_mat[0:3, 0:3] = L.dot(n_t) - (D + ntL ) * np.identity(3)
shad_mat[0:3, 3:4] = (D+ntL) * L - L * ntL
shad_mat[3:4, 0:3] = n_t
shad_mat[3:4, 3:4] = - ntL
return mat4(shad_mat.astype(np.float32).T.tolist())
class Item:
pass
cube = Item() # currently just a temporary holder of attributes and uniforms
if not glfw.init():
return -1;
# Create a windowed mode window and its OpenGL context
width, height = (640, 480)
window = glfw.create_window(width * 2, height, "scene", None, None);
# window2 = glfw.create_window(640, 480, "floor", None, None);
if window == None:
glfw.terminate()
return -1
# Loop until the user closes the window
glfw.make_context_current(window)
glClearColor(0.0, 0.0, 0.2, 1.0)
program_handle = tools.load_program("../shader/standardShading.v.glsl",
"../shader/standardShading.f.glsl")
glUseProgram(program_handle)
cube.obj = Object("../obj/cube.obj")
# initialize VAO
vao_handle = glGenVertexArrays(1)
glBindVertexArray(vao_handle)
# bind buffers
# indices buffer
i_buffer = glGenBuffers(1)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, i_buffer)
glBufferData(GL_ELEMENT_ARRAY_BUFFER,
(c_ushort * len(cube.obj.indices))(*cube.obj.indices),
GL_STATIC_DRAW)
# vertices buffer
v_buffer = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, v_buffer)
v_flatten = flatten(cube.obj.vertices)
glBufferData(GL_ARRAY_BUFFER,
(c_float * len(v_flatten))(*v_flatten),
GL_STATIC_DRAW)
# normals buffer
n_buffer = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, n_buffer)
n_flatten = flatten(cube.obj.normals)
glBufferData(GL_ARRAY_BUFFER,
(c_float * len(n_flatten))(*n_flatten),
GL_STATIC_DRAW)
# attributes initializing
vert_loc = glGetAttribLocation(program_handle, "vertexPosition_modelspace")
glEnableVertexAttribArray(vert_loc)
glBindBuffer(GL_ARRAY_BUFFER, v_buffer)
glVertexAttribPointer(vert_loc, 3, GL_FLOAT, GL_FALSE, 0, None)
# TODO: fix the existing attribute unable to retrieve problem
norm_loc = glGetAttribLocation(program_handle, "vertexNormal_modelspace")
glEnableVertexAttribArray(norm_loc)
glBindBuffer(GL_ARRAY_BUFFER, n_buffer)
glVertexAttribPointer(norm_loc, 3, GL_FLOAT, GL_FALSE, 0, None)
# uniforms
cube.model_mat = mat4(1.0)
cube.model_mat.scale(vec3(0.5))
cube.model_mat.rotate(pi / 3, vec3(1.0, 0.5, 1.7))
cube.position = vec3(0.5, 0, 1)
cube.model_mat.translate(cube.position)
# TODO: fix this stupid left-handed coord lookAt func
view_mat = look_at(vec3(-1, 2, 5),
vec3(0, 0, 0),
vec3(0, 1, 0))
view_mat_top = look_at(vec3(0, 4, 0),
vec3(0, 0, 0),
vec3(0, 0, -1))
proj_mat = mat4.perspective(45, 4./3, 0.1, 100)
model_view_inv = (view_mat * cube.model_mat).inverse()
# light_pos = vec3(2,1,0)
# light_pos = vec3(2,2,2)
light_pos = vec3(3,3,3)
V_loc = glGetUniformLocation(program_handle, "V")
glUniformMatrix4fv(V_loc, 1, GL_FALSE, view_mat.toList())
light_pos_loc = glGetUniformLocation(program_handle, "LightPosition_worldspace")
glUniform3f(light_pos_loc, light_pos.x, light_pos.y, light_pos.z)
MVP_loc = glGetUniformLocation(program_handle, "MVP")
M_loc = glGetUniformLocation(program_handle, "M")
MVint_loc = glGetUniformLocation(program_handle, "MVint")
floor_model_mat = mat4.translation((0,-0.51,0))*mat4.scaling((5,0.1,5))
floor_MVP = proj_mat*view_mat*floor_model_mat
floor_MVinv = (view_mat*floor_model_mat).inverse()
# initialize shadow projection program
shadow_program_handle = tools.load_program("../shader/shadowProjectionShading.v.glsl",
"../shader/shadowProjectionShading.f.glsl")
glUseProgram(shadow_program_handle)
shadow_MsVP_loc = glGetUniformLocation(shadow_program_handle, "MsVP")
VP_mat = proj_mat * view_mat;
VP_mat_top = proj_mat * view_mat_top;
shaject_mat = shadow_proj_mat(vec3(0,1,0), vec3(0,-0.45,0), light_pos)
glUniform3f(glGetUniformLocation(shadow_program_handle, "shadowColor"),
0.0, 0.0, 0.0) # black shadow
shadow_v_loc = glGetAttribLocation(shadow_program_handle, "coord3d")
glEnableVertexAttribArray(shadow_v_loc)
glBindBuffer(GL_ARRAY_BUFFER, v_buffer)
glVertexAttribPointer(shadow_v_loc, 3, GL_FLOAT, GL_FALSE, 0, None)
basic_program_handle = tools.load_program("../shader/basic.v.glsl",
"../shader/basic.f.glsl")
glUseProgram(basic_program_handle)
basic_mvp_loc = glGetUniformLocation(basic_program_handle, "mvp")
floor_basic_mvp = proj_mat*view_mat_top*floor_model_mat
glUniformMatrix4fv(basic_mvp_loc, 1, GL_FALSE, floor_basic_mvp.toList())
basic_v_loc = glGetAttribLocation(basic_program_handle, "coord3d")
glEnableVertexAttribArray(basic_v_loc)
glBindBuffer(GL_ARRAY_BUFFER, v_buffer)
glVertexAttribPointer(basic_v_loc, 3, GL_FLOAT, GL_FALSE, 0, None)
# initializing other stuff
glEnable(GL_DEPTH_TEST)
glDepthFunc(GL_LESS)
glEnable(GL_CULL_FACE)
image_obj = Image.open("../img/target.png")
image_obj = image_obj.convert("L")
def set_param(x):
cube.model_mat = mat4(1.0)
cube.model_mat.scale(vec3(0.5))
cube.model_mat.rotate(pi / 3, vec3(1.0, 0.5, 1.7))
# cube.model_mat.rotate(x[5], vec3(cos(x[4])*cos(x[3]), sin(x[4]), cos(x[4])*sin(x[3])))
cube.model_mat.translate((x[0], x[1], x[2]))
return
def draw(x):
set_param(x)
# Render here
# Make the window's context current
shaject_mat = shadow_proj_mat(vec3(0,1,0), vec3(0,-0.45,0), light_pos)
glfw.make_context_current(window)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
# draw the scene
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_CULL_FACE)
glViewport(0,0,width,height)
glUseProgram(program_handle)
glUniform3f(light_pos_loc, light_pos.x, light_pos.y, light_pos.z)
model_view_inv = (view_mat * cube.model_mat).inverse()
glUniformMatrix4fv(MVint_loc, 1, GL_TRUE, model_view_inv.toList())
glUniformMatrix4fv(M_loc, 1, GL_FALSE, cube.model_mat.toList())
MVP = proj_mat * view_mat * cube.model_mat
glUniformMatrix4fv(MVP_loc, 1, GL_FALSE, MVP.toList())
glDrawElements(GL_TRIANGLES, len(cube.obj.indices),
GL_UNSIGNED_SHORT, None);
glUniformMatrix4fv(MVint_loc, 1, GL_TRUE, floor_MVinv.toList())
glUniformMatrix4fv(M_loc, 1, GL_FALSE, floor_model_mat.toList())
glUniformMatrix4fv(MVP_loc, 1, GL_FALSE, floor_MVP.toList())
glDrawElements(GL_TRIANGLES, len(cube.obj.indices),
GL_UNSIGNED_SHORT, None)
glDisable(GL_CULL_FACE)
glUseProgram(shadow_program_handle)
glUniformMatrix4fv(shadow_MsVP_loc, 1, GL_FALSE, (VP_mat*shaject_mat*cube.model_mat).toList())
glDrawElements(GL_TRIANGLES, len(cube.obj.indices),
GL_UNSIGNED_SHORT, None)
glViewport(width, 0, width, height)
glDisable(GL_CULL_FACE)
glUseProgram(basic_program_handle)
glDrawElements(GL_TRIANGLES, len(cube.obj.indices),
GL_UNSIGNED_SHORT, None)
glUseProgram(shadow_program_handle)
glUniformMatrix4fv(shadow_MsVP_loc, 1, GL_FALSE, (VP_mat_top*shaject_mat*cube.model_mat).toList())
# glUniformMatrix4fv(shadow_M_loc, 1, GL_FALSE, model_mat.toList())
# glUniformMatrix4fv(shadow_VP_loc, 1, GL_FALSE, VP_mat_top.toList())
glDrawElements(GL_TRIANGLES, len(cube.obj.indices),
GL_UNSIGNED_SHORT, None)
# Swap front and back buffers
glfw.swap_buffers(window)
glfw.poll_events()
def get_image():
glfw.swap_buffers(window)
b = glReadPixels(width, 0, width, height, GL_RGB, GL_UNSIGNED_BYTE)
glfw.swap_buffers(window)
im = Image.fromstring(mode="RGB", size=(width, height), data=b)
im = im.transpose(Image.FLIP_TOP_BOTTOM)
im = im.convert("L")
return im
from PIL import ImageMath as imath
def optim_obj_xor(x):
draw(x)
image = get_image()
xor = imath.eval("a^b", a=image, b=image_obj)
res = sum(xor.getdata())
print x, res
return res
X, Y = np.arange(width).reshape(1,width), np.arange(height).reshape(height,1)
def get_sec_moment(image):
# image should be a gray scale Image object
img = 1 - np.array(image.getdata()) / 128 # turn white to 0 and black to 1
# using 128 in case of gray
img = img.astype(np.int8)
img = img.reshape(height, width)
M_00 = float(img.sum())
M_10 = (X * img).sum()
M_01 = (img * Y).sum()
m_10 = M_10 / M_00 if M_00 else 0
m_01 = M_01 / M_00 if M_00 else 0
X_offset = X-m_10
Y_offset = Y-m_01
M_20 = ((X_offset**2)*img).sum() / M_00 if M_00 else 0
M_02 = (img*(Y_offset**2)).sum() / M_00 if M_00 else 0
M_11 = (X_offset*img*Y_offset).sum() / M_00 if M_00 else 0
return np.array([M_20, M_11, M_02])
Mt_2 = get_sec_moment(image_obj)
def optim_obj_sec_moment(x):
draw(x)
image = get_image()
M_2 = get_sec_moment(image)
res = ((Mt_2 - M_2)**2).sum()
print res, x
return res
class Optim:
def __init__(self):
self.error_func = lambda:None
self.weight = None
self.method = ""
self.params = None
def set_weight(self, *coefficients):
self.weight = np.array(coefficients)
optim = Optim()
def get_jac(func, delta, x0):
# let func be the air-function and delta as the uniform delta for gradient
len_x = len(x0)
def jac(x):
fx = func(x)
grad = np.zeros(len_x)
for i in range(len_x):
x_t = np.zeros(len_x)
x_t[i] = delta
fx_t = func(x+x_t)
grad[i] = fx_t - fx
return grad / delta
return jac
x0 = np.array([0.5,0.5,0])
# print Mt_2
# print optim_obj_sec_moment(x0)
# raw_input("return to continue")
x_res = x0
draw(x0)
import cma
res = cma.fmin(objective_function=optim_obj_sec_moment,
x0=x0,
sigma0=1)
x_res = res[0]
optimize = False
if optimize:
from scipy import optimize
res = optimize.minimize(fun=optim_obj_sec_moment, x0=x0, method='BFGS',
callback=None, jac=get_jac(optim_obj_sec_moment, 0.005, x0),
bounds=((0, 2.5), (0, 2.5), (None, None)))
print "__end of optimization__"
print res
x_res = res.x
# light_pos.z = res.x[0]
# print light_pos.z
# im = get_image()
# im.save("target.png")
# im.show()
while not glfw.window_should_close(window):
draw(x_res)
glfw.terminate();
pass
def draw_a_few_cubes():
flatten = lambda l: [u for t in l for u in t]
c_array = lambda c_type: lambda l: (c_type*len(l))(*l)
look_at = lambda eye, at, up: mat4.lookAt(eye, 2*eye - at, up).inverse()
if not glfw.init():
return -1;
# Create a windowed mode window and its OpenGL context
window = glfw.create_window(640, 480, "scene", None, None);
# window2 = glfw.create_window(640, 480, "floor", None, None);
if window == None:
glfw.terminate()
return -1
# Loop until the user closes the window
glfw.make_context_current(window)
glClearColor(0.0, 0.0, 0.2, 1.0)
# glfw.make_context_current(window2)
# glClearColor(0.0, 0.2, 0.2, 1.0)
# glfw.make_context_current(window)
program_handle = tools.load_program("../shader/flatShading.v.glsl",
"../shader/flatShading.f.glsl")
glUseProgram(program_handle)
cube_obj = Object("../obj/cube.obj")
# initialize VAO
vao_handle = glGenVertexArrays(1)
glBindVertexArray(vao_handle)
# bind buffers
# indices buffer
i_buffer = glGenBuffers(1)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, i_buffer)
glBufferData(GL_ELEMENT_ARRAY_BUFFER,
(c_ushort * len(cube_obj.indices))(*cube_obj.indices),
GL_STATIC_DRAW)
# vertices buffer
v_buffer = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, v_buffer)
v_flatten = flatten(cube_obj.vertices)
glBufferData(GL_ARRAY_BUFFER,
(c_float * len(v_flatten))(*v_flatten),
GL_STATIC_DRAW)
# normals buffer
n_buffer = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, n_buffer)
n_flatten = flatten(cube_obj.normals)
glBufferData(GL_ARRAY_BUFFER,
(c_float * len(n_flatten))(*n_flatten),
GL_STATIC_DRAW)
# attributes initializing
vert_loc = glGetAttribLocation(program_handle, "vertexPosition_modelspace")
glEnableVertexAttribArray(vert_loc)
glBindBuffer(GL_ARRAY_BUFFER, v_buffer)
glVertexAttribPointer(vert_loc, 3, GL_FLOAT, GL_FALSE, 0, None)
# TODO: fix the existing attribute unable to retrieve problem
norm_loc = 0# glGetAttribLocation(program_handle, "vertexNormal_modelspace")
glEnableVertexAttribArray(norm_loc)
glBindBuffer(GL_ARRAY_BUFFER, n_buffer)
glVertexAttribPointer(norm_loc, 3, GL_FLOAT, GL_FALSE, 0, None)
# uniforms
model_mat = mat4(1.0)
model_mat.translate((0.5, 0, 0))
model_mat.rotate(pi / 2, vec3(1.0, 0.5, 1.7))
model_mat.scale(vec3(0.5))
view_mat = look_at(vec3(2, 1, 5),
vec3(0, 0, 0),
vec3(0, 1, 0))
proj_mat = mat4.perspective(45, 4./3, 0.1, 100)
model_view_inv = (view_mat * model_mat).inverse()
light_pos = vec3(0,3,0)
MVP = proj_mat * view_mat * model_mat
V_loc = glGetUniformLocation(program_handle, "V")
glUniformMatrix4fv(V_loc, 1, GL_FALSE, view_mat.toList())
light_pos_loc = glGetUniformLocation(program_handle, "LightPosition_worldspace")
glUniform3f(light_pos_loc, light_pos.x, light_pos.y, light_pos.z)
MVP_loc = glGetUniformLocation(program_handle, "MVP")
M_loc = glGetUniformLocation(program_handle, "M")
MVint_loc = glGetUniformLocation(program_handle, "MVint")
floor_model_mat = mat4.translation((0,-0.5,0))*mat4.scaling((5,0.1,5))
floor_MVP = proj_mat*view_mat*floor_model_mat
floor_MVinv = (view_mat*floor_model_mat).inverse()
flatten_biasmat = [ 0.5, 0.0, 0.0, 0.0,
0.0, 0.5, 0.0, 0.0,
0.0, 0.0, 0.5, 0.0,
0.5, 0.5, 0.5, 1.0]
flatten_biasmat = (c_float*16)(*flatten_biasmat)
bias_loc = glGetUniformLocation(program_handle, "DepthBiasMVP")
glUniformMatrix4fv(bias_loc, 1, GL_FALSE, flatten_biasmat)
shadow_map_loc = glGetUniformLocation(program_handle, "shadowMap")
# initializing other stuff
glEnable(GL_DEPTH_TEST)
glDepthFunc(GL_LESS)
glEnable(GL_CULL_FACE)
# initializing shadow mapping
depth_program_handle = tools.load_program("../shader/DepthRTT.v.glsl",
"../shader/DepthRTT.f.glsl")
depth_MVP_loc = glGetUniformLocation(depth_program_handle, "depthMVP")
depth_framebuffer = glGenFramebuffers(1)
glBindFramebuffer(GL_FRAMEBUFFER, depth_framebuffer)
depth_tex = glGenTextures(1)
glBindTexture(GL_TEXTURE_2D, depth_tex)
glTexImage2D(GL_TEXTURE_2D, # target
0, # level
GL_DEPTH_COMPONENT16, # internal format
1024, # width
1024, # height
0, # border
GL_DEPTH_COMPONENT, # format
GL_FLOAT, # type
None) # data pointer
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
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_COMPARE_FUNC, GL_LEQUAL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE);
glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, depth_tex, 0)
glDrawBuffer(GL_NONE)
if glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE:
raise RuntimeError("framebuffer is not okay")
depth_proj_mat = mat4.perspective(45, 1, 1, 50)
depth_view_mat = look_at(light_pos, vec3(0,4,0), vec3(0,1,0))
glUseProgram(depth_program_handle)
depth_vert_loc = glGetAttribLocation(depth_program_handle,
"vertexPosition_modelspace")
glEnableVertexAttribArray(depth_vert_loc)
glBindBuffer(GL_ARRAY_BUFFER, v_buffer)
print "vertices buffer handle:", v_buffer
glVertexAttribPointer(depth_vert_loc, # attribute handle
3, # size
GL_FLOAT, # type
GL_FALSE, # unnormalized
0, # stride
None # array buffer offset
)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, i_buffer)
# initialize the texture monitor
quad_vertices = [ -1.0, -1.0, 0.0, 1.0, -1.0, 0.0, -1.0, 1.0, 0.0,\
-1.0, 1.0, 0.0, 1.0, -1.0, 0.0, 1.0, 1.0, 0.0]
quad_v_buffer = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, quad_v_buffer)
glBufferData(GL_ARRAY_BUFFER, (c_float*(len(quad_vertices)))(*quad_vertices), GL_STATIC_DRAW)
quad_program_handle = tools.load_program("../shader/Passthrough.v.glsl",
"../shader/SimpleTexture.f.glsl")
tex_loc = glGetUniformLocation(quad_program_handle, "texture");
while not glfw.window_should_close(window):
# Render here
# Make the window's context current
glfw.make_context_current(window)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
# draw the shadow map
glBindFramebuffer(GL_FRAMEBUFFER, depth_framebuffer)
glViewport(0,0,1024,1024)
# TODO: see if the coming lines can be moved outside
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
glUseProgram(depth_program_handle)
depth_MVP = depth_proj_mat * depth_view_mat * model_mat
glUniformMatrix4fv(depth_MVP_loc, 1, GL_FALSE, depth_MVP.toList())
glEnableVertexAttribArray(depth_vert_loc)
glBindBuffer(GL_ARRAY_BUFFER, v_buffer)
glVertexAttribPointer(depth_vert_loc, # attribute handle
3, # size
GL_FLOAT, # type
GL_FALSE, # unnormalized
0, # stride
None # array buffer offset
)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, i_buffer)
glDrawElements(GL_TRIANGLES, len(cube_obj.indices),
GL_UNSIGNED_SHORT, None)
# draw the scene
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glViewport(0,0,640,480)
glUseProgram(program_handle)
glActiveTexture(GL_TEXTURE0)
glBindTexture(GL_TEXTURE_2D, depth_tex)
glUniform1i(shadow_map_loc, 0)
glUniformMatrix4fv(MVint_loc, 1, GL_TRUE, model_view_inv.toList())
glUniformMatrix4fv(M_loc, 1, GL_FALSE, model_mat.toList())
glUniformMatrix4fv(MVP_loc, 1, GL_FALSE, MVP.toList())
glDrawElements(GL_TRIANGLES, len(cube_obj.indices),
GL_UNSIGNED_SHORT, None);
glUniformMatrix4fv(MVint_loc, 1, GL_TRUE, floor_MVinv.toList())
glUniformMatrix4fv(M_loc, 1, GL_FALSE, floor_model_mat.toList())
glUniformMatrix4fv(MVP_loc, 1, GL_FALSE, floor_MVP.toList())
glDrawElements(GL_TRIANGLES, len(cube_obj.indices),
GL_UNSIGNED_SHORT, None)
# texture monitor
glViewport(0, 0, 256, 256)
glUseProgram(quad_program_handle)
# Bind our texture in Texture Unit 0
glActiveTexture(GL_TEXTURE0)
glBindTexture(GL_TEXTURE_2D, depth_tex)
# Set our "renderedTexture" sampler to user Texture Unit 0
glUniform1i(tex_loc, 0)
# 1rst attribute buffer : vertices
glEnableVertexAttribArray(0)
glBindBuffer(GL_ARRAY_BUFFER, quad_v_buffer)
glVertexAttribPointer(
0, # attribute 0. No particular reason for 0, but must match the layout in the shader.
3, # size
GL_FLOAT, # type
GL_FALSE, # normalized?
0, # stride
None # array buffer offset
)
# Draw the triangle !
# You have to disable GL_COMPARE_R_TO_TEXTURE above in order to see anything !
glDrawArrays(GL_TRIANGLES, 0, 6) # 2*3 indices starting at 0 -> 2 triangles
glDisableVertexAttribArray(0)
# Swap front and back buffers
glfw.swap_buffers(window)
# glfw.make_context_current(window2)
# glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
#
# glfw.swap_buffers(window2)
# Poll for and process events
glfw.poll_events()
glfw.terminate();
pass
def __init__(self, vert_path, frag_path):
self.handle = tools.load_program(vert_path, frag_path)