程序员经验分享-hwhale

Unity Shader：光照模型，纹理，详细注释

2023-05-16

Phong光照模型

进入摄像机的光线分为四个部分:

环境光（ambient）

其他所有间接光照

自发光（emissive）

给定一个方向，模型表面本身向该方向发射多少辐射量

漫反射（diffuse）

当光线从光源照射到模型表面时，会向所有方向散射多少辐射量

高光反射（specular）

当光线从光源照射到模型表面时，会向镜面反射方向散射多少辐射量

Blinn-Phong模型：引入半程向量来计算高光反射，能得到更好的结果

Blinn-Phong模型是各向同性（isotropic）的，固定视角和光源方向旋转表面时，反射不会发生变化。

逐像素光照：Phong着色（Phong shading）

使用每个像素的法线（对顶点法线插值得到 或法线纹理中采样得到）进行光照模型的计算

逐顶点光照：高洛德着色（Gouraud shading）

只在顶点上计算光照，将结果进行线性插值得到像素颜色，无法计算高光反射

且会导致图元内部的颜色暗于顶点处的最高颜色值，可能会产生棱角现象

但是计算量很小。

逐顶点光照 （Gouraud shading）

Shader "Custom/DiffuseVertex"
{
    Properties
    {
        _Diffuse ("Diffuse", Color) = (1,1,1,1)
        
    }
    SubShader
    {
        Pass{
            Tags { "RenderType"="ForwardBase" }
            CGPROGRAM
            //指定顶点着色器的函数
            #pragma vertex vert  
            //指定片元着色器的函数
            #pragma fragment frag
            #include "Lighting.cginc"
            struct a2v{  //顶点着色器的输入
                float4 vertex: POSITION;  //顶点坐标
                float3 normal:NORMAL;    //顶点法线
            };
            struct v2f{ //顶点着色器的输出，片元着色器的输入
                float4 pos:SV_POSITION;
                float3 color:COLOR;
            };

            fixed4 _Diffuse;

            v2f vert(a2v v)
            {
                v2f o;
                o.pos=UnityObjectToClipPos(v.vertex);   //使用内建函数实现MVP变换
                fixed3 ambient=UNITY_LIGHTMODEL_AMBIENT.xyz;  //使用内置宏获取环境光照
                fixed3 worldNormal=normalize(mul(v.normal,(float3x3)unity_WorldToObject)); //法线 的世界坐标
                fixed3 worldLight=normalize(_WorldSpaceLightPos0.xyz);  //光方向矢量 的世界坐标
                //saturate函数可以对矢量的每一个分量截取在[0,1]范围内
                fixed3 diffuse=_LightColor0.rgb * _Diffuse.rgb * saturate(dot(worldNormal,worldLight));
                o.color=ambient+diffuse;  //加上环境光照
                return o;
            }
            fixed4 frag(v2f i):SV_TARGET
            {
                return fixed4(i.color,1.0); 
            }
            
            ENDCG
        }
    }
    FallBack "Diffuse"
}

逐像素光照 （Phong shading）


