private void UpdateQuad()
{
quadRenderer.Begin();
quadRenderer.Quad(
new Vector3(renderer.Width - texture.Size.Width, 0, 0.0f),
new Vector3(renderer.Width, texture.Size.Height, 0.0f)
);
quadRenderer.End();
}
public override void Render()
{
QuadRenderer.Begin();
float alpha = (10 - timer) / 10;
QuadRenderer.DrawFullScreenGradient(new Color4(38f / 255, 38f / 255, 39f / 255, alpha), new Color4(70f / 255, 69f / 255, 70f / 255, alpha));
Color4 color = new Color4(1, 1, 1, alpha);
QuadRenderer.Draw(StartupLayer.logo, new Vector2(Display.Width / 2 - StartupLayer.logo.Width / 2, Display.Height / 2 - StartupLayer.logo.Height / 2 - 20 * alpha), color);
QuadRenderer.End();
}
public void UpdateQuads()
{
int n = currentLightCount;
float gap = 5.0f;
float size = (renderer.Width / (n + 1)) - gap;
float x = gap;
quadRenderer.Begin();
for (int i = 0; i < n; ++i)
{
quadRenderer.Quad(
new Vector3(x, gap, (float)(i)),
new Vector3(x + size, gap + size, (float)(i))
);
x += size + gap;
}
quadRenderer.End();
}
protected override void LoadContent()
{
base.LoadContent();
ContentWrapper.Initialize(this);
_spriteBatch = new SpriteBatch(GraphicsDevice);
_lineBatch = new LineBatch(GraphicsDevice);
_quadRenderer = new QuadRenderer(GraphicsDevice);
_input.LoadContent(GraphicsDevice.Viewport);
#if WINDOWS
_counter.LoadContent();
#endif
// Create rendertarget for transitions
PresentationParameters pp = GraphicsDevice.PresentationParameters;
_transitions.Add(new RenderTarget2D(GraphicsDevice, pp.BackBufferWidth, pp.BackBufferHeight, false, SurfaceFormat.Color, pp.DepthStencilFormat, pp.MultiSampleCount, RenderTargetUsage.DiscardContents));
_menuScreen = new MenuScreen();
List <Type> DemosToLoad = new List <Type>();
Assembly samplesFramework = Assembly.GetExecutingAssembly();
foreach (Type sampleType in samplesFramework.GetTypes())
{
if (sampleType.IsSubclassOf(typeof(PhysicsDemoScreen)))
{
DemosToLoad.Add(sampleType);
}
}
DemosToLoad.Add(DemosToLoad[0]); // HACK: Load the first sample two times, since some delayed creation stuff with the rendertargets always breaks the first preview picture.
bool firstPreview = true;
foreach (Type sampleType in DemosToLoad)
{
PhysicsDemoScreen demoScreen = samplesFramework.CreateInstance(sampleType.ToString()) as PhysicsDemoScreen;
#if WINDOWS
if (!firstPreview)
{
Console.WriteLine("Loading demo: " + demoScreen.GetTitle());
}
#endif
RenderTarget2D preview = new RenderTarget2D(GraphicsDevice, pp.BackBufferWidth / 2, pp.BackBufferHeight / 2, false, SurfaceFormat.Color, pp.DepthStencilFormat, pp.MultiSampleCount, RenderTargetUsage.DiscardContents);
demoScreen.Framework = this;
demoScreen.IsExiting = false;
demoScreen.Sprites = _spriteBatch;
demoScreen.Lines = _lineBatch;
demoScreen.Quads = _quadRenderer;
demoScreen.LoadContent();
// "Abuse" transition rendertarget to render screen preview
GraphicsDevice.SetRenderTarget(_transitions[0]);
GraphicsDevice.Clear(Color.Transparent);
_quadRenderer.Begin();
_quadRenderer.Render(Vector2.Zero, new Vector2(_transitions[0].Width, _transitions[0].Height), null, true, ContentWrapper.Grey, Color.White * 0.3f);
_quadRenderer.End();
// Update ensures that the screen is fully visible, we "cover" it so that no physics are run
demoScreen.Update(new GameTime(demoScreen.TransitionOnTime, demoScreen.TransitionOnTime), true, false);
demoScreen.Draw(new GameTime());
demoScreen.Draw(new GameTime());
GraphicsDevice.SetRenderTarget(preview);
GraphicsDevice.Clear(Color.Transparent);
_spriteBatch.Begin();
_spriteBatch.Draw(_transitions[0], preview.Bounds, Color.White);
_spriteBatch.End();
GraphicsDevice.SetRenderTarget(null);
demoScreen.ExitScreen();
demoScreen.Update(new GameTime(demoScreen.TransitionOffTime, demoScreen.TransitionOffTime), true, false);
if (!firstPreview)
{
_menuScreen.AddMenuItem(demoScreen, preview);
}
else
{
firstPreview = false;
}
}
AddScreen(new BackgroundScreen());
AddScreen(_menuScreen);
//TODO: This can't be called at this point in time in MonoGame
//ResetElapsedTime();
}
private void UpdateBrush()
{
if (updateBrush)
{
Display.context.OutputMerger.SetTargets(brushRenderTarget);
Display.context.ClearRenderTargetView(brushRenderTarget, Color.Transparent);
QuadRenderer.Begin();
Display.context.OutputMerger.BlendState = DeviceStates.blendStateDrawing;
int quality = 85;
Color4 color = new Color4(1, 1, 1, 1);
color.Alpha = 0.012f;
float size = 1;
for (int i = 1; i <= quality; i++)
{
size = ((100.0f - CurrentBrushSoftness) / 100) + ((float)i / quality) * (CurrentBrushSoftness / 100);
QuadRenderer.Draw(DefaultBrush, new Vector2(256 * (1 - size)), new Vector2(size), color);
}
QuadRenderer.End();
Display.context.OutputMerger.SetTargets(Display.depthStencil, Display.renderTarget);
GraphicsManager.Reset();
CurrentBrush.ressource = new ShaderResourceView(Display.device, brushTexture);
Display.context.CopyResource(brushTexture, brushTextureReadable);
Surface surf = brushTextureReadable.QueryInterface <Surface>();
DataStream streamN;
DataRectangle rect = surf.Map(SharpDX.DXGI.MapFlags.Read, out streamN);
streamN.Position = 0;
byte[] textureData = new byte[512 * 512 * 4];
streamN.ReadRange(textureData, 0, textureData.Length);
surf.Unmap();
System.Drawing.Bitmap bmp = new System.Drawing.Bitmap(
512, 512,
System.Drawing.Imaging.PixelFormat.Format32bppArgb
);
System.Drawing.Imaging.BitmapData bmpData = bmp.LockBits(
new System.Drawing.Rectangle(0, 0, 512, 512),
System.Drawing.Imaging.ImageLockMode.WriteOnly,
System.Drawing.Imaging.PixelFormat.Format32bppArgb
);
IntPtr safePtr = bmpData.Scan0;
System.Runtime.InteropServices.Marshal.Copy(textureData, 0, safePtr, textureData.Length);
bmp.UnlockBits(bmpData);
form.brushPreview.Image = bmp;
form.brushPreview.SizeMode = PictureBoxSizeMode.Zoom;
updateBrush = false;
}
}
protected override void WinUpdate()
{
if (ForegroundGame.Map == null)
{
return;
}
UpdateBrush();
Point pnt = new Point(InputHelper.mouseX, InputHelper.mouseY);
bool canZoom = true;
float realWheel = InputHelper.wheelDelta - deltaWheel;
deltaWheel = InputHelper.wheelDelta;
camera.ZoomLevel -= realWheel;
if (camera.ZoomLevel < camera.minZoom)
{
camera.ZoomLevel = camera.minZoom;
canZoom = false;
}
else if (camera.ZoomLevel > 50)
{
camera.ZoomLevel = 50;
}
bool freezeDestination = false;
if (updateWaterShader && !InputHelper.leftDown)
{
TerrainWater.Initialize();
updateWaterShader = false;
}
//------------------------------------------------------------------------------------------------ SELECTION STUFF
if ((currentTool == Tool.OBJECT_EDIT || currentTool == Tool.DECAL_EDIT) && InputHelper.altDown)
{
freezeDestination = true;
}
else if (currentTool != Tool.NOTHING && InputHelper.altDown && InputHelper.rightDown)
{
if (!LastRightClick)
{
clickPos = deltaPos = pnt;
lastBrushSize = CurrentBrushSize;
lastBrushSoftness = CurrentBrushSoftness;
}
float dx = pnt.X - deltaPos.X;
float dy = pnt.Y - deltaPos.Y;
float dist = 1;
if (destination != new Vector3(0, -99999, 0))
{
dist = Vector3.Distance(destination, camera.eyePosition);
dist /= ClientSize.Width / 2;
}
CurrentBrushSize = lastBrushSize + (dx * dist);
if (CurrentBrushSize < 1)
{
CurrentBrushSize = 1;
}
else if (CurrentBrushSize > 200)
{
CurrentBrushSize = 200;
}
form.brushSize.Value = (int)CurrentBrushSize;
CurrentBrushSoftness = lastBrushSoftness - (dy * dist);
if (CurrentBrushSoftness < 0)
{
CurrentBrushSoftness = 0;
}
else if (CurrentBrushSoftness > 100)
{
CurrentBrushSoftness = 100;
}
form.brushSoftness.Value = (int)CurrentBrushSoftness;
ChangeBrushProperties(CurrentBrushSize, CurrentBrushSoftness, CurrentBrushIntensity);
freezeDestination = true;
}
else
{
CameraInputs(pnt);
}
Ray ray = CameraHelper.RayFromScreen(pnt.X, pnt.Y);
if (!freezeDestination)
{
destination = ForegroundGame.Map.Pick(ray, false);
}
Vector2 size = new Vector2(CurrentBrushSize / 512);
Vector2 textPos = new Vector2(destination.X, destination.Z) + new Vector2(-256 + 256 * (1 - size.X));
//------------------------------------------------------------------------------------------------ MODIFICATION AND TOOLS AND STUFF
if (InputHelper.leftDown)
{
if (currentTool == Tool.PATHFINDING)
{
#region Pathfinding
int roundedSize = (int)Math.Ceiling(CurrentBrushSize / 2);
int destX = (int)Math.Round(destination.X, MidpointRounding.ToEven);
int destY = (int)Math.Round(destination.Z, MidpointRounding.ToEven);
int width = (int)Math.Ceiling((float)Terrain.info.width / 2);
for (int x = -roundedSize; x < roundedSize; x++)
{
for (int y = -roundedSize; y < roundedSize; y++)
{
float power = (Vector2.Distance(Vector2.Zero, new Vector2(x, y)) / CurrentBrushSize) / 0.5f;
float limit = 1 - (CurrentBrushSoftness / 100);
power = (power - limit) / (1 - limit);
power = 1 - GameUtils.Clamp(power, 0, 1);
if (power > 0 && Terrain.InsideMap(destX + x, destY + y))
{
Point2D point = new Point2D((int)((destX + x) / 2), (int)((destY + y) / 2));//ForegroundGame.Map_Space.WorldToSpace(new Vector3());
Terrain.info.accessibilityArray[point.X + point.Y * width] = (byte)(CurrentBrushColor.Green == 0 ? 0 : 1);
}
}
}
#endregion
}
else if (currentTool == Tool.TEXTURE)
{
#region Texture
Color4 colorAlphad = CurrentBrushColor;
colorAlphad.Alpha = CurrentBrushIntensity / 100;
Display.context.OutputMerger.SetTargets(drawableRenderTarget);
Display.context.ClearRenderTargetView(drawableRenderTarget, Color.Black);
QuadRenderer.Begin();
Display.context.OutputMerger.BlendState = DeviceStates.blendStateDrawing;
QuadRenderer.Draw(Terrain.info.TextureMap, new Vector2(0), Color.White);
QuadRenderer.Draw(CurrentBrush, textPos, size, colorAlphad);
QuadRenderer.End();
Display.context.OutputMerger.SetTargets(Display.depthStencil, Display.renderTarget);
GraphicsManager.Reset();
Texture2DDescription descHM = new Texture2DDescription()
{
ArraySize = 1,
BindFlags = BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.None,
Format = Format.R8G8B8A8_UNorm,
Width = Terrain.info.width,
Height = Terrain.info.height,
MipLevels = 1,
OptionFlags = ResourceOptionFlags.None,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default,
};
Terrain.info.TextureMap.Tex.Dispose();
Terrain.info.TextureMap.ressource.Dispose();
Terrain.info.TextureMap.Tex = new Texture2D(Display.device, descHM);
Display.context.CopyResource(drawableTexture, Terrain.info.TextureMap.Tex);
Terrain.info.TextureMap.RecreateSRV();
modifiedTextureMap = true;
#endregion
}
else if (currentTool == Tool.COLOR)
{
#region Color
Color4 colorAlphad = CurrentBrushColor;
colorAlphad.Alpha = CurrentBrushIntensity / 100;
Display.context.OutputMerger.SetTargets(drawableRenderTarget);
Display.context.ClearRenderTargetView(drawableRenderTarget, Color.Black);
QuadRenderer.Begin();
Display.context.OutputMerger.BlendState = DeviceStates.blendStateDrawing;
QuadRenderer.Draw(Terrain.info.ColorMap, new Vector2(0), Color.White);
QuadRenderer.Draw(CurrentBrush, textPos, size, colorAlphad);
QuadRenderer.End();
Display.context.OutputMerger.SetTargets(Display.depthStencil, Display.renderTarget);
GraphicsManager.Reset();
Texture2DDescription descHM = new Texture2DDescription()
{
ArraySize = 1,
BindFlags = BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.None,
Format = Format.R8G8B8A8_UNorm,
Width = Terrain.info.width,
Height = Terrain.info.height,
MipLevels = 1,
OptionFlags = ResourceOptionFlags.None,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default,
};
Terrain.info.ColorMap.Tex.Dispose();
Terrain.info.ColorMap.Tex = new Texture2D(Display.device, descHM);
Display.context.CopyResource(drawableTexture, Terrain.info.ColorMap.Tex);
Terrain.info.ColorMap.RecreateSRV();
modifiedColorMap = true;
#endregion
}
else if (currentTool == Tool.LANDSCAPE_DOWN || currentTool == Tool.LANDSCAPE_UP || currentTool == Tool.LANDSCAPE_SET || currentTool == Tool.LANDSCAPE_SMOOTH)
{
#region Terraforming
if (!LastClick && currentTool == Tool.LANDSCAPE_SET && !form.customSetValue.Checked)
{
form.levelTo.Value = (decimal)destination.Y;
}
int destX = (int)Math.Round(destination.X, MidpointRounding.ToEven);
int destY = (int)Math.Round(destination.Z, MidpointRounding.ToEven);
int roundedSize = (int)Math.Ceiling(CurrentBrushSize / 2);
if (currentTool == Tool.LANDSCAPE_SMOOTH)
{
listForSmoothing = new List <float[]>(roundedSize * roundedSize * 2 * 2);
}
for (int x = -roundedSize; x < roundedSize; x++)
{
for (int y = -roundedSize; y < roundedSize; y++)
{
float power = (Vector2.Distance(Vector2.Zero, new Vector2(x, y)) / CurrentBrushSize) / 0.5f;
float limit = 1 - (CurrentBrushSoftness / 100);
power = (power - limit) / (1 - limit);
power = 1 - GameUtils.Clamp(power, 0, 1);
if (power > 0 && Terrain.InsideMap(destX + x, destY + y))
{
float height = Terrain.vertices[destX + x + (destY + y) * Terrain.info.width].Position.Y;
switch (currentTool)
{
case Tool.LANDSCAPE_UP:
height += CurrentBrushIntensity / 100 * power;
Terrain.ChangeHeight(destX + x, destY + y, height);
break;
case Tool.LANDSCAPE_DOWN:
height -= CurrentBrushIntensity / 100 * power;
Terrain.ChangeHeight(destX + x, destY + y, height);
break;
case Tool.LANDSCAPE_SET:
Terrain.ChangeHeight(destX + x, destY + y, GameUtils.Lerp(height, HeightLevelSetBrush, power));
break;
case Tool.LANDSCAPE_SMOOTH:
listForSmoothing.Add(new float[] { destX + x, destY + y, CurrentBrushIntensity / 100 * power });
break;
}
}
}
}
if (currentTool == Tool.LANDSCAPE_SMOOTH)
{
Terrain.SmoothHeight(listForSmoothing);
}
DataStream stream;
Display.context.MapSubresource(Terrain.vertexBuffer, MapMode.WriteDiscard, SharpDX.Direct3D11.MapFlags.None, out stream);
stream.WriteRange(Terrain.vertices);
Display.context.UnmapSubresource(Terrain.vertexBuffer, 0);
updateWaterShader = true;
#endregion
}
}
LastClick = InputHelper.leftDown;
LastMiddleClick = InputHelper.middleDown;
LastRightClick = InputHelper.rightDown;
}
void UpdateQuad()
{
quadRenderer.Begin();
quadRenderer.Quad(Vector3.Zero, new Vector3(window.Width, window.Height, 0.0f));
quadRenderer.End();
}
public void Render()
{
renderer.Push();
quadRenderer.Begin();
Vector3 o = new Vector3(10.0f, 64, 0.0f);
Vector3 a = o;
float alpha = 0.50f;
textRenderer.TextBuffer.BeginPrint();
foreach (var timer in Timer.Timers)
{
quadRenderer.Quad(
o,
o + new Vector3(10.0f * timer.CPUTime, 5.0f, 0.0f),
new Vector4(timer.Color, alpha)
);
o.Y += 6.0f;
quadRenderer.Quad(
o,
o + new Vector3(10.0f * timer.GPUTime, 5.0f, 0.0f),
new Vector4(timer.Color, alpha)
);
textRenderer.TextBuffer.LowPrint(
o.X,
o.Y - 4.0f,
0.0f,
timer.ToString()
);
o.Y += 6.0f;
}
quadRenderer.Quad(
new Vector3(10.0f + 159.0f, a.Y, 0.0f),
new Vector3(10.0f + 161.0f, o.Y, 0.0f),
new Vector4(1.0f, 1.0f, 1.0f, alpha)
);
quadRenderer.End();
textRenderer.TextBuffer.EndPrint();
renderer.Requested.Mesh = textRenderer.TextBuffer.Mesh;
renderer.Requested.Material = textRenderer.Material;
renderer.Requested.Program = textRenderer.Material.Program;
renderer.Requested.MeshMode = MeshMode.PolygonFill;
//renderer.SetTexture("t_font", textRenderer.TextBuffer.FontStyle.Texture);
renderer.SetFrame(renderer.DefaultFrame);
renderer.RenderCurrent();
renderer.Global.Floats("alpha").Set(0.5f);
renderer.Global.Sync();
renderer.Requested.Mesh = quadRenderer.Mesh;
// \todo
//renderer.Requested.Material = uiMaterial; // this has blending on
renderer.Requested.Program = renderer.Programs["ColorFill"]; //colorFill;
renderer.Requested.MeshMode = MeshMode.PolygonFill;
renderer.SetFrame(renderer.DefaultFrame);
renderer.RenderCurrent();
renderer.Pop();
}
