Example #1
0
        public GameObjectEditor(ProjectService projectService, PalettesService palettesService, GraphicsService graphicsService, GameObjectService gameObjectService)
        {
            InitializeComponent();

            _projectService    = projectService;
            _gameObjectService = gameObjectService;
            _graphicsService   = graphicsService;
            _palettesService   = palettesService;
            _graphicsAccessor  = new GraphicsAccessor(graphicsService.GetGlobalTiles(), graphicsService.GetExtraTiles());
            viewObjects.Add(viewObject);

            Dpi dpi = this.GetDpi();

            _bitmap              = new WriteableBitmap(256, 256, dpi.X, dpi.Y, PixelFormats.Bgra32, null);
            _renderer            = new GameObjectRenderer(_gameObjectService, _palettesService, _graphicsAccessor);
            _renderer.RenderGrid = true;

            GameObjectRenderer.Source = _bitmap;

            List <Palette> palettes = _palettesService.GetPalettes();

            ObjectSelector.Initialize(_gameObjectService, _palettesService, _graphicsAccessor, palettes[0]);

            PaletteSelector.ItemsSource   = palettes;
            PaletteSelector.SelectedIndex = 0;

            _graphicsService.GraphicsUpdated      += _graphicsService_GraphicsUpdated;
            _graphicsService.ExtraGraphicsUpdated += _graphicsService_GraphicsUpdated;
        }
Example #2
0
 public GameObjectRenderer(GameObjectService gameObjectService, PalettesService palettesService, GraphicsAccessor graphicsAccessor) : base(graphicsAccessor)
 {
     BYTE_STRIDE        = 256 * 4;
     _buffer            = new byte[256 * 256 * 4];
     _gameObjectService = gameObjectService;
     _palettesService   = palettesService;
 }
        public GraphicsWindow(GraphicsService graphicsService, TileService tileService, PalettesService palettesService)
        {
            InitializeComponent();

            _graphicsService = graphicsService;
            _tileService     = tileService;
            _paletteService  = palettesService;

            _graphicsAccessor = new GraphicsAccessor(_graphicsService.GetTilesAtAddress(0));
            _graphicsRenderer = new GraphicsSetRender(_graphicsAccessor);
            _blockRenderer    = new BlockRenderer();


            Dpi dpi = this.GetDpi();

            _graphicsBitmap = new WriteableBitmap(128, 128, dpi.X, dpi.Y, PixelFormats.Bgra32, null);
            _editorBitmap   = new WriteableBitmap(16, 16, dpi.X, dpi.Y, PixelFormats.Bgra32, null);

            PatternTable.Source = _graphicsBitmap;
            EditorImage.Source  = _editorBitmap;

            LoadPalettes();
            GraphicsType.SelectedIndex = LayoutOrder.SelectedIndex = 0;

            _paletteService.PalettesChanged += _paletteService_PalettesChanged;
        }
Example #4
0
 public PaletteRenderer(PalettesService paletteService, PaletteType paletteType) : base(null)
 {
     _buffer          = new byte[256 * (paletteType == PaletteType.Full ? 64 : 32) * BYTES_PER_BLOCK];
     _paletteType     = paletteType;
     _palettesService = paletteService;
     BYTE_STRIDE      = 256 * 4;
 }
Example #5
0
        private void _ProjectPanel_ProjectLoaded(Project project)
        {
            _project           = project;
            _projectService    = new ProjectService(new ErrorService(), project);
            _graphicsService   = new GraphicsService(_errorService, project);
            _levelService      = new LevelService(_errorService, project);
            _palettesService   = new PalettesService(_errorService, project);
            _worldService      = new WorldService(_errorService, project);
            _tileService       = new TileService(_errorService, project);
            _textService       = new TextService(_errorService, project);
            _clipBoardService  = new ClipBoardService();
            _romService        = new RomService(_errorService, _graphicsService, _palettesService, _tileService, _levelService, _worldService, _textService);
            _gameObjectService = new GameObjectService(_errorService, project);

            _levelService.LevelUpdated += _levelService_LevelUpdated;
            _worldService.WorldUpdated += _worldService_WorldUpdated;


            List <WorldInfo> worldInfos = new List <WorldInfo>();

            worldInfos.AddRange(project.WorldInfo);
            worldInfos.Add(project.EmptyWorld);

            FilePanel.Initialize(_levelService, _worldService);

            SplashText.Visibility   = Visibility.Collapsed;
            _config.LastProjectPath = _project.DirectoryPath + "\\" + _project.Name + ".json";
        }
