GLES学习笔记---立方体贴图（一张图）

一、首先看一张效果图

立方体贴图

二、纹理坐标划分

如上图是一张2D纹理，我们需要将这个2D纹理贴到立方体上，立方体有6个面，所以上面的2D图分成了6个面，共有14个纹理坐标

三、立方体

上边的立方体一共8个顶点坐标，范围是[-1, 1]；

我们要做的是将纹理图贴到这6个面上面

四、顶点坐标纹理坐标关联

我们绘制的时候使用了VBO、VAO、EBO、

vertices里面是纹理坐标和顶点坐标的对应关系，纹理贴到哪个顶点上面；纹理坐标一共十四个，贴到8个顶点上。

indices里面是绘制的12个三角形

float DP = 0.5f;
                        /*顶点               纹理*/
    float vertices[] = {-DP, -DP, DP,     0.25,  0.333,  //0
                         DP, -DP, DP,     0.50,  0.333,  //1
                         DP,  DP, DP,     0.50,  0.666,  //2
                        -DP,  DP, DP,     0.25,  0.666,  //3
                        -DP, -DP, -DP,    1.00,  0.333,  //4
                         DP, -DP, -DP,    0.75,  0.333,  //5
                         DP,  DP, -DP,    0.75,  0.666,  //6
                        -DP,  DP, -DP,    1.00,  0.666,  //7

                        -DP, -DP, -DP,    0.25,    0,    //4  8
                        DP, -DP, -DP,      0.5,    0,    //5  9
                        DP,  DP, -DP,      0.5,    1,    //6  10
                        -DP,  DP, -DP,    0.25,    1,    //7  11

                        -DP, -DP, -DP,       0,  0.333,  //4  12
                        -DP,  DP, -DP,       0,  0.666,  //7  13
                        };

    unsigned int indices[] = {
            0, 1, 2, 0, 2, 3,  // front
            1, 2, 5, 2, 5, 6,  // right
            4, 5, 6, 4, 6, 7,  // back

            0, 3, 12, 3, 12, 13, // left

            0, 1, 8, 1, 8, 9,  // bottom
            2, 3, 10, 3, 10, 11, // top
    };

五、完整代码

有部分代码是测试用的，不用细究奇怪的逻辑

//
// Created by fengcheng.cai on 2023/12/15.
//
#define EGL_EGLEXT_PROTOTYPES
#define GL_GLEXT_PROTOTYPES

#include "com_sprd_opengl_test_MyNdk4.h"
#include <ggl.h>
#include <string.h>
#include <unistd.h>
#include <android/bitmap.h>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>

#define LOG_TAG "MyNdk4"

struct GL_Context4 {
    GLint program;
    EGLDisplay display;
    EGLSurface winSurface;
    EGLContext context;
    ANativeWindow *nw;
    AImageReader *reader;
};
static GL_Context4 gl_cxt;

static char *vertexSimpleShape = "#version 300 es\n"
                                 "layout (location = 0) in vec4 aPosition;\n"
                                 "layout (location = 1) in vec2 aTexCoord;\n"
                                 "uniform mat4 u_MVPMatrix;\n"
                                 "out vec2 TexCoord;\n"
                                 "void main() {\n"
                                 "     gl_Position = u_MVPMatrix * aPosition;\n"
                                 "     TexCoord = aTexCoord;\n"
                                 "}\n";

static char *fragSimpleShape = "#version 300 es\n"
                               "  precision  mediump float;\n"
                               "  in vec2 TexCoord;\n"
                               "  out vec4 FragColor;\n"
                               "  uniform sampler2D ourTexture;\n"
                               "  void main() {\n"
                               "       FragColor = texture(ourTexture, TexCoord);\n"
                               "  }\n";

