bb
157c6af18e
Avoid cases of filenames Update years in terms and other legal(ish) documents Don't update years in license headers, since change is not meaningful Will add linter rule in seperate commit Happy recompiling everyone! Original Patch By: Nescio Comment By: Gallaecio Differential Revision: D2620 This was SVN commit r27786.
319 lines
9.5 KiB
C++
319 lines
9.5 KiB
C++
/* Copyright (C) 2009 Wildfire Games.
|
|
* This file is part of 0 A.D.
|
|
*
|
|
* 0 A.D. 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 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* 0 A.D. 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 0 A.D. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
/*
|
|
* Determine which alpha blend map fits a given shape.
|
|
*/
|
|
|
|
#include "precompiled.h"
|
|
|
|
#include "AlphaMapCalculator.h"
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// CAlphaMapCalculator: functionality for calculating which alpha blend map
|
|
// fits a given shape
|
|
namespace CAlphaMapCalculator {
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// Blend4: structure mapping a blend shape for N,E,S,W to a particular map
|
|
struct Blend4 {
|
|
Blend4(BlendShape4 shape,int alphamap) : m_Shape(shape), m_AlphaMap(alphamap) {}
|
|
|
|
BlendShape4 m_Shape;
|
|
int m_AlphaMap;
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// Blend8: structure mapping a blend shape for N,NE,E,SE,S,SW,W,NW to a
|
|
// particular map
|
|
struct Blend8 {
|
|
Blend8(BlendShape8 shape,int alphamap) : m_Shape(shape), m_AlphaMap(alphamap) {}
|
|
|
|
BlendShape8 m_Shape;
|
|
int m_AlphaMap;
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// Data tables for mapping between shapes and blend maps
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
const Blend4 Blends1Neighbour[] =
|
|
{
|
|
Blend4(BlendShape4(1,0,0,0), 12)
|
|
};
|
|
|
|
|
|
const Blend4 Blends2Neighbour[] =
|
|
{
|
|
Blend4(BlendShape4(0,1,1,0), 7),
|
|
Blend4(BlendShape4(1,0,1,0), 10)
|
|
};
|
|
|
|
const Blend8 Blends2Neighbour8[] =
|
|
{
|
|
Blend8(BlendShape8(1,1,0,0,0,0,0,0), 12),
|
|
Blend8(BlendShape8(1,0,0,0,0,1,0,0), 12),
|
|
Blend8(BlendShape8(0,1,0,1,0,0,0,0), 0) ,
|
|
Blend8(BlendShape8(0,1,0,0,0,1,0,0), 0)
|
|
};
|
|
|
|
const Blend4 Blends3Neighbour[] =
|
|
{
|
|
Blend4(BlendShape4(1,1,1,0), 4)
|
|
};
|
|
|
|
const Blend8 Blends3Neighbour8[] =
|
|
{
|
|
Blend8(BlendShape8(1,1,0,0,1,0,0,0), 10),
|
|
Blend8(BlendShape8(1,1,0,0,0,0,0,1), 12),
|
|
Blend8(BlendShape8(1,1,1,0,0,0,0,0), 1),
|
|
Blend8(BlendShape8(0,1,1,0,1,0,0,0), 7),
|
|
Blend8(BlendShape8(0,0,1,0,1,0,1,0), 4),
|
|
Blend8(BlendShape8(1,1,0,0,0,1,0,0), 12),
|
|
Blend8(BlendShape8(1,1,0,1,0,0,0,0), 12),
|
|
Blend8(BlendShape8(0,0,1,0,1,0,0,1), 7),
|
|
Blend8(BlendShape8(1,0,0,1,0,1,0,0), 12),
|
|
Blend8(BlendShape8(0,1,0,1,0,1,0,0), 0)
|
|
};
|
|
|
|
const Blend8 Blends4Neighbour8[] =
|
|
{
|
|
Blend8(BlendShape8(1,1,0,0,1,0,0,1), 10),
|
|
Blend8(BlendShape8(1,1,0,1,1,0,0,0), 10),
|
|
Blend8(BlendShape8(1,1,0,0,1,1,0,0), 10),
|
|
Blend8(BlendShape8(1,1,0,1,0,0,0,1), 12),
|
|
Blend8(BlendShape8(0,1,1,0,1,1,0,0), 7),
|
|
Blend8(BlendShape8(1,1,1,1,0,0,0,0), 1),
|
|
Blend8(BlendShape8(1,1,1,0,1,0,0,0), 3),
|
|
Blend8(BlendShape8(0,0,1,0,1,1,0,1), 7),
|
|
Blend8(BlendShape8(1,0,1,0,1,1,0,0), 4),
|
|
Blend8(BlendShape8(1,1,1,0,0,1,0,0), 1),
|
|
Blend8(BlendShape8(1,1,0,1,0,1,0,0), 12),
|
|
Blend8(BlendShape8(0,1,0,1,0,1,0,1), 0)
|
|
};
|
|
|
|
const Blend8 Blends5Neighbour8[] =
|
|
{
|
|
Blend8(BlendShape8(1,1,1,1,1,0,0,0), 2),
|
|
Blend8(BlendShape8(1,1,1,1,0,0,0,1), 1),
|
|
Blend8(BlendShape8(1,1,1,0,1,0,0,1), 3),
|
|
Blend8(BlendShape8(1,1,1,0,1,0,1,0), 11),
|
|
Blend8(BlendShape8(1,1,1,0,0,1,0,1), 1),
|
|
Blend8(BlendShape8(1,1,0,1,1,1,0,0), 10),
|
|
Blend8(BlendShape8(1,1,1,0,1,1,0,0), 3),
|
|
Blend8(BlendShape8(1,0,1,0,1,1,0,1), 4),
|
|
Blend8(BlendShape8(1,1,0,1,0,1,0,1), 12),
|
|
Blend8(BlendShape8(0,1,1,0,1,1,0,1), 7)
|
|
};
|
|
|
|
const Blend8 Blends6Neighbour8[] =
|
|
{
|
|
Blend8(BlendShape8(1,1,1,1,1,1,0,0), 2),
|
|
Blend8(BlendShape8(1,1,1,1,1,0,1,0), 8),
|
|
Blend8(BlendShape8(1,1,1,1,0,1,0,1), 1),
|
|
Blend8(BlendShape8(1,1,1,0,1,1,1,0), 6),
|
|
Blend8(BlendShape8(1,1,1,0,1,1,0,1), 3),
|
|
Blend8(BlendShape8(1,1,0,1,1,1,0,1), 10)
|
|
};
|
|
|
|
const Blend8 Blends7Neighbour8[] =
|
|
{
|
|
Blend8(BlendShape8(1,1,1,1,1,1,0,1), 2),
|
|
Blend8(BlendShape8(1,1,1,1,1,1,1,0), 9)
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// MatchBlendShapeFlipped: test if the given shape can be made to fit the
|
|
// template in either unflipped state, or by flipping the shape in U or V
|
|
template<class T>
|
|
bool MatchBlendShapeFlipped(const T& templateshape,const T& shape,unsigned int& flags)
|
|
{
|
|
// test unrotated shape
|
|
if (shape==templateshape) {
|
|
return true;
|
|
}
|
|
|
|
// test against shape flipped in U
|
|
T tstShape;
|
|
templateshape.FlipU(tstShape);
|
|
if (shape==tstShape) {
|
|
flags|=BLENDMAP_FLIPU;
|
|
return true;
|
|
}
|
|
|
|
// test against shape flipped in V
|
|
templateshape.FlipV(tstShape);
|
|
if (shape==tstShape) {
|
|
flags|=BLENDMAP_FLIPV;
|
|
return true;
|
|
}
|
|
|
|
// no joy; no match by flipping
|
|
return false;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// MatchBlendShape: try and find a matching blendmap, and the required flip/
|
|
// rotation flags, to fit the given shape to the template
|
|
template<class T>
|
|
int MatchBlendShape(const T& templateshape,const T& shape,unsigned int& flags)
|
|
{
|
|
// try matching unrotated shape first using just flipping
|
|
if (MatchBlendShapeFlipped(templateshape,shape,flags)) {
|
|
return true;
|
|
}
|
|
|
|
// now try iterating through rotations of 90,180,270 degrees
|
|
T tstShape;
|
|
templateshape.Rotate90(tstShape);
|
|
if (MatchBlendShapeFlipped(tstShape,shape,flags)) {
|
|
// update flags - note if we've flipped in u or v, we need to rotate in
|
|
// the opposite direction
|
|
flags|=flags ? BLENDMAP_ROTATE270 : BLENDMAP_ROTATE90;
|
|
return true;
|
|
}
|
|
|
|
templateshape.Rotate180(tstShape);
|
|
if (MatchBlendShapeFlipped(tstShape,shape,flags)) {
|
|
flags|=BLENDMAP_ROTATE180;
|
|
return true;
|
|
}
|
|
|
|
templateshape.Rotate270(tstShape);
|
|
if (MatchBlendShapeFlipped(tstShape,shape,flags)) {
|
|
// update flags - note if we've flipped in u or v, we need to rotate in
|
|
// the opposite direction
|
|
flags|=flags ? BLENDMAP_ROTATE90 : BLENDMAP_ROTATE270;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// LookupBlend: find and return the blendmap fitting the given shape by
|
|
// iterating through the given data table and testing each shape in flipped and
|
|
// rotated forms until a match is found
|
|
template<class S,class T>
|
|
int LookupBlend(int tableSize,const S* table,const T& shape,unsigned int& flags)
|
|
{
|
|
// iterate through known blend shapes
|
|
for (int b=0;b<tableSize;b++) {
|
|
const S& blend=table[b];
|
|
if (MatchBlendShape(blend.m_Shape,shape,flags)) {
|
|
return blend.m_AlphaMap;
|
|
}
|
|
}
|
|
|
|
// eh? shouldn't get here if we've correctly considered all possible cases;
|
|
// keep the compiler happy, and, while we're still debugging possible shapes,
|
|
// return bad blend to highlight suspect alphamap logic
|
|
return 13;
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// Calculate: return the index of the blend map that fits the given shape,
|
|
// and the set of flip/rotation flags to get the shape correctly oriented
|
|
int Calculate(BlendShape8 shape,unsigned int& flags)
|
|
{
|
|
// assume we're not going to require flipping or rotating
|
|
flags=0;
|
|
|
|
// count number of neighbours
|
|
int count=0;
|
|
for (int i=0;i<8;i++) {
|
|
if (shape[i]) count++;
|
|
}
|
|
|
|
if (count==0) {
|
|
// no neighbours, just the centre tile has the given texture; use blend circle
|
|
return 0;
|
|
} else if (count==8) {
|
|
// all neighbours have same texture; return code to signal no alphamap required
|
|
return -1;
|
|
} else {
|
|
if (count<=4) {
|
|
// check if we can consider this a BlendShape4 - ie are any of the diagonals (NE,SE,SW,NW) set?
|
|
if (!shape[1] && !shape[3] && !shape[5] && !shape[7]) {
|
|
// ok, build a BlendShape4 and use that
|
|
BlendShape4 shape4;
|
|
shape4[0]=shape[0];
|
|
shape4[1]=shape[2];
|
|
shape4[2]=shape[4];
|
|
shape4[3]=shape[6];
|
|
|
|
switch (count) {
|
|
case 1:
|
|
return LookupBlend(sizeof(Blends1Neighbour)/sizeof(Blend4),Blends1Neighbour,shape4,flags);
|
|
|
|
case 2:
|
|
return LookupBlend(sizeof(Blends2Neighbour)/sizeof(Blend4),Blends2Neighbour,shape4,flags);
|
|
|
|
case 3:
|
|
return LookupBlend(sizeof(Blends3Neighbour)/sizeof(Blend4),Blends3Neighbour,shape4,flags);
|
|
|
|
case 4:
|
|
// N,S,E,W have same texture, NE,SE,SW,NW don't; use a blend 4 corners
|
|
return 5;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// we've got this far, so now we've got to consider the remaining choices, all containing
|
|
// diagonal elements
|
|
switch (count) {
|
|
case 1:
|
|
// trivial case - just return a circle blend
|
|
return 0;
|
|
|
|
case 2:
|
|
return LookupBlend(sizeof(Blends2Neighbour8)/sizeof(Blend8),Blends2Neighbour8,shape,flags);
|
|
|
|
case 3:
|
|
return LookupBlend(sizeof(Blends3Neighbour8)/sizeof(Blend8),Blends3Neighbour8,shape,flags);
|
|
|
|
case 4:
|
|
return LookupBlend(sizeof(Blends4Neighbour8)/sizeof(Blend8),Blends4Neighbour8,shape,flags);
|
|
|
|
case 5:
|
|
return LookupBlend(sizeof(Blends5Neighbour8)/sizeof(Blend8),Blends5Neighbour8,shape,flags);
|
|
|
|
case 6:
|
|
return LookupBlend(sizeof(Blends6Neighbour8)/sizeof(Blend8),Blends6Neighbour8,shape,flags);
|
|
|
|
case 7:
|
|
return LookupBlend(sizeof(Blends7Neighbour8)/sizeof(Blend8),Blends7Neighbour8,shape,flags);
|
|
}
|
|
|
|
}
|
|
|
|
// Shouldn't get here if we've correctly considered all possible cases;
|
|
// keep the compiler happy, and, while we're still debugging possible shapes,
|
|
// return bad blend to highlight suspect alphamap logic
|
|
return 13;
|
|
}
|
|
|
|
} // end of namespace
|