def reset_gl_context(self):
gl.glEnable(gl.GL_BLEND)
gl.glDisable(gl.GL_DEPTH_TEST)
gl.glDisable(gl.GL_CULL_FACE)
gl.glEnable(gl.GL_STENCIL_TEST)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glBlendFuncSeparate(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA,
gl.GL_ONE, gl.GL_ONE)
gl.glActiveTexture(gl.GL_TEXTURE0)
gl.glPixelStorei(gl.GL_UNPACK_ALIGNMENT, 1)
def on_start(self):
glDisable(GL_DITHER)
Window.clearcolor = (0, 0, 0, 1)
Window.size = self.screen_size
Window.left = 0
Window.fullscreen = True
self.set_led_mode(self.led_mode)
self.set_video_mode(self.video_mode)
self.update_bits()
self.set_pixel_mode(True)
def on_start(self):
glDisable(GL_DITHER)
Window.clearcolor = (0, 0, 0, 1)
# Window.minimize()
self.root.focus = True
Window.show_cursor = False
if self.external_function_plugin_package:
register_external_functions(self.function_factory,
self.external_function_plugin_package)
if self.external_stage_plugin_package:
register_external_stages(self.stage_factory,
self.external_stage_plugin_package)
def end(self):
if not self.drawing:
raise Exception("PolygonSpriteBatch.begin must be called before end.")
if self.vertexIndex > 0:
self.flush()
self.lastTexture = None
self.drawing = False
glDepthMask(True)
if self.isBlendingEnabled():
glDisable(GL_BLEND)
if self.customShader is not None:
self.customShader.end()
else:
self.shader.end()
def render(self, obj_file):
self.canvas.clear()
self.scene = ObjFile(obj_file)
with self.canvas:
self.cb = Callback(lambda args: glEnable(GL_DEPTH_TEST))
PushMatrix()
self._setup_scene()
PopMatrix()
self.cb = Callback(lambda args: glDisable(GL_DEPTH_TEST))
Clock.schedule_interval(self._update_glsl, 1 / 60.)
def iterate(self, dt):
glDisable(GL_BLEND)
# pass 1
fbo = self.fbo_pos2
fbo['texture_vel'] = 1
fbo['dt'] = dt
fbo.ask_update()
fbo.draw()
# pass 2
fbo = self.fbo_vel2
fbo['dt'] = dt
fbo.ask_update()
fbo.draw()
glEnable(GL_BLEND)
# switch the texture for the next run
self.fbo_pos, self.fbo_pos2 = self.fbo_pos2, self.fbo_pos
self.fbo_vel, self.fbo_vel2 = self.fbo_vel2, self.fbo_vel
def flush(self):
if self.vertexIndex == 0:
return
self.renderCalls += 1
self.totalRenderCalls += 1
trianglesInBatch = self.triangleIndex
if trianglesInBatch > self.maxTrianglesInBatch:
self.maxTrianglesInBatch = trianglesInBatch
self.lastTexture.bind()
self.mesh.setVertices(self.vertices, 0, self.vertexIndex)
self.mesh.setIndices(self.triangles, 0, trianglesInBatch)
if self.blendingDisabled:
glDisable(GL_BLEND)
else:
glEnable(GL_BLEND)
if self.blendSrcFunc != -1:
glBlendFuncSeparate(self.blendSrcFunc, self.blendDstFunc, self.blendSrcFuncAlpha, self.blendDstFuncAlpha)
self.mesh.render(self.customShader if self.customShader is not None else self.shader, GL_TRIANGLES, 0, trianglesInBatch)
self.vertexIndex = 0
self.triangleIndex = 0
def reset_gl_context(self, *args):
glDisable(GL_DEPTH_TEST)
def disable_alpha_sample_callback(self, *args):
gl.glDisable(gl.GL_SAMPLE_ALPHA_TO_COVERAGE)
def reset_gl_context(self, *args):
glDisable(GL_DEPTH_TEST)
def deactivate_depthtest(self, instr):
glDisable(GL_DEPTH_TEST)
def disable_alpha_sample_callback(self, *args):
gl.glDisable(gl.GL_SAMPLE_ALPHA_TO_COVERAGE)
def on_start(self):
glDisable(GL_DITHER)
Window.clearcolor = (0, 0, 0, 1)
# Window.minimize()
self.root.focus = True
Window.show_cursor = False
def deactivate_depthtest(self, instr):
glDisable(GL_DEPTH_TEST)
def on_start(self):
glDisable(GL_DITHER)
Window.clearcolor = (0, 0, 0, 1)
# Window.minimize()
self.root.focus = True
Window.show_cursor = False
def _leave_3d(self, *args):
glDisable(GL_DEPTH_TEST)
glDisable(GL_CULL_FACE)
def init_smaa(self):
curdir = dirname(__file__)
# load shaders sources
with open(join(curdir, "SMAA.h"), "r") as fd:
smaa_h = fd.read()
config = """
#version 410 compatibility
#define SMAA_PIXEL_SIZE vec2(1.0 / {width}, 1.0 / {height})
#define SMAA_PRESET_{quality} 1
#define SMAA_GLSL_4 1
""".format(
width=self.width, height=self.height, quality=self.quality.upper()
)
header_vs = (
config
+ """
#define SMAA_ONLY_COMPILE_VS 1
in vec2 vPosition;
in vec2 vTexCoords0;
uniform mat4 modelview_mat;
uniform mat4 projection_mat;
"""
+ smaa_h
)
header_fs = (
config
+ """
#define SMAA_ONLY_COMPILE_PS 1
"""
+ smaa_h
)
edge_vs = (
header_vs
+ """
out vec2 texcoord;
out vec4 offset[3];
out vec4 dummy2;
void main()
{
texcoord = vTexCoords0;
vec4 dummy1 = vec4(0);
SMAAEdgeDetectionVS(dummy1, dummy2, texcoord, offset);
gl_Position = projection_mat * modelview_mat * vec4(vPosition.xy, 0.0, 1.0);
}
"""
)
edge_fs = (
header_fs
+ """
uniform sampler2D albedo_tex;
in vec2 texcoord;
in vec4 offset[3];
in vec4 dummy2;
void main()
{
#if SMAA_PREDICATION == 1
gl_FragColor = SMAAColorEdgeDetectionPS(texcoord, offset, albedo_tex, depthTex);
#else
gl_FragColor = SMAAColorEdgeDetectionPS(texcoord, offset, albedo_tex);
#endif
}
"""
)
blend_vs = (
header_vs
+ """
out vec2 texcoord;
out vec2 pixcoord;
out vec4 offset[3];
out vec4 dummy2;
void main()
{
texcoord = vTexCoords0;
vec4 dummy1 = vec4(0);
SMAABlendingWeightCalculationVS(dummy1, dummy2, texcoord, pixcoord, offset);
gl_Position = projection_mat * modelview_mat * vec4(vPosition.xy, 0.0, 1.0);
}
"""
)
blend_fs = (
header_fs
+ """
uniform sampler2D edge_tex;
uniform sampler2D area_tex;
uniform sampler2D search_tex;
in vec2 texcoord;
in vec2 pixcoord;
in vec4 offset[3];
in vec4 dummy2;
void main()
{
gl_FragColor = SMAABlendingWeightCalculationPS(texcoord, pixcoord, offset, edge_tex, area_tex, search_tex, ivec4(0));
}
"""
)
neighborhood_vs = (
header_vs
+ """
out vec2 texcoord;
out vec4 offset[2];
out vec4 dummy2;
void main()
{
texcoord = vTexCoords0;
vec4 dummy1 = vec4(0);
SMAANeighborhoodBlendingVS(dummy1, dummy2, texcoord, offset);
gl_Position = projection_mat * modelview_mat * vec4(vPosition.xy, 0.0, 1.0);
}
"""
)
neighborhood_fs = (
header_fs
+ """
uniform sampler2D albedo_tex;
uniform sampler2D blend_tex;
in vec2 texcoord;
in vec4 offset[2];
in vec4 dummy2;
void main()
{
gl_FragColor = SMAANeighborhoodBlendingPS(texcoord, offset, albedo_tex, blend_tex);
}
"""
)
size = self.size
self.albedo_tex = Texture.create(size=size, bufferfmt="float")
self.albedo_fbo = Fbo(size=size, texture=self.albedo_tex)
self.edge_tex = Texture.create(size=size, bufferfmt="float")
self.edge_fbo = Fbo(size=size, vs=edge_vs, fs=edge_fs, texture=self.edge_tex)
self.edge_fbo.bind()
self.edge_fbo["albedo_tex"] = 0
self.edge_fbo.release()
self.blend_tex = Texture.create(size=size, bufferfmt="float")
self.blend_fbo = Fbo(size=size, vs=blend_vs, fs=blend_fs, texture=self.blend_tex)
self.blend_fbo.bind()
self.blend_fbo["edge_tex"] = 0
self.blend_fbo["area_tex"] = 1
self.blend_fbo["search_tex"] = 2
self.blend_fbo.release()
self.neighborhood = RenderContext(
use_parent_modelview=True, use_parent_projection=True, vs=neighborhood_vs, fs=neighborhood_fs
)
with self.neighborhood:
self.neighborhood["albedo_tex"] = 0
self.neighborhood["blend_tex"] = 1
self.area_tex = Texture.create(size=(AREATEX_WIDTH, AREATEX_HEIGHT), colorfmt="rg", icolorfmt="rg8")
with open(join(curdir, "smaa_area.raw"), "rb") as fd:
self.area_tex.blit_buffer(fd.read(), colorfmt="rg")
self.search_tex = Texture.create(size=(SEARCHTEX_WIDTH, SEARCHTEX_HEIGHT), colorfmt="red", icolorfmt="r8")
self.search_tex.min_filter = "nearest"
self.search_tex.mag_filter = "nearest"
with open(join(curdir, "smaa_search.raw"), "rb") as fd:
self.search_tex.blit_buffer(fd.read(), colorfmt="red")
with self.albedo_fbo:
ClearColor(0, 0, 0, 0)
ClearBuffers()
with self.edge_fbo:
Rectangle(size=self.size, texture=self.albedo_tex)
with self.blend_fbo:
BindTexture(index=1, texture=self.area_tex)
BindTexture(index=2, texture=self.search_tex)
Rectangle(size=self.size, texture=self.edge_tex)
self.neighborhood.add(self.albedo_fbo)
self.neighborhood.add(Callback(lambda *x: glDisable(GL_BLEND)))
self.neighborhood.add(self.edge_fbo)
self.neighborhood.add(self.blend_fbo)
self.neighborhood.add(Callback(lambda *x: glEnable(GL_BLEND)))
with self.neighborhood:
BindTexture(index=1, texture=self.blend_tex)
Rectangle(size=self.size, texture=self.albedo_tex)
self.smaa_canvas = Canvas()
with self.smaa_canvas.before:
def do_stuff(*args):
self.albedo_fbo.bind()
self.albedo_fbo.clear_buffer()
self.albedo_fbo.release()
self.edge_fbo.bind()
self.edge_fbo.clear_buffer()
self.edge_fbo.release()
self.blend_fbo.bind()
self.blend_fbo.clear_buffer()
self.blend_fbo.release()
self.albedo_fbo.ask_update()
self.edge_fbo.ask_update()
self.blend_fbo.ask_update()
self.neighborhood.ask_update()
Callback(do_stuff)
self.smaa_canvas.add(self.neighborhood)
self._g_debug_added = False
self._g_debug = [
Callback(lambda *x: glDisable(GL_BLEND)),
Color(0, 0, 0, 1),
Rectangle(size=self.size),
Color(1, 1, 1, 1),
Rectangle(size=self.size),
Callback(lambda *x: glEnable(GL_BLEND)),
]
