OpenSceneGraph 0.1.2__cp313-cp313-win_amd64.whl

OpenSceneGraph/examples/blur.py

@@ -0,0 +1,370 @@
+#!/usr/bin/env python3
+
+from OpenSceneGraph import *
+from OpenSceneGraph.GL import *
+
+import os
+import sys
+
+W, H = 800, 600
+
+os.environ.update({
+	"OSG_WINDOW": f"50 50 {W} {H}",
+	"OSG_THREADING": "SingleThreaded",
+	"OSG_GL_CONTEXT_PROFILE_MASK": "1",
+	"OSG_GL_VERSION": "4.6",
+	"OSG_GL_CONTEXT_VERSION": "4.6",
+})
+
+FULLSCREEN_VERT = """
+#version 330 core
+
+in vec4 osg_Vertex;
+in vec2 osg_MultiTexCoord0;
+
+out vec2 uv;
+
+void main() {
+	uv = osg_MultiTexCoord0;
+	gl_Position = osg_Vertex;
+}
+"""
+
+BLUR_FRAG_OLD = """
+#version 330 core
+
+uniform sampler2D inputTex;
+uniform vec2 texelStep;
+
+in vec2 uv;
+
+out vec4 fragColor;
+
+void main() {
+	// 9-tap-ish Gaussian weights.
+	// Offsets are in units of texelStep, so:
+	// horizontal: texelStep = vec2(1.0 / width, 0.0)
+	// vertical: texelStep = vec2(0.0, 1.0 / height)
+
+	vec4 sum = vec4(0.0);
+
+	sum += texture(inputTex, uv - 4.0 * texelStep) * 0.0162162162;
+	sum += texture(inputTex, uv - 3.0 * texelStep) * 0.0540540541;
+	sum += texture(inputTex, uv - 2.0 * texelStep) * 0.1216216216;
+	sum += texture(inputTex, uv - 1.0 * texelStep) * 0.1945945946;
+	sum += texture(inputTex, uv ) * 0.2270270270;
+	sum += texture(inputTex, uv + 1.0 * texelStep) * 0.1945945946;
+	sum += texture(inputTex, uv + 2.0 * texelStep) * 0.1216216216;
+	sum += texture(inputTex, uv + 3.0 * texelStep) * 0.0540540541;
+	sum += texture(inputTex, uv + 4.0 * texelStep) * 0.0162162162;
+
+	fragColor = sum;
+}
+"""
+
+BLUR_FRAG = """
+#version 330 core
+
+uniform sampler2D inputTex;
+uniform vec2 texelStep;
+// uniform float blurRadius;
+
+in vec2 uv;
+
+out vec4 fragColor;
+
+void main() {
+	// vec2 step = texelStep * blurRadius;
+	vec2 step = texelStep * 8;
+
+	vec4 sum = vec4(0.0);
+
+	sum += texture(inputTex, uv - 4.0 * step) * 0.0162162162;
+	sum += texture(inputTex, uv - 3.0 * step) * 0.0540540541;
+	sum += texture(inputTex, uv - 2.0 * step) * 0.1216216216;
+	sum += texture(inputTex, uv - 1.0 * step) * 0.1945945946;
+	sum += texture(inputTex, uv ) * 0.2270270270;
+	sum += texture(inputTex, uv + 1.0 * step) * 0.1945945946;
+	sum += texture(inputTex, uv + 2.0 * step) * 0.1216216216;
+	sum += texture(inputTex, uv + 3.0 * step) * 0.0540540541;
+	sum += texture(inputTex, uv + 4.0 * step) * 0.0162162162;
+
+	fragColor = sum;
+}
+"""
+
+COMPOSITE_FRAG = """
+#version 330 core
+
+uniform sampler2D sceneTex;
+uniform sampler2D blurTex;
+
+uniform float glowStrength;
+
+in vec2 uv;
+
+out vec4 fragColor;
+
+void main() {
+	vec4 scene = texture(sceneTex, uv);
+	vec4 blur = texture(blurTex, uv);
+
+	// Red sensor/display-style tint applied to the original.
+	vec3 redScene = scene.rgb * vec3(1.0, 0.28, 0.28);
+
+	// Red glow from blurred image.
+	vec3 redGlow = blur.rgb * vec3(1.0, 0.12, 0.08) * glowStrength;
+
+	// Screen-space scanlines.
+	float scan = step(0.35, fract(gl_FragCoord.y * 0.25));
+	scan = mix(0.72, 1.0, scan);
+
+	// Vignette.
+	float d = distance(uv, vec2(0.5));
+	float vignette = smoothstep(0.42, 0.12, d);
+
+	vec3 color = (redScene + redGlow) * scan * vignette;
+
+	fragColor = vec4(color, 1.0);
+}
+"""
+
+def make_color_texture(w, h):
+	tex = osg.Texture2D()
+
+	tex.size = (w, h)
+	tex.internalFormat = GL_RGBA
+	tex.filter = (osg.Texture.LINEAR, osg.Texture.LINEAR)
+	tex.wrap = (osg.Texture.CLAMP_TO_EDGE, osg.Texture.CLAMP_TO_EDGE)
+
+	return tex
+
+def make_fullscreen_quad():
+	geode = osg.Geode(name="fullscreen-quad")
+
+	geode.drawables.append(osg.createTexturedQuadGeometry(
+		osg.Vec3(-1.0, -1.0, -1.0),
+		osg.Vec3(2.0, 0.0, 0.0),
+		osg.Vec3(0.0, 2.0, 0.0),
+	))
+
+	return geode
+
+def make_program(name, vert, frag):
+	return osg.Program(name=name, shaders=(
+		osg.Shader(osg.Shader.VERTEX, vert),
+		osg.Shader(osg.Shader.FRAGMENT, frag),
+	))
+
+def make_scene_rtt_pass(output_tex, scene, w, h, name="Scene RTT"):
+	cam = osg.Camera()
+
+	cam.name = name
+	cam.renderOrder = (osg.Camera.PRE_RENDER, 0)
+	cam.renderTargetImplementation = osg.Camera.FRAME_BUFFER_OBJECT
+	cam.clearMask = GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT
+	# Important for blur/glow: clear to transparent black-ish, not visible blue.
+	# Since the final composite currently ignores alpha, RGB is what matters most.
+	cam.clearColor = osg.Vec4(0.0, 0.0, 0.0, 1.0)
+	cam.viewport = osg.Viewport(0, 0, w, h)
+	cam.attach(osg.Camera.COLOR_BUFFER, output_tex)
+
+	cam.children.append(scene)
+
+	return cam
+
+def make_fullscreen_rtt_pass(
+	input_tex,
+	output_tex,
+	frag_shader,
+	w,
+	h,
+	name="Post RTT",
+	order=1,
+	extra_uniforms=None
+):
+	cam = osg.Camera()
+
+	cam.name = name
+	cam.renderOrder = (osg.Camera.PRE_RENDER, order)
+	cam.dataVariance = osg.Object.DYNAMIC
+	cam.renderTargetImplementation = osg.Camera.FRAME_BUFFER_OBJECT
+	cam.clearMask = GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT
+	cam.clearColor = osg.Vec4(0.0, 0.0, 0.0, 1.0)
+	cam.viewport = osg.Viewport(0, 0, w, h)
+	cam.projectionMatrix = osg.Matrix.identity()
+	cam.viewMatrix = osg.Matrix.identity()
+	cam.referenceFrame = osg.Transform.ABSOLUTE_RF
+	cam.allowEventFocus = False
+
+	cam.attach(osg.Camera.COLOR_BUFFER, output_tex)
+
+	prog = make_program(f"{name}_program", FULLSCREEN_VERT, frag_shader)
+
+	cam.stateSet.attributes[osg.StateAttribute.PROGRAM] = (
+		prog,
+		osg.StateAttribute.ON | osg.StateAttribute.OVERRIDE
+	)
+
+	cam.stateSet.textureAttributes[0] = (
+		input_tex,
+		osg.StateAttribute.ON | osg.StateAttribute.OVERRIDE
+	)
+
+	cam.stateSet.uniforms["inputTex"] = 0
+
+	if extra_uniforms:
+		for k, v in extra_uniforms.items():
+			cam.stateSet.uniforms[k] = v
+
+	cam.children.append(make_fullscreen_quad())
+
+	return cam
+
+def make_blur_pass(input_tex, output_tex, w, h, direction, name, order):
+	if direction == "horizontal":
+		texel_step = osg.Vec2(1.0 / float(w), 0.0)
+
+	elif direction == "vertical":
+		texel_step = osg.Vec2(0.0, 1.0 / float(h))
+
+	else:
+		raise ValueError(f"invalid blur direction: {direction!r}")
+
+	return make_fullscreen_rtt_pass(
+		input_tex=input_tex,
+		output_tex=output_tex,
+		frag_shader=BLUR_FRAG,
+		w=w,
+		h=h,
+		name=name,
+		order=order,
+		extra_uniforms={
+			"texelStep": texel_step
+		}
+	)
+
+def make_composite_hud(scene_tex, blur_tex, w, h):
+	cam = osg.Camera()
+
+	cam.name = "Composite HUD"
+	cam.renderOrder = osg.Camera.POST_RENDER
+	cam.clearMask = GL_DEPTH_BUFFER_BIT
+	cam.viewport = osg.Viewport(0, 0, w, h)
+	cam.projectionMatrix = osg.Matrix.identity()
+	cam.viewMatrix = osg.Matrix.identity()
+	cam.referenceFrame = osg.Transform.ABSOLUTE_RF
+	cam.allowEventFocus = False
+
+	prog = make_program("composite_hud_program", FULLSCREEN_VERT, COMPOSITE_FRAG)
+
+	cam.stateSet.attributes[osg.StateAttribute.PROGRAM] = (
+		prog,
+		osg.StateAttribute.ON | osg.StateAttribute.OVERRIDE,
+	)
+
+	cam.stateSet.textureAttributes[0] = (
+		scene_tex,
+		osg.StateAttribute.ON | osg.StateAttribute.OVERRIDE,
+	)
+	cam.stateSet.textureAttributes[1] = (
+		blur_tex,
+		osg.StateAttribute.ON | osg.StateAttribute.OVERRIDE,
+	)
+
+	cam.stateSet.uniforms["sceneTex"] = 0
+	cam.stateSet.uniforms["blurTex"] = 1
+	cam.stateSet.uniforms["glowStrength"] = 2.0
+
+	cam.children.append(make_fullscreen_quad())
+
+	return cam
+
+# Make this do WHATEVER YOU WANT. :) It'll work just fine...
+def create_scene():
+	return osgDB.readNodeFile(len(sys.argv) >= 2 and sys.argv[1] or "glsl_simple.osgt")
+
+# The real pipeline-assembly entrypoint -- returns the root Node, no viewer/window side
+# effects. This is what external tooling (e.g. etc/pyside6-glsl.py's shader-editor scaffold)
+# imports and calls directly, so it MUST stay side-effect-free w.r.t. any global viewer state.
+# Takes (w, h) explicitly -- e.g. the real widget size at the caller's GL-context-current
+# point -- rather than reading the module-level W/H globals, which only __main__ below uses.
+def build_scene(w, h):
+	# Pass outputs:
+	#
+	# sceneColor: original osgSlug scene
+	# blurA: horizontal blur of sceneColor
+	# blurB: vertical blur of blurA
+	sceneColor = make_color_texture(w, h)
+	blurA = make_color_texture(w, h)
+	blurB = make_color_texture(w, h)
+
+	sceneColor.dataVariance = osg.Object.DYNAMIC
+	blurA.dataVariance = osg.Object.DYNAMIC
+	blurB.dataVariance = osg.Object.DYNAMIC
+
+	# Pass 1:
+	# Render actual scene to sceneColor.
+	scene_pass = make_scene_rtt_pass(
+		output_tex=sceneColor,
+		scene=create_scene(),
+		w=w,
+		h=h,
+		name="Scene RTT"
+	)
+
+	# Pass 2:
+	# Horizontal blur: sceneColor -> blurA.
+	blur_h_pass = make_blur_pass(
+		input_tex=sceneColor,
+		output_tex=blurA,
+		w=w,
+		h=h,
+		direction="horizontal",
+		name="Blur Horizontal RTT",
+		order=1
+	)
+
+	# Pass 3:
+	# Vertical blur: blurA -> blurB.
+	blur_v_pass = make_blur_pass(
+		input_tex=blurA,
+		output_tex=blurB,
+		w=w,
+		h=h,
+		direction="vertical",
+		name="Blur Vertical RTT",
+		order=2
+	)
+
+	# Pass 4:
+	# Composite original scene + blurred glow to default framebuffer.
+	hud = make_composite_hud(
+		scene_tex=sceneColor,
+		blur_tex=blurB,
+		w=w,
+		h=h
+	)
+
+	root = osg.Group()
+	root.children.extend((
+		scene_pass,
+		blur_h_pass,
+		blur_v_pass,
+		hud
+	))
+
+	return root
+
+if __name__ == "__main__":
+	viewer = osgViewer.Viewer()
+	viewer.sceneData = build_scene(W, H)
+	viewer.cameraManipulator = osgGA.TrackballManipulator()
+
+	# Should not be visible if HUD composite is covering the whole screen.
+	viewer.camera.clearColor = osg.Vec4(1.0, 0.0, 1.0, 1.0)
+
+	viewer.TODO()
+
+	while not viewer.done:
+		viewer.frame()

