renderer_state_host.h

#pragma once

#ifndef RENDERER_STATE_HOST_H
#define RENDERER_STATE_HOST_H




#include "renderer_state_base.h"
#include "renderer_detail_trace.h"
#include "renderer_detail_normal_mrf.h"
#include "renderer_camera.h"
#include "synchronized.h"
#include "platform.h"
#include "octree.h"
#include "vector.h"
#include "helpers.h"
#include "settings.h"

#include <array>
#include <algorithm>
#include <limits>
#include <cmath>

#include <assert.h>
#include <stdint.h>




namespace Renderer {




/*==============================================================================
    State< PLATFORM_HOST > specialization
==============================================================================*/


template<>
struct State< PLATFORM_HOST > {

    inline State();


    template< int t_ColorFormat, int t_Platform >
    void TraceScreen(
        uint8_t* const colors,
        Vector< unsigned int, 2 > const dimension,                                                                                // width, height
        unsigned int const pitch,                                                                                                 // bytes per row
        Synchronized::Heap< t_Platform > const& heap,                                                                             // heap containing the octree
        Synchronized::TextureHeap< t_ColorFormat, t_Platform > const& textureHeap,                                                // texture heap containing the octree's textures
        typename Synchronized::Heap< t_Platform >::template Pointer< Octree::Node< t_ColorFormat, t_Platform > > const& pRoot,    // root of the octree
        Camera const& camera                                                                                                      // camera matrix (x,y,z vectors, and position)
    ) const;
};




/*==============================================================================
    State< PLATFORM_HOST > methods
==============================================================================*/


State< PLATFORM_HOST >::State() {
}


template< int t_ColorFormat, int t_Platform >
void State< PLATFORM_HOST >::TraceScreen(
    uint8_t* const colors,
    Vector< unsigned int, 2 > const dimension,
    unsigned int const pitch,
    Synchronized::Heap< t_Platform > const& heap,
    Synchronized::TextureHeap< t_ColorFormat, t_Platform > const& textureHeap,
    typename Synchronized::Heap< t_Platform >::template Pointer< Octree::Node< t_ColorFormat, t_Platform > > const& pRoot,
    Camera const& camera
) const
{
    Vector< double, 3 > const& xx = camera.VectorX();
    Vector< double, 3 > const& yy = camera.VectorY();
    Vector< double, 3 > const& zz = camera.VectorZ();
    Vector< double, 3 > const& position = camera.Position();
    Vector< double, 2 > const fieldOfView = dimension * ( camera.Zoom() / dimension.Maximum() );

    double const spread = 2 * ( fieldOfView / dimension ).Minimum();    // x2 because for fov=1, the screen is 2 units wide for every 1 unit of distance

    std::unique_ptr< float[] > depths( new float[ dimension.Product() ] );

    #pragma omp parallel for
    for ( int ii = 0; ii < static_cast< int >( dimension[ 1 ] ); ++ii ) {

        unsigned int const offset = ii * pitch;
        for ( int jj = 0; jj < static_cast< int >( dimension[ 0 ] ); ++jj ) {

            Vector< int, 2 > const coordinates = { { jj, ii } };
            Vector< double, 2 > const direction = ( ( coordinates + 0.5 ) * 2 / dimension - 1 ) * fieldOfView;
            Vector< double, 3 > const ray = xx * direction[ 0 ] - yy * direction[ 1 ] - zz;

            uint8_t* const colorDestination = colors + offset + jj * 4;
            colorDestination[ 0 ] = 0x00;
            colorDestination[ 1 ] = 0x00;
            colorDestination[ 2 ] = 0x00;
            colorDestination[ 3 ] = 0xff;

            float* const depthDestination = depths.get() + coordinates[ 1 ] * dimension[ 0 ] + coordinates[ 0 ];
            *depthDestination = std::numeric_limits< float >::infinity();

            detail::Trace< t_ColorFormat, t_Platform >( colorDestination, depthDestination, pRoot, spread, position, ray );
        }
    }
}




}    // namespace Renderer




#endif    // RENDERER_STATE_HOST_H