2014-06-27 11:38:54 iteye_16646 阅读数 189
  • 快速入门Android开发 视频 教程 android studio

    这是一门快速入门Android开发课程,顾名思义是让大家能快速入门Android开发。 学完能让你学会如下知识点: Android的发展历程 搭建Java开发环境 搭建Android开发环境 Android Studio基础使用方法 Android Studio创建项目 项目运行到模拟器 项目运行到真实手机 Android中常用控件 排查开发中的错误 Android中请求网络 常用Android开发命令 快速入门Gradle构建系统 项目实战:看美图 常用Android Studio使用技巧 项目签名打包 如何上架市场

    19663 人正在学习 去看看 任苹蜻

一、还是像普通的android动态壁纸一样,创建一个没有activity的安卓工程TestLibGDXWallpaper
二、AndroidManifest.xml配置

  1.     <application
  2.         android:icon="@drawable/icon"
  3.         android:label="@string/app_name" >
  4.         <service
  5.             android:name=".MyLiveWallpaper"
  6.             android:icon="@drawable/icon"
  7.             android:label="@string/app_name"
  8.             android:permission="android.permission.BIND_WALLPAPER" >
  9.             <intent-filter>
  10.                 <action android:name="android.service.wallpaper.WallpaperService" />
  11.             </intent-filter>
  12.             <meta-data
  13.                 android:name="android.service.wallpaper"
  14.                 android:resource="@xml/livewallpaper" />
  15.         </service>
  16.     </application>
复制代码

1、权限android:permission="android.permission.BIND_WALLPAPER",否则该壁纸只能预览,不能被实际应用
2、
添加声明android:name="android.service.wallpaper.WallpaperService"以便系统识别
3、android:name=".MyLiveWallpaper"为动态壁纸的service类
4、meta-data部分为动态壁纸的配置信息xml/livewallpaper需要手动创建res/xml/livewallpaper.xml


三 、livewallpaper.xml

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <wallpaper xmlns:android="http://schemas.android.com/apk/res/android"
  3.     android:thumbnail="@drawable/icon" />
复制代码

只是配置其图标(没有“设置”项)


四、jar包和.so库导入
将从官方下载下来的压缩包中的gdx.jar和gdx-backend-android.jar包复制到工程libs目录下(再build path 步骤省略),将相关.so库复制到libs目录下!
 



五、service实现
1、service类MyLiveWallpaper实现gdx-backend-android中的AndroidLiveWallpaperService,这将需要实现三个抽象方法createConfig、createListener,这两个方法将会在壁纸出现时被调用(预览和点击设置之后都会调用);offsetChange,动态壁纸屏幕偏移量改变时调用!
2、createConfig直接返回new AndroidApplicationConfiguration();
3、createListener返回自写的类MyApplicationListener(实现ApplicationListener);
4、offsetChange可保存一些需要的偏移量。


至此一个动态壁纸的整体模版就出来了,可以设置为动态壁纸了,只是这个动态壁纸还没有内容罢了!
 

看到黑乎乎的动态壁纸却不知道怎么给其加上view,那么主要的问题就是在哪里添加view,就像普通的动态壁纸,显然添加不会放在service,那么就只能放在applicationListener咯
而applicationListener正是之前做桌面特效的粒子监听,于是将其搬移至此,测试可用!
 

2011-10-09 09:05:55 mandy2222 阅读数 58
  • 快速入门Android开发 视频 教程 android studio

    这是一门快速入门Android开发课程,顾名思义是让大家能快速入门Android开发。 学完能让你学会如下知识点: Android的发展历程 搭建Java开发环境 搭建Android开发环境 Android Studio基础使用方法 Android Studio创建项目 项目运行到模拟器 项目运行到真实手机 Android中常用控件 排查开发中的错误 Android中请求网络 常用Android开发命令 快速入门Gradle构建系统 项目实战:看美图 常用Android Studio使用技巧 项目签名打包 如何上架市场

    19663 人正在学习 去看看 任苹蜻
