//Setters for lambertian paramaters /* public void setKa(float ka) { ambientBRDF.DiffuseReflectionCoefficient = ka; } public void setKd(float kd) { diffuseBRDF.DiffuseReflectionCoefficient = kd; } public void setCd(RGBColor c) { ambientBRDF.ColorDiffuse = c; diffuseBRDF.ColorDiffuse = c; } public void setCd(Texture tex) { ambientBRDF.Texture = tex; diffuseBRDF.Texture = tex; } */ public override RGBColor Shade(ShadeRec sr) { Vect3D reflectedDirection = -sr.Ray.Direction; RGBColor L = ambientBRDF.Rho(sr, reflectedDirection) * sr.WorldPointer.AmbientLight.GetLighting(sr); int numLights = sr.WorldPointer.LightList.Count; Vect3D incomingDirection; float nDotWi; bool inShadow; Ray shadowRay; //float t = GlobalVars.kHugeValue; //Loop through list of lights and add radiance for each diffuse light source. for(int i = 0; i < numLights; i++) { incomingDirection = sr.WorldPointer.LightList[i].GetDirection(sr); nDotWi = sr.Normal * incomingDirection; //Direction must not be 0,0,0 to be a diffuse light source. if(nDotWi > 0.0) { inShadow = false; if(sr.WorldPointer.LightList[i].CastsShadows) { shadowRay = new Ray(sr.HitPoint + (GlobalVars.SHAD_K_EPSILON * incomingDirection), incomingDirection); inShadow = sr.WorldPointer.LightList[i].InShadow(sr, shadowRay); } if(!inShadow) { L += diffuseBRDF.F(sr, reflectedDirection, incomingDirection) * sr.WorldPointer.LightList[i].GetLighting(sr) * nDotWi; } } } return L; }
public override Vec3 SampleF(ShadeRec sr, ref Vec3 wr, Vec3 wo) { float ndotwo = (float)sr.Normal.Dot(wo); wr = (wo * -1) + 2.0 * sr.Normal * ndotwo; return(Fresnel(sr) * ColorUtils.WHITE / Math.Abs(sr.Normal.Dot(wr))); }
public override Vector3 Sample_F(ShadeRec sr, Vector3 wo, ref Vector3 wi, ref float pdf) { float ndotwo = Vector3.Dot(sr.Normal, wo); wi = -wo + 2.0f * sr.Normal * ndotwo; pdf = Vector3.AbsDot(sr.Normal, wi); return(kr * cr.GetColor(sr)); }
public override bool Hit(Ray ray, ref float tmin, ref ShadeRec sr) { if (bbox.Hit(ray)) { return(base.Hit(ray, ref tmin, ref sr)); } return(false); }
public override Vector3 ShadeAreaLight(ShadeRec sr) { return(m_ce * m_ls); //if (sr.normal.Nor().Dot(sr.ray.dir.Nor()) < 0f) // return m_fcolor; //else // return ColourF.Black; }
//public void SetTopMaterial(Material material) //{ // objects[0].Material = material; //} //public void SeTopBorderMaterial(Material material) //{ // objects[1].Material = material; //} //public void SetWallMaterial(Material material) //{ // objects[1].Material = material; //} //public void SetBottomBorderMaterial(Material material) //{ // objects[2].Material = material; //} //public void SetBottomMaterial(Material material) //{ // objects[2].Material = material; //} public override bool Hit(Ray ray, ref double tmin, ShadeRec sr) { if (bbox.Hit(ray)) { return(base.Hit(ray, ref tmin, sr)); } return(false); }
public override Vec3 SampleF(ShadeRec sr, ref Vec3 wi, Vec3 wo, ref float pdf) { float ndotwo = (float)sr.Normal.Dot(wo); Vec3 r = (wo * -1) + 2.0 * sr.Normal * ndotwo; pdf = (float)Math.Abs(sr.Normal.Dot(wi)); return(kr * cr); }
public override Vec3 GetDirection(ShadeRec sr) { samplePoint = obj.Sample(); normal = obj.GetNormal(samplePoint); wi = samplePoint - sr.HitPoint; wi.Normalize(); return(wi); }
public override Vector3 Path_Shade(ShadeRec sr) { Vector3 wo = -sr.Ray.Direction; Vector3 wi = Vector3.Zero(); Vector3 f = diffuse.Sample_F(sr, wo, ref wi); float ndotwi = Vector3.Dot(sr.Normal, wi); Ray reflected_ray = new Ray(sr.HitPoint, wi); return(f * sr.World.Tracer.TraceRay(reflected_ray, sr.Depth + 1) * ndotwi); }
public override Vector3 GetDirection(ShadeRec sr) { float r = Radius; Vector3 new_location = Vector3.Zero(); new_location.X = Location.X + r * (2.0f * MathUtil.RandomFloat() - 1.0f); new_location.Y = Location.Y + r * (2.0f * MathUtil.RandomFloat() - 1.0f); new_location.Z = Location.Z + r * (2.0f * MathUtil.RandomFloat() - 1.0f); return(Vector3.Normalize(new_location - sr.LocalHitPoint)); }
public override Vector3 Path_Shade(ShadeRec sr) { Vector3 wo = -sr.Ray.Direction; Vector3 wi = Vector3.Zero(); float pdf = 0; Vector3 fr = reflective.Sample_F(sr, wo, ref wi, ref pdf); Ray reflected_ray = new Ray(sr.HitPoint, wi); return(fr * sr.World.Tracer.TraceRay(reflected_ray, sr.Depth + 1) * (sr.Normal * wi) / pdf); }
public override RGBColor TraceRay(Ray ray, int depth) { ShadeRec shadeRec = world.IntersectAllObjects(ray); if (shadeRec.HasHitObject) { return(shadeRec.Color); } return(world.BackgroundColor); }
public override Vector3 GetDirection(ShadeRec sr) { Vector3 finaldir = Vector3.Zero(); finaldir.X = Direction.X + r * (2.0f * MathUtil.RandomFloat() - 1.0f); finaldir.Y = Direction.Y + r * (2.0f * MathUtil.RandomFloat() - 1.0f); finaldir.Z = Direction.Z + r * (2.0f * MathUtil.RandomFloat() - 1.0f); finaldir.Normalize(); return(finaldir); }
public Vec3 PathShade(ShadeRec sr) { Vec3 wo = sr.Ray.D * -1; Vec3 wi = null; float pdf = 0.0f; Vec3 f = diffuse.SampleF(sr, ref wi, wo, ref pdf); Ray reflectedRay = new Ray(sr.HitPoint, wi); return(f * sr.World.Tracer.TraceRay(reflectedRay, sr.Depth + 1) * sr.Normal.Dot(wi) / pdf); }
public override Vector3 Area_Light_Shade(ShadeRec sr) { if (Vector3.Dot(-sr.Normal, sr.Ray.Direction) > 0.0f) //here may be ConcaveSphere not support { return(Radiance * Color); } else { return(Vector3.Zero); } }
public override Vector3 GetDirection(ShadeRec sr) { w = sr.Normal; v = Vector3.Cross(new Vector3(0.0034f, 1, 0.0071f), w); v.Normalize(); u = Vector3.Cross(v, w); Vector3 sp = sampler.SampleHemisphere(); wi = sp.X * u + sp.Y * v + sp.Z * w; return(wi); }
public override Vector3 Global_Shade(ShadeRec sr) { if (sr.Depth == 1) { return(Vector3.Zero); } else { return(ls * t.GetColor(sr)); } }
public override Vector3 Path_Shade(ShadeRec sr) { if (Vector3.Dot(-sr.Normal, sr.Ray.Direction) > 0.0f) { return(Radiance * Color); } else { return(Vector3.Zero()); } }
public override Vector3 GetDirection(ShadeRec sr) { Vector3 w = sr.normal.Nor(); Vector3 v = w.Cross(Vector3.UpJitted).Nor(); //use Jitted Up vector avoid w parallels to vec3.up; Vector3 u = v.Cross(w).Nor(); Vector3 sp = m_sampler.SampleHemisphere(); Vector3 dir = sp.x * u + sp.y * v + sp.z * w; return(dir.Nor()); }
private SColor NormalMap(Ray ray, HitableList hitableList) { ShadeRec record = new ShadeRec(); if (hitableList.Hit(ray, 0.0, double.MaxValue, ref record)) { return(0.5 * new SColor(record.normal.X + 1, record.normal.Y + 1, record.normal.Z + 1, 2.0)); } double t = 0.5 * ray.normalDirection.Y + 1.0; return((1 - t) * new SColor(1, 1, 1) + t * new SColor(0.5, 0.7, 1)); }
public override Vector3 Area_Light_Shade(ShadeRec sr) { Vector3 L = base.Shade(sr); Vector3 wo = -sr.Ray.Direction; Vector3 wi = Vector3.Zero(); Vector3 fr = reflective.Sample_F(sr, wo, ref wi); Ray reflected_ray = new Ray(sr.HitPoint, wi); reflected_ray.Depth = sr.Depth + 1; L += fr * sr.World.Tracer.TraceRay(reflected_ray, sr.Depth + 1) * (sr.Normal * wi); return(L); }
public override Vector3 L(ShadeRec sr) { //falloff float falloff = (m_pos - sr.localHitPoint).length; falloff = falloff > m_range ? m_range : falloff; falloff = falloff / m_range; float t = 1f - falloff * falloff; return(m_atten * m_color); }
public override Vector3 Area_Light_Shade(ShadeRec sr) { Vector3 L = (base.Area_Light_Shade(sr)); Vector3 wo = (-sr.Ray.Direction); Vector3 wi = Vector3.Zero(); float pdf = 0; Vector3 fr = (glossy_specular.Sample_F(sr, wo, ref wi, ref pdf)); Ray reflected_ray = new Ray(sr.HitPoint, wi); L += fr * sr.World.Tracer.TraceRay(reflected_ray, sr.Depth + 1) * (Vector3.Dot(sr.Normal, wi)) / pdf; return(L); }
public override Vector3 GetColor(ShadeRec sr) { Vector3 hit_point = sr.LocalHitPoint; Vector3 offset = noise_ptr.vector_fbm(hit_point * ring_noise_frequency); Vector3 ring_point = hit_point + ring_noise * offset; Vector3 temp_vec = trunk_wobble * noise_ptr.vector_noise(new Vector3(0, 0, hit_point.Y * trunk_wobble_frequency)); ring_point.X += temp_vec.X; ring_point.Z += temp_vec.X; float r = MathUtil.Sqrt(ring_point.X * ring_point.X + ring_point.Z * ring_point.Z) * ring_frequency; Vector3 temp_vec2 = Vector3.Zero(); temp_vec2.X = angular_wobble_frequency * ring_point.X; temp_vec2.Y = angular_wobble_frequency * ring_point.Y * 0.1f; temp_vec2.Z = angular_wobble_frequency * ring_point.Z; float delta_r = angular_wobble * MathUtil.SmoothStep(0.0f, 5.0f, r) * noise_ptr.value_noise(temp_vec2); r += delta_r; r += ring_uneveness * noise_ptr.value_noise(new Vector3(r)); float temp = r; float in_ring = MathUtil.SmoothPulseTrain(0.1f, 0.55f, 0.7f, 0.95f, 1.0f, r); Vector3 grain_point = Vector3.Zero(); grain_point.X = hit_point.X * grain_frequency; grain_point.Y = hit_point.Y * grain_frequency * 0.05f; grain_point.Z = hit_point.Z * grain_frequency; float dpgrain = 0.2f; float grain = 0.0f; float amplitude = 1.0f; for (int i = 0; i < 2; i++) { float grain_valid = 1.0f - MathUtil.SmoothStep(0.2f, 0.6f, dpgrain); if (grain_valid > 0.0f) { float g = grain_valid * noise_ptr.value_noise(grain_point); g *= (0.3f + 0.7f * in_ring); g = MathUtil.Pow(MathUtil.Clamp(0.8f - g, 0.0f, 1.0f), 2.0f); g = grainy * MathUtil.SmoothStep(0.5f, 1.0f, g); if (i == 0) { in_ring *= (1.0f - 0.4f * grain_valid); } grain = amplitude * MathUtil.Max(grain, g); } grain_point = 2.0f * grain_point; dpgrain *= 2.0f; amplitude *= 0.5f; } float final_value = MathUtil.MixFloat(in_ring * ringy, 1.0f, grain); return(MathUtil.MixColor(light_color, dark_color, final_value)); }
public bool TIR(ShadeRec sr) { Vector3 wo = (-sr.Ray.Direction); float cos_thetai = Vector3.Dot(sr.Normal, wo); float eta = eta_in / eta_out; if (cos_thetai < 0.0) { eta = 1.0f / eta; } return(1.0f - (1.0f - cos_thetai * cos_thetai) / (eta * eta) < 0.0f); }
public override RGBColor F(ShadeRec shadeRec, Vector3d wi, Vector3d wo) { RGBColor L = new RGBColor(); double NdotWi = Vector3d.Dot(shadeRec.Normal, wi); Vector3d r = (-wi + (Vector3d)shadeRec.Normal * NdotWi * 2); double RdotWo = Vector3d.Dot(r, wo); if (RdotWo > 0) { L = CS*KS*Math.Pow(RdotWo, Exp); } return L; }
public override bool Hit(Ray ray, ref double tmin, ShadeRec sr) { Vec3 v0 = Mesh.Vertices[Index0]; Vec3 v1 = Mesh.Vertices[Index1]; Vec3 v2 = Mesh.Vertices[Index2]; double a = v0.X - v1.X, b = v0.X - v2.X, c = ray.D.X, d = v0.X - ray.O.X; double e = v0.Y - v1.Y, f = v0.Y - v2.Y, g = ray.D.Y, h = v0.Y - ray.O.Y; double i = v0.Z - v1.Z, j = v0.Z - v2.Z, k = ray.D.Z, l = v0.Z - ray.O.Z; double m = f * k - g * j, n = h * k - g * l, p = f * l - h * j; double q = g * i - e * k, s = e * j - f * i; double invDenom = 1.0 / (a * m + b * q + c * s); double e1 = d * m - b * n - c * p; double beta = e1 * invDenom; if (beta < 0.0 || beta > 1.0) { return(false); } double r = e * l - h * i; double e2 = a * n + d * q + c * r; double gamma = e2 * invDenom; if (gamma < 0.0 || gamma > 1.0) { return(false); } if (beta + gamma > 1.0) { return(false); } double e3 = a * p - b * r + d * s; double t = e3 * invDenom; if (t < kEpsilin) { return(false); } tmin = t; sr.Normal = Normal; sr.LocalHitPoint = ray.HitPoint(t); sr.U = InterpolateU(beta, gamma); sr.V = InterpolateV(beta, gamma); return(true); }
public override Vector3 L(ShadeRec sr) { if (!DistanceAttenuation) { return(Radiance * Color); } else { float d = Vector3.Distance(sr.HitPoint, (Location)); return(Radiance * Color / (d * d)); } }
public override bool Hit(Ray r, ref float tmin, ref ShadeRec sr) { Point3D p0 = parent.vertices[index0]; Point3D p1 = parent.vertices[index1]; Point3D p2 = parent.vertices[index2]; //solve with cramer's rule float a = p0.X - p1.X; float b = p0.X - p2.X; float c = r.Direction.X; float d = p0.X - r.Origin.X; float e = p0.Y - p1.Y; float f = p0.Y - p2.Y; float g = r.Direction.Y; float h = p0.Y - r.Origin.Y; float i = p0.Z - p1.Z; float j = p0.Z - p2.Z; float k = r.Direction.Z; float l = p0.Z - r.Origin.Z; float m = f * k - g * j; float n = h * k - g * l; float p = f * l - h * j; float q = g * i - e * k; float s = e * j - f * i; float inverseDenominator = 1.0f / (a * m + b * q + c * s); float beta = inverseDenominator * (d * m - b * n - c * p); if (beta < 0.0) return false; float rd = e * l - h * i; float gamma = inverseDenominator * (a * n + d * q + c * rd); if (gamma < 0.0) return false; if (beta + gamma > 1.0) return false; //Hit! float t = inverseDenominator * (a * p - b * rd + d * s); if (t < GlobalVars.K_EPSILON) return false; tmin = t; sr.Normal = InterpolateNormal(beta, gamma); sr.HitPointLocal = r.Origin + t * r.Direction; return true; }
public override bool Hit(Ray ray, ref float tmin, ref ShadeRec sr) { float t = Vector3.Dot((Center - ray.Position), Normal) / Vector3.Dot(ray.Direction, Normal); if (t > MathUtil.Epsilon) { tmin = t; sr.Normal = Normal; sr.LocalHitPoint = ray.Position + t * ray.Direction; return(true); } return(false); }
public override Vector3 L(ShadeRec sr) { float ndotd = Vector3.Dot(-light_normal, wi); if (ndotd > 0.0) { return(Material.Get_Le(sr)); } else { return(new Vector3()); } }
public override Vector3 Sample_F(ShadeRec sr, Vector3 wo, ref Vector3 wi) { Vector3 w = sr.Normal; Vector3 v = Vector3.Cross(new Vector3(0.0034f, 1, 0.0071f), w); v.Normalize(); Vector3 u = Vector3.Cross(v, w); Vector3 sp = Sampler.SampleHemisphere(); wi = sp.X * u + sp.Y * v + sp.Z * w; wi.Normalize(); return(ReflectionCoefficient * Texture.GetColor(sr) * MathUtil.InvPI); }
public override Vector3 L(ShadeRec sr) { float nDotD = (-m_lightNormal).Dot(m_wi); if (nDotD > 0f) { return(m_material.Shade(sr)); } else { return(ColourF.Black); } }
public override RGBColor Shade(ShadeRec sr) { RGBColor L = base.Shade(sr); //Factor in all direct illumination Vect3D reflectedDirection = -sr.Ray.Direction; //Vector pointing towards camera Vect3D perfectReflection = new Vect3D(1.0f,1.0f,1.0f); //Vector equivalent to perfect reflection RGBColor fr = reflectiveBRDF.SampleF(sr, ref perfectReflection, ref reflectedDirection); //Set vectors for reflection to correct values Point3D hitPoint = sr.HitPoint + (perfectReflection * GlobalVars.SHAD_K_EPSILON); //Avoid salt+pepper noise Ray reflectedRay = new Ray(hitPoint, perfectReflection); //Cast ray from point of incidence L += fr * sr.WorldPointer.CurrentTracer.TraceRay(reflectedRay, sr.RecursionDepth + 1) * (sr.Normal * perfectReflection); //Recurse! return L; }
public override RGBColor TraceRay(Ray ray, int depth) { ShadeRec shadeRec = new ShadeRec(world); //not used double t; // not used if (world.Sphere.Intersect(ray, out t, shadeRec)) { return new RGBColor(1, 0, 0); } else { return new RGBColor(0, 0, 0); } }
//Copy constructor public ShadeRec(ShadeRec shadeRec) { HitAnObject = shadeRec.HitAnObject; ObjectMaterial = shadeRec.ObjectMaterial; HitPoint = shadeRec.HitPoint; HitPointLocal = shadeRec.HitPointLocal; Normal = shadeRec.Normal; Color = shadeRec.Color; WorldPointer = shadeRec.WorldPointer; Ray = shadeRec.Ray; RecursionDepth = shadeRec.RecursionDepth; Direction = shadeRec.Direction; TMinimum = shadeRec.TMinimum; U = shadeRec.U; V = shadeRec.V; }
public override RGBColor TraceRay(Ray ray, int depth) { ShadeRec shadeRec = new ShadeRec(world); //not used double t; // not used if (world.Sphere.Intersect(ray, out t, shadeRec)) { return new RGBColor((float) (shadeRec.Normal.X + 1)/2, (float) (shadeRec.Normal.Y + 1)/2, (float) (shadeRec.Normal.Z + 1)/2); } else { return new RGBColor(0, 0, 0); } }
public override RGBColor Shade(ShadeRec shadeRec) { Vector3d wo = -shadeRec.Ray.Direction; RGBColor L = ambientBRDF.Rho(shadeRec, wo)*shadeRec.World.AmbientLight.L((shadeRec)); for (int i = 0; i < shadeRec.World.Lights.Count; i++) { Vector3d wi = shadeRec.World.Lights[i].GetDirection(shadeRec); double NdotWi = Vector3d.Dot(shadeRec.Normal, wi); if (NdotWi>0) { L = L + diffuseBRDF.F(shadeRec, wo, wi) + glossySpecularBRDF.F(shadeRec, wo, wi)*shadeRec.World.Lights[i].L(shadeRec)*NdotWi; } } return L; }
public override bool Intersect(Ray ray, out double tmin, ShadeRec shadeRec) { double t = Vector3d.Dot((Point - ray.Origin), Normal) / Vector3d.Dot(ray.Direction, Normal); if (t>kEpsilon && !double.IsInfinity(t)) { tmin = t; shadeRec.Normal = Normal; shadeRec.Hitpoint = ray.Origin + t*ray.Direction; return true; } else { tmin = 0; return false; } }
public override bool Intersect(Ray ray, out double tmin, ShadeRec shadeRec) { double t = 0; Vector3d temp = ray.Origin - Center; double a = Vector3d.Dot(ray.Direction, ray.Direction); double b = Vector3d.Dot(temp, ray.Direction)*2; double c = Vector3d.Dot(temp, temp) - Radius*Radius; double disc = b*b - 4*a*c; tmin = 0; if (disc < 0) { return false; } else { //TODO: what if denom == 0? double e = Math.Sqrt(disc); double denom = 2*a; //smaller root t = (-b - e)/denom; if (t>kEpsilon) { tmin = t; shadeRec.Normal = (temp + t*ray.Direction)/Radius; shadeRec.Hitpoint = ray.Origin + t*ray.Direction; return true; } //larger root t = (-b + e) / denom; if (t > kEpsilon) { tmin = t; shadeRec.Normal = (temp + t * ray.Direction) / Radius; shadeRec.Hitpoint = ray.Origin + t * ray.Direction; return true; } //no valid intersection return false; } }
//public void set_image(Image img_arg) { img = img_arg; } public override RGBColor GetColor(ShadeRec sr) { float u; float v; //Use provided UV coordinates if no map type defined if (_mapType == null) { u = sr.U; v = sr.U; } else { Point2D uv = _mapType.GetUV(sr.HitPointLocal); u = uv.coords.X; v = uv.coords.Y; } return _image.GetColorAtUV(u, v, true); }
public virtual RGBColor Shade(ShadeRec shadeRec) { return new RGBColor(); }
//public void setMapper(Mapper map) { _mapType = map; } public virtual RGBColor GetColor(ShadeRec sr) { return new RGBColor(1, 1, 1); }
public abstract RGBColor Shade(ShadeRec sr);
//Gets and sets /* virtual public void setKa(float ka) { ambientBRDF.DiffuseReflectionCoefficient = ka; } virtual public void setKd(float kd) { diffuseBRDF.DiffuseReflectionCoefficient = kd; } virtual public void setCd(RGBColor c) { ambientBRDF.ColorDiffuse = c; diffuseBRDF.ColorDiffuse = c; specularBRDF.ColorSpecular = c; } virtual public void setExp(float exp) { specularBRDF.PhongExponent = exp; } virtual public void setKs(float ks) { specularBRDF.SpecularReflectionCoefficient = ks; } virtual public void setCd(Texture tex) { ambientBRDF.Texture = tex; diffuseBRDF.Texture = tex; } */ public override RGBColor Shade(ShadeRec sr) { Vect3D reflectedDirection = -sr.Ray.Direction; //Ray pointing from point of intersection to camera. RGBColor L = ambientBRDF.Rho(sr, reflectedDirection) * sr.WorldPointer.AmbientLight.GetLighting(sr); //Start with ambient int numlights = sr.WorldPointer.LightList.Count; Vect3D incomingDirection; //Direction to incident light float nDotWi; bool inShadow; Ray shadowRay; //Add together light contributions for all light sources for(int i = 0; i<numlights; i++) { incomingDirection = sr.WorldPointer.LightList[i].GetDirection(sr); //Get the direction from the point of contact to the light source. nDotWi = (float)(sr.Normal * incomingDirection); //Dot product of normal and light source, 0 if orthogonal, 1 if parallel. if(nDotWi > 0.0f)//Avoid unnecessary light summation { inShadow = false; if(sr.WorldPointer.LightList[i].CastsShadows) { shadowRay = new Ray(sr.HitPoint+(GlobalVars.SHAD_K_EPSILON*incomingDirection), incomingDirection); inShadow = sr.WorldPointer.LightList[i].InShadow(sr, shadowRay); } if (!inShadow) { //Add diffuse and specular components. L += (diffuseBRDF.F(sr, reflectedDirection, incomingDirection) + specularBRDF.F(sr, reflectedDirection, incomingDirection)) * sr.WorldPointer.LightList[i].GetLighting(sr) * nDotWi; } } } return L; }
public virtual RGBColor Rho(ShadeRec sr, Vect3D reflectedDirection) { return GlobalVars.COLOR_BLACK; }
public override RGBColor F(ShadeRec shadeRec, Geometry.Vector3d wi, Geometry.Vector3d wo) { return CD*KD*1/Math.PI; }
public override Vector3d GetDirection(ShadeRec shadeRec) { return new Vector3d(); }
public virtual RGBColor SampleF(ShadeRec shadeRec, Vector3d wi, Vector3d wo) { return new RGBColor(); }
public virtual RGBColor Rho(ShadeRec shadeRec,Vector3d wo) { return new RGBColor(); }
public override RGBColor L(ShadeRec shadeRec) { return color*ls; }
public virtual bool Intersect(Ray ray, out double tmin, ShadeRec shadeRec) { tmin = 0; return false; }
public override Vector3d GetDirection(ShadeRec shadeRec) { Vector3d dir = Location - (Vector3d) shadeRec.Hitpoint; dir.Normalize(); return dir; }
public override RGBColor Rho(ShadeRec shadeRec, Geometry.Vector3d wo) { return CD*KD; }
public virtual RGBColor AreaLightShade(ShadeRec shadeRec) { return new RGBColor(); }
public override RGBColor L(ShadeRec shadeRec) { return Color*LightScale; }
public virtual RGBColor SampleF(ShadeRec sr, ref Vect3D incomingDirection, ref Vect3D reflectedDirection) { return GlobalVars.COLOR_BLACK; }
public virtual Vector3d GetDirection(ShadeRec shadeRec) { return new Vector3d(); }