def createBlendShader2():
global texBlendEffect
# Create shader effect that blends textures and applies to diffuse color
code = """
Effect "Texture Blend" {
Float BlendAmount { value 0 }
Texture2D Texture1 { unit 0 }
Texture2D Texture2 { unit 1 }
Shader {
BEGIN Material
m.diffuse = mix( texture2D( Texture1, uvTexture1).rgb, texture2D( Texture2, uvTexture2).rgb, BlendAmount);
END
}
}
"""
texBlendEffect = viz.addEffect(code)
def __init__(self, terrain):
self._terrain = terrain
# Shader code for sway animation.
swayCode = """
Effect {
Type SwayAnim
Float Amp_X {
value 0.05
}
Float Amp_Y {
value 0.05
}
Float Freq_X {
value 2.3
}
Float Freq_Y {
value 0.7
}
Float TimeOffset {
value 0.0
}
Shader {
BEGIN PreTransform
eyeVertex.xyz += vec3( sin((osg_FrameTime+ TimeOffset)*Freq_X)*gl_Color.r*Amp_X, abs(cos(osg_FrameTime*Freq_Y/2.0))*gl_Color.r*Amp_Y, 0.0);
END
}
}
"""
# Add the sway effect.
self._swayEffect = viz.addEffect(swayCode)
def __init__(self, terrain):
self._terrain = terrain
causticsCode = """
Effect {
Type CausticsAnim
Texture2D CausticsTex {
coordUnit -1
}
Shader {
BEGIN FragmentHeader
//
// Description : Array and textureless GLSL 2D/3D/4D simplex
// noise functions.
// Author : Ian McEwan, Ashima Arts.
// Maintainer : ijm
// Lastmod : 20110822 (ijm)
// License : Copyright (C) 2011 Ashima Arts. All rights reserved.
// Distributed under the MIT License. See LICENSE file.
// https://github.com/ashima/webgl-noise
//
vec3 mod289(vec3 x) {
return x - floor(x * (1.0 / 289.0)) * 289.0;
}
vec4 mod289(vec4 x) {
return x - floor(x * (1.0 / 289.0)) * 289.0;
}
vec4 permute(vec4 x) {
return mod289(((x*34.0)+1.0)*x);
}
vec4 taylorInvSqrt(vec4 r) {
return 1.79284291400159 - 0.85373472095314 * r;
}
vec3 fade(vec3 t) {
return t*t*t*(t*(t*6.0-15.0)+10.0);
}
float snoise(vec3 v)
{
const vec2 C = vec2(1.0/6.0, 1.0/3.0) ;
const vec4 D = vec4(0.0, 0.5, 1.0, 2.0);
// First corner
vec3 i = floor(v + dot(v, C.yyy) );
vec3 x0 = v - i + dot(i, C.xxx) ;
// Other corners
vec3 g = step(x0.yzx, x0.xyz);
vec3 l = 1.0 - g;
vec3 i1 = min( g.xyz, l.zxy );
vec3 i2 = max( g.xyz, l.zxy );
// x0 = x0 - 0.0 + 0.0 * C.xxx;
// x1 = x0 - i1 + 1.0 * C.xxx;
// x2 = x0 - i2 + 2.0 * C.xxx;
// x3 = x0 - 1.0 + 3.0 * C.xxx;
vec3 x1 = x0 - i1 + C.xxx;
vec3 x2 = x0 - i2 + C.yyy; // 2.0*C.x = 1/3 = C.y
vec3 x3 = x0 - D.yyy; // -1.0+3.0*C.x = -0.5 = -D.y
// Permutations
i = mod289(i);
vec4 p = permute( permute( permute(
i.z + vec4(0.0, i1.z, i2.z, 1.0 ))
+ i.y + vec4(0.0, i1.y, i2.y, 1.0 ))
+ i.x + vec4(0.0, i1.x, i2.x, 1.0 ));
// Gradients: 7x7 points over a square, mapped onto an octahedron.
// The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294)
float n_ = 0.142857142857; // 1.0/7.0
vec3 ns = n_ * D.wyz - D.xzx;
vec4 j = p - 49.0 * floor(p * ns.z * ns.z); // mod(p,7*7)
vec4 x_ = floor(j * ns.z);
vec4 y_ = floor(j - 7.0 * x_ ); // mod(j,N)
vec4 x = x_ *ns.x + ns.yyyy;
vec4 y = y_ *ns.x + ns.yyyy;
vec4 h = 1.0 - abs(x) - abs(y);
vec4 b0 = vec4( x.xy, y.xy );
vec4 b1 = vec4( x.zw, y.zw );
//vec4 s0 = vec4(lessThan(b0,0.0))*2.0 - 1.0;
//vec4 s1 = vec4(lessThan(b1,0.0))*2.0 - 1.0;
vec4 s0 = floor(b0)*2.0 + 1.0;
vec4 s1 = floor(b1)*2.0 + 1.0;
vec4 sh = -step(h, vec4(0.0));
vec4 a0 = b0.xzyw + s0.xzyw*sh.xxyy ;
vec4 a1 = b1.xzyw + s1.xzyw*sh.zzww ;
vec3 p0 = vec3(a0.xy,h.x);
vec3 p1 = vec3(a0.zw,h.y);
vec3 p2 = vec3(a1.xy,h.z);
vec3 p3 = vec3(a1.zw,h.w);
//Normalise gradients
vec4 norm = taylorInvSqrt(vec4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3)));
p0 *= norm.x;
p1 *= norm.y;
p2 *= norm.z;
p3 *= norm.w;
// Mix final noise value
vec4 m = max(0.6 - vec4(dot(x0,x0), dot(x1,x1), dot(x2,x2), dot(x3,x3)), 0.0);
m = m * m;
return 42.0 * dot( m*m, vec4( dot(p0,x0), dot(p1,x1), dot(p2,x2), dot(p3,x3) ) );
}
// Classic Perlin noise
float cnoise(vec3 P)
{
vec3 Pi0 = floor(P); // Integer part for indexing
vec3 Pi1 = Pi0 + vec3(1.0); // Integer part + 1
Pi0 = mod289(Pi0);
Pi1 = mod289(Pi1);
vec3 Pf0 = fract(P); // Fractional part for interpolation
vec3 Pf1 = Pf0 - vec3(1.0); // Fractional part - 1.0
vec4 ix = vec4(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
vec4 iy = vec4(Pi0.yy, Pi1.yy);
vec4 iz0 = Pi0.zzzz;
vec4 iz1 = Pi1.zzzz;
vec4 ixy = permute(permute(ix) + iy);
vec4 ixy0 = permute(ixy + iz0);
vec4 ixy1 = permute(ixy + iz1);
vec4 gx0 = ixy0 * (1.0 / 7.0);
vec4 gy0 = fract(floor(gx0) * (1.0 / 7.0)) - 0.5;
gx0 = fract(gx0);
vec4 gz0 = vec4(0.5) - abs(gx0) - abs(gy0);
vec4 sz0 = step(gz0, vec4(0.0));
gx0 -= sz0 * (step(0.0, gx0) - 0.5);
gy0 -= sz0 * (step(0.0, gy0) - 0.5);
vec4 gx1 = ixy1 * (1.0 / 7.0);
vec4 gy1 = fract(floor(gx1) * (1.0 / 7.0)) - 0.5;
gx1 = fract(gx1);
vec4 gz1 = vec4(0.5) - abs(gx1) - abs(gy1);
vec4 sz1 = step(gz1, vec4(0.0));
gx1 -= sz1 * (step(0.0, gx1) - 0.5);
gy1 -= sz1 * (step(0.0, gy1) - 0.5);
vec3 g000 = vec3(gx0.x,gy0.x,gz0.x);
vec3 g100 = vec3(gx0.y,gy0.y,gz0.y);
vec3 g010 = vec3(gx0.z,gy0.z,gz0.z);
vec3 g110 = vec3(gx0.w,gy0.w,gz0.w);
vec3 g001 = vec3(gx1.x,gy1.x,gz1.x);
vec3 g101 = vec3(gx1.y,gy1.y,gz1.y);
vec3 g011 = vec3(gx1.z,gy1.z,gz1.z);
vec3 g111 = vec3(gx1.w,gy1.w,gz1.w);
vec4 norm0 = taylorInvSqrt(vec4(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));
g000 *= norm0.x;
g010 *= norm0.y;
g100 *= norm0.z;
g110 *= norm0.w;
vec4 norm1 = taylorInvSqrt(vec4(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));
g001 *= norm1.x;
g011 *= norm1.y;
g101 *= norm1.z;
g111 *= norm1.w;
float n000 = dot(g000, Pf0);
float n100 = dot(g100, vec3(Pf1.x, Pf0.yz));
float n010 = dot(g010, vec3(Pf0.x, Pf1.y, Pf0.z));
float n110 = dot(g110, vec3(Pf1.xy, Pf0.z));
float n001 = dot(g001, vec3(Pf0.xy, Pf1.z));
float n101 = dot(g101, vec3(Pf1.x, Pf0.y, Pf1.z));
float n011 = dot(g011, vec3(Pf0.x, Pf1.yz));
float n111 = dot(g111, Pf1);
vec3 fade_xyz = fade(Pf0);
vec4 n_z = mix(vec4(n000, n100, n010, n110), vec4(n001, n101, n011, n111), fade_xyz.z);
vec2 n_yz = mix(n_z.xy, n_z.zw, fade_xyz.y);
float n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x);
return 2.2 * n_xyz;
}
float surface3 ( vec3 coord ) {
float frequency = 4.0;
float n = 0.0;
//n += 1.0 * abs( cnoise( coord * frequency ) );
//n += 0.5 * abs( cnoise( coord * frequency * 2.0 ) );
n += 2.0 * abs( snoise( coord * frequency * 10.0) );
return n;
}
END
BEGIN FinalColor
vec2 pos = vizfx_WorldPos.xz * .1;
float dir = max(0, dot(vizfx_WorldNormal, vec3(0,1.0,0)));
float n = surface3(vec3(pos, osg_FrameTime * .03));
vec3 caustics = vec3(1-n);
//gl_FragColor.rgb += vec3(caustics * dir * 0.5);
gl_FragColor.rgb = vizfx_BlendColorDodge( gl_FragColor.rgb, vec3(caustics * dir *.25 ) );
//gl_FragColor.rgb = vec3(caustics * dir*.5);
END
}
}
"""
# Add the caustics effect.
self._causticsEffect = viz.addEffect(causticsCode)
import viz
import vizfx
#viz.setMultiSample(8)
#viz.fov(60)
viz.go()
# Add a yellow spot light
# Add white point light
light = vizfx.addPointLight(color=viz.WHITE, pos=(0,2,0))
env = vizfx.addChild('Room_improved.osgb')
code = """
Effect {
Shader {
BEGIN Material
m.diffuse = vizfx_VertexColor.rgb;
END
}
}
"""
effect = viz.addEffect(code)
# Model will inherit MyColor property value from effect
#env.apply(effect)
def __init__(self, code, propertyNames): effect = viz.addEffect(code) viz.VizEffect.__init__(self, effect.id) self._properties = set(propertyNames)
def __init__(self, textures, auto_update = True, node = None, **kwargs):
# node to reference this instance in the scenegraph
self._node = node
if self._node == None:
self._node = viz.addGroup()
viz.VizNode.__init__(self, id = self._node.id, **kwargs)
# list of models affected by the shader effect
self._affected_models = []
# save projective textures
self._textures = textures
## Initialize depth cameras.
# They are used to capture a depth buffer for each face.
# Inverse shadow mapping is performed based on these buffers,
# such that the projection only hits the fisrt surface along the projection direction.
self._depth_cams = {
viz.POSITIVE_X : viz.addRenderNode(inheritView = False),
viz.NEGATIVE_X : viz.addRenderNode(inheritView = False),
viz.POSITIVE_Y : viz.addRenderNode(inheritView = False),
viz.NEGATIVE_Y : viz.addRenderNode(inheritView = False),
viz.POSITIVE_Z : viz.addRenderNode(inheritView = False),
viz.NEGATIVE_Z : viz.addRenderNode(inheritView = False)
}
# save projective depth textures
self._depth_textures = {
viz.POSITIVE_X : None,
viz.NEGATIVE_X : None,
viz.POSITIVE_Y : None,
viz.NEGATIVE_Y : None,
viz.POSITIVE_Z : None,
viz.NEGATIVE_Z : None
}
cube_euler = {
viz.POSITIVE_X : [90,0,0],
viz.NEGATIVE_X : [-90,0,0],
viz.POSITIVE_Y : [0,-90,0],
viz.NEGATIVE_Y : [0,90,0],
viz.POSITIVE_Z : [0,0,0],
viz.NEGATIVE_Z : [-180,0,0]
}
proj_mat = viz.Matrix.perspective(90.0,1.0,0.1,100.0)
for cam in self._depth_cams:
self._depth_cams[cam].drawOrder(1000)
self._depth_cams[cam].setRenderTexture(
viz.addRenderTexture(format = viz.TEX_DEPTH),
buffer = viz.RENDER_DEPTH
)
self._depth_cams[cam].setPosition(self.getPosition())
self._depth_cams[cam].setEuler(cube_euler[cam])
self._depth_cams[cam].setProjectionMatrix(proj_mat)
self._depth_cams[cam].setAutoClip(viz.OFF)
viz.grab(self, self._depth_cams[cam])
self._depth_textures[cam] = self._depth_cams[cam].getRenderTexture(viz.RENDER_DEPTH)
# load effect
code = self._getShaderCode()
self._effect = viz.addEffect(code)
# set initial property values
self._effect.setProperty("Tex_ProjMat", proj_mat)
self._effect.setProperty("Inv_ViewMat", toGL(viz.MainView.getMatrix().inverse()))
self._effect.setProperty("Tex_ViewMat_px", toGL(eulerMat(90,0,0)*self.getMatrix()))
self._effect.setProperty("Tex_ViewMat_nx", toGL(eulerMat(-90,0,0)*self.getMatrix()))
self._effect.setProperty("Tex_ViewMat_py", toGL(eulerMat(0,-90,0)*self.getMatrix()))
self._effect.setProperty("Tex_ViewMat_ny", toGL(eulerMat(0,90,0)*self.getMatrix()))
self._effect.setProperty("Tex_ViewMat_pz", toGL(eulerMat(0,0,0)*self.getMatrix()))
self._effect.setProperty("Tex_ViewMat_nz", toGL(eulerMat(180,0,0)*self.getMatrix()))
self._effect.setProperty("Tex_px", self._textures[viz.POSITIVE_X])
self._effect.setProperty("Tex_nx", self._textures[viz.NEGATIVE_X])
self._effect.setProperty("Tex_py", self._textures[viz.POSITIVE_Y])
self._effect.setProperty("Tex_ny", self._textures[viz.NEGATIVE_Y])
self._effect.setProperty("Tex_pz", self._textures[viz.POSITIVE_Z])
self._effect.setProperty("Tex_nz", self._textures[viz.NEGATIVE_Z])
self._effect.setProperty("TexDepth_px", self._depth_textures[viz.POSITIVE_X])
self._effect.setProperty("TexDepth_nx", self._depth_textures[viz.NEGATIVE_X])
self._effect.setProperty("TexDepth_py", self._depth_textures[viz.POSITIVE_Y])
self._effect.setProperty("TexDepth_ny", self._depth_textures[viz.NEGATIVE_Y])
self._effect.setProperty("TexDepth_pz", self._depth_textures[viz.POSITIVE_Z])
self._effect.setProperty("TexDepth_nz", self._depth_textures[viz.NEGATIVE_Z])
# init auto update
self._auto_update = vizact.onupdate(0, self.update)
self._auto_update.setEnabled(auto_update)
