VtkMultiTextureRenderer.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// -                        CloudViewer: www.cloudViewer.org                  -
// ----------------------------------------------------------------------------
// Copyright (c) 2018-2024 www.cloudViewer.org
// SPDX-License-Identifier: MIT
// ----------------------------------------------------------------------------
 
#pragma once
 
#include <vtkSmartPointer.h>
 
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
class vtkActor;
class vtkPolyData;
class vtkTexture;
class vtkImageData;
class vtkPolyDataMapper;
class vtkRenderer;
class vtkProperty;
 
namespace VtkUtils {
 
class VtkMultiTextureRenderer {
public:
    struct PBRMaterial {
        std::string name;  // Material name
 
        // PBR texture paths
        std::string baseColorTexture;  // Albedo/Diffuse
        std::string normalTexture;     // Normal map
        std::string metallicTexture;   // Metallic
        std::string roughnessTexture;  // Roughness
        std::string aoTexture;         // Ambient Occlusion
        std::string emissiveTexture;   // Emissive
 
        // Advanced PBR texture paths (VTK 9.2+)
        std::string sheenTexture;               // Sheen
        std::string clearcoatTexture;           // Clearcoat
        std::string clearcoatRoughnessTexture;  // Clearcoat roughness
        std::string anisotropyTexture;          // Anisotropy
 
        // Material parameters (use these values if no texture)
        float baseColor[3] = {1.0f, 1.0f, 1.0f};
        float metallic = 0.0f;
        float roughness = 0.5f;
        float ao = 1.0f;
        float emissive[3] = {0.0f, 0.0f, 0.0f};
        float opacity = 1.0f;
 
        // Advanced PBR parameters (VTK 9.2+)
        float anisotropy = 0.0f;          // Anisotropic reflection [0,1]
        float anisotropyRotation = 0.0f;  // Anisotropy rotation angle [0,1]
        float clearcoat = 0.0f;           // Clearcoat layer strength [0,1]
        float clearcoatRoughness = 0.0f;  // Clearcoat roughness [0,1]
        float sheen = 0.0f;      // Sheen for fabric-like materials [0,1]
        float sheenTint = 0.0f;  // Sheen color tint [0,1]
 
        // Phong lighting parameters (for non-PBR rendering)
        // RGB colors for ambient, diffuse, specular (can be used with
        // SetAmbientColor, etc.) Default to white (1.0, 1.0, 1.0) to match
        // baseColor and VTK defaults Ambient RGB color (white)
        float ambientColor[3] = {1.0f, 1.0f, 1.0f};
        // Diffuse RGB color (white)
        float diffuseColor[3] = {1.0f, 1.0f, 1.0f};
        // Specular RGB color (white)
        float specularColor[3] = {1.0f, 1.0f, 1.0f};
        // Intensity coefficients (for backward compatibility, used if colors
        // are uniform) Ambient intensity (legacy, use ambientColor for RGB)
        float ambient = 1.0f;
        // Diffuse intensity (legacy, use diffuseColor for RGB)
        float diffuse = 1.0f;
        // Specular intensity (legacy, use specularColor for RGB)
        float specular = 1.0f;
        // Shininess (legacy, use shininess for specular power)
        float shininess = 4.0f;
 
        // Flag to indicate if there are multiple map_Kd textures
        // VTK PBR doesn't support multiple map_Kd, so we need to use
        // traditional multi-texture rendering instead
        bool hasMultipleMapKd = false;
 
        // Check if has PBR textures
        bool hasPBRTextures() const {
            return !baseColorTexture.empty() || !normalTexture.empty() ||
                   !metallicTexture.empty() || !roughnessTexture.empty() ||
                   !aoTexture.empty();
        }
 
        // Check if has any texture
        bool hasAnyTexture() const {
            return hasPBRTextures() || !emissiveTexture.empty();
        }
    };
 
public:
    VtkMultiTextureRenderer();
    ~VtkMultiTextureRenderer();
 
    bool ApplyPBRMaterial(vtkSmartPointer<vtkActor> actor,
                          const PBRMaterial& material,
                          vtkSmartPointer<vtkPolyData> polydata,
                          vtkRenderer* renderer = nullptr);
 
private:
    enum class RenderingMode {
        PBR,       // Full PBR rendering (with PBR textures)
        TEXTURED,  // Single texture Phong rendering (only baseColor texture)
        MATERIAL_ONLY  // Pure material Phong rendering (no texture)
    };
 
    enum class TextureQuality {
        LOW,      // Low quality, fast loading
        MEDIUM,   // Medium quality
        HIGH,     // High quality
        ORIGINAL  // Original quality, no compression
    };
 
    enum class FilterMode {
        NEAREST,  // Nearest neighbor
        LINEAR,   // Linear interpolation
        MIPMAP    // Mipmap (best quality)
    };
 
    struct RenderOptions {
        TextureQuality quality = TextureQuality::HIGH;
        FilterMode filter_mode = FilterMode::MIPMAP;
        bool enable_mipmaps = true;
        bool enable_texture_cache = true;
        bool enable_compression = false;  // Texture compression (save VRAM)
        int max_texture_size = 4096;      // Maximum texture size
        bool interpolate_scalars = true;  // Scalar interpolation
        bool use_phong_shading = true;    // Use Phong shading
    };
 
    struct MaterialInfo {
        std::string name;                        // Material name
        std::string texture_file;                // Texture file path
        float ambient[3] = {1.0f, 1.0f, 1.0f};   // Ambient light
        float diffuse[3] = {1.0f, 1.0f, 1.0f};   // Diffuse
        float specular[3] = {0.0f, 0.0f, 0.0f};  // Specular
        float shininess = 0.0f;                  // Shininess
        float opacity = 1.0f;                    // Opacity
        int illum_model = 2;                     // Illumination model
    };
 
    RenderingMode DetectRenderingMode(const PBRMaterial& material) const;
 
    bool ApplyPBRRendering(vtkSmartPointer<vtkActor> actor,
                           const PBRMaterial& material,
                           vtkSmartPointer<vtkPolyData> polydata,
                           vtkRenderer* renderer,
                           float metallic,
                           float roughness,
                           float ao,
                           float opacity);
 
    bool ApplyTexturedRendering(vtkSmartPointer<vtkActor> actor,
                                const PBRMaterial& material,
                                float opacity);
 
    bool ApplyMaterialOnlyRendering(vtkSmartPointer<vtkActor> actor,
                                    const PBRMaterial& material,
                                    float opacity);
 
    void SetProperties(vtkProperty* property,
                       const PBRMaterial& material,
                       float opacity);
 
    vtkSmartPointer<vtkTexture> LoadTexture(const std::string& texture_path,
                                            const RenderOptions& options);
 
private:
    struct Impl;
    std::unique_ptr<Impl> impl_;
    RenderOptions default_options_;
 
    // Texture cache: path -> texture
    std::unordered_map<std::string, vtkSmartPointer<vtkTexture>> texture_cache_;
 
    // Texture memory usage statistics
    std::unordered_map<std::string, size_t> texture_memory_usage_;
};
 
}  // namespace VtkUtils