LearnOpenGL-光照-5.投光物

news2024/11/26 11:54:03

本人刚学OpenGL不久且自学，文中定有代码、术语等错误，欢迎指正

我写的项目地址：https://github.com/liujianjie/LearnOpenGLProject

文章目录

  • 投光物
  • 平行光
  • 点光源
  • 聚光
    • 不平滑的例子
    • 平滑例子

投光物

  • 前面几节使用的光照都来自于空间中的一个点

    即把光源当做一个点

    但现实世界中，我们有很多种类的光照，每种的表现都不同。

  • 投光物

    将光投射(Cast)到物体的光源叫做投光物

  • 小结

    我做个小总结，与前面几节把光源当做一个点的区别

    • 平行光

      • 与一个点做光源不一样

        点光源需要位置

        平行光需要方向

        所以在实现计算光源对片段的漫反射、镜面光影响，要得到光源的方向方式会不一样

    • 点光源

      • 与一个点做光源一样需要位置

        在实现计算光源对片段的漫反射、镜面光影响，要得到光源的方向方式会一样

      • 点光源会衰减，前面的点光不会

    • 聚光灯

      • 与一个点做光源一样需要位置

        在实现计算光源对片段的漫反射、镜面光影响，要得到光源的方向方式会一样

      • 聚光灯照射一个特点方向的范围，前面的点光没有范围且四周散射

平行光

这里需要定义平行光的方向向下，才符合太阳的光照照射（指向）方向，所以计算漫反射和镜面光强度的时候需要取反得到光源的方向向量。

  • 简介

    当我们使用一个假设光源处于无限远处的模型时，它就被称为定向光，因为它的所有光线都有着相同的方向，它与光源的位置是没有关系的。

  • 图示

    计算漫反射和镜面光分量时光源的方向

  • 特点

    因为所有的光线都是平行的，所以物体与光源的相对位置是不重要的，因为对场景中每一个物体光的方向都是一致的。

  • 例子

    定义一个光线方向向量而不是位置向量来模拟一个定向光。

    这个光线方向是从光源指向像素点的方向，若要模仿太阳光从上往下照射，各个分量值应该为负的

    cpp

    lightingShader.setVec3("light.direction", -0.2f, -1.0f, -0.3f);// 太阳光向下

    glsl

    #version 330 core
out vec4 FragColor;

in vec3 Normal;
in vec3 FragPos;
in vec2 TexCoords;// 纹理坐标

uniform vec3 viewPos;

struct Material {
    sampler2D diffuse;  // 纹理单元
    sampler2D specular;//  镜面光照颜色分量从纹理采样
    float shininess;
}; 
uniform Material material;

// 光照强度
struct Light {
    // vec3 position; // 使用平行光就不再需要位置了
    vec3 direction; // 从光源出发到全局的方向

    vec3 ambient;
    vec3 diffuse;
    vec3 specular;
};

