mirror of
https://github.com/glest/glest-source.git
synced 2025-09-08 23:10:42 +02:00
Code Restructuring to make mega-glest more standard
This commit is contained in:
Mark Vejvoda
@@ -1,304 +0,0 @@
|
||||
#include "main.h"
|
||||
|
||||
#include <stdexcept>
|
||||
|
||||
#include "graphics_factory_basic_gl.h"
|
||||
#include "graphics_interface.h"
|
||||
#include "util.h"
|
||||
|
||||
using namespace Shared::Platform;
|
||||
using namespace Shared::Graphics;
|
||||
using namespace Shared::Graphics::Gl;
|
||||
using namespace Shared::Util;
|
||||
|
||||
using namespace std;
|
||||
|
||||
namespace Shared{ namespace G3dViewer{
|
||||
|
||||
// ===============================================
|
||||
// class MainWindow
|
||||
// ===============================================
|
||||
|
||||
const string MainWindow::versionString= "v1.3.5-beta1";
|
||||
const string MainWindow::winHeader= "G3D viewer " + versionString + " - Built: " + __DATE__;
|
||||
|
||||
MainWindow::MainWindow(const string &modelPath):
|
||||
wxFrame(
|
||||
NULL, -1, winHeader.c_str(),
|
||||
wxPoint(Renderer::windowX, Renderer::windowY),
|
||||
wxSize(Renderer::windowW, Renderer::windowH))
|
||||
{
|
||||
renderer= Renderer::getInstance();
|
||||
this->modelPath= modelPath;
|
||||
model= NULL;
|
||||
playerColor= Renderer::pcRed;
|
||||
|
||||
speed= 0.025f;
|
||||
|
||||
glCanvas = new GlCanvas(this);
|
||||
|
||||
glCanvas->SetCurrent();
|
||||
|
||||
renderer->init();
|
||||
|
||||
|
||||
menu= new wxMenuBar();
|
||||
|
||||
//menu
|
||||
menuFile= new wxMenu();
|
||||
menuFile->Append(miFileLoad, "Load");
|
||||
menu->Append(menuFile, "File");
|
||||
|
||||
//mode
|
||||
menuMode= new wxMenu();
|
||||
menuMode->AppendCheckItem(miModeNormals, "Normals");
|
||||
menuMode->AppendCheckItem(miModeWireframe, "Wireframe");
|
||||
menuMode->AppendCheckItem(miModeGrid, "Grid");
|
||||
menu->Append(menuMode, "Mode");
|
||||
|
||||
//mode
|
||||
menuSpeed= new wxMenu();
|
||||
menuSpeed->Append(miSpeedSlower, "Slower");
|
||||
menuSpeed->Append(miSpeedFaster, "Faster");
|
||||
menu->Append(menuSpeed, "Speed");
|
||||
|
||||
//custom color
|
||||
menuCustomColor= new wxMenu();
|
||||
menuCustomColor->AppendCheckItem(miColorRed, "Red");
|
||||
menuCustomColor->AppendCheckItem(miColorBlue, "Blue");
|
||||
menuCustomColor->AppendCheckItem(miColorYellow, "Yellow");
|
||||
menuCustomColor->AppendCheckItem(miColorGreen, "Green");
|
||||
menu->Append(menuCustomColor, "Custom Color");
|
||||
|
||||
menuMode->Check(miModeGrid, true);
|
||||
menuCustomColor->Check(miColorRed, true);
|
||||
|
||||
SetMenuBar(menu);
|
||||
|
||||
//misc
|
||||
model= NULL;
|
||||
rotX= 0.0f;
|
||||
rotY= 0.0f;
|
||||
zoom= 1.0f;
|
||||
lastX= 0;
|
||||
lastY= 0;
|
||||
anim= 0.0f;
|
||||
|
||||
CreateStatusBar();
|
||||
|
||||
timer = new wxTimer(this);
|
||||
timer->Start(40);
|
||||
|
||||
if(!modelPath.empty()){
|
||||
Model *tmpModel= new ModelGl();
|
||||
renderer->loadTheModel(tmpModel, modelPath);
|
||||
model= tmpModel;
|
||||
GetStatusBar()->SetStatusText(getModelInfo().c_str());
|
||||
}
|
||||
}
|
||||
|
||||
MainWindow::~MainWindow(){
|
||||
delete renderer;
|
||||
delete model;
|
||||
delete timer;
|
||||
delete glCanvas;
|
||||
}
|
||||
|
||||
void MainWindow::onPaint(wxPaintEvent &event){
|
||||
renderer->reset(GetClientSize().x, GetClientSize().y, playerColor);
|
||||
renderer->transform(rotX, rotY, zoom);
|
||||
renderer->renderGrid();
|
||||
|
||||
renderer->renderTheModel(model, anim);
|
||||
glCanvas->SwapBuffers();
|
||||
}
|
||||
|
||||
void MainWindow::onClose(wxCloseEvent &event){
|
||||
delete this;
|
||||
}
|
||||
|
||||
void MainWindow::onMouseMove(wxMouseEvent &event){
|
||||
|
||||
int x= event.GetX();
|
||||
int y= event.GetY();
|
||||
wxPaintEvent paintEvent;
|
||||
|
||||
if(event.LeftIsDown()){
|
||||
rotX+= clamp(lastX-x, -10, 10);
|
||||
rotY+= clamp(lastY-y, -10, 10);
|
||||
onPaint(paintEvent);
|
||||
}
|
||||
else if(event.RightIsDown()){
|
||||
zoom*= 1.0f+(lastX-x+lastY-y)/100.0f;
|
||||
zoom= clamp(zoom, 0.1f, 10.0f);
|
||||
onPaint(paintEvent);
|
||||
}
|
||||
|
||||
lastX= x;
|
||||
lastY= y;
|
||||
}
|
||||
|
||||
void MainWindow::onMenuFileLoad(wxCommandEvent &event){
|
||||
string fileName;
|
||||
wxFileDialog fileDialog(this);
|
||||
fileDialog.SetWildcard("G3D files (*.g3d)|*.g3d");
|
||||
if(fileDialog.ShowModal()==wxID_OK){
|
||||
delete model;
|
||||
Model *tmpModel= new ModelGl();
|
||||
renderer->loadTheModel(tmpModel, fileDialog.GetPath().c_str());
|
||||
model= tmpModel;
|
||||
GetStatusBar()->SetStatusText(getModelInfo().c_str());
|
||||
}
|
||||
}
|
||||
|
||||
void MainWindow::onMenuModeNormals(wxCommandEvent &event){
|
||||
renderer->toggleNormals();
|
||||
menuMode->Check(miModeNormals, renderer->getNormals());
|
||||
}
|
||||
|
||||
void MainWindow::onMenuModeWireframe(wxCommandEvent &event){
|
||||
renderer->toggleWireframe();
|
||||
menuMode->Check(miModeWireframe, renderer->getWireframe());
|
||||
}
|
||||
|
||||
void MainWindow::onMenuModeGrid(wxCommandEvent &event){
|
||||
renderer->toggleGrid();
|
||||
menuMode->Check(miModeGrid, renderer->getGrid());
|
||||
}
|
||||
|
||||
void MainWindow::onMenuSpeedSlower(wxCommandEvent &event){
|
||||
speed/= 1.5f;
|
||||
}
|
||||
|
||||
void MainWindow::onMenuSpeedFaster(wxCommandEvent &event){
|
||||
speed*= 1.5f;
|
||||
}
|
||||
|
||||
void MainWindow::onMenuColorRed(wxCommandEvent &event){
|
||||
playerColor= Renderer::pcRed;
|
||||
menuCustomColor->Check(miColorRed, true);
|
||||
menuCustomColor->Check(miColorBlue, false);
|
||||
menuCustomColor->Check(miColorYellow, false);
|
||||
menuCustomColor->Check(miColorGreen, false);
|
||||
}
|
||||
|
||||
void MainWindow::onMenuColorBlue(wxCommandEvent &event){
|
||||
playerColor= Renderer::pcBlue;
|
||||
menuCustomColor->Check(miColorRed, false);
|
||||
menuCustomColor->Check(miColorBlue, true);
|
||||
menuCustomColor->Check(miColorYellow, false);
|
||||
menuCustomColor->Check(miColorGreen, false);
|
||||
}
|
||||
|
||||
void MainWindow::onMenuColorYellow(wxCommandEvent &event){
|
||||
playerColor= Renderer::pcYellow;
|
||||
menuCustomColor->Check(miColorRed, false);
|
||||
menuCustomColor->Check(miColorBlue, false);
|
||||
menuCustomColor->Check(miColorYellow, true);
|
||||
menuCustomColor->Check(miColorGreen, false);
|
||||
}
|
||||
|
||||
void MainWindow::onMenuColorGreen(wxCommandEvent &event){
|
||||
playerColor= Renderer::pcGreen;
|
||||
menuCustomColor->Check(miColorRed, false);
|
||||
menuCustomColor->Check(miColorBlue, false);
|
||||
menuCustomColor->Check(miColorYellow, false);
|
||||
menuCustomColor->Check(miColorGreen, true);
|
||||
}
|
||||
|
||||
void MainWindow::onTimer(wxTimerEvent &event){
|
||||
wxPaintEvent paintEvent;
|
||||
|
||||
anim= anim+speed;
|
||||
if(anim>1.0f){
|
||||
anim-= 1.f;
|
||||
}
|
||||
onPaint(paintEvent);
|
||||
}
|
||||
|
||||
string MainWindow::getModelInfo(){
|
||||
string str;
|
||||
|
||||
if(model!=NULL){
|
||||
str+= "Meshes: "+intToStr(model->getMeshCount());
|
||||
str+= ", Vertices: "+intToStr(model->getVertexCount());
|
||||
str+= ", Triangles: "+intToStr(model->getTriangleCount());
|
||||
str+= ", Version: "+intToStr(model->getFileVersion());
|
||||
}
|
||||
|
||||
return str;
|
||||
}
|
||||
|
||||
BEGIN_EVENT_TABLE(MainWindow, wxFrame)
|
||||
EVT_TIMER(-1, MainWindow::onTimer)
|
||||
EVT_CLOSE(MainWindow::onClose)
|
||||
EVT_MENU(miFileLoad, MainWindow::onMenuFileLoad)
|
||||
|
||||
EVT_MENU(miModeWireframe, MainWindow::onMenuModeWireframe)
|
||||
EVT_MENU(miModeNormals, MainWindow::onMenuModeNormals)
|
||||
EVT_MENU(miModeGrid, MainWindow::onMenuModeGrid)
|
||||
|
||||
EVT_MENU(miSpeedFaster, MainWindow::onMenuSpeedFaster)
|
||||
EVT_MENU(miSpeedSlower, MainWindow::onMenuSpeedSlower)
|
||||
|
||||
EVT_MENU(miColorRed, MainWindow::onMenuColorRed)
|
||||
EVT_MENU(miColorBlue, MainWindow::onMenuColorBlue)
|
||||
EVT_MENU(miColorYellow, MainWindow::onMenuColorYellow)
|
||||
EVT_MENU(miColorGreen, MainWindow::onMenuColorGreen)
|
||||
END_EVENT_TABLE()
|
||||
|
||||
// =====================================================
|
||||
// class GlCanvas
|
||||
// =====================================================
|
||||
|
||||
GlCanvas::GlCanvas(MainWindow * mainWindow):
|
||||
wxGLCanvas(mainWindow, -1, wxDefaultPosition)
|
||||
{
|
||||
this->mainWindow = mainWindow;
|
||||
}
|
||||
|
||||
void GlCanvas::onMouseMove(wxMouseEvent &event){
|
||||
mainWindow->onMouseMove(event);
|
||||
}
|
||||
|
||||
void GlCanvas::onPaint(wxPaintEvent &event){
|
||||
mainWindow->onPaint(event);
|
||||
}
|
||||
|
||||
BEGIN_EVENT_TABLE(GlCanvas, wxGLCanvas)
|
||||
EVT_MOTION(GlCanvas::onMouseMove)
|
||||
EVT_PAINT(GlCanvas::onPaint)
|
||||
END_EVENT_TABLE()
|
||||
|
||||
// ===============================================
|
||||
// class App
|
||||
// ===============================================
|
||||
|
||||
bool App::OnInit(){
|
||||
string modelPath;
|
||||
if(argc==2){
|
||||
modelPath= argv[1];
|
||||
}
|
||||
|
||||
mainWindow= new MainWindow(modelPath);
|
||||
mainWindow->Show();
|
||||
return true;
|
||||
}
|
||||
|
||||
int App::MainLoop(){
|
||||
try{
|
||||
return wxApp::MainLoop();
|
||||
}
|
||||
catch(const exception &e){
|
||||
wxMessageDialog(NULL, e.what(), "Exception", wxOK | wxICON_ERROR).ShowModal();
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
int App::OnExit(){
|
||||
return 0;
|
||||
}
|
||||
|
||||
}}//end namespace
|
||||
|
||||
IMPLEMENT_APP(Shared::G3dViewer::App)
|
||||
@@ -1,129 +0,0 @@
|
||||
#ifndef _SHADER_G3DVIEWER_MAIN_H_
|
||||
#define _SHADER_G3DVIEWER_MAIN_H_
|
||||
|
||||
#include <string>
|
||||
|
||||
#include <wx/wx.h>
|
||||
#include <wx/timer.h>
|
||||
#include <wx/glcanvas.h>
|
||||
|
||||
#include "renderer.h"
|
||||
#include "util.h"
|
||||
#include "window.h"
|
||||
|
||||
using Shared::Platform::Window;
|
||||
using Shared::Platform::MouseState;
|
||||
|
||||
using std::string;
|
||||
|
||||
namespace Shared{ namespace G3dViewer{
|
||||
|
||||
class GlCanvas;
|
||||
|
||||
// ===============================
|
||||
// class MainWindow
|
||||
// ===============================
|
||||
|
||||
class MainWindow: public wxFrame{
|
||||
private:
|
||||
DECLARE_EVENT_TABLE()
|
||||
|
||||
public:
|
||||
static const string versionString;
|
||||
static const string winHeader;
|
||||
|
||||
enum MenuId{
|
||||
miFileLoad,
|
||||
miModeWireframe,
|
||||
miModeNormals,
|
||||
miModeGrid,
|
||||
miSpeedSlower,
|
||||
miSpeedFaster,
|
||||
miColorRed,
|
||||
miColorBlue,
|
||||
miColorYellow,
|
||||
miColorGreen
|
||||
};
|
||||
|
||||
private:
|
||||
GlCanvas *glCanvas;
|
||||
Renderer *renderer;
|
||||
|
||||
wxTimer *timer;
|
||||
|
||||
wxMenuBar *menu;
|
||||
wxMenu *menuFile;
|
||||
wxMenu *menuMode;
|
||||
wxMenu *menuSpeed;
|
||||
wxMenu *menuCustomColor;
|
||||
|
||||
Model *model;
|
||||
string modelPath;
|
||||
|
||||
float speed;
|
||||
float anim;
|
||||
float rotX, rotY, zoom;
|
||||
int lastX, lastY;
|
||||
Renderer::PlayerColor playerColor;
|
||||
|
||||
public:
|
||||
MainWindow(const string &modelPath);
|
||||
~MainWindow();
|
||||
|
||||
void Notify();
|
||||
|
||||
void onPaint(wxPaintEvent &event);
|
||||
void onClose(wxCloseEvent &event);
|
||||
void onMenuFileLoad(wxCommandEvent &event);
|
||||
void onMenuModeNormals(wxCommandEvent &event);
|
||||
void onMenuModeWireframe(wxCommandEvent &event);
|
||||
void onMenuModeGrid(wxCommandEvent &event);
|
||||
void onMenuSpeedSlower(wxCommandEvent &event);
|
||||
void onMenuSpeedFaster(wxCommandEvent &event);
|
||||
void onMenuColorRed(wxCommandEvent &event);
|
||||
void onMenuColorBlue(wxCommandEvent &event);
|
||||
void onMenuColorYellow(wxCommandEvent &event);
|
||||
void onMenuColorGreen(wxCommandEvent &event);
|
||||
void onMouseMove(wxMouseEvent &event);
|
||||
void onTimer(wxTimerEvent &event);
|
||||
|
||||
string getModelInfo();
|
||||
};
|
||||
|
||||
// =====================================================
|
||||
// class GlCanvas
|
||||
// =====================================================
|
||||
|
||||
class GlCanvas: public wxGLCanvas{
|
||||
private:
|
||||
DECLARE_EVENT_TABLE()
|
||||
|
||||
public:
|
||||
GlCanvas(MainWindow *mainWindow);
|
||||
|
||||
void onMouseMove(wxMouseEvent &event);
|
||||
void onPaint(wxPaintEvent &event);
|
||||
|
||||
private:
|
||||
MainWindow *mainWindow;
|
||||
};
|
||||
|
||||
// ===============================
|
||||
// class App
|
||||
// ===============================
|
||||
|
||||
class App: public wxApp{
|
||||
private:
|
||||
MainWindow *mainWindow;
|
||||
|
||||
public:
|
||||
virtual bool OnInit();
|
||||
virtual int MainLoop();
|
||||
virtual int OnExit();
|
||||
};
|
||||
|
||||
}}//end namespace
|
||||
|
||||
DECLARE_APP(Shared::G3dViewer::App)
|
||||
|
||||
#endif
|
||||
@@ -1,272 +0,0 @@
|
||||
#include "renderer.h"
|
||||
|
||||
#include "opengl.h"
|
||||
#include "texture_gl.h"
|
||||
#include "graphics_interface.h"
|
||||
#include "graphics_factory_gl.h"
|
||||
|
||||
using namespace Shared::Graphics;
|
||||
using namespace Shared::Graphics::Gl;
|
||||
|
||||
namespace Shared{ namespace G3dViewer{
|
||||
|
||||
// ===============================================
|
||||
// class MeshCallbackTeamColor
|
||||
// ===============================================
|
||||
|
||||
void MeshCallbackTeamColor::execute(const Mesh *mesh){
|
||||
|
||||
//team color
|
||||
if(mesh->getCustomTexture() && teamTexture!=NULL){
|
||||
//texture 0
|
||||
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
|
||||
|
||||
//set color to interpolation
|
||||
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_INTERPOLATE);
|
||||
|
||||
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_TEXTURE);
|
||||
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
|
||||
|
||||
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_TEXTURE1);
|
||||
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
|
||||
|
||||
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB, GL_TEXTURE);
|
||||
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB, GL_SRC_ALPHA);
|
||||
|
||||
//set alpha to 1
|
||||
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
|
||||
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_TEXTURE);
|
||||
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
|
||||
|
||||
//texture 1
|
||||
glActiveTexture(GL_TEXTURE1);
|
||||
glMultiTexCoord2f(GL_TEXTURE1, 0.f, 0.f);
|
||||
glEnable(GL_TEXTURE_2D);
|
||||
|
||||
glBindTexture(GL_TEXTURE_2D, static_cast<const Texture2DGl*>(teamTexture)->getHandle());
|
||||
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
|
||||
|
||||
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_MODULATE);
|
||||
|
||||
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_PRIMARY_COLOR);
|
||||
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
|
||||
|
||||
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_PREVIOUS);
|
||||
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
|
||||
|
||||
//set alpha to 1
|
||||
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
|
||||
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_PRIMARY_COLOR);
|
||||
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
|
||||
|
||||
glActiveTexture(GL_TEXTURE0);
|
||||
}
|
||||
else{
|
||||
glActiveTexture(GL_TEXTURE1);
|
||||
glDisable(GL_TEXTURE_2D);
|
||||
glActiveTexture(GL_TEXTURE0);
|
||||
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
|
||||
}
|
||||
}
|
||||
|
||||
// ===============================================
|
||||
// class Renderer
|
||||
// ===============================================
|
||||
|
||||
Renderer::Renderer(){
|
||||
normals= false;
|
||||
wireframe= false;
|
||||
grid= true;
|
||||
}
|
||||
|
||||
Renderer::~Renderer(){
|
||||
delete modelRenderer;
|
||||
delete textureManager;
|
||||
}
|
||||
|
||||
Renderer * Renderer::getInstance(){
|
||||
static Renderer * renderer = new Renderer();
|
||||
return renderer;
|
||||
}
|
||||
|
||||
void Renderer::transform(float rotX, float rotY, float zoom){
|
||||
assertGl();
|
||||
|
||||
glMatrixMode(GL_MODELVIEW);
|
||||
glRotatef(rotY, 1.0f, 0.0f, 0.0f);
|
||||
glRotatef(rotX, 0.0f, 1.0f, 0.0f);
|
||||
glScalef(zoom, zoom, zoom);
|
||||
Vec4f pos(-8.0f, 5.0f, 10.0f, 0.0f);
|
||||
glLightfv(GL_LIGHT0,GL_POSITION, pos.ptr());
|
||||
|
||||
assertGl();
|
||||
}
|
||||
|
||||
void Renderer::init(){
|
||||
assertGl();
|
||||
|
||||
GraphicsFactory *gf= new GraphicsFactoryGl();
|
||||
|
||||
GraphicsInterface::getInstance().setFactory(gf);
|
||||
|
||||
modelRenderer= gf->newModelRenderer();
|
||||
textureManager= gf->newTextureManager();
|
||||
|
||||
//red tex
|
||||
customTextureRed= textureManager->newTexture2D();
|
||||
customTextureRed->getPixmap()->init(1, 1, 3);
|
||||
customTextureRed->getPixmap()->setPixel(0, 0, Vec3f(1.f, 0.f, 0.f));
|
||||
|
||||
//blue tex
|
||||
customTextureBlue= textureManager->newTexture2D();
|
||||
customTextureBlue->getPixmap()->init(1, 1, 3);
|
||||
customTextureBlue->getPixmap()->setPixel(0, 0, Vec3f(0.f, 0.f, 1.f));
|
||||
|
||||
//yellow tex
|
||||
customTextureYellow= textureManager->newTexture2D();
|
||||
customTextureYellow->getPixmap()->init(1, 1, 3);
|
||||
customTextureYellow->getPixmap()->setPixel(0, 0, Vec3f(1.f, 1.f, 0.f));
|
||||
|
||||
//green
|
||||
customTextureGreen= textureManager->newTexture2D();
|
||||
customTextureGreen->getPixmap()->init(1, 1, 3);
|
||||
customTextureGreen->getPixmap()->setPixel(0, 0, Vec3f(0.f, 0.5f, 0.f));
|
||||
|
||||
glClearColor(0.3f, 0.3f, 0.3f, 1.0f);
|
||||
glEnable(GL_TEXTURE_2D);
|
||||
glFrontFace(GL_CW);
|
||||
glEnable(GL_CULL_FACE);
|
||||
glEnable(GL_DEPTH_TEST);
|
||||
glEnable(GL_ALPHA_TEST);
|
||||
glAlphaFunc(GL_GREATER, 0.5f);
|
||||
glEnable(GL_LIGHTING);
|
||||
glEnable(GL_LIGHT0);
|
||||
|
||||
Vec4f diffuse= Vec4f(1.0f, 1.0f, 1.0f, 1.0f);
|
||||
Vec4f ambient= Vec4f(0.3f, 0.3f, 0.3f, 1.0f);
|
||||
Vec4f specular= Vec4f(0.1f, 0.1f, 0.1f, 1.0f);
|
||||
|
||||
glLightfv(GL_LIGHT0,GL_AMBIENT, ambient.ptr());
|
||||
glLightfv(GL_LIGHT0,GL_DIFFUSE, diffuse.ptr());
|
||||
glLightfv(GL_LIGHT0,GL_SPECULAR, specular.ptr());
|
||||
|
||||
glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
|
||||
glEnable(GL_COLOR_MATERIAL);
|
||||
|
||||
assertGl();
|
||||
}
|
||||
|
||||
void Renderer::reset(int w, int h, PlayerColor playerColor){
|
||||
assertGl();
|
||||
|
||||
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
||||
glViewport(0, 0, w, h);
|
||||
glMatrixMode(GL_PROJECTION);
|
||||
glLoadIdentity();
|
||||
gluPerspective(60.0f, static_cast<float>(w)/h, 1.0f, 200.0f);
|
||||
glMatrixMode(GL_MODELVIEW);
|
||||
glLoadIdentity();
|
||||
glTranslatef(0, -1.5, -5);
|
||||
|
||||
Texture2D *customTexture;
|
||||
switch(playerColor){
|
||||
case pcRed:
|
||||
customTexture= customTextureRed;
|
||||
break;
|
||||
case pcBlue:
|
||||
customTexture= customTextureBlue;
|
||||
break;
|
||||
case pcYellow:
|
||||
customTexture= customTextureYellow;
|
||||
break;
|
||||
case pcGreen:
|
||||
customTexture= customTextureGreen;
|
||||
break;
|
||||
default:
|
||||
assert(false);
|
||||
}
|
||||
meshCallbackTeamColor.setTeamTexture(customTexture);
|
||||
|
||||
if(wireframe){
|
||||
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
|
||||
glDisable(GL_TEXTURE_2D);
|
||||
glDisable(GL_LIGHTING);
|
||||
glDisable(GL_LIGHT0);
|
||||
}
|
||||
else{
|
||||
glEnable(GL_TEXTURE_2D);
|
||||
glEnable(GL_LIGHTING);
|
||||
glEnable(GL_LIGHT0);
|
||||
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
|
||||
}
|
||||
|
||||
assertGl();
|
||||
}
|
||||
|
||||
void Renderer::renderGrid(){
|
||||
if(grid){
|
||||
|
||||
float i;
|
||||
|
||||
assertGl();
|
||||
|
||||
glPushAttrib(GL_ENABLE_BIT);
|
||||
glDisable(GL_TEXTURE_2D);
|
||||
glDisable(GL_LIGHTING);
|
||||
|
||||
glBegin(GL_LINES);
|
||||
glColor3f(1.0f, 1.0f, 1.0f);
|
||||
for(i=-10.0f; i<=10.0f; i+=1.0f){
|
||||
glVertex3f(i, 0.0f, 10.0f);
|
||||
glVertex3f(i, 0.0f, -10.0f);
|
||||
}
|
||||
for(i=-10.0f; i<=10.0f; i+=1.0f){
|
||||
glVertex3f(10.f, 0.0f, i);
|
||||
glVertex3f(-10.f, 0.0f, i);
|
||||
}
|
||||
glEnd();
|
||||
|
||||
glPopAttrib();
|
||||
|
||||
assertGl();
|
||||
}
|
||||
}
|
||||
|
||||
void Renderer::toggleNormals(){
|
||||
normals= normals? false: true;
|
||||
}
|
||||
|
||||
void Renderer::toggleWireframe(){
|
||||
wireframe= wireframe? false: true;
|
||||
}
|
||||
|
||||
void Renderer::toggleGrid(){
|
||||
grid= grid? false: true;
|
||||
}
|
||||
|
||||
void Renderer::loadTheModel(Model *model, string file){
|
||||
model->setTextureManager(textureManager);
|
||||
model->loadG3d(file);
|
||||
textureManager->init();
|
||||
}
|
||||
|
||||
void Renderer::renderTheModel(Model *model, float f){
|
||||
if(model != NULL){
|
||||
modelRenderer->begin(true, true, !wireframe, &meshCallbackTeamColor);
|
||||
model->updateInterpolationData(f, true);
|
||||
modelRenderer->render(model);
|
||||
|
||||
if(normals){
|
||||
glPushAttrib(GL_ENABLE_BIT);
|
||||
glDisable(GL_LIGHTING);
|
||||
glDisable(GL_TEXTURE_2D);
|
||||
glColor3f(1.0f, 1.0f, 1.0f);
|
||||
modelRenderer->renderNormalsOnly(model);
|
||||
glPopAttrib();
|
||||
}
|
||||
|
||||
modelRenderer->end();
|
||||
}
|
||||
}
|
||||
|
||||
}}//end namespace
|
||||
@@ -1,92 +0,0 @@
|
||||
#ifndef _SHADER_G3DVIEWER_RENDERER_H_
|
||||
#define _SHADER_G3DVIEWER_RENDERER_H_
|
||||
|
||||
#include "model_renderer.h"
|
||||
#include "texture_manager.h"
|
||||
#include "model.h"
|
||||
#include "texture.h"
|
||||
|
||||
using Shared::Graphics::ModelRenderer;
|
||||
using Shared::Graphics::TextureManager;
|
||||
using Shared::Graphics::Model;
|
||||
using Shared::Graphics::Texture2D;
|
||||
|
||||
#include "model_renderer.h"
|
||||
|
||||
using Shared::Graphics::MeshCallback;
|
||||
using Shared::Graphics::Mesh;
|
||||
using Shared::Graphics::Texture;
|
||||
|
||||
namespace Shared{ namespace G3dViewer{
|
||||
|
||||
// ===============================================
|
||||
// class MeshCallbackTeamColor
|
||||
// ===============================================
|
||||
|
||||
class MeshCallbackTeamColor: public MeshCallback{
|
||||
private:
|
||||
const Texture *teamTexture;
|
||||
|
||||
public:
|
||||
void setTeamTexture(const Texture *teamTexture) {this->teamTexture= teamTexture;}
|
||||
virtual void execute(const Mesh *mesh);
|
||||
};
|
||||
|
||||
// ===============================
|
||||
// class Renderer
|
||||
// ===============================
|
||||
|
||||
class Renderer{
|
||||
public:
|
||||
static const int windowX= 100;
|
||||
static const int windowY= 100;
|
||||
static const int windowW= 640;
|
||||
static const int windowH= 480;
|
||||
|
||||
public:
|
||||
enum PlayerColor{
|
||||
pcRed,
|
||||
pcBlue,
|
||||
pcYellow,
|
||||
pcGreen
|
||||
};
|
||||
|
||||
private:
|
||||
bool wireframe;
|
||||
bool normals;
|
||||
bool grid;
|
||||
|
||||
ModelRenderer *modelRenderer;
|
||||
TextureManager *textureManager;
|
||||
Texture2D *customTextureRed;
|
||||
Texture2D *customTextureBlue;
|
||||
Texture2D *customTextureYellow;
|
||||
Texture2D *customTextureGreen;
|
||||
MeshCallbackTeamColor meshCallbackTeamColor;
|
||||
|
||||
Renderer();
|
||||
|
||||
public:
|
||||
~Renderer();
|
||||
static Renderer *getInstance();
|
||||
|
||||
void init();
|
||||
void reset(int w, int h, PlayerColor playerColor);
|
||||
void transform(float rotX, float rotY, float zoom);
|
||||
void renderGrid();
|
||||
|
||||
bool getNormals() const {return normals;}
|
||||
bool getWireframe() const {return wireframe;}
|
||||
bool getGrid() const {return grid;}
|
||||
|
||||
void toggleNormals();
|
||||
void toggleWireframe();
|
||||
void toggleGrid();
|
||||
|
||||
void loadTheModel(Model *model, string file);
|
||||
void renderTheModel(Model *model, float f);
|
||||
};
|
||||
|
||||
}}//end namespace
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user