molecule_renderer.hpp

/****************************************************************************

Copyright (c) 2012 Carlos Rafael Giani  ( email: dv xxx AT pseudoterminal xxx DOT xxx org , remove the xxx )

This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.

Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:

   1. The origin of this software must not be misrepresented; you must not
   claim that you wrote the original software. If you use this software
   in a product, an acknowledgment in the product documentation would be
   appreciated but is not required.

   2. Altered source versions must be plainly marked as such, and must not be
   misrepresented as being the original software.

   3. This notice may not be removed or altered from any source
   distribution.

****************************************************************************/



#ifndef ZMOL_MOLECULE_RENDERER_HPP
#define ZMOL_MOLECULE_RENDERER_HPP

#include <memory>
#include <functional>
#include "opengl3.hpp"
#include "glsl.hpp"
#include "buffer_object.hpp"
#include "vertex_array_object.hpp"
#include "molecule_data.hpp"
#include "noncopyable.hpp"
#include "texture.hpp"
#include "cml/cml.h"


namespace zmol
{


class molecule_shaders:
        private noncopyable
{
public:
        // Struct containing the GLSL program as well as GLSL uniform locations into that program.
        struct program_data
        {
                program m_program;
                GLint
                        m_model_view_uniform,
                        m_projection_uniform,
                        m_scale_factor_uniform,
                        m_texlen_uniform,
                        m_border_and_flatness_uniform,
                        m_lighting_params_uniform
                        ;

                // Constructor just sets the uniform locations to -1 (= "not initialized").
                program_data();
        };


        explicit molecule_shaders(std::function < void(std::string const &p_errormsg) > const &p_errormsg_callback);


        // The GLSL shaders and programs.
        program_data
                m_sphere_draw_to_screen,
                m_sphere_draw_to_shadowmap,
                m_sphere_draw_to_ao_atlas,
                m_cylinder_draw_to_screen,
                m_cylinder_draw_to_shadowmap,
                m_cylinder_draw_to_ao_atlas
                ;
};


class molecule_renderer:
        private noncopyable
{
public:
        enum rendering_modes
        {
                rendering_mode_space_filling, 
                rendering_mode_balls_and_sticks, 
                rendering_mode_licorice 
        };

        enum atom_color_modes
        {
                atom_color_mode_per_element, 
                atom_color_mode_per_chain 
        };


        typedef cml::matrix44f_c matrix;


        explicit molecule_renderer(
                molecule_shaders &p_molecule_shaders,
                molecule_data const &p_data,
                unsigned int const p_initial_left_viewport_offset, unsigned int const p_initial_top_viewport_offset,
                unsigned int const p_initial_viewport_width, unsigned int const p_initial_viewport_height,
                unsigned int const p_initial_atlas_size,
                float const p_initial_radius_scale = 1.0f,
                rendering_modes const p_initial_rendering_mode = rendering_mode_space_filling,
                atom_color_modes const p_initial_atom_color_mode = atom_color_mode_per_element
        );
        explicit molecule_renderer(
                molecule_shaders &p_molecule_shaders,
                molecule_data &&p_data,
                unsigned int const p_initial_left_viewport_offset, unsigned int const p_initial_top_viewport_offset,
                unsigned int const p_initial_viewport_width, unsigned int const p_initial_viewport_height,
                unsigned int const p_initial_atlas_size,
                float const p_initial_radius_scale = 1.0f,
                rendering_modes const p_initial_rendering_mode = rendering_mode_space_filling,
                atom_color_modes const p_initial_atom_color_mode = atom_color_mode_per_element
        );

        void set_rendering_mode(rendering_modes const p_new_rendering_mode);

        void set_atom_color_mode(atom_color_modes const p_new_atom_color_mode);

        void set_viewport(unsigned int const p_new_left_viewport_offset, unsigned int const p_new_top_viewport_offset, unsigned int const p_new_viewport_width, unsigned int const p_new_viewport_height);

        void set_radius_scale(float const p_new_radius_scale);

        void set_border_width(float const p_new_border_width);

        void set_border_variance(float const p_new_border_variance);

        void set_ao_strength(float const p_new_ao_strength);

        void set_direct_lighting_strength(float const p_new_direct_lighting_strength);

        void set_shininess(float const p_new_shininess);

        void set_glossiness(float const p_new_glossiness);

        void set_flatness(float const p_new_flatness);

        void set_atlas_size(unsigned int const p_new_atlas_size);

        void render(cml::quaternionf const &p_rotation);

        matrix const & get_projection() const { return m_projection; }


protected:
        typedef std::unique_ptr < texture > texture_uptr;


        // Rendering always happens in two passes: first the spheres, then the cylinders.
        enum passes
        {
                pass_spheres,
                pass_cylinders
        };


        // Common initializer for all the constructors.
        void init_renderer();

        // Internal rendering function for a specific pass using a given GLSL program.
        void render_internal(molecule_shaders::program_data &p_program_data, matrix const &p_rotation, matrix const &p_projection, passes const p_pass);

        // Calculates ambient occlusion; expects the impostor geometry to exist already, so calc_quads() must be called prior to this.
        void calc_ao();

        // Calculates impostor quads. This always needs to be called before the ambient occlusion term is calculated (= before calc_ao() is called).
        void calc_quads();

        // Initializes the atlas texture instance, that is, the value of m_ao_atlas.
        void init_atlas_texture();


        molecule_shaders &m_shaders;
        matrix m_projection;
        vertex_array_object m_vao;
        buffer_object m_vertices, m_indices;
        molecule_data m_data;
        std::size_t m_num_atoms, m_num_bonds;
        float m_scale_factor; // Factor to scale atom and cylinder radii and atom positions; depends on the overall size of the molecule
        float m_radius_scale; // User-defined scale by which the sphere and cylinder radii are scaled
        float m_border_width, m_border_variance;
        float m_ao_strength, m_direct_lighting_strength, m_shininess, m_glossiness, m_flatness;
        cml::vector3f m_base_translation;
        unsigned int m_left_viewport_offset, m_top_viewport_offset, m_viewport_width, m_viewport_height;
        unsigned int m_atlas_size;
        rendering_modes m_rendering_mode;
        atom_color_modes m_atom_color_mode;

        texture_uptr m_ao_atlas;
        std::size_t m_ao_patch_sidelength;
};


}


#endif