• 流沙画模拟器源码

        流沙画，在密封的玻璃镜框内，装入氧化铝、磨刚沙、无色的混合液和适量的气泡。
        当镜框倒竖时，利用氧化铝和磨刚沙的比重不同以及气泡的上浮力，使氧化铝和磨刚沙按不同速度下沉到空腔的底部，形成层次分明，跌宕有序的画面。
        装入镜框的沙粒，一般有黑色、白色、蓝色（或其它颜色），另外还可能加入一些较大的黑色颗粒。

        要用真实的物理模拟流沙画，需要给每个粒子赋予位置、速度等属性，使用流体动画，实现复杂，速度较慢。这里使用变通的方法，所有粒子沉降速度相同，这样粒子运动不会发生穿插，每一个像素上的粒子数量有限。利用粒子的颜色变化来模拟粒子沉积比例。

     可以贴到3DUI上

         //几个绘制小技巧， 左键撒沙子， 右键挖除， 每种粒子都可以调色

        //月亮：球形画刷+零重力 刷出圆形，右键挖出月亮。

        //云层：球形画刷+稀疏度+零重力 刷出云层，右键挖出云层轮廓，蓝色粒子洒在云彩上进行描边。

        //村落：方形画刷+稀疏度+零重力 刷出建筑，

        //滑坡：移动倾向+右键 挖出斜向山脊 
        
        //瀑布：右键挖空，使蓝色粒子下落形成瀑布水流

        //树木：先混合沙子撒少量树根，后撒树枝（棕色树叶代替），最后撒绿色树叶

        //小路：同色线刷子模拟路 或普降的烟尘

        //橡皮檫粒子会檫除接触到的其它粒子，树叶粒子会附着到树根粒子和其它树叶粒子。水粒子目前和沙粒子没有区别，应该具有更强的流动性。

        // 可以刷在已有沙子的内部，直接替换，刷出平滑体。可以用零重力沙子托起一堆带重力的沙子，然后檫除部分零重力沙子形成下雨或水流动画。

     源码：

    1. //========================================================
    2. //  @Date:     2016.05
    3. //  @File:     SourceDemoClient/SandBox/MiniGameSandBox.h
    4. //  @Brief:     MiniGameSandBox
    5. //  @Author:     LouLei
    6. //  @Email:  twopointfive@163.com
    7. //  @Copyright (Crapell) - All Rights Reserved
    8. //========================================================
    9.  
    10. #ifndef  __MiniGameSandBox__H__
    11. #define  __MiniGameSandBox__H__
    12.  
    13. #include "Math/MathLib.h"
    14. #include "Render/Texture.h"
    15. #include "Rpg/MiniGame.h"
    16.  
    17. namespace RendSys
    18. {
    19. 	class MC_Frame;
    20. }
    21. class SandBoxPlayerRole;
    22. class MiniGameSandBox:public MiniGame
    23. {
    24. public:
    25. 	enum ParticleType
    26. 	{
    27. 		PT_Null  = 0,
    28. 		PT_Sand ,
    29. 		PT_Water,
    30. 		PT_Stone,
    31. 		PT_Root ,  //树根在第一层，可以和沙粒混合
    32. 		PT_Tree ,  //树叶在第二层，和第一层可以重叠，其它粒子都在第一层
    33. 		PT_Wall ,
    34. 		PT_Erase,
    35. 		PT_Max  ,
    36. 	};
    37.  
    38. 	//大量堆积或挖空时沙子移动倾向
    39. 	enum ParticleMove
    40. 	{
    41. 		PM_Left  = 0, //倾向左    (从右向左遍历行粒子)
    42. 		PM_Right ,    //倾向右    (从左向右遍历行粒子)
    43. 		PM_Down  ,    //左右均衡 （偶数行从左向右遍历,奇数行从右向左遍历）
    44. 		PM_Max   ,
    45. 	};
    46.  
    47. 	enum BrushType
    48. 	{
    49. 		BT_Circle  = 0,
    50. 		BT_Square ,
    51. 		BT_Line,
    52. 		BT_Max  ,
    53. 	};
    54.  
    55. 	//粒子移动方向
    56. 	enum Dir
    57. 	{
    58. 		UP   =0,
    59. 		DOWN ,
    60. 		LEFT ,
    61. 		RIGHT,
    62. 		UPLEFT,
    63. 		UPRIGHT,
    64. 		DOWNLEFT,
    65. 		DOWNRIGHT,
    66. 	};
    67.  
    68. 	//
    69. 	class ParticleStyle
    70. 	{
    71. 	public:
    72. 		ParticleStyle();
    73. 		void SetColor(const Color& color,float hRange);
    74. 		void FreshBatchColor();   //批次间变色
    75. 		void FreshParticleColor();//批次内变色
    76.  
    77. 	public:
    78. 		bool  active;
    79. 		int   weight;		
    80. 		bool  gravity; //false不动，true没帧下降1像素，没有其它速度，同一个位置粒子数量有限
    81.  
    82. 		ParticleType type; 
    83. 		float hMin,hMax;
    84. 		float sMin,sMax;
    85. 		float lMin,lMax;
    86.  
    87. 		//批次间变色
    88. 		float h,s,l;
    89. 		float r,g,b;
    90. 		float hSpeedBatch,sSpeedBatch,lSpeedBatch;           
    91.  
    92. 		//批次内变色
    93. 		bool  particleHSL;
    94. 		float hParticle,sParticle,lParticle;
    95. 		float rParticle,gParticle,bParticle,aParticle;
    96. 		float hSpeedParticle,sSpeedParticle,lSpeedParticle;  
    97. 	};
    98.  
    99. 	//
    100. 	class Particle
    101. 	{
    102. 	public:
    103. 		//int    id;        //index
    104. 		//vec2I  pos;       //位置
    105.  
    106. 		//layer1
    107. 		ParticleType type;       //
    108. 		bool         gravity;
    109. 		char         color[4];
    110.  
    111. 		//layer2
    112. 		ParticleType type2;       //
    113. 		bool         gravity2;
    114. 		char         color2[4];
    115.  
    116. 		bool         rooted;     //树叶粒子是否生根
    117.  
    118. 		//char         flag;
    119. 		Particle*    neighbour[8];
    120. 	};
    121.  
    122. 	MiniGameSandBox();
    123. 	virtual ~MiniGameSandBox();
    124.  
    125. 	virtual bool KeepResource(bool once,int& circle,String& nextTip);
    126. 	virtual bool Start();
    127. 	virtual bool Stop();
    128. 	virtual bool Render();
    129. 	virtual void RenderUI();
    130. 	virtual bool Update();
    131. 	virtual bool Free();
    132. 	virtual bool IsEnd();
    133.  
    134. 	//处理游戏网络命令包
    135. 	virtual int  ProcessPacketCmd(PacketBase* packet);
    136. 	//virtual const char* CmdToString(const char* stream,int len);
    137.  
    138. 	void  ClearTarget();
    139. 	vec2I ScreenToTarget(const vec2 &pos);
    140.  
    141. 	void  UpdateInput();
    142. 	void  UpdateParticle();
    143. 	void  MapTarget();
    144.  
    145. 	void  Brushing(const vec2I& pos);
    146. 	void  Digging(const vec2I& pos);
    147.  
    148. 	void  FreshWeightAll();
    149. 	ParticleStyle* RandParticle();
    150.  
    151. //private:
    152. 	ParticleMove  particleMove;
    153. 	ParticleStyle Styles[PT_Max];
    154. 	int           WeightAll; //活动总概率 用于随机产生粒子
    155.  
    156. 	vec2I     Size;
    157. 	Particle* m_particles;
    158.  
    159. 	RectF      m_canvasRect;
    160. 	TexturePtr m_texTarget;
    161.  
    162. 	Color m_backColor;
    163.  
    164. 	int   m_brushSize;	
    165. 	int   m_brushSparse;	//刷子稀疏度
    166. 	bool  m_brushSparseRand;//刷子稀疏度噪声扰动
    167. 	int   m_brushShape;
    168. 	float m_brushTime;
    169. 	vec2I m_brushPos;
    170.  
    171. 	SandBoxPlayerRole* m_myRolePlayer;
    172. 	//非观战时 viewside==myside
    173. 	int              m_myViewSide;
    174. 	int              m_curSide;
    175.  
    176.  
    177. 	bool  m_workingWithAI;
    178. 	vec2I m_brushSpeed;
    179.  
    180. };
    181. extern MiniGameSandBox* G_SandBoxGame;
    182. #endif 
    183.

     

    1. //========================================================
    2. //  @Date:     2016.05
    3. //  @File:     SourceDemoClient/SandBox/MiniGameSandBox.cpp
    4. //  @Brief:     MiniGameSandBox
    5. //  @Author:     LouLei
    6. //  @Email:  twopointfive@163.com
    7. //  @Copyright (Crapell) - All Rights Reserved
    8. //========================================================
    9.  
    10. #include "General/Pch.h"
    11. #include "General/Window.h"
    12. #include "General/Timer.h"
    13. #include "Gui/GuiMgr.h"
    14. #include "Gui/RpgGuis.h"
    15. #include "Gui/GuiControlMisc.h"
    16. #include "Input/InputMgr.h"
    17. #include "SandBox/SandBoxPlayer.h"
    18. #include "SandBox/MiniGameSandBox.h"
    19. #include "SandBox/MiSandBox_PlayGui.h"
    20. #include "Render/RendDriver.h"
    21. #include "Render/Shader.h"
    22. #include "Render/MC_Misc.h"
    23. #include "Rpg/SyncGameInfo.h"
    24. #include "Packet/PacketMiniGame.h"
    25. #include "Net/PacketList.h"
    26. #include "Render/Camera.h"
    27. #include "General/Pce.h"
    28.  
    29. const char* SandBoxCmdToString(int enumeration)
    30. {
    31. 	switch(enumeration)
    32. 	{
    33. 	case CMD_ManMove :return "CMD_ManMove ";		
    34. 	case CMD_GameOver:return "CMD_GameOver";		
    35. 	case CMD_Restart :return "CMD_Restart ";			
    36. 	default             :return "CMD_unknow";
    37. 	}
    38. 	return "CMD_unknow";
    39. }
    40.  
    41. static int opDir[] =
    42. {
    43. 	MiniGameSandBox::DOWN,//UP ,
    44. 	MiniGameSandBox::UP,//DOWN ,
    45. 	MiniGameSandBox::RIGHT,//LEFT ,
    46. 	MiniGameSandBox::LEFT,//RIGHT,
    47. 	MiniGameSandBox::DOWNRIGHT,//UPLEFT,
    48. 	MiniGameSandBox::DOWNLEFT,//UPRIGHT,
    49. 	MiniGameSandBox::UPRIGHT,//DOWNLEFT,
    50. 	MiniGameSandBox::UPLEFT,//DOWNRIGHT,
    51. };
    52.  
    53. MiniGameSandBox* G_SandBoxGame;
    54. MiniGameSandBox::MiniGameSandBox()
    55. :m_particles(NULL)
    56. {
    57. 	G_SandBoxGame = this;
    58. 	CmdEnumToString = SandBoxCmdToString;
    59. }
    60.  
    61. MiniGameSandBox::~MiniGameSandBox()
    62. {
    63. 	G_SandBoxGame = NULL;
    64. }
    65.  
    66. bool MiniGameSandBox::Start()
    67. {
    68. 	m_myRolePlayer = NULL;
    69. 	if(!MiniGame::Start())
    70. 		return false;
    71.  
    72. 	m_workingWithAI = false;
    73.  
    74. 	ParticleStyle* style;
    75.  
    76. 	//todo save and load from cfg file
    77. 	style = &Styles[PT_Sand];
    78. 	style->type = PT_Sand;
    79. 	style->SetColor(Color(230/255.0f, 170/255.0f, 20/255.0f, 1),0.07f);
    80. 	style->sMin = 0.3f;
    81. 	style->sMax = 0.6f;
    82. 	style->lMin = 0.1f;
    83. 	style->lMax = 0.5f;
    84. 	style->hSpeedBatch = 0.02f;
    85. 	style->sSpeedBatch = 0.08f;
    86. 	style->lSpeedBatch = 0.08f;           //批次间变色
    87. 	style->hSpeedParticle = 0.005f;
    88. 	style->sSpeedParticle = 0.01f;
    89. 	style->lSpeedParticle = 0.01f;        //批次内变色
    90.  
    91.  
    92. 	style = &Styles[PT_Water];
    93. 	style->type = PT_Water;
    94. 	style->SetColor(Color(20/255.0f, 150/255.0f, 230/255.0f, 1),0.03f);
    95. 	style->sMin = 0.4f;
    96. 	style->sMax = 0.6f;
    97. 	style->lMin = 0.3f;
    98. 	style->lMax = 0.8f;
    99. 	style->hSpeedBatch = 0.005f;
    100. 	style->sSpeedBatch = 0.05f;
    101. 	style->lSpeedBatch = 0.1f;          
    102. 	style->hSpeedParticle = 0.005f;
    103. 	style->sSpeedParticle = 0.01f;
    104. 	style->lSpeedParticle = 0.01f;      
    105.  
    106. 	style = &Styles[PT_Stone];
    107. 	style->type = PT_Stone;
    108. 	style->SetColor(Color(20/255.0f, 50/255.0f, 50/255.0f, 1),0.01f);
    109. 	style->sMin = 0.4f;
    110. 	style->sMax = 0.6f;
    111. 	style->lMin = 0.3f;
    112. 	style->lMax = 0.5f;
    113. 	style->hSpeedBatch = 0.002f;
    114. 	style->sSpeedBatch = 0.05f;
    115. 	style->lSpeedBatch = 0.05f;          
    116. 	style->hSpeedParticle = 0.005f;
    117. 	style->sSpeedParticle = 0.01f;
    118. 	style->lSpeedParticle = 0.01f;  
    119.  
    120. 	style = &Styles[PT_Root];
    121. 	style->type = PT_Root;
    122. 	style->SetColor(Color(20/255.0f, 250/255.0f, 30/255.0f, 1),0.05f);
    123. 	style->sMin = 0.4f;
    124. 	style->sMax = 0.6f;
    125. 	style->lMin = 0.3f;
    126. 	style->lMax = 0.5f;
    127. 	style->hSpeedBatch = 0.01f;
    128. 	style->sSpeedBatch = 0.05f;
    129. 	style->lSpeedBatch = 0.05f;          
    130. 	style->hSpeedParticle = 0.005f;
    131. 	style->sSpeedParticle = 0.01f;
    132. 	style->lSpeedParticle = 0.01f;  
    133.  
    134.  
    135. 	style = &Styles[PT_Tree];
    136. 	style->type = PT_Tree;
    137. 	style->SetColor(Color(20/255.0f, 250/255.0f, 30/255.0f, 1),0.05f);
    138. 	style->sMin = 0.4f;
    139. 	style->sMax = 0.6f;
    140. 	style->lMin = 0.3f;
    141. 	style->lMax = 0.5f;
    142. 	style->hSpeedBatch = 0.01f;
    143. 	style->sSpeedBatch = 0.05f;
    144. 	style->lSpeedBatch = 0.05f;          
    145. 	style->hSpeedParticle = 0.005f;
    146. 	style->sSpeedParticle = 0.01f;
    147. 	style->lSpeedParticle = 0.01f;  
    148.  
    149. 	style = &Styles[PT_Erase];
    150. 	style->type = PT_Erase;
    151. 	style->SetColor(Color(255/255.0f, 0/255.0f, 0/255.0f, 1),0);
    152. 	style->sMin = 0.5f;
    153. 	style->sMax = 0.5f;
    154. 	style->lMin = 0.5f;
    155. 	style->lMax = 0.5f;
    156. 	style->hSpeedBatch = 0.0f;
    157. 	style->sSpeedBatch = 0.0f;
    158. 	style->lSpeedBatch = 0.0f;          
    159. 	style->hSpeedParticle = 0.0f;
    160. 	style->sSpeedParticle = 0.0f;
    161. 	style->lSpeedParticle = 0.0f;  
    162.  
    163. 	//
    164. 	for (int i=0;i<PT_Max;i++)
    165. 	{	
    166. 		style = &Styles[i];
    167. 		style->active = false;
    168. 		style->weight = 10;
    169. 		style->particleHSL  = style->hSpeedParticle>0 || style->sSpeedParticle>0 || style->lSpeedParticle>0;
    170. 	}
    171. 	style = &Styles[PT_Sand];
    172. 	style->active = true;
    173.  
    174. 	style = &Styles[PT_Root];
    175. 	style->weight = 1;
    176.  
    177. 	FreshWeightAll();
    178.  
    179. 	particleMove = PM_Down;
    180.  
    181. 	m_3dMode = false;
    182. 	m_brushSize   = 1;
    183. 	m_brushSparse = 1;
    184. 	m_brushSparseRand = false;
    185. 	m_brushShape  = 1;
    186. 	m_brushTime   = 0;
    187.  
    188. 	Size = vec2I(390,300);
    189. 	const int Num = Size.x * Size.y;
    190. 	SafeDeleteArray(m_particles);
    191.  
    192. 	m_texTarget = new Texture(true);
    193. 	m_texTarget->AllocTexture(Size.x,Size.y,RS_RGBA);
    194.  
    195. 	m_particles = new Particle[Num];
    196. 	memset(m_particles,0,sizeof(Particle)*Num);
    197.  
    198. 	//m_backColor = Color(50/255.0f, 90/255.0f, 120/255.0f, 0.3f);	
    199. 	m_backColor = Color(50/255.0f, 90/255.0f, 120/255.0f, 0.9f);
    200.  
    201. 	ClearTarget();
    202.  
    203. 	Particle* p = m_particles;
    204. 	int sizeX_1 = Size.x - 1;
    205. 	int sizeY_1 = Size.y - 1;
    206. 	for(int y=0;y<Size.y;++y)
    207. 	{
    208. 		for(int x=0;x<Size.x;++x,++p)
    209. 		{
    210. 			if(x>0)       p->neighbour[LEFT]  = p-1;
    211. 			if(x<sizeX_1) p->neighbour[RIGHT] = p+1;
    212. 			if(y>0)       p->neighbour[DOWN]  = p-Size.x;
    213. 			if(y<sizeY_1) p->neighbour[UP]    = p+Size.x;
    214.  
    215. 			if(x>0       && y>0)       p->neighbour[DOWNLEFT]  = p-Size.x-1;
    216. 			if(x<sizeX_1 && y>0)       p->neighbour[DOWNRIGHT] = p-Size.x+1;
    217. 			if(x>0       && y<sizeY_1) p->neighbour[UPLEFT]    = p+Size.x-1;
    218. 			if(x<sizeX_1 && y<sizeY_1) p->neighbour[UPRIGHT]   = p+Size.x+1;
    219. 		}
    220. 	}
    221.  
    222. 	m_curSide=SideRed;
    223.  
    224. 	if (m_movieScene)
    225. 	{
    226. 		Frame frame;
    227. 		frame.SetPos(m_startPos);
    228. 		m_movieScene->SetProgramFrame(&frame);
    229. 		m_movieScene->Advance();
    230. 	}
    231.  
    232. 	m_gameState  = MS_Gamming;
    233. 	m_myViewSide = SideBlack;
    234.  
    235. 	
    236. 	//for(int i = 0; i < m_allPlayerNum; i++)
    237. 	//{
    238. 	//	dynamic_cast<SandBoxPlayer*>(m_miniPlayer[i])->m_side = i==0?SideRed:SideBlack;
    239. 	//	//dynamic_cast<SandBoxPlayer*>(m_miniPlayer[i])->m_side = i==0?SideBlack:SideRed;
    240. 	//}
    241.  
    242.  
    243. //	if(m_myRolePlayer)
    244. //		m_myViewSide = m_myRolePlayer->m_side; 
    245.  
    246. 	//进入miniplaygui，（选人、选关卡都已在房间里进行完毕)。
    247. 	if(GetStyle()) G_GuiMgr->PushGui(GetStyle()->playGUI.c_str(),GL_DIALOG);
    248.  
    249. 	//
    250. 	for(int i = 0; i < m_allPlayerNum; i++)
    251. 	{
    252. 		if(m_miniPlayer[i])
    253. 			m_miniPlayer[i]->Start();
    254. 	}
    255.  
    256. 	//设置摄像机
    257. 	CameraCtrlerTarget* ctrler = new CameraCtrlerTarget;
    258. 	ctrler->SetDistToTar(60);
    259. 	ctrler->SetTarPos(m_startPos);
    260. 	G_Camera->PushCtrler(ctrler);
    261. 	G_Camera->SetEuler(0, -60, 0);
    262. 	//片头摄像机
    263. 	PushIntroCamera();
    264.  
    265. 	return true;
    266. }
    267.  
    268. void MiniGameSandBox::ClearTarget()
    269. {
    270. 	m_workingWithAI = false;
    271. 	const int Num = Size.x * Size.y;
    272. 	unsigned char BackColor[4] ={m_backColor.r*255,m_backColor.g*255,m_backColor.b*255,m_backColor.a*255};
    273. 	Particle* End = m_particles+Num;
    274. 	for(Particle* p=m_particles; p!=End; ++p)
    275. 	{
    276. 		//p->id  = i;
    277. 		p->type     = PT_Null;
    278. 		p->gravity  = true;
    279. 		p->color[0] = BackColor[0];
    280. 		p->color[1] = BackColor[1];
    281. 		p->color[2] = BackColor[2];
    282. 		p->color[3] = BackColor[3];
    283.  
    284. 		p->type2     = PT_Null;
    285. 		p->gravity2  = true;
    286. 		p->color2[0] = BackColor[0];
    287. 		p->color2[1] = BackColor[1];
    288. 		p->color2[2] = BackColor[2];
    289. 		p->color2[3] = BackColor[3];
    290. 	}
    291. }
    292.  
    293. MiniPlayer* MiniGameSandBox::CreatePlayer()
    294. {
    295. 	return NULL;//new SandBoxPlayer;
    296. }
    297.  
    298. MiniPlayer* MiniGameSandBox::CreateRobot()
    299. {
    300. 	return NULL;//new SandBoxPlayerRobot;
    301. }
    302.  
    303. MiniPlayer* MiniGameSandBox::CreateRole()
    304. {
    305. 	m_myRolePlayer = NULL;//new SandBoxPlayerRole;
    306. 	return NULL;//m_myRolePlayer;
    307. }
    308.  
    309.  
    310. bool MiniGameSandBox::Stop()
    311. {
    312. 	G_Camera->PopCtrler();
    313. 	//CameraCtrlerTarget* ctrlerTarget = G_Camera->IsCurCtrler<CameraCtrlerTarget>();
    314. 	//if(ctrlerTarget)
    315. 	//	ctrlerTarget->SetTarEntity(G_MyRole);
    316.  
    317. 	{
    318. 		if (m_myPlayer && m_myPlayer->m_liveNum>0)
    319. 		{
    320. 			G_GuiMgr->GetGui<Rpg_ResultDialog>()->ShowResult(true);
    321. 		}
    322. 		else
    323. 		{
    324. 			G_GuiMgr->GetGui<Rpg_ResultDialog>()->ShowResult(false);
    325. 		}
    326. 		G_GuiMgr->PushGui("Rpg_ResultDialog",GL_DIALOGBOTTOM); 
    327. 	}
    328. 	return MiniGame::Stop();
    329. }
    330.  
    331. //SandBoxPlayer* MiniGameSandBox::GetTurnPlayer()
    332. //{
    333. //	//return dynamic_cast<SandBoxPlayer*>(m_miniPlayer[m_curSide]);
    334. //	for(int i = 0; i < m_allPlayerNum; i++)
    335. //	{
    336. //		SandBoxPlayer* player = dynamic_cast<SandBoxPlayer*>(m_miniPlayer[i]);
    337. //		if (player->m_side == m_curSide)
    338. //		{
    339. //			return player;
    340. //		}
    341. //	}
    342. //	return NULL;
    343. //}
    344.  
    345. bool MiniGameSandBox::KeepResource(bool once,int& circle,String& nextTip)
    346. {
    347. 	//
    348. 	char buf[256];
    349. 	if (m_movieScene == NULL)
    350. 	{
    351. 		LoadConfig loader(LoadConfig::GenDonotReShrinkBound, true, true);
    352. 		m_movieScene = new RendSys::MovieClip;
    353. 		m_movieScene->LoadFromFile("data/minigame/SandBox/sandboxscene.movie", &loader);
    354.  
    355. 		Frame frame;
    356. 		frame.SetPos(m_startPos);
    357. 		m_movieScene->SetProgramFrame(&frame);
    358. 		m_movieScene->Advance();
    359. 	}
    360.  
    361. 	if (m_movieScene->IsLoadComplete() == false)
    362. 	{
    363. 		m_gameState = MS_End;
    364. 		return false;
    365. 	}
    366. 	return true;
    367. }
    368.  
    369. bool MiniGameSandBox::Render()
    370. {
    371. 	//attach target to ui3D control
    372.  
    373. 	//for(int i = 0; i < m_allPlayerNum; i++)
    374. 	//{
    375. 	//	dynamic_cast<SandBoxPlayer*>(m_miniPlayer[i])->Render();
    376. 	//}
    377.  
    378. 	return true;
    379. }
    380.  
    381. void MiniGameSandBox::RenderUI()
    382. {
    383. 	MiniGame::RenderUI();
    384. }
    385. bool MiniGameSandBox::Update()
    386. {
    387. 	m_turnTime  += G_Timer->GetStepTimeLimited();
    388. 	m_brushTime += G_Timer->GetStepTimeLimited();
    389.  
    390. 	MiSandBox_PlayGui* playGui = G_GuiMgr->GetGui<MiSandBox_PlayGui>();
    391. 	m_canvasRect = playGui->m_canvas->GetRectReal();
    392. 	m_canvasRect.SetPos(playGui->m_canvas->GetOffset());
    393.  
    394. 	playGui->m_canvas->SetTexture(m_texTarget,GCS_NORMAL);
    395.  
    396. 	m_movieScene->Advance();
    397.  
    398. 	UpdateInput();
    399. 	UpdateParticle();
    400. 	MapTarget();
    401.  
    402. 	//for(int i = 0; i < m_allPlayerNum; i++)
    403. 	//{
    404. 	//	dynamic_cast<SandBoxPlayer*>(m_miniPlayer[i])->Update();
    405. 	//}
    406. 	return true;
    407. }
    408.  
    409. void MiniGameSandBox::UpdateInput()
    410. {
    411. 	if (m_brushTime < 0.1f)
    412. 	{
    413. 		return;
    414. 	}
    415. 	
    416. 	//if (m_myRolePlayer && m_curSide != m_myRolePlayer->m_side)
    417. 	//	return;
    418.  
    419. 	vec2I pos;
    420. 	if (m_workingWithAI)
    421. 	{
    422. 		ParticleStyle* style;
    423. 		for (int i=0;i<PT_Max;i++)
    424. 		{	
    425. 			style = &Styles[i];
    426. 			//style->active = false;
    427. 			//style->weight = 10;
    428. 			//style->particleHSL  = style->hSpeedParticle>0 || style->sSpeedParticle>0 || style->lSpeedParticle>0;
    429. 		}
    430.  
    431. 		Styles[PT_Root].active  = true;
    432. 		Styles[PT_Water].active = true;
    433. 		Styles[PT_Tree].active  = true;
    434. 		FreshWeightAll();
    435.  
    436. 		m_brushSize = 7;
    437. 		m_brushSparse = 3;	
    438. 		m_brushSparseRand = true;
    439.  
    440. 		m_brushSpeed.x += RandRange(-2,2);
    441. 		Clamp(m_brushSpeed.x,-5,5);
    442.  
    443. 		m_brushPos.y = Size.y - m_brushSize;
    444. 		m_brushPos.x += m_brushSpeed.x;
    445. 		Clamp(m_brushPos.x,m_brushSize,Size.x-m_brushSize);
    446.  
    447. 		Brushing(m_brushPos);
    448. 	}
    449. 	else if (m_3dMode)
    450. 	{
    451. 		MiSandBox_PlayGui* playGui = G_GuiMgr->GetGui<MiSandBox_PlayGui>();
    452. 		vec2 newPosI;
    453. 		if (playGui->m_groupTargetCtrl->GetMapMousePos(G_Mouse->GetMousePos(),newPosI))
    454. 		{
    455. 			m_brushPos = ScreenToTarget(newPosI);
    456. 		}
    457. 	}
    458. 	else
    459. 	{
    460. 		m_brushPos = ScreenToTarget(G_Mouse->GetMousePos());
    461. 	}
    462.  
    463. 	if (G_SandBoxGame->IsButtonPressed(MOUSE_RIGHT))
    464. 	{
    465. 		Digging(m_brushPos);
    466. 	}		
    467. 	else if (G_SandBoxGame->IsButtonPressed(MOUSE_LEFT))
    468. 	{
    469. 		Brushing(m_brushPos);
    470. 	}
    471. }
    472. void MiniGameSandBox::Brushing(const vec2I& pos)
    473. {
    474. 	//刷粒子
    475. 	m_brushTime = 0;
    476.  
    477. 	int brushSizeSq = m_brushSize*m_brushSize;
    478. 	int minX = max(0,pos.x-m_brushSize);
    479. 	int maxX = min(Size.x-1,pos.x+m_brushSize);
    480. 	int minY = max(0,pos.y-m_brushSize);
    481. 	int maxY = min(Size.y-1,pos.y+m_brushSize);
    482.  
    483. 	if(m_brushShape==BT_Line)
    484. 	{
    485. 		minX = 0;
    486. 		maxX = Size.x-1;
    487. 		minY = pos.y;
    488. 		maxY = pos.y;
    489. 	}
    490.  
    491. 	int minSparse = min(0,1-m_brushSparse);
    492. 	int maxSparse = max(0,m_brushSparse-1);
    493.  
    494. 	unsigned char BackColor[4] ={m_backColor.r*255,m_backColor.g*255,m_backColor.b*255,m_backColor.a*255};
    495.  
    496. 	//
    497. 	ParticleStyle* style;
    498. 	for (int i=0;i<PT_Max;i++)
    499. 	{	
    500. 		style = &Styles[i];
    501. 		if (style->active)
    502. 		{
    503. 			style->FreshBatchColor();
    504. 		}
    505. 	}
    506.  
    507. 	Particle* p;
    508. 	int rx,ry;
    509. 	for (int y=minY;y<=maxY;y+=m_brushSparse)
    510. 	{
    511. 		for (int x=minX;x<=maxX;x+=m_brushSparse)
    512. 		{
    513. 			if (m_brushSparseRand)
    514. 			{
    515. 				ry = y + RandRange(minSparse,maxSparse);
    516. 				rx = x + RandRange(minSparse,maxSparse);
    517. 			}
    518. 			else
    519. 			{
    520. 				ry = y;
    521. 				rx = x;
    522. 			}
    523.  
    524. 			if( rx<minX || rx>maxX || ry<minY || ry>maxY)
    525. 				continue;
    526. 			if (m_brushShape==BT_Circle)
    527. 			{
    528. 				float difx = rx-pos.x;
    529. 				float dify = ry-pos.y;
    530. 				if( difx*difx + dify*dify > brushSizeSq)
    531. 					continue;
    532. 			}
    533.  
    534. 			p = &m_particles[ry*Size.x + rx];
    535.  
    536. 			style = RandParticle();
    537. 			if (style==NULL)
    538. 			{
    539. 				break;
    540. 			}
    541. 			if (style->particleHSL)
    542. 			{
    543. 				style->FreshParticleColor();
    544. 			}
    545.  
    546. 			if (style->type==PT_Tree)
    547. 			{
    548. 				p->type2     = style->type;
    549. 				p->gravity2  = style->gravity;
    550. 				p->color2[0] = style->rParticle;
    551. 				p->color2[1] = style->gParticle;
    552. 				p->color2[2] = style->bParticle;
    553. 				p->color2[3] = style->aParticle;
    554. 			}
    555. 			else
    556. 			{
    557. 				p->type     = style->type;
    558. 				p->gravity  = style->gravity;				
    559. 				p->color[0] = style->rParticle;
    560. 				p->color[1] = style->gParticle;
    561. 				p->color[2] = style->bParticle;
    562. 				p->color[3] = style->aParticle;
    563. 			}
    564.  
    565. 			p->rooted   = false;
    566. 		}
    567. 	}
    568. }
    569.  
    570. void MiniGameSandBox::Digging(const vec2I& pos)
    571. {
    572. 	//挖除粒子
    573. 	int brushSizeSq = m_brushSize*m_brushSize;
    574. 	int minX = max(0,pos.x-m_brushSize);
    575. 	int maxX = min(Size.x-1,pos.x+m_brushSize);
    576. 	int minY = max(0,pos.y-m_brushSize);
    577. 	int maxY = min(Size.y-1,pos.y+m_brushSize);
    578.  
    579. 	if(m_brushShape==BT_Line)
    580. 	{
    581. 		minX = 0;
    582. 		maxX = Size.x-1;
    583. 		minY = pos.y;
    584. 		maxY = pos.y;
    585. 	}
    586.  
    587. 	int minSparse = min(0,1-m_brushSparse);
    588. 	int maxSparse = max(0,m_brushSparse-1);
    589.  
    590. 	unsigned char BackColor[4] ={m_backColor.r*255,m_backColor.g*255,m_backColor.b*255,m_backColor.a*255};
    591.  
    592. 	//
    593. 	Particle* p;
    594. 	int rx,ry;
    595. 	for (int y=minY;y<=maxY;y+=m_brushSparse)
    596. 	{
    597. 		for (int x=minX;x<=maxX;x+=m_brushSparse)
    598. 		{
    599. 			if (m_brushSparseRand)
    600. 			{
    601. 				ry = y + RandRange(minSparse,maxSparse);
    602. 				rx = x + RandRange(minSparse,maxSparse);
    603. 			}
    604. 			else
    605. 			{
    606. 				ry = y;
    607. 				rx = x;
    608. 			}
    609.  
    610. 			if( rx<minX || rx>maxX || ry<minY || ry>maxY)
    611. 				continue;
    612. 			if (m_brushShape==BT_Circle)
    613. 			{
    614. 				float difx = rx-pos.x;
    615. 				float dify = ry-pos.y;
    616. 				if( difx*difx + dify*dify > brushSizeSq)
    617. 					continue;
    618. 			}
    619.  
    620. 			p = &m_particles[ry*Size.x + rx];
    621.  
    622. 			p->type     = PT_Null;
    623. 			p->gravity  = true;
    624. 			p->color[0] = BackColor[0];
    625. 			p->color[1] = BackColor[1];
    626. 			p->color[2] = BackColor[2];
    627. 			p->color[3] = BackColor[3];
    628.  
    629. 			p->type2     = PT_Null;
    630. 			p->gravity2  = true;
    631. 			p->color2[0] = BackColor[0];
    632. 			p->color2[1] = BackColor[1];
    633. 			p->color2[2] = BackColor[2];
    634. 			p->color2[3] = BackColor[3];
    635. 		}
    636. 	}
    637. }
    638. void MiniGameSandBox::UpdateParticle()
    639. {
    640. 	unsigned char BackColor[4] ={m_backColor.r*255,m_backColor.g*255,m_backColor.b*255,m_backColor.a*255};
    641.  
    642. 	//
    643. 	const Particle* End = m_particles+Size.x*Size.y;
    644. 	for(Particle* p=m_particles; p!=End; ++p)
    645. 	{
    646. 	//	p->flag    = 0;		
    647. 		p->rooted  = false;
    648. 	}
    649.  
    650. 	//
    651. 	const int LineNum  = Size.y;
    652. 	const int SizeX2a1 = Size.x*2 + 1;
    653. 	const int SizeX2_1 = Size.x*2 - 1;
    654.  
    655. 	Particle* lineBegin = m_particles;
    656. 	Particle* lineEnd   = m_particles + Size.x;
    657. 	int       step      = 1;
    658. 	if (particleMove==PM_Left)
    659. 	{
    660. 		lineBegin = m_particles + Size.x - 1;
    661. 		lineEnd   = m_particles - 1;
    662. 		step      = -1;
    663. 	}
    664.  
    665. 	Particle* n;	
    666. 	ParticleStyle* style;
    667. 	//（偶数行从左向右遍历  奇数行从右向左遍历，避免沙子向一侧堆时）
    668. 	//for(Particle* p=m_particles; p!=End; ++p)
    669. 	for(int _i=0; _i<LineNum;++_i)
    670. 	{
    671. 		for(Particle* p=lineBegin; p!=lineEnd; p+=step)
    672. 		{
    673. 			//style = &Styles[p->type];
    674.  
    675. 			//layer2
    676. 			if (p->type2 == PT_Tree) //树叶粒子 穿透其它粒子和相框底部  附着树根和其它树叶
    677. 			{
    678. 				if (/*p->flag==0 && */p->gravity2)
    679. 				{
    680. 					n = p->neighbour[DOWN];
    681. 					if (n &&(n->type==PT_Root || (n->type2==PT_Tree&&n->rooted==true)))  
    682. 					{
    683. 						p->rooted = true;
    684. 					}
    685. 					n = p->neighbour[DOWNLEFT];
    686. 					if (n && (n->type==PT_Root || (n->type2==PT_Tree&&n->rooted==true)))  
    687. 					{
    688. 						p->rooted = true;
    689. 					}
    690. 					n = p->neighbour[DOWNRIGHT];
    691. 					if (n && (n->type==PT_Root || (n->type2==PT_Tree&&n->rooted==true)))  
    692. 					{
    693. 						p->rooted = true;
    694. 					}			
    695.  
    696. 					if(p->rooted==false)
    697. 					{
    698. 						//move down
    699. 						n = p->neighbour[DOWN];
    700. 						if (n==NULL)
    701. 						{
    702. 							p->type2     = PT_Null;	//漏出底部边框
    703. 							p->gravity2  = true;			
    704. 							p->color2[0] = BackColor[0];
    705. 							p->color2[1] = BackColor[1];
    706. 							p->color2[2] = BackColor[2];
    707. 							p->color2[3] = BackColor[3];
    708. 						}
    709. 						else
    710. 						{
    711. 							n->type2     = p->type2;	//重叠下面的粒子
    712. 							n->gravity2  = p->gravity2;
    713. 							n->color2[0] = p->color2[0];
    714. 							n->color2[1] = p->color2[1];
    715. 							n->color2[2] = p->color2[2];
    716. 							p->color2[3] = p->color2[3];
    717. 							//n->flag     = 1;
    718.  
    719. 							p->type2     = PT_Null;	
    720. 							p->gravity2  = true;
    721. 							p->color2[0] = BackColor[0];
    722. 							p->color2[1] = BackColor[1];
    723. 							p->color2[2] = BackColor[2];
    724. 							p->color2[3] = BackColor[3];
    725. 							p->flag = 0;
    726. 						}
    727. 					}
    728. 				}
    729. 			}
    730.  
    731. 			//layer1
    732. 			{
    733. 				if (/*p->flag==0 && */p->type!=PT_Null && p->gravity)
    734. 				{
    735. 					n = NULL;
    736.  
    737. 					if ( p->neighbour[DOWN] 
    738. 					     && p->neighbour[DOWN]->type==PT_Null
    739. 					)  //密度轻挤占
    740. 					{
    741. 						n = p->neighbour[DOWN];
    742. 					}
    743. 					else
    744. 					{
    745. 						//if (p->particleMove==PM_Left) //此处改变顺序， 无法改变优先移动方向 ，决定因素是x轴的遍历顺序
    746. 						//{
    747. 							if (p->neighbour[DOWNLEFT] && p->neighbour[DOWNLEFT]->type==PT_Null)
    748. 							{
    749. 								n = p->neighbour[DOWNLEFT];
    750. 							}			
    751. 							else if (p->neighbour[DOWNRIGHT] && p->neighbour[DOWNRIGHT]->type==PT_Null)
    752. 							{
    753. 								n = p->neighbour[DOWNRIGHT];
    754. 							}
    755. 						//}
    756. 					}
    757.  
    758. 					if (n)
    759. 					{
    760. 						n->type     = p->type;
    761. 						n->gravity  = p->gravity;
    762. 						n->color[0] = p->color[0];
    763. 						n->color[1] = p->color[1];
    764. 						n->color[2] = p->color[2];
    765. 						n->color[3] = p->color[3];
    766. 						//n->flag     = 1;
    767.  
    768. 						p->type     = PT_Null;	
    769. 						p->gravity  = true;				
    770. 						p->color[0] = BackColor[0];
    771. 						p->color[1] = BackColor[1];
    772. 						p->color[2] = BackColor[2];
    773. 						p->color[3] = BackColor[3];
    774. 						p->flag = 0;
    775. 					}
    776.  
    777. 					//檫粒子
    778. 					if (p->type == PT_Erase)
    779. 					{
    780. 						n = p->neighbour[DOWN];
    781. 						if (n==NULL)
    782. 						{
    783. 							p->type    = PT_Null;	//漏出底部边框
    784. 							p->gravity = true;
    785. 						}
    786. 						else if(n->type!=PT_Null && n->type!=PT_Erase)
    787. 						{
    788. 							n->type    = PT_Null;	//檫除自己和下面的粒子，可以檫除树根 塌陷树木 不能直接檫除第二层的树叶， todo 不是立即檫除
    789. 							n->gravity = true;
    790. 							p->type    = PT_Null;	
    791. 							p->gravity = true;
    792. 						}
    793. 					}
    794.  
    795. 				}
    796. 			}
    797. 		}
    798.  
    799. 		if (particleMove==PM_Down)
    800. 		{
    801. 			//交换方向
    802. 			if (step==1)
    803. 			{
    804. 				lineBegin += SizeX2_1;
    805. 				lineEnd   -= 1;		
    806. 				step = -1;
    807. 			}
    808. 			else
    809. 			{
    810. 				lineBegin += 1;
    811. 				lineEnd   += SizeX2a1;		
    812. 				step = 1;
    813. 			}
    814. 		}
    815. 		else
    816. 		{
    817. 			lineBegin += Size.x;
    818. 			lineEnd   += Size.x;		
    819. 		}
    820.  
    821. 	}
    822. }
    823.  
    824. void MiniGameSandBox::MapTarget()
    825. {
    826. 	unsigned char* color;
    827. 	unsigned char* pixel = m_texTarget->GetImageData();
    828. 	const Particle* End  = m_particles+Size.x*Size.y;
    829. 	for(Particle* p=m_particles; p!=End; ++p,pixel+=4)
    830. 	{
    831. 		if (p->type2!=PT_Null)
    832. 		{
    833. 			pixel[0] = p->color2[0];
    834. 			pixel[1] = p->color2[1];
    835. 			pixel[2] = p->color2[2];
    836. 			pixel[3] = p->color2[3];
    837. 		}
    838. 		else
    839. 		{
    840. 			pixel[0] = p->color[0];
    841. 			pixel[1] = p->color[1];
    842. 			pixel[2] = p->color[2];
    843. 			pixel[3] = p->color[3];
    844. 		}
    845. 	}
    846.  
    847.  
    848. 	//画笔
    849. 	if (m_brushPos.x>=0&&m_brushPos.x<Size.x
    850. 		&&m_brushPos.y>=0&&m_brushPos.y<Size.y)
    851. 	{
    852. 		int minX = max(0,m_brushPos.x-m_brushSize);
    853. 		int maxX = min(Size.x-1,m_brushPos.x+m_brushSize);
    854. 		int minY = max(0,m_brushPos.y-m_brushSize);
    855. 		int maxY = min(Size.y-1,m_brushPos.y+m_brushSize);
    856.  
    857. 		Color color(1,1,1,1);
    858. 		if(m_brushShape==BT_Circle)
    859. 		{
    860. 			m_texTarget->Circle(m_brushPos.x,m_brushPos.y,m_brushSize,m_brushSize,1,color);
    861. 		}
    862. 		else if(m_brushShape==BT_Square)
    863. 		{
    864. 			m_texTarget->Line(minX,minY,maxX,minY,1,color);
    865. 			m_texTarget->Line(minX,minY,minX,maxY,1,color);
    866. 			m_texTarget->Line(maxX,maxY,maxX,minY,1,color);
    867. 			m_texTarget->Line(maxX,maxY,minX,maxY,1,color);
    868. 		}		
    869. 		else if(m_brushShape==BT_Line)
    870. 		{
    871. 			m_texTarget->Line(0,m_brushPos.y,Size.x,m_brushPos.y,1,color);
    872. 		}
    873. 	}
    874.  
    875. 	m_texTarget->RefreshFromData(m_texTarget->GetImageData(),RS_RGBA);
    876. }
    877.  
    878. bool MiniGameSandBox::Free()
    879. {
    880. 	MiniGame::Free();
    881. 	m_texTarget = NULL;
    882. 	SafeDeleteArray(m_particles);
    883. 	return true;
    884. }
    885.  
    886. bool MiniGameSandBox::IsEnd()
    887. {
    888. 	return m_gameState == MS_End;
    889. }
    890.  
    891. int  MiniGameSandBox::ProcessPacketCmd(PacketBase* packet)
    892. {
    893. 	int cmd;
    894. 	packet->ReadValue(cmd);
    895. 	switch(cmd)
    896. 	{
    897. 	case CMD_ManMove:
    898. 		break;
    899. 	case CMD_GameOver:
    900. 		break;
    901. 	case CMD_Restart:
    902. 	//	Free();
    903. 	//	Start();
    904. 		break;
    905. 	}
    906. 	return 0;
    907. }
    908.  
    909. vec2I MiniGameSandBox::ScreenToTarget(const vec2 &pos_)
    910. {
    911. 	vec2 pos(pos_);
    912. 	pos -= m_canvasRect.GetPos();
    913. 	pos = pos / m_canvasRect.GetExtent();
    914. 	pos.y = 1 - pos.y;
    915. 	pos.x *= Size.x;				
    916. 	pos.y *= Size.y;
    917. 	return vec2I(pos.x,pos.y);
    918. }
    919.  
    920. MiniGameSandBox::ParticleStyle* MiniGameSandBox::RandParticle()
    921. {
    922. 	ParticleStyle* style;
    923. 	if (WeightAll==0)
    924. 	{
    925. 		return NULL;
    926. 	}
    927. 	int weight = (Rand()%WeightAll) + 1;
    928.  
    929. 	for (int i=0;i<PT_Max;i++)
    930. 	{	
    931. 		style = &Styles[i];
    932. 		if (style->active)
    933. 		{
    934. 			weight -= style->weight;
    935. 			if (weight <=0)
    936. 			{
    937. 				return style;
    938. 			}
    939. 		}
    940. 	}
    941. 	return &Styles[0];
    942. }
    943.  
    944. void MiniGameSandBox::FreshWeightAll()
    945. {
    946. 	ParticleStyle* style;
    947. 	WeightAll = 0;
    948. 	for (int i=0;i<PT_Max;i++)
    949. 	{	
    950. 		style = &Styles[i];
    951. 		if (style->active)
    952. 		{
    953. 			WeightAll += style->weight;
    954. 		}
    955. 	}
    956. }
    957.  
    958. MiniGameSandBox::ParticleStyle::ParticleStyle()
    959. {
    960. 	type = PT_Null;
    961. 	SetColor(Color(230/255.0f, 170/255.0f, 20/255.0f, 1),0.07f);
    962. 	sMin = 0.3f;
    963. 	sMax = 0.6f;
    964. 	lMin = 0.1f;
    965. 	lMax = 0.5f;
    966. 	hSpeedBatch = 0.02f;
    967. 	sSpeedBatch = 0.08f;
    968. 	lSpeedBatch = 0.08f;           //批次间变色
    969. 	hSpeedParticle = 0.005f;
    970. 	sSpeedParticle = 0.01f;
    971. 	lSpeedParticle = 0.01f;        //批次内变色
    972.  
    973. 	active = false;
    974. 	weight = 1;
    975. 	particleHSL  = hSpeedParticle>0 || sSpeedParticle>0 || lSpeedParticle>0;
    976. }
    977.  
    978. void MiniGameSandBox::ParticleStyle::SetColor(const Color& color,float hRange)
    979. {
    980. 	rgb2hsl(color.r,color.g,color.b,h,s,l);
    981.  
    982. 	hMin = h - hRange;
    983. 	hMax = h + hRange;
    984.  
    985. 	Clamp(hMin,0.0f,1.0f);
    986. 	Clamp(sMin,0.0f,1.0f);
    987. }
    988.  
    989. void MiniGameSandBox::ParticleStyle::FreshBatchColor()
    990. {
    991. 	h += RandRange(-1.0f,1.0f)*hSpeedBatch;//批次间变色
    992. 	s += RandRange(-1.0f,1.0f)*sSpeedBatch;
    993. 	l += RandRange(-1.0f,1.0f)*lSpeedBatch;
    994.  
    995. 	Clamp(h,hMin,hMax);
    996. 	Clamp(s,sMin,sMax);
    997. 	Clamp(l,lMin,lMax);
    998.  
    999. 	hsl2rgb(h,s,l,r,g,b);
    1000. 	r *=255;
    1001. 	g *=255;
    1002. 	b *=255;
    1003.  
    1004. 	hParticle = h;//批次内变色
    1005. 	sParticle = s;
    1006. 	lParticle = l;
    1007. 	rParticle = r;
    1008. 	gParticle = g;
    1009. 	bParticle = b;
    1010. 	aParticle = 255;
    1011. }
    1012.  
    1013. void MiniGameSandBox::ParticleStyle::FreshParticleColor()
    1014. {
    1015. 	hParticle += RandRange(-1.0f,1.0f)*hSpeedParticle;//批次内变色
    1016. 	sParticle += RandRange(-1.0f,1.0f)*sSpeedParticle;
    1017. 	lParticle += RandRange(-1.0f,1.0f)*lSpeedParticle;
    1018. 	Clamp(hParticle,hMin,hMax);
    1019. 	Clamp(sParticle,sMin,sMax);
    1020. 	Clamp(lParticle,lMin,lMax);
    1021. 	hsl2rgb(hParticle,sParticle,lParticle,rParticle,gParticle,bParticle);
    1022. 	rParticle *=255;
    1023. 	gParticle *=255;
    1024. 	bParticle *=255;
    1025. 	//aParticle = 255;
    1026. }

  • 相关阅读:
    pbjs 无法编码 bytes 类型数据问题的解决方案
    我用 ChatGPT 写 2023 高考语文作文：全国卷（一）
    第三篇，芯片启动和时钟系统
    金九银十进大厂必刷的105道Java面试题（不得不说的秘密）
    NR 物理层编码 S1 -概述
    JSON和全局异常处理
    【代码精读】中断路由代码导读：当cpu运行在ATF来了一个Non secure Group1中断
    大学毕业一年 - 北漂生活
    十四、SpringBoot原理——SpringBoot应用是怎么启动的？从创建容器到运行容器，逐行分析完整过程
    robotframework RequestsLibrary Post On Session关键字 body为json的问题
  • 原文地址：https://blog.csdn.net/twopointfive/article/details/125453207