static GLint initShader(const char *source, GLint type) {
    //创建着色器对象，type表示着色器类型，比如顶点着色器为GL_VERTEX_SHADER，片段着色器为GL_FRAGMENT_SHADER。返回值为一个类似引用的数字。
    GLint sh = glCreateShader(type);
    if (sh == 0) {
        //返回值sh为0则表示创建着色器失败
        LOGD("glCreateShader %d failed", type);
        return 0;
    }
    //着色器对象加载着色器对象代码source
    glShaderSource(sh,
                   1,//shader数量
                   &source,
                   0);//代码长度，传0则读到字符串结尾

    //编译着色器对象
    glCompileShader(sh);

    //以下为打印出编译异常信息
    GLint status;
    glGetShaderiv(sh, GL_COMPILE_STATUS, &status);
    if (status == 0) {
        LOGD("glCompileShader %d failed", type);
        LOGD("source %s", source);
        auto *infoLog = new GLchar[512];
        GLsizei length;
        glGetShaderInfoLog(sh, 512, &length, infoLog);

        LOGD("ERROR::SHADER::VERTEX::COMPILATION_FAILED %s", infoLog);
        return 0;
    }

    LOGD("glCompileShader %d success", type);
    return sh;
}

JNIEXPORT void JNICALL Java_com_sprd_opengl_test_MyNdk4_init
        (JNIEnv *env, jobject obj, jobject surface) {
    // egl ------------------------------------------------------------------- start
    LOGD("init");

    ANativeWindow *nwin = ANativeWindow_fromSurface(env, surface);
    gl_cxt.nw = nwin;

    EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
    if (display == EGL_NO_DISPLAY) {
        LOGD("egl display failed");
        return;
    }

    if (EGL_TRUE != eglInitialize(display, 0, 0)) {
        LOGD("eglInitialize failed");
        return;
    }

    EGLConfig eglConfig;
    EGLint configNum;
    EGLint configSpec[] = {
            EGL_RED_SIZE, 8,
            EGL_GREEN_SIZE, 8,
            EGL_BLUE_SIZE, 8,
            EGL_ALPHA_SIZE, 8,
            EGL_DEPTH_SIZE, 8,
            EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
            EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
            EGL_RECORDABLE_ANDROID, EGL_TRUE,
            EGL_NONE
    };

    if (EGL_TRUE != eglChooseConfig(display, configSpec, &eglConfig, 1, &configNum)) {
        LOGD("eglChooseConfig failed");
        return;
    }

    EGLSurface winSurface = eglCreateWindowSurface(display, eglConfig, nwin, 0);
    if (winSurface == EGL_NO_SURFACE) {
        LOGD("eglCreateWindowSurface failed");
        return;
    }

    const EGLint ctxAttr[] = {
            EGL_CONTEXT_CLIENT_VERSION, 2,
            EGL_NONE
    };

    EGLContext context = eglCreateContext(display, eglConfig, EGL_NO_CONTEXT, ctxAttr);
    if (context == EGL_NO_CONTEXT) {
        LOGD("eglCreateContext failed");
        return;
    }

    if (EGL_TRUE != eglMakeCurrent(display, winSurface, winSurface, context)) {
        LOGD("eglMakeCurrent failed");
        return;
    }
    gl_cxt.display = display;
    gl_cxt.winSurface = winSurface;
    gl_cxt.context = context;

    // egl ------------------------------------------------------------------- end

    // shader ------------------------------------------------------------------- start
    GLint vsh = initShader(vertexSimpleShape, GL_VERTEX_SHADER);
    GLint fsh = initShader(fragSimpleShape, GL_FRAGMENT_SHADER);

    GLint program = glCreateProgram();
    if (program == 0) {
        LOGD("glCreateProgram failed");
        return;
    }

    glAttachShader(program, vsh);
    glAttachShader(program, fsh);

    glLinkProgram(program);
    GLint status2 = 0;
    glGetProgramiv(program, GL_LINK_STATUS, &status2);
    if (status2 == 0) {
        LOGD("glLinkProgram failed");
        return;
    }
    gl_cxt.program = program;
    LOGD("glLinkProgram success");
    // shader ------------------------------------------------------------------- end
}

