雨雪

实现方法概述

今天研究了一下雨雪，大部分雨可以通过粒子来实现，不过我自己见识过粒子雨雪的效率问题

看了看Game Programming Gems 5里头的实现方案，就是用一个大mesh，把深度测试关闭，用uv动画来实现和半透明混合来实现。当然，网上也有人说不建议使用此方案，因为它得为全屏做一个Blending，而且要画一个巨大的mesh。

我用的四层纹理动画实现，纹理图片是一张小圆点的素材，通过拉伸形成雨滴，雪花效果。四层纹理的速度，拉伸不一样可以形成很不错的视觉效果。

我不小心找到了它的出处，论文中有一个公式，可以导出给美术使用调节参数，试过之后效果不太好，已经被我否决，明天看看那个公式设计的因子重新设计一个公式，想办法通过尽可能少参数去做一个较好的控制。另外，文章提到的一点很重要，就是纹理移动的距离最好不要超过一个雨滴的大小，这样看起来才能形成连续的动画。所以vs做uv滚动的时候，尽可能尝试通过第一行去代替第二行的方式比较好。其中displacement =  sizeof( 圆点) / height( texture);

new_uv = vec2( in_uv.x, (in_uv.y+displacment) ) * scale_uv;

new_uv = vec2(in_uv * scale_uv.x, in_uv.y * scale_uv.y + displacement);

计算公式

原公式

把displacement 导出，当然我们可以在 SetVelocity(float velocity)函数内 把 velocity *= 0.01f;来把速度归一化为：纹理中圆点半径占整张纹理的百分比。在此之后我们可以专注于scale_uv的计算。先来看论文里的公式：

试验中可以考虑理想状态，先把不必要的去掉：

Velgravity重力产生的速度，直接去掉。如果想保留的话，加速效果可以在每一个vertex上绑一个属性，或者根据其高度来推一推近似的速度。

t_delta /  t_const 是为了帧率在变化的时候保持下落速度稳定，，忽略此项。

Vel_camera 可以用一个常数来表示。

原公式变为：

Vec_precip  = Cf  * Cvec;
E = Sstreak / (Sf *(Cpixel * Sf * Vec_precip  + Sstreak) );
Dprecip = Sstreak;

其中，Vec_precip是mesh下沉向量，E是缩放纹理用的系数。Dprecip是下落的距离。

变量

Sf：预定义的纹理缩放值，远处设大一些，看起来雨滴更小。

Cpixel：一个real-world space equivalent for each pixel in the texture的转换因子。

Sstreak：一个长度系数，让小雨显得更长，大雨更短。因为Sstreak = Dprecip，所以可以将Sstreak看成不能超过一个雨滴的大小，也就是 displacement。

从Gems5上看到的matrix 应该

matUV = [Sf, 0, 0, 0] 

                 [0 , E, 0, 0]

                 [0,  D, 0, 1]

                 [0,  0,  0, 1]

new_strq = matUV * strq;则new_uv = vec2( new_s, new_t);所以scale_uv = vec2(Sf, E);

今天没成功，明天去看看哪里有bug。

根据今天的实验效果，我决定放弃使用以上公式，并且用了第二个uv移动方式 new_uv = vec2(uv.x * scaleU,  uv.y * scaleV + offset);

先贴shader代码：