Shader "Custom/DiffusePixel"
{
    Properties
    {
        _Diffuse ("Diffuse", Color) = (1,1,1,1)
        _Specular("Specular",Color)=(1,1,1,1)
        _Gloss("Gloss",Range(8.0,256))=20
    }
    SubShader
    {
        Pass{
            Tags { "RenderType"="ForwardBase" }
            CGPROGRAM
    
            #pragma vertex vert
            #pragma fragment frag
            #include "Lighting.cginc"

            struct a2v{
                float4 vertex: POSITION;
                float3 normal:NORMAL;
            };
            struct v2f{
                float4 pos:SV_POSITION;
                float3 worldNormal:TEXCOORD0;
                float3 worldPos:TEXCOORD1;
            };

            fixed4 _Diffuse;
            fixed4 _Specular;
            float _Gloss;

            v2f vert(a2v v)
            {
                v2f o;
                o.pos=UnityObjectToClipPos(v.vertex);
                o.worldNormal=mul(v.normal,(float3x3)unity_WorldToObject);
                o.worldPos=mul(unity_ObjectToWorld,v.vertex).xyz;  //顶点变换到世界空间，并截取3x3矩阵
                return o;
            }
            fixed4 frag(v2f i):SV_TARGET
            {
                fixed3 worldNormal=normalize(i.worldNormal);  //法线向量归一化
                fixed3 ambient=UNITY_LIGHTMODEL_AMBIENT.xyz;  //环境光照
                fixed3 worldLight=normalize(_WorldSpaceLightPos0.xyz);  //指向光源的方向向量世界坐标
                //saturate函数可以对矢量的每一个分量截取在[0,1]范围内
                fixed lambert=saturate(dot(worldNormal,worldLight));  //兰伯特光照模型
                float halfLambert=dot(worldNormal,worldLight)*0.5+0.5; //半兰伯特光照模型
                fixed3 diffuse=_LightColor0.rgb * _Diffuse.rgb * halfLambert;  //计算漫反射(使用半兰伯特模型)
                return fixed4(ambient+diffuse,1.0);
            }
            
            ENDCG
        }
    }
    FallBack "Diffuse"
}

镜面反射（高光反射）

在上述基础上增加了specular分量的计算，使用半程向量，可以不用计算反射光线。同时也给出了计算反射光线的方法。

逐像素光照


Shader "Custom/DiffusePixel"
{
    Properties
    {
        _Diffuse ("Diffuse", Color) = (1,1,1,1)
        _Specular("Specular",Color)=(1,1,1,1)
        _Gloss("Gloss",Range(8.0,256))=20
    }
    SubShader
    {
        Pass{
            Tags { "RenderType"="ForwardBase" }
            CGPROGRAM
            
            #pragma vertex vert
            #pragma fragment frag
            #include "Lighting.cginc"

            struct a2v{
                float4 vertex: POSITION;
                float3 normal:NORMAL;
            };
            struct v2f{
                float4 pos:SV_POSITION;
                float3 worldNormal:TEXCOORD0;
                float3 worldPos:TEXCOORD1;
            };

            fixed4 _Diffuse;
            fixed4 _Specular;
            float _Gloss;

            v2f vert(a2v v)
            {
                v2f o;
                o.pos=UnityObjectToClipPos(v.vertex);
                o.worldNormal=mul(v.normal,(float3x3)unity_WorldToObject);
                o.worldPos=mul(unity_ObjectToWorld,v.vertex).xyz;  //顶点变换到世界空间，并截取3x3矩阵
                return o;
            }
            fixed4 frag(v2f i):SV_TARGET
            {
                fixed3 worldNormal=normalize(i.worldNormal);  //法线向量归一化
                fixed3 ambient=UNITY_LIGHTMODEL_AMBIENT.xyz;  //环境光照
                fixed3 worldLight=normalize(_WorldSpaceLightPos0.xyz);  //指向光源的方向向量世界坐标
                //saturate函数可以对矢量的每一个分量截取在[0,1]范围内
                fixed lambert=saturate(dot(worldNormal,worldLight));  //兰伯特光照模型
                float halfLambert=dot(worldNormal,worldLight)*0.5+0.5; //半兰伯特光照模型
                fixed3 diffuse=_LightColor0.rgb * _Diffuse.rgb * halfLambert;  //计算漫反射(使用半兰伯特模型)
                fixed3 viewDir=normalize(_WorldSpaceCameraPos.xyz - i.worldPos.xyz); //视线，从像素到摄像机
                fixed3 reflectDir=normalize(reflect(-worldLight,worldNormal)); //计算反射光线方向
                fixed3 halfDir=normalize(worldLight+viewDir);  //半程向量
                fixed3 specular_phong = _LightColor0.rgb * _Specular.rgb * pow(saturate(dot(reflectDir,viewDir)),_Gloss); //使用Phong模型计算的高光
                fixed3 specular_blinn = _LightColor0.rgb * _Specular.rgb * pow(saturate(dot(halfDir,worldNormal)),_Gloss); //使用Blinn-Phong模型计算的高光
                return fixed4(ambient+diffuse+specular_blinn,1.0);
            }
            
            ENDCG
        }
    }
    FallBack "Diffuse"
}

