OpenGL ES 三 opengl 坐标系 ，纹理坐标系

最新推荐文章于 2024-02-11 13:27:29 发布
最新推荐文章于 2024-02-11 13:27:29 发布
阅读量2.8k 收藏 8
点赞数 1
分类专栏： android opengl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kongbaidepao/article/details/109062001
版权

 

一、  常用的坐标系

 

 1.   Android View 坐标系

2. opengl坐标系中采用的是3维坐标:

                这里写图片描述

 static final float COORD[] = {
            -1.0f, -1.0f,  //1
            1.0f, -1.0f,   //2
            -1.0f, 1.0f,   //3
            1.0f, 1.0f,    //4
    };

坐标原点默认在屏幕的中间,即(width/2,height/2)位置上,z轴是从屏幕"内"指向屏幕外,而且还要注意原点和x,y轴平面是在屏幕的"表面",有引号,这个"表面"刚好是人看不到的面,所以如果你要画一条线,线端点(1,0,0),(0,1,0),直接画到屏幕上,将看不到显示,怎么办?很简单,这个坐标系是三维空间的,那么就将坐标系沿Z轴的负轴方向移动一点,将X,Y平面稍微向屏幕内部移动一点,就能够看到直线了,想象一下在三维空间中,将坐标系往屏幕里面推一下,那么x,y轴形成的平面就在屏幕里面了,在它上面的直线就可以看见了.后面有例子.

 

3. opengl 纹理的坐标系:

     

一般坐标系都自由操作移动(或旋转).


怎样证明 open gl 的纹理坐标系是什么样子的

在open gl 的坐标系中画出 x、Y、Z 轴的直线，根据现象就可以确定 

public class MainActivity extends Activity {
 
    private GLSurfaceView mSurfaceView;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
 
        mSurfaceView=new GLSurfaceView(this);
        mSurfaceView.setRenderer(new PumpKinRenderer()/*new PumpkinDotRenderer()*//*new PumpKinLineRenderer(this)*//*new PumpKinTriangleRenderer()*//*new PumpKinPyramidRenderer()*/);
        setContentView(mSurfaceView/*R.layout.activity_main*/);
    }
 
    @Override
    protected void onResume() {
        super.onResume();
        mSurfaceView.onResume();
    }
 
    @Override
    protected void onPause() {
        super.onPause();
        mSurfaceView.onPause();
    }
}
public class PumpKinRenderer implements GLSurfaceView.Renderer {
 
    private PumpKin pumpKin;
 
    public PumpKinRenderer(){
        pumpKin=new PumpKin();
    }
    @Override
    public void onSurfaceCreated(GL10 gl, EGLConfig config) {
 
        gl.glClearColor(0.0f,0.0f,0.0f,1.0f);
        gl.glClearDepthf(1.0f);
        gl.glEnable(GL10.GL_DEPTH_TEST);
        gl.glDepthFunc(GL10.GL_LEQUAL);
        gl.glHint(GL10.GL_PERSPECTIVE_CORRECTION_HINT,GL10.GL_NICEST);
        gl.glShadeModel(GL10.GL_SMOOTH);
        gl.glDisable(GL10.GL_DITHER);
 
    }
 
    @Override
    public void onSurfaceChanged(GL10 gl, int width, int height) {
 
        if(height==0){
            height=1;
        }
        float aspect=(float)width/height;
 
        gl.glViewport(0,0,width,height);
 
        gl.glMatrixMode(GL10.GL_PROJECTION);
        gl.glLoadIdentity();
        GLU.gluPerspective(gl, 45, aspect, 0.1f, 100.0f);
 
        gl.glMatrixMode(GL10.GL_MODELVIEW);
        gl.glLoadIdentity();
 
    }
 
