BansheeEngine/BansheeRenderer/Source/BsBansheeRenderer.cpp

#include "BsBansheeRenderer.h"
#include "BsCamera.h"
#include "BsSceneObject.h"
#include "BsSceneManager.h"
#include "BsRenderable.h"
#include "BsMaterial.h"
#include "BsMesh.h"
#include "BsPass.h"
#include "BsBlendState.h"
#include "BsRasterizerState.h"
#include "BsDepthStencilState.h"
#include "BsCoreApplication.h"
#include "BsViewport.h"
#include "BsRenderTarget.h"
#include "BsRenderQueue.h"
#include "BsOverlayManager.h"
#include "BsDrawHelper2D.h"
#include "BsDrawHelper3D.h"
#include "BsGUIManager.h"
#include "BsCoreThread.h"
#include "BsGpuParams.h"
#include "BsProfilerCPU.h"
#include "BsShader.h"
#include "BsTechnique.h"
#include "BsDrawList.h"

using namespace std::placeholders;

namespace BansheeEngine
{
	BansheeRenderer::BansheeRenderer()
	{
		mRenderableRemovedConn = gBsSceneManager().onRenderableRemoved.connect(std::bind(&BansheeRenderer::renderableRemoved, this, _1));
		mCameraRemovedConn = gBsSceneManager().onCameraRemoved.connect(std::bind(&BansheeRenderer::cameraRemoved, this, _1));

		// Init compatible material params
		RendererMaterialParams dx9params("BansheeD3D9RenderSystem", RenType_UnlitUntextured);

		// TODO - In a perfect world I would get element size and offsets by creating a dummy version of the param block
		// and reading the values.
		dx9params.addDataParam(RPS_WorldViewProjTfrm, GPT_VERTEX_PROGRAM, GPDT_MATRIX_4X4, sizeof(Matrix4), 0, 0, RP_AnyPass, RBS_PerObject);

		mRenderableMaterialParams.insert(dx9params);

		// Init default shaders
		mLitTexturedData.defaultShader = getDefaultShader(RenType_LitTextured);
		TechniquePtr defaultTechnique = mLitTexturedData.defaultShader->getBestTechnique();
		PassPtr defaultPass = defaultTechnique->getPass(0);

		const GpuParamDesc& vertParamDesc = defaultPass->getVertexProgram()->getParamDesc();
		const GpuParamDesc& fragParamDesc = defaultPass->getFragmentProgram()->getParamDesc();

		const Map<String, SHADER_DATA_PARAM_DESC>& dataParams = mLitTexturedData.defaultShader->_getDataParams();
		for (auto& param : dataParams)
		{
			if (param.second.rendererSemantic == BRPS_LightDir)
			{
				auto iterFind = fragParamDesc.params.find(param.second.gpuVariableName);
				if (iterFind == fragParamDesc.params.end())
					BS_EXCEPT(InternalErrorException, "Invalid default shader.");

				mLitTexturedData.lightDirParamDesc = iterFind->second;
			}
			else if (param.second.rendererSemantic == BRPS_Time)
			{
				auto iterFind = vertParamDesc.params.find(param.second.gpuVariableName);
				if (iterFind == vertParamDesc.params.end())
					BS_EXCEPT(InternalErrorException, "Invalid default shader.");

				mLitTexturedData.timeParamDesc = iterFind->second;
			}
			else if (param.second.rendererSemantic == RPS_WorldViewProjTfrm)
			{
				auto iterFind = vertParamDesc.params.find(param.second.gpuVariableName);
				if (iterFind == vertParamDesc.params.end())
					BS_EXCEPT(InternalErrorException, "Invalid default shader.");

				mLitTexturedData.wvpParamDesc = iterFind->second;
			}
		}

		const Map<String, SHADER_PARAM_BLOCK_DESC>& paramBlocks = mLitTexturedData.defaultShader->_getParamBlocks();
		for (auto& block : paramBlocks)
		{
			if (block.second.rendererSemantic == RBS_Occassional)
			{
				auto iterFind = vertParamDesc.paramBlocks.find(block.second.name);
				if (iterFind == vertParamDesc.paramBlocks.end())
					BS_EXCEPT(InternalErrorException, "Invalid default shader.");

				mLitTexturedData.staticParamBlockDesc = iterFind->second;
			}
			else if (block.second.rendererSemantic == RBS_PerFrame)
			{
				auto iterFind = fragParamDesc.paramBlocks.find(block.second.name);
				if (iterFind == fragParamDesc.paramBlocks.end())
					BS_EXCEPT(InternalErrorException, "Invalid default shader.");

				mLitTexturedData.perFrameParamBlockDesc = iterFind->second;
			}
			else if (block.second.rendererSemantic == RBS_PerObject)
			{
				auto iterFind = vertParamDesc.paramBlocks.find(block.second.name);
				if (iterFind == vertParamDesc.paramBlocks.end())
					BS_EXCEPT(InternalErrorException, "Invalid default shader.");

				mLitTexturedData.perObjectParamBlockDesc = iterFind->second;
			}
		}
	}