示例代码地址:http://developer.android.com/resources/samples/CubeLiveWallpaper/index.html
需代理。不能代理的朋友请下载下面的压缩包,是我自己整理的项目包。
主要是通过WallpaperService来实现的。
2015-02-02 09:29:38 tianyahelen 阅读数 633
  • 快速入门Android开发 视频 教程 android studio

    这是一门快速入门Android开发课程,顾名思义是让大家能快速入门Android开发。 学完能让你学会如下知识点: Android的发展历程 搭建Java开发环境 搭建Android开发环境 Android Studio基础使用方法 Android Studio创建项目 项目运行到模拟器 项目运行到真实手机 Android中常用控件 排查开发中的错误 Android中请求网络 常用Android开发命令 快速入门Gradle构建系统 项目实战:看美图 常用Android Studio使用技巧 项目签名打包 如何上架市场

    19663 人正在学习 去看看 任苹蜻

由于是在虚拟机上跑的 所以没有照片能够选择 在手机上跑的话能够直接取相册照片 。 跟大家分享一下 大家觉得能够的话就帮助下下~{:soso_e113:}

源码下载:http://code.662p.com/view/2312.html


  



 

 

 


 


详细说明:

2016-09-11 22:23:16 qinwenqiang666 阅读数 593
  • 快速入门Android开发 视频 教程 android studio

    这是一门快速入门Android开发课程,顾名思义是让大家能快速入门Android开发。 学完能让你学会如下知识点: Android的发展历程 搭建Java开发环境 搭建Android开发环境 Android Studio基础使用方法 Android Studio创建项目 项目运行到模拟器 项目运行到真实手机 Android中常用控件 排查开发中的错误 Android中请求网络 常用Android开发命令 快速入门Gradle构建系统 项目实战:看美图 常用Android Studio使用技巧 项目签名打包 如何上架市场

    19663 人正在学习 去看看 任苹蜻

动态壁纸

Livewallpaper(动态壁纸): 首先动态壁纸并不是GIF图片,而是一个独立的应用程序,本质是一个Service,甚至可以没有桌面图标。


直接看AndroidManifest.xml

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.qwq.clocklivewallpaper">

    <application
        android:allowBackup="true"
        android:icon="@drawable/clock"
        android:label="@string/app_name"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">

        <!-- 主界面Activity.可以去掉。动态壁纸应用是可以允许没有Activity的 -->
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

        <!-- 动态壁纸设置界面,可有可无,一般壁纸应用会有,作用是让用户自定义动态壁纸 -->
        <activity
            android:name=".SettingsActivity"
            android:exported="true"
            android:label="@string/app_name">
        </activity>

        <!-- 动态壁纸本质就是Service,所以此类为动态壁纸核心-->
        <service
            android:name=".ClockWallpaperService"
            android:enabled="true"
            android:label="@string/wallpaper_name" //下面第一张图片中label
            android:permission="android.permission.BIND_WALLPAPER">//动态壁纸必须加此权限

            <intent-filter>
                //系统就是通过APK的这个action把其当做一个动态墙纸。
              <action android:name="android.service.wallpaper.WallpaperService"></action>
            </intent-filter>

            <!-- android:resource 指定的xml很重要!!!后面会单独介绍 -->
            <meta-data
                android:name="android.service.wallpaper"
                android:resource="@xml/clock_wallpaper">
            </meta-data>

        </service>
    </application>

</manifest>

clock_wallpaper.xml

<?xml version="1.0" encoding="UTF-8"?>
<wallpaper xmlns:android="http://schemas.android.com/apk/res/android"
    android:description="@string/wallpaper_description"
    android:settingsActivity="com.qwq.clocklivewallpaper.SettingsActivity"
    android:thumbnail="@drawable/ic_preview" />

android:thumbnail 动态壁纸列表中的图标,
android:description 动态壁纸的简单介绍文字,有的手机可能不显示
动态壁纸列表图片

