实现一个同步的RenderApplication

#pragma once
//------------------------------------------------------------------------------
/** 
    @class App::SyncRenderApplication
    
    Render application class with single threaded rendering.
    
    (C) 2009 xoyojank
*/
#include "app/application.h"
#include "core/coreserver.h"
#include "debug/debuginterface.h"
#include "io/ioserver.h"
#include "interface/iointerface.h"
#include "input/inputserver.h"
#include "timing/timer.h"
#include "coregraphics/renderdevice.h"
#include "coregraphics/displaydevice.h"
#include "coregraphics/transformdevice.h"
#include "coregraphics/shaderserver.h"
#include "coregraphics/shaperenderer.h"
#include "coregraphics/vertexlayoutserver.h"
#include "resources/sharedresourceserver.h"
#include "resources/resourcemanager.h"
#include "models/modelserver.h"
#include "internalgraphics/internalgraphicsserver.h"
#include "lighting/lightserver.h"
#include "lighting/shadowserver.h"
#include "frame/frameserver.h"
#include "addons/nebula2/nebula2wrapper.h"
#include "http/httpinterface.h"

#include "coregraphics/textrenderer.h"

//------------------------------------------------------------------------------
namespace App
{
class SyncRenderApplication : public Application
{
public:
    /// constructor
    SyncRenderApplication();
    /// destructor
    virtual ~SyncRenderApplication();
    /// open the application
    virtual bool Open();
    /// close the application
    virtual void Close();
    /// run the application
    virtual void Run();

private:
    /// update the current time values
    void UpdateTime();

protected:
    /// set quit requested flag
    void SetQuitRequested(bool b);
    /// return true if quit requested
    bool IsQuitRequested() const;
    /// called to configure display
    virtual void OnConfigureDisplay();
    /// process input (called before rendering)
    virtual void OnProcessInput();
    /// update world 
    virtual void OnUpdateFrame();
	/// render current frame
	virtual void OnRenderFrame();
    /// get current absolute time
    Timing::Time GetTime() const;
    /// get current frame time
    Timing::Time GetFrameTime() const;

    Ptr<Core::CoreServer> coreServer;
	Ptr<Debug::DebugInterface> debugInterface;
    Ptr<IO::IoServer> ioServer;
    Ptr<Interface::IOInterface> ioInterface;
	Ptr<CoreGraphics::RenderDevice> renderDevice;
	Ptr<CoreGraphics::DisplayDevice> displayDevice;
	Ptr<CoreGraphics::TransformDevice> transformDevice;
	Ptr<CoreGraphics::ShaderServer> shaderServer;
	Ptr<CoreGraphics::ShapeRenderer> shapeRenderer;
	Ptr<CoreGraphics::VertexLayoutServer> vertexLayoutServer;
	Ptr<CoreGraphics::TextRenderer> textRenderer;
	Ptr<Resources::SharedResourceServer> sharedResourceServer;
	Ptr<Resources::ResourceManager> resourceManager;
	Ptr<Models::ModelServer> modelServer;
	Ptr<InternalGraphics::InternalGraphicsServer> graphicsServer;
	Ptr<Lighting::LightServer> lightServer;
	Ptr<Lighting::ShadowServer> shadowServer;
	Ptr<Frame::FrameServer> frameServer;
	Ptr<Anim::AnimationServer> animationServer;
    Ptr<Input::InputServer> inputServer;
	Ptr<Http::HttpInterface> httpInterface;
    Timing::Timer timer;
    Timing::Time time;
    Timing::Time frameTime;
    bool quitRequested;
};

//------------------------------------------------------------------------------
/**
*/
inline void
SyncRenderApplication::SetQuitRequested(bool b)
{
    this->quitRequested = b;
}

//------------------------------------------------------------------------------
/**
*/
inline bool
SyncRenderApplication::IsQuitRequested() const
{
    return this->quitRequested;
}

//------------------------------------------------------------------------------
/**
*/
inline Timing::Time
SyncRenderApplication::GetTime() const
{
    return this->time;
}

//------------------------------------------------------------------------------
/**
*/
inline Timing::Time
SyncRenderApplication::GetFrameTime() const
{
    return this->frameTime;
}

} // namespace App
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
//  syncrenderapplication.cc
//  (C) 2009 xoyojank
//------------------------------------------------------------------------------
#include "stdneb.h"
#include "apprender/syncrenderapplication.h"
#include "io/filestream.h"
#include "resources/simpleresourcemapper.h"
#include "coregraphics/streamtextureloader.h"
#include "coregraphics/streammeshloader.h"
#include "coregraphics/shaperenderer.h"
#include "resources/managedtexture.h"
#include "resources/managedmesh.h"
#include "coreanimation/streamanimationloader.h"
#include "internalgraphics/stagebuilder.h"
#include "internalgraphics/internalstage.h"
#include "internalgraphics/internalview.h"
#include "lighting/internalspotlightentity.h"
#include "apprender/platformconfig.h"
#include "debugrender/debugshaperenderer.h"
#include "models/nodes/statenodeinstance.h"