	BansheeRenderer::~BansheeRenderer()
	{
		mRenderableRemovedConn.disconnect();
		mCameraRemovedConn.disconnect();
	}

	const String& BansheeRenderer::getName() const
	{
		static String name = "BansheeRenderer";
		return name;
	}

	ShaderPtr BansheeRenderer::getDefaultShader(RenderableType type) const
	{
		return nullptr;
	}

	void BansheeRenderer::addRenderableProxy(RenderableProxyPtr proxy)
	{
		for (auto& element : proxy->renderableElements)
		{
			mRenderableElements.push_back(element);
			mWorldTransforms.push_back(element->worldTransform);
			mWorldBounds.push_back(element->calculateWorldBounds());

			element->id = (UINT32)(mRenderableElements.size() - 1);
		}
	}

	void BansheeRenderer::removeRenderableProxy(RenderableProxyPtr proxy)
	{
		for (auto& element : proxy->renderableElements)
		{
			assert(mRenderableElements.size() > element->id && element->id >= 0);

			if (mRenderableElements.size() == 0)
				mRenderableElements.erase(mRenderableElements.begin());
			else
			{
				std::swap(mRenderableElements[element->id], mRenderableElements.back());
				mRenderableElements.erase(mRenderableElements.end() - 1);

				mRenderableElements[element->id]->id = element->id;
			}
		}
	}

	void BansheeRenderer::updateRenderableProxy(RenderableProxyPtr proxy, Matrix4 localToWorld)
	{
		for (auto& element : proxy->renderableElements)
		{
			element->worldTransform = localToWorld;

			mWorldTransforms[element->id] = localToWorld;
			mWorldBounds[element->id] = element->calculateWorldBounds();
		}
	}

	void BansheeRenderer::addCameraProxy(CameraProxyPtr proxy)
	{
		RenderTargetPtr renderTarget = proxy->viewport.getTarget();
		auto findIter = std::find(mRenderTargets.begin(), mRenderTargets.end(), renderTarget);

		if (findIter != mRenderTargets.end())
		{
			proxy->renderQueue = bs_shared_ptr<RenderQueue>();

			findIter->cameras.push_back(proxy);
		}
		else
		{
			mRenderTargets.push_back(RenderTargetData());
			RenderTargetData& renderTargetData = mRenderTargets.back();

			proxy->renderQueue = bs_shared_ptr<RenderQueue>();
			renderTargetData.cameras.push_back(proxy);
		}

		// Sort everything based on priority
		auto cameraComparer = [&](const CameraProxyPtr& a, const CameraProxyPtr& b) { return a->priority > b->priority; };
		auto renderTargetInfoComparer = [&](const RenderTargetData& a, const RenderTargetData& b) { return a.target->getPriority() > b.target->getPriority(); };
		std::sort(begin(mRenderTargets), end(mRenderTargets), renderTargetInfoComparer);

		for (auto& camerasPerTarget : mRenderTargets)
		{
			Vector<CameraProxyPtr>& cameras = camerasPerTarget.cameras;

			std::sort(begin(cameras), end(cameras), cameraComparer);
		}
	}

