LearnOpenGL学习（光照 -- 颜色，基础光照，材质，光照贴图）

news2024/12/4 17:28:52

光照 

glm::vec3 lightColor(0.0f, 1.0f, 0.0f);
glm::vec3 toyColor(1.0f, 0.5f, 0.31f);
glm::vec3 result = lightColor * toyColor; // = (0.0f, 0.5f, 0.0f);

说明：当我们把光源的颜色与物体的颜色值相乘，所得到的就是这个物体所反射的颜色。

创建一个光照场景

#shader vertex
#version 330 core

layout(location = 0) in vec3 aPos;

uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;

void main()
{
	gl_Position = projection * view * model * vec4(aPos, 1.0);
};

#shader fragment
#version 330 core

out vec4 FragColor;

uniform vec3 objectColor;
uniform vec3 lightColor;

void main()
{
	FragColor = vec4(lightColor * objectColor, 1.0);
};

很简单，只需要计算一个光照

摄像机从正方体正中心看过去显示一个正方形，我还以为写错了，查了半天错，头都秃了。。。。

#include "TestLightColor.h"

#include "Render.h"
#include "imgui/imgui.h"

#include <glm/ext/matrix_clip_space.hpp>
#include <glm/ext/matrix_transform.hpp>
#include <GLFW/glfw3.h>

namespace test {

    void TestLightColor_scroll_callback(GLFWwindow* window, double xoffset, double yoffset);
    void TestLightColor_mouse_callback(GLFWwindow* window, double xposIn, double yposIn);

	TestLightColor::TestLightColor() : camera(glm::vec3(0.0f,0.0f,6.0f)) {
        float vertices[] = {
        -0.5f, -0.5f, -0.5f,
         0.5f, -0.5f, -0.5f,
         0.5f,  0.5f, -0.5f,
         0.5f,  0.5f, -0.5f,
        -0.5f,  0.5f, -0.5f,
        -0.5f, -0.5f, -0.5f,

        -0.5f, -0.5f,  0.5f,
         0.5f, -0.5f,  0.5f,
         0.5f,  0.5f,  0.5f,
         0.5f,  0.5f,  0.5f,
        -0.5f,  0.5f,  0.5f,
        -0.5f, -0.5f,  0.5f,

        -0.5f,  0.5f,  0.5f,
        -0.5f,  0.5f, -0.5f,
        -0.5f, -0.5f, -0.5f,
        -0.5f, -0.5f, -0.5f,
        -0.5f, -0.5f,  0.5f,
        -0.5f,  0.5f,  0.5f,

         0.5f,  0.5f,  0.5f,
         0.5f,  0.5f, -0.5f,
         0.5f, -0.5f, -0.5f,
         0.5f, -0.5f, -0.5f,
         0.5f, -0.5f,  0.5f,
         0.5f,  0.5f,  0.5f,

        -0.5f, -0.5f, -0.5f,
         0.5f, -0.5f, -0.5f,
         0.5f, -0.5f,  0.5f,
         0.5f, -0.5f,  0.5f,
        -0.5f, -0.5f,  0.5f,
        -0.5f, -0.5f, -0.5f,

        -0.5f,  0.5f, -0.5f,
         0.5f,  0.5f, -0.5f,
         0.5f,  0.5f,  0.5f,
         0.5f,  0.5f,  0.5f,
        -0.5f,  0.5f,  0.5f,
        -0.5f,  0.5f, -0.5f,
        };

        unsigned int indices[] = {
            0,1,2,
            3,4,5,
            6,7,8,
            9,10,11,
            12,13,14,
            15,16,17,
            18,19,20,
            21,22,23,
            24,25,26,
            27,28,29,
            30,31,32,
            33,34,35
        };

        GLCall(glEnable(GL_BLEND));
        GLCall(glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));

        m_VAO = std::make_unique<VertexArray>();
        
        m_VertexBuffer = std::make_unique<VertexBuffer>(vertices, sizeof(vertices));
        VertexBufferLayout layout;
        layout.Push<float>(3);
        m_VAO->AddBuffer(*m_VertexBuffer, layout);
        m_IndexBuffer = std::make_unique<IndexBuffer>(indices, 36);

        m_ColorShader = std::make_unique<Shader>("res/shaders/LightColor.shader"); 
        m_CubeShader = std::make_unique<Shader>("res/shaders/LightCube.shader");

