private void InitalizeGraphics()
{
if (Window.RenderCanvasHandle == IntPtr.Zero)
throw new InvalidOperationException("Window handle cannot be zero");
SwapChainDescription swapChainDesc = new SwapChainDescription()
{
BufferCount = 1,
Flags = SwapChainFlags.None,
IsWindowed = true,
OutputHandle = Window.RenderCanvasHandle,
SwapEffect = SwapEffect.Discard,
Usage = Usage.RenderTargetOutput,
ModeDescription = new ModeDescription()
{
Format = SlimDX.DXGI.Format.R8G8B8A8_UNorm,
//Format = SlimDX.DXGI.Format.B8G8R8A8_UNorm,
Width = Window.ClientSize.Width,
Height = Window.ClientSize.Height,
RefreshRate = new Rational(60, 1),
Scaling = DisplayModeScaling.Unspecified,
ScanlineOrdering = DisplayModeScanlineOrdering.Unspecified
},
SampleDescription = new SampleDescription(1, 0)
};
var giFactory = new SlimDX.DXGI.Factory();
var adapter = giFactory.GetAdapter(0);
Device device;
SwapChain swapChain;
Device.CreateWithSwapChain(adapter, DriverType.Hardware, DeviceCreationFlags.None, swapChainDesc, out device, out swapChain);
_swapChain = swapChain;
GraphicsDevice = device;
// create a view of our render target, which is the backbuffer of the swap chain we just created
using (var resource = SlimDX.Direct3D10.Resource.FromSwapChain<Texture2D>(swapChain, 0))
{
_backBuffer = new RenderTargetView(device, resource);
}
// setting a viewport is required if you want to actually see anything
var viewport = new Viewport(0, 0, Window.ClientSize.Width, Window.ClientSize.Height);
device.OutputMerger.SetTargets(_backBuffer);
device.Rasterizer.SetViewports(viewport);
CreateDepthStencil();
LoadVisualizationEffect();
// Allocate a large buffer to write the PhysX visualization vertices into
// There's more optimized ways of doing this, but for this sample a large buffer will do
_userPrimitivesBuffer = new SlimDX.Direct3D10.Buffer(GraphicsDevice, VertexPositionColor.SizeInBytes * 50000, ResourceUsage.Dynamic, BindFlags.VertexBuffer, CpuAccessFlags.Write, ResourceOptionFlags.None);
var elements = new[]
{
new InputElement("Position", 0, Format.R32G32B32A32_Float, 0, 0),
new InputElement("Color", 0, Format.R32G32B32A32_Float, 16, 0)
};
_inputLayout = new InputLayout(GraphicsDevice, _visualizationEffect.RenderScenePass0.Description.Signature, elements);
}
// Pack input data to ulong
public static ulong GenerateBits(FSLayer layer, Viewport vp, VPLayer vpLayer, Translucency trans, ushort Material, ushort depth, ushort ibID, ushort vbID)
{
ulong result = (ulong)layer << 62;
result += (ulong)vp << 59;
result += (ulong)vpLayer << 56;
result += (ulong)trans << 54;
int maxvb = 1 << 10;
if (vbID > maxvb || ibID > maxvb)
{
// Overflow
Common.Instance.WriteLine("VB/IB OVERFLOW!!!");
}
result += (ulong)vbID << 43;
result += (ulong)ibID << 32;
if (trans == Translucency.OPAQUE)
{
// Material first
result += (ulong)Material << 16;
result += (ulong)depth;
}
else
{
// Depth first
result += (ulong)depth << 16;
result += (ulong)Material;
}
if (vpLayer != GetVPLayer(result))
{
int test = 2;
}
return result;
}
/// <summary>
/// Constructor that takes an attribute list.
/// </summary>
/// <param name="attrList"> A <see cref="System.Int32"/>. </param>
public ViewportAdapter(System.Int32[] attrList) : base(attrList)
{
Viewport = new Viewport(this);
// make sure the viewport catches all events
AddEvents((int)Gdk.EventMask.AllEventsMask);
// mouse interaction signals
ButtonPressEvent += OnButtonPress;
ButtonReleaseEvent += OnButtonRelease;
MotionNotifyEvent += OnMotionNotify;
ScrollEvent += OnScroll;
KeyPressEvent += OnKeyPress;
KeyReleaseEvent += OnKeyRelease;
// Connect some other signals
DeleteEvent += OnWindowDeleteEvent;
ExposeEvent += OnExposed;
Realized += OnRealized;
SizeAllocated += OnSizeAllocated;
ConfigureEvent += OnConfigure;
CanFocus = true;
GrabFocus();
}
public void InitializeD3D()
{
var description = new SwapChainDescription()
{
BufferCount = 2,
Usage = Usage.RenderTargetOutput,
OutputHandle = form.Handle,
IsWindowed = true,
ModeDescription = new ModeDescription(0, 0, new Rational(60, 1), Format.R8G8B8A8_UNorm),
SampleDescription = new SampleDescription(1, 0),
Flags = SwapChainFlags.AllowModeSwitch,
SwapEffect = SwapEffect.Discard
};
//Create swap chain
Device.CreateWithSwapChain(DriverType.Hardware, DeviceCreationFlags.None, description, out this.device, out swapChain);
// create a view of our render target, which is the backbuffer of the swap chain we just created
// setting a viewport is required if you want to actually see anything
var resource = Resource.FromSwapChain<Texture2D>(swapChain, 0);
renderTarget = new RenderTargetView(device, resource);
var context = device.ImmediateContext;
var viewport = new Viewport(0.0f, 0.0f, form.ClientSize.Width, form.ClientSize.Height);
context.OutputMerger.SetTargets(renderTarget);
context.Rasterizer.SetViewports(viewport);
}
public void LoadResources()
{
if (m_Disposed == true)
{
Buffer = new Texture2D(GameEnvironment.Device, new Texture2DDescription()
{
Format = m_Format,
Width = m_Width,
Height = m_Height,
OptionFlags = ResourceOptionFlags.None,
MipLevels = 1,
ArraySize = 1,
BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.None,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default
});
View = new RenderTargetView(GameEnvironment.Device, Buffer);
ResourceView = new ShaderResourceView(GameEnvironment.Device, Buffer);
Viewport = new Viewport(0, 0, Buffer.Description.Width, Buffer.Description.Height);
m_Disposed = false;
}
}
public override HitResult CheckHit(SETItem item, Vector3 Near, Vector3 Far, Viewport Viewport, Matrix Projection, Matrix View, MatrixStack transform)
{
HitResult result = HitResult.NoHit;
transform.Push();
transform.NJTranslate(item.Position.ToVector3());
transform.NJRotateY(item.Rotation.Y);
transform.Push();
transform.NJTranslate(0, 0, 10);
transform.NJScale(0.1000000014901161f, 0.1000000014901161f, 2);
result = HitResult.Min(result, model.CheckHit(Near, Far, Viewport, Projection, View, transform, meshes));
transform.Pop();
transform.Push();
transform.NJTranslate(0, 0, 20);
transform.NJRotateX(0x2000);
transform.NJTranslate(0, 0, -3);
transform.NJScale(0.1000000014901161f, 0.1000000014901161f, 0.699999988079071f);
result = HitResult.Min(result, model.CheckHit(Near, Far, Viewport, Projection, View, transform, meshes));
transform.Pop();
transform.Push();
transform.NJTranslate(0, 0, 20);
transform.NJRotateX(0xE000);
transform.NJTranslate(0, 0, -3);
transform.NJScale(0.1000000014901161f, 0.1000000014901161f, 0.699999988079071f);
result = HitResult.Min(result, model.CheckHit(Near, Far, Viewport, Projection, View, transform, meshes));
transform.Pop();
transform.NJScale((item.Scale.X + 10) / 5f, (item.Scale.Y + 10) / 5f, 0.1000000014901161f);
result = HitResult.Min(result, model.CheckHit(Near, Far, Viewport, Projection, View, transform, meshes));
transform.Pop();
return result;
}
private void Raycast(Vector2 screenPos)
{
var backBuffer = GraphicsDevice.Presenter.BackBuffer;
screenPos.X *= backBuffer.Width;
screenPos.Y *= backBuffer.Height;
var viewport = new Viewport(0, 0, backBuffer.Width, backBuffer.Height);
var unprojectedNear =
viewport.Unproject(
new Vector3(screenPos, 0.0f),
camera.ProjectionMatrix,
camera.ViewMatrix,
Matrix.Identity);
var unprojectedFar =
viewport.Unproject(
new Vector3(screenPos, 1.0f),
camera.ProjectionMatrix,
camera.ViewMatrix,
Matrix.Identity);
var result = simulation.Raycast(unprojectedNear, unprojectedFar);
if (!result.Succeeded || result.Collider == null) return;
var rigidBody = result.Collider as RigidbodyComponent;
if (rigidBody == null) return;
rigidBody.Activate();
rigidBody.ApplyImpulse(new Vector3(0, 5, 0));
}
/// <summary>
/// Create Direct3D device and swap chain
/// </summary>
protected void InitDevice()
{
device = D3DDevice.CreateDeviceAndSwapChain(directControl.Handle, out swapChain);
// Create a render target view
using (Texture2D pBuffer = swapChain.GetBuffer<Texture2D>(0))
{
renderTargetView = device.CreateRenderTargetView(pBuffer);
}
device.OM.SetRenderTargets(new RenderTargetView[] { renderTargetView });
// Setup the viewport
Viewport vp = new Viewport()
{
Width = (uint)directControl.ClientSize.Width,
Height = (uint)directControl.ClientSize.Height,
MinDepth = 0.0f,
MaxDepth = 1.0f,
TopLeftX = 0,
TopLeftY = 0
};
device.RS.SetViewports(new Viewport[] { vp });
}
public FilterPixelShader(Device device, int imageWidth, int imageHeight, int constantBufferSize, string pixelShaderBytecodeFilename)
{
vertexShader = new VertexShader(device, new ShaderBytecode(File.ReadAllBytes("Content/FullScreenQuadVS.cso")));
pixelShader = new PixelShader(device, new ShaderBytecode(File.ReadAllBytes(pixelShaderBytecodeFilename)));
var rasterizerStateDesc = new RasterizerStateDescription()
{
CullMode = CullMode.None,
FillMode = FillMode.Solid,
IsDepthClipEnabled = false,
IsFrontCounterClockwise = true,
IsMultisampleEnabled = false,
};
rasterizerState = new RasterizerState(device, rasterizerStateDesc);
if (constantBufferSize > 0)
{
var constantBufferDesc = new BufferDescription()
{
Usage = ResourceUsage.Dynamic,
BindFlags = BindFlags.ConstantBuffer,
SizeInBytes = constantBufferSize,
CpuAccessFlags = CpuAccessFlags.Write,
StructureByteStride = 0,
OptionFlags = 0,
};
constantBuffer = new Buffer(device, constantBufferDesc);
}
viewport = new Viewport(0, 0, imageWidth, imageHeight); // TODO: get these dimensions
vertexBufferBinding = new VertexBufferBinding(null, 0, 0);
}
public RenderTarget(Device device, int width, int height, int sampleCount, int sampleQuality, Format format)
: this()
{
Texture = _disposer.Add(new Texture2D(device, new Texture2DDescription
{
Format = format,
Width = width,
Height = height,
ArraySize = 1,
MipLevels = 1,
BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None,
Usage = ResourceUsage.Default,
SampleDescription = new SampleDescription(sampleCount, sampleQuality),
}));
RenderTargetView = _disposer.Add(new RenderTargetView(device, Texture, new RenderTargetViewDescription
{
Format = format,
Dimension = RenderTargetViewDimension.Texture2DMultisampled,
//MipSlice = 0,
}));
ShaderResourceView = _disposer.Add(new ShaderResourceView(device, Texture));
Viewport = new Viewport(0, 0, width, height, 0.0f, 1.0f);
}
public Sprite initialize(Viewport v)
{
created_at = DateTime.Now;
viewport = v;
viewport.sprites.Add(this);
return this;
}
public static void CreateDeviceSwapChainAndRenderTarget(Form form,
out Device device, out SwapChain swapChain, out RenderTargetView renderTarget)
{
try
{
// the debug mode requires the sdk to be installed otherwise an exception is thrown
device = new Device(DeviceCreationFlags.Debug);
}
catch (Direct3D10Exception)
{
device = new Device(DeviceCreationFlags.None);
}
var swapChainDescription = new SwapChainDescription();
var modeDescription = new ModeDescription();
var sampleDescription = new SampleDescription();
modeDescription.Format = Format.R8G8B8A8_UNorm;
modeDescription.RefreshRate = new Rational(60, 1);
modeDescription.Scaling = DisplayModeScaling.Unspecified;
modeDescription.ScanlineOrdering = DisplayModeScanlineOrdering.Unspecified;
modeDescription.Width = WIDTH;
modeDescription.Height = HEIGHT;
sampleDescription.Count = 1;
sampleDescription.Quality = 0;
swapChainDescription.ModeDescription = modeDescription;
swapChainDescription.SampleDescription = sampleDescription;
swapChainDescription.BufferCount = 1;
swapChainDescription.Flags = SwapChainFlags.None;
swapChainDescription.IsWindowed = true;
swapChainDescription.OutputHandle = form.Handle;
swapChainDescription.SwapEffect = SwapEffect.Discard;
swapChainDescription.Usage = Usage.RenderTargetOutput;
using (var factory = new Factory())
{
swapChain = new SwapChain(factory, device, swapChainDescription);
}
using (var resource = swapChain.GetBuffer<Texture2D>(0))
{
renderTarget = new RenderTargetView(device, resource);
}
var viewport = new Viewport
{
X = 0,
Y = 0,
Width = WIDTH,
Height = HEIGHT,
MinZ = 0.0f,
MaxZ = 1.0f
};
device.Rasterizer.SetViewports(viewport);
device.OutputMerger.SetTargets(renderTarget);
}
/// <summary>
/// Create Direct3D device and swap chain
/// </summary>
public void InitDevice()
{
device = D3DDevice.CreateDeviceAndSwapChain(host.Handle, out swapChain);
// Create a render target view
using (Texture2D pBuffer = swapChain.GetBuffer<Texture2D>(0))
{
renderTargetView = device.CreateRenderTargetView(pBuffer);
}
device.OM.SetRenderTargets(new RenderTargetView[] { renderTargetView }, null);
// Setup the viewport
Viewport vp = new Viewport()
{
Width = (uint)host.ActualWidth,
Height = (uint)host.ActualHeight,
MinDepth = 0.0f,
MaxDepth = 1.0f,
TopLeftX = 0,
TopLeftY = 0
};
device.RS.SetViewports(new Viewport[] { vp });
}
void SetupViewport()
{
var renderer = Renderer;
var graphics = Graphics;
renderer.NumViewports = 2;
// Set up the front camera viewport
Viewport viewport = new Viewport(Context, scene, CameraNode.GetComponent<Camera>(), null);
renderer.SetViewport(0, viewport);
// Clone the default render path so that we do not interfere with the other viewport, then add
// bloom and FXAA post process effects to the front viewport. Render path commands can be tagged
// for example with the effect name to allow easy toggling on and off. We start with the effects
// disabled.
var cache = ResourceCache;
RenderPath effectRenderPath = viewport.RenderPath.Clone();
effectRenderPath.Append(cache.GetXmlFile("PostProcess/Bloom.xml"));
effectRenderPath.Append(cache.GetXmlFile("PostProcess/FXAA2.xml"));
// Make the bloom mixing parameter more pronounced
effectRenderPath.SetShaderParameter("BloomMix", new Vector2(0.9f, 0.6f));
effectRenderPath.SetEnabled("Bloom", false);
effectRenderPath.SetEnabled("FXAA2", false);
viewport.RenderPath = effectRenderPath;
// Set up the rear camera viewport on top of the front view ("rear view mirror")
// The viewport index must be greater in that case, otherwise the view would be left behind
IntRect rect = new IntRect(graphics.Width*2/3, 32, graphics.Width - 32, graphics.Height/3);
Viewport rearViewport = new Viewport(Context, scene, rearCameraNode.GetComponent<Camera>(), rect, null);
renderer.SetViewport(1, rearViewport);
}
public Minimap(Device device, DeviceContext dc, int minimapWidth, int minimapHeight, Terrain terrain, CameraBase viewCam)
{
_dc = dc;
_minimapViewport = new Viewport(0, 0, minimapWidth, minimapHeight);
CreateMinimapTextureViews(device, minimapWidth, minimapHeight);
_terrain = terrain;
SetupOrthoCamera();
_viewCam = viewCam;
// frustum vb will contain four corners of view frustum, with first vertex repeated as the last
var vbd = new BufferDescription(
VertexPC.Stride * 5,
ResourceUsage.Dynamic,
BindFlags.VertexBuffer,
CpuAccessFlags.Write,
ResourceOptionFlags.None,
0
);
_frustumVB = new Buffer(device, vbd);
_edgePlanes = new[] {
new Plane(1, 0, 0, -_terrain.Width / 2),
new Plane(-1, 0, 0, _terrain.Width / 2),
new Plane(0, 1, 0, -_terrain.Depth / 2),
new Plane(0, -1, 0, _terrain.Depth / 2)
};
ScreenPosition = new Vector2(0.25f, 0.75f);
Size = new Vector2(0.25f, 0.25f);
}
public static ScreenOffset Offset(Vector3 point, Rectangle bounds, Viewport viewport, Matrix projection,
Matrix view, Matrix currentAttitude)
{
// Create a World matrix for the point.
var world = Matrix.CreateWorld(point, new Vector3(0, 0, -1), new Vector3(0, 1, 0));
// Use Viewport.Project to project the point from 3D space into screen coordinates.
var projected = viewport.Project(Vector3.Zero, projection, view, world*currentAttitude);
if (projected.Z > 1 || projected.Z < 0)
{
// If the point is outside of this range, it is behind the camera.
// So hide the TextBlock for this point.
return default(ScreenOffset);
}
// Create a TranslateTransform to position the TextBlock.
// Offset by half of the TextBlock's RenderSize to center it on the point.
var tt = new ScreenOffset
{
TranslateX = projected.X - (bounds.Width/2),
TranslateY = projected.Y - (bounds.Height/2),
Scale = 1/projected.Z
};
return tt;
}
public static PrimitiveRasterizer CreateRasterizer(
PrimitiveTopology primitiveTopology,
RasterizerStateDescription rasterizerState,
int multiSampleCount,
ShaderOutputInputBindings outputInputBindings,
ref Viewport viewport,
Func<int, int, bool> fragmentQuadFilter)
{
switch (primitiveTopology)
{
case PrimitiveTopology.PointList:
throw new NotImplementedException();
case PrimitiveTopology.LineList:
case PrimitiveTopology.LineStrip:
throw new NotImplementedException();
case PrimitiveTopology.TriangleList:
case PrimitiveTopology.TriangleStrip:
return new TriangleRasterizer(
rasterizerState, multiSampleCount,
outputInputBindings, ref viewport,
fragmentQuadFilter);
default:
throw new ArgumentOutOfRangeException("primitiveTopology");
}
}
public ViewPortInfo(ElementId id, XYZ location, View v, Viewport vp)
{
this.id = id;
this.location = location;
this.view = v;
this.vport = vp;
}
public RenderTarget(Device device, SwapChain swapChain)
: this()
{
Texture = _disposer.Add(Texture2D.FromSwapChain<Texture2D>(swapChain, 0));
RenderTargetView = _disposer.Add(new RenderTargetView(device, Texture));
ShaderResourceView = null;
Viewport = new Viewport(0, 0, Width, Height, 0.0f, 1.0f);
}
protected virtual void ChooseSceneManager()
{
sceneMgr = mRoot.CreateSceneManager(SceneType.ST_GENERIC);
camera = sceneMgr.CreateCamera("Camera");
camera.Position = new Vector3(0, 0, 150);
camera.LookAt(Vector3.ZERO);
mViewport = mRenderWindow.AddViewport(camera);
}
public Camera(Viewport viewport)
{
this.Viewport = viewport;
this.ZoomFactor = 1.0f;
this.ViewPortCenter = new Vector(viewport.Width / 2.0f, viewport.Height / 2.0f);
this.innerPosition = Vector.Zero;
this.Position = Vector.Zero;
}
/// <summary>
/// Create a GameState without initializing a level in it.
/// </summary>
/// <param name="stack">The GameStateStack to which this GameState belongs</param>
public GameState(GameStateStack stack)
: this()
{
this.stack = stack;
this.bgRenderable = new Sprite(Resources.getRes("starfield"));
this.bgRenderable.Tiled = true;
this.view = new Viewport(Vector2.Zero, 500 * (Vector2.One + 0.667f * Vector2.UnitX));
}
partial void PickingUpdate(RenderUIElement renderUIElement, Viewport viewport, ref Matrix worldViewProj, GameTime drawTime)
{
if (renderUIElement.UIComponent.Page?.RootElement == null)
return;
UpdateMouseOver(ref viewport, ref worldViewProj, renderUIElement);
UpdateTouchEvents(ref viewport, ref worldViewProj, renderUIElement, drawTime);
}
public void InitializeViewport()
{
// Initialize the viewport and matrixes for 3d projection.
viewport = new Viewport(0, 0, (int)this.ActualWidth, (int)this.ActualHeight);
float aspect = viewport.AspectRatio;
projection = Matrix.CreatePerspectiveFieldOfView(1, aspect, 1, 12);
view = Matrix.CreateLookAt(new Vector3(0, 0, 1), Vector3.Zero, Vector3.Up);
}
public static HitResult CheckSpriteHit(Vector3 Near, Vector3 Far, Viewport Viewport, Matrix Projection, Matrix View, MatrixStack transform)
{
Vector3 pos = Vector3.Unproject(Near, Viewport, Projection, View, transform.Top);
Vector3 dir = Vector3.Subtract(pos, Vector3.Unproject(Far, Viewport, Projection, View, transform.Top));
IntersectInformation info;
if (!SquareMesh.Intersect(pos, dir, out info)) return HitResult.NoHit;
return new HitResult(null, info.Dist);
}
public void Open(DemoOpenInfo demoInfo)
{
this.window = demoInfo.Window;
this.viewport = demoInfo.Viewport;
this.scene = demoInfo.Scene;
this.demoInfo = demoInfo;
Open();
}
public static void Pan(Viewport transform, Point currentMap, Point previousMap)
{
Point current = transform.ScreenToWorld(currentMap.X, currentMap.Y);
Point previous = transform.ScreenToWorld(previousMap.X, previousMap.Y);
double diffX = previous.X - current.X;
double diffY = previous.Y - current.Y;
transform.Center = new Point(transform.CenterX + diffX, transform.CenterY + diffY);
}
public override void Render(View3D view, Viewport viewport)
{
m_View.Resize(new System.Drawing.Rectangle(0, 0, (int)viewport.Width, (int)viewport.Height), (int)viewport.Width, (int)viewport.Height);
float x, y, w, h;
float widthPerImage = (float)(viewport.Width / m_KinectColorImages.Count);
float heightPerImage = (widthPerImage / 4) * 3;
RectangleF imageBounds = new RectangleF(0, (viewport.Height - heightPerImage) * 0.5f, widthPerImage, heightPerImage);
switch (KinectImageMode)
{
case KinectImageMode.Color:
foreach (KinectColorImageTexture color in m_KinectColorImages)
{
UiStyleHelper.CovertToVertCoords(imageBounds, m_View.WindowSize, m_View.PixelSize, out x, out y, out w, out h);
color.Rectangle = new RectangleF(x, y, w, h);
color.Update();
color.Render(m_View);
imageBounds.Offset(widthPerImage, 0);
}
break;
case KinectImageMode.RawDepth:
case KinectImageMode.DepthBackgroundImage:
case KinectImageMode.DepthBackgroundRemoved:
foreach (KinectDepthImageTexture depth in m_KinectDepthImages)
{
UiStyleHelper.CovertToVertCoords(imageBounds, m_View.WindowSize, m_View.PixelSize, out x, out y, out w, out h);
depth.Rectangle = new RectangleF(x, y, w, h);
switch (KinectImageMode)
{
case KinectImageMode.RawDepth:
depth.ImageType = KinectDepthImageType.RawDepth;
break;
case KinectImageMode.DepthBackgroundImage:
depth.ImageType = KinectDepthImageType.DepthBackgroundImage;
break;
case KinectImageMode.DepthBackgroundRemoved:
depth.ImageType = KinectDepthImageType.DepthBackgroundRemoved;
break;
default:
break;
}
depth.Update();
depth.Render(m_View);
imageBounds.Offset(widthPerImage, 0);
}
break;
default:
break;
}
}
public override HitResult CheckHit(Vector3 Near, Vector3 Far, Viewport Viewport, Matrix Projection, Matrix View)
{
MatrixStack transform = new MatrixStack();
transform.Push();
transform.NJTranslate(0, offset, 0);
transform.NJTranslate(Position);
transform.NJRotateY(YRotation);
return Model.CheckHit(Near, Far, Viewport, Projection, View, transform, Meshes);
}
/// <summary>
/// Initialize a GameState without initializing anything in it.
/// </summary>
public GameState()
{
this.view = new Viewport(Vector2.Zero, 500*(Vector2.One + 0.667f*Vector2.UnitX));
this.pie.Origin = new Vector2(0.0f, pie.Origin.Y);
abilityColors.Add(1, Color.Green); dirs.Add(1, Vector2.UnitY);
abilityColors.Add(2, Color.Red); dirs.Add(2, Vector2.UnitX);
abilityColors.Add(3, Color.Blue); dirs.Add(3, -Vector2.UnitX);
abilityColors.Add(4, Color.Orange); dirs.Add(4, -Vector2.UnitY);
}
/*public float Calcmargin(int dim, float _margin)
* {
* if (p == Positioning.Absolute)
* {
* return _margin;
* }
* else
* {
* return (dim * (_margin / 100));
* }
* }*/
public override void Draw(SpriteBatch sb, Viewport v)
{
//i.Resise(new Size(size.width + (2 * Calcmargin(v.Width, margin)), size.height + (2 * Calcmargin(v.Height, margin))));
i.Draw(sb, v);
base.Draw(sb, v);
}
public override void _Ready()
{
Viewport root = GetTree().GetRoot();
}
public Camera(Viewport vPort)
{
position = new Vector2(0, 0);
viewPort = vPort;
}
public void Draw(Matrix view, Viewport viewport, Matrix projection, float scale, Vector3 cameraPosition, Vector3 cameraTarget)
{
board.Draw(view, viewport, projection, scale, cameraPosition, cameraTarget);
}
public ToolkitFrameSnapshot(ElementTag worldTag, ElementTag camera)
{
Viewport = new Viewport();
WorldTag = worldTag;
CurrentCameraTag = camera;
}
public override void Draw(Microsoft.Xna.Framework.GameTime gameTime)
{
SpriteBatch spriteBatch = ScreenManager.SpriteBatch;
Viewport viewport = ScreenManager.GraphicsDevice.Viewport;
SpriteFont littleFont = ScreenManager.LittleFont;
SpriteFont font = ScreenManager.Font;
SpriteFont bigFont = ScreenManager.BigFont;
Color titleColor = new Color(192, 192, 192) * TransitionAlpha;
Color yellowColor = new Color(255, 255, 0) * TransitionAlpha;
Vector2 position = new Vector2(0, 0);
float transitionOffset = (float)Math.Pow(TransitionPosition, 2);
if (ScreenState == ScreenState.TransitionOn)
{
position.X -= transitionOffset * 256;
}
else
{
position.X += transitionOffset * 512;
}
spriteBatch.Begin();
//draw background image
Vector2 backgroundOrigin = new Vector2(backgroundTexture.Width / 2, 0);
Vector2 backgroundPosition = new Vector2((viewport.Width / 2) + position.X, 0);
spriteBatch.Draw(backgroundTexture, backgroundPosition, null, titleColor, 0, backgroundOrigin, Vector2.One, SpriteEffects.None, 0);
//draw title
String titleString = "Lifetime Game Stats";
Vector2 titleOrigin = Utils.Utils.Instance.GetTextStringCenterOrigin(titleString, font);
Vector2 titleScale = new Vector2(1.4f, 1.4f);
Vector2 titlePosition = new Vector2((viewport.Width / 2) + position.X, 120);
spriteBatch.DrawString(font, titleString, titlePosition, yellowColor, 0, titleOrigin, titleScale, SpriteEffects.None, 0);
//draw stats
List <GameboardStats.StatValue> statValues = stats.SetValuesForStatsScreen();
int i = 0;
foreach (GameboardStats.StatValue statValue in statValues)
{
i++;
String initials = statValue.name;
String score = "" + statValue.value;
int heightOffset = (font.LineSpacing - 12) * i;
Vector2 scoreOrigin = Utils.Utils.Instance.GetTextStringRightOrigin(score, font);
Vector2 scorePosition = new Vector2(position.X + 980, 170 + heightOffset);
Vector2 initialsPosition = new Vector2(position.X + 300, 170 + heightOffset);
Vector2 initialsOrigin = new Vector2(0, scoreOrigin.Y);
spriteBatch.DrawString(font, initials, initialsPosition, titleColor, 0,
initialsOrigin, Vector2.One, SpriteEffects.None, 0);
spriteBatch.DrawString(font, score, scorePosition, titleColor, 0,
scoreOrigin, Vector2.One, SpriteEffects.None, 0);
}
//draw button image and text
int xPixelOffset = (viewport.Width - backgroundTexture.Width) / 2;
Rectangle bButtonRect = new Rectangle((int)position.X + xPixelOffset + 220, 570, 40, 40);
spriteBatch.Draw(bButtonImage, bButtonRect, Color.White * TransitionAlpha);
Vector2 backToMenuPosition = new Vector2(bButtonRect.X + 50, bButtonRect.Y);
spriteBatch.DrawString(littleFont, "Back To Help & Options", backToMenuPosition, yellowColor);
spriteBatch.End();
}
public void CreateScene(string scene)
{
// Scene
Scene = new Scene(Context);
if (!string.IsNullOrEmpty(scene))
{
var xml = ResourceCache.GetFile(scene, false);
Scene.LoadXml(xml);
defaultScene = false;
}
else
{
var octree = Scene.CreateComponent <Octree>();
// turn off gravity because prefabs may have RigidBody components
Scene.CreateComponent <PhysicsWorld>().SetGravity(Vector3.Zero);
defaultScene = true;
}
Scene.CreateComponent <DebugRenderer>();
rootNode = Scene.CreateChild("RootNode");
rootNode.Position = new Vector3(x: 0, y: 0, z: 0);
var zoneNode = Scene.CreateChild("Zone");
var zone = zoneNode.GetComponent <Zone>() ?? zoneNode.CreateComponent <Zone>();
zone.SetBoundingBox(new BoundingBox(-10000.0f, 10000.0f));
zone.AmbientColor = new Color(0.8f, 0.8f, 0.8f);
// GUI
errorText = new Text();
errorText.VerticalAlignment = VerticalAlignment.Center;
errorText.HorizontalAlignment = HorizontalAlignment.Center;
errorText.SetColor(new Color(1f, 0.2f, 0.2f));
errorText.SetFont(font: CoreAssets.Fonts.AnonymousPro, size: 20);
UI.Root.AddChild(errorText);
// Camera
CameraNode = Scene.CreateChild(name: "Camera");
CameraNode.Position = new Vector3(0, 2, -10);
CameraNode.Rotation = new Quaternion(10, 0, 0);
Pitch = 8;
Camera = CameraNode.CreateComponent <Camera>();
Input.SetMouseVisible(true, false);
// Light
lightNode = CameraNode.CreateChild("DirectionalLight");
lightNode.Position = new Vector3(0, 20, -5);
//lightNode.SetDirection(new Vector3(0.2f, 0.0f, 1f));
lightNode.CreateComponent <Box>();
light = lightNode.CreateComponent <Light>();
light.LightType = LightType.Point;
light.CastShadows = true;
light.Brightness = 1.0f;
light.Range = 50;
// Viewport
Viewport = new Viewport(Context, Scene, Camera, null);
Renderer.SetViewport(0, Viewport);
Viewport.RenderPath.Append(CoreAssets.PostProcess.FXAA3);
ResetClearColor();
}
public async Task <byte[]> TakeScreenshotAsync(ScreenshotFormat format, ScreenshotOptions options, Viewport viewport)
{
var response = await _session.SendAsync(new PageScreenshotRequest
{
MimeType = format == ScreenshotFormat.Jpeg ? ScreenshotMimeType.ImageJpeg : ScreenshotMimeType.ImagePng,
FullPage = options.FullPage,
Clip = options.Clip,
}).ConfigureAwait(false);
return(Convert.FromBase64String(response.Data));
}
public Task ResetViewportAsync(Viewport viewport) => throw new NotImplementedException();
// UI Methods
public override void Draw(GameTime gameTime)
{
if (Visible && drawBox.Width > 0 && drawBox.Height > 0)
{
Viewport currentViewport = Game.GraphicsDevice.Viewport;
int viewportMaxX = currentViewport.X + currentViewport.Width;
int viewportMaxY = currentViewport.Y + currentViewport.Height;
int offsetX = drawBox.X;
int offsetY = drawBox.Y;
if (container != null)
{
offsetX -= container.ScrollX;
offsetY -= container.ScrollY;
}
// Ensure that it is inbounds.
if (((offsetX + drawBox.Width) > 0) && (offsetX < currentViewport.Width) && ((offsetY + drawBox.Height) > 0) && (offsetY < currentViewport.Height))
{
XnaDrawArgs e = new XnaDrawArgs();
e.gameTime = gameTime;
e.SpriteBatch = GetSpriteBatch(this);
e.Location = new Rectangle(0, 0, drawBox.Width, drawBox.Height);
Viewport componentViewport = currentViewport;
componentViewport.X = Math.Max(offsetX + currentViewport.X, currentViewport.X);
componentViewport.Y = Math.Max(offsetY + currentViewport.Y, currentViewport.Y);
// Fix the argument location if it is offset in the negative direction (cropped due to scrolling).
if (offsetX < 0)
{
e.Location.X = offsetX;
componentViewport.Width = Math.Max(currentViewport.Width, (offsetX + drawBox.Width));
}
else
{
componentViewport.Width = Math.Min(drawBox.Width, (currentViewport.Width - offsetX));
}
if (offsetY < 0)
{
e.Location.Y = offsetY;
componentViewport.Height = Math.Max(currentViewport.Height, (offsetY + drawBox.Height));
}
else
{
componentViewport.Height = Math.Min(drawBox.Height, (currentViewport.Height - offsetY));
}
// Likewise fix the height
Game.GraphicsDevice.Viewport = componentViewport;
// Do Draw work.
e.SpriteBatch.Begin();
onDraw(e);
e.SpriteBatch.End();
// Call draw on all children
foreach (XnaUIComponent child in components)
{
child.Draw(gameTime);
}
// Repair the viewport
Game.GraphicsDevice.Viewport = currentViewport;
}
}
}
//forward compatibility (since v3.4) for existing code with no drawDepth
public Camera3D(string id, ActorType actorType,
Transform3D transform, ProjectionParameters projectionParameters, Viewport viewPort)
: this(id, actorType, transform, projectionParameters,
viewPort, 0, StatusType.Updated)
{
}
public StartScreen(GameEventListener gameEventListener,
IFrameWork framework, Viewport viewport, Camera camera) :
base(gameEventListener, framework, viewport, camera)
{
this.fontSize = (uint)(0.83f * fontSize); // mniejsza czcionka na ekranie startowym
}
static Result InitDevice()
{
//int width = form.ClientSize.Width;
//int height = form.ClientSize.Height;
int width = 2500;
int height = 1000;
SlimDX.DXGI.SwapChainDescription swapChainDesc = new SlimDX.DXGI.SwapChainDescription()
{
BufferCount = 1,
ModeDescription = new SlimDX.DXGI.ModeDescription()
{
Width = width,
Height = height,
Format = SlimDX.DXGI.Format.B8G8R8A8_UNorm,
RefreshRate = new Rational(60, 1),
},
Usage = SlimDX.DXGI.Usage.RenderTargetOutput,
OutputHandle = form.Handle,
SampleDescription = new SlimDX.DXGI.SampleDescription {
Count = 1, Quality = 0
},
IsWindowed = true,
};
Device.CreateWithSwapChain(DriverType.Hardware, DeviceCreationFlags.None, new FeatureLevel[] { FeatureLevel.Level_11_0 }, swapChainDesc, out _Device, out _SwapChain);
if (Result.Last.IsFailure)
{
return(Result.Last);
}
// Create a render target view
Texture2D backBuffer = Resource.FromSwapChain <Texture2D>(_SwapChain, 0);
_ViewRenderTarget = new RenderTargetView(_Device, backBuffer);
backBuffer.Dispose();
if (Result.Last.IsFailure)
{
return(Result.Last);
}
_Device.ImmediateContext.OutputMerger.SetTargets(_ViewRenderTarget);
// Setup the viewport
Viewport vp = new Viewport
{
Width = width,
Height = height,
MinZ = 0.0f,
MaxZ = 1.0f,
X = 0,
Y = 0,
};
_Device.ImmediateContext.Rasterizer.SetViewports(vp);
// Compile the vertex shader
ShaderBytecode vertexShaderCode = ShaderBytecode.CompileFromFile("haha.fx", "VS", "vs_4_0", ShaderFlags.EnableStrictness | ShaderFlags.Debug, EffectFlags.None);
if (Result.Last.IsFailure)
{
return(Result.Last);
}
// Create the vertex shader
_VertexShader = new VertexShader(_Device, vertexShaderCode);
if (Result.Last.IsFailure)
{
return(Result.Last);
}
// Define the input layout
InputElement[] inputElements = new InputElement[2]
{
new InputElement("POSITION", 0, SlimDX.DXGI.Format.R32G32B32_Float, 0, 0, InputClassification.PerVertexData, 0),
new InputElement("TEXCOORD", 0, SlimDX.DXGI.Format.R32G32_Float, 12, 0, InputClassification.PerVertexData, 0),
};
_LayOut = new InputLayout(_Device, vertexShaderCode, inputElements);
vertexShaderCode.Dispose();
if (Result.Last.IsFailure)
{
return(Result.Last);
}
// Set the input layout
_Device.ImmediateContext.InputAssembler.InputLayout = _LayOut;
// Compile the pixel shader
ShaderBytecode pixelShaderCode = ShaderBytecode.CompileFromFile("haha.fx", "PS", "ps_4_0", ShaderFlags.EnableStrictness | ShaderFlags.Debug, EffectFlags.None);
if (Result.Last.IsFailure)
{
return(Result.Last);
}
// Create the pixel shader
_PixelShader = new PixelShader(_Device, pixelShaderCode);
pixelShaderCode.Dispose();
if (Result.Last.IsFailure)
{
return(Result.Last);
}
// Create vertex buffer
CustomVertex[] vertices = new CustomVertex[]
{
new CustomVertex()
{
Pos = new Vector3(-1.0f, 1.0f, 0.0f), Tex = new Vector2(0.0f, 0.0f)
}, // top left
new CustomVertex()
{
Pos = new Vector3(0.0f, 1.0f, 0.0f), Tex = new Vector2(1.0f, 0.0f)
}, // top right
new CustomVertex()
{
Pos = new Vector3(-1.0f, 0.0f, 0.0f), Tex = new Vector2(0.0f, 1.0f)
}, // lower left
new CustomVertex()
{
Pos = new Vector3(0.0f, 0.0f, 0.0f), Tex = new Vector2(1.0f, 1.0f)
}, // lower right
new CustomVertex()
{
Pos = new Vector3(0.0f, 1.0f, 0.0f), Tex = new Vector2(0.0f, 0.0f)
}, // top left
new CustomVertex()
{
Pos = new Vector3(1.0f, 1.0f, 0.0f), Tex = new Vector2(1.0f, 0.0f)
}, // top right
new CustomVertex()
{
Pos = new Vector3(0.0f, 0.0f, 0.0f), Tex = new Vector2(0.0f, 1.0f)
}, // lower left
new CustomVertex()
{
Pos = new Vector3(1.0f, 0.0f, 0.0f), Tex = new Vector2(1.0f, 1.0f)
}, // lower right
new CustomVertex()
{
Pos = new Vector3(-1.0f, 0.0f, 0.0f), Tex = new Vector2(0.0f, 0.0f)
}, // top left
new CustomVertex()
{
Pos = new Vector3(0.0f, 0.0f, 0.0f), Tex = new Vector2(1.0f, 0.0f)
}, // top right
new CustomVertex()
{
Pos = new Vector3(-1.0f, -1.0f, 0.0f), Tex = new Vector2(0.0f, 1.0f)
}, // lower left
new CustomVertex()
{
Pos = new Vector3(0.0f, -1.0f, 0.0f), Tex = new Vector2(1.0f, 1.0f)
}, // lower right
new CustomVertex()
{
Pos = new Vector3(0.0f, 0.0f, 0.0f), Tex = new Vector2(0.0f, 0.0f)
}, // top left
new CustomVertex()
{
Pos = new Vector3(1.0f, 0.0f, 0.0f), Tex = new Vector2(1.0f, 0.0f)
}, // top right
new CustomVertex()
{
Pos = new Vector3(0.0f, -1.0f, 0.0f), Tex = new Vector2(0.0f, 1.0f)
}, // lower left
new CustomVertex()
{
Pos = new Vector3(1.0f, -1.0f, 0.0f), Tex = new Vector2(1.0f, 1.0f)
}, // lower right
};
DataStream vertexData = new DataStream(vertices, true, false);
int stride = System.Runtime.InteropServices.Marshal.SizeOf(vertices[0]);
BufferDescription bufferDesc = new BufferDescription
{
Usage = ResourceUsage.Default,
SizeInBytes = vertices.Length * stride,
BindFlags = BindFlags.VertexBuffer,
CpuAccessFlags = CpuAccessFlags.None,
};
_VertexBuffer = new SlimDX.Direct3D11.Buffer(_Device, vertexData, bufferDesc);
if (Result.Last.IsFailure)
{
return(Result.Last);
}
// Set vertex buffer
_Device.ImmediateContext.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(_VertexBuffer, stride, 0));
// Create index buffer
int[] indices = new int[]
{
0, 1, 2,
1, 3, 2,
4, 5, 6,
5, 7, 6,
8, 9, 10,
9, 11, 10,
12, 13, 14,
13, 15, 14,
};
bufferDesc.SizeInBytes = sizeof(int) * indices.Length;
bufferDesc.BindFlags = BindFlags.IndexBuffer;
_IndexBuffer = new SlimDX.Direct3D11.Buffer(_Device, new DataStream(indices, false, false), bufferDesc);
if (Result.Last.IsFailure)
{
return(Result.Last);
}
// Set index buffer
_Device.ImmediateContext.InputAssembler.SetIndexBuffer(_IndexBuffer, SlimDX.DXGI.Format.R32_UInt, 0);
// Set primitive topology
_Device.ImmediateContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleList;
// Load the Texture
LoadTexture();
if (Result.Last.IsFailure)
{
return(Result.Last);
}
// Create the sample state
SamplerDescription sampDesc = new SamplerDescription
{
Filter = Filter.MinMagMipPoint,
AddressU = TextureAddressMode.Wrap,
AddressV = TextureAddressMode.Wrap,
AddressW = TextureAddressMode.Wrap,
ComparisonFunction = Comparison.Never,
MinimumLod = 0,
MaximumLod = float.MaxValue,
};
_SamplerLinear = SamplerState.FromDescription(_Device, sampDesc);
if (Result.Last.IsFailure)
{
return(Result.Last);
}
return(ResultCode.Success);
}
public void SetViewport(uint index, ref Viewport viewport)
{
NoAllocSetViewportEntry entry = new NoAllocSetViewportEntry(index, ref viewport);
AddEntry(SetViewportEntryID, ref entry);
}
public void UpdateScale(float scale, Vector2 origin, Viewport viewport)
{
CLevel.LayersUpdateScale(scale);
CLevel.LayersUpdateCameras(origin, viewport);
}
public Camera(Viewport newViewport)
{
viewport = newViewport;
}
public void ResetClearColor() => Viewport.SetClearColor(Color.White);
public void Resize(Viewport viewport)
{
Camera.Resize(viewport);
}
/// ワールド座標をスクリーン位置へ変換します。
public static Vector3 WorldToScreen(Vector3 v, Viewport viewport, Matrix view, Matrix proj)
{
return(Vector3.TransformCoordinate(v, view * proj * CreateViewportMatrix(viewport)));
}
public override void _Ready()
{
Viewport root = GetTree().Root;
MainScene = root.GetChild(root.GetChildCount() - 1);
}
public Camera(Viewport newView)
{
view = newView;
}
/// <summary>
/// Gets the viewport.
/// </summary>
/// <returns></returns>
public override Rect GetViewport()
{
Viewport viewport = GraphicsDevice.Viewport;
return(new Rect(viewport.X, viewport.Y, viewport.Width, viewport.Height));
}
//bool isDoubleJump = false;
//int jumpCount = 0;
public Player(Texture2D texture, Vector2 position, Color tint, Vector2 speed, Viewport vp)
: base(speed)
{
currentAnimation = new Animation(TimeSpan.Zero, currentFrames, texture, position, tint, new Vector2(3), 0, SpriteEffects.None);
AddAnimations(PlayerStates.idle, getFrames(@"D:\FOR DENNIS\KnightPack\valiant_knight\style_B\spritesheet \spritesheet.txt", "idle"), TimeSpan.FromMilliseconds(66));
//ChangeState(PlayerStates.idle);
playerState = PlayerStates.idle;
currentFrames = getFrames(@"D:\FOR DENNIS\KnightPack\valiant_knight\style_B\spritesheet \spritesheet.txt", "idle");
}
public Result Execute(
ExternalCommandData commandData,
ref string message,
ElementSet elements)
{
UIApplication uiapp = commandData.Application;
UIDocument uidoc = uiapp.ActiveUIDocument;
Application app = uiapp.Application;
Document doc = uidoc.Document;
View activeView = doc.ActiveView;
try
{
using (var form = new FormAddActiveView("Enter Sheet Number"))
{
using (Transaction t = new Transaction(doc))
{
Reference legendRef = uidoc.Selection.PickObject(ObjectType.Element, "Select a Legend");
form.ShowDialog();
//if the user hits cancel just drop out of macro
if (form.DialogResult == forms.DialogResult.Cancel)
{
return(Result.Cancelled);
}
string sheetNumber = form.TextString.ToString();
List <ElementId> sheetIds = new List <ElementId>();
IEnumerable <ViewSheet> sheetItr = new FilteredElementCollector(doc).OfClass(typeof(ViewSheet)).ToElements().Cast <ViewSheet>();
foreach (ViewSheet e in sheetItr)
{
if (sheetNumber.Contains(e.SheetNumber))
{
sheetIds.Add(e.Id);
}
}
Viewport legendVp = doc.GetElement(legendRef) as Viewport;
ElementId legendId = legendVp.ViewId;
XYZ center = legendVp.GetBoxCenter();
// start the transaction
t.Start("Add Legend");
// loop through the list of sheet ids
foreach (ElementId sheetid in sheetIds)
{
Viewport.Create(doc, sheetid, legendId, center);
}
// commit the changes
t.Commit();
}
}
return(Result.Succeeded);
}//close try
catch (Exception ex)
{
TaskDialog.Show("Error", ex.Message);
return(Result.Failed);
}
}
/// <summary>
/// Draws scaled 2D text. Note that x and y are in viewport coordinates
/// (ranging from -1 to +1). fXScale and fYScale are the size fraction
/// relative to the entire viewport. For example, a fXScale of 0.25 is
/// 1/8th of the screen width. This allows you to output text at a fixed
/// fraction of the viewport, even if the screen or window size changes.
/// </summary>
public void DrawTextScaled(float x, float y, float z, float fXScale, float fYScale, System.Drawing.Color color,
string text, RenderFlags flags)
{
if (device == null)
{
throw new System.ArgumentNullException();
}
// Set up renderstate
savedStateBlock.Capture();
drawTextStateBlock.Apply();
device.VertexFormat = CustomVertex.TransformedColoredTextured.Format;
device.PixelShader = null;
device.SetStreamSource(0, vertexBuffer, 0);
// Set filter states
if ((flags & RenderFlags.Filtered) != 0)
{
samplerState0.MinFilter = TextureFilter.Linear;
samplerState0.MagFilter = TextureFilter.Linear;
}
Viewport vp = device.Viewport;
float xpos = (x + 1.0f) * vp.Width / 2;
float ypos = (y + 1.0f) * vp.Height / 2;
float sz = z;
float rhw = 1.0f;
float fLineHeight = (textureCoords[0, 3] - textureCoords[0, 1]) * textureHeight;
// Adjust for character spacing
xpos -= spacingPerChar * (fXScale * vp.Height) / fLineHeight;
float fStartX = xpos;
// Fill vertex buffer
int numTriangles = 0;
int realColor = color.ToArgb();
int iv = 0;
foreach (char c in text)
{
if (c == '\n')
{
xpos = fStartX;
ypos += fYScale * vp.Height;
}
if ((c - 32) < 0 || (c - 32) >= 128 - 32)
{
continue;
}
float tx1 = textureCoords[c - 32, 0];
float ty1 = textureCoords[c - 32, 1];
float tx2 = textureCoords[c - 32, 2];
float ty2 = textureCoords[c - 32, 3];
float w = (tx2 - tx1) * textureWidth;
float h = (ty2 - ty1) * textureHeight;
w *= (fXScale * vp.Height) / fLineHeight;
h *= (fYScale * vp.Height) / fLineHeight;
if (c != ' ')
{
fontVertices[iv++] = new CustomVertex.TransformedColoredTextured(new Vector4(xpos + 0 - 0.5f, ypos + h - 0.5f, sz, rhw), realColor, tx1, ty2);
fontVertices[iv++] = new CustomVertex.TransformedColoredTextured(new Vector4(xpos + 0 - 0.5f, ypos + 0 - 0.5f, sz, rhw), realColor, tx1, ty1);
fontVertices[iv++] = new CustomVertex.TransformedColoredTextured(new Vector4(xpos + w - 0.5f, ypos + h - 0.5f, sz, rhw), realColor, tx2, ty2);
fontVertices[iv++] = new CustomVertex.TransformedColoredTextured(new Vector4(xpos + w - 0.5f, ypos + 0 - 0.5f, sz, rhw), realColor, tx2, ty1);
fontVertices[iv++] = new CustomVertex.TransformedColoredTextured(new Vector4(xpos + w - 0.5f, ypos + h - 0.5f, sz, rhw), realColor, tx2, ty2);
fontVertices[iv++] = new CustomVertex.TransformedColoredTextured(new Vector4(xpos + 0 - 0.5f, ypos + 0 - 0.5f, sz, rhw), realColor, tx1, ty1);
numTriangles += 2;
if (numTriangles * 3 > (MaxNumfontVertices - 6))
{
// Unlock, render, and relock the vertex buffer
vertexBuffer.SetData(fontVertices, 0, LockFlags.Discard);
device.DrawPrimitives(PrimitiveType.TriangleList, 0, numTriangles);
numTriangles = 0;
iv = 0;
}
}
xpos += w - (2 * spacingPerChar) * (fXScale * vp.Height) / fLineHeight;
}
// Unlock and render the vertex buffer
vertexBuffer.SetData(fontVertices, 0, LockFlags.Discard);
if (numTriangles > 0)
{
device.DrawPrimitives(PrimitiveType.TriangleList, 0, numTriangles);
}
// Restore the modified renderstates
savedStateBlock.Apply();
}
//
protected override void OnAttach()
{
base.OnAttach();
instance = this;
viewport = RendererWorld.Instance.DefaultViewport;
window = ControlDeclarationManager.Instance.CreateControl(
"Gui\\PostEffectsWindow.gui");
Controls.Add(window);
for (int n = 0; n < scrollBarFloatParameters.Length; n++)
{
scrollBarFloatParameters[n] = (EScrollBar)window.Controls[
"FloatParameter" + n.ToString()];
scrollBarFloatParameters[n].ValueChange += floatParameter_ValueChange;
}
for (int n = 0; n < checkBoxBoolParameters.Length; n++)
{
checkBoxBoolParameters[n] = (ECheckBox)window.Controls["BoolParameter" + n.ToString()];
checkBoxBoolParameters[n].CheckedChange += boolParameter_CheckedChange;
}
listBox = (EListBox)window.Controls["List"];
listBox.Items.Add("HDR");
listBox.Items.Add("LDRBloom");
listBox.Items.Add("Glass");
listBox.Items.Add("OldTV");
listBox.Items.Add("HeatVision");
listBox.Items.Add("MotionBlur");
listBox.Items.Add("RadialBlur");
listBox.Items.Add("Blur");
listBox.Items.Add("Grayscale");
listBox.Items.Add("Invert");
listBox.Items.Add("Tiling");
listBox.SelectedIndexChange += listBox_SelectedIndexChange;
checkBoxEnabled = (ECheckBox)window.Controls["Enabled"];
checkBoxEnabled.Click += checkBoxEnabled_Click;
for (int n = 0; n < listBox.Items.Count; n++)
{
EButton itemButton = listBox.ItemButtons[n];
ECheckBox checkBox = (ECheckBox)itemButton.Controls["CheckBox"];
string name = GetListCompositorItemName((string)listBox.Items[n]);
CompositorInstance compositorInstance = viewport.GetCompositorInstance(name);
if (compositorInstance != null && compositorInstance.Enabled)
{
checkBox.Checked = true;
}
if (itemButton.Text == "HDR")
{
checkBox.Enable = false;
}
checkBox.Click += listBoxCheckBox_Click;
}
listBox.SelectedIndex = 0;
((EButton)window.Controls["Close"]).Click += delegate(EButton sender)
{
SetShouldDetach();
};
//ApplyToTheScreenGUI
{
ECheckBox checkBox = (ECheckBox)window.Controls["ApplyToTheScreenGUI"];
checkBox.Checked = EngineApp.Instance.ScreenGuiRenderer.ApplyPostEffectsToScreenRenderer;
checkBox.Click += delegate(ECheckBox sender)
{
EngineApp.Instance.ScreenGuiRenderer.ApplyPostEffectsToScreenRenderer = sender.Checked;
};
}
}
public void Draw(SpriteBatch sb, Viewport v, Point parent)
{
base.Draw(sb, v);
sb.DrawString(f, t, calcuedpos.GetVector() + parent.GetVector(), c);
}
public override void Draw(SpriteBatch sb, Viewport v)
{
base.Draw(sb, v);
}
public override void Draw(SpriteBatch sb, Viewport v)
{
Draw(sb, v, Point.Zero);
}
//creates a default camera3D - we can use this for a fixed camera archetype i.e. one we will clone - see MainApp::InitialiseCameras()
public Camera3D(string id, ActorType actorType, Viewport viewPort)
: this(id, actorType, Transform3D.Zero,
ProjectionParameters.StandardMediumFourThree, viewPort, 0, StatusType.Updated)
{
}
