private SetFloat ( int nameID, float value ) : void | ||
nameID | int | |
value | float | |
return | void |
static int SetFloat(IntPtr L) { try { int count = LuaDLL.lua_gettop(L); if (count == 3 && TypeChecker.CheckTypes <int, float>(L, 2)) { UnityEngine.MaterialPropertyBlock obj = (UnityEngine.MaterialPropertyBlock)ToLua.CheckObject(L, 1, typeof(UnityEngine.MaterialPropertyBlock)); int arg0 = (int)LuaDLL.lua_tonumber(L, 2); float arg1 = (float)LuaDLL.lua_tonumber(L, 3); obj.SetFloat(arg0, arg1); return(0); } else if (count == 3 && TypeChecker.CheckTypes <string, float>(L, 2)) { UnityEngine.MaterialPropertyBlock obj = (UnityEngine.MaterialPropertyBlock)ToLua.CheckObject(L, 1, typeof(UnityEngine.MaterialPropertyBlock)); string arg0 = ToLua.ToString(L, 2); float arg1 = (float)LuaDLL.lua_tonumber(L, 3); obj.SetFloat(arg0, arg1); return(0); } else { return(LuaDLL.luaL_throw(L, "invalid arguments to method: UnityEngine.MaterialPropertyBlock.SetFloat")); } } catch (Exception e) { return(LuaDLL.toluaL_exception(L, e)); } }
static public int SetFloat(IntPtr l) { try { int argc = LuaDLL.lua_gettop(l); if (matchType(l, argc, 2, typeof(int), typeof(float))) { UnityEngine.MaterialPropertyBlock self = (UnityEngine.MaterialPropertyBlock)checkSelf(l); System.Int32 a1; checkType(l, 2, out a1); System.Single a2; checkType(l, 3, out a2); self.SetFloat(a1, a2); pushValue(l, true); return(1); } else if (matchType(l, argc, 2, typeof(string), typeof(float))) { UnityEngine.MaterialPropertyBlock self = (UnityEngine.MaterialPropertyBlock)checkSelf(l); System.String a1; checkType(l, 2, out a1); System.Single a2; checkType(l, 3, out a2); self.SetFloat(a1, a2); pushValue(l, true); return(1); } pushValue(l, false); LuaDLL.lua_pushstring(l, "No matched override function SetFloat to call"); return(2); } catch (Exception e) { return(error(l, e)); } }
public void AssignParams() { var renderer = GetComponent<Renderer>(); var trans = GetComponent<Transform>(); var material = renderer.sharedMaterial; if (m_mpb == null) { m_mpb = new MaterialPropertyBlock(); m_mpb.SetFloat("_ObjectID", m_id); } var pos = m_use_root_position ? trans.root.position : trans.position; var rot = m_use_root_rotation ? trans.root.rotation : trans.rotation; var scale = m_use_root_scale ? trans.root.lossyScale : trans.lossyScale; if(m_debug_log) { Debug.Log("pos: " + pos); Debug.Log("rot: " + rot); Debug.Log("scale: " + scale); } m_mpb.SetVector("_Position", pos); m_mpb.SetVector("_Rotation", new Vector4(rot.x, rot.y, rot.z, rot.w)); m_mpb.SetVector("_Scale", scale); m_mpb.SetFloat("_LocalTime", m_local_time); for (int i = 0; i < m_fparams.Count; ++i) { m_mpb.SetFloat(m_fparams[i].key, m_fparams[i].value); } renderer.SetPropertyBlock(m_mpb); }
void UpdateOutline(bool outline) { MaterialPropertyBlock mpb = new MaterialPropertyBlock(); spriteRenderer.GetPropertyBlock(mpb); mpb.SetFloat("_Outline", outline ? 1f : 0); mpb.SetColor("_OutlineColor", color); spriteRenderer.SetPropertyBlock(mpb); }
protected virtual void Awake() { _handModel = GetComponent<HandModel>(); _renderer = GetComponentInChildren<Renderer>(); _fadePropertyBlock = new MaterialPropertyBlock(); _renderer.GetPropertyBlock(_fadePropertyBlock); _fadePropertyBlock.SetFloat("_Fade", 0); _renderer.SetPropertyBlock(_fadePropertyBlock); }
// Update is called once per frame void Update () { Debug.Log (Mathf.Abs( Mathf.Cos (Time.time))); var material = gameObject.GetComponent<SpriteRenderer> ().material; material.SetFloat ("ShineLocation", Mathf.Abs( Mathf.Cos (Time.time))); MaterialPropertyBlock pb = new MaterialPropertyBlock (); gameObject.GetComponent<SpriteRenderer> ().GetPropertyBlock(pb); pb.SetFloat ("ShineLocation", Mathf.Abs (Mathf.Cos (Time.time))); gameObject.GetComponent<SpriteRenderer> ().SetPropertyBlock (pb); }
/// <summary> /// Evaluates the property at "t" and stores its value in the MaterialPropertyBlock. /// </summary> /// <param name="block"></param> /// <param name="t"></param> public void Evaluate( MaterialPropertyBlock block, float t ) { if( type == Type.Color ) { block.SetColor( Id, Color.Lerp( from, to, t ) ); } else if( type == Type.Float ) { block.SetFloat( Id, Mathf.Lerp( from.a, to.a, t ) ); } }
static public int SetFloat(IntPtr l) { try { #if DEBUG var method = System.Reflection.MethodBase.GetCurrentMethod(); string methodName = GetMethodName(method); #if UNITY_5_5_OR_NEWER UnityEngine.Profiling.Profiler.BeginSample(methodName); #else Profiler.BeginSample(methodName); #endif #endif int argc = LuaDLL.lua_gettop(l); if (matchType(l, argc, 2, typeof(int), typeof(float))) { UnityEngine.MaterialPropertyBlock self = (UnityEngine.MaterialPropertyBlock)checkSelf(l); System.Int32 a1; checkType(l, 2, out a1); System.Single a2; checkType(l, 3, out a2); self.SetFloat(a1, a2); pushValue(l, true); return(1); } else if (matchType(l, argc, 2, typeof(string), typeof(float))) { UnityEngine.MaterialPropertyBlock self = (UnityEngine.MaterialPropertyBlock)checkSelf(l); System.String a1; checkType(l, 2, out a1); System.Single a2; checkType(l, 3, out a2); self.SetFloat(a1, a2); pushValue(l, true); return(1); } pushValue(l, false); LuaDLL.lua_pushstring(l, "No matched override function SetFloat to call"); return(2); } catch (Exception e) { return(error(l, e)); } #if DEBUG finally { #if UNITY_5_5_OR_NEWER UnityEngine.Profiling.Profiler.EndSample(); #else Profiler.EndSample(); #endif } #endif }
static public int SetFloat__Int32__Single(IntPtr l) { try { UnityEngine.MaterialPropertyBlock self = (UnityEngine.MaterialPropertyBlock)checkSelf(l); System.Int32 a1; checkType(l, 2, out a1); System.Single a2; checkType(l, 3, out a2); self.SetFloat(a1, a2); pushValue(l, true); return(1); } catch (Exception e) { return(error(l, e)); } }
void SetMaterial() { if (!sprite) { Debug.LogError("No sprite set for UI fill", gameObject); return; } MaterialPropertyBlock block = new MaterialPropertyBlock(); sprite.GetPropertyBlock(block); Vector3 scale = new Vector3(clockwise ? -1:1, 1, 1); Quaternion rot = Quaternion.Euler(0, 0, rotation + 90f); block.SetMatrix("_Rotation", Matrix4x4.TRS(Vector3.zero, rot, scale)); block.SetFloat("_Fill", fillAmount); sprite.SetPropertyBlock(block); }
private void InitShaderProperties() { if (this.isCut) { MaterialPropertyBlock materialPropertyBlock = new MaterialPropertyBlock(); this.renderer.GetPropertyBlock(materialPropertyBlock); materialPropertyBlock.SetFloat("_Variation", Mathf.Abs(Mathf.Abs(base.transform.position.x + base.transform.position.z) * 0.1f % 1f - 0.5f) * 2f); Quaternion q = Quaternion.AngleAxis(-base.transform.rotation.eulerAngles.y, Vector3.up); this.m_Matrix.SetTRS(Vector3.zero, q, new Vector3(1f, 1f, 1f)); materialPropertyBlock.SetMatrix("_TreeRotMatrix", this.m_Matrix); this.renderer.SetPropertyBlock(materialPropertyBlock); this.mat.EnableKeyword("_CUTVERSION"); } else { this.mat.DisableKeyword("_CUTVERSION"); } }
protected void ApplyToRenderers() { UnityEngine.Debug.Assert(this.exportToLocal); if (materialPropertyBlock == null) { materialPropertyBlock = new UnityEngine.MaterialPropertyBlock(); } int datasLength = this.Datas != null ? this.Datas.Length : 0; this.FindRenderers(renderers); int renderersCount = renderers.Count; for (int i = 0; i < renderersCount; ++i) { renderers[i].GetPropertyBlock(materialPropertyBlock); materialPropertyBlock.SetBuffer(this.BufferName, this.computeBuffer); materialPropertyBlock.SetFloat(this.bufferSizeName, datasLength); renderers[i].SetPropertyBlock(materialPropertyBlock); materialPropertyBlock.Clear(); } renderers.Clear(); }
private IEnumerator Fade() { if (_isFading) yield break; var mr = GetComponent<MeshRenderer>(); if (mr == null) yield break; _isFading = true; const float fadeRate = 2f; var pb = new MaterialPropertyBlock(); var val = IsVisible ? 0f : -1f; for (; ; ) { var dest = IsVisible ? 1f : 0f; var sign = Math.Sign(dest - val); val += sign * fadeRate * Time.deltaTime; if (sign == 0 || sign == 1 && val >= dest || sign == -1 && val <= dest) break; pb.SetFloat(FadeId, (float) val); mr.SetPropertyBlock(pb); yield return new WaitForEndOfFrame(); } mr.SetPropertyBlock(null); if (!IsVisible) { gameObject.SetActive(false); } _isFading = false; }
/// <summary> /// Constructor /// </summary> public FogOfWarTile() { material = new MaterialPropertyBlock(); material.SetFloat("_Alpha", alpha); }
void Update() { if (_subdivided != _subdivision) RebuildMesh(); var noiseDir = new Vector3(0.1f, 0.3f, -0.5f).normalized; _noiseOffset += noiseDir * (Time.deltaTime * _noiseSpeed); var radius = 1.0f + Reaktion.Perlin.Noise(Time.time, 23.5f) * _scaleAnimation; var props = new MaterialPropertyBlock(); props.SetVector("_NoiseOffset", _noiseOffset); props.SetFloat("_NoiseFrequency", _noiseFrequency); props.SetFloat("_NoiseAmplitude", _noiseAmplitude); props.SetFloat("_Opacity", _opacity); props.SetFloat("_Radius", radius); Graphics.DrawMesh( _mesh, transform.localToWorldMatrix, _material, 0, null, 0, props, _shadowCastingMode, _receiveShadows); }
void LateUpdate() { if (_needsReset) ResetResources(); // Call the kernels. UpdateKernelShader(); Graphics.Blit(null, _positionBuffer, _kernelMaterial, 0); Graphics.Blit(_positionBuffer, _normalBuffer1, _kernelMaterial, 1); Graphics.Blit(_positionBuffer, _normalBuffer2, _kernelMaterial, 2); // Update the line material. _lineMaterial.SetColor("_Color", _lineColor); // Make a material property block for the following drawcalls. var props1 = new MaterialPropertyBlock(); var props2 = new MaterialPropertyBlock(); props1.SetTexture("_PositionBuffer", _positionBuffer); props2.SetTexture("_PositionBuffer", _positionBuffer); props1.SetTexture("_NormalBuffer", _normalBuffer1); props2.SetTexture("_NormalBuffer", _normalBuffer2); var mapOffs = new Vector3(0, 0, VOffset); props1.SetVector("_MapOffset", mapOffs); props2.SetVector("_MapOffset", mapOffs); props1.SetFloat("_UseBuffer", 1); props2.SetFloat("_UseBuffer", 1); // Temporary variables. var mesh = _bulkMesh.mesh; var position = transform.position; var rotation = transform.rotation; var uv = new Vector2(0.5f / _positionBuffer.width, 0); position += transform.forward * ZOffset; // Draw mesh segments. for (var i = 0; i < _totalStacks; i += _stacksPerSegment) { uv.y = (0.5f + i) / _positionBuffer.height; props1.SetVector("_BufferOffset", uv); props2.SetVector("_BufferOffset", uv); if (_material) { // 1st half Graphics.DrawMesh( mesh, position, rotation, _material, 0, null, 0, props1, _castShadows, _receiveShadows); // 2nd half Graphics.DrawMesh( mesh, position, rotation, _material, 0, null, 1, props2, _castShadows, _receiveShadows); } // lines if (_lineColor.a > 0.0f) Graphics.DrawMesh( mesh, position, rotation, _lineMaterial, 0, null, 2, props1, false, false); } }
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 LUT3D SetProperty(MaterialPropertyBlock block) { block.SetFloat (PROP_SCALE, (float)(_dim - 1) / _dim); block.SetFloat (PROP_OFFSET, 1f / (2f * _dim)); block.SetTexture (PROP_3DLUT, _3dlut); return this; }
void Update() { if (_needsReset) { ResetResources(); ResetState(); _needsReset = false; } if (Application.isPlaying) { float deltaTime; int steps; if (_fixTimeStep) { // fixed time step deltaTime = 1.0f / _stepsPerSecond; steps = Mathf.RoundToInt(Time.deltaTime * _stepsPerSecond); } else { // variable time step deltaTime = Time.smoothDeltaTime; steps = 1; } // time steps for (var i = 0; i < steps; i++) StepKernel(deltaTime); } else { ResetState(); // warming up for (var i = 0; i < 32; i++) StepKernel(0.1f); } // drawing lines UpdateLineShader(); var matrix = transform.localToWorldMatrix; var stride = LinesPerDraw; var total = TotalLineCount; var props = new MaterialPropertyBlock(); var uv = new Vector2(0.5f / _historyLength, 0); for (var i = 0; i < total; i += stride) { uv.y = (0.5f + i) / total; props.SetVector("_BufferOffset", uv); // front face props.SetFloat("_Flip", 1); Graphics.DrawMesh( _mesh, matrix, _lineMaterial, gameObject.layer, null, 0, props, _castShadows, _receiveShadows ); // back face props.SetFloat("_Flip", -1); Graphics.DrawMesh( _mesh, matrix, _lineMaterial, gameObject.layer, null, 0, props, _castShadows, _receiveShadows ); } }
public void SetPropertyBlock(MaterialPropertyBlock block, Transform modelTransform) { // model local space to world space matrix var l2w = modelTransform.localToWorldMatrix; // world space to effector local space matrix var w2e = transform.worldToLocalMatrix; // effector local space to normalized effector space matrix var es = _effectorSize; var invs = new Vector3(1.0f / es.x, 1.0f / es.y, 1.0f / es.z); var e2n = Matrix4x4.Scale(invs); block.SetMatrix("_Effector", e2n * w2e * l2w); block.SetVector("_Steepness", new Vector3( _transitionSteepness, _emissionTransitionSteepness, _scaleTransitionSteepness )); block.SetColor("_InitialEmission", _initialEmission); block.SetFloat("_InitialScale", _initialScale); if (_effectType == EffectType.Destruction) SetDestructionProps(block, modelTransform); else SetDisintegrationProps(block); }
public bool AddToMaterialPropertyBlock(UnityEngine.MaterialPropertyBlock materialPropertyBlock) { materialPropertyBlock.SetFloat(this.PropertyName, this.PropertyValue); return(false); }
private void RefreshBrushCursor() { drawCursorBlock = drawCursorBlock ?? new MaterialPropertyBlock(); float quarter = Mathf.PI * 0.5f; this.angle = (this.angle + Mathf.PI * 2) % (Mathf.PI * 2); var angle = this.angle % quarter; int rots = Mathf.FloorToInt(this.angle / quarter + 3) % 4; //* if (angle > quarter * 0.5f) { angle -= quarter; rots = (rots + 1) % 4; } //*/ float alpha = -Mathf.Tan(angle / 2f); float beta = Mathf.Sin(angle); //var shearSprite4 = TextureByte.Pooler.Instance.ShearX(stamp.brush, Time.timeSinceLevelLoad % 1); byte value = (byte) drawHUD.selected; Blend<byte> blend_ = (canvas, brush) => brush == 0 ? (byte) 0 : value; brushRenderer.GetPropertyBlock(drawCursorBlock); if (value == 0) { drawCursorBlock.SetFloat("_Cycle", Time.timeSinceLevelLoad * 16); blend_ = (canvas, brush) => brush == 0 ? (byte) 0 : (byte) 1; } else { drawCursorBlock.SetFloat("_Cycle", 0); } brushRenderer.SetPropertyBlock(drawCursorBlock); brushSpriteD.Clear(0); if (followToggle.isOn) { var shearSprite1 = TextureByte.Pooler.Instance.Rotated(stamp.brush, rots); //var shearSprite1 = TextureByte.Pooler.Instance.Copy(stamp.brush); var shearSprite2 = TextureByte.Pooler.Instance.ShearX(shearSprite1, alpha); TextureByte.Pooler.Instance.FreeTexture(shearSprite1.mTexture); TextureByte.Pooler.Instance.FreeSprite(shearSprite1); var shearSprite3 = TextureByte.Pooler.Instance.ShearY(shearSprite2, beta); TextureByte.Pooler.Instance.FreeTexture(shearSprite2.mTexture); TextureByte.Pooler.Instance.FreeSprite(shearSprite2); var shearSprite4 = TextureByte.Pooler.Instance.ShearX(shearSprite3, alpha); TextureByte.Pooler.Instance.FreeTexture(shearSprite3.mTexture); TextureByte.Pooler.Instance.FreeSprite(shearSprite3); ////var shearSprite4 = shearSprite1; brushSpriteD.Blend(shearSprite4, blend_); TextureByte.Pooler.Instance.FreeTexture(shearSprite4.mTexture); TextureByte.Pooler.Instance.FreeSprite(shearSprite4); } else { brushSpriteD.Blend(stamp.brush, blend_); } Actor actor = targetActor; if (project == null) return; var scene = editScene; if (actor != null || scene.TryGetActor(next, out actor, 3)) { brushSpriteD.Crop(actor.costume[actor.position.direction], canvasPosition: next, brushPosition: actor.position.current); } brushSpriteD.mTexture.Apply(); }
private void UpdateCharacterInput() { IntVector2 cell = ((IntVector2) next).CellCoords(32); regCursor.gameObject.SetActive(true); regCursor.transform.localPosition = cell * 32 + IntVector2.one * 16; if (addCharacter.isOn) { cellCursor.gameObject.SetActive(true); cellCursor.transform.localPosition = cell * 32 + IntVector2.one * 16; cursorBlock = cursorBlock ?? new MaterialPropertyBlock(); cellCursor.GetPropertyBlock(cursorBlock); cursorBlock.SetFloat("_Cycle", Time.timeSinceLevelLoad * 12); cellCursor.SetPropertyBlock(cursorBlock); cellCursor.sprite = defaultCostume.down.uSprite; } else { cellCursor.gameObject.SetActive(false); } if (input.cancel.WasPressed) { hud.mode = HUD.Mode.Draw; CleanupCharacter(); return; } characterDialogue.interactable = possessedActor != null; if (possessedActor != null) { if (characterDialogue.isFocused) { possessedActor.dialogue = characterDialogue.text; } else { characterDialogue.text = possessedActor.dialogue; } } else { characterDialogue.text = "NO CHARACTER SELECTED"; } Actor hoveredActor; var scene = editScene; scene.TryGetActor(next, out hoveredActor, 0); if (hoveredActor != null) { if (hoveredActor == possessedActor) { SetCursorSprite(exitActorCursor); } else { SetCursorSprite(enterActorCursor); } } if (mousePress && hoveredActor != null) { if (removeCharacter.isOn) { scene.actors.Remove(hoveredActor); if (possessedActor == hoveredActor) possessedActor = null; var changes = new Changes(); changes.GetChange(hoveredActor, () => new ActorRemovedChange { world = scene, actor = hoveredActor }); Do(changes); removeCharacter.isOn = false; } else { if (possessedActor == hoveredActor) { possessedActor = null; cameraController.focusTarget = hoveredActor.position.current - Vector2.one * 16; } else { possessedActor = hoveredActor; characterDialogue.text = possessedActor.dialogue; } } } else if (mousePress && addCharacter.isOn) { var pos = ((IntVector2) next).CellCoords(32) * 32 + IntVector2.one * 16; var actor = new Actor { world = scene, costume = NewSimpleCostume(project), state = new State { fragment = "start", line = 0 }, position = new Position { prev = pos, next = pos, progress = 0, }, }; scene.actors.Add(actor); var changes = new Changes(); changes.GetChange(actor, () => new ActorAddedChange { world = scene, actor = actor }); Do(changes); characterPlaceSound.Play(); addCharacter.isOn = false; possessedActor = actor; } }
void Update () { //must reset mesh verts to 0 each frame. m_meshBuffer.SetData(new float[SIZE*7]); //Make the voxels. m_perlinNoise.SetInt("_Width", N); m_perlinNoise.SetInt("_Height", N); m_perlinNoise.SetFloat("_Frequency", 0.02f); m_perlinNoise.SetFloat("_Lacunarity", 2.0f); m_perlinNoise.SetFloat("_Gain", 0.5f); m_perlinNoise.SetFloat("_Time", Time.time * m_speed); m_perlinNoise.SetTexture(0, "_PermTable1D", perlin.GetPermutationTable1D()); m_perlinNoise.SetTexture(0, "_PermTable2D", perlin.GetPermutationTable2D()); m_perlinNoise.SetTexture(0, "_Gradient4D", perlin.GetGradient4D()); m_perlinNoise.SetBuffer(0, "_Result", m_noiseBuffer); m_perlinNoise.Dispatch(0, N/8, N/8, N/8); //Make the voxel normals. m_normals.SetInt("_Width", N); m_normals.SetInt("_Height", N); m_normals.SetBuffer(0, "_Noise", m_noiseBuffer); m_normals.SetBuffer(0, "_Result", m_normalsBuffer); m_normals.Dispatch(0, N/8, N/8, N/8); //Make the mesh verts m_marchingCubes.SetInt("_Width", N); m_marchingCubes.SetInt("_Height", N); m_marchingCubes.SetInt("_Depth", N); m_marchingCubes.SetInt("_Border", 1); m_marchingCubes.SetFloat("_Target", 0.0f); m_marchingCubes.SetBuffer(0, "_Voxels", m_noiseBuffer); m_marchingCubes.SetBuffer(0, "_Normals", m_normalsBuffer); m_marchingCubes.SetBuffer(0, "_Buffer", m_meshBuffer); m_marchingCubes.SetBuffer(0, "_CubeEdgeFlags", m_cubeEdgeFlags); m_marchingCubes.SetBuffer(0, "_TriangleConnectionTable", m_triangleConnectionTable); m_marchingCubes.Dispatch(0, N/8, N/8, N/8); m_drawBuffer.SetBuffer("_Buffer", m_meshBuffer); m_drawBuffer.SetPass(0); var prop = new MaterialPropertyBlock(); for (var i = 0; i < N; i++) { prop.SetFloat("_IdOffset", i * N * N * 3 * 5); Graphics.DrawMesh(m_mesh, transform.localToWorldMatrix, m_drawBuffer, 0, null, 0, prop); } }
void Update() { if (_needsReset) ResetResources(); if (Application.isPlaying) { UpdateKernelShader(); SwapBuffersAndInvokeKernels(); } 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", _scale * (1 - _scaleRandomness)); props.SetFloat("_ScaleMax", _scale); 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.SetVector("_BufferOffset", uv); Graphics.DrawMesh( mesh, position, rotation, material, 0, null, 0, props, _castShadows, _receiveShadows); } }