        m_ColorShader->Bind();
        m_CubeShader->Bind();
	}

	TestLightColor::~TestLightColor() {

	}

    void TestLightColor::OnStart(GLFWwindow* window) {
        glEnable(GL_DEPTH_TEST);
        m_Window = window;

        glfwSetWindowUserPointer(m_Window, reinterpret_cast<void*>(this));

        glfwSetCursorPosCallback(m_Window, test::TestLightColor_mouse_callback);
        glfwSetScrollCallback(m_Window, test::TestLightColor_scroll_callback);

        glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
    }

	void TestLightColor::OnUpdate(float delteTime) {

	}

	void TestLightColor::OnRender() {
        processInput(m_Window);
        float currentFrame = static_cast<float>(glfwGetTime());
        deltaTime = currentFrame - lastFrame;
        lastFrame = currentFrame;

        constexpr Render render;

        //processInput(m_Window);

        GLCall(glClearColor(0.0f, 0.0f, 0.0f, 1.0f));
        GLCall(glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT));

        GLCall(m_ColorShader->Bind());

        //GLCall(m_ColorShader->SetUniform3f("objectColor", 1.0f, 0.5f, 0.31f));
        //GLCall(m_ColorShader->SetUniform3f("lightColor", 1.0f, 1.0f, 1.0f));

        //glm::mat4 projection = glm::mat4(1.0f);
        glm::mat4  projection = glm::perspective(glm::radians(camera.Zoom),
            (float)test::SCR_WIDTH / (float)test::SCR_HEIGHT, 0.1f, 100.0f);
        glm::mat4 view = camera.GetViewMatrix();
        GLCall(m_ColorShader->SetUniformMat4f("projection", projection));
        GLCall(m_ColorShader->SetUniformMat4f("view", view));

        glm::mat4 model = glm::mat4(1.0f);
        GLCall(m_ColorShader->SetUniformMat4f("model", model));

        GLCall(m_VAO->Bind());
        GLCall(render.Draw(*m_VAO, *m_IndexBuffer, *m_ColorShader));

        GLCall(m_VAO->Bind());
        GLCall(m_CubeShader->Bind());
        GLCall(m_CubeShader->SetUniformMat4f("projection", projection));
        GLCall(m_CubeShader->SetUniformMat4f("view", view));
        model = glm::mat4(1.0f);
        model = glm::translate(model, lightPos);
        model = glm::scale(model, glm::vec3(2.0f));
        m_CubeShader->SetUniformMat4f("model", model);
        GLCall(render.Draw(*m_VAO, *m_IndexBuffer, *m_CubeShader));
        
	}

	void TestLightColor::OnImGuiRender() {
	
	}

    void TestLightColor::mouse_callback(GLFWwindow* window, double xposIn, double yposIn) {
        float xpos = static_cast<float>(xposIn);
        float ypos = static_cast<float>(yposIn);

        if (firstMouse)
        {
            lastX = xpos;
            lastY = ypos;
            firstMouse = false;
        }

        float xoffset = xpos - lastX;
        float yoffset = lastY - ypos; // reversed since y-coordinates go from bottom to top

        lastX = xpos;
        lastY = ypos;

        camera.ProcessMouseMovement(xoffset, yoffset);
    }

    void TestLightColor::scroll_callback(GLFWwindow* window, double xoffset, double yoffset) {
        camera.ProcessMouseScroll(static_cast<float>(yoffset));
    }

    void TestLightColor_mouse_callback(GLFWwindow* window, double xposIn, double yposIn) {
        TestLightColor* light = reinterpret_cast<TestLightColor*>(glfwGetWindowUserPointer(window));
        light->mouse_callback(window, xposIn, yposIn);
    }

    void TestLightColor_scroll_callback(GLFWwindow* window, double xoffset, double yoffset) {
        TestLightColor* light = reinterpret_cast<TestLightColor*>(glfwGetWindowUserPointer(window));
        light->mouse_callback(window, xoffset, yoffset);
    }

}

 基础光照

  • 环境光照(Ambient Lighting)：即使在黑暗的情况下，世界上通常也仍然有一些光亮（月亮、远处的光），所以物体几乎永远不会是完全黑暗的。为了模拟这个，我们会使用一个环境光照常量，它永远会给物体一些颜色。
  • 漫反射光照(Diffuse Lighting)：模拟光源对物体的方向性影响(Directional Impact)。它是风氏光照模型中视觉上最显著的分量。物体的某一部分越是正对着光源，它就会越亮。
  • 镜面光照(Specular Lighting)：模拟有光泽物体上面出现的亮点。镜面光照的颜色相比于物体的颜色会更倾向于光的颜色。

