public override T Evaluate(DifferentialGeometry dg) { T t1 = _tex1.Evaluate(dg), t2 = _tex2.Evaluate(dg); var amt = _amount.Evaluate(dg); return(Operators.Add(Operators.Multiply(t1, (1f - amt)), Operators.Multiply(t2, amt))); }
public override Bsdf GetBsdf(DifferentialGeometry dgGeom, DifferentialGeometry dgShading) { // Allocate _BSDF_, possibly doing bump mapping with _bumpMap_ var dgs = (_bumpMap != null) ? Bump(_bumpMap, dgGeom, dgShading) : dgShading; var bsdf = new Bsdf(dgs, dgGeom.Normal); // Evaluate textures for _MatteMaterial_ material and allocate BRDF Spectrum r = Spectrum.Clamp(_kd.Evaluate(dgs)); float sig = MathUtility.Clamp(_sigma.Evaluate(dgs), 0.0f, 90.0f); if (!r.IsBlack) { if (sig == 0.0f) { bsdf.Add(new Lambertian(r)); } else { bsdf.Add(new OrenNayar(r, sig)); } } return(bsdf); }
public override bool Intersect(Ray r, Pointer<float> tHit, Pointer<float> rayEpsilon, Pointer<DifferentialGeometry> dg) { Ray ray = (WorldToObject)[r]; if (MathHelper.Abs(ray.Direction.Z) < 1e-7) return false; float thit = (Height - ray.Origin.Z) / ray.Direction.Z; if (thit < ray.MinT || thit > ray.MaxT) return false; Point phit = ray[thit]; float dist2 = phit.X * phit.X + phit.Y * phit.Y; if (dist2 > Radius * Radius || dist2 < InnerRadius * InnerRadius) return false; float phi = MathHelper.Atan2(phit.Y, phit.X); if (phi < 0) phi += 2.0f * MathHelper.PI; if (phi > PhiMax) return false; float u = phi / PhiMax; float oneMinusV = ((MathHelper.Sqrt(dist2) - InnerRadius) / (Radius - InnerRadius)); float invOneMinusV = (oneMinusV > 0.0f) ? (1.0f / oneMinusV) : 0.0f; float v = 1.0f - oneMinusV; Vector dpdu = new Vector(-PhiMax * phit.Y, PhiMax * phit.X, 0); Vector dpdv = new Vector(-phit.X * invOneMinusV, -phit.Y * invOneMinusV, 0); dpdu *= PhiMax * MathHelper.InvTwoPI; dpdv *= (Radius - InnerRadius) / Radius; Normal dndu = new Normal(0, 0, 0), dndv = new Normal(0, 0, 0); Transform o2w = ObjectToWorld; dg[0] = new DifferentialGeometry(o2w[phit], o2w[dpdu], o2w[dpdv], o2w[dndu], o2w[dndv], u, v, this); tHit[0] = thit; rayEpsilon[0] = 5e-4f * ~tHit; return true; }
public override bool Intersect(Ray ray, ref DifferentialGeometry dg) { float A = ray.d.x * ray.d.x + ray.d.y * ray.d.y + ray.d.z * ray.d.z; float B = 2 * (ray.d.x * ray.o.x + ray.d.y * ray.o.y + ray.d.z * ray.o.z); float C = ray.o.x * ray.o.x + ray.o.y * ray.o.y + ray.o.z * ray.o.z - radius * radius; float[] t; if (!LR.Quadratic(A, B, C, out t)) { return(false); } if (t[0] > ray.maxt || t[1] < ray.mint) { return(false); } float thit = t[0]; if (t[0] < ray.mint) { thit = t[1]; if (thit > ray.maxt) { return(false); } } return(true); }
public override bool Intersect(Ray r, Pointer<float> tHit, Pointer<float> rayEpsilon, Pointer<DifferentialGeometry> dg) { float phi; Point phit; Ray ray = (WorldToObject)[r]; float A = ray.Direction.X * ray.Direction.X + ray.Direction.Y * ray.Direction.Y; float B = 2 * (ray.Direction.X * ray.Origin.X + ray.Direction.Y * ray.Origin.Y); float C = ray.Origin.X * ray.Origin.X + ray.Origin.Y * ray.Origin.Y - Radius * Radius; float t0 = 0, t1 = 0; if (!MathHelper.Quadratic(A, B, C, ref t0, ref t1)) return false; if (t0 > ray.MaxT || t1 < ray.MinT) return false; float thit = t0; if (t0 < ray.MinT) { thit = t1; if (thit > ray.MaxT) return false; } phit = ray[thit]; phi = MathHelper.Atan2(phit.Y, phit.X); if (phi < 0) phi += 2.0f * MathHelper.PI; if (phit.Z < ZMin || phit.Z > ZMax || phi > PhiMax) { if (thit == t1) return false; thit = t1; if (t1 > ray.MaxT) return false; phit = ray[thit]; phi = MathHelper.Atan2(phit.Y, phit.X); if (phi < 0) phi += 2.0f * MathHelper.PI; if (phit.Z < ZMin || phit.Z > ZMax || phi > PhiMax) return false; } float u = phi / PhiMax; float v = (phit.Z - ZMin) / (ZMax - ZMin); Vector dpdu = new Vector(-PhiMax * phit.Y, PhiMax * phit.X, 0); Vector dpdv = new Vector(0, 0, ZMax - ZMin); Vector d2Pduu = -PhiMax * PhiMax * new Vector(phit.X, phit.Y, 0); Vector d2Pduv = new Vector(0, 0, 0), d2Pdvv = new Vector(0, 0, 0); float E = Vector.Dot(dpdu, dpdu); float F = Vector.Dot(dpdu, dpdv); float G = Vector.Dot(dpdv, dpdv); Vector N = Vector.Normalize(Vector.Cross(dpdu, dpdv)); float e = Vector.Dot(N, d2Pduu); float f = Vector.Dot(N, d2Pduv); float g = Vector.Dot(N, d2Pdvv); float invEGF2 = 1.0f / (E * G - F * F); Normal dndu = new Normal((f * F - e * G) * invEGF2 * dpdu + (e * F - f * E) * invEGF2 * dpdv); Normal dndv = new Normal((g * F - f * G) * invEGF2 * dpdu + (f * F - g * E) * invEGF2 * dpdv); Transform o2w = ObjectToWorld; dg[0] = new DifferentialGeometry(o2w[phit], o2w[dpdu], o2w[dpdv], o2w[dndu], o2w[dndv], u, v, this); tHit[0] = thit; rayEpsilon[0] = 5e-4f * ~tHit; return true; }
public Bsdf(DifferentialGeometry dgShading, Normal nGeom, float eta = 1.0f) { _dgShading = dgShading; _ng = nGeom; _eta = eta; _nn = dgShading.Normal; _sn = Vector.Normalize(dgShading.DpDu); _tn = Normal.Cross(_nn, _sn); _bxdfs = new List <Bxdf>(); }
public Intersection(DifferentialGeometry dg, Primitive primitive, Transform objectToWorld, Transform worldToObject, float rayEpsilon) { _dg = dg; _primitive = primitive; WorldToObject = worldToObject; ObjectToWorld = objectToWorld; _rayEpsilon = rayEpsilon; }
public override void Map(DifferentialGeometry dg, ref float s, ref float t, ref float dsdx, ref float dtdx, ref float dsdy, ref float dtdy) { s = _su * dg.U + _du; t = _sv * dg.V + _dv; dsdx = _su * dg.dudx; dtdx = _sv * dg.dvdx; dsdy = _su * dg.dudy; dtdy = _sv * dg.dvdy; }
protected static DifferentialGeometry Bump(Texture <float> d, DifferentialGeometry dgGeom, DifferentialGeometry dgs) { // Compute offset positions and evaluate displacement texture DifferentialGeometry dgEval = dgs; // Shift _dgEval_ _du_ in the $u$ direction float du = .5f * (Math.Abs(dgs.DuDx) + Math.Abs(dgs.DuDy)); if (du == 0.0f) { du = .01f; } dgEval.Point = dgs.Point + du * dgs.DpDu; dgEval.U = dgs.U + du; dgEval.Normal = Normal.Normalize((Normal)Vector.Cross(dgs.DpDu, dgs.DpDv) + du * dgs.DnDu); float uDisplace = d.Evaluate(dgEval); // Shift _dgEval_ _dv_ in the $v$ direction float dv = .5f * (Math.Abs(dgs.DvDx) + Math.Abs(dgs.DvDy)); if (dv == 0.0f) { dv = .01f; } dgEval.Point = dgs.Point + dv * dgs.DpDv; dgEval.U = dgs.U; dgEval.V = dgs.V + dv; dgEval.Normal = Normal.Normalize((Normal)Vector.Cross(dgs.DpDu, dgs.DpDv) + dv * dgs.DnDv); float vDisplace = d.Evaluate(dgEval); float displace = d.Evaluate(dgs); // Compute bump-mapped differential geometry var dgBump = dgs.Clone(); dgBump.DpDu = dgs.DpDu + (uDisplace - displace) / du * (Vector)dgs.Normal + displace * (Vector)dgs.DnDu; dgBump.DpDv = dgs.DpDv + (vDisplace - displace) / dv * (Vector)dgs.Normal + displace * (Vector)dgs.DnDv; dgBump.Normal = (Normal)Vector.Normalize(Vector.Cross(dgBump.DpDu, dgBump.DpDv)); if (dgs.Shape.ReverseOrientation ^ dgs.Shape.TransformSwapsHandedness) { dgBump.Normal *= -1.0f; } // Orient shading normal to match geometric normal dgBump.Normal = Normal.FaceForward(dgBump.Normal, dgGeom.Normal); return(dgBump); }
public override bool Intersect(Ray ray, ref DifferentialGeometry dg) { Point3 p1 = m.P[v[0]]; Point3 p2 = m.P[v[1]]; Point3 p3 = m.P[v[2]]; Vector e1 = p2 - p1; Vector e2 = p3 - p1; Vector s1 = LR.Cross(ray.d, e2); float divisor = LR.Dot(s1, e1); if (divisor == 0.0f) { return(false); } float invDivisor = 1.0f / divisor; // Compute first barycentric coordinate Vector s = ray.o - p1; float b1 = LR.Dot(s, s1) * invDivisor; if (b1 < 0.0f || b1 > 1.0f) { return(false); } // Compute second barycentric coordinate Vector s2 = LR.Cross(s, e1); float b2 = LR.Dot(ray.d, s2) * invDivisor; if (b2 < 0.0f || b1 + b2 > 1.0f) { return(false); } // Compute _t_ to intersection point float t = LR.Dot(e2, s2) * invDivisor; if (t < ray.mint || t > ray.maxt) { return(false); } return(false); }
public abstract Bssrdf GetBssrdf(DifferentialGeometry dg, Transform objectToWorld);
public abstract T Evaluate(DifferentialGeometry dg);
public override bool Intersect(Ray r, Pointer<float> tHit, Pointer<float> rayEpsilon, Pointer<DifferentialGeometry> dg) { float phi; Point phit = new Point(); Ray ray = (WorldToObject)[r]; float A = ray.Direction.X * ray.Direction.X + ray.Direction.Y * ray.Direction.Y + ray.Direction.Z * ray.Direction.Z; float B = 2 * (ray.Direction.X * ray.Origin.X + ray.Direction.Y * ray.Origin.Y + ray.Direction.Z * ray.Origin.Z); float C = ray.Origin.X * ray.Origin.X + ray.Origin.Y * ray.Origin.Y + ray.Origin.Z * ray.Origin.Z - Radius * Radius; float t0 = 0, t1 = 0; if (!MathHelper.Quadratic(A, B, C, ref t0, ref t1)) return false; if (t0 > ray.MaxT || t1 < ray.MinT) return false; float thit = t0; if (t0 < ray.MinT) { thit = t1; if (thit > ray.MaxT) return false; } phit = ray[thit]; if (phit.X == 0.0f && phit.Y == 0.0f) phit.X = 1e-5f * Radius; phi = MathHelper.Atan2(phit.Y, phit.X); if (phi < 0.0f) phi += 2.0f * MathHelper.PI; if ((zmin > -Radius && phit.Z < zmin) || (zmax < Radius && phit.Z > zmax) || phi > phiMax) { if (thit == t1) return false; if (t1 > ray.MaxT) return false; thit = t1; phit = ray[thit]; if (phit.X == 0.0f && phit.Y == 0.0f) phit.X = 1e-5f * Radius; phi = MathHelper.Atan2(phit.Y, phit.X); if (phi < 0.0f) phi += 2.0f * MathHelper.PI; if ((zmin > -Radius && phit.Z < zmin) || (zmax < Radius && phit.Z > zmax) || phi > phiMax) return false; } float u = phi / phiMax; float theta = MathHelper.Acos(MathHelper.Clamp(phit.Z / Radius, -1.0f, 1.0f)); float v = (theta - thetaMin) / (thetaMax - thetaMin); float zradius = MathHelper.Sqrt(phit.X * phit.X + phit.Y * phit.Y); float invzradius = 1.0f / zradius; float cosphi = phit.X * invzradius; float sinphi = phit.Y * invzradius; Vector dpdu = new Vector(-phiMax * phit.Y, phiMax * phit.X, 0); Vector dpdv = (thetaMax - thetaMin) * new Vector(phit.Z * cosphi, phit.Z * sinphi, -Radius * MathHelper.Sin(theta)); Vector d2Pduu = -phiMax * phiMax * new Vector(phit.X, phit.Y, 0); Vector d2Pduv = (thetaMax - thetaMin) * phit.Z * phiMax * new Vector(-sinphi, cosphi, 0.0f); Vector d2Pdvv = -(thetaMax - thetaMin) * (thetaMax - thetaMin) * new Vector(phit.X, phit.Y, phit.Z); float E = Vector.Dot(dpdu, dpdu); float F = Vector.Dot(dpdu, dpdv); float G = Vector.Dot(dpdv, dpdv); Vector N = Vector.Normalize(Vector.Cross(dpdu, dpdv)); float e = Vector.Dot(N, d2Pduu); float f = Vector.Dot(N, d2Pduv); float g = Vector.Dot(N, d2Pdvv); float invEGF2 = 1.0f / (E * G - F * F); Normal dndu = new Normal((f * F - e * G) * invEGF2 * dpdu + (e * F - f * E) * invEGF2 * dpdv); Normal dndv = new Normal((g * F - f * G) * invEGF2 * dpdu + (f * F - g * E) * invEGF2 * dpdv); Transform o2w = ObjectToWorld; dg[0] = new DifferentialGeometry(o2w[phit], o2w[dpdu], o2w[dpdv], o2w[dndu], o2w[dndv], u, v, this); tHit[0] = thit; rayEpsilon[0] = 5e-4f * ~tHit; return true; }
public override bool Intersect(Ray r, Pointer<float> tHit, Pointer<float> rayEpsilon, Pointer<DifferentialGeometry> dg) { float phi, v; Point phit; Ray ray = (WorldToObject)[r]; float A = a * ray.Direction.X * ray.Direction.X + a * ray.Direction.Y * ray.Direction.Y - c * ray.Direction.Z * ray.Direction.Z; float B = 2.0f * (a * ray.Direction.X * ray.Origin.X + a * ray.Direction.Y * ray.Origin.Y - c * ray.Direction.Z * ray.Origin.Z); float C = a * ray.Origin.X * ray.Origin.X + a * ray.Origin.Y * ray.Origin.Y - c * ray.Origin.Z * ray.Origin.Z - 1; float t0 = 0, t1 = 0; if (!MathHelper.Quadratic(A, B, C, ref t0, ref t1)) return false; if (t0 > ray.MaxT || t1 < ray.MinT) return false; float thit = t0; if (t0 < ray.MinT) { thit = t1; if (thit > ray.MaxT) return false; } phit = ray[thit]; v = (phit.Z - p1.Z) / (p2.Z - p1.Z); Point pr = (1.0f - v) * p1 + v * p2; phi = MathHelper.Atan2(pr.X * phit.Y - phit.X * pr.Y, phit.X * pr.X + phit.Y * pr.Y); if (phi < 0) phi += 2 * MathHelper.PI; if (phit.Z < zmin || phit.Z > zmax || phi > phiMax) { if (thit == t1) return false; thit = t1; if (t1 > ray.MaxT) return false; phit = ray[thit]; v = (phit.Z - p1.Z) / (p2.Z - p1.Z); Point pr2 = (1.0f - v) * p1 + v * p2; phi = MathHelper.Atan2(pr2.X * phit.Y - phit.X * pr2.Y, phit.X * pr2.X + phit.Y * pr2.Y); if (phi < 0) phi += 2 * MathHelper.PI; if (phit.Z < zmin || phit.Z > zmax || phi > phiMax) return false; } float u = phi / phiMax; float cosphi = MathHelper.Cos(phi), sinphi = MathHelper.Sin(phi); Vector dpdu = new Vector(-phiMax * phit.Y, phiMax * phit.X, 0); Vector dpdv = new Vector((p2.X - p1.X) * cosphi - (p2.Y - p1.Y) * sinphi, (p2.X - p1.X) * sinphi + (p2.Y - p1.Y) * cosphi, p2.Z - p1.Z); Vector d2Pduu = -phiMax * phiMax * new Vector(phit.X, phit.Y, 0); Vector d2Pduv = phiMax * new Vector(-dpdv.Y, dpdv.X, 0); Vector d2Pdvv = new Vector(0, 0, 0); float E = Vector.Dot(dpdu, dpdu); float F = Vector.Dot(dpdu, dpdv); float G = Vector.Dot(dpdv, dpdv); Vector N = Vector.Normalize(Vector.Cross(dpdu, dpdv)); float e = Vector.Dot(N, d2Pduu); float f = Vector.Dot(N, d2Pduv); float g = Vector.Dot(N, d2Pdvv); float invEGF2 = 1.0f / (E * G - F * F); Normal dndu = new Normal((f * F - e * G) * invEGF2 * dpdu + (e * F - f * E) * invEGF2 * dpdv); Normal dndv = new Normal((g * F - f * G) * invEGF2 * dpdu + (f * F - g * E) * invEGF2 * dpdv); Transform o2w = ObjectToWorld; dg[0] = new DifferentialGeometry(o2w[phit], o2w[dpdu], o2w[dpdv], o2w[dndu], o2w[dndv], u, v, this); tHit[0] = thit; rayEpsilon[0] = 5e-4f * tHit; return true; }
public override Bssrdf GetBssrdf(DifferentialGeometry dg, Transform objectToWorld) { var dgs = _shape.GetShadingGeometry(objectToWorld, dg); return(_material.GetBssrdf(dg, dgs)); }
public abstract Bsdf GetBsdf(DifferentialGeometry dgGeom, DifferentialGeometry dgShading);
public override void GetShadingGeometry(Transform obj2world, DifferentialGeometry dg, Pointer<DifferentialGeometry> dgShading) { if (mesh.n == null && mesh.s == null) { dgShading[0] = dg; return; } float[] b = new float[3]; float[][] uv = new float[3][]; uv[0] = new float[2]; uv[1] = new float[2]; uv[2] = new float[2]; GetUVs(uv); float[][] A = { new float[2] { uv[1][0] - uv[0][0], uv[2][0] - uv[0][0] }, new float[2] { uv[1][1] - uv[0][1], uv[2][1] - uv[0][1] } }; float[] C = { dg.u - uv[0][0], dg.v - uv[0][1] }; if (!Transform.SolveLinearSystem2x2(A, C, ref b[1], ref b[2])) { b[0] = b[1] = b[2] = 1.0f / 3.0f; } else b[0] = 1.0f - b[1] - b[2]; Normal ns; Vector ss, ts; if (mesh.n != null) ns = Normal.Normalize(obj2world[b[0] * mesh.n[v[0]] + b[1] * mesh.n[v[1]] + b[2] * mesh.n[v[2]]]); else ns = dg.nn; if (mesh.s != null) ss = Vector.Normalize(obj2world[b[0] * mesh.s[v[0]] + b[1] * mesh.s[v[1]] + b[2] * mesh.s[v[2]]]); else ss = Vector.Normalize(dg.dpdu); ts = Vector.Cross(ss, ns); if (ts.SquaredMagnitude > 0.0f) { ts = Vector.Normalize(ts); ss = Vector.Cross(ts, ns); } else Extensions.CoordinateSystem((Vector)ns, out ss, out ts); Normal dndu, dndv; if (mesh.n != null) { float[][] uvs = new float[3][]; uvs[0] = new float[2]; uvs[1] = new float[2]; uvs[2] = new float[2]; GetUVs(uvs); float du1 = uvs[0][0] - uvs[2][0]; float du2 = uvs[1][0] - uvs[2][0]; float dv1 = uvs[0][1] - uvs[2][1]; float dv2 = uvs[1][1] - uvs[2][1]; Normal dn1 = mesh.n[v[0]] - mesh.n[v[2]]; Normal dn2 = mesh.n[v[1]] - mesh.n[v[2]]; float determinant = du1 * dv2 - dv1 * du2; if (determinant == 0.0f) dndu = dndv = new Normal(0, 0, 0); else { float invdet = 1.0f / determinant; dndu = ((dv2 * dn1 - dv1 * dn2) * invdet); dndv = ((-du2 * dn1 + du1 * dn2) * invdet); } } else dndu = dndv = new Normal(0, 0, 0); dgShading[0] = new DifferentialGeometry(dg.p, ss, ts, (ObjectToWorld)[dndu], (ObjectToWorld)[dndv], dg.u, dg.v, dg.shape); dgShading[0].Setdudx(dg.dudx); dgShading[0].Setdvdx(dg.dvdx); dgShading[0].Setdudy(dg.dudy); dgShading[0].Setdvdy(dg.dvdy); dgShading[0].Setdpdx(dg.dpdx); dgShading[0].Setdpdy(dg.dpdy); }
public override TU Evaluate(DifferentialGeometry dg) { return(Operators.Multiply(_tex2.Evaluate(dg), _tex1.Evaluate(dg))); }
public override Bssrdf GetBssrdf(DifferentialGeometry dg, Transform objectToWorld) { throw new InvalidOperationException("Aggregate.GetBssrdf() method called; should have gone to GeometricPrimitive."); }
public virtual void GetShadingGeometry(Transform obj2world, DifferentialGeometry dg, Pointer<DifferentialGeometry> dgShading) { dgShading[0] = dg; }
public virtual Bssrdf GetBssrdf(DifferentialGeometry dgGeom, DifferentialGeometry dgShading) { return(null); }
public abstract void Map(DifferentialGeometry dg, ref float s, ref float t, ref float dsdx, ref float dtdx, ref float dsdy, ref float dtdy);
public override bool IntersectP(Ray ray) { Point p1 = mesh.p[v[0]]; Point p2 = mesh.p[v[1]]; Point p3 = mesh.p[v[2]]; Vector e1 = p2 - p1; Vector e2 = p3 - p1; Vector s1 = Vector.Cross(ray.Direction, e2); float divisor = Vector.Dot(s1, e1); if (divisor == 0.0f) return false; float invDivisor = 1.0f / divisor; Vector d = ray.Origin - p1; float b1 = Vector.Dot(d, s1) * invDivisor; if (b1 < 0 || b1 > 1) return false; Vector s2 = Vector.Cross(d, e1); float b2 = Vector.Dot(ray.Direction, s2) * invDivisor; if (b2 < 0 || b1 + b2 > 1) return false; float t = Vector.Dot(e2, s2) * invDivisor; if (t < ray.MinT || t > ray.MaxT) return false; if (ray.Depth != -1 && mesh.alphaTexture != null) { Vector dpdu, dpdv; float[][] uvs = new float[3][]; uvs[0] = new float[2]; uvs[1] = new float[2]; uvs[2] = new float[2]; GetUVs(uvs); float du1 = uvs[0][0] - uvs[2][0]; float du2 = uvs[1][0] - uvs[2][0]; float dv1 = uvs[0][1] - uvs[2][1]; float dv2 = uvs[1][1] - uvs[2][1]; Vector dp1 = p1 - p3, dp2 = p2 - p3; float determinant = du1 * dv2 - dv1 * du2; if (determinant == 0.0f) { Extensions.CoordinateSystem(Vector.Normalize(Vector.Cross(e2, e1)), out dpdu, out dpdv); } else { float invdet = 1.0f / determinant; dpdu = (dv2 * dp1 - dv1 * dp2) * invdet; dpdv = (-du2 * dp1 + du1 * dp2) * invdet; } float b0 = 1 - b1 - b2; float tu = b0 * uvs[0][0] + b1 * uvs[1][0] + b2 * uvs[2][0]; float tv = b0 * uvs[0][1] + b1 * uvs[1][1] + b2 * uvs[2][1]; DifferentialGeometry dgLocal = new DifferentialGeometry(ray[t], dpdu, dpdv, new Normal(0,0,0), new Normal(0,0,0), tu, tv, this); if (mesh.alphaTexture.Evaluate(dgLocal) == 0.0f) return false; } return true; }
public override Bssrdf GetBssrdf(DifferentialGeometry dg, Transform objectToWorld) { return(null); }
public override T Evaluate(DifferentialGeometry dg) { return(_value); }