Лабораторная работа №51 / GLlab5 / GLlabView

// GLlabView.cpp : implementation of the CGLlabView class
//

#include "stdafx.h"
#include "GLlab.h"

#include "GLlabDoc.h"
#include "GLlabView.h"
#include "Dlg.h"
#include "Dlg3d.h"
#include "Fractal.h"
#include "FractalDlg.h"
#include "Figure3D.h"
#include "DlgLight.h"
#include "DlgScene.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CGLlabView

IMPLEMENT_DYNCREATE(CGLlabView, CView)

BEGIN_MESSAGE_MAP(CGLlabView, CView)
	//{{AFX_MSG_MAP(CGLlabView)
	ON_WM_CREATE()
	ON_WM_DESTROY()
	ON_COMMAND(ID_DRAW_LINESTRIP, OnDrawLinestrip)
	ON_UPDATE_COMMAND_UI(ID_DRAW_LINESTRIP, OnUpdateDrawLinestrip)
	ON_COMMAND(ID_DRAW_POINTS, OnDrawPoints)
	ON_UPDATE_COMMAND_UI(ID_DRAW_POINTS, OnUpdateDrawPoints)
	ON_COMMAND(ID_DRAW_QUADRILATERALS, OnDrawQuadrilaterals)
	ON_UPDATE_COMMAND_UI(ID_DRAW_QUADRILATERALS, OnUpdateDrawQuadrilaterals)
	ON_COMMAND(ID_DRAW_TRIANGLEFAN, OnDrawTrianglefan)
	ON_UPDATE_COMMAND_UI(ID_DRAW_TRIANGLEFAN, OnUpdateDrawTrianglefan)
	ON_COMMAND(ID_TEST_GLSCISSOR, OnTestGlscissor)
	ON_UPDATE_COMMAND_UI(ID_TEST_GLSCISSOR, OnUpdateTestGlscissor)
	ON_COMMAND(ID_TEST_GLALPHAFUNC, OnTestGlalphafunc)
	ON_UPDATE_COMMAND_UI(ID_TEST_GLALPHAFUNC, OnUpdateTestGlalphafunc)
	ON_COMMAND(ID_TEST_GLBLENDFUNC, OnTestGlblendfunc)
	ON_UPDATE_COMMAND_UI(ID_TEST_GLBLENDFUNC, OnUpdateTestGlblendfunc)
	ON_COMMAND(ID_TESTS_NULL, OnTestsNull)
	ON_UPDATE_COMMAND_UI(ID_TESTS_NULL, OnUpdateTestsNull)
	ON_COMMAND(ID__TESTSRELOCATION, OnTestsrelocation)
	ON_COMMAND(ID_DRAW3D_3DPICTURE, OnDraw3d3dpicture)
	ON_UPDATE_COMMAND_UI(ID_DRAW3D_3DPICTURE, OnUpdateDraw3d3dpicture)
	ON_COMMAND(ID_RELOCATION_RELOCATION3D, OnRelocationRelocation3d)
	ON_COMMAND(ID_FRACTAL_PIFAGORSTREE, OnFractalPifagorstree)
	ON_UPDATE_COMMAND_UI(ID_FRACTAL_PIFAGORSTREE, OnUpdateFractalPifagorstree)
	ON_COMMAND(ID_RELOCATION_FRACTALRELOCATION, OnRelocationFractalrelocation)
	ON_COMMAND(ID_DRAW3D_SCENE, OnDraw3dScene)
	ON_UPDATE_COMMAND_UI(ID_DRAW3D_SCENE, OnUpdateDraw3dScene)
	ON_COMMAND(ID_RELOCATION_LIGHTMATERIAL, OnRelocationLightmaterial)
	ON_COMMAND(ID_RELOCATION_SCENE, OnRelocationScene)
	//}}AFX_MSG_MAP
	// Standard printing commands
	ON_COMMAND(ID_FILE_PRINT, CView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_DIRECT, CView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_PREVIEW, CView::OnFilePrintPreview)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CGLlabView construction/destruction

