---

Scene.h

Go to the documentation of this file.

/***************************************************************************
 *cr                                                                       
 *cr            (C) Copyright 1995-2019 The Board of Trustees of the           
 *cr                        University of Illinois                       
 *cr                         All Rights Reserved                        
 *cr                                                                   
 ***************************************************************************/
/***************************************************************************
 * RCS INFORMATION:
 *
 *      $RCSfile: Scene.h,v $
 *      $Author: johns $        $Locker:  $             $State: Exp $
 *      $Revision: 1.69 $       $Date: 2020/12/24 04:21:51 $
 *
 ***************************************************************************/
#ifndef SCENE_H
#define SCENE_H

#include "Displayable.h"
#include "NameList.h"

class DisplayDevice;
class FileRenderer;
class DisplayColor;

// constants for this object
#define DISP_LIGHTS 4

// total number of colors defined here
#define REGCLRS         33
#define EXTRACLRS       1
#define VISCLRS         (REGCLRS - EXTRACLRS)
#define MAPCLRS         1024    
#define MAXCOLORS       (REGCLRS + MAPCLRS)

// where different type of colors start in indices
#define BEGREGCLRS      0
#define BEGMAP          REGCLRS

// regular (visible) colors
#define REGBLUE         0
#define REGRED          1
#define REGGREY         2
#define REGORANGE       3
#define REGYELLOW       4
#define REGTAN          5
#define REGSILVER       6
#define REGGREEN        7
#define REGWHITE        8
#define REGPINK         9
#define REGCYAN         10
#define REGPURPLE       11
#define REGLIME         12
#define REGMAUVRE       13
#define REGOCHRE        14
#define REGICEBLUE      15
#define REGBLACK        16

#define REGBLUE2        23

// macro to get colormap colors
#define MAPCOLOR(a)             (a + BEGMAP)


class ColorScale {
public:
  float min[3], mid[3], max[3];
  char name[32];

  int operator==(const ColorScale c) {
    return !memcmp(&c, this, sizeof(ColorScale));
  }
};


class Scene {
private:
  int backgroundmode;           
  int backgroundmode_changed;   
 
  struct LightState {
    float color[3];             
    float pos[3];               
    int highlighted;            
    int on;                     
  };
  int light_changed;            
  LightState lightState[DISP_LIGHTS]; 

  struct AdvancedLightState {
    float color[3];             
    float pos[3];               
    float constfactor;          
    float linearfactor;         
    float quadfactor;           
    float spotdir[3];           
    float fallstart;            
    float fallend;              
    int spoton;                 
    int highlighted;            
    int on;                     
  };
  int adv_light_changed;        
  AdvancedLightState advLightState[DISP_LIGHTS]; 

  static const float defaultColor[3L*REGCLRS];
  float colorData[3L*MAXCOLORS];
  NameList<NameList<int> *> categories;
  
  NameList<int> colorNames;
  
  int scaleActive;              
  float scaleMin, scaleMid, scaleMax;
  int scaleReverse;
  int scalePosterize;
  ResizeArray<ColorScale> colorScales;
  ResizeArray<const char *> colorScaleMenuNames;
  void create_colorscale();

  // displayables to handle the foreground and background colors of the display
  DisplayColor *background;
  DisplayColor *backgradtop;
  DisplayColor *backgradbot;
  DisplayColor *foreground;

  int background_color_changed;
  int background_color_id;

  int backgradtop_color_changed;
  int backgradtop_color_id;
  int backgradbot_color_changed;
  int backgradbot_color_id;

  int foreground_color_changed;
  int foreground_color_id;

public:
  Scene(void);            
  virtual ~Scene(void);   

  Displayable root;

  void set_background_mode(int mode);
  int  background_mode(void);

  void reset_lights(); 


  void define_light(int n, const float *color, const float *position);
  void activate_light(int n, int turnon);
  void highlight_light(int /* n */, int /* turnon */) {}
  void rotate_light(int n, float theta, char axis);
  void move_light(int n, const float *);
  const float *light_pos(int n) const; // return light position, or NULL
  const float *light_pos_default(int n) const; // return def. light position
  const float *light_color(int n) const;
  const float *light_color_default(int n) const;
  int light_active(int n) const { return lightState[n].on; }
  int light_highlighted(int) const { return FALSE; }


