Context.h

/********************************************************************/
/* Copyright (c) 2015 DG Technologies Inc. and Yuzi Mizuno          */
/* All rights reserved.                                             */
/********************************************************************/

#ifndef _MGContext_HH_
#define _MGContext_HH_

#include "mg/Pvector.h"
#include "mg/Attrib.h"
#include "mgGL/Color.h"
#include "mgGL/Appearance.h"
#include "mgGL/SnapAttrib.h"
#include "mgGL/glViewAttrib.h"
#include "Tl2/TLInputParam.h"


class MGOpenGLView;
class MGOfstream;
class MGIfstream;


class MG_DLL_DECLR MGContext: public MGAttrib{

public:

MGContext();
MGContext(const MGBox& bx);

MGContext(
    const MGSnapAttrib& snap_attrib,
    
    int line_density,       
    const MGColor& Bcolor,  
    const MGColor& Gcolor,  
    const MGColor& Hcolor,  
    float smooth,   
    float pick_aperture,
    const MGglViewAttrib& view,
    const MGColor gridColor[4],

    const int gridNum[2], 
    const double gridSpan[2], 
    
    const double torelance[6],
    const mgTLInputParam& tessellate_param,
    MGAppearance* appearance=0
);

MGContext(const MGContext& context);


~MGContext();

void InitializeCPlane(const MGBox& box);

MGContext& operator=(const MGGel& gel2);
MGContext& operator=(const MGContext& gel2);

bool operator<(const MGContext& gel2)const;
bool operator<(const MGGel& gel2)const;

MGContext* clone()const{return new MGContext(*this);};

const MGSnapAttrib& snap_attrib()const{return m_snap_attrib;}; //Snap data
MGSnapAttrib& snap_attrib(){return m_snap_attrib;}; //Snap data
void set_snap_attrib(const MGSnapAttrib& snap_attrib){m_snap_attrib=snap_attrib;};

//set/get line_density attrib data.
int line_density()const{return m_line_density;};
void set_line_density(int line_density){m_line_density=line_density;};


const MGColor& Bcolor()const{return m_Bcolor;};

MGColor& Bcolor(){return m_Bcolor;};

void set_Bcolor(const MGColor& Bcolor);

const MGColor& Gcolor()const{return m_Gcolor;};

MGColor& Gcolor(){return m_Gcolor;};

void set_Gcolor(const MGColor& Gcolor);

const MGColor& Hcolor()const{return m_Hcolor;};

MGColor& Hcolor(){return m_Hcolor;};

void set_Hcolor(const MGColor& Hcolor);


const MGColor* gridColors()const{return m_gridColor;};
const int* gridNum()const{return m_gridNum;};
const double* gridSpan()const{return m_gridSpan;};
void set_gridColors(const MGColor gridColor[4]);
void set_gridNum(const int gridNum[2]);
void set_gridSpan(const double gridSpan[2]);

// Grid color operations.
const MGColor& gridColor()const{return m_gridColor[0];};

MGColor& gridColor(){return m_gridColor[0];};

void set_gridColor(const MGColor& color){m_gridColor[0] = color;};

// X-axis(u-axis) color operations.
const MGColor& axisXcolor()const{return m_gridColor[1];};

MGColor& axisXcolor(){return m_gridColor[1];};

void set_axisXcolor(const MGColor& color){m_gridColor[1] = color;};

// Y-axis(v-axis) color operations.
const MGColor& axisYcolor()const{return m_gridColor[2];};

MGColor& axisYcolor(){return m_gridColor[2];};

void set_axisYcolor(const MGColor& color){m_gridColor[2] = color;};

// Z-axis color operations.
const MGColor& axisZcolor()const{return m_gridColor[3];};

MGColor& axisZcolor(){return m_gridColor[3];};

void set_axisZcolor(const MGColor& color){m_gridColor[3] = color;};

float smooth()const{return m_smooth;};  

void set_smooth(float smooth){m_smooth=smooth;};

float pick_aperture()const{return m_pick_aperture;};
void set_pick_aperture(double pick_aperture){m_pick_aperture=float(pick_aperture);};
void set_pick_aperture(float pick_aperture){m_pick_aperture=pick_aperture;};

const MGglViewAttrib& theView()const{return m_view;};
MGglViewAttrib& theView(){return m_view;};

void set_view(
    const MGglViewAttrib& view
);

void set_view_context(
    const MGOpenGLView& view
);

void applyDrawAttrib(MGOpenGLView& view);

double* tolerance(){return m_tolerance;};
const double* tolerance()const{return m_tolerance;};
void set_tolerance(
    double wc_zero,
    double rc_zero,
    double mach_zero,
    double line_zero,
    double angle_zero,
    double max_knot_ratio
);

const mgTLInputParam& tessellate_param()const{return m_tessellate_param;};
mgTLInputParam& tessellate_param(){return m_tessellate_param;};
void set_tessellate_param(const mgTLInputParam& tessellate_param){
    m_tessellate_param=tessellate_param;};

double tess_maximum_edge_length()const{return m_tessellate_param.max_edge_len();};
double tess_surface_tolerance()const{return m_tessellate_param.surfTol();};
double tess_curve_tolerance()const{return m_tessellate_param.crvTol();};

const MGAppearance* appearance()const{return m_appearance;};
MGAppearance* appearance(){return m_appearance;};

void set_appearance(
    MGAppearance* appearance    
);

long identify_type() const{return MGCONTEXT_TID;};


void exec_tolerance()const;

void exec_draw_attributes(mgVBO& vbo)const;

void exec_render_attributes(mgVBO& vbo)const;

std::ostream& out(std::ostream& ostrm) const;

std::string whoami()const{return "Context";};

void ReadMembers(MGIfstream& buf);
void WriteMembers(MGOfstream& buf)const;

private:

    MGSnapAttrib m_snap_attrib;
    

        int m_line_density;
        MGColor m_Bcolor;   
        MGColor m_Gcolor;   
        MGColor m_Hcolor;   
        float m_smooth; 
        float m_pick_aperture;
        MGglViewAttrib m_view;
        MGColor m_gridColor[4];
            //[0]=grid color, [1]=X-axis color, [2]=Y-axis color, [3]=Z-axis color.
        int m_gridNum[2]; 
        double m_gridSpan[2];



    double m_tolerance[6];
    mgTLInputParam m_tessellate_param;
    MGAppearance* m_appearance;

    //void setDefaultTolerance();
};
 // end of DisplayHandling group
#endif //#ifndef _MGContext_HH_