public void ApplyFast(Renderer target, int blendIndex) { // Binds IBL data, exposure, and a skybox texture globally or to a specific game object #if USE_PROPERTY_BLOCKS if (propBlock == null) { propBlock = new MaterialPropertyBlock(); } if (blendIndex == 0) { propBlock.Clear(); } else { target.GetPropertyBlock(propBlock); } ApplyToBlock(ref propBlock, this.blendIDs[blendIndex]); target.SetPropertyBlock(propBlock); #else //SharedMaterials are now used everywhere except through SkyAnchor foreach (Material mat in target.sharedMaterials) { Apply(mat, blendIndex); } #endif }
public void Draw() { var ListEnum = Lod.GetEnumerator(); int n = 0; Mpb.Clear(); while (ListEnum.MoveNext()) { _matrices[n] = ListEnum.Current.LocalToWorldMatrix; _colors[n] = ListEnum.Current.ArmyColor; _wreckage[n] = ListEnum.Current.IsWreckage; n++; if (n == MaxInstancingCount) { Mpb.SetVectorArray("_Color", _colors); Mpb.SetFloatArray("_Wreckage", _wreckage); Graphics.DrawMeshInstanced(BP.LODs[0].Mesh, 0, BP.LODs[0].Mat, _matrices, n, Mpb, ShadowCasting); //Graphics.DrawMeshInstancedIndirect(SharedMesh, 0, SharedMaterial, , null, 0, null, ShadowCasting); n = 0; Mpb.Clear(); } } if (n > 0) { Mpb.SetVectorArray("_Color", _colors); Mpb.SetFloatArray("_Wreckage", _wreckage); Graphics.DrawMeshInstanced(BP.LODs[0].Mesh, 0, BP.LODs[0].Mat, _matrices, n, Mpb, ShadowCasting); } }
public void OnDisable() { GCommon.UnregisterBeginRender(OnBeginCameraRender); GCommon.UnregisterBeginRenderSRP(OnBeginCameraRenderSRP); GTerrainData.GlobalDirty -= OnTerrainDataDirty; livePreviewMaterialProperties.Clear(); }
public static void DrawGeometryLivePreview(GStylizedTerrain t, Camera cam, Texture newHeightMap, Rect dirtyRect) { if (t.transform.rotation != Quaternion.identity || t.transform.lossyScale != Vector3.one) { return; } Mesh previewMesh = GEditorSettings.Instance.livePreview.GetTriangleMesh(t.TerrainData.Geometry.MeshResolution); Vector3 terrainSize = new Vector3( t.TerrainData.Geometry.Width, t.TerrainData.Geometry.Height, t.TerrainData.Geometry.Length); previewPropertyBlock.Clear(); previewPropertyBlock.SetTexture("_OldHeightMap", t.TerrainData.Geometry.HeightMap); previewPropertyBlock.SetTexture("_NewHeightMap", newHeightMap); previewPropertyBlock.SetTexture("_MainTex", newHeightMap); previewPropertyBlock.SetFloat("_Height", t.TerrainData.Geometry.Height); previewPropertyBlock.SetVector("_BoundMin", t.transform.position); previewPropertyBlock.SetVector("_BoundMax", t.transform.TransformPoint(terrainSize)); Material mat = GInternalMaterials.GeometryLivePreviewMaterial; mat.renderQueue = 4000; int gridSize = t.TerrainData.Geometry.ChunkGridSize; for (int x = 0; x < gridSize; ++x) { for (int z = 0; z < gridSize; ++z) { Rect uvRect = GCommon.GetUvRange(gridSize, x, z); if (!uvRect.Overlaps(dirtyRect)) { continue; } Vector3 localPos = new Vector3( terrainSize.x * uvRect.x, 0f, terrainSize.z * uvRect.y); Vector3 worldPos = t.transform.TransformPoint(localPos); Quaternion rotation = Quaternion.identity; Vector3 scale = new Vector3(terrainSize.x * uvRect.width, 1, terrainSize.z * uvRect.height); Graphics.DrawMesh( previewMesh, Matrix4x4.TRS(worldPos, rotation, scale), mat, LayerMask.NameToLayer("Default"), cam, 0, previewPropertyBlock); } } }
/// <summary> /// Evaluates the tween and, consequently, all the shader properties at "t" [0, 1]. /// </summary> /// <param name="t"></param> public void SampleAt(float t) { propertyBlock.Clear(); foreach (TweenShaderProperty p in shaderProperties) { p.Evaluate(propertyBlock, t); } targetRenderer.SetPropertyBlock(propertyBlock); }
public void UpdateTextureSize() { m_maskTex.Resize( resolutionMultiplier * Mathf.RoundToInt(transform.localScale.x * spriteRenderer.sprite.bounds.size.x), resolutionMultiplier * Mathf.RoundToInt(transform.localScale.y * spriteRenderer.sprite.bounds.size.y)); m_maskTex.Apply(); ClearMasks(); m_propBlock.Clear(); m_propBlock.SetTexture("_BlendMask", m_maskTex); m_renderer.SetPropertyBlock(m_propBlock); }
public virtual void Render(Matrix4x4 matrix, Color multColor, int layer = 0, Camera camera = null) { if (mEmpty) { return; } mProperty.Clear(); mProperty.AddColor("_Color", multColor); Graphics.DrawMesh( mMesh, matrix, mMaterial, layer, camera, 0, mProperty); }
public void Draw() { if (Lod == null || Lod.Count == 0) { return; } if (BP.LODs[0].Mesh == null) { //Missing mesh or material, skip rendering Debug.LogWarning("Missing mesh for blueprint " + BP.CodeName, gameObject); return; } else if (BP.LODs[0].Mat == null) { Debug.LogWarning("Missing material for blueprint " + BP.CodeName, gameObject); return; } var ListEnum = Lod.GetEnumerator(); int n = 0; Mpb.Clear(); while (ListEnum.MoveNext()) { _matrices[n] = ListEnum.Current.LocalToWorldMatrix; _colors[n] = ListEnum.Current.ArmyColor; _wreckage[n] = ListEnum.Current.IsWreckage; n++; if (n == MaxInstancingCount) { Mpb.SetVectorArray("_Color", _colors); Mpb.SetFloatArray("_Wreckage", _wreckage); Graphics.DrawMeshInstanced(BP.LODs[0].Mesh, 0, BP.LODs[0].Mat, _matrices, n, Mpb, ShadowCasting, true, 0, null, UnityEngine.Rendering.LightProbeUsage.Off, null); //Graphics.DrawMeshInstanced(UnitsInfo.Current.StrategicMesh, 0, BP.strategicMaterial, _matrices, n, Mpb, UnityEngine.Rendering.ShadowCastingMode.Off, false, 0, null, UnityEngine.Rendering.LightProbeUsage.Off, null); //Graphics.DrawMeshInstancedIndirect(SharedMesh, 0, SharedMaterial, , null, 0, null, ShadowCasting); n = 0; Mpb.Clear(); } } if (n > 0) { Mpb.SetVectorArray("_Color", _colors); Mpb.SetFloatArray("_Wreckage", _wreckage); Graphics.DrawMeshInstanced(BP.LODs[0].Mesh, 0, BP.LODs[0].Mat, _matrices, n, Mpb, ShadowCasting, true, 0, null, UnityEngine.Rendering.LightProbeUsage.Off, null); //Graphics.DrawMeshInstanced(UnitsInfo.Current.StrategicMesh, 0, BP.strategicMaterial, _matrices, n, Mpb, UnityEngine.Rendering.ShadowCastingMode.Off, false, 0, null, UnityEngine.Rendering.LightProbeUsage.Off, null); } }
/// <summary> /// Updates the shape fill appearance. /// </summary> public void UpdateFillAppearance() { if (fill_) { if (fillType_ != FillType.Custom) { if (fillTexture_ != null) { mpb_fill.SetTexture("_MainTex", fillTexture_); mpb_fill.SetVector("_TileOff", new Vector4(fillTextrueTiling_.x, fillTextrueTiling_.y, fillTextureOffset_.x, fillTextureOffset_.y)); } else { mpb_fill.Clear(); } if (fillType_ == FillType.Solid) { fillMaterial = Resources.Load("SR_FillLinearGradient") as Material; mpb_fill.SetColor("_Color1", fillColor1_); mpb_fill.SetColor("_Color2", fillColor1_); } else if (fillType_ == FillType.LinearGradient) { fillMaterial = Resources.Load("SR_FillLinearGradient") as Material; mpb_fill.SetColor("_Color1", fillColor1_); mpb_fill.SetColor("_Color2", fillColor2_); } else if (fillType_ == FillType.RadialGradient) { fillMaterial = Resources.Load("SR_FillRadialGradient") as Material; mpb_fill.SetColor("_Color1", fillColor1_); mpb_fill.SetColor("_Color2", fillColor2_); } mpb_fill.SetFloat("_Angle", fillAngle_); mpb_fill.SetFloat("_Slider1", fillOffset1_); mpb_fill.SetFloat("_Slider2", fillOffset2_); mr.SetPropertyBlock(mpb_fill); mr.sharedMaterial = fillMaterial; } else { mpb_fill.Clear(); mr.SetPropertyBlock(null); mr.sharedMaterial = customFillMaterial_; } } else { mr.sharedMaterial = null; } }
public static void SetEmission(GameObject go, Color emissionColor) { emissionPropertyBlock.Clear(); emissionPropertyBlock.SetColor("_EmissionColor", emissionColor); var renderers = go.GetComponentsInChildren <SkinnedMeshRenderer>(true); for (int i = 0; i < renderers.Length; ++i) { var r = renderers[i]; r.SetPropertyBlock(emissionPropertyBlock); } }
void Update() { foreach (var blink in _blinks) { if (!blink.Key) { toRemove.Add(blink.Key); continue; } var state = blink.Value; if (Time.unscaledTime > state.EndTime) { toRemove.Add(blink.Key); continue; } float duration = state.EndTime - state.StartTime; float t = (state.EndTime - Time.unscaledTime) / duration; var color = state.Color; color.a *= state.Curve.Evaluate(t); for (int i = 0; i < state.Renderers.Length; i++) { var renderer = state.Renderers[i]; renderer.GetPropertyBlock(_block); _block.SetColor("_BlinkColor", color); renderer.SetPropertyBlock(_block); } } _block.Clear(); for (int i = 0; i < toRemove.Count; i++) { var state = _blinks[toRemove[i]]; for (int j = 0; j < state.Renderers.Length; j++) { var renderer = state.Renderers[j]; if (!renderer) { continue; } renderer.GetPropertyBlock(_block); _block.SetColor("_BlinkColor", new Color(0, 0, 0, 0)); renderer.SetPropertyBlock(_block); } _blinks.Remove(toRemove[i]); } toRemove.Clear(); }
/// <summary> /// Updates the shape stroke appearance. /// </summary> public void UpdateStrokeAppearance() { if (stroke_) { if (strokeType_ != StrokeType.Custom) { if (strokeTexture_ != null) { mpb_stroke.SetTexture("_MainTex", strokeTexture_); } else { mpb_stroke.Clear(); } if (strokeType_ == StrokeType.Solid) { GradientColorKey[] gck = new GradientColorKey[2]; GradientAlphaKey[] gak = new GradientAlphaKey[2]; gck[0].color = strokeSolid_; gck[0].time = 0.0f; gck[1].color = strokeSolid_; gck[1].time = 1.0f; gak[0].alpha = strokeSolid_.a; gak[0].time = 0.0f; gak[1].alpha = strokeSolid_.a; gak[1].time = 1.0f; Gradient g = new Gradient(); g.SetKeys(gck, gak); lr.colorGradient = g; } else if (strokeType_ == StrokeType.MultiGradient) { lr.colorGradient = strokeGradient_; } lr.SetPropertyBlock(mpb_stroke); strokeMaterial = Resources.Load("SR_Stroke") as Material; lr.sharedMaterial = strokeMaterial; } else { mpb_stroke.Clear(); lr.SetPropertyBlock(null); lr.sharedMaterial = customStrokeMaterial_; } lr.startWidth = strokeWidth_; lr.endWidth = strokeWidth_; } }
private void SetupSplatPreview(GStylizedTerrain t) { Material mat = t.TerrainData.Shading.MaterialToRender; if (mat == null) { return; } int controlMapResolution = t.TerrainData.Shading.SplatControlResolution; int controlMapCount = t.TerrainData.Shading.SplatControlMapCount; if (controlMapCount == 0) { return; } RenderTexture[] rtControls = new RenderTexture[controlMapCount]; for (int i = 0; i < controlMapCount; ++i) { Texture2D splatControl = t.TerrainData.Shading.GetSplatControl(i); rtControls[i] = GetPreviewTexture(t, "splatControl" + i, controlMapResolution, splatControl.filterMode); GCommon.ClearRT(rtControls[i]); } instance.Internal_ApplySplat(t, rtControls); previewPropertyBlock.Clear(); //for (int i = 0; i < controlMapCount; ++i) //{ // if (!string.IsNullOrEmpty(t.TerrainData.Shading.SplatControlMapPropertyName)) // { // previewPropertyBlock.SetTexture(t.TerrainData.Shading.SplatControlMapPropertyName + i, rtControls[i]); // } //} }
internal void UpdateMaterialProperties(Renderer r, int index) { if (m_AnimatableProperties.Length == 0 || canvasRenderer.materialCount <= index) { return; } r.GetPropertyBlock(s_Mpb ?? (s_Mpb = new MaterialPropertyBlock())); if (s_Mpb.isEmpty) { return; } // #41: Copy the value from MaterialPropertyBlock to CanvasRenderer var mat = canvasRenderer.GetMaterial(index); if (!mat) { return; } foreach (var ap in m_AnimatableProperties) { ap.UpdateMaterialProperties(mat, s_Mpb); } s_Mpb.Clear(); }
/// <summary> /// This function is called when the behaviour becomes disabled. /// </summary> protected override void OnDisable() { // Unregister. s_ActiveSoftMasks.Remove(this); if (s_ActiveSoftMasks.Count == 0) { Canvas.willRenderCanvases -= UpdateMaskTextures; } // Reset the parent-child relation. for (int i = _children.Count - 1; 0 <= i; i--) { _children[i].SetParent(_parent); } _children.Clear(); SetParent(null); // Destroy objects. _mpb.Clear(); _mpb = null; _cb.Release(); _cb = null; ReleaseObject(_mesh); _mesh = null; ReleaseObject(_material); _material = null; ReleaseRt(ref _softMaskBuffer); base.OnDisable(); _hasStencilStateChanged = false; }
public void Update() { if (block == null) { block = new MaterialPropertyBlock(); } block.Clear(); if (lightTexture != null) { block.SetVector("_Tiling", new Vector4(transform.lossyScale.x, transform.lossyScale.y, xOffset, yOffset)); block.SetVector("_Light", new Vector4(directionShading, backWallOpacity, obscureWall ? 1 : 0, 0)); block.SetTexture("_MainTex", lightTexture); renderer.enabled = true; } else if (spriteTexture != null) { block.SetVector("_Light", new Vector4(directionShading, backWallOpacity, obscureWall ? 1 : 0, 0)); block.SetTexture("_MainTex", spriteTexture.texture); Vector2 size = spriteTexture.texture.texelSize; Rect part = spriteTexture.rect; block.SetVector("_Tiling", new Vector4(size.x * part.width, size.y * part.height, (size.x * part.x) + xOffset, (size.y * part.y) + yOffset)); renderer.enabled = true; } else { renderer.enabled = false; } renderer.SetPropertyBlock(block); }
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); }
// Token: 0x0600017E RID: 382 RVA: 0x00008827 File Offset: 0x00006A27 private void SetWind(MaterialPropertyBlock block, Vector4 input) { this.rend.GetPropertyBlock(block); block.Clear(); block.SetVector("_Wind", input); this.rend.SetPropertyBlock(block); }
void UpdateMaterial() { if (!initialised) { // Parameters changed before Awake() has been run, do a full update when appropriate. // (Can't rely on Awake() when the GameObject is disabled. It does a lousy job as a constructor.) regenerateMesh = true; return; } if ((renderer.sharedMaterials.Length != 1) || (renderer.sharedMaterials[0] != m_material)) { // Update only when necessary to prevent false scene changes. renderer.sharedMaterials = new Material[] { m_material }; } MaterialPropertyBlock materialProperties = new MaterialPropertyBlock(); renderer.GetPropertyBlock(materialProperties); if ((m_sprite != null) && (m_sprite.texture != null)) { materialProperties.SetTexture("_MainTex", m_sprite.texture); } else if (m_material != null) { if (materialProperties.GetTexture("_MainTex") != null) { materialProperties.Clear(); } m_material.SetTexture("_MainTex", null); } renderer.SetPropertyBlock(materialProperties); }
public override void RenderExtraStuff(ushort vehicleID, ref Vehicle vehicleData, RenderManager.CameraInfo cameraInfo, InstanceID id, Vector3 position, Quaternion rotation, Vector4 tyrePosition, Vector4 lightState, Vector3 scale, Vector3 swayPosition, bool underground, bool overground) { VehicleManager instance = Singleton <VehicleManager> .instance; Vehicle.Flags flags = instance.m_vehicles.m_buffer[vehicleID].m_flags; if (m_info != null && m_info.m_vehicleAI != null && m_info.m_subMeshes != null) { Matrix4x4 bodyMatrix = m_info.m_vehicleAI.CalculateBodyMatrix(flags, ref position, ref rotation, ref scale, ref swayPosition); Matrix4x4 value = m_info.m_vehicleAI.CalculateTyreMatrix(flags, ref position, ref rotation, ref scale, ref bodyMatrix); if ((flags & Vehicle.Flags.Inverted) != 0) { tyrePosition.x = 0f - tyrePosition.x; tyrePosition.y = 0f - tyrePosition.y; } MaterialPropertyBlock materialBlock = instance.m_materialBlock; materialBlock.Clear(); materialBlock.SetMatrix(instance.ID_TyreMatrix, value); materialBlock.SetVector(instance.ID_TyrePosition, tyrePosition); materialBlock.SetVector(instance.ID_LightState, lightState); for (int i = 0; i < m_info.m_subMeshes.Length; i++) { VehicleInfo.MeshInfo meshInfo = m_info.m_subMeshes[i]; RenderPoleMesh(vehicleID, ref vehicleData, position, rotation, swayPosition, underground, overground, instance, meshInfo, materialBlock); } } base.RenderExtraStuff(vehicleID, ref vehicleData, cameraInfo, id, position, rotation, tyrePosition, lightState, scale, swayPosition, underground, overground); }
public void Convert() { if (ControlArray.Count <= 0) { return; } _block.Clear(); for (int i = 0; i < ControlArray.Count; i++) { var control = ControlArray[i]; _block.SetTexture($"_Control_{i}", control); } _block.SetTexture("_DiffuseArray", DiffuseArray); _block.SetTexture("_NormalArray", NormalArray); _block.SetFloatArray("_DiffuseIndexes", DiffuseIndexes); _block.SetFloatArray("_NormalIndexes", NormalIndexes); _block.SetVectorArray("_Splats_ST", Tillings); _block.SetFloatArray("_NormalScales", NormalScales); var terrain = GetComponent <Terrain>(); terrain.SetSplatMaterialPropertyBlock(_block); }
private void OnValidate() { if (count <= 0) { count = 1; } if (block == null) { block = new MaterialPropertyBlock(); } block.Clear(); colorList.Clear(); offList.Clear(); cutOffList.Clear(); matrix = new Matrix4x4[count]; for (int i = 0; i < count; i++) { matrix[i] = Matrix4x4.TRS((transform.position + Random.insideUnitSphere * range), Quaternion.identity, Vector3.one); colorList.Add(new Vector4(Random.Range(0f, 1f), Random.Range(0f, 1f), Random.Range(0f, 1f), 1)); offList.Add(new Vector4(Random.Range(0.1f, 5f), Random.Range(0.1f, 5f), Random.Range(0.1f, 1f), Random.Range(0.1f, 1f))); cutOffList.Add(Random.Range(0.0f, 1)); } block.SetFloatArray(cutOff, cutOffList); block.SetVectorArray(maintexST, offList); block.SetVectorArray(baseColorId, colorList); }
void LateUpdate() { if (!Application.isPlaying) { return; } if (paletteTexture == null) { return; } if (_lastpaletteTexture != paletteTexture) { CalcPixelSize(); _lastpaletteTexture = paletteTexture; } //if(!dirtyFlag) return; block.Clear(); sp.GetPropertyBlock(block); block.SetTexture("_PaletteTex", paletteTexture); block.SetVector("_PaletteTextureSize", _texturePixelSize); sp.SetPropertyBlock(block); float index = (_currentIndex + 0.5f) / paletteTexture.width; sp.color = new Color(color.r, map(color.g, color.b), index, color.a); //dirtyFlag = false; }
protected virtual void OnWillRenderObject() { if (spriteRenderer == null) { spriteRenderer = GetComponent <SpriteRenderer>(); } var sprite = spriteRenderer.sprite; if (sprite != null) { if (propertyBlock == null) { propertyBlock = new MaterialPropertyBlock(); } propertyBlock.Clear(); propertyBlock.SetTexture("_MainTex", sprite.texture); propertyBlock.SetTexture("_AlphaTex", AlphaTex); propertyBlock.SetVector("_AlphaScale", CalculateAlphaScale(sprite)); propertyBlock.SetVector("_AlphaOffset", CalculateAlphaOffset(sprite)); propertyBlock.SetFloat("_Sharpness", Sharpness); spriteRenderer.SetPropertyBlock(propertyBlock); } }
private void CreateIndirectDrawResources() { _indirectDrawMaterial = new Material(_resources.FilledVoxelInstanceMaterial); _indirectDrawMaterial.enableInstancing = true; var volumeSize = _voxelsData.VolumeSize; _indirectDrawMaterial.SetVector(VoxelizationResources.VOLUME_SIZE, new Vector4(volumeSize.x, volumeSize.y, volumeSize.z, _voxelsData.VoxelSize)); _materialPropertyBlock = new MaterialPropertyBlock(); _materialPropertyBlock.Clear(); _materialPropertyBlock.SetBuffer(VoxelizationResources.FILLED_VOXELS_INSTANCES, _voxelsData.FilledVoxelInstances); var instancedMesh = _resources.FilledVoxelInstanceMesh; var args = new uint[5]; args[0] = instancedMesh.GetIndexCount(0); args[1] = 0; // instance count args[2] = instancedMesh.GetIndexStart(0); args[3] = instancedMesh.GetBaseVertex(0); args[4] = 0; // start instance location _indirectDrawArgs = new ComputeBuffer(1, args.Length * sizeof(uint), ComputeBufferType.IndirectArguments); _indirectDrawArgs.SetData(args); }
public void Clear() { MatrixList.Clear(); UvList.Clear(); Colors.Clear(); MaterialPropertyBlock.Clear(); }
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); }
private void DrawLivePreview(GStylizedTerrain t, Camera cam) { if (t.transform.rotation != Quaternion.identity || t.transform.lossyScale != Vector3.one) { return; } List <Rect> dirtyRects = new List <Rect>(instance.SplineCreator.SweepDirtyRect(t)); Rect r = new Rect(0, 0, 0, 0); for (int i = 0; i < dirtyRects.Count; ++i) { r.xMin = Mathf.Min(r.xMin, dirtyRects[i].xMin); r.xMax = Mathf.Max(r.xMax, dirtyRects[i].xMax); r.yMin = Mathf.Min(r.yMin, dirtyRects[i].yMin); r.yMax = Mathf.Max(r.yMax, dirtyRects[i].yMax); } RenderTexture rt = GetPreviewTexture(t); instance.Internal_Apply(t, rt, instance.SplineCreator.Editor_Vertices); previewPropertyBlock.Clear(); GLivePreviewDrawer.DrawMasksLivePreview( t, cam, new Texture[] { rt }, new Color[] { GEditorSettings.Instance.splineTools.negativeHighlightColor }, r); }
private void Update() { executeCommandBuffer = false; if (Source.enabled) { if (meshTransforms == null || meshTransforms.Length != NumLineSteps) { meshTransforms = new Matrix4x4[NumLineSteps]; } if (colorValues == null || colorValues.Length != NumLineSteps) { colorValues = new Vector4[NumLineSteps]; linePropertyBlock.Clear(); } for (int i = 0; i < NumLineSteps; i++) { float normalizedDistance = (1f / (NumLineSteps - 1)) * i; colorValues[i] = GetColor(normalizedDistance); meshTransforms[i] = Matrix4x4.TRS(Source.GetPoint(normalizedDistance), Source.GetRotation(normalizedDistance), Vector3.one * GetWidth(normalizedDistance)); } linePropertyBlock.SetVectorArray(colorID, colorValues); executeCommandBuffer = true; } }
public override void FrameUpdate(PipelineCamera cam, ref PipelineCommandData data) { if (SunLight.current == null) { return; } CommandBuffer buffer = data.buffer; int pass; lightBlock.Clear(); if (SunLight.current.enableShadow) { PipelineFunctions.UpdateShadowMapState(ref SunLight.shadMap, lightBlock, ref SunLight.current.settings, buffer); PipelineFunctions.DrawShadow(cam.cam, data.resources.gpuFrustumCulling, buffer, ref data.baseBuffer, ref SunLight.current.settings, ref SunLight.shadMap, cascadeShadowMapVP, shadowFrustumVP); PipelineFunctions.UpdateShadowMaskState(lightBlock, ref SunLight.shadMap, cascadeShadowMapVP); pass = 0; } else { pass = 1; } lightBlock.SetVector(ShaderIDs._LightFinalColor, SunLight.shadMap.light.color * SunLight.shadMap.light.intensity); buffer.SetRenderTarget(cam.targets.renderTargetIdentifier, cam.targets.depthIdentifier); lightBlock.SetVector(ShaderIDs._LightPos, -SunLight.shadMap.shadCam.forward); buffer.DrawMesh(GraphicsUtility.mesh, Matrix4x4.identity, shadMaskMaterial, 0, pass, lightBlock); }