C++ Vector4::Scale方法代码示例

// For Shading Purposes
void RT_shade(Ray* ray, int depth) {
    
    if (depth <= MAX_DEPTH){                
        
        // Color Coefficients
        Vector4* diffuseCoeff = new Vector4();
        Vector4* specularCoeff = new Vector4();
        double shininess;
        
        // Diffuse and Specular Terms
        double diffuseTerm[3] = {0.0, 0.0, 0.0};
        double specularTerm[3] = {0.0, 0.0, 0.0};
        
        if (ray->intersectedObject == SPHERE) {

            diffuseCoeff->ReInitialize(spheres[ray->intersectID].color_diffuse);
            specularCoeff->ReInitialize(spheres[ray->intersectID].color_specular);
            shininess = spheres[ray->intersectID].shininess;
        }
        else if (ray->intersectedObject == TRIANGLE) {

            // Interpolate diffuse and specular coefficients
            double alpha, beta;
            ObtainIntermediateTriangleIntersection(ray->intersectID, ray->intersectPoint, &alpha, &beta);

            diffuseCoeff->ReInitialize();
            InterpolateTriangleProperty(triangles[ray->intersectID].v[0].color_diffuse,
                    triangles[ray->intersectID].v[1].color_diffuse,
                    triangles[ray->intersectID].v[2].color_diffuse,
                    alpha, beta, diffuseCoeff, false);

            specularCoeff->ReInitialize();
            InterpolateTriangleProperty(triangles[ray->intersectID].v[0].color_specular,
                    triangles[ray->intersectID].v[1].color_specular,
                    triangles[ray->intersectID].v[2].color_specular,
                    alpha, beta, specularCoeff, false);

            // Interpolate shininess
            if (alpha > 0) {

                double intermediateShininess = beta * triangles[ray->intersectID].v[2].shininess
                        + (1 - beta) * triangles[ray->intersectID].v[1].shininess;

                shininess = ((alpha - 1) * triangles[ray->intersectID].v[0].shininess
                        + intermediateShininess) / alpha;
            } 
            else {
                shininess = triangles[ray->intersectID].v[0].shininess;
            }
        }

        // Boundary Checking        
        assert(diffuseCoeff->HasNonNegativeEntries());
        assert(!diffuseCoeff->HasGreaterThanOneEntries());
        assert(specularCoeff->HasNonNegativeEntries());
        assert(!specularCoeff->HasGreaterThanOneEntries());
        assert(shininess >= 0);
        
        // Normal Vector: N
        Vector4* N = new Vector4(ray->normal);
        N->ConvertToUnitVector();
        
        // Viewer Direction: V = ray->intersectedPoint - ray->source = -ray->dir
        Vector4* V = new Vector4(ray->dir);
        V->Scale(-1);
        V->ConvertToUnitVector();
        
        int dontCheckObject = NONE;
        int dontCheckObjectID = NONE;
        
        if (ray->intersectedObject == TRIANGLE) {
            dontCheckObject = ray->intersectedObject;
            dontCheckObjectID = ray->intersectID;
        }
        
                
        unsigned int i;
        for (i = 0; i < num_lights; i++) {            
            
            // Shoot a ray in the direction of the light
            Vector4* lightPos = new Vector4(lights[i].position);
            Ray* checkShadow = new Ray(ray->intersectPoint, lightPos);
            bool shadow = false;            
            
            double nearestTIntersect = FindNearestTIntersection(checkShadow,dontCheckObject,dontCheckObjectID);
            double point2LightDistance = FindDistanceOfIntersectedPointWithLight(ray,i);
            if (nearestTIntersect != INFINITY 
                && nearestTIntersect< point2LightDistance)
            {
                shadow = true;    
            }

            // Point to Light Vector: L = light_pos - intersectedPoint
            Vector4* L = new Vector4(lights[i].position);
            L->Subtraction(ray->intersectPoint);
            L->ConvertToUnitVector();            

            // Reflected Ray: R = 2(N.L)N - L
            Vector4* R = new Vector4(ray->normal);
//.........这里部分代码省略.........

//.........这里部分代码省略.........
    Vect3.x = 2;
    Vect3.y = 2;
    Vect3.z =2;
    cout <<Vect33.DotProduct(Vect3) << endl;

    Vect3.x = 4;
    Vect3.y = 4;
    Vect3.z = 4;
    Vect33.x =4;
    Vect33.y = 4;
    Vect3.z = 4;
    cout << Vect3.EulerAngle(Vect3, Vect33)<<endl;

    Vect3.x = 2;
    Vect3.y = 2;
    Vect3.z = 2;
    Vect33.x = 2;
    Vect33.y =2;
    Vect33.z = 2;
    cout << Vect3.CrossProduct(Vect3, Vect33)<<endl;

    Matrix3 Transform;
    Transform = Mat3;
    Vect3.x =2;
    Vect3.y = 2;
    Vect3.z = 2;
    cout << Vect3.m_TransformVector3(Mat3)<<endl;

    Matrix3 tempM;
    tempM = Mat3;
    Vect3.x = 2;
    Vect3.y = 2;
    Vect3.z = 2;
    cout << Vect3.Scale(Mat3);
    cout << endl;

    cout << "---------------------------VECTOR 4--------------------------------" << endl;
    Vect4.x = 2;
    Vect4.y =2;
    Vect4.z =2;
    Vect4.w = 2;
    cout << Vect4.m_Magnitude()<<endl;

    Vect4.x = 2;
    Vect4.y =2;
    Vect4.z =2;
    Vect4.w = 2;
    cout << Vect4.m_GetNormal(Vect4)<<endl;

    Vect4.x = 2;
    Vect4.y =2;
    Vect4.z =2;
    Vect4.w = 2;
    cout << Vect4.m_Normalise(Vect4) <<endl;

    Vect4.x = 2;
    Vect4.y =2;
    Vect4.z =2;
    Vect4.w = 2;
    cout << Vect4.m_DotProduct(Vect4) << endl;

    cout << Vect4.m_RGBconverter(0xFFFFFFFF)<<endl;

    Matrix4 Transform2;
    Transform2 = Mat4;
    Vect4.x = 2;

double FindNearestTIntersectionWithTriangle(Ray* ray, int* index, int noCheckID = NONE){
    
    assert(noCheckID==NONE || (noCheckID>=0 && noCheckID<num_triangles));
    
    double nearestTIntersect = INFINITY;
    *index = NONE;
    
    unsigned int i;    
    for (i = 0; i < num_triangles; i++) {
        
        if (i==noCheckID){
            continue;
        }
        // Vertices V0, V1 and V2
        Vector4* V0 = new Vector4(triangles[i].v[0].position);
        Vector4* V1 = new Vector4(triangles[i].v[1].position);
        Vector4* V2 = new Vector4(triangles[i].v[2].position);
        
        // Edges: VOV1, V0V2
        Vector4* V0V1 = new Vector4(V1);
        V0V1->Subtraction(V0);
        Vector4* V0V2 = new Vector4(V2);
        V0V2->Subtraction(V0);
        
        // Normal: N = V0V1 X V0V2
        Vector4* N = new Vector4(V0V1);
        N->CrossProductPost(V0V2);
        N->ConvertToUnitVector();
                
        // ray and normal should be opposite
        if (N->DotProduct(ray->dir)>0){
            N->Scale(-1);
        }
        
        // N = [A B C]
        // AX0 + BY0 + CZ0 + D = 0
        double D = -1*N->DotProduct(V0);                       
        
        if (N->DotProduct(ray->dir) != (double) 0) {
            // t = -(N.Ro + D)/ (N.Rd)
            double candidateT = -1 * (N->DotProduct(ray->source) + D) / N->DotProduct(ray->dir);            
            
            if (candidateT > 0){
                
                // P = Ro + tRd
                Vector4* point = new Vector4(ray->dir);
                point->Scale(candidateT);
                point->Addition(ray->source);

                // alpha*V0V1 + beta*V0V2 = V0P
                Vector4* V0P = new Vector4(point);
                V0P->Subtraction(V0);

                double alpha = 0.0;
                double beta = 0.0;

                //(x01)alpha + (x02)beta = x0p;
                //(y01)alpha + (y02)beta = y0p;
                //(z01)alpha + (z02)beta = z0p;
                double A1 = V0V1->vector[0];
                double B1 = V0V2->vector[0];
                double C1 = V0P->vector[0];

                double A2 = V0V1->vector[1];
                double B2 = V0V2->vector[1];
                double C2 = V0P->vector[1];
                
                double A3 = V0V1->vector[2];
                double B3 = V0V2->vector[2];
                double C3 = V0P->vector[2];

                SolveLinearEquation(A1, B1, C1, A2, B2, C2, &alpha, &beta);

                if (alpha == NONE) {
                    SolveLinearEquation(A2, B2, C2, A3, B3, C3, &alpha, &beta);
                }
                
                if (alpha == NONE) {
                    SolveLinearEquation(A1, B1, C1, A3, B3, C3, &alpha, &beta);
                }
                
//                // For Debugging Purposes
//                printf("\nTriangle: %d ==> CandidateT: %f ==> (%f,%f)",i,candidateT,alpha,beta);
                
                if (alpha > 0 && beta > 0 && (alpha + beta) < 1) {
                    if (nearestTIntersect > candidateT) {
                        nearestTIntersect = candidateT;
                        *index = i;
                    }
                }

                delete(V0P);
                delete(point); 
            }
        }
        
        delete(N);
        delete(V0V2);
        delete(V0V1);
        delete(V2);
//.........这里部分代码省略.........