OpenSceneGraph/examples/info.py

@@ -0,0 +1,126 @@
+#!/usr/bin/env python3
+
+# Quick diagnostic dump, not an interactive viewer: build_info() from OpenSceneGraph (and osgx,
+# if installed), the REQUESTED GL context (DisplaySettings, sourced from the OSG_GL_VERSION/
+# OSG_GL_CONTEXT_VERSION/OSG_GL_CONTEXT_PROFILE_MASK env vars set below), what a realized
+# GraphicsContext's own Traits resolved that request to, and what the driver ACTUALLY granted
+# (State.glExtensions). Realizes just long enough to populate that last part, then exits.
+# Edit the env vars below (or unset them) to see how the three stages diverge -- e.g. request a
+# GL version the driver doesn't support and watch Traits echo the request back while
+# GLExtensions reports what was actually negotiated instead.
+
+import os
+import sys
+
+os.environ.update({
+	"OSG_WINDOW": "50 50 100 100",
+	"OSG_THREADING": "SingleThreaded",
+	"OSG_GL_CONTEXT_PROFILE_MASK": "1",
+	"OSG_GL_VERSION": "4.6",
+	"OSG_GL_CONTEXT_VERSION": "4.6",
+})
+
+from OpenSceneGraph import *
+
+GL_EXTENSION_FIELDS = (
+	"contextID",
+	"glVersion",
+	"glslLanguageVersion",
+	"isGlslSupported",
+	"isShaderObjectsSupported",
+	"isVertexShaderSupported",
+	"isFragmentShaderSupported",
+	"isLanguage100Supported",
+	"isGeometryShader4Supported",
+	"areTessellationShadersSupported",
+	"isGpuShader4Supported",
+	"isUniformBufferObjectSupported",
+	"isGetProgramBinarySupported",
+	"isGpuShaderFp64Supported",
+	"isShaderAtomicCountersSupported",
+	"isRectangleSupported",
+	"isCubeMapSupported",
+	"isClipControlSupported",
+)
+
+def section(title):
+	print(f"\n== {title} ==")
+
+def dump(label, value):
+	# Display-only rounding: glVersion/glslLanguageVersion are C++ `float` (32-bit), so e.g.
+	# 4.6's nearest float32 widens to 4.599999904632568 once pybind11 hands it back as a
+	# Python (64-bit) float -- a real, if slightly lossy, binary representation, not corrupted
+	# data. Round here for a readable dump only; anything doing a real comparison against
+	# these values should still read the unrounded field directly.
+	if isinstance(value, float):
+		value = round(value, 4)
+
+	print(f"  {label:<32} {value}")
+
+def main(viewer):
+	section("build_info()")
+
+	for key, value in build_info().items():
+		dump(key, value)
+
+	try:
+		import osgx
+
+		section("build_info() [osgx]")
+
+		for key, value in osgx.build_info().items():
+			dump(key, value)
+
+	except ImportError:
+		section("osgx")
+		dump("status", "not installed")
+
+	section("DisplaySettings (requested)")
+
+	ds = osg.DisplaySettings.instance
+
+	dump("glContextVersion", repr(ds.glContextVersion))
+	dump("glContextProfileMask", ds.glContextProfileMask)
+	dump("glContextFlags", ds.glContextFlags)
+	dump("numMultiSamples", ds.numMultiSamples)
+
+	# viewer = osgViewer.Viewer()
+	#
+	# viewer.cameraManipulator = osgGA.TrackballManipulator()
+	viewer.realize()
+	viewer.frame()
+
+	gc = viewer.camera.graphicsContext
+
+	if not gc or not gc.valid():
+		sys.exit("error: failed to realize a GraphicsContext")
+
+	traits = gc.traits
+
+	section("GraphicsContext.Traits (resolved)")
+
+	dump("x, y", f"{traits.x}, {traits.y}")
+	dump("width, height", f"{traits.width}, {traits.height}")
+	dump("glContextVersion", repr(traits.glContextVersion))
+	dump("glContextProfileMask", traits.glContextProfileMask)
+	dump("glContextFlags", traits.glContextFlags)
+
+	section("GLExtensions (actual, from the driver)")
+
+	ext = gc.state.glExtensions
+
+	for field in GL_EXTENSION_FIELDS:
+		dump(field, getattr(ext, field))
+
+	print()
+
+	viewer.close()
+
+def build_scene(*args):
+	return None
+
+def configure_viewer(viewer, root):
+	main(viewer)
+
+if __name__ == "__main__":
+	main(osgViewer.Viewer())