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

最新推荐文章于 2023-06-11 13:13:37 发布
最新推荐文章于 2023-06-11 13:13:37 发布
阅读量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 坐标系统详解
最新发布
kfashfasf的博客
11-08 243
经过了这么久的介绍，我们都一直在绘制屏幕中的一个矩形。而事实上，之前的一切过程，我们还只是停留在建造模型的过程。这时候我们的画布里只有这一个模型，我们把当前的坐标系统称作是局部空间。当然，我们的屏幕中大多数情况下不可能只有一个模型，而是千千万万个模型。我们应该通过一系列矩阵变换将模型变换到一个更大的画布中。当然，我们的屏幕是不可能变大的，所以我们是通过一系列的矩阵缩放我们的模型然后放到原始画布中来模拟把模型放入大画布中这个过程。这里，我们把变换到大画布后的坐标系统称为是世界空间。
OpenGL之纹理坐标及纹理映射
一个小菜鸡的学习之路
06-11 2783
为了实现纹理贴图我们需要做三件事：将一张贴图加载到OpenGL中，提供纹理坐标和顶点（将纹理对应匹配到顶点上），并使用纹理坐标从纹理中进行取样操作取得像素颜色。由于三角形会被缩放、旋转、平移变换导致最后会以不同的结果投影显示到屏幕上，而且由于camera的不同操作看上去也会很不一样。GPU要做的就是让纹理紧跟三角形图元顶点的移动使其看上去真实（如果纹理看上去明显游离在三角形上产生错位就不真实了）。为实现这个效果开发者需要为每个顶点提供一系列纹理坐标。
OPENGL 的世界坐标和 纹理坐标
leonpengweicn的专栏
10-12 859
世界坐标    以屏幕中心为原点(0, 0, 0)。你面对屏幕，你的右边是x正轴，上面是y正轴，屏幕指向你的为z正轴。长度单位这样来定： 窗口范围按此单位恰好是(-1,-1)到(1,1)。 glVertexPointer(2, GL_FLOAT, 0, spriteVertices); glEnableClientState(GL_VERTEX_ARRAY);//启动独立的客户端功能，
OpenGL/OpenGL ES入门： 纹理应用 - 纹理坐标及案例解析(金字塔)
weixin_34381687的博客
05-26 948
系列推荐文章： OpenGL/OpenGL ES入门：图形API以及专业名词解析 OpenGL/OpenGL ES入门：渲染流程以及固定存储着色器 OpenGL/OpenGL ES入门：图像渲染实现以及渲染问题 OpenGL/OpenGL ES入门：基础变换 - 初识向量/矩阵 OpenGL/OpenGL ES入门：纹理初探 - 常用API解析 OpenGL/OpenGL ES入门： 纹理应用 ...
openGL坐标系
Benjamin's IT Life
09-17 3万+
OPENGL坐标系可分为：世界坐标系和当前绘图坐标系。 世界坐标系以屏幕中心为原点(0, 0, 0)。你面对屏幕，你的右边是x正轴，上面是y正轴，屏幕指向你的为z正轴。长度单位这样来定： 窗口范围按此单位恰好是(-1,-1)到(1,1)。 当前绘图坐标系是 绘制物体时的坐标系。程序刚初始化时，世界坐标系和当前绘图坐标系是重合的。当用glTranslatef()，glScalef(), glRotatef()对当前绘图坐标系进行平移、伸缩、旋转变换之后， 世界坐标系和当前绘图坐标系不再重合。改变以
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支持同时使用多个纹理，每个...
OpenGL中的坐标变换、矩阵变换
孙群
06-01 2万+
OpenGL中存在六种坐标系： 1. Object or model coordinates（模型坐标系） 2. World coordinates（世界坐标系） 3. Eye (or Camera) coordinates（视坐标系） 4. Clip coordinates（裁剪坐标系） 5. Normalized device coordinates（归一化设备坐标系） 6. Wi
OpenGL--坐标系详解
JeffersonZHabc的专栏
05-23 3623
OpenGL–坐标系详解 OpenGL最终将图形渲染到的设备屏幕本质上是2D的，我们对图形进行渲染的过程就是将3D场景转换为最终的2D场景的过程。   OpenGl中定义的点从用户构造模型的局部坐标系，经过模型变换转为世界坐标系，再经过视变换转换为相机坐标系，再经过投影变换转换为裁剪坐标系，再进行透视除法转换为规范化设备坐标系(NDC)，最后经过视口变换映射到屏幕坐标系。   坐标变换流程如下...
opengl各个坐标系理解与转换公式
XR风云
12-11 6623
1、标准化设备坐标(Normalized Device Coordinates, NDC) 顶点坐标已经在顶点着色器中处理过，它们就应该是标准化设备坐标了，标准化设备坐标是一个x、y和z值在-1.0到1.0的一小段空间。任何落在范围外的坐标都会被丢弃/裁剪，不会显示在你的屏幕上。 2、UV坐标系 UV坐标系一般以左下角为原点（0,0），经常用于贴图上面。范围为0-1. ...
Android OpenGL ES 开发教程(14)：三维坐标系及坐标变换初步
zwfandroid的专栏
12-30 999
OpenGL ES图形库最终的结果是在二维平面上显示3D物体（常称作模型Model)这是因为目前的打部分显示器还只能显示二维图形。但我们在构造3D模型时必须要有空间现象能力，所有对模型的描述还是使用三维坐标。也就是使用3D建模，而有OpenGL ES库来完成从3D模型到二维屏幕上的显示。 这个过程可以分成三个部分： 坐标变换，坐标变换通过使用变换矩阵来描述，因此学习3D绘图需要了解一些空间
OpenGL 顶点,坐标系,纹理坐标
scott.cgi
08-09 1万+
了解坐标系是绘制图形的基础。在使用openGL的场景中，有世界坐标，局部坐标，纹理坐标，和屏幕坐标几种。 openGL 坐标系：
OpenGL 世界坐标系与纹理坐标系
weixin_34023982的博客
02-03 433
OpenGL 坐标系 OpenGL是一个右手坐标系。就是正x轴在你的右手边，正y轴朝上，而正z轴是朝向后方的。取值是在【-1,1】之间。原点(0,0)在屏幕的中心。 OpenGL世界坐标系 参看下面的右手法则 OpenGL世界坐标系 纹理坐标系 纹理坐标系的取值在【0,1】之间。原点(0,0)在屏幕左下角。 转载于:https://juejin.im/post/5a7586c3f265d...
opengl 顶点坐标系 和 纹理坐标系 起点 和 映射关系
翻肚鱼儿的博客
12-03 1198
顶点坐标系 的 起点是 左下点（-1， -1），接下来是（1，-1） ， （-1， 1） ， （1 ， 1） 是一个反Z形状 纹理坐标系 的起点是 左下点 （0， 0），接下来是 （1 ， 0） ， （0， 1 ）， （1， 1）是一个反Z形状 ...
glViewport()函数和glOrtho()函数的理解
热门推荐
shizhipeng的专栏
12-04 5万+
在OpenGL中有两个比较重要的投影变换函数，glViewport和glOrtho.glOrtho是创建一个正交平行的视景体。 一般用于物体不会因为离屏幕的远近而产生大小的变换的情况。比如，常用的工程中的制图等。需要比较精确的显示。 而作为它的对立情况, glFrustum则产生一个透视投影。这是一种模拟真是生活中，人们视野观测物体的真实情况。例如：观察两条平行的火车到，在过了很远之后，这两条
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、付费专栏及课程。

余额充值