环境光照

void main()
{
    float ambientStrength = 0.1;
    vec3 ambient = ambientStrength * lightColor;

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

漫反射光照

为了（只）得到两个向量夹角的余弦值，我们使用的是单位向量（长度为1的向量），所以我们需要确保所有的向量都是标准化的，否则点乘返回的就不仅仅是余弦值了

法向量

#version 330 core
layout (location = 0) in vec3 aPos;
layout (location = 1) in vec3 aNormal;
...

修改橙色方块的着色器：（增加了漫反射）

#shader vertex
#version 330 core

layout (location = 0) in vec3 aPos;
layout (location = 1) in vec3 aNormal;

out vec3 Normal;
out vec3 FragPos;

uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;

void main()
{
	FragPos = vec3(model * vec4(aPos, 1.0));
	Normal = aNormal;

	gl_Position = projection * view * model * vec4(aPos, 1.0);
};

#shader fragment
#version 330 core

in vec3 Normal;
in vec3 FragPos;

out vec4 FragColor;


uniform vec3 objectColor;
uniform vec3 lightColor;
uniform vec3 lightPos;

void main()
{
	//ambient
	float ambientStrength = 0.1;
	vec3 ambient = ambientStrength * lightColor;

	//diffuse
	vec3 norm = normalize(Normal);
	vec3 lightDir = normalize(lightPos - FragPos);
	float diff = max(dot(norm, lightDir), 0.0);
	vec3 diffuse = diff * lightColor;

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

在顶点着色器中，我们可以使用inverse和transpose函数自己生成这个法线矩阵，这两个函数对所有类型矩阵都有效。注意我们还要把被处理过的矩阵强制转换为3×3矩阵，来保证它失去了位移属性以及能够乘以vec3的法向量。

Normal = mat3(transpose(inverse(model))) * aNormal;

 镜面光照

//specular 
	float specularStrength = 0.5f;
	vec3 viewDir = normalize(viewPos - FragPos);
	vec3 reflectDir = reflect(-lightDir, norm);
	float spec = pow(max(dot(viewDir, reflectDir), 0.0), 32);
	vec3 specular = specularStrength * spec * lightColor;

在顶点着色器中实现的风氏光照模型叫做Gouraud着色(Gouraud Shading)，而不是风氏着色(Phong Shading)。记住，由于插值，这种光照看起来有点逊色。风氏着色能产生更平滑的光照效果。

材质

#version 330 core
struct Material {
    vec3 ambient;
    vec3 diffuse;
    vec3 specular;
    float shininess;
}; 

uniform Material material;

在片段着色器中，我们创建一个结构体(Struct)来储存物体的材质属性。我们也可以把它们储存为独立的uniform值，但是作为一个结构体来储存会更有条理一些

void main()
{    
    // 环境光
    vec3 ambient = lightColor * material.ambient;

    // 漫反射 
    vec3 norm = normalize(Normal);
    vec3 lightDir = normalize(lightPos - FragPos);
    float diff = max(dot(norm, lightDir), 0.0);
    vec3 diffuse = lightColor * (diff * material.diffuse);

    // 镜面光
    vec3 viewDir = normalize(viewPos - FragPos);
    vec3 reflectDir = reflect(-lightDir, norm);  
    float spec = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess);
    vec3 specular = lightColor * (spec * material.specular);  

    vec3 result = ambient + diffuse + specular;
    FragColor = vec4(result, 1.0);
}

 忘写分号。。。

光的属性

物体过亮的原因是环境光、漫反射和镜面光这三个颜色对任何一个光源都全力反射。

如果我们假设 lightcolor 是 1.0，那么代码会是这样的：

vec3 ambient  = vec3(1.0) * material.ambient;
vec3 diffuse  = vec3(1.0) * (diff * material.diffuse);
vec3 specular = vec3(1.0) * (spec * material.specular);

所以物体的每个材质属性对每一个光照分量都返回了最大的强度。

为光照属性创建类似材质结构体的东西：

struct Light {
    vec3 position;

    vec3 ambient;
    vec3 diffuse;
    vec3 specular;
};

uniform Light light;
vec3 ambient  = light.ambient * material.ambient;
vec3 diffuse  = light.diffuse * (diff * material.diffuse);
vec3 specular = light.specular * (spec * material.specular);

调节各种类型的光的强度

glm::vec3 lightColor;
        lightColor.x = sin(glfwGetTime() * 2.0f);
        lightColor.y = sin(glfwGetTime() * 0.7f);
        lightColor.z = sin(glfwGetTime() * 1.3f);

        glm::vec3 diffuseColor = lightColor * glm::vec3(0.5f); // 降低影响
        glm::vec3 ambientColor = diffuseColor * glm::vec3(0.2f); // 很低的影响

        GLCall(m_ColorShader->Bind());

        GLCall(m_ColorShader->SetUniform3f("light.ambient", ambientColor));
        GLCall(m_ColorShader->SetUniform3f("light.diffuse", diffuseColor));

改变光源的环境光和漫反射颜色，让其随着时间变化

光照贴图

漫反射贴图

注意 sampler2D 是所谓的不透明类型(Opaque Type)，也就是说我们不能将它实例化，只能通过uniform来定义它。如果我们使用除uniform以外的方法（比如函数的参数）实例化这个结构体，GLSL会抛出一些奇怪的错误。这同样也适用于任何封装了不透明类型的结构体。

使用贴图

#shader vertex
#version 330 core

layout (location = 0) in vec3 aPos;
layout (location = 1) in vec3 aNormal;
layout (location = 2) in vec2 aTexCoords;

out vec3 Normal;
out vec3 FragPos;
out vec2 TexCoords;

uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;

void main()
{
	FragPos = vec3(model * vec4(aPos, 1.0));
	Normal = aNormal;
	TexCoords = aTexCoords;

	gl_Position = projection * view * model * vec4(aPos, 1.0);
};

#shader fragment
#version 330 core

in vec3 Normal;
in vec3 FragPos;

struct Light {
	vec3 position;
	vec3 ambient;
	vec3 diffuse;
	vec3 specular;
};

struct Material {
	sampler2D diffuse;
	vec3 specular;
	float shininess;
};

in vec2 TexCoords;

out vec4 FragColor;

uniform Light light;
uniform Material material;
uniform vec3 lightPos;
uniform vec3 viewPos;

void main()
{
	//ambient
	vec3 ambient = light.ambient * vec3(texture(material.diffuse, TexCoords));

	//diffuse
	vec3 norm = normalize(Normal);
	vec3 lightDir = normalize(lightPos - FragPos);
	float diff = max(dot(norm, lightDir), 0.0);
	vec3 diffuse = light.diffuse * diff * vec3(texture(material.diffuse, TexCoords));

	//specular 
	vec3 viewDir = normalize(viewPos - FragPos);
	vec3 reflectDir = reflect(-lightDir, norm);
	float spec = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess);
	vec3 specular = light.specular * (spec * material.specular);

	vec3 result = ambient + diffuse + specular;
	FragColor = vec4(result, 1.0);
};

