void Picture::render(Pixel* px)
{
Color *ambient = new Color(1, 1, 1);
Vertex *eye = new Vertex(0,0,0);
Light *light = new Light();
double attenuation = 0;
//while(true)
//{
char* fileName = "sphere.txt";
//cout<<"calling read object"<<endl;
BasicObject* sphere = readObject(fileName);
sphere->computeSandT();
//sphere->printFaces();
//cout<<"called it bitches"<<endl;
//delete[] fileName; //mingw appears to delete this automatically
fileName = "trs.txt";
InstanceObject* sphereInstance = buildInstanceObject(fileName, sphere);
//delete[] fileName;
//obtaining the window transform
int widthPixels = px->getWidth(); //the dimensions of the panel on which the drawing will occur
int heightPixels = px->getHeight();
getShaderInfo(eye, ambient, light, &attenuation);
Scene* scene = new Scene(light, ambient);
scene->buildTransform(getCameraTransform("camera.txt"));
scene->buildTransform(getPerspectiveTransform("fov.txt", widthPixels, heightPixels));
scene->buildTransform(AffineTransforms::window(widthPixels, heightPixels));
TransformNode* tn = new TransformNode();
tn->addChild(sphereInstance);
scene->addTransformNode(tn);
//for(;;)
//{
scene->render(px, eye, attenuation);
//}
delete scene;
//}
}
cvec3f Flock::m_getNearVelVec(UNITS_VEC& a_units, cvec3f& a_vel, vec3f& nearVelVec)
{
if (a_units.size() == 0)
return ZERO_VEC;
vec3f vec = ZERO_VEC;
int i;
for (i = 0; i < a_units.size(); ++i)
{
BasicObject* pObj = a_units[i];
cvec3f objVel = pObj->m_getVel();
vec += objVel;
}
vec /= (float)(a_units.size());
nearVelVec = vec;
return vec;
}
// C: 2*v_vObjects.size() + C(A*(MAX_MAX_DIST_TO_LEADER)) + C(m_classifyObjects) + gluepath.size()
// or 3*v_vObjects.size() + C(m_classifyObjects)
void Group::m_makeConsistent()
{
if (0 == v_vObjects.size())
{
return;
}
// try to assign one object
// with class CLASS_GROUP_STEERED as leader
VEC_GROUP::iterator it = find_if(v_vObjects.begin(),
v_vObjects.end(),
equal_class(GroupObjDescr::CLASS_GROUP_STEERED));
if (v_vObjects.end() != it)
{
BasicObject* pObj = (*it).first;
v_pLeader = pObj;
// refine leader path
if (!v_vLeaderPath.empty())
{
PATHELEM prevLeaderPos = v_vLeaderPath.back();
PATHELEM newLeaderPos(pObj->m_getPosition(), 1);
vector<PATHELEM> vGluePath;
MovementManager::m_recomputePath(0,
prevLeaderPos,
newLeaderPos,
vGluePath);
v_vLeaderPath.insert(v_vLeaderPath.end(),
vGluePath.begin(),
vGluePath.end());
}
}
else
{
v_pLeader = v_vObjects[0].first;
v_vLeaderPath.erase(v_vLeaderPath.begin(), v_vLeaderPath.end());
}
}
cvec3f Flock::m_getNearMidVec(UNITS_VEC& a_units, cvec3f& a_vel, vec3f& nearMidVec)
{
if (a_units.size() == 0)
return ZERO_VEC;
cpt3f thisPos = v_pObj->m_getPos();
cfloat refSpeed = v_pObj->getRefSpeed();
float medDist = 0.f;
int i;
for (i = 0; i < a_units.size(); ++i)
{
BasicObject* pObj = a_units[i];
cpt3f objPos = pObj->m_getPos();
cfloat dist2Obj = dist(thisPos, objPos);
medDist += dist2Obj;
}
medDist /= a_units.size();
assert(medDist > 0.f);
vec3f vec = ZERO_VEC;
for (i = 0; i < a_units.size(); ++i)
{
BasicObject* pObj = a_units[i];
cpt3f objPos = pObj->m_getPos();
cfloat dist2Obj = dist(thisPos, objPos);
cvec3f vec2Obj = (objPos - thisPos).normalize();
vec += vec2Obj * ((dist2Obj - medDist) / medDist) * (refSpeed / 2.f);
}
nearMidVec = vec;
return vec;
}
void Group::m_nextStep()
{
BasicConfiguration* pConf = BasicConfiguration::m_getBasicConfiguration();
MapGrid* pGrid = pConf->m_getGridMap();
if (!m_isConsistent())
{
m_makeConsistent();
}
m_classifyObjects();
INT_COORDS leadStep = v_pLeader->m_nextStep();
VEC_GROUP vGroupSteered;
VEC_GROUP::iterator it;
for (it = v_vObjects.begin(); it != v_vObjects.end(); ++it)
{
GROUP_OBJ obj = *it;
BasicObject* pObj = obj.first;
GroupObjDescr objDescr = obj.second;
INT_COORDS pos = pObj->m_getPosition();
cout << "LEADER POS: " << v_pLeader->m_getPosition().first << " " << v_pLeader->m_getPosition().second << endl;
cout << "CLASS: " << objDescr.nClass << endl;
//if (objDescr.nClass == GroupObjDescr::UNCLASSIFIED)
{
// trivial case: no need to move
pObj->m_nextStep();
}
/*else if (objDescr.nClass == GroupObjDescr::CLASS_SELF_STEERED)
{
INT_COORDS target = pObj->m_getActualTarget();
if (INVALID_COORDS == target)
{
pObj->m_setActualTarget(
m_predictLeaderPos(
MovementManager::m_getDistance(pos, target, 1)),
true);
}
pObj->m_nextStep();
m_classifyObject(pObj);
}
else if (objDescr.nClass == GroupObjDescr::CLASS_PATH_NOT_GROUP_STEERED)
{
int nLPathIndex = objDescr.nLPathIndex;
if (UNDEFINED == nLPathIndex)
{
cerr << "UNDEFINED == nLPathIndex" << endl;
return;
}
int nPathDistance = MovementManager::m_getDistance(
pos, v_vLeaderPath[nLPathIndex].gridElem, 1);
if (nLPathIndex == v_vLeaderPath.size() - 1)
{
cerr << "nLPathIndex == v_vLeaderPath.size() - 1" << endl;
return;
}
vector<INT_COORDS> vPotentialElems2;
vector<INT_COORDS> vDiffs;
MovementManager::m_getDiffs(1, vDiffs);
bool bNextStepAssigned = false;
vector<INT_COORDS>::iterator itDiff;
for (itDiff = vDiffs.begin(); itDiff != vDiffs.end(); ++itDiff)
{
INT_COORDS diff = *itDiff;
INT_COORDS nextPos =
make_pair(pos.first + diff.first, pos.second + diff.second);
GridElement* pElem = const_cast<GridElement*>(pGrid->m_getGridElement(
nextPos));
if (pElem && !pElem->m_isCoveredByObject())
{
int nNextPathDistance = MovementManager::m_getDistance(
nextPos, v_vLeaderPath[nLPathIndex + 1].gridElem, 1);
if (nNextPathDistance <= nPathDistance)
{
// this grid element is OK
pObj->m_setNextStep(nextPos);
bNextStepAssigned = true;
break;
}
else
{
vPotentialElems2.push_back(nextPos);
}
}
}
if (!bNextStepAssigned)
{
if (vPotentialElems2.empty())
{
// stay on actual position
pObj->m_setNextStep(pos);
}
else
{
pObj->m_setNextStep(vPotentialElems2[0]);
}
}
m_classifyObject(pObj);
}
else if (objDescr.nClass == GroupObjDescr::CLASS_PARTLY_GROUP_STEERED)
{
vGroupSteered.push_back(obj);
}
else
{
// GroupObjDescr::CLASS_GROUP_STEERED
vGroupSteered.push_back(obj);
}*/
}
if (!vGroupSteered.empty())
{
vector<INT_COORDS> vDiffs;
for (int i = 1; i <= v_nMaxGroupDist + 1; ++i)
{
vector<INT_COORDS> vDiffsTmp;
MovementManager::m_getDiffs(i, vDiffsTmp);
vDiffs.insert(
vDiffs.end(),
vDiffsTmp.begin(),
vDiffsTmp.end());
}
vector<INT_COORDS> vDiffs1;
MovementManager::m_getDiffs(1, vDiffs1);
VEC_GROUP::iterator it;
for (it = vGroupSteered.begin(); it != vGroupSteered.end(); ++it)
{
GROUP_OBJ obj = *it;
BasicObject* pObj = obj.first;
GroupObjDescr objDescr = obj.second;
int nLPathIndex = objDescr.nLPathIndex;
INT_COORDS pos = pObj->m_getPosition();
int nLeadDistance = MovementManager::m_getDistance(
pos, v_pLeader->m_getPosition(), 1);
int nPathDistance = MovementManager::m_getDistance(
pos, v_vLeaderPath[nLPathIndex].gridElem, 1);
vector<BasicObject*> vNeighbObjs;
vector<INT_COORDS>::iterator itDiff;
for (itDiff = vDiffs.begin(); itDiff != vDiffs.end(); ++itDiff)
{
INT_COORDS diff = *itDiff;
INT_COORDS neighbPos =
make_pair(pos.first + diff.first, pos.second + diff.second);
GridElement* pElem = const_cast<GridElement*>(pGrid->m_getGridElement(
neighbPos));
if (pElem && pElem->m_isCoveredByObject())
{
// TODO: add constraint only group objects
vNeighbObjs.push_back(pElem->m_getCoveringObject());
}
}
vector<INT_COORDS> vPotentialElems2;
bool bNextStepAssigned = false;
vector<INT_COORDS>::iterator itDiff1;
for (itDiff1 = vDiffs1.begin(); itDiff1 != vDiffs1.end(); ++itDiff1)
{
INT_COORDS diff1 = *itDiff1;
INT_COORDS nextPos =
make_pair(pos.first + diff1.first, pos.second + diff1.second);
GridElement* pElem = const_cast<GridElement*>(pGrid->m_getGridElement(
nextPos));
if (pElem && pElem->m_isCoveredByObject())
{
// invalid element
continue;
}
int nNextLeadDistance = MovementManager::m_getDistance(
nextPos, v_pLeader->m_getPosition(), 1);
int nNextPathDistance = MovementManager::m_getDistance(
nextPos, v_vLeaderPath[nLPathIndex + 1].gridElem, 1);
bool bObjFoundAtLessMinGroupDist = false,
bObjFoundAtMostMaxGroupDist = false;
vector<BasicObject*>::iterator itObj;
for (itObj = vNeighbObjs.begin(); itObj != vNeighbObjs.end(); ++itObj)
{
BasicObject* pObj = *itObj;
int nDistance = MovementManager::m_getDistance(
nextPos, pObj->m_getPosition(), 1);
if (nDistance < v_nMinGroupDist)
{
// TODO: take into consider. only already moved group elems
bObjFoundAtLessMinGroupDist = true;
break;
}
if (nDistance <= v_nMaxGroupDist)
{
bObjFoundAtMostMaxGroupDist = true;
}
}
bool bValid = !bObjFoundAtLessMinGroupDist && bObjFoundAtMostMaxGroupDist;
if (bValid && 1 /**/)
{
//pObj->m_setNextStep(nextPos);
bNextStepAssigned = true;
break;
}
if (bValid)
{
vPotentialElems2.push_back(nextPos);
}
}
if (!bNextStepAssigned)
{
if (vPotentialElems2.empty())
{
// stay on actual position
pObj->m_setNextStep(pos);
}
else
{
pObj->m_setNextStep(vPotentialElems2[0]);
}
}
m_classifyObject(pObj);
}
}
cout << "SZ: " << v_vLeaderPath.size() << endl;
if (!(v_pLeader->m_isStandingStill()))
{
v_vLeaderPath.push_back(PATHELEM(leadStep, 1));
}
}
BasicObject* Picture::readObject(char* fileName)
{
BasicObject* obj = new BasicObject();
FileIO* file = new FileIO(fileName, ' '); //assumed to be a read if a delimiter is specified
List<Vertex> vertices;
double x, y, z;
string* token;
int index1, index2, index3, temp;
//parsing the complex index information for the triangular face
//could include a vertex index, a vertex normal index, and texture coord information
string* str1;
string* str2;
string* str3;
string str11;
string str22;
string str33;
string* v = new string("v");
string* f = new string("f");
while (!file->eof())
{
ListIterator<string>* iter = file->getTokens();
token = iter->next();
//all vertices are held in the vertices list so that the faces can be created
if (*token == *v) //vertices
{
delete token;
token = iter->next();
x = atof((*token).c_str());
delete token;
token = iter->next();
y = atof((*token).c_str());
delete token;
token = iter->next();
z = atof((*token).c_str());
delete token;
Vertex* vertex = new Vertex(x, y, z);
vertices.add(vertex);
obj->addVertex(vertex);
}
else if (*token == *f) //face definition
{
delete token;
//get the complex index information for the triangle face
str1 = iter->next();
str2 = iter->next();
str3 = iter->next();
//parse the index information for the vertex index
temp = str1->find("/");
str11 = str1->erase(temp, str1->size() - 1);
temp = str2->find("/");
str22 = str2->erase(temp, str2->size() - 1);
temp = str3->find("/");
str33 = str3->erase(temp, str3->size() - 1);
char* cp;
int len;
cp = new char[10];
len = str11.length();
str11.copy(cp, len, 0);
cp[len] = '\0';
index1 = atoi(cp);
delete[] cp;
cp = new char[10];
len = str22.length();
str22.copy(cp, len, 0);
cp[len] = '\0';
index2 = atoi(cp);
delete[] cp;
cp = new char[10];
len = str33.length();
str33.copy(cp, len, 0);
cp[len] = '\0';
index3 = atoi(cp);
delete[] cp;
Face* face = new Face();
Vertex* vertex1 = vertices.get(index1);
Vertex* vertex2 = vertices.get(index2);
Vertex* vertex3 = vertices.get(index3);
face->addVertex(vertex1);
face->addVertex(vertex2);
face->addVertex(vertex3);
obj->addFace(face);
delete str1;
delete str2;
delete str3;
}
//still need to delete the tokens even if the line is completely disregarded
else
{
delete token;
while(iter->hasNext())
{
token = iter->next();
delete token;
}
}
delete iter;
}
delete v;
delete f;
delete file;
return obj;
}
void ConfigurationWriter::m_genGameObjects(vector<BasicObject*>& a_rvObjs /* out */, uint& a_numObjs /* out */)
{
srand(time(0));
BasicConfiguration* pConf = BasicConfiguration::m_getBasicConfiguration();
MapGrid* pGrid = pConf->m_getGridMap();
GameView* pView = pConf->m_getGameViewByUserId(DEFAULT_USER_ID);
const uint nCellsX = (uint)(pGrid->m_getNumCellX());
const uint nCellsY = (uint)(pGrid->m_getNumCellY());
assert(nCellsX > 0 && nCellsY > 0);
const uint cellSizeX = (uint)(pGrid->m_getGridElementSizeX());
const uint cellSizeY = (uint)(pGrid->m_getGridElementSizeY());
assert(cellSizeX > 0 && cellSizeY > 0);
RECTANGLE rect = pGrid->m_getGameRectangle();
uint rngX = (uint)(rect.drVertex.first - rect.ulVertex.first) * 4;
uint rngY = (uint)(rect.drVertex.second - rect.ulVertex.second) * 4;
const uint numGenObjs = (nCellsX * nCellsY) / 10;
if (0 == numGenObjs)
return;
const uint numGenUnits = (uint)((2.f * numGenObjs) / 3.f);
const uint numGenTanks = (uint)(numGenObjs / 6.f);
const uint numGenBuildings = numGenObjs - numGenUnits - numGenTanks;
// UNITS :
uint numUnitsAccepted = 0;
int i;
for (i = 0; i < numGenUnits * 2; ++i)
{
pt3f genPos = pt3f(rngX * ranf(), rngY * ranf(), 0.f);
if (posOutsideGrid(genPos)) continue;
const uint assign = (numUnitsAccepted % 2 == 0) ? 0 : 1;
BasicObject* pObj = new BasicObject(genPos, (assign == 0) ? G_UNIT_TXT_ID : G_ENEMY_UNIT_TXT_ID, 1.f, 1.f, assign);
Obstacle obs = pObj->m_getObstacle();
bool isColliding = false;
int j;
for (j = 0; j < a_rvObjs.size(); ++j)
{
Obstacle aObs = a_rvObjs[j]->m_getObstacle();
if (Obstacle::isColliding(obs, aObs))
{
isColliding = true;
break;
}
}
if (isColliding) continue;
a_rvObjs.push_back(pObj);
numUnitsAccepted++;
if (numUnitsAccepted == numGenUnits)
break;
}
// TANKS :
uint numTanksAccepted = 0;
for (i = 0; i < numGenTanks * 2; ++i)
{
pt3f genPos = pt3f(rngX * ranf(), rngY * ranf(), 0.f);
if (posOutsideGrid(genPos)) continue;
const uint assign = (numTanksAccepted % 2 == 0) ? 0 : 1;
BasicObject* pObj = new BasicObject(genPos, (assign == 0) ? G_TANK_TXT_ID : G_ENEMY_TANK_TXT_ID, 2.f, 2.f, (numTanksAccepted % 2 == 0) ? 0 : 1);
Obstacle obs = pObj->m_getObstacle();
bool isColliding = false;
int j;
for (j = 0; j < a_rvObjs.size(); ++j)
{
Obstacle aObs = a_rvObjs[j]->m_getObstacle();
if (Obstacle::isColliding(obs, aObs))
{
isColliding = true;
break;
}
}
if (isColliding) continue;
a_rvObjs.push_back(pObj);
numTanksAccepted++;
if (numTanksAccepted == numGenTanks)
break;
}
// BUILDINGS (common) :
uint numBuildingsAccepted = 0;
for (i = 0; i < numGenBuildings * 2; ++i)
{
pt3f genPos = pt3f(rngX * ranf(), rngY * ranf(), 0.f);
if (posOutsideGrid(genPos)) continue;
BasicObject* pObj = new BasicObject(genPos, G_HOUSE_TXT_ID, 3.f, 2.f, (numBuildingsAccepted % 2 == 0) ? 0 : 1);
Obstacle obs = pObj->m_getObstacle();
bool isColliding = false;
int j;
for (j = 0; j < a_rvObjs.size(); ++j)
{
Obstacle aObs = a_rvObjs[j]->m_getObstacle();
if (Obstacle::isColliding(obs, aObs))
{
isColliding = true;
break;
}
}
if (isColliding) continue;
a_rvObjs.push_back(pObj);
numBuildingsAccepted++;
if (numBuildingsAccepted == numGenBuildings)
break;
}
#ifdef __TRACE_ME
cout << "numUnitsAccepted:: " << numUnitsAccepted << endl;
cout << "numTanksAccepted:: " << numTanksAccepted << endl;
cout << "numBuildingsAccepted::" << numBuildingsAccepted << endl << endl;
#endif
a_numObjs = numUnitsAccepted + numTanksAccepted + numBuildingsAccepted;
return;
}
