FlatMapRenderer.java

Go to the documentation of this file.

/*
 * Gridarta MMORPG map editor for Crossfire, Daimonin and similar games.
 * Copyright (C) 2000-2023 The Gridarta Developers.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
package net.sf.gridarta.var.crossfire.gui.map.renderer;
 
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.image.BufferedImage;
import java.awt.image.RenderedImage;
import java.lang.ref.SoftReference;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import net.sf.gridarta.gui.filter.FilterControl;
import net.sf.gridarta.gui.filter.FilterState;
import net.sf.gridarta.gui.map.renderer.GridMapSquarePainter;
import net.sf.gridarta.model.filter.FilterConfigListener;
import net.sf.gridarta.model.io.GameObjectParser;
import net.sf.gridarta.model.mapgrid.MapGrid;
import net.sf.gridarta.model.mapmodel.MapModel;
import net.sf.gridarta.model.mapmodel.MapSquare;
import net.sf.gridarta.model.mapviewsettings.MapViewSettings;
import net.sf.gridarta.utils.ResourceIcons;
import net.sf.gridarta.var.crossfire.IGUIConstants;
import net.sf.gridarta.var.crossfire.model.archetype.Archetype;
import net.sf.gridarta.var.crossfire.model.gameobject.GameObject;
import net.sf.gridarta.var.crossfire.model.maparchobject.MapArchObject;
import org.apache.log4j.Category;
import org.apache.log4j.Logger;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
 
public class FlatMapRenderer extends AbstractFlatMapRenderer {
 
    @NotNull
    private static final Category LOG = Logger.getLogger(FlatMapRenderer.class);
 
    private static final long serialVersionUID = 1L;
 
    @NotNull
    private final MapModel<GameObject, MapArchObject, Archetype> mapModel;
 
    @NotNull
    private final FilterControl<GameObject, MapArchObject, Archetype> filterControl;
 
    @NotNull
    private final Color @NotNull [] highLightMask = { new Color(1.0f, 0.0f, 0.0f, 0.33f), new Color(0.0f, 1.0f, 0.0f, 0.33f), new Color(0.0f, 1.0f, 1.0f, 0.33f), };
 
    @NotNull
    private final Icon emptySquareIcon;
 
    @NotNull
    private final Point offset = new Point();
 
    @Nullable
    private SoftReference<BufferedImage> backBufferRef;
 
    @NotNull
    private final MapViewSettings mapViewSettings;
 
    @NotNull
    private final FilterState filterState = new FilterState();
 
    @NotNull
    private final SmoothingRenderer smoothingRenderer;
 
    @NotNull
    private final FilterConfigListener filterConfigListener = (filterConfigChangeType, filterConfig) -> forceRepaint();
 
    public FlatMapRenderer(@NotNull final MapViewSettings mapViewSettings, @NotNull final FilterControl<GameObject, MapArchObject, Archetype> filterControl, @NotNull final MapModel<GameObject, MapArchObject, Archetype> mapModel, @NotNull final MapGrid mapGrid, @NotNull final GridMapSquarePainter gridMapSquarePainter, @NotNull final GameObjectParser<GameObject, MapArchObject, Archetype> gameObjectParser, @NotNull final ResourceIcons resourceIcons, @NotNull final SmoothingRenderer smoothingRenderer) {
        super(mapViewSettings, mapModel, mapGrid, 32, gridMapSquarePainter, gameObjectParser);
        this.mapModel = mapModel;
        emptySquareIcon = resourceIcons.getResourceIcon(ResourceIcons.SQUARE_EMPTY);
        this.filterControl = filterControl;
        this.mapViewSettings = mapViewSettings;
        this.smoothingRenderer = smoothingRenderer;
        init();
        this.filterControl.addConfigListener(filterConfigListener);
    }
 
    @Override
    public void closeNotify() {
        super.closeNotify();
        filterControl.removeConfigListener(filterConfigListener);
    }
 
    @Override
    protected void updateSquare(@NotNull final Point point) {
        if (!mapModel.getMapArchObject().isPointValid(point)) {
            return;
        }
 
        final Image backBuffer = getBackBufferImage();
        if (backBuffer == null) {
            return;
        }
 
        final Graphics g = backBuffer.getGraphics();
        try {
            paintSquare(g, getBorderOffsetX() + point.x * IGUIConstants.SQUARE_WIDTH, getBorderOffsetY() + point.y * IGUIConstants.SQUARE_HEIGHT, mapModel.getMapSquare(point));
            paintSquareGrid(g, point);
            paintSquareSelection(g, point);
        } finally {
            g.dispose();
        }
    }
 
    @Override
    protected void updateSquares(@NotNull final Rectangle rectangle) {
        final Point point = new Point();
        if (mapViewSettings.isSmoothing()) {
            for (point.x = rectangle.x - 1; point.x < rectangle.x + rectangle.width + 1; point.x++) {
                for (point.y = rectangle.y - 1; point.y < rectangle.y + rectangle.height + 1; point.y++) {
                    updateSquare(point);
                }
            }
        } else {
            for (point.x = rectangle.x; point.x < rectangle.x + rectangle.width; point.x++) {
                for (point.y = rectangle.y; point.y < rectangle.y + rectangle.height; point.y++) {
                    updateSquare(point);
                }
            }
        }
    }
 
    @Override
    protected void updateAll() {
        final Image backBuffer = getBackBufferImage();
        if (backBuffer == null) {
            return;
        }
 
        final Graphics graphics = backBuffer.getGraphics();
        try {
            paintComponent(graphics, false, false);
        } finally {
            graphics.dispose();
        }
    }
 
    @Override
    public void paintComponent(@NotNull final Graphics g) {
        final BufferedImage backBuffer = getBackBufferImage();
        if (backBuffer == null) {
            paintComponent(g, false, true);
        } else {
            final int w = backBuffer.getWidth();
            final int h = backBuffer.getHeight();
            g.drawImage(backBuffer, 0, 0, w, h, 0, 0, w, h, null);
        }
    }
 
    @Override
    protected void resizeBackBuffer(@NotNull final Dimension size) {
        final RenderedImage backBuffer = getBackBufferImage();
        if (backBuffer != null && backBuffer.getWidth() == size.width && backBuffer.getHeight() == size.height) {
            return;
        }
 
        backBufferRef = null;
 
        if (LOG.isDebugEnabled()) {
            LOG.debug("Creating a backbuffer of size " + size.width + "x" + size.height + ".");
        }
        final BufferedImage newBackBuffer;
        //The backbuffer is optional
        //noinspection ErrorNotRethrown
        try {
            newBackBuffer = new BufferedImage(size.width, size.height, BufferedImage.TYPE_INT_ARGB);
        } catch (final OutOfMemoryError ignore) {
            if (LOG.isDebugEnabled()) {
                LOG.debug("out of memory creating new back buffer");
            }
            return;
        }
        final Graphics g = newBackBuffer.getGraphics();
        try {
            g.setColor(getBackground());
            g.fillRect(0, 0, size.width, size.height);
        } finally {
            g.dispose();
        }
        backBufferRef = new SoftReference<>(newBackBuffer);
    }
 
    @Override
    protected void paintSquare(@NotNull final Graphics g, final int x, final int y, @NotNull final MapSquare<GameObject, MapArchObject, Archetype> square) {
        filterControl.newSquare(filterState);
        if (square.isEmpty()) {
            emptySquareIcon.paintIcon(this, g, x, y);
        } else {
            g.fillRect(x, y, IGUIConstants.SQUARE_WIDTH, IGUIConstants.SQUARE_HEIGHT);
            if (mapViewSettings.isSmoothing()) {
                final int borderOffsetX = getBorderOffsetX();
                final int borderOffsetY = getBorderOffsetY();
                int layer = -1;
                for (final GameObject node : square) {
                    if (node.getAttributeInt(GameObject.INVISIBLE, true) == 0) {
                        layer++;
                    }
                    filterControl.objectInSquare(filterState, node);
                    if (filterControl.canShow(node) && mapViewSettings.isEditType(node)) {
                        paintGameObject(g, x, y, node);
                        if (node.getAttributeInt(GameObject.SMOOTHLEVEL, true) > 0) {
                            smoothingRenderer.paintSmooth(g, square.getMapLocation(), node.getAttributeInt(GameObject.SMOOTHLEVEL, true), layer, false, borderOffsetX, borderOffsetY);
                        }
                    }
                }
                if (layer > -1) {
                    smoothingRenderer.paintSmooth(g, square.getMapLocation(), 1, layer + 1, true, borderOffsetX, borderOffsetY);
                }
            } else {
                for (final GameObject node : square) {
                    filterControl.objectInSquare(filterState, node);
                    if (filterControl.canShow(node) && mapViewSettings.isEditType(node)) {
                        paintGameObject(g, x, y, node);
                    }
                }
            }
        }
        for (int i = 0; i < FilterControl.MAX_HIGHLIGHT; i++) {
            if (filterControl.isHighlightedSquare(filterState, i)) {
                final Color color = g.getColor();
                g.setColor(highLightMask[i]);
                g.fillRect(x, y, IGUIConstants.SQUARE_WIDTH, IGUIConstants.SQUARE_HEIGHT);
                g.setColor(color);
            }
        }
    }
 
    private void paintGameObject(@NotNull final Graphics g, final int x, final int y, @NotNull final net.sf.gridarta.model.gameobject.GameObject<GameObject, MapArchObject, Archetype> node) {
        final ImageIcon img = node.getNormalImage();
        if (!node.isMulti() || (img.getIconWidth() == IGUIConstants.SQUARE_WIDTH && img.getIconHeight() == IGUIConstants.SQUARE_HEIGHT)) {
            offset.x = 0;
            offset.y = 0;
        } else {
            // this is an oversized image, so it must be shifted
            // XXX: it must also be clipped to not overwrite filter information
            offset.x = IGUIConstants.SQUARE_WIDTH * (node.getArchetype().getMultiX() - node.getMinX());
            offset.y = IGUIConstants.SQUARE_HEIGHT * (node.getArchetype().getMultiY() - node.getMinY());
        }
        g.drawImage(img.getImage(), x, y, x + IGUIConstants.SQUARE_WIDTH, y + IGUIConstants.SQUARE_HEIGHT, offset.x, offset.y, offset.x + IGUIConstants.SQUARE_WIDTH, offset.y + IGUIConstants.SQUARE_HEIGHT, this);
    }
 
    @Nullable
    private BufferedImage getBackBufferImage() {
        if (backBufferRef == null) {
            return null;
        }
 
        final BufferedImage backBuffer = backBufferRef.get();
        if (backBuffer == null) {
            if (LOG.isDebugEnabled()) {
                LOG.debug("lost back buffer");
            }
            backBufferRef = null;
            return null;
        }
 
        return backBuffer;
    }
 
}