/// <summary>
/// Can be used to change the material of a prototype at runtime
/// </summary>
/// <param name="manager">GPUI Manager</param>
/// <param name="prototype">GPUI Prototype</param>
/// <param name="material">New material to set on the renderer</param>
/// <param name="lodLevel">LOD level</param>
/// <param name="rendererIndex">Renderer index on the LOD level</param>
/// <param name="subMeshIndex">Submesh index of the renderer</param>
public static void ChangeMaterial(GPUInstancerManager manager, GPUInstancerPrototype prototype, Material material, int lodLevel = 0, int rendererIndex = 0, int subMeshIndex = 0)
{
GPUInstancerRuntimeData runtimeData = manager.GetRuntimeData(prototype, true);
if (runtimeData == null)
{
return;
}
GPUInstancerRenderer gpuiRenderer = runtimeData.instanceLODs[lodLevel].renderers[rendererIndex];
// Generate proxy GO with a Mesh Renderer to get material property blocks
GameObject proxyGameObject = new GameObject("ProxyGO");
MeshFilter meshFilter = proxyGameObject.AddComponent <MeshFilter>();
MeshRenderer proxyRenderer = proxyGameObject.AddComponent <MeshRenderer>();
// Set mesh to proxy GO
meshFilter.mesh = gpuiRenderer.mesh;
// Set new material to runtime data
gpuiRenderer.materials[subMeshIndex] = GPUInstancerConstants.gpuiSettings.shaderBindings.GetInstancedMaterial(material);
// Set new material to proxy GO
proxyRenderer.materials[subMeshIndex] = material;
// Get material property blocks
proxyRenderer.GetPropertyBlock(gpuiRenderer.mpb);
if (gpuiRenderer.shadowMPB != null)
{
proxyRenderer.GetPropertyBlock(gpuiRenderer.shadowMPB);
}
// Destroy proxy GO
GameObject.Destroy(proxyGameObject);
// Setup new materials for instancing
GPUInstancerUtility.SetAppendBuffers(runtimeData);
}
private void Awake()
{
camLayerMask = unMaskLayer.value;
cam = CamMaskUtilities.MainCam;
hasBackground = false;
defaultCamLayer = cam.cullingMask;
mpb = new MaterialPropertyBlock();
maxTexPropId = Shader.PropertyToID("_MainTex");
colorPropId = Shader.PropertyToID("_Color");
if (top != null)
{
top.GetPropertyBlock(mpb);
mpb.SetColor(colorPropId, Color.clear);
top.SetPropertyBlock(mpb);
top.enabled = false;
}
if (background != null)
{
background.GetPropertyBlock(mpb);
mpb.SetColor(colorPropId, Color.clear);
background.SetPropertyBlock(mpb);
background.enabled = false;
}
transform.localPosition = Vector3.zero;
transform.localRotation = Quaternion.identity;
}
/// <summary>
/// This method was introduced as a workaround for too aggressive submesh draw call batching,
/// leading to incorrect draw order when 3+ materials are used at submeshes in alternating order.
/// Otherwise, e.g. when using Lightweight Render Pipeline, deliberately separated draw calls
/// "A1 B A2" are reordered to "A1A2 B", regardless of batching-related project settings.
/// </summary>
private void SetMaterialSettingsToFixDrawOrder()
{
if (reusedPropertyBlock == null)
{
reusedPropertyBlock = new MaterialPropertyBlock();
}
bool hasPerRendererBlock = meshRenderer.HasPropertyBlock();
if (hasPerRendererBlock)
{
meshRenderer.GetPropertyBlock(reusedPropertyBlock);
}
for (int i = 0; i < meshRenderer.sharedMaterials.Length; ++i)
{
if (!meshRenderer.sharedMaterials[i])
{
continue;
}
if (!hasPerRendererBlock)
{
meshRenderer.GetPropertyBlock(reusedPropertyBlock, i);
}
// Note: this parameter shall not exist at any shader, then Unity will create separate
// material instances (not in terms of memory cost or leakage).
reusedPropertyBlock.SetFloat(SUBMESH_DUMMY_PARAM_ID, i);
meshRenderer.SetPropertyBlock(reusedPropertyBlock, i);
meshRenderer.sharedMaterials[i].enableInstancing = false;
}
}
private void SetSize(float size)
{
MaterialPropertyBlock prop = new MaterialPropertyBlock();
meshRenderer.GetPropertyBlock(prop);
prop.SetFloat("_Size", size);
meshRenderer.SetPropertyBlock(prop);
}
public void SetHighlight(bool highlight)
{
MaterialPropertyBlock prop = new MaterialPropertyBlock();
meshRenderer.GetPropertyBlock(prop);
prop.SetFloat("_Highlight", highlight ? 1 : 0);
meshRenderer.SetPropertyBlock(prop);
}
public void SetMaterial(Material material)
{
paintMaterial = material;
if (material && !IsEraser)
{
reticle.GetPropertyBlock(propertyBlock);
propertyBlock.SetColor("_Color", paintMaterial.color);
reticle.SetPropertyBlock(propertyBlock);
}
}
public void Init()
{
transform.rotation = Quaternion.Euler(0, thing.facing, 0);
float x = thing.posX;
float z = thing.posY;
Vector3 origin = new Vector3(x, (float)MapLoader.maxZ / MapLoader.sizeDividor, z);
//Vector3 target = new Vector3(x, (float)MapLoader.minZ / MapLoader.sizeDividor, z);
RaycastHit hit;
if (Physics.Raycast(origin, Vector3.down, out hit))
{
transform.position = hit.point;
SectorController sc = hit.collider.gameObject.GetComponent <SectorController>();
if (sc != null)
{
if (mr != null)
{
mr.GetPropertyBlock(materialProperties);
materialProperties.SetFloat("_Brightness", alwaysBright ? 1f : sc.sector.brightness);
mr.SetPropertyBlock(materialProperties);
}
if (dynamic)
{
sc.DynamicThings.AddFirst(this);
}
else
{
sc.StaticThings.Add(this);
}
}
}
else
{
Destroy(gameObject);
}
if (!string.IsNullOrEmpty(spriteName))
{
Texture tex = TextureLoader.Instance.GetSpriteTexture(spriteName);
//materialProperties.SetFloat("_ScaleX", (float)tex.width / MapLoader.sizeDividor);
//materialProperties.SetFloat("_ScaleY", (float)tex.height / MapLoader.sizeDividor);
Mesh mesh = Mesher.Instance.CreateBillboardMesh((float)tex.width / MapLoader.sizeDividor, (float)tex.height / MapLoader.sizeDividor, .5f, 0);
GetComponent <MeshFilter>().mesh = mesh;
SetTexture(tex);
SetSpriteDirection(1);
}
}
private IEnumerator Start()
{
// Setting fade plane to black at start
var block = new MaterialPropertyBlock();
_fadePlane.GetPropertyBlock(block);
block.SetColor("_BaseColor", Color.black);
_fadePlane.SetPropertyBlock(block);
yield return(new WaitForSeconds(3));
FadeStartPlane();
}
// Update is called once per frame
void Update()
{
if (boolDoneOnce1 == false && isUnlocked == true)
{
StartCoroutine(Unlocking());
boolDoneOnce1 = true;
}
if (boolDoneOnce2 == false && isPlayed == true)
{
HasBeenPlayed();
boolDoneOnce2 = true;
}
if (boolDoneOnce3 == false && isGold == true)
{
HasBeenGold();
boolDoneOnce3 = true;
}
if (boolDoneOnce4 == false && isSelected == true)
{
meshRenderer.GetPropertyBlock(MatProp);
MatProp.SetFloat("_Outline", 0.1f);
meshRenderer.SetPropertyBlock(MatProp);
boolDoneOnce4 = true;
}
if (isLocked == true)
{
DebugConstrast();
}
}
public virtual void Init()
{
materialProperties = new MaterialPropertyBlock();
cell.x = Mathf.FloorToInt(transform.position.x);
cell.y = Mathf.FloorToInt(transform.position.z);
AddToGrid();
Triangle sectorTriangle = TheGrid.GetExactTriangle(transform.position);
if (sectorTriangle == null)
{
Debug.Log("Thing \"" + thingName + "\" no sector found.");
Destroy(gameObject);
return;
}
currentSector = sectorTriangle.sector;
transform.position = new Vector3(transform.position.x, currentSector.floorHeight, transform.position.z);
if (mr != null)
{
mr.GetPropertyBlock(materialProperties);
materialProperties.SetFloat("_SectorLight", alwaysBright ? 1f : currentSector.brightness);
mr.SetPropertyBlock(materialProperties);
}
CreateBillboard();
if (currentSector.Dynamic)
{
dynamic = true; //things need to update when on elevators, crushers, etc
}
if (!dynamic)
{
enabled = false;
}
SectorController sc = currentSector.floorObject;
if (dynamic)
{
sc.DynamicThings.AddFirst(this);
}
else
{
sc.StaticThings.Add(this);
}
}
public void ToggleWatermark()
{
sR.GetPropertyBlock(sphereBlock);
var curr = sphereBlock.GetInt("_Watermark");
if (curr == 1)
{
sphereBlock.SetInt("_Watermark", 0);
}
else
{
sphereBlock.SetInt("_Watermark", 1);
}
sR.SetPropertyBlock(sphereBlock);
}
// меняем цвет тушки
IEnumerator ChangeBodyColor(MeshRenderer mr, MaterialPropertyBlock MPB, Color color)
{
mr.GetPropertyBlock(MPB);
MPB.SetColor("_Color", Color.red);
mr.SetPropertyBlock(MPB);
yield return(new WaitForSeconds(0.2f));
if (mr != null)
{
mr.GetPropertyBlock(MPB);
MPB.SetColor("_Color", color);
mr.SetPropertyBlock(MPB);
}
}
// меняем цвет тушки
IEnumerator ChangeBodyColorInRage(MeshRenderer mr, MaterialPropertyBlock MPB, Color colorNew, float duration, Color colorOld)
{
mr.GetPropertyBlock(MPB);
MPB.SetColor("_Color", colorNew);
mr.SetPropertyBlock(MPB);
yield return(new WaitForSeconds(duration));
if (mr != null)
{
mr.GetPropertyBlock(MPB);
MPB.SetColor("_Color", colorOld);
mr.SetPropertyBlock(MPB);
}
}
public void ReloadSkin()
{
if (headPropertyBlock != null)
{
HeadRenderer.GetPropertyBlock(headPropertyBlock);
headPropertyBlock.SetTexture(mainTexShaderId, highlighted ? HighlightTexture : DefaultTexture);
HeadRenderer.SetPropertyBlock(headPropertyBlock);
}
foreach (ArcArcSegmentComponent s in segments)
{
s.DefaultTexture = DefaultTexture;
s.HighlightTexture = HighlightTexture;
s.ReloadSkin();
}
}
// Update is called once per frame
void Update()
{
if (mat == null || propBlock == null)
{
Init();
}
if (surfaceTexture == null || nightGlowTexture == null)
{
return;
}
meshRenderer.GetPropertyBlock(propBlock);
if (scroll)
{
rot += Vector2.right * rotateSpeed;
propBlock.SetVector("_Offset", rot);
}
if (sun != null)
{
Vector3 lightDir = (sun.position - transform.position).normalized;
propBlock.SetVector("_LightDir", lightDir);
}
propBlock.SetTexture("_SurfaceTexture", surfaceTexture);
propBlock.SetTexture("_WaterMask", nightGlowTexture);
propBlock.SetColor("_Tint", tint);
propBlock.SetFloat("_Radius", radius * zoom.ZoomLevel);
propBlock.SetFloat("_ShadowStrength", shadowStrength);
propBlock.SetColor("_ShadowColor", shadowColor);
propBlock.SetFloat("_NightGlow", nightGlow);
meshRenderer.SetPropertyBlock(propBlock);
}
void Awake()
{
for (int i = 0; i < 5; i++)
{
sprites[i] = TextureLoader.Instance.GetSpriteTexture(_spriteNames[i]);
}
mr = GetComponent <MeshRenderer>();
if (mr == null)
{
Destroy(gameObject);
return;
}
materialProperties = new MaterialPropertyBlock();
mr.GetPropertyBlock(materialProperties);
Triangle sectorTriangle = TheGrid.GetExactTriangle(transform.position);
if (sectorTriangle != null)
{
materialProperties.SetFloat("_SectorLight", alwaysBright ? 1f : sectorTriangle.sector.brightness);
}
CreateBillboard();
}
public void SwapSwitchTexture(MeshRenderer mr)
{
if (mr == null)
{
return;
}
MaterialPropertyBlock materialProperties = new MaterialPropertyBlock();
mr.GetPropertyBlock(materialProperties);
string current = materialProperties.GetTexture("_MainTex").name;
//some switches are "invisible" in the sense that they are placed in a non-switch texture wall
if (current.Substring(0, 2) != "SW")
{
return;
}
if (current[2] == '2')
{
current = "SW1" + current.Substring(3);
}
else
{
current = "SW2" + current.Substring(3);
}
materialProperties.SetTexture("_MainTex", GetWallTexture(current));
mr.SetPropertyBlock(materialProperties);
}
void LateUpdate()
{
Matrix4x4 invTransformMatrix = transform.worldToLocalMatrix;
// mat.SetMatrix("_InverseTransformMatrix", invTransformMatrix);
if (props == null)
{
props = new MaterialPropertyBlock();
}
if (rend == null)
{
rend = GetComponent <MeshRenderer>();
}
rend.GetPropertyBlock(props);
props.SetMatrix("_InverseTransformMatrix", invTransformMatrix);
rend.SetPropertyBlock(props);
if (ps != null)
{
psMain.scalingMode = ParticleSystemScalingMode.Hierarchy;
}
if (UseWorldSpaceRotation)
{
transform.rotation = Quaternion.Euler(worldRotation);
}
}
public void StartScene()
{
MPB = new MaterialPropertyBlock();
mr = GetComponentInChildren <MeshRenderer>();
mr.GetPropertyBlock(MPB);
MPB.SetColor("_Color", bodyColor);
mr.SetPropertyBlock(MPB);
Throwpoint = transform.Find("Throwpoint");
lr = Throwpoint.GetComponent <LineRenderer>();
curHealthPoint = maxHealthPoint;
path = new NavMeshPath();
timerForVoidZoneReloading = Random.Range(0, voidZoneReloadingTime); // рандомный таймер для войд зоны (чтобы на старте все враги не начинали одновременный каст)
timerForReloading = reloadingTime;
timerForVoidZoneCasting = voidZoneDuration;
if (rocketsCountPerShoot == 0)
{
rocketsCountPerShoot = 1;
}
curAng = 0;
targAng = twisterAngle / 2f;
rotateDir = 1;
}
public void Initialize(int gridIndex, int gridX, int gridY, GameManager gameManager)
{
this.gameManager = gameManager;
this.gridIndex = gridIndex;
this.gridX = gridX;
this.gridY = gridY;
transform = base.transform;
basePosition = new Vector3(gridX, _baseHeight + _heightVariance * Random.Range(-1f, 1f), gridY);
transform.localPosition = basePosition;
float h, s, v;
Color.RGBToHSV(_baseColor, out h, out s, out v);
_materialPropertyBlock = new MaterialPropertyBlock();
_meshRenderer.GetPropertyBlock(_materialPropertyBlock);
_materialPropertyBlock.SetColor("_Color", Color.HSVToRGB(h, s, v + _colorVariance * Random.Range(-1f, 1f)));
_meshRenderer.SetPropertyBlock(_materialPropertyBlock);
name = gridIndex.ToString();
neighbors = new List <Tile>()
{
gameManager.GetTile(gridX - 1, gridY),
gameManager.GetTile(gridX, gridY + 1),
gameManager.GetTile(gridX + 1, gridY),
gameManager.GetTile(gridX, gridY - 1)
};
neighbors.RemoveAll(x => x == null);
}
void HandleRender(SkeletonRenderer.SmartMesh.Instruction instruction)
{
int rendererCount = partsRenderers.Count;
if (rendererCount <= 0)
{
return;
}
int rendererIndex = 0;
if (copyPropertyBlock)
{
mainMeshRenderer.GetPropertyBlock(copiedBlock);
}
var submeshInstructions = instruction.submeshInstructions;
var submeshInstructionsItems = submeshInstructions.Items;
int lastSubmeshInstruction = submeshInstructions.Count - 1;
var currentRenderer = partsRenderers[rendererIndex];
bool addNormals = skeletonRenderer.calculateNormals;
bool addTangents = skeletonRenderer.calculateTangents;
for (int si = 0, start = 0; si <= lastSubmeshInstruction; si++)
{
if (submeshInstructionsItems[si].forceSeparate || si == lastSubmeshInstruction)
{
// Apply properties
var meshGenerator = currentRenderer.MeshGenerator;
meshGenerator.AddNormals = addNormals;
meshGenerator.AddTangents = addTangents;
if (copyPropertyBlock)
{
currentRenderer.SetPropertyBlock(copiedBlock);
}
// Render
currentRenderer.RenderParts(instruction.submeshInstructions, start, si + 1);
start = si + 1;
rendererIndex++;
if (rendererIndex < rendererCount)
{
currentRenderer = partsRenderers[rendererIndex];
}
else
{
// Not enough renderers. Skip the rest of the instructions.
break;
}
}
}
// Clear extra renderers if they exist.
for (; rendererIndex < rendererCount; rendererIndex++)
{
partsRenderers[rendererIndex].ClearMesh();
}
}
void SetIntensity(float _intensity)
{
light.intensity = Mathf.Lerp(0, lightMaxIntensity, _intensity);
meshRenderer.GetPropertyBlock(materialPropertyBlock, lightMaterialIndex);
materialPropertyBlock.SetColor("_EmissionColor", Color.Lerp(Color.black, maxMaterialColor, _intensity));
meshRenderer.SetPropertyBlock(materialPropertyBlock, lightMaterialIndex);
}
public void OnNewFrame(Astra.ColorizedBodyFrame frame)
{
if (frame.Width == 0 ||
frame.Height == 0)
{
return;
}
if (_lastFrameIndex == frame.FrameIndex)
{
return;
}
_lastFrameIndex = frame.FrameIndex;
EnsureTexture(frame.Width, frame.Height);
_texture.LoadRawTextureData(frame.DataPtr, (int)frame.ByteLength);
// .material.SetTexture("_MainTex", _texture);
MeshRenderer mr = GetComponent <MeshRenderer>();
MaterialPropertyBlock mpb = new MaterialPropertyBlock();
mr.GetPropertyBlock(mpb);
mpb.SetFloat("_Outline", true ? 1f : 0);
mpb.SetColor("_OutlineColor", new Color(0, 0, 0));
mr.SetPropertyBlock(mpb);
_texture.Apply();
}
/// <summary>
/// The Unity Start() method.
/// </summary>
public void Start()
{
//lr = FindObjectOfType<LineRenderer>();
camera = Camera.main.gameObject;
texture = GameObject.FindGameObjectWithTag("DepthTexture");
m_MeshRenderer = GetComponent <MeshRenderer>();
m_Mesh = GetComponent <MeshFilter>().mesh;
if (m_Mesh == null)
{
m_Mesh = new Mesh();
}
m_Mesh.Clear();
m_CachedColor = PointColor;
m_ScreenWidthId = Shader.PropertyToID("_ScreenWidth");
m_ScreenHeightId = Shader.PropertyToID("_ScreenHeight");
m_ColorId = Shader.PropertyToID("_Color");
m_PropertyBlock = new MaterialPropertyBlock();
m_MeshRenderer.GetPropertyBlock(m_PropertyBlock);
m_PropertyBlock.SetColor(m_ColorId, m_CachedColor);
m_MeshRenderer.SetPropertyBlock(m_PropertyBlock);
m_CachedPoints = new LinkedList <PointInfo>();
}
void UpdateVisuals()
{
if (mpb != null)
{
mr.GetPropertyBlock(mpb);
}
else
{
mpb = new MaterialPropertyBlock();
}
if (sprite != null)
{
mpb.SetTexture(mainTex, sprite);
}
mpb.SetColor(c, color);
mpb.SetColor(g, glow);
//mpb.SetColor (ec, new Color(163f/255f, 0, 0));
if (elite)
{
mpb.SetFloat(e, 1);
}
else
{
mpb.SetFloat(e, 0);
}
mpb.SetFloat(timeOffsetTex, timeOffset);
mpb.SetFloat(str, strength);
mr.SetPropertyBlock(mpb);
}
/// <summary>
/// Calls the rendering of a Portal frame
/// </summary>
private void OnWillRenderObject()
{
if (!TargetPortal)
{
return;
}
//Is the mesh renderer in the camera frustrum?
if (MeshRenderer.isVisible)
{
UpdateDopplegangers();
TargetPortal.UpdateDopplegangers();
#if UNITY_EDITOR
if (Camera.current.name == "SceneCamera" || Camera.current.name == "Preview Camera")
{
return;
}
#endif
TryRenderPortal(Camera.current, _nearClipVertsGlobal);
if (Camera.current == Camera.main)
{
SKSGlobalRenderSettings.Inverted = SKSGlobalRenderSettings.Inverted;
SKSGlobalRenderSettings.UvFlip = SKSGlobalRenderSettings.UvFlip;
}
MeshRenderer.GetPropertyBlock(_seamlessRecursionBlock);
SeamlessRecursionRenderer.SetPropertyBlock(_seamlessRecursionBlock);
//}
}
UpdateEffects();
}
private void SetMaterialProperty()
{
MeshRenderer renderer = gameObject.GetComponent <MeshRenderer>();
if (renderer == null)
{
return;
}
MaterialPropertyBlock matPb = new MaterialPropertyBlock();
renderer.GetPropertyBlock(matPb);
matPb.SetVector(ShaderParameters.TerrainLocalPosition, LocalPosition);
if (UsingChannels.Length == 1)
{
matPb.SetVector(ShaderParameters.ChannelsVector4_0, (UsingChannels[0] - Vector4.one));
}
else if (UsingChannels.Length == 2)
{
matPb.SetVector(ShaderParameters.ChannelsVector4_0, UsingChannels[0] - Vector4.one);
matPb.SetVector(ShaderParameters.ChannelsVector4_1, UsingChannels[1] - Vector4.one);
}
else if (UsingChannels.Length == 3)
{
matPb.SetVector(ShaderParameters.ChannelsVector4_0, UsingChannels[0] - Vector4.one);
matPb.SetVector(ShaderParameters.ChannelsVector4_1, UsingChannels[1] - Vector4.one);
matPb.SetVector(ShaderParameters.ChannelsVector4_2, UsingChannels[2] - Vector4.one);
}
renderer.SetPropertyBlock(matPb);
}
void LateUpdate()
{
int p = planes;
//if (!Application.isPlaying)p
if (Application.isPlaying && animate)
{
p = Mathf.FloorToInt(Mathf.Lerp(0, planes, animateCurve.Evaluate(Time.time * animateSpeed)));
}
UpdateMatrices();
if (meshRenderer && mesh)
{
meshRenderer.GetPropertyBlock(mpr);
mpr.SetColor("_Color", color);
for (int i = 0; i < p; i++)
{
Graphics.DrawMesh(mesh, _ms[i], meshRenderer.sharedMaterial, gameObject.layer, null, 0, mpr, shadowCastingMode, receiveShadows);
}
}
//Graphics.DrawMeshInstanced(mesh, 0, meshRenderer.sharedMaterial, _ms, mpr, shadowCastingMode, receiveShadows);
}
void UpdatePropBlock()
{
if (_meshRenderer)
{
if (_curPropBlock == null)
{
_curPropBlock = new MaterialPropertyBlock();
}
_meshRenderer.GetPropertyBlock(_curPropBlock);
_curPropBlock.SetColor("_Tint", tint);
var sprite = clip ? clip.Sprite : null;
var atlas = sprite && sprite.texture ? sprite.texture : Texture2D.whiteTexture;
var atlasA = sprite ? sprite.associatedAlphaSplitTexture : null;
_curPropBlock.SetTexture(
"_MainTex",
atlas ? atlas : Texture2D.whiteTexture);
if (atlasA)
{
_curPropBlock.SetTexture("_AlphaTex", atlasA);
_curPropBlock.SetFloat("_ExternalAlpha", 1.0f);
}
else
{
_curPropBlock.SetTexture("_AlphaTex", Texture2D.whiteTexture);
_curPropBlock.SetFloat("_ExternalAlpha", 0.0f);
}
_meshRenderer.SetPropertyBlock(_curPropBlock);
}
}
void Start()
{
currentFallOffTime = fallOffTime;
lastDamageTime = Mathf.NegativeInfinity;
mpb = new MaterialPropertyBlock();
mr.GetPropertyBlock(mpb);
}