    @Override
    public void onDrawFrame(GL10 gl) {
 
        gl.glClear(GL10.GL_COLOR_BUFFER_BIT|GL10.GL_DEPTH_BUFFER_BIT);
 
        gl.glLoadIdentity();
    
        //Z 轴下沉-2，不然看不到Z轴的线条
        gl.glTranslatef(0.0f,0.0f,-2f);
        // 旋转角度
        //gl.glRotatef(45,1.0f,1.0f,1.0f);
        pumpKin.draw(gl);
 
    }
}

 

public class PumpKin {
 
    private FloatBuffer vertexsBuffer;
    private FloatBuffer colorsBuffer;
 
    private ByteBuffer indicesBuffer;
 
    private float vertexs[]={
        0.0f,0.0f,0.0f,
            1.0f,0.0f,0.0f,
            0.0f,0.0f,0.0f,
            0.0f,1.0f,0.0f,
            0.0f,0.0f,0.0f,
            0.0f,0.0f,1.0f
    };
 
    // r g b 颜色
    //colors[0]和colors[1]表示从原点到坐标(1,0,0)的颜色,如果[0]和[1]颜色不同,将会产生颜色渐变
    private float colors[]={
            //红色
            1.0f,0.0f,0.0f,1.0f,
            1.0f,0.0f,0.0f,1.0f,
            //绿色
            0.0f,1.0f,0.0f,1.0f,
            0.0f,1.0f,0.0f,1.0f,
            //蓝色
            0.0f,0.0f,1.0f,1.0f,
            0.0f,0.0f,1.0f,1.0f
    };
 
    private byte indices[]={0,1,2};
 
    public PumpKin(){
 
        ByteBuffer vbb=ByteBuffer.allocateDirect(vertexs.length*4);
        vbb.order(ByteOrder.nativeOrder());
        vertexsBuffer=vbb.asFloatBuffer();
        vertexsBuffer.put(vertexs);
        vertexsBuffer.position(0);
 
        ByteBuffer cbb=ByteBuffer.allocateDirect(colors.length*4);
        cbb.order(ByteOrder.nativeOrder());
        colorsBuffer=cbb.asFloatBuffer();
        colorsBuffer.put(colors);
        colorsBuffer.position(0);
 
    }
 
    public void draw(GL10 gl){
 
        gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
        gl.glEnableClientState(GL10.GL_COLOR_ARRAY);
 
        gl.glVertexPointer(3,GL10.GL_FLOAT,0,vertexsBuffer);
        gl.glColorPointer(4,GL10.GL_FLOAT,0,colorsBuffer);
 
        gl.glDrawArrays(GL10.GL_LINES,0,vertexs.length/3);
 
        gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);
 
    }
 
}

  红色 蓝色为坐标系

  

 

贴图规则

 

 a .顶点数组  （2 open gl 的顶点数组）

 static final float COORD1[] = {
            -1.0f, -1.0f,
            1.0f, -1.0f,
            -1.0f, 1.0f,
            1.0f, 1.0f,
    };

 b. 提供纹理坐标，它称为纹理坐标数组 （需要纹理如何展示）

 

 

 b1 "整个纹理图片"的纹理坐标



float texCoords[] = new float[] {
        0.0f, 0.0f,
        1.0f, 0.0f,
        0.0f, 1.0f,
        1.0f, 1.0f,
  };

     

b2 . 右上角(整个纹理1/4)


float texCoords[] = new float[] {
          0.5f, 0.5f,
          1f, 0.5f,
          0.5f, 1f,
          1f, 1f
 };

  

b3.  截取中间的一个三角形


 float texCoords[] = new float[] {   
     0.0f, 0.0f,
     1.0f, 0.0f,
     0.5f, 1.0f,
};

 用上面的顶点数组 和  纹理数组挨个替换，可以查看到效果

float[] coord = COORD_REVERSE;
float[] texture_coord = TEXTURE_COORD_REVERSE;

 

b4  顶点坐标和 纹理坐标是 1  1 对应的 ，

corrd1[0] --> TEXTURE_COORD1[0]

