internal SpriteDefinition(SpriteSheet spriteSheet, string name, RectangleInt rectangle, Vector? origin) { this.SpriteSheet = spriteSheet; this.Name = name; this.Rectangle = rectangle; this.Origin = origin.HasValue ? origin.Value : Vector.Zero; }
public Sprite(SpriteSheet spriteSheet, string name, Vector2i size, Box2 coordinates) { SpriteSheet = spriteSheet; Name = name; Size = size; Coordinates = coordinates; }
protected Obstacle(SpriteSheet spriteSheet, float x, float y) { this.SpriteSheet = spriteSheet; this.X = x; this.Y = y; this.BoundingBox = new FloatRect(this.X + 5, this.Y, 40, 40); }
private Assets(ContentManager content) { Assets.content = content; player = new SpriteSheet("player"); gremlins = new SpriteSheet("gremlins"); guys = new SpriteSheet("guys"); walls = new SpriteSheet("walls"); titlescreen = content.Load<Texture2D>("titlescreen"); winscreen = content.Load<Texture2D>("winscreen2"); boom = content.Load<SoundEffect>("boom"); death = content.Load<SoundEffect>("death"); gethat = content.Load<SoundEffect>("gethat"); hit = content.Load<SoundEffect>("hit"); jump = content.Load<SoundEffect>("jump"); launch = content.Load<SoundEffect>("launch"); oof = content.Load<SoundEffect>("oof"); pew = content.Load<SoundEffect>("pew"); splat = content.Load<SoundEffect>("splat"); startgame = content.Load<SoundEffect>("startgame"); assets = this; }
public static void Init() { explosions = new List<Explosion>(); explosionsToBeRemoved = new List<Explosion>(); ss = new SpriteSheet(6, 8, spriteWidth, spriteHeight, "Resources\\SpriteSheets\\explosion.png"); //explosions.Add(new Explosion(new Vector3(0,0,-200f), 50, 50)); }
/// <summary> /// Sets the screen up (UI components, multimedia content, etc.) /// </summary> public override void Initialize() { base.Initialize(); //Create Physicworld CreatePhysicWorld(new Vector2(0, -20), true, false, Vector2.Zero); Sprite sand = new Sprite("sand", ResourceManager.CreateImage(Color.Transparent, (int)Preferences.Width, 65)); AddComponent(sand, 0, 415, BodyShape.SQUARE, BodyType.STATIC, Category.All); //Background SetBackground(ResourceManager.CreateImage("Images/background"), Adjustment.CENTER); spriteSheet = ResourceManager.CreateSpriteSheet("Images/spritesheet"); //Canyon CreateCanyon(new Vector2(620,274)); //Clowns castle CreateCastle(new Vector2(28,310)); //Helpers aux_offset = Vector2.Zero; timer = TimeSpan.Zero; iball = ResourceManager.CreateImage("Images/ball"); layer = new Layer(); Button breset = new Button(spriteSheet["bt_reset"], spriteSheet["bt_reset_pressed"]); breset.Released += new Component.ComponentEventHandler(breset_Released); AddComponent(breset, Preferences.ViewportManager.RightAnchor - breset.Size.X, 0); }
public SpriteGameObject(string assetname, int layer = 0, string id = "", int sheetIndex = 0) : base(layer, id) { if (assetname != "") sprite = new SpriteSheet(assetname, sheetIndex); else sprite = null; }
/// <summary>Create a new sprite game object.</summary> /// <param name="assetname">The name of the sprite file.</param> /// <param name="layer">The layer the object is in.</param> /// <param name="id">The ID to refer to the object.</param> /// <param name="sheetIndex">The index of the sprite in a sprite string or sheet.</param> /// <param name="paralax">The paralax mode that applies to this object.</param> public SpriteGameObject(string assetname, int layer = 0, string id = "", int sheetIndex = 0, Backgroundlayer paralax = Backgroundlayer.solid) : base(layer, id) { if (assetname != "") sprite = new SpriteSheet(assetname, sheetIndex); else sprite = null; this.paralax = paralax; }
public SpaceWorld(Game game, SpriteSheet spriteSheet, GameplayScreen screen, bool tutorial) : base(game, new Vector2(0, 0)) { Tutorial = tutorial; GameScreen = screen; this._spriteSheet = spriteSheet; this._Font = new ImageFont(); }
protected override async Task LoadContent() { await base.LoadContent(); spriteBatch = new SpriteBatch(GraphicsDevice); sphere = Asset.Load<Texture>("Sphere"); rotatedImages = Asset.Load<SpriteSheet>("RotatedImages"); }
protected override async Task LoadContent() { await base.LoadContent(); spriteUv = Asset.Load<SpriteSheet>("SpriteUV"); spriteSphere = Asset.Load<SpriteSheet>("SpriteSphere"); spriteBatch = new SpriteBatch(GraphicsDevice); }
public void ChangeSheet() { //Change sheet currentSheet = spriteSheets[currentAnim.sheetNum]; //Find frame data for new spritesheet FrameData(); }
public void testOneFrameInSprite() { SpriteSheet testSheet = new SpriteSheet(20, 20); testSheet.createStructure(1, 1); Assert.AreEqual(1, testSheet.Location.GetLength(0)); Assert.AreEqual(1, testSheet.Location.GetLength(1)); Assert.AreEqual(testSheet.frameDimX * 0, testSheet.getFrameLocationOnSheetAt(0, 0).X, "At Col = 0"); Assert.AreEqual(testSheet.frameDimY * 0, testSheet.getFrameLocationOnSheetAt(0, 0).Y, "At Row = 0"); }
public ThreeColorGameObject(string redAssetName, string greenAssetName, string blueAssetName) : base("") { colorRed = new SpriteSheet(redAssetName); colorGreen = new SpriteSheet(greenAssetName); colorBlue = new SpriteSheet(blueAssetName); Color = Color.Blue; }
protected override async Task LoadContent() { await base.LoadContent(); batch = new Sprite3DBatch(GraphicsDevice); sphere = Asset.Load<Texture>("Sphere"); rotatedImages = Asset.Load<SpriteSheet>("RotatedImages"); rasterizerState = RasterizerState.New(GraphicsDevice, new RasterizerStateDescription(CullMode.None)); }
public override void loadContent(Microsoft.Xna.Framework.Content.ContentManager contentManager) { Texture2D sheet = contentManager.Load<Texture2D>("collectiblePez"); image = new SpriteSheet(Game, sheet, 2, 2, gameScreen.ScreenManager.SpriteBatch) { position = Position, framesPerSecond = 8f }; image.scale = 1f / image.frameWidth; }
public Sprite(string name, SpriteSheet spriteSheet) { Debug.Assert(name.Length > 0, "sprite name was an empty string"); Debug.Assert(spriteSheet != null, "sprite sheet was null"); frame = spriteSheet.SourceRectangle(name); //this.sourceRectangle = spriteSheet.SourceRectangle(name); //this.spriteSheet = spriteSheet; }
public void testCreateStructureWithCorrectSize() { //GraphicsDeviceManager graphics = new GraphicsDeviceManager(this); SpriteSheet testSheet = new SpriteSheet(50, 50);//new SpriteSheet(new Texture2D(graphics.GraphicsDevice,50,50), new SpriteBatch(GraphicsDevice), 50, 50); //Assert.IsNotNull(testSheet); testSheet.createStructure(500/testSheet.frameDimX, 2000/testSheet.frameDimY); Assert.AreEqual(10, testSheet.Location.GetLength(0)); Assert.AreEqual(40, testSheet.Location.GetLength(1)); }
// Master Ovverride public static GameObject Create(string name, SS.Pivot pivot, Vector2 size, Material material, TextAsset data) { GameObject go = new GameObject(); go.AddComponent<MeshFilter>().sharedMesh = NewMesh(pivot, size); go.AddComponent<MeshRenderer>().material = material; Sprite sprite = go.AddComponent<Sprite>(); SpriteSheet sheetInfo = new SpriteSheet(material, data); Debug.Log("Names " + sheetInfo.AnimationNames()[0]); return go; }
public Character(SpriteSheet Sheet) { this.CharacterData.Sheet = Sheet; //runAnimation = sheet.GetAnimation("Run"); //runAnimation.Loop = true; //runAnimation.AnimationSpeed = 0.1f; //runAnimation.Animating = true; Weapon = Weapon.DefaultWeapon(); }
protected Character(string id, Stats.Stats stats, SpriteSheet spriteSheet) { this.Id = id; this.Stats = stats; this.SpriteSheet = spriteSheet; this.SpriteSheet.CurrentSprite.Position = new Vector2f(this.X, this.Y); this.BoundingBox = new FloatRect(this.X, this.Y + 50, 30, 30); this.X = 100; this.Y = 100; this.IsDead = false; }
public Projectile(SpriteSheet sprite, float x, float y, float deltaX, float deltaY, float projectileSpeed) : base(sprite, x, y) { this.DeltaX = deltaX; this.DeltaY = deltaY; this.ProjectileSpeed = projectileSpeed; this.Distance = 1000; this.BoundingBox = new FloatRect(this.SpriteSheet.CurrentSprite.GetGlobalBounds().Left, this.SpriteSheet.CurrentSprite.GetGlobalBounds().Top, 20, 20); this.IsActive = true; Projectiles.Add(this); }
/// <summary> /// Loads a <see cref="SpriteSheet"/>'s data onto the form. /// </summary> /// <param name="path">The name of the file to load.</param> protected void LoadFormData(string path) { fileName = path; spriteSheet = SpriteSheet.FromFile(path); spriteSheet.TileSize = new System.Drawing.Size(24, 24); Text = System.IO.Path.GetFileName(fileName) + " - Sprite Sheet Editor"; spriteSheetImage.Image = spriteSheet.Bitmap; OnFileLoaded(); }
protected override async Task LoadContent() { await base.LoadContent(); var virtualResolution = new Vector3(GraphicsDevice.BackBuffer.ViewWidth, GraphicsDevice.BackBuffer.ViewHeight, 200); spriteBatch = new SpriteBatch(GraphicsDevice) { VirtualResolution = virtualResolution }; spheres = Asset.Load<SpriteSheet>("SpriteSphere"); round = Asset.Load<Texture>("round"); staticFont = Asset.Load<SpriteFont>("StaticFonts/CourierNew10"); dynamicFont = Asset.Load<SpriteFont>("DynamicFonts/CourierNew10"); colorTexture = Texture.New2D(GraphicsDevice, 1, 1, PixelFormat.R8G8B8A8_UNorm, new[] { Color.White }); }
protected override void LoadContent() { _bg.LowerBackground = Content.Load<Texture2D>(@"Graphics\Background1"); _bg.UpperBackground = Content.Load<Texture2D>(@"Graphics\Background2"); mainSheet = Content.Load<SpriteSheet>(@"Graphics\SpriteSheets\16x16"); _supportedAnimations = mainSheet.Animations; sprite.Name = "testSprite"; G.EditorForm.grdProperty.SelectedObject = sprite; sprite.Play(_supportedAnimations[_animationIndex].Name); sprite.Position = G.ScreenCenter; sprite.Origin = Vector2.One * 0.5f; base.LoadContent(); }
/// <summary> /// Loads graphics content for this screen. The background texture is quite /// big, so we use our own local ContentManager to load it. This allows us /// to unload before going from the menus into the game itself, wheras if we /// used the shared ContentManager provided by the Game class, the content /// would remain loaded forever. /// </summary> public override void Activate(bool instancePreserved) { if (!instancePreserved) { if (content == null) content = new ContentManager(ScreenManager.Game.Services, "Content"); backgroundTexture = content.Load<Texture2D>("Backgrounds/lobby"); gat = new SpriteSheet(ScreenManager.Game, content.Load<Texture2D>("standSprite"), 2, 3, ScreenManager.SpriteBatch); Viewport vp = ScreenManager.Game.GraphicsDevice.Viewport; gat.scale = 0.4f * vp.Height / gat.frameHeight; gat.position = new Vector2(vp.Width * 0.08f, vp.Height * 0.8f); gat.framesPerSecond = 3f; } }
public void testCorrectFrames() { SpriteSheet testSheet = new SpriteSheet(50, 50); int widthTotalImage = 500; int heightTotalImage = 2000; testSheet.createStructure(widthTotalImage / testSheet.frameDimX, heightTotalImage / testSheet.frameDimY); for (int i = 0; i < testSheet.Location.GetLength(0); ++i) { for (int j = 0; j < testSheet.Location.GetLength(1); ++j) { Assert.AreEqual(testSheet.frameDimX * i, testSheet.getFrameLocationOnSheetAt(i, j).X, "At Col=" + i ); Assert.AreEqual(testSheet.frameDimY * j, testSheet.getFrameLocationOnSheetAt(i, j).Y, "At Row=" + j ); } } }
protected override async Task LoadContent() { await base.LoadContent(); spriteBatch = new SpriteBatch(GraphicsDevice); offlineTarget = Texture.New2D(GraphicsDevice, OfflineWidth, OfflineHeight, PixelFormat.R8G8B8A8_UNorm, TextureFlags.ShaderResource | TextureFlags.RenderTarget).DisposeBy(this); depthBuffer = Texture.New2D(GraphicsDevice, OfflineWidth, OfflineHeight, PixelFormat.D16_UNorm, TextureFlags.DepthStencil).DisposeBy(this); uv = Asset.Load<Texture>("uv"); spheres = Asset.Load<SpriteSheet>("SpriteSphere"); arial = Asset.Load<SpriteFont>("StaticFonts/Arial13"); width = GraphicsDevice.BackBuffer.ViewWidth; height = GraphicsDevice.BackBuffer.ViewHeight; }
public Screen(int w, int h, SpriteSheet sheet) { this.sheet = sheet; this.w = w; this.h = h; pixels = new int[w * h]; // Random random = new Random(); /* * for (int i = 0; i < MAP_WIDTH * MAP_WIDTH; i++) { colors[i] = Color.get(00, 40, 50, 40); tiles[i] = 0; * * if (random.nextInt(40) == 0) { tiles[i] = 32; colors[i] = Color.get(111, 40, 222, 333); databits[i] = random.nextInt(2); } else if (random.nextInt(40) == 0) { tiles[i] = 33; colors[i] = Color.get(20, 40, 30, 550); } else { tiles[i] = random.nextInt(4); databits[i] = random.nextInt(4); * * } } * * Font.setMap("Testing the 0341879123", this, 0, 0, Color.get(0, 555, 555, 555)); */ }
public SpriteRenderer(SpriteSheet spriteSheet) { SpriteSheet = spriteSheet; textureFire = Texture2D.Load(typeof(Particle).Assembly.GetManifestResourceStream("Granite.Particle.Textures.fire_color.png")); m_program = SpriteProgram.Instance; m_instances = new List<SpriteInstance>(); m_vao = new VertexArray(); GL.BindVertexArray(m_vao); m_bufferSprite = new Buffer<SpriteData>(); m_bufferQuad = new Buffer<Vector3>(); m_bufferQuad.SetData(new Vector3[] { new Vector3(0f, 0f, 0f), new Vector3(0f, 1f, 0f), new Vector3(1f, 1f, 0f), new Vector3(1f, 0f, 0f) }); GL.UseProgram(m_program); m_program.Position.SetValue(m_bufferQuad.GetView()); //m_program.Color.SetValue(m_bufferSprite.GetView(s => s.Color)); //m_program.Color.SetDivisor(1); m_program.Transform.SetValue(m_bufferSprite.GetView<Matrix4>("Transform")); m_program.Transform.SetDivisor(1); m_program.TextureOrigin.SetValue(m_bufferSprite.GetView<Vector2>("TextureOrigin")); m_program.TextureOrigin.SetDivisor(1); m_program.TextureTarget.SetValue(m_bufferSprite.GetView<Vector2>("TextureTarget")); m_program.TextureTarget.SetDivisor(1); m_program.Progress.SetValue(m_bufferSprite.GetView(s => s.Progress)); m_program.Progress.SetDivisor(1); GL.BindVertexArray(null); m_isDirty = true; }
public override void LoadContent(ContentManager content) { perchSprites = content.Load <SpriteSheet>("ONAF2/OwlPerch"); ventSprites = content.Load <SpriteSheet>("ONAF2/OwlVent"); jumpscareSprites = content.Load <SpriteSheet>("ONAF2/JumpscareOwl"); }
public SpriteRenderer(Actor actor, SpriteSheet spriteSheet) : base(actor) { this.spriteSheet = spriteSheet; this.currentAnimation = spriteSheet.DefaultAnimation; this.color = Color.White; }
private void SetSpriteImage(SpriteSheet sprite) { spriteComponent.SpriteProvider = new SpriteFromSheet { Sheet = sprite }; }
private void Start() { this.Icons = AssetManager.Load <SpriteSheet>("UI/TowerRankIcon"); this.RefreshData(); }
public override void Read(AssetReader reader) { base.Read(reader); bool isBoolFlags = IsBoolFlags(reader.Version); MipMapMode = (TextureImporterMipFilter)reader.ReadInt32(); if (isBoolFlags) { EnableMipMapBool = reader.ReadBoolean(); CorrectGammaBool = reader.ReadBoolean(); FadeOutBool = reader.ReadBoolean(); BorderMipMapBool = reader.ReadBoolean(); } else { EnableMipMap = reader.ReadInt32(); if (HasSRGBTexture(reader.Version)) { SRGBTexture = reader.ReadInt32(); } if (HasLinearTexture(reader.Version)) { LinearTexture = reader.ReadInt32(); } if (HasCorrectGamma(reader.Version)) { CorrectGamma = reader.ReadInt32(); } FadeOut = reader.ReadInt32(); BorderMipMap = reader.ReadInt32(); } if (HasMipMapsPreserveCoverage(reader.Version)) { MipMapsPreserveCoverage = reader.ReadInt32(); AlphaTestReferenceValue = reader.ReadSingle(); } MipMapFadeDistanceStart = reader.ReadInt32(); MipMapFadeDistanceEnd = reader.ReadInt32(); if (isBoolFlags) { ConvertToNormalMapBool = reader.ReadBoolean(); if (HasIsReadable(reader.Version)) { IsReadableBool = reader.ReadBoolean(); } } else { ConvertToNormalMap = reader.ReadInt32(); ExternalNormalMap = reader.ReadInt32(); if (IsReadableFirst(reader.Version)) { IsReadable = reader.ReadInt32(); reader.AlignStream(); } } HeightScale = reader.ReadSingle(); NormalMapFilter = (TextureImporterNormalFilter)reader.ReadInt32(); if (!IsReadableFirst(reader.Version)) { IsReadable = reader.ReadInt32(); } if (HasStreamingMipmaps(reader.Version)) { StreamingMipmaps = reader.ReadInt32(); StreamingMipmapsPriority = reader.ReadInt32(); } if (isBoolFlags) { GrayScaleToAlphaBool = reader.ReadBoolean(); } else { GrayScaleToAlpha = reader.ReadInt32(); } if (IsAlignGrayScaleToAlpha(reader.Version)) { reader.AlignStream(); } GenerateCubemap = (TextureImporterGenerateCubemap)reader.ReadInt32(); if (HasCubemapConvolution(reader.Version)) { CubemapConvolution = reader.ReadInt32(); } if (HasCubemapConvolutionSteps(reader.Version)) { CubemapConvolutionSteps = reader.ReadInt32(); CubemapConvolutionExponent = reader.ReadSingle(); } if (HasSeamlessCubemap(reader.Version)) { SeamlessCubemap = reader.ReadInt32(); } TextureFormat = (TextureFormat)reader.ReadInt32(); if (IsAlignTextureFormat(reader.Version)) { reader.AlignStream(); } if (HasRecommendedTextureFormat(reader.Version) && RecommendedTextureFormatFirst(reader.Version)) { RecommendedTextureFormat = reader.ReadInt32(); reader.AlignStream(); } MaxTextureSize = reader.ReadInt32(); TextureSettings.Read(reader); NPOTScale = (TextureImporterNPOTScale)reader.ReadInt32(); if (HasLightmap(reader.Version)) { Lightmap = reader.ReadInt32(); } if (HasRGBM(reader.Version)) { RGBM = reader.ReadInt32(); } if (HasCompressionQuality(reader.Version)) { CompressionQuality = reader.ReadInt32(); } if (HasAllowsAlphaSplitting(reader.Version)) { AllowsAlphaSplitting = reader.ReadInt32(); reader.AlignStream(); } if (HasSprite(reader.Version)) { SpriteMode = (SpriteImportMode)reader.ReadInt32(); SpriteExtrude = reader.ReadUInt32(); SpriteMeshType = (SpriteMeshType)reader.ReadInt32(); Alignment = (SpriteAlignment)reader.ReadInt32(); SpritePivot.Read(reader); } if (HasSprite(reader.Version) && SpritePixelsToUnitsFirst(reader.Version)) { SpritePixelsToUnits = reader.ReadSingle(); } if (HasSpriteBorder(reader.Version)) { SpriteBorder.Read(reader); } if (HasSprite(reader.Version) && !SpritePixelsToUnitsFirst(reader.Version)) { SpritePixelsToUnits = reader.ReadSingle(); } if (HasSpriteGenerateFallbackPhysicsShape(reader.Version)) { SpriteGenerateFallbackPhysicsShape = reader.ReadInt32(); } if (HasAlphaUsage(reader.Version)) { AlphaUsage = (TextureImporterAlphaSource)reader.ReadInt32(); } if (HasAlphaIsTransparency(reader.Version)) { AlphaIsTransparency = reader.ReadInt32(); } if (HasSpriteTessellationDetail(reader.Version)) { SpriteTessellationDetail = reader.ReadSingle(); } if (HasTextureType(reader.Version)) { TextureType = (TextureImporterType)reader.ReadInt32(); } if (HasRecommendedTextureFormat(reader.Version) && !RecommendedTextureFormatFirst(reader.Version)) { RecommendedTextureFormat = reader.ReadInt32(); } if (HasSourceTextureInformation(reader.Version)) { SourceTextureInformation = reader.ReadAsset<SourceTextureInformation>(); reader.AlignStream(); } if (HasTextureShape(reader.Version)) { TextureShape = (TextureImporterShape)reader.ReadInt32(); } if (HasSingleChannelComponent(reader.Version)) { SingleChannelComponent = reader.ReadInt32(); } if (HasMaxTextureSizeSet(reader.Version)) { MaxTextureSizeSet = reader.ReadInt32(); CompressionQualitySet = reader.ReadInt32(); TextureFormatSet = reader.ReadInt32(); } if (HasApplyGammaDecoding(reader.Version)) { ApplyGammaDecoding = reader.ReadInt32(); } reader.AlignStream(); if (HasPlatformSettings(reader.Version)) { PlatformSettings = reader.ReadAssetArray<TextureImporterPlatformSettings>(); } if (HasSprite(reader.Version)) { SpriteSheet.Read(reader); SpritePackingTag = reader.ReadString(); } if (HasOutput(reader.Version)) { Output.Read(reader); } if (HasPSDRemoveMatte(reader.Version)) { PSDRemoveMatte = reader.ReadBoolean(); PSDShowRemoveMatteOption = reader.ReadBoolean(); } reader.AlignStream(); PostRead(reader); }
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container) { YAMLMappingNode node = base.ExportYAMLRoot(container); node.AddSerializedVersion(ToSerializedVersion(container.ExportVersion)); YAMLMappingNode mipmap = new YAMLMappingNode(); mipmap.Add(MipMapModeName, (int)MipMapMode); mipmap.Add(EnableMipMapName, EnableMipMap); if (HasSRGBTexture(container.ExportVersion)) { mipmap.Add(SRGBTextureName, SRGBTexture); } if (HasLinearTexture(container.ExportVersion)) { mipmap.Add(LinearTextureName, LinearTexture); } if (HasCorrectGamma(container.ExportVersion)) { mipmap.Add(CorrectGammaName, CorrectGamma); } mipmap.Add(FadeOutName, FadeOut); mipmap.Add(BorderMipMapName, BorderMipMap); if (HasMipMapsPreserveCoverage(container.ExportVersion)) { mipmap.Add(MipMapsPreserveCoverageName, MipMapsPreserveCoverage); mipmap.Add(AlphaTestReferenceValueName, AlphaTestReferenceValue); } mipmap.Add(MipMapFadeDistanceStartName, MipMapFadeDistanceStart); mipmap.Add(MipMapFadeDistanceEndName, MipMapFadeDistanceEnd); node.Add(MipmapsName, mipmap); YAMLMappingNode bumpmap = new YAMLMappingNode(); bumpmap.Add(ConvertToNormalMapName, ConvertToNormalMap); if (HasExternalNormalMap(container.ExportVersion)) { bumpmap.Add(ExternalNormalMapName, ExternalNormalMap); } bumpmap.Add(HeightScaleName, HeightScale); bumpmap.Add(NormalMapFilterName, (int)NormalMapFilter); node.Add(BumpmapName, bumpmap); if (HasIsReadable(container.ExportVersion)) { node.Add(IsReadableName, IsReadable); } if (HasStreamingMipmaps(container.ExportVersion)) { node.Add(StreamingMipmapsName, StreamingMipmaps); node.Add(StreamingMipmapsPriorityName, StreamingMipmapsPriority); } node.Add(GrayScaleToAlphaName, GrayScaleToAlpha); node.Add(GenerateCubemapName, (int)GenerateCubemap); if (HasCubemapConvolution(container.ExportVersion)) { node.Add(CubemapConvolutionName, CubemapConvolution); } if (HasCubemapConvolutionSteps(container.ExportVersion)) { node.Add(CubemapConvolutionStepsName, CubemapConvolutionSteps); node.Add(CubemapConvolutionExponentName, CubemapConvolutionExponent); } if (HasSeamlessCubemap(container.ExportVersion)) { node.Add(SeamlessCubemapName, SeamlessCubemap); } node.Add(TextureFormatName, (int)TextureFormat); if (HasRecommendedTextureFormat(container.ExportVersion) && RecommendedTextureFormatFirst(container.ExportVersion)) { node.Add(RecommendedTextureFormatName, RecommendedTextureFormat); } node.Add(MaxTextureSizeName, MaxTextureSize); node.Add(TextureSettingsName, TextureSettings.ExportYAML(container)); node.Add(NPOTScaleName, (int)NPOTScale); if (HasLightmap(container.ExportVersion)) { node.Add(LightmapName, Lightmap); } if (HasRGBM(container.ExportVersion)) { node.Add(RGBMName, RGBM); } if (HasCompressionQuality(container.ExportVersion)) { node.Add(CompressionQualityName, CompressionQuality); } if (HasAllowsAlphaSplitting(container.ExportVersion)) { node.Add(AllowsAlphaSplittingName, AllowsAlphaSplitting); } if (HasSprite(container.ExportVersion)) { node.Add(SpriteModeName, (int)SpriteMode); node.Add(SpriteExtrudeName, SpriteExtrude); node.Add(SpriteMeshTypeName, (int)SpriteMeshType); node.Add(AlignmentName, (int)Alignment); node.Add(SpritePivotName, SpritePivot.ExportYAML(container)); } if (HasSprite(container.ExportVersion) && SpritePixelsToUnitsFirst(container.ExportVersion)) { node.Add(SpritePixelsToUnitsName, SpritePixelsToUnits); } if (HasSpriteBorder(container.ExportVersion)) { node.Add(SpriteBorderName, SpriteBorder.ExportYAML(container)); } if (HasSprite(container.ExportVersion) && !SpritePixelsToUnitsFirst(container.ExportVersion)) { node.Add(SpritePixelsToUnitsName, SpritePixelsToUnits); } if (HasSpriteGenerateFallbackPhysicsShape(container.ExportVersion)) { node.Add(SpriteGenerateFallbackPhysicsShapeName, SpriteGenerateFallbackPhysicsShape); } if (HasAlphaUsage(container.ExportVersion)) { node.Add(AlphaUsageName, (int)AlphaUsage); } if (HasAlphaIsTransparency(container.ExportVersion)) { node.Add(AlphaIsTransparencyName, AlphaIsTransparency); } if (HasSpriteTessellationDetail(container.ExportVersion)) { node.Add(SpriteTessellationDetailName, SpriteTessellationDetail); } if (HasTextureType(container.ExportVersion)) { node.Add(TextureTypeName, (int)TextureType); } if (HasRecommendedTextureFormat(container.ExportVersion) && !RecommendedTextureFormatFirst(container.ExportVersion)) { node.Add(RecommendedTextureFormatName, RecommendedTextureFormat); } if (HasSourceTextureInformation(container.ExportVersion)) { node.Add(SourceTextureInformationName, SourceTextureInformation.ExportYAML(container)); } if (HasTextureShape(container.ExportVersion)) { node.Add(TextureShapeName, (int)TextureShape); } if (HasSingleChannelComponent(container.ExportVersion)) { node.Add(SingleChannelComponentName, SingleChannelComponent); } if (HasMaxTextureSizeSet(container.ExportVersion)) { node.Add(MaxTextureSizeSetName, MaxTextureSizeSet); node.Add(CompressionQualitySetName, CompressionQualitySet); node.Add(TextureFormatSetName, TextureFormatSet); } if (HasApplyGammaDecoding(container.ExportVersion)) { node.Add(ApplyGammaDecodingName, GetApplyGammaDecoding(container.Version)); } if (HasPlatformSettings(container.ExportVersion)) { node.Add(GetPlatformSettingsName(container.ExportVersion), PlatformSettings.ExportYAML(container)); } if (HasSprite(container.ExportVersion)) { node.Add(SpriteSheetName, SpriteSheet.ExportYAML(container)); node.Add(SpritePackingTagName, SpritePackingTag); } /*if (HasOutput(container.ExportVersion)) { node.Add(OutputName, Output.ExportYAML(container)); }*/ if (HasPSDRemoveMatte(container.ExportVersion)) { node.Add(PSDRemoveMatteName, PSDRemoveMatte); node.Add(PSDShowRemoveMatteOptionName, PSDShowRemoveMatteOption); } PostExportYAML(container, node); return node; }
public override void Init(GraphicsDeviceManager graphics, ContentManager contentManager) { titleScreen = contentManager.Load <Texture2D>("title"); elementTexture = contentManager.Load <Texture2D>("elements"); elementSpriteSheet = new SpriteSheet(elementTexture, Constants.ELEMENT_IMAGE_SIZE); }
public TextSprite(SpriteSheet _font, Alignement align = Alignement.LEFT, int x = 0, int y = 0) { font = _font; position = new GridPosition(x, y); alignement = align; }
public PlayerDescriptor Load(IDataManagerArguments arguments) { var playerDataLoaderArgs = arguments as PlayerDataLoaderArguments; string filePath = EngineConstants.FILEPATH_ACCOUNTS + playerDataLoaderArgs.Username + EngineConstants.ACC_FILE_EXT; string name = ""; string password = ""; SpriteSheet sprite; float speed; int level; int health; int maximumHealth; int strength; int intelligence; int dexterity; int defense; Vector position; string mapID; Role role; try { using (var fileStream = new FileStream(filePath, FileMode.Open)) { using (var binaryReader = new BinaryReader(fileStream)) { name = binaryReader.ReadString(); password = binaryReader.ReadString(); sprite = new SpriteSheet(new SpriteInfo(binaryReader.ReadString()), binaryReader.ReadInt32(), binaryReader.ReadInt32(), binaryReader.ReadInt32(), binaryReader.ReadInt32()); speed = binaryReader.ReadSingle(); maximumHealth = binaryReader.ReadInt32(); health = binaryReader.ReadInt32(); strength = binaryReader.ReadInt32(); intelligence = binaryReader.ReadInt32(); dexterity = binaryReader.ReadInt32(); defense = binaryReader.ReadInt32(); level = binaryReader.ReadInt32(); position = new Vector(binaryReader.ReadSingle(), binaryReader.ReadSingle()); mapID = binaryReader.ReadString(); role = new Role(binaryReader.ReadString(), binaryReader.ReadInt32()); } } var playerDescriptor = new PlayerDescriptor(name, password) { SpriteSheet = sprite, Speed = speed, Level = level, Position = position, MapID = mapID, Stats = new Stats() { Health = health, MaximumHealth = maximumHealth, Strength = strength, Intelligence = intelligence, Dexterity = dexterity, Defense = defense, }, Role = role }; return(playerDescriptor); } catch (Exception ex) { return(null); } }
public override void CreateCosmeticChildren(ComponentManager manager) { base.CreateCosmeticChildren(manager); Sheet = new SpriteSheet(ContentPaths.Entities.Furniture.elevator, 32, 32); }
public EntityFactory(SpriteSheet spriteSheet) { this.spriteSheet = spriteSheet; }
partial void InitProjSpecific(XElement element) { var paddedFrame = new GUIFrame(new RectTransform(new Vector2(0.85f, 0.65f), GuiFrame.RectTransform, Anchor.Center) { RelativeOffset = new Vector2(0, 0.04f) }, style: null); var lightsArea = new GUIFrame(new RectTransform(new Vector2(1, 0.38f), paddedFrame.RectTransform, Anchor.TopLeft), style: null); powerIndicator = new GUITickBox(new RectTransform(new Vector2(0.45f, 0.8f), lightsArea.RectTransform, Anchor.Center, Pivot.CenterRight) { RelativeOffset = new Vector2(-0.05f, 0) }, TextManager.Get("EnginePowered"), font: GUI.SubHeadingFont, style: "IndicatorLightGreen") { CanBeFocused = false }; autoControlIndicator = new GUITickBox(new RectTransform(new Vector2(0.45f, 0.8f), lightsArea.RectTransform, Anchor.Center, Pivot.CenterLeft) { RelativeOffset = new Vector2(0.05f, 0) }, TextManager.Get("PumpAutoControl", fallBackTag: "ReactorAutoControl"), font: GUI.SubHeadingFont, style: "IndicatorLightYellow") { CanBeFocused = false }; powerIndicator.TextBlock.Wrap = autoControlIndicator.TextBlock.Wrap = true; powerIndicator.TextBlock.OverrideTextColor(GUI.Style.TextColor); autoControlIndicator.TextBlock.OverrideTextColor(GUI.Style.TextColor); GUITextBlock.AutoScaleAndNormalize(powerIndicator.TextBlock, autoControlIndicator.TextBlock); var sliderArea = new GUIFrame(new RectTransform(new Vector2(1, 0.6f), paddedFrame.RectTransform, Anchor.BottomLeft), style: null); string powerLabel = TextManager.Get("EngineForce"); new GUITextBlock(new RectTransform(new Vector2(1.0f, 0.3f), sliderArea.RectTransform, Anchor.TopCenter), "", textColor: GUI.Style.TextColor, font: GUI.SubHeadingFont, textAlignment: Alignment.Center) { AutoScaleHorizontal = true, TextGetter = () => { return(TextManager.AddPunctuation(':', powerLabel, (int)(targetForce) + " %")); } }; forceSlider = new GUIScrollBar(new RectTransform(new Vector2(0.95f, 0.45f), sliderArea.RectTransform, Anchor.Center), barSize: 0.1f, style: "DeviceSlider") { Step = 0.05f, OnMoved = (GUIScrollBar scrollBar, float barScroll) => { float newTargetForce = barScroll * 200.0f - 100.0f; if (Math.Abs(newTargetForce - targetForce) < 0.01) { return(false); } targetForce = newTargetForce; if (GameMain.Client != null) { correctionTimer = CorrectionDelay; item.CreateClientEvent(this); } return(true); } }; var textsArea = new GUIFrame(new RectTransform(new Vector2(1, 0.25f), sliderArea.RectTransform, Anchor.BottomCenter), style: null); var backwardsLabel = new GUITextBlock(new RectTransform(new Vector2(0.4f, 1.0f), textsArea.RectTransform, Anchor.CenterLeft), TextManager.Get("EngineBackwards"), textColor: GUI.Style.TextColor, font: GUI.SubHeadingFont, textAlignment: Alignment.CenterLeft); var forwardsLabel = new GUITextBlock(new RectTransform(new Vector2(0.4f, 1.0f), textsArea.RectTransform, Anchor.CenterRight), TextManager.Get("EngineForwards"), textColor: GUI.Style.TextColor, font: GUI.SubHeadingFont, textAlignment: Alignment.CenterRight); GUITextBlock.AutoScaleAndNormalize(backwardsLabel, forwardsLabel); foreach (XElement subElement in element.Elements()) { switch (subElement.Name.ToString().ToLowerInvariant()) { case "propellersprite": propellerSprite = new SpriteSheet(subElement); AnimSpeed = subElement.GetAttributeFloat("animspeed", 1.0f); break; } } }
public SnowTexture() { m_backgroundTexture = Texture2D.Load(typeof(Floor).Assembly.GetManifestResourceStream("Zombie.Game.Textures.snow.jpg")); m_backgroundSheet = new SpriteSheet(m_backgroundTexture); m_backgroundSprite = m_backgroundSheet.AddSprite("", new Box2i(Vector2i.Zero, m_backgroundTexture.Size)); }
protected virtual SpriteFromSheet BuildSpriteSheet() { var ss = new SpriteSheet(); //Each action has 8 directions * actionCount sprites int spriteSheetId = 0; foreach (var animation in XGCharacter.RawAnimationsData) { FileInfo f = new FileInfo(Path.Combine(_spritesPath, animation.StartSprite)); for (int dir = 0; dir < 5; dir++) { int skip = animation.SkipBetweenFiles * dir; for (int num = 0; num < animation.Count; num++) { var spritePath = f.DirectoryName + "\\" + (Convert.ToInt32(Path.GetFileNameWithoutExtension(f.Name)) + ((dir * animation.Count) + num + skip)).ToString().PadLeft(4, '0') + ".png"; if (File.Exists(spritePath)) // Some sprites missing? { var bytes = File.ReadAllBytes(spritePath); var image = Stride.Graphics.Image.Load(bytes); var texture = Texture.New(this.GraphicsDevice, image, TextureFlags.ShaderResource); var sprite = new Sprite($"{animation.Name}_{dir}_{num}", texture); ss.Sprites.Add(sprite); var animationKey = (animation.Name, (ECameraDirection)dir); if (!this._animations.ContainsKey(animationKey)) { this._animations.Add(animationKey, new List <IndividualAnimation>()); } _animations[animationKey].Add(new IndividualAnimation() { Name = animation.Name, Count = animation.Count, Direction = (ECameraDirection)dir, Frame = num, SpriteSheetId = spriteSheetId++ }); if (dir > 0 && dir < 4) // Get non-north south sprites. Will use for mirror { var bitmap = new Bitmap(spritePath); bitmap.RotateFlip(RotateFlipType.RotateNoneFlipX); bytes = BitmapToByteArray(bitmap); image = Stride.Graphics.Image.Load(bytes); texture = Texture.New(this.GraphicsDevice, image, TextureFlags.ShaderResource); sprite = new Sprite($"{animation.Name}_{dir}_{num}", texture); ss.Sprites.Add(sprite); animationKey = (animation.Name, (ECameraDirection)(8 - dir)); if (!this._animations.ContainsKey(animationKey)) { this._animations.Add(animationKey, new List <IndividualAnimation>()); } _animations[animationKey].Add(new IndividualAnimation() { Name = animation.Name, Count = animation.Count, Direction = (ECameraDirection)(8 - dir), Frame = num, SpriteSheetId = spriteSheetId++ }); } } } } } _previousAnimation = _animations[(EActionTypes.Idle, ECameraDirection.North)][0];
public override void Write(AssetWriter writer) { base.Write(writer); bool isBoolFlags = IsBoolFlags(writer.Version); writer.Write((int)MipMapMode); if (isBoolFlags) { writer.Write(EnableMipMapBool); writer.Write(CorrectGammaBool); writer.Write(FadeOutBool); writer.Write(BorderMipMapBool); } else { writer.Write(EnableMipMap); if (HasSRGBTexture(writer.Version)) { writer.Write(SRGBTexture); } if (HasLinearTexture(writer.Version)) { writer.Write(LinearTexture); } if (HasCorrectGamma(writer.Version)) { writer.Write(CorrectGamma); } writer.Write(FadeOut); writer.Write(BorderMipMap); } if (HasMipMapsPreserveCoverage(writer.Version)) { writer.Write(MipMapsPreserveCoverage); writer.Write(AlphaTestReferenceValue); } writer.Write(MipMapFadeDistanceStart); writer.Write(MipMapFadeDistanceEnd); if (isBoolFlags) { writer.Write(ConvertToNormalMapBool); if (HasIsReadable(writer.Version)) { writer.Write(IsReadableBool); } } else { writer.Write(ConvertToNormalMap); writer.Write(ExternalNormalMap); if (IsReadableFirst(writer.Version)) { writer.Write(IsReadable); writer.AlignStream(); } } writer.Write(HeightScale); writer.Write((int)NormalMapFilter); if (!IsReadableFirst(writer.Version)) { writer.Write(IsReadable); } if (HasStreamingMipmaps(writer.Version)) { writer.Write(StreamingMipmaps); writer.Write(StreamingMipmapsPriority); } if (isBoolFlags) { writer.Write(GrayScaleToAlphaBool); } else { writer.Write(GrayScaleToAlpha); } if (IsAlignGrayScaleToAlpha(writer.Version)) { writer.AlignStream(); } writer.Write((int)GenerateCubemap); if (HasCubemapConvolution(writer.Version)) { writer.Write(CubemapConvolution); } if (HasCubemapConvolutionSteps(writer.Version)) { writer.Write(CubemapConvolutionSteps); writer.Write(CubemapConvolutionExponent); } if (HasSeamlessCubemap(writer.Version)) { writer.Write(SeamlessCubemap); } writer.Write((int)TextureFormat); if (IsAlignTextureFormat(writer.Version)) { writer.AlignStream(); } if (HasRecommendedTextureFormat(writer.Version) && RecommendedTextureFormatFirst(writer.Version)) { writer.Write(RecommendedTextureFormat); writer.AlignStream(); } writer.Write(MaxTextureSize); TextureSettings.Write(writer); writer.Write((int)NPOTScale); if (HasLightmap(writer.Version)) { writer.Write(Lightmap); } if (HasRGBM(writer.Version)) { writer.Write(RGBM); } if (HasCompressionQuality(writer.Version)) { writer.Write(CompressionQuality); } if (HasAllowsAlphaSplitting(writer.Version)) { writer.Write(AllowsAlphaSplitting); writer.AlignStream(); } if (HasSprite(writer.Version)) { writer.Write((int)SpriteMode); writer.Write(SpriteExtrude); writer.Write((int)SpriteMeshType); writer.Write((int)Alignment); SpritePivot.Write(writer); } if (HasSprite(writer.Version) && SpritePixelsToUnitsFirst(writer.Version)) { writer.Write(SpritePixelsToUnits); } if (HasSpriteBorder(writer.Version)) { SpriteBorder.Write(writer); } if (HasSprite(writer.Version) && !SpritePixelsToUnitsFirst(writer.Version)) { writer.Write(SpritePixelsToUnits); } if (HasSpriteGenerateFallbackPhysicsShape(writer.Version)) { writer.Write(SpriteGenerateFallbackPhysicsShape); } if (HasAlphaUsage(writer.Version)) { writer.Write((int)AlphaUsage); } if (HasAlphaIsTransparency(writer.Version)) { writer.Write(AlphaIsTransparency); } if (HasSpriteTessellationDetail(writer.Version)) { writer.Write(SpriteTessellationDetail); } if (HasTextureType(writer.Version)) { writer.Write((int)TextureType); } if (HasRecommendedTextureFormat(writer.Version) && !RecommendedTextureFormatFirst(writer.Version)) { writer.Write(RecommendedTextureFormat); } if (HasSourceTextureInformation(writer.Version)) { SourceTextureInformation.Write(writer); writer.AlignStream(); } if (HasTextureShape(writer.Version)) { writer.Write((int)TextureShape); } if (HasSingleChannelComponent(writer.Version)) { writer.Write(SingleChannelComponent); } if (HasMaxTextureSizeSet(writer.Version)) { writer.Write(MaxTextureSizeSet); writer.Write(CompressionQualitySet); writer.Write(TextureFormatSet); } if (HasApplyGammaDecoding(writer.Version)) { writer.Write(ApplyGammaDecoding); } writer.AlignStream(); if (HasPlatformSettings(writer.Version)) { PlatformSettings.Write(writer); } if (HasSprite(writer.Version)) { SpriteSheet.Write(writer); writer.Write(SpritePackingTag); } if (HasOutput(writer.Version)) { Output.Write(writer); } if (HasPSDRemoveMatte(writer.Version)) { writer.Write(PSDRemoveMatte); writer.Write(PSDShowRemoveMatteOption); } writer.AlignStream(); PostWrite(writer); }
public static Texture2D RenderPatternIcons(GraphicsDevice device, Microsoft.Xna.Framework.Content.ContentManager Content, Gui.JsonTileSheet Sheet) { Initialize(); var shader = new Shader(Content.Load <Effect>(ContentPaths.Shaders.TexturedShaders), true); var sqrt = (int)(Math.Ceiling(Math.Sqrt(Patterns.Count))); var width = MathFunctions.NearestPowerOf2(sqrt * Sheet.TileWidth); var fitHorizontal = width / Sheet.TileWidth; var rowCount = (int)Math.Ceiling((float)Patterns.Count / (float)fitHorizontal); var height = MathFunctions.NearestPowerOf2(rowCount * Sheet.TileHeight); RenderTarget2D toReturn = new RenderTarget2D(device, width, height, false, SurfaceFormat.Color, DepthFormat.Depth16, 16, RenderTargetUsage.PreserveContents); var tileSheet = new SpriteSheet(ContentPaths.rail_tiles, 32); device.SetRenderTarget(toReturn); device.Clear(Color.Transparent); shader.SetTexturedTechnique(); shader.MainTexture = AssetManager.GetContentTexture(ContentPaths.rail_tiles); shader.SelfIlluminationEnabled = true; shader.SelfIlluminationTexture = AssetManager.GetContentTexture(ContentPaths.Terrain.terrain_illumination); shader.EnableShadows = false; shader.EnableLighting = false; shader.ClippingEnabled = false; shader.CameraPosition = new Vector3(-0.5f, 0.5f, 0.5f); shader.VertexColorTint = Color.White; shader.LightRamp = Color.White; shader.SunlightGradient = AssetManager.GetContentTexture(ContentPaths.Gradients.sungradient); shader.AmbientOcclusionGradient = AssetManager.GetContentTexture(ContentPaths.Gradients.ambientgradient); shader.TorchlightGradient = AssetManager.GetContentTexture(ContentPaths.Gradients.torchgradient); Viewport oldview = device.Viewport; int rows = height / Sheet.TileWidth; int cols = width / Sheet.TileWidth; device.ScissorRectangle = new Rectangle(0, 0, Sheet.TileWidth, Sheet.TileHeight); device.RasterizerState = RasterizerState.CullNone; device.DepthStencilState = DepthStencilState.Default; Vector3 half = Vector3.One * 0.5f; half = new Vector3(half.X, half.Y, half.Z); foreach (EffectPass pass in shader.CurrentTechnique.Passes) { int ID = 0; foreach (var type in Patterns) { int row = ID / cols; int col = ID % cols; var xboundsMin = 0; var xboundsMax = 0; var yboundsMin = 0; var yboundsMax = 0; var primitive = new RawPrimitive(); foreach (var piece in type.Pieces) { var rawPiece = RailLibrary.GetRailPiece(piece.RailPiece); var bounds = Vector4.Zero; var uvs = tileSheet.GenerateTileUVs(rawPiece.Tile, out bounds); primitive.AddQuad( Matrix.CreateRotationY((float)Math.PI * 0.5f * (float)piece.Orientation) * Matrix.CreateTranslation(new Vector3(piece.Offset.X, 0.0f, piece.Offset.Y)), Color.White, Color.White, uvs, bounds); xboundsMin = Math.Min(xboundsMin, piece.Offset.X); xboundsMax = Math.Max(xboundsMax, piece.Offset.X); yboundsMin = Math.Min(yboundsMin, piece.Offset.Y); yboundsMax = Math.Max(yboundsMax, piece.Offset.Y); } float xSize = xboundsMax - xboundsMin + 1; float ySize = yboundsMax - yboundsMin + 1; var cameraPos = new Vector3(xboundsMin + (xSize / 2), 2.0f, yboundsMax + 1.0f); device.Viewport = new Viewport(col * Sheet.TileWidth, row * Sheet.TileHeight, Sheet.TileWidth, Sheet.TileHeight); shader.View = Matrix.CreateLookAt(cameraPos, new Vector3((xboundsMin + (xSize / 2)), 0.0f, yboundsMin), Vector3.UnitY); shader.Projection = Matrix.CreatePerspectiveFieldOfView(1.0f, 1.0f, 0.1f, 10); shader.World = Matrix.Identity; shader.CameraPosition = cameraPos; pass.Apply(); primitive.Render(device); ++ID; } } device.Viewport = oldview; device.SetRenderTarget(null); return((Texture2D)toReturn); }
public override void Reset() { children.Clear(); floors = new GameObjectList(); this.Add(floors); ladders = new GameObjectList(); this.Add(ladders); scoreText = new GameObjectList(); this.Add(scoreText); mario = new Mario(new Vector2(100, 900)); this.Add(mario); pauline = new Pauline(new Vector2(800, 150)); this.Add(pauline); barrels = new GameObjectList(); this.Add(barrels); hammers = new GameObjectList(); this.Add(hammers); SpriteSheet floorSpriteDimensions = new SpriteSheet("spr_floor"); SpriteSheet ladderSpriteDimensions = new SpriteSheet("spr_ladder_piece"); for (int iFloors = 0; iFloors < floorLayers; iFloors++) { for (int jFloors = 0; jFloors < floorsPerLayer; jFloors++) { //add Kdanky Dang at first 2 floors if (iFloors == 0 && jFloors == 1) { kdankyDang = new KdankeyDang(new Vector2(jFloors * floorSpriteDimensions.Width, floorVerticalStartOffset + iFloors * floorSetsHeightDifference + jFloors * floorIndividualOffset)); kdankyDang.Origin = new Vector2(kdankyDang.Center.X, kdankyDang.Sprite.Height); this.Add(kdankyDang); } //create floors from right to left or left to right alternating //floorSetsHeightDifference gives the difference in height between the first floor of two sets //floorIndividualOffset gives the height each floor in a set goes down the next iteration if (iFloors % 2 == 0) //right to left walk direction for these platforms { floors.Add(new Floor(new Vector2( jFloors * floorSpriteDimensions.Width, floorVerticalStartOffset + iFloors * floorSetsHeightDifference + jFloors * floorIndividualOffset))); //add ladders to edges if (jFloors == floorsPerLayer - 1) { GameObjectList _ladders = new GameObjectList(); for (int iLadder = 0; iLadder < baseLadderAmount; iLadder++) { _ladders.Add(new Ladder(new Vector2( jFloors * floorSpriteDimensions.Width - ladderSpriteDimensions.Width / 2, ladderVerticalStartOffset + iLadder * ladderSpriteDimensions.Sprite.Height + floorVerticalStartOffset + iFloors * floorSetsHeightDifference + jFloors * floorIndividualOffset))); } ladders.Add(_ladders); } } else //left to right walkdirection for these platforms { //only spawn if the bottom layer is above the bottom of the screen. This is only present here because //the bottom layer will always go left to right by design if (floorVerticalStartOffset + iFloors * floorSetsHeightDifference + (jFloors + 1) * floorIndividualOffset + 48 < GameEnvironment.Screen.Y) { floors.Add(new Floor(new Vector2( GameEnvironment.Screen.X - floorSpriteDimensions.Width - jFloors * floorSpriteDimensions.Width, floorVerticalStartOffset + iFloors * floorSetsHeightDifference + jFloors * floorIndividualOffset))); } else { int kFloors = 0; while (GameEnvironment.Screen.X - floorSpriteDimensions.Width - (jFloors + kFloors) * floorSpriteDimensions.Width > -floorSpriteDimensions.Width) { floors.Add(new Floor(new Vector2( GameEnvironment.Screen.X - floorSpriteDimensions.Width - (jFloors + kFloors) * floorSpriteDimensions.Width, floorVerticalStartOffset + iFloors * floorSetsHeightDifference + jFloors * floorIndividualOffset))); kFloors++; } break; } //add ladders to edges if (jFloors == floorsPerLayer - 1) { GameObjectList _ladders = new GameObjectList(); for (int iLadder = 0; iLadder < baseLadderAmount; iLadder++) { _ladders.Add(new Ladder(new Vector2( GameEnvironment.Screen.X - floorSpriteDimensions.Width - (jFloors - 1) * floorSpriteDimensions.Width - ladderSpriteDimensions.Width / 2, ladderVerticalStartOffset + iLadder * ladderSpriteDimensions.Sprite.Height + floorVerticalStartOffset + iFloors * floorSetsHeightDifference + jFloors * floorIndividualOffset))); } ladders.Add(_ladders); } } //add misc ladders if (jFloors == ladderFloorMisc1 && iFloors == ladderFloorSetMisc1) { GameObjectList _ladders = new GameObjectList(); for (int iLadder = 0; iLadder < ladderAmountMisc1; iLadder++) { _ladders.Add(new Ladder(new Vector2( GameEnvironment.Screen.X - floorSpriteDimensions.Width - (jFloors - 1) * floorSpriteDimensions.Width - ladderSpriteDimensions.Width / 2, ladderVerticalStartOffset + iLadder * ladderSpriteDimensions.Sprite.Height + floorVerticalStartOffset + iFloors * floorSetsHeightDifference + jFloors * floorIndividualOffset))); } ladders.Add(_ladders); } if (jFloors == ladderFloorMisc2 && iFloors == ladderFloorSetMisc2) { GameObjectList _ladders = new GameObjectList(); for (int iLadder = 0; iLadder < ladderAmountMisc2; iLadder++) { _ladders.Add(new Ladder(new Vector2( jFloors * floorSpriteDimensions.Width - ladderSpriteDimensions.Width / 2, ladderVerticalStartOffset + iLadder * ladderSpriteDimensions.Sprite.Height + floorVerticalStartOffset + iFloors * floorSetsHeightDifference + jFloors * floorIndividualOffset))); } ladders.Add(_ladders); } if (jFloors == ladderFloorMisc3 && iFloors == ladderFloorSetMisc3) { GameObjectList _ladders = new GameObjectList(); for (int iLadder = 0; iLadder < ladderAmountMisc3; iLadder++) { _ladders.Add(new Ladder(new Vector2( jFloors * floorSpriteDimensions.Width - ladderSpriteDimensions.Width / 2, ladderVerticalStartOffset + iLadder * ladderSpriteDimensions.Sprite.Height + floorVerticalStartOffset + iFloors * floorSetsHeightDifference + jFloors * floorIndividualOffset))); } ladders.Add(_ladders); } if (jFloors == ladderFloorMisc4 && iFloors == ladderFloorSetMisc4) { GameObjectList _ladders = new GameObjectList(); for (int iLadder = 0; iLadder < ladderAmountMisc4; iLadder++) { _ladders.Add(new Ladder(new Vector2( jFloors * floorSpriteDimensions.Width - ladderSpriteDimensions.Width / 2, ladderVerticalStartOffset + iLadder * ladderSpriteDimensions.Sprite.Height + floorVerticalStartOffset + iFloors * floorSetsHeightDifference + jFloors * floorIndividualOffset))); } ladders.Add(_ladders); } } } //Add misc platforms //Pauline platforms floors.Add(new Floor(new Vector2(pauline.Position.X, pauline.Position.Y))); floors.Add(new Floor(new Vector2(pauline.Position.X - floorSpriteDimensions.Width, pauline.Position.Y))); //pauline ladders GameObjectList paulineLadders1 = new GameObjectList(0, "1"); GameObjectList paulineLadders2 = new GameObjectList(0, "1"); for (int iLadder = 0; iLadder < paulineMaxLadders; iLadder++) { paulineLadders1.Add(new Ladder(new Vector2(pauline.Position.X + floorSpriteDimensions.Width - ladderSpriteDimensions.Width, pauline.Position.Y + ladderVerticalStartOffset + iLadder * ladderSpriteDimensions.Height))); paulineLadders2.Add(new Ladder(new Vector2(pauline.Position.X - floorSpriteDimensions.Width, pauline.Position.Y + ladderVerticalStartOffset + iLadder * ladderSpriteDimensions.Height))); } ladders.Add(paulineLadders1); ladders.Add(paulineLadders2); hammers.Add(new HammerPowerup(new Vector2(50, 500))); hammers.Add(new HammerPowerup(new Vector2(1750, 300))); }
public InfantryDeath(World world, Point position, SpriteSheet sprite, string spriteSequenceName) : base(world, position, sprite, ExplosionHeight.Ground, spriteSequenceName) { }
public SpriteGameObject(string assetName, int layer = 0, string id = "", int sheetIndex = 0, float scale = 1f) : base(layer, id) { sprite = assetName != "" ? new SpriteSheet(assetName, sheetIndex) : null; this.scale = scale; }
public override async Task Execute() { spriteSheet = SpriteSheet; agentSpriteComponent = Entity.Get <SpriteComponent>(); // Calculate offset of the bullet from the Agent if he is facing left and right side // TODO improve this var bulletOffset = new Vector3(1f, 0.2f, 0f); // Initialize game entities if (!IsLiveReloading) { shootDelayCounter = 0f; isAgentFacingRight = true; currentAgentAnimation = AgentAnimation.Idle; } CurrentAgentAnimation = currentAgentAnimation; while (Game.IsRunning) { await Script.NextFrame(); var inputState = GetKeyboardInputState(); if (inputState == InputState.None) { inputState = GetPointerInputState(); } // Reset the shoot delay, if state changes if (inputState != InputState.Shoot && CurrentAgentAnimation == AgentAnimation.Shoot) { shootDelayCounter = 0; } if (inputState == InputState.RunLeft || inputState == InputState.RunRight) { // Update Agent's position var dt = (float)Game.UpdateTime.Elapsed.TotalSeconds; Entity.Transform.Position.X += ((inputState == InputState.RunRight) ? AgentMoveDistance : -AgentMoveDistance) * dt; if (Entity.Transform.Position.X < -gameWidthHalfX) { Entity.Transform.Position.X = -gameWidthHalfX; } if (Entity.Transform.Position.X > gameWidthHalfX) { Entity.Transform.Position.X = gameWidthHalfX; } isAgentFacingRight = inputState == InputState.RunRight; // If agent face left, flip the sprite Entity.Transform.Scale.X = isAgentFacingRight ? 1f : -1f; // Update the sprite animation and state CurrentAgentAnimation = AgentAnimation.Run; } else if (inputState == InputState.Shoot) { // Update shootDelayCounter, and check whether it is time to create a new bullet shootDelayCounter -= (float)Game.UpdateTime.Elapsed.TotalSeconds; if (shootDelayCounter > 0) { continue; } // Reset shoot delay shootDelayCounter = AgentShootDelay; // Spawns a new bullet var bullet = new Entity { new SpriteComponent { SpriteProvider = new SpriteFromSheet { Sheet = spriteSheet }, CurrentFrame = spriteSheet.FindImageIndex("bullet") }, // Will make the beam move along a direction at each frame new ScriptComponent { Scripts = { new BeamScript { DirectionX = isAgentFacingRight ? 1f : -1f, SpriteSheet = SpriteSheet } } } }; bullet.Transform.Position = (isAgentFacingRight) ? Entity.Transform.Position + bulletOffset : Entity.Transform.Position + (bulletOffset * new Vector3(-1, 1, 1)); SceneSystem.SceneInstance.Scene.Entities.Add(bullet); Logic.WatchBullet(bullet); // Start animation for shooting CurrentAgentAnimation = AgentAnimation.Shoot; } else { CurrentAgentAnimation = AgentAnimation.Idle; } } }
protected override Task <ResultStatus> DoCommandOverride(ICommandContext commandContext) { var assetManager = new ContentManager(); // Create atlas texture Dictionary <SpriteInfo, PackedSpriteInfo> spriteToPackedSprite = null; // Generate texture atlas var isPacking = Parameters.SheetAsset.Packing.Enabled; if (isPacking) { var resultStatus = CreateAtlasTextures(commandContext.Logger, out spriteToPackedSprite); if (resultStatus != ResultStatus.Successful) { return(Task.FromResult(resultStatus)); } } var imageGroupData = new SpriteSheet(); // add the sprite data to the sprite list. foreach (var image in Parameters.SheetAsset.Sprites) { string textureUrl; RectangleF region; ImageOrientation orientation; var borders = image.Borders; var center = image.Center + (image.CenterFromMiddle ? new Vector2(image.TextureRegion.Width, image.TextureRegion.Height) / 2 : Vector2.Zero); if (isPacking && spriteToPackedSprite.ContainsKey(image)) // ensure that unpackable elements (invalid because of null size/texture) are properly added in the sheet using the normal path { var packedSprite = spriteToPackedSprite[image]; var isOriginalSpriteRotated = image.Orientation == ImageOrientation.Rotated90; region = packedSprite.Region; orientation = (packedSprite.IsRotated ^ isOriginalSpriteRotated) ? ImageOrientation.Rotated90 : ImageOrientation.AsIs; textureUrl = SpriteSheetAsset.BuildTextureAtlasUrl(Url, spriteToPackedSprite[image].AtlasTextureIndex); // update the center and border info, if the packer rotated the sprite // note: X->Left, Y->Top, Z->Right, W->Bottom. if (packedSprite.IsRotated) { // turned the sprite CCW if (isOriginalSpriteRotated) { var oldCenterX = center.X; center.X = center.Y; center.Y = region.Height - oldCenterX; var oldBorderW = borders.W; borders.W = borders.X; borders.X = borders.Y; borders.Y = borders.Z; borders.Z = oldBorderW; } else // turned the sprite CW { var oldCenterX = center.X; center.X = region.Width - center.Y; center.Y = oldCenterX; var oldBorderW = borders.W; borders.W = borders.Z; borders.Z = borders.Y; borders.Y = borders.X; borders.X = oldBorderW; } } } else { region = image.TextureRegion; orientation = image.Orientation; Parameters.ImageToTextureUrl.TryGetValue(image, out textureUrl); } // Affect the texture Texture texture = null; if (textureUrl != null) { texture = AttachedReferenceManager.CreateProxyObject <Texture>(AssetId.Empty, textureUrl); } else { commandContext.Logger.Warning($"Image '{image.Name}' has an invalid image source file '{image.Source}', resulting texture will be null."); } imageGroupData.Sprites.Add(new Graphics.Sprite { Name = image.Name, Region = region, Orientation = orientation, Center = center, Borders = borders, PixelsPerUnit = new Vector2(image.PixelsPerUnit), Texture = texture, IsTransparent = false, }); } // set the transparency information to all the sprites if (Parameters.SheetAsset.Alpha != AlphaFormat.None) // Skip the calculation when format is forced without alpha. { var urlToTexImage = new Dictionary <string, Tuple <TexImage, Image> >(); using (var texTool = new TextureTool()) { foreach (var sprite in imageGroupData.Sprites) { if (sprite.Texture == null) // the sprite texture is invalid { continue; } var textureUrl = AttachedReferenceManager.GetOrCreateAttachedReference(sprite.Texture).Url; if (!urlToTexImage.ContainsKey(textureUrl)) { var image = assetManager.Load <Image>(textureUrl); var newTexImage = texTool.Load(image, false); // the sRGB mode does not impact on the alpha level texTool.Decompress(newTexImage, false); // the sRGB mode does not impact on the alpha level urlToTexImage[textureUrl] = Tuple.Create(newTexImage, image); } var texImage = urlToTexImage[textureUrl].Item1; var region = new Rectangle { X = (int)Math.Floor(sprite.Region.X), Y = (int)Math.Floor(sprite.Region.Y) }; region.Width = (int)Math.Ceiling(sprite.Region.Right) - region.X; region.Height = (int)Math.Ceiling(sprite.Region.Bottom) - region.Y; var alphaLevel = texTool.GetAlphaLevels(texImage, region, null, commandContext.Logger); // ignore transparent color key here because the input image has already been processed sprite.IsTransparent = alphaLevel != AlphaLevels.NoAlpha; } // free all the allocated images foreach (var tuple in urlToTexImage.Values) { tuple.Item1.Dispose(); assetManager.Unload(tuple.Item2); } } } // save the imageData into the data base assetManager.Save(Url, imageGroupData); return(Task.FromResult(ResultStatus.Successful)); }
public Sprite(Texture2D Texture, int GridWidth, int GridHeight) { SpriteSheet = new SpriteSheet(Texture).WithGrid((GridWidth, GridHeight)); color = Color.White; }
public AnimationManager(SpriteSheet spriteSheet, Vector2 initialPosition, Animation[] animations) { this.spriteSheet = spriteSheet; this.animations = animations; this.currentPosition = initialPosition; }
/// <summary> /// Draws all sprite sheets. /// </summary> private void DrawSpriteSheet(SpriteSheet spriteSheet) { // Updates texture locations in the sprite sheet. try { RefreshImageDimensions(spriteSheet); } catch { MessageBox.Show( $"Getting image dimensions for all frames failed for the sprite sheet named '{spriteSheet.Name}'.", "Export failed before draw", MessageBoxButton.OK, MessageBoxImage.Error); return; } TexturePacker texPacker = new TexturePacker(); try { texPacker.Pack(spriteSheet.Frames.ToList()); } catch (NullReferenceException) { MessageBox.Show( $"Packing the texture failed for the sprite sheet named '{spriteSheet.Name}'.", "Export failed before draw", MessageBoxButton.OK, MessageBoxImage.Error); return; } // Loads each image and draws it into the sprite sheet. using (Bitmap texSheet = new Bitmap(texPacker.Root.bounds.Width, texPacker.Root.bounds.Height)) { try { using (var canvas = Graphics.FromImage(texSheet)) { canvas.CompositingMode = System.Drawing.Drawing2D.CompositingMode.SourceCopy; canvas.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.None; foreach (var frame in spriteSheet.Frames) { using (var bitmap = Bitmap.FromFile(frame.GetAbsolutePath(projectSaveUrl))) { canvas.DrawImageUnscaled(bitmap, frame.X, frame.Y); } } } } catch { MessageBox.Show( $"Drawing the sprite sheet named '{spriteSheet.Name}' failed.", "Export failed to draw", MessageBoxButton.OK, MessageBoxImage.Error); return; } // Saves the final sprite sheet and updates the image source. try { string savePath = spriteSheet.GetAbsolutePath(projectSaveUrl); texSheet.Save($"{savePath}.png", System.Drawing.Imaging.ImageFormat.Png); SpritesheetImage.Source = new BitmapImage(new Uri(spriteSheet.ExportUrl, UriKind.Relative)); } catch { MessageBox.Show( $"The sprite sheet named '{spriteSheet.Name}' can't be saved with its current file path: /{spriteSheet.ExportUrl}.png", "Export failed to save", MessageBoxButton.OK, MessageBoxImage.Error); } } }
/// <summary> /// Initializes a new instance of the <see cref="SpriteSheetRenderer"/> class. /// </summary> /// <param name="texture">The texture.</param> /// <param name="spriteSheet">The sprite sheet.</param> public SpriteSheetRenderer(ITexture texture, SpriteSheet spriteSheet) { SpriteSheet = spriteSheet; Texture = texture; Texture.Filter = TextureFilterMode.Mipmap; }
/// <summary> /// Removes the tab linked to the given sprite sheet. /// </summary> private void RemoveSpriteSheetTab(SpriteSheet removedSpriteSheet) { TabItem tab = GetSpriteSheetTab(removedSpriteSheet); SpritesheetsList.Items.Remove(tab); }
public override async Task Execute() { spriteSheet = BulletSheet; agentSpriteComponent = Entity.Get <SpriteComponent>(); var animComponent = Entity.Get <AnimationComponent>(); PlayingAnimation playingAnimation = null; // Calculate offset of the bullet from the Agent if he is facing left and right side // TODO improve this var bulletOffset = new Vector3(1.3f, 1.65f, 0f); // Initialize game entities if (!IsLiveReloading) { shootDelayCounter = 0f; isAgentFacingRight = true; currentAgentAnimation = AgentAnimation.Idle; } CurrentAgentAnimation = currentAgentAnimation; var normalScaleX = Entity.Transform.Scale.X; var bulletCS = BulletColliderShape; Task animTask = null; while (Game.IsRunning) { await Script.NextFrame(); var inputState = GetKeyboardInputState(); if (inputState == InputState.None) { inputState = GetPointerInputState(); } if (inputState == InputState.RunLeft || inputState == InputState.RunRight) { // Update Agent's position var dt = (float)Game.UpdateTime.Elapsed.TotalSeconds; Entity.Transform.Position.X += ((inputState == InputState.RunRight) ? AgentMoveDistance : -AgentMoveDistance) * dt; if (Entity.Transform.Position.X < -gameWidthHalfX) { Entity.Transform.Position.X = -gameWidthHalfX; } if (Entity.Transform.Position.X > gameWidthHalfX) { Entity.Transform.Position.X = gameWidthHalfX; } isAgentFacingRight = inputState == InputState.RunRight; // If agent face left, flip the sprite Entity.Transform.Scale.X = isAgentFacingRight ? normalScaleX : -normalScaleX; // Update the sprite animation and state CurrentAgentAnimation = AgentAnimation.Run; if (playingAnimation == null || playingAnimation.Name != "Run") { playingAnimation = animComponent.Play("Run"); } } else if (inputState == InputState.Shoot) { if (animTask != null && !animTask.IsCompleted) { continue; } if (animTask != null && animTask.IsCompleted) { playingAnimation = null; } animTask = null; var rb = new RigidbodyComponent { CanCollideWith = CollisionFilterGroupFlags.CustomFilter1, CollisionGroup = CollisionFilterGroups.DefaultFilter }; rb.ColliderShapes.Add(new ColliderShapeAssetDesc { Shape = bulletCS }); // Spawns a new bullet var bullet = new Entity { new SpriteComponent { SpriteProvider = SpriteFromSheet.Create(spriteSheet, "bullet") }, rb, new BeamScript() }; bullet.Name = "bullet"; bullet.Transform.Position = (isAgentFacingRight) ? Entity.Transform.Position + bulletOffset : Entity.Transform.Position + (bulletOffset * new Vector3(-1, 1, 1)); bullet.Transform.UpdateWorldMatrix(); SceneSystem.SceneInstance.RootScene.Entities.Add(bullet); rb.LinearFactor = new Vector3(1, 0, 0); rb.AngularFactor = new Vector3(0, 0, 0); rb.ApplyImpulse(isAgentFacingRight ? new Vector3(25, 0, 0) : new Vector3(-25, 0, 0)); // Start animation for shooting CurrentAgentAnimation = AgentAnimation.Shoot; if (playingAnimation == null || playingAnimation.Name != "Attack") { playingAnimation = animComponent.Play("Attack"); animTask = animComponent.Ended(playingAnimation); } } else { CurrentAgentAnimation = AgentAnimation.Idle; if (playingAnimation == null || playingAnimation.Name != "Stance") { playingAnimation = animComponent.Play("Stance"); } } } }
public Professor(SpriteSheet readSprite, SpriteSheet talkSprite, Vector2 position, Game game, Camera cam) : base(readSprite, talkSprite, position, game, cam) { }
protected override async Task LoadContent() { await base.LoadContent(); Sprites = Asset.Load <SpriteSheet>("UIImages"); var lifeBar = new ImageElement { Source = Sprites["Logo"], HorizontalAlignment = HorizontalAlignment.Center }; lifeBar.DependencyProperties.Set(GridBase.ColumnSpanPropertyKey, 3); var quitGameButton = new Button { Content = new TextBlock { Text = "Quit Game", Font = Asset.Load <SpriteFont>("MicrosoftSansSerif15") }, VerticalAlignment = VerticalAlignment.Bottom, HorizontalAlignment = HorizontalAlignment.Left, Padding = Thickness.UniformRectangle(10), }; quitGameButton.DependencyProperties.Set(GridBase.ColumnPropertyKey, 0); quitGameButton.DependencyProperties.Set(GridBase.RowPropertyKey, 2); quitGameButton.Click += (sender, args) => Exit(); modalButton1Text = new TextBlock { Text = "Close Modal window 1", Font = Asset.Load <SpriteFont>("MicrosoftSansSerif15") }; var modalButton1 = new Button { Name = "Button Modal 1", Content = modalButton1Text, VerticalAlignment = VerticalAlignment.Center, HorizontalAlignment = HorizontalAlignment.Center, Padding = Thickness.UniformRectangle(10), }; modalButton1.Click += ModalButton1OnClick; modal1 = new ModalElement { Content = modalButton1, Name = "Modal 1" }; modal1.DependencyProperties.Set(Panel.ZIndexPropertyKey, 1); modal1.DependencyProperties.Set(GridBase.ColumnPropertyKey, 1); modal1.DependencyProperties.Set(GridBase.RowPropertyKey, 1); modal1.OutsideClick += Modal1OnOutsideClick; modalButton2Text = new TextBlock { Text = "Close Modal window 2", Font = Asset.Load <SpriteFont>("MicrosoftSansSerif15") }; var modalButton2 = new Button { Name = "Button Modal 2", Content = modalButton2Text, VerticalAlignment = VerticalAlignment.Center, HorizontalAlignment = HorizontalAlignment.Center, Padding = Thickness.UniformRectangle(10), }; modalButton2.Click += ModalButton2OnClick; modal2 = new ModalElement { Content = modalButton2, Name = "Modal 2" }; modal2.DependencyProperties.Set(Panel.ZIndexPropertyKey, 2); modal2.DependencyProperties.Set(GridBase.ColumnPropertyKey, 1); modal2.DependencyProperties.Set(GridBase.RowPropertyKey, 2); modal2.OutsideClick += Modal2OnOutsideClick; uniformGrid = new UniformGrid { Columns = 3, Rows = 3 }; uniformGrid.Children.Add(modal1); uniformGrid.Children.Add(modal2); uniformGrid.Children.Add(lifeBar); uniformGrid.Children.Add(quitGameButton); UIComponent.RootElement = uniformGrid; }
public TorchTile(TileId tileId) : base(tileId, SpriteSheet.GetSprites(TileId.Dirt)) { Tiles[(byte)tileId] = this; ConnectsToGrass = true; ConnectsToSand = true; }