Bar::Bar(int i, int j, int xSize, int zSize) {
this->i = i;
this->j = j;
barPos = Vector3(i, 0, j);
barkeepTile = Vector3(i + 1, 0 , j + 1);
for (int index = i; index < i + xSize; index++) {
for (int index2 = j; index2 < j + zSize; index2++) {
if (index == i) {
patronTiles.push_back(Vector3(index - 1, 0, index2));
}
if (index2 == j) {
patronTiles.push_back(Vector3(index, 0, index2 - 1));
}
if (index == i + xSize -1) {
patronTiles.push_back(Vector3(index + 1, 0, index2));
}
if (index2 == j + zSize - 1) {
patronTiles.push_back(Vector3(index, 0, index2 + 1));
}
MapTile *barTile = GameData::getInstance()->getGameMap()->getMapTile(index, index2);
barTile->setPrimitive(new ScenePrimitive(ScenePrimitive::TYPE_BOX, 5, 8, 5), "WoodMaterial", 6, true);
}
}
for (int index = i + 1; index < i - 1 + xSize; index++) {
for (int index2 = j + 1; index2 < j - 1 + zSize; index2++) {
MapTile *barTile = GameData::getInstance()->getGameMap()->getMapTile(index, index2);
barTile->removeObject(index, index2);
}
}
MapTile * temp = GameData::getInstance()->getGameMap()->getMapTile(i + xSize - 2, j + 1);
temp->setObject("barrel_03.mesh", "BitgemMaterial", 4, true);
temp->getObject()->setScale(0.1, 0.1, 0.1);
SceneMesh *object = new SceneMesh("barrel_01.mesh");
object->depthTest = true;
object->depthWrite = true;
object->setPosition(i*5, 4.5, j*5);
object->setMaterialByName("BitgemMaterial");
object->setScale(0.06, 0.06, 0.06);
GameData::getInstance()->getScene3D()->addChild(object);
/*ScenePrimitive *objectShadow;
objectShadow = new ScenePrimitive(ScenePrimitive::TYPE_CIRCLE, 5, 5, 20);
objectShadow->setPitch(-90);
objectShadow->depthTest = true;
objectShadow->depthWrite = true;
objectShadow->setPosition(i*5, 6, i*5);
objectShadow->setMaterialByName("SolidMaterial");
objectShadow->setColor(1, 1, 1, 0.3);
GameData::getInstance()->getScene3D()->addChild(objectShadow);
*/
TavernResources::getInstance()->barList.push_back(this);
}
HelloPolycodeApp::HelloPolycodeApp(PolycodeView *view) : EventHandler() {
#ifdef __APPLE__
core = new CocoaCore(view, 640,480,false,0,90);
#else
core = new SDLCore(view, 640,480,false,0,90);
#endif
CoreServices::getInstance()->getResourceManager()->addArchive("Resources/default.pak");
CoreServices::getInstance()->getResourceManager()->addDirResource("default", false);
CoreServices::getInstance()->getRenderer()->setTextureFilteringMode(Renderer::TEX_FILTERING_NEAREST);
Scene *scene = new Scene();
SceneMesh *mesh = new SceneMesh("Resources/ninja.mesh");
mesh->loadTexture("Resources/ninja.png");
scene->addEntity(mesh);
mesh->loadSkeleton("Resources/ninja.skeleton");
mesh->getSkeleton()->addAnimation("Run", "Resources/run.anim");
mesh->getSkeleton()->playAnimation("Run");
scene->getDefaultCamera()->setPosition(25,25,25);
scene->getDefaultCamera()->lookAt(Vector3(0,0,0));
}
void Particle::createSceneParticle(int particleType, Material *material, Mesh *particleMesh) {
switch(particleType) {
case BILLBOARD_PARTICLE:
{
if(!billboardMesh) {
billboardMesh = new Mesh(Mesh::QUAD_MESH);
Polygon *imagePolygon = new Polygon();
imagePolygon->addVertex(0,1,0,0,0);
imagePolygon->addVertex(1,1,0, 1, 0);
imagePolygon->addVertex(1,0,0, 1, 1);
imagePolygon->addVertex(0,0,0,0,1);
billboardMesh->addPolygon(imagePolygon);
for(int i=0; i < billboardMesh->getPolygonCount(); i++) {
for(int j=0; j < billboardMesh->getPolygon(i)->getVertexCount(); j++) {
billboardMesh->getPolygon(i)->getVertex(j)->x = billboardMesh->getPolygon(i)->getVertex(j)->x - (1.0/2.0f);
billboardMesh->getPolygon(i)->getVertex(j)->z = billboardMesh->getPolygon(i)->getVertex(j)->z - (1.0/2.0f);
}
}
billboardMesh->calculateNormals();
billboardMesh->arrayDirtyMap[RenderDataArray::VERTEX_DATA_ARRAY] = true;
billboardMesh->arrayDirtyMap[RenderDataArray::COLOR_DATA_ARRAY] = true;
billboardMesh->arrayDirtyMap[RenderDataArray::TEXCOORD_DATA_ARRAY] = true;
billboardMesh->arrayDirtyMap[RenderDataArray::NORMAL_DATA_ARRAY] = true;
}
SceneMesh *primitive = new SceneMesh(billboardMesh);
primitive->setMaterial(material);
primitive->billboardMode = true;
primitive->billboardRoll = true;
// primitive->alphaTest = true;
// primitive->depthTest = false;
primitive->depthWrite = false;
primitive->backfaceCulled = false;
particleBody = primitive;
}
break;
case MESH_PARTICLE:
{
SceneMesh *primitive = new SceneMesh(particleMesh);
if(particleMesh->getMeshType() == Mesh::TRI_MESH)
primitive->cacheToVertexBuffer(true);
primitive->setMaterial(material);
// primitive->billboardMode = true;
// primitive->billboardRoll = true;
//primitive->depthTest = false;
// primitive->backfaceCulled = false;
particleBody = primitive;
}
break;
default:
assert(0);
break;
}
}
bool Skybox::Load(File* f)
{
// Get mesh filename.
std::string meshFilename;
if (!f->GetDataLine(&meshFilename))
{
f->ReportError("Expected mesh file name for skybox");
return false;
}
// Obj mesh comes last, as mesh file name is appended to data file contents when we upload
ObjMesh* mesh = (ObjMesh*)TheResourceManager::Instance()->GetRes(meshFilename);
if (!mesh)
{
return false;
}
Assert(mesh);
// TODO Collision mesh not reqd
SceneMesh* sm = new SceneMesh;
sm->SetMesh(mesh);
sm->SetIsLit(false);
// sm->CalcCollisionMesh();
// sm->GetCollisionMesh()->CalcAABB(&m_aabb);
static const float S = 1000.0f; // box size - but not critical
m_aabb.Set(-S, S, -S, S, -S, S);
sm->SetAABB(m_aabb);
SetSceneNode(sm);
#ifdef _DEBUG
std::cout << "Got AABB for " << *this << " size: " << m_aabb.GetXSize() << " " << m_aabb.GetYSize() << " " << m_aabb.GetZSize() << "\n";
#endif
return true;
/*
if (!GameObject::Load(f))
{
return false;
}
m_mesh = LoadMeshResource(f);
Assert(m_mesh);
SceneMesh* sm = new SceneMesh;
sm->SetMesh(m_mesh);
m_sceneNode = sm;
GetVe1SceneGraph()->SetRootNode(SceneGraph::AMJU_SKYBOX, m_sceneNode);
return true;
*/
}
//--------------------------------------------------------------------------------------
// Handle updates to the scene. This is called regardless of which D3D API is used
//--------------------------------------------------------------------------------------
void CALLBACK OnFrameMove(double fTime, float fElapsedTime, void* pUserContext)
{
SceneMesh *pSceneMesh = g_Scenes[g_CurrentSceneId].pMesh;
g_UseOrbitalCamera = pSceneMesh && pSceneMesh->UseOrbitalCamera();
if (g_UseOrbitalCamera)
{
g_OrbitalCamera.FrameMove(fElapsedTime);
}
else
{
g_FirstPersonCamera.FrameMove(fElapsedTime);
}
}
void EntityEditorPropertyView::updateShaderOptions() {
SceneMesh *sceneMesh = dynamic_cast<SceneMesh*>(targetEntity);
SceneLabel *sceneLabel = dynamic_cast<SceneLabel*>(targetEntity);
SceneSprite *sceneSprite = dynamic_cast<SceneSprite*>(targetEntity);
shaderTexturesSheet->enabled = false;
shaderOptionsSheet->enabled = false;
if(sceneMesh) {
if(sceneMesh->getMaterial() && sceneMesh->getLocalShaderOptions()) {
// can't edit the textures manually on a scene label or sprite
if(!sceneLabel && !sceneSprite) {
shaderTexturesSheet->setShader(sceneMesh->getMaterial()->getShader(0), sceneMesh->getMaterial(), sceneMesh->getLocalShaderOptions());
shaderTexturesSheet->enabled = true;
}
shaderOptionsSheet->setShader(sceneMesh->getMaterial()->getShader(0), sceneMesh->getMaterial(), sceneMesh->getLocalShaderOptions());
}
}
}
btCollisionShape *CollisionEntity::createCollisionShape(Entity *entity, int type) {
btCollisionShape *collisionShape = NULL;
Vector3 scale = entity->getCompoundScale();
Vector3 bBox = entity->getLocalBoundingBox() * scale;
Number largestSize = bBox.x;
if(bBox.y > largestSize) {
largestSize = bBox.y;
}
if(bBox.z > largestSize) {
largestSize = bBox.z;
}
switch(type) {
case SHAPE_CAPSULE:
case CHARACTER_CONTROLLER:
collisionShape = new btCapsuleShape(bBox.x/2.0f, bBox.y/2.0f);
break;
case SHAPE_CONE: {
Number largest = bBox.x;
if(bBox.z > largest) {
largest = bBox.z;
}
collisionShape = new btConeShape(largest/2.0f, bBox.y);
}
break;
case SHAPE_CYLINDER:
{
collisionShape = new btCylinderShape(btVector3(bBox.x/2.0, bBox.y/2.0f,bBox.z/2.0));
}
break;
case SHAPE_PLANE:
collisionShape = new btBoxShape(btVector3(bBox.x/2.0f, 0.05,bBox.z/2.0f));
break;
case SHAPE_BOX:
collisionShape = new btBoxShape(btVector3(bBox.x/2.0f, bBox.y/2.0f,bBox.z/2.0f));
break;
case SHAPE_SPHERE:
collisionShape = new btSphereShape(largestSize/2.0f);
break;
case SHAPE_MESH:
{
SceneMesh* sceneMesh = dynamic_cast<SceneMesh*>(entity);
if(sceneMesh != NULL) {
btConvexHullShape *hullShape = new btConvexHullShape();
Mesh *mesh = sceneMesh->getMesh();
for(int i=0; i < mesh->getVertexCount(); i++) {
hullShape->addPoint(btVector3((btScalar)mesh->getVertex(i)->x, (btScalar)mesh->getVertex(i)->y,(btScalar)mesh->getVertex(i)->z));
}
collisionShape = hullShape;
} else {
Logger::log("Tried to make a mesh collision object from a non-mesh\n");
collisionShape = new btBoxShape(btVector3(bBox.x/2.0f, bBox.y/2.0f,bBox.z/2.0f));
}
}
break;
}
// collisionShape->setLocalScaling(btVector3(scale.x, scale.y, scale.z));
return collisionShape;
}
btCollisionShape *CollisionSceneEntity::createCollisionShape(SceneEntity *entity, int type) {
btCollisionShape *collisionShape = NULL;
Vector3 entityScale = entity->getScale();
Number largestScale = entityScale.x;
if(entityScale.y > largestScale)
largestScale = entityScale.y;
if(entityScale.z > largestScale)
largestScale = entityScale.z;
switch(type) {
case SHAPE_CAPSULE:
case CHARACTER_CONTROLLER:
collisionShape = new btCapsuleShape(entity->bBox.x/2.0f, entity->bBox.y/2.0f);
break;
case SHAPE_CONE: {
Number largest = entity->bBox.x;
if(entity->bBox.z > largest) {
largest = entity->bBox.z;
}
collisionShape = new btConeShape(largest/2.0f, entity->bBox.y);
}
break;
case SHAPE_CYLINDER:
{
collisionShape = new btCylinderShape(btVector3(entity->bBox.x/2.0, entity->bBox.y/2.0f,entity->bBox.z/2.0));
}
break;
case SHAPE_PLANE:
collisionShape = new btBoxShape(btVector3(entity->bBox.x/2.0f, 0.05,entity->bBox.z/2.0f));
break;
case SHAPE_BOX:
collisionShape = new btBoxShape(btVector3(entity->bBox.x/2.0f*entityScale.x, entity->bBox.y/2.0f*entityScale.y,entity->bBox.z/2.0f*entityScale.z));
break;
case SHAPE_SPHERE:
collisionShape = new btSphereShape(entity->bBox.x/2.0f*largestScale);
break;
case SHAPE_MESH:
{
SceneMesh* sceneMesh = dynamic_cast<SceneMesh*>(entity);
if(sceneMesh != NULL) {
btConvexHullShape *hullShape = new btConvexHullShape();
for(int i=0; i < sceneMesh->getMesh()->getPolygonCount(); i++) {
Polygon *poly = sceneMesh->getMesh()->getPolygon(i);
for(int j=0; j < poly->getVertexCount(); j++) {
hullShape->addPoint(btVector3((btScalar)poly->getVertex(j)->x, (btScalar)poly->getVertex(j)->y,(btScalar)poly->getVertex(j)->z));
}
}
collisionShape = hullShape;
} else {
Logger::log("Tried to make a mesh collision object from a non-mesh\n");
collisionShape = new btBoxShape(btVector3(entity->bBox.x/2.0f, entity->bBox.y/2.0f,entity->bBox.z/2.0f));
}
}
break;
}
return collisionShape;
}
void Scene::saveScene(const String& fileName) {
OSFILE *outFile = OSBasics::open(fileName.c_str(), "wb");
if(!outFile) {
Logger::log("Error opening scene file for writing\n");
return;
}
// geometry
unsigned int totalObjects = staticGeometry.size() + lights.size() + collisionGeometry.size() + customEntities.size();
unsigned int objType;
char flag = 0;
if(hasLightmaps)
flag = 1;
OSBasics::write(&flag, 1, 1, outFile);
OSBasics::write(&totalObjects, sizeof(unsigned int), 1, outFile);
unsigned int stLen;
for(int i=0; i <staticGeometry.size(); i++) {
SceneMesh *mesh = staticGeometry[i];
writeEntityMatrix(mesh, outFile);
objType = Scene::ENTITY_MESH;
OSBasics::write(&objType, sizeof(unsigned int), 1, outFile);
if(hasLightmaps) {
unsigned int lightmapIndex = mesh->lightmapIndex;
OSBasics::write(&lightmapIndex, sizeof(unsigned int), 1, outFile);
}
stLen = mesh->getMaterial()->getName().length();
OSBasics::write(&stLen, sizeof(unsigned int), 1, outFile);
OSBasics::write(mesh->getMaterial()->getName().c_str(), 1, stLen, outFile);
mesh->getMesh()->saveToFile(outFile);
}
/*
for(int i=0; i < collisionGeometry.size(); i++) {
SceneMesh *mesh = collisionGeometry[i];
writeEntityMatrix(mesh, outFile);
objType = Scene::ENTITY_COLLMESH;
OSBasics::write(&objType, sizeof(unsigned int), 1, outFile);
unsigned int collType = 1;
OSBasics::write(&collType, sizeof(unsigned int), 1, outFile);
unsigned int numVertices = mesh->getMesh()->getNumVertices();
OSBasics::write(&numVertices, sizeof(unsigned int), 1, outFile);
Number pos[3];
for(int j=0; j < numVertices; j++) {
Vertex *vert = mesh->getMesh()->getVertex(j);
pos[0] = vert->x;
pos[1] = vert->y;
pos[2] = vert->z;
OSBasics::write(pos, sizeof(Number),3, outFile);
}
unsigned int numFaces = mesh->getMesh()->getPolygonCount();
OSBasics::write(&numFaces, sizeof(unsigned int), 1, outFile);
unsigned int ind[3];
for(int j=0; j < numFaces; j++) {
Polygon *poly = mesh->getMesh()->getPolygon(j);
ind[0] = mesh->getMesh()->getVertexIndex(poly->getVertex(0));
ind[1] = mesh->getMesh()->getVertexIndex(poly->getVertex(1));
ind[2] = mesh->getMesh()->getVertexIndex(poly->getVertex(2));
OSBasics::write(ind, sizeof(unsigned int),3, outFile);
}
}
*/
/*
Number col[3],e,d;
for(int i=0; i < lights.size(); i++) {
writeEntityMatrix(lights[i], outFile);
objType = Scene::ENTITY_LIGHT;
OSBasics::write(&objType, sizeof(unsigned int), 1, outFile);
col[0] = lights[i]->lightColor.r;
col[1] = lights[i]->lightColor.g;
col[2] = lights[i]->lightColor.b;
e = lights[i]->getIntensity();
d = lights[i]->getDistance();
OSBasics::write(&e, sizeof(Number), 1, outFile);
OSBasics::write(&d, sizeof(Number), 1, outFile);
OSBasics::write(col, sizeof(Number), 3, outFile);
}
*/
for(int i=0; i < customEntities.size(); i++) {
SceneEntity *custEnt = customEntities[i];
writeEntityMatrix(custEnt, outFile);
objType = Scene::ENTITY_ENTITY;
OSBasics::write(&objType, sizeof(unsigned int), 1, outFile);
writeString(custEnt->custEntityType, outFile);
unsigned int numProps = custEnt->entityProps.size();
OSBasics::write(&numProps, sizeof(unsigned int), 1, outFile);
for(int j=0; j < numProps; j++) {
writeString(custEnt->entityProps[j].propName, outFile);
writeString(custEnt->entityProps[j].propValue, outFile);
}
}
if(!hasLightmaps) {
OSBasics::close(outFile);
return;
}
/*
unsigned int lmsize;
lmsize = packer->images.size();
OSBasics::write(&lmsize, sizeof(unsigned int), 1, outFile);
for(int i=0; i < packer->images.size(); i++) {
lmsize = packer->images[i]->getWidth();
OSBasics::write(&lmsize, sizeof(unsigned int), 1, outFile);
lmsize = packer->images[i]->getHeight();
OSBasics::write(&lmsize, sizeof(unsigned int), 1, outFile);
lmsize = packer->images[i]->getWidth() * packer->images[i]->getHeight() * 4;
OSBasics::write(&lmsize, sizeof(unsigned int), 1, outFile);
OSBasics::write(packer->images[i]->getPixels(), 1, lmsize, outFile);
}
*/
OSBasics::close(outFile);
}
void Scene::loadScene(const String& fileName) {
OSFILE *inFile = OSBasics::open(fileName.c_str(), "rb");
if(!inFile) {
Logger::log("Error opening scene file\n");
return;
}
Number r,g,b,a;
OSBasics::read(&r, sizeof(Number), 1, inFile);
OSBasics::read(&g, sizeof(Number), 1, inFile);
OSBasics::read(&b, sizeof(Number), 1, inFile);
clearColor.setColor(r,g,b,1.0f);
OSBasics::read(&r, sizeof(Number), 1, inFile);
OSBasics::read(&g, sizeof(Number), 1, inFile);
OSBasics::read(&b, sizeof(Number), 1, inFile);
ambientColor.setColor(r,g,b,1.0f);
unsigned int numObjects, objectType,namelen;
char buffer[1024];
char flag;
Number t[3],rq[4];
SceneEntity *newEntity;
unsigned int lightmapIndex = 0;
OSBasics::read(&flag, 1, 1, inFile);
hasLightmaps = false;
if(flag == 1)
hasLightmaps = true;
OSBasics::read(&numObjects, sizeof(unsigned int), 1, inFile);
Logger::log("Loading scene (%d objects)\n", numObjects);
for(int i=0; i < numObjects; i++) {
OSBasics::read(t, sizeof(Number), 3, inFile);
OSBasics::read(rq, sizeof(Number), 4, inFile);
newEntity = NULL;
OSBasics::read(&objectType, sizeof(unsigned int), 1, inFile);
SceneMesh *newSceneMesh;
Mesh *newMesh;
Material *newMaterial;
switch(objectType) {
case ENTITY_MESH:
if(hasLightmaps) {
OSBasics::read(&lightmapIndex, sizeof(unsigned int), 1, inFile);
} else {
lightmapIndex = 0;
}
OSBasics::read(&namelen, sizeof(unsigned int), 1, inFile);
memset(buffer, 0, 1024);
OSBasics::read(buffer, 1, namelen, inFile);
Logger::log("adding mesh (texture: %s)\n", buffer);
OSBasics::read(&r, sizeof(Number), 1, inFile);
OSBasics::read(&g, sizeof(Number), 1, inFile);
OSBasics::read(&b, sizeof(Number), 1, inFile);
OSBasics::read(&a, sizeof(Number), 1, inFile);
newMaterial = (Material*) CoreServices::getInstance()->getResourceManager()->getResource(Resource::RESOURCE_MATERIAL, buffer);
newMesh = new Mesh(Mesh::TRI_MESH);
newMesh->loadFromFile(inFile);
newSceneMesh = new SceneMesh(newMesh);
newSceneMesh->setColor(r,g,b,a);
newSceneMesh->lightmapIndex = lightmapIndex;
addEntity(newSceneMesh);
newEntity = (SceneEntity*)newSceneMesh;
staticGeometry.push_back(newSceneMesh);
if(newMaterial != NULL)
newSceneMesh->setMaterial(newMaterial);
break;
case ENTITY_ENTITY: {
Logger::log("loading entity\n");
String entityType = readString(inFile);
SceneEntity *newCustomEntity = new SceneEntity();
newCustomEntity->custEntityType = entityType;
newEntity = newCustomEntity;
customEntities.push_back(newCustomEntity);
} break;
case ENTITY_COLLMESH: {
/*
unsigned int collType,numVertices,numFaces;
Number co[3];
OSBasics::read(&collType, sizeof(unsigned int), 1, inFile);
OSBasics::read(&numVertices, sizeof(unsigned int), 1, inFile);
Mesh *mesh = new Mesh(Mesh::TRI_MESH);
for(int i=0; i < numVertices; i++) {
OSBasics::read(co, sizeof(Number), 3, inFile);
Vertex *newVert = new Vertex(co[0], co[1], co[2]);
mesh->addVertex(newVert);
}
OSBasics::read(&numFaces, sizeof(unsigned int), 1, inFile);
unsigned int fo[3];
for(int i=0; i < numFaces; i++) {
OSBasics::read(fo, sizeof(unsigned int), 3, inFile);
Polygon *newPoly = new Polygon();
newPoly->addVertex(mesh->getVertex(fo[0]));
newPoly->addVertex(mesh->getVertex(fo[1]));
newPoly->addVertex(mesh->getVertex(fo[2]));
mesh->addPolygon(newPoly);
}
SceneMesh *newMesh = new SceneMesh(mesh);
newEntity = newMesh;
loadCollisionChild(newEntity);
collisionGeometry.push_back(newMesh);
newMesh->visible = false;
// ScenePrimitive *test = new ScenePrimitive(ScenePrimitive::TYPE_BOX, newMesh->bBox.x,newMesh->bBox.y,newMesh->bBox.z);
// newMesh->addEntity(test);
*/
}
break;
case ENTITY_CAMERA:
newEntity = (SceneEntity*)this->getDefaultCamera();
break;
case ENTITY_LIGHT:
/*
Number col[3],e,d;
unsigned int lType;
OSBasics::read(&lType, sizeof(unsigned int), 1, inFile);
OSBasics::read(&e, sizeof(Number), 1, inFile);
OSBasics::read(&d, sizeof(Number), 1, inFile);
OSBasics::read(col, sizeof(Number), 3, inFile);
SceneLight *newLight = new SceneLight(lType, e, d, this);
newLight->lightColor.setColor(col[0],col[1],col[2],1.0f);
addLight(newLight);
newEntity = (SceneEntity*)newLight;
*/
break;
}
if(newEntity != NULL) {
unsigned int numProps;
OSBasics::read(&numProps, sizeof(unsigned int), 1, inFile);
for(int i=0; i < numProps; i++) {
String propName,propValue;
propName = readString(inFile);
propValue = readString(inFile);
EntityProp prop;
prop.propName = propName;
prop.propValue = propValue;
newEntity->entityProps.push_back(prop);
}
if(objectType == ENTITY_MESH) {
if(newEntity->getEntityProp("vertexnormals") == "false")
((SceneMesh*)newEntity)->getMesh()->useVertexNormals(false);
if(newEntity->getEntityProp("collision") != "") {
if(newEntity->getEntityProp("collision") == "mesh") {
loadCollisionChild(newEntity, false, 3);
}
}
}
newEntity->setPosition(t[0], t[1], t[2]);
newEntity->setRotationQuat(rq[0], rq[1], rq[2], rq[3]);
newEntity->rebuildTransformMatrix();
}
}
if(!hasLightmaps) {
OSBasics::close(inFile);
return;
}
/*
unsigned int lmsize,numLightmaps,imageWidth, imageHeight;
OSBasics::read(&numLightmaps, sizeof(unsigned int), 1, inFile);
packer = new LightmapPacker(this);
char *imageData;
for(int i=0 ; i < numLightmaps; i++) {
OSBasics::read(&imageWidth, sizeof(unsigned int), 1, inFile);
OSBasics::read(&imageHeight, sizeof(unsigned int), 1, inFile);
OSBasics::read(&lmsize, sizeof(unsigned int), 1, inFile);
imageData = (char*)malloc(lmsize);
OSBasics::read(imageData, 1, lmsize, inFile);
Image *newImage = new Image(imageData, imageWidth, imageHeight);
packer->images.push_back(newImage);
free(imageData);
}
packer->bindTextures();
*/
OSBasics::close(inFile);
}
void Background::Setup(CollisionScene * scene)
{
pScene = scene;
std::vector<ScenePrimitive*> boxs;
for (int star = 0; star < 4000; star++) //Main Star field
{
SceneMesh *dot;
SceneMesh *dotSide;
dot = new SceneMesh(Mesh::POINT_MESH);
dot->getMesh()->addVertex(0, 0, 0);
dotSide = new SceneMesh(Mesh::POINT_MESH);
dotSide->getMesh()->addVertex(0, 0, 0);
dot->setPosition(Vector3(Random::Number(-1200, 1200), Random::Number(-100, 100), -1));
pScene->addChild(dot);
if (dot->getPosition().x > 1050)
{
dotSide->setPosition(dot->getPosition().x - 1600, dot->getPosition().y, -1);
//pScene->addChild(dotSide);
}
else if (dot->getPosition().x < -1050)
{
dotSide->setPosition(dot->getPosition().x + 1600, dot->getPosition().y, -1);
//pScene->addChild(dotSide);
}
}
}