static void printMat4(glm::mat4 matrix) {
    LOGD("\nll\n%f, %f, %f, %f\n%f, %f, %f, %f\n%f, %f, %f, %f\n%f, %f, %f, %f\n",
             matrix[0][0], matrix[1][0], matrix[2][0], matrix[3][0],
             matrix[0][1], matrix[1][1], matrix[2][1], matrix[3][1],
             matrix[0][2], matrix[1][2], matrix[2][2], matrix[3][2],
             matrix[0][3], matrix[1][3], matrix[2][3], matrix[3][3]);
}

static void printVec4(glm::vec4 vec) {
    LOGD("\nll\n%f, %f, %f, %f\n",
         vec[0], vec[1], vec[2], vec[3]);
}

JNIEXPORT void JNICALL Java_com_sprd_opengl_test_MyNdk4_process
        (JNIEnv *env, jobject obj, jobject bitmap,  jint surfaceW, jint surfaceH) {
    glUseProgram(gl_cxt.program);
    AndroidBitmapInfo bitmapInfo;
    if (AndroidBitmap_getInfo(env, bitmap, &bitmapInfo) < 0) {
        LOGE("AndroidBitmap_getInfo() failed ! ");
        return;
    }
    void *bmpPixels;
    int width = bitmapInfo.width;
    int height = bitmapInfo.height;
    LOGD("process format: %d, stride: %d", bitmapInfo.format, bitmapInfo.stride);
    AndroidBitmap_lockPixels(env, bitmap, &bmpPixels);

    unsigned int textureId;
    glGenTextures(1, &textureId);
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, textureId);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);


    LOGD("process2  4");
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, bmpPixels);
    unsigned char *pOri = (unsigned char *)bmpPixels;
    LOGD("process2  5     %d, %d, %d, %d, %d, %d, %d, %d", *(pOri), *(pOri+1), *(pOri+2), *(pOri+3),
         *(pOri+114), *(pOri+115), *(pOri+116), *(pOri+117));
    glBindTexture(GL_TEXTURE_2D, 0);
    AndroidBitmap_unlockPixels(env, bitmap);

    float DP = 0.5f;
                        /*顶点               纹理*/
    float vertices[] = {-DP, -DP, DP,     0.25,  0.333,  //0
                         DP, -DP, DP,     0.50,  0.333,  //1
                         DP,  DP, DP,     0.50,  0.666,  //2
                        -DP,  DP, DP,     0.25,  0.666,  //3
                        -DP, -DP, -DP,    1.00,  0.333,  //4
                         DP, -DP, -DP,    0.75,  0.333,  //5
                         DP,  DP, -DP,    0.75,  0.666,  //6
                        -DP,  DP, -DP,    1.00,  0.666,  //7

                        -DP, -DP, -DP,    0.25,    0,    //4  8
                        DP, -DP, -DP,      0.5,    0,    //5  9
                        DP,  DP, -DP,      0.5,    1,    //6  10
                        -DP,  DP, -DP,    0.25,    1,    //7  11

                        -DP, -DP, -DP,       0,  0.333,  //4  12
                        -DP,  DP, -DP,       0,  0.666,  //7  13
                        };

    unsigned int indices[] = {
            0, 1, 2, 0, 2, 3,  // front
            1, 2, 5, 2, 5, 6,  // right
            4, 5, 6, 4, 6, 7,  // back

            0, 3, 12, 3, 12, 13, // left

            0, 1, 8, 1, 8, 9,  // bottom
            2, 3, 10, 3, 10, 11, // top
    };
    bool looper = true;
    int count = 0;
    float angleX = 0.0f;
    float angleY = 0.0f;
    float angleZ = 0.0f;