CGLlabView::CGLlabView()
{
	// TODO: add construction code here
	m_test=-1;
}

CGLlabView::~CGLlabView()
{
}

BOOL CGLlabView::PreCreateWindow(CREATESTRUCT& cs)
{
	// TODO: Modify the Window class or styles here by modifying
	//  the CREATESTRUCT cs
	cs.style |= WS_CLIPCHILDREN | WS_CLIPSIBLINGS;

	return CView::PreCreateWindow(cs);
}

/////////////////////////////////////////////////////////////////////////////
// CGLlabView drawing

void CGLlabView::OnDraw(CDC* pDC)
{
	CGLlabDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);
	// TODO: add draw code for native data here

	wglMakeCurrent(pDC->m_hDC, m_hRC);
    DrawWithOpenGL();
    wglMakeCurrent(pDC->m_hDC, NULL);

}

/////////////////////////////////////////////////////////////////////////////
// CGLlabView printing

BOOL CGLlabView::OnPreparePrinting(CPrintInfo* pInfo)
{
	// default preparation
	return DoPreparePrinting(pInfo);
}

void CGLlabView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// TODO: add extra initialization before printing
}

void CGLlabView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// TODO: add cleanup after printing
}

/////////////////////////////////////////////////////////////////////////////
// CGLlabView diagnostics

#ifdef _DEBUG
void CGLlabView::AssertValid() const
{
	CView::AssertValid();
}

void CGLlabView::Dump(CDumpContext& dc) const
{
	CView::Dump(dc);
}

CGLlabDoc* CGLlabView::GetDocument() // non-debug version is inline
{
	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CGLlabDoc)));
	return (CGLlabDoc*)m_pDocument;
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CGLlabView message handlers

int CGLlabView::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{
	if (CView::OnCreate(lpCreateStruct) == -1)
		return -1;
	
	// TODO: Add your specialized creation code here
	    PIXELFORMATDESCRIPTOR pfd =
    {
        sizeof(PIXELFORMATDESCRIPTOR), // Structure size.
        1,                             // Structure version number.
        PFD_DRAW_TO_WINDOW |           // Property flags.
            PFD_SUPPORT_OPENGL,
        PFD_TYPE_RGBA,
        24,                            // 24-bit color.
        0, 0, 0, 0, 0, 0,              // Not concerned with these.
        0, 0, 0, 0, 0, 0, 0,           // No alpha or accum buffer.
        32,                            // 32-bit depth buffer.
        0, 0,                          // No stencil or aux buffer.
        PFD_MAIN_PLANE,                // Main layer type.
        0,                             // Reserved.
        0, 0, 0                        // Unsupported.
    };

    CClientDC clientDC(this);

    int pixelFormat =
        ChoosePixelFormat(clientDC.m_hDC, &pfd);
    BOOL success =
        SetPixelFormat(clientDC.m_hDC, pixelFormat, &pfd);

    m_hRC = wglCreateContext(clientDC.m_hDC);
	
	return 0;
}


void CGLlabView::OnDestroy() 
{
	CView::OnDestroy();
	
	// TODO: Add your message handler code here
		wglDeleteContext(m_hRC);

}


void CGLlabView::OnDrawLinestrip() 
{
	// TODO: Add your command handler code here
	m_shape = LineStrip;
    Invalidate();	
}

void CGLlabView::OnUpdateDrawLinestrip(CCmdUI* pCmdUI) 
{
	// TODO: Add your command update UI handler code here
	if (m_shape == LineStrip)
        pCmdUI->SetCheck(TRUE);
    else
        pCmdUI->SetCheck(FALSE);	
}


void CGLlabView::OnDrawPoints() 
{
	// TODO: Add your command handler code here
	m_shape = Points;
    Invalidate();	
}

