Directx11进阶之基于GerstnerWave模拟一之基于CPU计算的实现

最新推荐文章于 2024-06-20 18:11:36 发布
最新推荐文章于 2024-06-20 18:11:36 发布
阅读量1k 收藏 2
点赞数
分类专栏： directx11进阶
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29523119/article/details/81055532
版权

GerstnerWave

我们海洋模拟在那个GerstnerWave和FFT是两种常用的方法，这次我参考《GEM GEMS1》实现了一套GerstnerWave，大概简单总结下

 

顶点位置计算:

(1) x,y也就是坐标点在XZ平面的位置分量

(2) Q为波浪的陡峭参数

(3) D控制波浪的移动方向，为float2

(4) A为波浪的振幅

(5) t 为游戏开始到目前运行的时间

(6) 假设波长为λ， 则 频率 w = 2* π / λ,

(7) 假设我们的波长每秒移动的速度为 S，则相位常量 δ = w * S

总体上计算GerstnerWave的顶点位置的方式是，初始化一个大网格，对网格的每个顶点初始化XZ屏幕的值，代入上面的公式计算。不过从上面公式看

 

struct WaveParam
{
public:
	float fAmplitude;
	float fSpeed;
	float fWaveLength;

	WaveParam::WaveParam(float amplitude, float speed, float waveLength):
		fAmplitude(amplitude), fSpeed(speed), fWaveLength(waveLength)
	{

	}
};

struct GerstnerWaveParam : public DirectionSineWaveParam
{
public:
	float fSteepness;

	GerstnerWaveParam(XMFLOAT2 direction, float amplitude, float speed,
		float waveLength, float steepness) :
		DirectionSineWaveParam(direction, amplitude, speed, waveLength),
		fSteepness(steepness)
	{

	}
};

 

//计算位置
void GerstnerWave::CalculateVertexPos(float time)
{
	UINT index = 0;

	//从左到右，从下到上
	for (int posZ = -mWaveHeight / 2; posZ <= mWaveHeight / 2; ++posZ)
	{
		for (int posX = -mWaveWidth / 2; posX <= mWaveWidth / 2; ++posX)
		{
			float fPositionX = (float)posX * mWaveGridSize;
			float fPositionZ = (float)posZ * mWaveGridSize;

			float fGerstnerX = fPositionX + GetPosXOffset(fPositionX, fPositionZ, time);
			float fGerstnerZ = fPositionZ + GetPosZOffset(fPositionX, fPositionZ, time);
			//pos
			mWaveVertexData[index].pos.x = fGerstnerX;
			mWaveVertexData[index].pos.z = fGerstnerZ;
			mWaveVertexData[index].pos.y = (float)GetWaveVertexHeight(fPositionX, fPositionZ, time);
			++index;
		}
	}
}
float GerstnerWave::GetWaveVertexHeight(int x, int z, float time)
{
	float fHeight = 0.0f;

	for (UINT iParamIndex = 0; iParamIndex < m_vecGerstnerWaveParam.size(); ++iParamIndex)
	{

		DirectionSineWaveParam& dirWaveParam = m_vecGerstnerWaveParam[iParamIndex];

		float fDdotXZ = dirWaveParam.fDrection.x * x + dirWaveParam.fDrection.y * z;

		//频率
		float w = 2.0f * XM_PI / dirWaveParam.fWaveLength;

		//相位差常量
		float phaseConstant = dirWaveParam.fSpeed * w;


		//posZ
		fHeight += (float)dirWaveParam.fAmplitude * sin(fDdotXZ * w + time * phaseConstant);

	}

	return fHeight;
}
float GerstnerWave::GetPosXOffset(float x, float z, float time)
{
	float fPosXOffset = 0.0f;

	for (UINT iParamIndex = 0; iParamIndex < m_vecGerstnerWaveParam.size(); ++iParamIndex)
	{
		GerstnerWaveParam& gerstnerWaveParam = m_vecGerstnerWaveParam[iParamIndex];

		float fDdotXZ = gerstnerWaveParam.fDrection.x * x + gerstnerWaveParam.fDrection.y * z;

		//频率
		float w = 2.0f * XM_PI / gerstnerWaveParam.fWaveLength;

		//相位差常量
		float phaseConstant = gerstnerWaveParam.fSpeed * w;

		fPosXOffset += (float)gerstnerWaveParam.fAmplitude * gerstnerWaveParam.fSteepness *
			gerstnerWaveParam.fDrection.x * cos(fDdotXZ * w + time * phaseConstant);
	}

	return fPosXOffset;
}


