|
public static fromFloats ( float x, float y, float width, float height ) : |
||
| x | float | The x coordinate. |
| y | float | The y coordinate. |
| width | float | Width. |
| height | float | Height. |
| return | ||
public override void Render(Graphics graphics, Camera camera)
{
var topLeft = Entity.transform.position + localOffset;
var destinationRect = RectangleExt.fromFloats(topLeft.X, topLeft.Y, _sourceRect.Width * Entity.transform.scale.X * TextureScale.X, _sourceRect.Height * Entity.transform.scale.Y * TextureScale.Y);
graphics.batcher.draw(Subtexture, destinationRect, _sourceRect, Color, Entity.transform.rotation, Origin * _inverseTexScale, SpriteEffects, layerDepth);
}
public override void render(Graphics graphics, Camera camera)
{
var topLeft = entity.transform.position + _localOffset;
var destinationRect = RectangleExt.fromFloats(topLeft.X, topLeft.Y, _sourceRect.Width * entity.transform.scale.X * textureScale.X, _sourceRect.Height * entity.transform.scale.Y * textureScale.Y);
graphics.batcher.draw(subtexture, destinationRect, _sourceRect, color, entity.transform.rotation, origin * _inverseTexScale, spriteEffects, _layerDepth);
}
void updateResolutionScaler()
{
var designSize = _designResolutionSize;
var screenSize = new Point(Screen.width, Screen.height);
var screenAspectRatio = (float)screenSize.X / (float)screenSize.Y;
var renderTargetWidth = screenSize.X;
var renderTargetHeight = screenSize.Y;
var resolutionScaleX = (float)screenSize.X / (float)designSize.X;
var resolutionScaleY = (float)screenSize.Y / (float)designSize.Y;
var rectCalculated = false;
// calculate the scale used by the PixelPerfect variants
pixelPerfectScale = 1;
if (_resolutionPolicy != SceneResolutionPolicy.None)
{
if ((float)designSize.X / (float)designSize.Y > screenAspectRatio)
{
pixelPerfectScale = screenSize.X / designSize.X;
}
else
{
pixelPerfectScale = screenSize.Y / designSize.Y;
}
if (pixelPerfectScale == 0)
{
pixelPerfectScale = 1;
}
}
switch (_resolutionPolicy)
{
case SceneResolutionPolicy.None:
_finalRenderDestinationRect.X = _finalRenderDestinationRect.Y = 0;
_finalRenderDestinationRect.Width = screenSize.X;
_finalRenderDestinationRect.Height = screenSize.Y;
rectCalculated = true;
break;
case SceneResolutionPolicy.ExactFit:
// exact design size render texture
renderTargetWidth = designSize.X;
renderTargetHeight = designSize.Y;
break;
case SceneResolutionPolicy.NoBorder:
// exact design size render texture
renderTargetWidth = designSize.X;
renderTargetHeight = designSize.Y;
resolutionScaleX = resolutionScaleY = Math.Max(resolutionScaleX, resolutionScaleY);
break;
case SceneResolutionPolicy.NoBorderPixelPerfect:
// exact design size render texture
renderTargetWidth = designSize.X;
renderTargetHeight = designSize.Y;
// we are going to do some cropping so we need to use floats for the scale then round up
pixelPerfectScale = 1;
if ((float)designSize.X / (float)designSize.Y < screenAspectRatio)
{
var floatScale = (float)screenSize.X / (float)designSize.X;
pixelPerfectScale = Mathf.ceilToInt(floatScale);
}
else
{
var floatScale = (float)screenSize.Y / (float)designSize.Y;
pixelPerfectScale = Mathf.ceilToInt(floatScale);
}
if (pixelPerfectScale == 0)
{
pixelPerfectScale = 1;
}
_finalRenderDestinationRect.Width = Mathf.ceilToInt(designSize.X * pixelPerfectScale);
_finalRenderDestinationRect.Height = Mathf.ceilToInt(designSize.Y * pixelPerfectScale);
_finalRenderDestinationRect.X = (screenSize.X - _finalRenderDestinationRect.Width) / 2;
_finalRenderDestinationRect.Y = (screenSize.Y - _finalRenderDestinationRect.Height) / 2;
rectCalculated = true;
break;
case SceneResolutionPolicy.ShowAll:
resolutionScaleX = resolutionScaleY = Math.Min(resolutionScaleX, resolutionScaleY);
renderTargetWidth = designSize.X;
renderTargetHeight = designSize.Y;
break;
case SceneResolutionPolicy.ShowAllPixelPerfect:
// exact design size render texture
renderTargetWidth = designSize.X;
renderTargetHeight = designSize.Y;
_finalRenderDestinationRect.Width = Mathf.ceilToInt(designSize.X * pixelPerfectScale);
_finalRenderDestinationRect.Height = Mathf.ceilToInt(designSize.Y * pixelPerfectScale);
_finalRenderDestinationRect.X = (screenSize.X - _finalRenderDestinationRect.Width) / 2;
_finalRenderDestinationRect.Y = (screenSize.Y - _finalRenderDestinationRect.Height) / 2;
rectCalculated = true;
break;
case SceneResolutionPolicy.FixedHeight:
resolutionScaleX = resolutionScaleY;
designSize.X = Mathf.ceilToInt(screenSize.X / resolutionScaleX);
// exact design size render texture for height but not width
renderTargetWidth = designSize.X;
renderTargetHeight = designSize.Y;
break;
case SceneResolutionPolicy.FixedHeightPixelPerfect:
// start with exact design size render texture height. the width may change
renderTargetHeight = designSize.Y;
_finalRenderDestinationRect.Width = Mathf.ceilToInt(designSize.X * resolutionScaleX);
_finalRenderDestinationRect.Height = Mathf.ceilToInt(designSize.Y * pixelPerfectScale);
_finalRenderDestinationRect.X = (screenSize.X - _finalRenderDestinationRect.Width) / 2;
_finalRenderDestinationRect.Y = (screenSize.Y - _finalRenderDestinationRect.Height) / 2;
rectCalculated = true;
renderTargetWidth = (int)(designSize.X * resolutionScaleX / pixelPerfectScale);
break;
case SceneResolutionPolicy.FixedWidth:
resolutionScaleY = resolutionScaleX;
designSize.Y = Mathf.ceilToInt(screenSize.Y / resolutionScaleY);
// exact design size render texture for width but not height
renderTargetWidth = designSize.X;
renderTargetHeight = designSize.Y;
break;
case SceneResolutionPolicy.FixedWidthPixelPerfect:
// start with exact design size render texture width. the height may change
renderTargetWidth = designSize.X;
_finalRenderDestinationRect.Width = Mathf.ceilToInt(designSize.X * pixelPerfectScale);
_finalRenderDestinationRect.Height = Mathf.ceilToInt(designSize.Y * resolutionScaleY);
_finalRenderDestinationRect.X = (screenSize.X - _finalRenderDestinationRect.Width) / 2;
_finalRenderDestinationRect.Y = (screenSize.Y - _finalRenderDestinationRect.Height) / 2;
rectCalculated = true;
renderTargetHeight = (int)(designSize.Y * resolutionScaleY / pixelPerfectScale);
break;
case SceneResolutionPolicy.BestFit:
var safeScaleX = (float)screenSize.X / (designSize.X - _designBleedSize.X);
var safeScaleY = (float)screenSize.Y / (designSize.Y - _designBleedSize.Y);
var resolutionScale = MathHelper.Max(resolutionScaleX, resolutionScaleY);
var safeScale = MathHelper.Min(safeScaleX, safeScaleY);
resolutionScaleX = resolutionScaleY = MathHelper.Min(resolutionScale, safeScale);
renderTargetWidth = designSize.X;
renderTargetHeight = designSize.Y;
break;
}
// if we didnt already calculate a rect (None and all pixel perfect variants calculate it themselves) calculate it now
if (!rectCalculated)
{
// calculate the display rect of the RenderTarget
var renderWidth = designSize.X * resolutionScaleX;
var renderHeight = designSize.Y * resolutionScaleY;
_finalRenderDestinationRect = RectangleExt.fromFloats((screenSize.X - renderWidth) / 2, (screenSize.Y - renderHeight) / 2, renderWidth, renderHeight);
}
// set some values in the Input class to translate mouse position to our scaled resolution
var scaleX = renderTargetWidth / (float)_finalRenderDestinationRect.Width;
var scaleY = renderTargetHeight / (float)_finalRenderDestinationRect.Height;
Input._resolutionScale = new Vector2(scaleX, scaleY);
Input._resolutionOffset = _finalRenderDestinationRect.Location;
// resize our RenderTargets
if (_sceneRenderTarget != null)
{
_sceneRenderTarget.Dispose();
}
_sceneRenderTarget = RenderTarget.create(renderTargetWidth, renderTargetHeight);
// only create the destinationRenderTarget if it already exists, which would indicate we have PostProcessors
if (_destinationRenderTarget != null)
{
_destinationRenderTarget.Dispose();
_destinationRenderTarget = RenderTarget.create(renderTargetWidth, renderTargetHeight);
}
// notify the Renderers, PostProcessors and FinalRenderDelegate of the change in render texture size
for (var i = 0; i < _renderers.length; i++)
{
_renderers.buffer[i].onSceneBackBufferSizeChanged(renderTargetWidth, renderTargetHeight);
}
for (var i = 0; i < _afterPostProcessorRenderers.length; i++)
{
_afterPostProcessorRenderers.buffer[i].onSceneBackBufferSizeChanged(renderTargetWidth, renderTargetHeight);
}
for (var i = 0; i < _postProcessors.length; i++)
{
_postProcessors.buffer[i].onSceneBackBufferSizeChanged(renderTargetWidth, renderTargetHeight);
}
if (_finalRenderDelegate != null)
{
_finalRenderDelegate.onSceneBackBufferSizeChanged(renderTargetWidth, renderTargetHeight);
}
camera.onSceneRenderTargetSizeChanged(renderTargetWidth, renderTargetHeight);
}
public void drawInto(
Batcher batcher,
ref FontCharacterSource text,
Vector2 position,
Color color,
float rotation,
Vector2 origin,
Vector2 scale,
SpriteEffects effect,
float depth)
{
var flipAdjustment = Vector2.Zero;
var flippedVert = (effect & SpriteEffects.FlipVertically) == SpriteEffects.FlipVertically;
var flippedHorz = (effect & SpriteEffects.FlipHorizontally) == SpriteEffects.FlipHorizontally;
if (flippedVert || flippedHorz)
{
Vector2 size;
measureString(ref text, out size);
if (flippedHorz)
{
origin.X *= -1;
flipAdjustment.X = -size.X;
}
if (flippedVert)
{
origin.Y *= -1;
flipAdjustment.Y = _font.LineSpacing - size.Y;
}
}
// TODO: This looks excessive... i suspect we could do most of this with simple vector math and avoid this much matrix work.
var requiresTransformation = flippedHorz || flippedVert || rotation != 0f || scale != Vector2.One;
if (requiresTransformation)
{
Matrix2D temp;
Matrix2D.createTranslation(-origin.X, -origin.Y, out _transformationMatrix);
Matrix2D.createScale(flippedHorz ? -scale.X : scale.X, flippedVert ? -scale.Y : scale.Y, out temp);
Matrix2D.multiply(ref _transformationMatrix, ref temp, out _transformationMatrix);
Matrix2D.createTranslation(flipAdjustment.X, flipAdjustment.Y, out temp);
Matrix2D.multiply(ref temp, ref _transformationMatrix, out _transformationMatrix);
Matrix2D.createRotation(rotation, out temp);
Matrix2D.multiply(ref _transformationMatrix, ref temp, out _transformationMatrix);
Matrix2D.createTranslation(position.X, position.Y, out temp);
Matrix2D.multiply(ref _transformationMatrix, ref temp, out _transformationMatrix);
}
// Get the default glyph here once.
SpriteFont.Glyph?defaultGlyph = null;
if (_font.DefaultCharacter.HasValue)
{
defaultGlyph = _glyphs[_font.DefaultCharacter.Value];
}
var currentGlyph = SpriteFont.Glyph.Empty;
var offset = requiresTransformation ? Vector2.Zero : position - origin;
var firstGlyphOfLine = true;
for (var i = 0; i < text.Length; ++i)
{
var c = text[i];
if (c == '\r')
{
continue;
}
if (c == '\n')
{
offset.X = requiresTransformation ? 0f : position.X - origin.X;
offset.Y += _font.LineSpacing;
firstGlyphOfLine = true;
continue;
}
if (!_glyphs.TryGetValue(c, out currentGlyph))
{
if (!defaultGlyph.HasValue)
{
throw new ArgumentException("Errors.TextContainsUnresolvableCharacters", "text");
}
currentGlyph = defaultGlyph.Value;
}
// The first character on a line might have a negative left side bearing.
// In this scenario, SpriteBatch/SpriteFont normally offset the text to the right,
// so that text does not hang off the left side of its rectangle.
if (firstGlyphOfLine)
{
offset.X += Math.Max(currentGlyph.LeftSideBearing, 0);
firstGlyphOfLine = false;
}
else
{
offset.X += _font.Spacing + currentGlyph.LeftSideBearing;
}
var p = offset;
if (flippedHorz)
{
p.X += currentGlyph.BoundsInTexture.Width;
}
p.X += currentGlyph.Cropping.X;
if (flippedVert)
{
p.Y += currentGlyph.BoundsInTexture.Height - _font.LineSpacing;
}
p.Y += currentGlyph.Cropping.Y;
// transform our point if we need to
if (requiresTransformation)
{
Vector2Ext.transform(ref p, ref _transformationMatrix, out p);
}
var destRect = RectangleExt.fromFloats(
p.X,
p.Y,
currentGlyph.BoundsInTexture.Width * scale.X,
currentGlyph.BoundsInTexture.Height * scale.Y);
batcher.draw(
_font.Texture,
destRect,
currentGlyph.BoundsInTexture,
color,
rotation,
Vector2.Zero,
effect,
depth);
offset.X += currentGlyph.Width + currentGlyph.RightSideBearing;
}
}