corrd1[1] --> TEXTURE_COORD1[1]

opengl会把纹理中颜色顶点绘到对应的世界坐标顶点上

所以可以任意改变顺序的，只要对应上就可以了，只要世界坐标和纹理坐标数组里的点能够对的上，顺序不是问题 

如下4组显示效果一样   

static final float COORD1[] = {
            -1.0f, -1.0f,
            1.0f, -1.0f,
            -1.0f, 1.0f,
            1.0f, 1.0f,
    };

    static final float TEXTURE_COORD1[] = {
            0.0f, 1.0f,
            1.0f, 1.0f,
            0.0f, 0.0f,
            1.0f, 0.0f,
    };

    static final float COORD2[] = {
            -1.0f, 1.0f,
            -1.0f, -1.0f,
            1.0f, 1.0f,
            1.0f, -1.0f,
    };

    static final float TEXTURE_COORD2[] = {
            0.0f, 0.0f,
            0.0f, 1.0f,
            1.0f, 0.0f,
            1.0f, 1.0f,
    };

    static final float COORD3[] = {
            1.0f, -1.0f,
            1.0f, 1.0f,
            -1.0f, -1.0f,
            -1.0f, 1.0f,
    };

    static final float TEXTURE_COORD3[] = {
            1.0f, 1.0f,
            1.0f, 0.0f,
            0.0f, 1.0f,
            0.0f, 0.0f,
    };


    static final float COORD4[] = {
            1.0f, -1.0f,
            1.0f, 1.0f,
            -1.0f, -1.0f,
            -1.0f, 1.0f,
    };

    static final float TEXTURE_COORD4[] = {
            1.0f, 1.0f,
            1.0f, 0.0f,
            0.0f, 1.0f,
            0.0f, 0.0f,
    };

  -1,-1 对应 0,1

  1,-1 对应 1,1

 static final float COORD1[] = {
            -1.0f, -1.0f,
            1.0f, -1.0f,
            -1.0f, 1.0f,
            1.0f, 1.0f,
    };

    static final float TEXTURE_COORD1[] = {
            0.0f, 1.0f,
            1.0f, 1.0f,
            0.0f, 0.0f,
            1.0f, 0.0f,
    };

  翻转效果

static final float COORD_REVERSE[] = {
            1.0f, -1.0f,
            1.0f, 1.0f,
            -1.0f, -1.0f,
            -1.0f, 1.0f,
    };

    static final float TEXTURE_COORD_REVERSE[] = {
            1.0f, 0.0f,
            1.0f, 1.0f,
            0.0f, 0.0f,
            0.0f, 1.0f,
    };

 

 

二 、 翻转的问题

 

1、OpenGL纹理的原点是左下角

 camera、mediaplayer出来的oes纹理或者fbo的纹理  左下角左下角坐标系

public static final float RECTANGLE_2D_TEX_COORDS[] = {
        0, 1,     // 0 bottom left
        1, 1,     // 1 bottom right
        0, 0,     // 2 top left
        1, 0     // 3 top right
};

2、在Android平台中，Bitmap绑定的2D纹理，是上下颠倒的， 可以按照在左上角处理

所以在 绑定2D纹理时， 需要修改纹理坐标系为左上角

public static final float RECTANGLE_2D_TEX_COORDS[] = {
        0, 1,     // 0 bottom left
        1, 1,     // 1 bottom right
        0, 0,     // 2 top left
        1, 0     // 3 top right
};

 

 

三、demo

public class Filter {

    protected static final String VERTEX_SHADER = "" +
            "attribute vec4 position;\n" +
            "attribute vec4 inputTextureCoordinate;\n" +
            " \n" +
            "varying vec2 textureCoordinate;\n" +
            " \n" +
            "void main()\n" +
            "{\n" +
            "    gl_Position = position;\n" +
            "    textureCoordinate = inputTextureCoordinate.xy;\n" +
            "}";
    protected static final String FRAGMENT_SHADER = "" +
            "varying highp vec2 textureCoordinate;\n" +
            " \n" +
            "uniform sampler2D inputImageTexture;\n" +
            " \n" +
            "void main()\n" +
            "{\n" +
            "     gl_FragColor = texture2D(inputImageTexture, textureCoordinate);\n" +
            "}";