	void BansheeRenderer::removeCameraProxy(CameraProxyPtr proxy)
	{
		RenderTargetPtr renderTarget = proxy->viewport.getTarget();
		auto findIter = std::find(mRenderTargets.begin(), mRenderTargets.end(), renderTarget);

		if (findIter != mRenderTargets.end())
		{
			auto findIter2 = std::find(findIter->cameras.begin(), findIter->cameras.end(), proxy);

			if (findIter2 != findIter->cameras.end())
			{
				findIter->cameras.erase(findIter2);
			}

			if (findIter->cameras.size() == 0)
				mRenderTargets.erase(findIter);
		}
	}

	void BansheeRenderer::updateCameraProxy(CameraProxyPtr proxy, Matrix4 viewMatrix)
	{
		proxy->viewMatrix = viewMatrix;
	}

	void BansheeRenderer::renderableRemoved(const HRenderable& renderable)
	{
		if (renderable->_getActiveProxy() != nullptr)
		{
			mDeletedRenderableProxies.push_back(renderable->_getActiveProxy());
		}
	}

	void BansheeRenderer::cameraRemoved(const HCamera& camera)
	{
		if (camera->_getActiveProxy() != nullptr)
		{
			mDeletedCameraProxies.push_back(camera->_getActiveProxy());
		}
	}

