khanat-opennel-code/code/nel/src/cegui/nelrenderer.cpp

355 lines
10 KiB
C++
Raw Normal View History

2010-05-06 00:08:41 +00:00
/**
* \file nelrenderer.cpp
* \date November 2004
* \author Matt Raykowski
* \author Henri Kuuste
*/
// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
/************************************************************************
purpose: Implementation of Renderer class for Nevrax engine
For use with GUI Library:
Crazy Eddie's GUI System (http://crayzedsgui.sourceforge.net)
Copyright (C)2004 Paul D Turner (crayzed@users.sourceforge.net)
This file contains code that is specific to NeL (http://www.nevrax.org)
*************************************************************************/
#include "CEGUIImagesetManager.h"
#include "CEGUIImageset.h"
#include "CEGUIImage.h"
#include "CEGUIExceptions.h"
#include "CEGUISystem.h"
#include "CEGUIEventArgs.h"
#include "CEGUIImageCodec.h"
#include "CEGUIDynamicModule.h"
#include <nel/misc/dynloadlib.h>
//#include <nel/cegui/inelrenderer.h>
#include <nel/cegui/nelrenderer.h>
#include <nel/cegui/neltexture.h>
#include <nel/cegui/nelresourceprovider.h>
#include <nel/3d/u_material.h>
#include <nel/3d/u_driver.h>
#include <nel/cegui/inellibrary.h>
#include <algorithm>
#ifdef NL_OS_WINDOWS
# define NOMINMAX
# include <windows.h>
#endif
#define S_(X) #X
#define STRINGIZE(X) S_(X)
#ifndef NL_STATIC
//class CCeguiRendererNelLibrary : public NLMISC::INelLibrary {
// void onLibraryLoaded(bool /* firstTime */) { }
// void onLibraryUnloaded(bool /* lastTime */) { }
//};
NLMISC_DECL_PURE_LIB(CCeguiRendererNelLibrary)
#endif /* #ifndef NL_STATIC */
/*
* Sound driver instance creation
*/
#ifdef NL_OS_WINDOWS
// ******************************************************************
#ifdef NL_STATIC
Renderer* createNeLRendererInstance
#else
__declspec(dllexport) CEGUI::Renderer *createNeLRendererInstance
#endif
(NL3D::UDriver *driver, bool withRP=true)
{
return new CEGUI::NeLRenderer(driver, withRP);
}
// ******************************************************************
#elif defined (NL_OS_UNIX)
extern "C"
{
CEGUI::Renderer *createNeLRendererInstance(NL3D::UDriver *driver, bool withRP=true)
{
return new CEGUI::NeLRenderer(driver, withRP);
}
} // extern "C"
#endif // NL_OS_UNIX
// Start of CEGUI namespace section
namespace CEGUI
{
class NeLTexture;
/*************************************************************************
Constants definitions
*************************************************************************/
const int NeLRenderer::VERTEX_PER_QUAD = 4;
const int NeLRenderer::VERTEX_PER_TRIANGLE = 3;
const int NeLRenderer::VERTEXBUFFER_CAPACITY = 4096;
NeLRenderer::NeLRenderer(NL3D::UDriver *driver, bool withRP, ImageCodec* codec)
{
m_Driver=driver;
d_queueing=true;
NL3D::UDriver::CMode mode;
driver->getCurrentScreenMode(mode);
d_display_area.d_left=0;
d_display_area.d_top=0;
d_display_area.d_right=(float)driver->getWindowWidth();
d_display_area.d_bottom=(float)driver->getWindowHeight();
m_InputDriver.addToServer(m_Driver->EventServer);
m_InputDriver.setScreenMode(d_display_area.getWidth(),d_display_area.getHeight(),(float)mode.Depth);
m_InputDriver.setDriver(m_Driver);
NLMISC::CHTimer::startBench();
m_NelProvider=withRP;
m_FrameCount=0;
m_ImageCodec = codec;
m_ImageCodecModule = NULL;
if(!m_ImageCodec)
setupImageCodec("");
}
NeLRenderer::~NeLRenderer(void)
{
destroyAllTextures();
cleanupImageCodec();
m_InputDriver.removeFromServer(m_Driver->EventServer);
NLMISC::CHTimer::clear();
}
// void NeLRenderer::addSearchPath(const std::string &path, bool recurse, bool alternative, class NLMISC::IProgressCallback *progressCallBack) {
// NLMISC::CPath::addSearchPath(path.c_str(),recurse,alternative,progressCallBack);
// }
void NeLRenderer::addQuad(const Rect& dest_rect, float z, const Texture* tex, const Rect& texture_rect, const ColourRect& colours, QuadSplitMode quad_split_mode)
{
using namespace NLMISC;
H_AUTO(NeLRenderer_addQuad);
/*
* Special note: quad splitting is not yet supported.
*/
NLMISC::CQuadColorUV nelquad;
NeLTexture *text=(NeLTexture *)tex;
// set quad position, flipping y co-ordinates, and applying appropriate texel origin offset
Rect position=dest_rect;
position.offset(Point(-0.5f, -0.5f));
// upper left
nelquad.V0.set(position.d_left, position.d_top, z);
nelquad.Uv0.set(texture_rect.d_left, texture_rect.d_top);
nelquad.Color0=colorToNeL(colours.d_bottom_left);
// upper right
nelquad.V1.set(position.d_right, position.d_top, z);
nelquad.Uv1.set(texture_rect.d_right, texture_rect.d_top);
nelquad.Color1=colorToNeL(colours.d_bottom_right);
// lower right
nelquad.V2.set(position.d_right, position.d_bottom, z);
nelquad.Uv2.set(texture_rect.d_right, texture_rect.d_bottom);
nelquad.Color2=colorToNeL(colours.d_top_right);
// lower left
nelquad.V3.set(position.d_left, position.d_bottom, z);
nelquad.Uv3.set(texture_rect.d_left, texture_rect.d_bottom);
nelquad.Color3=colorToNeL(colours.d_top_left);
if(!d_queueing) {
renderQuad(nelquad,text->getNeLTexture());
} else {
QuadVector::reverse_iterator itr = d_quadlist.rbegin();
if((d_quadlist.size() > 0) && ((*itr).texture == text)) {
(*itr).quads.push_back(nelquad);
} else {
QuadInfo qI;
qI.texture = text;
qI.quads.push_back(nelquad);
d_quadlist.push_back(qI);
}
}
}
void NeLRenderer::renderQuad(NLMISC::CQuadColorUV quad, NL3D::UMaterial mat) {
using namespace NLMISC;
H_AUTO(NeLRenderer_renderQuad);
m_Driver->setFrustum(NL3D::CFrustum(0, d_display_area.getWidth(), d_display_area.getHeight(), 0, -1, 1, false));
m_Driver->drawQuad(quad,mat);
}
void NeLRenderer::doRender(void)
{
using namespace NLMISC;
H_AUTO(NeLRenderer_doRender);
// set the culling frustrum
m_Driver->setFrustum(NL3D::CFrustum(0, d_display_area.getWidth(), d_display_area.getHeight(), 0, -1, 1, false));
// and go through the list.
for(QuadVector::iterator itr=d_quadlist.begin();itr!=d_quadlist.end();itr++) {
NL3D::UMaterial mat = (*itr).texture->getNeLTexture();
m_Driver->drawQuads((*itr).quads,mat);
}
m_FrameCount++;
if(m_FrameCount==200) {
#ifdef _DEBUG
NLMISC::CHTimer::displaySummary();
nlinfo("Quad list size: %d", d_quadlist.size());
#endif
m_FrameCount=0;
}
}
void NeLRenderer::clearRenderList(void)
{
d_quadlist.clear();
}
Texture *NeLRenderer::createTexture(void)
{
NeLTexture *tex=new NeLTexture(this);
d_texturelist.push_back((NeLTexture *const)tex);
return tex;
}
Texture *NeLRenderer::createTexture(const String &filename, const String &resourceGroup)
{
NeLTexture *tex=(NeLTexture*)createTexture();
tex->loadFromFile(filename, resourceGroup);
return tex;
}
Texture *NeLRenderer::createTexture(float size)
{
NeLTexture* tex = (NeLTexture*)createTexture();
return tex;
}
void NeLRenderer::destroyTexture(Texture* texture)
{
if (texture != NULL)
{
NeLTexture *tex=(NeLTexture *)texture;
d_texturelist.remove((NeLTexture *const)tex);
delete tex;
}
}
void NeLRenderer::destroyAllTextures(void)
{
while(!d_texturelist.empty())
{
destroyTexture((Texture *)*(d_texturelist.begin()));
}
}
void NeLRenderer::sortQuads(void)
{
;
}
void NeLRenderer::setQueueingEnabled(bool setting) {
d_queueing = setting;
}
bool NeLRenderer::isQueueingEnabled(void) const {
return d_queueing;
}
NLMISC::CRGBA NeLRenderer::colorToNeL(CEGUI::colour color) {
NLMISC::CRGBA ctmp;
ctmp.set((uint8)(color.getRed()*255),(uint8)(color.getGreen()*255),(uint8)(color.getBlue()*255),(uint8)(color.getAlpha()*255));
return ctmp;
}
ResourceProvider* NeLRenderer::createResourceProvider(void)
{
if(d_resourceProvider==0) {
//if(m_NelProvider) {
d_resourceProvider = new NeLResourceProvider();
//} else {
// d_resourceProvider = new DefaultResourceProvider();
//}
}
return d_resourceProvider;
}
ImageCodec &NeLRenderer::getImageCodec(void) {
return *m_ImageCodec;
}
void NeLRenderer::setImageCodec(const String &codecName) {
setupImageCodec(codecName);
}
void NeLRenderer::setImageCodec(ImageCodec *codec) {
if(codec) {
cleanupImageCodec();
m_ImageCodec = codec;
m_ImageCodecModule = 0;
}
}
void NeLRenderer::setupImageCodec(const String& codecName) {
// Cleanup the old image codec
if(m_ImageCodec)
cleanupImageCodec();
// Test whether we should use the default codec or not
if(codecName.empty())
m_ImageCodecModule = new DynamicModule(String("CEGUI") + m_DefaultImageCodecName);
else
m_ImageCodecModule = new DynamicModule(String("CEGUI") + codecName);
// Create the codec object itself
ImageCodec* (*createFunc)(void) = (ImageCodec* (*)(void))m_ImageCodecModule->getSymbolAddress("createImageCodec");
m_ImageCodec = createFunc();
}
void NeLRenderer::cleanupImageCodec() {
if (m_ImageCodec && m_ImageCodecModule) {
void(*deleteFunc)(ImageCodec*) = (void(*)(ImageCodec*))m_ImageCodecModule->getSymbolAddress("destroyImageCodec");
deleteFunc(m_ImageCodec);
m_ImageCodec = 0;
delete m_ImageCodecModule;
m_ImageCodecModule = 0;
}
}
String NeLRenderer::m_DefaultImageCodecName("DevILImageCodec");
} // end namespace CEGUI