render_options.h

// -*-c++-*-
#ifndef STORMM_RENDER_OPTIONS_H
#define STORMM_RENDER_OPTIONS_H
 
#include <string>
#include <vector>
#include "copyright.h"
#ifndef STORMM_USE_HPC
#  include "DataTypes/stormm_vector_types.h"
#endif
#include "reporting_enumerators.h"
 
namespace stormm {
namespace review {

constexpr double default_rec_bond_thickness  = 1.5;
constexpr double default_lig_bond_thickness  = 2.5;
constexpr double default_border_thickness    = 1.5;
constexpr double default_rec_light_atom_size = 12.0;
constexpr double default_rec_heavy_atom_size = 20.0;
constexpr double default_lig_light_atom_size = 16.0;
constexpr double default_lig_heavy_atom_size = 24.0;
constexpr double default_wat_light_atom_size = 8.0;
constexpr double default_wat_heavy_atom_size = 16.0;
constexpr double default_added_point_size    = 8.0;
constexpr LinePlotStyle default_border_style = LinePlotStyle::SOLID;
constexpr uchar4 default_rec_bond_color      = {  48,  48,  48, 255 };
constexpr uchar4 default_lig_bond_color      = { 128, 224, 224, 255 };
constexpr uchar4 default_border_line_color   = { 128, 128, 128, 255 };
constexpr uchar4 default_added_point_color   = { 168,   0,  39, 255 };
constexpr char default_lighting_mode[] = "gouraud";
constexpr char default_camlight_position[] = "right";

constexpr int maximum_line_width = 16;
constexpr int maximum_marker_size = 64;
  
//-------------------------------------------------------------------------------------------------
class RenderOptions {
public:

  RenderOptions();

  RenderOptions(const RenderOptions &original) = default;
  RenderOptions(RenderOptions &&original) = default;
  RenderOptions& operator=(const RenderOptions &original) = default;
  RenderOptions& operator=(RenderOptions &&original) = default;
  
  double getReceptorLineWidth() const;

  double getLigandLineWidth() const;

  double getReceptorLightAtomSize() const;

  double getReceptorHeavyAtomSize() const;

  double getLigandLightAtomSize() const;

  double getLigandHeavyAtomSize() const;

  double getWaterLightAtomSize() const;

  double getWaterHeavyAtomSize() const;

  double getAddedPointSize() const;

  const std::string& getReceptorHighlight() const;
  
  const std::string& getLigandHighlight() const;
  
  uchar4 getReceptorLineColor() const;

  std::string getFormattedReceptorLineColor(GridFileSyntax syntax) const;
  
  uchar4 getLigandLineColor() const;

  std::string getFormattedLigandLineColor(GridFileSyntax syntax) const;

  uchar4 getAddedPointColor() const;

  std::string getFormattedAddedPointColor(GridFileSyntax syntax) const;

  bool displayFieldBorders() const;

  double getBorderLineWidth() const;

  LinePlotStyle getBorderLineStyle() const;

  
  uchar4 getBorderLineColor() const;

  std::string getFormattedBorderColor(GridFileSyntax syntax) const;
  
  const std::string& getLightingMode() const;

  const std::string& getCamlightPosition() const;

  int getIsosurfaceCount() const;
  
  double getIsosurfaceValue(int index) const;

  uchar4 getIsosurfaceColor(int index) const;

  SurfaceRender getIsosurfaceDrawingMethod(int index) const;

  uchar4 getElementColor(int z_number) const;

  std::string getFormattedElementColor(int z_number, GridFileSyntax syntax) const;

  const RenderOptions* getSelfPointer() const;
  
  void setReceptorLineWidth(double width_in);
  
  void setLigandLineWidth(double width_in);

  void setReceptorLightAtomSize(double marker_size_in);

  void setReceptorHeavyAtomSize(double marker_size_in);

  void setLigandLightAtomSize(double marker_size_in);

  void setLigandHeavyAtomSize(double marker_size_in);

  void setWaterLightAtomSize(double marker_size_in);

  void setWaterHeavyAtomSize(double marker_size_in);

  void setAddedPointSize(double marker_size_in);

  void setPotentialFieldBorderDisplay(bool display_borders_in);

  void setFieldBorderLineWidth(double width_in);

  void setFieldBorderStyle(LinePlotStyle style_in);

  void setFieldBorderColor(const uchar4 color_in);
  
  void setReceptorHighlight(const std::string &highlight_in);
  
  void setLigandHighlight(const std::string &highlight_in);

  void setReceptorLineColor(const uchar4 color_in);
  void setReceptorLineColor(double red_in, double green_in, double blue_in);

  void setLigandLineColor(const uchar4 color_in);
  void setLigandLineColor(double red_in, double green_in, double blue_in);
  
  void setAddedPointColor(const uchar4 color_in);
  void setAddedPointColor(double red_in, double green_in, double blue_in);

  void setAtomicElementColor(int z_number, const uchar4 color_in);
  void setAtomicElementColor(int z_number, double red_in, double green_in, double blue_in);

  void setLightingMode(const std::string &mode_in);

  void setCamlightPosition(const std::string &position_in);

  void addIsosurface(double value_in, const uchar4 color_in, SurfaceRender material_in);
  void addIsosurface(double value_in, const double4 color_in, SurfaceRender material_in);
  
private:
  double receptor_bond_thickness;     
  double ligand_bond_thickness;       
  double rec_light_atom_marker_size;  
  double rec_heavy_atom_marker_size;  
  double lig_light_atom_marker_size;  
  double lig_heavy_atom_marker_size;  
  double wat_light_atom_marker_size;  
  double wat_heavy_atom_marker_size;  
  double added_point_marker_size;     
 
  // The following member variables control definition of the borders for a potential field plotted
  // against the scene.
  bool display_field_borders;       
  double border_line_thickness;     
  LinePlotStyle border_line_style;  
  uchar4 border_line_color;         
  
  // The following member variables control highlighting, placing circles around additional atom
  // series.  Each string is translated into an atom mask to produce the relevant list of atoms.
  std::string receptor_highlight;  
  std::string ligand_highlight;    
 
  // The following member variables control colors for atoms, bonds, and points.
  uchar4 receptor_line_color;          
  uchar4 ligand_line_color;            
  uchar4 added_point_color;            
  std::vector<uchar4> element_colors;  
  std::string lighting_mode;           
  std::string camlight_position;       
 
  // The following member variables control isosurface depictions.
  int isosurface_count;                             
  std::vector<double> isosurface_values;            
  std::vector<uchar4> isosurface_colors;            
  std::vector<SurfaceRender> isosurface_materials;  

  void checkIsosurfaceIndex(int index) const;

  void checkZNumber(int z_number, const char* caller) const;
  
  void checkLineWidth(double width_in, const char* caller = nullptr) const;

  void checkMarkerSize(double marker_size_in, const char* caller = nullptr) const;

  void checkColorRanges(double red_in, double green_in, double blue_in,
                        const char* caller = nullptr) const;
};

std::vector<uchar4> getDefaultElementColors();

std::string formatColor(const uchar4 color_in, GridFileSyntax syntax);
 
} // namespace review
} // namespace stormm
 
#endif