#define MAX_LEN 512
    float near[MAX_LEN] = {0.0f};
    for (int i = 0; i < MAX_LEN / 2; i++) {
        near[i] = 1.0f + 1.0f * i / (MAX_LEN / 2);
    }
    for (int i = 0; i < MAX_LEN / 2; i++) {
        near[i + MAX_LEN / 2] = 2.0f - 1.0f * i / (MAX_LEN / 2);
    }

    int sizeNear = sizeof(near) / sizeof(float);
    while(looper) {
        angleX += 0.5f;
        angleY += 0.6f;
        angleZ += 0.8f;
        glm::mat4 modelM = glm::mat4(1.0f);
        modelM = glm::scale(modelM, glm::vec3(1.0f, 1.0f, 1.0f));
        modelM = glm::rotate(modelM, glm::radians(angleX), glm::vec3(1.0f, 0.0f, 0.0f));
        modelM = glm::rotate(modelM, glm::radians(angleY), glm::vec3(0.0f, 1.0f, 0.0f));
        modelM = glm::rotate(modelM, glm::radians(angleZ), glm::vec3(0.0f, 0.0f, 1.0f));
        modelM = glm::translate(modelM, glm::vec3(0.0f, 0.0f, 0.0f));
        LOGD("modelM:");
        printMat4(modelM);

        glm::mat4 viewM = glm::lookAt(
                glm::vec3(0, 0, 2.88), // Camera is at (0,0,1), in World Space 相机位置
                glm::vec3(0, 0, 0), // and looks at the origin 观察点坐标
                glm::vec3(0, 1, 0));  // Head is up (set to 0,-1,0 to look upside-down) 相机 up 方向，即相机头部朝向
        LOGD("viewM:");
        printMat4(viewM);

        glm::mat4 mv = viewM*modelM;
        printVec4(mv*glm::vec4(-1.0, -1.0, 0, 1));
        printVec4(mv*glm::vec4(1.0, 1.0, 0, 1));
        printVec4(mv*glm::vec4(-1.0, 1.0, 0, 1));
        printVec4(mv*glm::vec4(1.0, -1.0, 0, 1));


        float ratio = 1.0f * width / height;
        LOGD("ratio: %f, width: %d, height: %d, surfaceW: %d, surfaceH: %d", ratio, width, height, surfaceW, surfaceH);
        glm::mat4 prjM;
        if (1.0f * height / width > 1.0f * surfaceH / surfaceW) {
            prjM = glm::ortho(-1.0f * width / height, 1.0f * width / height, -1.0f, 1.0f, 0.0f, 100.0f); //ratio 一般表示视口的宽高比，width/height
        } else {
            prjM = glm::ortho(-1.0f, 1.0f,
                              -1.0f * surfaceH / (1.0f*surfaceW*height/width), 1.0f * surfaceH / (1.0f*surfaceW*height/width),
                              3.0f, 100.0f);
        }

        prjM = glm::ortho(-1.0f, 1.0f,
                          -1.0f, 1.0f,
                          1.5f, 100.0f);  // 这两个值其实是负的方向更好理解

        printMat4(prjM);


//    prjM = glm::perspective(glm::radians(45.0f), 1.0f * surfaceW / surfaceH, 2.6f, 100.f); //ratio 一般表示视口的宽高比，width/height,
//    LOGD("prjM:");
//    printMat4(prjM);

        prjM = glm::frustum(-1.0f, 1.0f,
                        -1.0f, 1.0f,
                        near[count%sizeNear], 100.f);
        LOGD("prjM:");
        printMat4(prjM);



        glm::mat4 mvp = prjM*viewM*modelM;
        printVec4(mvp*glm::vec4(-DP, -DP, DP, 1));
        printVec4(mvp*glm::vec4(-DP, -DP, -DP, 1));

        //mvp = glm::mat4(1.0f);
        GLint mvpLoc = glGetUniformLocation(gl_cxt.program, "u_MVPMatrix");
        glUniformMatrix4fv(mvpLoc, 1, GL_FALSE, (GLfloat *)&mvp[0][0]);

        // optimal
        unsigned int VBO, EBO, VAO;
        glGenVertexArrays(1, &VAO);
        glBindVertexArray(VAO);

        glGenBuffers(1, &VBO);
        glBindBuffer(GL_ARRAY_BUFFER, VBO);
        glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
        glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)((0 + 3)*sizeof(float)));
        glEnableVertexAttribArray(0);
        glEnableVertexAttribArray(1);

        glGenBuffers(1, &EBO);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
        glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);

        glBindVertexArray(0);


        glBindVertexArray(VAO);
        glEnable(GL_DEPTH_TEST);
        glDepthFunc(GL_LEQUAL);
        glEnable(GL_TEXTURE_2D);
        glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

        // draw to screen
        glActiveTexture(GL_TEXTURE0);
        glBindTexture(GL_TEXTURE_2D, textureId);
        glDrawElements(GL_TRIANGLES, sizeof(indices) / sizeof(int), GL_UNSIGNED_INT, (void*)0);
        glBindTexture(GL_TEXTURE_2D, 0);

        glDisableVertexAttribArray(0);
        glDisableVertexAttribArray(1);
        glBindVertexArray(0);

        eglSwapBuffers(gl_cxt.display, gl_cxt.winSurface);

        count++;
        usleep(15 * 1000);
        if (count == 99999) {
            looper = false;
        }
    }


    LOGD("process2 X");
}

