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);
 
        enum class VolumeIntegrationQuality {
            k8 = 8,
            k16 = 16,
            k32 = 32,
            k64 = 64,
            k128 = 128,
            k256 = 256,
            k512 = 512,
            k1024 = 1024,
            k2048 = 2048,
            k4096 = 4096
        };
 
        enum class VolumeInterpolationMode {
            kNearest = 0,       
            kSmoothed = 1,      
            kLinear = 2,        
            kCubic = 3          
        };
 
        enum class VolumeCompositingMode {
            kMaximumIntensityProjection = 0,
            kAverage = 1,
            kBlend = 2 // using transfer function
        };
 
        enum class VolumeIsosurfaceMode {
            kNone = 0,          
            kIsovalue = 1,      
            kAlphaThreshold = 2 
        };
 
        enum class VolumeSliceMode {
            kNone = 0,          
            kOpaque = 1,        
            kTransparent = 2    
        };
 
        struct CGV_API volume_render_style : public render_style {
            VolumeIntegrationQuality integration_quality = VolumeIntegrationQuality::k128;
            bool enable_noise_offset = true;
            VolumeInterpolationMode interpolation_mode = VolumeInterpolationMode::kLinear;
            bool enable_depth_test = true;
            // the opacity threshold needed to pass before the volume is considered a solid surface (needed for defining depth and supporting focus picking)
            float picking_opacity_threshold = 0.03f;
 
            VolumeCompositingMode compositing_mode = VolumeCompositingMode::kBlend;
            
            float scale_adjustment_factor = 100.0f;
            
            bool enable_lighting = false;
            bool light_local_to_eye = true;
            bool use_gradient_texture = false;
            vec3 light_direction = normalize(cgv::vec3(-1.0f, 1.0f, 1.0f));
            float ambient_strength = 0.3f;
            float diffuse_strength = 0.8f;
            float specular_strength = 0.4f;
            float roughness = 0.3f;
            float specular_color_mix = 0.0f;
 
            bool enable_gradient_modulation = false;
            float gradient_lambda = 0.0f;
 
            VolumeIsosurfaceMode isosurface_mode = VolumeIsosurfaceMode::kNone;
            float isovalue = 0.5f;
            rgb isosurface_color = { 0.7f };
            bool isosurface_color_from_transfer_function = false;
 
            VolumeSliceMode slice_mode = VolumeSliceMode::kNone;
            int slice_axis = 2;
            float slice_coordinate = 0.5f;
            float slice_opacity = 0.5f;
 
            box3 clip_box = { vec3{0.0f}, vec3{1.0f} };
        };
 
        class CGV_API volume_renderer : public renderer
        {
        private:
            cgv::render::attribute_array_manager position_aam;
        protected:
            texture* volume_texture = nullptr;
            texture* transfer_function_texture = nullptr;
            texture noise_texture = texture("uint8[R]", TF_LINEAR, TF_LINEAR, TW_REPEAT, TW_REPEAT);
            texture* gradient_texture = nullptr;
            texture* depth_texture = nullptr;
            box3 bounding_box = { vec3{0.0f}, vec3{1.0f} };
            bool apply_bounding_box_transformation = false;
            vec2 noise_offset = { 0.0f };
 
            std::string get_default_prog_name() const override { return "volume.glpr"; }
            render_style* create_render_style() const override { return new volume_render_style(); }
            void update_shader_program_options(shader_compile_options& options) const override;
            void init_noise_texture(context& ctx);
        public:
            bool init(context& ctx) override;
            void clear (const context& ctx) override;
            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) override;
            bool validate_attributes(const context& ctx) const override;
            bool disable(context& ctx) override;
            void draw(context& ctx, size_t start, size_t count,
                bool use_strips = false, bool use_adjacency = false, uint32_t strip_restart_index = -1) override;
        };
    }
}
 
#include <cgv/config/lib_end.h>