def __init__(self):
# open the fragment shader, assuming it's relative to this code file
vertCode = ""
with open(
os.path.join(os.path.dirname(__file__), 'view_projector.vert'),
'r') as vertFile:
vertCode = vertFile.read()
fragCode = ""
with open(
os.path.join(os.path.dirname(__file__), 'view_projector.frag'),
'r') as fragFile:
fragCode = fragFile.read()
# Make a new shader, and assign some default values for the uniforms.
# Thesewill be replaced on update.
self._shader = viz.addShader(frag=fragCode, vert=vertCode)
# temp mat to default set the uniforms
mat = vizmat.Transform()
# Holds the inverse transform of the main view.
# This will help to calculate the model matrix inside the shader.
# Such that vertices can be re-projected into view space of the projector.
self._inv_view_uni = viz.addUniformMatrix('mainViewMat_inv', mat.get())
# View matrix of the projector.
self._view_uni = viz.addUniformMatrix('viewMat', mat.get())
# Projection matrix of the projector.
self._proj_uni = viz.addUniformMatrix('projMat', mat.get())
# Holds the depth texture to perform inverse shadow mapping.
# This will allow for projecting only onto first fragment hit.
self._depth_texture_uni = viz.addUniformInt('depth_tex', 3)
# This allows for accumulation of the previous frames projection
# along with the actual frames projection.
self._prev_texture_uni = viz.addUniformInt('prev_frame_tex', 4)
# specifies an additional scaling factor for frame based accumulation (value range [0.1,1.0])
self._frame_weight_uni = viz.addUniformFloat('frame_weight', 1.0)
# specifies a scaling factor for the view cone aperture (value range [0.0,1.0])
self._aperture_scale_uni = viz.addUniformFloat('aperture_scale', 1.0)
# attach all uniforms
self._shader.attach([
self._inv_view_uni, self._view_uni, self._proj_uni,
self._depth_texture_uni, self._prev_texture_uni,
self._frame_weight_uni, self._aperture_scale_uni
])
# Camera used to capture the depth texture.
self._depth_cam = viz.addRenderNode(inheritView=False)
self._depth_cam.drawOrder(1000)
self._depth_cam.setAutoClip(False)
self._depth_cam.setRenderTexture(
viz.addRenderTexture(format=viz.TEX_DEPTH),
buffer=viz.RENDER_DEPTH)
def __init__(self,
kernel=9,
alpha=0.8,
size=256,
pos=(0, 10, 0),
euler=(0, 90, 0),
area=[5, 5],
scene=viz.MainScene):
#Create render texture
self.shadowTex = viz.addRenderTexture(wrap=viz.CLAMP_TO_BORDER,
borderColor=viz.WHITE)
#Create render node to render shadow caster to texture
self.shadowPass = viz.addRenderNode(scene=scene,
size=[size, size],
inheritView=False,
autoClip=False)
self.shadowPass.setClearColor(viz.WHITE)
self.shadowPass.attachTexture(self.shadowTex)
self.shadowPass.setScene(None)
#Apply shader to render node so everything is black
code = """
#define I %alpha%
void main()
{
gl_FragColor = vec4(I,I,I,1.0);
}
"""
shader = viz.addShader(frag=code.replace('%alpha%', str(1.0 - alpha)))
self.shadowPass.apply(shader, op=viz.OP_OVERRIDE)
#Create projector for projecting shadow texture onto receivers
self.texProj = projector.add(self.shadowTex,
scene=scene,
cubemap=False)
#Save all render node passes
self.passes = [self.shadowPass]
#Setup render nodes to blur shadow texture
if kernel:
blur_source = """
uniform sampler2D srcImage;
void main(void)
{
vec4 color = vec4(0,0,0,0);
%code%
color.a = 1.0;
gl_FragColor = color;
}"""
horz_source = 'color += texture2D( srcImage, gl_TexCoord[0].xy + vec2( %f, 0.0 ) ) * %f;'
vert_source = 'color += texture2D( srcImage, gl_TexCoord[0].xy + vec2( 0.0, %f ) ) * %f;'
#Calculate weight and offsets for blur code
weights = []
offsets = []
mid = float(kernel - 1)
kernel *= 2
for i in xrange(0, kernel, 2):
offsets.append(((i - mid) / 2.0) * (1.0 / size))
x = (i - mid) / mid
weights.append(0.05 + ((-(x * x) + 1.0) / 4.0))
#Normalize weights
frac = 1.0 / sum(weights)
weights = [frac * x for x in weights]
#Create blur code for shaders
horz_blur_code = []
vert_blur_code = []
for w, o in zip(weights, offsets):
horz_blur_code.append(horz_source % (o, w))
vert_blur_code.append(vert_source % (o, w))
#Create shaders
horzBlurShader = viz.addShader(
frag=blur_source.replace('%code%', '\n'.join(horz_blur_code)))
vertBlurShader = viz.addShader(
frag=blur_source.replace('%code%', '\n'.join(vert_blur_code)))
srcImageUniform = viz.addUniformInt('srcImage', 0)
#Render texture for ping-ponging
tex2 = viz.addRenderTexture()
"""
Pass 2 renders the shadow texture onto a quad.
The quad has a shader attached which blurs the texture horizontally.
"""
self.blurPass1 = viz.addRenderNode(scene=scene)
self.blurPass1.setHUD(0, 200, 0, 200, renderQuad=True)
self.blurPass1.setSize(size, size)
self.blurPass1.setBuffer(viz.RENDER_FBO)
self.blurPass1.setOrder(viz.PRE_RENDER, 1)
self.blurPass1.attachTexture(tex2)
self.blurPass1.texture(self.shadowTex)
self.blurPass1.apply(horzBlurShader)
self.blurPass1.apply(srcImageUniform)
self.passes.append(self.blurPass1)
"""
Pass 3 renders the texture from pass 2 onto a quad.
The quad has a shader attached which blurs the texture vertically.
"""
self.blurPass2 = viz.addRenderNode(scene=scene)
self.blurPass2.setHUD(0, 200, 0, 200, renderQuad=True)
self.blurPass2.setSize(size, size)
self.blurPass2.setBuffer(viz.RENDER_FBO)
self.blurPass2.setOrder(viz.PRE_RENDER, 2)
self.blurPass2.attachTexture(self.shadowTex)
self.blurPass2.texture(tex2)
self.blurPass2.apply(vertBlurShader)
self.blurPass2.apply(srcImageUniform)
self.passes.append(self.blurPass2)
#Remove texture/shader/uniforms (already applied)
horzBlurShader.remove()
vertBlurShader.remove()
srcImageUniform.remove()
tex2.remove()
#Initialize shadow area/pos/euler
self.setArea(area)
self.setPosition(pos)
self.setEuler(euler)
def __init__(self,kernel=9,alpha=0.8,size=256,pos=(0,10,0),euler=(0,90,0),area=[5,5],scene=viz.MainScene):
#Create render texture
self.shadowTex = viz.addRenderTexture(wrap=viz.CLAMP_TO_BORDER,borderColor=viz.WHITE)
#Create render node to render shadow caster to texture
self.shadowPass = viz.addRenderNode(scene=scene,size=[size,size],inheritView=False,autoClip=False)
self.shadowPass.setClearColor(viz.WHITE)
self.shadowPass.attachTexture(self.shadowTex)
self.shadowPass.setScene(None)
#Apply shader to render node so everything is black
code = """
#define I %alpha%
void main()
{
gl_FragColor = vec4(I,I,I,1.0);
}
"""
shader = viz.addShader(frag=code.replace('%alpha%',str(1.0-alpha)))
self.shadowPass.apply(shader,op=viz.OP_OVERRIDE)
#Create projector for projecting shadow texture onto receivers
self.texProj = projector.add(self.shadowTex,scene=scene,cubemap=False)
#Save all render node passes
self.passes = [self.shadowPass]
#Setup render nodes to blur shadow texture
if kernel:
blur_source = """
uniform sampler2D srcImage;
void main(void)
{
vec4 color = vec4(0,0,0,0);
%code%
color.a = 1.0;
gl_FragColor = color;
}"""
horz_source = 'color += texture2D( srcImage, gl_TexCoord[0].xy + vec2( %f, 0.0 ) ) * %f;'
vert_source = 'color += texture2D( srcImage, gl_TexCoord[0].xy + vec2( 0.0, %f ) ) * %f;'
#Calculate weight and offsets for blur code
weights = []
offsets = []
mid = float(kernel - 1)
kernel *= 2
for i in xrange(0,kernel,2):
offsets.append( ((i-mid) / 2.0) * (1.0 / size) )
x = (i - mid) / mid
weights.append( 0.05 + ((-(x*x) + 1.0) / 4.0) )
#Normalize weights
frac = 1.0 / sum(weights)
weights = [ frac * x for x in weights ]
#Create blur code for shaders
horz_blur_code = []
vert_blur_code = []
for w,o in zip(weights,offsets):
horz_blur_code.append(horz_source%(o,w))
vert_blur_code.append(vert_source%(o,w))
#Create shaders
horzBlurShader = viz.addShader(frag=blur_source.replace('%code%','\n'.join(horz_blur_code)))
vertBlurShader = viz.addShader(frag=blur_source.replace('%code%','\n'.join(vert_blur_code)))
srcImageUniform = viz.addUniformInt('srcImage',0)
#Render texture for ping-ponging
tex2 = viz.addRenderTexture()
"""
Pass 2 renders the shadow texture onto a quad.
The quad has a shader attached which blurs the texture horizontally.
"""
self.blurPass1 = viz.addRenderNode(scene=scene)
self.blurPass1.setHUD(0,200,0,200,renderQuad=True)
self.blurPass1.setSize(size,size)
self.blurPass1.setBuffer(viz.RENDER_FBO)
self.blurPass1.setOrder(viz.PRE_RENDER,1)
self.blurPass1.attachTexture(tex2)
self.blurPass1.texture(self.shadowTex)
self.blurPass1.apply(horzBlurShader)
self.blurPass1.apply(srcImageUniform)
self.passes.append(self.blurPass1)
"""
Pass 3 renders the texture from pass 2 onto a quad.
The quad has a shader attached which blurs the texture vertically.
"""
self.blurPass2 = viz.addRenderNode(scene=scene)
self.blurPass2.setHUD(0,200,0,200,renderQuad=True)
self.blurPass2.setSize(size,size)
self.blurPass2.setBuffer(viz.RENDER_FBO)
self.blurPass2.setOrder(viz.PRE_RENDER,2)
self.blurPass2.attachTexture(self.shadowTex)
self.blurPass2.texture(tex2)
self.blurPass2.apply(vertBlurShader)
self.blurPass2.apply(srcImageUniform)
self.passes.append(self.blurPass2)
#Remove texture/shader/uniforms (already applied)
horzBlurShader.remove()
vertBlurShader.remove()
srcImageUniform.remove()
tex2.remove()
#Initialize shadow area/pos/euler
self.setArea(area)
self.setPosition(pos)
self.setEuler(euler)
def __init__(self, texFile, **kw):
viz.startlayer(viz.QUADS)
self.node = viz.endlayer(**kw)
vert = """
uniform int light;
uniform float osg_FrameTime;
uniform mat4 osg_ViewMatrixInverse;
void main(void)
{
/* Parameters are encoded in vertex color
r - Animation time offset
g - Animation speed
b - Particle Size
*/
//Compute alpha based on time
float time = (osg_FrameTime+gl_Color.r)*gl_Color.g;
//Animate vertex
//gl_Vertex.xyz += gl_Normal*sin(time)*0.2;
gl_Vertex.x += gl_Normal.x*sin(time)*0.2;
gl_Vertex.z += gl_Normal.z*sin(time)*0.2;
//Convert to eye space
gl_Vertex.xyz = gl_ModelViewMatrix * gl_Vertex;
//Extrude point
gl_Vertex.x += (gl_MultiTexCoord0.x*2.0-1.0)*gl_Color.b;
gl_Vertex.y += (gl_MultiTexCoord0.y*2.0-1.0)*gl_Color.b;
//Save clip vertex in eye space
gl_ClipVertex = gl_Vertex;
//Convert to screen coordinates
gl_Position = gl_ProjectionMatrix * gl_Vertex;
gl_FogFragCoord = abs(gl_ClipVertex.z);
gl_TexCoord[0].xy = gl_MultiTexCoord0.xy;
}
"""
frag = """
uniform float fog;
uniform sampler2D tex;
void main(void)
{
gl_FragColor = texture2D(tex,gl_TexCoord[0].xy);
float alpha = gl_FragColor.a;
if(fog != 0.0) {
float f = exp2(fog * gl_FogFragCoord);
f = clamp(f, 0.0, 1.0);
gl_FragColor = mix(gl_Fog.color, gl_FragColor, f);
}
gl_FragColor.a = alpha;
}
"""
tex = viz.add(texFile)
texUniform = viz.addUniformInt('tex',0)
shader = viz.addShader(vert=vert,frag=frag)
self.node.apply(shader)
self.node.apply(texUniform)
# self.node.apply(_fogUniform)
self.node.disable(viz.CULLING)
self.node.texture(tex)
self.node.enable(viz.SAMPLE_ALPHA_TO_COVERAGE)
self.node.disable(viz.BLEND)
#Initialize remove list
self.removeList = []
self.removeList.append(shader)
self.removeList.append(self.node)
self.removeList.append(tex)
self.removeList.append(texUniform)
def addWaterReflection(plane, height):
SIZE = [512, 512]
REFLECT_MASK = viz.LAST_MASK << 1
#Use same septh texture for both render nodes
depth = viz.addRenderTexture(format=viz.TEX_DEPTH)
#Setup reflection texture
reflectTex = viz.addRenderTexture()
reflect = viz.addRenderNode(size=SIZE)
reflect.attachTexture(reflectTex)
reflect.attachTexture(depth, viz.RENDER_DEPTH)
reflect.setMatrix(
viz.Matrix.translate(0, -height, 0) * viz.Matrix.scale(1, -1, 1) *
viz.Matrix.translate(0, height, 0))
reflect.setInheritView(True, viz.POST_MULT)
reflect.disable(viz.CULL_FACE, op=viz.OP_OVERRIDE)
reflect.clipPlane([0, -1, 0, -height]) #OP_OVERRIDE
reflect.setCullMask(REFLECT_MASK)
#Setup refraction texture
refractTex = viz.addRenderTexture()
refract = viz.addRenderNode(size=SIZE)
refract.attachTexture(refractTex)
refract.attachTexture(depth, viz.RENDER_DEPTH)
refract.clipPlane([0, -1, 0, -height]) #OP_OVERRIDE
refract.setCullMask(REFLECT_MASK)
vert = """
attribute vec3 Tangent;
uniform float osg_FrameTime;
#define WAVE_SCALE 0.01
#define WAVE_SPEED 0.01
void main(void)
{
gl_Position = ftransform();
vec2 fTranslation= vec2(mod(osg_FrameTime, 100.0)*WAVE_SPEED, 0.0);
vec2 vTexCoords = gl_Vertex.xz*WAVE_SCALE;
// Scale texture coordinates to get mix of low/high frequency details
gl_TexCoord[1].xy = vTexCoords.xy+fTranslation*2.0;
gl_TexCoord[2].xy = vTexCoords.xy*2.0+fTranslation*4.0;
gl_TexCoord[3].xy = vTexCoords.xy*4.0+fTranslation*2.0;
gl_TexCoord[4].xy = vTexCoords.xy*8.0+fTranslation;
// perspective corrected projection
gl_TexCoord[1].zw = gl_Position.w;
gl_TexCoord[5].xy = (gl_Position.xy + gl_Position.w)*0.5;
gl_TexCoord[5].zw = vec2(1, gl_Position.w);
// get tangent space basis
vec3 n = normalize(gl_NormalMatrix * gl_Normal);
vec3 t = normalize(gl_NormalMatrix * Tangent);
vec3 b = cross(n, t);
// compute tangent space eye vector
vec3 tmpVec = -vec3(gl_ModelViewMatrix * gl_Vertex);
gl_TexCoord[0].x = dot(tmpVec, t);
gl_TexCoord[0].y = dot(tmpVec, b);
gl_TexCoord[0].z = dot(tmpVec, n);
}
"""
frag = """
uniform sampler2D water_normal;
uniform sampler2D water_reflection;
uniform sampler2D water_refraction;
#define FADE_DIST 10.0
void main(void)
{
vec3 vEye = normalize(gl_TexCoord[0].xyz);
// Get bump layers
vec3 vBumpTexA = texture2D(water_normal, gl_TexCoord[1].xy).xyz;
vec3 vBumpTexB = texture2D(water_normal, gl_TexCoord[2].xy).xyz;
vec3 vBumpTexC = texture2D(water_normal, gl_TexCoord[3].xy).xyz;
vec3 vBumpTexD = texture2D(water_normal, gl_TexCoord[4].xy).xyz;
// Average bump layers
vec3 vBumpTex = normalize(2.0 * (vBumpTexA + vBumpTexB + vBumpTexC + vBumpTexD)-4.0);
// Apply individual bump scale for refraction and reflection
vec3 vRefrBump = vBumpTex * vec3(0.02, 0.02, 1.0);
vec3 vReflBump = vBumpTex * vec3(0.1, 0.1, 1.0);
// Compute projected coordinates
vec2 vProj = (gl_TexCoord[5].xy/gl_TexCoord[5].w);
vec4 vReflection = texture2D(water_reflection, vProj.xy + vReflBump.xy);
vec4 vRefraction = texture2D(water_refraction, vProj.xy + vRefrBump.xy);
// Compute Fresnel term
float NdotL = max(dot(vEye, vReflBump), 0.0);
float facing = (1.0 - NdotL);
float fresnelBias = 0.2;
float fresnelPow = 5.0;
float fresnel = max(fresnelBias + (1.0-fresnelBias)*pow(facing, fresnelPow), 0.0);
// Use distance to lerp between refraction and deep water color
float fDistScale = clamp(FADE_DIST/gl_TexCoord[1].w,0.0,1.0);
vec3 WaterDeepColor = (vRefraction.xyz * fDistScale + (1.0 - fDistScale) * vec3(0.0, 0.1, 0.125));
// Lerp between water color and deep water color
vec3 WaterColor = vec3(0, 0.1, 0.15);
vec3 waterColor = (WaterColor * facing + WaterDeepColor * (1.0 - facing));
vec3 cReflect = fresnel * vReflection;
// final water = reflection_color * fresnel + water_color
gl_FragColor = vec4(cReflect + waterColor, 1);
}
"""
shader = viz.addShader(vert=vert, frag=frag)
shader.attach(viz.addUniformInt('water_normal', 0))
shader.attach(viz.addUniformInt('water_reflection', 1))
shader.attach(viz.addUniformInt('water_refraction', 2))
plane.apply(shader)
#Apply reflection/refraction/normal texture to plane
plane.texture(viz.add('art/waves.dds', wrap=viz.REPEAT), unit=0)
plane.texture(reflectTex, unit=1)
plane.texture(refractTex, unit=2)
#Remove reflect mask from plane so it isn't drawn during reflect/refract stage
plane.setMask(REFLECT_MASK, mode=viz.MASK_REMOVE)
def createBlendShader1():
global shader, algaeBlend, TextureUnit1Uniform, TextureUnit2Uniform
shader = viz.addShader(frag='texBlend.frag')
algaeBlend = viz.addUniformFloat('BlendAmount', 0)
TextureUnit1Uniform = viz.addUniformInt('TextureUnit1', 0)
TextureUnit2Uniform = viz.addUniformInt('TextureUnit2', 1)
import viz
#~~~~~~~~~~Shader Set up~~~~~~~~#
# Red Shader
redFragCode = """
void main()
{
gl_FragColor = vec4(171./256.,43./256.,43./256.,1.0);
}"""
redShader = viz.addShader(frag=redFragCode)
# Blue Shader
blueFragCode = """
void main()
{
gl_FragColor = vec4(43./256.,43./256.,171./256.,1.0);
}"""
blueShader = viz.addShader(frag=blueFragCode)