JNIEXPORT void JNICALL Java_com_sprd_opengl_test_MyNdk4_uninit
        (JNIEnv *env, jobject obj) {
    LOGD("uninit");
    eglDestroySurface(gl_cxt.display, gl_cxt.winSurface);
    eglDestroyContext(gl_cxt.display, gl_cxt.context);
    eglMakeCurrent(gl_cxt.display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
    eglTerminate(gl_cxt.display);

    gl_cxt.winSurface = EGL_NO_SURFACE;
    gl_cxt.display = EGL_NO_DISPLAY;
    gl_cxt.context = EGL_NO_CONTEXT;
}

六、注意点

EGLint configSpec[] = {
            EGL_RED_SIZE, 8,
            EGL_GREEN_SIZE, 8,
            EGL_BLUE_SIZE, 8,
            EGL_ALPHA_SIZE, 8,
            EGL_DEPTH_SIZE, 8,
            EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
            EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
            EGL_RECORDABLE_ANDROID, EGL_TRUE,
            EGL_NONE
    };


glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);

一定要配置 EGL_DEPTH_SIZE，我调试的时候没有配置EGL_DEPTH_SIZE（即使

glEnable(GL_DEPTH_TEST)调用了），导致绘制的立方体一直有问题，没有立体效果

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/312584.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Redis（四）事务

Redis（四）事务

文章目录 事务Redis事务 vs 数据库事务常用命令总结 事务 一个队列中、一次性、顺序性、排他性执行一系列命令 官网https://redis.io/docs/interact/transactions/ Redis事务 vs 数据库事务 概述详述1、单独的隔离操作Redis的事务仅仅是保证事务里的操作会被连续独占的执行&a…
阅读更多...
2022 年全国职业院校技能大赛高职组云计算赛项试卷

2022 年全国职业院校技能大赛高职组云计算赛项试卷

【赛程名称】云计算赛项第一场-私有云 某企业拟使用OpenStack 搭建一个企业云平台&#xff0c;以实现资源池化弹性管理、企业应用集中管理、统一安全认证和授权等管理。 系统架构如图 1 所示&#xff0c;IP 地址规划如表 1 所示。 图 1 系统架构图 表 1 IP 地址规划 设备…
阅读更多...
Java零基础教学文档第四篇：HTML_CSS_JavaScript（2）

Java零基础教学文档第四篇：HTML_CSS_JavaScript（2）

【HTML】 【主要内容】WEB: 1&#xff0e;Web前端简介 2&#xff0e;创建第一个前端项目 3&#xff0e;相关标签详解 4&#xff0e;表格标签详解 5&#xff0e;表单标签详解 6&#xff0e;框架和实体字符 【学习目标】 1. Web前端简介 1.1 为什么要学习Web前端&#…
阅读更多...
【Python机器学习】SVM——预处理数据