void CGLlabView::OnUpdateDrawPoints(CCmdUI* pCmdUI) 
{
	// TODO: Add your command update UI handler code here
    if (m_shape == Points)
        pCmdUI->SetCheck(TRUE);
    else
        pCmdUI->SetCheck(FALSE);	
}

void CGLlabView::OnDrawQuadrilaterals() 
{
	// TODO: Add your command handler code here
    m_shape = Quads;
    Invalidate();	
}

void CGLlabView::OnUpdateDrawQuadrilaterals(CCmdUI* pCmdUI) 
{
	// TODO: Add your command update UI handler code here
    if (m_shape == Quads)
        pCmdUI->SetCheck(TRUE);
    else
        pCmdUI->SetCheck(FALSE);	
}

void CGLlabView::OnDrawTrianglefan() 
{
	// TODO: Add your command handler code here
    m_shape = TriangleFan;
    Invalidate();	
}

void CGLlabView::OnUpdateDrawTrianglefan(CCmdUI* pCmdUI) 
{
	// TODO: Add your command update UI handler code here
	if (m_shape == TriangleFan)
        pCmdUI->SetCheck(TRUE);
    else
        pCmdUI->SetCheck(FALSE);
}


void CGLlabView::DrawWithOpenGL()
{	 
    glClearColor(1.0f, 1.0f, 1.0f, 1.0f); //Белый цвет фона
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glColor3f(0.0f, 0.0f, 0.0f);
	
	GLint Width=512,Height=512;

	glViewport(0,0,Width,Height);


	switch(m_test)
	{
		case TglScissor		: EnGlscissor(); break;
		case TglAlphaFunc	: EnAlphafunc(); break;
		case TglBlendFunc	: EnGlblendfunc(); break;
	}

    switch(m_shape)
    {
        case Points        : DrawPoints(); break;
        case LineStrip     : DrawLineStrip(); break;
        case TriangleFan   : DrawTriangleFan(); break;
        case Quads         : DrawQuads(); break;
		case Figure3d	   : Draw3D(); break;
		case PifTree	   : DrawFractal(); break;
		case Scene		   : Draw3D(); break;
    }

	switch(m_test)
	{
		case TglScissor		: DisGlscissor(); break;
		case TglAlphaFunc	: DisAlphafunc(); break;
		case TglBlendFunc	: DisGlblendfunc(); break;
	}
    glFlush();
}

//Рисуем точки
void CGLlabView::DrawPoints()
{	
    GLfloat ps[2];
    glGetFloatv(GL_POINT_SIZE_RANGE, ps);

	glPointSize(20);

	glEnable(GL_POINT_SMOOTH);

    glBegin(GL_POINTS);
        glColor4f(1.0,0.0,0.0,0.4);
		glVertex2f(0.0f, 0.0f);	//Первая вершина

		glColor4f(0.0,1.0,0.0,0.6);
        glVertex2f(0.75f, 0.75f); //Вторая вершина

		glColor4f(0.0,0.0,1.0,1.0);
        glVertex2f(-0.75f, -0.75f);//Третья вершина

		glColor4f(0.0,1.0,1.0,0.3);
        glVertex2f(-0.75f, 0.75f);//Четвертая вершина

		glColor4f(1.0,1.0,0.0,0.5);
        glVertex2f(0.75f, -0.75f);//Пятая вершина
    glEnd();

	glDisable(GL_POINT_SMOOTH); 

}

//Рисуем линии
void CGLlabView::DrawLineStrip()
{
	glPointSize(20);

	glEnable(GL_LINE_STIPPLE); 
	glLineStipple(2,58360);

	glBegin(GL_LINE_STRIP);

	glColor4f(1.0,0.0,0.0,1.0);
	glVertex2f(-0.8f, -0.8f);	//Первая вершина


	glVertex2f(0.0f, 0.0f); //Вторая вершина

	glColor4f(0.0,0.0,1.0,0.2);
	glVertex2f(-0.8f, 0.8f);//Третья вершина

	

	glVertex2f(0.75f, 0.75f);//Четвертая вершина

	glColor4f(1.0,1.0,0.0,0.8);
	glVertex2f(0.75f, -0.75f);//Пятая вершина

	glEnd();

	glDisable(GL_LINE_STIPPLE); 
}