  void define_adv_light(int n, const float *color, const float *position,
                        float constant, float linear, float quad, 
                        float *spotdir, float fallstart, float fallend,
                        int spoton);
  void activate_adv_light(int n, int turnon);
  void highlight_adv_light(int /* n */, int /* turnon */) {}
  void move_adv_light(int n, const float *);
  const float *adv_light_pos(int n) const; // return light position, or NULL
  const float *adv_light_pos_default(int n) const; // return def. light position
  const float *adv_light_color(int n) const;
  const float *adv_light_color_default(int n) const;
  void adv_light_attenuation(int n, float constant, float linear, float quad);
  void adv_light_get_attenuation(int n, float &constant, float &linear, float &quad) const;
  void adv_light_spotlight(int n, float *spotdir, float fallstart, 
                           float fallend, int spoton);
  const float *adv_light_get_spotlight(int n, float &fallstart,
                                       float &fallend, int &spoton) const;
  int adv_light_active(int n) const { return advLightState[n].on; }
  int adv_light_highlighted(int) const { return FALSE; }


  int add_color_category(const char *catname) {
    if (categories.typecode(catname) != -1) return -1;
    return categories.add_name(catname, new NameList<int>);
  }
  int add_color_item(int cat_id, const char *name, int init_color) {
    NameList<int> *cat = categories.data(cat_id);
    return cat->add_name(name, init_color);
  }

  void set_category_item(int cat_id, int item, int color) {
    NameList<int> *cat = categories.data(cat_id);
    cat->set_data(item, color);
    root.color_changed(cat_id);
  }
  void set_color_value(int n, const float *rgb) {
    memcpy(colorData+3L*n, rgb, 3L*sizeof(float));
    root.color_rgb_changed(n);
  }

  // Returns the color index for a color category
  int get_category_item(int cat_id, int item) {
    NameList<int> *cat = categories.data(cat_id);
    return cat->data(item);
  }

  int num_categories() const { return categories.num(); }
  const char *category_name(int cat) const { return categories.name(cat); }
  int category_index(const char *catname) const { 
    return categories.typecode(catname);
  }
  int num_colors() const { return MAXCOLORS; }
  int num_regular_colors() const { return REGCLRS; }
  const char *color_name(int n) const { return colorNames.name(n); }

  int color_index(const char *name) const { return colorNames.typecode(name); }
  const float *color_value(int n) const { return colorData+3L*n; }
  const float *color_default_value(int n) const { return defaultColor+3L*n; }
  int num_category_items(int cat) const { 
    return categories.data(cat)->num(); 
  }
  const char *category_item_name(int cat, int item) const {
    return categories.data(cat)->name(item);
  }
  int category_item_index(int cat, const char *item) const {
    return categories.data(cat)->typecode(item);
  }
  int category_item_value(int cat, const char *item) const {
    return categories.data(cat)->data(item);
  }
  int category_item_value(int cat, int item) const {
    return categories.data(cat)->data(item);
  }

  int nearest_index(float r, float g, float b) const;

  void set_colorscale_params(float min, float mid, float max, 
                             int reverse, int posterize) {
    scaleMin = min; scaleMid = mid; scaleMax = max;
    scaleReverse = reverse;
    scalePosterize = posterize;
    create_colorscale();
  }
  void set_colorscale_method(int index) {
    if (scaleActive != index) {
      scaleActive = index;
      create_colorscale();
    }
  }

  int get_colorscale_colors(int whichScale, 
      float min[3], float mid[3], float max[3]);

  int set_colorscale_colors(int whichScale, 
      const float min[3], const float mid[3], const float max[3]);

  void colorscale_params(float *mid, float *min, float *max,
                         int *reverse, int *posterize) const {
    *mid = scaleMid; *min = scaleMin; *max = scaleMax; 
    *reverse = scaleReverse;
    *posterize = scalePosterize;
  }

  int colorscale_method() const { return scaleActive; }

  int num_colorscale_methods() const { return int(colorScales.num()); }
  const char *colorscale_method_name(int n) const {
    return colorScales[n].name;
  }
  const char *colorscale_method_menuname(int n) const {
    return colorScaleMenuNames[n];
  }

  int colorscale_type(int index);

 
  virtual int prepare();

  virtual void draw(DisplayDevice *);
  
  int filedraw(FileRenderer *, const char *, DisplayDevice *);

  void draw_finished();

};

#endif

---