镜面光贴图

 链接：container2_specular.png (500×500)

我们想要让物体的某些部分以不同的强度显示镜面高光。我们可以使用一个专门用于镜面高光的纹理贴图。这也就意味着我们需要生成一个黑白的（如果你想得话也可以是彩色的）纹理，来定义物体每部分的镜面光强度。

镜面光贴图上的每个像素都可以由一个颜色向量来表示，一个像素越「白」，乘积就会越大，物体的镜面光分量就会越亮。

采样镜面光贴图

//cpp
lightingShader.setInt("material.specular", 1);
...
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, specularMap);


//shader
struct Material {
    sampler2D diffuse;
    sampler2D specular;
    float     shininess;
};

vec3 ambient  = light.ambient  * vec3(texture(material.diffuse, TexCoords));
vec3 diffuse  = light.diffuse  * diff * vec3(texture(material.diffuse, TexCoords));  
vec3 specular = light.specular * spec * vec3(texture(material.specular, TexCoords));
FragColor = vec4(ambient + diffuse + specular, 1.0);

通过使用镜面光贴图我们可以对物体设置大量的细节，比如物体的哪些部分需要有闪闪发光的属性，我们甚至可以设置它们对应的强度。镜面光贴图能够在漫反射贴图之上给予我们更高一层的控制。

参考：颜色 - LearnOpenGL CN

基础光照 - LearnOpenGL CN

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

面向对象(二)——类和对象(上)

面向对象(二)——类和对象(上)

1 类的定义 做了关于对象的很多介绍&#xff0c;终于进入代码编写阶段。 本节中重点介绍类和对象的基本定义&#xff0c;属性和方法的基本使用方式。 【示例】类的定义方式 // 每一个源文件必须有且只有一个public class&#xff0c;并且类名和文件名保持一致&#xff01; …
阅读更多...
3GPP R18 LTM(L1/L2 Triggered Mobility)是什么鬼？(三) RACH-less LTM cell switch

