java多边形生成

多边形生成"/>

java多边形生成

一些基本概念…

脉动效应需要向两个方向移动,它需要淡入淡出。

为了知道应该应用多少“效果”,需要知道两件事。首先,整体效果循环需要多长时间(从完全不透明到完全透明再返回),以及动画在循环中的持续时间。

这不是一件简单的管理事情,有很多“有状态”的信息需要管理和维护,而且通常是与其他效果或实体分开的。

在我看来,最简单的解决方案是设计某种“时间线”,它沿时间线管理关键点(关键帧),计算每个点与它所代表的值之间的距离。

后退一步。我们知道在:

0%我们希望完全不透明

50%我们希望完全透明

100%我们想要完全不透明

上面考虑到我们想要“自动反转”动画。

使用百分比的原因是,它允许我们定义任何给定持续时间的时间线,时间线将处理其余时间。在可能的情况下,总是使用像这样的标准化值,这使得整个过程简单得多。

TimeLine

下面是一个非常简单的“时间线”概念。它有一个

Duration

,播放时间线的时间,关键帧,在时间线的持续时间内提供关键值,以及在时间线生命周期的特定点计算特定值的方法。

此实现还提供了“自动”重播功能。也就是说,如果时间线被“超过”了,它被指定

持续时间

,而不是停止,它将自动重置,并将“超过”时间作为下一个周期的一部分考虑在内(整洁)

public class TimeLine {

private Map mapEvents;

private Duration duration;

private LocalDateTime startedAt;

public TimeLine(Duration duration) {

mapEvents = new TreeMap<>();

this.duration = duration;

}

public void start() {

startedAt = LocalDateTime.now();

}

public boolean isRunning() {

return startedAt != null;

}

public float getValue() {

if (startedAt == null) {

return getValueAt(0.0f);

}

Duration runningTime = Duration.between(startedAt, LocalDateTime.now());

if (runningTimepareTo(duration) > 0) {

runningTime = runningTime.minus(duration);

startedAt = LocalDateTime.now().minus(runningTime);

}

long total = duration.toMillis();

long remaining = duration.minus(runningTime).toMillis();

float progress = remaining / (float) total;

return getValueAt(progress);

}

public void add(float progress, float value) {

mapEvents.put(progress, new KeyFrame(progress, value));

}

public float getValueAt(float progress) {

if (progress < 0) {

progress = 0;

} else if (progress > 1) {

progress = 1;

}

KeyFrame[] keyFrames = getKeyFramesBetween(progress);

float max = keyFrames[1].progress - keyFrames[0].progress;

float value = progress - keyFrames[0].progress;

float weight = value / max;

float blend = blend(keyFrames[0].getValue(), keyFrames[1].getValue(), 1f - weight);

return blend;

}

public KeyFrame[] getKeyFramesBetween(float progress) {

KeyFrame[] frames = new KeyFrame[2];

int startAt = 0;

Float[] keyFrames = mapEvents.keySet().toArray(new Float[mapEvents.size()]);

while (startAt < keyFrames.length && keyFrames[startAt] <= progress) {

startAt++;

}

if (startAt >= keyFrames.length) {

startAt = keyFrames.length - 1;

}

frames[0] = mapEvents.get(keyFrames[startAt - 1]);

frames[1] = mapEvents.get(keyFrames[startAt]);

return frames;

}

protected float blend(float start, float end, float ratio) {

float ir = (float) 1.0 - ratio;

return (float) (start * ratio + end * ir);

}

public class KeyFrame {

private float progress;

private float value;

public KeyFrame(float progress, float value) {

this.progress = progress;

this.value = value;

}

public float getProgress() {

return progress;

}

public float getValue() {

return value;

}

@Override

public String toString() {

return "KeyFrame progress = " + getProgress() + "; value = " + getValue();

}

}

}

设置时间线非常简单…

timeLine = new TimeLine(Duration.ofSeconds(5));

timeLine.add(0.0f, 1.0f);

