FaceObjectProviders.java

Go to the documentation of this file.

/*
 * Gridarta MMORPG map editor for Crossfire, Daimonin and similar games.
 * Copyright (C) 2000-2015 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.model.face;
 
import java.awt.image.ImageFilter;
import java.awt.image.RGBImageFilter;
import java.util.Collection;
import java.util.concurrent.CopyOnWriteArrayList;
import javax.swing.GrayFilter;
import javax.swing.ImageIcon;
import net.sf.gridarta.model.archetype.Archetype;
import net.sf.gridarta.model.baseobject.BaseObject;
import net.sf.gridarta.model.baseobject.BaseObjectVisitor;
import net.sf.gridarta.model.data.NamedObject;
import net.sf.gridarta.model.gameobject.GameObject;
import net.sf.gridarta.model.maparchobject.MapArchObject;
import net.sf.gridarta.utils.AlphaImageFilterInstance;
import net.sf.gridarta.utils.ResourceIcons;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
 
public class FaceObjectProviders {
 
    private static final int GRAY_PERCENTAGE = 50;
 
    @NotNull
    private static final ImageFilter GRAY_FILTER = new GrayFilter(false, GRAY_PERCENTAGE);
 
    @NotNull
    private static final FilterFaceProvider GRAY = new FilterFaceProvider(GRAY_FILTER);
 
    @NotNull
    private static final ImageFilter RED_FILTER = new ColourFilter(ColourFilter.RED_MASK);
 
    @NotNull
    private static final FilterFaceProvider RED = new FilterFaceProvider(RED_FILTER);
 
    @NotNull
    private static final ImageFilter GREEN_FILTER = new ColourFilter(ColourFilter.GREEN_MASK);
 
    @NotNull
    private static final FilterFaceProvider GREEN = new FilterFaceProvider(GREEN_FILTER);
 
    @NotNull
    private static final ImageFilter BLUE_FILTER = new ColourFilter(ColourFilter.BLUE_MASK);
 
    @NotNull
    private static final FilterFaceProvider BLUE = new FilterFaceProvider(BLUE_FILTER);
 
    @NotNull
    private static final ImageFilter GRID_FILTER = new RGBImageFilter() {
 
        @Override
        public int filterRGB(final int x, final int y, final int rgb) {
            return (x + y) % 2 == 0 ? rgb & ColourFilter.RED_GREEN_BLUE_MASK : rgb;
        }
 
        @NotNull
        @Override
        public RGBImageFilter clone() {
            return (RGBImageFilter) super.clone();
        }
 
    }; // GRID_FILTER
 
    @NotNull
    private static final FilterFaceProvider GRID = new FilterFaceProvider(GRID_FILTER);
 
    @Nullable
    private FaceProvider normalFaceProvider;
 
    @NotNull
    private static final FilterFaceProvider ALPHA = new FilterFaceProvider(AlphaImageFilterInstance.ALPHA_FILTER);
 
    @NotNull
    private final FilterFaceProvider doubleFaceProvider;
 
    @NotNull
    private final FilterFaceProvider doubleAlphaFaceProvider;
 
    @NotNull
    private final FilterFaceProvider stretchedFaceProvider;
 
    @NotNull
    private final FaceObjects faceObjects;
 
    @NotNull
    private final ResourceIcons resourceIcons;
 
    @NotNull
    private final Collection<FaceObjectProvidersListener> faceObjectProvidersListeners = new CopyOnWriteArrayList<>();
 
    public FaceObjectProviders(final int doubleFaceOffset, @NotNull final FaceObjects faceObjects, @NotNull final ResourceIcons resourceIcons) {
        this.faceObjects = faceObjects;
        this.resourceIcons = resourceIcons;
        doubleFaceProvider = new FilterFaceProvider(new DoubleImageFilter(doubleFaceOffset));
        doubleAlphaFaceProvider = new FilterFaceProvider(new DoubleImageFilter(doubleFaceOffset));
        stretchedFaceProvider = new FilterFaceProvider(new StretchedImageFilter());
    }
 
    public void addFaceObjectProvidersListener(@NotNull final FaceObjectProvidersListener listener) {
        faceObjectProvidersListeners.add(listener);
    }
 
    public void removeFaceObjectProvidersListener(@NotNull final FaceObjectProvidersListener listener) {
        faceObjectProvidersListeners.remove(listener);
    }
 
    public void reloadAll() {
        if (normalFaceProvider != null) {
            normalFaceProvider.reload();
        }
        for (final FaceProvider faceProvider : new FaceProvider[] { GRAY, RED, GREEN, BLUE, ALPHA, GRID, doubleFaceProvider, doubleAlphaFaceProvider, stretchedFaceProvider }) {
            faceProvider.reload();
        }
 
        for (final FaceObjectProvidersListener faceObjectProvidersListener : faceObjectProvidersListeners) {
            faceObjectProvidersListener.facesReloaded();
        }
    }
 
    public void setNormal(@NotNull final FaceProvider normalFaceProvider) {
        this.normalFaceProvider = normalFaceProvider;
        GRAY.setParent(normalFaceProvider);
        RED.setParent(normalFaceProvider);
        GREEN.setParent(normalFaceProvider);
        BLUE.setParent(normalFaceProvider);
        ALPHA.setParent(normalFaceProvider);
        GRID.setParent(normalFaceProvider);
        doubleFaceProvider.setParent(normalFaceProvider);
        doubleAlphaFaceProvider.setParent(normalFaceProvider);
        stretchedFaceProvider.setParent(normalFaceProvider);
    }
 
    @NotNull
    public <G extends GameObject<G, A, R>, A extends MapArchObject<A>, R extends Archetype<G, A, R>> ImageIcon getFace(@NotNull final BaseObject<G, A, R, ?> baseObject) {
        if (normalFaceProvider == null) {
            throw new IllegalStateException("normal face provider is unset");
        }
 
        final boolean[] undefinedArchetype = new boolean[1];
        baseObject.visit(new BaseObjectVisitor<G, A, R>() {
 
            @Override
            public void visit(@NotNull final Archetype<G, A, R> archetype) {
                undefinedArchetype[0] = archetype.isUndefinedArchetype();
            }
 
            @Override
            public void visit(@NotNull final GameObject<G, A, R> gameObject) {
                undefinedArchetype[0] = gameObject.hasUndefinedArchetype();
            }
 
        });
        return getFace(baseObject.getFaceObjName(), undefinedArchetype[0], normalFaceProvider, normalFaceProvider, 0);
    }
 
    @NotNull
    public ImageIcon getTrans(@NotNull final GameObject<?, ?, ?> gameObject) {
        return getFace(gameObject.getFaceObjName(), gameObject.hasUndefinedArchetype(), ALPHA, ALPHA, 0);
    }
 
    @NotNull
    public ImageIcon getDouble(@NotNull final GameObject<?, ?, ?> gameObject) {
        if (normalFaceProvider == null) {
            throw new IllegalStateException("normal face provider is unset");
        }
        return getFace(gameObject.getFaceObjName(), gameObject.hasUndefinedArchetype(), normalFaceProvider, doubleFaceProvider, 0);
    }
 
    @NotNull
    public ImageIcon getTransDouble(@NotNull final GameObject<?, ?, ?> gameObject) {
        return getFace(gameObject.getFaceObjName(), gameObject.hasUndefinedArchetype(), ALPHA, doubleAlphaFaceProvider, 0);
    }
 
    @NotNull
    public ImageIcon getStretched(@NotNull final GameObject<?, ?, ?> gameObject, final long stretch) {
        return getFace(gameObject.getFaceObjName(), gameObject.hasUndefinedArchetype(), stretchedFaceProvider, ALPHA, stretch);
    }
 
    @NotNull
    private ImageIcon getFace(@Nullable final String faceName, final boolean hasUndefinedArchetype, @NotNull final FaceProvider singleFaceProvider, @NotNull final FaceProvider doubleFaceProvider, final long stretch) {
        if (hasUndefinedArchetype) {
            return resourceIcons.getResourceIcon(ResourceIcons.SQUARE_NO_ARCH);
        }
 
        if (faceName == null) {
            return resourceIcons.getResourceIcon(ResourceIcons.SQUARE_NO_FACE);
        }
 
        final FaceObject faceObject = faceObjects.get(faceName);
        if (faceObject == null) {
            return resourceIcons.getResourceIcon(ResourceIcons.SQUARE_NO_FACE);
        }
 
        final FaceProvider faceProvider;
 
        if (stretch != 0) {
            faceProvider = stretchedFaceProvider;
        } else if (faceObject.isDouble()) {
            faceProvider = doubleFaceProvider;
        } else {
            faceProvider = singleFaceProvider;
        }
 
        final String alternativeFaceName = faceObject.getAlternativeFaceName();
        final String effectiveFaceName = alternativeFaceName != null && singleFaceProvider == doubleFaceProvider ? alternativeFaceName : faceName;
        final ImageIcon face = faceProvider.getImageIconForFacename(effectiveFaceName, stretch);
        return face == null ? resourceIcons.getResourceIcon(ResourceIcons.SQUARE_UNKNOWN) : face;
    }
 
    @Nullable
    public ImageIcon getImageIconForFacename(@NotNull final String faceObjName) {
        return normalFaceProvider == null ? null : normalFaceProvider.getImageIconForFacename(faceObjName, 0);
    }
 
    @Nullable
    public ImageIcon getDisplayIcon(@NotNull final NamedObject namedObject) {
        return getImageIconForFacename(namedObject.getDisplayIconName());
    }
 
}