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);
