Android自定义View实现八大行星绕太阳转动效果

最新推荐文章于 2024-09-27 15:39:55 发布
最新推荐文章于 2024-09-27 15:39:55 发布
阅读量236 收藏
点赞数
分类专栏： Android 文章标签： android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ldld1717/article/details/134763251
版权

        最近尝试使用Android自定义View实现了一个8大行星绕太阳转动的自定义View效果，效果静态图如下所示：

        还没来得及对该效果进行比较通用的包装，仅仅实现效果，有兴趣的可以继续扩展、美化、包装一下。

        核心代码就一个类PlanetsView。

package com.lllddd.planetsview

import android.animation.ObjectAnimator
import android.content.Context
import android.graphics.Canvas
import android.graphics.Color
import android.graphics.DashPathEffect
import android.graphics.Paint
import android.util.AttributeSet
import android.view.View
import android.view.animation.LinearInterpolator
import kotlin.math.cos
import kotlin.math.sin

class PlanetsView @JvmOverloads constructor(
    context: Context?,
    attrs: AttributeSet? = null,
    defStyleAttr: Int = 0
) : View(context, attrs, defStyleAttr) {
    /**
     * View宽度
     */
    private var mWidth = 0

    /**
     * View高度
     */
    private var mHeight = 0

    /**
     * 画笔
     */
    private var mPlanetPaint: Paint? = null
    private var mTrackPaint: Paint? = null

    /**
     * 太阳坐标
     */
    private var mSunX = 0f
    private var mSunY = 0f

    /**
     * 水星坐标
     */
    private var mMercuryX = 0f
    private var mMercuryY = 0f

    /**
     * 金星坐标
     */
    private var mVenusX = 0f
    private var mVenusY = 0f

    /**
     * 地球坐标
     */
    private var mEarthX = 0f
    private var mEarthY = 0f

    /**
     * 火星坐标
     */
    private var mMarsX = 0f
    private var mMarsY = 0f

    /**
     * 木星坐标
     */
    private var mJupiterX = 0f
    private var mJupiterY = 0f

    /**
     * 土星坐标
     */
    private var mSaturnX = 0f
    private var mSaturnY = 0f

    /**
     * 天王星坐标
     */
    private var mUranusX = 0f
    private var mUranusY = 0f

    /**
     * 海王星坐标
     */
    private var mNeptuneX = 0f
    private var mNeptuneY = 0f

    /**
     * 水星距离太阳的距离
     */
    private val mDistanceMercury = 90f

    /**
     * 金星距离太阳的距离
     */
    private val mDistanceVenus = 140f

    /**
     * 地球距离太阳的距离
     */
    private val mDistanceEarth = 200f

    /**
     * 火星距离太阳的距离
     */
    private val mDistanceMars = 250f

    /**
     * 木星距离太阳的距离
     */
    private val mDistanceJupiter = 310f

    /**
     * 土星距离太阳的距离
     */
    private val mDistanceSaturn = 390f

    /**
     * 天王星距离太阳的距离
     */
    private val mDistanceUranus = 440f

    /**
     * 海王星距离太阳的距离
     */
    private val mDistanceNeptune = 490f

    /**
     * 太阳角度
     */
    private var mSunAngle = 0f

    /**
     * 水星角度
     */
    private var mMercuryAngle = 0f

    /**
     * 金星角度
     */
    private var mVenusAngle = 0f

    /**
     * 地球角度
     */
    private var mEarthAngle = 0f

    /**
     * 火星角度
     */
    private var mMarsAngle = 0f

    /**
     * 木星角度
     */
    private var mJupiterAngle = 0f

    /**
     * 土星角度
     */
    private var mSaturnAngle = 0f

    /**
     * 天王星角度
     */
    private var mUranusAngle = 0f

    /**
     * 海王星角度
     */
    private var mNeptuneAngle = 0f

    /**
     * 太阳动画
     */
    private var mSunAnimator: ObjectAnimator? = null

    /**
     * 水星动画
     */
    private var mMercuryAnimator: ObjectAnimator? = null

    /**
     * 金星动画
     */
    private var mVenusAnimator: ObjectAnimator? = null

    /**
     * 地球动画
     */
    private var mEarthAnimator: ObjectAnimator? = null

    /**
     * 火星动画
     */
    private var mMarsAnimator: ObjectAnimator? = null

    /**
     * 木星动画
     */
    private var mJupiterAnimator: ObjectAnimator? = null

    /**
     * 土星动画
     */
    private var mSaturnAnimator: ObjectAnimator? = null

    /**
     * 天王星动画
     */
    private var mUranusAnimator: ObjectAnimator? = null

    /**
     * 海王星动画
     */
    private var mNeptuneAnimator: ObjectAnimator? = null

    init {
        init()
    }

    private fun init() {
        mPlanetPaint = Paint()
        mPlanetPaint!!.isAntiAlias = true
        mPlanetPaint!!.style = Paint.Style.FILL

        mTrackPaint = Paint()
        mTrackPaint!!.isAntiAlias = true
        mTrackPaint!!.style = Paint.Style.STROKE
        mTrackPaint!!.color = Color.GRAY
        mTrackPaint!!.strokeWidth = 2f

        // 设置虚线样式
        val intervals = floatArrayOf(20f, 20f)
        val phase = 2f
        val dashPathEffect = DashPathEffect(intervals, phase)
        mTrackPaint!!.pathEffect = dashPathEffect

        mSunX = width.toFloat()
        mSunY = height.toFloat()

        mMercuryX = mSunX + mDistanceMercury
        mMercuryY = mSunY

        mVenusX = mSunX + mDistanceVenus
        mVenusY = mSunY

        mEarthX = mSunX + mDistanceEarth
        mEarthY = mSunY

        mMarsX = mSunX + mDistanceMars
        mMarsY = mSunY

        mJupiterX = mSunX + mDistanceJupiter
        mJupiterY = mSunY

        mSaturnX = mSunX + mDistanceSaturn
        mSaturnY = mSunY

        mUranusX = mSunX + mDistanceUranus
        mUranusY = mSunY

        mNeptuneX = mSunX + mDistanceNeptune
        mNeptuneY = mSunY

        // 初始化属性动画
        mSunAnimator = ObjectAnimator.ofFloat(this, "sunAngle", 0f, 360f).apply {
            duration = 1000
            interpolator = LinearInterpolator()
            repeatCount = ObjectAnimator.INFINITE
            repeatMode = ObjectAnimator.RESTART
        }

        mMercuryAnimator = ObjectAnimator.ofFloat(this, "mercuryAngle", 0f, 360f).apply {
            duration = (4000f / 4.15f).toLong()
            interpolator = LinearInterpolator()
            repeatCount = ObjectAnimator.INFINITE
            repeatMode = ObjectAnimator.RESTART
        }

        mVenusAnimator = ObjectAnimator.ofFloat(this, "venusAngle", 0f, 360f).apply {
            duration = (4000f / 1.60f).toLong()
            interpolator = LinearInterpolator()
            repeatCount = ObjectAnimator.INFINITE
            repeatMode = ObjectAnimator.RESTART
        }

        mEarthAnimator = ObjectAnimator.ofFloat(this, "earthAngle", 0f, 360f).apply {
            duration = (4000f / 0.99f).toLong()
            interpolator = LinearInterpolator()
            repeatCount = ObjectAnimator.INFINITE
            repeatMode = ObjectAnimator.RESTART
        }

        mMarsAnimator = ObjectAnimator.ofFloat(this, "marsAngle", 0f, 360f).apply {
            duration = (4000f / 0.53f).toLong()
            interpolator = LinearInterpolator()
            repeatCount = ObjectAnimator.INFINITE
            repeatMode = ObjectAnimator.RESTART
        }

        mJupiterAnimator = ObjectAnimator.ofFloat(this, "jupiterAngle", 0f, 360f).apply {
            duration = (4000f / 0.38f).toLong()
            interpolator = LinearInterpolator()
            repeatCount = ObjectAnimator.INFINITE
            repeatMode = ObjectAnimator.RESTART
        }

        mSaturnAnimator = ObjectAnimator.ofFloat(this, "saturnAngle", 0f, 360f).apply {
            duration = (4000f / 0.13f).toLong()
            interpolator = LinearInterpolator()
            repeatCount = ObjectAnimator.INFINITE
            repeatMode = ObjectAnimator.RESTART
        }

        mUranusAnimator = ObjectAnimator.ofFloat(this, "uranusAngle", 0f, 360f).apply {
            duration = (4000f / 0.07f).toLong()
            interpolator = LinearInterpolator()
            repeatCount = ObjectAnimator.INFINITE
            repeatMode = ObjectAnimator.RESTART
        }

        mNeptuneAnimator = ObjectAnimator.ofFloat(this, "neptuneAngle", 0f, 360f).apply {
            duration = (4000f / 0.05f).toLong()
            interpolator = LinearInterpolator()
            repeatCount = ObjectAnimator.INFINITE
            repeatMode = ObjectAnimator.RESTART
        }
    }

    fun setSunAngle(angle: Float) {
        mSunAngle = angle
        invalidate()
    }

    fun setMercuryAngle(angle: Float) {
        mMercuryAngle = angle
        invalidate()
    }

    fun setVenusAngle(angle: Float) {
        mVenusAngle = angle
        invalidate()
    }

    fun setEarthAngle(angle: Float) {
        mEarthAngle = angle
        invalidate()
    }

    fun setMarsAngle(angle: Float) {
        mMarsAngle = angle
        invalidate()
    }

    fun setJupiterAngle(angle: Float) {
        mJupiterAngle = angle
        invalidate()
    }

    fun setSaturnAngle(angle: Float) {
        mSaturnAngle = angle
        invalidate()
    }

    fun setUranusAngle(angle: Float) {
        mUranusAngle = angle
        invalidate()
    }

    fun setNeptuneAngle(angle: Float) {
        mNeptuneAngle = angle
        invalidate()
    }

    override fun onAttachedToWindow() {
        super.onAttachedToWindow()

        // 开始属性动画
        mSunAnimator!!.start()
        mMercuryAnimator!!.start()
        mVenusAnimator!!.start()
        mEarthAnimator!!.start()
        mMarsAnimator!!.start()
        mJupiterAnimator!!.start()
        mSaturnAnimator!!.start()
        mUranusAnimator!!.start()
        mNeptuneAnimator!!.start()
    }

    override fun onDetachedFromWindow() {
        super.onDetachedFromWindow()

        // 停止属性动画
        mSunAnimator!!.cancel()
        mMercuryAnimator!!.cancel()
        mVenusAnimator!!.cancel()
        mEarthAnimator!!.cancel()
        mMarsAnimator!!.cancel()
        mJupiterAnimator!!.cancel()
        mSaturnAnimator!!.cancel()
        mUranusAnimator!!.cancel()
        mNeptuneAnimator!!.cancel()
    }

    override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec)
        mWidth = measuredWidth
        mHeight = measuredHeight
    }

    override fun onDraw(canvas: Canvas) {
        canvas.save()
        canvas.translate((mWidth shr 1).toFloat(), (mHeight shr 1).toFloat())
        canvas.drawCircle(mSunX, mSunY, mDistanceMercury, mTrackPaint!!)
        canvas.drawCircle(mSunX, mSunY, mDistanceVenus, mTrackPaint!!)
        canvas.drawCircle(mSunX, mSunY, mDistanceEarth, mTrackPaint!!)
        canvas.drawCircle(mSunX, mSunY, mDistanceMars, mTrackPaint!!)
        canvas.drawCircle(mSunX, mSunY, mDistanceJupiter, mTrackPaint!!)
        canvas.drawCircle(mSunX, mSunY, mDistanceSaturn, mTrackPaint!!)
        canvas.drawCircle(mSunX, mSunY, mDistanceUranus, mTrackPaint!!)
        canvas.drawCircle(mSunX, mSunY, mDistanceNeptune, mTrackPaint!!)
        canvas.restore()
        super.onDraw(canvas)
        canvas.save()
        canvas.translate((mWidth shr 1).toFloat(), (mHeight shr 1).toFloat())

        // 绘制太阳
        mPlanetPaint!!.color = Color.parseColor("#FF2200")
        canvas.drawCircle(mSunX, mSunY, SUN_RADIUS, mPlanetPaint!!)

        mMercuryX =
            (mSunX + mDistanceMercury * cos(Math.toRadians(mMercuryAngle.toDouble()))).toFloat()
        mMercuryY =
            (mSunY + mDistanceMercury * sin(Math.toRadians(mMercuryAngle.toDouble()))).toFloat()
        mPlanetPaint!!.color = Color.parseColor("#6495ED")
        canvas.drawCircle(mMercuryX, mMercuryY, MERCURY_RADIUS, mPlanetPaint!!)

        mVenusX =
            (mSunX + mDistanceVenus * cos(Math.toRadians(mVenusAngle.toDouble()))).toFloat()
        mVenusY =
            (mSunY + mDistanceVenus * sin(Math.toRadians(mVenusAngle.toDouble()))).toFloat()
        mPlanetPaint!!.color = Color.parseColor("#FFFF00")
        canvas.drawCircle(mVenusX, mVenusY, VENUS_RADIUS, mPlanetPaint!!)

        mEarthX =
            (mSunX + mDistanceEarth * cos(Math.toRadians(mEarthAngle.toDouble()))).toFloat()
        mEarthY =
            (mSunY + mDistanceEarth * sin(Math.toRadians(mEarthAngle.toDouble()))).toFloat()
        mPlanetPaint!!.color = Color.parseColor("#00FF00")
        canvas.drawCircle(mEarthX, mEarthY, EARTH_RADIUS, mPlanetPaint!!)

        mMarsX = (mSunX + mDistanceMars * cos(Math.toRadians(mMarsAngle.toDouble()))).toFloat()
        mMarsY = (mSunY + mDistanceMars * sin(Math.toRadians(mMarsAngle.toDouble()))).toFloat()
        mPlanetPaint!!.color = Color.parseColor("#D2691E")
        canvas.drawCircle(mMarsX, mMarsY, MARS_RADIUS, mPlanetPaint!!)

        mJupiterX =
            (mSunX + mDistanceJupiter * cos(Math.toRadians(mJupiterAngle.toDouble()))).toFloat()
        mJupiterY =
            (mSunY + mDistanceJupiter * sin(Math.toRadians(mJupiterAngle.toDouble()))).toFloat()
        mPlanetPaint!!.color = Color.parseColor("#FFE4B5")
        canvas.drawCircle(mJupiterX, mJupiterY, JUPITER_RADIUS, mPlanetPaint!!)

        mSaturnX =
            (mSunX + mDistanceSaturn * cos(Math.toRadians(mSaturnAngle.toDouble()))).toFloat()
        mSaturnY =
            (mSunY + mDistanceSaturn * sin(Math.toRadians(mSaturnAngle.toDouble()))).toFloat()
        mPlanetPaint!!.color = Color.parseColor("#A0522D")
        canvas.drawCircle(mSaturnX, mSaturnY, SATURN_RADIUS, mPlanetPaint!!)

        mUranusX =
            (mSunX + mDistanceUranus * cos(Math.toRadians(mUranusAngle.toDouble()))).toFloat()
        mUranusY =
            (mSunY + mDistanceUranus * sin(Math.toRadians(mUranusAngle.toDouble()))).toFloat()
        mPlanetPaint!!.color = Color.parseColor("#008080")
        canvas.drawCircle(mUranusX, mUranusY, URANUS_RADIUS, mPlanetPaint!!)

        mNeptuneX =
            (mSunX + mDistanceNeptune * cos(Math.toRadians(mNeptuneAngle.toDouble()))).toFloat()
        mNeptuneY =
            (mSunY + mDistanceNeptune * sin(Math.toRadians(mNeptuneAngle.toDouble()))).toFloat()
        mPlanetPaint!!.color = Color.parseColor("#4B0082")

        canvas.drawCircle(mNeptuneX, mNeptuneY, NEPTUNE_RADIUS, mPlanetPaint!!)

        canvas.restore()

        invalidate()
    }

    companion object {
        /**
         * 地球半径
         */
        private const val SUN_RADIUS = 50.0f

        /**
         * 地球半径
         */
        private const val EARTH_RADIUS = 20.0f

        /**
         * 水星半径
         */
        private const val MERCURY_RADIUS = EARTH_RADIUS * 0.7f

        /**
         * 金星半径
         */
        private const val VENUS_RADIUS = EARTH_RADIUS * 1.2f

        /**
         * 火星半径
         */
        private const val MARS_RADIUS = EARTH_RADIUS * 0.9f

        /**
         * 木星半径
         */
        private const val JUPITER_RADIUS = EARTH_RADIUS * 2f

        /**
         * 土星半径
         */
        private const val SATURN_RADIUS = EARTH_RADIUS * 1.7f

        /**
         * 天王星半径
         */
        private const val URANUS_RADIUS = EARTH_RADIUS * 1.2f

        /**
         * 海王星半径
         */
        private const val NEPTUNE_RADIUS = EARTH_RADIUS * 1.2f
    }
}

        再写一个MainActivity。