android:settingsActivity 指定一个Activity。系统会检测动态壁纸应用有没有此属性。如果有则和下方的图片显示效果一样(两个Button),点击下图中设定Button可跳转至指定的Activity(设置界面)。如果没有此属性,就只有一个设置壁纸Button。可以去掉此属性看一下效果。
动态壁纸设置界面图片


WallpaperService(核心)

实现动态壁纸必须继承WallpaperService,且重载onCreateEngine方法。onCreateEngine()方法只需返回一个Engine的子类对象就可以了,所以动态壁纸应用的主要工作就是实现Engine的子类。其原理是使用surfaceview不断更新,实现动态壁纸效果。不多说了,直接贴代码,重要的方法都会有所说明。

package com.qwq.clocklivewallpaper;

import android.content.SharedPreferences;
import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.os.Handler;
import android.preference.PreferenceManager;
import android.service.wallpaper.WallpaperService;
import android.util.Log;
import android.view.MotionEvent;
import android.view.SurfaceHolder;

import java.util.Date;

public class ClockWallpaperService extends WallpaperService {

    static final String TAG = ClockWallpaperService.class.getSimpleName();
    static final int POINTER_WIDTH = 9;

  //  onCreateEngine()方法需返回一个Engine的子类对象就可以了,
  //  所以动态壁纸应用的主要工作就是实现Engine的子类
  @Override
  public Engine onCreateEngine() {
        Log.d(TAG, "onCreateEngine");
        return new ClockWallpaperEngine();
    }


    //实现Engine的子类,本文的重中之重,动态壁纸就是在此具体实现的
  private class ClockWallpaperEngine extends Engine implements 
  OnSharedPreferenceChangeListener {
        private final Handler handler = new Handler();
        // surfacewive使用线程更新UI,所以我们可使用Runnable接口创建一个线程,把具体绘制方法放进去,
        // 下文会使用handler调用
        private final Runnable drawRunner = new Runnable() {
            @Override
            public void run() {
                draw();
            }
        };

        private Paint paint;
        private int width;
        private int height;
        private boolean isVisible = true;
        private boolean isShowSecond;
        private ClockView clockView;
        private SharedPreferences sp;

 //构造函数,初始化动态壁纸
 public ClockWallpaperEngine() {
            Log.d(TAG, "ClockWallpaperEngine");
            initSp();
            initPaint();
            startDrawClock();
        }

  public void initSp() {
         sp = PreferenceManager.getDefaultSharedPreferences(ClockWallpaperService.this);
         sp.registerOnSharedPreferenceChangeListener(this);
         isShowSecond = sp.getBoolean(SettingsActivity.IS_SHOW_SECOND, true);
        }

  public void initPaint() {
            paint = new Paint();
            paint.setAntiAlias(true);
            paint.setStyle(Paint.Style.STROKE);
            paint.setStrokeWidth(POINTER_WIDTH);
        }

   public void startDrawClock() {
            clockView = new ClockView(getApplicationContext());
            handler.post(drawRunner);
        }

   @Override
   public void onCreate(SurfaceHolder surfaceHolder) {
            super.onCreate(surfaceHolder);
            Log.d(TAG, "onCreate");
        }


   //监听是否可见变化,可见时开始更新UI,不可见时停止刷新
   @Override
   public void onVisibilityChanged(boolean visible) {
            this.isVisible = visible;
            if (visible) {
                handler.post(drawRunner);
            } else {
                handler.removeCallbacks(drawRunner);
            }
        }

   @Override
   public void onSurfaceDestroyed(SurfaceHolder holder) {
            super.onSurfaceDestroyed(holder);
            isVisible = false;
            handler.removeCallbacks(drawRunner);
            sp.unregisterOnSharedPreferenceChangeListener(this);
        }


   @Override
   public void onSurfaceChanged(SurfaceHolder holder,int format,int width,int height){    
            this.width = width;
            this.height = height;
            super.onSurfaceChanged(holder, format, width, height);
        }

   //绘制,每个200毫秒刷新界面
   private void draw() {
            SurfaceHolder holder = getSurfaceHolder();
            Canvas canvas = null;
            try {
                canvas = holder.lockCanvas();
                if (canvas != null) {
                    drawClock(canvas);
                }
            } finally {
                if (canvas != null) {
                    holder.unlockCanvasAndPost(canvas);
                }
            }

            handler.removeCallbacks(drawRunner);
            if (isVisible) {
                handler.postDelayed(drawRunner, 200);
            }
        }

  //具体绘制钟表
  private void drawClock(Canvas canvas) {
       canvas.drawColor(Color.WHITE);   //绘制整个动态壁纸的背景颜色
       clockView.config(width / 2, height / 2, (int) (width * 0.8f), new Date(), 
       paint, isShowSecond);
       clockView.draw(canvas);
        }

  @Override
  public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String 
  key){ 
     //监听SharedPreference变化,改变动态壁纸样式
     if (SettingsActivity.IS_SHOW_SECOND.equals(key)) {
     isShowSecond = sharedPreferences.getBoolean(SettingsActivity.IS_SHOW_SECOND,  
     true);
            }
        }

