opengles繪製可旋轉的球體

阿新 • • 發佈：2019-01-20

球體繪製類

package test.com.opengles6_1;

import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;
import java.util.ArrayList;
import android.annotation.SuppressLint;
import android.annotation.TargetApi;
import android.opengl.GLES20;
import android.os.Build;


/**
 *
 */

@SuppressLint("NewApi")
public class Ball {
	int mProgram;// 自定義渲染管線著色器程式id
	int muMVPMatrixHandle;// 總變換矩陣引用
	int maPositionHandle; // 頂點位置屬性引用
	int muRHandle;// 球的半徑屬性引用
	String mVertexShader;// 頂點著色器
	String mFragmentShader;// 片元著色器

	FloatBuffer mVertexBuffer;// 頂點座標資料緩衝
	int vCount = 0;
	float yAngle = 0;// 繞y軸旋轉的角度
	float xAngle = 0;// 繞x軸旋轉的角度
	float zAngle = 0;// 繞z軸旋轉的角度
	float r = 0.8f;
	public Ball(MySurfaceView mv) {
		// 初始化頂點座標與著色資料
		initVertexData();
		// 初始化shader
		initShader(mv);
	}

	// 初始化頂點座標資料的方法
	public void initVertexData() {
		// 頂點座標資料的初始化================begin============================
		/**
		 * 原理見   http://www.tuicool.com/articles/Qjm6bmy

<span style="white-space:pre">			</span>

<span style="white-space:pre">			http://blog.csdn.net/majing19921103/article/details/45017547</span>
		 */
		ArrayList<Float> alVertix = new ArrayList<Float>();// 存放頂點座標的ArrayList
		final int angleSpan = 2;// 將球進行單位切分的角度
		for (int vAngle = -90; vAngle < 90; vAngle = vAngle + angleSpan)// 垂直方向angleSpan度一份
		{
			for (int hAngle = 0; hAngle <= 360; hAngle = hAngle + angleSpan)// 水平方向angleSpan度一份
			{// 縱向橫向各到一個角度後計算對應的此點在球面上的座標
				float x0 = (float) (r * Constant.UNIT_SIZE
						* Math.cos(Math.toRadians(vAngle)) * Math.cos(Math
						.toRadians(hAngle)));
				float y0 = (float) (r * Constant.UNIT_SIZE
						* Math.cos(Math.toRadians(vAngle)) * Math.sin(Math
						.toRadians(hAngle)));
				float z0 = (float) (r * Constant.UNIT_SIZE * Math.sin(Math
						.toRadians(vAngle)));

				float x1 = (float) (r * Constant.UNIT_SIZE
						* Math.cos(Math.toRadians(vAngle)) * Math.cos(Math
						.toRadians(hAngle + angleSpan)));
				float y1 = (float) (r * Constant.UNIT_SIZE
						* Math.cos(Math.toRadians(vAngle)) * Math.sin(Math
						.toRadians(hAngle + angleSpan)));
				float z1 = (float) (r * Constant.UNIT_SIZE * Math.sin(Math
						.toRadians(vAngle)));

				float x2 = (float) (r * Constant.UNIT_SIZE
						* Math.cos(Math.toRadians(vAngle + angleSpan)) * Math
						.cos(Math.toRadians(hAngle + angleSpan)));
				float y2 = (float) (r * Constant.UNIT_SIZE
						* Math.cos(Math.toRadians(vAngle + angleSpan)) * Math
						.sin(Math.toRadians(hAngle + angleSpan)));
				float z2 = (float) (r * Constant.UNIT_SIZE * Math.sin(Math
						.toRadians(vAngle + angleSpan)));

				float x3 = (float) (r * Constant.UNIT_SIZE
						* Math.cos(Math.toRadians(vAngle + angleSpan)) * Math
						.cos(Math.toRadians(hAngle)));
				float y3 = (float) (r * Constant.UNIT_SIZE
						* Math.cos(Math.toRadians(vAngle + angleSpan)) * Math
						.sin(Math.toRadians(hAngle)));
				float z3 = (float) (r * Constant.UNIT_SIZE * Math.sin(Math
						.toRadians(vAngle + angleSpan)));

				// 將計算出來的XYZ座標加入存放頂點座標的ArrayList

<span style="white-space:pre">				</span>//兩個三角形構成一個四邊形 ，也就是兩條經線和兩條緯線相交構成的四邊形
				alVertix.add(x1);
				alVertix.add(y1);
				alVertix.add(z1);

				alVertix.add(x3);
				alVertix.add(y3);
				alVertix.add(z3);

				alVertix.add(x0);
				alVertix.add(y0);
				alVertix.add(z0);

				alVertix.add(x1);
				alVertix.add(y1);
				alVertix.add(z1);

				alVertix.add(x2);
				alVertix.add(y2);
				alVertix.add(z2);

				alVertix.add(x3);
				alVertix.add(y3);
				alVertix.add(z3);
			}
		}
		vCount = alVertix.size() / 3;// 頂點的數量為座標值數量的1/3，因為一個頂點有3個座標

		// 將alVertix中的座標值轉存到一個float陣列中
		float vertices[] = new float[vCount * 3];
		for (int i = 0; i < alVertix.size(); i++) {
			vertices[i] = alVertix.get(i);
		}

		// 建立頂點座標資料緩衝
		// vertices.length*4是因為一個整數四個位元組
		ByteBuffer vbb = ByteBuffer.allocateDirect(vertices.length * 4);
		vbb.order(ByteOrder.nativeOrder());// 設定位元組順序
		mVertexBuffer = vbb.asFloatBuffer();// 轉換為int型緩衝
		mVertexBuffer.put(vertices);// 向緩衝區中放入頂點座標資料
		mVertexBuffer.position(0);// 設定緩衝區起始位置
		// 特別提示：由於不同平臺位元組順序不同資料單元不是位元組的一定要經過ByteBuffer
		// 轉換，關鍵是要通過ByteOrder設定nativeOrder()，否則有可能會出問題
	}

