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)