float GerstnerWave::GetPosZOffset(float x, float z, float time)
{
	float fPosZOffset = 0.0f;

	for (UINT iParamIndex = 0; iParamIndex < m_vecGerstnerWaveParam.size(); ++iParamIndex)
	{
		GerstnerWaveParam& gerstnerWaveParam = m_vecGerstnerWaveParam[iParamIndex];

		float fDdotXZ = gerstnerWaveParam.fDrection.x * x + gerstnerWaveParam.fDrection.y * z;

		//频率
		float w = 2.0f * XM_PI / gerstnerWaveParam.fWaveLength;

		//相位差常量
		float phaseConstant = gerstnerWaveParam.fSpeed * w;

		fPosZOffset += (float)gerstnerWaveParam.fAmplitude * gerstnerWaveParam.fSteepness *
			gerstnerWaveParam.fDrection.y * cos(fDdotXZ * w + time * phaseConstant);
	}

	return fPosZOffset;
}

 

注意一下这里采用的是多组GerstnerWave参数叠加，因为仅仅1组效果不是很好，我参考了下网上的资料以及自己的实验结果，大概三组以及以上效果才能不错。

 

3组参数:

	vector<GerstnerWaveParam> vecGerstnerWaveParam;
	vecGerstnerWaveParam.push_back(GerstnerWaveParam(XMFLOAT2(0.7f, 0.7), 2.0f, 4.0f, 20.0f,0.3f));
	vecGerstnerWaveParam.push_back(GerstnerWaveParam(XMFLOAT2(0.7f, -0.7), 1.5f, 5.0f, 30.0f, 0.4f));
	vecGerstnerWaveParam.push_back(GerstnerWaveParam(XMFLOAT2(-0.7f, -0.3), 1.0f, 6.0f, 40.0f, 0.5f));

网格数是80 *  80, 每个格子大小为 1.0

大致得到的网格运算效果如下:

 

帧数只有17，有点 惨

 

顶点法线计算:

每个顶点法线的计算是计算临接的四个三角形的法线的规格向量的平均值。

