锐客网

  1. 首页 > 生活百科 > it技术 > >

java小动画代码 java动画编程

IT技术matrix

求java做动画代码import java.awt.Canvas;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.RenderingHints;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;
public class TestImage extends Frame
{
private static final long serialVersionUID = 1L;
private static boolean PRESSED = false;
private static int pointX = 0;
private static int pointy = 200;
private static int RIGHT_GO = 0;
private static int LEFT_GO = 0;
private static int DIR = 0;
private static int ANGLE = 0;
private static int W = 50;
private static int H = 60;
private _Canvas canvas = null;
public TestImage ()
{
add (canvas = new _Canvas ());
setIgnoreRepaint (true);
requestFocus ();
}
public class _Canvas extends Canvas implements Runnable
{
private static final long serialVersionUID = 1L;
private BufferedImage bi = null;
private Image bufferedImage = null;
private Thread thread = null;
private long sleepTime = 10;
public _Canvas ()
{
try
{
bi = ImageIO.read (new File ("go.png"));
}
catch (IOException e)
{}
setBackground (Color.BLACK);
requestFocus ();
addKeyListener (new KeyListener ()
{
@Override
public void keyTyped ( KeyEvent e )
{}
@Override
public void keyReleased ( KeyEvent e )
{
RIGHT_GO = 0;
PRESSED = false;
}
@Override
public void keyPressed ( KeyEvent e )
{
// 38 40 37 39上下左右
DIR = e.getKeyCode ();
PRESSED = true;
}
});
}
@Override
public void paint ( Graphics g )
{
Graphics2D g2d = (Graphics2D) g;
g2d.setRenderingHint (RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
g2d.drawImage (rotateImage (bi.getSubimage (RIGHT_GO, LEFT_GO, W, H), ANGLE, true), pointX, pointy, W, H,
this);
g2d.dispose ();
}
@Override
public void update ( Graphics g )
{
if (null == bufferedImage)
{
bufferedImage = createImage (getWidth (), getHeight ());
}
Graphics bufferedG = bufferedImage.getGraphics ();
bufferedG.clearRect (0, 0, getWidth (), getHeight ());
paint (bufferedG);
bufferedG.dispose ();
g.drawImage (bufferedImage, 0, 0, this);
g.dispose ();
}
public void start ()
{
thread = new Thread (this);
thread.setName ("TestImage");
thread.setPriority (Thread.MIN_PRIORITY);
thread.start ();
}
public synchronized void stop ()
{
thread = null;
notify ();
}
@Override
public void run ()
{
Thread me = Thread.currentThread ();
while (thread == me!isShowing () || getSize ().width == 0)
{
try
{
Thread.sleep (555);
}
catch (InterruptedException e)
{
return;
}
}
while (thread == meisShowing ())
{
if (PRESSED)
{
try
{
if (DIR == 39)
{
RIGHT_GO = RIGHT_GO50;
LEFT_GO = 0;
pointX = pointX1;
if (pointX420)
{
ANGLE = 90;
pointX--;
pointy--;
W = 60;
H = 50;
}
if (RIGHT_GO50)
{
RIGHT_GO = 0;
}
}
else if (DIR == 37)
{
pointX = pointX - 1;
RIGHT_GO = RIGHT_GO50;
LEFT_GO = 60;
if (pointX0)
{
ANGLE = -90;
pointX;
pointy--;
W = 60;
H = 50;
}
if (RIGHT_GO50)
{
RIGHT_GO = 0;
}
}
else if (DIR == 38)
{
W = 50;
H = 60;
pointy = 150;
ANGLE = 0;
RIGHT_GO = 100;
}
else if (DIR == 40)
{
W = 50;
H = 60;
ANGLE = 0;
pointy = 200;
RIGHT_GO = 0;
}
Thread.sleep (sleepTime);
repaint ();
}
catch (InterruptedException e)
{
break;
}
}
else
{
RIGHT_GO = RIGHT_GO50;
LEFT_GO = 0;
pointX = pointX1;
if (RIGHT_GO50)
{
RIGHT_GO = 0;
}
if (pointX500)
{
pointX = 0;
}
try
{
Thread.sleep (sleepTime);
repaint ();
}
catch (InterruptedException e)
{
break;
}
}
}
thread = null;
}
}
/**
* 旋转图像为指定角度
*
* @param degree
* @return
*/
public static BufferedImage rotateImage ( final BufferedImage image, final int angdeg, final boolean d )
{
int w = image.getWidth ();
int h = image.getHeight ();
int type = image.getColorModel ().getTransparency ();
BufferedImage img;
Graphics2D graphics2d;
( graphics2d = ( img = new BufferedImage (w, h, type) ).createGraphics () ).setRenderingHint (
RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
graphics2d.rotate (d ? -Math.toRadians (angdeg) : Math.toRadians (angdeg), w / 2, h / 2);
graphics2d.drawImage (image, 0, 0, null);
graphics2d.dispose ();
return img;
}
public static void main ( String[] args )
{
EventQueue.invokeLater (new Runnable ()
{
@Override
public void run ()
{
final TestImage ti = new TestImage ();
ti.setSize (new Dimension (500, 300));
ti.setLocationRelativeTo (null);
ti.addWindowListener (new WindowAdapter ()
{
@Override
public void windowClosing ( WindowEvent e )
{
System.exit (0);
}
@Override
public void windowDeiconified ( WindowEvent e )
{
ti.canvas.start ();
}
@Override
public void windowIconified ( WindowEvent e )
{
ti.canvas.stop ();
}
});
ti.setResizable (false);
ti.canvas.start ();
ti.setVisible (true);
}
});
}
}
Java编程实现一个能循环地自左向右移动的动画程序 。效果图
参考代码
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class MoveTextFrame extends JFrame {
JLabel jl;//文字标签
int speed=2;//移动速度
public MoveTextFrame() {
jl = new JLabel("文字动画");
jl.setForeground(Color.RED);
add(jl);
setSize(380, 100);//窗口大小
setLocationRelativeTo(null);//窗口居中
setResizable(false);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setVisible(true);
//设置定时器, 每隔25毫秒,改变一次文字标签的位置
Timer t = new Timer(25, new ActionListener() {
public void actionPerformed(ActionEvent e) {
int x = jl.getX() speed;//计算移动后的位置
if(x=390){//如果超过就指定像素,就重新从左边开水移动
x=-30;
}
jl.setLocation(x, jl.getY());//更新位置
//repaint();
}
});
t.start();
}
public static void main(String[] args) {
new MoveTextFrame();
}
}
我想要个用java写的小动画，是在JDK上实现的，可以帮我写下吗？/*显示一个立方体*/
#include dos.h
#include math.h
#include conio.h
#include stdio.h
#include stdlib.h
#include graphics.h
#define PI 3.1415926
/*定义按键*/
#define ESC 0x11b
/*以下4个键，依次是上 下 左 右*/
#define X_axis_clkwise0x4800
#define X_axis_Cntclkwise 0x5000
#define Y_axis_clkwise0x4b00
#define Y_axis_Cntclkwise 0x4d00
/*以下2个键，依次是A, D*/
#define Z_axis_clkwise0x1e61
#define Z_axis_Cntclkwise 0x2064
#define Distance_forward0x1177
#define Distance_Backward 0x1f73
/*以下6个键，依次是U, J, I, K, O, L*/
#define X_Delta_Plus0x1675
#define X_Delta_Minus0x246a
#define Y_Delta_Plus0x1769
#define Y_Delta_Minus0x256b
#define Z_Delta_Plus0x186f
#define Z_Delta_Minus0x266c
/*绕X轴旋转矩阵*/
float X_Rotate_Matrix[4][4] = { 1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, 0,
0, 0, 0, 1 };
/*绕Y轴旋转矩阵*/
float Y_Rotate_Matrix[4][4] = { 1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, 0,
0, 0, 0, 1 };
/*绕Z轴旋转矩阵*/
float Z_Rotate_Matrix[4][4] = { 1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, 0,
0, 0, 0, 1 };
/*平移矩阵*/
float Transist_Matrix[4][4] = { 1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, 0,
0, 0, 0, 1 };
/*透视投影变换矩阵*/
float Perspective_Projection[4][4] = { 1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 0, 0,
0, 0, 0, 1 };
int num;
float *Matrix_Mul(float *pMatrix1, int Num_Row_Matrix1, int Num_Column_Matrix1,
float *pMatrix2, int Num_Row_Matrix2, int Num_Column_Matrix2 ) {
/*实现两个矩阵:
输入参数: *pMatrix1: 指向第一个矩阵
Num_Row_Matrix1: 第一个矩阵的行数
Num_Column_Matrix1: 第一个矩阵的列数
余下三个参数类推;
return 指向运算结果的float类型指针.*/
int i, j, m, n;
float *pNewMatrix1, *pNewMatrix2, Sum;
if( Num_Column_Matrix1 != Num_Row_Matrix2) {
printf("Invalid Matrixs!\n");
return 0;
}
pNewMatrix1 = malloc(Num_Row_Matrix1 * Num_Column_Matrix2 * 4);
/*申请内存空间, Size(/bytes) = 第一个矩阵的行数 * 第二个矩阵的列数 * 4(= sizeof(float))*/
pNewMatrix2 = pNewMatrix1;
/*具体算法详见如下代码*/
for( i = 0; iNum_Row_Matrix1; i) {
for( n = 0; nNum_Column_Matrix2; n) {
Sum = 0;
for( j = 0; jNum_Column_Matrix1; j)
Sum=(*(pMatrix1 i*Num_Column_Matrix1 j)) * (*(pMatrix2 j*Num_Column_Matrix2 n));
*(pNewMatrix1) = Sum;
}
}
return pNewMatrix2;
}
/*转换成齐次坐标矩阵*/
void Matrix_Convertion(float *pMatrix, int Num_Row) {
int i, j;
for(i = 0; iNum_Row; i) {
if((*(pMatrix i*4 3)) != 0) {
*(pMatrix i*4) = (*(pMatrix i*4)) / (*(pMatrix i*4 3));
*(pMatrix i*4 1) = (*(pMatrix i*4 1)) / (*(pMatrix i*4 3));
*(pMatrix i*4 2) = (*(pMatrix i*4 2)) / (*(pMatrix i*4 3));
}
}
}
/*取得投影坐标*/
float *Get_X_Y(float *pMatrix, int Num_Row) {
int i, j, Num;
float *pNewMatrix;
Num = 0;
for(i = 0; iNum_Row; i) {
if((*(pMatrix i*4 3)) != 0)
Num;
}
pNewMatrix = malloc(Num * 2 * 4);
/*存放格式,{(x1, y1),(x2, y2), ... ,(xn, yn)}*/
for(i = 0; iNum; i) {
if((*(pMatrix i*4 3)) != 0) {
*(pNewMatrix i*2) = (*(pMatrix i*4)) 300;/*显示在屏幕中心, x = 300*/
*(pNewMatrix i*2 1) = (*(pMatrix i*4 1)) 200;/*显示在屏幕中心, y = 200*/
}
}
return pNewMatrix;
}
/*设置旋转矩阵, Rotate around aixs labled with X or Y or Z*/
void SetMatrix_X(float X_Angle) {
float CosX, SinX;
SinX = sin(X_Angle * PI /128);
CosX = cos(X_Angle * PI /128);
X_Rotate_Matrix[1][1] = CosX;
X_Rotate_Matrix[1][2] = SinX;
X_Rotate_Matrix[2][1] = -1 * SinX;
X_Rotate_Matrix[2][2] = CosX;
}
void SetMatrix_Y(float Y_Angle) {
float CosY, SinY;
SinY = sin(Y_Angle * PI /128);
CosY = cos(Y_Angle * PI /128);
Y_Rotate_Matrix[0][0] = CosY;
Y_Rotate_Matrix[0][2] = -1 * SinY;
Y_Rotate_Matrix[2][0] = SinY;
Y_Rotate_Matrix[2][2] = CosY;
}
void SetMatrix_Z(float Z_Angle) {
float CosZ, SinZ;
SinZ = sin(Z_Angle * PI /128);
CosZ = cos(Z_Angle * PI /128);
Z_Rotate_Matrix[0][0] = CosZ;
Z_Rotate_Matrix[0][1] = SinZ;
Z_Rotate_Matrix[1][0] = -1 * SinZ;
Z_Rotate_Matrix[1][1] = CosZ;
}
/*类同*/
void Set_Transist_Matrix(float X, float Y,float Z) {
Transist_Matrix[3][0] = X;
Transist_Matrix[3][1] = Y;
Transist_Matrix[3][2] = Z;
}
/*类同*/
void Set_Perspective_Projection(float k) {
Perspective_Projection[2][3] = -1/k;
}
/*初始化图形驱动*/
void InitGraph(void) {
int gd=DETECT,gm;
initgraph(gd,gm,"E:\\TC");
}
/*生成立方体*/
float *Cube(void) {
int i, j, k;
float *pPoints1, *pPoints2;
num = 0;
for( i = -50; i = 50; i= 20)
for( j = -50; j = 50; j= 20)
for( k = -50; k = 50; k= 20)
num;
pPoints1 = malloc( num * 4 * 4 );
pPoints2 = pPoints1;
for( i = -50; i = 50; i= 20)
for( j = -50; j = 50; j= 20)
for( k = -50; k = 50; k= 20) {
*(pPoints1) = i;
*(pPoints1) = j;
*(pPoints1) = k;
*(pPoints1) = 1;
}
return pPoints2;
}
/*Functions used for drawingClearing*/
void Plot_NewPoints(float *pPoints) {
int i;
for(i=0;inum;i)
putpixel( (int) (*(pPoints i*2)), (int) (*(pPoints i*2 1)), 7);
}
void Clear_OldPoints(float *pPoints) {
int i;
for(i=0;inum;i)
putpixel( (int) (*(pPoints i*2)), (int) (*(pPoints i*2 1)), 0);
}
/*Function used for controlling*/
void Operate(int Switch, float *Ang_Rot_X, float *Ang_Rot_Y, float *Ang_Rot_Z,
float *X_Delta, float *Y_Delta, float *Z_Delta,float *Distance) {
switch(Switch) {
case X_axis_clkwise: (*Ang_Rot_X)--; break;
case X_axis_Cntclkwise: (*Ang_Rot_X); break;
case Y_axis_clkwise: (*Ang_Rot_Y)--; break;
case Y_axis_Cntclkwise: (*Ang_Rot_Y); break;
case Z_axis_clkwise: (*Ang_Rot_Z)--; break;
case Z_axis_Cntclkwise: (*Ang_Rot_Z); break;
case X_Delta_Plus: (*X_Delta)--; break;
case X_Delta_Minus: (*X_Delta); break;
case Y_Delta_Plus: (*Y_Delta)--; break;
case Y_Delta_Minus: (*Y_Delta); break;
case Z_Delta_Plus: (*Z_Delta); break;
case Z_Delta_Minus: (*Z_Delta)--; break;
case Distance_forward: (*Distance); break;
case Distance_Backward: (*Distance)--;break;
default: (*Ang_Rot_Y); break;
}
}
int main() {
int i, j, Key;
float *pMatrix1, *pMatrix2;
float *pBasePoints;
float *pPerspectivePoints;
float Ang_Rot_Xaxis, Ang_Rot_Yaxis, Ang_Rot_Zaxis;
float X_Delta, Y_Delta, Z_Delta;
float Distance;
clrscr();
InitGraph();
/*Varieties initialized*/
pBasePoints = Cube();
Ang_Rot_Xaxis = 0;
Ang_Rot_Yaxis = 0;
Ang_Rot_Zaxis = 0;
X_Delta = 0;
Y_Delta = 0;
Z_Delta = 0;
Distance = 200;
Key = 0;
while(Key != ESC) {
if( bioskey(1) )
Key = bioskey(0);
Operate(Key, Ang_Rot_Xaxis, Ang_Rot_Yaxis, Ang_Rot_Zaxis,
X_Delta, Y_Delta, Z_Delta, Distance);
SetMatrix_X(Ang_Rot_Xaxis);
SetMatrix_Y(Ang_Rot_Yaxis);
SetMatrix_Z(Ang_Rot_Zaxis);
Set_Transist_Matrix(X_Delta, Y_Delta, Z_Delta);
Set_Perspective_Projection(Distance);
/*The following may be known by you
pay your attention specially to the pair of mallocfree */
pMatrix1 = Matrix_Mul( (float*)X_Rotate_Matrix, 4, 4, (float*)Y_Rotate_Matrix, 4, 4);
pMatrix2 = Matrix_Mul( pMatrix1, 4, 4, (float*)Z_Rotate_Matrix, 4, 4);
free(pMatrix1);
pMatrix1 = Matrix_Mul( pMatrix2, 4, 4, (float*)Transist_Matrix, 4, 4);
free(pMatrix2);
pMatrix2 = Matrix_Mul( pMatrix1, 4, 4, (float*)Perspective_Projection, 4, 4);
free(pMatrix1);
pMatrix1 = Matrix_Mul( pBasePoints, num, 4, pMatrix2, 4, 4);
free(pMatrix2);
Matrix_Convertion( pMatrix1, num);
pPerspectivePoints = Get_X_Y(pMatrix1, num);
Plot_NewPoints(pPerspectivePoints);
delay(5000);
Clear_OldPoints(pPerspectivePoints);
free(pPerspectivePoints);
free(pMatrix1);
}
free(pBasePoints);
closegraph();
return 0;
}
【java小动画代码 java动画编程】关于java小动画代码和java动画编程的介绍到此就结束了 ， 不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息 ， 记得收藏关注本站 。

    推荐阅读


    上一篇：苹果cms搭建电影资源站，苹果cmsv10资源站模板

    下一篇：如何做好企业微营销策划，如何做好企业微营销策划工作