   @Override
   public void onTouchEvent(MotionEvent event) {
            super.onTouchEvent(event);
            // 可以在这里做一些与用户交互的操作,例如动态星星壁纸,用户触摸屏幕时增加星星数量。
            Log.d(TAG, "onTouchEvent");
        }
    }

}


ClockView(钟表的具体绘制)

package com.qwq.clocklivewallpaper;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.util.Log;
import android.view.View;

import java.util.Calendar;
import java.util.Date;

public class ClockView extends View {

    static final String TAG = ClockView.class.getSimpleName();
    private float x;
    private float y;
    private int radius;
    private Calendar cal;
    private Paint paint;
    private Bitmap clockDial = BitmapFactory.decodeResource(getResources(),R.drawable.clock_bg);
    private int sizeScaled = -1;
    private Bitmap clockDialScaled;
    private boolean isShowSecond;

    public ClockView(Context context) {
        super(context);
        cal = Calendar.getInstance();
    }

//设置钟表宽高等属性
public void config(float x, float y, int size, Date date, Paint paint, boolean 
    isShowSecond) {
        this.x = x;
        this.y = y;
        this.paint = paint;
        this.isShowSecond = isShowSecond;

        cal.setTime(date);

        if (size != sizeScaled) {
            clockDialScaled = Bitmap.createScaledBitmap(clockDial, size, size, false);
            radius = size / 2;
        }
    }

//具体绘制钟表的指针
protected void onDraw(Canvas canvas) {
   Log.d(TAG,"onDraw:"+canvas);
   super.onDraw(canvas);
   if (paint != null) {
            canvas.drawBitmap(clockDialScaled, x - radius, y - radius, null);

            float sec = cal.get(Calendar.SECOND);
            float min = cal.get(Calendar.MINUTE);
            float hour = cal.get(Calendar.HOUR_OF_DAY);


   paint.setColor(Color.RED);
   canvas.drawLine(x, y,
   (float)(x + (radius * 0.5f)*Math.cos(Math.toRadians((hour / 12.0f * 360.0f) - 90f))),
   (float)(y + (radius * 0.5f)*Math.sin(Math.toRadians((hour / 12.0f * 360.0f) -90f))),   
   paint);
   canvas.save();

    paint.setColor(Color.BLUE);
    canvas.drawLine(x, y, 
    (float)(x + (radius * 0.6f)*Math.cos(Math.toRadians((min / 60.0f * 360.0f) - 90f))),
    (float)(y + (radius * 0.6f)*Math.sin(Math.toRadians((min / 60.0f * 360.0f) - 90f))),  
    paint);
    canvas.save();

    if (isShowSecond) {
       paint.setColor(Color.GREEN);
       canvas.drawLine(x, y,
       (float)(x + (radius * 0.7f)*Math.cos(Math.toRadians((sec/60.0f * 360.0f) - 90f))),
       (float)(y + (radius * 0.7f)*Math.sin(Math.toRadians((sec/60.0f * 360.0f) - 90f))),   
       paint);
          }
        }
    }

}