	void BansheeRenderer::renderAll() 
	{
		gProfilerCPU().beginSample("renderA");

		gBsSceneManager().updateRenderableTransforms();

		// Remove proxies from deleted Renderables
		for (auto& proxy : mDeletedRenderableProxies)
		{
			if (proxy != nullptr)
				gCoreAccessor().queueCommand(std::bind(&BansheeRenderer::removeRenderableProxy, this, proxy));
		}

		// Add or update Renderable proxies
		const Vector<HRenderable>& allRenderables = gBsSceneManager().getAllRenderables();
		Vector<HSceneObject> dirtySceneObjects;
		Vector<HRenderable> dirtyRenderables;

		for (auto& renderable : allRenderables)
		{
			bool addedNewProxy = false;
			RenderableProxyPtr proxy;

			if (!renderable->_isCoreDirty())
			{
				proxy = renderable->_getActiveProxy();

				if (proxy != nullptr)
					gCoreAccessor().queueCommand(std::bind(&BansheeRenderer::removeRenderableProxy, this, proxy));

				proxy = renderable->_createProxy();
				renderable->_setActiveProxy(proxy);

				gCoreAccessor().queueCommand(std::bind(&BansheeRenderer::addRenderableProxy, this, proxy));

				dirtyRenderables.push_back(renderable);
				dirtySceneObjects.push_back(renderable->SO());
				addedNewProxy = true;
			}
			else if (!renderable->SO()->_isCoreDirty())
			{
				proxy = renderable->_getActiveProxy();
				assert(proxy != nullptr);

				gCoreAccessor().queueCommand(std::bind(&BansheeRenderer::updateRenderableProxy, this, proxy, renderable->SO()->getWorldTfrm()));

				dirtySceneObjects.push_back(renderable->SO());
			}

			if (!addedNewProxy)
			{
				for (UINT32 i = 0; i < (UINT32)proxy->renderableElements.size(); i++)
				{
					HMaterial mat = renderable->getMaterial(i);
					if (mat != nullptr && mat.isLoaded() && mat->_isCoreDirty(MaterialDirtyFlag::Params))
					{
						Vector<PassParameters> dirtyPassParams;
						for (UINT32 j = 0; j < mat->getNumPasses(); j++)
						{
							PassParametersPtr passParams = mat->getPassParameters(j);

							PassParameters dirtyParams;
							for (UINT32 k = 0; k < passParams->getNumParams(); k++)
							{
								GpuParamsPtr params = passParams->getParamByIdx(k);
								if (params != nullptr && params->_isCoreDirty())
								{
									dirtyParams.setParamByIdx(k, params->clone());

									params->_markCoreClean();
								}
							}

							dirtyPassParams.push_back(dirtyParams);
						}
						
						gCoreAccessor().queueCommand(std::bind(&BansheeRenderer::updateMaterialProxy, this, proxy->renderableElements[i]->material, dirtyPassParams));
					}
				}
			}
		}

		// Mark all renderables as clean (needs to be done after all proxies are updated as
		// this will also clean materials & meshes which may be shared, so we don't want to clean them
		// too early.
		for (auto& renderable : dirtyRenderables)
		{
			renderable->_markCoreClean();
		}

		// Remove proxies from deleted Cameras
		for (auto& proxy : mDeletedCameraProxies)
		{
			if (proxy != nullptr)
				gCoreAccessor().queueCommand(std::bind(&BansheeRenderer::removeCameraProxy, this, proxy));
		}

		// Add or update Camera proxies
		const Vector<HCamera>& allCameras = gBsSceneManager().getAllCameras();
		for (auto& camera : allCameras)
		{
			if (!camera->_isCoreDirty())
			{
				CameraProxyPtr proxy = camera->_getActiveProxy();

				if (proxy != nullptr)
					gCoreAccessor().queueCommand(std::bind(&BansheeRenderer::removeCameraProxy, this, proxy));

				proxy = camera->_createProxy();
				camera->_setActiveProxy(proxy);

				gCoreAccessor().queueCommand(std::bind(&BansheeRenderer::addCameraProxy, this, proxy));

				camera->_markCoreClean();
				dirtySceneObjects.push_back(camera->SO());
			}
			else if (!camera->SO()->_isCoreDirty())
			{
				CameraProxyPtr proxy = camera->_getActiveProxy();
				assert(proxy != nullptr);

				gCoreAccessor().queueCommand(std::bind(&BansheeRenderer::updateCameraProxy, this, proxy, camera->getViewMatrix()));

				dirtySceneObjects.push_back(camera->SO());
			}
		}

		// Mark scene objects clean
		for (auto& dirtySO : dirtySceneObjects)
		{
			dirtySO->_markCoreClean();
		}

		// Populate direct draw lists
		for (auto& camera : allCameras)
		{
			DrawListPtr drawList = bs_shared_ptr<DrawList>();

			// Get GUI render operations
			GUIManager::instance().render(camera->getViewport(), *drawList);

			// Get overlay render operations
			OverlayManager::instance().render(camera->getViewport(), *drawList);

			// Get debug render operations
			DrawHelper3D::instance().render(camera, *drawList);
			DrawHelper2D::instance().render(camera, *drawList);

			// Get any operations from hooked up callbacks
			const Viewport* viewportRawPtr = camera->getViewport().get();
			auto callbacksForViewport = mRenderCallbacks[viewportRawPtr];

			for (auto& callback : callbacksForViewport)
				callback(viewportRawPtr, *drawList);

			gCoreAccessor().queueCommand(std::bind(&BansheeRenderer::setDrawList, camera->_getActiveProxy(), drawList));
		}

		gCoreAccessor().queueCommand(std::bind(&BansheeRenderer::renderAllCore, this));
	}

	void BansheeRenderer::setDrawList(CameraProxyPtr proxy, DrawListPtr drawList)
	{
		RenderQueuePtr renderQueue = proxy->renderQueue;

		const Vector<DrawOperation>& drawOps = drawList->getDrawOperations();
		for (auto& drawOp : drawOps)
		{
			// TODO - Will I need to check if materials match renderer?

			renderQueue->add(drawOp.material->_createProxy(),
				drawOp.mesh->_createProxy(drawOp.submeshIdx), drawOp.worldPosition);
		}
	}

	void BansheeRenderer::updateMaterialProxy(MaterialProxyPtr proxy, Vector<PassParameters> dirtyPassParams)
	{
		assert(proxy->passes.size() == dirtyPassParams.size());

		for (UINT32 i = 0; i < (UINT32)proxy->passes.size(); i++)
		{
			PassParameters& dirtyParams = dirtyPassParams[i];

			if (dirtyParams.mVertParams != nullptr)
				proxy->passes[i].vertexProgParams = dirtyParams.mVertParams;

			if (dirtyParams.mFragParams != nullptr)
				proxy->passes[i].fragmentProgParams = dirtyParams.mFragParams;

			if (dirtyParams.mGeomParams != nullptr)
				proxy->passes[i].geometryProgParams = dirtyParams.mGeomParams;

			if (dirtyParams.mHullParams != nullptr)
				proxy->passes[i].hullProgParams = dirtyParams.mHullParams;

			if (dirtyParams.mDomainParams != nullptr)
				proxy->passes[i].domainProgParams = dirtyParams.mDomainParams;

			if (dirtyParams.mComputeParams != nullptr)
				proxy->passes[i].computeProgParams = dirtyParams.mComputeParams;
		}
	}