    static final float COORD1[] = {
            -1.0f, -1.0f,
            1.0f, -1.0f,
            -1.0f, 1.0f,
            1.0f, 1.0f,
    };

    static final float TEXTURE_COORD1[] = {
            0.0f, 1.0f,
            1.0f, 1.0f,
            0.0f, 0.0f,
            1.0f, 0.0f,
    };

    static final float COORD2[] = {
            -1.0f, 1.0f,
            -1.0f, -1.0f,
            1.0f, 1.0f,
            1.0f, -1.0f,
    };

    static final float TEXTURE_COORD2[] = {
            0.0f, 0.0f,
            0.0f, 1.0f,
            1.0f, 0.0f,
            1.0f, 1.0f,
    };

    static final float COORD3[] = {
            1.0f, -1.0f,
            1.0f, 1.0f,
            -1.0f, -1.0f,
            -1.0f, 1.0f,
    };

    static final float TEXTURE_COORD3[] = {
            1.0f, 1.0f,
            1.0f, 0.0f,
            0.0f, 1.0f,
            0.0f, 0.0f,
    };


    static final float COORD4[] = {
            1.0f, -1.0f,
            1.0f, 1.0f,
            -1.0f, -1.0f,
            -1.0f, 1.0f,
    };

    static final float TEXTURE_COORD4[] = {
            1.0f, 1.0f,
            1.0f, 0.0f,
            0.0f, 1.0f,
            0.0f, 0.0f,
    };

    static final float COORD_REVERSE[] = {
            1.0f, -1.0f,
            1.0f, 1.0f,
            -1.0f, -1.0f,
            -1.0f, 1.0f,
    };

    static final float TEXTURE_COORD_REVERSE[] = {
            1.0f, 0.0f,
            1.0f, 1.0f,
            0.0f, 0.0f,
            0.0f, 1.0f,
    };

    static final float COORD_FLIP[] = {
            1.0f, -1.0f,
            1.0f, 1.0f,
            -1.0f, -1.0f,
            -1.0f, 1.0f,
    };

    static final float TEXTURE_COORD_FLIP[] = {
            0.0f, 1.0f,
            0.0f, 0.0f,
            1.0f, 1.0f,
            1.0f, 0.0f,
    };

    private String mVertexShader;
    private String mFragmentShader;

    private FloatBuffer mCubeBuffer;
    private FloatBuffer mTextureCubeBuffer;

    protected int mProgId;
    protected int mAttribPosition;
    protected int mAttribTexCoord;
    protected int mUniformTexture;


    public Filter() {
        this(VERTEX_SHADER, FRAGMENT_SHADER);
    }

    public Filter(String vertexShader, String fragmentShader) {
        mVertexShader = vertexShader;
        mFragmentShader = fragmentShader;
    }

    public void init() {
        loadVertex();
        initShader();
        GLES20.glBlendFunc(GLES20.GL_ONE, GLES20.GL_ONE_MINUS_SRC_ALPHA);
    }

    public void loadVertex() {
        float[] coord = COORD1;
        float[] texture_coord = TEXTURE_COORD1;

        mCubeBuffer = ByteBuffer.allocateDirect(coord.length * 4)
                .order(ByteOrder.nativeOrder())
                .asFloatBuffer();
        mCubeBuffer.put(coord).position(0);

        mTextureCubeBuffer = ByteBuffer.allocateDirect(texture_coord.length * 4)
                .order(ByteOrder.nativeOrder())
                .asFloatBuffer();
        mTextureCubeBuffer.put(texture_coord).position(0);
    }