namespace App
{
using namespace Core;
using namespace IO;
using namespace Interface;
using namespace CoreGraphics;
using namespace InternalGraphics;
using namespace Resources;
using namespace Models;
using namespace Input;
using namespace Timing;
using namespace CoreAnimation;
using namespace Lighting;
using namespace Frame;
using namespace Anim;
using namespace Debug;

//------------------------------------------------------------------------------
/**
*/
SyncRenderApplication::SyncRenderApplication() :
    time(0.0),
    frameTime(0.0),
    quitRequested(false)
{
    // empty
}

//------------------------------------------------------------------------------
/**
*/
SyncRenderApplication::~SyncRenderApplication()
{
    n_assert(!this->IsOpen());
}

//------------------------------------------------------------------------------
/**
*/
bool
SyncRenderApplication::Open()
{
    n_assert(!this->IsOpen());
    if (Application::Open())
    {
        // setup core subsystem
        this->coreServer = CoreServer::Create();
        this->coreServer->SetCompanyName(this->companyName);
        this->coreServer->SetAppName(this->appName);
        this->coreServer->Open();

        // setup io subsystem
        // FIXME: REDUNDANT!!! 
        this->ioServer = IoServer::Create();
        this->ioServer->RegisterStandardUriSchemes();
        this->ioServer->SetupStandardAssigns();
        this->ioServer->MountStandardZipArchives();

        this->ioInterface = IOInterface::Create();
        this->ioInterface->Open();

		// setup http subsystem
		this->httpInterface = Http::HttpInterface::Create();
		this->httpInterface->Open();

		// setup debug subsystem
		this->debugInterface = DebugInterface::Create();
		this->debugInterface->Open();

        // setup graphics subsystem
		this->renderDevice = RenderDevice::Create();
		this->displayDevice = DisplayDevice::Create();
		this->transformDevice = TransformDevice::Create();
		this->shaderServer = ShaderServer::Create();
		this->shapeRenderer = ShapeRenderer::Create();
		this->textRenderer = TextRenderer::Create();
		this->vertexLayoutServer = VertexLayoutServer::Create();
		this->sharedResourceServer = SharedResourceServer::Create();
		this->resourceManager = ResourceManager::Create();
		this->modelServer = ModelServer::Create();
		this->graphicsServer = InternalGraphicsServer::Create();
		this->lightServer = LightServer::Create();
		this->shadowServer = ShadowServer::Create();
		this->frameServer = FrameServer::Create();
		this->animationServer = AnimationServer::Create();
        this->OnConfigureDisplay();
		if (!this->displayDevice->Open())
		{
			n_error("SyncRenderApplication: failed to open display device!");
		}
		if (!this->renderDevice->Open())
		{
			n_error("SyncRenderApplication: failed to open render device!");
		}
		this->vertexLayoutServer->Open();
		this->shaderServer->Open();
		this->transformDevice->Open();
		this->shapeRenderer->Open();
		this->sharedResourceServer->Open();
		this->resourceManager->Open();
		this->frameServer->Open();
		this->textRenderer->Open();

		// setup resource mapper for textures
		// FIXME: should be configurable!
		Ptr<SimpleResourceMapper> texMapper = SimpleResourceMapper::Create();
		texMapper->SetPlaceholderResourceId(ResourceId(PLACEHOLDER_TEXTURENAME));
		texMapper->SetResourceClass(Texture::RTTI);
		texMapper->SetResourceLoaderClass(StreamTextureLoader::RTTI);
		texMapper->SetManagedResourceClass(ManagedTexture::RTTI);
		this->resourceManager->AttachMapper(texMapper.upcast<ResourceMapper>());

		// setup resource mapper for meshes
		// FIXME: should be configurable!
		Ptr<SimpleResourceMapper> meshMapper = SimpleResourceMapper::Create();
		meshMapper->SetPlaceholderResourceId(ResourceId(PLACEHOLDER_MESHNAME));
		meshMapper->SetResourceClass(Mesh::RTTI);
		meshMapper->SetResourceLoaderClass(StreamMeshLoader::RTTI);
		meshMapper->SetManagedResourceClass(ManagedMesh::RTTI);
		this->resourceManager->AttachMapper(meshMapper.upcast<ResourceMapper>());

		// setup resource mapper for animations
		// FIXME: should be configurable!
		//Ptr<SimpleResourceMapper> animMapper = SimpleResourceMapper::Create();
		//animMapper->SetPlaceholderResourceId(ResourceId("ani:examples/eagle.nax2"));
		//animMapper->SetResourceClass(MemoryAnimation::RTTI);
		//animMapper->SetResourceLoaderClass(StreamAnimationLoader::RTTI);
		//animMapper->SetManagedResourceClass(ManagedAnimation::RTTI);
		//this->resourceManager->AttachMapper(animMapper.upcast<ResourceMapper>());

		this->modelServer->Open();
		this->graphicsServer->Open();
		this->lightServer->Open();
		this->shadowServer->Open();

        // setup input subsystem
        //this->inputServer = InputServer::Create();
        //this->inputServer->Open();

        // setup frame timer
        this->timer.Start();
        this->time = 0.0;
        this->frameTime = 0.01;

        return true;
    }
    return false;
}

//------------------------------------------------------------------------------
/**
*/
void
SyncRenderApplication::OnConfigureDisplay()
{
    // display adapter
    Adapter::Code adapter = Adapter::Primary;
    if (this->args.HasArg("-adapter"))
    {
        adapter = Adapter::FromString(this->args.GetString("-adapter"));
        if (this->displayDevice->AdapterExists(adapter))
        {
            this->displayDevice->SetAdapter(adapter);
        }
    }

    // display mode
    DisplayMode displayMode;
    if (this->args.HasArg("-x"))
    {
        displayMode.SetXPos(this->args.GetInt("-x"));
    }
    if (this->args.HasArg("-y"))
    {
        displayMode.SetYPos(this->args.GetInt("-y"));
    }
    if (this->args.HasArg("-w"))
    {
        displayMode.SetWidth(this->args.GetInt("-w"));
    }
    if (this->args.HasArg("-h"))
    {
        displayMode.SetHeight(this->args.GetInt("-h"));
    }
    this->displayDevice->SetDisplayMode(displayMode);
    this->displayDevice->SetFullscreen(this->args.GetBool("-fullscreen"));
    this->displayDevice->SetAlwaysOnTop(this->args.GetBool("-alwaysontop"));
    this->displayDevice->SetVerticalSyncEnabled(this->args.GetBool("-vsync"));
    if (this->args.HasArg("-aa"))
    {
        this->displayDevice->SetAntiAliasQuality(AntiAliasQuality::FromString(this->args.GetString("-aa")));
    }
    #if __XBOX360__
        this->displayDevice->SetAntiAliasQuality(AntiAliasQuality::Medium);
    #endif
}

//------------------------------------------------------------------------------
/**
*/
void
SyncRenderApplication::Close()
{
    n_assert(this->IsOpen());

    this->timer.Stop();

    //this->inputServer->Close();
    //this->inputServer = 0;

	this->frameServer = 0;
	this->shadowServer = 0;
	this->lightServer = 0;
	this->graphicsServer = 0;
	this->modelServer = 0;
	this->resourceManager = 0;
	this->sharedResourceServer = 0;
	this->vertexLayoutServer = 0;
	this->shapeRenderer = 0;
	this->shaderServer = 0;
	this->transformDevice = 0;
	this->displayDevice = 0;
	this->renderDevice = 0;
	this->animationServer = 0;
	this->textRenderer = 0;

	this->debugInterface->Close();
	this->debugInterface = 0;

	this->httpInterface->Close();
	this->httpInterface = 0;

    this->ioInterface->Close();
    this->ioInterface = 0;
    this->ioServer = 0;

    this->coreServer->Close();
    this->coreServer = 0;

    Application::Close();
}

//------------------------------------------------------------------------------
/**
*/
void
SyncRenderApplication::Run()
{
    n_assert(this->isOpen);
    //while (!(this->inputServer->IsQuitRequested() || this->IsQuitRequested()))
    //{
    //    // process input
    //    this->inputServer->BeginFrame();
    //    this->inputServer->OnFrame();
	while(true)
	{
        this->OnProcessInput();

        // update time
        this->UpdateTime();

        // run "game logic"
        this->OnUpdateFrame();

		// render frame
		this->OnRenderFrame();

        //this->inputServer->EndFrame();

        if (!this->displayDevice->IsFullscreen())
        {
            Core::SysFunc::Sleep(0.0);
        }
    }
}

//------------------------------------------------------------------------------
/**
*/
void
SyncRenderApplication::OnProcessInput()
{
    // empty, override this method in a subclass
}

//------------------------------------------------------------------------------
/**
*/
void
SyncRenderApplication::OnUpdateFrame()
{
    // empty, override this method in a subclass
}

//------------------------------------------------------------------------------
/**
*/
void
SyncRenderApplication::UpdateTime()
{
    Time curTime = this->timer.GetTime();
    this->frameTime = curTime - this->time;
    this->time = curTime;
}

//------------------------------------------------------------------------------
void
SyncRenderApplication::OnRenderFrame()
{
	// empty, override this method in a subclass
}
	
} // namespace App