3GPP R18 LTM(L1/L2 Triggered Mobility)是什么鬼？(三) RACH-less LTM cell switch

这篇看下RACH-less LTM cell switch。 相比于RACH-based LTM，RACH-less LTM在进行LTM cell switch之前就要先知道target cell的TA信息，进而才能进行RACH-less过程，这里一般可以通过UE自行测量或者通过RA过程获取，而这里的RA一般是通过PDCCH order过程触发。根据38.300中的描…
阅读更多...
实验13 使用预训练resnet18实现CIFAR-10分类

实验13 使用预训练resnet18实现CIFAR-10分类

1.数据预处理 首先利用函数transforms.Compose定义了一个预处理函数transform&#xff0c;里面定义了两种操作&#xff0c;一个是将图像转换为Tensor&#xff0c;一个是对图像进行标准化。然后利用函数torchvision.datasets.CIFAR10下载数据集&#xff0c;这个函数有四个常见的…
阅读更多...
P1226 快速幂

P1226 快速幂

【STUACM-算法入门-快速幂】https://www.bilibili.com/video/BV1Hi4y1L7qB?p2&vd_sourcee583d26dc0028b3e6ea220aadf5bc7fe 想先把a的b次方算出来再对p取模是不可能的&#xff0c;因为肯定超出long long 范围。 需要知道&#xff1a;(x*y)mod p (x mod p)*(y mod p) mo…
阅读更多...
【力扣热题100】—— Day3.反转链表

【力扣热题100】—— Day3.反转链表

你不会永远顺遂&#xff0c;更不会一直年轻&#xff0c;你太安静了&#xff0c;是时候出发了 —— 24.12.2 206. 反转链表 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5] 输出&…
阅读更多...
containerd安装

containerd安装

containerd安装 参考资料前置准备Installing containerdInstalling runcInstalling CNI plugins containerd is available as a daemon for Linux and Windows. It manages the complete container lifecycle of its host system, from image transfer and storage to containe…
阅读更多...
底部导航栏新增功能按键

底部导航栏新增功能按键

场景需求&#xff1a; 在底部导航栏添加power案件&#xff0c;单击息屏&#xff0c;长按 关机 如下实现图 借此需求&#xff0c;需要掌握技能&#xff1a; 底部导航栏如何实现新增、修改、删除底部导航栏流程对底部导航栏部分样式如何修改。 比如放不下、顺序排列、坑点如…
阅读更多...
Python 入门教程（2）搭建环境 | 2.4、VSCode配置Node.js运行环境

Python 入门教程（2）搭建环境 | 2.4、VSCode配置Node.js运行环境

文章目录 一、VSCode配置Node.js运行环境1、软件安装2、安装Node.js插件3、配置VSCode4、创建并运行Node.js文件5、调试Node.js代码 一、VSCode配置Node.js运行环境 1、软件安装 安装下面的软件&#xff1a; 安装Node.js&#xff1a;Node.js官网 下载Node.js安装包。建议选择L…
阅读更多...
火语言RPA流程组件介绍--键盘按键

火语言RPA流程组件介绍--键盘按键

&#x1f6a9;【组件功能】&#xff1a;模拟键盘按键 配置预览 配置说明 按键 点击后,在弹出的软键盘上选择需要的按键 执行后等待时间(ms) 默认值300,执行该组件后等待300毫秒后执行下一个组件. 输入输出 输入类型 万能对象类型(System.Object)输出类型 万能对象类型…
阅读更多...
【人工智能-基础】SVM中的核函数到底是什么

【人工智能-基础】SVM中的核函数到底是什么

文章目录 支持向量机（SVM）中的核函数详解1. 什么是核函数？核函数的作用：2. 核技巧：从低维到高维的映射3. 常见的核函数类型3.1 线性核函数3.2 多项式核函数3.3 高斯径向基函数（RBF核）4. 总结支持向量机（SVM）中的核函数详解 支持向量机（SVM，Support Vector Machine）…
阅读更多...
万字长文解读深度学习——多模态模型BLIP2

万字长文解读深度学习——多模态模型BLIP2

&#x1f33a;历史文章列表&#x1f33a; 深度学习——优化算法、激活函数、归一化、正则化 深度学习——权重初始化、评估指标、梯度消失和梯度爆炸 深度学习——前向传播与反向传播、神经网络&#xff08;前馈神经网络与反馈神经网络&#xff09;、常见算法概要汇总 万字长…
阅读更多...
大数据开发治理--大数据AI公共数据集分析