uniform Light light;
void main()
{
    // 取负变为光源的方向向量，用在计算漫反射和镜面光分量时
    vec3 lightDir = normalize(-light.direction);
    // 环境光光照分量
    float ambientStrength = 0.1;
    // 从漫反射纹理读取颜色分量
    vec3 ambient = light.ambient * vec3(texture(material.diffuse, TexCoords)); 

    // 漫反射光照分量
    vec3 norm = normalize(Normal);
    // vec3 lightDir = normalize(light.position - FragPos);// 一个点做光源才需要这样相减计算片段到光源的方向向量
    float diff = max(dot(norm, lightDir), 0.0);             // 得到光源对当前片段实际的漫反射影响
    vec3 diffuse = light.diffuse * diff * vec3(texture(material.diffuse, TexCoords));// 从漫反射纹理读取颜色分量

    // 镜面光照分量
    float specularStrength = 0.5;
    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 specular = light.specular * spec * vec3(texture(material.specular, TexCoords)); 

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

    • 说明

      依旧是冯氏光照模型

      vec3 lightDir = normalize(-light.direction);

      因为direction是光源指向像素点，加了负号以后成为像素点指向光源（光源的方向），这样才能与前面小节相符，正确计算光源对片段的漫反射和镜面光影响。

      对应开头的小结

      在实现计算光源对片段的漫反射、镜面光影响，要得到光源的方向方式会不一样

      // vec3 lightDir = normalize(light.position - FragPos);// 一个点做光源才需要这样相减计算片段到光源的方向向量
// 取负变为光源的方向向量，用在计算漫反射和镜面光分量时
vec3 lightDir = normalize(-light.direction);
float diff = max(dot(norm, lightDir), 0.0);             // 得到光源对当前片段实际的漫反射影响

点光源

这里算距离与衰减，无论是光源的方向还是光源的指向方向都可以，但是计算漫反射和镜面光强度还是依旧用光的方向向量。

  • 介绍

    处于世界中某一个位置的光源，它会朝着所有方向发光，但光线会随着距离逐渐衰减

  • 图

    计算漫反射和镜面光分量时光源的方向图就不用画了，就是片段指向灯泡

  • 重点在于如何定义衰减，即距离与衰减系数关系

    • 若用线性

      • 距离的增长线性地减少光的强度，从而让远处的物体更暗

      • 这样的线性方程通常会看起来比较假

    • 用以下公式才是稍好的选择

      定义3个（可配置的）项：常数项Kc、一次项Kl和二次项Kq。

      • 解读

        • 常数项Kc通常保持为1.0，它的主要作用是保证分母永远不会比1小，否则的话在某些距离上它反而会增加强度，这肯定不是我们想要的效果。

        • 一次项Kl会与距离值相乘，以线性的方式减少强度。

        • 二次项Kq会与距离的平方相乘，让光源以二次递减的方式减少强度。

          二次项在距离比较小的时候影响会比一次项小很多，但当距离值比较大的时候它就会比一次项更大了。

      • 效果

        光在近距离时亮度很高、随着距离变远亮度迅速降低、最后会以更慢的速度减少亮度

        匹配

        现实：灯在近处通常会非常亮、随着距离的增加光源的亮度一开始会下降非常快、但在远处时剩余的光强度就会下降的非常缓慢

      • 选择正确的值

        距离常数项一次项二次项
        71.00.71.8
        131.00.350.44
        201.00.220.20
        321.00.140.07
        501.00.090.032
        651.00.070.017
        1001.00.0450.0075
        1601.00.0270.0028
        2001.00.0220.0019
        3251.00.0140.0007
        6001.00.0070.0002
        32501.00.00140.000007

  • 例子

    • glsl

      #version 330 core
out vec4 FragColor;
struct Material {
    sampler2D diffuse;  // 纹理单元
    sampler2D specular;//  镜面光照颜色分量从纹理采样
    float shininess;
}; 
// 点光源
struct Light {
    vec3 position;  // 需要位置

    vec3 ambient;   
    vec3 diffuse;
    vec3 specular;

    float constant; // 常数
    float linear;   // 一次项
    float quadratic;// 二次项
};

in vec3 FragPos;
in vec3 Normal;
in vec2 TexCoords;// 纹理坐标

uniform vec3 viewPos;
uniform Material material;
uniform Light light;
void main()
{
    // 环境光光照分量
    // 从漫反射纹理读取颜色分量
    vec3 ambient = light.ambient * vec3(texture(material.diffuse, TexCoords)); 

    // 漫反射光照分量
    vec3 norm = normalize(Normal);
    vec3 lightDir = normalize(light.position - FragPos); // 得到光源的方向,与一个点做光源一样
    float diff = max(dot(norm, lightDir), 0.0);         // 得到光源对当前片段实际的漫反射影响
    vec3 diffuse = light.diffuse * diff * texture(material.diffuse, TexCoords).rgb;// 从漫反射纹理读取颜色分量

    // 镜面光照分量
    vec3 viewDir = normalize(viewPos - FragPos);        // 是观察者方向，不是观察者看向的方向
    vec3 reflectDir = reflect(-lightDir, norm);         // reflect要求第一个参数是光源指向像素点的向量
    float spec = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess);// 光源对当前片段的镜面光影响
    // 采样镜面光纹理颜色作为镜面光照颜色分量
    //vec3 specular = light.specular * spec * vec3(texture(material.specular, TexCoords)); // 这句也行
    vec3 specular = light.specular * spec * texture(material.specular, TexCoords).rgb; 

    // 计算衰减
    float distance  = length(light.position - FragPos);                // 得到光源到片段长度
    float attenuation = 1.0 / (light.constant + light.linear * distance // 根据公式
                        + light.quadratic * distance * distance);
    
    // 光照分量随距离衰减
    ambient *= attenuation;
    diffuse *= attenuation;
    specular *= attenuation;

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

      • 说明

        与一个点做光源一样，用光源的位置减去片段位置得到光源的方向

        vec3 lightDir = normalize(light.position - FragPos); // 得到光源的方向,与一个点做光源一样

      cpp

      lightingShader.setFloat("light.constant",  1.0f);
lightingShader.setFloat("light.linear",    0.09f);
lightingShader.setFloat("light.quadratic", 0.032f);

    • 重要bug

      箱子发生旋转，法线也要跟随着变换，不然法线不再垂直顶点，会导致如下不正确效果

      所以需要在vs阶段需计算发生变换后的法线

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

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

out vec3 FragPos;  
out vec3 Normal;
out vec2 TexCoords;
void main()
{
    gl_Position = projection * view * model * vec4(aPos, 1.0);
    FragPos = vec3(model * vec4(aPos, 1.0));
    // Normal = aNormal;// 只有顶点只发生位移时才可以保持不变
    Normal = mat3(transpose(inverse(model))) * aNormal;
    TexCoords = aTexCoords;
}

      以下正确结果

聚光

这里定义光源的位置为摄像机的位置向量，计算漫反射和镜面光反射，得摄像机的位置减去像素点的位置就成光的方向向量。

  • 简介

    位于环境中某个位置的光源，它只朝一个特定方向而不是所有方向照射光线。

    这样的结果就是只有在聚光方向的特定半径内的物体才会被照亮，其它的物体都会保持黑暗。

    聚光很好的例子就是路灯或手电筒

  • opengl上表示

    OpenGL中聚光是用一个世界空间位置、一个方向和一个切光角来表示，切光角指定了聚光的半径

  • 实现思路

    对于每个片段，我们会计算片段是否位于聚光的切光方向之间（也就是在锥形内），如果是的话，我们就会相应地照亮片段

  • 图示

    • LightDir：从片段指向光源的向量。
    • SpotDir：聚光所指向的方向。（但实际计算时，取反方向）
    • Phiϕ：指定了聚光半径的切光角。落在这个角度之外的物体都不会被这个聚光所照亮。
    • Thetaθ：LightDir向量和SpotDir向量之间的夹角。在聚光内部的话θ值应该比ϕ值小。

    要做的就是计算LightDir向量和SpotDir向量之间的点积，等于cosθ值，将cosθ值与切光角cosϕ值对比

不平滑的例子

  • 计算向量图示

    算theta时，为了与光的方向向量对应，dot(光的方向向量，取反光源照射前方向量)

  • 代码

    #version 330 core
out vec4 FragColor;
struct Material {
    sampler2D diffuse;  // 漫反射颜色分量从纹理采样
    sampler2D specular;//  镜面光照颜色分量从纹理采样
    float shininess;
}; 
// 聚光灯
struct Light {
    vec3  position; // 需要位置
    vec3  direction;// 需要照射方向
    float cutOff;

    vec3 ambient;
    vec3 diffuse;
    vec3 specular;
    float constant; // 常数
    float linear;   // 一次项
    float quadratic;// 二次项
};

in vec3 FragPos;
in vec3 Normal;
in vec2 TexCoords;// 纹理坐标

uniform vec3 viewPos;
uniform Material material;
uniform Light light;
void main()
{
    // 光源的方向向量：像素点指向光源
    vec3 lightDir = normalize(light.position - FragPos);
    // 算出theta，dot(像素点指向光源，光源照射的方向取反）
    float theta = dot(lightDir, normalize(-light.direction)); 
    // float theta=dot(-lightDir, normalize(light.direction));// dot(光源指向像素点, 光源照射的方向)
    // 执行正常光照计算：由于theta是cos值，cutOff也是cos值，cos(0-90)递减，所以theta>，而不是<
    if(theta > light.cutOff){
        // 片段在切角内
        // 从漫反射纹理读取颜色分量
        vec3 ambient = light.ambient * vec3(texture(material.diffuse, TexCoords)); 

        // 漫反射光照分量
        vec3 norm = normalize(Normal);
        vec3 lightDir = normalize(light.position - FragPos); // 得到光源的方向,与一个点做光源一样
        float diff = max(dot(norm, lightDir), 0.0);         // 得到光源对当前片段实际的漫反射影响
        vec3 diffuse = light.diffuse * diff * texture(material.diffuse, TexCoords).rgb;// 从漫反射纹理读取颜色分量

        // 镜面光照分量
        vec3 viewDir = normalize(viewPos - FragPos);       // 是观察者方向，不是观察者看向的方向
        vec3 reflectDir = reflect(-lightDir, norm);         // reflect要求第一个参数是光源指向像素点的向量
        float spec = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess);// 光源对当前片段的镜面光影响
        // 采样镜面光纹理颜色作为镜面光照颜色分量
        //vec3 specular = light.specular * spec * vec3(texture(material.specular, TexCoords)); // 这句也行
        vec3 specular = light.specular * spec * texture(material.specular, TexCoords).rgb; 

        // 计算衰减
        float distance  = length(light.position - FragPos);                 // 得到光源到片段长度
        float attenuation = 1.0 / (light.constant + light.linear * distance // 根据公式
                            + light.quadratic * distance * distance);
    
        // 光照分量随距离衰减
        ambient *= attenuation;
        diffuse *= attenuation;
        specular *= attenuation;

        vec3 result = (ambient + diffuse + specular) ;
    
        FragColor = vec4(result, 1.0);
    }else{
        // 片段不在切角内：计算环境光，以免全黑
        FragColor = vec4(light.ambient * vec3(texture(material.diffuse, TexCoords)), 1.0) ;
    }
}

    上传数据

    lightingShader.setVec3("light.position",  camera.Position);