//Рисуем треугольники
void CGLlabView::DrawTriangleFan()
{	glEnable(GL_FLAT);

	glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
	glLineWidth(5);

	
	glBegin(GL_TRIANGLE_FAN);
	glColor4f(1.0,0.0,0.0,1.0);
	glVertex2f(0.0f, -0.25f);
	
	glColor4f(0.0,0.0,1.0,0.2);
	glVertex2f(-0.5f, -0.25f);
	glVertex2f(-0.25f, 0.25f);	//Первый треугольник

	glColor4f(1.0,1.0,0.0,0.6);
	glVertex2f(0.25f, 0.25f);		//Второй треугольник
	glVertex2f(0.5f, -0.25f);		//Третий треугольник

	glEnd();

	glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
	glLineWidth(1);

	glBegin(GL_TRIANGLE_FAN);
	glColor4f(0.0,1.0,0.0,0.5);
	glVertex2f(0.0f, 0.0f);
	
	glColor4f(0.0,1.0,0.0,0.2);
	glVertex2f(-0.8f, -0.25f);
	glVertex2f(-0.8f, 0.25f);	

	glColor4f(0.0,1.0,0.0,0.5);
	glVertex2f(-0.25f, 0.8f);
	glVertex2f(0.25f, 0.8f);

	glColor4f(0.0,1.0,0.0,0.9);
	glVertex2f(0.8f, 0.25f);		
	glVertex2f(0.8f, -0.25f);	
	
	glColor4f(0.0,1.0,0.0,0.1);
	glVertex2f(0.25f, -0.8f);		
	glVertex2f(-0.25f, -0.8f);
	glVertex2f(-0.8f, -0.25f);


	glEnd();
	
}

//Рисуем квадраты
void CGLlabView::DrawQuads()
{
	glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);

	glBegin(GL_QUADS);

	glColor4f(0.0,0.0,1.0,0.9);
	glVertex2f(-0.3f, -0.3f);
	glVertex2f(0.3f, -0.3f);
	glVertex2f(0.3f, 0.3f);
	glVertex2f(-0.3f, 0.3f);

	glEnd();


	glBegin(GL_QUADS);

	glColor4f(1.0,1.0,0.0,0.6);
	glVertex2f(-0.7f, -0.7f);
	glVertex2f(0.7f, -0.7f);
	glVertex2f(0.7f, 0.7f);
	glVertex2f(-0.7f, 0.7f);

	glEnd();

//	glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);




}

void CGLlabView::OnTestGlscissor() 
{
	// TODO: Add your command handler code here
	m_test=TglScissor;

	Invalidate();

	
}


void CGLlabView::OnUpdateTestGlscissor(CCmdUI* pCmdUI) 
{
	// TODO: Add your command update UI handler code here
	
	if (m_test==TglScissor)
	{
	pCmdUI->SetCheck(TRUE);
	}
	else
	{
	pCmdUI->SetCheck(FALSE);
	}
}

void CGLlabView::OnTestGlalphafunc() 
{
	// TODO: Add your command handler code here
		m_test=TglAlphaFunc;
		Invalidate();
}

void CGLlabView::OnUpdateTestGlalphafunc(CCmdUI* pCmdUI) 
{
	// TODO: Add your command update UI handler code here
	if (m_test==TglAlphaFunc)
	{
	pCmdUI->SetCheck(TRUE);
	}
	else
	{
	pCmdUI->SetCheck(FALSE);
	}
}


