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)