this.Hit = new RayHit() { ray = ray, Normal = normal, distance = distance, Collidable = collidable, };
private RayData drawPlayerChosenDirection(RayData rd) { RaycastHit2D hit = Physics2D.Raycast(rd.origin, rd.direction, rd.magnitude); if (hit.collider != null) { if (hit.collider.gameObject.GetComponentInChildren <Battery>() != null) { StartCoroutine(_Battery.increaseCharge(0.34f)); rd.hitBattery = true; } rd.hit = true; rd.direction = Vector2.Reflect((hit.point - rd.origin).normalized, hit.normal); rd.origin = hit.point + hit.normal * 0.01f; emitLightningPathParticle(lightningPS, rd.origin, 1);// + hit2dNormal * 0.1f); _Screenshake.increaseTrauma(0.5f, -hit.normal); StartCoroutine(spawnLight(hit.point)); spawnSpark(hit); } else { rd.origin += (rd.direction * rd.magnitude); emitLightningPathParticle(lightningPS, rd.origin, 30); } return(rd); }
private void showRay(RayData ray, bool bShow) { if (ray.line) { bool vis = bShow; vis &= (ray.Equals(_Ray[RAY_MOUSE])); ray.line.gameObject.SetActive(vis); } if (ray.spark && !bShow) { ray.spark.SetActive(false); } if (!bShow) { ray.hit = null; if (ray.press) { ray.press.SetButtonState(OVButtonState.Normal); ray.press = null; } } }
public Renderer(int screenWidth, int screenHeight) { camera = new Camera(GRID_X, GRID_Y, screenWidth, screenHeight, (float)Math.PI / 2.8f); frame_buffer = new PixelBuffer(screenWidth, screenHeight); // Generate placeholder texture textures = new Dictionary <int, TextureDef>(); sprites = new Dictionary <int, SpriteDef>(); missing_sprites = new Dictionary <int, bool>(); missing_textures = new Dictionary <int, bool>(); PixelBuffer tex = new PixelBuffer(16, 16); Render.clear(tex, new Rgba(0, 0, 0)); for (int y = 0; y < 16; y++) { for (int x = 0; x < 16; x++) { byte b = (byte)(x * 16); byte c = (byte)(y * 16); Render.point(tex, x, y, new Rgba(0, b, c)); } } default_sprite = new SpriteDef(0, tex); default_texture = new TextureDef(0, tex); // Ray buffer used for storing ray cast results. ray_buffer = new RayData[camera.view_cols]; for (int index = 0; index < ray_buffer.Length; index++) { ray_buffer[index] = new RayData(); } }
public static RayData Raycast(Ray ray) { RayData rayData = new RayData(); RaycastHit hit; if (Physics.Raycast(ray, out hit, 100)) { Debug.DrawLine(ray.origin, hit.point, Color.blue); rayData.hit = true; RaytracingColor rayColor = hit.transform.gameObject.GetComponent <RaytracingColor>(); if (rayColor == null) { rayData.color = Color.blue; } else { rayData.color = rayColor.color; } rayData.normal = hit.normal; rayData.hitPosition = hit.point; } else { Debug.DrawLine(ray.origin, ray.origin + 100f * ray.direction, Color.red); rayData.hit = false; rayData.color = Color.black; } return(rayData); }
/// <summary> /// Sets up _colliderRays to resemble the provided reference data. /// </summary> /// <param name="rayData"></param> private void SetupRaysForWall(RayData rayData) { float lengthFactor = 2.0f / _amountOfGapsBetweenRays; //We need full length of the edge. We got half from the data. //Divide by amount of edges once (would have twice otherwise). float widthOffsetLength = rayData.WidthOffset.magnitude * lengthFactor; float heightOffsetLength = rayData.HeightOffset.magnitude * lengthFactor; Vector3 widthOffsetStep = rayData.WidthOffset.normalized * widthOffsetLength; Vector3 heightOffsetStep = rayData.HeightOffset.normalized * heightOffsetLength; int rayIndex = 0; for (int i = 0; i < _raysPerEdge; i++) { Vector3 currentRayPosition = rayData.rayPosition + i * widthOffsetStep; for (int j = 0; j < _raysPerEdge; j++) { Ray ray = _colliderRays[rayIndex]; ray.origin = currentRayPosition; ray.direction = rayData.normal; _colliderRays[rayIndex] = ray; currentRayPosition += heightOffsetStep; rayIndex++; } } }
// RayData 삽입 public void PushRayData(RayData _RayData) { hitPoint = _RayData.hitPoint; hitDir = _RayData.hitDir; rayDistance = _RayData.rayDistance; hitRay = _RayData.hitRay; }
this.hits.Add(new RayHit() { ray = ray, Normal = normal, distance = distance, Collidable = collidable, });
/// <summary> /// Ray-versus-triangle intersection test suitable for ray-tracing etc. /// Port of Möller–Trumbore algorithm c++ version from: /// https://en.wikipedia.org/wiki/Möller–Trumbore_intersection_algorithm /// /// Adapted from https://answers.unity.com/questions/861719/a-fast-triangle-triangle-intersection-algorithm-fo.html /// </summary> /// <returns><c>The distance along the ray to the intersection</c> if one exists, <c>NaN</c> if one does not.</returns> /// <param name="ray">Le ray.</param> /// <param name="v0">A vertex of the triangle.</param> /// <param name="v1">A vertex of the triangle.</param> /// <param name="v2">A vertex of the triangle.</param> static float IntersectRayTriangle(RayData ray, float3 v0, float3 v1, float3 v2) { const float epsilon = 0.000001f; float3 e1 = v1 - v0; float3 e2 = v2 - v0; float3 h = math.cross(ray.Direction, e2); float a = math.dot(e1, h); if (a > -epsilon && a < epsilon) { return(float.NaN); } float f = 1.0f / a; float3 s = ray.Origin - v0; float u = f * math.dot(s, h); if (u < 0.0f || u > 1.0f) { return(float.NaN); } float3 q = math.cross(s, e1); float v = f * math.dot(ray.Direction, q); if (v < 0.0f || u + v > 1.0f) { return(float.NaN); } float t = f * math.dot(e2, q); return(t > epsilon ? t : float.NaN); }
public void AddRay() { GameObject g = new GameObject("Ray " + (Rays.Count + 1)); g.transform.parent = transform; CheckPoints(); RayData rayData = new RayData(); Keyframe k1 = new Keyframe(); k1.time = 0f; k1.value = 1f; Keyframe k2 = new Keyframe(); k2.time = 1f; k2.value = 1f; rayData.Shape.AddKey(k1); rayData.Shape.AddKey(k2); rayData.AmplitudeMask.AddKey(k1); rayData.AmplitudeMask.AddKey(k2); rayData.RayHolder = g; Material m = new Material(Shader.Find("UltimateRayDesigner/Ray_Add")); m.SetTexture("_MainTex", Resources.Load("Textures/RayTexture_5") as Texture2D); m.SetTexture("_Mask", Resources.Load("Textures/Mask1") as Texture2D); m.SetTexture("_Distortion", Resources.Load("Textures/Noise_1") as Texture2D); m.SetColor("_TintColor", new Color(0.0f, .3f, 1f, 1f)); rayData.Mat = m; Rays.Add(rayData); }
bool getRayData(int rayid, out RayData raydata) { bool v = false; raydata = _Ray[rayid]; v = raydata.isValid; return(v); }
private RayData drawRandomPathAndBounces(RayData rd) { if (rd.hit == true) // handle reflection { RaycastHit2D hit = Physics2D.Raycast(rd.origin, rd.direction, rd.magnitude); if (hit.collider != null) // bounced off one wall into another wall //Debug.DrawLine(rd.origin, rd.origin + rd.direction * rd.magnitude, Color.red, 3f); { if (hit.collider.gameObject.GetComponentInChildren <Battery>() != null) { StartCoroutine(_Battery.increaseCharge(0.34f)); rd.hitBattery = true; } rd.hit = true; rd.direction = Vector2.Reflect((hit.point - rd.origin).normalized, hit.normal); rd.origin = hit.point + hit.normal * 0.01f; emitLightningPathParticle(lightningPS, rd.origin, 1);// + hit2dNormal * 0.1f); _Screenshake.increaseTrauma(0.5f, -hit.normal); StartCoroutine(spawnLight(hit.point)); spawnSpark(hit); } else // bounced off wall into space { Debug.DrawLine(rd.origin, rd.origin + rd.direction * rd.magnitude, Color.green, 3f); print("bounced off wall into space"); rd.origin += (rd.direction * rd.magnitude); emitLightningPathParticle(lightningPS, rd.origin, 30); rd.hit = false; } } else // draw random ray { rd.direction = (Random.insideUnitCircle + rd.direction).normalized; RaycastHit2D hit = Physics2D.Raycast(rd.origin, rd.direction, rd.magnitude); if (hit.collider != null) { if (hit.collider.gameObject.GetComponentInChildren <Battery>() != null) { StartCoroutine(_Battery.increaseCharge(0.34f)); rd.hitBattery = true; } rd.hit = true; rd.direction = Vector2.Reflect((hit.point - rd.origin).normalized, hit.normal); rd.origin = hit.point + hit.normal * 0.01f; emitLightningPathParticle(lightningPS, rd.origin, 1);// + hit2dNormal * 0.1f); _Screenshake.increaseTrauma(0.5f, -hit.normal); StartCoroutine(spawnLight(hit.point)); spawnSpark(hit); } else { print("random ray hit space"); rd.origin += (rd.direction * rd.magnitude); emitLightningPathParticle(lightningPS, rd.origin, 30); } } return(rd); }
public void Execute(int i_arrayIndex) { Entity octreeRayEntity = a_collisionChecksEntities [i_arrayIndex]; RayData rayData = new RayData() { ray = ray }; a_rayData [octreeRayEntity] = rayData; }
public void Execute(int i_arrayIndex) { Entity octreeRayEntity = a_collisionChecksEntities [i_arrayIndex]; // Its value should be 0, if no collision is detected. // And >= 1, if instance collision is detected, or there is more than one collision, // indicating number of collisions. IsCollidingData isCollidingData = a_isCollidingData [octreeRayEntity]; isCollidingData.i_collisionsCount = 0; // Reset colliding instances counter. // isCollidingData.i_nearestInstanceCollisionIndex = 0 ; // Unused // isCollidingData.f_nearestDistance = float.PositiveInfinity ; // Unused OctreeEntityPair4CollisionData octreeEntityPair4CollisionData = a_octreeEntityPair4CollisionData [octreeRayEntity]; RayData rayData = a_rayData [octreeRayEntity]; RayMaxDistanceData rayMaxDistanceData = a_rayMaxDistanceData [octreeRayEntity]; // Octree entity pair, for collision checks Entity octreeRootNodeEntity = octreeEntityPair4CollisionData.octree2CheckEntity; // Is target octree active if (a_isActiveTag.Exists(octreeRootNodeEntity)) { RootNodeData octreeRootNodeData = a_octreeRootNodeData [octreeRootNodeEntity]; DynamicBuffer <NodeBufferElement> a_nodesBuffer = nodeBufferElement [octreeRootNodeEntity]; DynamicBuffer <NodeInstancesIndexBufferElement> a_nodeInstancesIndexBuffer = nodeInstancesIndexBufferElement [octreeRootNodeEntity]; DynamicBuffer <NodeChildrenBufferElement> a_nodeChildrenBuffer = nodeChildrenBufferElement [octreeRootNodeEntity]; DynamicBuffer <InstanceBufferElement> a_instanceBuffer = instanceBufferElement [octreeRootNodeEntity]; // To even allow instances collision checks, octree must have at least one instance. if (octreeRootNodeData.i_totalInstancesCountInTree > 0) { if (IsRayColliding_Common._IsNodeColliding(octreeRootNodeData, octreeRootNodeData.i_rootNodeIndex, rayData.ray, ref isCollidingData, a_nodesBuffer, a_nodeChildrenBuffer, a_nodeInstancesIndexBuffer, a_instanceBuffer, rayMaxDistanceData.f)) { /* * // Debug * Debug.Log ( "Is colliding." ) ; */ } } } a_isCollidingData [octreeRayEntity] = isCollidingData; // Set back. }
public void renderFloor() { TextureDef tex = textures[0]; float obsX = -camera.x / camera.grid_x; float obsY = -camera.y / camera.grid_y; RayData leftAngles = ray_buffer[0]; RayData rightAngles = ray_buffer[ray_buffer.Length - 1]; for (int screenY = frame_buffer.height / 2; screenY < frame_buffer.height; screenY++) { Render.floor(frame_buffer, screenY, 1, obsX, obsY, leftAngles, rightAngles, default_texture.pixelBuffer); } }
public void DuplicateRay(int _index) { GameObject g = new GameObject("Ray " + (Rays.Count + 1)); g.transform.parent = transform; if (!StartPoint) { StartPoint = new GameObject("Start Point"); StartPoint.transform.parent = transform; StartPoint.transform.localPosition = new Vector3(0f, 0f, 0f); } if (!EndPoint) { EndPoint = new GameObject("EndPoint"); EndPoint.transform.parent = transform; EndPoint.transform.localPosition = new Vector3(10f, 0f, 0f); } if (!ControlPointOne) { ControlPointOne = new GameObject("ControlPointOne"); ControlPointOne.transform.parent = transform; ControlPointOne.transform.localPosition = new Vector3(2f, 4f, 0f); } if (!ControlPointTwo) { ControlPointTwo = new GameObject("ControlPointTwo"); ControlPointTwo.transform.parent = transform; ControlPointTwo.transform.localPosition = new Vector3(8f, 4f, 0f); } RayData rayData = new RayData(); rayData.faceMode = Rays[_index].faceMode; rayData.Steps = Rays[_index].Steps; rayData.AmplitudeMask = CopyAnimationCurve(Rays[_index].AmplitudeMask); rayData.Shape = CopyAnimationCurve(Rays[_index].Shape); rayData.WidthAmplitude = Rays[_index].WidthAmplitude; rayData.TextureSpeed = Rays[_index].TextureSpeed; rayData.DistortionSpeed = Rays[_index].DistortionSpeed; Material mat = new Material(Shader.Find("UltimateRayDesigner/Ray_Add")); mat.CopyPropertiesFromMaterial(Rays[_index].Mat); rayData.Mat = mat; rayData.RayHolder = g; Rays.Add(rayData); }
public static RaycastHit2D[] CircleCastAll(Vector2 origin, float radius, Vector2 direction, float distance, int layerMask, out RayData rayData) { rayData = new RayData(); List <RaycastHit2D> rayHits = new List <RaycastHit2D>(); RaycastHit2D[] rays = Physics2D.CircleCastAll(origin, radius, direction, distance, layerMask); for (int i = 0; i < rays.Length; i++) { RaycastHit2D rayHit = rays[i]; } return(rayHits.ToArray()); }
public void Execute([ReadOnly] ref RayEntityPair4CollisionData rayEntityPair4Collision) // public void Execute ( int i_arrayIndex ) { // Entity octreeEntity = a_collisionChecksEntities [i_arrayIndex] ; // RayEntityPair4CollisionData rayEntityPair4CollisionData = a_rayEntityPair4CollisionData [octreeEntity] ; Entity octreeRayEntity = rayEntityPair4Collision.ray2CheckEntity; RayData rayData = new RayData() { ray = ray }; a_rayData [octreeRayEntity] = rayData; }
private void UpdateRaycast(RayData rayData) { rayData.m_hit = Physics.Raycast(transform.position, rayData.m_direction, out _hit, _radius); if (rayData.m_hit) { rayData.m_hitCollider = _hit.collider; rayData.m_end = _hit.point; } else { rayData.m_hitCollider = null; rayData.m_end = rayData.m_start + rayData.m_direction * _radius; } }
private double IntersectTri(RayData ray, Vector3 tri1, Vector3 tri2, Vector3 tri3, out Vector3 normal) { Vector3 vec1Proj = tri2 - tri1; Vector3 vec2Proj = tri3 - tri2; Vector3 vec3Proj = tri1 - tri3; normal = vec1Proj.Cross(vec2Proj); double div = ray.Direction.Dot(normal); if (Math.Abs(div) < double.Epsilon) { return(-1); } double dist = (tri1 - ray.Origin).Dot(normal) / div; if (dist < 0 || dist > 1) { return(-1); } Vector3 posHitProj = ray.Origin + ray.Direction * dist; double uu = vec1Proj.Dot(vec1Proj); double uv = vec1Proj.Dot(vec2Proj); double vv = vec2Proj.Dot(vec2Proj); Vector3 w = posHitProj - tri1; double wu = w.Dot(vec1Proj); double wv = w.Dot(vec2Proj); double d = uv * uv - uu * vv; double s = (uv * wv - vv * wu) / d; if (s < 0 || s > 1.0) { return(-1); } double t = (uv * wu - uu * wv) / d; if (t < 0 || s + t > 1.0) { return(-1); } return(dist); }
static public void _DebugRays([ReadOnly] ref NativeArray <Entity> na_collisionChecksEntities, [ReadOnly] ref ComponentDataFromEntity <RayData> a_rayData, [ReadOnly] ref ComponentDataFromEntity <RayMaxDistanceData> a_rayMaxDistanceData, [ReadOnly] ref ComponentDataFromEntity <IsCollidingData> a_isCollidingData, [ReadOnly] ref ComponentDataFromEntity <RayEntityPair4CollisionData> a_rayEntityPair4CollisionData, bool canDebugAllChecks, bool canDebugAllrays) { // Debug all, or only one check int i_debugCollisionChecksCount = canDebugAllChecks ? na_collisionChecksEntities.Length : 1; // Debug // ! Ensure test this only with single, or at most few ray entiities. for (int i_collisionChecksIndex = 0; i_collisionChecksIndex < i_debugCollisionChecksCount; i_collisionChecksIndex++) { Entity octreeRayEntity = na_collisionChecksEntities [i_collisionChecksIndex]; Entity octreeRayEntity2; if (!a_rayData.Exists(octreeRayEntity)) { RayEntityPair4CollisionData rayEntityPair4CollisionData = a_rayEntityPair4CollisionData [octreeRayEntity]; octreeRayEntity2 = rayEntityPair4CollisionData.ray2CheckEntity; } else { octreeRayEntity2 = octreeRayEntity; } // Draw all available rays, or signle ray if (canDebugAllrays) { RayData rayData = a_rayData [octreeRayEntity2]; RayMaxDistanceData rayMaxDistanceData = a_rayMaxDistanceData [octreeRayEntity2]; Debug.DrawLine(rayData.ray.origin, rayData.ray.origin + rayData.ray.direction * rayMaxDistanceData.f, Color.red); } else if (i_collisionChecksIndex == 0) { RayData rayData = a_rayData [octreeRayEntity2]; RayMaxDistanceData rayMaxDistanceData = a_rayMaxDistanceData [octreeRayEntity2]; Debug.DrawLine(rayData.ray.origin, rayData.ray.origin + rayData.ray.direction * rayMaxDistanceData.f, Color.red); } IsCollidingData isCollidingData = a_isCollidingData [octreeRayEntity]; if (isCollidingData.i_collisionsCount > 0) { Debug.Log("Is colliding."); } } }
[BurstCompile(CompileSynchronously = true)] // note the lack of Fast-math; doesn't play nicely with NaNs static float FindTriangleIntersection(float3 *vertices, int *indices, int numTriangles, RayData *rayPtr) { RayData ray = *rayPtr; float minT = float.PositiveInfinity; for (int tri = 0; tri < numTriangles; tri++) { int idx0 = indices[3 * tri + 0]; int idx1 = indices[3 * tri + 1]; int idx2 = indices[3 * tri + 2]; float t = IntersectRayTriangle(ray, vertices[idx0], vertices[idx1], vertices[idx2]); minT = math.min(t, minT); } return(minT); }
private RayData[] GetOriginalDatas() { RayData[] rayDatas = new RayData[_divide + 1]; Vector3 center = transform.position; float startAngle = transform.eulerAngles.y - _angle / 2; float angle = _angle / _divide; RayData rayDataCache = null; for (int i = 0; i <= _divide; i++) { rayDataCache = new RayData(center, startAngle + angle * i, _radius); rayDatas[i] = rayDataCache; } return(rayDatas); }
public void Drive() { UpdateVisibility(); if (!_bShow) { return; } if (!_OVSDKCamera) { CreateOVSDKCamera(); } RayData raydata = GetOVSDKRay(); MyRayCast(raydata.index, raydata.device_index, raydata.ray); this.Proessdata(raydata.index, raydata.device_index); this.ProsseDrag(); }
private EdgeData GetApproximationEdge(RayData startEdgeRayData, RayData endEdgeRayData) { if (_approximationPrecision <= 0) { return(null); } Vector3 center = transform.position; float maxAngle = Vector3.Angle(startEdgeRayData.m_direction, endEdgeRayData.m_direction); float curAngle = _approximationPrecision; RayData edgeRayData = new RayData(center, startEdgeRayData.m_angle + _approximationPrecision, _radius); UpdateRaycast(edgeRayData); while (RayData.IsHittingSameObject(startEdgeRayData, edgeRayData)) { curAngle += _approximationPrecision; if (curAngle > maxAngle) { edgeRayData = null; break; } edgeRayData.UpdateDirection(_approximationPrecision); UpdateRaycast(edgeRayData); } if (edgeRayData == null) { return(null); } EdgeData edgeData = new EdgeData(); edgeData.m_secondRay = edgeRayData; edgeData.m_firstRay = new RayData(center, edgeRayData.m_angle - _approximationPrecision, _radius); UpdateRaycast(edgeData.m_firstRay); return(edgeData); }
/// <summary> /// Casts rays for given wall. Returns shortest partial vector for this wall. If no collision found - /// returns partial vector as long as the cast ray. /// </summary> /// <param name="currentVelocity"></param> /// <returns></returns> private Vector3 CastRaysForWall(RayData rayData) { float closestDistance = rayData.rayLength; foreach (var ray in _colliderRays) { RaycastHit hit; if (Physics.Raycast(ray, out hit, rayData.rayLength, _collisionLayerMask)) { if (hit.distance < closestDistance) { closestDistance = hit.distance; } } Debug.DrawRay(ray.origin, ray.direction * rayData.rayLength, Color.magenta); } return(rayData.normal * (closestDistance - _skinWidth)); }
// Update is called once per frame void Update() { Vector3 screenOrigin = transform.position + (0.5f) * height * cameraTransform.up + (-0.5f) * width * cameraTransform.right; float dx = width / renderTexture.width; float dy = height / renderTexture.height; screenOrigin = screenOrigin + 0.5f * dx * cameraTransform.right - 0.5f * dy * cameraTransform.up; for (int x = 0; x < renderTexture.width; x++) { for (int y = 0; y < renderTexture.height; y++) { Ray ray = new Ray(cameraTransform.position, (screenOrigin + x * dx * cameraTransform.right - y * dy * cameraTransform.up - cameraTransform.position).normalized ); RayData rayData = RaytracingUtils.Raycast(ray); if (rayData.hit) { Color color = rayData.color; Vector3 lightDirection = (light.transform.position - rayData.hitPosition).normalized; color = color * light.color * light.intensity * Vector3.Dot(lightDirection, rayData.normal); Render(x, y, color); } else { Render(x, y, backgroundColor); } } } UpdateRender(); }
public DirectionalColorData DirectionalColor(Vec3f start, Vec3f direction, int reflections) { Vec3f pos = start; for (int i = 0; i < MaxMarches; i++) { var objData = ClosestObject(pos); if (objData.Distance <= DistanceThreshold) { Vec3f normal = Gradient(pos); pos += 2f * DistanceThreshold * normal; var data = new RayData(pos, start, normal, objData.SDObj.Mat); ColorIntensity intensity = Lighting.RayIntensity(data); if (reflections > 0 && objData.SDObj.Mat.Specular > 0f) { Vec3f reflectionDir = direction - 2f * normal.Dot(direction) * normal; intensity += DirectionalColor(pos, reflectionDir, reflections - 1).Intensity *objData.SDObj.Mat.Specular; } return(new DirectionalColorData { Intensity = intensity }); } if ((pos - Cam.Pos).Magnitude > MaxRayDistance) { return(Lighting.Background.BackgroundColorData(direction)); } pos += direction * objData.Distance; } return(Lighting.Background.BackgroundColorData(direction)); }
private void OnDrawGizmos() { if (!_drawGizmo) { return; } Vector3 center = transform.position; RayData[] datas = GetRayDatas(); RayData cacheData = datas[0]; Handles.color = _gizmoColor; Handles.DrawSolidArc(center, transform.up, transform.forward, 360, _hitScale * 2); for (int i = 0; i < datas.Length; i++) { cacheData = datas[i]; Debug.DrawLine(center, cacheData.m_end, _gizmoColor); Handles.DrawSolidArc(cacheData.m_end, transform.up, transform.forward, 360, _hitScale); } }
private EdgeData GetBisectionEdge(RayData startEdgeRayData, RayData endEdgeRayData) { if (!startEdgeRayData.m_hit && !endEdgeRayData.m_hit) { return(GetApproximationEdge(startEdgeRayData, endEdgeRayData)); } if (RayData.IsHittingSameObject(startEdgeRayData, endEdgeRayData)) { return(null); } Vector3 center = transform.position; EdgeData edgeData = new EdgeData(); float angle = 0; RayData edgeRayData = null; for (int i = 0; i < _bisectionCount; i++) { angle = (startEdgeRayData.m_angle + endEdgeRayData.m_angle) / 2; edgeRayData = new RayData(center, angle, _radius); UpdateRaycast(edgeRayData); if (RayData.IsHittingSameObject(startEdgeRayData, edgeRayData)) { startEdgeRayData = edgeRayData; } else { endEdgeRayData = edgeRayData; } } edgeData.m_firstRay = startEdgeRayData; edgeData.m_secondRay = endEdgeRayData; return(edgeData); }
public abstract void GenerateLiRays(IRayEngineScene scene, Sample sample, ref RayData ray, VolumeComputation comp);