void CGLlabView::OnTestGlblendfunc() 
{
	// TODO: Add your command handler code here
		m_test=TglBlendFunc;
		Invalidate();
}

void CGLlabView::OnUpdateTestGlblendfunc(CCmdUI* pCmdUI) 
{
	// TODO: Add your command update UI handler code here
	if (m_test==TglBlendFunc)
	{
	pCmdUI->SetCheck(TRUE);
	}
	else
	{
	pCmdUI->SetCheck(FALSE);
	}
	
}

//тело фильтра Glscissor
void CGLlabView::EnGlscissor()
{	
	CGLlabDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);
	
	glEnable(GL_SCISSOR_TEST);
	glScissor(pDoc->ScissorX,pDoc->ScissorY,pDoc->ScissorHight,pDoc->ScissorWidth);

}

void CGLlabView::DisGlscissor()
{
	glDisable(GL_SCISSOR_TEST);
}

//тело фильтра Alphafunc
void CGLlabView::EnAlphafunc()
{	CGLlabDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);

	glEnable(GL_ALPHA_TEST); 	
	
	glAlphaFunc(pDoc->AlphaFunc, pDoc->AlphaRef);

}

void CGLlabView::DisAlphafunc()
{
	glDisable(GL_ALPHA_TEST);
}

//тело фильтра blendfunc
void CGLlabView::EnGlblendfunc()
{	CGLlabDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);


	glEnable(GL_BLEND); 
	glBlendFunc(pDoc->BlendSfactor, pDoc->BlendDfactor);

}

void CGLlabView::DisGlblendfunc()
{
	glDisable(GL_BLEND);
}

void CGLlabView::OnTestsNull() 
{
	// TODO: Add your command handler code here
		m_test=-1;
		Invalidate();
}



void CGLlabView::OnUpdateTestsNull(CCmdUI* pCmdUI) 
{
	// TODO: Add your command update UI handler code here
	if (m_test==-1)
	{
	pCmdUI->SetCheck(TRUE);
	}
	else
	{
	pCmdUI->SetCheck(FALSE);
	}
}

void CGLlabView::OnTestsrelocation() 
{
	// TODO: Add your command handler code here
	Dlg dlg;

	int result = dlg.DoModal();

	if (result == IDOK) {
	
		CGLlabDoc* pDoc = GetDocument();
		ASSERT_VALID(pDoc);
		
		pDoc->ScissorX=dlg.m_ScissorX;
		pDoc->ScissorY=dlg.m_ScissorY;
		pDoc->ScissorHight=dlg.m_ScissorHight;
		pDoc->ScissorWidth=dlg.m_ScissorWidth;

		pDoc->AlphaRef=dlg.m_AlphaRef;
		
		pDoc->AlphaFunc=dlg.AlphaFunc;

		pDoc->BlendSfactor=dlg.BlendSfactor;
		pDoc->BlendDfactor=dlg.BlendDfactor;

	}
}

void CGLlabView::OnDraw3d3dpicture() 
{
	// TODO: Add your command handler code here
	
    m_shape = Figure3d;
    Invalidate();
	
}


void CGLlabView::OnUpdateDraw3d3dpicture(CCmdUI* pCmdUI) 
{
	// TODO: Add your command update UI handler code here
	if (m_shape==Figure3d)
	{
	pCmdUI->SetCheck(TRUE);
	}
	else
	{
	pCmdUI->SetCheck(FALSE);
	}
}



