opengles演算法

⑴ opengl es 頂點數 和texture哪個對性能影響大

當設計程序時，一個關鍵的問題在於設備是否支持2.0,1.1或者是兩者都支持。
opengl2.0顯然是更強大的，平時自己做的頂點和片元的計算能夠更清晰和准確，性能更佳。
opengles2.0和opengles1.0相比更具靈活性，功能也更強大。
可以自定義頂點和像素計算，可以讓表現方式更加准確。
如果要執行同樣的運算，用opengles1.1通常需要幾個渲染pass,復雜的狀態設置，演算法也更簡單明了。
shader確保了能夠更准確，清晰地執行運算，並且性能更佳。
opengles2.0需要更多前台的工作（shader），而這些工作，opengles1.1都幫做好了。
opengles1.1提供了一個標準的固定渲染管線，這個管線為3d程序提供了提供了很好的參照（如何編寫渲染語言）。
如果對程序沒什麼太大要求，opengles1.1不需要太多的代碼就可以實現了；
如果要求程序在所有設備在都能良好運行，那麼應該選擇用opengles1.1（主要是可以兼容舊設備）。
但是在新的ios設備上，如果用opengles2.0將發揮它們強大的圖形渲染能力。

⑵ 圖形引擎性能測試

隨著計算機軟體和硬體，計算機圖形應用在各個領域的迅速蔓延和深度的快速發展。計算機圖形學已進入三維，三維圖形到處的時代。科學可視化，計算機動畫和虛擬現實，在最近幾年的一個熱門話題，已成為計算機圖形學的核心技術是三大熱點話題的三維圖形。

很多演算法和三維圖形的專業3D應用程序的快速發展是困難的。寫微型計算機一般使用OpenGL或DirectX，OpenGL或DirectX 3D圖形應用程序的真實感圖形的生產性能優良的，但直接使用它們仍存在一些缺點：1，非表面的對象，該對象在系統開發在現場設計方案，操作更困難。 2，主要使用的主要原，比較難寫一個程序來顯示復雜的場景。 3，建模工具很好地結合起來。 4，缺乏一些非常重要的關鍵技術，如動態切削LOD（層次細節）的支持。基於上述的硬體和圖形演算法簡單，易於使用，功能豐富的3D圖形開發環境，可以調用3D圖形引擎，應用程序開發人員需要一個包。

發動機，機行業術語借用了相同的名稱，以示對整個系統的核心。也被稱為「基礎庫支持的應用程序或抽象到具體的應用。3D引擎的場景結構，對象處理，以及場景渲染，事件處理，碰撞檢測問題需要解決。

⑶ 想從事游戲開發，現在需要學什麼

根據游戲類型的不同，所學的軟體也不一樣。

中小型游戲大致可分為網頁游戲，flash游戲，小游戲等，基本上都是一些休閑類的傻呆萌的情節和操作。

這類游戲開發相對比較簡單，會 javascript、HTML、flashcs、Java 就可以進行開發了，語言類主要有 C / C++，匯編語言，著色器語言，腳本語言，高效的開發語言 C# 或 Java 。

現在的游戲主要分為三種：

1、PC 類端游（就是電腦上面運行的游戲）

這類游戲在線人數多，游戲中要處理的數據龐大。所以對伺服器性能要求非常高，一般都是採用C++ 做為開發語言，C++ 可以直接操作內存數據，與操作系統直接交互，減少數據之間的復制，它運行效率高，處理速度快，是很適合這里游戲開發語言。

學習這種游戲的開發，學習的有 C++ 編程，Linux 網路編程、TCP/IP 通訊協議、多線程編程再加資料庫。

PC 類端游戲開發周期較長。大概需要三年左右的時間。

2、網頁游戲（比如現在經常說的 1 刀 999 級）

因為是網頁游戲，游戲的界面展示依賴於網路傳輸，所在在畫面和特效上會次於客戶端游戲很多。和端游類是差不多是一樣的，有些公司之前是做端游的，他們就直接把端游的伺服器架構拿來就可以使用，以完成快速開發。

需要學習內容和端游差不多。