timeLine.add(0.5f, 0.0f);

timeLine.add(1.0f, 1.0f);

我们给出一个特定的

持续时间

并设置关键帧值。在那之后,我们只需要“启动”它并获得电流

value

来自

时间线

根据比赛时间而定。

对于一个看起来很简单的问题,这似乎是一个很大的工作,但是请记住,这是动态的,并且是可重用的。

它是动态的,你可以提供

持续时间

您需要,因此改变速度,它将“只是工作”,并可重用,因为您可以为多个实体生成多个实例,并且它将被独立管理。

例子。。。

下面的例子简单地利用了Swing

Timer

作为动画的“主循环”。在每个循环中,它要求

时间线

对于“当前”值,它只是作为

alpha

“脉动”效应的值。

这个

时间线

类本身是完全分离的,因此无论“如何”建立“主循环”,您只需启动它并在任何时候从中提取“当前”值…

import java.awt.AlphaComposite;

import java.awt.Color;

import java.awt.Dimension;

import java.awt.EventQueue;

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.Rectangle;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.time.Duration;

import java.time.LocalDateTime;

import java.util.Map;

import java.util.TreeMap;

import javax.swing.JFrame;

import javax.swing.JPanel;

import javax.swing.Timer;

import javax.swing.UIManager;

import javax.swing.UnsupportedLookAndFeelException;

public class Test {

public static void main(String[] args) {

new Test();

}

public Test() {

EventQueue.invokeLater(new Runnable() {

@Override

public void run() {

try {

UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());

} catch (ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException ex) {

ex.printStackTrace();

}

JFrame frame = new JFrame("Testing");

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

frame.add(new TestPane());

frame.pack();

frame.setLocationRelativeTo(null);

frame.setVisible(true);

}

});

}

public class TestPane extends JPanel {

private TimeLine timeLine;

private float alpha = 0;

public TestPane() {

timeLine = new TimeLine(Duration.ofSeconds(5));

timeLine.add(0.0f, 1.0f);

timeLine.add(0.5f, 0.0f);

timeLine.add(1.0f, 1.0f);

Timer timer = new Timer(5, new ActionListener() {

@Override

public void actionPerformed(ActionEvent e) {

if (!timeLine.isRunning()) {

timeLine.start();

}

alpha = timeLine.getValue();

repaint();

}

});

timer.start();

}

@Override

public Dimension getPreferredSize() {

return new Dimension(200, 200);

}

protected void paintComponent(Graphics g) {

super.paintComponent(g);

Graphics2D g2d = (Graphics2D) g.create();

g2d.setComposite(AlphaComposite.SrcOver.derive(alpha));

g2d.setColor(Color.RED);

g2d.fill(new Rectangle(45, 45, 110, 110));

g2d.dispose();

g2d = (Graphics2D) g.create();

g2d.setColor(getBackground());

g2d.fill(new Rectangle(50, 50, 100, 100));

g2d.setColor(Color.BLACK);

g2d.draw(new Rectangle(50, 50, 100, 100));

g2d.dispose();

}

}

}

我会把

时间线

作为指定实体效果的一部分。这会把

时间线

对于一个特定的实体,这意味着许多实体都可以拥有自己的

时间线

计算不同值和效果的验证

“有更简单的解决方案吗?”

这是一个主观问题。可能会有一种“更简单”的方法,可以完成相同的工作,但是它不会像这种方法那样具有可扩展性或可重用性。

动画是一个复杂的主题,试图使其在复杂的解决方案中工作,运行多个不同的效果和实体只是使问题复杂化。

我已经玩弄了制作

时间线

通用的,因此它可以用于根据所需结果生成不同值的真实性,使其成为更灵活和可重用的解决方案。

颜色混合……

我不知道这是不是一个要求,但是如果你有一系列的颜色,你想在它们之间混合,一个

时间线

也会在这里帮助你(你不需要这么长的时间)。可以设置一系列颜色(作为关键帧),并根据动画的进度计算要使用的颜色。