Example #6
0
 public LevelRenderer(GraphicsAccessor graphicsAccessor, LevelDataAccessor levelDataAccessor, PalettesService paletteService, GameObjectService gameObjectService, List <TileTerrain> terrain) : base(graphicsAccessor)
 {
     _levelDataAccessor = levelDataAccessor;
     _gameObjectService = gameObjectService;
     _paletteService    = paletteService;
     _terrain           = terrain;
     _buffer            = new byte[BITMAP_WIDTH * BITMAP_HEIGHT * 4];
 }
Example #7
0
        public WorldRenderer(GraphicsAccessor graphicsAccessor, WorldDataAccessor worldDataAccessor, PalettesService paletteService, List <MapTileInteraction> terrain) : base(graphicsAccessor)
        {
            _worldDataAccessor = worldDataAccessor;
            _paletteService    = paletteService;
            _terrain           = terrain;
            _buffer            = new byte[BITMAP_WIDTH * BITMAP_HEIGHT * 4];

            BYTE_STRIDE = BYTES_PER_PIXEL * PIXELS_PER_BLOCK_ROW * BLOCKS_PER_SCREEN * 4;
        }
Example #8
0
        public void Initialize(GameObjectService gameObjectService, PalettesService palettesService, GraphicsAccessor graphicsAccessor, Palette palette)
        {
            _gameObjectService = gameObjectService;
            _graphicsAccessor  = graphicsAccessor;
            _palette           = palette;
            _palettesService   = palettesService;

            _objectTypes = new List <GameObjectType>();

            _renderer = new GameObjectRenderer(gameObjectService, _palettesService, graphicsAccessor);

            Dpi dpi = this.GetDpi();

            _bitmap = new WriteableBitmap(256, 256, dpi.X, dpi.Y, PixelFormats.Bgra32, null);

            _selectedGroup = new Dictionary <GameObjectType, string>();

            switch (ObjectGroup)
            {
            case GameObjectGroup.Level:
                _objectTypes.Add(GameObjectType.Global);
                _objectTypes.Add(GameObjectType.TypeA);
                _objectTypes.Add(GameObjectType.TypeB);

                break;

            case GameObjectGroup.World:
                _objectTypes.Add(GameObjectType.World);
                break;

            case GameObjectGroup.All:
                _objectTypes.Add(GameObjectType.Global);
                _objectTypes.Add(GameObjectType.TypeA);
                _objectTypes.Add(GameObjectType.TypeB);
                _objectTypes.Add(GameObjectType.World);
                break;
            }

            foreach (var objectType in _objectTypes)
            {
                _selectedGroup[objectType] = null;
            }


            _selectedObject = null;

            GameObjectImage.Source      = _bitmap;
            GameObjectTypes.ItemsSource = _objectTypes;

            _renderer.Update(palette);

            CanvasArea.Background         = new SolidColorBrush(palette.RgbColors[0][0].ToMediaColor());
            GameObjectTypes.SelectedIndex = 0;

            _gameObjectService.GameObjectUpdated += GameObjectsUpdated;
        }
