/************************************************************************
Yutaka Ohtake 

CMeshEditorView.h
Window 

Copyright (c) 1999-2001 
The University of Aizu. All Rights Reserved.
************************************************************************/

#if !defined(AFX_MESHEDITORVIEW_H__74788752_75B0_4E94_BF2C_35A23657F977__INCLUDED_)
#define AFX_MESHEDITORVIEW_H__74788752_75B0_4E94_BF2C_35A23657F977__INCLUDED_

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

#include <gl\gl.h>
#include <gl\glu.h>
#include <math.h>

class CMeshEditorView : public CView
{
protected: // シリアライズ機能のみから作成します。
	CMeshEditorView();
	DECLARE_DYNCREATE(CMeshEditorView)

// アトリビュート
public:
	CMeshEditorDoc* GetDocument();
	GLfloat Rx,Ry,Rz;
	int color_type;
// オペレーション
public:

// オーバーライド
	// ClassWizard は仮想関数のオーバーライドを生成します。
	//{{AFX_VIRTUAL(CMeshEditorView)
	public:
	virtual void OnDraw(CDC* pDC);  // このビューを描画する際にオーバーライドされます。
	virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
	protected:
	//}}AFX_VIRTUAL

// インプリメンテーション
public:
	void line(float p1[3], float p2[3], float r, float n[3]);
	void drawVertexCluster(MeshData *mesh, Node** cluster, BOOL gray_scale);
	void wireFrame(MeshData *mesh);
	void drawTagEdges(MeshData *mesh, Node **ridge_pair, Node **ravine_pair, BOOL transparent, BOOL grey_scale, BOOL shaded);
	void drawRidgePath(MeshData* mesh, Node*** normal_path, int* normal_path_N, Node*** ridge_path, int* ridge_path_N, Node*** ravine_path, int* ravine_path_N, BOOL grey_scale);
	void drawColoredVertex(MeshData* mesh, float (*v)[3], BOOL gray);
	void drawRidgeEdge(MeshData *mesh, BOOL transparent, BOOL grey_scale);
	void drawPrincipalDir(MeshData* mesh, BOOL max, BOOL min, BOOL transparent, BOOL gray_scale);
	void drawRidgeVertexAsSegmet(MeshData* mesh, BOOL transparent, BOOL gray_scale, BOOL principal_dir);
	void smoothShade(MeshData* mesh);
	void flatShade(MeshData* mesh);
	virtual ~CMeshEditorView();
#ifdef _DEBUG
	virtual void AssertValid() const;
	virtual void Dump(CDumpContext& dc) const;
#endif

public:
	void drawSilhouette(MeshData* mesh);
	void drawRidgeTriangle(MeshData* mesh);
	void convertToColorG(int n, float (*v)[3], float (*color)[3]);
	void drawKEdge(MeshData* mesh);
	void drawNonManifold(MeshData* mesh);
	void draw();
	void freeList();
	void setSize(float line, float point);
	void sphere2(float r[3], float p[3], float d[3][3], int n);
	void drawTensor(MeshData *mesh, BOOL max, BOOL min, BOOL transparent, BOOL gray_scale);
	int vertex_count, face_count;

protected:
	//BOOL isMousePressed, isRButtonPressed;
	HGLRC m_hRC;
	GLdouble eye[3], center[3];
	int px, py;
	float vx[3], vy[3], vz[3];
	BOOL isLPressed, isRPressed;
	float view_angle;
	float shift_x, shift_y, shift_z;
	float ray[3], start[3];

// 生成されたメッセージ マップ関数
protected:
	void convertToEdgeColor(int n, double (*v)[3], float(*color)[3][3]);
	void cylinder(float p1[], float p2[], float n1[], float n2[], float r, int n);
	void sphere(float r, float p[3], int n);
	void convertToColor(int n, float (*v)[3], float (*color)[3]);
	//{{AFX_MSG(CMeshEditorView)
	afx_msg void OnSize(UINT nType, int cx, int cy);
	afx_msg void OnDestroy();
	afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
	afx_msg void OnRButtonUp(UINT nFlags, CPoint point);
	afx_msg void OnRButtonDown(UINT nFlags, CPoint point);
	afx_msg void OnLButtonDown(UINT nFlags, CPoint point);
	afx_msg void OnLButtonUp(UINT nFlags, CPoint point);
	afx_msg void OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags);
	afx_msg BOOL OnMouseWheel(UINT nFlags, short zDelta, CPoint pt);
	afx_msg void OnMouseMove(UINT nFlags, CPoint point);
	afx_msg void OnLButtonDblClk(UINT nFlags, CPoint point);
	//}}AFX_MSG
	DECLARE_MESSAGE_MAP()