【Python机器学习】SVM——预处理数据

为了解决特征特征数量级差异过大&#xff0c;导致的模型过拟合问题&#xff0c;有一种方法就是对每个特征进行缩放&#xff0c;使其大致处于同一范围。核SVM常用的缩放方法是将所有的特征缩放到0和1之间。 “人工”处理方法&#xff1a; import matplotlib.pyplot as plt from…
阅读更多...
Java异常处理之旅：解救迷失的程序员

Java异常处理之旅：解救迷失的程序员

目录​​​​​​​ 一、前言 二、基础知识 2.1 异常的概念 ​​​​​​2.2 异常分类 2.3 异常处理的原则 ​​​​​​三、异常处理的语法 3.1 try-catch语句 3.2 finally语句 3.3 throw语句 3.4 throws关键字 3.5 自定义异常 四、常见异常及处理方式 4.1 NullP…
阅读更多...
【C语言】linux内核set_task_stack_end_magic函数

【C语言】linux内核set_task_stack_end_magic函数

一、函数定义 void set_task_stack_end_magic(struct task_struct *tsk) {unsigned long *stackend;stackend end_of_stack(tsk);*stackend STACK_END_MAGIC; /* for overflow detection */ } 内核版本6.4.3、6.7。 二、代码解读 解读1 这段代码是一个在Linux内核中定…
阅读更多...
芯课堂 | 固件升级方法及架构

芯课堂 | 固件升级方法及架构

本次介绍一种固件升级方法及架构。 所述方法通过运行引导加载程序&#xff0c;并基于引导加载程序&#xff0c;获取启动引导标志位&#xff1b; 在启动引导标志位为预设枚举标志位时&#xff0c;执行对应启动引导标志位的固件升级动作&#xff1b; 在启动引导标志位为非预设…
阅读更多...
Cesium 模型压平

Cesium 模型压平

最近整理了下手上的代码&#xff0c;以下是对模型压平的说明。 原理是使用了customShader来重新设置了模型的着色器&#xff0c;通过修改模型顶点的坐标来实现了压平。 废话不多说&#xff0c;下面上代码&#xff1a; /*** class* description 3dtiles模型压平*/ class Flat…
阅读更多...
leetcode 每日一题 2024年01月11日 构造有效字符串的最少插入数

leetcode 每日一题 2024年01月11日 构造有效字符串的最少插入数

题目 2645. 构造有效字符串的最少插入数 给你一个字符串 word &#xff0c;你可以向其中任何位置插入 “a”、“b” 或 “c” 任意次&#xff0c;返回使 word 有效 需要插入的最少字母数。 如果字符串可以由 “abc” 串联多次得到&#xff0c;则认为该字符串 有效 。 示例 …
阅读更多...
辞旧岁，赢新篇，创维汽车召开年度会议立足过去，展望未来

辞旧岁，赢新篇，创维汽车召开年度会议立足过去，展望未来

为辞旧迎新&#xff0c;再创辉煌&#xff0c;创维汽车于1月4日-5日召开了事业部年度会议。本次会议将23年整体运营情况作出总结并对新一年的发展作出了目标规划。创维集团、创维汽车创始人黄宏生先生&#xff0c;开沃新能源汽车集团执行董事兼首席运营官诸萍女士&#xff0c;创…
阅读更多...
记录一次华为云服务器扩容系统磁盘

记录一次华为云服务器扩容系统磁盘

转载说明&#xff1a;如果您喜欢这篇文章并打算转载它&#xff0c;请私信作者取得授权。感谢您喜爱本文&#xff0c;请文明转载&#xff0c;谢谢。 1. 扩容步骤 1.1 在华为云控制台操作磁盘扩容 1.2 服务器上操作扩容步骤 1&#xff09;fdisk -l 查看扩容情况&#xff0c;确认…
阅读更多...
git: Updates were rejected because the tip of your current branch is behind

git: Updates were rejected because the tip of your current branch is behind