lightingShader.setVec3("light.direction", camera.Front);
lightingShader.setFloat("light.cutOff",   glm::cos(glm::radians(12.5f)));

    • 说明

      算theta时，为了与光的方向向量对应，dot(像素点指向光源，光源照射的方向取反）

      float theta = dot(lightDir, normalize(-light.direction));

      与一个点做光源一样，用光源的位置减去片段位置得到光源的方向

      vec3 lightDir = normalize(light.position - FragPos); // 得到光源的方向,与一个点做光源一样

    • 注意点theta > light.cutOff

      因为上传给cutOff的是已经计算好了的cos值，且theta也是cosθ值（cosθ=dot(lightDir, normalize(-light.direction)))

      cos(0-90内)递减，所以theta >light.cutOff，代表当前夹角要比规定的范围角度要小，需要照亮

  • 效果

    • 疑问点

      为什么，计算cos角度要用弧度值

      lightingShader.setFloat("light.cutOff", glm::cos(glm::radians(12.5f)));

      glm::cos()；接收的参数需要是弧度值

  • 测试点积两个向量的方向

    glm::vec3 lightDir = camera.Position;
glm::vec3 lightdirection = camera.Front;
float theta1 = glm::dot(lightDir, glm::normalize(-lightdirection));// 对应第一个图
cout << "像素点指向光源：" << theta1 << endl;
float theta2 = glm::dot(-lightDir, glm::normalize(lightdirection));// 对应第二个图
cout << "光源指向像素点：" << theta2 << endl;

    方向一样，点积值一样