Example #9
0
        public TileBlockEditor(ProjectService projectService, WorldService worldService, LevelService levelService, GraphicsService graphicsService, PalettesService palettesService, TileService tileService, TextService textService)
        {
            _ignoreChanges = true;
            InitializeComponent();

            _projectService  = projectService;
            _palettesService = palettesService;
            _graphicsService = graphicsService;
            _worldService    = worldService;
            _levelService    = levelService;
            _tileService     = tileService;
            _textService     = textService;

            List <KeyValuePair <string, string> > tileSetText = _textService.GetTable("tile_sets");

            tileSetText.Insert(0, new KeyValuePair <string, string>("0", "Map"));

            TerrainList.ItemsSource        = _localTileTerrain = _tileService.GetTerrainCopy();
            LevelList.ItemsSource          = _levelService.AllWorldsLevels();
            MapInteractionList.ItemsSource = _localMapTileInteraction = _tileService.GetMapTileInteractionCopy();

            _graphicsAccessor = new GraphicsAccessor(_graphicsService.GetTileSection(0), _graphicsService.GetTileSection(0), _graphicsService.GetGlobalTiles(), _graphicsService.GetExtraTiles());

            _graphicsSetRenderer = new GraphicsSetRender(_graphicsAccessor);
            _tileSetRenderer     = new TileSetRenderer(_graphicsAccessor, _localTileTerrain, _localMapTileInteraction);

            Dpi dpi = this.GetDpi();

            _graphicsSetBitmap = new WriteableBitmap(128, 128, dpi.X, dpi.Y, PixelFormats.Bgra32, null);
            _tileBlockBitmap   = new WriteableBitmap(16, 16, dpi.X, dpi.Y, PixelFormats.Bgra32, null);

            GraphicsSetImage.Source = _graphicsSetBitmap;

            TileBlockImage.Source = _tileBlockBitmap;

            BlockSelector.Initialize(_graphicsAccessor, _tileService, _tileService.GetTileSet(0), _graphicsService.GetPalette(0), _tileSetRenderer);
            BlockSelector.TileBlockSelected += BlockSelector_TileBlockSelected;

            LevelList.SelectedIndex          = 1;
            BlockSelector.SelectedBlockValue = 0;
            _ignoreChanges = false;

            _graphicsService.GraphicsUpdated      += _graphicsService_GraphicsUpdated;
            _graphicsService.ExtraGraphicsUpdated += _graphicsService_GraphicsUpdated;
        }
Example #10
0
        public void ConvertPalettes()
        {
            ProjectService  projectService  = new ProjectService(new ErrorService());
            Project         project         = projectService.LoadProject(@"C:\Projects\Mario Adventure 3\Mushroom Mayhem\Mushroom Mayhem.json");
            LevelService    levelService    = new LevelService(new ErrorService(), project);
            WorldService    worldService    = new WorldService(new ErrorService(), project);
            PalettesService palettesService = new PalettesService(new ErrorService(), project);
            var             palettes        = palettesService.GetPalettes();

            foreach (IInfo info in levelService.AllWorldsLevels())
            {
                if (info.InfoType == InfoType.Level)
                {
                    LevelInfo levelInfo = info as LevelInfo;
                    Level     level     = levelService.LoadLevel(levelInfo);
                    Palette   palette   = palettes.Where(p => p.Id == level.PaletteId).FirstOrDefault();
                    if (!palette.Renamed)
                    {
                        palette.Name    = level.Name;
                        palette.Renamed = true;
                        palettesService.CommitPalette(palette);
                    }
                }

                if (info.InfoType == InfoType.World)
                {
                    WorldInfo worldInfo = info as WorldInfo;
                    World     world     = worldService.LoadWorld(worldInfo);
                    Palette   palette   = palettes.Where(p => p.Id == world.PaletteId).FirstOrDefault();
                    if (!palette.Renamed)
                    {
                        palette.Name    = world.Name;
                        palette.Renamed = true;
                        palettesService.CommitPalette(palette);
                    }
                }
            }

            projectService.SaveProject();
        }
