void YmxExplodeParticleSystem::_ResetParticle(YmxParticle* p) { p->x = m_Center.x; p->y = m_Center.y; if(m_RGBVariant == 0) { p->color = m_StartColor; }else { p->alpha = RESTRICT_RGB(m_StartColorA + GetRandomInteger(-m_RGBVariant, m_RGBVariant)); p->red = RESTRICT_RGB(m_StartColorR + GetRandomInteger(-m_RGBVariant, m_RGBVariant)); p->green = RESTRICT_RGB(m_StartColorG + GetRandomInteger(-m_RGBVariant, m_RGBVariant)); p->blue = RESTRICT_RGB(m_StartColorB + GetRandomInteger(-m_RGBVariant, m_RGBVariant)); } float theta = GetRandomFloat(m_StartAngle, m_EndAngle); float velocity = m_Velocity + GetRandomFloat(-m_VelocityVariant, m_VelocityVariant); float cosValue = CosFastByAngle(theta); float sinValue = SinFastByAngle(theta); p->velocity.x = velocity * cosValue * m_Delta; p->velocity.y = velocity * sinValue * m_Delta; p->acceleration.x = (m_Acceleration * cosValue + m_FieldAcceleration.x) * m_Delta; p->acceleration.y = (m_Acceleration * sinValue + m_FieldAcceleration.y) * m_Delta; p->life = m_ParLife + GetRandomFloat(-m_ParLifeVariant, m_ParLifeVariant); }
void InitPlayerParticle(Particle *p) { *p = (Particle){player.pEmitter.source.position, Vector2Zero(), GetRandomFloat(player.pEmitter.source.minRotation, player.pEmitter.source.maxRotation), GetRandomFloat(player.pEmitter.source.minScale, player.pEmitter.source.maxScale), player.pEmitter.source.aColor, GetRandomFloat(player.pEmitter.source.minDuration, player.pEmitter.source.maxDuration), 0, TRUE}; p->velocity = Vector2Product(GetRandomVector2(player.pEmitter.source.minSpeed, player.pEmitter.source.maxSpeed), player.pEmitter.source.direction); }
void YmxExplodeParticleSystem::_ResetParticle(int index) { m_ParVertexs[index].x = m_Center.x; m_ParVertexs[index].y = m_Center.y; m_ParVertexs[index].z = m_z; m_ParVertexs[index].size = m_StartSize + GetRandomFloat(-m_SizeVariant, m_SizeVariant); if(m_RGBVariant == 0) { m_ParVertexs[index].color = m_StartColor; }else { m_ParVertexs[index].alpha = RESTRICT_RGB(m_StartColorA + GetRandomInteger(-m_RGBVariant, m_RGBVariant)); m_ParVertexs[index].red = RESTRICT_RGB(m_StartColorR + GetRandomInteger(-m_RGBVariant, m_RGBVariant)); m_ParVertexs[index].green = RESTRICT_RGB(m_StartColorG + GetRandomInteger(-m_RGBVariant, m_RGBVariant)); m_ParVertexs[index].blue = RESTRICT_RGB(m_StartColorB + GetRandomInteger(-m_RGBVariant, m_RGBVariant)); } float theta = GetRandomFloat(m_StartAngle, m_EndAngle); float velocity = m_Velocity + GetRandomFloat(-m_VelocityVariant, m_VelocityVariant); float cosValue = CosFastByAngle(theta); float sinValue = SinFastByAngle(theta); m_ParAttributes[index].velocity.x = velocity * cosValue * m_Delta; m_ParAttributes[index].velocity.y = velocity * sinValue * m_Delta; m_ParAttributes[index].acceleration.x = (m_Acceleration * cosValue + m_FieldAcceleration.x) * m_Delta; m_ParAttributes[index].acceleration.y = (m_Acceleration * sinValue + m_FieldAcceleration.y) * m_Delta; m_ParAttributes[index].life = m_ParLife + GetRandomFloat(-m_ParLifeVariant, m_ParLifeVariant); }
/* 1. 将粒子复活并将其置入粒子源处 2. 获取任意方向,大小在规定范围内的速度,并将其规范化,以便绘制出球形区域 3. 设置粒子的颜色为随机颜色 4. 设置粒子的生命周期为2s */ void FIRE::reset_particle(ATTRIBUTE *attribute) { attribute->_alive = true; attribute->_position = _origin; D3DXVECTOR3 min = D3DXVECTOR3(-1.0f, -1.0f, -1.0f); D3DXVECTOR3 max = D3DXVECTOR3( 1.0f, 1.0f, 1.0f); //获取任意方向的速度 GetRandomVector( &attribute->_velocity, &min, &max); //将速度规范化才能绘制出球形 D3DXVec3Normalize( &attribute->_velocity, &attribute->_velocity); attribute->_velocity *= 100.0f; //将粒子设置为一个随机的颜色 attribute->_color = D3DXCOLOR( GetRandomFloat(0.0f, 1.0f), GetRandomFloat(0.0f, 1.0f), GetRandomFloat(0.0f, 1.0f), 1.0f); attribute->_age = 0.0f; attribute->_life_time = 2.0f; // lives for 2 seconds }
void ComParticle::Awake() { m_vecParticles.resize(numParticle); for (int i = 0; i < numParticle; ++i) { Attribute* att = new Attribute(); att->position.y = 0; att->velocity.x = GetRandomFloat(-0.01f, 0.01f); att->velocity.z = GetRandomFloat(0.01f, 0.02f); att->velocity.y = GetRandomFloat(-0.01f, 0.01f); // 불은 처음에 노란색 이후 빨간색 att->color = 0xFFFFFF99; // 노란색 R - 255 G - 255 B - 153 //att->color = 0xFFFF0000; // 빨간색 R - 255 G - 0 B - 0 att->age = i * 0.1f; m_vecParticles[i] = att; } pDevice9->CreateVertexBuffer(numParticle * sizeof(Particle), D3DUSAGE_POINTS | D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, Particle::FVF, D3DPOOL_DEFAULT, &m_VB, 0); texture = Assets::GetTexture(L"Resources/particle/snow.png"); gameObject->transform->SetPosition(0, 0, -1); }
void YmxCometParticleSystem::_ResetParticle(YmxParticle* p) { p->x = m_Position.x; p->y = m_Position.y; if(m_RGBVariant == 0) { p->color = m_StartColor; }else { p->alpha = RESTRICT_RGB(m_StartColorA + GetRandomInteger(-m_RGBVariant, m_RGBVariant)); p->red = RESTRICT_RGB(m_StartColorR + GetRandomInteger(-m_RGBVariant, m_RGBVariant)); p->green = RESTRICT_RGB(m_StartColorG + GetRandomInteger(-m_RGBVariant, m_RGBVariant)); p->blue = RESTRICT_RGB(m_StartColorB + GetRandomInteger(-m_RGBVariant, m_RGBVariant)); } float theta = GetRandomFloat(0.0f, 360.0f); float sinMulDelta = SinFastByAngle(theta) * m_Delta; float cosMulDelta = CosFastByAngle(theta) * m_Delta; float velocity = m_Velocity + GetRandomFloat(-m_VelocityVariant, m_VelocityVariant); float acceleration = m_Acceleration + GetRandomFloat(-m_AccelerationVariant, m_AccelerationVariant); p->velocity.x = velocity * cosMulDelta; p->velocity.y = velocity * sinMulDelta; p->acceleration.x = acceleration * cosMulDelta; p->acceleration.y = acceleration * sinMulDelta; p->size = m_StartSize + GetRandomFloat(-m_SizeVariant, m_SizeVariant); p->life = m_ParLife + GetRandomFloat(-m_ParLifeVariant, m_ParLifeVariant); }
void GetRandomVectorInUnitCircle(float *u,float *v) { // JLM 9/11/98 do { *u = GetRandomFloat(-1.0,1.0); *v = GetRandomFloat(-1.0,1.0); } while ( (*u)*(*u) + (*v)*(*v) > 1.0); }
void d3d::GetRandomVector( D3DXVECTOR3* out, D3DXVECTOR3* min, D3DXVECTOR3* max) { out->x = GetRandomFloat(min->x, max->x); out->y = GetRandomFloat(min->y, max->y); out->z = GetRandomFloat(min->z, max->z); }
// Returns a random unit vector on the unit sphere. void GetRandomVec(D3DXVECTOR3& out) { out.x = GetRandomFloat(-1.0f, 1.0f); out.y = GetRandomFloat(-1.0f, 1.0f); out.z = GetRandomFloat(-1.0f, 1.0f); // Project onto unit sphere. D3DXVec3Normalize(&out, &out); }
void YmxSnowParticleSystem::_ResetParticle(YmxParticle* p, bool bOnBordary) { if(bOnBordary) { float k = GetRandomFloat(0.0f, 1.0f); if(k < m_AppearRatesOnBordary[LEFT]) { p->x = m_BoundingBox.left; p->y = GetRandomFloat(m_BoundingBox.top, m_BoundingBox.bottom); } else if(k < m_AppearRatesOnBordary[RIGHT]) { p->x = m_BoundingBox.right; p->y = GetRandomFloat(m_BoundingBox.top, m_BoundingBox.bottom); } else if(k < m_AppearRatesOnBordary[BOTTOM]) { p->x = GetRandomFloat(m_BoundingBox.left, m_BoundingBox.right); p->y = m_BoundingBox.bottom; } else { p->x = GetRandomFloat(m_BoundingBox.left, m_BoundingBox.right); p->y = m_BoundingBox.top; } } else { p->x = GetRandomFloat(m_BoundingBox.left, m_BoundingBox.right); p->y = GetRandomFloat(m_BoundingBox.top, m_BoundingBox.bottom); } p->velocity.x = GetRandomFloat(m_MinVelocity.x, m_MaxVelocity.x); p->velocity.y = GetRandomFloat(m_MinVelocity.y, m_MaxVelocity.y); p->color = _GetRandomColor(); }
//本函数没错 //设置粒子属性 P245 //在指定的外界体内创建了具有随机xz坐标的雪花粒子,并将粒子的y坐标设为 //外接体高度值,赋予雪花一定向左下飘的速度 void SNOW::reset_particle(ATTRIBUTE *attribute) { attribute->_alive = true; GetRandomVector(&attribute->_position, //设置雪花飘落的速度大小以及方向 &_box._min, &_box._max); attribute->_position.y = _box._max.y; attribute->_velocity.x = GetRandomFloat(0.0f,1.0f) * (-3.0f); attribute->_velocity.y = GetRandomFloat(0.0f,1.0f) * (-10.0f); attribute->_velocity.z = 0.0f; attribute->_color = WHITE; //设定雪花的颜色(实际上雪花的颜色是纹理的颜色) }
void PropsDemo::buildGrassFin(GrassVertex* v, WORD* k, int& indexOffset, D3DXVECTOR3& worldPos, D3DXVECTOR3& scale) { // Only top vertices have non-zero amplitudes: // The bottom vertices are fixed to the ground. float amp = GetRandomFloat(0.5f, 1.0f); v[0] = GrassVertex(D3DXVECTOR3(-1.0f,-0.5f, 0.0f), D3DXVECTOR2(0.0f, 1.0f), 0.0f); v[1] = GrassVertex(D3DXVECTOR3(-1.0f, 0.5f, 0.0f), D3DXVECTOR2(0.0f, 0.0f), amp); v[2] = GrassVertex(D3DXVECTOR3( 1.0f, 0.5f, 0.0f), D3DXVECTOR2(1.0f, 0.0f), amp); v[3] = GrassVertex(D3DXVECTOR3( 1.0f,-0.5f, 0.0f), D3DXVECTOR2(1.0f, 1.0f), 0.0f); // Set indices of fin. k[0] = 0 + indexOffset; k[1] = 1 + indexOffset; k[2] = 2 + indexOffset; k[3] = 0 + indexOffset; k[4] = 2 + indexOffset; k[5] = 3 + indexOffset; // Offset the indices by four to have the indices index into // the next four elements of the vertex buffer for the next fin. indexOffset += 4; // Scale the fins and randomize green color intensity. for(int i = 0; i < 4; ++i) { v[i].pos.x *= scale.x; v[i].pos.y *= scale.y; v[i].pos.z *= scale.z; // Generate random offset color (mostly green). v[i].colorOffset = D3DXCOLOR( GetRandomFloat(0.0f, 0.1f), GetRandomFloat(0.0f, 0.2f), GetRandomFloat(0.0f, 0.1f), 0.0f); } // Add offset so that the bottom of fin touches the ground // when placed on terrain. Otherwise, the fin's center point // will touch the ground and only half of the fin will show. float heightOver2 = (v[1].pos.y - v[0].pos.y) / 2; worldPos.y += heightOver2; // Set world center position for the quad. v[0].quadPos = worldPos; v[1].quadPos = worldPos; v[2].quadPos = worldPos; v[3].quadPos = worldPos; }
void DecorationMap::GenVBuffers(int32_t patchId) { const TerrainGob* terrain = this->GetParent(); ImageData* imgdata = GetMaskData(); int32_t patchCell = terrain->GetPatchDim() - 1; int32_t numPatchX = (terrain->GetNumCols()-1) / patchCell; int32_t numPatchY = (terrain->GetNumRows()-1) / patchCell; float dimx = (float)imgdata->GetWidth() / numPatchX; float dimy = (float)imgdata->GetHeight() / numPatchY; Bound2di box; int32_t px = patchId % numPatchX; int32_t py = patchId / numPatchX; box.x1 = (int32_t) (px * dimx); box.x2 = box.x1 + (int32_t)dimx; box.y1 = (int32_t) (py * dimy); box.y2 = box.y1 + (int32_t)dimy; float ycol = (float)imgdata->GetHeight(); float xcol = (float)imgdata->GetWidth(); float halfu = 1.0f / ( 2.0f * xcol); float halfv = 1.0f / (2.0f * ycol); auto& list = m_listOfVBList[patchId]; list.clear(); srand(7353 + patchId * m_instId); for(int32_t y = box.y1; y < box.y2; y++) { float v = y / ycol; for(int32_t x = box.x1; x < box.x2; x++) { float u = x / xcol; uint8_t r = *((uint8_t*)imgdata->PixelAt(x,y)); if(r > 0) { for(int32_t k = 0; k < m_numOfDecoratorsPerTexel; k++) { float nu = GetRandomFloat(u-halfu, u+halfu); float nv = GetRandomFloat(v-halfv,v+halfv); float2 posn(nu,nv); list.push_back(posn); } } } }//// for(int32_t y = box.y1; y < box.y2; y++) }
WorldPoint3D Map3D_c::ReflectPoint(WorldPoint3D fromWPt,WorldPoint3D toWPt,WorldPoint3D wp) { WorldPoint3D movedPoint = TurnLEAlongShoreLine(fromWPt, wp, toWPt); // use length of fromWPt to beached point or to toWPt? /*if (!InVerticalMap(movedPoint)) { movedPoint.z = fromWPt.z; // try not changing depth if (!InVerticalMap(movedPoint)) movedPoint.p = fromWPt.p; // use original point }*/ //movedPoint.z = toWPt.z; // attempt the z move // code goes here, check mixedLayerDepth? if (!InVerticalMap(movedPoint) || movedPoint.z == 0) // these points are supposed to be below the surface { double depthAtPt = DepthAtPoint(movedPoint.p); // code goes here, a check on return value if (depthAtPt <= 0) { OSErr err = 0; return fromWPt; // code goes here, may want to force the point back into map somehow } //if (depthAtPt==0) //movedPoint.z = .1; if (movedPoint.z > depthAtPt) movedPoint.z = GetRandomFloat(.9*depthAtPt,.99*depthAtPt); //if (movedPoint.z > depthAtPt) movedPoint.z = GetRandomFloat(.7*depthAtPt,.99*depthAtPt); //if (movedPoint.z <= 0) movedPoint.z = GetRandomFloat(.01*depthAtPt,.1*depthAtPt); if (movedPoint.z <= 0) //movedPoint.z = GetRandomFloat(.01*depthAtPt,.1*depthAtPt); movedPoint.z = 0; // let points surface or resurface (redispersing is taken care of in TRandom3D) //movedPoint.z = fromWPt.z; // try not changing depth //if (!InVerticalMap(movedPoint)) //movedPoint.p = fromWPt.p; // use original point - code goes here, need to find a z in the map } return movedPoint; }
void initParticle(Particle& out) { // Time particle is created relative to the global running // time of the particle system. out.initialTime = mTime; // Flare lives for 2-4 seconds. out.lifeTime = GetRandomFloat(2.0f, 4.0f); // Initial size in pixels. out.initialSize = GetRandomFloat(10.0f, 15.0f); // Give a very small initial velocity to give the flares // some randomness. GetRandomVec(out.initialVelocity); // Scalar value used in vertex shader as an amplitude factor. out.mass = GetRandomFloat(1.0f, 2.0f); // Start color at 50-100% intensity when born for variation. out.initialColor = GetRandomFloat(0.5f, 1.0f)*WHITE; // Generate random particle on the ring in polar coordinates: // random radius and random angle. float r = GetRandomFloat(10.0f, 14.0f); float t = GetRandomFloat(0, 2.0f*D3DX_PI); // Convert to Cartesian coordinates. out.initialPos.x = r*cosf(t); out.initialPos.y = r*sinf(t); // Random depth value in [-1, 1] (depth of the ring) out.initialPos.z = GetRandomFloat(-1.0f, 1.0f); }
//传入当前需要重新设置的墙体的迭代器与所有坦克所在位置 //主坦克,敌方坦克,第三方坦克,注意:第三方坦克为类的成员 void WALL::reset(list<IMFOR_WALL>::iterator index,PROPERTY *pro,TANK *host) { float x,z; int sign = 1; list<IMFOR_WALL>::iterator i; PROPERTY *p; x = GetRandomFloat(_box._min.x + 1000,_box._max.x - 1000); z = GetRandomFloat(_box._min.z + 1000,_box._max.z - 1000); while(1) { for(i = _imfor.begin();i != _imfor.end();i++) { if(i != index) if((x - i->_position.x) * (x - i->_position.x) + (z - i->_position.z) * (z - i->_position.z) < _distance * 80) { x = GetRandomFloat(_box._min.x + 1000,_box._max.x - 1000); z = GetRandomFloat(_box._min.z + 1000,_box._max.z - 1000); i = _imfor.begin(); } } //判断是否与第三方坦克位置重复-------------- //是否与敌方坦克所在位置重复 for(p = pro;p != pro + 8;p++) if((x - p->_position.x) * (x - p->_position.x) + (z - p->_position.z) * (z - p->_position.z) < _distance) sign = 0; if(sign == 1) //最后,若主坦克也没有与再生点重复,该点可用 if((x - host->_position.x) * (x - host->_position.x) + (z - host->_position.z) * (z - host->_position.z) > _distance) { index->_position = D3DXVECTOR3(x,0,z); //位置 index->_life = _life_time; //声明 index->_mesh->mesh_release(); sign = (int)GetRandomFloat(0,20) % _random; //x文件 index->_mesh->Init(_x_name[sign],4); return ; } sign = 1; } }
///////////////////////////////////// // Class GameObject TankEnemy::TankEnemy() { m_type = GameObjectType_TankEnemy; m_analizeTime = kEnemyAIAnalizeTime; m_analizeTimer = GetRandomFloat( 0.0, m_analizeTime); m_lastAnalizeX = 0.0; m_lastAnalizeY = 0.0; m_health = kEnemyHealth; m_speed = kEnemySpeed; setColor( ConsoleColor_DarkCyan, ConsoleColor_Cyan ); }
void WALL::reset_boss(const D3DXVECTOR3 &position) { _boss._run_time = GetRandomFloat(_life_time / 4,_life_time / 2); _boss._target = position; _boss._look = _boss._target - _boss._position; D3DXVec3Normalize(&_boss._look,&_boss._look); _boss._velocity = _boss._look * _boss._mul; float angle; angle = D3DXVec3Dot(&D3DXVECTOR3(0,0,1),&_boss._look) / D3DXVec3Length(&_boss._look); if(_boss._look.x < 0) angle = D3DX_PI - acos(angle); else angle = D3DX_PI + acos(angle); D3DXMatrixRotationAxis(&_boss._rotation,&D3DXVECTOR3(0,1,0),angle); //记录旋转角度 }
//传入的二级指针为X文件提供了随机选择范围 //外界传入随机数的同时,需要将其对char数组的行数取余 //随机数即存储了数组的维数,同时存储了墙体的数量 / 倍数 WALL::WALL(LPDIRECT3DDEVICE9 device,wchar_t (*x_name)[50],BOUNDINGBOX &box,int ran): _random(ran), //取余是为了避免随机数过大 _distance(10000), //与墙体发生撞击的距离的平方 _life_time(500), //再生墙体的生命值 _life_cut(1) //墙体收到打击时生命值的衰减系数 ,_mul(10) ,_box(box) ,_x_name(x_name) ,_device(device) ,_life_mul(10) { list<IMFOR_WALL>::iterator index; IMFOR_WALL wall; int j; TANK a(device); wall._life = _life_time; //初始化一个虚拟的wall wall._position = D3DXVECTOR3(0,0,0); wall._mesh = new MESHXFILE(device); j = GetRandomFloat(0,_random); wall._mesh->Init(x_name[j],4); a._position = D3DXVECTOR3(0,0,0); PROPERTY enemy[8]; for(int i = 0;i < 8;i++) //虚拟敌方坦克的信息 enemy[i]._position = D3DXVECTOR3(0,0,0); _imfor.push_back(wall); index = _imfor.begin(); reset(index,enemy,&a); for(int i = 0;i < _random * _mul - 1;i++) { _imfor.push_back(wall); index++; reset(index,enemy,&a); } //BOSS坦克的信息 _boss._target = D3DXVECTOR3(0,0,-1); //目标 _boss._position = D3DXVECTOR3(5000,5000,5000); //位置 _boss._look = D3DXVECTOR3(0,0,-1); //观察方向 D3DXMatrixIdentity(&_boss._rotation); _boss._mesh = new MESHXFILE(device); //x文件 _boss._mesh->Init(x_name[5],BOSS); //初始化BOSS的x文件与纹理 _boss._velocity = _boss._look * 0; _boss._run_time = 0; _boss._run_cut = 1; _boss._alive = false; _boss._mul = 10; _boss._life = 0; //初始化生命值 }
void initParticle(Particle& out) { // Generate at camera. out.initialPos = gCamera->pos(); // Set down a bit so it looks like player is carrying the gun. out.initialPos.y -= 3.0f; // Fire in camera's look direction. float speed = 500.0f; out.initialVelocity = speed*gCamera->look(); out.initialTime = mTime; out.lifeTime = 4.0f; out.initialColor = WHITE; out.initialSize = GetRandomFloat(80.0f, 90.0f); out.mass = 1.0f; }
// Update frame-based values. void D3D12ExecuteIndirect::OnUpdate() { for (UINT n = 0; n < TriangleCount; n++) { const float offsetBounds = 2.5f; // Animate the triangles. m_constantBufferData[n].offset.x += m_constantBufferData[n].velocity.x; if (m_constantBufferData[n].offset.x > offsetBounds) { m_constantBufferData[n].velocity.x = GetRandomFloat(0.01f, 0.02f); m_constantBufferData[n].offset.x = -offsetBounds; } } UINT8* destination = m_pCbvDataBegin + (TriangleCount * m_frameIndex * sizeof(ConstantBufferData)); memcpy(destination, &m_constantBufferData[0], TriangleCount * sizeof(ConstantBufferData)); }
void YmxSnowParticleSystem::_AddParticle(bool bOnBordary) { YmxParticle *p = new YmxParticle; _ResetParticle(p, bOnBordary); p->next = NULL; if(m_bSupportPSize) { p->size = GetRandomFloat(m_MinSize, m_MaxSize); p->next = m_Particles; m_Particles = p; } else { int index = GetRandomInteger(0, m_psizeNum - 1); p->next = m_ParsGroups[index].particles; m_ParsGroups[index].particles = p; } m_Count++; }
void initParticle(Particle& out) { // Generate about the origin. out.initialPos = D3DXVECTOR3(0.0f, 0.0f, 0.0f); out.initialTime = mTime; out.lifeTime = GetRandomFloat(4.0f, 5.0f); out.initialColor = WHITE; out.initialSize = GetRandomFloat(8.0f, 12.0f); out.mass = GetRandomFloat(0.8f, 1.2f); out.initialVelocity.x = GetRandomFloat(-2.5f, 2.5f); out.initialVelocity.y = GetRandomFloat(15.0f, 25.0f); out.initialVelocity.z = GetRandomFloat(-2.5f, 2.5f); }
void Explosion::initParticle(VertexParticle& out) { // Generate about the origin. out.psPosition = m_v3Position; out.initialTime = m_fTime; out.lifeTime = GetRandomFloat(0.5f, 1.0f); out.colour = m_d3cColour; out.initialSize = GetRandomFloat(32.0f, 50.0f); out.mass = GetRandomFloat(0.8f, 1.2f); out.initialVelocity.x = GetRandomFloat(-100.0f, 100.0f); out.initialVelocity.y = GetRandomFloat(-100.0f, 100.0f); out.initialVelocity.z = GetRandomFloat(-100.0f, 100.0f); }
//更新第三方坦克与墙体位置等消息,注意,需要设置发射子弹 void WALL::update(GUN_CHILD *gun,TANK_ENEMY *pro,TANK *host) { if((_boss._position.x - host->_position.x) * (_boss._position.x - host->_position.x) + (_boss._position.z - host->_position.z) * (_boss._position.z - host->_position.z) < (_distance)) { host->_life = 0; return; } //更新墙壁 list<IMFOR_WALL>::iterator index; for(index = _imfor.begin();index != _imfor.end();index++) { if(index->_life <= 0) //若墙壁已经打爆,根据现场所有坦克的位置确认新的墙壁的位置 { int i; i = GetRandomFloat(0,13); if(i < 4) { if(_boss._alive == false) //打爆墙壁时,若boss不存在,出现 { _boss._alive = true; _boss._position = index->_position; _boss._life = _life_time * _life_mul; _boss._run_time = 0; } } else if(i < 5) { if(pro->_mul > 1) //敌方降低 pro->_mul -= 1; } else if(i < 7) //我方坦克速度增加 host->_mul += 1; else tree_or_explore = !tree_or_explore; reset(index,pro->_imfor,host); } } if(_boss._alive == true) update_boss(host->_position); }
//初始化粒子 void SnowParticle::ResetParticle(Particle* particle) { particle->age = 0.0f; particle->isLive = true; particle->lifeTime = GetRandomFloat(2.0f, 10.0f); particle->color = D3DCOLOR_RGBA(rand() % 255, rand() % 255, rand() % 255, rand() % 255); particle->colorFade = D3DXCOLOR(D3DCOLOR_RGBA(0, 0, 0, 0)); D3DXVECTOR3 minVec(0, 50, 0); D3DXVECTOR3 maxVec(50, 70, 50); D3DXVECTOR3 pos; GetRandomVector(&pos, &minVec, &maxVec); particle->position = pos; particle->initVelocity = D3DXVECTOR3(GetRandomFloat(0, 1.0f), GetRandomFloat(-1.0f, 0.0f), GetRandomFloat(0.0f, 1.0f)); particle->velocity = D3DXVECTOR3(GetRandomFloat(-1.0f, 1.0f), GetRandomFloat(-1.0f, 0.0f), GetRandomFloat(-1.0f, 1.0f)); }
SensorData_t* FrameGenerator::GenerateSensorData(SensorData_t* pData) { if (!pData) { pData = new SensorData_t; } pData->gpsData.latitude = GetRandomFloat(); pData->gpsData.longitude = GetRandomFloat(); pData->gpsData.altitude = GetRandomFloat() / 200; pData->gpsData.groundSpeed = GetRandomFloat() / 100; pData->rangeFinderData.rangeBack = GetRandomFloat() / 100; pData->rangeFinderData.rangeFront = GetRandomFloat() / 100; return pData; }
void FireBall::initParticle(ParticleEmitter::Particle& out) { // Time particle is created relative to the global running // time of the particle system. out.initialTime = mTime; out.age=mTime; // Flare lives for 2-4 seconds. // original values //out.lifeTime = GetRandomFloat(2.0f, 8.0f); out.lifeTime = GetRandomFloat(mMinLifeTime, mMaxLifeTime); // Initial size in pixels. // original values //out.initialSize = GetRandomFloat(10.0f, 15.0f); out.initialSize = GetRandomFloat(mMinSize, mMaxSize); // Give a very small initial velocity to give the flares // some randomness. GetRandomVec(out.initialVelocity); out.initialVelocity.x *= mAccelImpulse.x; out.initialVelocity.y *= mAccelImpulse.y; out.initialVelocity.z *= mAccelImpulse.z; out.initialVelocity.x += mAccelShift.x; out.initialVelocity.y += mAccelShift.y; out.initialVelocity.z += mAccelShift.z; // Scalar value used in vertex shader as an amplitude factor. out.mass = GetRandomFloat(1.0f, 2.0f); // Start color at 50-100% intensity when born for variation. out.initialColor = static_cast<DWORD>(GetRandomFloat(0.5f, 1.0f) * 1.0f);//white; V3 temp = mParticleRadius - mInitPos; float length = temp.Length(); V3 tempNormal = temp.Normalize(); //D3DXMATRIX outmtx; noMat3 outmtx; //D3DXMatrixRotationYawPitchRoll(&outmtx,GetRandomFloat(0.0f,2.0f)*noMath::PI,GetRandomFloat(0.0f,2.0f)*noMath::PI,0.0f); noAngles angle(RAD2DEG(GetRandomFloat(0.0f,2.0f)*noMath::PI), RAD2DEG(GetRandomFloat(0.0f,2.0f)*noMath::PI), 0.0f); outmtx = angle.ToMat3(); //D3DXVec3TransformCoord(&temp,&temp,&outmtx); temp = outmtx * temp; out.initialPos = mInitPos + (temp * length); }
Vector2 GetRandomVector2(Vector2 a, Vector2 b) { return (Vector2){GetRandomFloat(a.x, b.x), GetRandomFloat(a.y, b.y)}; }
// Update frame-based values. void D3D12HeterogeneousMultiadapter::OnUpdate() { // Add the oldest timestamp data to our moving average counters. // Use the oldest timestamp index to limit CPU waits. { // The oldest frame is the current frame index and it will always be complete due to the wait in MoveToNextFrame(). const UINT oldestFrameIndex = m_frameIndex; assert(m_frameFenceValues[oldestFrameIndex] <= m_frameFence->GetCompletedValue()); // Get the timestamp values from the result buffers. D3D12_RANGE readRange = {}; const D3D12_RANGE emptyRange = {}; UINT64* ppMovingAverage[] = { m_drawTimes, m_blurTimes }; for (UINT i = 0; i < GraphicsAdaptersCount; i++) { readRange.Begin = 2 * oldestFrameIndex * sizeof(UINT64); readRange.End = readRange.Begin + 2 * sizeof(UINT64); void* pData = nullptr; ThrowIfFailed(m_timestampResultBuffers[i]->Map(0, &readRange, &pData)); const UINT64* pTimestamps = reinterpret_cast<UINT64*>(static_cast<UINT8*>(pData) + readRange.Begin); const UINT64 timeStampDelta = pTimestamps[1] - pTimestamps[0]; // Unmap with an empty range (written range). m_timestampResultBuffers[i]->Unmap(0, &emptyRange); // Calculate the GPU execution time in microseconds. const UINT64 gpuTimeUS = (timeStampDelta * 1000000) / m_directCommandQueueTimestampFrequencies[i]; ppMovingAverage[i][m_currentTimesIndex] = gpuTimeUS; } // Move to the next index. m_currentTimesIndex = (m_currentTimesIndex + 1) % MovingAverageFrameCount; } // Dynamically change the workload on the primary adapter. This is a VERY naive implementation. // The point here is to show that applications have a choice with how to spend their extra cycles. // Note: If copies take longer then you should take that into account as well. { static UINT64 framesSinceLastUpdate = 0; framesSinceLastUpdate++; if (framesSinceLastUpdate > MovingAverageFrameCount) { // Calculate the average draw and blur times for last few frames. m_drawTimeMovingAverage = 0; m_blurTimeMovingAverage = 0; for (UINT i = 0; i < MovingAverageFrameCount; i++) { m_drawTimeMovingAverage += m_drawTimes[i]; m_blurTimeMovingAverage += m_blurTimes[i]; } m_drawTimeMovingAverage /= MovingAverageFrameCount; m_blurTimeMovingAverage /= MovingAverageFrameCount; framesSinceLastUpdate = 0; // Adjust the shader blur time to be at least 20ms/frame. // Note: This is just done to show that we can reach ~100% utilization of both adapters. if (AllowShaderDynamicWorkload) { const UINT64 desiredBlurPSTimeUS = 20000; // 20 ms if (m_blurTimeMovingAverage < desiredBlurPSTimeUS || m_blurPSLoopCount != 0) { // Adjust the PS blur time based on the moving average. const float timeDelta = (static_cast<float>(desiredBlurPSTimeUS) - static_cast<float>(m_blurTimeMovingAverage)) / static_cast<float>(m_blurTimeMovingAverage); if (timeDelta < -.05f || timeDelta > .01f) { const float stepSize = max(1.0f, m_blurPSLoopCount); m_blurPSLoopCount += static_cast<INT>(stepSize * timeDelta); } } } // Adjust the render time to be greater than the blur time. { const UINT64 desiredDrawPSTimeUS = m_blurTimeMovingAverage + static_cast<UINT64>(m_blurTimeMovingAverage * .10f); const float timeDelta = (static_cast<float>(desiredDrawPSTimeUS) - static_cast<float>(m_drawTimeMovingAverage)) / static_cast<float>(m_drawTimeMovingAverage); if (timeDelta < -.10f || timeDelta > .01f) { if (AllowDrawDynamicWorkload) { // Adjust the number of triangles drawn. const float stepSize = max(1.0f, m_triangleCount); m_triangleCount = min(m_triangleCount + static_cast<INT>(stepSize * timeDelta), MaxTriangleCount); } else if (AllowShaderDynamicWorkload) { // Adjust the number of the PS loop count based on the moving average. const float stepSize = max(1.0f, m_psLoopCount); m_psLoopCount += static_cast<INT>(stepSize * timeDelta); } } } } // Conditionally update the window's title. if (framesSinceLastUpdate % WindowTextUpdateFrequency == 0) { UpdateWindowTitle(); } } // Update the workloads. { WorkloadConstantBufferData* pWorkloadDst = m_pWorkloadCbvDataBegin + m_frameIndex; WorkloadConstantBufferData* pWorkloadSrc = &m_workloadConstantBufferData; pWorkloadSrc->loopCount = m_psLoopCount; memcpy(pWorkloadDst, pWorkloadSrc, sizeof(WorkloadConstantBufferData)); WorkloadConstantBufferData* pBlurWorkloadDst = m_pBlurWorkloadCbvDataBegin + m_frameIndex; WorkloadConstantBufferData* pBlurWorkloadSrc = &m_blurWorkloadConstantBufferData; pBlurWorkloadSrc->loopCount = m_blurPSLoopCount; memcpy(pBlurWorkloadDst, pBlurWorkloadSrc, sizeof(WorkloadConstantBufferData)); } // Update the triangles. { const float offsetBounds = 2.5f; for (UINT n = 0; n < m_triangleCount; n++) { // Animate the triangles. m_constantBufferData[n].offset.x += m_constantBufferData[n].velocity.x; if (m_constantBufferData[n].offset.x > offsetBounds) { m_constantBufferData[n].velocity.x = GetRandomFloat(0.01f, 0.02f); m_constantBufferData[n].offset.x = -offsetBounds; } } ConstantBufferData* dst = m_pCbvDataBegin + (m_frameIndex * MaxTriangleCount); memcpy(dst, &m_constantBufferData[0], m_triangleCount * sizeof(ConstantBufferData)); } }