第十一章 OpenGL ES 基础-基础光照

已于 2024-04-19 14:47:45 修改
阅读量684 收藏 19
点赞数 10
分类专栏： OpenGL 文章标签： OpenGL 算法 GLSL
于 2024-04-01 10:47:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012836015/article/details/137222935
版权

第十一章 OpenGL ES 基础-基础光照

第一章 OpenGL ES 基础-屏幕、纹理、顶点坐标
第二章 OpenGL ES 基础-GLSL语法简单总结
第三章 OpenGL ES 基础-GLSL渲染纹理
第四章 OpenGL ES 基础-位移、缩放、旋转原理
第五章 OpenGL ES 基础-透视投影矩阵与正交投影矩阵
第六章 OpenGL ES 基础-FBO、VBO理解与运用
第七章 OpenGL ES 基础-输入输出框架思维
第八章 OpenGL ES 基础-MVP矩阵理解
第九章 OpenGL ES 基础-高斯模糊原理
第十章 OpenGL ES 基础-图像USM锐化
第十一章 OpenGL ES 基础-基础光照
第十二章 OpenGL ES 基础-色温、色调、亮度、对比度、饱和度、高光
第十三章 OpenGL ES-RGB、HSV、HSL模型介绍
第十四章 OpenGL ES-方框模糊（均值模糊）
第十五章 OpenGL ES-VR 全景模式原理
第十六章 OpenGL ES-桶形畸变算法-常用VR

冯氏光照模型

现实世界中的光照是极其复杂，难以计算的，因此OpenGL的光照使用的是简化的模型，其中一个模型被称为冯氏光照模型。

冯氏光照模型的主要结构由三个分量组成：
1、环境(Ambient)光照
2、漫反射(Diffuse)光照
3、镜面(Specular)光照
在这里插入图片描述

环境(Ambient)光照

环境光通常都不是来自于同一个光源，而是来自于我们周围分散的很多光源，即使它们可能并不是那么显而易见。它可以向很多方向发散并反弹，所以现实环境周围通常总会有些光亮，对应的物体通常都会反射些微弱的光。lightColor为光源的颜色，ambientStrength为强度，objectColor为物体颜色。

//环境光的计算
void main()
{
    float ambientStrength = 0.1;
    vec3 ambient = ambientStrength * lightColor;

    vec3 result = ambient * objectColor;
    FragColor = vec4(result, 1.0);
}

漫反射(Diffuse)光照

环境光和漫反射光最大的区别在于：漫反射光依赖于光源的方向，而环境光和光源方向完全无关，环境光在场景中是均匀分布的，对场景中的所有物体都有效，而漫反射光在物体朝向光源的一面才有光照效果，在背面则没有光照效果。除了光源方向，漫反射光还和物体表面的法向有关。
在这里插入图片描述
上图中2个光束的强度都是一样的，唯一不同的只是方向，则在左边的图中，物体表面光照要亮一些，因为光线是直射，而右边的图中，物体表面光照要弱一些，因为有因为有一个角度。

在这里插入图片描述
有四道光A,B,C,D,注意：物体表面法向和A重合，但方向相反。光线A和法向的夹角是0，余弦值就是1，所以A光速光照的强度最大，B次之，C和法向夹角是90度，所以光照强度是0，而D作用与物体的背面，余弦值是个负值，光照强度不可能是个负值，所以D的光照强度也是0，也就是说，光源要在物体表面有光照效果，光源方向和物体表面法向夹角必须是0-90度之间。
如果物体表面是个平面，那么法向就是一个固定的向量，但真实物体表面往往并不是平面，所以物体表面的法向是不断变化的，如下图中的两个法向。
在这里插入图片描述
对三角形面来说，可以取它的面法向计算光照，此时三角形面上的光照是均匀的，但这种光照效果并不好，我们通常都是对每个顶点定义法向，而三角形面光栅化后的每个像素，它的法向是由顶点法向插值得到。这种光照模型称作 Phong Shading， 下面就是顶点法向插值后的效果:
在这里插入图片描述