static const char* strVertexShader = {
		"#version 150\n"
		"uniform mat4 u_MatWV;"
		"uniform mat4 u_MatP;"
		"uniform vec4 u_Disp;"
		"uniform vec4 u_ScaleU;"
		"uniform vec4 u_ScaleV;"
		"in vec3 in_Pos;"
		"in vec2 in_TexCoord;"		
		"out vec4 tc12;"
		"out vec4 tc34;"
		"void main(){"
		"	gl_Position = u_MatP * u_MatWV * vec4(in_Pos, 1.0);"
		"	tc12 = vec4("
		"		in_TexCoord.x * u_ScaleU.x,"
		"		(in_TexCoord.y * u_ScaleV.x + u_Disp.x) ,"
		"		in_TexCoord.x * u_ScaleU.y,"
		"		(in_TexCoord.y * u_ScaleV.y + u_Disp.y));"
		"	tc34 = vec4("
		"		in_TexCoord.x * u_ScaleU.z,"
		"		(in_TexCoord.y * u_ScaleV.z  + u_Disp.z),"
		"		in_TexCoord.x * u_ScaleU.w,"
		"		(in_TexCoord.y * u_ScaleV.w + u_Disp.w));"
		"}\0\0"
	};

	static const char* strPixelShader = {
		"#version 150\n"
		"uniform sampler2D u_texRain; "
		"in vec4 tc12;"
		"in vec4 tc34;"
		"out vec4 fragColor;"
		"void main(){"
		"	vec4 factor = vec4(0.3,0.2,0.2,0.2);"
		"	fragColor = factor.x * texture(u_texRain, tc12.xy)"
		"		+ factor.y * texture(u_texRain, tc12.zw)"
		"		+ factor.z * texture(u_texRain, tc34.xy)"
		"		+ factor.w * texture(u_texRain, tc34.zw);"
		"}\0\0"

修改适应方案

参数制定

然后给出我的scale_uv解决方案。我的mesh生成方式每个网格的高是宽的两倍，所以 scale_uv_init  = vec2( u, u / 2 * k ); 其中，四层的u我给出了一组常数来确定。而k我将导出成每层的控制变量。因为 k 应该是一个小数，数值越小，则拉伸效果越明显，同时速度则越大，所以 我用 1/k 来做速度的控制因子。导出factor_level：

scale_k = 1 / (factor_level)^2;

offset_step_k = m_RainDropSize / factor_level;

m_RainDropSize = 一个圆点像素 / 纹理高度像素;

level_factor 取值在1-5之间都能很好的控制效果。

附上mesh代码

const float R_RFACTOR		= 1.0;
const int R_NUM			= 360;
const int R_CNT			= 36 * 5;
const int R_STEP		= R_NUM / R_CNT;
const int R_HEIGHT		= 30;
const int R_FACE_CNT		= 2 * R_CNT * (R_HEIGHT - 1);
const float R_RADIUS		= 100.0f;
const float W_H_RADIO		= 2.0f;
const float R_GRIDHEIGHT	= R_RADIUS * 2 * 3.1415926 / R_CNT * W_H_RADIO;

const int VB_SIZE = (R_CNT+1) * R_HEIGHT * sizeof(SWVertex);
m_vb = m_device->CreateVertexBuffer(VB_SIZE,Graphic::BU_WRITE, 0);
SWVertex* pVertexPtr = (SWVertex*)m_vb->Lock(Graphic::BU_WRITE);
SWVertex* pVtx = pVertexPtr;
const float MIDH = (R_HEIGHT-1)/2.0;
for(int i = 0; i < R_HEIGHT; i++)
{
	for(int j = 0; j <= R_NUM; j+= R_STEP)
	{
		float radius = 2 * (float)(j * 1.0f / R_NUM) * 3.1415926f;
		float h = i - MIDH;
		float r = R_RFACTOR * (MIDH - fabs(h)) / MIDH;
		//float r = 1.0 * i / R_HEIGHT ;
		pVtx->pos[0] = r * R_RADIUS * sin(radius);
		pVtx->pos[2] = r * R_RADIUS * cos(radius);
		pVtx->pos[1] = R_GRIDHEIGHT * h;
		
		pVtx->uv[0] = j * 1.0f / R_NUM;
		pVtx->uv[1] = i * 1.0f /(R_HEIGHT-1);
		pVtx++;
	}
}

//1.3 1.5的估计好多不兼容，来个1.1的
static const char* VertexShader = {
		 "#version 110\n"  
        "uniform mat4 u_MatWV;"  
        "uniform mat4 u_MatP;"  
        "uniform vec4 u_Disp;"  
        "uniform vec4 u_ScaleU;"  
        "uniform vec4 u_ScaleV;"  
        "attribute vec3 in_Pos;" 
        "attribute vec2 in_TexCoord;"        
        "varying vec4 tc12;"  
        "varying vec4 tc34;"  
        "void main(){"  
        //"   gl_Position = u_MatP * u_MatWV * vec4(in_Pos, 1.0);"  
		"	gl_Position = ftransform();"
        "   tc12 = vec4("  
        "       in_TexCoord.x * u_ScaleU.x,"  
        "       (in_TexCoord.y * u_ScaleV.x + u_Disp.x) ,"  
        "       in_TexCoord.x * u_ScaleU.y,"  
        "       (in_TexCoord.y * u_ScaleV.y + u_Disp.y));"  
        "   tc34 = vec4("  
        "       in_TexCoord.x * u_ScaleU.z,"  
        "       (in_TexCoord.y * u_ScaleV.z  + u_Disp.z),"  
        "       in_TexCoord.x * u_ScaleU.w,"  
        "       (in_TexCoord.y * u_ScaleV.w + u_Disp.w));"  
        "}\0\0"  
	};


	static const char* FragmentShader = {
		"#version 110\n"  
        "uniform sampler2D u_texRain; "  
        "varying vec4 tc12;"  
        "varying vec4 tc34;"  
        //"out vec4 fragColor;"  
        "void main(){"  
        "   vec4 factor = vec4(0.3,0.2,0.2,0.2);"  
        //"   fragColor = "
		"   gl_FragColor = "
		"		  factor.x * texture2D(u_texRain, tc12.xy)"  
        "       + factor.y * texture2D(u_texRain, tc12.zw)"  
        "       + factor.z * texture2D(u_texRain, tc34.xy)"  
        "       + factor.w * texture2D(u_texRain, tc34.zw);"  
        "}\0\0"  
	};

文献

附上论文地址：http://ofb.net/~niniane/rainsnow/rainsnow-sketch.pdf (submitted to SIGGRAPH 2004) 居然是名华人。