3、手機游戲（主要區分為安卓和 IOS）

手機類游戲目前是最熱門的游戲，很多熱播的電視劇或者電影之後，都會有相同情節的手游上線。

伺服器主流的開發語言是 C++ 和 Java，但是 C++ 學習難度大，開發速度慢。一般來說我們都是使用Java語言來開發伺服器。

(3)opengles演算法擴展閱讀：

學習的先後順序

1、首先是C++語言。

2、只是做windows方面的游戲學習，可以學習下DirectX，這個很方便在windows下做游戲開發。

3、如果想製作跨平台游戲，建議學習下opengl/opengles，這是個很強大很專業的圖形介面，因為很多平台支持所以適合跨平台游戲製作使用。

4、想學習 3d 游戲並迅速工作，建議學習 u3d 引擎、ue 引擎這些游戲引擎，有了以上的基礎學習這些引擎也可以理解的更深入，u3d 還會用到 c# 與 js 語言。

5、做2d游戲，可以使用 cocos2dx 等一些引擎，當然你也可以使用上面的 3d 引擎製作 2d 游戲。

6、然後就是可以深入的研究一些開源的游戲引擎，終極目標是可以自己做出一款比較棒的游戲引擎。

⑷ 用opengl將灰度值寫入像素信息

玩灰度,要用可編程管線.你到powervr的網站找opengles 的pc模擬器玩玩吧

⑸ 畢業設計選了用android做一個3d魔方的游戲，應為android以前沒接觸過的，要從頭開始學的。這個難嗎高手

只要java好就沒有問題，這是3D魔方android的源碼。
package com.example.android.image3D;

import android.view.SurfaceView;
import android.view.SurfaceHolder;
import android.content.Context;
import android.util.AttributeSet;
import java.util.ArrayList;
import java.util.concurrent.Semaphore;

import javax.microedition.khronos.egl.EGL10;
import javax.microedition.khronos.egl.EGL11;
import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.egl.EGLContext;
import javax.microedition.khronos.egl.EGLDisplay;
import javax.microedition.khronos.egl.EGLSurface;
import javax.microedition.khronos.opengles.GL;
import javax.microedition.khronos.opengles.GL10;