void Wave::CalculateVertexNormal()
{

	for (int row = 0; row < mWaveHeight + 1; ++row)
	{
		for (int column = 0; column < mWaveWidth + 1; ++column)
		{
			int index = row * (mWaveWidth + 1) + column;
			XMFLOAT3 vertex1 = mWaveVertexData[index].pos;
			//左下角
			if ((0 == row && 0 == column))
			{
				XMFLOAT3 vertex2 = mWaveVertexData[(row + 1) * (mWaveWidth + 1) + column].pos;
				XMFLOAT3 vertex3 = mWaveVertexData[row * (mWaveWidth + 1) + column + 1].pos;
				mWaveVertexData[index].normal = CrossNormal(vertex1, vertex2, vertex3);
			}

			//右下角
			else if (0 == row && column == mWaveWidth)
			{
				XMFLOAT3 vertex2 = mWaveVertexData[row * (mWaveWidth + 1) + column - 1].pos;
				XMFLOAT3 vertex3 = mWaveVertexData[(row + 1) * (mWaveWidth + 1) + column].pos;
				mWaveVertexData[index].normal = CrossNormal(vertex1, vertex2, vertex3);
			}
			//左上角
			else if (mWaveHeight == row && 0 == column)
			{
				XMFLOAT3 vertex2 = mWaveVertexData[row * (mWaveWidth + 1) + column + 1].pos;
				XMFLOAT3 vertex3 = mWaveVertexData[(row - 1) * (mWaveWidth + 1) + column].pos;
				mWaveVertexData[index].normal = CrossNormal(vertex1, vertex2, vertex3);
			}
			//右上角
			else if (mWaveHeight == row && column == mWaveWidth)
			{
				XMFLOAT3 vertex2 = mWaveVertexData[(row - 1) * (mWaveWidth + 1) + column].pos;
				XMFLOAT3 vertex3 = mWaveVertexData[row * (mWaveWidth + 1) + column - 1].pos;
				mWaveVertexData[index].normal = CrossNormal(vertex1, vertex2, vertex3);
			}
			//左边
			else if (0 == column)
			{
				XMFLOAT3 vertex2 = mWaveVertexData[(row + 1) * (mWaveWidth + 1) + column].pos;
				XMFLOAT3 vertex3 = mWaveVertexData[row * (mWaveWidth + 1) + column + 1].pos;
				XMFLOAT3 vertex4 = mWaveVertexData[(row - 1) * (mWaveWidth + 1) + column].pos;
				XMFLOAT3 normal1 = CrossNormal(vertex1, vertex2, vertex3);
				XMFLOAT3 normal2 = CrossNormal(vertex1, vertex3, vertex4);
				mWaveVertexData[index].normal =
					XMFLOAT3((normal1.x + normal2.x) / 2.0f, (normal1.y + normal2.y) / 2.0f, (normal1.z + normal2.z) / 2.0f);
			}

			//右边
			else if (column == mWaveWidth)
			{
				XMFLOAT3 vertex2 = mWaveVertexData[(row - 1) * (mWaveWidth + 1) + column].pos;
				XMFLOAT3 vertex3 = mWaveVertexData[row * (mWaveWidth + 1) + column - 1].pos;
				XMFLOAT3 vertex4 = mWaveVertexData[(row + 1) * (mWaveWidth + 1) + column].pos;
				XMFLOAT3 normal1 = CrossNormal(vertex1, vertex2, vertex3);
				XMFLOAT3 normal2 = CrossNormal(vertex1, vertex3, vertex4);
				mWaveVertexData[index].normal =
					XMFLOAT3((normal1.x + normal2.x) / 2.0f, (normal1.y + normal2.y) / 2.0f, (normal1.z + normal2.z) / 2.0f);
			}
			//下边
			else if (0 == row)
			{
				XMFLOAT3 vertex2 = mWaveVertexData[row  * (mWaveWidth + 1) + column - 1].pos;
				XMFLOAT3 vertex3 = mWaveVertexData[(row + 1) * (mWaveWidth + 1) + column].pos;
				XMFLOAT3 vertex4 = mWaveVertexData[row * (mWaveWidth + 1) + column + 1].pos;
				XMFLOAT3 normal1 = CrossNormal(vertex1, vertex2, vertex3);
				XMFLOAT3 normal2 = CrossNormal(vertex1, vertex3, vertex4);
				mWaveVertexData[index].normal =
					XMFLOAT3((normal1.x + normal2.x) / 2.0f, (normal1.y + normal2.y) / 2.0f, (normal1.z + normal2.z) / 2.0f);
			}
			//上边
			else if (mWaveHeight == row)
			{
				XMFLOAT3 vertex2 = mWaveVertexData[row  * (mWaveWidth + 1) + column + 1].pos;
				XMFLOAT3 vertex3 = mWaveVertexData[(row - 1) * (mWaveWidth + 1) + column].pos;
				XMFLOAT3 vertex4 = mWaveVertexData[row * (mWaveWidth + 1) + column - 1].pos;
				XMFLOAT3 normal1 = CrossNormal(vertex1, vertex2, vertex3);
				XMFLOAT3 normal2 = CrossNormal(vertex1, vertex3, vertex4);

				mWaveVertexData[index].normal =
					XMFLOAT3((normal1.x + normal2.x) / 2.0f, 
					(normal1.y + normal2.y) / 2.0f, (normal1.z + normal2.z) / 2.0f);
			}
			//里面的
			else
			{
				XMFLOAT3 vertex2 = mWaveVertexData[(row + 1)  * (mWaveWidth + 1) + column].pos;
				XMFLOAT3 vertex3 = mWaveVertexData[row * (mWaveWidth + 1) + column + 1].pos;
				XMFLOAT3 vertex4 = mWaveVertexData[(row - 1) * (mWaveWidth + 1) + column].pos;
				XMFLOAT3 vertex5 = mWaveVertexData[row * (mWaveWidth + 1) + column - 1].pos;
				XMFLOAT3 normal1 = CrossNormal(vertex1, vertex2, vertex3);
				XMFLOAT3 normal2 = CrossNormal(vertex1, vertex3, vertex4);
				XMFLOAT3 normal3 = CrossNormal(vertex1, vertex4, vertex5);
				XMFLOAT3 normal4 = CrossNormal(vertex1, vertex5, vertex2);
				float normalX = (normal1.x + normal2.x + normal3.x + normal4.x) / 4.0f;
				float normalY = (normal1.y + normal2.y + normal3.y + normal4.y) / 4.0f;
				float normalZ = (normal1.z + normal2.z + normal3.z + normal4.z) / 4.0f;
				mWaveVertexData[index].normal = XMFLOAT3(normalX, normalY, normalZ);
			}

			NormalizeFloat3(mWaveVertexData[index].normal);
		}

	}
}