2017-08-14 15:37:55 chennai1101 阅读数 2456
  • 快速入门Android开发 视频 教程 android studio

    这是一门快速入门Android开发课程,顾名思义是让大家能快速入门Android开发。 学完能让你学会如下知识点: Android的发展历程 搭建Java开发环境 搭建Android开发环境 Android Studio基础使用方法 Android Studio创建项目 项目运行到模拟器 项目运行到真实手机 Android中常用控件 排查开发中的错误 Android中请求网络 常用Android开发命令 快速入门Gradle构建系统 项目实战:看美图 常用Android Studio使用技巧 项目签名打包 如何上架市场

    19663 人正在学习 去看看 任苹蜻

Android OpenGL动态壁纸

首先申明下,本文为笔者学习《OpenGL ES应用开发实践指南》的笔记,并加入笔者自己的理解和归纳总结。

1、动态壁纸的Service组件

WallpaperService提供了基本的动态壁纸的实现。
public class GLWallpaperService extends WallpaperService {

    @Override
    public Engine onCreateEngine() {
        return new GLEngine();
    }

}

2、创建自定义GLSurfaceView

GLSurfaceView会调用getHolder()来添加界面,只需重载getHolder方法,返回动态壁纸的渲染表面。onWallpaperDestroy在销毁动态壁纸时被调用,使用GLSurfaceView的onDetachedFromWindow方法。
class WallpaperGLSurfaceView extends GLSurfaceView {

	public WallpaperGLSurfaceView(Context context) {
		super(context);
	}

	@Override
	public SurfaceHolder getHolder() {
		return GLEngine.this.getSurfaceHolder();
	}

	public void onWallpaperDestroy() {
		super.onDetachedFromWindow();
	}
}

3、Engine类

GLEngine继承Engine类,当动态壁纸创建时,调用GLEngine的onCreate方法来初始化,销毁时调用onDestroy方法。当动态壁纸可见或者隐藏时,onVisibilityChanged方法会被调用。
public class GLEngine extends Engine {
	@Override
	public void onCreate(SurfaceHolder surfaceHolder) {
		super.onCreate(surfaceHolder);
	}

	@Override
	public void onVisibilityChanged(boolean visible) {
		super.onVisibilityChanged(visible);
	}

	@Override
	public void onDestroy() {
		super.onDestroy();
	}

}
完善动态壁纸的生命周期,在onCreate中创建GLSurfaceView,onDestroy中销毁。
private WallpaperGLSurfaceView mSurfaceView;
		
@Override
public void onCreate(SurfaceHolder surfaceHolder) {
	super.onCreate(surfaceHolder);

	mSurfaceView = new WallpaperGLSurfaceView(GLWallpaperService.this);
}
	
public void onVisibilityChanged(boolean visible) {
	super.onVisibilityChanged(visible);

	if (mRender) {
		if (visible) {
			mSurfaceView.onResume();
		} else {
			mSurfaceView.onPause();
		}
	}
}

@Override
public void onDestroy() {
	super.onDestroy();

	mSurfaceView.onWallpaperDestroy();
}

4、添加配置

在AndroidManifest.xml中添加
<uses-feature android:name="android.software.live_wallpaper" />
<uses-feature android:glEsVersion="0x00020000" android:required="true" />
表明这个应用包含一个动态壁纸,并且还需要OpenGL ES 2.0或以上版本。
还需要添加动态壁纸Service的引用
<service android:name=".opengl.GLWallpaperService"
	android:label="@string/app_name"
	android:permission="android.permission.BIND_WALLPAPER" >
	<intent-filter>
		<action android:name="android.service.wallpaper.WallpaperService" />
	</intent-filter>
	<meta-data
		android:name="android.service.wallpaper"
		android:resource="@xml/wallpaper" />
