public void UpdateLocalPosition()
{
_doesLocalPositionNeedUpdate = false;
float minY = 100000000;
float maxY = -100000000;
float minX = 100000000;
float maxX = -100000000;
int lineCount = _letterQuadLines.Length;
for (int i = 0; i < lineCount; i++)
{
FLetterQuadLine line = _letterQuadLines[i];
minY = Math.Min(line.bounds.yMin, minY);
maxY = Math.Max(line.bounds.yMax, maxY);
}
float offsetY = -(minY + ((maxY - minY) * _anchorY));
for (int i = 0; i < lineCount; i++)
{
FLetterQuadLine line = _letterQuadLines[i];
float offsetX = -line.bounds.width * _anchorX;
minX = Math.Min(offsetX, minX);
maxX = Math.Max(offsetX + line.bounds.width, maxX);
int quadCount = line.quads.Length;
for (int q = 0; q < quadCount; q++)
{
//todo: figure out where this magic 1.0f comes from
//it's needed for everything to be perfectly positioned, but I'm not sure why...
line.quads[q].CalculateVectors(offsetX + _font.offsetX + 1.0f, offsetY + _font.offsetY + 1.0f);
}
}
_textRect.x = minX;
_textRect.y = minY + offsetY;
_textRect.width = maxX - minX;
_textRect.height = maxY - minY;
_isMeshDirty = true;
}
public void UpdateLocalPosition()
{
_doesLocalPositionNeedUpdate = false;
float minY = 100000000;
float maxY = -100000000;
float minX = 100000000;
float maxX = -100000000;
int lineCount = _letterQuadLines.Length;
for (int i = 0; i < lineCount; i++)
{
FLetterQuadLine line = _letterQuadLines[i];
minY = Math.Min(line.bounds.yMin, minY);
maxY = Math.Max(line.bounds.yMax, maxY);
}
float offsetY = -(minY + ((maxY - minY) * _anchorY));
for (int i = 0; i < lineCount; i++)
{
FLetterQuadLine line = _letterQuadLines[i];
float offsetX = -line.bounds.width * _anchorX;
minX = Math.Min(offsetX, minX);
maxX = Math.Max(offsetX + line.bounds.width, maxX);
int quadCount = line.quads.Length;
for (int q = 0; q < quadCount; q++)
{
line.quads[q].CalculateVectors(offsetX, offsetY);
}
}
_textRect.x = minX;
_textRect.y = minY + offsetY;
_textRect.width = maxX - minX;
_textRect.height = maxY - minY;
_isMeshDirty = true;
}
public FLetterQuadLine[] GetQuadInfoForText(string text, FTextParams textParams)
{
int lineCount = 0;
int letterCount = 0;
char[] letters = text.ToCharArray();
//at some point these should probably be pooled and reused so we're not allocing new ones all the time
FLetterQuadLine[] lines = new FLetterQuadLine[10];
int lettersLength = letters.Length;
for(int c = 0; c<lettersLength; ++c)
{
char letter = letters[c];
if(letter == ASCII_NEWLINE)
{
lines[lineCount] = new FLetterQuadLine();
lines[lineCount].letterCount = letterCount;
lines[lineCount].quads = new FLetterQuad[letterCount];
lineCount++;
letterCount = 0;
}
else
{
letterCount++;
}
}
lines[lineCount] = new FLetterQuadLine();
lines[lineCount].letterCount = letterCount;
lines[lineCount].quads = new FLetterQuad[letterCount];
FLetterQuadLine[] oldLines = lines;
lines = new FLetterQuadLine[lineCount+1];
for(int c = 0; c<lineCount+1; ++c)
{
lines[c] = oldLines[c];
}
lineCount = 0;
letterCount = 0;
float nextX = 0;
float nextY = 0;
FCharInfo charInfo;
char previousLetter = '\0';
float minX = 100000;
float maxX = -100000;
float minY = 100000;
float maxY = -100000;
float usableLineHeight = _lineHeight + textParams.scaledLineHeightOffset + _textParams.scaledLineHeightOffset;
for(int c = 0; c<lettersLength; ++c)
{
char letter = letters[c];
if(letter == ASCII_NEWLINE)
{
lines[lineCount].bounds = new Rect(minX,minY,maxX-minX,maxY-minY);
minX = 100000;
maxX = -100000;
minY = 100000;
maxY = -100000;
nextX = 0;
nextY -= usableLineHeight;
lineCount++;
letterCount = 0;
}
else
{
FKerningInfo foundKerning = _nullKerning;
for(int k = 0; k<_kerningCount; k++)
{
FKerningInfo kerningInfo = _kerningInfos[k];
if(kerningInfo.first == previousLetter && kerningInfo.second == letter)
{
foundKerning = kerningInfo;
}
}
//TODO: Reuse letterquads with pooling!
FLetterQuad letterQuad = new FLetterQuad();
if(_charInfosByID.ContainsKey(letter))
{
charInfo = _charInfosByID[letter];
}
else //we don't have that character in the font
{
//blank, character (could consider using the "char not found square")
charInfo = _charInfosByID[0];
}
float totalKern = foundKerning.amount + textParams.scaledKerningOffset + _textParams.scaledKerningOffset;
nextX += totalKern;
letterQuad.charInfo = charInfo;
Rect quadRect = new Rect(nextX + charInfo.offsetX, nextY - charInfo.offsetY - charInfo.height, charInfo.width, charInfo.height);
letterQuad.rect = quadRect;
lines[lineCount].quads[letterCount] = letterQuad;
minX = Math.Min (minX, quadRect.xMin);
maxX = Math.Max (maxX, quadRect.xMax);
maxY = Math.Max (maxY, nextY);
minY = Math.Min (minY, nextY - usableLineHeight);
// minY = Math.Min (minY, quadRect.yMin);
// maxY = Math.Max (maxY, quadRect.yMax);
nextX += charInfo.xadvance;
letterCount++;
}
previousLetter = letter;
}
lines[lineCount].bounds = new Rect(minX,minY,maxX-minX,maxY-minY);
return lines;
}
public FLetterQuadLine[] GetQuadInfoForText(string text, FTextParams textParams)
{
int lineCount = 0;
int letterCount = 0;
char[] letters = text.ToCharArray();
FLetterQuadLine[] lines = new FLetterQuadLine[10];
for(int c = 0; c<letters.Length; ++c)
{
char letter = letters[c];
if(letter == ASCII_NEWLINE)
{
lines[lineCount] = new FLetterQuadLine();
lines[lineCount].letterCount = letterCount;
lines[lineCount].quads = new FLetterQuad[letterCount];
lineCount++;
letterCount = 0;
}
else
{
letterCount++;
}
}
lines[lineCount] = new FLetterQuadLine();
lines[lineCount].letterCount = letterCount;
lines[lineCount].quads = new FLetterQuad[letterCount];
FLetterQuadLine[] oldLines = lines;
lines = new FLetterQuadLine[lineCount+1];
for(int c = 0; c<lineCount+1; ++c)
{
lines[c] = oldLines[c];
}
lineCount = 0;
letterCount = 0;
float nextX = 0;
float nextY = 0;
FCharInfo charInfo;
char previousLetter = '\0';
float minX = 100000;
float maxX = -100000;
float minY = 100000;
float maxY = -100000;
for(int c = 0; c<letters.Length; ++c)
{
char letter = letters[c];
if(letter == ASCII_NEWLINE)
{
lines[lineCount].bounds = new Rect(minX,minY,maxX-minX,maxY-minY);
minX = 100000;
maxX = -100000;
minY = 100000;
maxY = -100000;
nextX = 0;
nextY -= _lineHeight + textParams.scaledLineHeightOffset + _fontTextParams.scaledLineHeightOffset;
lineCount++;
letterCount = 0;
}
else
{
FKerningInfo foundKerning = _nullKerning;
foreach(FKerningInfo kerningInfo in _kerningInfos)
{
if(kerningInfo.first == previousLetter && kerningInfo.second == letter)
{
foundKerning = kerningInfo;
}
}
//TODO: Reuse letterquads with pooling!
FLetterQuad letterQuad = new FLetterQuad();
charInfo = _charInfosByID[letter];
float totalKern = foundKerning.amount + textParams.scaledKerningOffset + _fontTextParams.scaledKerningOffset;
nextX += totalKern;
letterQuad.charInfo = charInfo;
//
Rect quadRect = new Rect(nextX + charInfo.offsetX, nextY - charInfo.offsetY - charInfo.height, charInfo.width, charInfo.height);
letterQuad.rect = quadRect;
lines[lineCount].quads[letterCount] = letterQuad;
minX = Math.Min (minX, quadRect.xMin);
maxX = Math.Max (maxX, quadRect.xMax);
minY = Math.Min (minY, quadRect.yMin);
maxY = Math.Max (maxY, quadRect.yMax);
nextX += charInfo.xadvance;
letterCount++;
}
previousLetter = letter;
}
lines[lineCount].bounds = new Rect(minX,minY,maxX-minX,maxY-minY);
return lines;
}
public FLetterQuadLine[] GetQuadInfoForText(string text, FTextParams labelTextParams)
{
int lineCount = 0;
int letterCount = 0;
char[] letters = text.ToCharArray();
//at some point these should probably be pooled and reused so we're not allocing new ones all the time
//now they're structs though, so it might not be an issue
FLetterQuadLine[] lines = new FLetterQuadLine[15];
int lettersLength = letters.Length;
for (int c = 0; c < lettersLength; ++c)
{
char letter = letters[c];
if (letter == ASCII_NEWLINE)
{
lines[lineCount] = new FLetterQuadLine();
lines[lineCount].letterCount = letterCount;
lines[lineCount].quads = new FLetterQuad[letterCount];
lineCount++;
letterCount = 0;
}
else
{
letterCount++;
}
}
lines[lineCount] = new FLetterQuadLine();
lines[lineCount].letterCount = letterCount;
lines[lineCount].quads = new FLetterQuad[letterCount];
FLetterQuadLine[] oldLines = lines;
lines = new FLetterQuadLine[lineCount + 1];
for (int c = 0; c < lineCount + 1; ++c)
{
lines[c] = oldLines[c];
}
lineCount = 0;
letterCount = 0;
float nextX = 0;
float nextY = 0;
FCharInfo charInfo;
char previousLetter = '\0';
float minX = float.MaxValue;
float maxX = float.MinValue;
float minY = float.MaxValue;
float maxY = float.MinValue;
float usableLineHeight = _lineHeight + labelTextParams.scaledLineHeightOffset + _textParams.scaledLineHeightOffset;
for (int c = 0; c < lettersLength; ++c)
{
char letter = letters[c];
if (letter == ASCII_NEWLINE)
{
if (letterCount == 0)
{
lines[lineCount].bounds = new Rect(0, 0, nextY, nextY - usableLineHeight);
}
else
{
lines[lineCount].bounds = new Rect(minX, minY, maxX - minX, maxY - minY);
}
minX = float.MaxValue;
maxX = float.MinValue;
minY = float.MaxValue;
maxY = float.MinValue;
nextX = 0;
nextY -= usableLineHeight;
lineCount++;
letterCount = 0;
}
else
{
FKerningInfo foundKerning = _nullKerning;
for (int k = 0; k < _kerningCount; k++)
{
FKerningInfo kerningInfo = _kerningInfos[k];
if (kerningInfo.first == previousLetter && kerningInfo.second == letter)
{
foundKerning = kerningInfo;
}
}
//TODO: Reuse letterquads with pooling!
FLetterQuad letterQuad = new FLetterQuad();
if (_charInfosByID.ContainsKey(letter))
{
charInfo = _charInfosByID[letter];
}
else //we don't have that character in the font
{
//blank, character (could consider using the "char not found square")
charInfo = _charInfosByID[0];
}
float totalKern = foundKerning.amount + labelTextParams.scaledKerningOffset + _textParams.scaledKerningOffset;
if (letterCount == 0)
{
nextX = -charInfo.offsetX; //don't offset the first character
}
else
{
nextX += totalKern;
}
letterQuad.charInfo = charInfo;
Rect quadRect = new Rect(nextX + charInfo.offsetX, nextY - charInfo.offsetY - charInfo.height, charInfo.width, charInfo.height);
letterQuad.rect = quadRect;
lines[lineCount].quads[letterCount] = letterQuad;
minX = Math.Min(minX, quadRect.xMin);
maxX = Math.Max(maxX, quadRect.xMax);
minY = Math.Min(minY, nextY - usableLineHeight);
maxY = Math.Max(maxY, nextY);
nextX += charInfo.xadvance;
letterCount++;
}
previousLetter = letter;
}
if (letterCount == 0) //there were no letters, so minX and minY would be crazy if we used them
{
lines[lineCount].bounds = new Rect(0, 0, nextY, nextY - usableLineHeight);
}
else
{
lines[lineCount].bounds = new Rect(minX, minY, maxX - minX, maxY - minY);
}
return(lines);
}
public FLetterQuadLine[] GetQuadInfoForText(string text, FTextParams textParams)
{
int lineCount = 0;
int letterCount = 0;
char[] letters = text.ToCharArray();
FLetterQuadLine[] lines = new FLetterQuadLine[10];
for (int c = 0; c < letters.Length; ++c)
{
char letter = letters[c];
if (letter == ASCII_NEWLINE)
{
lines[lineCount] = new FLetterQuadLine();
lines[lineCount].letterCount = letterCount;
lines[lineCount].quads = new FLetterQuad[letterCount];
lineCount++;
letterCount = 0;
}
else
{
letterCount++;
}
}
lines[lineCount] = new FLetterQuadLine();
lines[lineCount].letterCount = letterCount;
lines[lineCount].quads = new FLetterQuad[letterCount];
FLetterQuadLine[] oldLines = lines;
lines = new FLetterQuadLine[lineCount + 1];
for (int c = 0; c < lineCount + 1; ++c)
{
lines[c] = oldLines[c];
}
lineCount = 0;
letterCount = 0;
float nextX = 0;
float nextY = 0;
FCharInfo charInfo;
char previousLetter = '\0';
float minX = 100000;
float maxX = -100000;
float minY = 100000;
float maxY = -100000;
for (int c = 0; c < letters.Length; ++c)
{
char letter = letters[c];
if (letter == ASCII_NEWLINE)
{
lines[lineCount].bounds = new Rect(minX, minY, maxX - minX, maxY - minY);
minX = 100000;
maxX = -100000;
minY = 100000;
maxY = -100000;
nextX = 0;
nextY -= _lineHeight + textParams.scaledLineHeightOffset + _fontTextParams.scaledLineHeightOffset;
lineCount++;
letterCount = 0;
}
else
{
FKerningInfo foundKerning = _nullKerning;
foreach (FKerningInfo kerningInfo in _kerningInfos)
{
if (kerningInfo.first == previousLetter && kerningInfo.second == letter)
{
foundKerning = kerningInfo;
}
}
//TODO: Reuse letterquads with pooling!
FLetterQuad letterQuad = new FLetterQuad();
charInfo = _charInfosByID[letter];
float totalKern = foundKerning.amount + textParams.scaledKerningOffset + _fontTextParams.scaledKerningOffset;
nextX += totalKern;
letterQuad.charInfo = charInfo;
//
Rect quadRect = new Rect(nextX + charInfo.offsetX, nextY - charInfo.offsetY - charInfo.height, charInfo.width, charInfo.height);
letterQuad.rect = quadRect;
lines[lineCount].quads[letterCount] = letterQuad;
minX = Math.Min(minX, quadRect.xMin);
maxX = Math.Max(maxX, quadRect.xMax);
minY = Math.Min(minY, quadRect.yMin);
maxY = Math.Max(maxY, quadRect.yMax);
nextX += charInfo.xadvance;
letterCount++;
}
previousLetter = letter;
}
lines[lineCount].bounds = new Rect(minX, minY, maxX - minX, maxY - minY);
return(lines);
}
public FLetterQuadLine[] GetQuadInfoForText(string text, FTextParams labelTextParams)
{
int lineCount = 0;
int letterCount = 0;
char[] letters = text.ToCharArray();
//at some point these should probably be pooled and reused so we're not allocing new ones all the time
//now they're structs though, so it might not be an issue
FLetterQuadLine[] lines = new FLetterQuadLine[10];
int lettersLength = letters.Length;
for(int c = 0; c<lettersLength; ++c)
{
char letter = letters[c];
if(letter == ASCII_NEWLINE)
{
lines[lineCount] = new FLetterQuadLine();
lines[lineCount].letterCount = letterCount;
lines[lineCount].quads = new FLetterQuad[letterCount];
lineCount++;
letterCount = 0;
}
else
{
letterCount++;
}
}
lines[lineCount] = new FLetterQuadLine();
lines[lineCount].letterCount = letterCount;
lines[lineCount].quads = new FLetterQuad[letterCount];
FLetterQuadLine[] oldLines = lines;
lines = new FLetterQuadLine[lineCount+1];
for(int c = 0; c<lineCount+1; ++c)
{
lines[c] = oldLines[c];
}
lineCount = 0;
letterCount = 0;
float nextX = 0;
float nextY = 0;
FCharInfo charInfo;
char previousLetter = '\0';
float minX = float.MaxValue;
float maxX = float.MinValue;
float minY = float.MaxValue;
float maxY = float.MinValue;
float usableLineHeight = _lineHeight + labelTextParams.scaledLineHeightOffset + _textParams.scaledLineHeightOffset;
for(int c = 0; c<lettersLength; ++c)
{
char letter = letters[c];
if(letter == ASCII_NEWLINE)
{
if(letterCount == 0)
{
lines[lineCount].bounds = new Rect(0,0,nextY,nextY - usableLineHeight);
}
else
{
lines[lineCount].bounds = new Rect(minX,minY,maxX-minX,maxY-minY);
}
minX = float.MaxValue;
maxX = float.MinValue;
minY = float.MaxValue;
maxY = float.MinValue;
nextX = 0;
nextY -= usableLineHeight;
lineCount++;
letterCount = 0;
}
else
{
FKerningInfo foundKerning = _nullKerning;
for(int k = 0; k<_kerningCount; k++)
{
FKerningInfo kerningInfo = _kerningInfos[k];
if(kerningInfo.first == previousLetter && kerningInfo.second == letter)
{
foundKerning = kerningInfo;
}
}
FLetterQuad letterQuad = new FLetterQuad();
if(!_charInfosByID.TryGetValue(letter,out charInfo))
{
charInfo = _charInfosByID[0];
}
float totalKern = foundKerning.amount + labelTextParams.scaledKerningOffset + _textParams.scaledKerningOffset;
if(letterCount == 0)
{
nextX = -charInfo.offsetX; //don't offset the first character
}
else
{
nextX += totalKern;
}
letterQuad.charInfo = charInfo;
Rect quadRect = new Rect(nextX + charInfo.offsetX, nextY - charInfo.offsetY - charInfo.height, charInfo.width, charInfo.height);
letterQuad.rect = quadRect;
lines[lineCount].quads[letterCount] = letterQuad;
minX = Math.Min (minX, quadRect.xMin);
maxX = Math.Max (maxX, quadRect.xMax);
minY = Math.Min (minY, nextY - usableLineHeight);
maxY = Math.Max (maxY, nextY);
nextX += charInfo.xadvance;
letterCount++;
}
previousLetter = letter;
}
if(letterCount == 0) //there were no letters, so minX and minY would be crazy if we used them
{
lines[lineCount].bounds = new Rect(0,0,nextY,nextY - usableLineHeight);
}
else
{
lines[lineCount].bounds = new Rect(minX,minY,maxX-minX,maxY-minY);
}
for(int n = 0; n<lineCount+1; n++)
{
lines[n].bounds.height += labelTextParams.scaledLineHeightOffset + _textParams.scaledLineHeightOffset;
}
return lines;
}