因为有些边缘或者角落的点并没有四个临接面，所以要做出一定的条件判断。

 

顶点切线的计算：

方法和之前的教程 Directx11教程十二之NormalMap(法线贴图)是一样的，利用位置边向量和纹理UV边向量

//计算切线
void Wave::CalculateVertexTangent()
{
	for (int row = 0; row < mWaveHeight + 1; ++row)
	{
		for (int column = 0; column < mWaveWidth + 1; ++column)
		{
			int index = row * (mWaveWidth + 1) + column;
			VertexPCNTT vertex1;
			VertexPCNTT vertex2;
			VertexPCNTT vertex3;
			
			//除开最上面行和最右行
			if (row >= 0 && row <= mWaveHeight - 1 && column >= 0 && column <= mWaveWidth - 1)
			{
				vertex1 = mWaveVertexData[index];
				vertex2 = mWaveVertexData[(row + 1) * (mWaveWidth + 1) + column];
				vertex3 = mWaveVertexData[row * (mWaveWidth + 1) + column + 1];

			}
			//除开右上角的最右行
			else if (row != mWaveHeight &&column == mWaveWidth)
			{
				vertex1 = mWaveVertexData[index];
				vertex2 = mWaveVertexData[(row + 1) * (mWaveWidth + 1) + column];
				vertex3 = mWaveVertexData[row * (mWaveWidth + 1) + column - 1];
			}
			//最上面一行
			else
			{
				mWaveVertexData[index].tangent = mWaveVertexData[index - mWaveWidth - 1].tangent;
				continue;
			}
		
			float Edge1[3], Edge2[3];
			float TexEdge1[2], TexEdge2[2];

			//计算面的两个向量  
			//边向量1  
			Edge1[0] = vertex2.pos.x - vertex1.pos.x; //E0X  
			Edge1[1] = vertex2.pos.y - vertex1.pos.y; //E0Y  
			Edge1[2] = vertex2.pos.z - vertex1.pos.z; //E0Z  

			//边向量2  
			Edge2[0] = vertex3.pos.x - vertex1.pos.x; //E1X  
			Edge2[1] = vertex3.pos.y - vertex1.pos.y; //E1Y  
			Edge2[2] = vertex3.pos.z - vertex1.pos.z; //E1Z  

			//纹理边向量1  
			TexEdge1[0] = vertex2.uv.x - vertex1.uv.x; //U0  
			TexEdge1[1] = vertex2.uv.y - vertex1.uv.y; //V0  

			//纹理边向量2  
			TexEdge2[0] = vertex3.uv.x - vertex1.uv.x; //U1  
			TexEdge2[1] = vertex3.uv.y - vertex1.uv.y; //V1  

			 //求出TB在模型空间坐标的方程系数  
			float den = 1.0f / (TexEdge1[0] * TexEdge2[1] - TexEdge1[1] * TexEdge2[0]);


			//求出Tangent  
			XMFLOAT3 tangent;
			tangent.x = den*(TexEdge2[1] * Edge1[0] - TexEdge1[1] * Edge2[0]);
			tangent.y = den*(TexEdge2[1] * Edge1[1] - TexEdge1[1] * Edge2[1]);
			tangent.z = den*(TexEdge2[1] * Edge1[2] - TexEdge1[1] * Edge2[2]);
			NormalizeFloat3(tangent);

			//求出垂直于Nomral的Tangent
			XMFLOAT3& normal = mWaveVertexData[index].normal;
			float dot = Dot(normal, tangent);
			tangent.x =-(tangent.x - dot * normal.x);
			tangent.y = -(tangent.y - dot * normal.y);
			tangent.z = -(tangent.z - dot * normal.z);
			NormalizeFloat3(tangent);
			
			mWaveVertexData[index].tangent = tangent;
		}
	}
}

 

