openglView.h

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

class MGBox;
class MGGroup;
class MGObject;
class MGGLAttrib;
class MGAttribedGel;
class MGGelPositions;
class MGStraight;
class MGEdge;
class mgVBO;

#include <afxwin.h>
#include <GL/glew.h>
#include <list>
#include <set>
#include <glm/glm.hpp>
#include "mg/Types.h"
#include "mg/Pvector.h"
#include "mg/PickObjects.h"
#include "mg/Position.h"
#include "mg/Straight.h"
#include "mg/Group.h"
#include "mgGL/Color.h"
#include "mgGL/sysGLList.h"
#include "mgGL/glViewAttrib.h"
#include "mgGL/ConstructionPlane.h"
#include "mgGL/glslprogram.h"


class MG_DLL_DECLR MGOpenGLView{

friend class MGglViewAttrib;

public:


mgSysGLList m_sysgllist;


MGOpenGLView(
    bool perspective=true   
);

MGOpenGLView(
    const MGglViewAttrib& glatr
);

virtual ~MGOpenGLView();


int attach_drawer(
    mgVBO* drawer
    ,bool common=true
);

void detach_drawer(
    mgVBO* drawer
    ,bool common=true
);

void copy(const MGOpenGLView& glview2);

void copy(const MGglViewAttrib& glatr);

const MGColor& Bcolor()const;
const MGColor& Gcolor()const;
static const MGColor& Hcolor(){return mgVBOElement::getHilightColor();};

//static const MGColor& BcolorDefault(){ return m_BcolorDefault;};
//static const MGColor& GcolorDefault(){ return m_GcolorDefault;};
//static const MGColor& HcolorDefault(){ return m_HcolorDefault;};

const MGPosition& center()const{return m_viewAttrib.center();};

const MGConstructionPlane& cplane()const{return m_viewAttrib.cplane();};
MGConstructionPlane& cplane(){return m_viewAttrib.cplane();};

bool DeleteDisplayList_by_function(int fc){
    return m_sysgllist.delete_lists_by_function_code(fc);
}

bool DeleteDisplayList_by_function_object_code(int fc,const MGGel* gel){
    return m_sysgllist.delete_lists_by_function_object_code(fc,gel);
}

double diameter()const{return m_viewAttrib.diameter();};

const MGDrawParam& draw_param()const;
MGDrawParam& draw_param();

int line_density()const{return draw_param().line_desity_wire_face();};

void execDefaultStaticAttrib();

void drawScene(const MGPickObjects* pobjs=0);

void enable_grid_snap(bool bEnabled);

const MGPosition& eye_position()const{return m_viewAttrib.eye_position();};

void get_model_matrix(
    glm::mat4& modelMat //double modelMat[16] ///<OpenGL's model matrix
)const;

void get_projection_matrix(
    const int vp[4],
    glm::mat4& projMat  //double projMat[16]    ///<OpenGL's projection matrix
)const;

bool get_surface_parameter_glv(
    const MGFSurface& surf,
    int sx, 
    int sy, 
    MGPosition& uv  
)const;

//SysGLリストのを取得する
mgSysGL* getSysGLByFunctionCode(int fc){return m_sysgllist.getSysGLByFunctionCode(fc);};

void get_viewport(
    glm::ivec4& vp
)const;
void get_viewport(
    int vp[4]
)const;

void get_window(int& width, int& height)const;

HDC getHDC() const{return m_hDC;};

HGLRC getRC() const{return m_hRC;};

MGOpenGLView* get_parent_OpenGLView(){return m_parent_glView;};
const MGOpenGLView* get_parent_OpenGLView()const{return m_parent_glView;};
bool has_parent_OpenGLView()const{return m_parent_glView!=0;};

static MGOpenGLView* getCurrentOpenGLView(){return m_currentGLView;};

bool has_display_list()const;

void home(){m_viewAttrib.setHomeMatrix();};

void import_context(
    const MGContext& ctx
);

void importViewAttribFromContext(
    const MGContext& ctx
);

void importDrawAttribFromContext(
    const MGContext& ctx
);

void importGridAttrib(const MGContext& ctx);

//Initialize the viewing environment.
//When the eye position is necessary to update, setEyePositionUpVector() must be invoked
//before initializeViewingEnvironmentByBox since the current eye position direction is used.
//Initialization is done by the parameter box.
//initializeViewingEnvironmentByBox updates only the construction plane's (u,v) direction.
//The (u,v) direction is (up-vector*eyePosition, up-vector).
void initializeViewingEnvironmentByBox(
    const MGBox& box
);

void initialize_viewing_environment(
    const MGPlane& plane,
    double diameter,
    bool rotate=false
);

bool is_enabled_grid_snap()const;

bool is_perspective() const{return m_viewAttrib.is_perspective();};

MGPosition locate_glv(int x, int y, MGPosition* uv=0)const;

void make_construction_plane(
    const MGPosition& mid,  
    const MGVector& uderi,  
    const MGVector& vderi,  
    double uspan,           
    double vspan,           
    int ulnum,          
    int lnum            
);

void make_display_list(const MGContext& ctx,const MGGroup& grp);

void mglTranslate(const glm::vec3& vec);
void mglRotate(float angle, const glm::vec3& axis);
void mglScale(const glm::vec3& factor);

void pan_zoom(int x0, int y0, int x1, int y1);

void pan_zoom(const MGBox& box);

MGPickObjects pick_glv(
    const float center[2],  
    float aperturex=-1.,
    float aperturey=-1.,
    const MGAbstractGels& objtype=mgAll_Object
);

int pick_start_end_glv(
    const MGCurve& curve,
    int sx, 
    int sy  
);

int pick_perimeter_glv(
    const MGSurface& surf,
    int sx, 
    int sy,
    MGPosition* uv=0,   
    float aperturex=-1.,
    float aperturey=-1.
);

const MGEdge* pick_edge_glv(
    const MGFace& f,
    int sx, 
    int sy,
    MGPosition* uv=0,   
    float aperturex=-1.,
    float aperturey=-1.
);

float pick_aperture()const;

int pick_to_select_buf(
    const float center[2],
    const float delta[2],
    mgVBO* display_list,
    std::set<unsigned>& selected
);


void project(
    const MGPosition& world,
    MGPosition& screen,
    const glm::mat4* modelMat=0,    
    const glm::mat4* projlMat=0,    
    const glm::ivec4* vp=0      
)const;

mgSysGL* push_back_to_sysgl(int fc,const MGGel* oi=0){return m_sysgllist.push_back(fc,oi);};
mgSysGL* push_front_to_sysgl(int fc,const MGGel* oi=0){return  m_sysgllist.push_front(fc,oi);};

void push_back_to_sysgl(mgSysGL* sysgl){m_sysgllist.push_back(sysgl);};

void rotate(float angle, float x, float y, float z);

void rotate(float angle, float vector[3], const MGPosition& center);

void rotate(const float angle[2]);

void scale(
    double factor,  
    int* center=0
);

void set_center(const MGPosition& pos){ m_viewAttrib.set_center(pos);}
void set_center_current(int x, int y);

void set_line_density(int line_density=1);

//Set line density and tessellation parameter of draw_param.
void setDrawParam(const MGContext& ctx);

void setProjectionMat2GLSL(bool initialize=false);

void setModelViewMat2GLSL();

void setNdcMat2GLSL();

void set_output_dpi(float dpi){m_dpi = dpi;};

float get_output_dpi(){return m_dpi;};

void setDpiFactor2GLSL();

void setEyePositionUpVector(
    const MGPosition& eyeP,
    const MGVector& upVector
);

void set_parent_OpenGLView(MGOpenGLView* parent=0);

void setBcolor(const MGColor& color);

void set_fovy(double fovy){m_viewAttrib.set_fovy(fovy);};

//void set_defalut_colors();

void setGcolor(const MGColor& color);

static void setHcolor(const MGColor& color){mgVBOElement::setHilightColor(color);};

void set_pick_aperture(double pick_aperture);
void set_pick_aperture(float pick_aperture);

void set_smooth(float smooth);

void set_window(int width, int height);

void setProjModelViewMat2GLSL();

float smooth()const;

double span_length()const{return m_viewAttrib.diameter()*double(smooth())*.1;};

void translate(double dx, double dy);

void translate_without_scale(double dx, double dy);

void unproject(
    int x,
    int y,
    MGStraight& sl, 
    MGCSisect& is   
)const;

void unproject_to_sl_glv(int x, int y, MGStraight& sl)const;

const MGVector& view_up_vector()const{return m_viewAttrib.view_up_vector();};

double view_volume_far()const{return m_viewAttrib.view_volume_far();}

double view_volume_height()const{return m_viewAttrib.view_volume_height();}

double view_volume_near()const{return m_viewAttrib.view_volume_near();}

double get_scale() {return m_viewAttrib.m_scale;};

void get_near_position(
    const MGCurve* crv, 
    const float center[2],
    double& t   
);

mgVBO* display_list();

void set_display_list(
    mgVBO* dlist
){m_display_list=dlist;};

void setViewMode(MGCL::VIEWMODE vmode=MGCL::WIRE);

void makeRCCurrent()const;

void setDCRC(HDC dc, HGLRC rc);

void setupDrawEnv(const MGColor& backColor, bool selection=false);

void screen_to_world(
    int wh[2],  
    double sx,  
    double sy,  
    double& wx,
    double& wy
)const;

const MGglViewAttrib& viewAttrib()const{return m_viewAttrib;};
MGglViewAttrib& viewAttrib(){return m_viewAttrib;};

MGCL::VIEWMODE viewMode()const{return m_viewAttrib.viewMode();};

protected:
    int m_width, m_height;//Window's width and height.

