public SimpleOverlay(string textureName, string shaderName = "Default",
EffectPriority priority = EffectPriority.VeryLow, RenderLayers layer = RenderLayers.All)
: base(priority, layer)
{
this._texture = TextureManager.AsyncLoad(textureName == null ? "" : textureName);
this._shader = new ScreenShaderData(Main.ScreenShaderRef, shaderName);
}
public SimpleOverlay(string textureName, ScreenShaderData shader,
EffectPriority priority = EffectPriority.VeryLow, RenderLayers layer = RenderLayers.All)
: base(priority, layer)
{
this._texture = TextureManager.AsyncLoad(textureName == null ? "" : textureName);
this._shader = shader;
}
public void Draw(SpriteBatch spriteBatch, RenderLayers layer)
{
if (_overlayCount == 0)
{
return;
}
bool flag = false;
for (int i = 0; i < _activeOverlays.Length; i++)
{
for (LinkedListNode <Overlay> linkedListNode = _activeOverlays[i].First; linkedListNode != null; linkedListNode = linkedListNode.Next)
{
Overlay value = linkedListNode.Value;
if (value.Layer == layer && value.IsVisible())
{
if (!flag)
{
spriteBatch.Begin(SpriteSortMode.Immediate, BlendState.AlphaBlend, SamplerState.LinearClamp, DepthStencilState.Default, RasterizerState.CullNone, null, Main.Transform);
flag = true;
}
value.Draw(spriteBatch);
}
}
}
if (flag)
{
spriteBatch.End();
}
}
public void Draw(SpriteBatch spriteBatch, RenderLayers layer)
{
if (this._overlayCount == 0)
{
return;
}
bool flag = false;
for (int index = 0; index < this._activeOverlays.Length; ++index)
{
for (LinkedListNode <Overlay> linkedListNode = this._activeOverlays[index].First; linkedListNode != null; linkedListNode = linkedListNode.Next)
{
Overlay overlay = linkedListNode.Value;
if (overlay.Layer == layer && overlay.IsVisible())
{
if (!flag)
{
spriteBatch.Begin((SpriteSortMode)1, (BlendState)BlendState.AlphaBlend, (SamplerState)SamplerState.LinearClamp, (DepthStencilState)DepthStencilState.Default, (RasterizerState)RasterizerState.CullNone, (Effect)null, Main.Transform);
flag = true;
}
overlay.Draw(spriteBatch);
}
}
}
if (!flag)
{
return;
}
spriteBatch.End();
}
public void Draw(SpriteBatch spriteBatch, RenderLayers layer)
{
// padding area of 5 for draws
Rectangle area = GetScreenArea(5);
for (int x = area.Left; x <= area.Right; x++)
{
for (int y = area.Top; y <= area.Bottom; y++)
{
CoverData data = GetData(x, y);
// don't do anything
if (data.Orientation == 0)
{
continue;
}
if (_coveringTypes[data.Type].Layer != layer)
{
continue;
}
_coveringTypes[data.Type].Draw(spriteBatch, x, y, data.Variation, data.Orientation);
}
}
}
public Cell(float x, float y, Texture2D texture, RenderLayers layer, Color?tint)
{
Position = new Vector2(x, y);
Texture = texture;
Layer = layer;
Tint = tint.HasValue ? tint.GetValueOrDefault() : Color.White;
GameLoopFunctions.Renderable.Add(this);
}
public Button(Texture2D disabled, Texture2D shown, Texture2D clicked, Rectangle position, Color?tint, RenderLayers layer = RenderLayers.FrontSpriteLayer)
{
textures[0] = disabled;
textures[1] = shown;
textures[2] = clicked;
Position = position;
Tint = tint.GetValueOrDefault();
Layer = layer;
}
public SimpleOverlay(
string textureName,
string shaderName = "Default",
EffectPriority priority = EffectPriority.VeryLow,
RenderLayers layer = RenderLayers.All)
: base(priority, layer)
{
this._texture = (Asset <Texture2D>)Main.Assets.Request <Texture2D>(textureName == null ? "" : textureName, (AssetRequestMode)1);
this._shader = new ScreenShaderData(Main.ScreenShaderRef, shaderName);
}
public override void OnInitialize(Microsoft.DirectX.Direct3D.Device d)
{
ShowMouseCursor = true;
d.RenderState.Lighting = true;
d.RenderState.FillMode = FillMode.Solid;
d.RenderState.ZBufferEnable = true;
d.RenderState.ShadeMode = ShadeMode.Phong;
d.RenderState.SpecularEnable = true;
d.RenderState.AntiAliasedLineEnable = true;
d.RenderState.MultiSampleAntiAlias = true;
d.RenderState.Ambient = Color.White;
d.Lights[0].Diffuse = Color.White;
d.Lights[0].Type = LightType.Directional;
d.Lights[0].Falloff = 132f;
d.Lights[0].InnerConeAngle = 10;
d.Lights[0].OuterConeAngle = 20;
d.Lights[0].Specular = Color.White;
d.Lights[0].Position = new Vector3(0, 0, -100);
d.Lights[0].Direction = new Vector3(0, 0, 1);
d.Lights[0].Update();
d.Lights[0].Enabled = true;
_Projection_ = Matrix.PerspectiveFovLH(.8f, (float)d.Viewport.Width / (float)d.Viewport.Height, 1.0f, 100.0f);
_View_ = Matrix.LookAtLH(new Vector3(0, 0, -4f), new Vector3(0, 0, 0), new Vector3(0, 1, 0));
selected_material.Diffuse = Color.Yellow;
selected_material.Specular = Color.White;
selected_material.SpecularSharpness = 32f;
teapot_material.Diffuse = Color.DodgerBlue;
teapot_material.Specular = Color.White;
teapot_material.SpecularSharpness = 32f;
font = new Microsoft.DirectX.Direct3D.Font(d, new System.Drawing.Font("Arial", 12));
teapot = Mesh.Teapot(d);
_Line_ = new Microsoft.DirectX.Direct3D.Line(d);
RenderLayers.Add(new RenderableLayer(this.Layer1));
RenderLayers.Add(new RenderableLayer(this.Layer2));
/* Remember to set the appropriate State, or risk being stuck in INIT
* forever. To begin rendering set the scene state to RENDER.
* */
State = SceneState.RENDER;
}
public override void Initialise()
{
base.Initialise();
//Setup the render as a forward renderer
Renderer = new RendererForward();
//Load a scene
Scene = new DummyScene();
// Load the shaders from disk
Shader = new Shader(GraphicsDevice, "ShaderTest0");
var cubeShader = new Shader(GraphicsDevice, "Cube");
// Define the model's vertices and indices
VertexPositionColor[] quadVertices =
{
new VertexPositionColor(new Vector2(-.75f, .75f), Color.Red),
new VertexPositionColor(new Vector2(.75f, .75f), Color.Green),
new VertexPositionColor(new Vector2(-.75f, -.75f), Color.Blue),
new VertexPositionColor(new Vector2(.75f, -.75f), Color.Yellow)
};
ushort[] quadIndices = { 0, 1, 2, 3 };
//Create a vertex buffer
vertexBuffer = new VertexBuffer <VertexPositionColor>(
GraphicsDevice,
new VertexPositionColor(),
quadVertices.Length,
VertexPositionColor.SizeInBytes);
//Set the data of the vertex buffer to the vertices
vertexBuffer.SetData(0, quadVertices);
//Create an index buffer
indexBuffer = new IndexBuffer(
GraphicsDevice,
quadIndices.Length,
IndexFormat.UInt16);
//Set the data of the index buffer to the indices
indexBuffer.SetData(0, quadIndices);
// Register the ImGUI Layer
RenderLayers.Add(new ImGUILayer(GraphicsDevice));
// Init RenderDoc
// RenderDoc.LaunchReplayUI();
}
public override void DrawAtLayer(SpriteBatch spriteBatch, RenderLayers layer, bool beginSB)
{
if (layer == RenderLayers.All)
{
if (beginSB)
{
spriteBatch.Begin();
}
spriteBatch.Draw(Main.blackTileTexture, new Rectangle(0, 0, Main.screenWidth, Main.screenHeight), null, _color * _opacity.Ease(_currentTime));
if (beginSB)
{
spriteBatch.End();
}
}
}
public override void DrawAtLayer(SpriteBatch spriteBatch, RenderLayers layer, bool beginSB)
{
// draw beacon overlay and particles
if (layer == RenderLayers.TilesAndNPCs)
{
if (beginSB)
{
spriteBatch.Begin();
}
spriteBatch.Draw(SpiritMod.Instance.GetTexture("Textures/Events/BeaconOverlay"), _center - new Vector2(16f, 10f) - Main.screenPosition, Color.White * _overlayOpacity.Ease(_currentTime));
float overlayOpacity = 1.0f - _overlayOpacity.Ease(_currentTime);
if (_currentTime < BUILDUP_LENGTH + PAUSE_TIME * 0.5f)
{
for (int i = 0; i < _particles.Count; i++)
{
Vector2 scale = _particles[i].Size * new Vector2(0.0625f);
spriteBatch.Draw(Main.blackTileTexture, _particles[i].Position - Main.screenPosition, null, Color.White * _particles[i].Lifetime * _particles[i].Opacity * overlayOpacity, 0f, Vector2.Zero, scale, SpriteEffects.None, 0f);
}
}
if (beginSB)
{
spriteBatch.End();
}
}
// draw screen flash
if (layer == RenderLayers.All)
{
if (beginSB)
{
spriteBatch.Begin();
}
spriteBatch.Draw(Main.blackTileTexture, new Rectangle(0, 0, Main.screenWidth, Main.screenHeight), null, Color.White * _flashOpacity.Ease(_currentTime));
if (beginSB)
{
spriteBatch.End();
}
}
}
#pragma warning restore CC0074 // Make field readonly
public static void DrawTexture(SpriteBatch spriteBatch, Texture2D texture, Vector2 cell, RenderLayers layer, Color tint)
{
spriteBatch.Draw(texture, cell, null, null, null, 0.0f, Vector2.One, tint, SpriteEffects.None, Layers[(int)layer]);
}
public virtual void DrawAtLayer(SpriteBatch spriteBatch, RenderLayers layer, bool beginSB)
{
}
public CoveringOverlay(EffectPriority priority, RenderLayers layer) : base(priority, layer)
{
}
public AshstormOverlay(EffectPriority priority = 0, RenderLayers layer = RenderLayers.TilesAndNPCs) : base(priority, layer)
{
_ashes = new Ash[1000];
}
public override void OnInitialize(Microsoft.DirectX.Direct3D.Device d)
{
RenderLayers.Add(new RenderableLayer(this.Layer1));
State = SceneState.RENDER;
}
/// <summary>
/// Adds a layer filter for rendering meshes only on the specified layer.
/// </summary>
/// <param name="modelRenderer">The model renderer.</param>
/// <param name="activelayers">The activelayers.</param>
/// <returns>ModelRenderer.</returns>
public static ModelRenderer AddLayerFilter(this ModelRenderer modelRenderer, RenderLayers activelayers)
{
modelRenderer.AcceptRenderMesh.Add((context, renderMesh) => (renderMesh.Parameters.Get(RenderingParameters.RenderLayer) & activelayers) != RenderLayers.RenderLayerNone);
modelRenderer.AppendDebugName("Layer " + activelayers);
return(modelRenderer);
}
public static void DrawTexture(SpriteBatch spriteBatch, Texture2D texture, Rectangle cell, RenderLayers layer, Color tint)
{
spriteBatch.Draw(texture, destinationRectangle: cell, layerDepth: Layers[(int)layer], color: tint);
}
public SimpleOverlay(string textureName, ScreenShaderData shader, EffectPriority priority = EffectPriority.VeryLow, RenderLayers layer = RenderLayers.All)
: base(priority, layer)
{
_texture = Main.Assets.Request <Texture2D>((textureName == null) ? "" : textureName, Main.content, (AssetRequestMode)1);
_shader = shader;
}
public override void Update(double timestep)
{
if (inputStore.WasPressed(Keys.F2))
{
enabledLayers ^= RenderLayers.Normal;
}
if (inputStore.WasPressed(Keys.F3))
{
enabledLayers ^= RenderLayers.Debug;
}
if (inputStore.WasPressed(Keys.F4))
{
enabledLayers ^= RenderLayers.Collision;
}
if (inputStore.WasPressed(Keys.F5))
{
enabledLayers ^= RenderLayers.Scripting;
}
var entities = this.world.Scene.Entities.Values;
foreach (var entity in entities)
{
var rootTransform = Matrix4x4.Identity;
if (entity.TryGetChild <TransformComponent>(out var transform))
{
rootTransform = transform.TransformationMatrix;
}
var renderModels = entity.GetChildren <RenderModelComponent>();
for (int j = 0; j < renderModels.Length; j++)
{
var renderModel = renderModels[j];
if ((renderModel.RenderModel.RenderLayer & this.enabledLayers) == 0)
{
continue;
}
var localTransform = renderModel.RenderModel.CreateTransformationMatrix();
var finalTransform = Matrix4x4.Multiply(localTransform, rootTransform);
if (renderModel.DrawCommands == null)
{
graphics.UploadModel(renderModel.RenderModel, out var commands);
renderModel.UpdateDrawCommands(commands);
}
// BUG: If a model should be rendered by multiple shaders, (ie diffuse + wireframe) we'll need to
// submit a draw group with unique draw command instances per shader. This is because the
// shader uniform handle is stored on the draw commands. Alternatively, we could perhaps
// move the shader uniform handle to the draw group and submit same commands with different
// wrapping DrawGroup instances
// If we get rid of rendering a single item in multiple shaders, this wouldn't be a problem
DrawGroup group = new DrawGroup()
{
DrawCommands = renderModel.DrawCommands,
Transform = finalTransform,
Flags = renderModel.RenderModel.Flags
};
renderList.Add(group);
}
if (entity.TryGetChild <PointLightEmitterComponent>(out var pointLight))
{
renderList.Add(new PointLight()
{
Position = pointLight.Light.Position + rootTransform.Translation,
Color = pointLight.Light.Color,
Radius = pointLight.Light.Radius
});
}
}
}
public AuroraOverlay(EffectPriority priority = EffectPriority.High, RenderLayers layer = RenderLayers.Sky) : base(priority, layer)
{
}
public Entity(float x, float y, Texture2D texture, RenderLayers layer, Color?tint) : base(x, y, texture, layer, tint)
{
GameLoopFunctions.Updatable.Add(this);
}
public static void Main(string[] args)
{
//// ***********************************************************
//// GroupDocs.Viewer Cloud API Examples
//// ***********************************************************
//TODO: Get your Client Id and Client Secret at https://dashboard.groupdocs.cloud (free registration is required).
Constants.MyClientId = "XXXX-XXXX-XXXX-XXXX";
Constants.MyClientSecret = "XXXXXXXXXXXXXXXX";
Constants.MyStorage = "First Storage";
// Uploading sample test files from local disk to cloud storage
Constants.UploadSampleTestFiles();
#region Basic usage
GetSupportedFormats.Run();
GetDocumentInformation.Run();
GetAttachments.Run();
HtmlViewerExcludeFonts.Run();
HtmlViewerMinifyHtml.Run();
HtmlViewerResponsiveLayout.Run();
ImageViewerAddTextOverlay.Run();
ImageViewerAdjustImageSize.Run();
ImageViewerAdjustJpgQuality.Run();
ImageViewerGetTextCoordinates.Run();
PdfViewerAdjustJpgQuality.Run();
PdfViewerProtectPdf.Run();
#endregion
#region AdvancedUsage
ViewProtectedDocument.Run();
SpecifyEncoding.Run();
RenderWithCustomFonts.Run();
AddWatermark.Run();
RenderComments.Run();
RenderNotes.Run();
RenderHiddenPages.Run();
RenderConsecutivePages.Run();
RenderSelectedPages.Run();
ReplaceMissingFont.Run();
ReorderPages.Run();
FlipRotatePages.Run();
GetInfoForArchiveFile.Run();
RenderArchiveFolder.Run();
AdjustOutputImageSize.Run();
GetInfoForCadDrawing.Run();
RenderAllLayouts.Run();
RenderLayers.Run();
RenderSingleLayout.Run();
SplitIntoTiles.Run();
AdjustPageSize.Run();
RenameEmailFields.Run();
GetInfoForProjectFile.Run();
AdjustTimeUnit.Run();
RenderTimeInterval.Run();
GetInfoForOutlookDataFile.Run();
LimitCountOfItemsToRender.Run();
RenderFolder.Run();
FilterMessages.Run();
AdjustImageQuality.Run();
DisableCharsGrouping.Run();
EnableFontHinting.Run();
EnableLayeredRendering.Run();
GetInfoForPdfFile.Run();
RenderOriginalPageSize.Run();
AdjustTextOverflowInCells.Run();
RenderSpreadsheetWithGridLines.Run();
RenderHiddenColumnsAndRows.Run();
RenderPrintAreas.Run();
SkipRenderingOfEmptyColumns.Run();
SkipRenderingOfEmptyRows.Run();
SplitWorksheetsIntoPages.Run();
RenderTrackedChanges.Run();
SpecifyMaxCharsAndRows.Run();
RenderVisioDocumentFigures.Run();
FilterMailStorage.Run();
HtmlViewerLimitImageSize.Run();
HtmlViewerOptimizeForPrinting.Run();
#endregion
Console.WriteLine("Completed!");
Console.ReadKey();
}
public Overlay(EffectPriority priority, RenderLayers layer)
{
this._priority = priority;
this._layer = layer;
}
////////////////
public CustomEntityOverlay(EffectPriority priority = EffectPriority.VeryHigh, RenderLayers layer = RenderLayers.Walls)
: base(priority, layer)
{
}
