volume_renderer.h

#pragma once
 
#include "renderer.h"
 
#include "gl/lib_begin.h"
 
namespace cgv { // @<
    namespace render { // @<
        
        class CGV_API volume_renderer;
 
 
        extern CGV_API volume_renderer& ref_volume_renderer(context& ctx, int ref_count_change = 0);
 
        struct CGV_API volume_render_style : public render_style {
            /*@name global volume rendering options*/
 
            enum IntegrationQuality {
                IQ_8 = 8,
                IQ_16 = 16,
                IQ_32 = 32,
                IQ_64 = 64,
                IQ_128 = 128,
                IQ_256 = 256,
                IQ_512 = 512,
                IQ_1024 = 1024,
                IQ_2048 = 2048,
                IQ_4096 = 4096
            } integration_quality;
            bool enable_noise_offset;
            enum InterpolationMode {
                IP_NEAREST = 0,     
                IP_SMOOTHED = 1,    
                IP_LINEAR = 2,      
                IP_CUBIC = 3        
            } interpolation_mode;
            bool enable_depth_test;
 
            enum CompositingMode {
                CM_MAXIMUM_INTENSITY_PROJECTION = 0,
                CM_AVERAGE = 1,
                CM_BLEND = 2 // using transfer function
            } compositing_mode;
            
            float scale_adjustment_factor;
            
            bool enable_lighting;
            bool light_local_to_eye;
            bool use_gradient_texture;
            vec3 light_direction;
            float ambient_strength;
            float diffuse_strength;
            float specular_strength;
            float roughness;
            float specular_color_mix;
 
            bool enable_gradient_modulation;
            float gradient_lambda;
 
            enum IsosurfaceMode{
                IM_NONE = 0,            
                IM_ISOVALUE = 1,        
                IM_ALPHA_THRESHOLD = 2  
            } isosurface_mode;
            float isovalue;
            rgb isosurface_color;
            bool isosurface_color_from_transfer_function;
 
            enum SliceMode {
                SM_DISABLED = 0,   // no slice
                SM_OPAQUE = 1,     // opaque slice rendering
                SM_TRANSPARENT = 2 // transparent slice rendering 
            } slice_mode;
            int   slice_axis;
            float slice_coordinate;
            float slice_opacity;
 
            box3 clip_box;
 
            //}@
            volume_render_style();
        };
 
        class CGV_API volume_renderer : public renderer
        {
        private:
            cgv::render::attribute_array_manager position_aam;
        protected:
            texture* volume_texture;
            texture* transfer_function_texture;
            texture noise_texture;
            texture* gradient_texture;
            texture* depth_texture;
            box3 bounding_box;
            bool apply_bounding_box_transformation;
            vec2 noise_offset;
            render_style* create_render_style() const;
            void update_defines(shader_define_map& defines);
            bool build_shader_program(context& ctx, shader_program& prog, const shader_define_map& defines);
            void init_noise_texture(context& ctx);
        public:
            volume_renderer();
            bool init(context& ctx);
            virtual void clear (const context& ctx);
            bool set_volume_texture(texture* tex);
            bool set_transfer_function_texture(texture* tex);
            bool set_gradient_texture(texture* tex);
            bool set_depth_texture(texture* tex);
            void set_bounding_box(const box3& bbox);
            void transform_to_bounding_box(bool flag);
            void set_noise_offset(const vec2& offset);
            bool enable(context& ctx);
            bool validate_attributes(const context& ctx) const;
            bool disable(context& ctx);
            void draw(context& ctx, size_t start, size_t count,
                bool use_strips = false, bool use_adjacency = false, uint32_t strip_restart_index = -1);
        };
    }
}
 
#include <cgv/config/lib_end.h>