顶点UV

 

这个倒没什么好说的

void Wave::CalculateVertexUV()
{
	for (int row = 0; row < mWaveHeight + 1; ++row)
	{
		for (int column = 0; column < mWaveWidth + 1; ++column)
		{
			int index = row * (mWaveWidth + 1) + column;
			float u = ((float)(column) / (float)mWaveHeight);
			float v = ((float)(row) / (float)mWaveWidth);
			mWaveVertexData[index].uv.x = u;
			mWaveVertexData[index].uv.y = v;
		}
	}

}

 

 

Shader代码:

 

Texture2D DiffuseTex:register(t0);  
Texture2D NormalTex:register(t1);
SamplerState SampleWrapLinear:register(s0);
SamplerState SampleClampPoint:register(s1);

cbuffer CBMatrix:register(b0)
{
	matrix World;
	matrix View;
	matrix Proj;
	matrix WorldInvTranspose;
	float3 cameraPos;
	float pad1;
	float4 dirLightColor;
	float3 dirLightDir;
	float pad2;
	float3 ambientLight;
	float pad3;
};

cbuffer CBEveryFrame:register(b1)
{
	float4 surfaceColor;
}

struct VertexIn
{
	float3 Pos:POSITION;
	float3 Color:COLOR;
	float3 Normal:NORMAL;
	float3 Tangent:TANGENT;
	float2 Tex:TEXCOORD;  

};


struct VertexOut
{
	float4 Pos:SV_POSITION;
	float3 worldPos:POSITION0;
	float3 WorldNormal:NORMAL;
	float3 WorldTangent:TANGENT;
	float2 Tex:TEXCOORD0;
};



VertexOut VS(VertexIn ina)
{
	VertexOut outa;
	outa.Pos = mul(float4(ina.Pos, 1.0f), World);

	outa.worldPos = outa.Pos.xyz;
	outa.Pos = mul(outa.Pos, View);
	outa.Pos = mul(outa.Pos, Proj);
	outa.WorldNormal = mul(ina.Normal, (float3x3)WorldInvTranspose);  //此事世界逆转置矩阵的第四行本来就没啥用
	outa.WorldNormal = normalize(outa.WorldNormal);

	outa.WorldTangent = mul(ina.Tangent, (float3x3)World);
	outa.WorldTangent = normalize(outa.WorldTangent);
	
	outa.Tex = ina.Tex;
	return outa;
}