void CGLlabView::Draw3D()
{	//Документ
	CGLlabDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);

	Figure3D fig;

	//Установки поворота фигурки
	fig.SetAngle(pDoc->Rotate[0]);
	fig.SetBX(pDoc->Rotate[1]);
	fig.SetBY(pDoc->Rotate[2]);
	fig.SetBZ(pDoc->Rotate[3]);
	fig.SetDX(pDoc->Move[0]);
	fig.SetDY(pDoc->Move[1]);
	fig.SetDZ(pDoc->Move[2]);
	if (m_shape == Figure3d)
	{	
	//Установки освещения и материала
	fig.SetLightAmbient(pDoc->LightAmbient);
	fig.SetLightDiffuse(pDoc->LightDiffuse);
	fig.SetLightSpecular(pDoc->LightSpecular);
	fig.SetLightPosition(pDoc->LightPosition);
	fig.SetLightNapr(pDoc->LightNapr);
	fig.SetMatAmbient(pDoc->MatAmbient);
	fig.SetMatDiffuse(pDoc->MatDiffuse);
	fig.SetMatEmission(pDoc->MatEmission);
	fig.SetMatSpecular(pDoc->MatSpecular);
	fig.SetSpot(pDoc->spot);
	fig.SetTwoside(pDoc->twoside);
	

	fig.Enab3D();
	fig.EnabLight();
	fig.EnabMaterial();

	fig.DrawChel();
//	fig.DrawScene();

	fig.DisabMaterial();
	fig.DisabLight();
	fig.Disab3D();
	}
	if (m_shape == Scene)
	{	
				
		fig.SetSceneLamps(pDoc->LampsScene);
		fig.SetSceneDifuseLamp(pDoc->SceneLamp1,1);
		fig.SetSceneDifuseLamp(pDoc->SceneLamp2,2);
		fig.SetSceneDifuseLamp(pDoc->SceneLamp3,3);

		fig.Enab3D();
		fig.EnabLightScene();

		fig.DrawScene();

		fig.DisabLightScene();
		fig.Disab3D();
	}
}


void CGLlabView::OnRelocationRelocation3d() 
{
	// TODO: Add your command handler code here
	Dlg3d dlg;

	int result = dlg.DoModal();

	if (result == IDOK) {
	
		CGLlabDoc* pDoc = GetDocument();
		ASSERT_VALID(pDoc);

		pDoc->Move[0]=atof(dlg.m_dX);
		pDoc->Move[1]=atof(dlg.m_dY);
		pDoc->Move[2]=atof(dlg.m_dZ);

		pDoc->Rotate[0]=dlg.m_Angle;
		pDoc->Rotate[1]=dlg.Rotate[0];
		pDoc->Rotate[2]=dlg.Rotate[1];
		pDoc->Rotate[3]=dlg.Rotate[2];

		Draw3D();
	}
}

void CGLlabView::OnFractalPifagorstree() 
{
	// TODO: Add your command handler code here
	m_shape = PifTree;
    Invalidate();
}

void CGLlabView::OnUpdateFractalPifagorstree(CCmdUI* pCmdUI) 
{
	// TODO: Add your command update UI handler code here
	if (m_shape==PifTree)
	{
	pCmdUI->SetCheck(TRUE);
	}
	else
	{
	pCmdUI->SetCheck(FALSE);
	}
}

void CGLlabView::DrawFractal()
{	Fractal fr;

	CGLlabDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);

	fr.A=0.4;
	fr.DrawTree(pDoc->Fractal_dX,pDoc->Fractal_dY,pDoc->Fract_inter);

}

void CGLlabView::OnRelocationFractalrelocation() 
{
	// TODO: Add your command handler code here
	FractalDlg dlg;

	int result = dlg.DoModal();

	if (result == IDOK) {
		
		CGLlabDoc* pDoc = GetDocument();
		ASSERT_VALID(pDoc);
		
		pDoc->Fract_inter=dlg.m_Inter;	
		
		pDoc->Fractal_dX=atof(dlg.m_dX)/10;
		pDoc->Fractal_dY=atof(dlg.m_dY)/10;
	}
}


void CGLlabView::OnDraw3dScene() 
{
	// TODO: Add your command handler code here
	m_shape = Scene;
    Invalidate();
}