	// 初始化shader
	public void initShader(MySurfaceView mv) {
		// 載入頂點著色器的指令碼內容
		mVertexShader = ShaderUtil.loadFromAssetsFile("vertex.sh",
				mv.getResources());
		// 載入片元著色器的指令碼內容
		mFragmentShader = ShaderUtil.loadFromAssetsFile("frag.sh",
				mv.getResources());
		// 基於頂點著色器與片元著色器建立程式
		mProgram = ShaderUtil.createProgram(mVertexShader, mFragmentShader);
		// 獲取程式中頂點位置屬性引用
		maPositionHandle = GLES20.glGetAttribLocation(mProgram, "aPosition");
		// 獲取程式中總變換矩陣引用
		muMVPMatrixHandle = GLES20.glGetUniformLocation(mProgram, "uMVPMatrix");
		// 獲取程式中球半徑引用
		muRHandle = GLES20.glGetUniformLocation(mProgram, "uR");
	}

	@TargetApi(Build.VERSION_CODES.FROYO)
	@SuppressLint("NewApi")
	public void drawSelf() {

		MatrixState.rotate(xAngle, 1, 0, 0);//繞X軸轉動
		MatrixState.rotate(yAngle, 0, 1, 0);//繞Y軸轉動
		MatrixState.rotate(zAngle, 0, 0, 1);//繞Z軸轉動
		// 制定使用某套shader程式
		GLES20.glUseProgram(mProgram);
		// 將最終變換矩陣傳入shader程式
		GLES20.glUniformMatrix4fv(muMVPMatrixHandle, 1, false,
				MatrixState.getFinalMatrix(), 0);
		// 將半徑尺寸傳入shader程式
		GLES20.glUniform1f(muRHandle, r * Constant.UNIT_SIZE);
		// 為畫筆指定頂點位置資料
		GLES20.glVertexAttribPointer(maPositionHandle, 3, GLES20.GL_FLOAT,
				false, 3 * 4, mVertexBuffer);
		// 允許頂點位置資料陣列
		GLES20.glEnableVertexAttribArray(maPositionHandle);
		// 繪製球
		GLES20.glDrawArrays(GLES20.GL_TRIANGLES, 0, vCount);
	}
}

矩陣變換類

package test.com.opengles6_1;
import java.nio.ByteBuffer;
import android.opengl.Matrix;

//儲存系統矩陣狀態的類
public class MatrixState
{
	private static float[] mProjMatrix = new float[16];//4x4矩陣 投影用
	private static float[] mVMatrix = new float[16];//攝像機位置朝向9引數矩陣
	private static float[] currMatrix;//當前變換矩陣

