raytracingesq

Color RayTrace(int depth, Color final_color, Scene ascene, vector<Object*> scene_objects, vector<Light*> light_sources, vector<float> intersections, Ray winning_ray, float index_of_winning_object){

    Vector3 camraydir=winning_ray.getRayDirection();
    Vector3 camrayori=winning_ray.getRayOrigin();
    Vector3 intersection_position=camrayori.vectAdd(camraydir.vectMult(intersections[index_of_winning_object]));
    Vector3 intersecting_ray_direction=camraydir;
    Vector3 winning_object_normal=scene_objects.at(index_of_winning_object)->getNormalAt(intersection_position);

    float material_index=scene_objects.at(index_of_winning_object)->getMaterialIndex();
    Color diffuse_color=ascene.da_material[material_index].getDiffusal();
    Color object_color=ascene.da_material[material_index].getAmbient();
    Color ambient_color=ascene.da_ambient;
    Color specular_color=ascene.da_material[material_index].getSpecular();


    //=======REFLECTION=======//
    //=======REFLECTION=======//
    //=======REFLECTION=======//
    /*
    if(ascene.da_material[material_index].getSpecular().brightness()>0){
        if(depth<1){
            // reflection from objects with specular intensity
            float dot1 = winning_object_normal.dot(intersecting_ray_direction.negative());
            Vector3 scalar1 = winning_object_normal.vectMult(dot1);
            Vector3 add1 = scalar1.vectAdd(intersecting_ray_direction);
            Vector3 scalar2 = add1.vectMult(2);
            Vector3 add2 = intersecting_ray_direction.negative().vectAdd(scalar2);
            Vector3 reflection_direction = add2.normalize();

            Ray reflection_ray (intersection_position, reflection_direction);

            // determine what the ray intersects with first
            vector<float> reflection_intersections;
            for (int reflection_index = 0; reflection_index < scene_objects.size(); reflection_index++) {
                reflection_intersections.push_back(scene_objects.at(reflection_index)->findIntersection(reflection_ray));
            }
            int index_of_winning_object_with_reflection = winningObjectIndex(reflection_intersections);
            if (index_of_winning_object_with_reflection != -1) {
                // reflection ray missed everthing else
                if (reflection_intersections.at(index_of_winning_object_with_reflection) > accuracy) {
                    // determine the position and direction at the point of intersection with the reflection ray
                    // the ray only affects the color if it reflected off something
                    Vector3 reflection_intersection_position = intersection_position.vectAdd(reflection_direction.vectMult(reflection_intersections.at(index_of_winning_object_with_reflection)));
                    Vector3 reflection_intersection_ray_direction = reflection_direction;
                    depth++;
                    Ray send_reflection_ray(reflection_intersection_position,reflection_intersection_ray_direction);
                    Color reflection_intersection_color = RayTrace(depth, final_color, ascene, scene_objects, light_sources, intersections, send_reflection_ray, index_of_winning_object_with_reflection);

                    final_color.setColorRed(final_color.getColorRed()+reflection_intersection_color.getColorRed()*specular_color.getColorRed());
                    final_color.setColorGreen(final_color.getColorGreen()+reflection_intersection_color.getColorGreen()*specular_color.getColorGreen());
                    final_color.setColorBlue(final_color.getColorBlue()+reflection_intersection_color.getColorBlue()*specular_color.getColorBlue());
                }
            }
        }
    }
*/
    //=======DIFFUSE SHADING=======//
    //=======DIFFUSE SHADING=======//
    //=======DIFFUSE SHADING=======//
    for(int k=0; k < light_sources.size(); k++){
        //calculate diffuse shading
        Vector3 light_direction=light_sources.at(k)->light_position.vectAdd(intersection_position.negative()).normalize();

        Color light_color=light_sources.at(k)->light_color;
        float cosine_angle = winning_object_normal.dot(light_direction);

        if(fancybackground==true){
            if(ascene.da_material[material_index].getspecExpP()==-1)
            {
                //checkered/tile floor pattern
                int square=(int)floor(intersection_position.z()/100)+(int)floor(intersection_position.x()/100);
                //cout<<square<<endl;
                if((square % 2)== 0 ){
                    //normal tile
                    object_color.setColorRed(0);
                    object_color.setColorGreen(0);
                    object_color.setColorBlue(0);
                }
                else{
                    //white tile
                    object_color.setColorRed(1);
                    object_color.setColorGreen(1);
                    object_color.setColorBlue(1);
                }
            }
        }

        if(cosine_angle>0){
            //Shadow
            bool shadowed=false;
            float distance_to_light=light_direction.length();
            Ray shadow_ray(intersection_position, light_direction); //position negative yapınca shadow kapanıo

            vector<double> secondary_intersections;

            for (int m = 0; m < scene_objects.size() && shadowed == false; m++) {
                secondary_intersections.push_back(scene_objects.at(m)->findIntersection(shadow_ray));
            }

            for (int c = 0; c < secondary_intersections.size(); c++) {
                if (secondary_intersections.at(c) > accuracy) {
                    if (secondary_intersections.at(c) <= distance_to_light) {
                        shadowed = true;
                    }
                }
                break;
            }

            if (shadowed == false) {
                //nonshadow
                float diffred=cosine_angle*diffuse_color.getColorRed();
                float diffgreen=cosine_angle*diffuse_color.getColorGreen();
                float diffblue=cosine_angle*diffuse_color.getColorBlue();

                final_color.setColorRed(final_color.getColorRed()+diffred*light_color.getColorRed()/255*object_color.getColorRed());
                final_color.setColorGreen(final_color.getColorGreen()+diffgreen*light_color.getColorGreen()/255*object_color.getColorGreen());
                final_color.setColorBlue(final_color.getColorBlue()+diffblue*light_color.getColorBlue()/255*object_color.getColorBlue());

                if(final_color.getColorRed()<ambient_color.getColorRed())
                    final_color.setColorRed(final_color.getColorRed()+ambient_color.getColorRed()/255*object_color.getColorRed());
                if(final_color.getColorGreen()<ambient_color.getColorGreen())
                    final_color.setColorGreen(final_color.getColorGreen()+ambient_color.getColorGreen()/255*object_color.getColorGreen());
                if(final_color.getColorBlue()<ambient_color.getColorBlue())
                    final_color.setColorBlue(final_color.getColorBlue()+ambient_color.getColorBlue()/255*object_color.getColorBlue());
                //nonshadow
                //specular
                if (ascene.da_material[material_index].getSpecular().brightness()>0){
                    // special [0-1]
                    float dot1 = winning_object_normal.dot(intersecting_ray_direction.negative());
                    Vector3 scalar1 = winning_object_normal.vectMult(dot1);
                    Vector3 add1 = scalar1.vectAdd(intersecting_ray_direction);
                    Vector3 scalar2 = add1.vectMult(2);
                    Vector3 add2 = intersecting_ray_direction.negative().vectAdd(scalar2);
                    Vector3 reflection_direction = add2.normalize();

                    float specular = reflection_direction.dot(light_direction);
                    if (specular > 0) {
                        specular = pow(specular, 10);

                        final_color.setColorRed(final_color.getColorRed()+specular*light_color.getColorRed()/255*specular_color.getColorRed());
                        final_color.setColorGreen(final_color.getColorGreen()+specular*light_color.getColorGreen()/255*specular_color.getColorGreen());
                        final_color.setColorBlue(final_color.getColorBlue()+specular*light_color.getColorBlue()/255*specular_color.getColorBlue());
                    }
                }
                //specular
            }else{
                final_color.setColorRed(final_color.getColorRed()+ambient_color.getColorRed()/255*object_color.getColorRed());
                final_color.setColorGreen(final_color.getColorGreen()+ambient_color.getColorGreen()/255*object_color.getColorGreen());
                final_color.setColorBlue(final_color.getColorBlue()+ambient_color.getColorBlue()/255*object_color.getColorBlue());
            }
            //Shadow

        }else{
            final_color.setColorRed(final_color.getColorRed()+ambient_color.getColorRed()/255*object_color.getColorRed());
            final_color.setColorGreen(final_color.getColorGreen()+ambient_color.getColorGreen()/255*object_color.getColorGreen());
            final_color.setColorBlue(final_color.getColorBlue()+ambient_color.getColorBlue()/255*object_color.getColorBlue());
        }
    }

    return final_color;
}