体积光渲染——SRP实现

最新推荐文章于 2022-07-11 20:57:10 发布
最新推荐文章于 2022-07-11 20:57:10 发布
阅读量651 收藏 2
点赞数 1
分类专栏： Unity
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wodownload2/article/details/108490333
版权

参考网址：
https://zhuanlan.zhihu.com/p/124297905
https://zhuanlan.zhihu.com/p/21425792?refer=c_37032701
效果图：
原git中有两个错误，需要修改，很是费解！！！
在这里插入图片描述

LightVolumePass.cs

void RenderLightVolume(ScriptableRenderContext context, RenderingData renderingData)
{
	……
	 switch (light.lightType)
     {
     	case LightType.Point:
        case LightType.Spot:
             cmd.DrawMesh(volumeData.Volume.VolumeMesh, volumeData.Volume.transform.localToWorldMatrix, volumeMat, 0, PassVolumeScattering);
             break;
         case LightType.Directional:
             cmd.BlitFullScreen(BuiltinRenderTextureType.None, rt, volumeMat, PassFullScreenVolumeScattering);
             break;
     }
     cmd.Blit(rt, renderingData.ColorTarget, volumeMat, PassVolumeResolve);

cmd设置绘制目的地：

cmd.GetTemporaryRT(rt, renderSize.x, renderSize.y, 0, FilterMode.Point, RenderTextureFormat.Default);
cmd.SetRenderTarget(rt, rt);
cmd.ClearRenderTarget(false, true, Color.black);

绘制完之后再：cmd.Blit(rt, renderingData.ColorTarget, volumeMat, PassVolumeResolve);

体积光核心shader部分：

float4 volumeLight(v2f_default i) : SV_TARGET
{
    i.screenPos /= i.screenPos.w;
    
    float3 ray = normalize(i.worldPos - _WorldCameraPos);
    float cameraDepth = tex2D(_CameraDepthTex, i.screenPos.xy).r;
    float near, far, depth;
    depth = getBoundary(ray, near, far);
    
    // Perform z culling with camera depth buffer
    float3 nearWorldPos = _WorldCameraPos + ray * near;
    float4 p = UnityWorldToClipPos(nearWorldPos);
    p /= p.w;
    //clip(p.z - cameraDepth);

    
    // Limit far distance with camera depth buffer
    float cameraWorldDepth = depthToWorldDistance(i.screenPos.xy, cameraDepth);
    far = min(far, cameraWorldDepth);
    near = max(_RangeLimit.x, near);
    far = min(_RangeLimit.y, far);

    // Jitter sample
    float offset = sampleOffset(i.screenPos.xy) * (far - near) / _Steps;
    far += offset;
    near +=offset;

    // Volumetric ray-marching
    float3 transmittance = 1;
    float3 color = 0;
    color = scattering(ray, near, far, transmittance);

    return float4(color, 1);
}

getBoundary函数：

float getBoundary(float3 ray, out float near, out float far)
{
    float maxNear = _ProjectionParams.y;
    float minFar = _ProjectionParams.z;
    bool intersected = false;
    for(int i = 0; i < _BoundaryPlaneCount; i++)
    {
        float t = intersectPlane(_BoundaryPlanes[i], _WorldCameraPos, ray, intersected);
        if(intersected && dot(ray, _BoundaryPlanes[i].xyz) < 0) // frontface
            maxNear = max(maxNear, t);
        else if(intersected)
            minFar = min(minFar, t);
    }
    near = maxNear;
    far = minFar;
    return minFar - maxNear;
}

这个函数求解，是当前射线方向上，近平面和远平面，已经far-near的深度。
如图所示：
在这里插入图片描述

float cameraWorldDepth = depthToWorldDistance(i.screenPos.xy, cameraDepth);
far = min(far, cameraWorldDepth);
near = max(_RangeLimit.x, near);
far = min(_RangeLimit.y, far);

经过这段代码：

在这里插入图片描述
far前移至自己的顶点位置。

在这里插入图片描述
只要步进这6个点，然后计算每个步进点的颜色值，累加，即得到黑色点的颜色值。
其中near到绿色的far，直接的距离就是体积光的效果。

float3 scattering(float3 ray, float near, float far, out float3 transmittance) // Alpha is total transmittance
{
    transmittance = 1;
    float3 totalLight = 0;
    float stepSize = (far - near) / _Steps;
    [loop]
    for(int i = 1; i <= _Steps; i++) //这个for就是步进的代码体现
    {
        float3 pos = _WorldCameraPos + ray * (near + stepSize * i);
        transmittance *= exp(-stepSize * extinctionAt(pos));
        float3 lightDir;
        totalLight += transmittance * lightAt(pos, lightDir) * stepSize * phaseHG(lightDir, -ray);
    }
    return totalLight;
}

某个步进点的颜色值：

float3 lightAt(float3 pos, out float3 lightDir)
{
 	lightDir = normalize(_LightPosition.xyz - pos * _LightPosition.w);
    float lightDistance = lerp(_LightDistance, distance(_LightPosition.xyz, pos), _LightPosition.w);
    float3 transmittance = lerp(1, exp(-lightDistance * _TransmittanceExtinction), _IncomingLoss);
    float3 inScatter = _TransmittanceExtinction * (1 - _AbsorptionRatio);

 	float3 lightColor = _LightColor.rgb;
    lightColor *= step(_LightCosHalfAngle, dot(lightDir, _LightDirection));
    lightColor *= shadowAt(pos);
    lightColor *= inScatter;
    lightColor *= transmittance;
    return lightColor;
}

聚光灯的网格：
在这里插入图片描述

视椎体的平面方程：

 List<Vector4> planes = new List<Vector4>(6);
        public List<Vector4> GetVolumeBoundFaces(Camera camera)
        {
            planes.Clear();
            Matrix4x4 viewProjection = Matrix4x4.identity;
            if(light.type == LightType.Spot)
            {
                viewProjection = Matrix4x4.Perspective(light.spotAngle, 1, 0.03f, light.range) * Matrix4x4.Scale(new Vector3(1, 1, -1)) * light.transform.worldToLocalMatrix;
                var m0 = viewProjection.GetRow(0);
                var m1 = viewProjection.GetRow(1);
                var m2 = viewProjection.GetRow(2);
                var m3 = viewProjection.GetRow(3);
                planes.Add( -(m3 + m0));
                planes.Add( -(m3 - m0));
                planes.Add( -(m3 + m1));
                planes.Add( -(m3 - m1));
                // planes.Add( -(m3 + m2)); // ignore near
                planes.Add( -(m3 - m2));
            }
            else if(light.type == LightType.Directional)
            {
                viewProjection = camera.projectionMatrix * camera.worldToCameraMatrix;
                var m2 = viewProjection.GetRow(2);
                var m3 = viewProjection.GetRow(3);
                planes.Add(-(m3 + m2)); // near plane only
            }
            return planes;

        }

射线和平面相交的判断：
https://blog.csdn.net/a435262767/article/details/104700156

   float intersectPlane(float4 plane, float3 origin, float3 dir, out bool intersect)
    {
        // t = -(O . P) / (D . P)
        float d = dot(dir, plane.xyz);
        intersect = d != 0;
        return -dot(float4(origin.xyz, 1), plane) / d;
    }

总的shader：

Shader "SarRP/LightVolume/Raymarching" {
    Properties {
        [HideInInspector] _MainTex ("MainTex", 2D) = "white" {}
        _ExtinctionTex ("Extinction", 3D) = "white" {}
        _AbsorptionRatio ("Absorption Ratio", Range(0, 1)) = 0.5
        _UVScale ("UV Scale", Vector) = (1, 1, 1, 1)
        //[HDR] _TransmittanceExtinction ("Extinction Scale", Color) = (1, 1, 1, 1)
        // _IncomingLoss ("Light Attenuation", Range(0, 1)) = 1
        //_Steps ("Steps", Int) = 64
        _Seed ("Seed", Float) = 1
        _HGFactor ("HG Phase Factor", Range(-1, 1)) = 0
        //_SampleNoise ("Sample Noise", 2D) = "black" {}
    }

    HLSLINCLUDE

    #include "../Lib.hlsl"
    #include "../Light.hlsl"
    #include "../Noise.hlsl"
    #include "../Shadow/ShadowLib.hlsl"

    float intersectPlane(float4 plane, float3 origin, float3 dir, out bool intersect)
    {
        // t = -(O . P) / (D . P)
        float d = dot(dir, plane.xyz);
        intersect = d != 0;
        return -dot(float4(origin.xyz, 1), plane) / d;
    }

    uint _VolumeIndex;
    RWTexture2DArray<half2> _RWVolumeDepthTexture;
    Texture2DArray<half2> _VolumeDepthTexture;
    sampler3D _ExtinctionTex;
    float4x4 _LightProjectionMatrix;
    float3 _UVScale;
    int _Steps;
    float2 _RangeLimit;
    float3 _TransmittanceExtinction;
    float _IncomingLoss;
    float _LightDistance;
    float4 _BoundaryPlanes[16];
    int _BoundaryPlaneCount;
    float _Seed;
    float4 _FrameSize;
    float _HGFactor;
    float _AbsorptionRatio;
    
    sampler2D _SampleNoise;
    float4 _SampleNoise_TexelSize;

    sampler2D _CameraDepthTex;

    float4 volumeDepth(v2f_default i, fixed facing : VFACE) : SV_TARGET
    {
        uint3 coord = uint3(_ScreenParams.xy * i.pos.xy, _VolumeIndex);
        half2 depth = _RWVolumeDepthTexture[coord].rg;
        if(facing > 0)
            depth.r = distance(i.worldPos, _WorldCameraPos);
        else
            depth.g = distance(i.worldPos, _WorldCameraPos);
        _RWVolumeDepthTexture[coord] = depth;
        return float4(depth.rg, 0, 0);
    }

    float phaseHG(float3 lightDir, float3 viewDir)
    {
        float g = _HGFactor;
        return (1 - g * g) / (4 * PI * pow(1 + g * g - 2 * g * dot(viewDir, lightDir), 1.5)); 
    }

    float3 sampleExtinctionTex(float3 pos)
    {
        float3 noise = tex3D(_ExtinctionTex, pos * _UVScale).rgb;
        noise *= .5;
        noise += .5;
        return noise;
    }

    float3 extinctionAt(float3 pos)
    {
        return 1 * _TransmittanceExtinction;
    }

    float3 lightAt(float3 pos, out float3 lightDir)
    {
	    lightDir = normalize(_LightPosition.xyz - pos * _LightPosition.w);
        float lightDistance = lerp(_LightDistance, distance(_LightPosition.xyz, pos), _LightPosition.w);
        float3 transmittance = lerp(1, exp(-lightDistance * _TransmittanceExtinction), _IncomingLoss);
        float3 inScatter = _TransmittanceExtinction * (1 - _AbsorptionRatio);

	    float3 lightColor = _LightColor.rgb;
        lightColor *= step(_LightCosHalfAngle, dot(lightDir, _LightDirection));
        lightColor *= shadowAt(pos);
        lightColor *= inScatter;
        lightColor *= transmittance;

        return lightColor;
    }

    float3 scattering(float3 ray, float near, float far, out float3 transmittance) // Alpha is total transmittance
    {
        transmittance = 1;
        float3 totalLight = 0;
        float stepSize = (far - near) / _Steps;
        [loop]
        for(int i = 1; i <= _Steps; i++)
        {
            float3 pos = _WorldCameraPos + ray * (near + stepSize * i);
            transmittance *= exp(-stepSize * extinctionAt(pos));
            //transmittance = exp(-far * extinctionAt(pos));
            /*if(transmittance.x < 0.01 && transmittance.y < 0.01 && transmittance.z < 0.01)
                break;*/
            float3 lightDir;
            totalLight += transmittance * lightAt(pos, lightDir) * stepSize * phaseHG(lightDir, -ray);
            //totalLight = transmittance;
        }
        return totalLight;
    }

    float getBoundary(float3 ray, out float near, out float far)
    {
        float maxNear = _ProjectionParams.y;
        float minFar = _ProjectionParams.z;
        bool intersected = false;
        for(int i = 0; i < _BoundaryPlaneCount; i++)
        {
            float t = intersectPlane(_BoundaryPlanes[i], _WorldCameraPos, ray, intersected);
            if(intersected && dot(ray, _BoundaryPlanes[i].xyz) < 0) // frontface
                maxNear = max(maxNear, t);
            else if(intersected)
                minFar = min(minFar, t);
        }
        near = maxNear;
        far = minFar;
        return minFar - maxNear;
    }

    float sampleOffset(float2 screenPos)
    {
        //return 0;
        // return gold_noise(screenPos, _Seed);
        return tex2D(_SampleNoise, screenPos * _FrameSize.xy * _SampleNoise_TexelSize.xy) * 2 - 1;
    }

    float4 volumeLight(v2f_default i) : SV_TARGET
    {
        i.screenPos /= i.screenPos.w;
        
        float3 ray = normalize(i.worldPos - _WorldCameraPos);
        float cameraDepth = tex2D(_CameraDepthTex, i.screenPos.xy).r;
        float near, far, depth;
        depth = getBoundary(ray, near, far);
        
        // Perform z culling with camera depth buffer
        float3 nearWorldPos = _WorldCameraPos + ray * near;
        float4 p = UnityWorldToClipPos(nearWorldPos);
        p /= p.w;
        //clip(p.z - cameraDepth);

        
        // Limit far distance with camera depth buffer
        float cameraWorldDepth = depthToWorldDistance(i.screenPos.xy, cameraDepth);
        far = min(far, cameraWorldDepth);
        near = max(_RangeLimit.x, near);
        far = min(_RangeLimit.y, far);

        // Jitter sample
        float offset = sampleOffset(i.screenPos.xy) * (far - near) / _Steps;
        far += offset;
        near +=offset;

        // Volumetric ray-marching
        float3 transmittance = 1;
        float3 color = 0;
        color = scattering(ray, near, far, transmittance);

        return float4(color, 1);
    }

    float _GlobalFogExtinction;

    float4 globalFog(v2f_ray i) : SV_TARGET
    {
        float3 ray = normalize(i.ray);
        float depth = tex2D(_CameraDepthTex, i.uv).r;
        float3 worldPos = _WorldCameraPos + LinearEyeDepth(depth) * i.ray;
        float z = distance(_WorldCameraPos, worldPos);
        float transmittance = exp(-_GlobalFogExtinction * z);

        float3 color = _AmbientLight * (1 - transmittance);
        return float4(color.rgb, 1 - transmittance);
    }

    sampler2D _MainTex;
    float4 _MainTex_TexelSize;

    float randf(float2 pos, float seed)
    {
        return gold_noise(pos, seed) *.5 + .5;
    }

    float4 mixScreen(v2f_default i) : SV_TARGET
    {
        float4 col = 0;
        float R = 4;
        for(int j = 0; j < 4; j++)
        {
            float dist = j * R;
            dist += randf(i.uv.xy, _Seed + j);
            dist = sqrt(dist);
            float2 rot;
            float ang = randf(i.uv.xy, _Seed + j) * 2 * PI;
            sincos(ang, rot.x, rot.y);
            float2 offset = rot * dist * _MainTex_TexelSize.xy;
            col += tex2D(_MainTex, i.uv.xy + offset).rgba;
        }
        //return tex2D(_MainTex, i.uv.xy);
        return col / 4;
    }

    ENDHLSL

    SubShader {
        // #0 Distance between front & backface
        Pass {
            Name "Light Volume Raymarching"
            ZTest Off
            ZWrite Off
            Cull Off
            Blend One Zero

            HLSLPROGRAM

            #pragma vertex vert_default
            #pragma fragment volumeDepth
            #pragma target 5.0

            ENDHLSL
        }
        // #1 Volumetric scattering
        Pass {
            Name "Light Volume Scattering"
            ZTest Less
            ZWrite Off
            Cull Front
            Blend One One

            HLSLPROGRAM

            #pragma vertex vert_default
            #pragma fragment volumeLight
            #pragma target 5.0
            
            //#pragma enable_d3d11_debug_symbols

            ENDHLSL
        }

        // #2 Full-screen volumetric scattering
        Pass {
            Name "Full-screne Light Volume Scattering"
            ZTest Less
            ZWrite Off
            Cull Off
            Blend One One

            HLSLPROGRAM

            #pragma vertex vert_blit_default
            #pragma fragment volumeLight
            #pragma target 5.0
            
            //#pragma enable_d3d11_debug_symbols

            ENDHLSL
        }

        // #3 Blit to Screen Buffer
        Pass {
            Name "Light Volume Scattering"
            ZTest Off
            ZWrite On
            Cull Back
            Blend One One

            HLSLPROGRAM

            #pragma vertex vert_default
            #pragma fragment mixScreen
            #pragma target 5.0
            
            //#pragma enable_d3d11_debug_symbols

            ENDHLSL
        }

        // #4 Global Fog
        Pass {
            Name "Global Fog"
            ZTest Off
            ZWrite On
            Cull Off
            Blend One OneMinusSrcAlpha

            HLSLPROGRAM

            #pragma vertex vert_ray
            #pragma fragment globalFog
            #pragma target 5.0
            
            //#pragma enable_d3d11_debug_symbols

            ENDHLSL
        }
    }
}
wodownload2
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
体积雾/体积光原理及实现paper
04-19
对体积光和体积雾原理讲解很详细的文档，还有对其实现及gitHub地址。
体积光渲染技术
weixin_34015860的博客
08-03 1872
什么是体积光 遮光物体被光源照射时，在其周围呈现的光的放射性泄露，称其为体积光。例如太阳照到树上，会从树叶的缝隙中透过形成光柱。之所以称之为体积光，是因为这种特效下的光照相比以往游戏中的光照给人视觉上以空间的感觉。体积光让游戏玩家更真实的感觉。有时也指实现这一特效的技术。-《百度百科》 Volumetric lighting is a technique...
游戏开发相关实时渲染技术之体积光
weixin_30675967的博客
11-15 109
https://zhuanlan.zhihu.com/p/21425792 转载于:https://www.cnblogs.com/guochen/p/9964739.html
RayMarching实现体积光渲染
weixin_39289457的博客
04-26 1792
RayMarching实现体积光效果（平行光） 前言 本次Demo核心代码来自github，本次Demo分享简化了部分代码包含模型自定义调节代码，改为统一用Cube代替模型，并追加光照计算以及体积雾效果，本次demo是在平行光下计算的体积光。
[OpenGL] 体积光效果实现
(ง •̀_•́)ง
02-23 6426
reference: Volumetric Light Effects in Killzone: Shadow Fall [1] Interactive Rendering Method for Displaying Shafts of Light [2] 游戏开发相关实时渲染技术之体积光 [3] 本文包含的内容： 1.体积光介绍 2.使用Ray-match实现最基本的体积...
fast-srp:纯NodeJS SRP实现
05-10
是一个纯粹实现的。 这是的和的的衍生作品。 创建验证器 'use strict' ; var srp6a = require ( 'fast-srp' ) ; /** * Computes the verifier of a user. Only needed to add the user to the auth system. * *...
python网络编程——实现ARP协议
12-23
2.使用scapy库中的srp()函数发送二层数据包并获得返回值 3.使用type()函数分析返回值类型，查询对应的类中的方法，来提取关键信息 发送包的属性可以在scapy中查询，如： 查询本机对应网卡，IP，MAC 代码： import ...
Volumetric-Occlusion-Mask-SRP:使用SRP为对象创建体积遮挡蒙版，以在其渲染过程中使用
04-29
将研究建立一个基于网格距离场的系统来实现此效果。 使用Unity 2018.2.0b7程序包管理器：轻量级渲染管道1.1.10-预览版和后处理2.0.7-预览版大多数代码在LightweightPipeline.Render中，请确保将包管理器中提供的...
SRP-6a:安全远程密码协议（SRP）算法的实现
05-12
SRP 6a相互认证算法。 什么是SRP： ： 这是和描述的步骤 客户端从密码生成一个和一个。 客户端向服务器发送用户名和A。 服务器生成b和B。B是从b和v生成的（验证程序是从DB生成的） 客户端和服务器都从A和B生成U...
基于Matlab实现SRP-PHAT的麦克风声源定位
最新发布
06-23
【作品名称】：基于Matlab实现SRP-PHAT的麦克风声源定位 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【项目介绍】：当前项目基本...
UnityShader 基于物理的体积光（丁达尔光线）
weixin_43368234的博客
07-11 3520
UnityShader 基于物理的体积光（丁达尔光线）
体积光
l1987021的专栏
04-08 1729
体积光是透射的一种，次表面散射也是，所不同的是次表面散射是在模型里面，而体积光一般都是在模型外面。   伪体积光散射： 基于延迟渲染的体积光散射，简单说就是2D模拟3D效果，过程： 1.在屏幕中渲染光源 2.在屏幕中渲染遮蔽 3.屏幕中某点的颜色，是这个点到光源的这个线段上采样点的光的颜色的累积 (- -)。 #define NUM_SAMPLES 200 // 采样数 [nu...
游戏开发相关实时渲染技术分享：体积光的表现形式探究
woliuqiangdong的博客
09-23 667
https://www.fgba.net/sitemap.xml
基于物理的体积光实现
u012740992的专栏
11-25 1333
序言 在上一个项目中，美术的同学有在场景中实现体积光的要求，当时因为时间紧迫关系，第一反应就是在Assetstore找插件，找了一阵没找到适合的插件，后来使用了网格简单实现。 再后来然后注意到github上Unity有一个VolumetricLighting的实现，好开心啊果断clone下来，打开Unity一看，效果大体还可以，其实却有好多细节没有实现。 阅读了一阵 VolumetricLighting的 源码，发现它只支持延迟渲染，不能用于移动平台，除了AreaLight其它类型Light没有实现阴影体积
[图形学] Killzone: Shadow Fall 中的体积光效果
(ง •̀_•́)ง
02-16 2668
reference : 《GPU Pro 5》 简介 体积光效果是由于光线在潮湿、多尘或烟雾环境中散射产生的（如图3.1所示）。这是一个令人惊叹的自然现象，它可以用于创建壮观的图像，并为环境增添氛围感。 关于光散射和体积光已经有了许多文章。它们的中的大多数都专注于提高渲染性能和图像质量的技术。但是，它们中的大多数都没有解决在现实中的游戏场景中实现效果所需要克服...
体积光和软阴影(Volume Light and Soft Shadow)
08-04 2217
把点光源扩展了一下，允许指定体积。在体积光模式下，需要指定采样范围以及采样模式。float radius;int volume;int samplingMethod;其中的volume是采样密度，也就是相当于体积的一个系数。radius指定了采样范围，samplingMethod指定了采样范围。下图是使用stochastic采样10个点，外部使用Adaptive Grid作自适应采样的结果
volume light/light shaft/god ray
weixin_30480583的博客
03-30 257
试了gpugems3中的方法。 方法很简单，将一张遮挡后的明暗图做一些sample，再调整一下，add到原先的target上。有意思的是 其实我在2004年的时候就在一个项目中看到一个老外用了这种方法，当时也没放在心上，没想到现在会 出现在gpugem3上。不过这种方法其实只是近似的做了一些处理，使挡住光源的物体造成lightshaft的 效果，没有利用到深度的信息，还不是真正的“vo...
OpenGL 体积光 光柱实现代码解读教程
黑子风暴
09-11 525
engine.cpp 图 GL依赖库大全 链接：https://pan.baidu.com/s/13jJIhkOdMetsPSkbKfbUmg 提取码：n0ud 体积光源代码 链接：https://pan.baidu.com/s/17kycTiPfwVU1IrBPdnOMNg 提取码：7fjw
绘制半圆_关于Mesh绘制体积光的一次思考
weixin_32259417的博客
01-15 151
之前在知乎拜读了 @刘相敬的文章：刘相敬：高质量Mesh体积光渲染​zhuanlan.zhihu.com并和诸位大佬@黄翔 @oz01展开了一系列技术交流，交流后对于Mesh绘制体积光的可行性陷入思考，即Mesh绘制如何达到或接近于纯粹的物理渲染的程度。我们在之前的文章中实现过基于视锥空间体素渲染的基于物理的体积渲染实现：MaxwellGeng：Physically Based Volumetri...
大学毕业论文-—srp基于单片机的红外测温仪.doc
07-08
论文作者详细阐述了红外测温的工作原理，并对系统中的关键元器件——单片机和红外传感器进行了特征分析。" 本文主要探讨的知识点包括： 1. **红外测温技术**：红外测温仪利用物体发射的红外辐射能量来测量其温度，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值