	//保護變換矩陣的棧
	static float[][] mStack=new float[10][16];
	static int stackTop=-1;

	public static void setInitStack()//獲取不變換初始矩陣
	{
		currMatrix=new float[16];
		Matrix.setRotateM(currMatrix, 0, 0, 1, 0, 0);
	}

	public static void pushMatrix()//保護變換矩陣
	{
		stackTop++;
		for(int i=0;i<16;i++)
		{
			mStack[stackTop][i]=currMatrix[i];
		}
	}

	public static void popMatrix()//恢復變換矩陣
	{
		for(int i=0;i<16;i++)
		{
			currMatrix[i]=mStack[stackTop][i];
		}
		stackTop--;
	}

	public static void translate(float x,float y,float z)//設定沿xyz軸移動
	{
		Matrix.translateM(currMatrix, 0, x, y, z);
	}

	public static void rotate(float angle,float x,float y,float z)//設定繞xyz軸移動
	{
		Matrix.rotateM(currMatrix,0,angle,x,y,z);
	}


	//設定攝像機
	static ByteBuffer llbb= ByteBuffer.allocateDirect(3*4);
	static float[] cameraLocation=new float[3];//攝像機位置
	public static void setCamera
			(
					float cx,	//攝像機位置x
					float cy,   //攝像機位置y
					float cz,   //攝像機位置z
					float tx,   //攝像機目標點x
					float ty,   //攝像機目標點y
					float tz,   //攝像機目標點z
					float upx,  //攝像機UP向量X分量
					float upy,  //攝像機UP向量Y分量
					float upz   //攝像機UP向量Z分量
			)
	{
		Matrix.setLookAtM
				(
						mVMatrix,
						0,
						cx,
						cy,
						cz,
						tx,
						ty,
						tz,
						upx,
						upy,
						upz
				);
	}

	//設定透視投影引數
	public static void setProjectFrustum
	(
			float left,		//near面的left
			float right,    //near面的right
			float bottom,   //near面的bottom
			float top,      //near面的top
			float near,		//near面距離
			float far       //far面距離
	)
	{
		Matrix.frustumM(mProjMatrix, 0, left, right, bottom, top, near, far);
	}

	//設定正交投影引數
	public static void setProjectOrtho
	(
			float left,		//near面的left
			float right,    //near面的right
			float bottom,   //near面的bottom
			float top,      //near面的top
			float near,		//near面距離
			float far       //far面距離
	)
	{
		Matrix.orthoM(mProjMatrix, 0, left, right, bottom, top, near, far);
	}

	//獲取具體物體的總變換矩陣
	static float[] mMVPMatrix=new float[16];
	public static float[] getFinalMatrix()
	{
		Matrix.multiplyMM(mMVPMatrix, 0, mVMatrix, 0, currMatrix, 0);
		Matrix.multiplyMM(mMVPMatrix, 0, mProjMatrix, 0, mMVPMatrix, 0);
		return mMVPMatrix;
	}

	//獲取具體物體的變換矩陣
	public static float[] getMMatrix()
	{
		return currMatrix;
	}
}

//surfaceview

package test.com.opengles6_1;

import android.content.Context;
import android.opengl.GLES20;
import android.opengl.GLSurfaceView;
import android.view.MotionEvent;

import javax.microedition.khronos.opengles.GL10;
import javax.microedition.khronos.egl.EGLConfig;

class MySurfaceView extends GLSurfaceView
{
    private final float TOUCH_SCALE_FACTOR = 180.0f/320;//角度縮放比例
    private SceneRenderer mRenderer;//場景渲染器
    Ball ball;//球