attribute vec4 aPosition;
attribute vec2 aCoord;
attribute vec3 aNormal;//每个顶点定义法向
uniform mat4 uMatrix; // 物体的矩阵
uniform vec4 uBaseColor; // 物体颜色    物体有a,所以是4个颜色
uniform vec3 uLightColor; // 光源颜色    光源是没有a,所以是3个颜色
uniform float uAmbientStrength;//默认0.3 光强度
uniform float uDiffuseStrength;//默认0.5
uniform float uSpecularStrength;//默认0.8
uniform vec3 uLightPosition;  // 光源位置
varying vec4 vColor;

//在片元着色器中计算光照会获得更好更真实的光照效果，但是会比较耗性能
//在片元着色器里面只需要赋值颜色就可以了


//漫反射的计算
vec4 diffuseColor(){
    //模型变换后的位置
    vec3 fragPos=(uMatrix*aPosition).xyz;
    //光照方向
    vec3 direction=normalize(uLightPosition-fragPos);
    //模型变换后的法线向量
    vec3 normal=normalize(mat3(uMatrix)*aNormal);
    //max(cos(入射角)，0)
    float diff = max(dot(normal,direction), 0.0);
    //材质的漫反射系数*max(cos(入射角)，0)*光照颜色
    vec3 diffuse=uDiffuseStrength * diff * uLightColor;
    return vec4(diffuse,1.0);
}

   vec3 specular=uSpecularStrength*diff*uLightColor;
    return vec4(specular,1.0);
}

void main(){
    gl_Position=uMatrix*aPosition;
    vColor=diffuseColor()* uBaseColor;
}

镜面(Specular)光照

和漫反射光照一样，镜面光照也决定于光的方向向量和物体的法向量，但是它也决定于观察方向，例如玩家是从什么方向看向这个片段的。镜面光照决定于表面的反射特性。如果我们把物体表面设想为一面镜子，那么镜面光照最强的地方就是我们看到表面上反射光的地方。你可以在下图中看到效果：
 在这里插入图片描述
为此我们还需要一个观察者坐标（即摄像机）。光的反射向量与观察方向之间夹角越小,镜面光照效果越强。
物体片段着色器部分代码：


attribute vec4 aPosition;
attribute vec2 aCoord;
attribute vec3 aNormal;//每个顶点定义法向
uniform mat4 uMatrix; // 物体的矩阵
uniform vec4 uBaseColor; // 物体颜色    物体有a,所以是4个颜色
uniform vec3 uLightColor; // 光源颜色    光源是没有a,所以是3个颜色
uniform float uAmbientStrength;//默认0.3 光强度
uniform float uDiffuseStrength;//默认0.5
uniform float uSpecularStrength;//默认0.8
uniform vec3 uLightPosition;  // 光源位置
varying vec4 vColor;

//在片元着色器中计算光照会获得更好更真实的光照效果，但是会比较耗性能
//在片元着色器里面只需要赋值颜色就可以了




//镜面光计算，镜面光计算有两种方式，一种是冯氏模型，一种是Blinn改进的冯氏模型
//这里使用的是改进的冯氏模型，基于Half-Vector的计算方式
vec4 specularColor(){
    //模型变换后的位置
    vec3 fragPos=(uMatrix*aPosition).xyz;
    //光照方向
    vec3 lightDirection=normalize(uLightPosition-fragPos);
    //模型变换后的法线向量
    vec3 normal=normalize(mat3(uMatrix)*aNormal);
    //观察方向，这里将观察点固定在（0，0，uLightPosition.z）处
    vec3 viewDirection=normalize(vec3(0,0,uLightPosition.z)-fragPos);
    //观察向量与光照向量的半向量
    vec3 hafVector=normalize(lightDirection+viewDirection);
    //max(0,cos(半向量与法向量的夹角)^粗糙度
    float diff=pow(max(dot(normal,hafVector),0.0),4.0);
    //材质的镜面反射系数*max(0,cos(反射向量与观察向量夹角)^粗糙度*光照颜色
    //材质的镜面反射系数*max(0,cos(半向量与法向量的夹角)^粗糙度*光照颜色
    vec3 specular=uSpecularStrength*diff*uLightColor;
    return vec4(specular,1.0);
}

