public PBRRay(PBRPoint3 p, PBRVector3 d, float tm = float.PositiveInfinity, float rt = 0.0f)
{
_origin = new PBRPoint3(p);
_direction = new PBRVector3(d);
_tMax = tm;
_rTime = rt;
}
public void ScaleDifferential(float s)
{
rxOrigin = _origin + (rxOrigin - _origin) * s;
ryOrigin = _origin + (ryOrigin - _origin) * s;
rxDirection = _direction + (rxDirection - _direction) * s;
ryDirection = _direction + (ryDirection - _direction) * s;
}
public PBRRay(PBRRay r)
{
_origin = new PBRPoint3(r.Origin);
_direction = new PBRVector3(r.Direction);
_tMax = r.TMax;
_rTime = r.RTime;
}
public PBRRay()
{
_origin = new PBRPoint3();
_direction = new PBRVector3();
_tMax = float.PositiveInfinity;
_rTime = 0.0f;
}
public Interaction(PBRPoint3 po, PBRNormals normal, PBRVector3 err, PBRVector3 w, float t)
{
_time = t;
_normal = new PBRNormals(normal);
_oError = new PBRVector3(err);
wo = new PBRVector3(w);
_p = new PBRPoint3(po);
}
public bool Equals(object obj)
{
if (obj is PBRVector3)
{
PBRVector3 v = (PBRVector3)obj;
return(this._x == v.X && this._y == v.Y && this._z == v.Z);
}
return(false);
}
public PBRTransform LookAt(PBRPoint3 pos, PBRPoint3 look, PBRVector3 up)
{
Matrix4x4 cameraToWorld = new Matrix4x4();
cameraToWorld.M[0, 3] = pos.X;
cameraToWorld.M[1, 3] = pos.Y;
cameraToWorld.M[2, 3] = pos.Z;
cameraToWorld.M[2, 3] = 1;
return(null);
}
public void CoordSystem(PBRVector3 v1, out PBRVector3 v2, out PBRVector3 v3)
{
if (Math.Abs(v1.X) > Math.Abs(v1.Y))
{
v2 = new PBRVector3(-v1.Z, 0, v1.X) / (float)Math.Sqrt(v1.X * v1.X + v1.Z * v1.Z);
}
else
{
v2 = new PBRVector3(0, v1.Z, -v1.Y) / (float)Math.Sqrt(v1.Y * v1.Y + v1.Z * v1.Z);
}
v3 = Cross(v1, v2);
}
public static PBRTransform Translate(PBRVector3 delta)
{
Matrix4x4 m = new Matrix4x4(1, 0, 0, delta.X,
0, 1, 0, delta.Y,
0, 0, 1, delta.Z,
0, 0, 0, 1);
Matrix4x4 invM = new Matrix4x4(1, 0, 0, -delta.X,
0, 1, 0, -delta.Y,
0, 0, 1, -delta.Z,
0, 0, 0, 1);
return(new PBRTransform(m, invM));
}
public int MaximumExtent()
{
PBRVector3 d = Diagonal();
if (d.X > d.Y && d.X > d.Z)
{
return(0);
}
else if (d.Y > d.Z)
{
return(1);
}
else
{
return(2);
}
}
public PBRVector3 Offset(PBRPoint3 p)
{
PBRVector3 o = p - _pMin;
if (_pMax.X > _pMin.X)
{
p.X /= _pMax.X - _pMin.X;
}
if (_pMax.Y > _pMin.Y)
{
p.Y /= _pMax.Y - _pMin.Y;
}
if (_pMax.Z > _pMin.Z)
{
p.Z /= _pMax.Z - _pMin.Z;
}
return(o);
}
public PBRRayDifferential(PBRPoint3 p, PBRVector3 d, float tMax = float.PositiveInfinity, float pTime = 0.0f) : base(p, d, tMax, pTime)
{
_hasDifferentials = false;
}
public static float Dot(PBRVector3 a, PBRVector3 b)
{
return(a.X * b.X + a.Y * b.Y + a.Z / b.Z);
}
public PBRVector3(PBRVector3 v) : base(v)
{
}
public float SurfaceArea()
{
PBRVector3 d = Diagonal();
return(2 * (d.X * d.Y + d.X * d.Z + d.Y * d.Z));
}
public float Volume()
{
PBRVector3 d = Diagonal();
return(d.X * d.Y * d.Z);
}
public static float AbsDot(PBRVector3 a, PBRVector3 b)
{
return(Math.Abs(a.X * b.X + a.Y * b.Y + a.Z + b.Z));
}
public static PBRVector3 Cross(PBRVector3 a, PBRVector3 b)
{
return(new PBRVector3(a.Y * b.Z - a.Z * b.Y,
a.Z * b.X - a.X * b.Z,
a.X * b.Y - a.Y * b.X));
}
public PBRPoint3(PBRVector3 p) : base(p)
{
}
