void Update()
{
if (rotateToNoon)
{
sun.transform.RotateAround(sunPos, sunUp, 180f * (Time.deltaTime / timeToSwitch));
float lerpFactor = Mathf.Clamp01(sun.transform.forward.y / noonVector.y);
sunLight.intensity = lerpFactor;
RenderSettings.fogColor = Color.Lerp(dayFogColor, Color.black, lerpFactor);
reflectionProbe.RenderProbe();
timer += Time.deltaTime;
if (timer >= timeToSwitch)
{
isNoon = true;
rotateToNoon = false;
sun.transform.forward = noonVector;
RenderSettings.fogColor = dayFogColor;
}
}
else if (rotateToMidnight)
{
sun.transform.RotateAround(sunPos, sunUp, 180f * (Time.deltaTime / timeToSwitch));
float lerpFactor = Mathf.Clamp01(sun.transform.forward.y / noonVector.y);
sunLight.intensity = lerpFactor;
RenderSettings.fogColor = Color.Lerp(Color.black, dayFogColor, lerpFactor);
reflectionProbe.RenderProbe();
timer += Time.deltaTime;
if (timer >= timeToSwitch)
{
isNoon = false;
rotateToMidnight = false;
RenderSettings.fogColor = Color.black;
}
}
}
void Awake()
{
RenderSettings.sun = sun;
roomLightsOn = false;
windowIntensity = windowLight.intensity;
extIntensity = exteriorLight.intensity;
lampAnim = lampSwitch.GetComponent <Animation>();
rend = lamp.GetComponent <Renderer>();
paintingRend = painting.GetComponent <Renderer>();
wallNumberRend = wallNumbers.transform.GetChild(0).GetComponent <Renderer>();
wallNumberRend.sharedMaterial.SetColor("_Color", noAlpha);
wallNumberRend.sharedMaterial.SetColor("_EmissionColor", Color.black);
purple = new Color32(145, 0, 255, 255);
blue = new Color(0, 1, 0.9f);
noAlpha = new Color32(0, 0, 0, 0);
white = new Color32(255, 255, 255, 255);
foreach (Light light in ambientLights)
{
light.enabled = false;
}
foreach (Light light in testLights)
{
light.enabled = false;
}
if (probe != null)
{
probe.RenderProbe();
}
}
private void SetReflections()
{
switch (Options.Settings.Quality)
{
case 0:
_reflectionRefreshInterval = 1.0f / 3.0f;
_reflectionProbe.resolution = 64;
_reflectionProbe.refreshMode = ReflectionProbeRefreshMode.ViaScripting;
break;
case 1:
_reflectionRefreshInterval = 1.0f / 10.0f;
_reflectionProbe.resolution = 128;
_reflectionProbe.refreshMode = ReflectionProbeRefreshMode.ViaScripting;
break;
case 2:
_reflectionRefreshInterval = 1.0f / 30.0f;
_reflectionProbe.resolution = 256;
_reflectionProbe.refreshMode = ReflectionProbeRefreshMode.ViaScripting;
break;
default:
break;
}
_reflectionProbe.RenderProbe();
}
void OnTriggerEnter(Collider collider)
{
UnityEngine.GameObject obj = collider.gameObject;
if (null != obj)
{
if (obj == LogicSystem.PlayerSelf)
{
if (!IsNight)
{
LocalLevelLightmapData.LoadLightingScenario(0);
Debug.Log("Switch to DayLight");
DayLight.SetActive(true);
NightLight.SetActive(false);
// GlobalReflectionProbe.intensity = ReflectionProbeIntensity;
GlobalReflectionProbe.RenderProbe();
IsNight = true;
}
else
{
LocalLevelLightmapData.LoadLightingScenario(1);
Debug.Log("Switch to NightLight");
DayLight.SetActive(false);
NightLight.SetActive(true);
// GlobalReflectionProbe.intensity = ReflectionProbeIntensity / 2.0f;
GlobalReflectionProbe.RenderProbe();
IsNight = false;
}
}
}
}
public override void BehaviorEnabled()
{
probe.enabled = true;
if (probe.refreshMode == ReflectionProbeRefreshMode.ViaScripting)
{
probe.RenderProbe();
}
prevPos = transform.position;
}
protected override void Refresh()
{
if (m_UseRenderTexture)
{
m_Probe.RenderProbe(m_RenderTexture);
}
else
{
m_Probe.RenderProbe(null);
}
}
private void Start()
{
Windowed();
Batchui = gameObject.AddComponent <BatchUI>();
_lastDirectory = Application.dataPath;
HeightMap = null;
HdHeightMap = null;
DiffuseMap = null;
DiffuseMapOriginal = null;
NormalMap = null;
MetallicMap = null;
SmoothnessMap = null;
EdgeMap = null;
AoMap = null;
_propertyCompShader = Shader.Find("Hidden/Blit_Property_Comp");
_propertyCompMaterial = new Material(_propertyCompShader);
Shader.SetGlobalFloat(CorrectionId, GamaCorrection);
FullMaterial = new Material(FullMaterialRef.shader);
FullMaterial.CopyPropertiesFromMaterial(FullMaterialRef);
SampleMaterial = new Material(SampleMaterialRef.shader);
SampleMaterial.CopyPropertiesFromMaterial(SampleMaterialRef);
HeightFromDiffuseGuiScript = HeightFromDiffuseGuiObject.GetComponent <HeightFromDiffuseGui>();
NormalFromHeightGuiScript = NormalFromHeightGuiObject.GetComponent <NormalFromHeightGui>();
EdgeFromNormalGuiScript = EdgeFromNormalGuiObject.GetComponent <EdgeFromNormalGui>();
AoFromNormalGuiScript = AoFromNormalGuiObject.GetComponent <AoFromNormalGui>();
EditDiffuseGuiScript = EditDiffuseGuiObject.GetComponent <EditDiffuseGui>();
MetallicGuiScript = MetallicGuiObject.GetComponent <MetallicGui>();
SmoothnessGuiScript = SmoothnessGuiObject.GetComponent <SmoothnessGui>();
MaterialGuiScript = MaterialGuiObject.GetComponent <MaterialGui>();
_tilingTextureMakerGuiScript = TilingTextureMakerGuiObject.GetComponent <TilingTextureMakerGui>();
_saveLoadProjectScript = SaveLoadProjectObject.GetComponent <SaveLoadProject>();
_settingsGuiScript = SettingsGuiObject.GetComponent <SettingsGui>();
_settingsGuiScript.LoadSettings();
if (Application.platform == RuntimePlatform.WindowsEditor ||
Application.platform == RuntimePlatform.WindowsPlayer)
{
_pathChar = '\\';
}
TestObject.GetComponent <Renderer>().material = FullMaterial;
SetMaterialValues();
ReflectionProbe.RenderProbe();
HideGuiLocker.LockEmpty += LoadHideState;
}
private void Awake()
{
if (state != AzureReflectionProbeState.On)
{
return;
}
if (refreshMode == ReflectionProbeRefreshMode.ViaScripting && updateAtFirstFrame)
{
reflectionProbe.RenderProbe();
//DynamicGI.UpdateEnvironment();
}
}
//--------------------------------------------------------------------------
private void OnEnable()
{
mainCamera = Camera.main.transform;
RenderSettings.ambientMode = UnityEngine.Rendering.AmbientMode.Trilight;
RenderSettings.sun = myLight;
RenderSettings.skybox = skyMaterial;
RenderSettings.defaultReflectionResolution = probe.resolution;
RenderSettings.defaultReflectionMode = UnityEngine.Rendering.DefaultReflectionMode.Custom;
RenderSettings.customReflection = new Cubemap(probe.resolution, TextureFormat.RGBA32, true);
probeRenderID = probe.RenderProbe();
#if UNITY_EDITOR
lastNightDuration = -1;
#endif
}
IEnumerator Start()
{
observerIsRunning = false;
EnvironmentMapSphere.SetActive(false);
UnityWebRequest request = UnityWebRequest.GetTexture(URL);
request.timeout = 3;
yield return(request.Send());
if (request.responseCode != 200)
{
switch (IBLType)
{
case IBLTypes.ReflectionProbe:
ReflectionProbe.RenderProbe();
break;
case IBLTypes.Skyshop:
RenderToCubemap();
UpdateSphericalHarmonics();
break;
default:
break;
}
yield break;
}
DefaultEnvironmentMapSphere.SetActive(false);
EnvironmentMapSphere.SetActive(true);
targetRenderer = EnvironmentMapSphere.GetComponent <Renderer>();
texture = new Texture2D(2, 2);
imageBytes = new List <byte>();
mainCamera = Camera.main;
if ((IBLType == IBLTypes.ReflectionProbe) && (ReflectionProbe != null))
{
observerIsRunning = true;
}
#if SKYSHOP
else if ((IBLType == IBLTypes.Skyshop) && (EnvironmentCubemap != null) && (Sky != null))
{
observerIsRunning = true;
}
#endif
}
// Update is called once per frame
void Update()
{
if (directionFaced == Direction.X)
{
offset = (plane.transform.position.x - character.transform.position.x);
transform.position = new Vector3(
plane.transform.position.x + offset,
character.transform.position.y,
character.transform.position.z);
}
if (directionFaced == Direction.Y)
{
offset = (plane.transform.position.y - character.transform.position.y);
transform.position = new Vector3(
character.transform.position.x,
plane.transform.position.z + offset,
character.transform.position.z);
}
if (directionFaced == Direction.Z)
{
offset = (plane.transform.position.z - character.transform.position.z);
transform.position = new Vector3(
character.transform.position.x,
character.transform.position.y,
plane.transform.position.z + offset);
}
probe.RenderProbe(texture);
}
// Refresh Methods
public void RefreshReflection(bool timeSlice = false)
{
if (customRendering)
{
if (rendering == true)
{
return;
}
CreateTexturesAndMaterial();
if (renderCam == null)
{
CreateRenderCamera();
}
UpdateCameraSettings();
renderCam.transform.position = transform.position;
renderCam.targetTexture = renderTexture;
if (!timeSlice)
{
refreshing = StartCoroutine(RefreshInstant(renderTexture, mirrorTexture));
}
else
{
refreshing = StartCoroutine(RefreshOvertime(renderTexture, mirrorTexture));
}
}
else
{
myProbe.RenderProbe();
}
}
void Update()
{
if (RenderProbe)
{
float tempHitY;
float tempY;
RaycastHit hit;
if (Physics.Raycast(Camera.main.transform.position, Vector3.down, out hit, RayLength))
{
tempHitY = hit.point.y;
}
else
{
tempHitY = 0f;
}
tempY = tempHitY - (Camera.main.transform.position.y - tempHitY);
transform.position = new Vector3(Camera.main.transform.position.x, tempY, Camera.main.transform.position.z);
if (probe)
{
curTime += Time.deltaTime;
if (curTime > RenderDelay)
{
probe.RenderProbe();
curTime = 0f;
}
}
}
}
private void Update()
{
Vector3 pos = Camera.main.transform.position;
probe.transform.position = new Vector3(pos.x, pos.y * -1, pos.z);
probe.RenderProbe();
}
private IEnumerator UpdateEnvironmentMapRoutine()
{
UnityWebRequest request = UnityWebRequest.GetTexture(URL);
yield return(request.Send());
if (request.responseCode == 200)
{
UpdateObserverRotation();
UpdateTexture(request.downloadHandler.data);
switch (IBLType)
{
case IBLTypes.ReflectionProbe:
ReflectionProbe.RenderProbe();
break;
case IBLTypes.Skyshop:
RenderToCubemap();
UpdateSphericalHarmonics();
break;
default:
break;
}
Resources.UnloadUnusedAssets();
}
else if (request.isError)
{
Debug.Log(request.error);
}
}
/// <summary>
/// Update the scene environment reflections
/// </summary>
public void UpdateReflections()
{
if (!probeGameObject || !probeComponent)
{
UpdateReflectionProbe();
}
// The Update function refreshes the Reflection Probe and copies the result to the default specular reflection Cubemap.
// The texture associated with the real-time Reflection Probe is a render target and RenderSettings.customReflection is a Cubemap. We have to check the support if copying from render targets to Textures is supported.
if ((SystemInfo.copyTextureSupport & CopyTextureSupport.RTToTexture) != 0)
{
// Wait until previous RenderProbe is finished before we refresh the Reflection Probe again.
// renderId is a token used to figure out when the refresh of a Reflection Probe is finished. The refresh of a Reflection Probe can take mutiple frames when time-slicing is used.
if (renderId == -1 || probeComponent.IsFinishedRendering(renderId))
{
if (probeComponent.IsFinishedRendering(renderId))
{
//Debug.Log("probeComponent.texture.width = " + probeComponent.texture.width + " blendedCubemap.width = "+ blendedCubemap.width);
//Debug.Log("probeComponent.texture.height = " + probeComponent.texture.height + " blendedCubemap.height = " + blendedCubemap.height);
//Debug.Log("probeComponent.resolution = " + probeComponent.resolution);
// After the previous RenderProbe is finished, we copy the probe's texture to the cubemap and set it as a custom reflection in RenderSettings.
if (probeComponent.texture.width == blendedCubemap.width && probeComponent.texture.height == blendedCubemap.height)
{
Graphics.CopyTexture(probeComponent.texture, blendedCubemap as Texture);
//Debug.Log("Copying");
}
RenderSettings.customReflection = blendedCubemap;
}
renderId = probeComponent.RenderProbe();
}
}
}
/* ----------------------------------------
* At Awake, assign ReflectionProbe component to
* probe' variable and update cubemap
*/
void Awake()
{
// Assign assign ReflectionProbe component to 'probe' variable
probe = GetComponent <ReflectionProbe> ();
// Use RenderProbe function to update reflection cubemap
probe.RenderProbe();
}
private void OnDisable()
{
// Restore and render a default probe
if (probe != null && probe.isActiveAndEnabled)
{
probe.mode = UnityEngine.Rendering.ReflectionProbeMode.Realtime;
probe.refreshMode = UnityEngine.Rendering.ReflectionProbeRefreshMode.ViaScripting;
probe.RenderProbe();
}
RenderSettings.skybox = startSky;
if (directionalLight != null)
{
directionalLight.color = startLightColor;
directionalLight.transform.rotation = startLightRot;
directionalLight.intensity = startLightBrightness;
}
if (captureCamera != null)
{
captureCamera.Shutdown();
}
DynamicGI.UpdateEnvironment();
}
//
void OnEnable()
{
myProbe = GetComponent <ReflectionProbe>();
if (!standalone && myProbe != null)
{
myProbe.enabled = true;
}
if (customRendering)
{
myProbe.mode = ReflectionProbeMode.Custom;
myProbe.refreshMode = ReflectionProbeRefreshMode.ViaScripting;
CreateCubemap();
CreateTexturesAndMaterial();
CreateRenderCamera();
currentRes = myProbe.resolution;
rendering = false;
StartCoroutine(RefreshFirstTime());
}
else
{
myProbe.mode = ReflectionProbeMode.Realtime;
myProbe.refreshMode = ReflectionProbeRefreshMode.ViaScripting;
myProbe.RenderProbe();
}
}
void Update()
{
if (!debug)
{
probe.transform.position = new Vector3(
cam.transform.position.x,
cam.transform.position.y * -1,
cam.transform.position.z
);
}
else
{
#if UNITY_EDITOR
var cam = SceneView.lastActiveSceneView.camera;
probe.transform.position = new Vector3(
cam.transform.position.x,
cam.transform.position.y * -1,
cam.transform.position.z
);
#endif
}
probe.RenderProbe();
}
public override void DoUpdate()
{
if (Vector3.Angle(Player.instance.headTrs.position - trs.position, Player.instance.headTrs.forward) <= maxAnlgeToBlock)
{
reflectionProbe.RenderProbe();
}
}
private void Update()
{
if (rf.IsFinishedRendering(RenderId))
{
rf.RenderProbe(targetTexture = null);
}
}
void Start()
{
Piece.Moved += MovePiece;
Piece.Rotated += RotatePiece;
placeholderManager = transform.parent.GetComponent <PlaceholderManager>();
ReflectionProbe rp = transform.parent.GetComponentInChildren <ReflectionProbe>();
if (rp != null)
{
rps.Add(rp);
rp.RenderProbe();
}
Renderer r = GetComponent <Renderer>();
if (Piece.Color == PieceColor.Red)
{
r.material = redMaterial;
}
else if (Piece.Color == PieceColor.Silver)
{
r.material = silverMaterial;
}
}
/// <summary>Event triggered when the skybox exposure Slider has changed.</summary>
/// <param name="exposure">The new exposure value.</param>
public void OnSkyboxExposureChanged(float exposure)
{
_skyboxMaterial.SetFloat("_Exposure", exposure);
_skyboxRenderer.material = _skyboxMaterial;
RenderSettings.skybox = _skyboxMaterial;
DynamicGI.UpdateEnvironment();
_reflectionProbe.RenderProbe();
}
private void UpdateEnvironment(Environment environment)
{
RenderSettings.skybox = environment.skybox;
mainLight.color = environment.lightColor;
mainLight.intensity = environment.intensity;
DynamicGI.UpdateEnvironment();
_reflectionProbe.RenderProbe();
}
IEnumerator RefreshProbeEffect()
{
while (true)
{
Probe.RenderProbe();
yield return(WaitRefreshProbe);
}
}
IEnumerator ProcessProbesCoroutine()
{
yield return(null);
RenderId = TheProbe.RenderProbe(null);
// Debug.Log ("Processing Probes Update Coroutine!");
}
public void RenderProbe()
{
if (targetProbe != null)
{
renderID = targetProbe.RenderProbe();
StartCoroutine(WaitForRenderRoutine());
}
}
public static IEnumerator UpdateProbe()
{
while (true)
{
probe.RenderProbe();
yield return(new WaitForSeconds(probeUpdateDelay));
}
}
public Material[] temp_mats = new Material[5]; // array of materials used to sed materials on chrome sphere
void Awake()
{
startpos = transform.position;
chime = GetComponent <AudioSource>();
mesh = gameObject.GetComponent <MeshRenderer>();
probe = GetComponent <ReflectionProbe>();
probe.RenderProbe();
}
