/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program.  If not, see <http://www.gnu.org/licenses/>.
*
*/

#include "watchmaker/render.h"
#include "watchmaker/windows_hacks.h"
#include "watchmaker/3d/render/opengl_3d.h"
#include "watchmaker/render.h"
#include "watchmaker/3d/render/opengl_renderer.h"
#include "watchmaker/3d/render/opengl_2d.h"
#include "watchmaker/3d/render/shadows.h"
#include "watchmaker/ll/ll_regen.h"

namespace Watchmaker {

unsigned int bLightmaps = FALSE;                                                                // if lightmaps are activated
unsigned int bDisableShadows = FALSE;                                                           // if shadows should be disabled
unsigned int bDisableMultiTexturing = FALSE;                                                    // if multitexturing should be disabled

gBatchBlock BatchBlockList[MAX_BATCH_BLOCKS];
gBatchBlock BatchBlockListSpecial[MAX_BATCH_BLOCKS_SPECIAL];
//gBatchBlock BatchBlockListLightmaps[MAX_BATCH_BLOCKS_LIGHTMAPS];
gBatchBlock BatchBlockListSky[MAX_BATCH_BLOCKS_SKY];

unsigned int NumBatchBlocks = 0;
unsigned int NumBatchBlocksSpecial = 0;
//unsigned int NumBatchBlocksLightmaps=0;
unsigned int NumBatchBlocksSky = 0;

/* -----------------13/08/99 10.34-------------------
 *              Comparazione per BB
 * --------------------------------------------------*/
int cmpbb(const void *a, const void *b) {
	const gBatchBlock *v1 = (const gBatchBlock *)a;
	const gBatchBlock *v2 = (const gBatchBlock *)b;

	if (v1->Texture2 < v2->Texture2) return -1;
	else if (v1->Texture2 > v2->Texture2) return 1;
	else if (v1->Texture1 < v2->Texture1) return -1;
	else if (v1->Texture1 > v2->Texture1) return 1;
	else return 0;
}

/* -----------------31/05/99 10.12-------------------
 *          Attiva o disattiva lo ZBuffer
 * --------------------------------------------------*/
bool rSetZBufferState(bool state) {
	g_renderer->setRenderState(RenderState::ZENABLE, state);
	g_renderer->setRenderState(RenderState::ZWRITE_ENABLE, state);

	return !g_renderer->error();
}


/* -----------------25/06/99 11.14-------------------
 *  Renderizza il cielo senza considerare lo zbuffer
 * --------------------------------------------------*/
void RenderSky() {
	unsigned int    i;
	bool            hres;
	gBatchBlock     *bb;

	if (!NumBatchBlocksSky)
		return;

	if (!rSetZBufferState(false)) {
		DebugLogFile("Can't rSetZBufferState FALSE");
		return ;
	}

	g_renderer->setRenderState(RenderState::ALPHABLEND, TRUE);
	g_renderer->setRenderState(RenderState::ALPHAREF, 0x00000055);
	g_renderer->setBlendFunc(BlendFactor::ONE, BlendFactor::INVSRCALPHA);
	if (g_renderer->error()) {
		return;
	}

	bb = &BatchBlockListSky[0];
	for (i = 0; i < NumBatchBlocksSky; i++, bb++) {
		if (bb->Texture1 < 0) continue;
		rSetUserViewMatrix(bb->ViewMatrixNum);

		if (bb->Texture1)
			g_renderer->setTexture(0, gTextureList[bb->Texture1]);
		else
			g_renderer->setTexture(0, nullptr);

		g_renderer->drawIndexedPrimitivesVBO(PrimitiveType::TRIANGLE, *bb);
		hres = !g_renderer->error();
		if (!hres) {
			Common::String str = g_renderer->getErrorString();
			DebugLogWindow("DrawIndexedPrimitiveVB ERROR:\n\r%s", str.c_str());
		}
		bb->Texture1 = -3;
		bb->Texture2 = -3;
	}

	if (!rSetZBufferState(true)) {
		DebugLogFile("Can't rSetZBufferState TRUE");
		return ;
	}
}


/* -----------------31/05/99 10.19-------------------
 *          Renderizza la Geometria
 * --------------------------------------------------*/
void RenderGeometry() {
	signed short int LastViewMatrixNum, LastTexture1, LastTexture2;
	gBatchBlock *bb;
	bool hres = false;

	RenderSky();
	//warning("TODO: Texture configuration");
#if 0
	g_renderer->SetTextureStageState(0, D3DTSS_TEXCOORDINDEX, 0);
	g_renderer->SetTextureStageState(1, D3DTSS_TEXCOORDINDEX, 1);
	g_renderer->SetTextureStageState(1, D3DTSS_COLOROP,   D3DTOP_DISABLE);
	g_renderer->SetTextureStageState(1, D3DTSS_ALPHAOP,   D3DTOP_DISABLE);
#endif
	g_renderer->setTextureWrapMode(1, TextureWrapMode::CLAMP);

	g_renderer->setRenderState(RenderState::TEXTUREFACTOR, 0xFFFFFFFF);
	g_renderer->setRenderState(RenderState::ALPHAREF, 0x00000000);

	g_renderer->setRenderState(RenderState::ALPHABLEND, FALSE);
	if (g_renderer->error()) {
		return;
	}

	LastViewMatrixNum = LastTexture1 = LastTexture2 = -2;
	bb = &BatchBlockList[0];
	qsort(bb, NumBatchBlocks, sizeof(gBatchBlock), cmpbb);
	for (uint i = 0; i < NumBatchBlocks; i++, bb++) {
		if (bb->Texture1 < 0) continue;

		if (bb->ViewMatrixNum != LastViewMatrixNum) {
			rSetUserViewMatrix(bb->ViewMatrixNum);
			LastViewMatrixNum = bb->ViewMatrixNum;
		}
		if (bb->Texture1 != LastTexture1) {
			if (bb->Texture1)
				g_renderer->setTexture(0, gTextureList[bb->Texture1]);
			else
				g_renderer->setTexture(0, nullptr);
			LastTexture1 = bb->Texture1;
		}
		if ((g_renderer->supportsMultiTexturing()) && (bb->Texture2 != LastTexture2)) {
			if (bb->Texture2 > 0) {
				if (LastTexture2 <= 0) {
					//warning("TODO: Texture configuration");
#if 0
					g_renderer->SetTextureStageState(1, D3DTSS_COLOROP,   D3DTOP_MODULATE);
					g_renderer->SetTextureStageState(1, D3DTSS_COLORARG1, D3DTA_TEXTURE);
					g_renderer->SetTextureStageState(1, D3DTSS_COLORARG2, D3DTA_CURRENT);
					g_renderer->SetTextureStageState(1, D3DTSS_ALPHAOP,   D3DTOP_SELECTARG2);
					g_renderer->SetTextureStageState(1, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
#endif
					g_renderer->setTextureWrapMode(1, TextureWrapMode::CLAMP);
				}
				g_renderer->setTexture(1, gTextureList[bb->Texture2]);
			} else if (LastTexture2 > 0) {
				//warning("TODO: Texture configuration");
#if 0
				g_renderer->SetTextureStageState(1, D3DTSS_COLOROP,   D3DTOP_DISABLE);
				g_renderer->SetTextureStageState(1, D3DTSS_ALPHAOP,   D3DTOP_DISABLE);
#endif
				g_renderer->setTexture(1, nullptr);
			}
			LastTexture2 = bb->Texture2;
		}

		g_renderer->drawIndexedPrimitivesVBO(PrimitiveType::TRIANGLE, *bb);

		hres = !g_renderer->error();
		if (!hres) {
			Common::String str = g_renderer->getErrorString();
			DebugLogWindow("DrawIndexedPrimitiveVB ERROR:\n\r%s", str.c_str());
		}
		bb->Texture1 = -3;
	}
	//warning("TODO: Texture configuration");
#if 0
	g_renderer->SetTextureStageState(1, D3DTSS_COLOROP,   D3DTOP_DISABLE);
	g_renderer->SetTextureStageState(1, D3DTSS_ALPHAOP,   D3DTOP_DISABLE);
#endif

//	2nd pass: lightmaps, if device doesn't support multi-texturing
	if ((!g_renderer->supportsMultiTexturing()) && (bLightmaps)) {
		g_renderer->setRenderState(RenderState::ZWRITE_ENABLE, FALSE);

#if 0 // TODO
		g_renderer->SetTextureStageState(0, D3DTSS_TEXCOORDINDEX, 1);                        // use mapping coordinates set 1
#endif
		g_renderer->setBlendFunc(BlendFactor::ZERO, BlendFactor::SRCCOLOR);
		g_renderer->setRenderState(RenderState::ALPHABLEND, true);
		if (g_renderer->error()) {
			return;
		}

		LastViewMatrixNum = LastTexture1 = LastTexture2 = -2;
		bb = &BatchBlockList[0];
		for (uint i = 0; i < NumBatchBlocks; i++, bb++) {
			if (bb->Texture2 <= 0) continue;

			if (bb->ViewMatrixNum != LastViewMatrixNum) {
				rSetUserViewMatrix(bb->ViewMatrixNum);
				LastViewMatrixNum = bb->ViewMatrixNum;
			}
			if (bb->Texture2 != LastTexture2) {
				g_renderer->setTexture(0, gTextureList[bb->Texture2]);
				LastTexture2 = bb->Texture2;
			}

			g_renderer->drawIndexedPrimitivesVBO(PrimitiveType::TRIANGLE, *bb);
			hres = !g_renderer->error();
			if (!hres) {
				Common::String str = g_renderer->getErrorString();
				DebugLogWindow("DrawIndexedPrimitiveVB ERROR:\n\r%s", str.c_str());
			}
		}

		g_renderer->setRenderState(RenderState::ZWRITE_ENABLE, TRUE);
#if 0 // TODO
		g_renderer->SetTextureStageState(0, D3DTSS_TEXCOORDINDEX, 0);                        // mapping coordinates back to set 0
#endif
	}

//	Clipmaps
	g_renderer->setRenderState(RenderState::ALPHABLEND, TRUE);
	g_renderer->setRenderState(RenderState::ALPHAREF, 0x00000055);

	g_renderer->setBlendFunc(BlendFactor::ONE, BlendFactor::INVSRCALPHA);
	if (g_renderer->error()) {
		return;
	}

	LastViewMatrixNum = LastTexture1 = LastTexture2 = -2;
	bb = &BatchBlockListSpecial[0];
	qsort(bb, NumBatchBlocksSpecial, sizeof(gBatchBlock), cmpbb);
	for (uint i = 0; i < NumBatchBlocksSpecial; i++, bb++) {
		if (bb->Texture1 < 0) continue;
		if (!(bb->Flags1 & T3D_MATERIAL_CLIPMAP) ||
		        (bb->Flags1 & T3D_MATERIAL_FLARE) ||
		        (bb->Flags1 & T3D_MATERIAL_SMOKE))
			continue;

		if (bb->ViewMatrixNum != LastViewMatrixNum) {
			rSetUserViewMatrix(bb->ViewMatrixNum);
			LastViewMatrixNum = bb->ViewMatrixNum;
		}
		if (bb->Texture1 != LastTexture1) {
			if (bb->Texture1)
				g_renderer->setTexture(0, gTextureList[bb->Texture1]);
			else
				g_renderer->setTexture(0, nullptr);
			LastTexture1 = bb->Texture1;
		}

		g_renderer->drawIndexedPrimitivesVBO(PrimitiveType::TRIANGLE, *bb);
		hres = !g_renderer->error();
		if (!hres) {
			Common::String str = g_renderer->getErrorString();
			DebugLogWindow("DrawIndexedPrimitiveVB ERROR:\n\r%s", str.c_str());
		}
		bb->Texture1 = -3;
		bb->Texture2 = -3;
	}

//	Render Smoke or Flare materials
	g_renderer->setRenderState(RenderState::ALPHAREF, 0x00000055);
	g_renderer->setRenderState(RenderState::ZWRITE_ENABLE, FALSE);
	if (g_renderer->error()) {
		return;
	}

	LastViewMatrixNum = LastTexture1 = LastTexture2 = -2;
	bb = &BatchBlockListSpecial[0];
	for (uint i = 0; i < NumBatchBlocksSpecial; i++, bb++) {
		if (bb->Texture1 < 0) continue;
		if (!(bb->Flags1 & T3D_MATERIAL_FLARE) &&
		        !(bb->Flags1 & T3D_MATERIAL_SMOKE))
			continue;

		if (bb->Flags1 & T3D_MATERIAL_FLARE_SUN) {
			g_renderer->setBlendFunc(BlendFactor::ONE, BlendFactor::INVSRCCOLOR);
		} else if (bb->Flags1 & T3D_MATERIAL_FLARESOFT) {
			g_renderer->setRenderState(RenderState::ZENABLE, FALSE);
			g_renderer->setBlendFunc(BlendFactor::DESTCOLOR, BlendFactor::ONE);
		} else if (bb->Flags1 & T3D_MATERIAL_SMOKE) {
			g_renderer->setBlendFunc(BlendFactor::SRCALPHA, BlendFactor::ONE);
		} else {
			g_renderer->setBlendFunc(BlendFactor::SRCCOLOR, BlendFactor::ONE);
		}
		if (g_renderer->error()) {
			return;
		}

		if (bb->ViewMatrixNum != LastViewMatrixNum) {
			rSetUserViewMatrix(bb->ViewMatrixNum);
			LastViewMatrixNum = bb->ViewMatrixNum;
		}
		if (bb->Texture1 != LastTexture1) {
			if (bb->Texture1)
				g_renderer->setTexture(0, gTextureList[bb->Texture1]);
			else
				g_renderer->setTexture(0, nullptr);
			LastTexture1 = bb->Texture1;
		}

		g_renderer->drawIndexedPrimitivesVBO(PrimitiveType::TRIANGLE, *bb);
		if (!hres) {
			Common::String str = g_renderer->getErrorString();
			DebugLogWindow("DrawIndexedPrimitiveVB ERROR:\n\r%s", str.c_str());
		}
		bb->Texture1 = -3;
		bb->Texture2 = -3;
	}
	g_renderer->setRenderState(RenderState::ZWRITE_ENABLE, TRUE);
	hres = !g_renderer->error();
	if (!hres) {
		return;
	}

//	Print transparent/translucent materials
	g_renderer->setRenderState(RenderState::ALPHAREF, 0x0000002);

	LastViewMatrixNum = LastTexture1 = LastTexture2 = -2;
	bb = &BatchBlockListSpecial[0];
	for (uint i = 0; i < NumBatchBlocksSpecial; i++, bb++) {
		if (bb->Texture1 < 0) continue;
		if ((bb->Flags1 & T3D_MATERIAL_FLARE) ||
		        (bb->Flags1 & T3D_MATERIAL_SMOKE))
			continue;

		if (bb->Flags1 & T3D_MATERIAL_GLASS) {
			g_renderer->setBlendFunc(BlendFactor::DESTCOLOR, BlendFactor::ZERO);
			return;
		} else if (bb->Flags1 & T3D_MATERIAL_OPACITY) {
			g_renderer->setBlendFunc(BlendFactor::ONE, BlendFactor::SRCCOLOR);
		} else if (bb->Flags1 & T3D_MATERIAL_BOTTLE) {
			g_renderer->setBlendFunc(BlendFactor::ONE, BlendFactor::INVDESTCOLOR);
		} else if (bb->Flags1 & T3D_MATERIAL_ADDITIVE) {
			g_renderer->setBlendFunc(BlendFactor::DESTCOLOR, BlendFactor::ONE);
		} else {
			continue;
		}
		if (g_renderer->error()) {
			return;
		}

		if (bb->ViewMatrixNum != LastViewMatrixNum) {
			rSetUserViewMatrix(bb->ViewMatrixNum);
			LastViewMatrixNum = bb->ViewMatrixNum;
		}
		if (bb->Texture1 != LastTexture1) {
			if (bb->Texture1)
				g_renderer->setTexture(0, gTextureList[bb->Texture1]);
			else
				g_renderer->setTexture(0, nullptr);
			LastTexture1 = bb->Texture1;
		}

		g_renderer->drawIndexedPrimitivesVBO(PrimitiveType::TRIANGLE, *bb);
		hres = !g_renderer->error();
		if (!hres) {
			Common::String str = g_renderer->getErrorString();
			DebugLogWindow("DrawIndexedPrimitiveVB ERROR:\n\r%s", str.c_str());
		}
		bb->Texture1 = -3;
		bb->Texture2 = -3;
	}

//	Render blank materials
//	???
}

/* -----------------31/05/99 10.55-------------------
 *              Renderizza la scena
 * --------------------------------------------------*/
bool rRenderScene() {
	unsigned int    i, j;
	bool            hres;
	//static unsigned int dwFrameCount = 0;

	g_renderer->setRenderState(RenderState::LIGHT, false);
	g_renderer->setRenderState(RenderState::CLIP, true);
	g_renderer->setRenderState(RenderState::EXTENT, false);

	// Added:
	ResetScreenBuffer();

	if (!gStencilBitDepth && !bDisableShadows) {
//tb
		//Render Projected shadow into shadow surface
		for (j = 0; j < gNumShadowBoxesList; j++) {
			SHADOWBOX *sb = ShadowBoxesList[j];
			rSetUserViewMatrix(sb->ViewMatrixNum);
			if (bDisableShadows) break;
			warning("TODO: Shadows");
#if 0
			for (i = 0; i < sb->NumShadowsList; i++) {
				if (!(hres = RenderProjectiveShadow(&sb->ShadowsList[i]))) {
					Common::String str = g_renderer->getErrorString();
					DebugLogFile("Unable to RenderProjectiveShadow into a texture: %s | %d %d | %d", str.c_str(), S_OK, DD_OK, hres);
					bDisableShadows = TRUE;
					break;
				}

				if (sb->ShadowsList[i].ProjectiveTexture.lpDDSurface) {
					if (hres = sb->ShadowsList[i].ProjectiveTexture.lpDDSurface->BltFast(0, 0, g_pddsShadowBuffer, NULL, DDBLTFAST_NOCOLORKEY) != S_OK) {
						Common::String str = g_renderer->getErrorString();
						DebugLogWindow("Unable to blitfast Shadowbuffer into a texture: %s", str.c_str());
						bDisableShadows = TRUE;
						break;
					}

				}
				/*              if (g_pddsBackBuffer && !j)
				                {
				                    RECT    rect;
				                    rect.left=rect.top=0;
				                    rect.right=rect.bottom=256;

				                    if (FAILED(hres=g_pddsBackBuffer->BltFast(0,0,sb->ShadowsList[i].ProjectiveTexture.lpDDSurface,&rect,DDBLTFAST_NOCOLORKEY)))
				                    {
				                        Common::String str = g_renderer->getErrorString();
				                        DebugLogWindow("Unable to blit projective texture: %s",str);
				                        bDisableShadows=TRUE;
				                        break;
				                    }
				                }*/
			}
#endif
		}
//tb
	}

	// Begin the scene.
#if 0
	if (FAILED(g_pd3dDevice->BeginScene()))
		goto closescene;
#endif
	RenderGeometry();

	if (gStencilBitDepth && !bDisableShadows) {
//sb
		rSaveViewMatrix();
		g_renderer->setRenderState(RenderState::ALPHAREF, 0x00000002);
		hres = !g_renderer->error();
		if (!hres) {
			Common::String str = g_renderer->getErrorString();
			DebugLogWindow("Unable to SetRenderState for Shadowbuffer: %s", str.c_str());
			bDisableShadows = TRUE;
		}

		//Render Shadows volumes
		for (j = 0; j < gNumShadowBoxesList; j++) {
			SHADOWBOX *sb = ShadowBoxesList[j];
			rSetUserViewMatrix(sb->ViewMatrixNum);
			for (i = 0; i < sb->NumShadowsList; i++)
				RenderShadow(&sb->ShadowsList[i], sb->ShadowsList[i].VB);

			if (i) {
				RenderShadowBox(sb, sb->VBO);

				unsigned int width, height, bpp;
				rGetScreenInfos(&width, &height, &bpp);
				DrawShadow(0, 0, width, height, sb->Intensity);
			}
		}
		rRestoreViewMatrix();
//sb
	} else if (!bDisableShadows) {
//tb
		for (j = 0; j < gNumShadowBoxesList; j++) {
			SHADOWBOX *sb = ShadowBoxesList[j];
			rSetUserViewMatrix(sb->ViewMatrixNum);
			for (i = 0; i < sb->NumShadowsList; i++)
				if (!(hres = DrawProjectiveShadow(&sb->ShadowsList[i]))) {
					Common::String str = g_renderer->getErrorString();
					DebugLogFile("Unable to DrawProjectiveShadow: %s", str.c_str());
					bDisableShadows = TRUE;
				}
		}
//tb
	}

	if (gNumLinesArray && gNumPointsBuffer) {
		rSaveViewMatrix();
		rSetLinesViewMatrix();

		g_renderer->setBlendFunc(BlendFactor::ONE, BlendFactor::ZERO);
		g_renderer->setRenderState(RenderState::ALPHABLEND, false);
		if (g_renderer->error()) {
			goto closescene;
		}

		g_renderer->setTexture(0, nullptr);
		/*
		hres=g_pd3dDevice->DrawIndexedPrimitiveVB(  D3DPT_LINELIST,
		                                              g_lpD3DPointsBuffer,0,gNumPointsBuffer,
		                                              gLinesArray, gNumLinesArray,0);
		*/
		g_renderer->drawIndexedPrimitivesVBO(PrimitiveType::LINE, g_lpD3DPointsBuffer, 0, gNumPointsBuffer, gLinesArray, gNumLinesArray/*, 0*/);
		hres = g_renderer->error();
		if (!hres) {
			Common::String str = g_renderer->getErrorString();
			DebugLogWindow("DrawIndexedPrimitiveVB ERROR:\n\r%s", str.c_str());
		}
		rRestoreViewMatrix();
		gNumLinesArray = 0;
	}


	if (gNumTrianglesArray) {
		rSetZBufferState(FALSE);

		g_renderer->setRenderState(RenderState::ALPHAREF, 0x0000000);
		g_renderer->setBlendFunc(BlendFactor::ONE, BlendFactor::SRCALPHA);
		g_renderer->setRenderState(RenderState::ALPHABLEND, true);
		if (g_renderer->error()) {
			goto closescene;
		}

		g_renderer->setTexture(0, nullptr);
		g_renderer->drawPrimitives(PrimitiveType::TRIANGLE,
		                           /*D3DFVF_TLVERTEX,*/ gTriangles,
		                           gNumTrianglesArray/*, 0x0*/);
		hres = !g_renderer->error();
		if (!hres) {
			Common::String str = g_renderer->getErrorString();
			DebugLogWindow("DrawIndexedPrimitiveVB ERROR:\n\r%s", str.c_str());
		}
		gNumTrianglesArray = 0;
		rSetZBufferState(TRUE);
	}
#if 0
	g_pd3dDevice->EndScene();
#endif
	NumBatchBlocks = 0;
	NumBatchBlocksSpecial = 0;
//	NumBatchBlocksLightmaps=0;
	NumBatchBlocksSky = 0;

	//dwFrameCount++;

	return TRUE;
	// End the scene.

closescene:
#if 0
	g_pd3dDevice->EndScene();
#endif
	DebugLogFile("Error during renderscene");
	return FALSE;
}


/* -----------------13/08/99 10.34-------------------
 *          Aggiunge un nuovo BatchBlock
 * --------------------------------------------------*/
gBatchBlock *rNewBatchBlock(signed short int T1, unsigned int F1, signed short int T2, unsigned int F2) {
	gBatchBlock *bb;

	bb = nullptr;
	if ((F1 & T3D_MATERIAL_GLASS) ||
	        (F1 & T3D_MATERIAL_OPACITY) ||
	        (F1 & T3D_MATERIAL_CLIPMAP) ||
	        (F1 & T3D_MATERIAL_SMOKE) ||
	        (F1 & T3D_MATERIAL_BOTTLE) ||
	        (F1 & T3D_MATERIAL_FLARE) ||
	        (F1 & T3D_MATERIAL_ADDITIVE)) {
		if ((NumBatchBlocksSpecial + 1) < MAX_BATCH_BLOCKS_SPECIAL)
			bb = &BatchBlockListSpecial[NumBatchBlocksSpecial++];
		else
			DebugLogFile("Too many BB Special: %d (MAX is %d)!", NumBatchBlocksSpecial, MAX_BATCH_BLOCKS_SPECIAL);
	}
//	else if( (T2>0) )
//	{
//		if( (NumBatchBlocksLightmaps+1) < MAX_BATCH_BLOCKS_LIGHTMAPS )
//			bb=&BatchBlockList[NumBatchBlocksLightmaps++];
//		else
//			DebugLogFile("Too many BB LightMaps: %d (MAX is %d)!",NumBatchBlocksLightmaps,MAX_BATCH_BLOCKS_LIGHTMAPS);
//	}
	else if ((F1 & T3D_MATERIAL_SKY)) {
		if ((NumBatchBlocksSky + 1) < MAX_BATCH_BLOCKS_SKY)
			bb = &BatchBlockListSky[NumBatchBlocksSky++];
		else
			DebugLogFile("Too many BB Sky: %d (MAX is %d)!", NumBatchBlocksSky, MAX_BATCH_BLOCKS_SKY);
	} else {
		if ((NumBatchBlocks + 1) < MAX_BATCH_BLOCKS)
			bb = &BatchBlockList[NumBatchBlocks++];
		else
			DebugLogFile("Too many BB: %d (MAX is %d)!", NumBatchBlocks, MAX_BATCH_BLOCKS);
	}

	if (!bb) return nullptr;

	*bb = gBatchBlock(T1, T2, F1, F2);
	return bb;
}

} // End of namespace Watchmaker