大数据开发治理--大数据AI公共数据集分析

本文以分析公共数据集的数据示例&#xff0c;为您展示如何使用DataWorks进行简单数据分析工作。本教程以申请免费资源为例为您展示详细操作步骤&#xff0c;您也可以使用付费资源&#xff0c;操作类似。 教程简介 阿里云DataWorks基于多种大数据引擎&#xff0c;为数据仓库、…
阅读更多...
ESP32-S3模组上跑通ES8388（13）

ESP32-S3模组上跑通ES8388（13）

接前一篇文章&#xff1a;ESP32-S3模组上跑通ES8388&#xff08;12&#xff09; 二、利用ESP-ADF操作ES8388 2. 详细解析 上一回解析了es8388_init函数中的第6段代码&#xff0c;本回继续往下解析。为了便于理解和回顾&#xff0c;再次贴出es8388_init函数源码&#xff0c;在…
阅读更多...
【Mac】安装Gradle

【Mac】安装Gradle

1、说明 Gradle 运行依赖 JVM&#xff0c;需要先安装JDK&#xff0c;Gradle 与 JDK的版本对应参见&#xff1a;Java Compatibility IDEA的版本也是有要求Gradle版本的&#xff0c;二者版本对应关系参见&#xff1a;Third-Party Software and Licenses 本次 Gradle 安装版本为…
阅读更多...
根据YAML文件创建Conda环境

根据YAML文件创建Conda环境

YAML&#xff08;全称为YAML Ain’t Markup Language&#xff09;是一种轻量级的标记语言。在Python中&#xff0c;YAML文件包含conda环境名和依赖&#xff0c;如图所示。 根据yaml文件创建Conda环境 1.切换路径 找到miniAnaconda或Anaconda&#xff0c;打开Anaconda Powersh…
阅读更多...
【分组去重】.NET开源 ORM 框架 SqlSugar 系列

【分组去重】.NET开源 ORM 框架 SqlSugar 系列

&#x1f4a5; .NET开源 ORM 框架 SqlSugar 系列 &#x1f389;&#x1f389;&#x1f389; 【开篇】.NET开源 ORM 框架 SqlSugar 系列【入门必看】.NET开源 ORM 框架 SqlSugar 系列【实体配置】.NET开源 ORM 框架 SqlSugar 系列【Db First】.NET开源 ORM 框架 SqlSugar 系列…
阅读更多...
故障诊断 | Transformer-LSTM组合模型的故障诊断（Matlab）

故障诊断 | Transformer-LSTM组合模型的故障诊断（Matlab）

效果一览 文章概述 故障诊断 | Transformer-LSTM组合模型的故障诊断（Matlab） 源码设计 %% 初始化 clear close all clc disp(此程序务必用2023b及其以上版本的MATLAB！否则会报错！) warning off %
阅读更多...
亚马逊云（AWS）使用root用户登录

亚马逊云（AWS）使用root用户登录

最近在AWS新开了服务器&#xff08;EC2&#xff09;&#xff0c;用于学习&#xff0c;遇到一个问题就是默认是用ec2-user用户登录&#xff0c;也需要密钥对。 既然是学习用的服务器&#xff0c;还是想直接用root登录&#xff0c;下面开始修改&#xff1a; 操作系统是&#xff1…
阅读更多...
Android笔记【12】脚手架Scaffold和导航Navigation

Android笔记【12】脚手架Scaffold和导航Navigation

一、前言 学习课程时&#xff0c;对于自己不懂的点的记录。 对于cy老师第二节课总结。 二、内容 1、PPT介绍scaffold 2、开始代码实操 先新建一个screen包&#xff0c;写一个Homescreen函数&#xff0c;包括四个页面。 再新建一个compenent包&#xff0c;写一个displayText…
阅读更多...
HookVip4.0.3 | 可解锁各大应用会员

HookVip4.0.3 | 可解锁各大应用会员

HookVip是一款可以解锁会员的模块工具&#xff0c;需要搭配相应框架结合使用。这款插件工具支持多种框架如LSPosed、LSPatch、太极、应用转生等&#xff0c;并且完全免费&#xff0c;占用内存小。支持的软件包括now要想、神奇脑波、塔罗牌占卜、爱剪辑、人人视频、咪萌桌面宠物…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023