纹理

单一纹理贴图

Shader "Custom/SingleTexture"
{
    Properties
    {
        _Color ("Color", Color) = (1,1,1,1)  //控制物体整体色调
        _Specular ("Specular",Color) = (1,1,1,1)  
        _Gloss ("Gloss",Range(8.0,256)) = 20  
        _MainTex ("Main Tex",2D)="white" {}  //使用的纹理贴图
    }
    SubShader
    {
        Pass{
            Tags { "LightMode"="ForwardBase" }
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "Lighting.cginc"

            struct a2v{
                float4 vertex: POSITION;
                float3 normal:NORMAL;
                float4 texcoord:TEXCOORD0;
            };
            struct v2f{
                float4 pos:SV_POSITION;       //裁剪空间坐标
                float3 worldNormal:TEXCOORD0; //世界空间坐标
                float3 worldPos:TEXCOORD1;
                float2 uv:TEXCOORD2;
            };

            fixed4 _Color;
            fixed4 _Specular;
            float _Gloss;
            sampler2D _MainTex;
            float4 _MainTex_ST;  //纹理的缩放和平移值
            v2f vert(a2v v)
            {
                v2f o;  //顶点着色器输出
                o.pos=UnityObjectToClipPos(v.vertex);  
                o.worldNormal=UnityObjectToWorldNormal(v.normal);
                o.worldPos=mul(unity_ObjectToWorld,v.vertex).xyz;  
                o.uv=v.texcoord.xy * _MainTex_ST.xy + _MainTex_ST.zw; //乘以缩放矩阵，再加上平移量
                //或者可以使用内置宏:
                //o.uv=TRANSFORM_TEX(v.texcoord,_MainTex);
                return o;
            }
            fixed4 frag(v2f i):SV_TARGET
            {
                fixed3 worldNormal=normalize(i.worldNormal);
                fixed3 worldLightDir=normalize(UnityWorldSpaceLightDir(i.worldPos));  //使用内置函数得到光线矢量
                fixed3 albedo=tex2D(_MainTex,i.uv).rgb * _Color.rgb;  //从纹理中获得计算漫反射使用的颜色
                fixed3 diffuse=albedo*_LightColor0.rgb*max(0,dot(worldNormal,worldLightDir)); //计算漫反射颜色
                fixed3 viewDir=normalize(UnityWorldSpaceViewDir(i.worldPos));
                fixed3 halfDir=normalize(worldLightDir+viewDir);  //计算半程向量
                fixed3 specular=_LightColor0.rgb * _Specular.rgb *pow(max(0,dot(worldNormal,halfDir)),_Gloss);
                fixed3 ambient=UNITY_LIGHTMODEL_AMBIENT.xyz * albedo;  //计算环境光照
                
                return fixed4(ambient+diffuse+specular,1.0);


            }
            
            ENDCG
        }
    }
    FallBack "Specular"
}

法线贴图

在顶点的切线空间中计算

