public void Startup(IServiceProvider serviceProvider)
{
if (serviceProvider == null)
{
throw new ArgumentNullException(nameof(serviceProvider));
}
_logger = serviceProvider.GetRequiredService <ILogger>();
_engine = serviceProvider.GetRequiredService <IClientEngine>();
_networking = serviceProvider.GetRequiredService <ClientNetworking>();
_entities = serviceProvider.GetRequiredService <ClientEntities>();
_clientUI = new ImGuiInterface(_logger, _engine, this);
_renderer = new Renderer.Renderer(
_engine.GameWindow,
_logger,
_engine.FileSystem,
_engine.CommandContext,
_engine.UserInterface.WindowManager.InputSystem,
_engine.Time,
this,
Framework.Path.EnvironmentMaps,
Framework.Path.Shaders);
_engine.GameWindow.Resized += _renderer.WindowResized;
_entities.Startup(_renderer);
}
protected override void OnRender(Renderer.Renderer renderer)
{
if (Content != null)
{
Content.Render(renderer);
}
}
protected override void OnRender(Renderer.Renderer renderer)
{
base.OnRender(renderer);
if (ShowGridLines)
{
renderer.GraphicsDevice.RasterizerState = BaseWindow.WithoutClipping;
var gridColor = GridLinesColor ?? Color.Red;
renderer.Draw(AbsoluteVisualOffset + new Vector2(0, 0),
AbsoluteVisualOffset + new Vector2(0, ActualHeight), gridColor);
float xx = 0;
for (int x = 0; x < columnDefinitions.Count; x++)
{
xx += columnDefinitions[x].FinalLength;
renderer.Draw(AbsoluteVisualOffset + new Vector2(xx, 0),
AbsoluteVisualOffset + new Vector2(xx, ActualHeight), gridColor);
}
renderer.Draw(AbsoluteVisualOffset + new Vector2(0, 0),
AbsoluteVisualOffset + new Vector2(ActualWidth, 0), gridColor);
float yy = 0;
for (int y = 0; y < rowDefinitions.Count; y++)
{
yy += rowDefinitions[y].FinalLength;
renderer.Draw(AbsoluteVisualOffset + new Vector2(0, yy),
AbsoluteVisualOffset + new Vector2(ActualWidth, yy), gridColor);
}
}
}
protected override void OnRender(Renderer.Renderer renderer)
{
// not the best way to display watermark text
var wt = textBlock.Text;
var wb = textBlock.Foreground;
if (wt == string.Empty)
{
textBlock.Text = Watermark;
textBlock.Foreground = WatermarkBrush;
}
textBlock.Text = wt;
textBlock.Foreground = wb;
textBlock.Render(renderer);
if (EnableMarker && HasFocus)
{
// TODO: Marker Flashing with Interval ofc
if (MarkerLocation < 0 || MarkerLocation > Text.Length)
{
throw new IndexOutOfRangeException("MarkerLocation");
}
var MarkerText = Text.Substring(0, MarkerLocation);
var MarkerPosition = textBlock.TextStartPosition;
// (-2), we want it to be closer to the character.
MarkerPosition.X += Font.MeasureString(MarkerText).X - 2;
var mChar = (MarkerLocation == Text.Length) ? MarkerChar2 : MarkerChar1;
renderer.DrawString(Font, mChar.ToString(), MarkerPosition, (Color)MarkerBrush);
}
}
protected override void OnRender(Renderer.Renderer renderer)
{
elapsedTimeSinceLastUpdate += renderer.ElapsedTime;
if (elapsedTimeSinceLastUpdate >= UpdateFrequency.TotalSeconds)
{
Update(renderer.ElapsedTime);
elapsedTimeSinceLastUpdate -= (float)UpdateFrequency.TotalSeconds;
}
// TODO: Render to Texture
var Bounds = AbsoluteRenderTransform;
float x = Bounds.X;
float deltaX = Bounds.Width / (float)ValuesToGraph;
float yScale = Bounds.Bottom - Bounds.Top;
if (GraphValues.Count <= 2)
{
return;
}
for (int i = GraphValues.Count - 1; i > 0; i--)
{
var y1 = Bounds.Bottom - ((GraphValues[i] / (AdaptiveMaximum - AdaptiveMinimum)) * yScale);
var y2 = Bounds.Bottom - ((GraphValues[i - 1] / (AdaptiveMaximum - AdaptiveMinimum)) * yScale);
var x1 = new Vector2(MathHelper.Clamp(x, Bounds.Left, Bounds.Right), MathHelper.Clamp(y1, Bounds.Top, Bounds.Bottom));
var x2 = new Vector2(MathHelper.Clamp(x + deltaX, Bounds.Left, Bounds.Right), MathHelper.Clamp(y2, Bounds.Top, Bounds.Bottom));
renderer.Draw(x1, x2, LineColor);
x += deltaX;
}
}
public void GenerateBillboardTextures(IEnumerable <Texture> textures)
{
_logger.Information($"Generating billboard textures.");
foreach (var tex in textures)
{
var word = GenerateBillboardText();
var color = _billboardColors[_random.Next(_billboardColors.Count)];
using (var text = new Textbox("Consolas")
.WithText(word, new Vector2(), 1.5f)
.WithHue(color.X)
.WithSaturation(color.Y)
.WithValue(color.Z))
using (var renderer = new Renderer.Renderer())
using (var backbufferRenderer = new BackBufferRenderer(_logger, tex, tex.Width, tex.Height, false))
{
renderer.BeforeRender = () => { GL.Enable(EnableCap.Blend); };
renderer.AfterRender = () => { GL.Disable(EnableCap.Blend); };
renderer.AddToScene(text.Text);
backbufferRenderer.RenderToTexture(renderer, _projectionMatrix, Matrix4.Identity);
if (text.CursorAdvance > tex.Width)
{
_logger.Warning($"The billboard text is wider than the texture width! ({word})");
}
}
}
}
public ViewModelBase(SWF.IWin32Window hiddenForm, RenderHost renderHost)
{
this.renderHost = renderHost;
colorTextures = new ColorTextures();
textureCache = new TextureCache(colorTextures, renderHost);
renderer = new Renderer.Renderer(hiddenForm, renderHost, colorTextures, textureCache);
mapLoaded = false;
cameraPanScale = 1.0f;
cameraScrollScale = 1.0f;
}
/// <summary>
/// Initialise the manaager with an initial portrait
/// </summary>
/// <param name="renderer">The rendering object</param>
/// <param name="display">The display object</param>
/// <param name="startID">The id of the starting portrait</param>
/// <param name="startPortrait">The starting portrait object</param>
public Manager(Renderer.Renderer renderer, Display.Display display, int startID, Portrait startPortrait)
{
_renderer = renderer;
_display = display;
_currentPortrait = startID;
Portraits = new Dictionary <int, Portrait>();
AddPortrait(_currentPortrait, startPortrait); // Add the initial portrait to the list.
startPortrait.SetManager(this);
Portraits[_currentPortrait].SelectThisPortrait(); // Initialise the portrait
}
/// <summary>
/// Initializes and starts the game
/// </summary>
/// <param name="gameWindow">Game window instance</param>
public static void Run(GameWindow gameWindow)
{
try
{
if (SystemEnvironment.LaunchArguments.Contains("--disableLogging") || SystemEnvironment.LaunchArguments.Contains("-dl"))
{
Console.WriteLine("craftersmine EtherEngine (c) craftersmine 2018-2019");
Debugging.Logger = null;
Console.WriteLine("Game Logging capability is disabled! To enable logging please remove \"--disableLogging\" or \"-dl\" argument from shortcut or start line");
}
else
{
Debugging.Logger = new Logger(SystemEnvironment.TemporaryDirectory, "craftersmine.EtherEngine");
}
Debugging.Log(LogEntryType.Info, "craftersmine EtherEngine (c) craftersmine 2018-2019");
Debugging.Log(LogEntryType.Info, "Enabling visual styles...");
Application.EnableVisualStyles();
GameWindow = gameWindow;
GameWndPointer = GameWindow.Handle;
Debugging.Log(LogEntryType.Info, "Initializing DirectInput keyboard...");
KeyboardInstance = new Keyboard();
Debugging.Log(LogEntryType.Info, "Initializing XInput gamepad...");
GamepadInstance = new Gamepad();
Debugging.Log(LogEntryType.Info, "Creating GameUpdater...");
GameUpdater = new UpdateTimer(60);
GameUpdater.FixedUpdate += GameUpdateHandlers.FixedUpdateHandler;
GameUpdater.Update += GameUpdateHandlers.UpdateHandler;
GameUpdater.PausedUpdate += GameUpdateHandlers.PausedUpdateHandler;
// TODO: Game initialization logic goes below here
Debugging.Log(LogEntryType.Info, "Creating Renderer...");
Renderer = new Renderer.Renderer(GameWndPointer);
Debugging.Log(LogEntryType.Info, "Loading default scene...");
SceneManager.LoadScene(new Scene {
BackgroundColor = new Color(0f)
});
Renderer.SetFullscreenState(GameWindow.WindowParameters.IsFullscreen);
Debugging.Log(LogEntryType.Done, "Game initialized!");
GameInitialized += Initialized;
RenderLoop.Run(GameWindow, new RenderLoop.RenderCallback(Renderer.Render));
}
catch (Exception ex)
{
CrashHandler.Handle(ex);
}
}
public void Reinitialize(
Simulation simulation,
Renderer.Renderer renderer
)
{
this.simulation = simulation;
this.renderer = renderer;
if (this.thread == null)
{
this.thread = new Thread(Run);
this.thread.Name = "SimulationThread" + processor;
this.thread.Start();
}
}
//Load content
public void Load(ContentManager content, GraphicsDevice graphicsDevice)
{
_renderer = new Renderer.Renderer();
_logic = new MainLogic();
_editorLogic = new EditorLogic();
_assets = new Assets();
_debug = new DebugScreen();
_uiLogic = new UILogic();
Shaders.Load(content);
_assets.Load(content, graphicsDevice);
_renderer.Load(content);
_logic.Load(content);
_debug.LoadContent(content);
_uiLogic.Load(content);
}
//Load content
public void Load(ContentManager content, GraphicsDevice graphicsDevice)
{
_debug = new DebugScreen();
_debug.LoadContent(content);
_mainLogic = new MainLogic();
_mainLogic.Load(content);
_guiRenderer = new GUIRenderer();
_guiRenderer.Load(content);
_guiLogicSample = new GuiLogicSample();
_guiLogicSample.Load(content);
_renderer = new Renderer.Renderer();
_renderer.Load(content);
}
protected internal override void OnRender(Renderer.Renderer renderer, BoundingRectangle bound)
{
// TODO: Image Size Calculation
SpriteEffects Effects = SpriteEffects.None;
if (Flip != Flip.None & Flip != Flip.Both)
{
Effects = (SpriteEffects)Flip;
}
else if (Flip == Flip.Both)
{
Effects = SpriteEffects.FlipVertically | SpriteEffects.FlipHorizontally;
}
renderer.Draw(Source, bound, SourceRectangle, Color.White);
}
//Load content
public void Load(ContentManager content, GraphicsDevice graphicsDevice)
{
_renderer = new Renderer.Renderer();
_sceneLogic = new MainSceneLogic();
_guiLogic = new GUILogic();
_editorLogic = new EditorLogic();
_assets = new Assets();
_debug = new DebugScreen();
_guiRenderer = new GUIRenderer();
Globals.content = content;
Shaders.Load(content);
_assets.Load(content, graphicsDevice);
_renderer.Load(content);
_sceneLogic.Load(content);
_debug.LoadContent(content);
_guiRenderer.Load(content);
}
internal RenderWindow() : base(800, 640, GraphicsMode.Default, "Render Window", GameWindowFlags.Default, DisplayDevice.Default, 3, 0, GraphicsContextFlags.ForwardCompatible)
{
renderer = new Renderer.Renderer();
Renderer.RendererSettings settings = new Renderer.RendererSettings();
renderer.Settings = settings;
OpenTK.Graphics.OpenGL.GL.Viewport(0, 0, 800, 640);
cameraMovement.flag = cameraMoveflag.None;
cameraMovement.CBackwardTicks = 0;
cameraMovement.CDownTicks = 0;
cameraMovement.CForwardTicks = 0;
cameraMovement.CleftTicks = 0;
cameraMovement.CPanLeft = 0;
cameraMovement.CPanRight = 0;
cameraMovement.CRightTicks = 0;
cameraMovement.CTiltDown = 0;
cameraMovement.CTiltUp = 0;
cameraMovement.CUpTicks = 0;
}
protected internal override void OnRender(Renderer.Renderer renderer, BoundingRectangle bound)
{
if (prevBound != null && prevBound != bound)
{
needsRebuild = true;
}
prevBound = bound;
if (needsRebuild)
{
Build(bound);
needsRebuild = false;
}
foreach (var sprite in rectangles)
{
renderer.Draw(Texture, sprite.Location, sprite.Source, Color.White);
}
}
protected override void OnRender(Renderer.Renderer renderer)
{
// TODO: Rendering
base.OnRender(renderer);
}
public void Reintialize()
{
Rendex = new Renderer.Renderer(720, 360);
}
protected internal override void OnRender(Renderer.Renderer renderer, BoundingRectangle bound)
{
// How should I do this? Hm.
base.OnRender(renderer, bound);
}
/// <summary>
/// Set the rendering options
/// </summary>
/// <param name="renderer">The render object</param>
/// <param name="display">The display object</param>
public void SetRenderOptions(Renderer.Renderer renderer, Display.Display display)
{
_renderer = renderer;
_display = display;
}
protected override void OnRender(Renderer.Renderer renderer)
{
renderer.Draw(AbsoluteRenderTransform, InnerBrush);
}
/// <summary>
/// Applies filter on PNG image in body of HTTP request
/// </summary>
/// <param name="filter">Name of the filter</param>
/// <param name="coords">Cropping area of image</param>
public void Post(string filter, string coords)
{
Bitmap bodyBitmap = null;
Bitmap result = null;
MemoryStream stream = null;
try
{
IRenderStrategy filterStrategy = GetFilter(filter);
if (Context.Request.ContentLength64 > 102400 || Context.Request.ContentLength64 <= 8 || filterStrategy == null)
{
Context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
return;
}
byte[] file = new byte[Context.Request.ContentLength64];
Context.Request.InputStream.Read(file, 0, 8);
for (int i = 0; i < 8; i++)
{
if (file[i] != PngSignature[i])
{
Context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
return;
}
}
Context.Request.InputStream.Read(file, 8, (int)Context.Request.ContentLength64 - 8);
stream = new MemoryStream(file);
Renderer.Renderer renderer = new Renderer.Renderer();
bodyBitmap = new Bitmap(stream);
Rectangle cropArea = ConvertToRectangle(coords);
cropArea.Intersect(new Rectangle(0, 0, bodyBitmap.Width, bodyBitmap.Height));
logger.Trace($"#{Context.Request.RequestTraceIdentifier} Rectangle of target bitmap: {cropArea.X}, {cropArea.Y}, {cropArea.Width}, {cropArea.Height}");
if (cropArea.Width == 0 || cropArea.Height == 0)
{
Context.Response.StatusCode = (int)HttpStatusCode.NoContent;
return;
}
result = renderer.RenderBitmap(bodyBitmap, cropArea, filterStrategy).Result;
stream.Dispose(); stream = new MemoryStream();
result.Save(stream, System.Drawing.Imaging.ImageFormat.Png);
Context.Response.AddHeader("Content-Type", "application/octet-stream");
Context.Response.ContentLength64 = stream.Length;
Context.Response.OutputStream.Write(stream.ToArray(), 0, (int)stream.Length);
}
catch (OverflowException e) when(e.Message == "Value was either too large or too small for an Int32.")
{
Context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
return;
}
catch (ArgumentException)
{
Context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
return;
}
catch (Exception ex)
{
throw ex;
}
finally
{
if (bodyBitmap != null)
{
bodyBitmap.Dispose();
}
if (result != null)
{
result.Dispose();
}
if (stream != null)
{
stream.Dispose();
}
}
}
public void Connect(Renderer.Renderer renderer)
{
this.renderer = renderer;
InitializationDependsOn(renderer);
}
public MeshRenderer()
{
Renderer = RendererCore.Renderer.Renderer.Instance;
}
protected internal override void OnRender(Renderer.Renderer renderer, BoundingRectangle bound)
{
renderer.Draw(bound, (Color)this);
}
protected internal virtual void OnRender(Renderer.Renderer renderer, BoundingRectangle bound)
{
}
protected override void OnRender(Renderer.Renderer renderer)
{
base.OnRender(renderer);
}
public int Initialise( )
{
PresentationParameters Presentation =
new PresentationParameters( );
#region Windows specific
#if WINDOWS
Presentation.BackBufferWidth = m_Form.ClientSize.Width;
Presentation.BackBufferHeight = m_Form.ClientSize.Height;
Presentation.IsFullScreen = false;
Presentation.DeviceWindowHandle = m_Form.Handle;
#endif
#endregion
Presentation.BackBufferFormat = SurfaceFormat.Color;
Presentation.DepthStencilFormat = DepthFormat.Depth24Stencil8;
Presentation.RenderTargetUsage = RenderTargetUsage.DiscardContents;
Presentation.PresentationInterval = PresentInterval.Immediate;
m_Renderer = new Renderer.Renderer( Presentation );
m_Renderer.SetClearColour( 0.6f, 0.0f, 0.0f );
m_TestModel = new Renderer.Model( ref m_Renderer );
string ModelString = "TestModel.blood";
m_TestModel.Load( ref ModelString );
return 0;
}
protected internal override void OnRender(Renderer.Renderer renderer, BoundingRectangle bound)
{
Visual.Measure(new Vector2(bound.Width, bound.Height));
Visual.Arrange(bound);
Visual.Render(renderer);
}