void main(){
    gl_Position=uMatrix*aPosition;
    vColor=specularColor()* uBaseColor;
}

具体使用

整个冯氏光照模型的代码如下：

attribute vec4 aPosition;
attribute vec2 aCoord;
attribute vec3 aNormal;
uniform mat4 uMatrix; // 物体的矩阵
uniform vec4 uBaseColor; // 物体颜色    物体有a,所以是4个颜色
uniform vec3 uLightColor; // 光源颜色    光源是没有a,所以是3个颜色
uniform float uAmbientStrength;//默认0.3 光强度
uniform float uDiffuseStrength;//默认0.5
uniform float uSpecularStrength;//默认0.8
uniform vec3 uLightPosition;  // 光源位置
varying vec4 vColor;

//在片元着色器中计算光照会获得更好更真实的光照效果，但是会比较耗性能
//在片元着色器里面只需要赋值颜色就可以了


//环境光的计算
vec4 ambientColor(){
    vec3 ambient = uAmbientStrength * uLightColor;
    return vec4(ambient,1.0);
}

//漫反射的计算
vec4 diffuseColor(){
    //模型变换后的位置
    vec3 fragPos=(uMatrix*aPosition).xyz;
    //光照方向
    vec3 direction=normalize(uLightPosition-fragPos);
    //模型变换后的法线向量
    vec3 normal=normalize(mat3(uMatrix)*aNormal);
    //max(cos(入射角)，0)
    float diff = max(dot(normal,direction), 0.0);
    //材质的漫反射系数*max(cos(入射角)，0)*光照颜色
    vec3 diffuse=uDiffuseStrength * diff * uLightColor;
    return vec4(diffuse,1.0);
}

//镜面光计算，镜面光计算有两种方式，一种是冯氏模型，一种是Blinn改进的冯氏模型
//这里使用的是改进的冯氏模型，基于Half-Vector的计算方式
vec4 specularColor(){
    //模型变换后的位置
    vec3 fragPos=(uMatrix*aPosition).xyz;
    //光照方向
    vec3 lightDirection=normalize(uLightPosition-fragPos);
    //模型变换后的法线向量
    vec3 normal=normalize(mat3(uMatrix)*aNormal);
    //观察方向，这里将观察点固定在（0，0，uLightPosition.z）处
    vec3 viewDirection=normalize(vec3(0,0,uLightPosition.z)-fragPos);
    //观察向量与光照向量的半向量
    vec3 hafVector=normalize(lightDirection+viewDirection);
    //max(0,cos(半向量与法向量的夹角)^粗糙度
    float diff=pow(max(dot(normal,hafVector),0.0),4.0);
    //材质的镜面反射系数*max(0,cos(反射向量与观察向量夹角)^粗糙度*光照颜色
    //材质的镜面反射系数*max(0,cos(半向量与法向量的夹角)^粗糙度*光照颜色
    vec3 specular=uSpecularStrength*diff*uLightColor;
    return vec4(specular,1.0);
}

void main(){
    gl_Position=uMatrix*aPosition;
    vColor=(ambientColor() + diffuseColor() + specularColor())* uBaseColor;
}



precision highp float;

//uniform sampler2D uTexture;
varying vec4 vColor;

void main(){
    gl_FragColor=vColor;
}

package com.opengles.book.es2_0.light;

import android.content.res.Resources;
import android.opengl.GLES20;
import android.opengl.GLSurfaceView;
import android.opengl.Matrix;

import com.opengles.book.es2_0.utils.BufferUtils;
import com.opengles.book.es2_0.utils.MatrixUtils;
import com.opengles.book.es2_0.utils.ShaderUtils;

import java.nio.FloatBuffer;

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


public class LightRenderer implements GLSurfaceView.Renderer {

    private Resources res;
    private int glProgramId;

    private int glAPosition;
    private int glACoord;
    private int glANormal;

    private int glUMatrix;
    private int glUBaseColor;
    private int glULightColor;
    private int glUAmbientStrength;
    private int glUDiffuseStrength;
    private int glUSpecularStrength;
    private int glULightPosition;