public:
	void drawRidgeS(MeshData *mesh, BOOL transparent, BOOL gray_scale, float T_ridge, float T_ravine, float width);
	void drawRidgeL(MeshData *mesh, BOOL transparent, BOOL gray_scale);
	void drawDualGraph(MeshData* mesh);
	void drawScaleMap(MeshData* mesh, float *sigma);
	void drawGaussianSupport(MeshData* mesh);
	void drawPickedPoint();
	void drawColoredTriangle(MeshData *mesh, float (*v)[3], BOOL gray);
	void convertToEdgeColorG(int n, double (*v)[3], float (*color)[3][3]);
	void drawPoints(MeshData *mesh);
	void initGL();
	void drawHatch2(MeshData *mesh, float Li[], float T1, float T2);
	void drawHatch(MeshData *mesh, float L[3], float T1, float T2);
	void drawTminAsLong(MeshData *mesh);
	void drawTmaxAsLong(MeshData *mesh);
	void drawDisconT(MeshData* mesh, BOOL grey_scale, float T);
	void drawDisconK(MeshData *mesh, BOOL grey_scale, float T);

	static inline void MAT_VEC(float y[3], float A[3][3], float x[3]){
		y[0] = A[0][0]*x[0] + A[0][1]*x[1] + A[0][2]*x[2];
		y[1] = A[1][0]*x[0] + A[1][1]*x[1] + A[1][2]*x[2];
		y[2] = A[2][0]*x[0] + A[2][1]*x[1] + A[2][2]*x[2];
	}

	static inline void MAT_TIMES(float C[3][3], float A[3][3], float B[3][3]){
		C[0][0] = A[0][0]*B[0][0] + A[0][1]*B[1][0] + A[0][2]*B[2][0];
		C[0][1] = A[0][0]*B[0][1] + A[0][1]*B[1][1] + A[0][2]*B[2][1];
		C[0][2] = A[0][0]*B[0][2] + A[0][1]*B[1][2] + A[0][2]*B[2][2];

		C[1][0] = A[1][0]*B[0][0] + A[1][1]*B[1][0] + A[1][2]*B[2][0];
		C[1][1] = A[1][0]*B[0][1] + A[1][1]*B[1][1] + A[1][2]*B[2][1];
		C[1][2] = A[1][0]*B[0][2] + A[1][1]*B[1][2] + A[1][2]*B[2][2];

		C[2][0] = A[2][0]*B[0][0] + A[2][1]*B[1][0] + A[2][2]*B[2][0];
		C[2][1] = A[2][0]*B[0][1] + A[2][1]*B[1][1] + A[2][2]*B[2][1];
		C[2][2] = A[2][0]*B[0][2] + A[2][1]*B[1][2] + A[2][2]*B[2][2];
	}

	static inline void GENERATE_MAT(float R[3][3], float angle, float v[3]){
		double l = sqrt(v[0]*v[0] + v[1]*v[1]);
		double a;
		if(l == 0)
			a = 0;
		else
			a = acos(v[1]/l);
		if(v[0] < 0)
			a = -a;
		double b = acos(v[2]/MeshData::LENGTH(v));

		float Rz[3][3], Rx[3][3], Rt[3][3]; 
		Rz[0][0] = Rz[1][1] = (float)cos(a);
		Rz[0][1] = (float)sin(a);
		Rz[1][0] = -Rz[0][1];
		Rz[2][0] = Rz[2][1] = Rz[0][2] = Rz[1][2] = 0;
		Rz[2][2] = 1;

		Rt[0][0] = Rt[1][1] = (float)cos(angle);
		Rt[0][1] = -(float)sin(angle);
		Rt[1][0] = -Rt[0][1];
		Rt[2][0] = Rt[2][1] = Rt[0][2] = Rt[1][2] = 0;
		Rt[2][2] = 1;

		Rx[0][0] = 1;
		Rx[0][1] = Rx[0][2] = Rx[1][0] = Rx[2][0] = 0;
		Rx[1][1] = Rx[2][2] = (float)cos(b);
		Rx[1][2] = (float)sin(b);
		Rx[2][1] = -Rx[1][2];

		float tmp[3][3];
		MAT_TIMES(tmp, Rz, Rx);
		MAT_TIMES(R, tmp, Rt);
		Rz[1][0] *= -1;
		Rz[0][1] *= -1;
		Rx[1][2] *= -1;
		Rx[2][1] *= -1;
		MAT_TIMES(tmp, R, Rx);
		MAT_TIMES(R, tmp, Rz);
	}
};

#ifndef _DEBUG  // MeshEditorView.cpp ファイルがデバッグ環境の時使用されます。
inline CMeshEditorDoc* CMeshEditorView::GetDocument()
   { return (CMeshEditorDoc*)m_pDocument; }
#endif

/////////////////////////////////////////////////////////////////////////////

//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ は前行の直前に追加の宣言を挿入します。

#endif // !defined(AFX_MESHEDITORVIEW_H__74788752_75B0_4E94_BF2C_35A23657F977__INCLUDED_)