    private float mPreviousY;//上次的觸控位置Y座標
    private float mPreviousX;//上次的觸控位置X座標
    public MySurfaceView(Context context) {
        super(context);
        this.setEGLContextClientVersion(2); //設定使用OPENGL ES2.0
        mRenderer = new SceneRenderer();	//建立場景渲染器
        setRenderer(mRenderer);				//設定渲染器
        setRenderMode(GLSurfaceView.RENDERMODE_CONTINUOUSLY);//設定渲染模式為主動渲染
    }
    //觸控事件回撥方法
    @Override
    public boolean onTouchEvent(MotionEvent e) {
        float y = e.getY();
        float x = e.getX();
        switch (e.getAction()) {
            case MotionEvent.ACTION_MOVE:
                float dy = y - mPreviousY;//計算觸控筆Y位移
                float dx = x - mPreviousX;//計算觸控筆X位移
                ball.yAngle += dx * TOUCH_SCALE_FACTOR;//設定填充橢圓繞y軸旋轉的角度
                ball.xAngle+= dy * TOUCH_SCALE_FACTOR;//設定填充橢圓繞x軸旋轉的角度
        }
        mPreviousY = y;//記錄觸控筆位置
        mPreviousX = x;//記錄觸控筆位置
        return true;
    }
    private class SceneRenderer implements GLSurfaceView.Renderer
    {

        public void onDrawFrame(GL10 gl)
        {
            //清除深度緩衝與顏色緩衝
            GLES20.glClear(GLES20.GL_DEPTH_BUFFER_BIT | GLES20.GL_COLOR_BUFFER_BIT);
            //保護現場
            MatrixState.pushMatrix();
            //繪製球
            MatrixState.pushMatrix();
            ball.drawSelf();
            MatrixState.popMatrix();
            //恢復現場
            MatrixState.popMatrix();
        }

        public void onSurfaceChanged(GL10 gl, int width, int height) {
            //設定視窗大小及位置
            GLES20.glViewport(0, 0, width, height);
            //計算GLSurfaceView的寬高比
            Constant.ratio = (float) width / height;
            // 呼叫此方法計算產生透視投影矩陣
            MatrixState.setProjectFrustum(-Constant.ratio, Constant.ratio, -1, 1, 20, 100);
            // 呼叫此方法產生攝像機9引數位置矩陣
            MatrixState.setCamera(0, 0, 30, 0f, 0f, 0f, 0f, 1.0f, 0.0f);

            //初始化變換矩陣
            MatrixState.setInitStack();
        }

        public void onSurfaceCreated(GL10 gl, EGLConfig config) {
            //設定螢幕背景色RGBA
            GLES20.glClearColor(0f,0f,0f, 1.0f);
            //建立球物件
            ball=new Ball(MySurfaceView.this);
            //開啟深度檢測
            GLES20.glEnable(GLES20.GL_DEPTH_TEST);
            //開啟背面剪裁
            GLES20.glEnable(GLES20.GL_CULL_FACE);
        }
    }
}

//著色語言載入類

package test.com.opengles6_1;

import java.io.ByteArrayOutputStream;
import java.io.InputStream;

import android.content.res.Resources;
import android.opengl.GLES20;
import android.util.Log;

//載入頂點Shader與片元Shader的工具類
public class ShaderUtil 
{
    //載入制定shader的方法
    public static int loadShader
    (
            int shaderType, //shader的型別  GLES20.GL_VERTEX_SHADER   GLES20.GL_FRAGMENT_SHADER
            String source   //shader的指令碼字串
    )
    {
        //建立一個新shader
        int shader = GLES20.glCreateShader(shaderType);
        //若建立成功則載入shader
        if (shader != 0)
        {
            //載入shader的原始碼
            GLES20.glShaderSource(shader, source);
            //編譯shader
            GLES20.glCompileShader(shader);
            //存放編譯成功shader數量的陣列
            int[] compiled = new int[1];
            //獲取Shader的編譯情況
            GLES20.glGetShaderiv(shader, GLES20.GL_COMPILE_STATUS, compiled, 0);
            if (compiled[0] == 0)
            {//若編譯失敗則顯示錯誤日誌並刪除此shader
                Log.e("ES20_ERROR", "Could not compile shader " + shaderType + ":");
                Log.e("ES20_ERROR", GLES20.glGetShaderInfoLog(shader));
                GLES20.glDeleteShader(shader);
                shader = 0;
            }
        }
        return shader;
    }

    //建立shader程式的方法
    public static int createProgram(String vertexSource, String fragmentSource)
    {
        //載入頂點著色器
        int vertexShader = loadShader(GLES20.GL_VERTEX_SHADER, vertexSource);
        if (vertexShader == 0)
        {
            return 0;
        }

        //載入片元著色器
        int pixelShader = loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentSource);
        if (pixelShader == 0)
        {
            return 0;
        }