    private float[] mvpMatrix; // 物体的矩阵
    private float[] lambMatrix; // 光源的矩阵
    private FloatBuffer vertexBuffer;
    private float lx = 0f, ly = 0.8f, lz = -1f; // 光源位置


    private final float DEFAULT_AMBIENT = 0.3f;
    private final float DEFAULT_DIFFUSE = 0.5f;
    private final float DEFAULT_SPECULAR = 0.8f;

    private float ambientStrength = 0;
    private float diffuseStrength = 0;
    private float specularStrength = 0;


    // 包含了顶点数据，法线数据
    private final float[] data = new float[]{
            -0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f,
            0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f,
            0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f,
            0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f,
            -0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f,
            -0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f,

            -0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f,
            0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f,
            0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f,
            0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f,
            -0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f,
            -0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f,

            -0.5f, 0.5f, 0.5f, -1.0f, 0.0f, 0.0f,
            -0.5f, 0.5f, -0.5f, -1.0f, 0.0f, 0.0f,
            -0.5f, -0.5f, -0.5f, -1.0f, 0.0f, 0.0f,
            -0.5f, -0.5f, -0.5f, -1.0f, 0.0f, 0.0f,
            -0.5f, -0.5f, 0.5f, -1.0f, 0.0f, 0.0f,
            -0.5f, 0.5f, 0.5f, -1.0f, 0.0f, 0.0f,

            0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f,
            0.5f, 0.5f, -0.5f, 1.0f, 0.0f, 0.0f,
            0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f,
            0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f,
            0.5f, -0.5f, 0.5f, 1.0f, 0.0f, 0.0f,
            0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f,

            -0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f,
            0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f,
            0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f,
            0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f,
            -0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f,
            -0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f,

            -0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f,
            0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f,
            0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f,
            0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f,
            -0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f,
            -0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f
    };

    public LightRenderer(Resources res) {
        this.res = res;
        vertexBuffer = BufferUtils.arr2FloatBuffer(data);
    }

    public void setAmbientStrength(boolean isChecked) {
        this.ambientStrength = isChecked ? DEFAULT_AMBIENT : 0;
    }

    public void setDiffuseStrength(boolean isChecked) {
        this.diffuseStrength = isChecked ? DEFAULT_DIFFUSE : 0;
    }

    public void setSpecularStrength(boolean isChecked) {
        this.specularStrength = isChecked ? DEFAULT_SPECULAR : 0;
    }

    @Override
    public void onSurfaceCreated(GL10 gl, EGLConfig config) {
        GLES20.glEnable(GLES20.GL_DEPTH_TEST);

        GLES20.glEnable(GLES20.GL_CULL_FACE);
        GLES20.glCullFace(GLES20.GL_FRONT);
        GLES20.glFrontFace(GLES20.GL_CW);

        glProgramId = ShaderUtils.createProgram(res, "light/light.vert", "light/light.frag");

        glAPosition = GLES20.glGetAttribLocation(glProgramId, "aPosition");
        glACoord = GLES20.glGetAttribLocation(glProgramId, "aCoord");
        glANormal = GLES20.glGetAttribLocation(glProgramId, "aNormal");

        glUMatrix = GLES20.glGetUniformLocation(glProgramId, "uMatrix");
        glUBaseColor = GLES20.glGetUniformLocation(glProgramId, "uBaseColor");
        glULightColor = GLES20.glGetUniformLocation(glProgramId, "uLightColor");

        glUAmbientStrength = GLES20.glGetUniformLocation(glProgramId, "uAmbientStrength");
        glUDiffuseStrength = GLES20.glGetUniformLocation(glProgramId, "uDiffuseStrength");
        glUSpecularStrength = GLES20.glGetUniformLocation(glProgramId, "uSpecularStrength");

        glULightPosition = GLES20.glGetUniformLocation(glProgramId, "uLightPosition");
    }