	void BansheeRenderer::renderAllCore()
	{
		THROW_IF_NOT_CORE_THREAD;

		// TODO: Perform hardware buffer updates
		// For each render type
		//   - Update static and per-frame gpu buffers update it with new data
		//     e.g. write lightDir parameter to static buffer and write time parameter to per-frame buffer
		//     (I will also likely need per-camera buffers later)
		//   - Go through all RenderableProxies and get their per-object buffers, update them with per-object data
		//   - Call updateHardwareBuffers() on all params
		//   - Ensure that when MaterialProxy is added/updated I properly create per-object buffers and hook up
		//     buffers

		// Render everything, target by target
		for (auto& renderTargetData : mRenderTargets)
		{
			RenderTargetPtr target = renderTargetData.target;
			Vector<CameraProxyPtr>& cameras = renderTargetData.cameras;

			RenderSystem::instance().beginFrame();

			for(auto& camera : cameras)
			{
				Viewport& viewport = camera->viewport;
				RenderSystem::instance().setViewport(viewport);

				UINT32 clearBuffers = 0;
				if(viewport.getRequiresColorClear())
					clearBuffers |= FBT_COLOR;

				if(viewport.getRequiresDepthClear())
					clearBuffers |= FBT_DEPTH;

				if(viewport.getRequiresStencilClear())
					clearBuffers |= FBT_STENCIL;

				if(clearBuffers != 0)
					RenderSystem::instance().clearViewport(clearBuffers, viewport.getClearColor(), viewport.getClearDepthValue(), viewport.getClearStencilValue());

				render(*camera, camera->renderQueue);
			}

			RenderSystem::instance().endFrame();
			RenderSystem::instance().swapBuffers(target);
		}
	}

	void BansheeRenderer::render(const CameraProxy& cameraProxy, const RenderQueuePtr& renderQueue) 
	{
		THROW_IF_NOT_CORE_THREAD;

		RenderSystem& rs = RenderSystem::instance();

		if (!cameraProxy.ignoreSceneRenderables)
		{
			// TODO - Do frustum culling
			for (auto& renderableProxy : mRenderableElements)
			{
				// TODO - Apply world-view-proj matrix

				renderQueue->add(renderableProxy->material, renderableProxy->mesh, mWorldBounds[renderableProxy->id].getSphere().getCenter());
				
			}
		}

		Matrix4 projMatrixCstm = cameraProxy.projMatrix;
		Matrix4 viewMatrixCstm = cameraProxy.viewMatrix;

		Matrix4 viewProjMatrix = projMatrixCstm * viewMatrixCstm;

		renderQueue->sort();
		const Vector<RenderQueueElement>& sortedRenderElements = renderQueue->getSortedElements();

		for(auto iter = sortedRenderElements.begin(); iter != sortedRenderElements.end(); ++iter)
		{
			MaterialProxyPtr materialProxy = iter->material;

			setPass(materialProxy->passes[iter->passIdx]);
			draw(*iter->mesh);
		}
	}