Example #11
0
        public PaletteEditor(ProjectService projectService, PalettesService palettesService)
        {
            InitializeComponent();

            _projectService  = projectService;
            _palettesService = palettesService;

            Dpi dpi = this.GetDpi();

            _bitmapSection = new WriteableBitmap(256, 32, dpi.X, dpi.Y, PixelFormats.Bgra32, null);
            _bitmapFull    = new WriteableBitmap(256, 64, dpi.X, dpi.Y, PixelFormats.Bgra32, null);

            ImageSection.Source = _bitmapSection;
            ImageFull.Source    = _bitmapFull;

            _rendererSection = new PaletteRenderer(_palettesService, PaletteType.Section);
            _rendererFull    = new PaletteRenderer(_palettesService, PaletteType.Full);

            PaletteList.ItemsSource   = _palettesService.GetPalettes();
            PaletteList.SelectedIndex = 0;

            UpdateFull();

            _palettesService.PalettesChanged += _palettesService_PalettesChanged;
            _rgbPalette = _palettesService.RgbPalette;
            _rgbEditors = new List <PaletteRgbEditor>();

            for (int i = 0; i < 0x40; i++)
            {
                PaletteRgbEditor rgbEditor = new PaletteRgbEditor();
                rgbEditor.RgbColor     = _rgbPalette[i];
                rgbEditor.PaletteIndex = i;

                _rgbEditors.Add(rgbEditor);
                PaletteRgbList.Children.Add(rgbEditor);
            }
        }
Example #12
0
        public WorldPanel(GraphicsService graphicsService, PalettesService palettesService, TextService textService, TileService tileService, WorldService worldService, LevelService levelService, GameObjectService gameObjectService, WorldInfo worldInfo)
        {
            InitializeComponent();

            _worldInfo         = worldInfo;
            _textService       = textService;
            _graphicsService   = graphicsService;
            _tileService       = tileService;
            _palettesService   = palettesService;
            _worldService      = worldService;
            _gameObjectService = gameObjectService;

            _historyService     = new HistoryService();
            _interactions       = _tileService.GetMapTileInteractions();
            _world              = _worldService.LoadWorld(_worldInfo);
            _compressionService = new CompressionService();
            Tile[] bottomTableSet = _graphicsService.GetTileSection(_world.TileTableIndex);
            Tile[] topTableSet    = _graphicsService.GetTileSection(_world.AnimationTileTableIndex);
            _graphicsAccessor  = new GraphicsAccessor(topTableSet, bottomTableSet, _graphicsService.GetGlobalTiles(), _graphicsService.GetExtraTiles());
            _worldDataAccessor = new WorldDataAccessor(_world);

            _bitmap        = new WriteableBitmap(WorldRenderer.BITMAP_WIDTH, WorldRenderer.BITMAP_HEIGHT, 96, 96, PixelFormats.Bgra32, null);
            _worldRenderer = new WorldRenderer(_graphicsAccessor, _worldDataAccessor, _palettesService, _tileService.GetMapTileInteractions());
            _worldRenderer.Initializing();

            _tileSet = _tileService.GetTileSet(_world.TileSetIndex);

            Palette palette = _palettesService.GetPalette(_world.PaletteId);

            _worldRenderer.Update(tileSet: _tileSet, palette: palette);

            WorldRenderSource.Source = _bitmap;
            WorldRenderSource.Width  = _bitmap.PixelWidth;
            WorldRenderSource.Height = _bitmap.PixelHeight;
            CanvasContainer.Width    = RenderContainer.Width = _world.ScreenLength * 16 * 16;

            SelectedEditMode.SelectedIndex = 0;
            SelectedDrawMode.SelectedIndex = 0;

            TileSelector.Initialize(_graphicsAccessor, _tileService, _tileSet, palette);
            ObjectSelector.Initialize(_gameObjectService, _palettesService, _graphicsAccessor, palette);
            PointerEditor.Initialize(levelService, _worldInfo);

            _world.ObjectData.ForEach(o => o.GameObject = gameObjectService.GetObject(o.GameObjectId));


            UpdateTextTables();

            _graphicsService.GraphicsUpdated      += _graphicsService_GraphicsUpdated;
            _graphicsService.ExtraGraphicsUpdated += _graphicsService_GraphicsUpdated;
            _palettesService.PalettesChanged      += _palettesService_PalettesChanged;
            _tileService.TileSetUpdated           += _tileService_TileSetUpdated;
            _worldService.WorldUpdated            += _worldService_WorldUpdated;
            gameObjectService.GameObjectUpdated   += GameObjectService_GameObjectsUpdated;


            _world.ObjectData.ForEach(o =>
            {
                o.CalcBoundBox();
                o.CalcVisualBox(true);
            });

            _initializing = false;
            _worldRenderer.Ready();
            Update();
        }