public class View3D extends SurfaceView implements SurfaceHolder.Callback {

private static final Semaphore sEglSemaphore = new Semaphore(1);
private boolean mSizeChanged = true;

private SurfaceHolder mHolder;
private GLThread mGLThread;
private GLWrapper mGLWrapper;

public View3D(Context context) {
super(context);
init();
}

public View3D(Context context, AttributeSet attrs) {
super(context, attrs);
init();
}

private void init() {
mHolder = getHolder();
mHolder.addCallback(this);
mHolder.setType(SurfaceHolder.SURFACE_TYPE_GPU);
}

public SurfaceHolder getSurfaceHolder() {
return mHolder;
}

public void setGLWrapper(GLWrapper glWrapper) {
mGLWrapper = glWrapper;
}

public void setRenderer(Renderer renderer) {
mGLThread = new GLThread(renderer);
mGLThread.start();
}

public void surfaceCreated(SurfaceHolder holder) {
mGLThread.surfaceCreated();
}

public void surfaceDestroyed(SurfaceHolder holder) {
mGLThread.surfaceDestroyed();
}

public void surfaceChanged(SurfaceHolder holder,
int format, int w, int h) {
mGLThread.onWindowResize(w, h);
}

public void onPause() {
mGLThread.onPause();
}

public void onResume() {
mGLThread.onResume();
}

@Override
public void onWindowFocusChanged(boolean hasFocus) {
super.onWindowFocusChanged(hasFocus);
mGLThread.onWindowFocusChanged(hasFocus);
}

public void queueEvent(Runnable r) {
mGLThread.queueEvent(r);
}

@Override
protected void onDetachedFromWindow() {
super.onDetachedFromWindow();
mGLThread.requestExitAndWait();
}

public interface GLWrapper {
GL wrap(GL gl);
}

public interface Renderer {

int[] getConfigSpec();

void surfaceCreated(GL10 gl);
void sizeChanged(GL10 gl, int width, int height);
void drawFrame(GL10 gl);
}

private class EglHelper {

EGL10 mEgl;
EGLDisplay mEglDisplay;
EGLSurface mEglSurface;
EGLConfig mEglConfig;
EGLContext mEglContext;

public EglHelper() {

}

public void start(int[] configSpec){

mEgl = (EGL10) EGLContext.getEGL();
mEglDisplay = mEgl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
int[] version = new int[2];
mEgl.eglInitialize(mEglDisplay, version);

EGLConfig[] configs = new EGLConfig[1];
int[] num_config = new int[1];
mEgl.eglChooseConfig(mEglDisplay, configSpec, configs, 1,
num_config);
mEglConfig = configs[0];

mEglContext = mEgl.eglCreateContext(mEglDisplay, mEglConfig,
EGL10.EGL_NO_CONTEXT, null);

mEglSurface = null;
}

public GL createSurface(SurfaceHolder holder) {

if (mEglSurface != null) {

mEgl.eglMakeCurrent(mEglDisplay, EGL10.EGL_NO_SURFACE,
EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_CONTEXT);
mEgl.eglDestroySurface(mEglDisplay, mEglSurface);
}

mEglSurface = mEgl.eglCreateWindowSurface(mEglDisplay,
mEglConfig, holder, null);

mEgl.eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
mEglContext);

GL gl = mEglContext.getGL();
if (mGLWrapper != null) {
gl = mGLWrapper.wrap(gl);
}
return gl;
}

public boolean swap() {
mEgl.eglSwapBuffers(mEglDisplay, mEglSurface);
return mEgl.eglGetError() != EGL11.EGL_CONTEXT_LOST;
}

public void finish() {
if (mEglSurface != null) {
mEgl.eglMakeCurrent(mEglDisplay, EGL10.EGL_NO_SURFACE,
EGL10.EGL_NO_SURFACE,
EGL10.EGL_NO_CONTEXT);
mEgl.eglDestroySurface(mEglDisplay, mEglSurface);
mEglSurface = null;
}
if (mEglContext != null) {
mEgl.eglDestroyContext(mEglDisplay, mEglContext);
mEglContext = null;
}
if (mEglDisplay != null) {
mEgl.eglTerminate(mEglDisplay);
mEglDisplay = null;
}
}

}

class GLThread extends Thread {

private boolean mDone;
private boolean mPaused;
private boolean mHasFocus;
private boolean mHasSurface;
private boolean mContextLost;
private int mWidth;
private int mHeight;
private Renderer mRenderer;
private ArrayList<Runnable>
mEventQueue = new ArrayList<Runnable>();
private EglHelper mEglHelper;

GLThread(Renderer renderer) {
super();
mDone = false;
mWidth = 0;
mHeight = 0;
mRenderer = renderer;
setName("GLThread");
}

@Override
public void run() {

try {
try {
sEglSemaphore.acquire();
} catch (InterruptedException e) {
return;
}
guardedRun();
} catch (InterruptedException e) {

} finally {
sEglSemaphore.release();
}
}

private void guardedRun() throws InterruptedException {
mEglHelper = new EglHelper();
int[] configSpec = mRenderer.getConfigSpec();
mEglHelper.start(configSpec);

GL10 gl = null;
boolean tellRendererSurfaceCreated = true;
boolean tellRendererSurfaceChanged = true;

while (!mDone) {

int w, h;
boolean changed;
boolean needStart = false;
synchronized (this) {
Runnable r;
while ((r = getEvent()) != null) {
r.run();
}
if (mPaused) {
mEglHelper.finish();
needStart = true;
}
if(needToWait()) {
while (needToWait()) {
wait();
}
}
if (mDone) {
break;
}
changed = mSizeChanged;
w = mWidth;
h = mHeight;
mSizeChanged = false;
}
if (needStart) {
mEglHelper.start(configSpec);
tellRendererSurfaceCreated = true;
changed = true;
}
if (changed) {
gl = (GL10) mEglHelper.createSurface(mHolder);
tellRendererSurfaceChanged = true;
}
if (tellRendererSurfaceCreated) {
mRenderer.surfaceCreated(gl);
tellRendererSurfaceCreated = false;
}
if (tellRendererSurfaceChanged) {
mRenderer.sizeChanged(gl, w, h);
tellRendererSurfaceChanged = false;
}
if ((w > 0) && (h > 0)) {

mRenderer.drawFrame(gl);
mEglHelper.swap();
}
}
mEglHelper.finish();
}

private boolean needToWait() {
return (mPaused || (! mHasFocus) || (! mHasSurface) || mContextLost)
&& (! mDone);
}

public void surfaceCreated() {
synchronized(this) {
mHasSurface = true;
mContextLost = false;
notify();
}
}

public void surfaceDestroyed() {
synchronized(this) {
mHasSurface = false;
notify();
}
}

public void onPause() {
synchronized (this) {
mPaused = true;
}
}

public void onResume() {
synchronized (this) {
mPaused = false;
notify();
}
}

public void onWindowFocusChanged(boolean hasFocus) {
synchronized (this) {
mHasFocus = hasFocus;
if (mHasFocus == true) {
notify();
}
}
}

public void onWindowResize(int w, int h) {
synchronized (this) {
mWidth = w;
mHeight = h;
mSizeChanged = true;
}
}

public void requestExitAndWait() {
synchronized(this) {
mDone = true;
notify();
}
try {
join();
} catch (InterruptedException ex) {
Thread.currentThread().interrupt();
}
}

public void queueEvent(Runnable r) {
synchronized(this) {
mEventQueue.add(r);
}
}

private Runnable getEvent() {
synchronized(this) {
if (mEventQueue.size() > 0) {
return mEventQueue.remove(0);
}

}
return null;
}
}
}

