VBO.h

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

#if !defined(_MGVBO__INCLUDED_)
#define _MGVBO__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include "MGCLStdAfx.h"
#include "mg/Pvector.h"
#include "mg/drawParam.h"
#include "mgGL/glslprogram.h"
#include "mgGL/StaticGLAttrib.h"
#include "mgGL/Color.h"
#include "mgGL/GLAttrib.h"
#include "mgGL/VBOElement.h"
#include "mgGL/VBOLeafBuilder.h"

class MGPosition;
class MGBox;
class MGBPointSeq;
class MGSPointSeq;
class MGCurve;
class MGSPointSeq;
class MGCellBase;
class mgTL2Triangles;
class MGStl;
class MGColor;
class MGAttribedGel;
class mgVBO;
class MGComplex;
class MGImage;


// Vertex Buffer Object Class.



class MG_DLL_DECLR mgVBO:public mgVBOElement{

friend class MGDNameControl;
friend class MGAttribedGel;
friend class mgVBOPointer;

// オペレーション
public:
enum ELEMENT_TARGET{
    WIRE=0,
    SHADING=1,
    BOTH
};

typedef MGPvector<mgVBOElement> container_type;
typedef container_type::iterator iterator;
typedef container_type::const_iterator const_iterator;

mgVBO();

mgVBO(const MGAttribedGel& gel);

mgVBO(const mgVBO& vbo);

mgVBO& operator=(const mgVBO& vbo);

virtual ~mgVBO();

void initializeVBO(MGCL::VIEWMODE viewMode=MGCL::DONTCARE);

bool buildVBOHierarchy(
    mgVBO& parent,
    std::vector<mgVBO*>& vbos
);

virtual void make_display_list(MGCL::VIEWMODE vmode=MGCL::DONTCARE);

virtual void draw(MGCL::VIEWMODE viewMode=MGCL::DONTCARE);

virtual void redraw(MGCL::VIEWMODE viewMode=MGCL::DONTCARE);

virtual void selectionDraw(MGCL::VIEWMODE viewMode=MGCL::DONTCARE);

void highlight();

virtual void clearElements(mgVBO::ELEMENT_TARGET target=BOTH);

virtual void clearStaticAttributes();

mgVBOElement* back()const{return m_target_elements->back();};
mgVBOElement* front()const{return m_target_elements->front();};

iterator begin_element(){return m_target_elements->begin();};
iterator end_element(){return m_target_elements->end();};
const_iterator begin_element()const{return m_target_elements->begin();};
const_iterator end_element()const{return m_target_elements->end();};
int elementNumber()const{return (int)m_target_elements->size();};
void pop_back_element(){m_target_elements->pop_back();};
void push_back_element(mgVBOElement* elm){m_target_elements->push_back(elm);};

unsigned getDName()const{return m_dname;};

MGAttribedGel* gel()const{return m_gel;};

virtual GLuint getSelectionName()const;

virtual bool is_made(MGCL::VIEWMODE viewMode=MGCL::DONTCARE);

bool is_InBegin();

virtual void Begin(GLenum type, ELEMENT_TARGET target=WIRE);

virtual mgVBOLeaf* End(GLenum polygonMode=GL_FILL);

void setDirty(bool is_dirty=true, mgVBO::ELEMENT_TARGET target=BOTH)const;

//void setFunctionID(int functionID);
void setDrawType(mgGLSL::DrawType drawType);

void setTexture(mgTexture* texture);

void Color(const MGColor& colr);
void Color3fv(const float colr[3]);
void Color3dv(const double colr[3]);
void Color4fv(const float colr[4]);
void Color4ubv(const unsigned char rgba[4]);

void Normal(const MGVector& norml);
void Normal(float x, float y, float z);
void Normal3d(double x, double y, double z);
void Normal3fv(const float norml[3]);
void Normal3dv(const double norml[3]);

virtual void Vertex(const MGPosition& v);
virtual void Vertex(float x, float y, float z=0.0f);
virtual void Vertex3d(double x, double y, double z=0.0);
virtual void Vertex2fv(const float v[2]);
virtual void Vertex3fv(const float v[3]);
virtual void Vertex2dv(const double v[2]);
virtual void Vertex3dv(const double v[3]);

void TexCoord(const MGPosition& v);
void TexCoord(float x, float y);
void TexCoord2d(double x, double y);
void TexCoord2fv(const float v[2]);
void TexCoord2dv(const double v[2]);


void setStaticAttribColor(const MGColor& color);//colorにはundefinedのものも許される
void setStaticAttribColor(const float color[4]);
void setStaticAttribColor(float r, float g, float b);
void setStaticAttribLineWidth(GLfloat size);
void setStaticAttribPointSize(GLfloat size);

void setLineStipple(short int factor, GLushort pattern=0);

void LineWidth(GLfloat size){setStaticAttribLineWidth(size);};

void disableLinePattern();


void drawGel(const MGAttribedGel& gel);

void drawVBOLeaf(
    const mgVBOLeaf& leaf,
    ELEMENT_TARGET target=SHADING
);

void deleteGel(const MGAttribedGel& gel);

//Draw an arrow symbol with implementation of OpenGL.
//data[0] is the origin of the arrow, data[1] is the top of the arrow,
//data[2], [3] are two bottoms of arrowhead.
void drawArrow(const MGPosition pos[4]);

void drawBox(const MGBox& box);

void drawPointSeq(
    const MGBPointSeq& bp,
    bool draw_points=true   
);
void drawPointSeq(
    const MGSPointSeq& sp,
    bool draw_points=true   
);

//Draw 3D point(vertex) in world coordinates.
//The object is converted to point(s) and is drawn.
//This is valid only for topology objects or MGPoint.
void draw3DVertex(const MGObject& obj);
void draw3DVertex_in_star(const MGComplex& obj);
void draw3DVertex_in_star(const MGCellBase& obj);

void drawWire_in_star(const MGComplex& obj);
void drawWire_in_star(const MGCellBase& obj);

double drawCurvaGraph(
    const MGCurve& curve,
    double scale,
    int density,
    bool use_radius,
    bool getLength=false
);

void drawPoint(double x,double y,double z, double size=-1.);
void drawPoint(const MGPosition& pos, double size=-1.);
void drawPointInverseColor(double x,double y,double z, double size=-1.);
void drawPointInverseColor(const MGPosition& pos, double size=-1.);

void drawPointWithColor(double x,double y,double z,
    double outerSize, double innerSize,
    const MGColor* colorInner=0, const MGColor* colorOuter=0
);

void drawPointWithColor(const MGPosition& pos,
    double outerSize, double innerSize,
    const MGColor* colorInner=0, const MGColor* colorOuter=0
);

void drawPoints(
    const MGColor& boundary_color,
    const MGColor& inner_color,
    const std::vector<MGPosition>& ipos,
    double size=-1.
);

void drawPolyline(const MGBPointSeq& line, bool closed=false);

void drawPolyline(const std::vector<MGPosition>& line, bool closed=false);

void drawStraight(const MGPosition& end, const MGPosition& start);

//Draw an object in its parameter space(MGDraw_in_parameter_space).
//This is valid only for Surface, Face, Loop, Edge.
void drawObjInParameterSpace(const MGObject& obj);

void drawRectangle(
    const MGBox& box    //Box to draw.
);

//void drawWTess(
//  const mgTLData& tld //tessellation data.
//);

//void drawPTess(
//  const mgTLData& tld //tessellation data.
//);

void drawSurfaceCurvature(
    const mgTL2Triangles& tld,
    MGCL::SURFACE_CURVATURE_KIND kind,
    double lower, double upper //minimum and maximum value of the curvatures of the kind.
);

void drawSurfaceCurvature(
    const std::vector<mgTL2Triangles>& tldvec,
    MGCL::SURFACE_CURVATURE_KIND kind,
    double lower,
    double upper 
);

void drawShade(
    const mgTL2Triangles& tris,
    ELEMENT_TARGET target=SHADING,
    GLenum polygonMode=GL_FILL//Polygon mode to draw, GLPOINT, GL_LINE, or GLFILL.
);

void drawShade(
    const std::vector<mgTL2Triangles>& trisVector,
    ELEMENT_TARGET target=SHADING,
    GLenum polygonMode=GL_FILL//Polygon mode to draw, GLPOINT, GL_LINE, or GLFILL.
);

void drawSTL(
    const MGStl& stl, 
    ELEMENT_TARGET target=SHADING,
    GLenum polygonMode=GL_FILL
);

void setDrawParam(const MGDrawParam& dpara){mgVBOElement::setDrawParam(dpara);};
//const MGDrawParam& getDrawParam()const{return mgVBOElement::getDrawParam();};
//const MGColor& getHilightColor()const{return mgVBOElement::getHilightColor();};
GLfloat getPointSize()const;
GLfloat getLineWidth()const;

const MGColor& staticColor()const{return m_colorStatic;};
MGColor& staticColor(){return m_colorStatic;};

void setLightMode(int mode){m_lightMode=mode;};
int getLightMode(){return m_lightMode;};

protected:

    unsigned m_dname;
    MGAttribedGel* m_gel;

    MGPvector<mgVBOElement>* m_target_elements;

    mutable bool m_elementsDirty:1;
    MGPvector<mgVBOElement> m_elements;

    mutable bool m_elementsShadeDirty:1;
    MGPvector<mgVBOElement> m_elementsShade;

    MGColor m_colorStatic;

    GLfloat m_lineWidthStatic;

    GLfloat m_pointSizeStatic;

    short int m_stippleFactor;
    GLushort m_LineStipplePattern;

    int m_lightMode;

    mgGLSL::CoordinateType m_coordinateType;

    std::auto_ptr<mgVBOLeafBuilder> m_builder;

void execStaticColorAttrib(){mgGLSL::execStaticColorAttrib(m_colorStatic);};

virtual void execStaticGLAttrib();

virtual void execModelTypeAttrib();

void setDlName(unsigned name){m_dname=name;};
void setGel(const MGAttribedGel* gel);

void setElementTarget(ELEMENT_TARGET target);

};

namespace MGCL{

MG_DLL_DECLR double getCurveCurvatureLength(
    const MGCurve& curve, double scale, int density, bool use_radius
);

}


class MG_DLL_DECLR mgLightModeSwitcher{
public:
    mgLightModeSwitcher(mgVBO& vbo, mgGLSL::ShadeMode mode):m_vbo(vbo){
        m_orgMode = m_vbo.getLightMode();
        m_vbo.setLightMode(mode);
    };

    ~mgLightModeSwitcher(){
        m_vbo.setLightMode(m_orgMode);
    };

private:
    mgVBO& m_vbo;
    int m_orgMode;
};
 // end of DisplayHandling group
#endif // !defined(_MGVBO__INCLUDED_)