public override void render( Graphics graphics )
{
Core.graphicsDevice.setRenderTarget( null );
graphics.batcher.begin( BlendState.NonPremultiplied, Core.defaultSamplerState, DepthStencilState.None, null, _windEffect );
graphics.batcher.draw( previousSceneRender, _destinationRect, Color.White );
graphics.batcher.end();
}
public override void render( Graphics graphics )
{
Core.graphicsDevice.setRenderTarget( null );
graphics.batcher.begin( BlendState.NonPremultiplied, Core.defaultSamplerState, DepthStencilState.None, null );
graphics.batcher.draw( previousSceneRender, Vector2.Zero, _color );
graphics.batcher.end();
}
public override void debugRender( Graphics graphics )
{
graphics.batcher.drawHollowRect( bounds, Debug.Colors.colliderBounds, Debug.Size.lineSizeMultiplier );
graphics.batcher.drawCircle( shape.position, ( (Circle)shape ).radius, Debug.Colors.colliderEdge, Debug.Size.lineSizeMultiplier );
graphics.batcher.drawPixel( entity.transform.position, Debug.Colors.colliderPosition, 4 * Debug.Size.lineSizeMultiplier );
graphics.batcher.drawPixel( shape.position, Debug.Colors.colliderCenter, 2 * Debug.Size.lineSizeMultiplier );
}
public override void render(Nez.Graphics graphics, Camera camera)
{
if (debugRenderEnabled)
{
graphics.batcher.drawCircle(_position, 10f, Color.DarkRed);
}
}
public override void debugRender( Graphics graphics )
{
if( _cameraStyle == CameraStyle.LockOn )
graphics.batcher.drawHollowRect( _worldSpaceDeadzone.x - 5, _worldSpaceDeadzone.y - 5, _worldSpaceDeadzone.width, _worldSpaceDeadzone.height, Color.DarkRed );
else
graphics.batcher.drawHollowRect( _worldSpaceDeadzone, Color.DarkRed );
}
public override void render( Graphics graphics, Camera camera )
{
// we need to send the top of of the plane to the Effect
var screenSpaceTop = entity.scene.camera.worldToScreenPoint( entity.transform.position );
( material as WaterReflectionMaterial ).effect.screenSpaceVerticalOffset = screenSpaceTop.Y / entity.scene.sceneRenderTargetSize.Y;
graphics.batcher.draw( _texture, bounds, new Rectangle( 0, 0, 1, 1 ), color );
}
public override void render(Nez.Graphics graphics, Nez.Camera camera)
{
if (Core.debugRenderEnabled)
{
graphics.batcher.drawCircle(camera.screenToWorldPoint(_midSize), 10f, Color.Beige);
graphics.batcher.drawCircle(_targetPos, 10f, Color.Orchid);
graphics.batcher.drawCircle(_targetPos, 10f, Color.Green);
}
}
public override void debugRender( Graphics graphics )
{
foreach( var group in tiledMap.objectGroups )
renderObjectGroup( group, graphics );
if( _colliders != null )
{
foreach( var collider in _colliders )
collider.debugRender( graphics );
}
}
public override void render(Nez.Graphics graphics, Nez.Camera camera)
{
// TODO figure out the height of the target dynamically.
var barPos = entity.position + _targetOffset;
var health = entity.getComponent <Health>();
if (health != null)
{
var healthWidth = (float)health.Hp / health.MaxHp * BarWidth;
graphics.batcher.drawRect(barPos, BarWidth, BarHeight, Color.Red);
graphics.batcher.drawRect(barPos, healthWidth, BarHeight, Color.Chartreuse);
}
}
public override void render( Graphics graphics, Camera camera )
{
if( _destRectsDirty )
{
subtexture.generateNinePatchRects( _finalRenderRect, _destRects, subtexture.top, subtexture.bottom, subtexture.right, subtexture.left );
_destRectsDirty = false;
}
var pos = ( entity.transform.position + _localOffset ).ToPoint();
for( var i = 0; i < 9; i++ )
{
// shift our destination rect over to our position
var dest = _destRects[i];
dest.X += pos.X;
dest.Y += pos.Y;
graphics.batcher.draw( subtexture, dest, subtexture.ninePatchRects[i], color );
}
}
public override void render( Graphics graphics, Camera camera )
{
// flush the 2D batch so we render appropriately depth-wise
graphics.batcher.flushBatch();
Core.graphicsDevice.BlendState = BlendState.Opaque;
Core.graphicsDevice.DepthStencilState = DepthStencilState.Default;
for( var i = 0; i < _model.Meshes.Count; i++ )
{
var mesh = _model.Meshes[i];
for( var j = 0; j < mesh.Effects.Count; j++ )
{
var effect = mesh.Effects[j] as BasicEffect;
effect.World = worldMatrix;
effect.View = camera.viewMatrix3D;
effect.Projection = camera.projectionMatrix3D;
}
mesh.Draw();
}
}
public override void debugRender( Graphics graphics )
{
var poly = shape as Polygon;
graphics.batcher.drawHollowRect( bounds, Debug.Colors.colliderBounds, Debug.Size.lineSizeMultiplier );
graphics.batcher.drawPolygon( shape.position, poly.points, Debug.Colors.colliderEdge, true, Debug.Size.lineSizeMultiplier );
graphics.batcher.drawPixel( entity.transform.position, Debug.Colors.colliderPosition, 4 * Debug.Size.lineSizeMultiplier );
graphics.batcher.drawPixel( shape.position, Debug.Colors.colliderCenter, 2 * Debug.Size.lineSizeMultiplier );
// Normal debug code
//for( var i = 0; i < poly.points.Length; i++ )
//{
// Vector2 p2;
// var p1 = poly.points[i];
// if( i + 1 >= poly.points.Length )
// p2 = poly.points[0];
// else
// p2 = poly.points[i + 1];
// var perp = Vector2Ext.perpendicular( ref p1, ref p2 );
// Vector2Ext.normalize( ref perp );
// var mp = Vector2.Lerp( p1, p2, 0.5f ) + poly.position;
// graphics.batcher.drawLine( mp, mp + perp * 10, Color.White );
//}
}
public override void debugRender( Graphics graphics )
{
stage.getRoot().debugRender( graphics );
}
public override void render( Graphics graphics, Camera camera )
{
stage.render( graphics, camera );
}
void renderObjectGroup( TiledObjectGroup group, Graphics graphics )
{
var renderPosition = entity.transform.position + _localOffset;
foreach( var obj in group.objects )
{
if( !obj.visible )
continue;
switch( obj.tiledObjectType )
{
case TiledObject.TiledObjectType.Ellipse:
graphics.batcher.drawCircle( new Vector2( renderPosition.X + obj.x + obj.width * 0.5f, renderPosition.Y + obj.y + obj.height * 0.5f ), obj.width * 0.5f, group.color );
break;
case TiledObject.TiledObjectType.Image:
throw new NotImplementedException( "Image layers are not yet supported" );
case TiledObject.TiledObjectType.Polygon:
graphics.batcher.drawPoints( renderPosition, obj.polyPoints, group.color, true );
break;
case TiledObject.TiledObjectType.Polyline:
graphics.batcher.drawPoints( renderPosition, obj.polyPoints, group.color, false );
break;
case TiledObject.TiledObjectType.None:
graphics.batcher.drawHollowRect( renderPosition.X + obj.x, renderPosition.Y + obj.y, obj.width, obj.height, group.color );
break;
default:
throw new ArgumentOutOfRangeException();
}
}
}
public override void render(Nez.Graphics graphics, Camera camera)
{
graphics.batcher.draw(_subtexture, entity.transform.position + localOffset, color, entity.transform.rotation, origin, entity.transform.scale * _scale, spriteEffects, _layerDepth);
}
public override void debugRender( Graphics graphics )
{
graphics.batcher.drawHollowRect( shape.bounds, Color.Black );
graphics.batcher.drawPolygon( absolutePosition, ((shape as Polygon).points), Color.DarkRed, true );
graphics.batcher.drawPixel( absolutePosition, Color.Yellow, 4 );
}
public override void render( Graphics graphics, Camera camera )
{
// First we draw all the trail nodes using the border color. we need to draw them slightly larger, so the border is left visible
// when we draw the actual nodes
// adjust the startScale and endScale to take into consideration the border
var borderStartScale = startScale + borderSize / _cursorTexture.Width;
var borderEndScale = endScale + borderSize / _cursorTexture.Width;
// draw all nodes with the new scales
for( var i = 0; i < _trailNodeCount; i++ )
{
var node = _trailNodes[i];
var lerpFactor = (float)i / (float)( _trailNodeCount - 1 );
lerpFactor = Mathf.pow( lerpFactor, lerpExponent );
var scale = MathHelper.Lerp( borderStartScale, borderEndScale, lerpFactor );
// draw using the border Color
graphics.batcher.draw( _cursorTexture, node.position, null, borderColor, 0.0f, _textureCenter, scale, SpriteEffects.None, 0.0f );
}
// Next, we draw all the nodes normally, using the fill Color because before we drew them larger, after we draw them at
// their normal size, a border will remain visible.
for( var i = 0; i < _trailNodeCount; i++ )
{
var node = _trailNodes[i];
var lerpFactor = (float)i / (float)( _trailNodeCount - 1 );
lerpFactor = Mathf.pow( lerpFactor, lerpExponent );
var scale = MathHelper.Lerp( startScale, endScale, lerpFactor );
// draw using the fill color
graphics.batcher.draw( _cursorTexture, node.position, null, fillColor, 0.0f, _textureCenter, scale, SpriteEffects.None, 0.0f );
}
}
public override void render( Graphics graphics, Camera camera )
{
calculateVertices();
_basicEffect.Projection = camera.projectionMatrix;
_basicEffect.View = camera.transformMatrix;
_basicEffect.CurrentTechnique.Passes[0].Apply();
Core.graphicsDevice.DrawUserPrimitives( PrimitiveType.TriangleStrip, _vertices, 0, _ribbonLength * 2 + 1 );
}
public override void render( Graphics graphics )
{
Core.graphicsDevice.setRenderTarget( null );
graphics.batcher.begin( BlendState.NonPremultiplied, Core.defaultSamplerState, DepthStencilState.None, null );
// we only render the previousSceneRender while fading to _color. It will be null after that.
if( !_isNewSceneLoaded )
graphics.batcher.draw( previousSceneRender, _destinationRect, Color.White );
graphics.batcher.draw( _overlayTexture, new Rectangle( 0, 0, Screen.width, Screen.height ), _color );
graphics.batcher.end();
}
public override void render( Graphics graphics )
{
Core.graphicsDevice.setRenderTarget( null );
graphics.batcher.begin( BlendState.AlphaBlend, Core.defaultSamplerState, DepthStencilState.None, null, _textureWipeEffect );
// we only render the previousSceneRender while populating the squares
if( !_isNewSceneLoaded )
graphics.batcher.draw( previousSceneRender, _destinationRect, Color.White );
else
graphics.batcher.draw( _overlayTexture, new Rectangle( 0, 0, Screen.width, Screen.height ), Color.Transparent );
graphics.batcher.end();
}
public override void render( Graphics graphics, Camera camera )
{
_sprite.drawOutline( graphics, camera, outlineColor, outlineWidth );
_sprite.render( graphics, camera );
}
public override void render( Graphics graphics, Camera camera )
{
graphics.batcher.draw( subtexture, entity.transform.position + _localOffset, _sourceRect, color, entity.transform.rotation, origin, entity.transform.scale, spriteEffects, _layerDepth );
}
public override void render( Graphics graphics, Camera camera )
{
// we override render and use position instead of entityPosition. this keeps the text in place even if the entity moves
graphics.batcher.drawString( _font, _text, localOffset, color, entity.transform.rotation, origin, entity.transform.scale, spriteEffects, layerDepth );
}
/// <summary>
/// returns true if we are done with this debug draw item
/// </summary>
public bool draw( Graphics graphics )
{
switch( drawType )
{
case DebugDrawType.Line:
graphics.batcher.drawLine( start, end, color );
break;
case DebugDrawType.HollowRectangle:
graphics.batcher.drawHollowRect( rectangle, color );
break;
case DebugDrawType.Pixel:
graphics.batcher.drawPixel( x, y, color, size );
break;
case DebugDrawType.BitmapFontText:
graphics.batcher.drawString( bitmapFont, text, position, color, 0f, Vector2.Zero, scale, SpriteEffects.None, 0f );
break;
case DebugDrawType.SpriteFontText:
graphics.batcher.drawString( spriteFont, text, position, color, 0f, Vector2.Zero, new Vector2( scale ), SpriteEffects.None, 0f );
break;
case DebugDrawType.ConsoleText:
graphics.batcher.drawString( bitmapFont, text, position, color, 0f, Vector2.Zero, scale, SpriteEffects.None, 0f );
break;
}
duration -= Time.deltaTime;
return duration < 0f;
}
public override void render( Graphics graphics, Camera camera )
{
// flush the 2D batch so we render appropriately depth-wise
graphics.batcher.flushBatch();
Core.graphicsDevice.BlendState = BlendState.Opaque;
Core.graphicsDevice.DepthStencilState = DepthStencilState.Default;
// Set BasicEffect parameters.
_basicEffect.World = worldMatrix;
_basicEffect.View = camera.viewMatrix3D;
_basicEffect.Projection = camera.projectionMatrix3D;
_basicEffect.DiffuseColor = color.ToVector3();
// Set our vertex declaration, vertex buffer, and index buffer.
Core.graphicsDevice.SetVertexBuffer( _vertexBuffer );
Core.graphicsDevice.Indices = _indexBuffer;
_basicEffect.CurrentTechnique.Passes[0].Apply();
var primitiveCount = _indices.Count / 3;
Core.graphicsDevice.DrawIndexedPrimitives( PrimitiveType.TriangleList, 0, 0, primitiveCount );
}
public override void render( Graphics graphics )
{
Core.graphicsDevice.setRenderTarget( null );
// if we are scaling out we dont need to render the previous scene anymore since we want the new scene to be visible
if( !_isNewSceneLoaded )
{
graphics.batcher.begin( BlendState.Opaque, Core.defaultSamplerState, DepthStencilState.None, null );
graphics.batcher.draw( previousSceneRender, Vector2.Zero, Color.White );
graphics.batcher.end();
}
graphics.batcher.begin( _blendState, Core.defaultSamplerState, DepthStencilState.None, null );
graphics.batcher.draw( _maskRenderTarget, Vector2.Zero, Color.White );
graphics.batcher.end();
}
public override void debugRender( Graphics graphics )
{
// due to the override of position in render we have to do the same here
var rect = bounds;
rect.location = localOffset;
graphics.batcher.drawHollowRect( rect, Color.Yellow );
}
public override void render( Graphics graphics, Camera camera )
{
// TODO: make culling smarter and only render the lines that are actually on the screen rather than all or nothing
var width = _points.GetLength( 0 );
var height = _points.GetLength( 1 );
for( var y = 1; y < height; y++ )
{
for( var x = 1; x < width; x++ )
{
var left = new Vector2();
var up = new Vector2();
var p = projectToVector2( _points[x, y].position );
if( x > 1 )
{
float thickness;
Color gridColor;
if( y % gridMajorPeriodY == 1 )
{
thickness = gridMajorThickness;
gridColor = gridMajorColor;
}
else
{
thickness = gridMinorThickness;
gridColor = gridMinorColor;
}
// use Catmull-Rom interpolation to help smooth bends in the grid
left = projectToVector2( _points[x - 1, y].position );
var clampedX = Math.Min( x + 1, width - 1 );
var mid = Vector2.CatmullRom( projectToVector2( _points[x - 2, y].position ), left, p, projectToVector2( _points[clampedX, y].position ), 0.5f );
// If the grid is very straight here, draw a single straight line. Otherwise, draw lines to our new interpolated midpoint
if( Vector2.DistanceSquared( mid, ( left + p ) / 2 ) > 1 )
{
drawLine( graphics.batcher, left, mid, gridColor, thickness );
drawLine( graphics.batcher, mid, p, gridColor, thickness );
}
else
{
drawLine( graphics.batcher, left, p, gridColor, thickness );
}
}
if( y > 1 )
{
float thickness;
Color gridColor;
if( x % gridMajorPeriodX == 1 )
{
thickness = gridMajorThickness;
gridColor = gridMajorColor;
}
else
{
thickness = gridMinorThickness;
gridColor = gridMinorColor;
}
up = projectToVector2( _points[x, y - 1].position );
var clampedY = Math.Min( y + 1, height - 1 );
var mid = Vector2.CatmullRom( projectToVector2( _points[x, y - 2].position ), up, p, projectToVector2( _points[x, clampedY].position ), 0.5f );
if( Vector2.DistanceSquared( mid, ( up + p ) / 2 ) > 1 )
{
drawLine( graphics.batcher, up, mid, gridColor, thickness );
drawLine( graphics.batcher, mid, p, gridColor, thickness );
}
else
{
drawLine( graphics.batcher, up, p, gridColor, thickness );
}
}
// Add interpolated lines halfway between our point masses. This makes the grid look
// denser without the cost of simulating more springs and point masses.
if( x > 1 && y > 1 )
{
var upLeft = projectToVector2( _points[x - 1, y - 1].position );
drawLine( graphics.batcher, 0.5f * ( upLeft + up ), 0.5f * ( left + p ), gridMinorColor, gridMinorThickness ); // vertical line
drawLine( graphics.batcher, 0.5f * ( upLeft + left ), 0.5f * ( up + p ), gridMinorColor, gridMinorThickness ); // horizontal line
}
}
}
}
public override void debugRender( Graphics graphics )
{
graphics.batcher.drawCircle( bounds.center, ((Circle)shape).radius, Color.IndianRed );
graphics.batcher.drawPixel( bounds.center, Color.IndianRed, 4 );
}
public override void preRender( Graphics graphics )
{
Core.graphicsDevice.setRenderTarget( _maskRenderTarget );
graphics.batcher.begin( BlendState.AlphaBlend, Core.defaultSamplerState, DepthStencilState.None, null );
graphics.batcher.draw( _maskTexture, _maskPosition, null, Color.White, _renderRotation, _maskOrigin, _renderScale, SpriteEffects.None, 0 );
graphics.batcher.end();
Core.graphicsDevice.setRenderTarget( null );
}
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 pos = ( entity.transform.position - ( origin * entity.transform.localScale ) + localOffset );
var size = new Point( (int)( _width * entity.transform.localScale.X ), (int)( _height * entity.transform.localScale.Y ) );
var destRect = new Rectangle( (int)pos.X, (int)pos.Y, size.X, size.Y );
graphics.batcher.draw( subtexture, destRect, subtexture.sourceRect, color, entity.transform.rotation, SpriteEffects.None, layerDepth, _skewTopX, _skewBottomX, _skewLeftY, _skewRightY );
}
public override void render( Graphics graphics, Camera camera )
{
_basicEffect.Projection = camera.projectionMatrix;
_basicEffect.View = camera.transformMatrix;
_basicEffect.CurrentTechnique.Passes[0].Apply();
// TODO: set the _basicEffect.World = entity.transform.localToWorldTransform instead of manualy mucking with verts and a local matrix
// see the deferred lighting PolygonMesh class for details.
Core.graphicsDevice.SamplerStates[0] = SamplerState.AnisotropicClamp;
Core.graphicsDevice.DrawUserPrimitives( PrimitiveType.TriangleList, _verts, 0, _points.Length - 2, VertexPositionColor.VertexDeclaration );
}