void CGLlabView::OnUpdateDraw3dScene(CCmdUI* pCmdUI) 
{
	// TODO: Add your command update UI handler code here
	if (m_shape==Scene)
	{
	pCmdUI->SetCheck(TRUE);
	}
	else
	{
	pCmdUI->SetCheck(FALSE);
	}
}

void CGLlabView::OnRelocationLightmaterial() 
{
	// TODO: Add your command handler code here
	DlgLight dlg;

	int result = dlg.DoModal();
	
	if (result == IDOK) {
		
		CGLlabDoc* pDoc = GetDocument();
		ASSERT_VALID(pDoc);
		
		pDoc->LightPosition[0]=dlg.m_lampX;
		pDoc->LightPosition[1]=dlg.m_lampY;
		pDoc->LightPosition[2]=dlg.m_lampZ;

		pDoc->LightNapr[0]=dlg.m_lightToX;
		pDoc->LightNapr[1]=dlg.m_LightToY;
		pDoc->LightNapr[2]=dlg.m_LightToZ;

		pDoc->LightAmbient[0]=dlg.m_LAmbRed;
		pDoc->LightAmbient[1]=dlg.m_LAmbGreen;
		pDoc->LightAmbient[2]=dlg.m_LAmbBlue;

		pDoc->LightDiffuse[0]=dlg.m_LDifRed;
		pDoc->LightDiffuse[1]=dlg.m_LDifGreen;
		pDoc->LightDiffuse[2]=dlg.m_LDifBlue;

		pDoc->LightSpecular[0]=dlg.m_LSpecRed;
		pDoc->LightSpecular[1]=dlg.m_LSpecGreen;
		pDoc->LightSpecular[2]=dlg.m_LSpecBlue;

		pDoc->MatAmbient[0]=dlg.m_MAmbRed;
		pDoc->MatAmbient[1]=dlg.m_MAmbGreen;
		pDoc->MatAmbient[2]=dlg.m_MAmbBlue;

		pDoc->MatDiffuse[0]=dlg.m_MDifRed;
		pDoc->MatAmbient[1]=dlg.m_MDifGreen;
		pDoc->MatAmbient[2]=dlg.m_MDifBlue;

		pDoc->MatSpecular[0]=dlg.m_MSpecRed;
		pDoc->MatSpecular[1]=dlg.m_MSpecGreen;
		pDoc->MatSpecular[2]=dlg.m_MSpecBlue;

		pDoc->MatEmission[0]=dlg.m_MEmisRed;
		pDoc->MatEmission[1]=dlg.m_MEmisGreen;
		pDoc->MatEmission[2]=dlg.m_MEmisBlue;

		pDoc->spot=dlg.m_Spot;
		pDoc->twoside=dlg.TwoSide;

	}
}

void CGLlabView::OnRelocationScene() 
{
	// TODO: Add your command handler code here
	DlgScene dlg;

	int result = dlg.DoModal();
	
	if (result == IDOK) {
		
		CGLlabDoc* pDoc = GetDocument();
		ASSERT_VALID(pDoc);

		pDoc->LampsScene[0]=dlg.Lamps[0];
		pDoc->LampsScene[1]=dlg.Lamps[1];
		pDoc->LampsScene[2]=dlg.Lamps[2];

		pDoc->SceneLamp1[0]=dlg.m_L1Red;
		pDoc->SceneLamp1[1]=dlg.m_L1Green;
		pDoc->SceneLamp1[2]=dlg.m_L1Blue;
		pDoc->SceneLamp2[0]=dlg.m_L2Red;
		pDoc->SceneLamp2[1]=dlg.m_L2Green;
		pDoc->SceneLamp2[2]=dlg.m_L2Blue;
		pDoc->SceneLamp3[0]=dlg.m_L3Red;
		pDoc->SceneLamp3[1]=dlg.m_L3Green;
		pDoc->SceneLamp3[2]=dlg.m_L3Blue;

	}
}