mirrors/0ad
1
0
Fork 2
mirror of https://gitea.wildfiregames.com/0ad/0ad.git synced 2026-09-21 20:06:40 +00:00
Code Issues Packages Projects Releases Wiki Activity

Separates terrain alphamap combining and uploading.

Browse Source 
Tested By: Stan
Differential Revision: https://code.wildfiregames.com/D4419
This was SVN commit r26184.
This commit is contained in:
vladislavbelov
2022-01-07 14:33:54 +00:00
parent 9d7457da9b
commit 15c40861b4
9 changed files with 227 additions and 198 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/graphics/TerrainTextureEntry.cpp
+2 -174
View File
@@ -23,11 +23,8 @@
#include "graphics/Terrain.h"
#include "graphics/TerrainProperties.h"
#include "graphics/TerrainTextureManager.h"
#include "graphics/Texture.h"
#include "lib/allocators/shared_ptr.h"
#include "lib/file/io/io.h"
#include "graphics/TextureManager.h"
#include "lib/ogl.h"
#include "lib/tex/tex.h"
#include "lib/utf8.h"
#include "ps/CLogger.h"
#include "ps/CStrInternStatic.h"
@@ -143,7 +140,7 @@ CTerrainTextureEntry::CTerrainTextureEntry(CTerrainPropertiesPtr properties, con
}
if (CRenderer::IsInitialised())
LoadAlphaMaps(alphamap);
m_TerrainAlpha = g_TexMan.LoadAlphaMap(alphamap);
float texAngle = 0.f;
float texSize = 1.f;
@@ -197,172 +194,3 @@ const float* CTerrainTextureEntry::GetTextureMatrix() const
{
return &m_TextureMatrix._11;
}
// LoadAlphaMaps: load the 14 default alpha maps, pack them into one composite texture and
// calculate the coordinate of each alphamap within this packed texture
void CTerrainTextureEntry::LoadAlphaMaps(const VfsPath& alphaMapType)
{
const std::wstring key = L"(alpha map composite" + alphaMapType.string() + L")";
CTerrainTextureManager::TerrainAlphaMap::iterator it = g_TexMan.m_TerrainAlphas.find(alphaMapType);
if (it != g_TexMan.m_TerrainAlphas.end())
{
m_TerrainAlpha = it;
return;
}
g_TexMan.m_TerrainAlphas[alphaMapType] = TerrainAlpha();
it = g_TexMan.m_TerrainAlphas.find(alphaMapType);
TerrainAlpha &result = it->second;
//
// load all textures and store Handle in array
//
Tex textures[NUM_ALPHA_MAPS] = {};
const VfsPath path = VfsPath("art/textures/terrain/alphamaps") / alphaMapType;
const wchar_t* fnames[NUM_ALPHA_MAPS] =
{
L"blendcircle.png",
L"blendlshape.png",
L"blendedge.png",
L"blendedgecorner.png",
L"blendedgetwocorners.png",
L"blendfourcorners.png",
L"blendtwooppositecorners.png",
L"blendlshapecorner.png",
L"blendtwocorners.png",
L"blendcorner.png",
L"blendtwoedges.png",
L"blendthreecorners.png",
L"blendushape.png",
L"blendbad.png"
};
size_t base = 0; // texture width/height (see below)
// for convenience, we require all alpha maps to be of the same BPP
// (avoids another ogl_tex_get_size call, and doesn't hurt)
size_t bpp = 0;
for (size_t i = 0; i < NUM_ALPHA_MAPS; ++i)
{
// note: these individual textures can be discarded afterwards;
// we cache the composite.
std::shared_ptr<u8> fileData;
size_t fileSize;
if (g_VFS->LoadFile(path / fnames[i], fileData, fileSize) != INFO::OK ||
textures[i].decode(fileData, fileSize) != INFO::OK)
{
g_TexMan.m_TerrainAlphas.erase(it);
LOGERROR("Failed to load alphamap: %s", alphaMapType.string8());
const VfsPath standard("standard");
if (path != standard)
LoadAlphaMaps(standard);
return;
}
// Get its size and make sure they are all equal.
// (the packing algo assumes this).
if (textures[i].m_Width != textures[i].m_Height)
DEBUG_DISPLAY_ERROR(L"Alpha maps are not square");
// .. first iteration: establish size
if (i == 0)
{
base = textures[i].m_Width;
bpp = textures[i].m_Bpp;
}
// .. not first: make sure texture size matches
else if (base != textures[i].m_Width || bpp != textures[i].m_Bpp)
DEBUG_DISPLAY_ERROR(L"Alpha maps are not identically sized (including pixel depth)");
}
//
// copy each alpha map (tile) into one buffer, arrayed horizontally.
//
const size_t tileWidth = 2 + base + 2; // 2 pixel border (avoids bilinear filtering artifacts)
const size_t totalWidth = round_up_to_pow2(tileWidth * NUM_ALPHA_MAPS);
const size_t totalHeight = base; ENSURE(is_pow2(totalHeight));
std::shared_ptr<u8> data;
AllocateAligned(data, totalWidth * totalHeight, maxSectorSize);
// for each tile on row
for (size_t i = 0; i < NUM_ALPHA_MAPS; ++i)
{
// get src of copy
u8* src = textures[i].get_data();
ENSURE(src);
const size_t srcStep = bpp / 8;
// get destination of copy
u8* dst = data.get() + (i * tileWidth);
// for each row of image
for (size_t j = 0; j < base; ++j)
{
// duplicate first pixel
*dst++ = *src;
*dst++ = *src;
// copy a row
for (size_t k = 0; k < base; ++k)
{
*dst++ = *src;
src += srcStep;
}
// duplicate last pixel
*dst++ = *(src - srcStep);
*dst++ = *(src - srcStep);
// advance write pointer for next row
dst += totalWidth - tileWidth;
}
result.m_AlphaMapCoords[i].u0 = static_cast<float>(i * tileWidth + 2) / totalWidth;
result.m_AlphaMapCoords[i].u1 = static_cast<float>((i + 1) * tileWidth - 2) / totalWidth;
result.m_AlphaMapCoords[i].v0 = 0.0f;
result.m_AlphaMapCoords[i].v1 = 1.0f;
}
for (size_t i = 0; i < NUM_ALPHA_MAPS; ++i)
textures[i].free();
// Enable the following to save a png of the generated texture
// in the public/ directory, for debugging.
#if 0
Tex t;
ignore_result(t.wrap(totalWidth, totalHeight, 8, TEX_GREY, data, 0));
const VfsPath filename("blendtex.png");
DynArray da;
RETURN_STATUS_IF_ERR(tex_encode(&t, filename.Extension(), &da));
// write to disk
//Status ret = INFO::OK;
{
std::shared_ptr<u8> file = DummySharedPtr(da.base);
const ssize_t bytes_written = g_VFS->CreateFile(filename, file, da.pos);
if(bytes_written > 0)
ENSURE(bytes_written == (ssize_t)da.pos);
//else
// ret = (Status)bytes_written;
}
ignore_result(da_free(&da));
#endif
result.m_CompositeAlphaMap = Renderer::Backend::GL::CTexture::Create2D(
Renderer::Backend::Format::A8, totalWidth, totalHeight,
Renderer::Backend::Sampler::MakeDefaultSampler(
Renderer::Backend::Sampler::Filter::LINEAR,
Renderer::Backend::Sampler::AddressMode::CLAMP_TO_EDGE));
// Upload the composite texture.
g_Renderer.BindTexture(0, result.m_CompositeAlphaMap->GetHandle());
glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, totalWidth, totalHeight, 0, GL_ALPHA, GL_UNSIGNED_BYTE, data.get());
g_Renderer.BindTexture(0, 0);
m_TerrainAlpha = it;
}