external-repos/forge
1
0
Fork 0
mirror of https://github.com/Card-Forge/forge.git synced 2025-11-17 03:08:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' of https://git.cardforge.org/core-developers/forge.git

Browse Source
This commit is contained in:
Alessandro Coli
2019-10-09 22:20:15 +02:00
parent 9ed54f726c 7bcba5df37
commit 17706bd5e4
8 changed files with 189 additions and 134 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
forge-gui-mobile/src/forge/CachedCardImage.java
View File

@@ -34,11 +34,7 @@ public abstract class CachedCardImage implements ImageFetcher.Callback {
}
public Texture getImage() {
return ImageCache.getImage(key, true, false);
}
public Texture getImage(boolean mask) {
return ImageCache.getImage(key, true, mask);
return ImageCache.getImage(key, true);
}
public abstract void onImageFetched();

46
forge-gui-mobile/src/forge/Graphics.java
View File

@@ -312,21 +312,21 @@ public class Graphics {
}
//adjust width/height so rectangle covers equivalent filled area
w = Math.round(w - 1);
h = Math.round(h - 1);
w = Math.round(w + 1);
h = Math.round(h + 1);
startShape(ShapeType.Line);
shapeRenderer.setColor(color);
x = adjustX(x);
float y2 = adjustY(y, h);
float x2 = x + w;
y = y2 + h;
//TODO: draw arcs at corners
shapeRenderer.line(x, y, x, y2);
shapeRenderer.line(x, y2, x2 + 1, y2); //+1 prevents corner not being filled
shapeRenderer.line(x2, y2, x2, y);
shapeRenderer.line(x2 + 1, y, x, y); //+1 prevents corner not being filled
shapeRenderer.arc(adjustX(x) + cornerRadius, adjustY(y + cornerRadius, 0), cornerRadius, 90f, 90f);
shapeRenderer.arc(adjustX(x) + w - cornerRadius, adjustY(y + cornerRadius, 0), cornerRadius, 0f, 90f);
shapeRenderer.arc(adjustX(x) + w - cornerRadius, adjustY(y + h - cornerRadius, 0), cornerRadius, 270, 90f);
shapeRenderer.arc(adjustX(x) + cornerRadius, adjustY(y + h - cornerRadius, 0), cornerRadius, 180, 90f);
shapeRenderer.rect(adjustX(x) + cornerRadius, adjustY(y, cornerRadius), w - 2*cornerRadius, cornerRadius);
shapeRenderer.rect(adjustX(x) + w - cornerRadius, adjustY(y + cornerRadius, h - 2*cornerRadius), cornerRadius, h - 2*cornerRadius);
shapeRenderer.rect(adjustX(x) + cornerRadius, adjustY(y + h - cornerRadius, cornerRadius), w - 2*cornerRadius, cornerRadius);
shapeRenderer.rect(adjustX(x), adjustY(y + cornerRadius, h - 2*cornerRadius), cornerRadius, h - 2*cornerRadius);
endShape();
@@ -343,6 +343,30 @@ public class Graphics {
batch.begin();
}
public void fillRoundRect(Color color, float x, float y, float w, float h, float radius) {
batch.end(); //must pause batch while rendering shapes
if (alphaComposite < 1) {
color = FSkinColor.alphaColor(color, color.a * alphaComposite);
}
if (color.a < 1) { //enable blending so alpha colored shapes work properly
Gdx.gl.glEnable(GL_BLEND);
}
startShape(ShapeType.Filled);
shapeRenderer.setColor(color);
shapeRenderer.circle(adjustX(x+radius), adjustY(y+radius, 0), radius);
shapeRenderer.circle(adjustX((x+w) - radius), adjustY(y+radius, 0), radius);
shapeRenderer.circle(adjustX(x+radius), adjustY((y+h) - radius, 0), radius);
shapeRenderer.circle(adjustX((x+w) - radius), adjustY((y+h) - radius, 0), radius);
shapeRenderer.rect(adjustX(x), adjustY(y+radius, h-radius*2), w, h-radius*2);
shapeRenderer.rect(adjustX(x+radius), adjustY(y, h), w-radius*2, h);
endShape();
if (color.a < 1) {
Gdx.gl.glDisable(GL_BLEND);
}
batch.begin();
}
public void drawRect(float thickness, FSkinColor skinColor, float x, float y, float w, float h) {
drawRect(thickness, skinColor.getColor(), x, y, w, h);
}