</service>
在资源目录res/xml下,添加wapaper.xml文件
<?xml version="1.0" encoding="utf-8"?>
<wallpaper xmlns:android="http://schemas.android.com/apk/res/android"
    android:thumbnail="@drawable/ic_wallpaper" />

5、体验动态壁纸

(1) 切换到设备的主屏幕上,按住屏幕的空白部分,直至弹出一个菜单。
(2) 选择"动态壁纸",从弹出的列表中选择我们自己的动态壁纸。
(3) 选择"设置壁纸"


6、随主屏幕滚动背景

当你在主屏幕上的不同页面之间来回滑动时,动态壁纸没有移动,通过Engine的onOffsetsChanged方法,可以是实现动态壁纸的滚动效果。
public void onOffsetsChanged(final float xOffset, final float yOffset, float xOffsetStep,
							 float yOffsetStep, int xPixelOffset, int yPixelOffset) {
	mSurfaceView.queueEvent(new Runnable() {
		@Override
		public void run() {
			mShaderRender.handleOffsetsChanged(xOffset, yOffset);
		}
	});
}

7、GLWallpaperService类

public class GLWallpaperService extends WallpaperService {

    @Override
    public Engine onCreateEngine() {
        return new GLEngine();
    }

    public class GLEngine extends Engine {
        private WallpaperGLSurfaceView mSurfaceView;
        private OpenGLParticleShaderRender mShaderRender;
        private boolean mRender;

        @Override
        public void onCreate(SurfaceHolder surfaceHolder) {
            super.onCreate(surfaceHolder);

            mSurfaceView = new WallpaperGLSurfaceView(GLWallpaperService.this);

            ActivityManager am = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
            ConfigurationInfo configurationInfo = am.getDeviceConfigurationInfo();

            boolean supportEs2 = configurationInfo.reqGlEsVersion >= 0x20000;

            if (supportEs2) {
                // 选择OpenGL ES 2.0
                mSurfaceView.setEGLContextClientVersion(2);
                mShaderRender = new OpenGLParticleShaderRender();
                // 设置渲染
                mSurfaceView.setRenderer(mShaderRender);
                mRender = true;
            } else {
                Toast.makeText(GLWallpaperService.this ,
                        "This device does not support OpenGL ES 2.0",
                        Toast.LENGTH_LONG).show();
            }
        }

        @Override
        public void onVisibilityChanged(boolean visible) {
            super.onVisibilityChanged(visible);

            if (mRender) {
                if (visible) {
                    mSurfaceView.onResume();
                } else {
                    mSurfaceView.onPause();
                }
            }
        }

        @Override
        public void onDestroy() {
            super.onDestroy();

            mSurfaceView.onWallpaperDestroy();
        }

        @Override
        public void onOffsetsChanged(final float xOffset, final float yOffset, float xOffsetStep,
                                     float yOffsetStep, int xPixelOffset, int yPixelOffset) {
            mSurfaceView.queueEvent(new Runnable() {
                @Override
                public void run() {
                    LogUtil.log("GLEngine", "xOffset = " + xOffset + ", yOffset = " + yOffset);
                    mShaderRender.handleOffsetsChanged(xOffset, yOffset);
                }
            });
        }

        class WallpaperGLSurfaceView extends GLSurfaceView {

            public WallpaperGLSurfaceView(Context context) {
                super(context);
            }

            @Override
            public SurfaceHolder getHolder() {
                return GLEngine.this.getSurfaceHolder();
            }

            public void onWallpaperDestroy() {
                super.onDetachedFromWindow();
            }
        }

    }