        //建立程式
        int program = GLES20.glCreateProgram();
        //若程式建立成功則向程式中加入頂點著色器與片元著色器
        if (program != 0)
        {
            //向程式中加入頂點著色器
            GLES20.glAttachShader(program, vertexShader);
            checkGlError("glAttachShader");
            //向程式中加入片元著色器
            GLES20.glAttachShader(program, pixelShader);
            checkGlError("glAttachShader");
            //連結程式
            GLES20.glLinkProgram(program);
            //存放連結成功program數量的陣列
            int[] linkStatus = new int[1];
            //獲取program的連結情況
            GLES20.glGetProgramiv(program, GLES20.GL_LINK_STATUS, linkStatus, 0);
            //若連結失敗則報錯並刪除程式
            if (linkStatus[0] != GLES20.GL_TRUE)
            {
                Log.e("ES20_ERROR", "Could not link program: ");
                Log.e("ES20_ERROR", GLES20.glGetProgramInfoLog(program));
                GLES20.glDeleteProgram(program);
                program = 0;
            }
        }
        return program;
    }

    //檢查每一步操作是否有錯誤的方法
    public static void checkGlError(String op)
    {
        int error;
        while ((error = GLES20.glGetError()) != GLES20.GL_NO_ERROR)
        {
            Log.e("ES20_ERROR", op + ": glError " + error);
            throw new RuntimeException(op + ": glError " + error);
        }
    }

    //從sh指令碼中載入shader內容的方法
    public static String loadFromAssetsFile(String fname,Resources r)
    {
        String result=null;
        try
        {
            InputStream in=r.getAssets().open(fname);
            int ch=0;
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            while((ch=in.read())!=-1)
            {
                baos.write(ch);
            }
            byte[] buff=baos.toByteArray();
            baos.close();
            in.close();
            result=new String(buff,"UTF-8");
            result=result.replaceAll("\\r\\n","\n");
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
        return result;
    }
}

</pre><pre name="code" class="java">

效果圖

//專案下載地址

http://download.csdn.net/detail/hb707934728/9597955

opengles繪製可旋轉的球體

球體繪製類 package test.com.opengles6_1; import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.nio.FloatBuffer; import java.uti

C#OpenGL(SharpGL)繪製可旋轉長方體

全域性欄位： // X軸座標 private float _x = 0; // Y軸座標 private float _y = 0; //Z軸座標 private float _z = 0;

OpenGL——點的繪製(使用OpenGL來繪製可旋轉座標系的螺旋線)

package com.example.opengl1; import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.nio.FloatBuffer; import javax.microedi

QT中給各控件增加背景圖片(可縮放可旋轉)的幾種方法

.net detail eight iou rotate art board 按鈕 previous 1. 給QPushButton 增加背景圖片：背景圖片可根據Button大小自由縮放。 [cpp] view plain copy vo

Canvas實現3D效果-可旋轉的立方體

獲得操作陰影換算 http 取出 main TP 變換摘要：Canvas畫布是一個二維平面，如何展示出3D效果？通過將三維空間中的Z軸抽取出來，將圖像的點投影到與Z軸垂直的平面上，在通過旋轉等變換效果，我們就能實現3D效果。一、建立坐標系 1）立方體坐標系

【Unity3D BezierCurve繪製曲線】動態新增路徑點繪製可調節曲線（三維空間）

近日，專案需求：前提：三維空間 1.動態新增（刪除）路徑點，通過兩個以上的路徑點來繪製曲線，刪除點之後不影響其他點繪製曲線； 2.每個路徑點都可以被拖拽發生位移，可以通過鎖定某個軸，使該軸不發生位移； 3.每個路徑點處有兩個可調節點（首尾只有一個調節點），可通過調節點來調節曲線切線（

在螢幕繪製一個旋轉的線框立方體（使用頂點快取和索引快取）

首先裡面還是有兩個基本的檔案：d3dUtility.h以及d3dUtility.cpp 裡面的主要內容就是實現Direct3D的初始化，以及模板函式的的實現，和訊息迴圈函式的宣告，回撥函式的宣告。具體的解釋在部落格：在螢幕繪製一個三角形以及Direct3D初始化例程中有詳細的解釋，這裡

iOS Tabbar中間新增凸起可旋轉按鈕