平滑例子

  • 引入

    如上一个例子，发现聚光灯的光圈边缘并不平滑

  • 解决方法

    我们可以将内圆锥设置为上一个例子聚光灯的圆锥，但我们也需要一个外圆锥，来让光从内圆锥逐渐减暗，直到外圆锥的边界。

  • 融入代码中

    为了创建一个外圆锥，我们只需要再定义一个余弦值来代表聚光灯方向向量和外圆锥向量（等于它的半径）的夹角

  • 边缘平滑且圆锥内正常思路

    如果一个片段处于内外圆锥之间，将会给它计算出一个0.0到1.0之间的强度值。

    如果片段在内圆锥之内，它的强度就是1.0。

    如果在外圆锥之外强度值就是0.0。

  • 公式来计算边缘平滑且圆锥内正常

    • 理解方式一

      θ = dot(像素点指向光源，光源照射的方向取反）= cos(它们之间的夹角)

      γ = cos（外圆角度）

      ϵ(Epsilon) = cos(内圆角度) - cos（外圆角度）

    • 结合下方图表理解

      θ = cos（θ（角度） = dot(像素点指向光源，光源照射的方向取反）= cos(它们之间的夹角)

      γ = cos（γ（角度））= γ（外光切）

      ϵ(Epsilon) = ϕ（内光切）- γ（外光切）

    θθ（角度）ϕ（内光切）ϕ（角度）γ（外光切）γ（角度）ϵI
    0.87300.91250.82350.91 - 0.82 = 0.090.87 - 0.82 / 0.09 = 0.56
    0.9260.91250.82350.91 - 0.82 = 0.090.9 - 0.82 / 0.09 = 0.89
    0.97140.91250.82350.91 - 0.82 = 0.090.97 - 0.82 / 0.09 = 1.67
    0.83340.91250.82350.91 - 0.82 = 0.090.83 - 0.82 / 0.09 = 0.11
    0.64500.91250.82350.91 - 0.82 = 0.090.64 - 0.82 / 0.09 = -2.0
    0.966150.997812.50.95317.50.9978 - 0.953 = 0.04480.966 - 0.953 / 0.0448 = 0.29

    • 个人发现图表有错（也许没错）

      最后一行：cos值计算错了

      cos（12.5）=0.976，而表中的0.9978是cos(12.5rad)，把12.5当做弧度来计算cos值

  • 转换为代码

    glsl

    #version 330 core
out vec4 FragColor;
struct Material {
    sampler2D diffuse;  // 漫反射颜色分量从纹理采样
    sampler2D specular;//  镜面光照颜色分量从纹理采样
    float shininess;
}; 
// 聚光灯
struct Light {
    vec3  position; // 需要位置
    vec3  direction;// 需要照射方向
    float cutOff;	// ϕ（内光切）
    float outerCutOff;// γ（外光切）

    vec3 ambient;
    vec3 diffuse;
    vec3 specular;
    float constant; // 常数
    float linear;   // 一次项
    float quadratic;// 二次项
};
in vec3 FragPos;
in vec3 Normal;
in vec2 TexCoords;// 纹理坐标

uniform vec3 viewPos;
uniform Material material;
uniform Light light;
void main()
{
    // 光源的方向向量：像素点指向光源
    vec3 lightDir = normalize(light.position - FragPos);
    // 算出theta，dot(像素点指向光源，光源照射的方向取反）
    float theta = dot(lightDir, normalize(-light.direction));
    // float theta=dot(-lightDir, normalize(light.direction));// dot(光源指向像素点, 光源照射的方向)

    

    // 从漫反射纹理读取颜色分量
    vec3 ambient = light.ambient * vec3(texture(material.diffuse, TexCoords)); 

    // 漫反射光照分量
    vec3 norm = normalize(Normal);
    // vec3 lightDir = normalize(light.position - FragPos); // 得到光源的方向
    float diff = max(dot(norm, lightDir), 0.0);
    vec3 diffuse = light.diffuse * diff * texture(material.diffuse, TexCoords).rgb;// 从漫反射纹理读取颜色分量

     // 镜面光照分量
    vec3 viewDir = normalize(viewPos - FragPos);            // 是观察者方向，不是观察者看向的方向
    vec3 reflectDir = reflect(-lightDir, norm);             // reflect要求第一个参数是光源指向像素点的向量
    float spec = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess);// 光源对当前片段的镜面光影响
    // 采样镜面光纹理颜色作为镜面光照颜色分量
    //vec3 specular = light.specular * spec * vec3(texture(material.specular, TexCoords)); // 这句也行
    vec3 specular = light.specular * spec * texture(material.specular, TexCoords).rgb; 

    // 计算衰减
    float distance  = length(light.position - FragPos);                 // 得到光源到片段长度
    float attenuation = 1.0 / (light.constant + light.linear * distance // 根据公式
                        + light.quadratic * distance * distance);
    
    // 光照分量随距离衰减
    ambient *= attenuation;
    diffuse *= attenuation;
    specular *= attenuation;

    // 为了边缘平滑且圆锥内正常
    float epsilon = light.cutOff - light.outerCutOff;
    float intensity = clamp((theta - light.outerCutOff) / epsilon, 0.0, 1.0);

    // 将不对环境光做出影响，让它总是能有一点光
    diffuse *= intensity;
    specular *= intensity;// 聚光灯受影响

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

    lightingShader.use();
lightingShader.setVec3("viewPos", camera.Position);
lightingShader.setVec3("light.position", camera.Position);
lightingShader.setVec3("light.direction", camera.Front);// direction是光照射方向
lightingShader.setFloat("light.cutOff", glm::cos(glm::radians(12.5f)));		//ϕ（内光切）
lightingShader.setFloat("light.outerCutOff", glm::cos(glm::radians(17.5f)));// γ（外光切）

  • 效果

    请添加图片描述

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

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

相关文章

IR 808 Alkyne，IR-808 alkyne，IR 808炔烃，近红外吲哚类花菁染料

IR 808 Alkyne，IR-808 alkyne，IR 808炔烃，近红外吲哚类花菁染料

【产品理化指标】&#xff1a;中文名&#xff1a;IR-808炔烃英文名&#xff1a;IR-808 alkyne&#xff0c;Alkyne 808-IR CAS号&#xff1a;N/AIR-808结构式&#xff1a;规格包装&#xff1a;10mg&#xff0c;25mg&#xff0c;50mg&#xff0c;接受各种复杂PEGS定制服务&#x…
阅读更多...
Git的下载、安装、配置、使用、卸载

Git的下载、安装、配置、使用、卸载

前言 我是跟着狂神老师学的。该博客仅用于笔记所用。 下面是老师的B站和笔记 B站&#xff1a;https://www.bilibili.com/video/BV1FE411P7B3?p1&vd_source9266cf72b1f398b63abe0aefe358d7d6 笔记&#xff1a;https://mp.weixin.qq.com/s/Bf7uVhGiu47uOELjmC5uXQ 一、准备工…
阅读更多...
【18】组合逻辑 - VL18 实现3-8译码器①

【18】组合逻辑 - VL18 实现3-8译码器①

VL18 实现3-8译码器① 1 题目 【这题我的思路非常绝境】奈斯 ！！ 看真值表的思路：Yi所在列【0仅一个其余全1】，故【以0为对象求解】 观察发现：E3 E2_n E1_n = 100 时 是 译码的使能信号 ； 并且E3 E2_n E1_n为其他值时，都不使能译码 然后就很简单，没有仿真就成功了 2 代…
阅读更多...
Linux：文件流指针 与 文件描述符

Linux：文件流指针 与 文件描述符

目录一、文件描述符二、文件流指针三、缓冲区之前讲解过了IO库函数和IO接口&#xff0c;库函数是对系统调用接口的封装&#xff0c;也就是说实际上在库函数内部是通过调用系统调用接口来完成最终功能的。 库函数通过文件流指针操作文件&#xff0c;系统调用接口通过文件描述符操…
阅读更多...
在一个web应用中应该如何完成资源的跳转

在一个web应用中应该如何完成资源的跳转

在一个web应用中通过两种方式&#xff0c;可以完成资源的跳转&#xff1a; 第一种方式&#xff1a;请求转发 第二种方式&#xff1a;重定向 转发和重定向的区别&#xff1a; 代码上的区别&#xff1a; 请求转发 // 获取请求转发器对象 RequestDispatcher dispatcher request.…
阅读更多...
3-1 SpringCloud快速开发入门: Ribbon 是什么

3-1 SpringCloud快速开发入门: Ribbon 是什么

接上一章节Eureka 服务注册中心自我保护机制&#xff0c;这里讲讲Ribbon 是什么 Ribbon 是什么 通常说的负载均衡是指将一个请求均匀地分摊到不同的节点单元上执行&#xff0c;负载均和分为硬件负载均衡和软件负载均衡&#xff1a; **硬件负载均衡&#xff1a;**比如 F5、深信…
阅读更多...
C# 实现 key-value 结构自定义缓存 CustomCache

C# 实现 key-value 结构自定义缓存 CustomCache

功能需求 使用 C# 编写一个 key-value 结构进程内缓存&#xff0c;实现数据的缓存操作&#xff0c;此处所用到的知识点如下&#xff1a; 线程安全的字典 ConcurrentDictionary&#xff1b;设计模式之单例模式&#xff08;Singleton&#xff09;&#xff1b;缓存数据【主动 &a…
阅读更多...
3.10多线程

3.10多线程

一.常见锁策略1.悲观锁 vs乐观锁体现在处理锁冲突的态度①悲观锁:预期锁冲突的概率高所以做的工作更多,付出的成本更多,更低效②乐观锁:预期锁冲突的概率低所以做的工作少,付出的成本更低,更搞笑2.读写锁 vs 普通的互斥锁①普通的互斥锁,只有两个操作 加锁和解锁只有两个线程针…
阅读更多...
HT32合泰单片机开发环境搭建和配置教程

HT32合泰单片机开发环境搭建和配置教程

HT32合泰(Holtek)单片机开发环境搭建安装教程 前言 最近在准备合泰杯的比赛&#xff0c;在看合泰官方的PPT和数据手册学习&#xff0c;顺便做个合泰单片机的开发环境搭建教程。 合泰杯比赛发放的开发板是ESK32-30501&#xff0c;用的单片机是HT32F52352。 合泰杯官网地址&a…
阅读更多...
【C++】vector的使用及其模拟实现

【C++】vector的使用及其模拟实现

这里写目录标题一、vector的介绍及使用1. vector的介绍2. 构造函数3. 遍历方式4. 容量操作及空间增长问题5. 增删查改6. vector二维数组二、vector的模拟实现1. 构造函数2. 迭代器和基本接口3. reserve和resize4. push_back和pop_back5. insert和erase5. 迭代器失效问题5. 浅拷…
阅读更多...
Java中的 this 和 super

Java中的 this 和 super

1 this 关键字 1.1 this 访问本类属性 this 代表对当前对象的一个引用 所谓当前对象&#xff0c;指的是调用当前类中方法或属性的那个对象this只能在方法内部使用&#xff0c;表示对“调用方法的那个对象”的引用this.属性名&#xff0c;表示本对象自己的属性 当对象的属性和…
阅读更多...
IntelliJ IDEA 编码设置

IntelliJ IDEA 编码设置

1.场景 适用于配置idea文件编码 2.配置 对已经存在的项目设置文件编码 可以设置全局的编码 以及 项目的编码 一般没啥特殊要求 都建议设置为 UTF-8 以及 配置项目的目录的单独编码 也建议UTF-8 idea可以单独设置properties的编码 也建议改为 UTF-8&#xff0c;其中有一个重点…
阅读更多...
HCIP --- GRE和MGRE

HCIP --- GRE和MGRE

VPN----虚拟私有网络&#xff1a;依靠ISP或者其他网络管理机构在公有网络基础上构建的专用的安全数据通信网络&#xff0c;只不过该网络是逻辑上的而非物理的。 虚拟&#xff1a;用户不再需要拥有实际的长途数据线路&#xff0c;而是使用公共网络资源建立的属于自己的私有网络…
阅读更多...
[论文笔记]Transformer-XL: Attentive Language Models Beyond a Fixed-Length Context

[论文笔记]Transformer-XL: Attentive Language Models Beyond a Fixed-Length Context

引言 我们知道Transformer很好用&#xff0c;但它设定的最长长度是512。像一篇文章超过512个token是很容易的&#xff0c;那么我们在处理这种长文本的情况下也想利用Transformer的强大表达能力需要怎么做呢&#xff1f; 本文就带来一种处理长文本的Transformer变种——Transf…
阅读更多...
SQS (Simple Queue Service)简介

SQS (Simple Queue Service)简介

mazon Simple Queue Service (SQS)是一种完全托管的消息队列服务&#xff0c;可以让你分离和扩展微服务、分布式系统和无服务应用程序。 在讲解SQS之前&#xff0c;首先让我们了解一下什么是消息队列。 消息队列 还是举一个电商的例子&#xff0c;一个用户在电商网站下单后付…
阅读更多...
【LeetCode每日一题:[面试题 17.05] 字母与数字-前缀和+Hash表】

【LeetCode每日一题:[面试题 17.05] 字母与数字-前缀和+Hash表】

题目描述 给定一个放有字母和数字的数组&#xff0c;找到最长的子数组&#xff0c;且包含的字母和数字的个数相同。 返回该子数组&#xff0c;若存在多个最长子数组&#xff0c;返回左端点下标值最小的子数组。若不存在这样的数组&#xff0c;返回一个空数组。 示例 1: 输入…
阅读更多...
LDGRB-01 3AFE61320954P0001

LDGRB-01 3AFE61320954P0001

LDGRB-01 3AFE61320954P0001变频器的作用_变频器工作原理变频器是把工频电源&#xff08;50Hz或60Hz&#xff09;变换成各种频率的交流电源&#xff0c;以实现电机的变速运行的设备&#xff0c;其中控制电路完成对主电路的控制&#xff0c;整流电路将交流电变换成直流电&#x…
阅读更多...
教育培训机构屡遭投诉？湖南中创教育给出三点建议

教育培训机构屡遭投诉？湖南中创教育给出三点建议

在中消协发布的《2021年校外教育培训领域消费者权益保护报告》中&#xff0c;受新冠疫情以及校外教育培训行业治理政策的冲击&#xff0c;我国校外教育培训领域消费维权舆情及消费者投诉呈上升趋势。2021年全国消协组织受理有关校外教育培训的投诉案件共80,528件&#xff0c;同…
阅读更多...
探索N-gram模型：语言模型中的基础算法

探索N-gram模型：语言模型中的基础算法

❤️觉得内容不错的话&#xff0c;欢迎点赞收藏加关注&#x1f60a;&#x1f60a;&#x1f60a;&#xff0c;后续会继续输入更多优质内容❤️&#x1f449;有问题欢迎大家加关注私戳或者评论&#xff08;包括但不限于NLP算法相关&#xff0c;linux学习相关&#xff0c;读研读博…
阅读更多...
Proteus8.15安装教程

Proteus8.15安装教程

1、解压Proteus8.15 安装包&#xff0c;然后双击进去&#xff0c;找到setup文件&#xff0c;右键&#xff0c;以管理员身份运行。 2、需要安装一些插件&#xff0c;点击“next”。把插件安装完成。 点击“finfish” 点击“install” 点击“Cancel” 3、如果没有上面步骤&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023