    @Override
    public void onSurfaceChanged(GL10 gl, int width, int height) {
        // 整体缩小0.5f，相当于置于正中心
        mvpMatrix = MatrixUtils.getOriginalMatrix();
        Matrix.scaleM(mvpMatrix, 0, 0.5f, 0.5f * width / (float) height, 0.5f);

        // 平移指定距离，确定光源位置，并整体缩小0.09
        lambMatrix = MatrixUtils.getOriginalMatrix();
        Matrix.translateM(lambMatrix, 0, lx, ly, lz);
        Matrix.scaleM(lambMatrix, 0, 0.09f, 0.09f * width / (float) height, 0.09f);
    }

    @Override
    public void onDrawFrame(GL10 gl) {
        GLES20.glClear(GLES20.GL_DEPTH_BUFFER_BIT | GLES20.GL_COLOR_BUFFER_BIT);
        GLES20.glClearColor(0.5f, 0.5f, 0.5f, 1.0f);

        GLES20.glUseProgram(glProgramId);
        Matrix.rotateM(mvpMatrix, 0, 2, -1, -1, 1); // 绕xy旋转
        GLES20.glUniformMatrix4fv(glUMatrix, 1, false, mvpMatrix, 0);


        // ---------------- 设置光 start  -----------------
        //环境光强度
        GLES20.glUniform1f(glUAmbientStrength, ambientStrength);
        //漫反射光强度
        GLES20.glUniform1f(glUDiffuseStrength, diffuseStrength);
        //镜面光强度
        GLES20.glUniform1f(glUSpecularStrength, specularStrength);
        //光源颜色
        GLES20.glUniform3f(glULightColor, 0.0f, 0.0f, 1.0f);   // 物体默认颜色是blue
        //物体颜色
        GLES20.glUniform4f(glUBaseColor, 1.0f, 1.0f, 1.0f, 1.0f); // 物体默认颜色是黑色
        //光源位置
        GLES20.glUniform3f(glULightPosition, lx, ly, lz);
        // ---------------- 设置光 end  -----------------


        //传入顶点信息
        vertexBuffer.position(0);
        GLES20.glEnableVertexAttribArray(glAPosition);
        GLES20.glVertexAttribPointer(glAPosition, 3, GLES20.GL_FLOAT, false,
                6*4, //  跨度，一般情况下写0系统会自动识别。识别方式为size*sizeof(数组定义时报类型) 6*4，此处不传跨度会绘制不出来图形，不知为何？？？
                vertexBuffer);

        //传入法线信息
        vertexBuffer.position(3);
        GLES20.glEnableVertexAttribArray(glANormal);
        GLES20.glVertexAttribPointer(glANormal, 3, GLES20.GL_FLOAT, false,
                6*4, //  跨度，一般情况下写0系统会自动识别。识别方式为size*sizeof(数组定义时报类型) 6*4，此处不传跨度会绘制不出来图形，不知为何？？？
                vertexBuffer);

        // 绘制缓冲区的图形
        GLES20.glDrawArrays(GLES20.GL_TRIANGLES,0,data.length/6);

        // 再绘制一个立方体，标记光源位置
        GLES20.glUniformMatrix4fv(glUMatrix,1,false,lambMatrix,0);
        GLES20.glDrawArrays(GLES20.GL_TRIANGLES,0,data.length/6);

        //释放资源
//        GLES20.glDisable(GLES20.GL_CULL_FACE);
//        GLES20.glDisable(GLES20.GL_DEPTH_TEST);
        GLES20.glDisableVertexAttribArray(glAPosition);
        GLES20.glDisableVertexAttribArray(glANormal);

    }
}
baoyu45585
关注
  • 10
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
OpenGL光照基础
m0_37029616的博客
09-25 243
还是简单的盒子，加了光照，看起来可能不够真实
西蒙iphone opengl es 第00章
04-05
OpenGL ES 是一种在嵌入式设备上广泛使用的图形库，主要设计...这个第00章可能是一个引子，为后续章节建立基础，引导学习者逐步掌握 OpenGL ES 的核心原理和实践技巧，从而在 iPhone 平台上创建出引人入胜的视觉体验。
第三章 OpenGL ES 基础-基础-GLSL渲染纹理
u012836015的博客
03-08 1392
vec4 ：是四个分量的向量mat4 ：是4x4的浮点矩阵渲染一张图片纹理写简单的shader在 OpenGL 中，线程调用 GLSL（OpenGL Shading Language）时通常需要注意一些关联问题，以确保正确的操作和流程。GLSL 着色器编译在一个线程中加载、编译和链接 GLSL 着色器程序。确保着色器程序在正确的上下文中创建，并且每个着色器程序都与合适的 OpenGL 上下文相关联。Uniform 和 Attribute 数据传递。
第一章 OpenGL ES 基础-屏幕、纹理、顶点坐标
u012836015的博客
03-07 1645
GL_TRIANGLE_STRIP：指定要绘制的基本图元类型为三角形条带，即每三个顶点定义一个三角形，但从第三个顶点开始，每个新顶点都与前两个顶点一起构成一个新的三角形。坐标系 的 左下点（-1， -1），右下角（1，-1） ， 左上角（-1， 1） ， 右上角（1 ， 1）坐标系 的 左下点 （0， 0），右下角（1 ， 0） ， 左上角（0， 1 ）， 右上角（1， 1）0：指定了要渲染的顶点数组的起始索引，这里表示从顶点数组的第一个顶点开始。使用第二个顶点作为三角形条带的第二个顶点。
第四章 OpenGL ES 基础-位移、缩放、旋转原理
u012836015的博客
03-05 1057
对应矩阵效果注意:必须是相同维度矩阵才行,比如23矩阵不能和33矩阵进行加减矩阵与标量数乘和矩阵与标量加减类似, 实际是对矩阵的每个元素和该标量进行相乘,如下图所示所以值其实就是两个矩阵行列式相乘的和,取出矩阵A的i行下的所有元素与矩阵B的j列下的所有元素进行相乘和。
疯狂android资料：第十二章OpenGL与3D应用开发.doc
09-22
在`onDrawFrame()`方法中，通过GL10接口（实际上是GL11的实例）调用一系列OpenGL ES函数来绘制3D图形。这些函数包括但不限于定义顶点位置、设置颜色、绘制多边形等。开发者需要对3D图形学的基本概念有所了解，如顶点...
OPENGL ES 3.0编程指南 原书第2版
04-18
OpenGL ES 3.0编程指南，作为原书的第二版，是深入理解并掌握移动设备图形编程技术的重要参考资料。本书专为那些希望在Android、iOS等移动平台上利用OpenGL ES进行高性能图形处理的开发者设计。OpenGL ES是OpenGL的...
opengles绘制灰度地形图
10-09
在"opengles11_2"这个项目文件中，可能包含了实现上述步骤的源代码，包括顶点和片段着色器的GLSL代码，以及数据加载和渲染的C++或Java代码。通过阅读和理解这些代码，你可以进一步掌握OpenGL ES在实际应用中的工作...
Android OpenGL ES学习
03-21
同时，掌握良好的图形学基础知识，如几何、投影、光照等，将有助于深入理解和应用OpenGL ES。 通过不断实践和理解这些概念，你可以创建出复杂的3D场景、动态效果以及各种视觉特效，提升Android应用的图形表现力。...
算法 101 对称二叉树(Python)
weixin_51696882的博客
07-18 210
给你一个二叉树的根节点 root ， 检查它是否轴对称。
【18】输出字符菱形
2301_78786609的博客
07-19 365
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。
Held-Karp算法的C++代码
m0_61862494的博客
07-19 243
Held-Karp算法是动态规划的一种应用，用于解决旅行商问题 (TSP)。该算法通过记录部分路径的最小成本来避免重复计算，从而有效地降低计算复杂度。Held-Karp算法使用一个状态压缩动态规划表。表示从起点出发，访问过所有由。表示的集合中的节点，并以节点。结束的最小路径长度。
【算法】深入理解并优化算法：提升软件开发效率与质量
Xiaoxin的博客
07-22 608
在软件开发领域，算法是解决问题的核心工具，它不仅决定了程序的运行效率，还直接影响到用户体验和系统稳定性。随着数据量的爆炸性增长和计算需求的日益复杂，掌握并优化算法成为了每一位开发者必备的技能。本文将从算法的基本概念出发，探讨几种常见的算法类型，分享优化策略，并讨论算法在软件开发中的重要性。
145. 数组子序列的排列（卡码网周赛第二十六期（23年阿里淘天笔试真题））
lulutoy的博客
07-18 394
符合要求的子序列有：{1}，{1}，{1，2}，{1，2}，{1，2，3}，{1，2，3}，{1，2，3，4}，{1，2，3，4}，{1，5，2，3，4}，{1，5，2，3，4}共 10 个。讨厌鬼有一个长度为 n （1 < n < 10^5）的数组，他想知道这个数组有多少个子序列是一个排列?一行一个整数，表示有多少个子序列是一个排列。排列的定义: 长度为 m 的数组，1 到 m 每个元素都出现过，且恰好出现 1 次。子序列的定义: 数组删除若干个元素(也可以不删)后得到的新数组。第一行输入一个整数 n。
2024.7.19 刷题总结
TheJustice_的博客
07-19 222
543.二叉树的直径，这道题是一道考察递归的题目，按照树的一般算法，维护一个最大直径答案值，定义一个递归函数，开头是递归返回条件，即当前节点为空节点就返回0，否则分别往左和往右递归，维护每个节点的最大深度为左右最大深度中的最大值再加一，答案用左右节点的最大深度的和再加一来维护.124.二叉树中的最大路径和，这是一道考察递归的题目，从根节点出发，类似于dfs，分别递归寻找左右节点的路径和，直到叶子节点再返回，从叶子节点往上更新以每个节点为根节点的最大路径，直到返回根节点，用一个变量来维护答案.
2024.7.22
最新发布
white__ice的博客
07-22 428
Q次操作，每次操作有下列两种： •1,l,r,x：表示把l到r的所有ai变成x •2,l,r,x：查询l到r的所有砝码，每个砝码可以用无数次，是否能称出重量x ai和所有的x都不大于m。若tp=1，则第二行有两个正整数n,k，表示天数和小L赚的金币个数。对于30%的数据，n,m,Q≤10 对于50%的数据，n,m,Q≤1000 对于另外20%的数据，opt=2 对于100% 的数据，n,Q≤10。共2行，每行1个字符串，依次表示a,b。有两种方案，每天的价格分别是：[1,1,2,2]，[1,2,1,2]。
算法日记day 13（删除字符串中的所有重复元素）
m0_74980681的博客
07-18 714
初始化栈，将字符串中的元素分别加入栈中，每个元素加入栈时都与栈顶元素进行比较，如果相同则说明元素重复，栈顶元素弹出，继续遍历下一个元素，直到所有元素遍历完毕，此时栈中剩下的元素即为不重复的元素，但此时栈中元素的顺序与题目要求顺序相反，因此需要弹出栈中元素的同时赋给一个新的字符串。例如，在 "abbaca" 中，我们可以删除 "bb" 由于两字母相邻且相同，这是此时唯一可以执行删除操作的重复项。之后我们得到字符串 "aaca"，其中又只有 "aa" 可以执行重复项删除操作，所以最后的字符串为 "ca"。
回溯题目的套路总结
qq_51286996的博客
07-22 90
昨天写完了LeeCode的7，8道回溯算法的题目，写一下总结，这类题目的共同特点就是暴力搜索问题，排列组合或者递归，枚举出所有可能的答案，思路很简单，实现起来的套路也很通用，一回溯问题为例，常用的是构建一颗搜索树，bfs，dfs模板函数名（递归参数）if（这里是终止条件）一般达到终止条件就需要把答案放入for（）push，压入元素，函数名（递归参数）//这里是往下一层进行递归pop递归失败，弹出压入的元素这里是写了一个大致的模板，实际的题目还要对照画出一颗树形图更合适，并且方便理解。
OpenGLES基础：框架与操作详解
OpenGLES提供了基础的3D图形操作，如矩阵变换、光照计算、抗锯齿和像素更新，但并不支持复杂几何建模，而是通过命令来描述如何呈现几何对象，而非直接描述对象本身。 GL命令采用客户端-服务器模式，程序作为客户端...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

baoyu45585

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

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

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

打赏作者

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

抵扣说明：

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

余额充值