Ray Ray::getInConeRay(Vec3f intersection, Vec3f * triangle, int depth, pair <int, int> exceptionTriangle) { Vec3f n = getNormalwithRayComes(triangle, this->direction); //find a unit vector in the plane Vec3f ex(triangle[0] - intersection); ex /= ex.length(); //another unit vector in the plane to forme a local coordiante Vec3f ey = cross(n, ex); Vec3f wi(this->position - intersection); wi /= wi.length(); float cosTheta_i = dot(wi, n); if(cosTheta_i < -EPS) cout << "ERROR in getInConeRaysOut: l'angle theta_i est plus grande que 90, something wrong with the direction" << endl; //find a eOnPlane vector unit (which lies on plane) float xComponent = getRandomFloat(-1.0, 1.0); float yComponent = getRandomFloat(-1.0, 1.0); Vec3f eOnPlane(xComponent * ex + yComponent * ey); eOnPlane /= eOnPlane.length(); //to ensure the direction Out lies inside the cone //dirOut = costheta_i * normal + sintheta_i * eOnPlane Vec3f dirOut(cosTheta_i * n + sqrt(1 - cosTheta_i*cosTheta_i) * eOnPlane); dirOut /= dirOut.length(); return Ray(intersection, dirOut, bshRoot, depth, exceptionTriangle); }
vector<float> generateTestData() { //Generates a data point either in the range (0.75,0.75) -> (1,1) or (0,0) -> (.25,.25) double g = getRandomFloat(0, 1); double lb; double ub; if (g < 0.33) { lb = 0.8; ub = 1.00; } else if (g < 0.66) { lb = 0.0; ub = 0.2; } else { lb = 0.4; ub = 0.6; } vector<float> generatedVector; generatedVector.push_back(getRandomFloat(lb, ub)); generatedVector.push_back(getRandomFloat(lb, ub)); generatedVector.shrink_to_fit(); return generatedVector; }
float ParticleSystem::getRandomValue(float base, float variance) { float min = base - (variance / 2); float max = base + (variance / 2); return getRandomFloat(min, max); }
Perceptron::Perceptron(unsigned int newFeatureSpaceDimension) { for (unsigned int i = 0; i != newFeatureSpaceDimension + 1; ++i) weights.push_back(getRandomFloat(-0.05, 0.05)); featureSpaceDimension = newFeatureSpaceDimension; }
inline f32 getFloatFromValueRange( const CTreeGenerator::SValueRange<f32>& range, s32 seed ) { if ( range.IsValue ) return range.Value; return getRandomFloat( seed, range.Min, range.Max ); }
void main() { vec2 gravity = vec2(0.0, -0.0005); float max = 0.05; float maxSquared = max * max; outPos = inPos; outVel = inVel; outVel += gravity; // limit speed float speedSquared = dot(outVel, outVel); if (speedSquared > maxSquared) { vec2 norm = normalize(outVel); outVel *= max; } outPos += outVel; // keep in frame if (inPos.y < -1.0) { outPos.x = 0.0; outPos.y = 0.0; // reset velocity and position // use position to generate random number for velocity direction float newFloat = getRandomFloat(inPos); // use a different vector to generate a random number for velocity length vec2 altVec; if (inPos.x != 0.0 && inPos.y != 0.0) { altVec = inPos + vec2(1.0/inPos.x, 1.0/inPos.y); } else { altVec = inPos; } float newSpeed = getRandomFloat(altVec); newSpeed = mapFloat(newSpeed, 0.0, 1.0, 0.06, 0.15); // make min output number smaller; why does that happen? outVel = getDir(newFloat); outVel *= newSpeed; outPos = mousePos; } outCol = inCol; gl_Position = vec4(outPos, 0.0, 1.0); }
void dbRoundPosGenerator::Generate(double dt, dbParticleData *p, size_t startId, size_t endId) { for (size_t i = startId; i < endId; ++i) { double ang = getRandomFloat(0.0f, DB_PI*2.0f, 2); p->position_[i] = center_ + core::dbVector3(radX_*(float)sin(ang), radY_*(float)cos(ang), 0.f); p->velocity_[i] = core::dbVector3(); } }
void Game::initVoronoiDiagram() { Box2 vertexBounds = bounds_; vertexBounds.pad(5.0f); Box2 triangulationBounds = vertexBounds; triangulationBounds.pad(5.0f); delauneyTriangulation_ = DelauneyTriangulation(triangulationBounds); int subdivCount = 30; float subdivWidth = float(vertexBounds.getWidth()) / float(subdivCount); float subdivHeight = float(vertexBounds.getHeight()) / float(subdivCount); for (int i = 0; i < subdivCount; ++i) { for (int j = 0; j < subdivCount; ++j) { float x = vertexBounds.p1.x + (float(i) + getRandomFloat()) * subdivWidth; float y = vertexBounds.p1.y + (float(j) + getRandomFloat()) * subdivHeight; delauneyTriangulation_.addVertex(Vector2(x, y)); } } voronoiDiagram_.generate(delauneyTriangulation_); }
//when an enemy loses health, check if they are afraid bool Follower::addHealth(float _health) { bool boolReturn = Pawn::addHealth(_health); //if health was removed and they are below fear health if (boolReturn && (_health < 0) && (mHealth < mFearHealth)) { float chance = mHealth / mFearHealth; if (getRandomFloat(0.0f, 1.0f) > chance) bAfraid = true; } return boolReturn; }
Ray Ray::getRandomRay_Sphere(Vec3f intersection, Vec3f * triangle, int depth, pair <int, int> exceptionTriangle) { Vec3f en = getNormalwithRayComes(triangle, this->direction); //find a unit vector in the plane Vec3f ex(triangle[0] - intersection); ex.normalize(); //another unit vector in the plane to forme a local coordiante Vec3f ey = cross(en, ex); ey.normalize(); float angleN = getRandomFloat(0.0, acos(-1.0) / 2); float angleXY = getRandomFloat(0.0, 2 * acos(-1.0)); Vec3f dirOut((ex * cos(angleXY) * sin(angleN)) + (ey * sin(angleXY) * sin(angleN)) + (en * cos(angleN))); dirOut.normalize(); return Ray(intersection, dirOut, bshRoot, depth, exceptionTriangle, this->DBG); }
int getActorDefense(character *actor) { float defense = actor->statDefense; int inventoryIndex = 0; item *itmPtr; while (inventoryIndex < actor->numberOfItems) { itmPtr = actor->inventory[inventoryIndex]; defense += itmPtr->statDefense; inventoryIndex ++; } defense *= getRandomFloat(.75, 1); return (int)(defense + .5); }
void Enemy::chooseTarget() { if (!bAttackPlayer) {//if only see the follower, attack them bPursuingPlayer = false; } else if (!bAttackFollower) {//if only sees the player, attack them bPursuingPlayer = true; } else//else choose randomly between them { if (getRandomFloat(0.0f, 1.0f) < 0.5f) bPursuingPlayer = true; else bPursuingPlayer = false; } }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(example_mlst_node_process, ev, data) { static struct etimer et; PROCESS_BEGIN(); //Initialize the mlst-network. Has to be done to open ports, etc. mlst_init(); eamlst_set_energy_state(ENERGY_STATE); while(1) { mlst_print_state(); rsunicast_print_state(); etimer_set(&et, CLOCK_SECOND * 4 * getRandomFloat(0.5,1.0)); //uint8_t data[7]; //mlst_send(&data, sizeof(data)); PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et)); } PROCESS_END(); }
void spawnCube() { evil cube; cube.dead = false; cube.x = getRandomFloat() * 2.f * playFieldWidth - playFieldWidth; cube.z = getRandomFloat() * 2.f * playFieldLength - playFieldLength; cube.y = getRandomFloat() * (cube_max_Y - cube_min_Y) + cube_min_Y; cube.dx = getRandomFloat() * 2.0f - 1.0f; cube.dy = getRandomFloat() * 2.0f - 1.0f; cube.dz = getRandomFloat() * 2.0f - 1.0f; _evilCubes.push_back(cube); }
void _actorLogic(character *actor) { int moved = 0; if (!actor->hp) { return; } character *player = getPlayer(), *ptr = CHARACTERS; item *weaponPtr = NULL, *actorWeapon = actorGetItemWithFlag(actor, IS_WEAPON); int hitActor = 0; int nx = actor->x + actor->vx; int ny = actor->y + actor->vy; int spawnPosition[2]; if (!actor->turns) { return; } if (actor->delay > 1) { actor->delay --; return; } actor->turns = 0; actor->delay = 0; if (actor->nextStanceFlagsToAdd) { tickSystemsWithMaskForEntity(getWorld(), actor->entityId, EVENT_ADD_STANCE); actor->stanceFlags |= actor->nextStanceFlagsToAdd; actor->nextStanceFlagsToAdd = 0x0; } if (actor->nextStanceFlagsToRemove) { tickSystemsWithMaskForEntity(getWorld(), actor->entityId, EVENT_REMOVE_STANCE); actor->stanceFlags ^= actor->nextStanceFlagsToRemove; if (actor->nextStanceFlagsToRemove & IS_STUNNED) { if (actor == player) { showMessage(5, "You regain composure.", NULL); } else { showMessage(5, "It regains composure.", NULL); } } else if (actor->nextStanceFlagsToRemove & IS_HOLDING_LODGED_WEAPON) { if (actor == player) { showMessage(5, "You dislodge the weapon.", NULL); } else { showMessage(5, "Something dislodges their weapon.", NULL); } } if (actor->nextStanceFlagsToRemove & IS_STUCK_WITH_LODGED_WEAPON) { weaponPtr = getItemLodgedInActor(actor); weaponPtr->itemFlags ^= IS_LODGED; weaponPtr->lodgedInActor = NULL; } actor->nextStanceFlagsToRemove = 0x0; } while (ptr != NULL) { if (ptr == actor || ptr->hp <= 0) { ptr = ptr->next; continue; } if (ptr->x == nx && ptr->y == ny) { hitActor = 1; break; } ptr = ptr->next; } if (_checkForTouchedItemAndHandle(actor, nx, ny)) { actor->vx = 0; actor->vy = 0; return; } if (hitActor) { actor->vx = 0; actor->vy = 0; if (attack(actor, ptr)) { return; } } else if (actor->vx || actor->vy) { if (actor->stanceFlags & IS_STUCK_WITH_LODGED_WEAPON && getItemLodgedInActor(actor)->owner) { printf("Cant move because of stuck weapon.\n"); return; } if (actor->stanceFlags & IS_HOLDING_LODGED_WEAPON) { actor->stanceFlags ^= IS_HOLDING_LODGED_WEAPON; dropItem(actor, actorWeapon); printf("Handle letting go of weapon!\n"); showMessage(10, "You let go of the weapon.", NULL); return; } if (isPositionWalkable(nx, ny)) { moved = 1; if (actor->aiFlags & IS_VOID_WORM && getRandomFloat(0, 1) > .95) { getOpenPositionInRoom(getRandomRoom(), spawnPosition); createVoidWorm(spawnPosition[0], spawnPosition[1]); } if (actor->aiFlags & IS_VOID_WORM) { createVoidWormTail(actor->x, actor->y); } actor->lastX = actor->x; actor->lastY = actor->y; actor->x = nx; actor->y = ny; setStance(actor, IS_MOVING); if (actor->itemLight) { actor->itemLight->fuel -= getLevel(); } if (actor->stanceFlags & IS_STABBING) { actor->statStabCount --; if (!actor->statStabCount) { unsetStance(actor, IS_STABBING); } } TCOD_map_compute_fov(actor->fov, actor->x, actor->y, actor->sightRange, 1, FOV_SHADOW); } else { if (actor->stanceFlags & IS_MOVING) { unsetStance(actor, IS_MOVING); if (actor->stanceFlags & IS_STABBING) { actor->statStabCount = 0; unsetStance(actor, IS_STABBING); } } } } else { if (actor->stanceFlags & IS_MOVING) { unsetStance(actor, IS_MOVING); if (actor->stanceFlags & IS_STABBING) { actor->statStabCount = 0; unsetStance(actor, IS_STABBING); } } } if (moved) { _checkForItemCollisions(actor); } if (!(actor->aiFlags & IS_IMMUNE_TO_DARKNESS) && _checkIfPositionLit(actor)) { return; } if (actor->itemLight) { actor->itemLight->x = actor->x; actor->itemLight->y = actor->y; } actor->vx = 0; actor->vy = 0; }
float getRandomFloat(float end) { return getRandomFloat(0.0f, end); }
void CTreeGenerator::appendBranch( const core::matrix4& transform, SBranch* branch, f32 lengthScale, f32 radiusScale, s32 level, SMeshBuffer* buffer, core::array<STreeLeaf>& leaves ) { if ( level <= 0 ) return; // Do nothing, this branch is invisible. // Add this branch f32 length = lengthScale * getFloatFromValueRange( branch->Length, Seed++ ); f32 radius = getFloatFromValueRange( branch->Radius, Seed++ ); f32 radiusEndScale = radiusScale * getFloatFromValueRange( branch->RadiusEnd, Seed++ ); f32 radiusEnd = radius * radiusEndScale; radius = radiusScale * radius; if ( level == 1 ) radiusEnd = 0; s32 radialSegments = (level*(RadialSegments-3))/Levels + 3; if ( level > CutoffLevel ) { BuildCylinder( buffer->Vertices, buffer->Indices, buffer->BoundingBox, length, radius, radiusEnd, radialSegments, transform ); } // Add children if ( level > 1 ) { core::list<SBranchChild>::Iterator it = branch->Children.begin(); while ( it != branch->Children.end() ) { SBranchChild* child = &(*it); it++; SBranch* childBranch = getBranchWithId( child->IdRef ); if ( childBranch == 0 ) continue; if ( !isValueInRange( level, child->LevelRange ) ) continue; s32 childLevel = level + getIntFromValueRange( child->RelativeLevel, Seed++ ); // RelativeLevel is usually negative, -1 in particular. s32 numChildren = getIntFromValueRange( child->Count, Seed++ ); f32 positionRange = child->Position.Max - child->Position.Min; positionRange /= (f32)numChildren; f32 orientation = getRandomFloat( Seed++, 0, 360.0f ); for ( s32 i=0; i<numChildren; i++ ) { f32 childLengthScale = lengthScale * getFloatFromValueRange( child->LengthScale, Seed++ ); orientation += getFloatFromValueRange( child->Orientation, Seed++ ); // Clamp value between 0 and 360. This is needed for gravity to work properly if ( orientation < 0.0f ) orientation += 360.0f; else if ( orientation > 360.0f ) orientation -= 360.0f; f32 childOrientation = orientation; f32 gravity = getFloatFromValueRange( child->GravityInfluence, Seed++ ); f32 childPitch = getFloatFromValueRange( child->Pitch, Seed++ ); f32 childPosition = getFloatFromValueRange( child->Position, Seed++ ); f32 position; if ( child->Position.IsValue ) position = child->Position.Value; else position = (child->Position.Min + positionRange * i + positionRange * getRandomFloat( Seed++, 0, 1 )); f32 childRadiusScale = (radiusScale*(1.0f-position) + radiusEndScale*position) * getFloatFromValueRange( child->RadiusScale, Seed++ ); // Build transformation matrix core::matrix4 mat; mat.setRotationDegrees( core::vector3df(childPitch, childOrientation, 0.0f) ); mat[13] = length * position; mat = transform * mat; if ( gravity != 0.0f ) { // Do some extra work core::vector3df vDown = core::vector3df( 0, -1, 0 ); core::vector3df vBranch = core::vector3df( 0, 1, 0 ); mat.rotateVect(vBranch); core::vector3df vSide; if ( fabs( vBranch.Y ) >= 0.9f ) { vSide = core::vector3df( 1, 0, 0 ); mat.rotateVect(vSide); } else { vSide = vBranch.crossProduct(vDown); vSide.normalize(); } vDown = vSide.crossProduct(vBranch); vDown.normalize(); setMatrixVec( mat, 0, vSide ); setMatrixVec( mat, 2, vDown ); f32 dot = -vBranch.Y; if ( gravity < 0.0f ) dot = -dot; f32 angle = acos( dot ); angle *= gravity; core::matrix4 mat2; mat2.setRotationRadians( core::vector3df( angle,0,0 ) ); mat = mat * mat2; } // Add the branch appendBranch( mat, childBranch, childLengthScale, childRadiusScale, childLevel, buffer, leaves ); } } } // Add leaves if ( AddLeaves ) { core::list<SLeaf>::Iterator lit = branch->Leaves.begin(); while ( lit != branch->Leaves.end() ) { SLeaf* leaf = &(*lit); lit++; if ( !isValueInRange( level, leaf->LevelRange ) ) continue; s32 count = getIntFromValueRange( leaf->Count, LeafSeed++ ); for ( s32 i=0; i<count; i++ ) { f32 width = getFloatFromValueRange( leaf->Width, LeafSeed++ ); f32 height = getFloatFromValueRange( leaf->Height, LeafSeed++ ); f32 scale = getFloatFromValueRange( leaf->Scale, LeafSeed++ ); f32 position = getFloatFromValueRange( leaf->Position, LeafSeed++ ); f32 roll = getFloatFromValueRange( leaf->Roll, LeafSeed++ ); f32 anchor = getFloatFromValueRange( leaf->Anchor, LeafSeed++ ); core::matrix4 mat; mat[13] = length * position; mat = transform * mat; STreeLeaf treeLeaf; treeLeaf.Position = mat.getTranslation(); treeLeaf.Color.setRed( getIntFromValueRange( leaf->Red, LeafSeed++ ) ); treeLeaf.Color.setGreen( getIntFromValueRange( leaf->Green, LeafSeed++ ) ); treeLeaf.Color.setBlue( getIntFromValueRange( leaf->Blue, LeafSeed++ ) ); treeLeaf.Color.setAlpha( getIntFromValueRange( leaf->Alpha, LeafSeed++ ) ); treeLeaf.Size = core::dimension2df(scale*width, scale*height); treeLeaf.Roll = roll; if ( leaf->HasAxis ) { treeLeaf.HasAxis = true; treeLeaf.Axis = leaf->Axis; treeLeaf.Position += leaf->Axis * height * scale * anchor / 2.0f; } else { treeLeaf.HasAxis = false; } leaves.push_back( treeLeaf ); } } } }
/** * CParticleEffect::initParticle * @date Modified June 01, 2006 */ void CParticleEffect::initParticle(CParticleManager::SParticle* pParticle, D3DXMATRIX* mOffset) { D3DXMATRIX mPosOffset, mOrientation = *mOffset; D3DXMatrixIdentity(&mPosOffset); mPosOffset._41 = mOffset->_41; mPosOffset._42 = mOffset->_42; mPosOffset._43 = mOffset->_43; mOrientation._41 = mOrientation._42 = mOrientation._43 = 0.0f; mOrientation._44 = 1.0f; float fMinVel, fMaxVel; D3DXVec3Normalize(&fMinVel, &m_vMinVelocity, &m_vMinVelocity); D3DXVec3Normalize(&fMaxVel, &m_vMaxVelocity, &m_vMaxVelocity); D3DXVec3TransformCoord(&m_vMinVelocityTrans, &m_vMinVelocity, &mOrientation); D3DXVec3TransformCoord(&m_vMaxVelocityTrans, &m_vMaxVelocity, &mOrientation); m_vMinVelocity *= fMinVel; m_vMaxVelocity *= fMaxVel; // Update attributes BYTE cR = GET_RED(pParticle->Color), cG = GET_GREEN(pParticle->Color), cB = GET_BLUE(pParticle->Color), cA = GET_ALPHA(pParticle->Color); for(size_t j = 0; j < m_vAttributes.size(); ++j) { float fScale = m_vAttributes[j]->getValue(0.0f); switch(m_vAttributes[j]->getType()) { case CParticleAttribute::ATR_COLORRED: cR = (BYTE)(fScale * 255.0f); break; case CParticleAttribute::ATR_COLORGREEN: cG = (BYTE)(fScale * 255.0f); break; case CParticleAttribute::ATR_COLORBLUE: cB = (BYTE)(fScale * 255.0f); break; case CParticleAttribute::ATR_COLORALPHA: cA = (BYTE)(fScale * 255.0f); break; case CParticleAttribute::ATR_SIZE: pParticle->Size = fScale; break; case CParticleAttribute::ATR_ROTATION: pParticle->Rotation = degreesToRadians(fScale); break; case CParticleAttribute::ATR_ACCELX: pParticle->Acceleration.x = fScale; break; case CParticleAttribute::ATR_ACCELY: pParticle->Acceleration.y = fScale; break; case CParticleAttribute::ATR_ACCELZ: pParticle->Acceleration.z = fScale; break; } } pParticle->Color = D3DCOLOR_ARGB(cA, cR, cG, cB); getRandomVector(&pParticle->Velocity, &m_vMinVelocityTrans, &m_vMaxVelocityTrans); pParticle->Velocity *= getRandomFloat(fMinVel, fMaxVel); m_vMinVelocityTrans *= fMinVel; m_vMaxVelocityTrans *= fMaxVel; D3DXVECTOR3 vMin(0.0f, 0.0f, 0.0f), vMax(0.0f, 0.0f, 0.0f); switch(m_eSpawnShape) { case SH_CUBE: vMin.x = -m_vSpawnRadius.x; vMin.y = -m_vSpawnRadius.y; vMin.z = -m_vSpawnRadius.z; getRandomVector(&pParticle->Position, &vMin, &m_vSpawnRadius); break; case SH_SQUARE: vMin.x = -m_vSpawnRadius.x; vMin.z = -m_vSpawnRadius.z; vMax.x = m_vSpawnRadius.x; vMax.z = m_vSpawnRadius.z; getRandomVector(&pParticle->Position, &vMin, &vMax); break; case SH_SPHERE: getRandomVector(&vMin, -1.0f, 1.0f); D3DXVec3Normalize(&vMin, &vMin); pParticle->Position.x = vMin.x * m_vSpawnRadius.x; pParticle->Position.y = vMin.y * m_vSpawnRadius.x; pParticle->Position.z = vMin.z * m_vSpawnRadius.x; break; case SH_CIRCLE: getRandomVector(&vMin, -1.0f, 1.0f); D3DXVec3Normalize(&vMin, &vMin); pParticle->Position.x = vMin.x * m_vSpawnRadius.x; pParticle->Position.y = 0.0f; pParticle->Position.z = vMin.z * m_vSpawnRadius.x; break; } D3DXVec3TransformCoord(&pParticle->Position, &pParticle->Position, &mPosOffset); }
inline s32 getRandomInt( s32 seed, s32 min, s32 max ) { return (s32)(getRandomFloat(seed,min,max) + 0.50f); }
void _drawDynamicLight(light *lght) { int x, y, penalty, r_tint, g_tint, b_tint; float distMod, alpha; character *player = getPlayer(); TCOD_map_t levelMap = getLevelMap(); if (!lght->lightMap) { return; } TCOD_map_clear(lght->lightMap, 0, 0); if (!lght->fuel) { return; } for (y = lght->y - 32; y < lght->y + 32; y++) { for (x = lght->x - 32; x < lght->x + 32; x++) { if (x < 0 || x >= WINDOW_WIDTH || y < 0 || y >= WINDOW_HEIGHT) { continue; } if (TCOD_map_is_in_fov(lght->fov, x, y)) { if (lght->fuel < lght->size) { penalty = lght->size - lght->fuel; } else { penalty = 0; } distMod = lght->size - (distanceFloat(lght->x, lght->y, x, y) + penalty); if (distMod <= 0) { TCOD_map_set_properties(lght->lightMap, x, y, 0, 0); } else { TCOD_map_set_properties(lght->lightMap, x, y, 1, 1); } if (isPositionWalkable(x, y)) { distMod -= getRandomFloat(0, lght->flickerRate); } if (distMod < 0) { distMod = 0; } else if (distMod > lght->size / 2) { distMod = lght->size / 2; } alpha = (distMod / (float) lght->size); alpha *= lght->sizeMod; if (lght->noTint) { r_tint = 1; g_tint = 1; b_tint = 1; } else { if (!TCOD_map_is_walkable(levelMap, x, y)) { r_tint = 55 + RED_SHIFT; g_tint = 55; b_tint = 55; if (alpha > .45) { alpha = .45; } } else { r_tint = lght->r_tint + RED_SHIFT; g_tint = lght->g_tint; b_tint = lght->b_tint; alpha = clipFloat(alpha, 0, lght->brightness); } } if (!player || TCOD_map_is_in_fov(player->fov, x, y)) { drawCharBackEx(DYNAMIC_LIGHT_CONSOLE, x, y, TCOD_color_RGB(r_tint, g_tint, b_tint), TCOD_BKGND_ADDALPHA(alpha)); } } } } }
void FaultInjector::start(float tMin, float tMax) { timer.attach(this, &FaultInjector::generateFaults, getRandomFloat(tMin, tMax)); }