Shader "Custom/NormalMap_TangentSpace"
{
    Properties
    {
        _Color ("Color Tint", Color) = (1,1,1,1)  //控制整体色调
        _MainTex ("Main Tex", 2D) = "white" {}   //光照贴图
        _BumpMap ("Normal Map",2D)="bump" {}     //法线纹理
        _BumpScale ("Bump Scale",Float)=1.0
        _Specular ("Specular", Color)=(1,1,1,1)
        _Gloss ("Gloss", Range(0,255)) = 10
        
    }
    SubShader
    {
        Pass{
            Tags { "LightMode"="ForwardBase" }
            
            CGPROGRAM
            // Physically based Standard lighting model, and enable shadows on all light types
            #pragma vertex vert
            #pragma fragment frag
            #include "Lighting.cginc"
            #include "UnityCG.cginc"

            fixed4 _Color;
            fixed4 _Specular;
            float _Gloss;
            sampler2D _MainTex;
            float4 _MainTex_ST;  //纹理的缩放和平移值
            sampler2D _BumpMap;
            float4 _BumpMap_ST;
            float _BumpScale;  //控制凹凸程度

            struct a2v{
                float4 vertex: POSITION;
                float3 normal:NORMAL;    
                float4 tangent:TANGENT;  //切线方向
                float4 texcoord:TEXCOORD0;   //_MainTex和_BumpMap 通常使用同一组纹理坐标
            };
            struct v2f{
                float4 pos:SV_POSITION;       //裁剪空间坐标
                float4 uv:TEXCOORD0;        //xy存储光照贴图的纹理坐标，zw存储法线贴图的纹理坐标
                float3 lightDir:TEXCOORD1;  //光照方向
                float3 viewDir:TEXCOORD2;   //视角方向k
            };


            v2f vert(a2v v)
            {
                v2f o;  //顶点着色器输出
                o.pos=UnityObjectToClipPos(v.vertex);
                o.uv.xy=v.texcoord.xy * _MainTex_ST.xy + _MainTex_ST.zw;  //纹理坐标乘以纹理的缩放加上平移
                o.uv.zw=v.texcoord.xy * _BumpMap_ST.xy + _BumpMap_ST.zw;  //法线贴图坐标乘以缩放加上平移
                //用z轴（法线）叉乘x轴（切线）来计算y轴（副切线）的方向
                float3 binormal=cross(normalize(v.normal),normalize(v.tangent.xyz)) * v.tangent.w;
                //构造切线空间到模型空间的变换矩阵
                float3x3 rotation=float3x3(v.tangent.xyz,binormal,v.normal);
                //把光照方向和视角方向变换到切线空间
                o.lightDir=mul(rotation,ObjSpaceLightDir(v.vertex));
                o.viewDir=mul(rotation,ObjSpaceViewDir(v.vertex));
                return o;
            }
            fixed4 frag(v2f i):SV_TARGET
            {

                fixed3 tangentLightDir=normalize(i.lightDir);  //切线空间下的光照方向
                fixed3 tangentViewDir=normalize(i.viewDir);   //切线空间下的观察方向
                fixed4 packedNormal=tex2D(_BumpMap,i.uv.zw);  //从法线贴图中采样得到切线空间下的法线
                
                fixed3 tangentNormal;
                tangentNormal.xy=(packedNormal.xy*2-1)*_BumpScale;
                tangentNormal.z=sqrt(1.0-saturate(dot(tangentNormal.xy,tangentNormal.xy))); //z^2=1-(x^2+y^2)
                
                //如果在Unity中把法线纹理的类型设置成Normal_Map，可以使用内置宏:
                //tangentNormal=UnpackNormal(packedNormal);
                //tangentNormal.xy*=_BumpScale
                //tangentNormal.z=sqrt(1.0-saturate(dot((tangentNormal.xy,tangentNormal.xy)))); //z^2=1-(x^2+y^2)

                fixed3 albedo=tex2D(_MainTex,i.uv).rgb * _Color.rgb;  //从纹理中获得计算漫反射使用的颜色
                fixed3 ambient=UNITY_LIGHTMODEL_AMBIENT.xyz * albedo;  //计算环境光照
                fixed3 diffuse=albedo*_LightColor0.rgb*max(0,dot(tangentNormal,tangentLightDir)); //在切线空间中计算漫反射颜色
                fixed3 halfDir=normalize(tangentLightDir+tangentViewDir);  //半程向量
                //在切线空间中计算高光
                fixed3 specular=_LightColor0.rgb * _Specular.rgb *pow(max(0,dot(tangentNormal,halfDir)),_Gloss);
                
                return fixed4(ambient+diffuse+specular,1.0);


            }
            
            ENDCG
        }
    }
    FallBack "Specular"
}