    public void initShader() {
        mProgId = GLHelper.loadProgram(mVertexShader, mFragmentShader);
        mAttribPosition = GLES20.glGetAttribLocation(mProgId, "position");
        mUniformTexture = GLES20.glGetUniformLocation(mProgId, "inputImageTexture");
        mAttribTexCoord = GLES20.glGetAttribLocation(mProgId,
                "inputTextureCoordinate");
    }

    public void drawFrame(int glTextureId) {
        if (!GLES20.glIsProgram(mProgId)) {
            initShader();
        }
        GLES20.glUseProgram(mProgId);

        mCubeBuffer.position(0);
        GLES20.glVertexAttribPointer(mAttribPosition, 2, GLES20.GL_FLOAT, false, 0, mCubeBuffer);
        GLES20.glEnableVertexAttribArray(mAttribPosition);

        mTextureCubeBuffer.position(0);
        GLES20.glVertexAttribPointer(mAttribTexCoord, 2, GLES20.GL_FLOAT, false, 0,
                mTextureCubeBuffer);
        GLES20.glEnableVertexAttribArray(mAttribTexCoord);

        if (glTextureId != GLHelper.NO_TEXTURE) {
            GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
            GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, glTextureId);
            GLES20.glUniform1i(mUniformTexture, 0);
        }
        GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4);

        GLES20.glDisableVertexAttribArray(mAttribPosition);
        GLES20.glDisableVertexAttribArray(mAttribTexCoord);
        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, 0);

        GLES20.glDisable(GLES20.GL_BLEND);

    }
}

 

 