package com.lllddd.planetsview

import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    }
}

        布局文件非常简单。

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <com.lllddd.planetsview.PlanetsView
        android:layout_width="0dp"
        android:layout_height="0dp"
        android:background="@drawable/bg_galaxy"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintDimensionRatio="1:1"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

</androidx.constraintlayout.widget.ConstraintLayout>

        大功告成。

OpenLD
关注
专栏目录
Android TV Menu 3D星体旋转效果
学无止境
09-10 1万+
在Android中，如果想要实现3D动画效果一般有两种选择：一是使用Open GL ES，二是使用Camera。Open GL ES使用起来太过复杂，一般是用于比较高级的3D特效或游戏，并且这个也不是开源的，像比较简单的一些3D效果，使用Camera就足够了。 一些熟知的Android 3D动画如对某个View进行旋转或翻转的 Rotate3dAnimation类，还有使用Gallery（ G......
Android 自定义View（一）实现时钟表盘效果
一名互联网时代苟且偷生的 Android码农
05-27 2996
一、前言 Android 自定义View是高级进阶不可或缺的内容，日常工作中，经常会遇到产品、UI设计出花里胡哨的界面。当系统自带的控件不能满足开发需求时，就只能自己动手撸一个效果。 本文就带自定义View初学者手动撸一个效果，通过自定义View实现钟表功能，每行代码都有注释，保证易懂，看不懂你留言打我！！！ 二、实现效果 先看效果图 步骤分析 实现以上效果，主要分为四个步骤： 绘制外层表盘 绘制刻度线 绘制刻度数字 绘制指针 三、代码实现 1、绘制外层表盘 外层表盘就是一个空心圆，只要获取圆的x、y
Android-CreditsRoll-实现星球大战字幕效果
08-13
CreditsRoll - 实现星球大战字幕效果
Android星球效果实现
weixin_30399821的博客
10-16 863
在项目中看着这个旋转效果挺炫的，就抽取出来做个记录。主要是使用CarrouselLayout 稍微修改 CarrouselLayout代码Demo下载z地址：GitHub https://github.com/lyfkai/AndroidCarrouselLayout 主要代码如下 ： public class CarrouselLayout extends R...
android行星动画,Android实现SoulApp星球效果
weixin_29865183的博客
05-26 773
SoulApp的星球看起来太炫酷了！！！啥也不说先上图：soul planet.gif基础知识首先得拿出我们的数学知识：球坐标系(r,θ,φ)与直角坐标系(x,y,z)的转换关系:x = rsinθcosφ.y = rsinθsinφ.z = rcosθ.Q：What！为什么要整个球坐标系啊？A：因为星球嘛，位置信息当然球坐标系更加简单额。实现思路核心算法来自：3dTagCloudAndroid在...
SoulPlanet:Soul App星球效果
05-11
Soul Planet Soul App星球效果 效果图 感谢 基于，修改部分代码实现
Android自定义View(模拟竖直平面小球绕圆环旋转效果)
12-05
自定义加载等待View，模拟小球在最低点以一定初速度在重力作用下绕圆环做变速圆周运动的效果（详见：http://blog.csdn.net/l_wwbs/article/details/53408830）。
Android自定义View—仿雷达扫描效果
09-21
在Android开发中，自定义View是一项重要的技能，它允许开发者创造出独特且富有创意的用户界面。本篇文章将探讨如何创建一个仿雷达扫描效果的自定义View。雷达扫描效果常见于许多应用中，如游戏、安全监控或者定位...
Android 自定义View（四）实现股票自选列表滑动效果
一名互联网时代苟且偷生的 Android码农
06-06 2268
自定义View一、前言二、开发准备工作1、先上效果图2、案例源码下载3、案例应用知识点4、案例思路分析三、代码实现1、自定义 TextView2、自定义 CustomizeScrollView3、主页面布局4、主列表 Adapter四、总结 一、前言 Android 开发过程中自定义 View 真的是无处不在，随随便便一个 UI 效果，都会用到自定义 View。前面三篇文章已经讲过自定义 View 的一些案例效果，相关类和 API，还有事件分发理论知识请自行充电。作者不喜欢讲一些原理性的东西，直接上效果和源
Android 自定义View，实现折线图
06-10
本篇文章将深入探讨如何在Android中实现一个自定义的折线图视图，帮助你理解自定义View的基本步骤以及绘制折线图的核心技术。 首先，创建一个新的Java类，继承自`View`或`ViewGroup`。在这里，我们选择`View`，因为...
Android实现3D标签云效果
01-04
最近业务需求，要求实现一个3D星球环绕效果，经过百般查找，终于找到了这个功能。 来先看看效果图： 首先还是添加第三方依赖库： compile 'com.moxun:tagcloudlib:1.1.0' 布局： <?xml version=1.0 encoding=utf-8?> <android.support.constraint.ConstraintLayout xmlns:android=http://schemas.android.com/apk/res/android xmlns:app=http://schemas.android.com/apk/res-a
opengl的太阳系模型
01-12
视点变换，旋转，加速减速，星空背景 太阳，光晕 各行星纹理 #include #include #include #include #include #include #include #pragma comment(lib, "winmm.lib") #pragma comment(lib,"wininet") // 纹理图像结构 typedef struct { int imgWidth; // 纹理宽度 int imgHeight; // 纹理高度 unsigned char byteCount; // 每个象素对应的字节数，3：24位图，4：带alpha通道的24位图 unsigned char *data; // 纹理数据 }TEXTUREIMAGE; // BMP文件头 #pragma pack(2) typedef struct { unsigned short bfType; // 文件类型 unsigned long bfSize; // 文件大小 unsigned short bfReserved1; // 保留位 unsigned short bfReserved2; // 保留位 unsigned long bfOffBits; // 数据偏移位置 }BMPFILEHEADER; #pragma pack() // BMP信息头 typedef struct { unsigned long biSize; // 此结构大小 long biWidth; // 图像宽度 long biHeight; // 图像高度 unsigned short biPlanes; // 调色板数量 unsigned short biBitCount; // 每个象素对应的位数，24：24位图，32：带alpha通道的24位图 unsigned long biCompression; // 压缩 unsigned long biSizeImage; // 图像大小 long biXPelsPerMeter;// 横向分辨率 long biYPelsPerMeter;// 纵向分辨率 unsigned long biClrUsed; // 颜色使用数 unsigned long biClrImportant; // 重要颜色数 }BMPINFOHEADER; // 定义窗口的标题、宽度、高度、全屏布尔变量 #define WIN_TITLE "模拟太阳系各星球的转动" const int WIN_WIDTH = 800; const int WIN_HEIGHT = 600; BOOL isFullScreen = FALSE; // 初始不为全屏 #define DEG_TO_RAD 0.017453 float angle=0.0; static GLdouble viewer[]= {0,0,0,0,0}; // 初始化视角 GLUquadricObj *quadric; // 建立二次曲面对象 GLfloat angle_Z; // 星空旋转角度 bool g_bOrbitOn = true; // 控制转动暂停 float g_fSpeedmodifier = 1.0f; // 时间控制 float g_fElpasedTime; double g_dCurrentTime; double g_dLastTime; GLfloat LightAmbient[] = { 1.0f, 1.0f, 1.0f, 0.0f }; // 环境光参数 GLfloat LightDiffuse[] = { 1.0f, 1.0f, 1.0f, 0.0f }; // 漫射光参数 GLfloat LightPosition[] = { 0.0f, 0.0f, 0.0f, 1.0f }; // 光源的位置 // 纹理图象 TEXTUREIMAGE skyImg; TEXTUREIMAGE sunImg; TEXTUREIMAGE rayImg; TEXTUREIMAGE mercuImg; TEXTUREIMAGE venusImg; TEXTUREIMAGE earthImg; TEXTUREIMAGE marsImg; TEXTUREIMAGE jupiterImg; TEXTUREIMAGE saturnImg; TEXTUREIMAGE uranusImg; TEXTUREIMAGE neptuneImg; TEXTUREIMAGE moonImg; GLuint texture[12]; // 纹理数组 // 星球速度定义 static float fSunSpin = 0.0f; // 太阳自转速度 static float fMercuSpin = 0.0f; // 水星自转速度 static float fMercuOrbit = 0.0f; // 水星公转速度 static float fVenusSpin = 0.0f; // 金星自转速度 static float fVenusOrbit = 0.0f; // 金星公转速度 static float fEarthSpin = 0.0f; // 地球自转速度 static float fEarthOrbit = 0.0f; // 地球公转速度 static float fMarsSpin = 0.0f; // 火星自转速度 static float fMarsOrbit = 0.0f; // 火星公转速度 static float fJupiterSpin = 0.0f; // 木星自转速度 static float fJupiterOrbit = 0.0f; // 木星公转速度 static float fSaturnSpin = 0.0f; // 土星自转速度 static float fSaturnOrbit = 0.0f; // 土星公转速度 static float fUranusSpin = 0.0f; // 天王星自转速度 static float fUranusOrbit = 0.0f; // 天王星公转速度 static float fNeptuneSpin = 0.0f; // 海王星自转速度 static float fNeptuneOrbit = 0.0f; // 海王星公转速度 static float fMoonSpin = 0.0f; // 月亮自转速度 static float fMoonOrbit = 0.0f; // 月亮公转速度 void MakeTexture(TEXTUREIMAGE textureImg, GLuint * texName) //转换为纹理 { glPixelStorei(GL_UNPACK_ALIGNMENT, 1); //对齐像素字节函数 glGenTextures(1,texName); //第一个参数指定表明获取多少个连续的纹理标识符 glBindTexture(GL_TEXTURE_2D , *texName); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, textureImg.imgWidth,textureImg.imgHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, textureImg.data); } // 初始化OpenGL void InitGL(void) { glClearColor(0.0f, 0.0f, 0.0f, 0.5f); //设置黑色背景 glClearDepth(2.0f); // 设置深度缓存 glEnable(GL_DEPTH_TEST); //启动深度测试 glDepthFunc(GL_LEQUAL); //深度小或相等的时候渲染 glShadeModel(GL_SMOOTH); //启动阴影平滑 glEnable(GL_CULL_FACE); //开启剔除操作效果 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); //使用质量最好的模式指定颜色和纹理坐标的插值质量 glLightfv(GL_LIGHT1, GL_AMBIENT, LightAmbient); // 设置环境光 glLightfv(GL_LIGHT1, GL_DIFFUSE, LightDiffuse); // 设置漫反射光 glEnable(GL_LIGHTING); // 打开光照 glEnable(GL_LIGHT1); // 打开光源1 // 载入纹理 glEnable(GL_TEXTURE_2D); // 开启2D纹理映射 MakeTexture(skyImg, &texture;[0]); MakeTexture(sunImg, &texture;[1]); MakeTexture(rayImg, &texture;[2]); MakeTexture(mercuImg, &texture;[3]); MakeTexture(venusImg, &texture;[4]); MakeTexture(earthImg, &texture;[5]); MakeTexture(marsImg, &texture;[6]); MakeTexture(jupiterImg, &texture;[7]); MakeTexture(saturnImg, &texture;[8]); MakeTexture(uranusImg, &texture;[9]); MakeTexture(neptuneImg, &texture;[10]); MakeTexture(moonImg, &texture;[11]); quadric = gluNewQuadric(); // 建立一个曲面对象指针 gluQuadricTexture(quadric, GLU_TRUE); // 建立纹理坐标 gluQuadricDrawStyle(quadric, GLU_FILL); // 面填充 } void Display(void) { glLoadIdentity(); // 设置观察点的位置和观察的方向 gluLookAt(viewer[0],viewer[1],viewer[2],viewer[3],viewer[4],-5,0,1,0); //摄像机x,摄像机y,摄像机z, 目标点x,目标点y,目标点z, 摄像机顶朝向x,摄像机顶朝向y,摄像机顶朝向z // 获得系统时间使太阳系有动态效果 g_dCurrentTime = timeGetTime(); g_fElpasedTime = (float)((g_dCurrentTime - g_dLastTime) * 0.0005); g_dLastTime = g_dCurrentTime; glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glMatrixMode( GL_MODELVIEW ); //指定GL_MODELVIEW是下一个矩阵操作的目标 glTranslatef(0.0f, 0.0f, -5.0f); // 将坐标系移入屏幕5.0f glRotatef(10, 1.0f ,0.0f, 0.0f); // 将坐标系绕x轴旋转10度 glEnable(GL_LIGHT0); // 打开光源0 /**********************************绘制背景星空********************************************/ glPushMatrix (); // 当前模型矩阵入栈 glTranslatef(-10.0f, 3.0f, 0.0f); glRotatef(angle_Z, 0.0f, 0.0f, 1.0f); glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, texture[0]); // 星空纹理 glBegin(GL_QUADS); glNormal3f( 0.0f, 0.0f, 1.0f); glTexCoord2f(0.0f, 0.0f); glVertex3f(-50.0f, -50.0f, -50.0f); glTexCoord2f(6.0f, 0.0f); glVertex3f( 50.0f, -50.0f, -50.0f); glTexCoord2f(6.0f, 6.0f); glVertex3f( 50.0f, 50.0f, -50.0f); glTexCoord2f(0.0f, 6.0f); glVertex3f(-50.0f, 50.0f, -50.0f); glEnd(); glBegin(GL_QUADS); glNormal3f( 0.0f, 0.0f, -1.0f); glTexCoord2f(6.0f, 6.0f); glVertex3f(-50.0f, -50.0f, 50.0f); glTexCoord2f(0.0f, 6.0f); glVertex3f( 50.0f, -50.0f, 50.0f); glTexCoord2f(0.0f, 0.0f); glVertex3f( 50.0f, 50.0f, 50.0f); glTexCoord2f(6.0f, 0.0f); glVertex3f(-50.0f, 50.0f, 50.0f); glEnd(); glBegin(GL_QUADS); glNormal3f( 0.0f, 1.0f, 0.0f); glTexCoord2f(0.0f, 0.0f); glVertex3f(-50.0f, -50.0f, -50.0f); glTexCoord2f(6.0f, 6.0f); glVertex3f( 50.0f, -50.0f, 50.0f); glTexCoord2f(6.0f, 0.0f); glVertex3f( 50.0f, -50.0f, -50.0f); glTexCoord2f(0.0f, 6.0f); glVertex3f(-50.0f, -50.0f, 50.0f); glEnd(); glBegin(GL_QUADS); glNormal3f( 0.0f, -1.0f, 0.0f); glTexCoord2f(6.0f, 6.0f); glVertex3f(-50.0f, 50.0f, -50.0f); glTexCoord2f(0.0f, 0.0f); glVertex3f( 50.0f, 50.0f, 50.0f); glTexCoord2f(0.0f, 6.0f); glVertex3f( 50.0f, 50.0f, -50.0f); glTexCoord2f(6.0f, 0.0f); glVertex3f(-50.0f, 50.0f, 50.0f); glEnd(); glBegin(GL_QUADS); glNormal3f( 1.0f, 0.0f, 0.0f); glTexCoord2f(0.0f, 0.0f); glVertex3f(-50.0f, -50.0f, -50.0f); glTexCoord2f(6.0f, 6.0f); glVertex3f(-50.0f, 50.0f, 50.0f); glTexCoord2f(0.0f, 6.0f); glVertex3f(-50.0f, -50.0f, 50.0f); glTexCoord2f(6.0f, 0.0f); glVertex3f(-50.0f, 50.0f, -50.0f); glEnd(); glBegin(GL_QUADS); glNormal3f( -1.0f, 0.0f, 0.0f); glTexCoord2f(6.0f, 6.0f); glVertex3f(50.0f, -50.0f, -50.0f); glTexCoord2f(0.0f, 0.0f); glVertex3f(50.0f, 50.0f, 50.0f); glTexCoord2f(6.0f, 0.0f); glVertex3f(50.0f, -50.0f, 50.0f); glTexCoord2f(0.0f, 6.0f); glVertex3f(50.0f, 50.0f, -50.0f); glEnd(); glPopMatrix (); // 当前模型矩阵出栈 /**********************************绘制太阳************************************************/ glBindTexture(GL_TEXTURE_2D, texture[2]); // 光晕纹理 glEnable(GL_BLEND); // 开启混合 glDisable(GL_DEPTH_TEST); // 关闭深度测试 // 绘制太阳光晕 glDisable(GL_LIGHTING); // 关闭光照 glBlendFunc(GL_SRC_ALPHA,GL_ONE); // 半透明混合函数 glColor4f(1.0f, 0.5f, 0.0f, 0.5f); // 设置RGBA值 glBegin(GL_QUADS); glNormal3f( 0.0f, 0.0f, 1.0f); glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f,-1.0f, 0.0f); glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f,-1.0f, 0.0f); glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, 0.0f); glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, 0.0f); glEnd(); glDisable(GL_BLEND); // 关闭混合 glEnable(GL_DEPTH_TEST); glEnable(GL_LIGHTING); // 开启光照 glLightfv(GL_LIGHT1, GL_POSITION, LightPosition); // 设置光源1位置 glBindTexture(GL_TEXTURE_2D, texture[1]); // 太阳纹理 // 将坐标系绕Y轴旋转fSunSpin角度,控制太阳自转 glRotatef(fSunSpin,0.0,1.0,0.0); gluSphere(quadric, 0.3f, 32, 32); // 绘制太阳球体 /**********************************绘制水星************************************************/ glDisable(GL_LIGHT0); glEnable(GL_TEXTURE_2D ); // 开启纹理 glPushMatrix (); // 当前模型视图矩阵入栈 // 将坐标系绕Y轴旋转fMercuOrbit角度,控制水星公转 glRotatef(fMercuOrbit, 0.0f, 1.0f, 0.0f); glRotatef(-90.0f, 1.0f, 0.0f, 0.0f); // 将坐标系绕X轴旋转-90度 glTranslatef(0.5f, 0.0f, 0.0f); // 将坐标系右移0.5f glBindTexture(GL_TEXTURE_2D, texture[3]); // 水星纹理 // 将坐标系绕Z轴旋转fMercuSpin角度 控制水星自转 glRotatef(fMercuSpin , 0.0f, 0.0f, 1.0f); gluSphere(quadric, 0.04f, 32, 32); // 水星球体 glPopMatrix (); // 当前模型视图矩阵出栈 // 绘制轨道 glBegin(GL_LINE_LOOP); for(angle=0;angle<=360;angle++) glVertex3f(0.5f*sin(DEG_TO_RAD*angle),0,0.5f*cos(DEG_TO_RAD*angle)); glEnd(); /**********************************绘制金星************************************************/ glDisable(GL_LIGHT0); glEnable(GL_TEXTURE_2D ); // 开启纹理 glPushMatrix (); // 当前模型视图矩阵入栈 // 将坐标系绕Y轴旋转fVenusOrbit角度,控制金星公转 glRotatef(fVenusOrbit , 0.0f, 1.0f, 0.0f); glRotatef(-90.0f, 1.0f, 0.0f, 0.0f);// 将坐标系绕X轴旋转-90度 glTranslatef(0.8f, 0.0f, 0.0f); // 将坐标系右移0.8f glBindTexture(GL_TEXTURE_2D, texture[4]); // 金星纹理 // 将坐标系绕Z轴旋转fVenusSpin角度,控制金星自转 glRotatef(fVenusSpin , 0.0f, 0.0f, 1.0f); gluSphere(quadric, 0.06f, 32, 32); // 金星球体 glPopMatrix (); glBegin(GL_LINE_LOOP); for(angle=0;angle<=360;angle++) glVertex3f(0.8f*sin(DEG_TO_RAD*angle),0,0.8f*cos(DEG_TO_RAD*angle)); glEnd(); /**********************************绘制地球************************************************/ glDisable(GL_LIGHT0); glEnable(GL_TEXTURE_2D ); // 开启纹理 glPushMatrix (); // 当前模型视图矩阵入栈 // 将坐标系绕Y轴旋转fEarthOrbit角度,控制地球公转 glRotatef(fEarthOrbit , 0.0f, 1.0f, 0.0f); glRotatef(-90.0f, 1.0f, 0.0f, 0.0f);// 将坐标系绕X轴旋转-90度 glTranslatef(1.1f, 0.0f, 0.0f); // 将坐标系右移1.1f glBindTexture(GL_TEXTURE_2D, texture[5]); // 地球纹理 // 将坐标系绕Z轴旋转fEarthSpin角度,控制地球自转 glRotatef(fEarthSpin , 0.0f, 0.0f, 1.0f); gluSphere(quadric, 0.08f, 32, 32); // 地球球体 glPopMatrix (); glBegin(GL_LINE_LOOP); for(angle=0;angle<=360;angle++) glVertex3f(1.1f*sin(DEG_TO_RAD*angle),0,1.1f*cos(DEG_TO_RAD*angle)); glEnd(); /**********************************绘制火星************************************************/ glDisable(GL_LIGHT0); glEnable(GL_TEXTURE_2D ); // 开启纹理 glPushMatrix (); // 当前模型视图矩阵入栈 // 将坐标系绕Y轴旋转fMarsOrbit角度,控制火星公转 glRotatef(fMarsOrbit , 0.0f, 1.0f, 0.0f); glRotatef(-90.0f, 1.0f, 0.0f, 0.0f); // 将坐标系绕X轴旋转-90度 glTranslatef(1.4f, 0.0f, 0.0f); // 将坐标系右移1.4f glBindTexture(GL_TEXTURE_2D, texture[6]); // 火星纹理 // 将坐标系绕Z轴旋转fMarsSpin角度,控制火星自转 glRotatef(fMarsSpin , 0.0f, 0.0f, 1.0f); gluSphere(quadric, 0.04f, 32, 32); // 火星球体 glPopMatrix (); glBegin(GL_LINE_LOOP); for(angle=0;angle<=360;angle++) glVertex3f(1.4f*sin(DEG_TO_RAD*angle),0,1.4f*cos(DEG_TO_RAD*angle)); glEnd(); /**********************************绘制木星************************************************/ glDisable(GL_LIGHT0); glEnable(GL_TEXTURE_2D ); // 开启纹理 glPushMatrix (); // 当前模型视图矩阵入栈 // 将坐标系绕Y轴旋转fJupiterOrbit角度,控制木星公转 glRotatef(fJupiterOrbit , 0.0f, 1.0f, 0.0f); glRotatef(-90.0f, 1.0f, 0.0f, 0.0f); // 将坐标系绕X轴旋转-90度 glTranslatef(1.7f, 0.0f, 0.0f); // 将坐标系右移1.7f glBindTexture(GL_TEXTURE_2D, texture[7]); // 木星纹理 // 将坐标系绕Z轴旋转fJupiterSpin角度,控制木星自转 glRotatef(fJupiterSpin , 0.0f, 0.0f, 1.0f); gluSphere(quadric, 0.13f, 32, 32); // 木星球体 glPopMatrix (); glBegin(GL_LINE_LOOP); for(angle=0;angle<=360;angle++) glVertex3f(1.7f*sin(DEG_TO_RAD*angle),0,1.7f*cos(DEG_TO_RAD*angle)); glEnd(); /**********************************绘制土星************************************************/ glDisable(GL_LIGHT0); glEnable(GL_TEXTURE_2D ); // 开启纹理 glPushMatrix (); // 当前模型视图矩阵入栈 // 将坐标系绕Y轴旋转fSaturnOrbit角度,控制土星公转 glRotatef(fSaturnOrbit , 0.0f, 1.0f, 0.0f); glRotatef(-90.0f, 1.0f, 0.0f, 0.0f); // 将坐标系绕X轴旋转-90度 glTranslatef(1.9f, 0.0f, 0.0f); // 将坐标系右移1.9f glBindTexture(GL_TEXTURE_2D, texture[8]); // 土星纹理 // 将坐标系绕Z轴旋转fSaturnSpin角度,控制土星自转 glRotatef(fSaturnSpin , 0.0f, 0.0f, 1.0f); gluSphere(quadric, 0.1f, 32, 32); // 土星球体 glPopMatrix (); glBegin(GL_LINE_LOOP); for(angle=0;angle<=360;angle++) glVertex3f(1.9f*sin(DEG_TO_RAD*angle),0,1.9f*cos(DEG_TO_RAD*angle)); glEnd(); /**********************************绘制天王星**********************************************/ glDisable(GL_LIGHT0); glEnable(GL_TEXTURE_2D ); // 开启纹理 glPushMatrix (); // 当前模型视图矩阵入栈 // 将坐标系绕Y轴旋转fUranusOrbit角度,控制天王星公转 glRotatef(fUranusOrbit , 0.0f, 1.0f, 0.0f); glRotatef(-90.0f, 1.0f, 0.0f, 0.0f); // 将坐标系绕X轴旋转-90度 glTranslatef(2.1f, 0.0f, 0.0f); // 将坐标系右移2.1f glBindTexture(GL_TEXTURE_2D, texture[9]); // 天王星纹理 // 将坐标系绕Z轴旋转fUranusSpin角度,控制天王星自转 glRotatef(fUranusSpin , 0.0f, 0.0f, 1.0f); gluSphere(quadric, 0.1f, 32, 32); // 天王星球体 glPopMatrix (); glBegin(GL_LINE_LOOP); for(angle=0;angle<=360;angle++) glVertex3f(2.1f*sin(DEG_TO_RAD*angle),0,2.1f*cos(DEG_TO_RAD*angle)); glEnd(); /**********************************绘制海王星**********************************************/ glDisable(GL_LIGHT0); glEnable(GL_TEXTURE_2D ); // 开启纹理 glPushMatrix (); // 当前模型视图矩阵入栈 // 将坐标系绕Y轴旋转fNeptuneOrbit角度,控制海王星公转 glRotatef(fNeptuneOrbit , 0.0f, 1.0f, 0.0f); glRotatef(-90.0f, 1.0f, 0.0f, 0.0f); // 将坐标系绕X轴旋转-90度 glTranslatef(2.3f, 0.0f, 0.0f); // 将坐标系右移2.3f glBindTexture(GL_TEXTURE_2D, texture[10]); // 海王星纹理 // 将坐标系绕Z轴旋转fNeptuneSpin角度,控制海王星自转 glRotatef(fNeptuneSpin , 0.0f, 0.0f, 1.0f); gluSphere(quadric, 0.08f, 32, 32); // 海王星球体 glPopMatrix (); glBegin(GL_LINE_LOOP); for(angle=0;angle<=360;angle++) glVertex3f(2.3f*sin(DEG_TO_RAD*angle),0,2.3f*cos(DEG_TO_RAD*angle)); glEnd(); /**********************************绘制月亮************************************************/ glDisable(GL_LIGHT0); glEnable(GL_TEXTURE_2D ); // glBindTexture(GL_TEXTURE_2D, texture[11]); // 月亮纹理 glPushMatrix (); // 将坐标系绕Y轴旋转fEarthOrbit角度,控制月亮跟随地球 glRotatef(fEarthOrbit , 0.0f, 1.0f, 0.0f); glTranslatef(1.1f, 0.0f, 0.0f); // 将坐标系右移1.1f // 将坐标系绕Y轴旋转fMoonOrbit角度,控制月亮公转 glRotatef(fMoonOrbit , 0.0f, 1.0f, 0.0f); glTranslatef(0.15f, 0.0f, 0.0f); // 将坐标系绕Y轴旋转fMoonSpin角度,控制月亮自转 glBindTexture(GL_TEXTURE_2D, texture[11]); glRotatef(fMoonSpin , 0.0f, 1.0f, 0.0f); gluSphere(quadric, 0.02, 32, 32); // 月亮球体 glPopMatrix (); // 控制各星球转动的速度 if( g_bOrbitOn == true ) { fSunSpin -= g_fSpeedmodifier * (g_fElpasedTime * 10.0f); fMercuSpin -= g_fSpeedmodifier * (g_fElpasedTime * 15.0f); fMercuOrbit -= g_fSpeedmodifier * (g_fElpasedTime * 40.0f); fVenusSpin -= g_fSpeedmodifier * (g_fElpasedTime * 10.0f); fVenusOrbit -= g_fSpeedmodifier * (g_fElpasedTime * 30.0f); fEarthSpin -= g_fSpeedmodifier * (g_fElpasedTime * 100.0f); fEarthOrbit -= g_fSpeedmodifier * (g_fElpasedTime * 20.0f); fMarsSpin -= g_fSpeedmodifier * (g_fElpasedTime * 30.0f); fMarsOrbit -= g_fSpeedmodifier * (g_fElpasedTime * 50.0f); fJupiterSpin -= g_fSpeedmodifier * (g_fElpasedTime * 90.0f); fJupiterOrbit -= g_fSpeedmodifier * (g_fElpasedTime * 35.0f); fSaturnSpin -= g_fSpeedmodifier * (g_fElpasedTime * 90.0f); fSaturnOrbit -= g_fSpeedmodifier * (g_fElpasedTime * 25.0f); fUranusSpin -= g_fSpeedmodifier * (g_fElpasedTime * 70.0f); fUranusOrbit -= g_fSpeedmodifier * (g_fElpasedTime * 15.0f); fNeptuneSpin -= g_fSpeedmodifier * (g_fElpasedTime * 40.0f); fNeptuneOrbit -= g_fSpeedmodifier * (g_fElpasedTime * 5.0f); fMoonSpin -= g_fSpeedmodifier * (g_fElpasedTime * 50.0f); fMoonOrbit -= g_fSpeedmodifier * (g_fElpasedTime * 200.0f); } angle_Z += 0.01f; // 星空旋转 glutSwapBuffers(); // 交换双缓存 glFlush(); } void Reshape(int width, int height) { if (height==0) height=1; // 改变窗口 glViewport(0,0,width,height); // 设置视口 // 设置投影矩阵 glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,0.1f,100.0f); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); gluLookAt(viewer[0],viewer[1],viewer[2],viewer[3],viewer[4],-5,0,1,0); } void keyboard(unsigned char key, int x, int y) { switch(key) { case 'r': case 'R': // 视点上下左右移动 if(viewer[0]=-6.0) viewer[0]-=0.5; break; case 'u': case 'U': if(viewer[1]=-6.0) viewer[1]-=0.1; break; case'+': case '=': // 加速,减速,暂停 g_fSpeedmodifier+=1.0f; glutPostRedisplay(); break; case ' ': g_bOrbitOn = !g_bOrbitOn; glutPostRedisplay(); break; case'-': //按'-'减小运行速度 g_fSpeedmodifier-=1.0f; glutPostRedisplay(); break; case VK_ESCAPE: // 按ESC键时退出 exit(0); break; default: break; } } void special_keys(int s_keys, int x, int y) { switch(s_keys) { case GLUT_KEY_F1: // 按F1键时切换窗口/全屏模式 if(isFullScreen) { glutReshapeWindow(WIN_WIDTH, WIN_HEIGHT); glutPositionWindow(30, 30); isFullScreen = FALSE; } else { glutFullScreen(); isFullScreen = TRUE; } break; case GLUT_KEY_RIGHT: // 视角上下左右旋转 if(viewer[3]=-3.0) viewer[3]-=0.1; break; case GLUT_KEY_UP: if(viewer[4]=-4.5) viewer[4]-=0.1; break; default: break; } } void mouse(int btn, int state, int x, int y) // 远近视角 { if(btn==GLUT_RIGHT_BUTTON && state == GLUT_DOWN) viewer[2]+=0.3; if(btn==GLUT_LEFT_BUTTON && state == GLUT_DOWN&&viewer;[2]>=-3.9) viewer[2]-=0.3; } void LoadBmp(char *filename, TEXTUREIMAGE *textureImg) // 载入图片 { int i, j; FILE *file; BMPFILEHEADER bmpFile; BMPINFOHEADER bmpInfo; int pixel_size; // 初始化纹理数据 textureImg->imgWidth = 0; textureImg->imgHeight = 0; if (textureImg->data != NULL) { delete []textureImg->data; } // 打开文件 file = fopen(filename, "rb"); if (file == NULL) { return; } // 获取文件头 rewind(file); fread(&bmpFile;, sizeof(BMPFILEHEADER), 1, file); fread(&bmpInfo;, sizeof(BMPINFOHEADER), 1, file); // 验证文件类型 if (bmpFile.bfType != 0x4D42) { return; } // 获取图像色彩数 pixel_size = bmpInfo.biBitCount >> 3; // 读取文件数据 textureImg->data = new unsigned char[bmpInfo.biWidth * bmpInfo.biHeight * pixel_size]; for(i = 0 ; i < bmpInfo.biHeight; i++) { fseek(file, bmpFile.bfOffBits + (bmpInfo.biHeight - i - 1) * bmpInfo.biWidth * pixel_size, SEEK_SET); for (j = 0; j data + (i * bmpInfo.biWidth + j) * pixel_size + 2, sizeof(unsigned char), 1, file); // 绿色分量 fread(textureImg->data + (i * bmpInfo.biWidth + j) * pixel_size + 1, sizeof(unsigned char), 1, file); // 蓝色分量 fread(textureImg->data + (i * bmpInfo.biWidth + j) * pixel_size + 0, sizeof(unsigned char), 1, file); // Alpha分量 if (pixel_size == 4) { fread(textureImg->data + (i * bmpInfo.biWidth + j) * pixel_size + 3, sizeof(unsigned char), 1, file); } } } // 记录图像相关参数 textureImg->imgWidth = bmpInfo.biWidth; textureImg->imgHeight = bmpInfo.biHeight; textureImg->byteCount = pixel_size; fclose(file); } // 程序主函数 void main(int argc, char** argv) { //读图片 LoadBmp("Picture//Sky.bmp" , &skyImg;); LoadBmp("Picture//Sun.bmp" , &sunImg;); LoadBmp("Picture//Ray.bmp" , &rayImg;); LoadBmp("Picture//Mercu.bmp" , &mercuImg;); LoadBmp("Picture//Venus.bmp" , &venusImg;); //金星 LoadBmp("Picture//Earth.bmp" , &earthImg;); LoadBmp("Picture//Mars.bmp" , &marsImg;); //火星 LoadBmp("Picture//Jupiter.bmp" , &jupiterImg;); //木星 LoadBmp("Picture//Saturn.bmp" , &saturnImg;); //土星 LoadBmp("Picture//Uranus.bmp" , &uranusImg;); //天王星 LoadBmp("Picture//Neptune.bmp" , &neptuneImg;); //海王星 LoadBmp("Picture//Moon.bmp" , &moonImg;); glutInit(&argc;, argv); // 初始化GLUT库 glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH); // 初始化显示模式 glutInitWindowSize(WIN_WIDTH, WIN_HEIGHT); // 初始化窗口大小 glutInitWindowPosition(20,20); // 初始化窗口位置 GLuint window = glutCreateWindow(WIN_TITLE); // 建立窗口 InitGL(); // 初始化OpenGL glutDisplayFunc(Display); glutReshapeFunc(Reshape); glutKeyboardFunc(keyboard); glutSpecialFunc(special_keys); glutMouseFunc(mouse); glutIdleFunc(Display); // 设置窗口空闲时的处理函数 glutMainLoop(); // 进入事件处理循环 }
android动画 行星,AndroidAnimation
weixin_28987735的博客
05-25 229
Android自定义View 星球运动在dribbble闲逛的时候发现的一个有意思的星球运动的动画,刚好最近时间尚可,就简单实现了一下中间运动的部分,又是因为时间的原因,开头位移的部分没有完成.这是在dribbble中发现的动画这是我自己实现的效果... 总觉得我这个星球有点胖... 因为胖所以转的慢么这是.速度等细节还有优化的余地设计过程老办法,先分解动画的构成.整个动画可以看做是一个自旋的...
Android UI系列之3D星体旋转效果
Tomes.V.White
07-13 3969
转载自：http://blog.csdn.net/johnwcheung/article/details/52496652 在Android中，如果想要实现3D动画效果一般有两种选择：一是使用Open GL ES，二是使用Camera。Open GL ES使用起来太过复杂，一般是用于比较高级的3D特效或游戏，并且这个也不是开源的，像比较简单的一些3D效果，使用Camera就足够了。
Android 漂浮类动效的分析与实现！
热门推荐
GAStudio
04-22 1万+
上一篇只讲了Canvas中的drawBitmap方法，并且还说的这个方法好像很腻害、能做出很多牛逼效果的样子，接下来这篇文章只是为了作为上一篇文章的一个小栗子，进一步拓展大家利用drawBitmap 完成动效的思路！ 好了，先上失真的不能再失真的效果图： 咱们先一起来分析下上面的效果： 假定这是你刚从UE 或动效射鸡湿手里拿到上面的动效设计图，映入眼帘的是苍茫的星空，漂浮的星球营造出的深邃、浩瀚的宇宙，好了，不多BB了，针对上图你会想到什么样的实现方案？ 1. 有些同学可能会想到创建对应数量个ImageVi
Android实现SoulApp星球效果
u012582497的博客
05-20 8035
SoulApp的星球看起来太炫酷了！！！ 啥也不说先上图： Github传送门 biu biu biu ~~~ 基础知识 首先得拿出我们的数学知识： 球坐标系(r,θ,φ)与直角坐标系(x,y,z)的转换关系: x = rsinθcosφ. y = rsinθsinφ. z = rcosθ. Q：What！为什么要整个球坐标系啊？ A：因为星球嘛，位置信息当然球坐标系更加简单额。 实现...
Android 贝塞尔 星球 星际 旋转动画
用技术改变世界
07-29 1384
效果 三个星球，ABC。 当点击星球B ，则B星球逆时针旋转到A星球的位置，A星球旋转到C星球的位置，C星球旋转到B星球的位置。 如果点击的是C星球，则顺时针旋转。 此动画涉及到ObjectAnimator动画，贝塞尔曲线，路径path等技术点。 下面说说逻辑： 一、首先确定三个星球的坐标，分别A(aX, aY), B(bX, By), C(cX, cY) 二、了解贝...
Android Opengl ES2.0 -实现小行星显示效果并可触摸控制
NoMmmMoN的博客
04-30 1524
本示例是通过sharder实现的平面小行星效果。带触摸控制旋转，其中触摸控制旋转使用旋转矩阵的方式计算。小行星的sharder是从国外某论坛找到的，没有深入研究实现方式。附旋转矩阵计算公式：double alaph_x = x * PI / 180; double theta_y = y * PI / 180; double phi_z = z * PI / 180; double Sx =
windows10使用bat脚本安装前后端环境之msyql5.7安装配置并重置用户密码
最新发布
风吹淡了悲伤
09-27 333
mysql-user-init.sql：重置root密码（并新增zhangsan用户授予权限）adserver-simple.sql：创建数据库sql脚本。5.启动并修改root密码（新增用户初始化授予权限）2.新增data文件夹与my.ini配置文件。1.下载mysql5.7 zip格式安装包。4.安装mysql windows服务。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值