在世界空间中计算(推荐)

// Upgrade NOTE: replaced '_Object2World' with 'unity_ObjectToWorld'

Shader "Custom/NormalMap_WorldSpace"
{
    Properties
    {
        _Color ("Color Tint", Color) = (1,1,1,1)  //控制整体色调
        _MainTex ("Main Tex", 2D) = "white" {}   //基本纹理贴图
        _BumpMap ("Normal Map",2D)="bump" {}     //法线纹理
        _BumpScale ("Bump Scale",Float)=1.0    //凹凸程度
        _Specular ("Specular", Color)=(1,1,1,1)
        _Gloss ("Gloss", Range(0,255)) = 10
        
    }
    SubShader
    {
        Pass{
            Tags { "LightMode"="ForwardBase" }
            
            CGPROGRAM
            // Physically based Standard lighting model, and enable shadows on all light types
            #pragma vertex vert
            #pragma fragment frag
            #include "Lighting.cginc"
            #include "UnityCG.cginc"

            fixed4 _Color;
            fixed4 _Specular;
            float _Gloss;
            sampler2D _MainTex;
            float4 _MainTex_ST;  //纹理贴图的缩放和平移值
            sampler2D _BumpMap;
            float4 _BumpMap_ST;  //法线贴图的缩放和平移值
            float _BumpScale;  

            struct a2v{
                float4 vertex: POSITION;
                float3 normal:NORMAL;    
                float4 tangent:TANGENT;  //切线方向,w分量存储旋向性，用于确定副切线的方向性
                float4 texcoord:TEXCOORD0;   //_MainTex和_BumpMap 通常使用同一组纹理坐标
            };
            struct v2f{
                float4 pos:SV_POSITION;       //裁剪空间坐标
                float4 uv:TEXCOORD0;        //xy存储光照贴图的纹理坐标，zw存储法线贴图的纹理坐标
                float4 TtoW0: TEXCOORD1;    //分开存储切线空间到世界空间的变换矩阵
                float4 TtoW1: TEXCOORD2;
                float4 TtoW2: TEXCOORD3;
                
            };


            v2f vert(a2v v)
            {
                v2f o;  //顶点着色器输出
                o.pos=UnityObjectToClipPos(v.vertex);
                o.uv.xy=v.texcoord.xy * _MainTex_ST.xy + _MainTex_ST.zw;  //纹理坐标乘以纹理的缩放加上平移
                o.uv.zw=v.texcoord.xy * _BumpMap_ST.xy + _BumpMap_ST.zw;  //法线贴图坐标乘以缩放加上平移

                float3 worldPos=mul(unity_ObjectToWorld,v.vertex);
                fixed3 worldNormal=UnityObjectToWorldNormal(v.normal);
                fixed3 worldTangent=UnityObjectToWorldDir(v.tangent.xyz);
                //用z轴（法线）叉乘x轴（切线）来计算y轴（副切线）的方向
                fixed3 worldBinormal=cross(worldNormal,worldTangent) * v.tangent.w;
                //切线空间变换到世界空间的变换矩阵，前三列是切线空间的坐标轴在世界空间下的表达
                //因为只需要变换向量（法线），不需要计算平移，只需要3x3的矩阵, w分量可以用于存储worldPos
                o.TtoW0=float4(worldTangent.x,worldBinormal.x,worldNormal.x,worldPos.x);
                o.TtoW1=float4(worldTangent.y,worldBinormal.y,worldNormal.y,worldPos.y);
                o.TtoW2=float4(worldTangent.z,worldBinormal.z,worldNormal.z,worldPos.z);
                return o;
            }
            fixed4 frag(v2f i):SV_TARGET
            {

                float3 worldPos=float3(i.TtoW0.w,i.TtoW1.w,i.TtoW2.w);
                fixed3 lightDir=normalize(UnityWorldSpaceLightDir(worldPos));
                fixed3 viewDir=normalize(UnityWorldSpaceViewDir(worldPos));
                fixed3 bump=UnpackNormal(tex2D(_BumpMap,i.uv.zw));
                bump.xy*=_BumpScale;
                bump.z=sqrt(1.0-saturate(dot(bump.xy,bump.xy)));
                //左乘变换矩阵，等于和每一行的行向量进行点乘,得到世界空间中的法线
                bump=normalize(half3(dot(i.TtoW0.xyz,bump),dot(i.TtoW1.xyz,bump),dot(i.TtoW2.xyz,bump)));
                
                fixed3 albedo=tex2D(_MainTex,i.uv).rgb * _Color.rgb;  //从纹理中获得计算漫反射使用的颜色
                fixed3 ambient=UNITY_LIGHTMODEL_AMBIENT.xyz * albedo;  //计算环境光照
                fixed3 diffuse=albedo*_LightColor0.rgb*max(0,dot(bump,lightDir)); //计算漫反射颜色
                fixed3 halfDir=normalize(lightDir+viewDir);  //半程向量
                //计算高光
                fixed3 specular=_LightColor0.rgb * _Specular.rgb *pow(max(0,dot(bump,halfDir)),_Gloss);
                return fixed4(ambient+diffuse+specular,1.0);

            }
            ENDCG
        }
    }
    FallBack "Specular"
}