⑹ 游戲開發需要學什麼

游戲開發需要學圖形引擎，聲音引擎，物理引擎，游戲引擎，人工智慧或游戲邏輯，游戲GUI界面（菜單），游戲開發工具，支持區域網對戰的網路引擎開發，支持互聯網對戰的網路引擎開發。

選擇培訓學習游戲開發課程，還可以學到深入的圖形學課程，講解包括OpenGL渲染管線，著色器，高光計算、菲尼爾色散、霧方程式等高階課程。對於從事過Unity游戲開發的人員也具有相當的學習價值。

⑺ 三維數據分析有哪些好的方法與軟體

三維數據處理軟體都包含哪些模塊

三維數據處理軟體，一般包含三個模塊：數據管理和處理，三維渲染，UI。 這與圖形學的三個經典問題是相對應的：建模，渲染和交互。與一般常見的數據處理軟體，比如圖像視頻處理，不同的是，這里的數據展示模塊需要三維渲染。與之對應的UI操作，也變成了一些三維空間的變換，比如模型的旋轉縮放等。

如何搭建一個簡單的三維數據處理軟體

那麼如何快速的搭建一個三維數據處理軟體呢？採用搭積木的方式，每個模塊都有很多現成的開發包可以選擇。比如UI模塊處，一般常見的有MFC，QT，MyGUI（Magic3D使用的UI）等。數據處理演算法方面，常見的有Geometry++，CGAL，OpenMesh，PCL等。渲染模塊，可以使用OpenGL或者Direct3D，也可以使用渲染引擎，如OGRE，OSG等。

如何選擇幾何演算法開發包

幾何演算法模塊，一般有三種選擇：自主開發，使用開源庫，使用商業庫。如何選擇呢？開發包API的生命周期，大概分為開發，維護和升級。對於一個演算法，幾乎不可能開發出放之四海皆準的API。它的絕大部分時間都在維護和升級。開發包的選擇，其實就是一個成本問題。開發階段主要是時間成本，如何快速的實現目標功能是最關鍵的問題。維護和升級階段需要盡量低的成本開銷。所謂開源庫免費，其實只是在開發階段免費，而開發階段最看重的卻是時間成本。有了源代碼就需要人去維護，沒有人維護的源代碼是沒有用處的。商業庫的主要優勢就是有專業的團隊來維護和升級這些API，並且成本會比個人做得更低。如果想清楚API的生命周期以及每個階段的成本開銷後，根據自身具體情況，就能很容易的做出選擇了。

