protected override void OnRenderCore(DrawingContext dc, RenderState state)
{
if (DataSource == null) return;
var transform = Plotter2D.Viewport.Transform;
Rect bounds = Rect.Empty;
using (IPointEnumerator enumerator = DataSource.GetEnumerator(GetContext()))
{
Point point = new Point();
while (enumerator.MoveNext())
{
enumerator.GetCurrent(ref point);
enumerator.ApplyMappings(this);
Point zero = new Point(point.X, 0);
Point screenPoint = point.DataToScreen(transform);
Point screenZero = zero.DataToScreen(transform);
double height = screenPoint.Y = screenZero.Y;
height = (height >= 0) ? height : -height;
dc.DrawRectangle(Fill, new Pen(Stroke, StrokeThickness),
new Rect(screenPoint.X - BarWidth / 2, screenZero.Y, BarWidth, height));
bounds = Rect.Union(bounds, point);
}
}
ContentBounds = bounds;
}
public void StartEffect(string text, float duration)
{
_renderState = RenderState.Rendering;
_sequense = null;
_sequense = DOTween.Sequence();
_animation = _textUI.DOText(text, duration);
_sequense.Append(_animation);
_sequense.AppendCallback(new TweenCallback(FinishDisplay));
}
/// <summary>
/// Renders the control</summary>
/// <param name="action">Render action</param>
/// <param name="camera">Camera</param>
/// <param name="state">Render state</param>
/// <param name="transform">Transform</param>
public void Render(IRenderAction action, Camera camera, RenderState state, Matrix4F transform)
{
float s1, s2, s3;
// apply xform
Gl.glPushMatrix();
Util3D.glMultMatrixf(transform);
CalcAxisLengths(camera, transform, out s1, out s2, out s3);
bool drawX, drawY, drawZ;
DecideArrowDrawing(transform, camera, out drawX, out drawY, out drawZ);
if (drawX)
{
RenderXArrow(s1);
RenderXAxis(s1);
}
if (drawY)
{
RenderYArrow(s2);
RenderYAxis(s2);
}
if (drawZ)
{
RenderZArrow(s3);
RenderZAxis(s3);
}
RenderXYSquare(s1 * SquareLength, s2 * SquareLength, true);
RenderYZSquare(s2 * SquareLength, s3 * SquareLength, true);
RenderXZSquare(s1 * SquareLength, s3 * SquareLength, true);
Gl.glPopMatrix();
}
public Renderer(GraphicsDevice device, RenderState renderState)
{
RenderState = renderState;
Device = device;
_effect = new BasicEffect(Device);
_bufferedInstructions = new List<IEnumerable<RenderInstruction>>();
}
/// <summary>
/// The method that is passed to the BitmapContext for rendering the image using OpenGl</summary>
private void Paint()
{
// Setup render state. Copied from RenderCommands.DoCommand()'s RenderSmooth.
RenderState rs = new RenderState();
rs.RenderMode =
RenderMode.Smooth |
RenderMode.SolidColor |
RenderMode.Lit |
RenderMode.CullBackFace |
RenderMode.Textured;
rs.SolidColor = new Vec4F(1, 1, 1, 1);
m_scene.StateStack.Push(rs);
// Change some settings related to printing information text. We don't want it.
string originalTitle = m_action.Title;
m_action.Title = string.Empty;
bool originalStatsEnabled = Util3D.RenderStats.Enabled;
Util3D.RenderStats.Enabled = false;
// Dispatch the scene
m_action.Dispatch(m_scene, m_camera);
// Restore some settings.
m_action.Title = originalTitle;
Util3D.RenderStats.Enabled = originalStatsEnabled;
}
protected override void PreRenderCode(RenderState state)
{
if (ShowMeasure)
AddMeasure();
IsGrey = true;
base.PreRenderCode(state);
}
public GraphicsDevice()
{
BitmapCacheEnabled = true;
RenderAtScale = 1;
RenderState = new RenderState();
PresentationParameters = new PresentationParameters();
PresentationParameters.BackBufferFormat = SurfaceFormat.Canvas;
}
/// <summary>
/// Constructor</summary>
/// <param name="renderObject">RenderObject. A reference is held to this, so that IRenderObject.Dispatch
/// can be called.</param>
/// <param name="transform">Transform to use when dispatching the RenderObject; a reference is held</param>
/// <param name="graphPath">Graph path leading to RenderObject; a reference is held</param>
/// <param name="renderState">RenderState to use for RenderObject; is copied</param>
public TraverseNode(
IRenderObject renderObject,
Matrix4F transform,
Stack<SceneNode> graphPath,
RenderState renderState)
{
Init(renderObject, transform, graphPath, renderState);
}
public void SetTemporaryRenderState(RenderState renderState, int value)
{
int oldState = _device.GetRenderState(renderState);
if (oldState.Equals(value))
return;
_changedStates[renderState] = oldState;
_device.SetRenderState(renderState, value);
}
public TextureBaker(GraphicsDevice graphicsDevice, int width, int height, RenderState state)
: base(graphicsDevice)
{
_renderTarget = new RenderTarget2D(GraphicsDevice, width, height);
GraphicsDevice.SetRenderTarget(_renderTarget);
GraphicsDevice.Clear(Color.Transparent);
Begin(SpriteSortMode.Immediate, BlendState.Opaque);
SetState(state);
}
public async Task<Errorable<bool>> ProcessCustomElement(string elementName, RenderState state)
{
if (elementName != "cms-scheduled") return false;
var err = await processScheduledElement(state).ConfigureAwait(continueOnCapturedContext: false);
if (err.HasErrors) return err.Errors;
return true;
}
public FontStyle( string fontName )
{
Font = _UI.Font.Get( fontName );
RenderState = new RenderState( (int)E_Effect.IntensityAsAlpha_PMA, E_BlendState.AlphaBlend );
TrackingPercentage = 0.0f;
HeightPercentage = 1.0f;
RenderPasses = new List< FontStyleRenderPass >();
}
// Init
public void Init()
{
Texture.TextureIndex = 0;
Texture.PUV = new Vector2( 0.0f );
Texture.SUV = new Vector2( 1.0f );
Color = 0xffffffff;
AspectRatio = 1.0f;
Scale = 1.0f;
RenderState = new RenderState( (int)E_Effect.MultiTexture1, E_BlendState.AlphaBlend );
LayerOffset = 0;
}
/// <summary>
/// Initializes instance</summary>
/// <param name="renderObject">RenderObject. A reference is held to this, so that IRenderObject.Dispatch
/// can be called.</param>
/// <param name="transform">Transform to use when dispatching the RenderObject; a reference is held</param>
/// <param name="graphPath">Graph path leading to RenderObject; a reference is held</param>
/// <param name="renderState">RenderState to use for RenderObject; is copied</param>
public void Init(
IRenderObject renderObject,
Matrix4F transform,
Stack<SceneNode> graphPath,
RenderState renderState)
{
m_renderObject = renderObject;
m_transform = transform;
m_renderState.Init(renderState);
m_graphPath = graphPath.ToArray();//faster to create every time than to cache!
}
private static bool RenderStatesDiffer(RenderState oldRenderState, RenderState newRenderState, RenderMode flag)
{
bool oldRenderStateNull = (oldRenderState == null);
bool newFlag = ((newRenderState.RenderMode & flag) != 0);
if (oldRenderStateNull)
return true;
bool oldFlag = ((oldRenderState.RenderMode & flag) != 0);
return oldFlag != newFlag;
}
protected override void PreRenderModule(RenderState state)
{
base.PreRenderModule(state);
if (!ShowModuleShading)
return;
if (IsGrey)
{
Canvas.FillRectangle(Brushes.Gray, state.Location.X, Settings.TopMargin, (state.CurrentPattern.WideCount * Settings.WideWidth) + (state.CurrentPattern.NarrowCount * Settings.NarrowWidth), Canvas.VisibleClipBounds.Height);
}
IsGrey = !IsGrey;
}
protected internal void Render(RenderState state)
{
for(int i=0;i<subBatchs.Count;i++)
subBatchs[i].Render(state);
Graphics.device.SetRenderTarget(backbuffer);
state.spriteBatch.Begin(SpriteSortMode.BackToFront, BlendState.AlphaBlend);
for (int i = 0; i < drawCalls.Count; i++)
drawCalls[i].Render(state);
state.spriteBatch.End();
drawCalls.Clear();
subBatchs.Clear();
}
private static void CommitSmooth(RenderState renderState, RenderState previousRenderState)
{
if ((renderState.RenderMode & RenderMode.Smooth) != 0)
{
if (RenderStatesDiffer(previousRenderState, renderState, RenderMode.Smooth))
{
Gl.glShadeModel(Gl.GL_SMOOTH);
Gl.glPolygonMode(Gl.GL_FRONT_AND_BACK, Gl.GL_FILL);
Util3D.RenderStats.RenderStateChanges++;
//Console.WriteLine("CommitSmooth");
}
Vec4F color = renderState.SolidColor;
Gl.glColor4f(color.X, color.Y, color.Z, color.W);
}
}
public void Setup(Mashup mashup, MapTileSourceFactory mapTileSourceFactory, RenderProgressPanel2.LaunchRenderedBrowserDelegate launchRenderedBrowser, RenderState.FlushRenderedTileCachePackageDelegate flushRenderedTileCachePackage)
{
this.flushRenderedTileCachePackage = flushRenderedTileCachePackage;
this.ReplacePreviewImage(null);
if (this.mashup != null)
{
this.mashup.dirtyEvent.Remove(new DirtyListener(this.MashupChangedHandler));
}
this.mashup = mashup;
this.mapTileSourceFactory = mapTileSourceFactory;
this.launchRenderedBrowser = launchRenderedBrowser;
if (this.mashup != null)
{
this.mashup.dirtyEvent.Add(new DirtyListener(this.MashupChangedHandler));
}
this.MashupChangedHandler();
}
/// <summary>
/// Renders a renderable components and applies its required renderstate if necessary.
/// </summary>
void Render(ICamera camera, RenderComponent renderable) {
RenderState desiredState = renderable.RenderState;
if (desiredState != null) {
if (_currentlyEnabledState != desiredState) {
if (_currentlyEnabledState != null) {
_currentlyEnabledState(false);
}
desiredState(true);
_currentlyEnabledState = desiredState;
}
}
renderable.Render(camera);
}
/// <summary>
/// LoadContent will be called once per game and is the place to load
/// all of your content.
/// </summary>
public void LoadContent()
{
// Create a new SpriteBatch, which can be used to draw textures.
_spriteBatch = new SpriteBatch(_gdm.GraphicsDevice);
RenderState renderState = new RenderState(_spriteBatch.GetScreenDimensions());
_renderer = new Renderer(_gdm.GraphicsDevice, renderState);
_mouseCursorTexture = _content.Load<Texture2D>("cursor");
_logFont = _content.Load<SpriteFont>("LogFont");
LoadFile("../../gamedata.haumea");
foreach (IView view in _views)
{
view.LoadContent(_content);
}
}
private static void ForceApplyRenderState(RenderState renderState)
{
Enable(EnableCap.PrimitiveRestart, renderState.PrimitiveRestart.Enabled);
GL.PrimitiveRestartIndex(renderState.PrimitiveRestart.Index);
Enable(EnableCap.CullFace, renderState.FacetCulling.Enabled);
GL.CullFace(TypeConverterGL3x.To(renderState.FacetCulling.Face));
GL.FrontFace(TypeConverterGL3x.To(renderState.FacetCulling.FrontFaceWindingOrder));
Enable(EnableCap.ProgramPointSize, renderState.ProgramPointSize == ProgramPointSize.Enabled);
GL.PolygonMode(MaterialFace.FrontAndBack, TypeConverterGL3x.To(renderState.RasterizationMode));
Enable(EnableCap.ScissorTest, renderState.ScissorTest.Enabled);
Rectangle rectangle = renderState.ScissorTest.Rectangle;
GL.Scissor(rectangle.Left, rectangle.Bottom, rectangle.Width, rectangle.Height);
Enable(EnableCap.StencilTest, renderState.StencilTest.Enabled);
ForceApplyRenderStateStencil(StencilFace.Front, renderState.StencilTest.FrontFace);
ForceApplyRenderStateStencil(StencilFace.Back, renderState.StencilTest.BackFace);
Enable(EnableCap.DepthTest, renderState.DepthTest.Enabled);
GL.DepthFunc(TypeConverterGL3x.To(renderState.DepthTest.Function));
GL.DepthRange(renderState.DepthRange.Near, renderState.DepthRange.Far);
Enable(EnableCap.Blend, renderState.Blending.Enabled);
GL.BlendFuncSeparate(
TypeConverterGL3x.To(renderState.Blending.SourceRGBFactor),
TypeConverterGL3x.To(renderState.Blending.DestinationRGBFactor),
TypeConverterGL3x.To(renderState.Blending.SourceAlphaFactor),
TypeConverterGL3x.To(renderState.Blending.DestinationAlphaFactor));
GL.BlendEquationSeparate(
TypeConverterGL3x.To(renderState.Blending.RGBEquation),
TypeConverterGL3x.To(renderState.Blending.AlphaEquation));
GL.BlendColor(renderState.Blending.Color);
GL.DepthMask(renderState.DepthMask);
GL.ColorMask(renderState.ColorMask.Red, renderState.ColorMask.Green,
renderState.ColorMask.Blue, renderState.ColorMask.Alpha);
}
public override IEnumerable<GdiRenderObject> RenderSymbols(IEnumerable<Point2D> locations, Symbol2D symbol,
Symbol2D highlightSymbol, Symbol2D selectSymbol,
RenderState renderState)
{
if (renderState == RenderState.Selected) symbol = selectSymbol;
if (renderState == RenderState.Highlighted) symbol = highlightSymbol;
foreach (Point2D location in locations)
{
Bitmap bitmapSymbol = getSymbol(symbol);
if (bitmapSymbol.PixelFormat != PixelFormat.Undefined)
{
System.Drawing.Drawing2D.Matrix transform = ViewConverter.Convert(symbol.AffineTransform);
System.Drawing.Imaging.ColorMatrix colorTransform = ViewConverter.Convert(symbol.ColorTransform);
RectangleF bounds = new RectangleF(ViewConverter.Convert(location), bitmapSymbol.Size);
GdiRenderObject holder = new GdiRenderObject(bitmapSymbol, bounds, transform, colorTransform);
holder.State = renderState;
yield return holder;
}
else
Debug.WriteLine("Unkbown pixel format");
}
}
protected void Paint(Point location)
{
Canvas.ScaleTransform(Settings.Scale, Settings.Scale);
Canvas.Clear(Color.White);
var state = new RenderState(location);
PreRenderCode(state);
for (state.Index = 0; state.Index < Codes.Count; state.Index++)
{
state.CurrentPattern = Definition.GetPattern(Codes[state.Index]);
PreRenderModule(state);
var r = DrawPattern(state.CurrentPattern, state.Location);
if (r.Length > 0)
Canvas.FillRectangles(Brushes.Black, r);
PostRenderModule(state);
}
PostRenderCode();
PaintText();
}
/// <summary>
/// Renders all renderable components using the specified camera.
/// </summary>
public void Render(ICamera camera) {
lock (_renderables) {
_renderables.Sort(delegate(RenderComponent drawable, RenderComponent otherDrawable) {
return drawable.CompareTo(otherDrawable);
});
camera.Clear();
foreach (RenderComponent renderable in _renderables) {
if (renderable.IsHidden) {
continue;
}
Render(camera, renderable);
}
if (_currentlyEnabledState != null) {
_currentlyEnabledState(false);
_currentlyEnabledState = null;
}
}
}
public ContextGL3x(GameWindow gameWindow, int width, int height)
{
Vector4 clearColor = new Vector4();
GL.GetFloat(GetPName.DepthClearValue, out _clearDepth);
GL.GetInteger(GetPName.StencilClearValue, out _clearStencil);
GL.GetFloat(GetPName.ColorClearValue, out clearColor);
_clearColor = Color.FromArgb(
Convert.ToInt32(clearColor.W * 255.0),
Convert.ToInt32(clearColor.X * 255.0),
Convert.ToInt32(clearColor.Y * 255.0),
Convert.ToInt32(clearColor.Z * 255.0));
_renderState = new RenderState();
_textureUnits = new TextureUnitsGL3x();
//
// Sync GL state with default render state.
//
ForceApplyRenderState(_renderState);
Viewport = new Rectangle(0, 0, width, height);
_gameWindow = gameWindow;
}
private Task<Errorable> processDoctypeElement(RenderState st)
{
// <cms-doctype type="html" />
// generates
// <!DOCTYPE html>
var xr = st.Reader;
if (!xr.IsEmptyElement)
{
st.Error("cms-doctype must be an empty element");
st.SkipElementAndChildren("cms-doctype");
return Task.FromResult(Errorable.NoErrors);
}
if (!xr.MoveToAttribute("type"))
{
st.Error("cms-doctype must have a type attribute");
xr.MoveToElement();
return Task.FromResult(Errorable.NoErrors);
}
string type = xr.Value;
xr.MoveToElement();
if (type == "html")
{
// HTML5 doctype:
st.Writer.Append("<!DOCTYPE html>\r\n\r\n");
return Task.FromResult(Errorable.NoErrors);
}
else
{
st.Error("cms-doctype has unknown type value '{0}'", type);
return Task.FromResult(Errorable.NoErrors);
}
}
public Color GetArrowLineColor(RenderState state)
{
if ((state & (RenderState.Hover | RenderState.Dragging)) != 0)
{
if ((state & RenderState.Incompatible) != 0)
{
return Color.Red;
}
else
if ((state & RenderState.Compatible) != 0)
{
return Color.DarkOrange;
}
else
if ((state & RenderState.Dragging) != 0)
return Color.SteelBlue;
else
return Color.DarkOrange;
}
else
if ((state & RenderState.Incompatible) != 0)
{
return Color.Gray;
}
else
if ((state & RenderState.Compatible) != 0)
{
return Color.White;
}
else
if ((state & RenderState.Connected) != 0)
{
return Color.Black;
}
else
return Color.LightGray;
}
/// <summary>
/// Creates a new GdiRenderObject instance.
/// </summary>
/// <param name="path">The path to draw.</param>
/// <param name="fill">
/// The brush used to fill the path when the state is <see cref="RenderState.Normal"/>.
/// </param>
/// <param name="highlightFill">
/// The brush used to fill the path when the state is <see cref="RenderState.Highlighted"/>.
/// </param>
/// <param name="selectFill">
/// The brush used to fill the path when the state is <see cref="RenderState.Selected"/>.
/// </param>
/// <param name="line">
/// The pen used to draw a line when the state is <see cref="RenderState.Normal"/>.
/// </param>
/// <param name="highlightLine">
/// The pen used to draw a line when the state is <see cref="RenderState.Highlighted"/>.
/// </param>
/// <param name="selectLine">
/// The pen used to draw a line when the state is <see cref="RenderState.Selected"/>.
/// </param>
/// <param name="outline">
/// The pen used to outline the path when the state is <see cref="RenderState.Normal"/>.
/// </param>
/// <param name="highlightOutline">
/// The pen used to outline the path when the state is <see cref="RenderState.Highlighted"/>.
/// </param>
/// <param name="selectOutline">
/// The pen used to outline the path when the state is <see cref="RenderState.Selected"/>.
/// </param>
public GdiRenderObject(GraphicsPath path, Brush fill, Brush highlightFill, Brush selectFill,
Pen line, Pen highlightLine, Pen selectLine,
Pen outline, Pen highlightOutline, Pen selectOutline)
{
_state = RenderState.Normal;
GdiPath = path;
Fill = fill;
HighlightFill = highlightFill;
SelectFill = selectFill;
Line = line;
HighlightLine = highlightLine;
SelectLine = selectLine;
Outline = outline;
HighlightOutline = highlightOutline;
SelectOutline = selectOutline;
Image = null;
Bounds = RectangleF.Empty;
AffineTransform = null;
ColorTransform = null;
Text = null;
Font = null;
}
private static void CommitWire(RenderState renderState, RenderState previousRenderState)
{
if ((renderState.RenderMode & RenderMode.Wireframe) != 0)
{
if (RenderStatesDiffer(previousRenderState, renderState, RenderMode.Wireframe))
{
Gl.glDisable(Gl.GL_TEXTURE_2D);
Gl.glDisable(Gl.GL_CULL_FACE);
Gl.glPolygonMode(Gl.GL_FRONT_AND_BACK, Gl.GL_LINE);
Gl.glPolygonOffset(-1.0f, -1.0f);
Gl.glEnable(Gl.GL_POLYGON_OFFSET_LINE);
Util3D.RenderStats.RenderStateChanges++;
//Console.WriteLine("CommitWire");
}
Vec4F color = renderState.WireframeColor;
Gl.glColor4f(color.X, color.Y, color.Z, color.W);
bool makeGlCall = false;
if (previousRenderState == null)
makeGlCall = true;
else
{
bool previousRsWasSmooth = ((previousRenderState.RenderMode & RenderMode.Smooth) != 0);
bool previousRsHadDifferentThickness = (previousRenderState.LineThickness != renderState.LineThickness);
makeGlCall = previousRsWasSmooth || previousRsHadDifferentThickness;
}
if (makeGlCall)
Gl.glLineWidth(renderState.LineThickness);
}
}
public string GetLegendFilename(Legend legend)
{
return(RenderState.ForceValidFilename(string.Format("{0}_{1}.png",
GetDisplayName(),
legend.displayName)));
}
protected override void Draw(double elapsed)
{
Viewport.Replace(0, 0, Width, Height);
RenderState.ClearColor = new Color4(0.2f, 0.2f, 0.2f, 1f);
RenderState.ClearAll();
imGui.NewFrame(elapsed);
Renderer2D.Start(Width, Height);
Renderer2D.DrawString("Arial", 16, "Librelancer", new Vector2(8), Color4.Black);
Renderer2D.DrawString("Arial", 16, "Librelancer", new Vector2(6), Color4.White);
var startY = Renderer2D.LineHeight("Arial", 16) + 8;
Renderer2D.Finish();
ImGui.PushFont(ImGuiHelper.Noto);
var size = (Vector2)ImGui.GetIO().DisplaySize;
ImGui.SetNextWindowSize(new Vector2(size.X, size.Y - startY), ImGuiCond.Always);
ImGui.SetNextWindowPos(new Vector2(0, startY), ImGuiCond.Always, Vector2.Zero);
bool childopened = true;
ImGui.Begin("screen", ref childopened,
ImGuiWindowFlags.NoTitleBar |
ImGuiWindowFlags.NoSavedSettings |
ImGuiWindowFlags.NoBringToFrontOnFocus |
ImGuiWindowFlags.NoMove |
ImGuiWindowFlags.NoResize |
ImGuiWindowFlags.NoBackground);
if (ImGui.BeginPopupModal("Error", ref openError, ImGuiWindowFlags.AlwaysAutoResize))
{
ImGui.Text(errorText);
if (ImGui.Button("Ok"))
{
ImGui.CloseCurrentPopup();
}
ImGui.EndPopup();
}
ImGui.AlignTextToFramePadding();
ImGui.Text("Freelancer Directory: ");
ImGui.SameLine();
freelancerFolder.InputText("##folder", ImGuiInputTextFlags.None, 280);
ImGui.SameLine();
if (ImGui.Button("..."))
{
string newFolder;
if ((newFolder = FileDialog.ChooseFolder()) != null)
{
freelancerFolder.SetText(newFolder);
}
}
ImGui.AlignTextToFramePadding();
ImGui.Text("Resolution: ");
ImGui.SameLine();
ImGui.PushItemWidth(130);
ImGui.InputInt("##resX", ref resolutionX, 0, 0);
resolutionX = MathHelper.Clamp(resolutionX, 600, 16384);
ImGui.SameLine();
ImGui.Text("x");
ImGui.SameLine();
ImGui.InputInt("##resY", ref resolutionY, 0, 0);
resolutionY = MathHelper.Clamp(resolutionY, 400, 16384);
ImGui.PopItemWidth();
SoundSlider("Master Volume: ", ref masterVolume);
SoundSlider("Music Volume: ", ref musicVolume);
SoundSlider("Sfx Volume: ", ref sfxVolume);
ImGui.Checkbox("VSync", ref vsync);
if (Program.introForceDisable)
{
ImGui.Text("Intro Movies Disabled");
}
else
{
ImGui.Checkbox("Skip Intro Movies", ref skipIntroMovies);
}
ImGui.Dummy(new Vector2(16));
ImGui.Dummy(new Vector2(1));
ImGui.SameLine(ImGui.GetWindowWidth() - 70);
if (ImGui.Button("Launch"))
{
LaunchClicked();
}
ImGui.End();
ImGui.PopFont();
imGui.Render(RenderState);
}
public void Bind(RenderState renderState)
{
RenderState = renderState;
HandleBind();
}
public override IEnumerable <RenderObject> RenderSymbols(IEnumerable <Point2D> locations, Symbol2D symbolData,
Symbol2D highlightSymbolData,
Symbol2D selectSymbolData, RenderState renderState)
{
foreach (Point2D point in locations)
{
RenderObject ro = new RenderObject();
ro.RenderedPaths = new Double[][] { new Double[] { point.X, point.Y } };
yield return(ro);
}
}
/// <summary>
/// Notifies that rendering of the plain part has finished.
/// </summary>
/// <param name="renderState">The current render state.</param>
/// <param name="passID">The ID of the current pass (starting with 0)</param>
internal override void NotifyAfterRenderPlain(RenderState renderState, int passID)
{
// Nothing to be done here
}
/// <summary>
/// Do a command</summary>
/// <param name="commandTag">Command</param>
public void DoCommand(object commandTag)
{
if (commandTag is Command)
{
DesignControl control = m_renderView.ViewControl;
switch ((Command)commandTag)
{
case Command.Fit:
m_renderView.Fit();
break;
case Command.RenderSmooth:
control.RenderState.RenderMode &= ~RenderMode.Wireframe;
control.RenderState.RenderMode |= (RenderMode.Smooth | RenderMode.SolidColor |
RenderMode.Lit | RenderMode.CullBackFace | RenderMode.Textured);
control.Invalidate();
break;
case Command.RenderWireFrame:
control.RenderState.RenderMode |= (RenderMode.Wireframe | RenderMode.WireframeColor);
control.RenderState.RenderMode &= ~(RenderMode.Smooth | RenderMode.SolidColor |
RenderMode.Lit | RenderMode.Textured | RenderMode.CullBackFace);
control.Invalidate();
break;
case Command.RenderOutlined:
control.RenderState.RenderMode |= (RenderMode.Wireframe | RenderMode.Smooth |
RenderMode.Lit | RenderMode.WireframeColor | RenderMode.SolidColor |
RenderMode.CullBackFace | RenderMode.Textured);
control.Invalidate();
break;
case Command.RenderTextured:
control.RenderState.RenderMode ^= RenderMode.Textured;
control.Invalidate();
break;
case Command.RenderLight:
control.RenderState.RenderMode ^= RenderMode.Lit;
control.Invalidate();
break;
case Command.RenderBackFace:
control.RenderState.RenderMode ^= RenderMode.CullBackFace;
control.Invalidate();
break;
case Command.RenderCycle:
RenderState renderState = control.RenderState;
if ((renderState.RenderMode & RenderMode.Smooth) != 0 &&
(renderState.RenderMode & RenderMode.Wireframe) != 0)
{
// outlined -> smooth
goto case Command.RenderSmooth;
}
else if ((renderState.RenderMode & RenderMode.Smooth) != 0)
{
// smooth -> wireframe
goto case Command.RenderWireFrame;
}
else
{
// wireframe -> outlined
goto case Command.RenderOutlined;
}
}
}
}
public void LoadRenderState(RenderState renderState)
{
activeRenderState = renderState;
stPropertyGrid1.LoadProperty(renderState, OnPropertyChanged);
}
unsafe void RenderImDrawData(ImDrawDataPtr draw_data, RenderState rstate)
{
var io = ImGui.GetIO();
//Set cursor
var cur = ImGuiNative.igGetMouseCursor();
switch (cur)
{
case ImGuiMouseCursor.Arrow:
game.CursorKind = CursorKind.Arrow;
break;
case ImGuiMouseCursor.ResizeAll:
game.CursorKind = CursorKind.Move;
break;
case ImGuiMouseCursor.TextInput:
game.CursorKind = CursorKind.TextInput;
break;
case ImGuiMouseCursor.ResizeNS:
game.CursorKind = CursorKind.ResizeNS;
break;
case ImGuiMouseCursor.ResizeNESW:
game.CursorKind = CursorKind.ResizeNESW;
break;
case ImGuiMouseCursor.ResizeNWSE:
game.CursorKind = CursorKind.ResizeNWSE;
break;
}
//Render
draw_data.ScaleClipRects(io.DisplayFramebufferScale);
var mat = Matrix4.CreateOrthographicOffCenter(0, game.Width, game.Height, 0, 0, 1);
Shader lastShader = textShader;
textShader.SetMatrix(textShader.GetLocation("modelviewproj"), ref mat);
textShader.SetInteger(textShader.GetLocation("tex"), 0);
colorShader.SetMatrix(textShader.GetLocation("modelviewproj"), ref mat);
colorShader.SetInteger(textShader.GetLocation("tex"), 0);
textShader.UseProgram();
rstate.Cull = false;
rstate.BlendMode = BlendMode.Normal;
rstate.DepthEnabled = false;
for (int n = 0; n < draw_data.CmdListsCount; n++)
{
var cmd_list = draw_data.CmdListsRange[n];
byte * vtx_buffer = (byte *)cmd_list.VtxBuffer.Data;
ushort *idx_buffer = (ushort *)cmd_list.IdxBuffer.Data;
var vtxCount = cmd_list.VtxBuffer.Size;
var idxCount = cmd_list.IdxBuffer.Size;
if (vboSize < vtxCount || iboSize < idxCount)
{
if (vbo != null)
{
vbo.Dispose();
}
if (ibo != null)
{
ibo.Dispose();
}
vboSize = Math.Max(vboSize, vtxCount);
iboSize = Math.Max(iboSize, idxCount);
vbo = new VertexBuffer(typeof(Vertex2D), vboSize, true);
ibo = new ElementBuffer(iboSize, true);
vbo.SetElementBuffer(ibo);
vbuffer = new Vertex2D[vboSize];
ibuffer = new ushort[iboSize];
}
for (int i = 0; i < cmd_list.IdxBuffer.Size; i++)
{
ibuffer[i] = idx_buffer[i];
}
for (int i = 0; i < cmd_list.VtxBuffer.Size; i++)
{
var ptr = (ImDrawVert *)vtx_buffer;
var unint = ptr[i].col;
var a = unint >> 24 & 0xFF;
var b = unint >> 16 & 0xFF;
var g = unint >> 8 & 0xFF;
var r = unint & 0xFF;
vbuffer[i] = new Vertex2D(ptr[i].pos, ptr[i].uv, new Color4(r / 255f, g / 255f, b / 255f, a / 255f));
}
vbo.SetData(vbuffer, cmd_list.VtxBuffer.Size);
ibo.SetData(ibuffer, cmd_list.IdxBuffer.Size);
int startIndex = 0;
for (int cmd_i = 0; cmd_i < cmd_list.CmdBuffer.Size; cmd_i++)
{
var pcmd = cmd_list.CmdBuffer[cmd_i];
//TODO: Do something with pcmd->UserCallback ??
var tid = pcmd.TextureId.ToInt32();
Texture2D tex;
if (tid == FONT_TEXTURE_ID)
{
if (lastShader != textShader)
{
textShader.UseProgram();
lastShader = textShader;
}
fontTexture.BindTo(0);
}
else if (textures.TryGetValue(tid, out tex))
{
if (lastShader != colorShader)
{
colorShader.UseProgram();
lastShader = colorShader;
}
tex.BindTo(0);
}
else
{
dot.BindTo(0);
}
GL.Enable(GL.GL_SCISSOR_TEST);
GL.Scissor(
(int)pcmd.ClipRect.X,
(int)(io.DisplaySize.Y - pcmd.ClipRect.W),
(int)(pcmd.ClipRect.Z - pcmd.ClipRect.X),
(int)(pcmd.ClipRect.W - pcmd.ClipRect.Y));
vbo.Draw(PrimitiveTypes.TriangleList, 0, startIndex, (int)pcmd.ElemCount / 3);
GL.Disable(GL.GL_SCISSOR_TEST);
startIndex += (int)pcmd.ElemCount;
}
}
}
/// <summary>
/// Updates all parameters.
/// </summary>
internal void UpdateValues(RenderState renderState, CBPerView cbPerView)
{
m_cbPerView.SetData(renderState.Device.DeviceImmediateContextD3D11, cbPerView);
}
public void Render(RenderState rstate)
{
ImGui.Render();
RenderImDrawData(ImGui.GetDrawData(), rstate);
}
internal string GetFilesystemName()
{
return(RenderState.ForceValidFilename(string.Format("Layer_{0}", displayName)));
}
public static void ReadRenderState(this FMAT m, RenderState renderState)
{
}
static TranslatorControl()
{
s_renderState = new RenderState();
s_renderState.RenderMode = RenderMode.Smooth | RenderMode.DisableZBuffer | RenderMode.Alpha;
}
public static void PushState(RenderState mask)
{
var state = AcquireState();
state.StateMask = mask;
if ((mask & RenderState.Viewport) != 0)
{
state.Viewport = Viewport;
}
if ((mask & RenderState.Transform1) != 0)
{
state.Transform1 = Transform1;
}
if ((mask & RenderState.Transform2) != 0)
{
state.Transform2 = Transform2;
}
if ((mask & RenderState.Blending) != 0)
{
state.Blending = Blending;
}
if ((mask & RenderState.Shader) != 0)
{
state.Shader = Shader;
}
if ((mask & RenderState.ColorWriteEnabled) != 0)
{
state.ColorWriteEnabled = ColorWriteEnabled;
}
if ((mask & RenderState.CullMode) != 0)
{
state.CullMode = CullMode;
}
if ((mask & RenderState.DepthState) != 0)
{
state.DepthState = DepthState;
}
if ((mask & RenderState.ScissorState) != 0)
{
state.ScissorState = ScissorState;
}
if ((mask & RenderState.StencilState) != 0)
{
state.StencilState = StencilState;
}
if ((mask & RenderState.ColorFactor) != 0)
{
state.ColorFactor = ColorFactor;
}
if ((mask & RenderState.World) != 0)
{
state.World = World;
}
if ((mask & RenderState.View) != 0)
{
state.View = View;
}
if ((mask & RenderState.Projection) != 0)
{
state.Projection = Projection;
}
stateStack.Push(state);
}
/// <summary>
/// Renders control for picking</summary>
/// <param name="action">Render action</param>
/// <param name="camera">Camera</param>
/// <param name="renderState">Render state</param>
/// <param name="transform">Transform, local to world</param>
public void RenderPick(IRenderAction action, Camera camera, RenderState renderState, Matrix4F transform)
{
action.RenderStateGuardian.Commit(renderState);
// apply xform
Gl.glPushMatrix();
Util3D.glMultMatrixf(transform);
float s1, s2, s3;
CalcAxisLengths(camera, transform, out s1, out s2, out s3);
float squareSideX = s1 * SquareLength;
float squareSideY = s2 * SquareLength;
float squareSideZ = s3 * SquareLength;
bool drawX, drawY, drawZ;
DecideArrowDrawing(transform, camera, out drawX, out drawY, out drawZ);
// Mark each axis with a different name.
// Since the OpenGl selection buffer does a bad job in detecting lines we'll use
// triangles instead.
Gl.glPushName(m_nameBase);
if (drawX)
{
Gl.glPushName((int)HitElement.X_ARROW);
Gl.glBegin(Gl.GL_TRIANGLES);
Gl.glVertex3f(squareSideX, 0, 0);
Gl.glVertex3f(s1, 0, 0);
Gl.glVertex3f(squareSideX, 0, 0);
Gl.glEnd();
RenderXArrow(s1);
Gl.glPopName();
}
if (drawY)
{
Gl.glPushName((int)HitElement.Y_ARROW);
Gl.glBegin(Gl.GL_TRIANGLES);
Gl.glVertex3f(0, squareSideY, 0);
Gl.glVertex3f(0, s2, 0);
Gl.glVertex3f(0, squareSideY, 0);
Gl.glEnd();
RenderYArrow(s2);
Gl.glPopName();
}
if (drawZ)
{
Gl.glPushName((int)HitElement.Z_ARROW);
Gl.glBegin(Gl.GL_TRIANGLES);
Gl.glVertex3f(0, 0, squareSideZ);
Gl.glVertex3f(0, 0, s3);
Gl.glVertex3f(0, 0, squareSideZ);
Gl.glEnd();
RenderZArrow(s3);
Gl.glPopName();
}
if (drawX && drawY)
{
Gl.glPushName((int)HitElement.XY_SQUARE);
RenderXYSquare(squareSideX, squareSideY, true);
Gl.glPopName();
}
if (drawY && drawZ)
{
Gl.glPushName((int)HitElement.YZ_SQUARE);
RenderYZSquare(squareSideY, squareSideZ, true);
Gl.glPopName();
}
if (drawX && drawZ)
{
Gl.glPushName((int)HitElement.XZ_SQUARE);
RenderXZSquare(squareSideX, squareSideZ, true);
Gl.glPopName();
}
Gl.glPopMatrix();
Gl.glPopName();
}
public override IEnumerable <RenderObject> RenderPaths(IEnumerable <Path2D> paths,
StylePen outline, StylePen highlightOutline,
StylePen selectOutline, RenderState renderState)
{
foreach (Path2D path in paths)
{
RenderObject ro = new RenderObject();
ro.RenderedPaths = new Double[path.Figures.Count][];
for (Int32 figureIndex = 0; figureIndex < path.Figures.Count; figureIndex++)
{
ro.RenderedPaths[figureIndex] = new Double[path.Figures[figureIndex].Points.Count * 2];
for (Int32 pointIndex = 0; pointIndex < path.Figures[figureIndex].Points.Count; pointIndex++)
{
Point2D point = path.Figures[figureIndex].Points[pointIndex];
ro.RenderedPaths[figureIndex][pointIndex * 2] = point.X;
ro.RenderedPaths[figureIndex][pointIndex * 2 + 1] = point.Y;
}
}
yield return(ro);
}
}
/// <summary>
/// Updates all parameters.
/// </summary>
/// <param name="renderState">The render state on which to apply.</param>
/// <param name="cbPerFrame">Per frame data.</param>
internal void UpdateValues(RenderState renderState, CBPerFrame cbPerFrame)
{
_cbPerFrame !.SetData(renderState.Device.DeviceImmediateContextD3D11, cbPerFrame);
}
private static void RenderTilesToTexture(RenderTask task, GameTime gt, GameContext context)
{
/* Our world is laid out in memory in terms of X / Y, but
* we are rendering isometric, which means that the rendering
* order for tiles must be like so:
*
* North
* 1 3 5 9 13 19 25
* 2 6 10 14 20 26 32
* 4 8 15 21 27 33 37
* East 7 12 18 28 34 38 42 West
* 11 17 24 31 39 43 45
* 16 23 30 36 41 46 48
* 22 29 35 40 44 47 49
* South
*
* We also need to account for situations where the user rotates
* the isometric view.
*/
/*
* North
* 0 0.5 1 1.5 2 2.5 3
* -0.5 0 0.5 1 1.5 2 2.5
* -1 -0.5 0 0.5 1 1.5 2
* East -1.5 -1 -0.5 0 0.5 1 1.5 West
* -2 -1.5 -1 -0.5 0 0.5 1
* -2.5 -2 -1.5 -1 -0.5 0 0.5
* -3 -2.5 -2 -1.5 -1 -0.5 0
* South
*
* v = (x - y) / 2.0
*/
int DEBUG_ZOFFSET = 0;//TileIsometricifier.TILE_CUBE_HEIGHT * Settings.ChunkDepth - 200;
if (m_CurrentRenderState == null)
{
RenderState rs = new RenderState();
rs.ZTop = Chunk.Depth;
rs.ZBottom = 0;
rs.ChunkTarget = RenderTargetFactory.Create(
m_GraphicsDevice,
TileIsometricifier.TILE_TOP_WIDTH * Chunk.Width,
TileIsometricifier.TILE_TOP_HEIGHT * Chunk.Width + TileIsometricifier.TILE_CUBE_HEIGHT * Chunk.Depth + TileIsometricifier.CHUNK_HEIGHT_ALLOWANCE,
true,
SurfaceFormat.Bgra5551,
DepthFormat.None);
rs.ChunkDepthMap = RenderTargetFactory.Create(
m_GraphicsDevice,
TileIsometricifier.TILE_TOP_WIDTH * Chunk.Width,
TileIsometricifier.TILE_TOP_HEIGHT * Chunk.Width + TileIsometricifier.TILE_CUBE_HEIGHT * Chunk.Depth + TileIsometricifier.CHUNK_HEIGHT_ALLOWANCE,
true,
SurfaceFormat.Bgra5551,
DepthFormat.None);
FilteredConsole.WriteLine(FilterCategory.GraphicsMemoryUsage, "Allocated textures for chunk " + task.Chunk.X + ", " + task.Chunk.Y + ", " + task.Chunk.Z + ".");
m_GraphicsDevice.SetRenderTarget(rs.ChunkTarget);
if (FilteredFeatures.IsEnabled(Feature.DebugChunkBackground))
{
Color c = new Color(
(float)m_DebugRandomizer.NextDouble(),
(float)m_DebugRandomizer.NextDouble(),
(float)m_DebugRandomizer.NextDouble()
);
m_GraphicsDevice.Clear(ClearOptions.Target, c, 1.0f, 0);
}
else
{
m_GraphicsDevice.Clear(ClearOptions.Target, Color.Transparent, 1.0f, 0);
}
rs.ChunkDepthMapCleared = false;
rs.SpriteBatch = new SpriteBatch(m_GraphicsDevice);
rs.CurrentZ = rs.ZBottom;
rs.RenderTask = task;
rs.CellRenderOrder = GetCellRenderOrder(RenderToNE);
rs.RenderMode = 0;
m_CurrentRenderState = rs;
}
if (m_CurrentRenderState.RenderMode == 0 /* chunk texture */)
{
m_GraphicsDevice.SetRenderTarget(m_CurrentRenderState.ChunkTarget);
m_CurrentRenderState.SpriteBatch.Begin(SpriteSortMode.Immediate, null);
int count = 0;
int zcount = 0;
while (m_CurrentRenderState.CurrentZ < m_CurrentRenderState.ZTop && gt.ElapsedGameTime.TotalMilliseconds < Performance.RENDERING_MILLISECONDS)
{
int z = m_CurrentRenderState.CurrentZ;
int rcx = TileIsometricifier.TILE_TOP_WIDTH * Chunk.Width / 2 - TileIsometricifier.TILE_TOP_WIDTH / 2;
int rcy = TileIsometricifier.TILE_CUBE_HEIGHT * Chunk.Depth + TileIsometricifier.TILE_TOP_HEIGHT * Chunk.Width / 2 - DEBUG_ZOFFSET;
int rw = TileIsometricifier.TILE_TOP_WIDTH;
int rh = TileIsometricifier.TILE_TOP_HEIGHT / 2;
for (int i = 0; i < m_CurrentRenderState.CellRenderOrder.Length; i++)
{
// Calculate the X / Y of the tile in the grid.
int x = m_CurrentRenderState.CellRenderOrder[i] % RenderWidth;
int y = m_CurrentRenderState.CellRenderOrder[i] / RenderWidth;
// Calculate the render position on screen.
int rx = rcx + (int)((x - y) / 2.0 * rw);
int ry = rcy + (x + y) * rh - (rh / 2 * (RenderWidth + RenderHeight)) - (z * TileIsometricifier.TILE_CUBE_HEIGHT);
Block b = task.Chunk.m_Blocks[x, y, z];
if (b == null)
{
if (FilteredFeatures.IsEnabled(Feature.DebugChunkTiles))
{
m_CurrentRenderState.SpriteBatch.Draw(
task.Textures["tiles.grass"],
new Vector2(rx, ry),
Color.White
);
}
continue;
}
Tile t = b.Tile;
if (t.Image == null)
{
if (FilteredFeatures.IsEnabled(Feature.DebugChunkTiles))
{
m_CurrentRenderState.SpriteBatch.Draw(
task.Textures["tiles.dirt"],
new Vector2(rx, ry),
Color.White
);
}
continue;
}
Color col = new Color(1f, 1f, 1f, 1f).ToPremultiplied();
if (task.Chunk.X == 0 && task.Chunk.Y == 0 && x == 0 && y == 0)
{
col = new Color(1f, 0f, 0f, 1f).ToPremultiplied();
}
if (FilteredFeatures.IsEnabled(Feature.DebugChunkTiles))
{
m_CurrentRenderState.SpriteBatch.Draw(
task.Textures[t.Image],
new Vector2(rx, ry),
col
);
}
if (FilteredFeatures.IsEnabled(Feature.RenderCellTops))
{
m_CurrentRenderState.SpriteBatch.Draw(
task.Textures[t.Image + ".isometric.top"],
new Rectangle(rx, ry, TileIsometricifier.TILE_TOP_WIDTH, TileIsometricifier.TILE_TOP_HEIGHT),
null,
col,
0,
new Vector2(0, 0),
SpriteEffects.None,
0 // TODO: Use this to correct rendering artifacts.
);
}
if (FilteredFeatures.IsEnabled(Feature.RenderCellSides))
{
m_CurrentRenderState.SpriteBatch.Draw(
task.Textures[t.Image + ".isometric.sideL"],
new Rectangle(rx, ry + TileIsometricifier.TILE_TOP_HEIGHT / 2,
TileIsometricifier.TILE_SIDE_WIDTH, TileIsometricifier.TILE_SIDE_HEIGHT),
null,
col,
0,
new Vector2(0, 0),
SpriteEffects.None,
0 // TODO: Use this to correct rendering artifacts.
);
m_CurrentRenderState.SpriteBatch.Draw(
task.Textures[t.Image + ".isometric.sideR"],
new Rectangle(rx + TileIsometricifier.TILE_TOP_WIDTH / 2, ry + TileIsometricifier.TILE_TOP_HEIGHT / 2,
TileIsometricifier.TILE_SIDE_WIDTH, TileIsometricifier.TILE_SIDE_HEIGHT),
null,
col,
0,
new Vector2(0, 0),
SpriteEffects.None,
0 // TODO: Use this to correct rendering artifacts.
);
}
count++;
}
m_CurrentRenderState.CurrentZ++;
zcount++;
}
FilteredConsole.WriteLine(FilterCategory.OptimizationTiming, "Rendered " + zcount + " levels, " + count + " cells to texture target in " + gt.ElapsedGameTime.Milliseconds + "ms.");
m_CurrentRenderState.SpriteBatch.End();
m_GraphicsDevice.SetRenderTarget(null);
}
else if (m_CurrentRenderState.RenderMode == 1 /* depth map */ &&
FilteredFeatures.IsEnabled(Feature.IsometricOcclusion))
{
m_GraphicsDevice.SetRenderTarget(m_CurrentRenderState.ChunkDepthMap);
if (!m_CurrentRenderState.ChunkDepthMapCleared)
{
m_CurrentRenderState.SpriteBatch.Begin(SpriteSortMode.Immediate, null);
m_GraphicsDevice.Clear(ClearOptions.Target, Color.Transparent, 1.0f, 0);
m_CurrentRenderState.SpriteBatch.End();
m_CurrentRenderState.ChunkDepthMapCleared = true;
}
BlendState bs = new BlendState();
bs.AlphaBlendFunction = BlendFunction.Max;
bs.AlphaSourceBlend = Blend.One;
bs.AlphaDestinationBlend = Blend.One;
bs.ColorBlendFunction = BlendFunction.Max;
bs.ColorSourceBlend = Blend.One;
bs.ColorDestinationBlend = Blend.One;
m_CurrentRenderState.SpriteBatch.Begin(SpriteSortMode.Immediate, bs, null, null, null, context.Effects["IsometricDepthMap"]);
context.Effects["IsometricDepthMap"].Parameters["RotationMode"].SetValue(RenderToNE);
context.Effects["IsometricDepthMap"].CurrentTechnique.Passes[0].Apply();
int count = 0;
int zcount = 0;
while (m_CurrentRenderState.CurrentZ < m_CurrentRenderState.ZTop && gt.ElapsedGameTime.TotalMilliseconds < Performance.RENDERING_MILLISECONDS)
{
int z = m_CurrentRenderState.CurrentZ;
int rcx = TileIsometricifier.TILE_TOP_WIDTH * Chunk.Width / 2 - TileIsometricifier.TILE_TOP_WIDTH / 2;
int rcy = TileIsometricifier.TILE_CUBE_HEIGHT * Chunk.Depth + TileIsometricifier.TILE_TOP_HEIGHT * Chunk.Width / 2 - DEBUG_ZOFFSET;
int rw = TileIsometricifier.TILE_TOP_WIDTH;
int rh = TileIsometricifier.TILE_TOP_HEIGHT / 2;
for (int i = 0; i < m_CurrentRenderState.CellRenderOrder.Length; i++)
{
// Calculate the X / Y of the tile in the grid.
int x = m_CurrentRenderState.CellRenderOrder[i] % RenderWidth;
int y = m_CurrentRenderState.CellRenderOrder[i] / RenderWidth;
// Calculate the "depth" of the tile.
int depth = x + y + z;
// Calculate the render position on screen.
int rx = rcx + (int)((x - y) / 2.0 * rw);
int ry = rcy + (x + y) * rh - (rh / 2 * (RenderWidth + RenderHeight)) - (z * TileIsometricifier.TILE_CUBE_HEIGHT);
Block b = task.Chunk.m_Blocks[x, y, z];
if (b == null)
{
continue;
}
Tile t = b.Tile;
if (t.Image == null)
{
continue;
}
context.Effects["IsometricDepthMap"].Parameters["CellDepth"].SetValue((float)Math.Min(depth / 255f, 1.0f));
context.Effects["IsometricDepthMap"].CurrentTechnique.Passes[0].Apply();
m_CurrentRenderState.SpriteBatch.Draw(
task.Textures[t.Image + ".isometric.top"],
new Rectangle(rx, ry, TileIsometricifier.TILE_TOP_WIDTH, TileIsometricifier.TILE_TOP_HEIGHT),
null,
Color.White,
0,
new Vector2(0, 0),
SpriteEffects.None,
0
);
m_CurrentRenderState.SpriteBatch.Draw(
task.Textures[t.Image + ".isometric.sideL"],
new Rectangle(rx, ry + 12, TileIsometricifier.TILE_SIDE_WIDTH, TileIsometricifier.TILE_SIDE_HEIGHT),
null,
Color.White,
0,
new Vector2(0, 0),
SpriteEffects.None,
0
);
m_CurrentRenderState.SpriteBatch.Draw(
task.Textures[t.Image + ".isometric.sideR"],
new Rectangle(rx + 16, ry + 12, TileIsometricifier.TILE_SIDE_WIDTH, TileIsometricifier.TILE_SIDE_HEIGHT),
null,
Color.White,
0,
new Vector2(0, 0),
SpriteEffects.None,
0
);
count++;
}
m_CurrentRenderState.CurrentZ++;
zcount++;
}
FilteredConsole.WriteLine(FilterCategory.OptimizationTiming, "Rendered " + zcount + " levels, " + count + " cells to texture target in " + gt.ElapsedGameTime.TotalMilliseconds + "ms.");
m_CurrentRenderState.SpriteBatch.End();
m_GraphicsDevice.SetRenderTarget(null);
}
if (m_CurrentRenderState.CurrentZ == m_CurrentRenderState.ZTop)
{
if (m_CurrentRenderState.RenderMode < 1)
{
m_CurrentRenderState.CurrentZ = m_CurrentRenderState.ZBottom;
m_CurrentRenderState.RenderMode++;
}
else
{
m_CurrentRenderState.RenderTask.Result = m_CurrentRenderState.ChunkTarget;
m_CurrentRenderState.RenderTask.DepthMap = m_CurrentRenderState.ChunkDepthMap;
m_CurrentRenderState.RenderTask.HasResult = true;
m_CurrentRenderState = null;
}
}
}
public GlobeClipmapTerrain(Context context, RasterSource terrainSource, EsriRestImagery imagery, Ellipsoid ellipsoid, int clipmapPosts)
{
_terrainSource = terrainSource;
_ellipsoid = ellipsoid;
_clipmapPosts = clipmapPosts;
_clipmapSegments = _clipmapPosts - 1;
int clipmapLevels = _terrainSource.Levels.Count;
_clipmapLevels = new ClipmapLevel[clipmapLevels];
for (int i = 0; i < _clipmapLevels.Length; ++i)
{
_clipmapLevels[i] = new ClipmapLevel();
}
for (int i = 0; i < _clipmapLevels.Length; ++i)
{
RasterLevel terrainLevel = _terrainSource.Levels[i];
_clipmapLevels[i].Terrain = terrainLevel;
_clipmapLevels[i].HeightTexture = Device.CreateTexture2D(new Texture2DDescription(_clipmapPosts, _clipmapPosts, TextureFormat.Red32f));
_clipmapLevels[i].NormalTexture = Device.CreateTexture2D(new Texture2DDescription(_clipmapPosts, _clipmapPosts, TextureFormat.RedGreenBlue32f));
_clipmapLevels[i].CoarserLevel = i == 0 ? null : _clipmapLevels[i - 1];
_clipmapLevels[i].FinerLevel = i == _clipmapLevels.Length - 1 ? null : _clipmapLevels[i + 1];
// Aim for roughly one imagery texel per geometry texel.
// Find the first imagery level that meets our resolution needs.
double longitudeResRequired = terrainLevel.PostDeltaLongitude;
double latitudeResRequired = terrainLevel.PostDeltaLatitude;
RasterLevel imageryLevel = null;
for (int j = 0; j < imagery.Levels.Count; ++j)
{
imageryLevel = imagery.Levels[j];
if (imageryLevel.PostDeltaLongitude <= longitudeResRequired &&
imageryLevel.PostDeltaLatitude <= latitudeResRequired)
{
break;
}
}
_clipmapLevels[i].Imagery = imageryLevel;
_clipmapLevels[i].ImageryWidth = (int)Math.Ceiling(_clipmapPosts * terrainLevel.PostDeltaLongitude / imageryLevel.PostDeltaLongitude);
_clipmapLevels[i].ImageryHeight = (int)Math.Ceiling(_clipmapPosts * terrainLevel.PostDeltaLatitude / imageryLevel.PostDeltaLatitude);
_clipmapLevels[i].ImageryTexture = Device.CreateTexture2D(new Texture2DDescription(_clipmapLevels[i].ImageryWidth, _clipmapLevels[i].ImageryHeight, TextureFormat.RedGreenBlue8, false));
}
_shaderProgram = Device.CreateShaderProgram(
EmbeddedResources.GetText("OpenGlobe.Scene.Terrain.ClipmapTerrain.GlobeClipmapVS.glsl"),
EmbeddedResources.GetText("OpenGlobe.Scene.Terrain.ClipmapTerrain.GlobeClipmapFS.glsl"));
_fillPatchPosts = (clipmapPosts + 1) / 4; // M
_fillPatchSegments = _fillPatchPosts - 1;
// Create the MxM block used to fill the ring and the field.
Mesh fieldBlockMesh = RectangleTessellator.Compute(
new RectangleD(new Vector2D(0.0, 0.0), new Vector2D(_fillPatchSegments, _fillPatchSegments)),
_fillPatchSegments, _fillPatchSegments);
_fillPatch = context.CreateVertexArray(fieldBlockMesh, _shaderProgram.VertexAttributes, BufferHint.StaticDraw);
// Create the Mx3 block used to fill the space between the MxM blocks in the ring
Mesh ringFixupHorizontalMesh = RectangleTessellator.Compute(
new RectangleD(new Vector2D(0.0, 0.0), new Vector2D(_fillPatchSegments, 2.0)),
_fillPatchSegments, 2);
_horizontalFixupPatch = context.CreateVertexArray(ringFixupHorizontalMesh, _shaderProgram.VertexAttributes, BufferHint.StaticDraw);
// Create the 3xM block used to fill the space between the MxM blocks in the ring
Mesh ringFixupVerticalMesh = RectangleTessellator.Compute(
new RectangleD(new Vector2D(0.0, 0.0), new Vector2D(2.0, _fillPatchSegments)),
2, _fillPatchSegments);
_verticalFixupPatch = context.CreateVertexArray(ringFixupVerticalMesh, _shaderProgram.VertexAttributes, BufferHint.StaticDraw);
Mesh offsetStripHorizontalMesh = RectangleTessellator.Compute(
new RectangleD(new Vector2D(0.0, 0.0), new Vector2D(2 * _fillPatchPosts, 1.0)),
2 * _fillPatchPosts, 1);
_horizontalOffsetPatch = context.CreateVertexArray(offsetStripHorizontalMesh, _shaderProgram.VertexAttributes, BufferHint.StaticDraw);
Mesh offsetStripVerticalMesh = RectangleTessellator.Compute(
new RectangleD(new Vector2D(0.0, 0.0), new Vector2D(1.0, 2 * _fillPatchPosts - 1)),
1, 2 * _fillPatchPosts - 1);
_verticalOffsetPatch = context.CreateVertexArray(offsetStripVerticalMesh, _shaderProgram.VertexAttributes, BufferHint.StaticDraw);
Mesh centerMesh = RectangleTessellator.Compute(new RectangleD(new Vector2D(0.0, 0.0), new Vector2D(2.0, 2.0)), 2, 2);
_centerPatch = context.CreateVertexArray(centerMesh, _shaderProgram.VertexAttributes, BufferHint.StaticDraw);
Mesh degenerateTriangleMesh = CreateDegenerateTriangleMesh();
_degenerateTrianglePatch = context.CreateVertexArray(degenerateTriangleMesh, _shaderProgram.VertexAttributes, BufferHint.StaticDraw);
_patchOriginInClippedLevel = (Uniform <Vector2F>)_shaderProgram.Uniforms["u_patchOriginInClippedLevel"];
_levelScaleFactor = (Uniform <Vector2F>)_shaderProgram.Uniforms["u_levelScaleFactor"];
_levelZeroWorldScaleFactor = (Uniform <Vector2F>)_shaderProgram.Uniforms["u_levelZeroWorldScaleFactor"];
_levelOffsetFromWorldOrigin = (Uniform <Vector2F>)_shaderProgram.Uniforms["u_levelOffsetFromWorldOrigin"];
_heightExaggeration = (Uniform <float>)_shaderProgram.Uniforms["u_heightExaggeration"];
_viewPosInClippedLevel = (Uniform <Vector2F>)_shaderProgram.Uniforms["u_viewPosInClippedLevel"];
_fineLevelOriginInCoarse = (Uniform <Vector2F>)_shaderProgram.Uniforms["u_fineLevelOriginInCoarse"];
_unblendedRegionSize = (Uniform <Vector2F>)_shaderProgram.Uniforms["u_unblendedRegionSize"];
_oneOverBlendedRegionSize = (Uniform <Vector2F>)_shaderProgram.Uniforms["u_oneOverBlendedRegionSize"];
_fineTextureOrigin = (Uniform <Vector2F>)_shaderProgram.Uniforms["u_fineTextureOrigin"];
_showBlendRegions = (Uniform <bool>)_shaderProgram.Uniforms["u_showBlendRegions"];
_useBlendRegions = (Uniform <bool>)_shaderProgram.Uniforms["u_useBlendRegions"];
_oneOverClipmapSize = (Uniform <float>)_shaderProgram.Uniforms["u_oneOverClipmapSize"];
_color = (Uniform <Vector3F>)_shaderProgram.Uniforms["u_color"];
_blendRegionColor = (Uniform <Vector3F>)_shaderProgram.Uniforms["u_blendRegionColor"];
_terrainToImageryResolutionRatio = (Uniform <Vector2F>)_shaderProgram.Uniforms["u_terrainToImageryResolutionRatio"];
_terrainOffsetInImagery = (Uniform <Vector2F>)_shaderProgram.Uniforms["u_terrainOffsetInImagery"];
_oneOverImagerySize = (Uniform <Vector2F>)_shaderProgram.Uniforms["u_oneOverImagerySize"];
_showImagery = (Uniform <bool>)_shaderProgram.Uniforms["u_showImagery"];
_lighting = (Uniform <bool>)_shaderProgram.Uniforms["u_shade"];
((Uniform <Vector3F>)_shaderProgram.Uniforms["u_globeRadiiSquared"]).Value =
ellipsoid.RadiiSquared.ToVector3F();
_renderState = new RenderState();
_renderState.FacetCulling.FrontFaceWindingOrder = fieldBlockMesh.FrontFaceWindingOrder;
_primitiveType = fieldBlockMesh.PrimitiveType;
float oneOverBlendedRegionSize = (float)(10.0 / _clipmapPosts);
_oneOverBlendedRegionSize.Value = new Vector2F(oneOverBlendedRegionSize, oneOverBlendedRegionSize);
float unblendedRegionSize = (float)(_clipmapSegments / 2 - _clipmapPosts / 10.0 - 1);
_unblendedRegionSize.Value = new Vector2F(unblendedRegionSize, unblendedRegionSize);
_useBlendRegions.Value = true;
_showImagery.Value = true;
_oneOverClipmapSize.Value = 1.0f / clipmapPosts;
_updater = new ClipmapUpdater(context, _clipmapLevels);
HeightExaggeration = 0.00001f;
}
public void Draw(RenderState rstate, Matrix4 world, Lighting lights)
{
throw new NotImplementedException();
}
public override void PushState(RenderState mask)
{
var cmd = AddCommand <PushStateCommand>();
cmd.Mask = mask;
}
public void HandleInput()
{
if (Input.IsPressed(Keys.Left) || Input.IsPressed(Keys.A))
{
SetModel(ChunkIndex - 1);
}
if (Input.IsPressed(Keys.Right) || Input.IsPressed(Keys.D))
{
SetModel(ChunkIndex + 1);
}
if (Input.IsPressed(Keys.D1))
{
SetModel(0);
}
if (Input.IsPressed(Keys.D2))
{
SetModel(1);
}
if (Input.IsPressed(Keys.D3))
{
SetModel(2);
}
if (Input.IsPressed(Keys.D4))
{
SetModel(3);
}
if (Input.IsPressed(Keys.D5))
{
SetModel(4);
}
if (Input.IsPressed(Keys.D6))
{
SetModel(5);
}
if (Input.IsPressed(Keys.D7))
{
SetModel(6);
}
if (Input.IsPressed(Keys.D8))
{
SetModel(7);
}
if (Input.IsPressed(Keys.D9))
{
SetModel(8);
}
if (Input.IsPressed(Keys.Up))
{
RenderState = (RenderState)((int)(RenderState + 1) % RenderStateCount);
}
if (Input.IsPressed(Keys.Down))
{
RenderState = (RenderState)((int)(RenderState - 1 + RenderStateCount) % RenderStateCount);
}
if (Input.IsPressed(Keys.Z))
{
ToggleWireframe();
}
if (Input.IsPressed(Keys.R))
{
ToggleRotation();
}
}
protected override void Draw(double elapsed)
{
VertexBuffer.TotalDrawcalls = 0;
EnableTextInput();
Viewport.Replace(0, 0, Width, Height);
RenderState.ClearColor = new Color4(0.2f, 0.2f, 0.2f, 1f);
RenderState.ClearAll();
//
if (world != null)
{
if (wireFrame)
{
RenderState.Wireframe = true;
}
world.Renderer.Draw();
RenderState.Wireframe = false;
}
//
guiHelper.NewFrame(elapsed);
ImGui.PushFont(ImGuiHelper.Noto);
//Main Menu
ImGui.BeginMainMenuBar();
if (ImGui.BeginMenu("File"))
{
if (Theme.IconMenuItem("Open", "open", Color4.White, true))
{
var folder = FileDialog.ChooseFolder();
if (folder != null)
{
if (GameConfig.CheckFLDirectory(folder))
{
openLoad = true;
LoadData(folder);
}
else
{
//Error dialog
}
}
}
if (Theme.IconMenuItem("Quit", "quit", Color4.White, true))
{
Exit();
}
ImGui.EndMenu();
}
if (world != null)
{
if (ImGui.MenuItem("Change System (F6)"))
{
sysIndex = sysIndexLoaded;
openChangeSystem = true;
}
}
if (ImGui.BeginMenu("View"))
{
if (ImGui.MenuItem("Debug Text", "", showDebug, true))
{
showDebug = !showDebug;
}
if (ImGui.MenuItem("Wireframe", "", wireFrame, true))
{
wireFrame = !wireFrame;
}
if (ImGui.MenuItem("Infocard", "", infocardOpen, true))
{
infocardOpen = !infocardOpen;
}
if (ImGui.MenuItem("Universe Map", "", universeOpen, true))
{
universeOpen = !universeOpen;
}
if (ImGui.MenuItem("VSync", "", vSync, true))
{
vSync = !vSync;
SetVSync(vSync);
}
ImGui.EndMenu();
}
var h = ImGui.GetWindowHeight();
ImGui.EndMainMenuBar();
//Other Windows
if (world != null)
{
if (showDebug)
{
ImGui.SetNextWindowPos(new Vector2(0, h), ImGuiCond.Always, Vector2.Zero);
ImGui.Begin("##debugWindow", ImGuiWindowFlags.NoTitleBar |
ImGuiWindowFlags.NoMove | ImGuiWindowFlags.AlwaysAutoResize | ImGuiWindowFlags.NoBringToFrontOnFocus);
ImGui.Text(string.Format(DEBUG_TEXT, curSystem.Name, curSystem.Nickname,
camera.Position.X, camera.Position.Y, camera.Position.Z,
DebugDrawing.SizeSuffix(GC.GetTotalMemory(false)), (int)Math.Round(RenderFrequency), VertexBuffer.TotalDrawcalls, VertexBuffer.TotalBuffers));
ImGui.End();
}
ImGui.SetNextWindowSize(new Vector2(100, 100), ImGuiCond.FirstUseEver);
if (infocardOpen)
{
if (ImGui.Begin("Infocard", ref infocardOpen))
{
var szX = Math.Max(20, ImGui.GetWindowWidth());
var szY = Math.Max(20, ImGui.GetWindowHeight());
if (icard == null)
{
icard = new InfocardControl(this, systemInfocard, szX);
}
icard.Draw(szX);
}
ImGui.End();
}
if (universeOpen)
{
if (ImGui.Begin("Map", ref universeOpen))
{
ImGui.BeginTabBar("##maptabs");
if (ImGui.BeginTabItem("Universe"))
{
var szX = Math.Max(20, ImGui.GetWindowWidth());
var szY = Math.Max(20, ImGui.GetWindowHeight() - 50);
string result = UniverseMap.Draw(universeBackgroundRegistered, GameData, (int)szX,
(int)szY, 20);
if (result != null)
{
for (int i = 0; i < systems.Length; i++)
{
if (result.Equals(systems[i], StringComparison.OrdinalIgnoreCase))
{
sysIndex = i;
ChangeSystem();
break;
}
}
}
ImGui.EndTabItem();
}
if (ImGui.BeginTabItem("System"))
{
var szX = Math.Max(20, ImGui.GetWindowWidth());
var szY = Math.Max(20, ImGui.GetWindowHeight() - 70);
systemMap.Draw((int)szX, (int)szY);
ImGui.EndTabItem();
}
ImGui.EndTabBar();
}
ImGui.End();
}
}
//dialogs must be children of window or ImGui default "Debug" window appears
if (openChangeSystem)
{
ImGui.OpenPopup("Change System");
openChangeSystem = false;
}
bool popupopen = true;
if (ImGui.BeginPopupModal("Change System", ref popupopen, ImGuiWindowFlags.AlwaysAutoResize))
{
ImGui.Combo("System", ref sysIndex, systems, systems.Length);
if (ImGui.Button("Ok"))
{
ChangeSystem();
ImGui.CloseCurrentPopup();
}
ImGui.SameLine();
if (ImGui.Button("Cancel"))
{
ImGui.CloseCurrentPopup();
}
ImGui.EndPopup();
}
if (openLoad)
{
ImGui.OpenPopup("Loading");
openLoad = false;
}
popupopen = true;
if (ImGui.BeginPopupModal("Loading", ref popupopen, ImGuiWindowFlags.AlwaysAutoResize))
{
if (world != null)
{
ImGui.CloseCurrentPopup();
}
ImGuiExt.Spinner("##spinner", 10, 2, ImGui.GetColorU32(ImGuiCol.ButtonHovered, 1));
ImGui.SameLine();
ImGui.Text("Loading");
ImGui.EndPopup();
}
ImGui.PopFont();
guiHelper.Render(RenderState);
}
public RenderState CreateState(Dictionary <string, object> data)
{
RenderState state = new RenderState();
if (data.ContainsKey("Cull"))
{
string p = (string)data["Cull"];
if (p.Equals("front", StringComparison.InvariantCultureIgnoreCase))
{
state.RasterizerState = RasterizerState.CullClockwise;
}
else if (p.Equals("back", StringComparison.InvariantCultureIgnoreCase))
{
state.RasterizerState = RasterizerState.CullCounterClockwise;
}
else if (!p.Equals("off", StringComparison.InvariantCultureIgnoreCase))
{
throw new ContentException("Cull state parameter must be one of front, back or off.");
}
}
if (data.ContainsKey("DepthWrite"))
{
string p = (string)data["DepthWrite"];
if (p.Equals("on", StringComparison.InvariantCultureIgnoreCase))
{
state.DepthWrite = true;
}
else if (!p.Equals("off", StringComparison.InvariantCultureIgnoreCase))
{
throw new ContentException("DepthWrite state parameter must be one of on or off.");
}
}
if (data.ContainsKey("DepthFunc"))
{
DepthFunction func;
if (!Enum.TryParse <DepthFunction>((string)data["DepthWrite"], true, out func))
{
throw new ContentException(string.Format("DepthFunc state parameter must be one of {0}.", EnumToStringList(typeof(DepthFunction))));
}
state.DepthFunction = func;
}
if (data.ContainsKey("DepthOffset"))
{
List <object> args = (List <object>)data["DepthOffset"];
if (args == null || args.Count != 2 || !args.All(a => a is long || a is double))
{
throw new ContentException("DepthOffset state parameter must be an array of 2 integers.");
}
state.DepthOffsetFactor = Convert.ToSingle(args[0]);
state.DepthOffsetUnits = Convert.ToSingle((float)args[1]);
}
if (data.ContainsKey("BlendEnable"))
{
string p = (string)data["BlendEnable"];
if (p.Equals("on", StringComparison.InvariantCultureIgnoreCase))
{
state.BlendState = BlendState.AlphaBlend;
}
else if (p.Equals("off", StringComparison.InvariantCultureIgnoreCase))
{
state.ColorSourceBlend = BlendingFactorSrc.One;
state.AlphaSourceBlend = BlendingFactorSrc.One;
state.ColorDestinationBlend = BlendingFactorDest.Zero;
state.AlphaDestinationBlend = BlendingFactorDest.Zero;
}
else
{
throw new ContentException("BlendEnable state parameter must be one of on or off.");
}
}
if (data.ContainsKey("BlendFunc"))
{
List <object> args = (List <object>)data["BlendFunc"];
if (args == null || args.Count != 2 || args.Count != 4 || !args.All(a => a is string))
{
throw new ContentException("BlendFunc state parameter must be an array of 2 blend factors.");
}
BlendingFactorSrc src;
BlendingFactorDest dst;
if (!Enum.TryParse <BlendingFactorSrc>((string)args[0], true, out src))
{
throw new ContentException(string.Format("BlendFunc states first parameter must be one of {0}.", EnumToStringList(typeof(BlendingFactorSrc))));
}
state.ColorSourceBlend = src;
if (!Enum.TryParse <BlendingFactorDest>((string)args[1], true, out dst))
{
throw new ContentException(string.Format("BlendFunc states second parameter must be one of {0}.", EnumToStringList(typeof(BlendingFactorDest))));
}
state.ColorDestinationBlend = dst;
if (args.Count == 4)
{
if (!Enum.TryParse <BlendingFactorSrc>((string)args[3], true, out src))
{
throw new ContentException(string.Format("BlendFunc states third parameter must be one of {0}.", EnumToStringList(typeof(BlendingFactorSrc))));
}
state.AlphaSourceBlend = src;
if (!Enum.TryParse <BlendingFactorDest>((string)args[4], true, out dst))
{
throw new ContentException(string.Format("BlendFunc states fourth parameter must be one of {0}.", EnumToStringList(typeof(BlendingFactorDest))));
}
state.AlphaDestinationBlend = dst;
}
}
if (data.ContainsKey("ColorBlendMode"))
{
BlendEquationMode func;
if (!Enum.TryParse <BlendEquationMode>((string)data["ColorBlendMode"], true, out func))
{
throw new ContentException(string.Format("ColorBlendMode state parameter must be one of {0}.", EnumToStringList(typeof(BlendEquationMode))));
}
state.ColorBlendFunction = func;
}
if (data.ContainsKey("AlphaBlendMode"))
{
BlendEquationMode func;
if (!Enum.TryParse <BlendEquationMode>((string)data["AlphaBlendMode"], true, out func))
{
throw new ContentException(string.Format("AlphaBlendMode state parameter must be one of {0}.", EnumToStringList(typeof(BlendEquationMode))));
}
state.AlphaBlendFunction = func;
}
if (data.ContainsKey("StencilFunc"))
{
StencilFunction func;
if (!Enum.TryParse <StencilFunction>((string)data["StencilFunc"], true, out func))
{
throw new ContentException(string.Format("StencilFunc state parameter must be one of {0}.", EnumToStringList(typeof(StencilFunction))));
}
state.StencilEnable = true;
state.StencilFunction = func;
}
if (data.ContainsKey("StencilPass"))
{
StencilOp func;
if (!Enum.TryParse <StencilOp>((string)data["StencilPass"], true, out func))
{
throw new ContentException(string.Format("StencilPass state parameter must be one of {0}.", EnumToStringList(typeof(StencilOp))));
}
state.StencilEnable = true;
state.StencilPass = func;
}
if (data.ContainsKey("StencilFail"))
{
StencilOp func;
if (!Enum.TryParse <StencilOp>((string)data["StencilFail"], true, out func))
{
throw new ContentException(string.Format("StencilFail state parameter must be one of {0}.", EnumToStringList(typeof(StencilOp))));
}
state.StencilEnable = true;
state.StencilFail = func;
}
if (data.ContainsKey("StencilZFail"))
{
StencilOp func;
if (!Enum.TryParse <StencilOp>((string)data["StencilZFail"], true, out func))
{
throw new ContentException(string.Format("StencilZFail state parameter must be one of {0}.", EnumToStringList(typeof(StencilOp))));
}
state.StencilEnable = true;
state.StencilZFail = func;
}
if (data.ContainsKey("StencilWriteMask"))
{
long p = (long)data["StencilWriteMask"];
if (!(data["StencilWriteMask"] is long) || p < 0 || p > 255)
{
throw new ContentException("StencilWriteMask state parameter must be an integer.");
}
state.StencilEnable = true;
state.StencilWriteMask = (int)p;
}
if (data.ContainsKey("StencilReadMask"))
{
long p = (long)data["StencilReadMask"];
if (!(data["StencilReadMask"] is long) || p < 0 || p > 255)
{
throw new ContentException("StencilReadMask state parameter must be an integer.");
}
state.StencilEnable = true;
state.StencilReadMask = (int)p;
}
return(state);
}
public Viewport3D(MainWindow mw)
{
this.mw = mw;
rstate = mw.RenderState;
vps = mw.Viewport;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:SME.VHDL.Transformations.FixSwitchStatementTypes"/> class.
/// </summary>
/// <param name="state">The render state.</param>
public FixSwitchStatementTypes(RenderState state)
{
State = state;
}
public void Draw(Graphics gfx, Rectangle bounds, RenderState state, object value, Color foreColor, Color backColor, Font font)
{
var BackgroundBrush = GetBrush(backColor);
gfx.FillRectangle(BackgroundBrush, bounds);
int ActualChunkThickness = (ChunkThickness > 0) ? ChunkThickness : ProgressBarRenderer.ChunkThickness;
int ActualChunkSpaceThickness = (ChunkSpaceThickness >= 0) ? ChunkSpaceThickness : ProgressBarRenderer.ChunkSpaceThickness;
int TotalChunkThickness = ActualChunkThickness + ActualChunkSpaceThickness;
int Value = Utils.Clamp((int)value, MinValue, MaxValue);
double PercentageFactor = ((double)Value + Math.Abs(MinValue)) / (MaxValue - MinValue);
int BarThickness = 0;
Rectangle BarBounds;
Rectangle ChunkBounds;
bounds.Inflate(-1, -1); // Leave a 1 pixel wide border around the progressbar.
if (Horizontal)
{
BarThickness = (int)Math.Floor(PercentageFactor * (bounds.Width - 2));
BarThickness = Utils.Clamp(BarThickness, 0, bounds.Width - 2);
BarBounds = new Rectangle(bounds.Left + 1, bounds.Top + 1, BarThickness, bounds.Height - 2);
ChunkBounds = new Rectangle(bounds.Left + 1, bounds.Top + 1, ActualChunkThickness, bounds.Height - 2);
ProgressBarRenderer.DrawHorizontalBar(gfx, bounds);
}
else
{
BarThickness = (int)Math.Floor(PercentageFactor * (bounds.Height - 2));
BarThickness = Utils.Clamp(BarThickness, 0, bounds.Height - 2);
BarBounds = new Rectangle(bounds.Left + 1, bounds.Top + 1 + (bounds.Height - 2 - BarThickness), bounds.Width - 2, BarThickness);
ChunkBounds = new Rectangle(bounds.Left + 1, bounds.Top + 1 + (bounds.Height - 2 - ActualChunkThickness), bounds.Width - 2, ActualChunkThickness);
ProgressBarRenderer.DrawVerticalBar(gfx, bounds);
}
if (BarThickness == 0 && Value > MinValue)
{
// If value is greater than the minimal value at least show something. Even if it's only one pixel.
BarThickness = 1;
}
int ChunkCount = (int)Math.Floor((BarThickness + ActualChunkSpaceThickness) / (double)TotalChunkThickness);
int RemainingBarThickness = BarThickness - ChunkCount * TotalChunkThickness;
if (ActualChunkSpaceThickness <= 0)
{
// No chunks, so draw one big chunk which should be a solid bar.
ProgressBarRenderer.DrawHorizontalChunks(gfx, BarBounds);
}
else
{
if (Horizontal)
{
for (int i = 0; i < ChunkCount; i++)
{
ProgressBarRenderer.DrawHorizontalChunks(gfx, ChunkBounds);
ChunkBounds.X += TotalChunkThickness;
}
if (RemainingBarThickness > 0)
{
ChunkBounds.Width = RemainingBarThickness;
ProgressBarRenderer.DrawHorizontalChunks(gfx, ChunkBounds);
}
}
else
{
for (int i = 0; i < ChunkCount; i++)
{
ProgressBarRenderer.DrawVerticalChunks(gfx, ChunkBounds);
ChunkBounds.Y -= TotalChunkThickness;
}
if (RemainingBarThickness > 0)
{
ChunkBounds.Height = RemainingBarThickness;
ChunkBounds.Y += (TotalChunkThickness - RemainingBarThickness - 1);
ProgressBarRenderer.DrawVerticalChunks(gfx, ChunkBounds);
}
}
}
}
public VertexDisplacementMapTerrainTile(Context context, TerrainTile tile)
{
//
// Upload height map as a one channel floating point texture
//
WritePixelBuffer pixelBuffer = Device.CreateWritePixelBuffer(PixelBufferHint.Stream,
sizeof(float) * tile.Heights.Length);
pixelBuffer.CopyFromSystemMemory(tile.Heights);
_texture = Device.CreateTexture2DRectangle(new Texture2DDescription(
tile.Resolution.X, tile.Resolution.Y, TextureFormat.Red32f));
_texture.CopyFromBuffer(pixelBuffer, ImageFormat.Red, ImageDatatype.Float);
///////////////////////////////////////////////////////////////////
ShaderProgram spTerrain = Device.CreateShaderProgram(
EmbeddedResources.GetText("OpenGlobe.Scene.Terrain.VertexDisplacementMapTerrainTile.TerrainVS.glsl"),
EmbeddedResources.GetText("OpenGlobe.Scene.Terrain.VertexDisplacementMapTerrainTile.TerrainFS.glsl"));
_heightExaggerationUniform = (Uniform <float>)spTerrain.Uniforms["u_heightExaggeration"];
((Uniform <Vector2F>)spTerrain.Uniforms["u_positionToTextureCoordinate"]).Value = new Vector2F(
(float)(1.0 / (double)(tile.Resolution.X)),
(float)(1.0 / (double)(tile.Resolution.Y)));
((Uniform <Vector2F>)spTerrain.Uniforms["u_positionToRepeatTextureCoordinate"]).Value = new Vector2F(
(float)(4.0 / (double)tile.Resolution.X),
(float)(4.0 / (double)tile.Resolution.Y));
///////////////////////////////////////////////////////////////////
ShaderProgram spNormals = Device.CreateShaderProgram(
EmbeddedResources.GetText("OpenGlobe.Scene.Terrain.VertexDisplacementMapTerrainTile.NormalsVS.glsl"),
EmbeddedResources.GetText("OpenGlobe.Scene.Terrain.VertexDisplacementMapTerrainTile.NormalsGS.glsl"),
EmbeddedResources.GetText("OpenGlobe.Scene.Terrain.VertexDisplacementMapTerrainTile.NormalsFS.glsl"));
_heightExaggerationNormals = (Uniform <float>)spNormals.Uniforms["u_heightExaggeration"];
_fillDistanceNormals = (Uniform <float>)spNormals.Uniforms["u_fillDistance"];
((Uniform <Vector3F>)spNormals.Uniforms["u_color"]).Value = Vector3F.Zero;
///////////////////////////////////////////////////////////////////
ShaderProgram spWireframe = Device.CreateShaderProgram(
EmbeddedResources.GetText("OpenGlobe.Scene.Terrain.VertexDisplacementMapTerrainTile.WireframeVS.glsl"),
EmbeddedResources.GetText("OpenGlobe.Scene.Terrain.VertexDisplacementMapTerrainTile.WireframeGS.glsl"),
EmbeddedResources.GetText("OpenGlobe.Scene.Terrain.VertexDisplacementMapTerrainTile.WireframeFS.glsl"));
_lineWidthWireframe = (Uniform <float>)spWireframe.Uniforms["u_halfLineWidth"];
_heightExaggerationWireframe = (Uniform <float>)spWireframe.Uniforms["u_heightExaggeration"];
((Uniform <Vector3F>)spWireframe.Uniforms["u_color"]).Value = Vector3F.Zero;
///////////////////////////////////////////////////////////////////
Mesh mesh = RectangleTessellator.Compute(new RectangleD(new Vector2D(0.5, 0.5),
new Vector2D((double)tile.Resolution.X - 0.5, (double)tile.Resolution.Y - 0.5)),
tile.Resolution.X - 1, tile.Resolution.Y - 1);
_va = context.CreateVertexArray(mesh, spWireframe.VertexAttributes, BufferHint.StaticDraw);
_primitiveType = mesh.PrimitiveType;
///////////////////////////////////////////////////////////////////
RenderState rsTerrain = new RenderState();
rsTerrain.FacetCulling.FrontFaceWindingOrder = mesh.FrontFaceWindingOrder;
RenderState rsWireframe = new RenderState();
rsWireframe.Blending.Enabled = true;
rsWireframe.Blending.SourceRGBFactor = SourceBlendingFactor.SourceAlpha;
rsWireframe.Blending.SourceAlphaFactor = SourceBlendingFactor.SourceAlpha;
rsWireframe.Blending.DestinationRGBFactor = DestinationBlendingFactor.OneMinusSourceAlpha;
rsWireframe.Blending.DestinationAlphaFactor = DestinationBlendingFactor.OneMinusSourceAlpha;
rsWireframe.FacetCulling.FrontFaceWindingOrder = mesh.FrontFaceWindingOrder;
rsWireframe.DepthTest.Function = DepthTestFunction.LessThanOrEqual;
RenderState rsNormals = new RenderState();
rsNormals.FacetCulling.Enabled = false;
rsNormals.Blending.Enabled = true;
rsNormals.Blending.SourceRGBFactor = SourceBlendingFactor.SourceAlpha;
rsNormals.Blending.SourceAlphaFactor = SourceBlendingFactor.SourceAlpha;
rsNormals.Blending.DestinationRGBFactor = DestinationBlendingFactor.OneMinusSourceAlpha;
rsNormals.Blending.DestinationAlphaFactor = DestinationBlendingFactor.OneMinusSourceAlpha;
///////////////////////////////////////////////////////////////////
_drawStateTerrain = new DrawState(rsTerrain, spTerrain, _va);
_drawStateWireframe = new DrawState(rsWireframe, spWireframe, _va);
_drawStateNormals = new DrawState(rsNormals, spNormals, _va);
_tileMinimumHeight = tile.MinimumHeight;
_tileMaximumHeight = tile.MaximumHeight;
_heightExaggeration = 1;
_normalsAlgorithm = TerrainNormalsAlgorithm.ForwardDifference;
_showTerrain = true;
_dirty = true;
}
public override IEnumerable <RenderObject> RenderPaths(IEnumerable <Path2D> paths, StylePen line,
StylePen highlightLine, StylePen selectLine,
StylePen outline, StylePen highlightOutline,
StylePen selectOutline, RenderState renderState)
{
return(renderPath(paths));
}
public ModelViewer(string name, IDrawable drawable, MainWindow win, UtfTab parent, ModelNodes hprefs)
{
selectedCam = win.Config.DefaultCameraMode;
LibreLancer.Shaders.AllShaders.Compile();
Title = string.Format("Model Viewer ({0})", name);
Name = name;
this.drawable = drawable;
this.parent = parent;
this.hprefs = hprefs;
rstate = win.RenderState;
vps = win.Viewport;
res = win.Resources;
buffer = win.Commands;
_window = win;
if (drawable is CmpFile)
{
//Setup Editor UI for constructs + hardpoints
vmsModel = (drawable as CmpFile).CreateRigidModel(true);
animator = new AnimationComponent(vmsModel, (drawable as CmpFile).Animation);
int maxLevels = 0;
foreach (var p in vmsModel.AllParts)
{
if (p.Mesh != null && p.Mesh.Levels != null)
{
maxLevels = Math.Max(maxLevels, p.Mesh.Levels.Length);
if (p.Mesh.Switch2 != null)
{
foreach (var d in p.Mesh.Switch2)
{
maxDistance = Math.Max(d, maxDistance);
}
}
}
}
foreach (var cmpPart in (drawable as CmpFile).Parts)
{
if (cmpPart.Camera != null)
{
cameraPart = cmpPart;
break;
}
}
levels = new string[maxLevels];
for (int i = 0; i < maxLevels; i++)
{
levels[i] = i.ToString();
}
}
else if (drawable is ModelFile)
{
vmsModel = (drawable as ModelFile).CreateRigidModel(true);
levels = new string[vmsModel.AllParts[0].Mesh.Levels.Length];
for (int i = 0; i < levels.Length; i++)
{
levels[i] = i.ToString();
}
if (vmsModel.Root.Mesh.Switch2 != null)
{
foreach (var d in vmsModel.Root.Mesh.Switch2)
{
maxDistance = Math.Max(d, maxDistance);
}
}
}
else if (drawable is SphFile)
{
levels = new string[] { "0" };
vmsModel = (drawable as SphFile).CreateRigidModel(true);
}
if (vmsModel != null)
{
foreach (var p in vmsModel.AllParts)
{
foreach (var hp in p.Hardpoints)
{
gizmos.Add(new HardpointGizmo(hp, p));
}
if (p.Wireframe != null)
{
hasVWire = true;
}
}
}
SetupViewport();
maxDistance += 50;
popups = new PopupManager();
popups.AddPopup("Confirm Delete", ConfirmDelete, ImGuiWindowFlags.AlwaysAutoResize);
popups.AddPopup("Warning", MinMaxWarning, ImGuiWindowFlags.AlwaysAutoResize);
popups.AddPopup("Apply Complete", (x) =>
{
ImGui.Text("Hardpoints successfully written");
if (ImGui.Button("Ok"))
{
ImGui.CloseCurrentPopup();
}
}, ImGuiWindowFlags.AlwaysAutoResize);
popups.AddPopup("Apply Complete##Parts", (x) =>
{
ImGui.Text("Parts successfully written");
if (ImGui.Button("Ok"))
{
ImGui.CloseCurrentPopup();
}
}, ImGuiWindowFlags.AlwaysAutoResize);
popups.AddPopup("New Hardpoint", NewHardpoint, ImGuiWindowFlags.AlwaysAutoResize);
}
