View difference between Paste ID: BpmL6Qtf and Bc6rBMpj

 //----Render loop-----//
 this.canvas = this.surfaceHolder.lockCanvas();
 
                 int width = canvas.getWidth();
                 int height = canvas.getHeight();
 
                 float fov = 160.0f * (float)Math.PI / 180.0f;
                 float zdir = 1.0f / (float)Math.tan(fov);
                 float aspect = (float)height / (float)width;
 
                 for(int x = 0; x < width; x++){
                     for(int y = 0; y < height; y++){
                         float xdir = (x / (float)width) * 2.0f - 1.0f;
                         float ydir = ((y / (float)height) * 2.0f - 1.0f) * aspect;
 
                         Vector3D direction = new Vector3D(xdir, ydir, zdir).normalize();
                         Ray ray = new Ray(Camera, direction);
 
                         float r = 0, g = 0, b = 0;
                         for(int i = 0; i < RAYS_PER_PIXEL; i++){
                             CColor color = Trace(ray, 0);
                             r += color.r;
                             g += color.g;
                             b += color.b;
                         }
 
                         r/= RAYS_PER_PIXEL;
                         g/= RAYS_PER_PIXEL;
                         b/= RAYS_PER_PIXEL;
 
                         Paint paint = new Paint();
                         paint.setColor(Color.argb(255,(int)r,(int)g,(int)b));
                         canvas.drawPoint(x,y,paint);
 
 
 //---Trace Function---//
 
 public CColor Trace(Ray ray, int depth){
         float hitDistance = 5000.0f;
         BaseObject hitObject = null;
 
         for(BaseObject obj: scene.SceneObjects){
             float intersect = obj.intersect(ray);
             if(intersect < hitDistance && intersect > -1.0f) {
                 hitDistance = intersect;
                 hitObject = obj;
             }
         }
 
         if(hitDistance == 5000.0f) {
             return new CColor(0,0,0);
         }
 
         if(hitObject.isEmitter) {
             return hitObject.color;
         }
 
         if(depth == MAX_DEPTH) {
             return new CColor(0,0,0);
         }
 
         Vector3D hitPoint = ray.origin.add(ray.direction.mult(hitDistance * 0.99f));
         Vector3D normal = hitObject.normal(hitPoint);
 
         Vector3D randomVector = Vector3D.getRandomVectorInHemisphere();
         if(randomVector.dot(normal) < 0.0f)
             randomVector = randomVector.negate();
 
         Ray reflectionRay = new Ray(hitPoint, randomVector.normalize());
 
         CColor returnColor = Trace(reflectionRay, depth + 1);
 
         float r = hitObject.color.r * returnColor.r;
         float g = hitObject.color.g * returnColor.g;
         float b = hitObject.color.b * returnColor.b;
 
         r /= 255.0f;
         g /= 255.0f;
         b /= 255.0f;
 
         return new CColor(r,g,b);
     }
 
 //---Vector Class---//
 
 public class Vector3D {
     public float x;
     public float y;
     public float z;
     private static Random rnd = new Random(new Date().getTime());
 
     public Vector3D(float x, float y, float z){
         this.x = x;
         this.y = y;
         this.z = z;
     }
 
     public Vector3D add(Vector3D addVector){
         return new Vector3D(this.x + addVector.x, this.y + addVector.y, this.z + addVector.z);
     }
 
     public Vector3D sub(Vector3D subVector){
         return new Vector3D(this.x - subVector.x, this.y - subVector.y, this.z - subVector.z);
     }
 
     public Vector3D mult(Vector3D multVector){
         return new Vector3D(this.x * multVector.x, this.y * multVector.y, this.z * multVector.z);
     }
 
     public Vector3D mult(float mult){
         return mult(new Vector3D(mult,mult,mult));
     }
 
     public float dot(Vector3D dotVector){
         return this.x * dotVector.x + this.y * dotVector.y + this.z * dotVector.z;
     }
 
     public Vector3D normalize(){
         float f = (float)(1.0f / Math.sqrt(this.dot(this)));
 
         x *= f;
         y *= f;
         z *= f;
 
         return new Vector3D(x,y,z);
     }
 
     public Vector3D negate(){
         return new Vector3D(this.x = -x, this.y = -y, this.z = -z);
     }
 
     public static Vector3D getRandomVectorInHemisphere(){
         float x = (float)rnd.nextDouble() * 2.0f - 1.0f;
         float y = (float)rnd.nextDouble() * 2.0f - 1.0f;
         float z = (float)rnd.nextDouble() * 2.0f - 1.0f;
 
         int negate = rnd.nextInt();
 
         if(negate % 2 > 0){
             x *= -1;
             y *= -1;
             z *= -1;
         }
 
         return new Vector3D(x,y,z).normalize();
     }
 }
 
 //---Sphere---//
 
 public class Sphere extends BaseObject {
     public Vector3D center;
     public float radius;
 
     public Sphere(CColor color, boolean isEmitter, Vector3D center, float radius){
         this.color = color;
         this.isEmitter = isEmitter;
         this.center = center;
         this.radius = radius;
     }
 
     public float intersect(Ray ray){
         Vector3D v = ray.origin.sub(this.center);
 
         float a = ray.direction.dot(ray.direction);
         float b = 2.0f * ray.direction.dot(v);
         float c = v.dot(v) - (this.radius * this.radius);
 
         float discriminant = (b*b) - (4.0f * a * c);
 
         if(discriminant > 0){
             float x1 = (-b - (float)Math.sqrt(discriminant) / (2.0f * a));
             float x2 = (-b + (float)Math.sqrt(discriminant) / (2.0f * a));
 
 
             if (x1 >= 0 && x2 >= 0) return x1;
             if (x1 < 0 && x2 >= 0) return x2;
             else return -1.0f;
         }
         else
             return -1.0f;
     }
 
     public Vector3D normal(Vector3D intersectionVector){
         return intersectionVector.sub(this.center).normalize();
     }
 }