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 怎么将世界坐标转化为 屏幕坐标的

游戏中的东西哦，世界坐标就是整个游戏中的坐标，屏幕坐标是显示在屏幕上的坐标，当物体移动的时候屏幕坐标可以不动，但世界坐标是在动的，所以就让人产生视觉效果感觉这个人是在走，其实那个人的坐标是没动的，但他的世界坐标动了，如果让他屏幕坐标也动起来的话就会感觉他走的很快，其实没什么可转换的，你明白世界坐标和屏幕坐标的原理就知道了