随机返回一个指定向量的垂直向量

粒子系统里粒子角度的控制麻烦又简单，所以随机数总是发挥这重要的作用，随机数产生器代码：

随机数头文件

/////////////////////////////////////////////////////////////////
// EOMrandomMaker.h		
// 随机数产生器
// 
// 高国文 @2013-11-22
/////////////////////////////////////////////////////////////////
#pragma once


#include "stdafx.h"			// 预编译头


#define EOM_RANDOM_COEFF 4164903690U
typedef unsigned char		uchar;
typedef char				schar;
typedef unsigned short		ushort;
typedef unsigned int		uint32;
typedef unsigned __int64	uint64;


// 预声明
class randomMaker; 


///////////////////////class randomMaker 开始////////////////////
class randomMaker
{////////////////////////////////////////////////////////////////
	// 构造
public:
	randomMaker();
	randomMaker( uint64 state );
/////////////////////////////////////////////////////////////////
// 数据
public:
/////////////////////////////////////////////////////////////////
// 属性
public:
	uint64 state;
/////////////////////////////////////////////////////////////////
// 操作
public:
	// 整形随机数产生器
	uint32	nexti32();
	ushort	nextus();
	short	nexts();
	// 随机BOOL
	bool	nextb();
	// 8位随机数产生器
	uchar nextuc();
	schar nextc();
	// 浮点随机数产生器
	float	nextf();
	double	nextd();
	// 受范围限制的随机数产生器
	int		randomInRange(int a, int b);
	float	randomInRange(float a, float b);
	double	randomInRange(double a, double b);
};///////////////////////class randomMaker 结束////////////////////


// 功能：更新状态，返回下一个32位整形/短整型随机数
inline uint32	randomMaker::nexti32() 
{
	state = (uint64)( state*EOM_RANDOM_COEFF + (state >> 32) );
	return (uint32)state;
}
inline ushort	randomMaker::nextus() { return (ushort)nexti32(); }
inline short	randomMaker::nexts() { return (short)nexti32(); }
// 功能：随机BOOL
inline bool randomMaker::nextb()	{ return (nexti32() > UINT_MAX/2)? (true):(false); }
// 功能：更新状态，返回下一个8位有/无符号随机数
inline uchar	randomMaker::nextuc() { return (uchar)nexti32(); }
inline char	randomMaker::nextc() { return (schar)nexti32(); }
// 功能：更新状态，返回下一个浮点/双浮点随机数
inline float	randomMaker::nextf() { return nexti32()*2.3283064365386962890625e-10f; }
inline double	randomMaker::nextd()
{
	uint32 t = nexti32();
	return (((__int64)t << 32) | nexti32())*5.4210108624275221700372640043497e-20;
}
// 功能：产生 a-b 范围的随机数
inline int	randomMaker::randomInRange(int a, int b) { return a == b ? a : (int)(nexti32()%(b - a) + a); }
inline float	randomMaker::randomInRange(float a, float b) { return nextf()*(b - a) + a; }
inline double	randomMaker::randomInRange(double a, double b) { return nextd()*(b - a) + a; }

随机数源文件：

/////////////////////////////////////////////////////////////////
// EOMrandomMaker.h		
// 随机数产生器
// 
// 高国文 @2013-11-22
/////////////////////////////////////////////////////////////////


#include "stdafx.h"		// 预编译头
#include "EOMrandomMaker.h"


///////////////////////class randomMaker 开始////////////////////
// 构造
// 功能：构造
randomMaker::randomMaker( ) 
{
	state = 0xffffffff; 
}
// 功能：构造
randomMaker::randomMaker(uint64 _state) 
{ 
	state = ( (_state)? (_state):(0xffffffff) ); 
}
///////////////////////class randomMaker 结束////////////////////

下面，是产生随机向量（单位向量）的函数。当然，你需要先指定一个向量（非必须为单位向量），然后调用就可以了

/*
* 随机产生一个垂直与指定向量的向量
*/ 
void calRandomVecticalVector(FV3 result, const FV3 dir, randomMaker *rm)
{
	result[0] = rm->randomInRange(-1.0f, 1.0f);
	result[1] = rm->randomInRange(-1.0f, 1.0f);
	result[2] = (dir[0] * result[0] + dir[1] * result[1]) / dir[2];
	// 单位化向量
	float len = sqrtf( result[0] * result[0] + result[1] * result[1] + result[2] * result[2] );
	result[0] /= len;
	result[1] /= len;
	result[2] /= len;
}

验证一下效果，我们定义一个数组，大小为800，目标向量为Z正半轴，

#define NUMS 800
typedef float(&FV3)[3];

float randomVector[NUMS][3];
float zvector[3] = {0.0f, 0.0f, 1.0f};
randomMaker *rm = nullptr;

接下来初始化随机数生成器，并生成800个随机向量

rm = new randomMaker(11111);

	for (int i = 0; i < NUMS; ++i)
	{
		calRandomVecticalVector(randomVector[i], zvector, rm);
	}

随后依次绘制如下，800个垂直z轴的线条基本组成了圆面：

soso，其实这并非真正的随机向量，只不过耍了点“小聪明”，如果精度要求不高的话基本可以满足要求了。

///////////////////////////////////////////////////////////////////////////////////

2014-6-30函数calRandomVecticalVector(...)有点“问题”，现在改正如下:

// 返回3维向量的随机垂直向量
void createRandomVerticalVector(float* result, float* v, randomMaker* rng)
{
	int tag = -1;
	float num = 0.f;
	for (size_t ite = 0; ite < 3; ++ite)
	{
		if (0 != v[ite])
			tag = ite;

		result[ite] = rng->randomInRange(-1.f, 1.f);
		num += result[ite] * v[ite];
	}

	result[tag] = (num - result[tag] * v[tag]) / v[tag];
	// 单位化结果向量
	float len = sqrtf(result[0] * result[0] + result[1] * result[1] + result[2] * result[2]);
	result[0] /= len;
	result[1] /= len;
	result[2] /= len;

	return;
}