一、报错含义 由于本地分支的tip落后远程分支&#xff0c;push操作被拒绝。 二、产生原因 我再本地拉去了新的分支并未同步到远程仓库&#xff0c;在新分支进行开发&#xff0c;由于前几天同步也创建了该分支并同步到了远程仓库&#xff0c;导致我本次push失败 三、解决方…
阅读更多...
【CSS】首个字符占用多行，并自定义样式

【CSS】首个字符占用多行，并自定义样式

效果 代码 <!DOCTYPE html> <html lang"en"><head><meta charset"UTF-8" /><meta name"viewport" content"widthdevice-width, initial-scale1.0" /><title>首字母大写</title><style&…
阅读更多...
C++力扣题目111--二叉树的最小深度

C++力扣题目111--二叉树的最小深度

力扣题目链接(opens new window) 给定一个二叉树&#xff0c;找出其最小深度。 最小深度是从根节点到最近叶子节点的最短路径上的节点数量。 说明: 叶子节点是指没有子节点的节点。 示例: 给定二叉树 [3,9,20,null,null,15,7], 返回它的最小深度 2 思路 看完了这篇104.二…
阅读更多...
原生微信小程序-两次设置支付密码校验，密码设置二次确认

原生微信小程序-两次设置支付密码校验，密码设置二次确认

效果 具体代码 1、wxml <view style"{{themeColor}}"><view classcontainer><view class"password_content"><view wx:if{{type 1}}><view class"title"><view class"main_title">设置支付密码…
阅读更多...
【Android开发】不同Activity之间的数据回传实例（一）摘桃子游戏

【Android开发】不同Activity之间的数据回传实例（一）摘桃子游戏

一、功能介绍 该项目实现的功能主要有&#xff1a; 在首页显示一个按钮点击该按钮跳转到桃园页面在桃园页面&#xff0c;点击桃子会弹窗显示摘到几个桃子&#xff0c;同时被点击桃子消失&#xff0c;总桃子数1点击退出桃园会返回首页&#xff0c;首页桃子数会根据点击的桃子数…
阅读更多...
PPT插件-大珩助手-《提取选中的幻灯片》-选中新建

PPT插件-大珩助手-《提取选中的幻灯片》-选中新建

选中新建 提取选中的幻灯片到新的幻灯文稿中。PDF编辑器可以提取指定的页面到新的PDF文档中&#xff0c;PPT没有这个功能&#xff0c;因此开发。 软件介绍 PPT大珩助手是一款全新设计的Office PPT插件&#xff0c;它是一款功能强大且实用的PPT辅助工具&#xff0c;支持Wps Wo…
阅读更多...
锂电池的电压和容量怎么计算？

锂电池的电压和容量怎么计算？

锂电池组是由电池单体&#xff08;电芯&#xff09;通过串并联来组成 1、串联(S)增加电压&#xff0c;容量不变。 例如&#xff1a;1个磷酸铁锂电池的额定电压为3.2V&#xff0c;容量为4000mAH&#xff0c;将10个磷酸铁锂电芯串联&#xff0c;电池组电压&#xff1a;3.2v*10&a…
阅读更多...
usb静电防护芯片选择

usb静电防护芯片选择

方案1 USBLC6-2SC6 优缺点 优点&#xff1a;进出使用不同的焊盘&#xff0c;如果没有焊接好信号必定不能通过。有效的避免了虚焊导致故障。 缺点&#xff1a;不能省略&#xff0c;调试时也不能省略。 原理图 参考价格 参考来源 USB切换方案&#xff0c;多电脑共用USB方案…
阅读更多...
leecode1143 | 最长公共子序列

leecode1143 | 最长公共子序列

给定两个字符串 text1 和 text2&#xff0c;返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 &#xff0c;返回 0 。 一个字符串的 子序列 是指这样一个新的字符串&#xff1a;它是由原字符串在不改变字符的相对顺序的情况下删除某些字符&#xff08;也可以不…
阅读更多...
最新文章

Copyright @ 2022~2023