    private class OpenGLParticleShaderRender implements GLSurfaceView.Renderer {
        private Particle mParticle;
        private ParticleProgram mParticleProgram;
        private ParticleShooter mRedParticleShooter, mGreenParticleShooter, mBlueParticleShooter;
        private long mGlobalStartTime;

        private float[] projectionMatrix = new float[16];
        private float[] viewMatrix = new float[16];
        private float[] viewProjectionMatrix = new float[16];

        private float xOffset, yOffset;

        @Override
        public void onSurfaceCreated(GL10 gl, EGLConfig config) {
            GLES20.glClearColor(0.0f, 0.0f, 0.0f, 0.1f);

            GLES20.glEnable(GLES20.GL_BLEND);
            GLES20.glBlendFunc(GLES20.GL_ONE, GLES20.GL_ONE);

            mParticleProgram = new ParticleProgram(GLWallpaperService.this);
            mParticle = new Particle(10000);

            mGlobalStartTime = System.nanoTime();

            final Geometry.Vector particleDirection = new Geometry.Vector(0f, 0.5f, 0f);

            mRedParticleShooter = new ParticleShooter(new Geometry.Point(-1, 0, 0),
                    particleDirection, Color.rgb(250, 50, 5));

            mGreenParticleShooter = new ParticleShooter(new Geometry.Point(0, 0, 0),
                    particleDirection, Color.rgb(25, 255, 25));

            mBlueParticleShooter = new ParticleShooter(new Geometry.Point(1, 0, 0),
                    particleDirection, Color.rgb(5, 50, 255));
            final float angleVarianceInDegrees = 5f;
            final float speedVariance = 1f;

            mRedParticleShooter = new ParticleShooter(new Geometry.Point(-1, 0, 0),
                    particleDirection, Color.rgb(250, 50, 5), angleVarianceInDegrees, speedVariance);

            mGreenParticleShooter = new ParticleShooter(new Geometry.Point(0, 0, 0),
                    particleDirection, Color.rgb(25, 255, 25), angleVarianceInDegrees, speedVariance);

            mBlueParticleShooter = new ParticleShooter(new Geometry.Point(1, 0, 0),
                    particleDirection, Color.rgb(5, 50, 255), angleVarianceInDegrees, speedVariance);
        }

        @Override
        public void onSurfaceChanged(GL10 gl, int width, int height) {
            // 设置视图尺寸
            GLES20.glViewport(0, 0, width, height);

            // 创建透视投影
            Matrix.perspectiveM(projectionMatrix, 0, 45, (float)width / (float)height, 1f, 10f);

            updateViewMatrices();
        }

        @Override
        public void onDrawFrame(GL10 gl) {
            // 清空屏幕
            GLES20.glClear(GL10.GL_COLOR_BUFFER_BIT);

            float currentTime = (System.nanoTime() - mGlobalStartTime) / 1000000000f;
            mRedParticleShooter.addParticles(mParticle, currentTime, 5);
            mGreenParticleShooter.addParticles(mParticle, currentTime, 5);
            mBlueParticleShooter.addParticles(mParticle, currentTime, 5);

            mParticleProgram.setUniform(viewProjectionMatrix);
            mParticleProgram.setCurrentTime(currentTime);
            mParticle.bindData(mParticleProgram);
            mParticle.draw();
        }

        private void handleOffsetsChanged(float xOffset, float yOffset) {
            this.xOffset = (xOffset - 0.5f) * 2.5f;
            this.yOffset = (yOffset - 0.5f) * 2.5f;
            updateViewMatrices();
        }

        private void updateViewMatrices() {
            // 定义模型矩阵
            Matrix.setIdentityM(viewMatrix, 0);
            Matrix.translateM(viewMatrix, 0, 0f - xOffset, -1.5f - yOffset, -5f);

            Matrix.multiplyMM(viewProjectionMatrix, 0, projectionMatrix, 0, viewMatrix, 0);
        }

    }

}
显示如下


没有更多推荐了,返回首页