При создании fbo в kivy, он принимает "with_depthbuffer" в качестве аргумента. В документации говорится, что это приведет к тому, что fbo будет выделен с буфером z. Я хотел бы попробовать использовать это для световых эффектов.
Мой вопрос: где я могу найти и использовать этот буфер?
У меня есть возможность очистить его, но поиск в исходном коде для этого не помогает.
Я заметил, что fbo.texture имеет атрибут bufferfmt. Сохранен ли буфер глубины в текстуре изображения? Могу ли я получить доступ к этому в glsl, чтобы получить глубину пикселя?
Заранее спасибо
EDIT:
Я нашел своего рода «хакерский» способ сохранения информации о глубине, назначив gl_FragColor для vec4 (lambert_value, -1.0 / vertex_pos.z, 1.0, 1.0) и используя эти значения в пост-обработке. Но, очевидно, я не могу использовать это в реальном приложении
EDIT:
Хорошо, я предполагаю, что временный способ, которым я придумал, кажется довольно точным, как это было сделано.
Я посетил эту страницу: https://github.com/kivy/kivy/blob/master/kivy/graphics/fbo.pyx
и в строке 230 буфер рендеринга связывается, если with_depthbuffer == True.
Я посмотрел, что такое буфер рендеринга, и, по-видимому, его нельзя использовать, кроме как в текущем проходе шейдера. Это значит, что моя цель получить эту информацию от fbo не сработала.
Тогда я понял, что мне никогда не понадобится информация о глубине с точки зрения камеры, только свет. Поэтому я просто генерирую информацию о глубине, используя шейдер света. Я чувствую себя глупо. Но вот как все это происходит. Я думаю, что я могу понять это. Я буду постоянно обновлять эту страницу, так что там будет немного больше информации. Спасибо за чтение
Если вы хотите проверить это, просто нажмите / перетащите, чтобы изменить положение источника света.
Есть также закомментированные строки, которые используют мой временный подход к сохранению информации о глубине, чтобы вы могли видеть, к чему я клоню.
Вам также понадобится какой-нибудь объектный файл, я использовал обезьяну blender
main.py
post_shader = '''
#ifdef GL_ES
precision highp float;
#endif
/* Outputs from the vertex shader */
varying vec4 frag_color;
varying vec2 tex_coord0;
/* uniform texture samplers */
uniform sampler2D texture0;
uniform vec2 mouse_pos;
void main(void)
{
float distance = length(gl_FragCoord.xy - mouse_pos) * .02;
vec4 pixel = texture2D(texture0, tex_coord0);
vec3 color = pixel.rgb / distance;
gl_FragColor = vec4(color, 1.0);
// uncomment for desired results
// float brightness = clamp(pixel.r / distance, .1, .8) * pixel.g;
// gl_FragColor = vec4(brightness, brightness, brightness, 1.0);
}
'''
from kivy.app import App
from kivy.clock import Clock
from kivy.core.window import Window
from kivy.uix.widget import Widget
from kivy.resources import resource_find
from kivy.uix.floatlayout import FloatLayout
from kivy.graphics.opengl import *
from kivy.graphics import *
from objloader import ObjFile
class Renderer(Widget):
def __init__(self, **kwargs):
self.canvas = RenderContext(use_parent_projection=True)
# self.canvas.shader.fs = resource_find('post_shader.glsl')
self.canvas.shader.fs = post_shader
scene = ObjFile(resource_find("Models/monkey.obj"))
m = list(scene.objects.values())[0]
self.z_pos = 0
self.d = 1
super(Renderer, self).__init__(**kwargs)
with self.canvas:
self.fbo = Fbo(compute_normal_matrix=True,
with_depthbuffer=True)
self.fbo.shader.source = resource_find('simple.glsl')
self.display = Rectangle()
with self.fbo:
self.cb = Callback(self.setup_gl_context)
ClearColor(1, 0, 0, 0)
ClearBuffers(clear_depth=True)
PushMatrix()
self.translation = Translate(0, 0, -3)
self.rot = Rotate(1, 0, 1, 0)
UpdateNormalMatrix()
Color(rgb=(0, 0, 0))
self.mesh = Mesh(vertices=m.vertices,
indices=m.indices,
fmt=m.vertex_format,
mode='triangles')
PopMatrix()
self.cb = Callback(self.reset_gl_context)
self.display.texture = self.fbo.texture
Clock.schedule_interval(self.update, 1 / 60.)
def setup_gl_context(self, *args):
glEnable(GL_DEPTH_TEST)
glEnable(GL_CULL_FACE)
def reset_gl_context(self, *args):
glDisable(GL_DEPTH_TEST)
glDisable(GL_CULL_FACE)
def on_touch_move(self, touch):
self.canvas['mouse_pos'] = touch.pos
def update(self, dt):
self.z_pos += self.d * dt
if self.d > 0:
if self.z_pos > -2:
self.d *= -1
elif self.z_pos < -15:
self.d *= -1
self.translation.z = self.z_pos
self.rot.angle += dt * 10
def on_size(self, *args):
self.display.size = self.size
self.fbo['projection_mat'].perspective(90, self.width / float(self.height), .1, 25)
class RendererApp(App):
def build(self):
root = FloatLayout()
root.add_widget(Renderer())
return root
if __name__ == "__main__":
RendererApp().run()
simple.glsl
/* simple.glsl
simple diffuse lighting based on laberts cosine law; see e.g.:
http://en.wikipedia.org/wiki/Lambertian_reflectance
http://en.wikipedia.org/wiki/Lambert%27s_cosine_law
*/
---VERTEX SHADER-------------------------------------------------------
#ifdef GL_ES
precision highp float;
#endif
attribute vec3 v_pos;
attribute vec3 v_normal;
uniform mat4 modelview_mat;
uniform mat4 projection_mat;
varying vec4 normal_vec;
varying vec4 vertex_pos;
void main (void) {
//compute vertex position in eye_space and normalize normal vector
vec4 pos = modelview_mat * vec4(v_pos,1.0);
vertex_pos = pos;
normal_vec = vec4(v_normal, 0.0);
gl_Position = projection_mat * pos;
}
---FRAGMENT SHADER-----------------------------------------------------
#ifdef GL_ES
precision highp float;
#endif
varying vec4 normal_vec;
varying vec4 vertex_pos;
uniform mat4 normal_mat;
void main (void){
//correct normal, and compute light vector (assume light at the eye)
vec4 v_normal = normalize( normal_mat * normal_vec ) ;
vec4 v_light = normalize( vec4(0,0,0,1) - vertex_pos );
//reflectance based on lamberts law of cosine
float theta = clamp(dot(v_normal, v_light), 0.0, 1.0);
gl_FragColor = vec4(theta, theta, theta, 1.0);
// uncomment for desired results
// gl_FragColor = vec4(theta, -3.0 / vertex_pos.z, 1.0, 1.0);
}