數字幾何處理是什麼

數字幾何處理，一般是指點雲網格數據的處理。和傳統的NURBS正向建模的模型相比，數字幾何處理的對象一般是三維掃描儀採集的數據，是曲面的離散表達，也就是數字化的。它的研究內容包括數據的獲取，存儲，表示，編輯，可視化等等。

OpenGL是什麼

OpenGL是一套跨平台的圖形繪制API，它通過一系列API把三維模型渲染到2D屏幕上。OpenGL採用了流水線機制，其繪制過程也稱為渲染流水線。此外還有OpenGLES，主要用於嵌入式系統，或者移動平台；WebGL主要用於Web瀏覽器里的圖形繪制。

OpenGL流水線

OpenGL通過一系列API可以設置渲染流水線的狀態，所以OpenGL也是一個狀態機。三維模型通過一些處理，最終渲染到2D屏幕上：

• 模型離散為三角面片：所有模型都需要離散為三角面片，OpenGL只接受三角面片輸入。注意，雖然OpenGL也可以接受四邊形，NURBS等輸入，其本質最後都是三角面片的繪制。

• Vertex Shader把三維三角片轉化到屏幕坐標系下的2D三角片：這個過程包含了變換，裁剪等操作

• 2D三角片的光柵化：2D三角片被離散化，用屏幕坐標系的像素來表示，這也叫光柵化。

• Pixel Shader為光柵化後的模型像素著色。

  上面是渲染流水線的大致描述，其中還有很多細節，不同的API也有些細節上的差別。最早的OpenGL是固定的流水線，也就是只能通過API來設置一些流水線中的狀態。現代的OpenGL開放出了一些Shader，用戶可以自己為Shader寫代碼，利用Shader可以寫出各式各樣的渲染效果。

  渲染模塊使用OpenGL還是渲染引擎

  如果渲染模塊不是主要業務，建議使用渲染引擎。因為引擎內有很多現成的工具可以使用，減少開發的時間成本。

⑻ android opengl es與surfaceview什麼關系