参考

  1. 冯乐乐 《Unity Shader 入门精要》
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

Unity Shader：光照模型，纹理，详细注释 的相关文章

  • FPGA_边沿监测理解

    一 简易频率计设计中为什么一定要获取下降沿 gate a 实际闸门信号 gate a stand 将实际闸门信号打一拍之后的信号 gate a fall s 下降沿标志信号 cnt clk stand Y值 xff0c 即在实际闸门信号下

  • HAL库 STM32 串口通信

    一 实验条件 将STM32的PA9复用为串口1的TX xff0c PA10复用为串口1的RX STM32芯片的输出TX和接收RX与CH340的接收RX和发送TX相连 xff08 收发交叉且PCB上默认没有相连 xff0c 所以需要用P3跳线

  • 全局变量和局部变量

    一 C语言由四种地方可以定义变量 在函数外部定义的是全局变量 xff08 这里的函数包括main函数 xff09 在头文件中定义的是全局变量 在函数或语句块内部定义的是局部变量 函数的参数是该函数的局部变量 全局变量 xff0c 在定义位置

  • 单片机中断

    蓝桥杯单片机之中断 1 中断含义及过程 中断是指CPU在处理A事情时 xff0c 发现B请求CPU立刻去处理 xff08 中断发生 xff09 xff0c 于是CPU去处理B xff08 中断服务 xff09 xff0c 处理完B后又再次回

  • AprilTag的使用、相关问题及解决方法

    使用棋盘格标定相机 安装标定功能包 span class token function sudo span span class token function apt get span span class token function i

  • 对接海康综合安防管理平台经验总结

    前言 xff1a 因业务需要对接海康威视的综合安防管理平台获得下属所管理的摄像头 xff0c 根据摄像头code获得监控视频流信息 1 详情可以浏览海康开放平台 xff0c 在官网上有对应的接入指南以及开放的API接口 前提是本地已部署了海

  • 【环境配置】Visual Studio opencv配置

    需求 在Visual Studio环境中编写C 43 43 代码 xff0c 同时可以调用OpenCV的相关代码 1 安装OpenCV 访问 opencv 官网下载对应平台的库文件 注意 xff1a Visual Studio和OpenCV

  • MySQL常见用法

    文章目录 一 时间类1 1 DATE SUB 函数1 2 NOW CURDATE CURTIME DATE 函数1 3 实战 二 统计类三 字符类3 1 LOCATE 函数3 2 concat 函数3 3 concat ws 函数3 4 g

  • 牢记公式，ardupilot EKF2就是纸老虎（四）！

    版权声明 xff1a 本文为博主原创文章 xff0c 转载请附上博文链接 xff01 四 一睹EKF2芳容 因为篇幅过长 xff0c 写的一些公式会乱码 xff0c 没办法只能把 牢记公式 xff0c ardupilot EKF2就是纸老虎

  • Java Optional使用

    文章目录 Optional一 Optional 简介二 创建 Optional 实例2 1 empty 方法2 2 of 方法2 3 ofNullable 方法 三 Optional的使用3 1 访问 Optional 对象的值3 1 1

  • 正则表达式：基础详解以及在Java中的使用

    文章目录 一 正则表达式1 1 正则表达式中的特殊字符1 2 正则表达式所支持的合法字符1 3 方括号表达式1 4 边界匹配符1 5 三种模式的数量表示符 二 应用2 1 String 类2 2 Pattern 类和 Matcher 类 一

  • Python学习：关键字global和nonlocal的用法说明

    一 global global关键字用来在函数或其他局部作用域中使用全局变量 1 1 如果局部要对全局变量修改 xff0c 而不使用global关键字 count 61 0 def global test count 43 61 1 pri

  • Python：flask框架下前后端的数据交互

    文章目录 前提 一 前端发送数据 xff0c 后端接受数据1 1 路由传参数 数据 1 2 表单提交 二 后端发送数据 xff0c 前端接受数据 前提 后端 xff1a python 的 flask 框架 前端 xff1a html css

  • Python关于None的报错：'NoneType' object is not iterable和cannot unpack non-iterable NoneType object

    文章目录 一 TypeError 39 NoneType 39 object is not iterable xff08 类型错误 xff1a 39 NoneType 39 对象不是可迭代的 xff09 二 TypeError cannot

  • Git：合并分支----git merge命令应用的三种情景

    文章目录 一 git merge 命令应用的三种情景1 1 快进 无冲突 1 2 非 快进 xff0c 修改不同文件 无冲突 1 3 非 快进 xff0c 修改相同文件 有冲突 一 git merge 命令应用的三种情景 1 1 快进 无冲

  • Git：远程分支----git fetch命令的使用

    git fetch 命令的使用 从远程主机克隆 Git 的 clone 命令会为你自动将远程主机命名为 origin xff0c 拉取它的所有数据 xff0c 创建一个指向它的 master 分支的指针 xff0c 并且在本地将其命名为 o

  • Git：移除文件----git rm命令的使用

    文章目录 一 git rm 命令使用1 1 rm 命令1 2 git rm 命令1 3 git rm f 命令1 4 git rm cached 命令 一 git rm 命令使用 Git 本地数据管理 xff0c 大概可以分为三个区 xff

  • 【OpenMv小车】OpenMv追小球的小车之pid调用

    pid py gt gt https github com wagnerc4 flight controller blob master pid py openmv 官网 xff1a http book openmv cc project

  • 【深入理解C++】函数模板作为成员函数

    文章目录 1 普通类的成员函数模板2 类模板的成员函数模板 1 普通类的成员函数模板 不管是普通类还是类模板 xff0c 它们的成员函数都可以是函数模板 xff0c 称为成员函数模板 xff0c 但不可以是虚函数 xff0c 否则编译器报错

  • QGroundControl开发之使用自定义mavlink

    工具 对QGC进行二次开发时 xff0c 常常会遇到想使用自定义mavlink的情况 xff0c 但不像APM那样编译命令会根据xml文件自动生成mavlink协议 QGC似乎不能自动生成mavlink协议 xff08 之前试过似乎不能自动

随机推荐

热门标签