	void BansheeRenderer::setPass(const MaterialProxyPass& pass)
	{
		THROW_IF_NOT_CORE_THREAD;

		RenderSystem& rs = RenderSystem::instance();

		if (pass.vertexProg)
		{
			rs.bindGpuProgram(pass.vertexProg);
			rs.bindGpuParams(GPT_VERTEX_PROGRAM, pass.vertexProgParams);
		}
		else
			rs.unbindGpuProgram(GPT_VERTEX_PROGRAM);

		if (pass.fragmentProg)
		{
			rs.bindGpuProgram(pass.fragmentProg);
			rs.bindGpuParams(GPT_FRAGMENT_PROGRAM, pass.geometryProgParams);
		}
		else
			rs.unbindGpuProgram(GPT_FRAGMENT_PROGRAM);

		if (pass.geometryProg)
		{
			rs.bindGpuProgram(pass.geometryProg);
			rs.bindGpuParams(GPT_GEOMETRY_PROGRAM, pass.geometryProgParams);
		}
		else
			rs.unbindGpuProgram(GPT_GEOMETRY_PROGRAM);

		if (pass.hullProg)
		{
			rs.bindGpuProgram(pass.hullProg);
			rs.bindGpuParams(GPT_HULL_PROGRAM, pass.hullProgParams);
		}
		else
			rs.unbindGpuProgram(GPT_HULL_PROGRAM);

		if (pass.domainProg)
		{
			rs.bindGpuProgram(pass.domainProg);
			rs.bindGpuParams(GPT_DOMAIN_PROGRAM, pass.domainProgParams);
		}
		else
			rs.unbindGpuProgram(GPT_DOMAIN_PROGRAM);

		if (pass.computeProg)
		{
			rs.bindGpuProgram(pass.computeProg);
			rs.bindGpuParams(GPT_COMPUTE_PROGRAM, pass.computeProgParams);
		}
		else
			rs.unbindGpuProgram(GPT_COMPUTE_PROGRAM);

		// TODO - Try to limit amount of state changes, if previous state is already the same

		// Set up non-texture related pass settings
		if (pass.blendState != nullptr)
			rs.setBlendState(pass.blendState.getInternalPtr());
		else
			rs.setBlendState(BlendState::getDefault());

		if (pass.depthStencilState != nullptr)
			rs.setDepthStencilState(pass.depthStencilState.getInternalPtr(), pass.stencilRefValue);
		else
			rs.setDepthStencilState(DepthStencilState::getDefault(), pass.stencilRefValue);

		if (pass.rasterizerState != nullptr)
			rs.setRasterizerState(pass.rasterizerState.getInternalPtr());
		else
			rs.setRasterizerState(RasterizerState::getDefault());
	}

	void BansheeRenderer::draw(const MeshProxy& meshProxy)
	{
		THROW_IF_NOT_CORE_THREAD;

		RenderSystem& rs = RenderSystem::instance();
		MeshPtr mesh = meshProxy.mesh;
		std::shared_ptr<VertexData> vertexData = mesh->_getVertexData();

		rs.setVertexDeclaration(vertexData->vertexDeclaration);
		auto vertexBuffers = vertexData->getBuffers();

		if (vertexBuffers.size() > 0)
		{
			VertexBufferPtr buffers[MAX_BOUND_VERTEX_BUFFERS];

			UINT32 endSlot = 0;
			UINT32 startSlot = MAX_BOUND_VERTEX_BUFFERS;
			for (auto iter = vertexBuffers.begin(); iter != vertexBuffers.end(); ++iter)
			{
				if (iter->first >= MAX_BOUND_VERTEX_BUFFERS)
					BS_EXCEPT(InvalidParametersException, "Buffer index out of range");

				startSlot = std::min(iter->first, startSlot);
				endSlot = std::max(iter->first, endSlot);
			}

			for (auto iter = vertexBuffers.begin(); iter != vertexBuffers.end(); ++iter)
			{
				buffers[iter->first - startSlot] = iter->second;
			}

			rs.setVertexBuffers(startSlot, buffers, endSlot - startSlot + 1);
		}

		SubMesh subMesh = meshProxy.subMesh;
		rs.setDrawOperation(subMesh.drawOp);

		IndexBufferPtr indexBuffer = mesh->_getIndexBuffer();

		UINT32 indexCount = subMesh.indexCount;
		if (indexCount == 0)
			indexCount = indexBuffer->getNumIndices();

		rs.setIndexBuffer(indexBuffer);
		rs.drawIndexed(subMesh.indexOffset, indexCount, mesh->_getVertexOffset(), vertexData->vertexCount);

		mesh->_notifyUsedOnGPU();
	}
}