1.SurfaceFlinger是一個服務，主要是負責合成各窗口的Surface，然後通過OpenGLES顯示到FrameBuffer上。 2.DisplayHardware是對顯示設備的抽象，包括FrameBuffer和Overlay。載入FrameBuffer和Overlay插件，並初始化OpenGLES: view plain mNativeWindow = new FramebufferNativeWindow(); framebuffer_device_t const * fbDev = mNativeWindow->getDevice(); if (hw_get_mole(OVERLAY_HARDWARE_MODULE_ID, &mole) == 0) { overlay_control_open(mole, &mOverlayEngine); } surface = eglCreateWindowSurface(display, config, mNativeWindow.get(), NULL); eglMakeCurrent(display, surface, surface, context); 3.FramebufferNativeWindow 是framebuffer 的抽象，它負責載入libgralloc，並打開framebuffer設備。FramebufferNativeWindow並不直接使用 framebuffer，而是自己創建了兩個Buffer： queueBuffer負責顯示一個Buffer到屏幕上，它調用fb->post去顯示。 dequeueBuffer獲取一個空閑的Buffer，用來在後台繪制。 這兩個函數由eglSwapBuffers調過來，調到 view plain egl_window_surface_v2_t::swapBuffers： nativeWindow->queueBuffer(nativeWindow, buffer); nativeWindow->dequeueBuffer(nativeWindow, &buffer); 4.msm7k/liboverlay是Overlay的實現，與其它平台不同的是，高通平台上的Overlay並不是提供一個framebuffer設備，而通過fb0的ioctl來實現的，ioctl分為兩類操作： OverlayControlChannel用於設置參數，比如設置Overlay的位置，寬度和高度： view plain bool OverlayControlChannel::setPosition(int x, int y, uint32_t w, uint32_t h) { ov.dst_rect.x = x; ov.dst_rect.y = y; ov.dst_rect.w = w; ov.dst_rect.h = h; ioctl(mFD, MSMFB_OVERLAY_SET, &ov); } OverlayDataChannel用於顯示Overlay，其中最重要的函數就是queueBuffer: view plain bool OverlayDataChannel::queueBuffer(uint32_t offset) { mOvData.data.offset = offset; ioctl(mFD, MSMFB_OVERLAY_PLAY, odPtr)) } 5.msm7k/libgralloc 是顯示緩存的抽象，包括framebuffer和普通Surface的Buffer。framebuffer只是/dev/graphic/fb0的包 裝，Surface的Buffer則是對/dev/pmem、ashmem和GPU內存(msm_hw3dm)的包裝，它的目標主要是方便硬體加速，因為 DMA傳輸使用物理地址，要求內存在物理地址上連續。 6.msm7k/libbit這是2D加速庫，主要負責Surface的拉伸、旋轉和合成等操作。它有兩種實現方式： bit.cpp: 基於fb0的ioctl(MSMFB_BLIT)的實現。 bit_c2d.cpp: 基於kgsl的實現，只是對libC2D2.so的包裝，libC2D2.so應該是不開源的。 7.pmem misc/pmem.c: 對物理內存的管理，演算法和用戶空間的介面。 board-msm7x27.c定義了物理內存的預設大小： view plain #define MSM_PMEM_MDP_SIZE 0x1B76000 #define MSM_PMEM_ADSP_SIZE 0xB71000 #define MSM_PMEM_AUDIO_SIZE 0x5B000 #define MSM_FB_SIZE 0x177000 #define MSM_GPU_PHYS_SIZE SZ_2M #define PMEM_KERNEL_EBI1_SIZE 0x1C00 msm_msm7x2x_allocate_memory_regions分配幾大塊內存用於給pmem做二次分配。 8.KGSL Kernel Graphics System Layer (KGSL)，3D圖形加速驅動程序，源代碼drivers/gpu/msm目錄下，它是對GPU的包裝，給OpenGLES 2.0提供抽象的介面。 9.msm_hw3dm 這個我在內核中沒有找到相關代碼。 10.msm_fb msm_fb.c: framebuffer, overlay和blit的用戶介面。 mdp_dma.c: 對具體顯示設備的包裝，提供兩種framebuffer更新的方式： mdp_refresh_screen： 定時更新。 mdp_dma_pan_update: 通過pan display主動更新。 mdp_dma_lcdc.c：針對LCD實現的顯示設備，mdp_lcdc_update用更新framebuffer。

⑼ 自學游戲開發需要學多久

半年。開發軟體和開發游戲完全是兩個不同的方向，就拿開發游戲來說，不同的游戲引擎所使用的編程語言也是有區別的，比如Unity用的是C#。

游戲開發需要學習的專業知識比較多。除了基礎的Unity引擎知識，現在的游戲還會涉及一些VR技術等。除此以外，有些游戲公司還會要求游戲開發工程師具備一定的策劃能力。

學習的先後順序：

1、首先是C++語言。

2、只是做windows方面的游戲學習，可以學習下DirectX，這個很方便在windows下做游戲開發。

3、如果想製作跨平台游戲，建議學習下opengl/opengles，這是個很強大很專業的圖形介面，因為很多平台支持所以適合跨平台游戲製作使用。

4、想學習 3d 游戲並迅速工作，建議學習 u3d 引擎、ue 引擎這些游戲引擎，有了以上的基礎學習這些引擎也可以理解的更深入，u3d 還會用到 c# 與 js 語言。

⑽ opengles 怎麼將世界坐標轉化為 屏幕坐標的

游戲中的東西哦，世界坐標就是整個游戲中的坐標，屏幕坐標是顯示在屏幕上的坐標，當物體移動的時候屏幕坐標可以不動，但世界坐標是在動的，所以就讓人產生視覺效果感覺這個人是在走，其實那個人的坐標是沒動的，但他的世界坐標動了，如果讓他屏幕坐標也動起來的話就會感覺他走的很快，其實沒什麼可轉換的，你明白世界坐標和屏幕坐標的原理就知道了