float4 PS(VertexOut outa) : SV_Target
{
	float4 color = float4(0.0, 0.0, 0.0, 1.0);

	float3 normal = NormalTex.Sample(SampleWrapLinear, outa.Tex).xyz;
	normal = normal * 2.0 - 1.0;

	float3 N = normalize(outa.WorldNormal);
	float3 T = normalize(outa.WorldTangent);
	float3 B = normalize(cross(N, T));

	float3 worldNormal;
	worldNormal.x = normal.x * T.x + normal.y * B.x + normal.z * N.x;
	worldNormal.y = normal.x * T.y + normal.y * B.y + normal.z * N.y;
	worldNormal.z = normal.x * T.z + normal.y * B.z + normal.z * N.z;
	worldNormal = normalize(worldNormal);

	//float3 worldNormal = normalize(outa.WorldNormal);

	//计算diffuseLight
	float3 invLightDir = -normalize(dirLightDir);
	float diffuseFactor = saturate(dot(worldNormal, invLightDir));
	float3 diffuse = DiffuseTex.Sample(SampleWrapLinear, outa.Tex).xyz;
	diffuse = pow(diffuse, float4(2.0f, 2.0f, 2.0f, 0.0f));


	//SpecularLight
	float3 viewDir = normalize(cameraPos - outa.worldPos);
	float3 halfDir = normalize(invLightDir + viewDir);
	float spec = pow(saturate(dot(halfDir, worldNormal)), 32);
	float3 specular = float3(spec, spec, spec);

	color = float4((ambientLight + dirLightColor.xyz * diffuseFactor) * diffuse  + specular * 0.0f, 1.0);

	float correctGamma = 1.0 / 2.0;

	color = pow(color, float4(correctGamma, correctGamma, correctGamma, 0.0));

	return color;
}

DiffuseMap：

 

NormalMap:

 

80 X 80的大小只有16帧 只能说这样的大量并行数据下 CPU计算性能太差了，所以还是得指望ComputeShader。

下篇博客：Directx11进阶之基于GerstnerWave模拟二之基于ComputeShader的实现

源码：

https://github.com/2047241149/SDEngine 的Wave.h,  Wave.Cpp,  GerstnerWave.h,  GerstnerWave.cpp

 

参考资料:

【1】《GPU GEMS 1》的 Chapter 1. Effective Water Simulation from Physical Models

【2】水面的简单渲染 – Gerstner波