    MGOpenGLView* m_parent_glView;
    
    mgVBO* m_display_list;


    //for OpenGL State machine 
    HGLRC m_hRC;    
    HDC m_hDC;      

    MGColor m_Bcolor;   
    MGColor m_Gcolor;   
    float m_smooth; 
    float m_pick_aperture;

    MGglViewAttrib m_viewAttrib;
    
    glm::mat4 m_lookAtMat;

    glm::vec3 m_XAxis_current;
    glm::vec3 m_center_current;
    glm::vec3 m_up_vector_current;

    glm::mat4 m_projMat;


    float m_dpi; // output device independ value;

//Highlight pobjs.
void highlight(const MGPickObjects* pobjsP);

void set_perspective(bool pers,double fovy=45.){
    m_viewAttrib.set_perspective(pers,fovy);
};

private:

    static MGOpenGLView* m_currentGLView;
    //static MGColor m_BcolorDefault;   ///<Default Background color.
    //static MGColor m_GcolorDefault;   ///<Default Object lines color.
    //static MGColor m_HcolorDefault;   ///<Default Object highlight color.

std::list<mgVBO*> m_command_drawersCommon;

std::list<mgVBO*> m_command_drawersSpecific;

void extractSelected(
    const int viewport[4],
    std::set<unsigned>& selected
);

void drawCommandDrawer(
    std::list<mgVBO*>& drawers
);

void setLookAtMat();

};

unsigned OpenGLStartDisplayName();


 // end of DisplayHandling group
#endif