private void CreateDevice(IntPtr windowHandle, int width, int height) { try { parameters = new PresentationParameters(); parameters.BackBufferWidth = Math.Max(width, 1); parameters.BackBufferHeight = Math.Max(height, 1); parameters.BackBufferFormat = SurfaceFormat.Color; parameters.DepthStencilFormat = DepthFormat.Depth24; parameters.DeviceWindowHandle = windowHandle; parameters.PresentationInterval = PresentInterval.Immediate; parameters.IsFullScreen = false; graphicsDevice = new GraphicsDevice( GraphicsAdapter.DefaultAdapter, GraphicsProfile.Reach, parameters); if (DeviceCreated != null) DeviceCreated(this, EventArgs.Empty); } catch (Exception ex) { throw new ApplicationException("Failed to initialize GraphicsDeviceService. See inner exception for details.", ex); } }
/// <summary> /// InitializePlot the multicopter entity simulation environment /// </summary> /// <param name="device">A reference to the graphics device</param> /// <param name="physicsEngine">A reference to the created instance of the physics engine</param> public override void Initialize(xnagrfx.GraphicsDevice device, PhysicsEngine physicsEngine) { try { InitError = string.Empty; // Build the model ProgrammaticallyBuildModel(device, physicsEngine); // Reset values, position, rotation of the multicopter entity Reset(); // Insert propellers dynamically based on multicopter type InsertPropellers(device, physicsEngine); base.Initialize(device, physicsEngine); } catch (Exception ex) { // In case of exception delete physics entity and manage the errors if (PhysicsEntity != null) { PhysicsEngine.DeleteEntity(PhysicsEntity); } HasBeenInitialized = false; InitError = ex.ToString(); } }
public XNATexture2DImplementation(XFG.GraphicsDevice device, int width, int height, bool genMipMaps, SurfaceFormat format) : base(width, height, format) { _graphicsDevice = device; _texture2D = new XFG.Texture2D(device, width, height, genMipMaps, XNAHelper.ToXNASurfaceFormat(format)); }
public override void Draw(Microsoft.Xna.Framework.Graphics.GraphicsDevice device) { if (Mesh == null) { return; } var effect = new BasicEffect(device, null); effect.World = World; effect.View = View; effect.Projection = Projection; effect.Begin(); if (Texture != null) { effect.TextureEnabled = true; effect.Texture = Texture; } foreach (var pass in effect.CurrentTechnique.Passes) { pass.Begin(); Mesh.Draw(device); pass.End(); } effect.End(); }
public static Texture2D ResourceToTexture2D(string resource, GraphicsDevice gd) { using (Stream stream = Assembly.GetCallingAssembly().GetManifestResourceStream(resource)) { return Texture2D.FromStream(gd, stream); } }
/// <summary> /// Constructor is private, because this is a singleton class: /// client controls should use the public AddRef method instead. /// </summary> GraphicsDeviceService(IntPtr windowHandle, int width, int height) { parameters = new PresentationParameters(); // Basic settings. parameters.BackBufferWidth = Math.Max(width, 1); parameters.BackBufferHeight = Math.Max(height, 1); parameters.BackBufferFormat = SurfaceFormat.Color; parameters.DepthStencilFormat = DepthFormat.Depth24; parameters.DeviceWindowHandle = windowHandle; parameters.PresentationInterval = PresentInterval.Immediate; parameters.IsFullScreen = false; // High-quality settings. parameters.MultiSampleCount = 4; // Try for high-quality graphics, otherwise drop down to basic settings. try { graphicsDevice = new GraphicsDevice(GraphicsAdapter.DefaultAdapter, GraphicsProfile.HiDef, parameters); } catch { parameters.MultiSampleCount = 0; graphicsDevice = new GraphicsDevice(GraphicsAdapter.DefaultAdapter, GraphicsProfile.Reach, parameters); } }
public void Draw(Microsoft.Xna.Framework.Graphics.GraphicsDevice device) { foreach (var scene in Scenes) { scene.Draw(device); } }
public TextTest(IKernel kernel, GraphicsDevice device, ContentManager content) : base("Text Test", kernel) { _kernel = kernel; _device = device; _content = content; }
protected void LoadContent() { GrDev = base.GraphicsDevice; spriteBatch = new SpriteBatch(base.GraphicsDevice); spriteBatch1 = new SpriteBatch(base.GraphicsDevice); this.camera = new Camera2D(new Viewport(0, 0, (int)Assets.screenWidth, (int)Assets.screenHeight)); if (this.acel != null) { acel.ReportInterval = acel.MinimumReportInterval; acel.ReadingChanged += Aceloro; } if (this.orientationSensor != null) { Settings.orientation = this.orientationSensor.GetCurrentOrientation(); switch (Settings.orientation) { case SimpleOrientation.NotRotated: Settings.or = 1; break; case SimpleOrientation.Faceup: Settings.or = 1; break; case SimpleOrientation.Rotated180DegreesCounterclockwise: Settings.or = 2; break; case SimpleOrientation.Rotated270DegreesCounterclockwise: Settings.or = 3; break; case SimpleOrientation.Rotated90DegreesCounterclockwise: Settings.or = 4; break; } this.orientationSensor.OrientationChanged += OrientationChange; } }
public TextureContext(GraphicsDevice graphicsDevice, Stream stream, bool premultiplyAlpha) { _texture = Texture2D.FromStream(graphicsDevice, stream); if (premultiplyAlpha) PremultiplyTexture(_texture); }
public SpriteTest(IKernel kernel, ContentManager content, GraphicsDevice device) : base("Sprite Test", kernel) { _kernel = kernel; _content = content; _device = device; }
public override void Draw(GraphicsDevice device) { for (int i = 0; i < m_Elements.Count; i++) { m_Elements[i].Draw(device); } }
public Snowplow(GraphicsDevice device, Model model, VFXEffect effect) : base(device,model,effect) { _isDoubleSided["Circle"] = true; _isDoubleSided["Circle.004"] = true; _isDoubleSided["Circle.003"] = true; }
public void DrawBefore2D(GraphicsDevice gd, WorldState state) { foreach (var avatar in Blueprint.Avatars) { avatar.Draw(gd, state); } }
public ModelLoader(ContentManager contentManager, GraphicsDevice graphicsDevice) { content = contentManager; graphics = graphicsDevice; modelEffect = contentManager.Load<Effect>("EffectFiles/model"); }
public ParticlesTest(IKernel kernel, ContentManager content, GraphicsDevice device) : base("Particles", kernel) { _kernel = kernel; _content = content; _device = device; }
internal void SetConstantBuffers(GraphicsDevice device, int shaderProgram) #endif { // If there are no constant buffers then skip it. if (_valid == 0) return; var valid = _valid; for (var i = 0; i < _buffers.Length; i++) { var buffer = _buffers[i]; if (buffer != null) { #if DIRECTX buffer.Apply(device, _stage, i); #elif OPENGL || PSM buffer.Apply(device, shaderProgram); #endif } // Early out if this is the last one. valid &= ~(1 << i); if (valid == 0) return; } }
public ContentManager GetContentManager(GraphicsDevice graphicsDevice) { return new ContentManager(new XnaServiceProvider(graphicsDevice)) { RootDirectory = "Content" }; }
/// <summary> /// Creates a new instance of Content. /// </summary> /// <param name="basePath">Path to client directory.</param> /// <param name="device">A GraphicsDevice instance.</param> private Content(string basePath, GraphicsDevice device) { this.BasePath = basePath; this.Device = device; Changes = new ChangeManager(); UIGraphics = new UIGraphicsProvider(this); AvatarMeshes = new AvatarMeshProvider(this, Device); AvatarBindings = new AvatarBindingProvider(this); AvatarTextures = new AvatarTextureProvider(this, Device); AvatarSkeletons = new AvatarSkeletonProvider(this); AvatarAppearances = new AvatarAppearanceProvider(this); AvatarOutfits = new AvatarOutfitProvider(this); AvatarAnimations = new AvatarAnimationProvider(this); AvatarPurchasables = new AvatarPurchasables(this); AvatarHandgroups = new HandgroupProvider(this, Device); AvatarCollections = new AvatarCollectionsProvider(this); AvatarThumbnails = new AvatarThumbnailProvider(this, Device); WorldObjects = new WorldObjectProvider(this); WorldFloors = new WorldFloorProvider(this); WorldWalls = new WorldWallProvider(this); WorldObjectGlobals = new WorldGlobalProvider(this); WorldCatalog = new WorldObjectCatalog(); Audio = new Audio(this); GlobalTuning = new Tuning(Path.Combine(basePath, "tuning.dat")); Init(); }
/// <summary> /// Creates a new RenderTargetImageSource. /// </summary> /// <param name="graphics">The GraphicsDevice to use.</param> /// <param name="width">The width of the image source.</param> /// <param name="height">The height of the image source.</param> public RenderTargetImageSource(GraphicsDevice graphics, int width, int height) { // create the render target and buffer to hold the data renderTarget = new RenderTarget2D(graphics, width, height, false, SurfaceFormat.Color, DepthFormat.Depth24Stencil8); buffer = new byte[width * height * 4]; writeableBitmap = new WriteableBitmap(width, height, 96, 96, PixelFormats.Bgra32, null); }
internal void ClearTargets(GraphicsDevice device, RenderTargetBinding[] targets) { // NOTE: We make the assumption here that the caller has // locked the d3dContext for us to use. var pixelShaderStage = device._d3dContext.PixelShader; // We assume 4 targets to avoid a loop within a loop below. var target0 = targets[0].RenderTarget; var target1 = targets[1].RenderTarget; var target2 = targets[2].RenderTarget; var target3 = targets[3].RenderTarget; // Make one pass across all the texture slots. for (var i = 0; i < _textures.Length; i++) { if (_textures[i] != target0 && _textures[i] != target1 && _textures[i] != target2 && _textures[i] != target3) continue; // Immediately clear the texture from the device. _dirty &= ~(1 << i); _textures[i] = null; pixelShaderStage.SetShaderResource(i, null); } }
internal Effect(GraphicsDevice device) { graphicsDevice = device; Parameters = new EffectParameterCollection(); Techniques = new EffectTechniqueCollection(); CurrentTechnique = new EffectTechnique(this); }
Texture2D Circle(GraphicsDevice graphics, int radius) { int aDiameter = radius * 2; Vector2 aCenter = new Vector2(radius, radius); Texture2D aCircle = new Texture2D(graphics, aDiameter, aDiameter, false, SurfaceFormat.Color); Color[] aColors = new Color[aDiameter * aDiameter]; for (int i = 0; i < aColors.Length; i++) { int x = (i + 1) % aDiameter; int y = (i + 1) / aDiameter; Vector2 aDistance = new Vector2(Math.Abs(aCenter.X - x), Math.Abs(aCenter.Y - y)); if (Math.Sqrt((aDistance.X * aDistance.X) + (aDistance.Y * aDistance.Y)) > radius) { aColors[i] = Color.Transparent; } else { aColors[i] = Color.White; } } aCircle.SetData<Color>(aColors); return aCircle; }
public XNATexture2DImplementation(XFG.GraphicsDevice device, int width, int height, bool genMipmaps, SurfaceFormat format, DepthFormat depthFormat, int multiSampleCount, RenderTargetUsage usage) : base(width, height, format, depthFormat, multiSampleCount, usage) { _graphicsDevice = device; _texture2D = new XFG.RenderTarget2D(device, width, height, genMipmaps, XNAHelper.ToXNASurfaceFormat(format), XNAHelper.ToXNADepthFormat(depthFormat), multiSampleCount, XFG.RenderTargetUsage.PlatformContents); }
public XnaTextureManager( XFG.GraphicsDevice device ) : base() { this._device = device; Is32Bit = true; }
public Renderer(GraphicsDevice device, RenderState renderState) { RenderState = renderState; Device = device; _effect = new BasicEffect(Device); _bufferedInstructions = new List<IEnumerable<RenderInstruction>>(); }
internal void PlatformSetSamplers(GraphicsDevice device) { for (var i = 0; i < _actualSamplers.Length; i++) { var sampler = _actualSamplers[i]; var texture = device.Textures[i]; if (sampler != null && texture != null && sampler != texture.glLastSamplerState) { // TODO: Avoid doing this redundantly (see TextureCollection.SetTextures()) // However, I suspect that rendering from the same texture with different sampling modes // is a relatively rare occurrence... GL.ActiveTexture(TextureUnit.Texture0 + i); GraphicsExtensions.CheckGLError(); // NOTE: We don't have to bind the texture here because it is already bound in // TextureCollection.SetTextures(). This, of course, assumes that SetTextures() is called // before this method is called. If that ever changes this code will misbehave. // GL.BindTexture(texture.glTarget, texture.glTexture); // GraphicsExtensions.CheckGLError(); sampler.Activate(device, texture.glTarget, texture.LevelCount > 1); texture.glLastSamplerState = sampler; } } }
internal Effect(GraphicsDevice graphicsDevice) { if (graphicsDevice == null) throw new ArgumentNullException ("Graphics Device Cannot Be Null"); this.GraphicsDevice = graphicsDevice; }
public void DrawAfter2D(GraphicsDevice gd, WorldState state) { gd.RenderState.CullMode = CullMode.CullCounterClockwiseFace; foreach (var avatar in Blueprint.Avatars){ avatar.Draw(gd, state); } }
public static unsafe void Reset(GraphicsDevice graphicsDevice, PresentationParameters parameters) { var fi = typeof(GraphicsDevice).GetField("pComPtr", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance); var ptr = fi.GetValue(graphicsDevice); var pComPtr = new IntPtr(System.Reflection.Pointer.Unbox(ptr)); if (g_mdxAssembly == null) throw new ApplicationException("GraphicsDevice.Reset failed. Please install Managed DirectX from the Assault Wing web site."); var mdxDeviceType = g_mdxAssembly.GetType("Microsoft.DirectX.Direct3D.Device"); var mdxPresentParametersType = g_mdxAssembly.GetType("Microsoft.DirectX.Direct3D.PresentParameters"); var dev = Activator.CreateInstance(mdxDeviceType, pComPtr); dynamic dxParameters = new MDXPresentParameters(Activator.CreateInstance(mdxPresentParametersType)); dxParameters.AutoDepthStencilFormat = parameters.DepthStencilFormat.ToD3D(); dxParameters.BackBufferCount = 1; dxParameters.BackBufferFormat = parameters.BackBufferFormat.ToD3D(); dxParameters.BackBufferHeight = parameters.BackBufferHeight; dxParameters.BackBufferWidth = parameters.BackBufferWidth; dxParameters.DeviceWindow = null; dxParameters.DeviceWindowHandle = parameters.DeviceWindowHandle; dxParameters.EnableAutoDepthStencil = false; // ??? dxParameters.ForceNoMultiThreadedFlag = false; // ??? dxParameters.FullScreenRefreshRateInHz = 0; // ??? should be 0 for windowed mode; in fullscreen mode take value from DisplayModeCollection dxParameters.MultiSample = GetMDXEnumValue("MultiSampleType", "None"); dxParameters.MultiSampleQuality = 0; dxParameters.PresentationInterval = parameters.PresentationInterval.ToD3D(); dxParameters.PresentFlag = GetMDXEnumValue("PresentFlag", "None"); // ??? dxParameters.SwapEffect = GetMDXEnumValue("SwapEffect", "Flip"); // ??? see _parameters.RenderTargetUsage dxParameters.Windowed = !parameters.IsFullScreen; var resetMethod = mdxDeviceType.GetMethod("Reset"); var mdxPresentParametersArray = Array.CreateInstance(mdxPresentParametersType, 1); mdxPresentParametersArray.SetValue(((MDXPresentParameters)dxParameters).WrappedValue, 0); resetMethod.Invoke(dev, new[] { mdxPresentParametersArray }); }
public GraphicsManger(GraphicsDevice graphicsDevice, SpriteBatch spriteBatch, ContentManager content) { Console.WriteLine("graphics manager initialized"); GraphicsDevice = graphicsDevice; SpriteBatch = spriteBatch; Content = content; }
public XEngineGraphics(XEngineGame game) { this.mGame = game; this.mDevice = null; this.mSpriteBatch = null; }
public void draw(SpriteBatchWrapper sprites, GraphicsDevice device) { if (this.wantsToExit()) { return; } this.activeScene.draw(sprites, device); }
public override void Initialize() { base.Initialize(); graphics = Game1.Instance.Graphics.GraphicsDevice; spriteBatch = new SpriteBatch(graphics); }
internal void ApplyState(GraphicsDevice device) { bool flag = device.GetRenderTargets().Length > 0; if (this.CullMode == CullMode.None) { GL.Disable(EnableCap.CullFace); } else { GL.Enable(EnableCap.CullFace); GL.CullFace(CullFaceMode.Back); if (this.CullMode == CullMode.CullClockwiseFace) { if (flag) GL.FrontFace(FrontFaceDirection.Cw); else GL.FrontFace(FrontFaceDirection.Ccw); } else if (flag) GL.FrontFace(FrontFaceDirection.Ccw); else GL.FrontFace(FrontFaceDirection.Cw); } if (this.FillMode == FillMode.Solid) GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Fill); else GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Line); if (this.ScissorTestEnable) GL.Enable(EnableCap.ScissorTest); else GL.Disable(EnableCap.ScissorTest); GL.Enable(EnableCap.PolygonOffsetFill); GL.PolygonOffset(this.SlopeScaleDepthBias, this.DepthBias * 1E+07f); }
public RenderTarget2D(GraphicsDevice graphicsDevice, int width, int height, bool mipMap, SurfaceFormat preferredFormat, DepthFormat preferredDepthFormat, int preferredMultiSampleCount, RenderTargetUsage usage) : base(graphicsDevice, width, height, mipMap, preferredFormat) { RenderTargetUsage = usage; DepthStencilFormat = preferredDepthFormat; }
public Microsoft.Xna.Framework.Graphics.Texture2D GetPreviewTexture(Microsoft.Xna.Framework.Graphics.GraphicsDevice GraphicsDevice) { var MapPreview = new Texture2D(GraphicsDevice, PreviewSize.Width, PreviewSize.Height, false, SurfaceFormat.Color); MapPreview.SetData(Preview); return(MapPreview); }
public override void draw(Microsoft.Xna.Framework.Graphics.GraphicsDevice _GraphicsDevice, Microsoft.Xna.Framework.Graphics.SpriteBatch _SpriteBatch) { float percentageLife = Configuration.Configuration.networkManager.client.PlayerObject.HealthPoints / Configuration.Configuration.networkManager.client.PlayerObject.MaxHealthPoints; Rectangle source = new Rectangle(0, (int)((1 - percentageLife) * this.Bounds.Height), this.Bounds.Width, (int)(this.Bounds.Height * percentageLife)); Rectangle destination = new Rectangle(this.Bounds.X, (int)(this.Bounds.Y + (1 - percentageLife) * this.Bounds.Height), this.Bounds.Width, (int)(this.Bounds.Height * percentageLife)); _SpriteBatch.Draw(Ressourcen.RessourcenManager.ressourcenManager.Texture[this.BackgroundGraphicPath], destination, source, this.ComponentColor); }
/*public void setAnimation(Animation.AnimatedObjectAnimation _Animation) * { * this.animation = _Animation; * if(this.equipment!=null) * { * this.equipment.A * }*/ private void drawEquipment(Microsoft.Xna.Framework.Graphics.GraphicsDevice _GraphicsDevice, Microsoft.Xna.Framework.Graphics.SpriteBatch _SpriteBatch, Vector2 _BodyCenter) { if (this.equipment != null) { this.equipment.Position = new Vector3(_BodyCenter, 0); this.equipment.drawWearingEquipment(_GraphicsDevice, _SpriteBatch, this.color, this.animation); } }
public void CreateBuffer(Microsoft.Xna.Framework.Graphics.GraphicsDevice gd) { VertexBuffer = new VertexBuffer(gd, TerrainVertex.SizeInBytes * Vertices.Length, BufferUsage.WriteOnly); VertexBuffer.SetData(Vertices); IndexBuffer = new IndexBuffer(gd, typeof(int), Indexes.Length, BufferUsage.WriteOnly); IndexBuffer.SetData(Indexes); }
public override void Draw(Microsoft.Xna.Framework.Graphics.GraphicsDevice device, Camera cam) { if (ApplicationSettings.ShowDebugLines) { Debug.DrawLines(device, cam); } if (ApplicationSettings.ShowDebugPhysics) { Matrix proj = cam.projectionMatrix; Matrix view = cam.view; if (rayCastPlane.HasValue) { if (rayCastPlane.Value.normal == Vector3.up) { view = Matrix.CreateRotationX(MathHelper.ToRadians(90)) * view; } } physicsDebugView.RenderDebugData(ref proj, ref view, b => dontDrawColliders.Contains(b.UserData)); // NOTE: This only works for XY plane stuff PressPlay.FFWD.Vector3 inPos = Input.mousePosition; inPos.z = cam.nearClipPlane; PressPlay.FFWD.Vector2 castPos = cam.ScreenToWorldPoint(inPos); if (rayCastPlane.HasValue) { float dist; Ray ray = Camera.main.ScreenPointToRay(inPos); if (rayCastPlane.Value.Raycast(ray, out dist)) { Vector3 pt = ray.GetPoint(dist); castPos = new Vector2(pt.x, pt.z); } else { castPos = Vector2.zero; } } Debug.Display("Mouse / Physics", inPos + " / " + castPos); RaycastHit[] hits = Physics.PointcastAll(castPos, cam.cullingMask); if (hits.Length > 0) { Debug.Display("Over", String.Join("\n", hits.Select(h => h.collider.ToString()).OrderBy(s => s).ToArray())); } else { Debug.Display("Over", ""); } } if (ApplicationSettings.ShowDebugPhysicsCustom) { Physics.DrawDebug(); } }
/// <summary> /// Construct /// </summary> /// <param name="Content"></param> /// <param name="GraphicsDevice"></param> /// <param name="newSpace"></param> public RainParticle(Microsoft.Xna.Framework.Content.ContentManager Content, Microsoft.Xna.Framework.Graphics.GraphicsDevice GraphicsDevice, int newSpace) { // TODO: Complete member initialization rainView = new List <RainView>(); this.m_rainTexture = Content.Load <Texture2D>("rain"); this.GraphicsDevice = GraphicsDevice; this.space = newSpace; random1 = new Random(); random2 = new Random(); }
public void PreDraw(Microsoft.Xna.Framework.Graphics.GraphicsDevice device) { foreach (var scene in Scenes) { if (scene.Visible) { scene.PreDraw(device); } } }
/// <summary> /// Draws the meshes making up this Avatar instance. /// </summary> /// <param name="device">A GraphicsDevice instance.</param> public override void Draw(Microsoft.Xna.Framework.Graphics.GraphicsDevice device) { Effect.CurrentTechnique = Effect.Techniques[DefaultTechnique]; Effect.Parameters["View"].SetValue(View); Effect.Parameters["Projection"].SetValue(Projection); Effect.Parameters["World"].SetValue(World); Effect.Parameters["AmbientLight"].SetValue(AmbientLight); DrawGeometry(device, Effect); }
public static bool TryCreateTexture(SpanBitmap src, XNA.GraphicsDevice device, out XNA.Texture2D tex) { try { tex = null; Copy(src, ref tex, false, device, null, null); return(true); } catch (ArgumentException) { tex = null; return(false); } }
/// <summary> /// /// </summary> /// <param name="pDevice"></param> public void LoadGraphicsContent(XNA.Graphics.GraphicsDevice pDevice) { mSpriteBatch = new SpriteBatch(pDevice); mPrimitiveBatch = new PrimitivesSample.PrimitiveBatch(pDevice); if (this.mLogoTexture == null) { this.mLogoTexture = Texture2D.FromFile(pDevice, @"Content\Logo.png"); } }
/// <summary> /// Creates a new instance of <see cref="XNAEffectImplementation"/>. /// </summary> /// <param name="renderer">The XNA renderer.</param> /// <param name="byteCode">The compiled byte code.</param> internal XNAEffectImplementation(XNARenderer renderer, byte[] byteCode) { _renderer = renderer; _graphicsDevice = renderer.GraphicsDevice; _cachedByteCode = byteCode; _effect = new XFG.Effect(_graphicsDevice, byteCode); base.SetParameters(new XNAEffectParameterCollection(_effect.Parameters)); base.SetTechniques(new XNAEffectTechniqueCollection(_effect.Techniques)); _currentTechnique = (XNAEffectTechnique)base.Techniques[0]; }
public virtual void drawWearingEquipment(Microsoft.Xna.Framework.Graphics.GraphicsDevice _GraphicsDevice, Microsoft.Xna.Framework.Graphics.SpriteBatch _SpriteBatch, Microsoft.Xna.Framework.Color _Color, Animation.AnimatedObjectAnimation _Animation) { try { _SpriteBatch.Draw(Ressourcen.RessourcenManager.ressourcenManager.Texture[this.Body.MainBody.TexturePath], new Microsoft.Xna.Framework.Vector2(this.Position.X, this.Position.Y), _Animation.sourceRectangle(), _Animation.drawColor(), 0f, Microsoft.Xna.Framework.Vector2.Zero, new Microsoft.Xna.Framework.Vector2(this.Scale, this.Scale), Microsoft.Xna.Framework.Graphics.SpriteEffects.None, 1.0f); } catch (Exception e) { } }
public void draw(Microsoft.Xna.Framework.Graphics.GraphicsDevice _GraphicsDevice, Microsoft.Xna.Framework.Graphics.SpriteBatch _SpriteBatch, Vector2 _BodyCenter) { Vector2 var_Position = new Vector2(this.position.X + _BodyCenter.X, this.position.Y + _BodyCenter.Y); Color var_DrawColor = this.color; if (!this.animation.graphicPath().Equals("")) { _SpriteBatch.Draw(Ressourcen.RessourcenManager.ressourcenManager.Texture[this.animation.graphicPath()], var_Position, this.animation.sourceRectangle(), var_DrawColor, 0f, Vector2.Zero, new Vector2(this.scale, this.scale), SpriteEffects.None, 1.0f); } this.drawEquipment(_GraphicsDevice, _SpriteBatch, _BodyCenter); }
public XNARenderSystemProvider() { _game = new XNAGame(); _gdManager = new XNA.GraphicsDeviceManager(_game); _gdManager.GraphicsProfile = XFG.GraphicsProfile.HiDef; _gdManager.ApplyChanges(); _renderer = new XNARenderer(_gdManager.GraphicsDevice); _device = _renderer.GraphicsDevice; _content = new ContentManager(new EmbeddedResourceLocator(Tesla.Xna.DefaultContent.ResourceManager)); _content.UseDefaultContent = false; }
/// <summary> /// Initialization /// </summary> /// <param name="device"></param> /// <param name="physicsEngine"></param> public override void Initialize(xnagrfx.GraphicsDevice device, PhysicsEngine physicsEngine) { try { InitError = string.Empty; // set flag so rendering engine renders us last Flags |= VisualEntityProperties.UsesAlphaBlending; // creates effect, loads meshes, etc base.Initialize(device, physicsEngine); HeightFieldShapeProperties hf = new HeightFieldShapeProperties("height field", 2, 0.02f, 2, 0.02f, 0, 0, 1, 1); hf.HeightSamples = new HeightFieldSample[hf.RowCount * hf.ColumnCount]; for (int i = 0; i < hf.HeightSamples.Length; i++) { hf.HeightSamples[i] = new HeightFieldSample(); } _particlePlane = new Shape(hf); _particlePlane.State.Name = "sonar impact plane"; VisualEntityMesh sonarMesh = null; // we render on our own only the laser impact points. The laser Box is rendered as part of the parent. int index = Meshes.Count; Meshes.Add(SimulationEngine.ResourceCache.CreateMesh(device, _particlePlane.State)); Meshes[0].Textures[0] = SimulationEngine.ResourceCache.CreateTextureFromFile(device, "particle.bmp"); // we have a custom effect, with an additional global parameter. Get handle to it here if (Effect != null) { _timeAttenuationHandle = Effect.GetParameter("timeAttenuation"); } World = xna.Matrix.Identity; if (Meshes.Count > 1) { sonarMesh = Meshes[0]; } if (Parent == null) { throw new Exception("This entity must be a child of another entity."); } Parent.AddShapeToPhysicsEntity(_sonarBox, sonarMesh); } catch (Exception ex) { HasBeenInitialized = false; InitError = ex.ToString(); } }
/// <summary> /// Draws the meshes making up this Avatar instance. /// </summary> /// <param name="device">A GraphicsDevice instance.</param> public override void Draw(Microsoft.Xna.Framework.Graphics.GraphicsDevice device) { Effect.CurrentTechnique = Effect.Techniques[DefaultTechnique]; Effect.Parameters["View"].SetValue(View); Effect.Parameters["Projection"].SetValue(Projection); Effect.Parameters["World"].SetValue(World); Effect.Parameters["AmbientLight"].SetValue(new Vector4(1, 1, 1, 1)); var test = Vector4.Transform(new Vector4(0, 5.2f, 0, 1), World * View * Projection); DrawGeometry(device, Effect); }
public void Initialize(Microsoft.Xna.Framework.Graphics.GraphicsDevice device) { this.Device = device; foreach (var scene in Scenes) { scene.Initialize(this); } foreach (var scene in External) { scene.Initialize(this); } }
internal XNASwapChainImplementation(XNA.GraphicsDeviceManager gdManager, IntPtr windowHandle, PresentationParameters presentParams) { _gdManager = gdManager; _graphicsDevice = gdManager.GraphicsDevice; _windowHandle = windowHandle; _presentParams = presentParams; _pp = new XFG.PresentationParameters(); _pp.DeviceWindowHandle = windowHandle; _pp.IsFullScreen = false; _pp.DisplayOrientation = XNA.DisplayOrientation.Default; SetXNAPresentationParameters(presentParams); _graphicsDevice.Reset(_pp); }
public static void Initialize(GDM gdm, GD gd, CM cm, SB sb) { G.gdm = gdm; G.gd = gd; G.cm = cm; G.sb = sb; w = gdm.PreferredBackBufferWidth = 1024; h = gdm.PreferredBackBufferHeight = 768; gdm.ApplyChanges(); leftVp = new Viewport(0, 0, G.w / 2, G.h); rightVp = new Viewport(G.w / 2, 0, G.w / 2, G.h); screenVp = new Viewport(0, 0, G.w, G.h); }
internal XNARenderer(XFG.GraphicsProfile profile) { _dummyForm = new System.Windows.Forms.Form(); XFG.PresentationParameters pp = new XFG.PresentationParameters(); pp.BackBufferFormat = XFG.SurfaceFormat.Color; pp.BackBufferHeight = 1; pp.BackBufferWidth = 1; pp.DepthStencilFormat = XFG.DepthFormat.None; pp.DeviceWindowHandle = _dummyForm.Handle; pp.PresentationInterval = XFG.PresentInterval.Immediate; pp.IsFullScreen = false; _device = new XFG.GraphicsDevice(XFG.GraphicsAdapter.DefaultAdapter, profile, pp); }
/// <summary> /// Insert propellers dynamically based on multicopter type /// </summary> private void InsertPropellers(xnagrfx.GraphicsDevice device, PhysicsEngine physicsEngine) { // InitializePlot propeller list propellerEntities = new List <PropellerEntity>(); // Calculate angleChange between arms by dividing 360° by the number of propellers float angleBetweenArms = (2 * xna.MathHelper.Pi) / Globals.Instance.multicopterPropellerCount[multicopterType]; float propellerInclinationAngleRad = xna.MathHelper.ToRadians(propellerInclinationAngle); // Define the position of the first propeller (the other positions are calculated by rotating this vector) Vector3 positionFirstPropeller = new Vector3(0.11f, CHASSIS_DIMENSIONS_HEIGHT - 0.005f, 0.0f); // Define the orientation axis of the first propeller (the other orientation axis are calculated by rotating this vector) Vector3 orientationAxisFirstPropeller = new Vector3(0, 0, 1); // Calculate the force direction of the first propeller (the other force directions are calculated by rotating this vector) Vector3 forceDirectionFirstPropeller = MathHelper.RotateAroundAxis_Z( new Vector3(0, 1, 0), // The normal force direction at zero inclination is straight upwards new Vector3(), // The forces are local, we rotate around (0, 0, 0) propellerInclinationAngleRad // Get inclination angleChange in rad ); // InitializePlot every propeller for every arm for (byte i = 0; i < Globals.Instance.multicopterPropellerCount[multicopterType]; i++) { // Construct the name by the current number string namePropeller = State.Name + " Propeller " + (i + 1); // Calculate the angleChange between this arm and the first arm float currentAngle = angleBetweenArms * i; // Calculate the position of the propeller by rotating the first position around the y-axis Vector3 positionPropeller = MathHelper.RotateAroundAxis_Y(positionFirstPropeller, new Vector3(), currentAngle); // Calculate the position of the orientation axis by rotating the first orientation axis around the y-axis Vector3 orientationAxisPropeller = MathHelper.RotateAroundAxis_Y(orientationAxisFirstPropeller, new Vector3(), currentAngle); //Quaternion orientationPropeller = Quaternion.FromAxisAngle(orientationAxisPropeller.X, 0, orientationAxisPropeller.Z, propellerInclinationAngleRad); Quaternion orientationPropeller = Quaternion.FromAxisAngle(new AxisAngle(orientationAxisPropeller, propellerInclinationAngleRad)); // Calculate the force direction of the propeller by rotating the first force direction around the y-axis Vector3 forceDirectionPropeller = MathHelper.RotateAroundAxis_Y(forceDirectionFirstPropeller, new Vector3(), currentAngle); // Create the new propeller entity PropellerEntity newPropellerEntity = new PropellerEntity(namePropeller, positionPropeller, orientationPropeller, forceDirectionPropeller); newPropellerEntity.Parent = this; newPropellerEntity.Initialize(device, physicsEngine); // Add the new propeller entity propellerEntities.Add(newPropellerEntity); } }
/// <summary> /// Updates the scene. /// </summary> private void Form1_OnFrameMove(Microsoft.Xna.Framework.Graphics.GraphicsDevice pDevice) { mWorldMat = Matrix.Identity * Matrix.CreateScale(m_Scale) * Matrix.CreateRotationX(m_RotationX) * Matrix.CreateRotationY(m_RotationY) * Matrix.CreateRotationZ(m_RotationZ); if (m_RenderSim.GetBodyMesh() != null && m_RenderSim.GetHeadMesh() != null) { if (m_IsAnimating) { m_RenderSim.GetBodyMesh().AdvanceFrame(ref m_RenderSim.SimSkeleton, m_CurrentAnim, ref m_CurrentFrame, .02f); m_RenderSim.SimSkeleton.ComputeBonePositions(m_RenderSim.SimSkeleton.RootBone, mWorldMat); } } }
//protected Rectangle rectangle; public StaticGraphic(Device graphicDevice, string source, Vector2 position, float rotate, float scale, Color color, byte alpha, byte parameter) { Texturearray = new[] { Texture2D.FromFile(graphicDevice, source) }; Origin = new Vector2(0, 0); Position = position; Rotate = rotate; Scale = new Vector2(scale, scale); Layer = 0; Color = color; Alpha = alpha; Parameter = parameter; CurrentFrameIndex = 0; }
/// <summary> /// Constructor is private, because this is a singleton class: /// client controls should use the public AddRef method instead. /// </summary> GraphicsDeviceService(IntPtr windowHandle, int width, int height) { parameters = new PresentationParameters(); parameters.BackBufferWidth = Math.Max(width, 1); parameters.BackBufferHeight = Math.Max(height, 1); parameters.BackBufferFormat = SurfaceFormat.Color; parameters.DepthStencilFormat = DepthFormat.Depth24; parameters.DeviceWindowHandle = windowHandle; parameters.PresentationInterval = PresentInterval.Immediate; parameters.IsFullScreen = false; graphicsDevice = new Microsoft.Xna.Framework.Graphics.GraphicsDevice(GraphicsAdapter.DefaultAdapter, GraphicsProfile.HiDef, parameters); }