带帯大师兄
关注
专栏目录
水面的简单渲染 – Gerstner波
mmqqyyqqyyq的博客
11-14 558
水面的简单渲染 – Gerstner波
Unity Gerstner Waves(模拟大海波浪)
zakerhero的博客
08-30 7027
之前学习了一些Gerstner Waves的知识，看了一些教程，但发现说的略不够通俗，为了便于自己理解，我自己来写一个给自己的教程吧。 该教程会有三个步骤，一阐述原理，二给出源码和源码解释，三提供demo下载。这样一来就算文字看不懂， 也可以下载demo，运行demo，结合源码一起看，总有一种方式能让你看懂(^_^)。 原理解释 参考：GPU Gems的官方文档 https://deve...
Waves Moving Vertices----gerstner wave
小孔明的专栏
10-22 549
https://catlikecoding.com/unity/tutorials/flow/waves/ animate vertices create gerstner waves control wave direction combine multiple waves. 1 sine waves animating textures can create the illusion
Gerstner Wave 理解
paserity的博客
04-01 437
先看上半部分的sin波，红点代表平衡位置，黑点代表表面的偏移位置。实际上水面波也会在传播方向上运动，我们在日常生活中也经常看到，比如飘在水面的叶子也会在波传播的方向上左右晃动，而非单纯的上下移动。假设是不可压缩流体，表面质点分布均匀的话，我们知道在波峰的位置，由于表面往上移动，必须要有水流来填补下面的空间，这意味着周边质点汇集。可以清晰的看到表面质点的汇集和分散现象，同时这里给出了质点的受力分析：水体表面的质点受到重力（向下）和水的压力（指向表面法线方向），两者结合的合力组成了匀速圆周运动的向心力。
Unity 半透明shader以及扩展（外发光内发光）
SnoopyNa2Co3的博客
12-27 5707
半透shader什么时候用到呢 1.如果主角被东西挡住，摄像机要不拉近要不把挡住的物体半透 2.很多游戏用到残影，一般残影都是半透的，然后慢慢透明 从左到右 1.使用标准材质球 2.使用半透材质球 3.使用外发光的半透材质球 4.使用内发光和外发光的材质球 shader比较简单直接上代码 这些都是surface shader 1.半透shader Shader "Sno...
Physx在DirectX11中的实现，球铰模拟
10-08
标题提到的“Physx在DirectX11中的实现，球铰模拟”意味着这个项目或教程将展示如何在DirectX 11环境中利用PhysX进行球形铰链约束（也称为球关节）的物理模拟。球铰是一种允许物体在三维空间中旋转的约束，类似于...
通信与网络中的基于DirectX的音频视频无线传输系统设计与实现
12-05
1引言 　近些年来，多媒体技术，网络技术和无线通信技术的迅速发展为相互之间的交叉融合奠定了基础，也使其成为信息产业发展的必然趋势，传统的Internet主要提供数据业务，无线通信主要提供语音业务，而多媒体技术...
基于DirectX11的赛车模拟渲染器源码+项目说明.zip
01-28
【资源说明】 1、该资源包括项目的全部源码，下载可以直接使用！ 2、本项目适合作为计算机、数学、电子信息等专业的课程设计、期末大作业和毕设项目，作为参考资料...基于DirectX11的赛车模拟渲染器源码+项目说明.zip
使用DirectX11 SDK框架的NvFlex流体模拟
10-10
NvFlex实例1：使用DirectX11 SDK渲染框架结合NvFlex库实现流体渲染。由于NvFlex是Nvidia的开发包，可能在其他显卡上运行异常，但AMD显卡也可以跑，会出一个提示框，点击确定后开始运行。共7900个粒子。
一个效果非常屎的Gerstner wave
03-05
水面映射之类的高科技都没加
Opengl實現Gerstner波
07-11
[OpenGL] 动态的水面模拟 真实的水面模拟在三维游戏领域一直是一个非常热门的问题，因为在大型的场景中，流体总是不可避免地会存在的。
虚幻引擎 Gerstner Waves -GPU Gems 从物理模型中实现有效的水体模拟
最新发布
UTwelve虚幻4全懵工程师
06-20 1390
在UE中实现GerstnerWaves，并计算准确的波的法线叠加
Gerstner Wave In UDK
weixin_33682719的博客
05-28 107
转载于:https://www.cnblogs.com/Baesky/archive/2013/05/28/GerstnerWaves.html
UE5入门学习笔记（一）——Gerstner波
qq_45523399的博客
09-11 2323
在UE5中实现Gerstner波。
Unity Shader Example 15 (Gerstner Wave)
aa20274270的博客
08-04 2003
Shader "Unlit/GerstnerWave" { Properties { _MainTex ("Texture", 2D) = "black" {} // example 1(1个波的高度y) /* _GAmplitude ("Wave Amplitude", float) = 0.3 _GFrequency ("Wave Frequency", float)
[DirectX11]Gerstner波 实现简单的水面模拟
05-14 1291
利用Gerstner波方程模拟简单的水面波纹效果
Unity Shader学习：Gerstner波
咪咪博客
12-28 957
Unity Shader学习：Gerstner波 参考：https://www.jianshu.com/p/2b0e3f7f15b4?utm_campaign=maleskine https://blog.csdn.net/aa20274270/article/details/52122495 比较坑的是套用公式得出的法线效果不对，最后看了别人源码改了后才对 镜面反射扒来需要调整x轴旋转，可以自行修改代码 shader部分: Shader "Zzc/Gerstna" { Properties {
基于DirectX9的3D游戏引擎渲染系统研究与实现
"基于DirectX9的3D游戏引擎渲染系统研究与实现" 本论文的研究目的就是通过对游戏引擎渲染系统的理论研究，开发出一个可以胜任3D游戏和3D应用程序渲染功能的高效的游戏引擎渲染系统，并在开发实践中掌握游戏引擎渲染...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值