空白的泡
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Android OpenGL20 世界坐标系,屏幕坐标系,纹理坐标系 <8>
刘志保的博客
05-20 4729
在  http://blog.csdn.net/qq_31726827/article/details/51265186这一篇大概介绍了坐标系,但是如何应用的呢?并没有特别说明,下面通过测试Sample来说一下. 第一个想说的:世界坐标系,这个坐标很容易,opengl 坐标原点默认给在屏幕中间,一般3D 顶点参照使用这个坐标系,具体参见上面的博客.这里介绍一下着色是如何进行的,工
OpenGL中的坐标系
亲亲Friends的博客
05-12 885
最近在学习OpenGL，但是书中的各种坐标系搞得我颇为痛苦，既不知道各种坐标系是做什么用的，也不知道各自是如何转换的，往往是看书看到吐。一番纠结之后，还是得自己去找资料解决，下面就把我个人学到的各种坐标系的知识分享出来，省的后来人跟我一样痛苦了。 首先声明一点，对于三维物体，openGL使用右手坐标，从左到右，x递增，从下到上，y递增，从远到近，z递增。 但是对于二维问题，在OpenGL中x轴与y...
OpenGL 坐标系统详解
kfashfasf的博客
11-08 249
经过了这么久的介绍，我们都一直在绘制屏幕中的一个矩形。而事实上，之前的一切过程，我们还只是停留在建造模型的过程。这时候我们的画布里只有这一个模型，我们把当前的坐标系统称作是局部空间。当然，我们的屏幕中大多数情况下不可能只有一个模型，而是千千万万个模型。我们应该通过一系列矩阵变换将模型变换到一个更大的画布中。当然，我们的屏幕是不可能变大的，所以我们是通过一系列的矩阵缩放我们的模型然后放到原始画布中来模拟把模型放入大画布中这个过程。这里，我们把变换到大画布后的坐标系统称为是世界空间。
十一、理解纹理坐标
lin1109221208的博客
07-19 6986
纹理坐标就是纹理与图形的映射关系，图形中每个顶点都会关联一个纹理坐标，表示顶点需要从该位置读取纹理图像的数据。 纹理坐标的范围是 0 到 1 之间， 顶点坐标一般是用（ x，y，z）描述，而纹理坐标是用（ s，t，r）描述 常规情况下，纹理坐标默认左下角为（0，0），右上角为（1，1），如图所示 纹理坐标的映射关系并不是固定的，可以根据图片的翻转，进行不同的映射，但是不能让图片交叉，有以下几种映射情况 ...
OpenGL之纹理坐标及纹理映射
一个小菜鸡的学习之路
06-11 2841
为了实现纹理贴图我们需要做三件事：将一张贴图加载到OpenGL中，提供纹理坐标和顶点（将纹理对应匹配到顶点上），并使用纹理坐标从纹理中进行取样操作取得像素颜色。由于三角形会被缩放、旋转、平移变换导致最后会以不同的结果投影显示到屏幕上，而且由于camera的不同操作看上去也会很不一样。GPU要做的就是让纹理紧跟三角形图元顶点的移动使其看上去真实（如果纹理看上去明显游离在三角形上产生错位就不真实了）。为实现这个效果开发者需要为每个顶点提供一系列纹理坐标。
OpenGL之glViewPort函数的用法
热门推荐
草上爬的博客
05-10 4万+
其函数原型为：glViewport(GLint x,GLint y,GLsizei width,GLsizei height)x，y 以像素为单位，指定了视口的左下角位置。width，height 表示这个视口矩形的宽度和高度，根据窗口的实时变化重绘窗口。在默认情况下，视口被设置为占据打开窗口的整个像素矩形，窗口大小和设置视口大小相同，所以为了选择一个更小的绘图区域，就可以用glViewport函...
OpenGL | 纹理坐标及环绕模式
该用户还没想到好的昵称的博客
03-14 873
纹理坐标及环绕模式。
OpenGL中屏幕坐标转为OpenGL坐标
风中静草
08-14 1369
在opengl中我们经常碰到需要把屏幕坐标转换成opengl坐标，例如我们做拾取，旋转，平移等操作。网上有很多相关代码：    原理：    鼠标点击屏幕中的某点，然后获取该点屏幕坐标对应的OpenGL坐标。鼠标点的坐标很容易获得，直接从鼠标点击消息中获取就可以，但是OpenGL坐标却需要做一定计算转换。需要用到的核心OpenGL函数是gluUnProject()。    代码1： GLint
OpenGL ES纹理详解
08-27
在Android中使用的OpenGL ES的纹理坐标系跟官方的纹理坐标系统不一样，在Android中使用官方的纹理坐标系统，得到的结果是相反的，而是左上角是st坐标(0.0,0.0)点，右下角是st坐标(1.0,1.0)点。 二维纹理映射的原理...
opengles绘制纹理
08-16
在本主题“opengles绘制纹理”中，我们将深入探讨如何在OpenGL ES环境中加载和绘制纹理，以增强图形渲染的质量和表现力。 1. **纹理的概念** 在计算机图形学中，纹理是指附加到几何形状上的二维图像数据，用于给...
android OpenGL ES 地球仪绘制——球体绘制及纹理映射——源码
09-03
在OpenGL ES中，我们使用`GL_TEXTURE_2D`纹理坐标系，通过`glBindTexture()`绑定纹理，`glTexImage2D()`加载纹理数据。接着，为每个顶点设置纹理坐标，使用`glTexCoordPointer()`指定纹理坐标数组，最后在顶点着色器...
opengl-es.zip_opengl_opengl es
09-14
- **坐标系统**：OpenGL ES使用右手坐标系，Z轴正向通常指向屏幕内部。 - **视口（Viewport）**：将3D图形映射到2D屏幕的区域。 2. **设置上下文（Context）**： 在OpenGL ES中，首先需要创建一个有效的绘图上...
android opengl es 圆锥纹理贴图
05-07
1. **纹理坐标**：每个顶点都有对应的纹理坐标，这些坐标告诉OpenGL ES如何将纹理映射到几何体表面。通常使用UV坐标系，U和V分别对应纹理的水平和垂直方向。 2. **纹理单元**：OpenGL ES支持同时使用多个纹理，每个...
对Android opengl ES世界坐标系和纹理坐标系的理解
yellowcath的专栏
06-17 1万+
初学opengl ES,每一个教你在屏幕上贴图的opengl版hello world都有两个顶点数组，然后一般都不解释，初学者基本搞不懂这些顶点为什么要这么写，它们之间为什么要按这个顺序排列。
OpenGL纹理坐标 与 Cocos2d-x 纹理坐标
Wlk1229
12-18 1886
Cocos2d-x 纹理坐标 声明：本文使用的是cocos2d-x-3.17的代码 OpenGL纹理坐标 在OpenGL中2D纹理坐标系如下： 原点为左下角，向右为X轴正方向，向上为Y轴正方向。 纹理数据排列 创建一个2*2的二维纹理，需要四个像素，以下是4个像素的数据 floattexData[]={1.0,0.0,0.0,1.0, ...
OpenGL-ES 学习(4)---- OpenGL-ES 坐标体系
最新发布
小猪佩奇的博客
02-11 1341
从 [l，r] 到 [-1, 1] 的x坐标范围，从 [b，t] 到 [-1,1 ]的y坐标范围和 [-n，-f] 到[-1, 1] 的 z 的坐标范围。透视除法是一种将 3D 坐标变换到 2D 屏幕上的方法，它可以将3D空间中的任意点投影到一个正方体的六个面上，然后去掉那些不在正方体内部的点，得到最终可以显示在屏幕上的点。观察空间(View Space)也被称为 OpenGL-ES 相机空间（定义了相机所在的位置），即从摄像机的角度观察到的空间，它将对象的世界空间的坐标转换为观察者视野前面的坐标。
OPENGL 的世界坐标和 纹理坐标
leonpengweicn的专栏
10-12 861
世界坐标    以屏幕中心为原点(0, 0, 0)。你面对屏幕，你的右边是x正轴，上面是y正轴，屏幕指向你的为z正轴。长度单位这样来定： 窗口范围按此单位恰好是(-1,-1)到(1,1)。 glVertexPointer(2, GL_FLOAT, 0, spriteVertices); glEnableClientState(GL_VERTEX_ARRAY);//启动独立的客户端功能，
OpenGL视口变换函数：glViewport
jack_20的博客
08-02 1100
调用glViewPort函数来决定视见区域，告诉OpenGL应把渲染之后的图形绘制在窗体的哪个部位。当视见区域是整个窗体时，OpenGL将把渲染结果绘制到整个窗口。        glViewPort(x:GLInt;y:GLInt;Width:GLSizei;Height:GLSizei);        其中，参数X，Y指定了视见区域的左下角在窗口中的位置，一般情况下为（0，0），Widt
Android OpenGL ES 二 、 FBO 离屏渲染
10-05 2933
1. 什么是FBO 2. FBO还需相关对象来辅佐，Shader；原纹理texture；输出纹理texture（fbo纹理） 2.1 如何创建 FBO private int createFbo(int width, int height) { int[] texture = new int[1]; int[] fbo = new int[1]; //创建FBO GLES20.glGenFrameb...
android 纹理坐标原点,OpenGL顶点坐标与纹理坐标
06-07
在 Android 中，纹理坐标原点通常位于左下角，而 OpenGL 顶点坐标则通常位于中心或左上角，这意味着在将纹理坐标应用到 OpenGL 顶点坐标时需要进行一些转换。 具体而言，将纹理坐标的原点从左下角移动到左上角可以通过以下方式实现： 1. 将纹理坐标的 y 坐标反转，即将其从 1.0 减去。 2. 将纹理坐标的原点向上平移，即将其减去 0.5。 转换后的纹理坐标可以与 OpenGL 顶点坐标进行匹配，以便正确地对纹理进行贴图。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

空白的泡

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值