前言最近的專案中有需求在tabbar中間新增凸起按鈕，並且點選時按鈕要旋轉，看了仿閒魚的凸起，點選後是present出來View，而不是像常規的tabbar上新增一個頁面(親測，閒魚的超出Tabbar部分點選是沒有反應的，這是bug啊，下文對這個問題有詳解)，所以不符合要求，經過一段摸索最後得的一個

如何快速繪製三維球體呢？

如何快速繪製三維球體呢？我們在CAD繪圖設計工作中，常常會用需要繪製各種各樣的CAD圖形，通常情況下我們都是一點一點練習繪製。但是有時候我們需要繪製各種各樣繁瑣複雜的CAD三維圖形。這時候該如何快速繪製呢？今天小編就為大家演示一下，如何快速繪製三維球體圖形。具體演示步驟如下：步驟一：首先，我們先在電腦端下

canvas繪製可控制的行走的小人

素材img 程式碼 var Person = function (ctx) { /*繪製工具*/ this.ctx = ctx || document.querySelector('canvas').getContext('2d');

使用CAD編輯器快速繪製三維球體

使用迅捷CAD編輯器快速繪製三維球體。我們都知道CAD繪圖設計都是先從簡單的圖形開始，一點一點練習繪製的，正所謂熟能生巧。在日常的CAD繪圖工作中，我們常常需要繪製各種各樣不同的CAD圖形，其中就包括繪製三維球體。那麼如何快速繪製一個三維球體呢？具體演示步驟如下：步驟一：首先，我們先在電腦端下載安裝迅捷C

3D語音天氣球（原始碼分享）——建立可旋轉的3D球

開篇廢話：在9月份時參加了一個網站的比賽，比賽的題目是需要使用第三方平臺提供的服務做出創意的作品。於是我選擇使用語音服務，天氣服務，Unity3D，Android來製作一個3D語音天氣預報，我給它起名叫做3D語音天氣球（好土。。。）雖然沒獲獎但我覺得這個專案中還是有

OpenGL_Qt學習筆記之_04(3D圖形的繪製和旋轉)

繪製四稜錐四稜錐由5個面構成一個封閉的立體圖,其中4個共頂點的側面是三角形,底面是個四邊形。如果我們要繪製一個3D的四稜錐只需要繪製這5個面即可，繪製的方法和前一篇文章OpenGL_Qt學習筆記之_03(平面圖形的著色和旋轉)的相同。只不過這裡的頂點座標是3維的，所以影象深度那一維不

iOS可旋轉的餅圖

效果圖：餅圖的第三方類在例子中是有的，使用起來也很簡單，下面是使用的程式碼。 ViewController.h #import <UIKit/UIKit.h> #import "PieChartView.h" @interface ViewCont

opengles繪製立方體

本人比較懶，不說廢話，直接貼程式碼，程式碼後附有完整專案 package test.com.opengles5_3; import android.opengl.GLES20; import java.nio.ByteBuffer; import java.nio.B

IOS 影象OPENGLES中的旋轉

昨天搞定視訊顯示後,接著就要將視訊旋轉到合適的角度(我攝像頭採集時,沒有設定方向,所以CIF影象預設的方向似乎是逆時針旋轉90度),所以對方收到的原始資料展現時,一來不能鋪滿螢幕,二來有90度的. 查資料,包括同事在android上都是使用glRotatex/glRota

Android圖片預覽功能（可旋轉、縮放、左右切換）

我們要實現的效果 1、點選圖片出現預覽介面 2、可對圖片進行旋轉、縮放 3、能左右滑動，預覽其他圖片 4、單擊預覽介面後，回到上一介面具體如下圖：使用到的第三方庫

3D立體相簿，一個可旋轉的立體相簿

11359.gif 主要功能：立體球體展示可自行新增本地照片可旋轉，照片可放大用的程式碼是用的雲標籤的code，程式碼略有改動主要程式碼呼叫 // 呼叫展示 self.sphereView = [[YoungSphere alloc] initWithFrame:CGRectMake

h5 canvas繪製的旋轉小球

<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> &l

QT中給各控制元件增加背景圖片(可縮放可旋轉)的幾種方法

1. 給QPushButton 增加背景圖片：背景圖片可根據Button大小自由縮放。 void setButtonBackImage(QPushButton *button,QString image,int sizeW, int sizeH) { //163

opengles繪製可旋轉的球體

相關推薦