#include "stdneb.h"    
#include "apprender/syncrenderapplication.h"    
#include "coregraphics/memoryvertexbufferloader.h"    
#include "resources/resourceloader.h"    
#include "timing/time.h"    

using namespace App;   
using namespace Util;   
using namespace Math;   
using namespace CoreGraphics;   
using namespace Resources;   

ImplementNebulaApplication()   

class LineRenderApp : public SyncRenderApplication   
{   
	Ptr<VertexBuffer> vertexBuffer;   
	Ptr<ShaderInstance> shaderInstance;   

public:   
	bool Open()   
	{   
		if (SyncRenderApplication::Open())   
		{   
			// vertex    
			Array<VertexComponent> vertexComponents;   
			vertexComponents.Append(VertexComponent(VertexComponent::Position, 0, VertexComponent::Float3));   
			float vertex[2][3] = { {-1.0f, -1.0f, 0.0f}, {1.0f, 1.0f, 0.0f} };   
			vertexBuffer = VertexBuffer::Create();   
			Ptr<MemoryVertexBufferLoader> vbLoader = MemoryVertexBufferLoader::Create();   
			vbLoader->Setup(vertexComponents, 2, vertex, 2 * 3 * sizeof(float));   
			vertexBuffer->SetLoader(vbLoader.upcast<ResourceLoader>());   
			vertexBuffer->SetAsyncEnabled(false);   
			vertexBuffer->Load();   
			vertexBuffer->SetLoader(NULL);   
			// shader    
			this->shaderInstance = this->shaderServer->CreateShaderInstance(ResourceId("shd:shape"));   
			Ptr<ShaderVariable> color = this->shaderInstance->GetVariableBySemantic(ShaderVariable::Semantic("MatDiffuse"));   
			color->SetVector(float4(1.0f, 1.0f, 1.0f, 1.0f));   
			Ptr<ShaderVariable> mvp = this->shaderInstance->GetVariableBySemantic(ShaderVariable::Semantic("ModelViewProjection"));   
			mvp->SetMatrix(matrix44::identity());   
		}   
		return true;   
	}   

	void OnRenderFrame()   
	{   
		this->displayDevice->ProcessWindowMessages();   
		this->renderDevice->BeginFrame();   
		this->renderDevice->BeginPass(this->renderDevice->GetDefaultRenderTarget(), this->shaderInstance);   
		PrimitiveGroup primGroup;   
		primGroup.SetBaseVertex(0);   
		primGroup.SetNumVertices(2);   
		primGroup.SetPrimitiveTopology(PrimitiveTopology::LineList);   

		this->renderDevice->SetVertexBuffer(this->vertexBuffer);   
		this->renderDevice->SetPrimitiveGroup(primGroup);   
		this->renderDevice->Draw();   
		this->renderDevice->EndPass();   
		this->renderDevice->EndFrame();   
		this->renderDevice->Present();   
	}   
};   

void  
NebulaMain(const CmdLineArgs& args)   
{   
	LineRenderApp app;   
	app.SetAppName("Test Renderer");   
	app.SetCmdLineArgs(args);   
	if (app.Open())   
	{   
		app.Run();   
		app.Close();   
	}   
	app.Exit();   
}