public void OnWillRenderObject() { if (m_MatProps == null) { m_MatProps = new MaterialPropertyBlock(); } Camera cam = Camera.current; cam.depthTextureMode |= DepthTextureMode.Depth; m_MatProps.Clear(); m_MatProps.AddVector("_CameraLocalPos", transform.InverseTransformPoint(cam.transform.position)); m_MatProps.AddMatrix("_CameraToLocal", transform.worldToLocalMatrix * cam.transform.localToWorldMatrix); m_MatProps.AddVector("_Scale", transform.localScale); m_MatProps.AddFloat("_Brightness", m_Brightness); if (Application.isPlaying) { float time = Time.time; m_TimeElapsed += m_Speed * (time - m_LastFrameTime); m_LastFrameTime = time; Shader.SetGlobalFloat("_FireTime", m_StartTime + m_TimeElapsed); } else { Shader.SetGlobalFloat("_FireTime", m_StartTime); } renderer.SetPropertyBlock(m_MatProps); }
/* * Sets the shader uniforms that are necessary to project on screen the * given TerrainQuad. This method can set the uniforms that are specific to * the given quad. */ public virtual void SetUniforms(TerrainNode node, TerrainQuad quad, MaterialPropertyBlock matPropertyBlock) { if (matPropertyBlock == null || node == null || quad == null) { return; } double ox = quad.GetOX(); double oy = quad.GetOY(); double l = quad.GetLength(); double distFactor = (double)node.GetDistFactor(); int level = quad.GetLevel(); matPropertyBlock.AddVector(m_uniforms.offset, new Vector4((float)ox, (float)oy, (float)l, (float)level)); Vector3d2 camera = node.GetLocalCameraPos(); matPropertyBlock.AddVector(m_uniforms.camera, new Vector4((float)((camera.x - ox) / l), (float)((camera.y - oy) / l), (float)((camera.z - node.GetView().GetGroundHeight()) / (l * distFactor)), (float)camera.z)); Vector3d2 c = node.GetLocalCameraPos(); Matrix3x3d m = m_localToTangent * (new Matrix3x3d(l, 0.0, ox - c.x, 0.0, l, oy - c.y, 0.0, 0.0, 1.0)); matPropertyBlock.AddMatrix(m_uniforms.tileToTangent, m.ToMatrix4x4()); SetScreenUniforms(node, quad, matPropertyBlock); }
MaterialPropertyBlock get_properties(int scale, float x, float y, float tex_x, float tex_y) { level_property_block.Clear(); level_property_block.AddVector("_slab_scale", new Vector4(scale, scale)); level_property_block.AddVector("_slab_origin", new Vector4(x, y)); level_property_block.AddVector("_slab_tex_origin", new Vector4(tex_x, tex_y)); return(level_property_block); }
public void SetTile(MaterialPropertyBlock matPropertyBlock, int level, int tx, int ty) { if (!m_producer.IsGPUProducer()) { return; } RenderTexture tex = null; Vector3 coords = Vector3.zero, size = Vector3.zero; SetTile(ref tex, ref coords, ref size, level, tx, ty); matPropertyBlock.AddTexture(m_uniforms.tile, tex); matPropertyBlock.AddVector(m_uniforms.tileCoords, coords); matPropertyBlock.AddVector(m_uniforms.tileSize, size); }
void LateUpdate() { float t = 0.0f; float dt = Time.deltaTime; if (ignoreTimescale == true) { t = Time.realtimeSinceStartup; } else { t = BulletTime.time; } t = t / 20.0f; // To match with Time.x in the shader. softDirection = Vector3.Lerp(softDirection, Vector3.Normalize(lastPos - transform.position), Responsiveness * 30f * dt); lastPos = transform.position; var wind = softDirection * Strength + transform.TransformDirection(ObjectSpaceWind); if (properties == null) { return; } properties.Clear(); properties.AddVector("_Wind", wind.normalized); properties.AddFloat("_T", t); GetComponent <Renderer>().SetPropertyBlock(properties); }
public void AddToMaterialPropertyBlock(MaterialPropertyBlock block) { Node first = this.first; int count = this.count; while (count-- > 0) { switch (first.type) { case PropType.Float: block.AddFloat(first.property, first.value.FLOAT); break; case PropType.Vector: block.AddVector(first.property, first.value.VECTOR); break; case PropType.Color: block.AddColor(first.property, first.value.COLOR); break; case PropType.Matrix: block.AddMatrix(first.property, first.value.MATRIX); break; } first = first.next; } }
static int AddVector(IntPtr L) { int count = LuaDLL.lua_gettop(L); Type[] types0 = { typeof(MaterialPropertyBlock), typeof(int), typeof(Vector4) }; Type[] types1 = { typeof(MaterialPropertyBlock), typeof(string), typeof(Vector4) }; if (count == 3 && LuaScriptMgr.CheckTypes(L, types0, 1)) { MaterialPropertyBlock obj = LuaScriptMgr.GetNetObject <MaterialPropertyBlock>(L, 1); int arg0 = (int)LuaScriptMgr.GetNumber(L, 2); Vector4 arg1 = LuaScriptMgr.GetNetObject <Vector4>(L, 3); obj.AddVector(arg0, arg1); return(0); } else if (count == 3 && LuaScriptMgr.CheckTypes(L, types1, 1)) { MaterialPropertyBlock obj = LuaScriptMgr.GetNetObject <MaterialPropertyBlock>(L, 1); string arg0 = LuaScriptMgr.GetString(L, 2); Vector4 arg1 = LuaScriptMgr.GetNetObject <Vector4>(L, 3); obj.AddVector(arg0, arg1); return(0); } else { LuaDLL.luaL_error(L, "invalid arguments to method: MaterialPropertyBlock.AddVector"); } return(0); }
// Token: 0x06004B62 RID: 19298 RVA: 0x0012667C File Offset: 0x0012487C public void AddToMaterialPropertyBlock(MaterialPropertyBlock block) { global::UIPanelMaterialPropertyBlock.Node next = this.first; int num = this.count; while (num-- > 0) { switch (next.type) { case global::UIPanelMaterialPropertyBlock.PropType.Float: block.AddFloat(next.property, next.value.FLOAT); break; case global::UIPanelMaterialPropertyBlock.PropType.Vector: block.AddVector(next.property, next.value.VECTOR); break; case global::UIPanelMaterialPropertyBlock.PropType.Color: block.AddColor(next.property, next.value.COLOR); break; case global::UIPanelMaterialPropertyBlock.PropType.Matrix: block.AddMatrix(next.property, next.value.MATRIX); break; } next = next.next; } }
public void SetOffset(Vector4 offset) { MaterialPropertyBlock props = new MaterialPropertyBlock(); GetComponent <Renderer>().GetPropertyBlock(props); props.AddVector(offsetID, offset); GetComponent <Renderer>().SetPropertyBlock(props); }
public MaterialPropertyBlock CreatePropertiesBlock() { MaterialPropertyBlock material = new MaterialPropertyBlock(); material.AddVector(_idMinBounds, _minBounds); material.AddVector(_idMaxBounds, _maxBounds); material.AddMatrix(_idProjection, _projectionMatrixCached); material.AddMatrix(_idViewWorldLight, _viewWorldLight); material.AddMatrix(_idLocalRotation, _localRotation); material.AddMatrix(_idRotation, _rotation); material.AddColor(_idColorTint, colorTint); material.AddFloat(_idSpotExponent, spotExponent); material.AddFloat(_idConstantAttenuation, constantAttenuation); material.AddFloat(_idLinearAttenuation, linearAttenuation); material.AddFloat(_idQuadraticAttenuation, quadraticAttenuation); material.AddFloat(_idLightMultiplier, lightMultiplier); switch (shadowMode) { case ShadowMode.Realtime: renderer.sharedMaterial.SetTexture("_ShadowTexture", _depthTexture); break; case ShadowMode.Baked: break; case ShadowMode.None: renderer.sharedMaterial.SetTexture("_ShadowTexture", null); break; } #if UNITY_4_2 || UNITY_4_3 || UNITY_4_4 float far = camera.farClipPlane; float near = camera.nearClipPlane; float fov = camera.fieldOfView; #else float far = camera.far; float near = camera.near; float fov = camera.fov; #endif material.AddVector(_idLightParams, new Vector4(near, far, far - near, (camera.isOrthoGraphic) ? Mathf.PI : fov * 0.5f * Mathf.Deg2Rad)); return(material); }
void Update() { if (_needsReset) { ResetResources(); } UpdateKernelShader(); if (Application.isPlaying) { // Swap the particle buffers. var temp = _positionBuffer1; _positionBuffer1 = _positionBuffer2; _positionBuffer2 = temp; temp = _rotationBuffer1; _rotationBuffer1 = _rotationBuffer2; _rotationBuffer2 = temp; // Call the kernel shader. Graphics.Blit(_positionBuffer1, _positionBuffer2, _kernelMaterial, 2); Graphics.Blit(_rotationBuffer1, _rotationBuffer2, _kernelMaterial, 3); } else { InitializeAndPrewarmBuffers(); } // Make a material property block for the following drawcalls. var props = new MaterialPropertyBlock(); props.SetTexture("_PositionBuffer", _positionBuffer2); props.SetTexture("_RotationBuffer", _rotationBuffer2); props.SetFloat("_ScaleMin", _minScale); props.SetFloat("_ScaleMax", _maxScale); props.SetFloat("_RandomSeed", _randomSeed); // Temporary variables var mesh = _bulkMesh.mesh; var position = transform.position; var rotation = transform.rotation; var material = _material ? _material : _defaultMaterial; var uv = new Vector2(0.5f / _positionBuffer2.width, 0); // Draw a bulk mesh repeatedly. for (var i = 0; i < _positionBuffer2.height; i++) { uv.y = (0.5f + i) / _positionBuffer2.height; props.AddVector("_BufferOffset", uv); Graphics.DrawMesh( mesh, position, rotation, material, 0, null, 0, props, _castShadows, _receiveShadows); } }
public virtual void OnWillRenderObject() { if (m_mpb == null) { m_mpb = new MaterialPropertyBlock(); m_mpb.AddVector("_Position", Vector4.zero); m_mpb.AddVector("_Rotation", Vector4.zero); m_mpb.AddVector("_Scale", Vector4.one); m_renderer = GetComponent <Renderer>(); m_trans = GetComponent <Transform>(); } var rot = m_trans.rotation; m_mpb.SetVector("_Position", m_trans.position); m_mpb.SetVector("_Rotation", new Vector4(rot.x, rot.y, rot.z, rot.w)); m_mpb.SetVector("_Scale", m_trans.localScale); m_renderer.SetPropertyBlock(m_mpb); }
void Update() { if (_needsReset) { ResetResources(); } // Advance the time variables. _rotationNoiseTime += _rotationNoiseSpeed * Time.deltaTime; // Call the kernels. UpdateKernelShader(); if (_needsReset || _positionUpdateFlag) { Graphics.Blit(null, _positionBuffer, _kernelMaterial, 0); } Graphics.Blit(null, _rotationBuffer, _kernelMaterial, 1); if (_needsReset || _scaleUpdateFlag) { Graphics.Blit(null, _scaleBuffer, _kernelMaterial, 2); } // Make a material property block for the following drawcalls. var props = new MaterialPropertyBlock(); props.AddTexture("_PositionTex", _positionBuffer); props.AddTexture("_RotationTex", _rotationBuffer); props.AddTexture("_ScaleTex", _scaleBuffer); // Temporary variables. var mesh = _bulkMesh.mesh; var position = transform.position; var rotation = transform.rotation; var material = _material ? _material : _defaultMaterial; var uv = new Vector2(0.5f / _positionBuffer.width, 0); // Draw mesh segments. for (var i = 0; i < _positionBuffer.height; i++) { uv.y = (0.5f + i) / _positionBuffer.height; props.AddVector("_BufferOffset", uv); Graphics.DrawMesh( mesh, position, rotation, material, 0, null, 0, props, _castShadows, _receiveShadows); } // Clear flag variables. _positionUpdateFlag = true; _scaleUpdateFlag = true; _needsReset = false; }
protected override void SetScreenUniforms(TerrainNode node, TerrainQuad quad, MaterialPropertyBlock matPropertyBlock) { double ox = quad.GetOX(); double oy = quad.GetOY(); double l = quad.GetLength(); Vector3d2 p0 = new Vector3d2(ox, oy, R); Vector3d2 p1 = new Vector3d2(ox + l, oy, R); Vector3d2 p2 = new Vector3d2(ox, oy + l, R); Vector3d2 p3 = new Vector3d2(ox + l, oy + l, R); Vector3d2 pc = (p0 + p3) * 0.5; double l0 = 0.0, l1 = 0.0, l2 = 0.0, l3 = 0.0; Vector3d2 v0 = p0.Normalized(ref l0); Vector3d2 v1 = p1.Normalized(ref l1); Vector3d2 v2 = p2.Normalized(ref l2); Vector3d2 v3 = p3.Normalized(ref l3); Matrix4x4d deformedCorners = new Matrix4x4d(v0.x * R, v1.x * R, v2.x * R, v3.x * R, v0.y * R, v1.y * R, v2.y * R, v3.y * R, v0.z * R, v1.z * R, v2.z * R, v3.z * R, 1.0, 1.0, 1.0, 1.0); matPropertyBlock.AddMatrix(m_uniforms.screenQuadCorners, (m_localToScreen * deformedCorners).ToMatrix4x4()); Matrix4x4d deformedVerticals = new Matrix4x4d(v0.x, v1.x, v2.x, v3.x, v0.y, v1.y, v2.y, v3.y, v0.z, v1.z, v2.z, v3.z, 0.0, 0.0, 0.0, 0.0); matPropertyBlock.AddMatrix(m_uniforms.screenQuadVerticals, (m_localToScreen * deformedVerticals).ToMatrix4x4()); matPropertyBlock.AddVector(m_uniforms.screenQuadCornerNorms, new Vector4((float)l0, (float)l1, (float)l2, (float)l3)); Vector3d2 uz = pc.Normalized(); Vector3d2 ux = (new Vector3d2(0, 1, 0)).Cross(uz).Normalized(); Vector3d2 uy = uz.Cross(ux); Matrix4x4d ltow = node.GetLocalToWorld(); Matrix3x3d tangentFrameToWorld = new Matrix3x3d(ltow.m[0, 0], ltow.m[0, 1], ltow.m[0, 2], ltow.m[1, 0], ltow.m[1, 1], ltow.m[1, 2], ltow.m[2, 0], ltow.m[2, 1], ltow.m[2, 2]); Matrix3x3d m = new Matrix3x3d(ux.x, uy.x, uz.x, ux.y, uy.y, uz.y, ux.z, uy.z, uz.z); matPropertyBlock.AddMatrix(m_uniforms.tangentFrameToWorld, (tangentFrameToWorld * m).ToMatrix4x4()); }
void Update() { if (_needsReset) { ResetResources(); } ApplyKernelParameters(); if (Application.isPlaying) { // Swap the buffers. var temp = _positionBuffer1; _positionBuffer1 = _positionBuffer2; _positionBuffer2 = temp; temp = _rotationBuffer1; _rotationBuffer1 = _rotationBuffer2; _rotationBuffer2 = temp; } else { // Editor: initialize the buffer on every update. Graphics.Blit(null, _positionBuffer1, _kernelMaterial, 0); Graphics.Blit(null, _rotationBuffer1, _kernelMaterial, 1); } // Apply the kernel shaders. Graphics.Blit(_positionBuffer1, _positionBuffer2, _kernelMaterial, 2); Graphics.Blit(_rotationBuffer1, _rotationBuffer2, _kernelMaterial, 3); // Draw the bulk mesh. _surfaceMaterial.SetTexture("_PositionTex", _positionBuffer2); _surfaceMaterial.SetTexture("_RotationTex", _rotationBuffer2); _surfaceMaterial.SetColor("_Color", _color); _surfaceMaterial.SetVector("_ScaleParams", new Vector2(_minScale, _maxScale)); var uv = new Vector2(0.5f / _positionBuffer2.width, 0); var offset = new MaterialPropertyBlock(); for (var i = 0; i < _positionBuffer2.height; i++) { uv.y = (0.5f + i) / _positionBuffer2.height; offset.AddVector("_BufferOffset", uv); Graphics.DrawMesh(_bulkMesh.mesh, transform.position, transform.rotation, _surfaceMaterial, 0, null, 0, offset); } }
void Update() { if (_needsReset) { ResetResources(); } // Call the kernels. UpdateKernelShader(); Graphics.Blit(null, _positionBuffer, _kernelMaterial, 0); Graphics.Blit(null, _rotationBuffer, _kernelMaterial, 1); Graphics.Blit(null, _scaleBuffer, _kernelMaterial, 2); // Make a material property block for the following drawcalls. var props = new MaterialPropertyBlock(); props.AddTexture("_PositionTex", _positionBuffer); props.AddTexture("_RotationTex", _rotationBuffer); props.AddTexture("_ScaleTex", _scaleBuffer); props.SetVector("_ColumnRow", new Vector2(_columns, _rows)); props.SetVector("_UVOffset", UVOffset); // Temporary variables. var mesh = _bulkMesh.mesh; var position = transform.position; var rotation = transform.rotation; var material = _material ? _material : _defaultMaterial; var uv = new Vector2(0.5f / _positionBuffer.width, 0); position += transform.right * XOffset; position += transform.up * YOffset; // Draw mesh segments. for (var i = 0; i < _positionBuffer.height; i++) { uv.y = (0.5f + i) / _positionBuffer.height; props.AddVector("_BufferOffset", uv); Graphics.DrawMesh( mesh, position, rotation, material, 0, null, 0, props, _castShadows, _receiveShadows); } }
// Update is called once per frame void Update() { //编辑模式 if (!Application.isPlaying) { //获取材质信息 MeshRenderer meshRender = gameObject.GetComponent <MeshRenderer>(); if (meshRender != null) { // meshRender.sharedMaterial.color = Color.black; //meshRender.sharedMaterial.SetVector("_TintColor", new Vector4(1, 0, 0, 1)); MaterialPropertyBlock block = new MaterialPropertyBlock(); block.AddVector("_TintColor", new Vector4(color.r, color.g, color.b, 1)); meshRender.SetPropertyBlock(block); //Debug.Log("editor" + color.ToString()); } } }
public void AddToMaterialPropertyBlock(MaterialPropertyBlock block) { UIPanelMaterialPropertyBlock.Node node = this.first; int num = this.count; while (true) { int num1 = num; num = num1 - 1; if (num1 <= 0) { break; } switch (node.type) { case UIPanelMaterialPropertyBlock.PropType.Float: { block.AddFloat(node.property, [email protected]); break; } case UIPanelMaterialPropertyBlock.PropType.Vector: { block.AddVector(node.property, [email protected]); break; } case UIPanelMaterialPropertyBlock.PropType.Color: { block.AddColor(node.property, [email protected]); break; } case UIPanelMaterialPropertyBlock.PropType.Matrix: { block.AddMatrix(node.property, [email protected]); break; } } node = node.next; } }
private void ApplyToBlock(ref MaterialPropertyBlock block, ShaderIDs bids) { #if USE_PROPERTY_BLOCKS block.AddVector(bids.exposureIBL, exposures); block.AddVector(bids.exposureLM, exposuresLM); block.AddMatrix(bids.skyMatrix, skyMatrix); block.AddMatrix(bids.invSkyMatrix, invMatrix); block.AddVector(bids.skyMin, skyMin); block.AddVector(bids.skyMax, skyMax); if (specularCube) { block.AddTexture(bids.specCubeIBL, specularCube); } else { block.AddTexture(bids.specCubeIBL, blackCube); } block.AddVector(bids.SH[0], SH.cBuffer[0]); block.AddVector(bids.SH[1], SH.cBuffer[1]); block.AddVector(bids.SH[2], SH.cBuffer[2]); block.AddVector(bids.SH[3], SH.cBuffer[3]); block.AddVector(bids.SH[4], SH.cBuffer[4]); block.AddVector(bids.SH[5], SH.cBuffer[5]); block.AddVector(bids.SH[6], SH.cBuffer[6]); block.AddVector(bids.SH[7], SH.cBuffer[7]); block.AddVector(bids.SH[8], SH.cBuffer[8]); #endif }