raytrace.cpp

一个由Mike Gashler完成的机器学习方面的includes neural net, naive bayesian classifier, decision tree, KNN, a genet

// --------------------------------------------------------
// This demo file is dedicated to the Public Domain. See:
// http://creativecommons.org/licenses/publicdomain
// --------------------------------------------------------

#include "RayTrace.h"
#ifdef WIN32
#else // WIN32
#include <unistd.h>
#endif // !WIN32
#include "../GClasses/GTime.h"
#include "../GClasses/GMacros.h"
#include "../GClasses/GRayTrace.h"
#include "../GClasses/GBits.h"
#include "../GClasses/GPointerQueue.h"
#include "../GClasses/GThread.h"
#include "GRibParser.h"
#include "Interpolate.h"



class RayTraceDialog : public GWidgetDialog
{
friend class RayTraceController;
protected:
	RayTraceController* m_pController;
	GWidgetImageButton* m_pButtonManual;
	GWidgetFileSystemBrowser* m_pFileSystemBrowser;
	GWidgetCheckBox* m_pCheckBox;

public:
	RayTraceDialog(RayTraceController* pController, int w, int h)
	: GWidgetDialog(w, h, 0xff884466)
	{
		m_pController = pController;

		// Make the manual button
		GImage* pManualImage = ControllerBase::GetManualImage();
		m_pButtonManual = new GWidgetImageButton(this, w - pManualImage->GetWidth() / 2 - 5, 5, pManualImage);

		GString s;
		s.Copy(L"Begin");
		m_pFileSystemBrowser = new GWidgetFileSystemBrowser(this, 100, 400, 500, 190, ".rib");
		m_pCheckBox = new GWidgetCheckBox(this, 5, 400, 20, 20);
		s.Copy(L"High Quality");
		new GWidgetTextLabel(this, 26, 400, 70, 20, &s, 0xff002200);
	}

	virtual ~RayTraceDialog()
	{
	}

	virtual void OnReleaseImageButton(GWidgetImageButton* pButton)
	{
		if(pButton == m_pButtonManual)
			OpenAppFile("../doc/Waffles/RayTrace.html");
		else
			GAssert(false, "unrecognized image button");
	}

	virtual void OnReleaseTextButton(GWidgetTextButton* pButton)
	{
	}

	virtual void OnSelectFilename(GWidgetFileSystemBrowser* pBrowser, const char* szFilename)
	{
		m_pController->OnSelectFile(szFilename);
	}
};


// ----------------------------------------------------------------------------

RayTraceView::RayTraceView(RayTraceController* pController)
: ViewBase()
{
	m_pDialog = new RayTraceDialog(pController, m_screenRect.w, m_screenRect.h);
	m_pImage = NULL;
}

RayTraceView::~RayTraceView()
{
	delete(m_pDialog);
}

/*virtual*/ void RayTraceView::Draw(SDL_Surface *pScreen)
{
	GImage* pCanvas = m_pDialog->GetImage();
	if(m_pImage)
	{
		GRect r(0, 0, m_pImage->GetWidth(), m_pImage->GetHeight());
		pCanvas->Blit(0, 0, m_pImage, &r);
	}
	BlitImage(pScreen, m_screenRect.x, m_screenRect.y, pCanvas);
}

void RayTraceView::OnChar(char c)
{
	m_pDialog->HandleChar(c);
}

void RayTraceView::OnMouseDown(int nButton, int x, int y)
{
	x -= m_screenRect.x;
	y -= m_screenRect.y;
	GWidgetAtomic* pNewWidget = m_pDialog->FindAtomicWidget(x, y);
	m_pDialog->GrabWidget(pNewWidget, nButton, x, y);
}

void RayTraceView::OnMouseUp(int nButton, int x, int y)
{
	m_pDialog->ReleaseWidget(nButton);
}

bool RayTraceView::OnMousePos(int x, int y)
{
	return m_pDialog->HandleMousePos(x - m_screenRect.x, y - m_screenRect.y);
}


// -------------------------------------------------------------------------------

RayTraceController::RayTraceController()
: ControllerBase()
{
	m_pView = new RayTraceView(this);
	m_bRendering = false;
	m_pScene = NULL;
}

RayTraceController::~RayTraceController()
{
	delete(m_pView);
}

void RayTraceController::OnSelectFile(const char* szFilename)
{
	m_pScene = RibParser::LoadScene(szFilename);
	if(!m_pScene)
	{
		printf("Failed to create scene\n");
		m_bKeepRunning = false;
		return;
	}
	if(((RayTraceView*)m_pView)->m_pDialog->m_pCheckBox->IsChecked())
		m_pScene->SetRenderMode(GRayTraceScene::QUALITY_RAY_TRACE);
	else
		m_pScene->SetRenderMode(GRayTraceScene::FAST_RAY_TRACE);
	m_pScene->RenderBegin();
	GImage* pImage = m_pScene->GetImage();
//m_pScene->RenderSinglePixel(pImage->GetWidth() / 2, pImage->GetHeight() / 2);
	((RayTraceView*)m_pView)->SetImage(pImage);
	m_bRendering = true;
}

void RayTraceController::RunModal()
{
	double timeOld = GTime::GetTime();
	double time;
	double timeUpdate = 0;
	m_pView->Update();
	while(m_bKeepRunning)
	{
		time = GTime::GetTime();
		if(HandleEvents(time - timeOld)) // HandleEvents returns true if it thinks the view needs to be updated
		{
			m_pView->Update();
			timeUpdate = time;
		}
		else if(m_bRendering)
		{
			m_bRendering = m_pScene->RenderLine();
			if(!m_bRendering || time - timeUpdate > .25)
			{
				m_pView->Update();
				timeUpdate = time;
			}
		}
		else
		{
			GThread::sleep(10);
		}
		timeOld = time;
	}
}