public void BindRayTracedReflectionData(CommandBuffer cmd, HDCamera hdCamera, HDRaytracingEnvironment rtEnvironment, RayTracingShader reflectionShader, ScreenSpaceReflection settings, LightCluster lightClusterSettings) { // Grab the acceleration structures and the light cluster to use RayTracingAccelerationStructure accelerationStructure = m_RayTracingManager.RequestAccelerationStructure(rtEnvironment.reflLayerMask); HDRaytracingLightCluster lightCluster = m_RayTracingManager.RequestLightCluster(rtEnvironment.reflLayerMask); // Define the shader pass to use for the reflection pass cmd.SetRayTracingShaderPass(reflectionShader, "IndirectDXR"); // Set the acceleration structure for the pass cmd.SetRayTracingAccelerationStructure(reflectionShader, HDShaderIDs._RaytracingAccelerationStructureName, accelerationStructure); // Inject the ray-tracing sampling data cmd.SetRayTracingTextureParam(reflectionShader, HDShaderIDs._OwenScrambledTexture, m_Asset.renderPipelineResources.textures.owenScrambledTex); cmd.SetRayTracingTextureParam(reflectionShader, HDShaderIDs._ScramblingTexture, m_Asset.renderPipelineResources.textures.scramblingTex); // Global reflection parameters cmd.SetRayTracingFloatParams(reflectionShader, HDShaderIDs._RaytracingIntensityClamp, settings.clampValue.value); cmd.SetRayTracingFloatParams(reflectionShader, HDShaderIDs._RaytracingReflectionMinSmoothness, settings.minSmoothness.value); cmd.SetRayTracingIntParams(reflectionShader, HDShaderIDs._RaytracingReflectSky, settings.reflectSky.value ? 1 : 0); // Inject the ray generation data cmd.SetGlobalFloat(HDShaderIDs._RaytracingRayBias, rtEnvironment.rayBias); cmd.SetGlobalFloat(HDShaderIDs._RaytracingRayMaxLength, settings.rayLength.value); cmd.SetRayTracingIntParams(reflectionShader, HDShaderIDs._RaytracingNumSamples, settings.numSamples.value); int frameIndex = hdCamera.IsTAAEnabled() ? hdCamera.taaFrameIndex : (int)m_FrameCount % 8; cmd.SetRayTracingIntParam(reflectionShader, HDShaderIDs._RaytracingFrameIndex, frameIndex); // Set the data for the ray generation cmd.SetRayTracingTextureParam(reflectionShader, HDShaderIDs._SsrLightingTextureRW, m_ReflIntermediateTexture0); cmd.SetRayTracingTextureParam(reflectionShader, HDShaderIDs._SsrHitPointTexture, m_ReflIntermediateTexture1); cmd.SetRayTracingTextureParam(reflectionShader, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthStencilBuffer()); cmd.SetRayTracingTextureParam(reflectionShader, HDShaderIDs._NormalBufferTexture, m_SharedRTManager.GetNormalBuffer()); // Set ray count tex cmd.SetRayTracingIntParam(reflectionShader, HDShaderIDs._RayCountEnabled, m_RayTracingManager.rayCountManager.RayCountIsEnabled()); cmd.SetRayTracingTextureParam(reflectionShader, HDShaderIDs._RayCountTexture, m_RayTracingManager.rayCountManager.rayCountTexture); // Compute the pixel spread value float pixelSpreadAngle = Mathf.Atan(2.0f * Mathf.Tan(hdCamera.camera.fieldOfView * Mathf.PI / 360.0f) / Mathf.Min(hdCamera.actualWidth, hdCamera.actualHeight)); cmd.SetRayTracingFloatParam(reflectionShader, HDShaderIDs._RaytracingPixelSpreadAngle, pixelSpreadAngle); // LightLoop data cmd.SetGlobalBuffer(HDShaderIDs._RaytracingLightCluster, lightCluster.GetCluster()); cmd.SetGlobalBuffer(HDShaderIDs._LightDatasRT, lightCluster.GetLightDatas()); cmd.SetGlobalVector(HDShaderIDs._MinClusterPos, lightCluster.GetMinClusterPos()); cmd.SetGlobalVector(HDShaderIDs._MaxClusterPos, lightCluster.GetMaxClusterPos()); cmd.SetGlobalInt(HDShaderIDs._LightPerCellCount, lightClusterSettings.maxNumLightsPercell.value); cmd.SetGlobalInt(HDShaderIDs._PunctualLightCountRT, lightCluster.GetPunctualLightCount()); cmd.SetGlobalInt(HDShaderIDs._AreaLightCountRT, lightCluster.GetAreaLightCount()); // Note: Just in case, we rebind the directional light data (in case they were not) cmd.SetGlobalBuffer(HDShaderIDs._DirectionalLightDatas, m_LightLoopLightData.directionalLightData); cmd.SetGlobalInt(HDShaderIDs._DirectionalLightCount, m_lightList.directionalLights.Count); // Evaluate the clear coat mask texture based on the lit shader mode RenderTargetIdentifier clearCoatMaskTexture = hdCamera.frameSettings.litShaderMode == LitShaderMode.Deferred ? m_GbufferManager.GetBuffersRTI()[2] : TextureXR.GetBlackTexture(); cmd.SetRayTracingTextureParam(reflectionShader, HDShaderIDs._SsrClearCoatMaskTexture, clearCoatMaskTexture); }
/// <summary> /// Get the horizontal FOV from the stereo camera /// </summary> public static float GetHorizontalFieldOfViewRadians(this Camera camera) { return(2f * Mathf.Atan(Mathf.Tan(camera.fieldOfView * Mathf.Deg2Rad * 0.5f) * camera.aspect)); }
public virtual IEnumerator Start() { findS3dCamera(); checkpoints = new Vector2[5]; objectCopyR = UnityEngine.Object.Instantiate(gameObject, transform.position, transform.rotation); UnityEngine.Object.Destroy((s3dGuiTexture)objectCopyR.GetComponent(typeof(s3dGuiTexture))); objectCopyR.name = gameObject.name + "_R"; gameObject.name = gameObject.name + "_L"; gameObject.layer = camera3D.leftOnlyLayer; objectCopyR.layer = camera3D.rightOnlyLayer; obPosition = gameObject.transform.position; // if using stereo shader + side-by-side + not squeezed, double width of guiTexture if ((camera3D.useStereoShader && (camera3D.format3D == (mode3D)0)) && !camera3D.sideBySideSqueezed) { xWidth = GetComponent <GUITexture>().pixelInset.width * 2; { float _33 = xWidth; Rect _34 = gameObject.GetComponent <GUITexture>().pixelInset; _34.width = _33; gameObject.GetComponent <GUITexture>().pixelInset = _34; } { float _35 = xWidth; Rect _36 = objectCopyR.GetComponent <GUITexture>().pixelInset; _36.width = _35; objectCopyR.GetComponent <GUITexture>().pixelInset = _36; } xInset = gameObject.GetComponent <GUITexture>().pixelInset.width / -2; { float _37 = xInset; Rect _38 = gameObject.GetComponent <GUITexture>().pixelInset; _38.x = _37; gameObject.GetComponent <GUITexture>().pixelInset = _38; } { float _39 = xInset; Rect _40 = objectCopyR.GetComponent <GUITexture>().pixelInset; _40.x = _39; objectCopyR.GetComponent <GUITexture>().pixelInset = _40; } } else { // if not using stereo shader + squeezed, halve width of guiTexture if (!camera3D.useStereoShader && camera3D.sideBySideSqueezed) { xWidth = gameObject.GetComponent <GUITexture>().pixelInset.width * 0.5f; { float _41 = xWidth; Rect _42 = gameObject.GetComponent <GUITexture>().pixelInset; _42.width = _41; gameObject.GetComponent <GUITexture>().pixelInset = _42; } { float _43 = xWidth; Rect _44 = objectCopyR.GetComponent <GUITexture>().pixelInset; _44.width = _43; objectCopyR.GetComponent <GUITexture>().pixelInset = _44; } xInset = gameObject.GetComponent <GUITexture>().pixelInset.width / -2; { float _45 = xInset; Rect _46 = gameObject.GetComponent <GUITexture>().pixelInset; _46.x = _45; gameObject.GetComponent <GUITexture>().pixelInset = _46; } { float _47 = xInset; Rect _48 = objectCopyR.GetComponent <GUITexture>().pixelInset; _48.x = _47; objectCopyR.GetComponent <GUITexture>().pixelInset = _48; } } } // find corner offset corner = new Vector2((gameObject.GetComponent <GUITexture>().pixelInset.width / 2) / Screen.width, (gameObject.GetComponent <GUITexture>().pixelInset.height / 2) / Screen.height); toggleVisible(beginVisible); float horizontalFOV = (2 * Mathf.Atan(Mathf.Tan((camera3D.GetComponent <Camera>().fieldOfView *Mathf.Deg2Rad) / 2) * camera3D.GetComponent <Camera>().aspect)) * Mathf.Rad2Deg; unitWidth = Mathf.Tan((horizontalFOV / 2) * Mathf.Deg2Rad); // need unit width to calculate cursor depth when there's a HIT (horizontal image transform) screenWidth = (unitWidth * camera3D.zeroPrlxDist) * 2; setScreenParallax(); if (timeToDisplay != 0f) { yield return(new WaitForSeconds(timeToDisplay)); toggleVisible(false); } s3dCursor = (s3dGuiCursor)gameObject.GetComponent(typeof(s3dGuiCursor)); if (s3dCursor) { s3dCursor.initialize(); } }
/// <summary> /// Raises the web cam texture to mat helper initialized event. /// </summary> public void OnWebCamTextureToMatHelperInitialized() { Debug.Log("OnWebCamTextureToMatHelperInitialized"); Mat webCamTextureMat = webCamTextureToMatHelper.GetMat(); #if NETFX_CORE && !DISABLE_HOLOLENSCAMSTREAM_API // HololensCameraStream always returns image data in BGRA format. texture = new Texture2D(webCamTextureMat.cols(), webCamTextureMat.rows(), TextureFormat.BGRA32, false); #else texture = new Texture2D(webCamTextureMat.cols(), webCamTextureMat.rows(), TextureFormat.RGBA32, false); #endif texture.wrapMode = TextureWrapMode.Clamp; Debug.Log("Screen.width " + Screen.width + " Screen.height " + Screen.height + " Screen.orientation " + Screen.orientation); processingAreaRect = new OpenCVForUnity.Rect((int)(webCamTextureMat.cols() * (outsideClippingRatio.x - clippingOffset.x)), (int)(webCamTextureMat.rows() * (outsideClippingRatio.y + clippingOffset.y)), (int)(webCamTextureMat.cols() * (1f - outsideClippingRatio.x * 2)), (int)(webCamTextureMat.rows() * (1f - outsideClippingRatio.y * 2))); processingAreaRect = processingAreaRect.intersect(new OpenCVForUnity.Rect(0, 0, webCamTextureMat.cols(), webCamTextureMat.rows())); dstMat = new Mat(webCamTextureMat.rows(), webCamTextureMat.cols(), CvType.CV_8UC1); dstMatClippingROI = new Mat(dstMat, processingAreaRect); // fill all black. //Imgproc.rectangle (dstMat, new Point (0, 0), new Point (dstMat.width (), dstMat.height ()), new Scalar (0, 0, 0, 0), -1); grayMat = new Mat(dstMatClippingROI.rows(), dstMatClippingROI.cols(), CvType.CV_8UC1); lineMat = new Mat(dstMatClippingROI.rows(), dstMatClippingROI.cols(), CvType.CV_8UC1); maskMat = new Mat(dstMatClippingROI.rows(), dstMatClippingROI.cols(), CvType.CV_8UC1); //create a striped background. bgMat = new Mat(dstMatClippingROI.rows(), dstMatClippingROI.cols(), CvType.CV_8UC1, new Scalar(255)); for (int i = 0; i < bgMat.rows() * 2.5f; i = i + 4) { Imgproc.line(bgMat, new Point(0, 0 + i), new Point(bgMat.cols(), -bgMat.cols() + i), new Scalar(0), 1); } grayPixels = new byte[grayMat.cols() * grayMat.rows() * grayMat.channels()]; maskPixels = new byte[maskMat.cols() * maskMat.rows() * maskMat.channels()]; quad_renderer = gameObject.GetComponent <Renderer> () as Renderer; quad_renderer.sharedMaterial.SetTexture("_MainTex", texture); quad_renderer.sharedMaterial.SetVector("_VignetteOffset", new Vector4(clippingOffset.x, clippingOffset.y)); Matrix4x4 projectionMatrix; #if NETFX_CORE && !DISABLE_HOLOLENSCAMSTREAM_API projectionMatrix = webCamTextureToMatHelper.GetProjectionMatrix(); quad_renderer.sharedMaterial.SetMatrix("_CameraProjectionMatrix", projectionMatrix); #else //This value is obtained from PhotoCapture's TryGetProjectionMatrix() method.I do not know whether this method is good. //Please see the discussion of this thread.Https://forums.hololens.com/discussion/782/live-stream-of-locatable-camera-webcam-in-unity projectionMatrix = Matrix4x4.identity; projectionMatrix.m00 = 2.31029f; projectionMatrix.m01 = 0.00000f; projectionMatrix.m02 = 0.09614f; projectionMatrix.m03 = 0.00000f; projectionMatrix.m10 = 0.00000f; projectionMatrix.m11 = 4.10427f; projectionMatrix.m12 = -0.06231f; projectionMatrix.m13 = 0.00000f; projectionMatrix.m20 = 0.00000f; projectionMatrix.m21 = 0.00000f; projectionMatrix.m22 = -1.00000f; projectionMatrix.m23 = 0.00000f; projectionMatrix.m30 = 0.00000f; projectionMatrix.m31 = 0.00000f; projectionMatrix.m32 = -1.00000f; projectionMatrix.m33 = 0.00000f; quad_renderer.sharedMaterial.SetMatrix("_CameraProjectionMatrix", projectionMatrix); #endif quad_renderer.sharedMaterial.SetFloat("_VignetteScale", vignetteScale); float halfOfVerticalFov = Mathf.Atan(1.0f / projectionMatrix.m11); float aspectRatio = (1.0f / Mathf.Tan(halfOfVerticalFov)) / projectionMatrix.m00; Debug.Log("halfOfVerticalFov " + halfOfVerticalFov); Debug.Log("aspectRatio " + aspectRatio); // //Imgproc.rectangle (dstMat, new Point (0, 0), new Point (webCamTextureMat.width (), webCamTextureMat.height ()), new Scalar (126, 126, 126, 255), -1); // }
/// <summary> /// Update Arm Shape /// target: Keypoint to modify /// Returns modified keypoint /// </summary> Vector3 ArmShape(int arm, Vector3 target, Vector3 shoulderPos) { float rotTheta = 0f; Vector3 centerEllipse; //Transform target from world space to local EMOTE coordinates // targetLocal = transform.InverseTransformPoint(target); //Translate to world //Vector3 targetLocal = target - _arms[arm].Shoulder.position; Vector3 targetLocal = target - shoulderPos; // Debug.Log(targetLocal); //Rotate to emote targetLocal = new Vector3(targetLocal.y, -targetLocal.z, targetLocal.x); //hor float theta = Mathf.Atan(Abratio * targetLocal.y / -targetLocal.z); if (-targetLocal.z < 0) { theta += Mathf.PI; } if (theta < 0) { theta += 2 * Mathf.PI; } float a = -targetLocal.z / Mathf.Cos(theta); if (Hor == 0) { // WRONG! rotTheta = 0f; rotTheta = theta; } else if (Hor < 0f && 0 < theta && theta <= Mathf.PI) { rotTheta = Mathf.Min(theta - Hor * MaxdTheta, Mathf.PI); } else if (Hor < 0f && Mathf.PI < theta && theta <= 2 * Mathf.PI) { rotTheta = Mathf.Max(theta + Hor * MaxdTheta, Mathf.PI); } else if (Hor > 0f && 0 < theta && theta <= Mathf.PI) { rotTheta = Mathf.Max(theta - Hor * MaxdTheta, 0); } else if (Hor > 0f && Mathf.PI < theta && theta <= 2 * Mathf.PI) { rotTheta = Mathf.Min(theta + Hor * MaxdTheta, 2 * Mathf.PI); } float hdz = -(a * Mathf.Cos(rotTheta)) - targetLocal.z; float hdy = (a * Mathf.Sin(rotTheta) / Abratio) - targetLocal.y; //sag theta = Mathf.Atan(Abratio * targetLocal.x / -targetLocal.y); if (targetLocal.y < 0) { theta += Mathf.PI; } if (theta < 0) { theta += 2 * Mathf.PI; } a = targetLocal.y / Mathf.Cos(theta); if (Sag == 0) { // WRONG! rotTheta = 0f; rotTheta = theta; } else if (Sag < 0f && 0 < theta && theta <= Mathf.PI) { rotTheta = Mathf.Min(theta - Sag * MaxdTheta, Mathf.PI); } else if (Sag < 0f && Mathf.PI < theta && theta <= 2 * Mathf.PI) { rotTheta = Mathf.Max(theta + Sag * MaxdTheta, Mathf.PI); } else if (Sag > 0f && 0 < theta && theta <= Mathf.PI) { rotTheta = Mathf.Max(theta - Sag * MaxdTheta, 0); } else if (Sag > 0f && Mathf.PI < theta && theta <= 2 * Mathf.PI) { rotTheta = Mathf.Min(theta + Sag * MaxdTheta, 2 * Mathf.PI); } float sdx = -(a * Mathf.Sin(rotTheta) / Abratio) - targetLocal.x; float sdy = (a * Mathf.Cos(rotTheta)) - targetLocal.y; //ver theta = Mathf.Atan(-Abratio * targetLocal.z / -targetLocal.x); if (-targetLocal.x < 0) { theta += Mathf.PI; } if (theta < 0) { theta += 2 * Mathf.PI; } a = -targetLocal.x / Mathf.Cos(theta); if (Ver == 0) { // WRONG! rotTheta = 0f; rotTheta = theta; } else if (Ver < 0f && 0 < theta && theta <= Mathf.PI) { rotTheta = Mathf.Min(theta - Ver * MaxdTheta, Mathf.PI); } else if (Ver < 0f && Mathf.PI < theta && theta <= 2 * Mathf.PI) { rotTheta = Mathf.Max(theta + Ver * MaxdTheta, Mathf.PI); } else if (Ver > 0f && 0 < theta && theta <= Mathf.PI) { rotTheta = Mathf.Max(theta - Ver * MaxdTheta, 0); } else if (Ver > 0f && Mathf.PI < theta && theta <= 2 * Mathf.PI) { rotTheta = Mathf.Min(theta + Ver * MaxdTheta, 2 * Mathf.PI); } float vdx = -(a * Mathf.Cos(rotTheta)) - targetLocal.x; float vdz = -(a * Mathf.Sin(rotTheta) / Abratio) - targetLocal.z; if (Mathf.Abs(sdx) < 0.0001f) { sdx = 0f; } if (Mathf.Abs(sdy) < 0.0001f) { sdy = 0f; } if (Mathf.Abs(vdx) < 0.0001f) { vdx = 0f; } if (Mathf.Abs(vdz) < 0.0001f) { vdz = 0f; } if (Mathf.Abs(hdy) < 0.0001f) { hdy = 0f; } if (Mathf.Abs(hdz) < 0.0001f) { hdz = 0f; } //Update keypoint position if (arm == 1) { sdx = -sdx; } targetLocal.x += sdx + vdx; targetLocal.y += sdy + hdy; targetLocal.z += hdz + vdz; //Transform target from local EMOTE space to world coordinates // target = transform.TransformPoint(targetLocal); //Convert back to unity coordinate system targetLocal = new Vector3(targetLocal.z, targetLocal.x, -targetLocal.y); //Translate back to world coordinate //target = targetLocal + _arms[arm].Shoulder.position; target = targetLocal + shoulderPos; return(target); }
public void Render(HDCamera hdCamera, CommandBuffer cmd, RTHandleSystem.RTHandle outputTexture, ScriptableRenderContext renderContext, CullingResults cull) { // First thing to check is: Do we have a valid ray-tracing environment? HDRaytracingEnvironment rtEnvironement = m_RaytracingManager.CurrentEnvironment(); RaytracingShader forwardShader = m_PipelineAsset.renderPipelineResources.shaders.forwardRaytracing; Shader raytracingMask = m_PipelineAsset.renderPipelineResources.shaders.raytracingFlagMask; // Check the validity of the state before computing the effect bool invalidState = rtEnvironement == null || !rtEnvironement.raytracedObjects || forwardShader == null || raytracingMask == null || m_PipelineResources.textures.owenScrambledTex == null || m_PipelineResources.textures.scramblingTex == null; // If any resource or game-object is missing We stop right away if (invalidState) { return; } // Grab the acceleration structure and the list of HD lights for the target camera RaytracingAccelerationStructure accelerationStructure = m_RaytracingManager.RequestAccelerationStructure(rtEnvironement.raytracedLayerMask); HDRaytracingLightCluster lightCluster = m_RaytracingManager.RequestLightCluster(rtEnvironement.raytracedLayerMask); if (m_RaytracingFlagMaterial == null) { m_RaytracingFlagMaterial = CoreUtils.CreateEngineMaterial(raytracingMask); } // Before going into raytracing, we need to flag which pixels needs to be raytracing EvaluateRaytracingMask(cull, hdCamera, cmd, renderContext); // Define the shader pass to use for the reflection pass cmd.SetRaytracingShaderPass(forwardShader, "ForwardDXR"); // Set the acceleration structure for the pass cmd.SetRaytracingAccelerationStructure(forwardShader, HDShaderIDs._RaytracingAccelerationStructureName, accelerationStructure); // Inject the ray-tracing sampling data cmd.SetRaytracingTextureParam(forwardShader, m_RayGenShaderName, HDShaderIDs._OwenScrambledTexture, m_PipelineResources.textures.owenScrambledTex); cmd.SetRaytracingTextureParam(forwardShader, m_RayGenShaderName, HDShaderIDs._ScramblingTexture, m_PipelineResources.textures.scramblingTex); // Inject the ray generation data cmd.SetGlobalFloat(HDShaderIDs._RaytracingRayBias, rtEnvironement.rayBias); cmd.SetGlobalFloat(HDShaderIDs._RaytracingRayMaxLength, rtEnvironement.raytracingRayLength); cmd.SetGlobalFloat(HDShaderIDs._RaytracingMaxRecursion, rtEnvironement.rayMaxDepth); // Set the data for the ray generation cmd.SetRaytracingTextureParam(forwardShader, m_RayGenShaderName, HDShaderIDs._RaytracingFlagMask, m_RaytracingFlagTarget); cmd.SetRaytracingTextureParam(forwardShader, m_RayGenShaderName, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthStencilBuffer()); cmd.SetRaytracingTextureParam(forwardShader, m_RayGenShaderName, HDShaderIDs._CameraColorTextureRW, outputTexture); // Compute the pixel spread value float pixelSpreadAngle = Mathf.Atan(2.0f * Mathf.Tan(hdCamera.camera.fieldOfView * Mathf.PI / 360.0f) / Mathf.Min(hdCamera.actualWidth, hdCamera.actualHeight)); cmd.SetRaytracingFloatParam(forwardShader, HDShaderIDs._PixelSpreadAngle, pixelSpreadAngle); // Set the light cluster data if available { // LightLoop data cmd.SetGlobalBuffer(HDShaderIDs._RaytracingLightCluster, lightCluster.GetCluster()); cmd.SetGlobalBuffer(HDShaderIDs._LightDatasRT, lightCluster.GetLightDatas()); cmd.SetGlobalVector(HDShaderIDs._MinClusterPos, lightCluster.GetMinClusterPos()); cmd.SetGlobalVector(HDShaderIDs._MaxClusterPos, lightCluster.GetMaxClusterPos()); cmd.SetGlobalInt(HDShaderIDs._LightPerCellCount, rtEnvironement.maxNumLightsPercell); cmd.SetGlobalInt(HDShaderIDs._PunctualLightCountRT, lightCluster.GetPunctualLightCount()); cmd.SetGlobalInt(HDShaderIDs._AreaLightCountRT, lightCluster.GetAreaLightCount()); } // Set the data for the ray miss cmd.SetRaytracingTextureParam(forwardShader, m_MissShaderName, HDShaderIDs._SkyTexture, m_SkyManager.skyReflection); // Run the calculus cmd.DispatchRays(forwardShader, m_RayGenShaderName, (uint)hdCamera.actualWidth, (uint)hdCamera.actualHeight, 1); }
private void Run() { //set 3d face object points. objectPoints = new MatOfPoint3f( new Point3(-31, 72, 86), //l eye new Point3(31, 72, 86), //r eye new Point3(0, 40, 114), //nose new Point3(-20, 15, 90), //l mouse new Point3(20, 15, 90), //r mouse new Point3(-69, 76, -2), //l ear new Point3(69, 76, -2) //r ear ); imagePoints = new MatOfPoint2f(); rvec = new Mat(); tvec = new Mat(); rotMat = new Mat(3, 3, CvType.CV_64FC1); faceLandmarkDetector = new FaceLandmarkDetector(shape_predictor_68_face_landmarks_dat_filepath); rgbMat = new Mat(); capture = new VideoCapture(); capture.open(dance_avi_filepath); if (capture.isOpened()) { Debug.Log("capture.isOpened() true"); } else { Debug.Log("capture.isOpened() false"); } Debug.Log("CAP_PROP_FORMAT: " + capture.get(Videoio.CAP_PROP_FORMAT)); Debug.Log("CV_CAP_PROP_PREVIEW_FORMAT: " + capture.get(Videoio.CV_CAP_PROP_PREVIEW_FORMAT)); Debug.Log("CAP_PROP_POS_MSEC: " + capture.get(Videoio.CAP_PROP_POS_MSEC)); Debug.Log("CAP_PROP_POS_FRAMES: " + capture.get(Videoio.CAP_PROP_POS_FRAMES)); Debug.Log("CAP_PROP_POS_AVI_RATIO: " + capture.get(Videoio.CAP_PROP_POS_AVI_RATIO)); Debug.Log("CAP_PROP_FRAME_COUNT: " + capture.get(Videoio.CAP_PROP_FRAME_COUNT)); Debug.Log("CAP_PROP_FPS: " + capture.get(Videoio.CAP_PROP_FPS)); Debug.Log("CAP_PROP_FRAME_WIDTH: " + capture.get(Videoio.CAP_PROP_FRAME_WIDTH)); Debug.Log("CAP_PROP_FRAME_HEIGHT: " + capture.get(Videoio.CAP_PROP_FRAME_HEIGHT)); capture.grab(); capture.retrieve(rgbMat, 0); int frameWidth = rgbMat.cols(); int frameHeight = rgbMat.rows(); colors = new Color32[frameWidth * frameHeight]; texture = new Texture2D(frameWidth, frameHeight, TextureFormat.RGBA32, false); gameObject.transform.localScale = new Vector3((float)frameWidth, (float)frameHeight, 1); capture.set(Videoio.CAP_PROP_POS_FRAMES, 0); gameObject.GetComponent <Renderer> ().material.mainTexture = texture; Debug.Log("Screen.width " + Screen.width + " Screen.height " + Screen.height + " Screen.orientation " + Screen.orientation); float width = (float)frameWidth; float height = (float)frameHeight; float imageSizeScale = 1.0f; float widthScale = (float)Screen.width / width; float heightScale = (float)Screen.height / height; if (widthScale < heightScale) { Camera.main.orthographicSize = (width * (float)Screen.height / (float)Screen.width) / 2; imageSizeScale = (float)Screen.height / (float)Screen.width; } else { Camera.main.orthographicSize = height / 2; } //set cameraparam int max_d = (int)Mathf.Max(width, height); double fx = max_d; double fy = max_d; double cx = width / 2.0f; double cy = height / 2.0f; camMatrix = new Mat(3, 3, CvType.CV_64FC1); camMatrix.put(0, 0, fx); camMatrix.put(0, 1, 0); camMatrix.put(0, 2, cx); camMatrix.put(1, 0, 0); camMatrix.put(1, 1, fy); camMatrix.put(1, 2, cy); camMatrix.put(2, 0, 0); camMatrix.put(2, 1, 0); camMatrix.put(2, 2, 1.0f); Debug.Log("camMatrix " + camMatrix.dump()); distCoeffs = new MatOfDouble(0, 0, 0, 0); Debug.Log("distCoeffs " + distCoeffs.dump()); //calibration camera Size imageSize = new Size(width * imageSizeScale, height * imageSizeScale); double apertureWidth = 0; double apertureHeight = 0; double[] fovx = new double[1]; double[] fovy = new double[1]; double[] focalLength = new double[1]; Point principalPoint = new Point(0, 0); double[] aspectratio = new double[1]; Calib3d.calibrationMatrixValues(camMatrix, imageSize, apertureWidth, apertureHeight, fovx, fovy, focalLength, principalPoint, aspectratio); Debug.Log("imageSize " + imageSize.ToString()); Debug.Log("apertureWidth " + apertureWidth); Debug.Log("apertureHeight " + apertureHeight); Debug.Log("fovx " + fovx [0]); Debug.Log("fovy " + fovy [0]); Debug.Log("focalLength " + focalLength [0]); Debug.Log("principalPoint " + principalPoint.ToString()); Debug.Log("aspectratio " + aspectratio [0]); //To convert the difference of the FOV value of the OpenCV and Unity. double fovXScale = (2.0 * Mathf.Atan((float)(imageSize.width / (2.0 * fx)))) / (Mathf.Atan2((float)cx, (float)fx) + Mathf.Atan2((float)(imageSize.width - cx), (float)fx)); double fovYScale = (2.0 * Mathf.Atan((float)(imageSize.height / (2.0 * fy)))) / (Mathf.Atan2((float)cy, (float)fy) + Mathf.Atan2((float)(imageSize.height - cy), (float)fy)); Debug.Log("fovXScale " + fovXScale); Debug.Log("fovYScale " + fovYScale); //Adjust Unity Camera FOV https://github.com/opencv/opencv/commit/8ed1945ccd52501f5ab22bdec6aa1f91f1e2cfd4 if (widthScale < heightScale) { ARCamera.fieldOfView = (float)(fovx [0] * fovXScale); } else { ARCamera.fieldOfView = (float)(fovy [0] * fovYScale); } invertZM = Matrix4x4.TRS(Vector3.zero, Quaternion.identity, new Vector3(1, 1, -1)); Debug.Log("invertZM " + invertZM.ToString()); axes.SetActive(false); head.SetActive(false); rightEye.SetActive(false); leftEye.SetActive(false); mouth.SetActive(false); mouthParticleSystem = mouth.GetComponentsInChildren <ParticleSystem> (true); }
// Expects a value between -1f and 1f and returns a value between -1f and 1f public static float ArctanDistribution(float x, float factor) { return(2f * Mathf.Atan(factor * x) / Mathf.PI); }
//converts a vector to the local space, ignoring yaw. Vector3 convertToLocal(Vector3 global) { float gX, gY, gZ; float lX, lY, lZ, lZ2, pitch, roll; float zxAngle, zyAngle; gX = global.x; //Z and Y are switched, so we are swapping them here to make sense of them. gY = global.z; gZ = global.y; pitch = rate.xRotation; roll = rate.zRotation; if (flipXRots) { pitch *= -1; } if (flipZRots) { roll *= -1; } if (gX != 0) { zxAngle = Mathf.Rad2Deg * Mathf.Atan(Mathf.Abs(gX) / Mathf.Abs(gZ)) * (Mathf.Abs(gX) / gX) + 90 * ((Mathf.Abs(gZ) - gZ) / 2 * gZ) * -gX; } else { zxAngle = 0; } if (gY != 0) { zyAngle = Mathf.Rad2Deg * Mathf.Atan(Mathf.Abs(gY) / Mathf.Abs(gZ)) * (Mathf.Abs(gY) / gY) + 90 * ((Mathf.Abs(gZ) - gZ) / 2 * gZ) * -gY; } else { zyAngle = 0; } lX = Mathf.Sin(Mathf.Deg2Rad * (zxAngle - roll)); lY = Mathf.Sin(Mathf.Deg2Rad * (zyAngle - pitch)); lZ = Mathf.Cos(Mathf.Deg2Rad * (zxAngle - roll)); lZ2 = Mathf.Cos(Mathf.Deg2Rad * (zyAngle - pitch)); float magXZ = Mathf.Sqrt(lX * lX + lZ * lZ); lX /= magXZ; lZ /= magXZ; float magYZ = Mathf.Sqrt(lY * lY + lZ2 * lZ2); float equilizerMag = lZ2 / lZ; lY /= equilizerMag; lZ2 /= equilizerMag; Debug.Log("Pitch: " + pitch + " Roll: " + roll); Debug.Log("Vector is: <" + lX + "," + lY + "," + lZ + "> or <" + lX + "," + lY + "," + lZ2 + ">"); //Swap the Y and Z back return(new Vector3(lX, lZ, lY)); }
private float roll() { return(Mathf.Atan(-Gx / Gz)); }
// Use this for initialization // Update is called once per frame void Update() { pos = Cam.WorldToScreenPoint(boneRef.transform.position); mPos = Input.mousePosition; boneRef.transform.localEulerAngles = new Vector3(0, 0, ((180.0f * Mathf.Atan((mPos.y - pos.y) / (mPos.x - pos.x))) / Mathf.PI)); }
private float pitch() { return(Mathf.Atan(Gy / (Mathf.Sqrt(Mathf.Pow(Gx, 2) + Mathf.Pow(Gz, 2))))); }
private void BakeSettings() { EditorGUILayout.LabelField(NavMeshEditorWindow.s_Styles.m_AgentSizeHeader, EditorStyles.boldLabel, new GUILayoutOption[0]); Rect controlRect = EditorGUILayout.GetControlRect(false, 120f, new GUILayoutOption[0]); this.DrawAgentDiagram(controlRect, this.m_AgentRadius.floatValue, this.m_AgentHeight.floatValue, this.m_AgentClimb.floatValue, this.m_AgentSlope.floatValue); float num = EditorGUILayout.FloatField(NavMeshEditorWindow.s_Styles.m_AgentRadiusContent, this.m_AgentRadius.floatValue, new GUILayoutOption[0]); if (num >= 0.001f && !Mathf.Approximately(num - this.m_AgentRadius.floatValue, 0f)) { this.m_AgentRadius.floatValue = num; if (!this.m_ManualCellSize.boolValue) { this.m_CellSize.floatValue = 2f * this.m_AgentRadius.floatValue / 6f; } } if (this.m_AgentRadius.floatValue < 0.05f && !this.m_ManualCellSize.boolValue) { EditorGUILayout.HelpBox("The agent radius you've set is really small, this can slow down the build.\nIf you intended to allow the agent to move close to the borders and walls, please adjust voxel size in advaced settings to ensure correct bake.", MessageType.Warning); } float num2 = EditorGUILayout.FloatField(NavMeshEditorWindow.s_Styles.m_AgentHeightContent, this.m_AgentHeight.floatValue, new GUILayoutOption[0]); if (num2 >= 0.001f && !Mathf.Approximately(num2 - this.m_AgentHeight.floatValue, 0f)) { this.m_AgentHeight.floatValue = num2; } EditorGUILayout.Slider(this.m_AgentSlope, 0f, 60f, NavMeshEditorWindow.s_Styles.m_AgentSlopeContent, new GUILayoutOption[0]); if (this.m_AgentSlope.floatValue > 60f) { EditorGUILayout.HelpBox("The maximum slope should be set to less than " + 60f + " degrees to prevent NavMesh build artifacts on slopes. ", MessageType.Warning); } float num3 = EditorGUILayout.FloatField(NavMeshEditorWindow.s_Styles.m_AgentClimbContent, this.m_AgentClimb.floatValue, new GUILayoutOption[0]); if (num3 >= 0f && !Mathf.Approximately(this.m_AgentClimb.floatValue - num3, 0f)) { this.m_AgentClimb.floatValue = num3; } if (this.m_AgentClimb.floatValue >= this.m_AgentHeight.floatValue) { EditorGUILayout.HelpBox("Step height should be less than agent height.\nClamping step height to " + this.m_AgentHeight.floatValue + ".", MessageType.Warning); } float floatValue = this.m_CellSize.floatValue; float num4 = floatValue * 0.5f; int num5 = (int)Mathf.Ceil(this.m_AgentClimb.floatValue / num4); float num6 = Mathf.Tan(this.m_AgentSlope.floatValue / 180f * 3.14159274f) * floatValue; int num7 = (int)Mathf.Ceil(num6 * 2f / num4); if (num7 > num5) { float f = (float)num5 * num4 / (floatValue * 2f); float num8 = Mathf.Atan(f) / 3.14159274f * 180f; float num9 = (float)(num7 - 1) * num4; EditorGUILayout.HelpBox(string.Concat(new string[] { "Step Height conflicts with Max Slope. This makes some slopes unwalkable.\nConsider decreasing Max Slope to < ", num8.ToString("0.0"), " degrees.\nOr, increase Step Height to > ", num9.ToString("0.00"), "." }), MessageType.Warning); } EditorGUILayout.Space(); EditorGUILayout.LabelField(NavMeshEditorWindow.s_Styles.m_OffmeshHeader, EditorStyles.boldLabel, new GUILayoutOption[0]); bool flag = !InternalEditorUtility.HasProFeaturesEnabled(); if (flag) { EditorGUILayout.HelpBox("This is only available in the Pro version of Unity.", MessageType.Warning); if (this.m_LedgeDropHeight.floatValue != 0f) { this.m_LedgeDropHeight.floatValue = 0f; } if (this.m_MaxJumpAcrossDistance.floatValue != 0f) { this.m_MaxJumpAcrossDistance.floatValue = 0f; } GUI.enabled = false; } float num10 = EditorGUILayout.FloatField(NavMeshEditorWindow.s_Styles.m_AgentDropContent, this.m_LedgeDropHeight.floatValue, new GUILayoutOption[0]); if (num10 >= 0f && !Mathf.Approximately(num10 - this.m_LedgeDropHeight.floatValue, 0f)) { this.m_LedgeDropHeight.floatValue = num10; } float num11 = EditorGUILayout.FloatField(NavMeshEditorWindow.s_Styles.m_AgentJumpContent, this.m_MaxJumpAcrossDistance.floatValue, new GUILayoutOption[0]); if (num11 >= 0f && !Mathf.Approximately(num11 - this.m_MaxJumpAcrossDistance.floatValue, 0f)) { this.m_MaxJumpAcrossDistance.floatValue = num11; } if (flag) { GUI.enabled = true; } EditorGUILayout.Space(); this.m_Advanced = GUILayout.Toggle(this.m_Advanced, NavMeshEditorWindow.s_Styles.m_AdvancedHeader, EditorStyles.foldout, new GUILayoutOption[0]); if (this.m_Advanced) { EditorGUI.indentLevel++; bool flag2 = EditorGUILayout.Toggle(NavMeshEditorWindow.s_Styles.m_ManualCellSizeContent, this.m_ManualCellSize.boolValue, new GUILayoutOption[0]); if (flag2 != this.m_ManualCellSize.boolValue) { this.m_ManualCellSize.boolValue = flag2; if (!flag2) { this.m_CellSize.floatValue = 2f * this.m_AgentRadius.floatValue / 6f; } } EditorGUI.BeginDisabledGroup(!this.m_ManualCellSize.boolValue); EditorGUI.indentLevel++; float num12 = EditorGUILayout.FloatField(NavMeshEditorWindow.s_Styles.m_CellSizeContent, this.m_CellSize.floatValue, new GUILayoutOption[0]); if (num12 > 0f && !Mathf.Approximately(num12 - this.m_CellSize.floatValue, 0f)) { this.m_CellSize.floatValue = Math.Max(0.01f, num12); } if (num12 < 0.01f) { EditorGUILayout.HelpBox("The voxel size should be larger than 0.01.", MessageType.Warning); } float num13 = (this.m_CellSize.floatValue <= 0f) ? 0f : (this.m_AgentRadius.floatValue / this.m_CellSize.floatValue); EditorGUILayout.LabelField(" ", num13.ToString("0.00") + " voxels per agent radius", EditorStyles.miniLabel, new GUILayoutOption[0]); if (this.m_ManualCellSize.boolValue) { float num14 = this.m_CellSize.floatValue * 0.5f; if ((int)Mathf.Floor(this.m_AgentHeight.floatValue / num14) > 250) { EditorGUILayout.HelpBox("The number of voxels per agent height is too high. This will reduce the accuracy of the navmesh. Consider using voxel size of at least " + (this.m_AgentHeight.floatValue / 250f / 0.5f).ToString("0.000") + ".", MessageType.Warning); } if (num13 < 1f) { EditorGUILayout.HelpBox("The number of voxels per agent radius is too small. The agent may not avoid walls and ledges properly. Consider using voxel size of at least " + (this.m_AgentRadius.floatValue / 2f).ToString("0.000") + " (2 voxels per agent radius).", MessageType.Warning); } else { if (num13 > 8f) { EditorGUILayout.HelpBox("The number of voxels per agent radius is too high. It can cause excessive build times. Consider using voxel size closer to " + (this.m_AgentRadius.floatValue / 8f).ToString("0.000") + " (8 voxels per radius).", MessageType.Warning); } } } if (this.m_ManualCellSize.boolValue) { EditorGUILayout.HelpBox("Voxel size controls how accurately the navigation mesh is generated from the level geometry. A good voxel size is 2-4 voxels per agent radius. Making voxel size smaller will increase build time.", MessageType.None); } EditorGUI.indentLevel--; EditorGUI.EndDisabledGroup(); EditorGUILayout.Space(); float num15 = EditorGUILayout.FloatField(NavMeshEditorWindow.s_Styles.m_MinRegionAreaContent, this.m_MinRegionArea.floatValue, new GUILayoutOption[0]); if (num15 >= 0f && num15 != this.m_MinRegionArea.floatValue) { this.m_MinRegionArea.floatValue = num15; } EditorGUILayout.Space(); bool flag3 = EditorGUILayout.Toggle(NavMeshEditorWindow.s_Styles.m_AgentPlacementContent, this.m_AccuratePlacement.boolValue, new GUILayoutOption[0]); if (flag3 != this.m_AccuratePlacement.boolValue) { this.m_AccuratePlacement.boolValue = flag3; } EditorGUI.indentLevel--; } }
public void RenderReflections(HDCamera hdCamera, CommandBuffer cmd, RTHandleSystem.RTHandle outputTexture, ScriptableRenderContext renderContext, uint frameCount) { // First thing to check is: Do we have a valid ray-tracing environment? HDRaytracingEnvironment rtEnvironement = m_RaytracingManager.CurrentEnvironment(); BlueNoise blueNoise = m_RaytracingManager.GetBlueNoiseManager(); ComputeShader bilateralFilter = m_PipelineAsset.renderPipelineResources.shaders.reflectionBilateralFilterCS; RaytracingShader reflectionShader = m_PipelineAsset.renderPipelineResources.shaders.reflectionRaytracing; bool missingResources = rtEnvironement == null || blueNoise == null || bilateralFilter == null || reflectionShader == null || m_PipelineResources.textures.owenScrambledTex == null || m_PipelineResources.textures.scramblingTex == null; // Try to grab the acceleration structure and the list of HD lights for the target camera RaytracingAccelerationStructure accelerationStructure = m_RaytracingManager.RequestAccelerationStructure(hdCamera); HDRaytracingLightCluster lightCluster = m_RaytracingManager.RequestLightCluster(hdCamera); // If no acceleration structure available, end it now if (accelerationStructure == null || lightCluster == null || missingResources) { return; } // Compute the actual resolution that is needed base on the quality string targetRayGen = ""; switch (rtEnvironement.reflQualityMode) { case HDRaytracingEnvironment.ReflectionsQuality.QuarterRes: { targetRayGen = m_RayGenHalfResName; }; break; case HDRaytracingEnvironment.ReflectionsQuality.Integration: { targetRayGen = m_RayGenIntegrationName; }; break; } // Define the shader pass to use for the reflection pass cmd.SetRaytracingShaderPass(reflectionShader, "ReflectionDXR"); // Set the acceleration structure for the pass cmd.SetRaytracingAccelerationStructure(reflectionShader, HDShaderIDs._RaytracingAccelerationStructureName, accelerationStructure); // Inject the ray-tracing sampling data cmd.SetRaytracingTextureParam(reflectionShader, targetRayGen, HDShaderIDs._OwenScrambledTexture, m_PipelineResources.textures.owenScrambledTex); cmd.SetRaytracingTextureParam(reflectionShader, targetRayGen, HDShaderIDs._ScramblingTexture, m_PipelineResources.textures.scramblingTex); // Global reflection parameters cmd.SetRaytracingFloatParams(reflectionShader, HDShaderIDs._RaytracingIntensityClamp, rtEnvironement.reflClampValue); cmd.SetRaytracingFloatParams(reflectionShader, HDShaderIDs._RaytracingReflectionMinSmoothness, rtEnvironement.reflMinSmoothness); cmd.SetRaytracingFloatParams(reflectionShader, HDShaderIDs._RaytracingReflectionMaxDistance, rtEnvironement.reflBlendDistance); // Inject the ray generation data cmd.SetGlobalFloat(HDShaderIDs._RaytracingRayBias, rtEnvironement.rayBias); cmd.SetGlobalFloat(HDShaderIDs._RaytracingRayMaxLength, rtEnvironement.reflRayLength); cmd.SetRaytracingIntParams(reflectionShader, HDShaderIDs._RaytracingNumSamples, rtEnvironement.reflNumMaxSamples); int frameIndex = hdCamera.IsTAAEnabled() ? hdCamera.taaFrameIndex : (int)frameCount % 8; cmd.SetGlobalInt(HDShaderIDs._RaytracingFrameIndex, frameIndex); // Set the data for the ray generation cmd.SetRaytracingTextureParam(reflectionShader, targetRayGen, HDShaderIDs._SsrLightingTextureRW, m_LightingTexture); cmd.SetRaytracingTextureParam(reflectionShader, targetRayGen, HDShaderIDs._SsrHitPointTexture, m_HitPdfTexture); cmd.SetRaytracingTextureParam(reflectionShader, targetRayGen, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthStencilBuffer()); cmd.SetRaytracingTextureParam(reflectionShader, targetRayGen, HDShaderIDs._NormalBufferTexture, m_SharedRTManager.GetNormalBuffer()); // Set ray count tex cmd.SetRaytracingIntParam(reflectionShader, HDShaderIDs._RayCountEnabled, m_RaytracingManager.rayCountManager.rayCountEnabled); cmd.SetRaytracingTextureParam(reflectionShader, targetRayGen, HDShaderIDs._RayCountTexture, m_RaytracingManager.rayCountManager.rayCountTex); // Compute the pixel spread value float pixelSpreadAngle = Mathf.Atan(2.0f * Mathf.Tan(hdCamera.camera.fieldOfView * Mathf.PI / 360.0f) / Mathf.Min(hdCamera.actualWidth, hdCamera.actualHeight)); cmd.SetRaytracingFloatParam(reflectionShader, HDShaderIDs._RaytracingPixelSpreadAngle, pixelSpreadAngle); // LightLoop data cmd.SetGlobalBuffer(HDShaderIDs._RaytracingLightCluster, lightCluster.GetCluster()); cmd.SetGlobalBuffer(HDShaderIDs._LightDatasRT, lightCluster.GetLightDatas()); cmd.SetGlobalVector(HDShaderIDs._MinClusterPos, lightCluster.GetMinClusterPos()); cmd.SetGlobalVector(HDShaderIDs._MaxClusterPos, lightCluster.GetMaxClusterPos()); cmd.SetGlobalInt(HDShaderIDs._LightPerCellCount, rtEnvironement.maxNumLightsPercell); cmd.SetGlobalInt(HDShaderIDs._PunctualLightCountRT, lightCluster.GetPunctualLightCount()); cmd.SetGlobalInt(HDShaderIDs._AreaLightCountRT, lightCluster.GetAreaLightCount()); // Evaluate the clear coat mask texture based on the lit shader mode RenderTargetIdentifier clearCoatMaskTexture = hdCamera.frameSettings.litShaderMode == LitShaderMode.Deferred ? m_GbufferManager.GetBuffersRTI()[2] : Texture2D.blackTexture; cmd.SetRaytracingTextureParam(reflectionShader, targetRayGen, HDShaderIDs._SsrClearCoatMaskTexture, clearCoatMaskTexture); // Set the data for the ray miss cmd.SetRaytracingTextureParam(reflectionShader, m_MissShaderName, HDShaderIDs._SkyTexture, m_SkyManager.skyReflection); // Compute the actual resolution that is needed base on the quality uint widthResolution = 1, heightResolution = 1; switch (rtEnvironement.reflQualityMode) { case HDRaytracingEnvironment.ReflectionsQuality.QuarterRes: { widthResolution = (uint)hdCamera.actualWidth / 2; heightResolution = (uint)hdCamera.actualHeight / 2; }; break; case HDRaytracingEnvironment.ReflectionsQuality.Integration: { widthResolution = (uint)hdCamera.actualWidth; heightResolution = (uint)hdCamera.actualHeight; }; break; } // Run the calculus cmd.DispatchRays(reflectionShader, targetRayGen, widthResolution, heightResolution, 1); using (new ProfilingSample(cmd, "Filter Reflection", CustomSamplerId.RaytracingFilterReflection.GetSampler())) { switch (rtEnvironement.reflQualityMode) { case HDRaytracingEnvironment.ReflectionsQuality.QuarterRes: { // Fetch the right filter to use int currentKernel = bilateralFilter.FindKernel("RaytracingReflectionFilter"); // Inject all the parameters for the compute cmd.SetComputeTextureParam(bilateralFilter, currentKernel, HDShaderIDs._SsrLightingTextureRW, m_LightingTexture); cmd.SetComputeTextureParam(bilateralFilter, currentKernel, HDShaderIDs._SsrHitPointTexture, m_HitPdfTexture); cmd.SetComputeTextureParam(bilateralFilter, currentKernel, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthStencilBuffer()); cmd.SetComputeTextureParam(bilateralFilter, currentKernel, HDShaderIDs._NormalBufferTexture, m_SharedRTManager.GetNormalBuffer()); cmd.SetComputeTextureParam(bilateralFilter, currentKernel, "_NoiseTexture", blueNoise.textureArray16RGB); cmd.SetComputeTextureParam(bilateralFilter, currentKernel, "_VarianceTexture", m_VarianceBuffer); cmd.SetComputeTextureParam(bilateralFilter, currentKernel, "_MinColorRangeTexture", m_MinBoundBuffer); cmd.SetComputeTextureParam(bilateralFilter, currentKernel, "_MaxColorRangeTexture", m_MaxBoundBuffer); cmd.SetComputeTextureParam(bilateralFilter, currentKernel, "_RaytracingReflectionTexture", outputTexture); cmd.SetComputeTextureParam(bilateralFilter, currentKernel, HDShaderIDs._ScramblingTexture, m_PipelineResources.textures.scramblingTex); cmd.SetComputeIntParam(bilateralFilter, HDShaderIDs._SpatialFilterRadius, rtEnvironement.reflSpatialFilterRadius); // Texture dimensions int texWidth = outputTexture.rt.width; int texHeight = outputTexture.rt.width; // Evaluate the dispatch parameters int areaTileSize = 8; int numTilesXHR = (texWidth / 2 + (areaTileSize - 1)) / areaTileSize; int numTilesYHR = (texHeight / 2 + (areaTileSize - 1)) / areaTileSize; // Bind the right texture for clear coat support cmd.SetComputeTextureParam(bilateralFilter, currentKernel, HDShaderIDs._SsrClearCoatMaskTexture, clearCoatMaskTexture); // Compute the texture cmd.DispatchCompute(bilateralFilter, currentKernel, numTilesXHR, numTilesYHR, 1); int numTilesXFR = (texWidth + (areaTileSize - 1)) / areaTileSize; int numTilesYFR = (texHeight + (areaTileSize - 1)) / areaTileSize; RTHandleSystem.RTHandle history = hdCamera.GetCurrentFrameRT((int)HDCameraFrameHistoryType.RaytracedReflection) ?? hdCamera.AllocHistoryFrameRT((int)HDCameraFrameHistoryType.RaytracedReflection, ReflectionHistoryBufferAllocatorFunction, 1); // Fetch the right filter to use currentKernel = bilateralFilter.FindKernel("TemporalAccumulationFilter"); cmd.SetComputeFloatParam(bilateralFilter, HDShaderIDs._TemporalAccumuationWeight, rtEnvironement.reflTemporalAccumulationWeight); cmd.SetComputeTextureParam(bilateralFilter, currentKernel, HDShaderIDs._AccumulatedFrameTexture, history); cmd.SetComputeTextureParam(bilateralFilter, currentKernel, HDShaderIDs._CurrentFrameTexture, outputTexture); cmd.SetComputeTextureParam(bilateralFilter, currentKernel, "_MinColorRangeTexture", m_MinBoundBuffer); cmd.SetComputeTextureParam(bilateralFilter, currentKernel, "_MaxColorRangeTexture", m_MaxBoundBuffer); cmd.DispatchCompute(bilateralFilter, currentKernel, numTilesXFR, numTilesYFR, 1); } break; case HDRaytracingEnvironment.ReflectionsQuality.Integration: { HDUtils.BlitCameraTexture(cmd, hdCamera, m_LightingTexture, outputTexture); } break; } } }
float FovForHeightAndDistance(float height, float distance) { return(2f * Mathf.Atan(height * 0.5f / distance) * Mathf.Rad2Deg); }
//Calculate thetaOne by IM1 public void thetaOneCalc() { this.thetaOne = Mathf.Atan((this.obj.transform.position.y - explosionPoint.y) / Mathf.Sqrt(Mathf.Pow(this.obj.transform.position.x - explosionPoint.x, 2) + Mathf.Pow(this.obj.transform.position.z - explosionPoint.z, 2))); }
void OnWizardCreate() { GameObject newCone = new GameObject("Cone"); if (openingAngle > 0 && openingAngle < 180) { radiusTop = 0; radiusBottom = length * Mathf.Tan(openingAngle * Mathf.Deg2Rad / 2); } string meshName = newCone.name + numVertices + "v" + radiusTop + "t" + radiusBottom + "b" + length + "l" + length + (outside ? "o" : "") + (inside ? "i" : ""); string meshPrefabPath = "Assets/Editor/" + meshName + ".asset"; Mesh mesh = (Mesh)AssetDatabase.LoadAssetAtPath(meshPrefabPath, typeof(Mesh)); if (mesh == null) { mesh = new Mesh(); mesh.name = meshName; // can't access Camera.current //newCone.transform.position = Camera.current.transform.position + Camera.current.transform.forward * 5.0f; int multiplier = (outside ? 1 : 0) + (inside ? 1 : 0); int offset = (outside && inside ? 2 * numVertices : 0); Vector3[] vertices = new Vector3[2 * multiplier * numVertices]; // 0..n-1: top, n..2n-1: bottom Vector3[] normals = new Vector3[2 * multiplier * numVertices]; Vector2[] uvs = new Vector2[2 * multiplier * numVertices]; int[] tris; float slope = Mathf.Atan((radiusBottom - radiusTop) / length); // (rad difference)/height float slopeSin = Mathf.Sin(slope); float slopeCos = Mathf.Cos(slope); int i; for (i = 0; i < numVertices; i++) { float angle = 2 * Mathf.PI * i / numVertices; float angleSin = Mathf.Sin(angle); float angleCos = Mathf.Cos(angle); float angleHalf = 2 * Mathf.PI * (i + 0.5f) / numVertices; // for degenerated normals at cone tips float angleHalfSin = Mathf.Sin(angleHalf); float angleHalfCos = Mathf.Cos(angleHalf); vertices[i] = new Vector3(radiusTop * angleCos, radiusTop * angleSin, 0); vertices[i + numVertices] = new Vector3(radiusBottom * angleCos, radiusBottom * angleSin, length); if (radiusTop == 0) { normals[i] = new Vector3(angleHalfCos * slopeCos, angleHalfSin * slopeCos, -slopeSin); } else { normals[i] = new Vector3(angleCos * slopeCos, angleSin * slopeCos, -slopeSin); } if (radiusBottom == 0) { normals[i + numVertices] = new Vector3(angleHalfCos * slopeCos, angleHalfSin * slopeCos, -slopeSin); } else { normals[i + numVertices] = new Vector3(angleCos * slopeCos, angleSin * slopeCos, -slopeSin); } uvs[i] = new Vector2(1.0f * i / numVertices, 1); uvs[i + numVertices] = new Vector2(1.0f * i / numVertices, 0); if (outside && inside) { // vertices and uvs are identical on inside and outside, so just copy vertices[i + 2 * numVertices] = vertices[i]; vertices[i + 3 * numVertices] = vertices[i + numVertices]; uvs[i + 2 * numVertices] = uvs[i]; uvs[i + 3 * numVertices] = uvs[i + numVertices]; } if (inside) { // invert normals normals[i + offset] = -normals[i]; normals[i + numVertices + offset] = -normals[i + numVertices]; } } mesh.vertices = vertices; mesh.normals = normals; mesh.uv = uvs; // create triangles // here we need to take care of point order, depending on inside and outside int cnt = 0; if (radiusTop == 0) { // top cone tris = new int[numVertices * 3 * multiplier]; if (outside) { for (i = 0; i < numVertices; i++) { tris[cnt++] = i + numVertices; tris[cnt++] = i; if (i == numVertices - 1) { tris[cnt++] = numVertices; } else { tris[cnt++] = i + 1 + numVertices; } } } if (inside) { for (i = offset; i < numVertices + offset; i++) { tris[cnt++] = i; tris[cnt++] = i + numVertices; if (i == numVertices - 1 + offset) { tris[cnt++] = numVertices + offset; } else { tris[cnt++] = i + 1 + numVertices; } } } } else if (radiusBottom == 0) { // bottom cone tris = new int[numVertices * 3 * multiplier]; if (outside) { for (i = 0; i < numVertices; i++) { tris[cnt++] = i; if (i == numVertices - 1) { tris[cnt++] = 0; } else { tris[cnt++] = i + 1; } tris[cnt++] = i + numVertices; } } if (inside) { for (i = offset; i < numVertices + offset; i++) { if (i == numVertices - 1 + offset) { tris[cnt++] = offset; } else { tris[cnt++] = i + 1; } tris[cnt++] = i; tris[cnt++] = i + numVertices; } } } else { // truncated cone tris = new int[numVertices * 6 * multiplier]; if (outside) { for (i = 0; i < numVertices; i++) { int ip1 = i + 1; if (ip1 == numVertices) { ip1 = 0; } tris[cnt++] = i; tris[cnt++] = ip1; tris[cnt++] = i + numVertices; tris[cnt++] = ip1 + numVertices; tris[cnt++] = i + numVertices; tris[cnt++] = ip1; } } if (inside) { for (i = offset; i < numVertices + offset; i++) { int ip1 = i + 1; if (ip1 == numVertices + offset) { ip1 = offset; } tris[cnt++] = ip1; tris[cnt++] = i; tris[cnt++] = i + numVertices; tris[cnt++] = i + numVertices; tris[cnt++] = ip1 + numVertices; tris[cnt++] = ip1; } } } mesh.triangles = tris; AssetDatabase.CreateAsset(mesh, meshPrefabPath); AssetDatabase.SaveAssets(); } MeshFilter mf = newCone.AddComponent <MeshFilter>(); mf.mesh = mesh; newCone.AddComponent <MeshRenderer>(); if (addCollider) { MeshCollider mc = newCone.AddComponent <MeshCollider>(); mc.sharedMesh = mf.sharedMesh; } Selection.activeObject = newCone; }
public override void Update(Camera mainCamera) { if (!hasCameraDeviceOpened) { return; } if (!OVRPlugin.SetHandNodePoseStateLatency(OVRManager.instance.handPoseStateLatency)) { Debug.LogWarning("HandPoseStateLatency is invalid. Expect a value between 0.0 to 0.5, get " + OVRManager.instance.handPoseStateLatency); } directCompositionCamera.clearFlags = mainCamera.clearFlags; directCompositionCamera.backgroundColor = mainCamera.backgroundColor; directCompositionCamera.cullingMask = mainCamera.cullingMask & (~OVRManager.instance.extraHiddenLayers); directCompositionCamera.nearClipPlane = mainCamera.nearClipPlane; directCompositionCamera.farClipPlane = mainCamera.farClipPlane; if (OVRMixedReality.useFakeExternalCamera || OVRPlugin.GetExternalCameraCount() == 0) { OVRPose trackingSpacePose = new OVRPose(); trackingSpacePose.position = OVRMixedReality.fakeCameraPositon; trackingSpacePose.orientation = OVRMixedReality.fakeCameraRotation; directCompositionCamera.fieldOfView = OVRMixedReality.fakeCameraFov; directCompositionCamera.aspect = OVRMixedReality.fakeCameraAspect; if (cameraInTrackingSpace) { directCompositionCamera.transform.FromOVRPose(trackingSpacePose, true); } else { OVRPose worldSpacePose = new OVRPose(); worldSpacePose = OVRExtensions.ToWorldSpacePose(trackingSpacePose); directCompositionCamera.transform.FromOVRPose(worldSpacePose); } } else { OVRPlugin.CameraExtrinsics extrinsics; OVRPlugin.CameraIntrinsics intrinsics; // So far, only support 1 camera for MR and always use camera index 0 if (OVRPlugin.GetMixedRealityCameraInfo(0, out extrinsics, out intrinsics)) { float fovY = Mathf.Atan(intrinsics.FOVPort.UpTan) * Mathf.Rad2Deg * 2; float aspect = intrinsics.FOVPort.LeftTan / intrinsics.FOVPort.UpTan; directCompositionCamera.fieldOfView = fovY; directCompositionCamera.aspect = aspect; if (cameraInTrackingSpace) { OVRPose trackingSpacePose = ComputeCameraTrackingSpacePose(extrinsics); directCompositionCamera.transform.FromOVRPose(trackingSpacePose, true); } else { OVRPose worldSpacePose = ComputeCameraWorldSpacePose(extrinsics); directCompositionCamera.transform.FromOVRPose(worldSpacePose); } } else { Debug.LogWarning("Failed to get external camera information"); } } if (hasCameraDeviceOpened) { if (boundaryMeshMaskTexture == null || boundaryMeshMaskTexture.width != Screen.width || boundaryMeshMaskTexture.height != Screen.height) { boundaryMeshMaskTexture = new RenderTexture(Screen.width, Screen.height, 0, RenderTextureFormat.R8); boundaryMeshMaskTexture.Create(); } UpdateCameraFramePlaneObject(mainCamera, directCompositionCamera, boundaryMeshMaskTexture); directCompositionCamera.GetComponent <OVRCameraFrameCompositionManager>().boundaryMeshMaskTexture = boundaryMeshMaskTexture; } }
public override void Update(GameObject gameObject, Camera mainCamera) { RefreshCameraObjects(gameObject, mainCamera); OVRPlugin.SetHandNodePoseStateLatency(0.0); // the HandNodePoseStateLatency doesn't apply to the external composition. Always enforce it to 0.0 #if OVR_ANDROID_MRC RefreshAudioFilter(); int drawTextureIndex = (frameIndex / 2) % 2; int castTextureIndex = 1 - drawTextureIndex; backgroundCamera.enabled = (frameIndex % 2) == 0; foregroundCamera.enabled = (frameIndex % 2) == 1; if (frameIndex % 2 == 0) { if (lastMrcEncodeFrameSyncId != -1) { OVRPlugin.Media.SyncMrcFrame(lastMrcEncodeFrameSyncId); lastMrcEncodeFrameSyncId = -1; } lastMrcEncodeFrameSyncId = CastMrcFrame(castTextureIndex); SetCameraTargetTexture(drawTextureIndex); } ++frameIndex; #endif backgroundCamera.clearFlags = mainCamera.clearFlags; backgroundCamera.backgroundColor = mainCamera.backgroundColor; backgroundCamera.cullingMask = mainCamera.cullingMask & (~OVRManager.instance.extraHiddenLayers); backgroundCamera.nearClipPlane = mainCamera.nearClipPlane; backgroundCamera.farClipPlane = mainCamera.farClipPlane; foregroundCamera.cullingMask = mainCamera.cullingMask & (~OVRManager.instance.extraHiddenLayers); foregroundCamera.nearClipPlane = mainCamera.nearClipPlane; foregroundCamera.farClipPlane = mainCamera.farClipPlane; if (OVRMixedReality.useFakeExternalCamera || OVRPlugin.GetExternalCameraCount() == 0) { OVRPose worldSpacePose = new OVRPose(); OVRPose trackingSpacePose = new OVRPose(); trackingSpacePose.position = OVRManager.instance.trackingOriginType == OVRManager.TrackingOrigin.EyeLevel ? OVRMixedReality.fakeCameraEyeLevelPosition : OVRMixedReality.fakeCameraFloorLevelPosition; trackingSpacePose.orientation = OVRMixedReality.fakeCameraRotation; worldSpacePose = OVRExtensions.ToWorldSpacePose(trackingSpacePose); backgroundCamera.fieldOfView = OVRMixedReality.fakeCameraFov; backgroundCamera.aspect = OVRMixedReality.fakeCameraAspect; foregroundCamera.fieldOfView = OVRMixedReality.fakeCameraFov; foregroundCamera.aspect = OVRMixedReality.fakeCameraAspect; if (cameraInTrackingSpace) { backgroundCamera.transform.FromOVRPose(trackingSpacePose, true); foregroundCamera.transform.FromOVRPose(trackingSpacePose, true); } else { backgroundCamera.transform.FromOVRPose(worldSpacePose); foregroundCamera.transform.FromOVRPose(worldSpacePose); } } else { OVRPlugin.CameraExtrinsics extrinsics; OVRPlugin.CameraIntrinsics intrinsics; OVRPlugin.Posef calibrationRawPose; // So far, only support 1 camera for MR and always use camera index 0 if (OVRPlugin.GetMixedRealityCameraInfo(0, out extrinsics, out intrinsics, out calibrationRawPose)) { float fovY = Mathf.Atan(intrinsics.FOVPort.UpTan) * Mathf.Rad2Deg * 2; float aspect = intrinsics.FOVPort.LeftTan / intrinsics.FOVPort.UpTan; backgroundCamera.fieldOfView = fovY; backgroundCamera.aspect = aspect; foregroundCamera.fieldOfView = fovY; foregroundCamera.aspect = intrinsics.FOVPort.LeftTan / intrinsics.FOVPort.UpTan; if (cameraInTrackingSpace) { OVRPose trackingSpacePose = ComputeCameraTrackingSpacePose(extrinsics, calibrationRawPose); backgroundCamera.transform.FromOVRPose(trackingSpacePose, true); foregroundCamera.transform.FromOVRPose(trackingSpacePose, true); } else { OVRPose worldSpacePose = ComputeCameraWorldSpacePose(extrinsics, calibrationRawPose); backgroundCamera.transform.FromOVRPose(worldSpacePose); foregroundCamera.transform.FromOVRPose(worldSpacePose); } } else { Debug.LogError("Failed to get external camera information"); return; } } Vector3 headToExternalCameraVec = mainCamera.transform.position - foregroundCamera.transform.position; float clipDistance = Vector3.Dot(headToExternalCameraVec, foregroundCamera.transform.forward); foregroundCamera.farClipPlane = Mathf.Max(foregroundCamera.nearClipPlane + 0.001f, clipDistance); }
private void CreateWarning() { Destroy(this.gameObject, 10f); ParticleSystem ps; warning_temp = Instantiate(warning_effect, this.transform.position, Quaternion.identity); ps = warning_temp.GetComponent <ParticleSystem>(); var simulate = ps.main; simulate.simulationSpeed = 1 / 2f; warning_temp.transform.localScale = new Vector3(40, 0.7f, 0.7f); if (dir.x > 0) { warning_temp.transform.rotation = Quaternion.Euler(0, 0, Mathf.Rad2Deg * Mathf.Atan((dir.y) / dir.x)); } else { warning_temp.transform.rotation = Quaternion.Euler(0, 0, 180 + Mathf.Rad2Deg * Mathf.Atan((dir.y) / dir.x)); } switch (UpLoadData.boss_level) { case 0: NetworkManager.instance.InstantiateBossSkill(UpLoadData.boss_index, 26, warning_temp.transform, 2f, true, false); break; case 1: NetworkManager.instance.InstantiateBossSkill(UpLoadData.boss_index, 26, warning_temp.transform, 1.8f, true, false); break; case 2: NetworkManager.instance.InstantiateBossSkill(UpLoadData.boss_index, 26, warning_temp.transform, 1f, true, false); break; case 3: NetworkManager.instance.InstantiateBossSkill(UpLoadData.boss_index, 26, warning_temp.transform, 0.5f, true, false); break; } switch (UpLoadData.boss_level) { case 0: Destroy(warning_temp, 2f); break; case 1: Destroy(warning_temp, 1.8f); break; case 2: Destroy(warning_temp, 1f); break; case 3: Destroy(warning_temp, 0.5f); break; } }
public void VoxelizeInput(Pathfinding.Util.GraphTransform graphTransform, Bounds graphSpaceBounds) { AstarProfiler.StartProfile("Build Navigation Mesh"); AstarProfiler.StartProfile("Voxelizing - Step 1"); // Transform from voxel space to graph space. // then scale from voxel space (one unit equals one voxel) // Finally add min Matrix4x4 voxelMatrix = Matrix4x4.TRS(graphSpaceBounds.min, Quaternion.identity, Vector3.one) * Matrix4x4.Scale(new Vector3(cellSize, cellHeight, cellSize)); transformVoxel2Graph = new Pathfinding.Util.GraphTransform(voxelMatrix); // Transform from voxel space to world space // add half a voxel to fix rounding transform = graphTransform * voxelMatrix * Matrix4x4.TRS(new Vector3(0.5f, 0, 0.5f), Quaternion.identity, Vector3.one); int maximumVoxelYCoord = (int)(graphSpaceBounds.size.y / cellHeight); AstarProfiler.EndProfile("Voxelizing - Step 1"); AstarProfiler.StartProfile("Voxelizing - Step 2 - Init"); // Cosine of the slope limit in voxel space (some tweaks are needed because the voxel space might be stretched out along the y axis) float slopeLimit = Mathf.Cos(Mathf.Atan(Mathf.Tan(maxSlope * Mathf.Deg2Rad) * (cellSize / cellHeight))); // Temporary arrays used for rasterization float[] vTris = new float[3 * 3]; float[] vOut = new float[7 * 3]; float[] vRow = new float[7 * 3]; float[] vCellOut = new float[7 * 3]; float[] vCell = new float[7 * 3]; if (inputMeshes == null) { throw new System.NullReferenceException("inputMeshes not set"); } // Find the largest lengths of vertex arrays and check for meshes which can be skipped int maxVerts = 0; for (int m = 0; m < inputMeshes.Count; m++) { maxVerts = System.Math.Max(inputMeshes[m].vertices.Length, maxVerts); } // Create buffer, here vertices will be stored multiplied with the local-to-voxel-space matrix var verts = new Vector3[maxVerts]; AstarProfiler.EndProfile("Voxelizing - Step 2 - Init"); AstarProfiler.StartProfile("Voxelizing - Step 2"); // This loop is the hottest place in the whole rasterization process // it usually accounts for around 50% of the time for (int m = 0; m < inputMeshes.Count; m++) { RasterizationMesh mesh = inputMeshes[m]; var meshMatrix = mesh.matrix; // Flip the orientation of all faces if the mesh is scaled in such a way // that the face orientations would change // This happens for example if a mesh has a negative scale along an odd number of axes // e.g it happens for the scale (-1, 1, 1) but not for (-1, -1, 1) or (1,1,1) var flipOrientation = VectorMath.ReversesFaceOrientations(meshMatrix); Vector3[] vs = mesh.vertices; int[] tris = mesh.triangles; int trisLength = tris.Length; // Transform vertices first to world space and then to voxel space for (int i = 0; i < vs.Length; i++) { verts[i] = transform.InverseTransform(meshMatrix.MultiplyPoint3x4(vs[i])); } int mesharea = mesh.area; for (int i = 0; i < trisLength; i += 3) { Vector3 p1 = verts[tris[i]]; Vector3 p2 = verts[tris[i + 1]]; Vector3 p3 = verts[tris[i + 2]]; if (flipOrientation) { var tmp = p1; p1 = p3; p3 = tmp; } int minX = (int)(Utility.Min(p1.x, p2.x, p3.x)); int minZ = (int)(Utility.Min(p1.z, p2.z, p3.z)); int maxX = (int)System.Math.Ceiling(Utility.Max(p1.x, p2.x, p3.x)); int maxZ = (int)System.Math.Ceiling(Utility.Max(p1.z, p2.z, p3.z)); minX = Mathf.Clamp(minX, 0, voxelArea.width - 1); maxX = Mathf.Clamp(maxX, 0, voxelArea.width - 1); minZ = Mathf.Clamp(minZ, 0, voxelArea.depth - 1); maxZ = Mathf.Clamp(maxZ, 0, voxelArea.depth - 1); // Check if the mesh is completely out of bounds if (minX >= voxelArea.width || minZ >= voxelArea.depth || maxX <= 0 || maxZ <= 0) { continue; } Vector3 normal; int area; //AstarProfiler.StartProfile ("Rasterize..."); normal = Vector3.Cross(p2 - p1, p3 - p1); float cosSlopeAngle = Vector3.Dot(normal.normalized, Vector3.up); if (cosSlopeAngle < slopeLimit) { area = UnwalkableArea; } else { area = 1 + mesharea; } Utility.CopyVector(vTris, 0, p1); Utility.CopyVector(vTris, 3, p2); Utility.CopyVector(vTris, 6, p3); for (int x = minX; x <= maxX; x++) { int nrow = clipper.ClipPolygon(vTris, 3, vOut, 1F, -x + 0.5F, 0); if (nrow < 3) { continue; } nrow = clipper.ClipPolygon(vOut, nrow, vRow, -1F, x + 0.5F, 0); if (nrow < 3) { continue; } float clampZ1 = vRow[2]; float clampZ2 = vRow[2]; for (int q = 1; q < nrow; q++) { float val = vRow[q * 3 + 2]; clampZ1 = System.Math.Min(clampZ1, val); clampZ2 = System.Math.Max(clampZ2, val); } int clampZ1I = Mathf.Clamp((int)System.Math.Round(clampZ1), 0, voxelArea.depth - 1); int clampZ2I = Mathf.Clamp((int)System.Math.Round(clampZ2), 0, voxelArea.depth - 1); for (int z = clampZ1I; z <= clampZ2I; z++) { //AstarProfiler.StartFastProfile(1); int ncell = clipper.ClipPolygon(vRow, nrow, vCellOut, 1F, -z + 0.5F, 2); if (ncell < 3) { //AstarProfiler.EndFastProfile(1); continue; } ncell = clipper.ClipPolygonY(vCellOut, ncell, vCell, -1F, z + 0.5F, 2); if (ncell < 3) { //AstarProfiler.EndFastProfile(1); continue; } //AstarProfiler.EndFastProfile(1); //AstarProfiler.StartFastProfile(2); float sMin = vCell[1]; float sMax = vCell[1]; for (int q = 1; q < ncell; q++) { float val = vCell[q * 3 + 1]; sMin = System.Math.Min(sMin, val); sMax = System.Math.Max(sMax, val); } //AstarProfiler.EndFastProfile(2); int maxi = (int)System.Math.Ceiling(sMax); // Skip span if below or above the bounding box if (maxi >= 0 && sMin <= maximumVoxelYCoord) { // Make sure mini >= 0 int mini = System.Math.Max(0, (int)sMin); // Make sure the span is at least 1 voxel high maxi = System.Math.Max(mini + 1, maxi); voxelArea.AddLinkedSpan(z * voxelArea.width + x, (uint)mini, (uint)maxi, area, voxelWalkableClimb); } } } } //AstarProfiler.EndFastProfile(0); //AstarProfiler.EndProfile ("Rasterize..."); } AstarProfiler.EndProfile("Voxelizing - Step 2"); }
/// <summary> /// Get back the FOV from the Projection matrix, to bypass a round number /// </summary> /// <param name="projection"></param> /// <returns></returns> float GetFOVFromProjectionMatrix(Matrix4x4 projection) { return(Mathf.Atan(1 / projection[1, 1]) * 2.0f); }
/// <summary> /// expend the camera by vertical. /// </summary> /// <param name="camera">Camera.</param> /// <param name="fScale">F scale.</param> static public void ExpendCameraByVertical(Camera camera, float fScale) { float a2 = Mathf.Atan(Mathf.Tan(camera.fieldOfView / 2 / 180 * Mathf.PI) * fScale); camera.fieldOfView = a2 / Mathf.PI * 180 * 2; }
public override void Raycast(PointerEventData eventData, List <RaycastResult> resultAppendList) { base.Raycast(eventData, resultAppendList); toExclude.Clear(); foreach (var result in resultAppendList) { var objImage = result.gameObject.GetComponent <Image>(); if (!objImage) { continue; } if (!objImage.sprite) { continue; } var objAlphaCheck = result.gameObject.GetComponent <AlphaCheck>(); if (SelectiveMode && !objAlphaCheck) { continue; } try { var objTrs = result.gameObject.transform as RectTransform; // Evaluating pointer position relative to object local space Vector3 pointerGPos; if (eventCamera) { var objPlane = new Plane(objTrs.forward, objTrs.position); float distance; var cameraRay = eventCamera.ScreenPointToRay(eventData.position); objPlane.Raycast(cameraRay, out distance); pointerGPos = cameraRay.GetPoint(distance); } else { pointerGPos = eventData.position; float rotationCorrection = (-objTrs.forward.x * (pointerGPos.x - objTrs.position.x) - objTrs.forward.y * (pointerGPos.y - objTrs.position.y)) / objTrs.forward.z; pointerGPos += new Vector3(0, 0, objTrs.position.z + rotationCorrection); } Vector3 pointerLPos = objTrs.InverseTransformPoint(pointerGPos); var objTex = objImage.mainTexture as Texture2D; Rect texRect; // Case for sprites with redundant transparent areas (Unity trims them internally, so we have to handle that) if (objImage.sprite.textureRectOffset.sqrMagnitude > 0) { texRect = objImage.sprite.packed ? new Rect(objImage.sprite.textureRect.xMin - objImage.sprite.textureRectOffset.x, objImage.sprite.textureRect.yMin - objImage.sprite.textureRectOffset.y, objImage.sprite.textureRect.width + objImage.sprite.textureRectOffset.x * 2f, objImage.sprite.textureRect.height + objImage.sprite.textureRectOffset.y * 2f) : objImage.sprite.rect; } else { texRect = objImage.sprite.textureRect; } var objSize = objTrs.rect.size; // Correcting objSize in case "preserve aspect" is enabled if (objImage.preserveAspect) { if (objSize.x < objSize.y) { objSize.y = objSize.x * (texRect.height / texRect.width); } else { objSize.x = objSize.y * (texRect.width / texRect.height); } // Also we need to cut off empty object space var halfPivot = new Vector2(Mathf.Abs(objTrs.pivot.x) == .5f ? 2 : 1, Mathf.Abs(objTrs.pivot.y) == .5f ? 2 : 1); if (Mathf.Abs(pointerLPos.x * halfPivot.x) > objSize.x || Mathf.Abs(pointerLPos.y * halfPivot.y) > objSize.y) { toExclude.Add(result); continue; } } // Evaluating texture coordinates of the targeted spot float texCorX = pointerLPos.x + objSize.x * objTrs.pivot.x; float texCorY = pointerLPos.y + objSize.y * objTrs.pivot.y; #region TILED_SLICED // Will be used if image has a border var borderTotalWidth = objImage.sprite.border.x + objImage.sprite.border.z; var borderTotalHeight = objImage.sprite.border.y + objImage.sprite.border.w; var fillRect = new Rect(objImage.sprite.border.x, objImage.sprite.border.y, Mathf.Clamp(objSize.x - borderTotalWidth, 0f, Mathf.Infinity), Mathf.Clamp(objSize.y - borderTotalHeight, 0f, Mathf.Infinity)); var isInsideFillRect = objImage.hasBorder && fillRect.Contains(new Vector2(texCorX, texCorY)); // Correcting texture coordinates in case image is tiled if (objImage.type == Image.Type.Tiled) { if (isInsideFillRect) { if (!objImage.fillCenter) { toExclude.Add(result); continue; } texCorX = objImage.sprite.border.x + (texCorX - objImage.sprite.border.x) % (texRect.width - borderTotalWidth); texCorY = objImage.sprite.border.y + (texCorY - objImage.sprite.border.y) % (texRect.height - borderTotalHeight); } else if (objImage.hasBorder) { // If objSize is below border size the border areas will shrink texCorX *= Mathf.Clamp(borderTotalWidth / objSize.x, 1f, Mathf.Infinity); texCorY *= Mathf.Clamp(borderTotalHeight / objSize.y, 1f, Mathf.Infinity); if (texCorX > texRect.width - objImage.sprite.border.z && texCorX < objImage.sprite.border.x + fillRect.width) { texCorX = objImage.sprite.border.x + (texCorX - objImage.sprite.border.x) % (texRect.width - borderTotalWidth); } else if (texCorX > objImage.sprite.border.x + fillRect.width) { texCorX = texCorX - fillRect.width + texRect.width - borderTotalWidth; } if (texCorY > texRect.height - objImage.sprite.border.w && texCorY < objImage.sprite.border.y + fillRect.height) { texCorY = objImage.sprite.border.y + (texCorY - objImage.sprite.border.y) % (texRect.height - borderTotalHeight); } else if (texCorY > objImage.sprite.border.y + fillRect.height) { texCorY = texCorY - fillRect.height + texRect.height - borderTotalHeight; } } else { if (texCorX > texRect.width) { texCorX %= texRect.width; } if (texCorY > texRect.height) { texCorY %= texRect.height; } } } // Correcting texture coordinates in case image is sliced else if (objImage.type == Image.Type.Sliced) { if (isInsideFillRect) { if (!objImage.fillCenter) { toExclude.Add(result); continue; } texCorX = objImage.sprite.border.x + (texCorX - objImage.sprite.border.x) * ((texRect.width - borderTotalWidth) / fillRect.width); texCorY = objImage.sprite.border.y + (texCorY - objImage.sprite.border.y) * ((texRect.height - borderTotalHeight) / fillRect.height); } else { // If objSize is below border size the border areas will shrink texCorX *= Mathf.Clamp(borderTotalWidth / objSize.x, 1f, Mathf.Infinity); texCorY *= Mathf.Clamp(borderTotalHeight / objSize.y, 1f, Mathf.Infinity); if (texCorX > objImage.sprite.border.x && texCorX < objImage.sprite.border.x + fillRect.width) { texCorX = objImage.sprite.border.x + (texCorX - objImage.sprite.border.x) * ((texRect.width - borderTotalWidth) / fillRect.width); } else if (texCorX > objImage.sprite.border.x + fillRect.width) { texCorX = texCorX - fillRect.width + texRect.width - borderTotalWidth; } if (texCorY > objImage.sprite.border.y && texCorY < objImage.sprite.border.y + fillRect.height) { texCorY = objImage.sprite.border.y + (texCorY - objImage.sprite.border.y) * ((texRect.height - borderTotalHeight) / fillRect.height); } else if (texCorY > objImage.sprite.border.y + fillRect.height) { texCorY = texCorY - fillRect.height + texRect.height - borderTotalHeight; } } } #endregion // Correcting texture coordinates by scale in case simple or filled image else { texCorX *= texRect.width / objSize.x; texCorY *= texRect.height / objSize.y; } // For filled images, check if targeted spot is outside of the filled area #region FILLED if (objImage.type == Image.Type.Filled) { var nCorX = texRect.height > texRect.width ? texCorX * (texRect.height / texRect.width) : texCorX; var nCorY = texRect.width > texRect.height ? texCorY * (texRect.width / texRect.height) : texCorY; var nWidth = texRect.height > texRect.width ? texRect.height : texRect.width; var nHeight = texRect.width > texRect.height ? texRect.width : texRect.height; if (objImage.fillMethod == Image.FillMethod.Horizontal) { if (objImage.fillOrigin == (int)Image.OriginHorizontal.Left && texCorX / texRect.width > objImage.fillAmount) { toExclude.Add(result); continue; } if (objImage.fillOrigin == (int)Image.OriginHorizontal.Right && texCorX / texRect.width < (1 - objImage.fillAmount)) { toExclude.Add(result); continue; } } if (objImage.fillMethod == Image.FillMethod.Vertical) { if (objImage.fillOrigin == (int)Image.OriginVertical.Bottom && texCorY / texRect.height > objImage.fillAmount) { toExclude.Add(result); continue; } if (objImage.fillOrigin == (int)Image.OriginVertical.Top && texCorY / texRect.height < (1 - objImage.fillAmount)) { toExclude.Add(result); continue; } } #region RADIAL_90 if (objImage.fillMethod == Image.FillMethod.Radial90) { if (objImage.fillOrigin == (int)Image.Origin90.BottomLeft) { if (objImage.fillClockwise && Mathf.Atan(nCorY / nCorX) / (Mathf.PI / 2) < (1 - objImage.fillAmount)) { toExclude.Add(result); continue; } if (!objImage.fillClockwise && Mathf.Atan(nCorY / nCorX) / (Mathf.PI / 2) > objImage.fillAmount) { toExclude.Add(result); continue; } } if (objImage.fillOrigin == (int)Image.Origin90.TopLeft) { if (objImage.fillClockwise && nCorY < -(1 / Mathf.Tan((1 - objImage.fillAmount) * Mathf.PI / 2)) * nCorX + nHeight) { toExclude.Add(result); continue; } if (!objImage.fillClockwise && nCorY > -(1 / Mathf.Tan(objImage.fillAmount * Mathf.PI / 2)) * nCorX + nHeight) { toExclude.Add(result); continue; } } if (objImage.fillOrigin == (int)Image.Origin90.TopRight) { if (objImage.fillClockwise && nCorY > Mathf.Tan((1 - objImage.fillAmount) * Mathf.PI / 2) * (nCorX - nWidth) + nHeight) { toExclude.Add(result); continue; } if (!objImage.fillClockwise && nCorY < Mathf.Tan(objImage.fillAmount * Mathf.PI / 2) * (nCorX - nWidth) + nHeight) { toExclude.Add(result); continue; } } if (objImage.fillOrigin == (int)Image.Origin90.BottomRight) { if (objImage.fillClockwise && nCorY > (1 / Mathf.Tan((1 - objImage.fillAmount) * Mathf.PI / 2)) * (nWidth - nCorX)) { toExclude.Add(result); continue; } if (!objImage.fillClockwise && nCorY < (1 / Mathf.Tan(objImage.fillAmount * Mathf.PI / 2)) * (nWidth - nCorX)) { toExclude.Add(result); continue; } } } #endregion #region RADIAL_180 if (objImage.fillMethod == Image.FillMethod.Radial180) { if (objImage.fillOrigin == (int)Image.Origin180.Bottom) { if (objImage.fillClockwise && Mathf.Atan2(nCorY, 2 * (nCorX - nWidth / 2)) < (1 - objImage.fillAmount) * Mathf.PI) { toExclude.Add(result); continue; } if (!objImage.fillClockwise && Mathf.Atan2(texCorY, 2 * (nCorX - nWidth / 2)) > objImage.fillAmount * Mathf.PI) { toExclude.Add(result); continue; } } if (objImage.fillOrigin == (int)Image.Origin180.Left) { if (objImage.fillClockwise && Mathf.Atan2(nCorX, -2 * (nCorY - nHeight / 2)) < (1 - objImage.fillAmount) * Mathf.PI) { toExclude.Add(result); continue; } if (!objImage.fillClockwise && Mathf.Atan2(nCorX, -2 * (nCorY - nHeight / 2)) > objImage.fillAmount * Mathf.PI) { toExclude.Add(result); continue; } } if (objImage.fillOrigin == (int)Image.Origin180.Top) { if (objImage.fillClockwise && Mathf.Atan2(nHeight - nCorY, -2 * (nCorX - nWidth / 2)) < (1 - objImage.fillAmount) * Mathf.PI) { toExclude.Add(result); continue; } if (!objImage.fillClockwise && Mathf.Atan2(nHeight - nCorY, -2 * (nCorX - nWidth / 2)) > objImage.fillAmount * Mathf.PI) { toExclude.Add(result); continue; } } if (objImage.fillOrigin == (int)Image.Origin180.Right) { if (objImage.fillClockwise && Mathf.Atan2(nWidth - nCorX, 2 * (nCorY - nHeight / 2)) < (1 - objImage.fillAmount) * Mathf.PI) { toExclude.Add(result); continue; } if (!objImage.fillClockwise && Mathf.Atan2(nWidth - nCorX, 2 * (nCorY - nHeight / 2)) > objImage.fillAmount * Mathf.PI) { toExclude.Add(result); continue; } } } #endregion #region RADIAL_360 if (objImage.fillMethod == Image.FillMethod.Radial360) { if (objImage.fillOrigin == (int)Image.Origin360.Bottom) { if (objImage.fillClockwise) { var angle = Mathf.Atan2(nCorY - nHeight / 2, nCorX - nWidth / 2) + Mathf.PI / 2; var checkAngle = Mathf.PI * 2 * (1 - objImage.fillAmount); angle = angle < 0 ? Mathf.PI * 2 + angle : angle; if (angle < checkAngle) { toExclude.Add(result); continue; } } if (!objImage.fillClockwise) { var angle = Mathf.Atan2(nCorY - nHeight / 2, nCorX - nWidth / 2) + Mathf.PI / 2; var checkAngle = Mathf.PI * 2 * objImage.fillAmount; angle = angle < 0 ? Mathf.PI * 2 + angle : angle; if (angle > checkAngle) { toExclude.Add(result); continue; } } } if (objImage.fillOrigin == (int)Image.Origin360.Right) { if (objImage.fillClockwise) { var angle = Mathf.Atan2(nCorY - nHeight / 2, nCorX - nWidth / 2); var checkAngle = Mathf.PI * 2 * (1 - objImage.fillAmount); angle = angle < 0 ? Mathf.PI * 2 + angle : angle; if (angle < checkAngle) { toExclude.Add(result); continue; } } if (!objImage.fillClockwise) { var angle = Mathf.Atan2(nCorY - nHeight / 2, nCorX - nWidth / 2); var checkAngle = Mathf.PI * 2 * objImage.fillAmount; angle = angle < 0 ? Mathf.PI * 2 + angle : angle; if (angle > checkAngle) { toExclude.Add(result); continue; } } } if (objImage.fillOrigin == (int)Image.Origin360.Top) { if (objImage.fillClockwise) { var angle = Mathf.Atan2(nCorY - nHeight / 2, nCorX - nWidth / 2) - Mathf.PI / 2; var checkAngle = Mathf.PI * 2 * (1 - objImage.fillAmount); angle = angle < 0 ? Mathf.PI * 2 + angle : angle; if (angle < checkAngle) { toExclude.Add(result); continue; } } if (!objImage.fillClockwise) { var angle = Mathf.Atan2(nCorY - nHeight / 2, nCorX - nWidth / 2) - Mathf.PI / 2; var checkAngle = Mathf.PI * 2 * objImage.fillAmount; angle = angle < 0 ? Mathf.PI * 2 + angle : angle; if (angle > checkAngle) { toExclude.Add(result); continue; } } } if (objImage.fillOrigin == (int)Image.Origin360.Left) { if (objImage.fillClockwise) { var angle = Mathf.Atan2(nCorY - nHeight / 2, nCorX - nWidth / 2) - Mathf.PI; var checkAngle = Mathf.PI * 2 * (1 - objImage.fillAmount); angle = angle < 0 ? Mathf.PI * 2 + angle : angle; if (angle < checkAngle) { toExclude.Add(result); continue; } } if (!objImage.fillClockwise) { var angle = Mathf.Atan2(nCorY - nHeight / 2, nCorX - nWidth / 2) - Mathf.PI; var checkAngle = Mathf.PI * 2 * objImage.fillAmount; angle = angle < 0 ? Mathf.PI * 2 + angle : angle; if (angle > checkAngle) { toExclude.Add(result); continue; } } } } #endregion } #endregion // Getting targeted pixel alpha from object's texture float alpha = objTex.GetPixel((int)(texCorX + texRect.x), (int)(texCorY + texRect.y)).a; // Deciding if we need to exclude the object from results list if (objAlphaCheck) { if (objAlphaCheck.IncludeMaterialAlpha) { alpha *= objImage.color.a; } if (alpha < objAlphaCheck.AlphaThreshold) { toExclude.Add(result); } } else { if (IncludeMaterialAlpha) { alpha *= objImage.color.a; } if (alpha < AlphaThreshold) { toExclude.Add(result); } } } catch (UnityException e) { if (Application.isEditor && ShowTextureWarnings) { Debug.LogWarning(string.Format("Check for alpha failed: {0}", e.Message)); } }; } resultAppendList.RemoveAll(r => toExclude.Contains(r)); }
/// <summary> /// 配置灯光环境 /// </summary> void ConfigureLights() { mainLightExists = false; bool shadowmaskExists = false; bool subtractiveLighting = false; shadowTileCount = 0; for (int i = 0; i < cull.visibleLights.Count; i++) { if (i == maxVisibleLights) //超过最大灯光数量跳出循环 { break; } VisibleLight light = cull.visibleLights[i]; //visibleLightColors[i] = light.finalColor; Vector4 attenuation = Vector4.zero; attenuation.w = 1; Vector4 shadow = Vector4.zero; LightBakingOutput baking = light.light.bakingOutput; //标识 visibleLightOcclusionMasks[i] = occlusionMasks[baking.occlusionMaskChannel + 1]; if (baking.lightmapBakeType == LightmapBakeType.Mixed) { shadowmaskExists |= baking.mixedLightingMode == MixedLightingMode.Shadowmask; //subtractiveLighting |= baking.mixedLightingMode == MixedLightingMode.Subtractive; if (baking.mixedLightingMode == MixedLightingMode.Subtractive) { subtractiveLighting = true; //设置的颜色设置进去 cameraBuffer.SetGlobalColor(subtractiveShadowColorId, RenderSettings.subtractiveShadowColor); } } if (light.lightType == LightType.Directional) { Vector4 v = light.localToWorld.GetColumn(2); v.x = -v.x; v.y = -v.y; v.z = -v.z; visibleLightDirectionsOrPositions[i] = v; shadow = ConfigureShadows(i, light.light); shadow.z = 1f; //标识处理方向光 if (i == 0 && shadow.x > 0f && shadowCascades > 0) { mainLightExists = true; shadowTileCount -= 1; } } else { visibleLightDirectionsOrPositions[i] = light.localToWorld.GetColumn(3); //获取点光源位置 attenuation.x = 1f / Mathf.Max(light.range * light.range, 0.00001f); if (light.lightType == LightType.Spot) { Vector4 v = light.localToWorld.GetColumn(2); v.x = -v.x; v.y = -v.y; v.z = -v.z; visibleLightSpotDirections[i] = v; float outerRad = Mathf.Deg2Rad * 0.5f * light.spotAngle; float outerCos = Mathf.Cos(outerRad); float outerTan = Mathf.Tan(outerRad); float innerCos = Mathf.Cos(Mathf.Atan(((64f - 18f) / 64f) * outerTan)); float angleRange = Mathf.Max(innerCos - outerCos, 0.001f); attenuation.z = 1f / angleRange; attenuation.w = -outerCos * attenuation.z; //阴影 //Light shadowLight = light.light; //Bounds shadowBounds; //if (shadowLight.shadows != LightShadows.None && cull.GetShadowCasterBounds(i, out shadowBounds)) //{ // shadowTileCount += 1; // shadow.x = shadowLight.shadowStrength; //x分量存阴影强度 // shadow.y = shadowLight.shadows == LightShadows.Soft ? 1f : 0f; //} shadow = ConfigureShadows(i, light.light); } else { visibleLightSpotDirections[i] = Vector4.one; } } visibleLightColors[i] = light.finalColor; visibleLightAttenuations[i] = attenuation; shadowData[i] = shadow; } bool useDistanceShadowmask = QualitySettings.shadowmaskMode == ShadowmaskMode.DistanceShadowmask; //是否存在shadowMask CoreUtils.SetKeyword(cameraBuffer, shadowmaskKeyword, shadowmaskExists && !useDistanceShadowmask); CoreUtils.SetKeyword(cameraBuffer, subtractiveLightingKeyword, subtractiveLighting); CoreUtils.SetKeyword(cameraBuffer, distanceShadowmask, shadowmaskExists && useDistanceShadowmask); //for (; i < maxVisibleLights; i++) //还原清除后面灯光颜色(0,0,0,0) //{ // visibleLightColors[i] = Color.clear; //} //告诉Unity 超出最大灯光数量的索引设置为-1使其不起作用 if (mainLightExists || cull.visibleLights.Count > maxVisibleLights) { int[] lightIndices = cull.GetLightIndexMap(); if (mainLightExists) { lightIndices[0] = -1; } for (int i = maxVisibleLights; i < cull.visibleLights.Count; i++) { lightIndices[i] = -1; } cull.SetLightIndexMap(lightIndices); } }
void Update() { index = FindClosestEnemy(); attackTimer += Time.deltaTime; beamTimer += Time.deltaTime; lifeSpanTimer += Time.deltaTime; if (index != -1) { if (attackTimer > 1f) { if (enemies[index].transform.position.y < 2.35f) { aimedEnemy = enemies[index]; //shoot Vector3 diff = enemies[index].transform.position - new Vector3(-0.1875f, -1.6275f); float rotation = 0f; //rotation if (diff.x == 0f) { if (diff.y <= 0f) { rotation = 0f; } if (diff.y > 0f) { rotation = 180f; } } if (diff.x < 0f) { if (diff.y < 0f) { rotation = -Mathf.Atan(diff.x / diff.y) * 180 / Mathf.PI + 180f; } if (diff.y == 0f) { rotation = 0f; } if (diff.y > 0f) { rotation = -Mathf.Atan(diff.x / diff.y) * 180 / Mathf.PI; } } if (diff.x > 0f) { if (diff.y < 0f) { rotation = -Mathf.Atan(diff.x / diff.y) * 180 / Mathf.PI + 180f; } if (diff.y == 0f) { rotation = 0f; } if (diff.y > 0f) { rotation = -Mathf.Atan(diff.x / diff.y) * 180 / Mathf.PI; } } Quaternion rot = Quaternion.Euler(0f, 0f, rotation); beamImage.transform.rotation = rot; //length beamLength = Mathf.Sqrt(diff.x * diff.x + diff.y * diff.y * (((Screen.height / (float)Screen.width) > 2) ? 1.25f * 1.25f : 1)) * 1.4f; beamFired = true; beamTimer = 0f; attackTimer = 0f; } } } if (beamFired) { if (beamTimer >= 0.5f) { beamImage.transform.localScale = new Vector3(1f, 0f); beamFired = false; if (aimedEnemy != null) { aimedEnemy.gameObject.GetComponent <DamageDealer>().DealDamage(Mathf.RoundToInt(dmg * Random.Range(0.8f, 1.2f))); } } else { float length = beamLength * beamTimer * 2f; beamImage.transform.localScale = new Vector3(1f, length); } } if (lifeSpanTimer > 20.9f) { Destroy(gameObject); } }
public static float FocaltoFOV(float focal, float axisResolution) { return(2.0f * Mathf.Atan(0.5f * axisResolution / focal) * Mathf.Rad2Deg); // virtual camera (pinhole type) vertical field of view }
private Vector3 getVelocityDirection(int i) { float angle = Mathf.Atan(TerrainManager.instance.multiplier_y * (parsing.yData[i + 1] - parsing.yData[i]) / (parsing.xData[i + 1] - parsing.xData[i])); return(new Vector3(Mathf.Cos(angle), Mathf.Sin(angle), 0)); }
void InitializeLightConstants(List <VisibleLight> lights, int lightIndex, out Vector4 lightPos, out Vector4 lightColor, out Vector4 lightDistanceAttenuation, out Vector4 lightSpotDir, out Vector4 lightSpotAttenuation) { lightPos = k_DefaultLightPosition; lightColor = k_DefaultLightColor; lightDistanceAttenuation = k_DefaultLightSpotAttenuation; lightSpotDir = k_DefaultLightSpotDirection; lightSpotAttenuation = k_DefaultLightAttenuation; // When no lights are visible, main light will be set to -1. // In this case we initialize it to default values and return if (lightIndex < 0) { return; } VisibleLight lightData = lights[lightIndex]; if (lightData.lightType == LightType.Directional) { Vector4 dir = -lightData.localToWorld.GetColumn(2); lightPos = new Vector4(dir.x, dir.y, dir.z, 0.0f); } else { Vector4 pos = lightData.localToWorld.GetColumn(3); lightPos = new Vector4(pos.x, pos.y, pos.z, 1.0f); } // VisibleLight.finalColor already returns color in active color space lightColor = lightData.finalColor; // Directional Light attenuation is initialize so distance attenuation always be 1.0 if (lightData.lightType != LightType.Directional) { // Light attenuation in lightweight matches the unity vanilla one. // attenuation = 1.0 / 1.0 + distanceToLightSqr * quadraticAttenuation // then a smooth factor is applied to linearly fade attenuation to light range // the attenuation smooth factor starts having effect at 80% of light range // smoothFactor = (lightRangeSqr - distanceToLightSqr) / (lightRangeSqr - fadeStartDistanceSqr) // We rewrite smoothFactor to be able to pre compute the constant terms below and apply the smooth factor // with one MAD instruction // smoothFactor = distanceSqr * (1.0 / (fadeDistanceSqr - lightRangeSqr)) + (-lightRangeSqr / (fadeDistanceSqr - lightRangeSqr) // distanceSqr * oneOverFadeRangeSqr + lightRangeSqrOverFadeRangeSqr float lightRangeSqr = lightData.range * lightData.range; float fadeStartDistanceSqr = 0.8f * 0.8f * lightRangeSqr; float fadeRangeSqr = (fadeStartDistanceSqr - lightRangeSqr); float oneOverFadeRangeSqr = 1.0f / fadeRangeSqr; float lightRangeSqrOverFadeRangeSqr = -lightRangeSqr / fadeRangeSqr; float quadAtten = 25.0f / lightRangeSqr; lightDistanceAttenuation = new Vector4(quadAtten, oneOverFadeRangeSqr, lightRangeSqrOverFadeRangeSqr, 1.0f); } if (lightData.lightType == LightType.Spot) { Vector4 dir = lightData.localToWorld.GetColumn(2); lightSpotDir = new Vector4(-dir.x, -dir.y, -dir.z, 0.0f); // Spot Attenuation with a linear falloff can be defined as // (SdotL - cosOuterAngle) / (cosInnerAngle - cosOuterAngle) // This can be rewritten as // invAngleRange = 1.0 / (cosInnerAngle - cosOuterAngle) // SdotL * invAngleRange + (-cosOuterAngle * invAngleRange) // If we precompute the terms in a MAD instruction float cosOuterAngle = Mathf.Cos(Mathf.Deg2Rad * lightData.spotAngle * 0.5f); // We neeed to do a null check for particle lights // This should be changed in the future // Particle lights will use an inline function float cosInnerAngle; if (lightData.light != null) { cosInnerAngle = Mathf.Cos(LightmapperUtils.ExtractInnerCone(lightData.light) * 0.5f); } else { cosInnerAngle = Mathf.Cos((2.0f * Mathf.Atan(Mathf.Tan(lightData.spotAngle * 0.5f * Mathf.Deg2Rad) * (64.0f - 18.0f) / 64.0f)) * 0.5f); } float smoothAngleRange = Mathf.Max(0.001f, cosInnerAngle - cosOuterAngle); float invAngleRange = 1.0f / smoothAngleRange; float add = -cosOuterAngle * invAngleRange; lightSpotAttenuation = new Vector4(invAngleRange, add, 0.0f); } Light light = lightData.light; // TODO: Add support to shadow mask if (light != null && light.bakingOutput.mixedLightingMode == MixedLightingMode.Subtractive && light.bakingOutput.lightmapBakeType == LightmapBakeType.Mixed) { if (m_MixedLightingSetup == MixedLightingSetup.None && lightData.light.shadows != LightShadows.None) { m_MixedLightingSetup = MixedLightingSetup.Subtractive; lightDistanceAttenuation.w = 0.0f; } } }
private void PlaceCubeNear(Vector3 clickPoint) { if (camScript.editing == true && OverUI == false) { var finalPosition = grid.GetNearestPointOnGrid(clickPoint); if (clickNum == 1) { startPos = finalPosition; if (history.Count > 0) { JointCheck(startPos); } if (overlap == false && midCreate == false) { history.Add(startPos); cubeClickBack = GameObject.CreatePrimitive(PrimitiveType.Cylinder); cubeClickBack.transform.position = new Vector3(-2.7f, finalPosition.y, finalPosition.z); cubeClickBack.transform.Rotate(0, 0, 90); cubeClickBack.transform.localScale = new Vector3(cubeClickScale, cubeClickScaleY, cubeClickScale); cubeClickBack.GetComponent <Renderer>().material.color = Color.green; cubeClickBack.AddComponent(typeof(CustomStructureConfig)); cubeClickBack.tag = "Structure"; cubeClickBack.name = "Pivot"; GroundCheck(startPos, cubeClickBack); cubeClickFront = GameObject.CreatePrimitive(PrimitiveType.Cylinder); cubeClickFront.transform.position = new Vector3(2.7f, finalPosition.y, finalPosition.z); cubeClickFront.transform.Rotate(0, 0, 90); cubeClickFront.transform.localScale = new Vector3(cubeClickScale, cubeClickScaleY, cubeClickScale); cubeClickFront.GetComponent <Renderer>().material.color = Color.green; cubeClickFront.AddComponent(typeof(CustomStructureConfig)); cubeClickFront.tag = "Structure"; cubeClickFront.name = "Pivot"; GroundCheck(startPos, cubeClickFront); clickNum = 2; } } else if (clickNum == 2) { endPos = finalPosition; if (history.Count > 0) { JointCheck(endPos); } if (endPos != history[history.Count - 1]) { history.Add(endPos); if (overlap == false) { cubeClickBack = GameObject.CreatePrimitive(PrimitiveType.Cylinder); cubeClickBack.transform.position = new Vector3(-2.7f, finalPosition.y, finalPosition.z); cubeClickBack.transform.Rotate(0, 0, 90); cubeClickBack.transform.localScale = new Vector3(cubeClickScale, cubeClickScaleY, cubeClickScale); cubeClickBack.GetComponent <Renderer>().material.color = Color.blue; cubeClickBack.AddComponent(typeof(CustomStructureConfig)); cubeClickBack.tag = "Structure"; cubeClickBack.name = "Pivot"; GroundCheck(endPos, cubeClickBack); cubeClickFront = GameObject.CreatePrimitive(PrimitiveType.Cylinder); cubeClickFront.transform.position = new Vector3(2.7f, finalPosition.y, finalPosition.z); cubeClickFront.transform.Rotate(0, 0, 90); cubeClickFront.transform.localScale = new Vector3(cubeClickScale, cubeClickScaleY, cubeClickScale); cubeClickFront.GetComponent <Renderer>().material.color = Color.blue; cubeClickFront.AddComponent(typeof(CustomStructureConfig)); cubeClickFront.tag = "Structure"; cubeClickFront.name = "Pivot"; GroundCheck(endPos, cubeClickFront); } Vector3 mid = startPos + (endPos - startPos) / 2; float changeY = endPos.y - startPos.y; float changeZ = endPos.z - startPos.z; float difYZ = changeY / changeZ; float angle = Mathf.Atan(difYZ); double result = RadianToDegree(angle); float xScale = Mathf.Abs(endPos.x - startPos.x); float yScale = Mathf.Abs(endPos.y - startPos.y); float zScale = Mathf.Abs(endPos.z - startPos.z); float zScale2 = Mathf.Abs((zScale * zScale) + (yScale * yScale)); float root = Mathf.Sqrt(zScale2); if (xScale == 0) { xScale = 1; } if (yScale == 0) { yScale = 1; } if (zScale == 0) { zScale = yScale; } if (materialDrop.value == 0) //steel { poleBack = GameObject.CreatePrimitive(PrimitiveType.Cube); GameObject go = poleBack; go.name = "steelBack"; go.transform.position = new Vector3(-2.7f, mid.y, mid.z); go.transform.localScale = new Vector3(0.5f, 0.5f, root + 0.5f); go.transform.Rotate(new Vector3(-(float)result, 0, 0)); go.tag = "Structure"; go.AddComponent(typeof(Rigidbody)); go.AddComponent(typeof(CustomStructureConfig)); Rigidbody rb = go.GetComponent <Rigidbody>(); rb.isKinematic = true; FindNearPivots(go.transform.position, go.transform.localScale, go); poleFront = GameObject.CreatePrimitive(PrimitiveType.Cube); go = poleFront; //(GameObject go = blahblablah) go.name = "steelFront"; go.transform.position = new Vector3(2.7f, mid.y, mid.z); go.transform.localScale = new Vector3(0.5f, 0.5f, root + 0.5f); go.transform.Rotate(new Vector3(-(float)result, 0, 0)); go.tag = "Structure"; go.AddComponent(typeof(Rigidbody)); go.AddComponent(typeof(CustomStructureConfig)); rb = go.GetComponent <Rigidbody>(); rb.isKinematic = true; FindNearPivots(go.transform.position, go.transform.localScale, go); } else if (materialDrop.value == 1) //road { roadCube = GameObject.CreatePrimitive(PrimitiveType.Cube); GameObject go = roadCube; go.name = "Road"; go.transform.position = new Vector3(0, mid.y, mid.z); go.transform.localScale = new Vector3(5.4f, 0.5f, root + 0.5f); go.transform.Rotate(new Vector3(-(float)result, 0, 0)); go.GetComponent <Renderer>().material.color = Color.black; go.tag = "Structure"; go.AddComponent(typeof(Rigidbody)); go.AddComponent(typeof(CustomStructureConfig)); Rigidbody rb = go.GetComponent <Rigidbody>(); rb.isKinematic = true; FindNearPivots(go.transform.position, go.transform.localScale, go); } clickNum = 1; } else { clickNum = 1; } } //Destroy(cubeClickBack); } }