11
forge-gui-mobile/src/forge/assets/ImageCache.java
View File

@@ -82,11 +82,7 @@ public class ImageCache {
}
public static Texture getImage(InventoryItem ii) {
return getImage(ii.getImageKey(false), true, false);
}
public static Texture getImage(InventoryItem ii, Boolean mask) {
return getImage(ii.getImageKey(false), true, mask);
return getImage(ii.getImageKey(false), true);
}
/**
@@ -112,9 +108,6 @@ public class ImageCache {
* </p>
*/
public static Texture getImage(String imageKey, boolean useDefaultIfNotFound) {
return getImage(imageKey, useDefaultIfNotFound, false);
}
public static Texture getImage(String imageKey, boolean useDefaultIfNotFound, boolean maskCard) {
if (StringUtils.isEmpty(imageKey)) {
return null;
}
@@ -133,8 +126,6 @@ public class ImageCache {
Texture image;
if (useDefaultIfNotFound) {
// Load from file and add to cache if not found in cache initially.
if (maskCard)//if we add pixmap modification here, it will slow performance so we do this on the image loader lol :)...
imageKey += "#drawroundcorner#";
image = cache.get(imageKey);
if (image != null) { return image; }

97
forge-gui-mobile/src/forge/assets/ImageLoader.java
View File

@@ -3,11 +3,7 @@ package forge.assets;
import java.io.File;
import com.badlogic.gdx.files.FileHandle;
import com.badlogic.gdx.graphics.Color;
import com.badlogic.gdx.graphics.Pixmap;
import com.badlogic.gdx.graphics.Texture;
import com.badlogic.gdx.graphics.TextureData;
import com.badlogic.gdx.graphics.glutils.PixmapTextureData;
import org.cache2k.integration.CacheLoader;
import forge.Forge;
@@ -16,21 +12,15 @@ import forge.ImageKeys;
final class ImageLoader extends CacheLoader<String, Texture> {
@Override
public Texture load(String key) {
boolean mask = key.contains("#drawroundcorner#");
boolean alphaCard = false;
boolean textureFilter = Forge.isTextureFilteringEnabled();
if (key.length() > 4){
if ((key.substring(0,4).contains("LEA/")) || (key.substring(0,2).contains("A/")))
alphaCard = true;
//TODO dont add border on some sets???
}
File file = ImageKeys.getImageFile(key.replaceAll("#drawroundcorner#",""));
File file = ImageKeys.getImageFile(key);
if (file != null) {
FileHandle fh = new FileHandle(file);
Texture t = new Texture(fh, textureFilter);
try {
return generateTexture(fh, t, mask, alphaCard, textureFilter);
Texture t = new Texture(fh, textureFilter);
if (textureFilter)
t.setFilter(Texture.TextureFilter.MipMapLinearLinear, Texture.TextureFilter.Linear);
return t;
}
catch (Exception ex) {
Forge.log("Could not read image file " + fh.path() + "\n\nException:\n" + ex.toString());
@@ -38,81 +28,4 @@ final class ImageLoader extends CacheLoader<String, Texture> {
}
return null;
}
public Texture generateTexture(FileHandle fh, Texture t, boolean mask, boolean alphaCard, boolean textureFilter) {
if (!mask) {
if (textureFilter)
t.setFilter(Texture.TextureFilter.MipMapLinearLinear, Texture.TextureFilter.Linear);
return t;
}
Pixmap pImage = new Pixmap(fh);
int w = pImage.getWidth();
int h = pImage.getHeight();
int radius = alphaCard ? (h - w) / 6 : (h - w) / 8;
Pixmap pMask = createRoundedRectangle(w, h, radius, Color.RED);
drawPixelstoMask(pImage, pMask);
TextureData textureData = new PixmapTextureData(
pMask, //pixmap to use
Pixmap.Format.RGBA8888,
textureFilter, //use mipmaps
false, true);
t = new Texture(textureData);
if (textureFilter)
t.setFilter(Texture.TextureFilter.MipMapLinearLinear, Texture.TextureFilter.Linear);
pImage.dispose();
pMask.dispose();
return t;
}
public Pixmap createRoundedRectangle(int width, int height, int cornerRadius, Color color) {
Pixmap pixmap = new Pixmap(width, height, Pixmap.Format.RGBA8888);
Pixmap ret = new Pixmap(width, height, Pixmap.Format.RGBA8888);
pixmap.setColor(color);
//round corners
pixmap.fillCircle(cornerRadius, cornerRadius, cornerRadius);
pixmap.fillCircle(width - cornerRadius - 1, cornerRadius, cornerRadius);
pixmap.fillCircle(cornerRadius, height - cornerRadius - 1, cornerRadius);
pixmap.fillCircle(width - cornerRadius - 1, height - cornerRadius - 1, cornerRadius);
//two rectangle parts
pixmap.fillRectangle(cornerRadius, 0, width - cornerRadius * 2, height);
pixmap.fillRectangle(0, cornerRadius, width, height - cornerRadius * 2);
//draw rounded rectangle
ret.setColor(color);
for (int x = 0; x < width; x++) {
for (int y = 0; y < height; y++) {
if (pixmap.getPixel(x, y) != 0) ret.drawPixel(x, y);
}
}
pixmap.dispose();
return ret;
}
public void drawPixelstoMask(Pixmap pixmap, Pixmap mask){
int pixmapWidth = mask.getWidth();
int pixmapHeight = mask.getHeight();
Color pixelColor = new Color();
for (int x=0; x<pixmapWidth; x++){
for (int y=0; y<pixmapHeight; y++){
if (mask.getPixel(x, y) != 0) {
Color.rgba8888ToColor(pixelColor, pixmap.getPixel(x, y));
mask.setColor(pixelColor);
mask.drawPixel(x, y);
}
}
}
}
public void blendPixmaps(Pixmap pixmap, Pixmap mask, Pixmap model){
int pixmapWidth = pixmap.getWidth();
int pixmapHeight = pixmap.getHeight();
Color pixelColor = new Color();
Color maskPixelColor = new Color();
for (int x=0; x<pixmapWidth; x++){
for (int y=0; y<pixmapHeight; y++){
Color.rgba8888ToColor(pixelColor, pixmap.getPixel(x, y));
Color.rgba8888ToColor(maskPixelColor, mask.getPixel(x, y));
pixelColor.a = pixelColor.a * maskPixelColor.a;
model.setColor(pixelColor);
model.drawPixel(x, y);
}
}
}
}

33
forge-gui-mobile/src/forge/card/CardImage.java
View File

@@ -1,7 +1,9 @@
package forge.card;
import com.badlogic.gdx.graphics.Color;
import com.badlogic.gdx.graphics.Texture;
import com.badlogic.gdx.graphics.g2d.TextureRegion;
import forge.Graphics;
import forge.assets.FImage;
import forge.assets.ImageCache;
@@ -22,6 +24,24 @@ public class CardImage implements FImage {
private static boolean isPreferenceEnabled(ForgePreferences.FPref preferenceName) {
return FModel.getPreferences().getPrefBoolean(preferenceName);
}
public static TextureRegion croppedBorderImage(Texture image) {
float rscale = 0.96f;
int rw = Math.round(image.getWidth()*rscale);
int rh = Math.round(image.getHeight()*rscale);
int rx = Math.round((image.getWidth() - rw)/2);
int ry = Math.round((image.getHeight() - rh)/2)-2;
TextureRegion rimage = new TextureRegion(image, rx, ry, rw, rh);
return rimage;
}
public static Color borderColor(PaperCard c) {
if (c == null)
return Color.valueOf("#1d1d1d");
CardEdition ed = FModel.getMagicDb().getEditions().get(c.getEdition());
if (ed != null && ed.isWhiteBorder())
return Color.valueOf("#fffffd");
return Color.valueOf("#1d1d1d");
}
@Override
public float getWidth() {
@@ -38,9 +58,9 @@ public class CardImage implements FImage {
@Override
public void draw(Graphics g, float x, float y, float w, float h) {
boolean mask = isPreferenceEnabled(ForgePreferences.FPref.UI_ENABLE_BORDER_MASKING);
if (image == null) { //attempt to retrieve card image if needed
boolean mask = isPreferenceEnabled(ForgePreferences.FPref.UI_ENABLE_BORDER_MASKING);
image = ImageCache.getImage(card, mask);
image = ImageCache.getImage(card);
if (image == null) {
if (mask) //render this if mask is still loading
CardImageRenderer.drawCardImage(g, CardView.getCardForUi(card), false, x, y, w, h, CardStackPosition.Top);
@@ -53,7 +73,14 @@ public class CardImage implements FImage {
CardImageRenderer.drawCardImage(g, CardView.getCardForUi(card), false, x, y, w, h, CardStackPosition.Top);
}
else {
g.drawImage(image, x, y, w, h);
if (mask) {
float radius = (h - w)/8;
g.drawRoundRect(3, borderColor(card), x, y, w, h, radius);
g.fillRoundRect(borderColor(card), x, y, w, h, radius);
g.drawImage(croppedBorderImage(image), x+radius/2.2f, y+radius/2, w*0.96f, h*0.96f);
}
else
g.drawImage(image, x, y, w, h);
}
}
}

61
forge-gui-mobile/src/forge/card/CardImageRenderer.java
View File

@@ -2,6 +2,7 @@ package forge.card;
import com.badlogic.gdx.graphics.Color;
import com.badlogic.gdx.graphics.Texture;
import com.badlogic.gdx.graphics.g2d.TextureRegion;
import com.badlogic.gdx.utils.Align;
import com.google.common.collect.ImmutableList;
import forge.Graphics;
@@ -323,10 +324,29 @@ public class CardImageRenderer {
x += pieceWidths[i];
}
}
public static TextureRegion croppedBorderImage(Texture image) {
float rscale = 0.96f;
int rw = Math.round(image.getWidth()*rscale);
int rh = Math.round(image.getHeight()*rscale);
int rx = Math.round((image.getWidth() - rw)/2);
int ry = Math.round((image.getHeight() - rh)/2)-2;
TextureRegion rimage = new TextureRegion(image, rx, ry, rw, rh);
return rimage;
}
public static Color borderColor(CardView c) {
if (c == null)
return Color.valueOf("#1d1d1d");
CardStateView state = c.getCurrentState();
CardEdition ed = FModel.getMagicDb().getEditions().get(state.getSetCode());
if (ed != null && ed.isWhiteBorder() && state.getFoilIndex() == 0)
return Color.valueOf("#fffffd");
return Color.valueOf("#1d1d1d");
}
public static void drawZoom(Graphics g, CardView card, GameView gameView, boolean altState, float x, float y, float w, float h, float dispW, float dispH, boolean isCurrentCard) {
boolean mask = isPreferenceEnabled(ForgePreferences.FPref.UI_ENABLE_BORDER_MASKING);
final Texture image = ImageCache.getImage(card.getState(altState).getImageKey(MatchController.instance.getLocalPlayers()), true, mask);
//this one is currently using the mask, others are cropped and use generated borders from shaperenderer ...
final Texture image = ImageCache.getImage(card.getState(altState).getImageKey(MatchController.instance.getLocalPlayers()), true);
if (image == null) { //draw details if can't draw zoom
drawDetails(g, card, gameView, altState, x, y, w, h);
return;
@@ -343,21 +363,54 @@ public class CardImageRenderer {
drawCardImage(g, card, altState, x, y, w, h, CardStackPosition.Top);
}
else {
float radius = (h - w)/8;
float wh_Adj = ForgeConstants.isGdxPortLandscape && isCurrentCard ? 1.38f:1.0f;
float new_w = w*wh_Adj;
float new_h = h*wh_Adj;
float new_x = ForgeConstants.isGdxPortLandscape && isCurrentCard ? (dispW - new_w) / 2:x;
float new_y = ForgeConstants.isGdxPortLandscape && isCurrentCard ? (dispH - new_h) / 2:y;
float new_xRotate = (dispW - new_h) /2;
float new_yRotate = (dispH - new_w) /2;
boolean rotateSplit = FModel.getPreferences().getPrefBoolean(ForgePreferences.FPref.UI_ROTATE_SPLIT_CARDS);
boolean rotatePlane = FModel.getPreferences().getPrefBoolean(ForgePreferences.FPref.UI_ROTATE_PLANE_OR_PHENOMENON);
if (rotatePlane && (card.getCurrentState().isPhenomenon() || card.getCurrentState().isPlane())) {
g.drawRotatedImage(image, new_x, new_y, new_w, new_h, new_x + new_w / 2, new_y + new_h / 2, -90);
if (mask){
if (rotatePlane) {
g.drawRoundRect(3, borderColor(card), new_xRotate, new_yRotate, new_h, new_w, radius);
g.fillRoundRect(borderColor(card), new_xRotate, new_yRotate, new_h, new_w, radius);
}
else {
g.drawRoundRect(3, borderColor(card), x, y, w, h, radius);
g.fillRoundRect(borderColor(card), x, y, w, h, radius);
}
g.drawRotatedImage(croppedBorderImage(image), new_x+radius/2.3f, new_y+radius/2, new_w*0.96f, new_h*0.96f, (new_x+radius/2.3f) + (new_w*0.96f) / 2, (new_y+radius/2) + (new_h*0.96f) / 2, -90);
}
else
g.drawRotatedImage(image, new_x, new_y, new_w, new_h, new_x + new_w / 2, new_y + new_h / 2, -90);
} else if (rotateSplit && isCurrentCard && card.isSplitCard() && canLook) {
boolean isAftermath = card.getText().contains("Aftermath") || card.getAlternateState().getOracleText().contains("Aftermath");
g.drawRotatedImage(image, new_x, new_y, new_w, new_h, new_x + new_w / 2, new_y + new_h / 2, isAftermath ? 90 : -90);
if (mask){
if (rotateSplit) {
g.drawRoundRect(3, borderColor(card), new_xRotate, new_yRotate, new_h, new_w, radius);
g.fillRoundRect(borderColor(card), new_xRotate, new_yRotate, new_h, new_w, radius);
}
else {
g.drawRoundRect(3, borderColor(card), x, y, w, h, radius);
g.fillRoundRect(borderColor(card), x, y, w, h, radius);
}
g.drawRotatedImage(croppedBorderImage(image), new_x+radius/2.3f, new_y+radius/2, new_w*0.96f, new_h*0.96f, (new_x+radius/2.3f) + (new_w*0.96f) / 2, (new_y+radius/2) + (new_h*0.96f) / 2, isAftermath ? 90 : -90);
}
else
g.drawRotatedImage(image, new_x, new_y, new_w, new_h, new_x + new_w / 2, new_y + new_h / 2, isAftermath ? 90 : -90);
}
else {
g.drawImage(image, x, y, w, h);
if (mask) {
g.drawRoundRect(3, borderColor(card), x, y, w, h, radius);
g.fillRoundRect(borderColor(card), x, y, w, h, radius);
g.drawImage(croppedBorderImage(image), x+radius/2.4f, y+radius/2, w*0.96f, h*0.96f);
}
else
g.drawImage(image, x, y, w, h);
}
}
CardRenderer.drawFoilEffect(g, card, x, y, w, h, isCurrentCard && canLook && image != ImageCache.defaultImage);

65
forge-gui-mobile/src/forge/card/CardRenderer.java
View File

@@ -391,16 +391,51 @@ public class CardRenderer {
g.drawText(set, font, foreColor, x, y, w, h, false, Align.center, true);
}
public static TextureRegion croppedBorderImage(Texture image) {
float rscale = 0.96f;
int rw = Math.round(image.getWidth()*rscale);
int rh = Math.round(image.getHeight()*rscale);
int rx = Math.round((image.getWidth() - rw)/2);
int ry = Math.round((image.getHeight() - rh)/2)-2;
TextureRegion rimage = new TextureRegion(image, rx, ry, rw, rh);
return rimage;
}
public static Color borderColor(IPaperCard c) {
if (c == null)
return Color.valueOf("#1d1d1d");
CardEdition ed = FModel.getMagicDb().getEditions().get(c.getEdition());
if (ed != null && ed.isWhiteBorder())
return Color.valueOf("#fffffd");
return Color.valueOf("#1d1d1d");
}
public static Color borderColor(CardView c) {
if (c == null)
return Color.valueOf("#1d1d1d");
CardStateView state = c.getCurrentState();
CardEdition ed = FModel.getMagicDb().getEditions().get(state.getSetCode());
if (ed != null && ed.isWhiteBorder() && state.getFoilIndex() == 0)
return Color.valueOf("#fffffd");
return Color.valueOf("#1d1d1d");
}
public static void drawCard(Graphics g, IPaperCard pc, float x, float y, float w, float h, CardStackPosition pos) {
boolean mask = isPreferenceEnabled(FPref.UI_ENABLE_BORDER_MASKING);
Texture image = new RendererCachedCardImage(pc, false).getImage(mask);
Texture image = new RendererCachedCardImage(pc, false).getImage();
if (image != null) {
if (image == ImageCache.defaultImage) {
CardImageRenderer.drawCardImage(g, CardView.getCardForUi(pc), false, x, y, w, h, pos);
}
else {
g.drawImage(image, x, y, w, h);
if (mask) {
float radius = (h - w)/8;
g.drawRoundRect(3, borderColor(pc), x, y, w, h, radius);
g.fillRoundRect(borderColor(pc), x, y, w, h, radius);
g.drawImage(croppedBorderImage(image), x+radius/2.4f, y+radius/2, w*0.96f, h*0.96f);
}
else
g.drawImage(image, x, y, w, h);
}
if (pc.isFoil()) { //draw foil effect if needed
final CardView card = CardView.getCardForUi(pc);
@@ -420,7 +455,7 @@ public class CardRenderer {
public static void drawCard(Graphics g, CardView card, float x, float y, float w, float h, CardStackPosition pos, boolean rotate) {
boolean mask = isPreferenceEnabled(FPref.UI_ENABLE_BORDER_MASKING);
Texture image = new RendererCachedCardImage(card, false).getImage(mask);
Texture image = new RendererCachedCardImage(card, false).getImage();
if (image != null) {
if (image == ImageCache.defaultImage) {
@@ -428,10 +463,26 @@ public class CardRenderer {
}
else {
if(FModel.getPreferences().getPrefBoolean(ForgePreferences.FPref.UI_ROTATE_PLANE_OR_PHENOMENON)
&& (card.getCurrentState().isPhenomenon() || card.getCurrentState().isPlane()) && rotate)
g.drawRotatedImage(image, x, y, w, h, x + w / 2, y + h / 2, -90);
else
g.drawImage(image, x, y, w, h);
&& (card.getCurrentState().isPhenomenon() || card.getCurrentState().isPlane()) && rotate){
if (mask) {
float radius = (h - w)/8;
g.drawRoundRect(3, borderColor(card), x, y, w, h, radius);
g.fillRoundRect(borderColor(card), x, y, w, h, radius);
g.drawRotatedImage(croppedBorderImage(image), x+radius/2.3f, y+radius/2, w*0.96f, h*0.96f, (x+radius/2.3f) + (w*0.96f) / 2, (y+radius/2) + (h*0.96f) / 2, -90);
}
else
g.drawRotatedImage(image, x, y, w, h, x + w / 2, y + h / 2, -90);
}
else {
if (mask) {
float radius = (h - w)/8;
g.drawRoundRect(3, borderColor(card), x, y, w, h, radius);
g.fillRoundRect(borderColor(card), x, y, w, h, radius);
g.drawImage(croppedBorderImage(image), x+radius/2.4f, y+radius/2, w*0.96f, h*0.96f);
}
else
g.drawImage(image, x, y, w, h);
}
}
drawFoilEffect(g, card, x, y, w, h, false);
}

4
forge-gui-mobile/src/forge/screens/settings/SettingsPage.java
View File

@@ -302,8 +302,8 @@ public class SettingsPage extends TabPage<SettingsScreen> {
localizer.getMessage("nlDisableCardEffect")),
4);
lstSettings.addItem(new BooleanSetting(FPref.UI_ENABLE_BORDER_MASKING,
"Experimental Round Border Mask",
"When enabled, the card corners are rounded (CPU/GPU Dependent atm)."),
"Enable Round Border Mask",
"When enabled, the card corners are rounded (Preferably Card with Full Borders)."),
4);
lstSettings.addItem(new CustomSelectSetting(FPref.UI_CARD_COUNTER_DISPLAY_TYPE,