gzdoom/src/hwrenderer/data/flatvertices.h

// 
//---------------------------------------------------------------------------
//
// Copyright(C) 2005-2016 Christoph Oelckers
// All rights reserved.
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program.  If not, see http://www.gnu.org/licenses/
//
//--------------------------------------------------------------------------
//

#ifndef _HW__VERTEXBUFFER_H
#define _HW__VERTEXBUFFER_H

#include "tarray.h"
#include "hwrenderer/data/buffers.h"
#include <atomic>
#include <mutex>

class FRenderState;

struct FFlatVertex
{
	float x, z, y;	// world position
	float u, v;		// texture coordinates

	void SetFlatVertex(vertex_t *vt, const secplane_t &plane);
	void Set(float xx, float zz, float yy, float uu, float vv)
	{
		x = xx;
		z = zz;
		y = yy;
		u = uu;
		v = vv;
	}
};

class FFlatVertexBuffer
{
	TArray<FFlatVertex> vbo_shadowdata;
	TArray<uint32_t> ibo_data;

	IVertexBuffer *mVertexBuffer;
	IIndexBuffer *mIndexBuffer;

	unsigned int mIndex;
	std::atomic<unsigned int> mCurIndex;
	std::mutex mBufferMutex;
	unsigned int mNumReserved;


	static const unsigned int BUFFER_SIZE = 2000000;
	static const unsigned int BUFFER_SIZE_TO_USE = 1999500;


	// Temporary data for creating an indexed buffer
	struct FIndexGenerationInfo
	{
		TArray<vertex_t *> vertices;
		TMap<vertex_t*, uint32_t> vertexmap;

		uint32_t AddVertex(vertex_t *vert)
		{
			auto check = vertexmap.CheckKey(vert);
			if (check != nullptr) return *check;
			auto index = vertices.Push(vert);
			vertexmap[vert] = index;
			return index;
		}

		uint32_t GetIndex(vertex_t *vert)
		{
			auto check = vertexmap.CheckKey(vert);
			if (check != nullptr) return *check;
			return ~0;
		}
	};


public:
	enum
	{
		QUAD_INDEX = 0,
		FULLSCREEN_INDEX = 4,
		PRESENT_INDEX = 8,
		STENCILTOP_INDEX = 12,
		STENCILBOTTOM_INDEX = 16,

		NUM_RESERVED = 20
	};

	FFlatVertexBuffer(int width, int height);
	~FFlatVertexBuffer();

	void OutputResized(int width, int height);
	void Bind(FRenderState &state);
	void CreateVBO();
	void Copy(int start, int count);

	FFlatVertex *GetBuffer(int index) const
	{
		FFlatVertex *ff = (FFlatVertex*)mVertexBuffer->Memory();
		return &ff[index];
	}

	FFlatVertex *GetBuffer() const
	{
		return GetBuffer(mCurIndex);
	}

	template<class T>
	FFlatVertex *Alloc(int num, T *poffset)
	{
	again:
		FFlatVertex *p = GetBuffer();
		auto index = mCurIndex.fetch_add(num);
		*poffset = static_cast<T>(index);
		if (index + num >= BUFFER_SIZE_TO_USE)
		{
			std::lock_guard<std::mutex> lock(mBufferMutex);
			if (mCurIndex >= BUFFER_SIZE_TO_USE)	// retest condition, in case another thread got here first
				mCurIndex = mIndex;

			if (index >= BUFFER_SIZE_TO_USE) goto again;
		}
		return p;
	}

	void Reset()
	{
		mCurIndex = mIndex;
	}

	void Map()
	{
		mVertexBuffer->Map();
	}

	void Unmap()
	{
		mVertexBuffer->Unmap();
	}

private:
	int CreateIndexedSubsectorVertices(subsector_t *sub, const secplane_t &plane, int floor, int vi, FIndexGenerationInfo &gen);
	int CreateIndexedSectorVertices(sector_t *sec, const secplane_t &plane, int floor, FIndexGenerationInfo &gen);
	int CreateIndexedVertices(int h, sector_t *sec, const secplane_t &plane, int floor, TArray<FIndexGenerationInfo> &gen);
	void CreateIndexedFlatVertices();

	void UpdatePlaneVertices(sector_t *sec, int plane);
protected:
	void CreateVertices();
	void CheckPlanes(sector_t *sector);
public:
	void CheckUpdate(sector_t *sector);
};

#endif