renderer_detail_trace.cpp

#include "renderer_detail_trace.h"




namespace Renderer {


namespace detail {




/*==============================================================================
    Project function
==============================================================================*/


double Project( Vector< double, 3 >& position, Vector< double, 3 > const& ray ) {

    if ( 
        ( position[ 0 ] >= 0 ) && ( position[ 0 ] <= 1 ) &&
        ( position[ 1 ] >= 0 ) && ( position[ 1 ] <= 1 ) &&
        ( position[ 2 ] >= 0 ) && ( position[ 2 ] <= 1 )
    )
    {
        return 0;    // **NOTE: return
    }
    else {

        if ( position[ 0 ] < 0 ) {

            if ( ray[ 0 ] > 0 ) {

                double const lambda = -position[ 0 ] / ray[ 0 ];
                Vector< double, 3 > projected = { { 0, position[ 1 ] + lambda * ray[ 1 ], position[ 2 ] + lambda * ray[ 2 ] } };
                if (
                    ( projected[ 1 ] >= 0 ) && ( projected[ 1 ] <= 1 ) &&
                    ( projected[ 2 ] >= 0 ) && ( projected[ 2 ] <= 1 )
                )
                {
                    position = projected;
                    return lambda;    // **NOTE: return
                }
            }
        }
        else if ( position[ 0 ] > 1 ) {

            if ( ray[ 0 ] < 0 ) {

                double const lambda = ( 1 - position[ 0 ] ) / ray[ 0 ];
                Vector< double, 3 > projected = { { 1, position[ 1 ] + lambda * ray[ 1 ], position[ 2 ] + lambda * ray[ 2 ] } };
                if (
                    ( projected[ 1 ] >= 0 ) && ( projected[ 1 ] <= 1 ) &&
                    ( projected[ 2 ] >= 0 ) && ( projected[ 2 ] <= 1 )
                )
                {
                    position = projected;
                    return lambda;    // **NOTE: return
                }
            }
        }

        if ( position[ 1 ] < 0 ) {

            if ( ray[ 1 ] > 0 ) {

                double const lambda = -position[ 1 ] / ray[ 1 ];
                Vector< double, 3 > projected = { { position[ 0 ] + lambda * ray[ 0 ], 0, position[ 2 ] + lambda * ray[ 2 ] } };
                if (
                    ( projected[ 0 ] >= 0 ) && ( projected[ 0 ] <= 1 ) &&
                    ( projected[ 2 ] >= 0 ) && ( projected[ 2 ] <= 1 )
                )
                {
                    position = projected;
                    return lambda;    // **NOTE: return
                }
            }
        }
        else if ( position[ 1 ] > 1 ) {

            if ( ray[ 1 ] < 0 ) {

                double const lambda = ( 1 - position[ 1 ] ) / ray[ 1 ];
                Vector< double, 3 > projected = { { position[ 0 ] + lambda * ray[ 0 ], 1, position[ 2 ] + lambda * ray[ 2 ] } };
                if (
                    ( projected[ 0 ] >= 0 ) && ( projected[ 0 ] <= 1 ) &&
                    ( projected[ 2 ] >= 0 ) && ( projected[ 2 ] <= 1 )
                )
                {
                    position = projected;
                    return lambda;    // **NOTE: return
                }
            }
        }

        if ( position[ 2 ] < 0 ) {

            if ( ray[ 2 ] > 0 ) {

                double const lambda = -position[ 2 ] / ray[ 2 ];
                Vector< double, 3 > projected = { { position[ 0 ] + lambda * ray[ 0 ], position[ 1 ] + lambda * ray[ 1 ], 0 } };
                if (
                    ( projected[ 0 ] >= 0 ) && ( projected[ 0 ] <= 1 ) &&
                    ( projected[ 1 ] >= 0 ) && ( projected[ 1 ] <= 1 )
                )
                {
                    position = projected;
                    return lambda;    // **NOTE: return
                }
            }
        }
        else if ( position[ 2 ] > 1 ) {

            if ( ray[ 2 ] < 0 ) {

                double const lambda = ( 1 - position[ 2 ] ) / ray[ 2 ];
                Vector< double, 3 > projected = { { position[ 0 ] + lambda * ray[ 0 ], position[ 1 ] + lambda * ray[ 1 ], 1 } };
                if (
                    ( projected[ 0 ] >= 0 ) && ( projected[ 0 ] <= 1 ) &&
                    ( projected[ 1 ] >= 0 ) && ( projected[ 1 ] <= 1 )
                )
                {
                    position = projected;
                    return lambda;    // **NOTE: return
                }
            }
        }
    }

    return std::numeric_limits< double >::infinity();
}




}    // namespace detail


}    // namespace Renderer