void OutXmlSerializer::popStructure()
{
ZENIC_ASSERT(!(m_current->value()).compare("struct"));
ZENIC_ASSERT(m_stack.count());
m_current = m_stack[m_stack.count()-1];
m_stack.popBack();
}
bool OutXmlSerializer::save(Stream& stream)
{
XmlDocument doc;
XmlDeclaration* decl = zenic_new XmlDeclaration;
decl->setValue("xml");
decl->setAttribute("version","1.0");
decl->setAttribute("encoding","ISO-8859-1");
doc.addChild(decl);
XmlComment* comment = new XmlComment;
comment->setValue(" Cell XML Object Graph ");
doc.addChild(comment);
// add initial objects
for (uint i = 0, n = count(); i < n; ++i)
{
Serializable* initial = (*this)[i];
uint j,m;
for (j = 0, m = m_objects.count(); j < m; ++j)
{
if (m_objects[j] == initial)
break;
}
if (j == m_objects.count())
m_objects.pushBack(initial);
}
// build xml tree
XmlElement* root = new XmlElement;
root->setValue("zenic");
for (uint i = 0; i < m_objects.count(); ++i)
{
Serializable* object = m_objects[i];
ZENIC_ASSERT(object);
m_current = 0;
m_currentIndex = i;
object->serialize(*this);
ZENIC_ASSERT(m_current);
root->addChild(m_current);
}
doc.addChild(root);
// write tree to stream
if (!doc.save(stream))
return false;
return true;
}
void Branch::init()
{
ZENIC_ASSERT(s_settings);
ZENIC_ASSERT(s_settings->m_sides < MaxSides);
float angle = 0.0f;
const float angleStep = (3.1415f * 2.0f) / (s_settings->m_sides-1);
for (uint i = 0; i < s_settings->m_sides; angle += angleStep, ++i)
{
s_cosTable[i] = zenic::cos(angle);
s_sinTable[i] = zenic::sin(angle);
}
}
void Branch::generateSection(Vector3* coords, const Vector3& start, const Vector3& end)
{
ZENIC_ASSERT(coords);
Vector3 up(0.0f, 1.0f, 0.0f);
Vector3 rel = end - start;
Vector3 n = rel.normalize();
Vector3 right = up.cross(n);
float rightLength = right.length();
if (rightLength)
right *= 1.0f / rightLength;
else
right = Vector3(1.0f, 0, 0);
up = n.cross(right);
for (uint i = 0; i < s_settings->m_sides; ++i)
{
Vector3 temp = up * (s_cosTable[i] * m_radius) + right * (s_sinTable[i] * m_radius);
coords[i] = start + temp;
}
m_radius = m_radius * (s_settings->m_contact * 0.01f) + (s_settings->m_contactVariation * 0.01f * floatRandom());
}
void CubeRenderer::beginShadow()
{
ZENIC_ASSERT(m_shadowModel);
if (!m_shadowModel)
return;
//m_renderer.beginRenderModels();
// Override the default gifchain with alpha enabled.
m_dmaChain.addSrcCntTag(VIF_STCYCL(1, 1), VIF_UNPACK(zenic::ps2::vif::V4_32, 1, 20));
m_dmaChain.add64(GIFTAG(0, 0, 1, GS_PRIM(gs::Tristrip, gs::Gouraud, gs::Texturing, 0, gs::Blend, 0, gs::Stq,
gs::Context1, 0), gif::Packed, 3));
m_dmaChain.add64(0x512);
m_dmaChain.endPacket();
// Set alpha
m_dmaChain.addSrcCntTag(0, VIF_DIRECT(2));
m_dmaChain.add128(GIFTAG(1, gif::Eop, 0, 0, gif::Packed, 1),gif::A_D);
m_dmaChain.add128(GS_ALPHA(1, 0, 2, 2, 0x80),GS_REG(ALPHA_1));
m_dmaChain.endPacket();
}
FileSystem& FileSystem::instance()
{
if (!m_instance)
m_instance = zenic_new FileSystem;
ZENIC_ASSERT(m_instance);
return *m_instance;
}
Profiler::Profiler(const char* name)
{
m_timer.update();
m_time0 = m_timer.tick();
m_name = name;
m_curr = branchStepDown(name);
ZENIC_ASSERT(m_curr);
}
void OutXmlSerializer::process(const char* name, Pointer* ptr, u32 elementSize)
{
XmlElement* data = new XmlElement;
data->setValue("data");
if (name)
data->setAttribute("name",name);
if ((&m_allocation.allocator()) != (&HeapAllocator::allocator()))
{
BufferStream temp;
temp << hex << setfill('0') << setw(8) << ptr->m_allocator->handle();
data->setAttribute("allocator",temp.string());
}
if (m_allocation.alignment() != SerializableAllocation::DefaultAlignment)
{
BufferStream temp;
temp << m_allocation.alignment();
data->setAttribute("align",temp.string());
}
if (ptr->m_count > 0)
{
BufferStream temp;
temp << ptr->m_count;
data->setAttribute("count",temp.string());
}
{
BufferStream temp;
temp << elementSize;
data->setAttribute("size",temp.string());
}
{
BufferStream temp;
Base64::encode(temp,ptr->m_objects,elementSize * ptr->m_count);
if (temp.buffer().count() > 0)
{
XmlText* text = zenic_new XmlText;
text->setValue(temp.string());
data->addChild(text);
}
}
ZENIC_ASSERT(m_current);
m_current->addChild(data);
m_allocation = SerializableAllocation();
}
void SaPart6::update(float time, float deltaTime, SyncPoints::Part* syncPoints)
{
static float testTime = 0.0f;
static int camera = 1;
ZENIC_ASSERT(m_scene);
m_renderer.setClearColor(40, 40, 40);
/*
if (testTime >= ((60.0f / 172.0f) * 2.0f))
{
static bool cameraSwitch = false;
if (cameraSwitch)
m_scene->switchToCamera(1);
else
m_scene->switchToCamera(2);
cameraSwitch = !cameraSwitch;
testTime = 0.0f;
}
*/
testTime += deltaTime;
//if (!m_padCamera)
m_renderer.setSceneCamera(m_scene->primaryCamera());
//else
// m_renderer.setSceneCamera(&m_padCamera->sceneCamera());
GS_WRITE(BGCOLOR,GS_BGCOLOR(255,0,0));
Model::resetCollectedModelCount();
m_scene->rootNode()->update(time);
float angle = time * 0.1f;
Matrix4 my;
Matrix4 mx;
my = my.makeYrotation(angle);
mx = mx.makeXrotation(angle);
FftStream& stream = FftStream::instance();
addDisolveObject(stream.hihatData(), 0, my);
addDisolveObject(stream.bassData(), 1, mx);
m_renderer.renderScene(m_scene, true);
PostEffectHelper hlp(m_renderer, m_dmaChain);
hlp.motionBlur(0x40);
}
void LoadingPart::showImage()
{
ZENIC_ASSERT(m_loading);
TextureSystem& textureSystem = m_renderer.textureSystem();
textureSystem.setTexture(0, m_loading);
textureSystem.sync();
textureSystem.activateTexture(m_dmaChain, m_loading);
PostEffectHelper hlp(m_renderer, m_dmaChain);
hlp.setRgba(0, 0, 0, 0);
hlp.setTex0Pal((450*32) + 32, (450*32), 2, 20, 7, 7, 0, 1);
hlp.blit(0, 0, 512, 448);
hlp.blit(192, 200, 192 + 128, 200 + 64, 0.0f, 0.0f, 128.0f, 64.0f, false, true);
}
void OutXmlSerializer::process(const char* name, const char* valueType, BufferStream& value)
{
XmlElement* variable = zenic_new XmlElement;
variable->setValue(valueType);
if (name)
variable->setAttribute("name",name);
XmlText* text = zenic_new XmlText;
text->setValue(value.string());
variable->addChild(text);
ZENIC_ASSERT(m_current);
m_current->addChild(variable);
}
Profiler::~Profiler()
{
ZENIC_ASSERT(m_curr);
m_timer.update();
m_time1 = m_timer.tick();
m_curr->time = m_time1 - m_time0;
m_curr->accTime += m_curr->time;
m_curr->timeBuffer[++m_curr->timeIndex] = m_curr->time;
if (m_curr->timeIndex > TimeBuffers-1)
m_curr->timeIndex = 0;
branchStepUp();
}
void OutXmlSerializer::pushStructure(const char* name, SerializableStructure* structure, Pointer* ptr)
{
ZENIC_ASSERT(structure);
XmlElement* st = new XmlElement;
st->setValue("struct");
if (name)
st->setAttribute("name",name);
SerializableFactory* factory = structure->factory();
{
BufferStream temp;
temp << hex << setw(8) << setfill('0') << factory->host();
st->setAttribute("host",temp.string());
}
{
BufferStream temp;
temp << hex << setw(8) << setfill('0') << factory->type();
st->setAttribute("type",temp.string());
}
{
BufferStream temp;
temp << hex << setw(8) << setfill('0') << structure->identifier();
st->setAttribute("id",temp.string());
}
if (ptr->m_allocator && (ptr->m_allocator != &HeapAllocator::allocator()))
{
BufferStream temp;
temp << hex << setfill('0') << setw(8) << ptr->m_allocator->handle();
st->setAttribute("allocator",temp.string());
}
{
BufferStream temp;
temp << ptr->m_count;
st->setAttribute("count",temp.string());
}
m_stack.pushBack(m_current);
m_current->addChild(st);
m_current = st;
}
void DotXsiLoader::process(ExporterBackend& backend, OutSerializer& serializer, bool oneObject)
{
m_serializer = &serializer;
ZENIC_ASSERT(m_serializer);
buildImages(backend);
buildMaterials(backend);
SceneInfo* sceneInfo = zenic_new SceneInfo;
sceneInfo->setLength(10.0f); // TODO: Fix this length
if (!oneObject)
m_serializer->add(sceneInfo);
traverseRecursive(m_scene->Root(), backend, *sceneInfo, 0, oneObject);
for (std::vector<CSLModel*>::iterator i = m_meshList.begin(); i != m_meshList.end(); ++i)
{
CSLModel* model = (*i);
Node* parentNode = 0;
if (model->Parent())
parentNode = backend.findNode(model->Parent());
Node* node = backend.buildModel(*i);
if (parentNode && node && !oneObject)
parentNode->attachChild(node);
// If we only want to export one object just add the first we find and exit the loop
if (oneObject)
{
m_serializer->add(node);
break;
}
}
//
saveMaterialAndImages();
}
void OutXmlSerializer::process(SerializableVersion& version)
{
if (!m_current)
{
ZENIC_ASSERT(version.factory());
XmlElement* current = zenic_new XmlElement;
current->setValue("object");
{
BufferStream temp;
temp << m_currentIndex;
current->setAttribute("id",temp.string());
}
{
BufferStream temp;
temp << hex << setw(8) << setfill('0') << version.factory()->host();
current->setAttribute("host",temp.string());
}
{
BufferStream temp;
temp << hex << setw(8) << setfill('0') << version.factory()->type();
current->setAttribute("type",temp.string());
}
m_current = current;
}
XmlElement* v = zenic_new XmlElement;
v->setValue("version");
XmlText* text = zenic_new XmlText;
BufferStream temp;
temp << version.version();
text->setValue(temp.string());
v->addChild(text);
m_current->addChild(v);
}
void OutXmlSerializer::process(const char* name, Serializable*& object)
{
XmlElement* reference = new XmlElement;
reference->setValue("ref");
if (name)
reference->setAttribute("name",name);
XmlText* text = new XmlText;
if (object)
{
// insert into list if needed
uint i;
for (i = 0; i < m_objects.count(); ++i)
{
if (m_objects[i] == object)
break;
}
if (i == m_objects.count())
m_objects.pushBack(object);
BufferStream temp;
temp << i;
text->setValue(temp.string());
}
else
text->setValue("null");
reference->addChild(text);
ZENIC_ASSERT(m_current);
m_current->addChild(reference);
}
void DotXsiLoader::buildImages(ExporterBackend& backend)
{
CSLImageLibrary* imageLibrary = m_scene->GetImageLibrary();
if (!imageLibrary)
return;
CSLImage** imageList = imageLibrary->GetImageList();
int imageCount = imageLibrary->GetImageCount();
m_textures.clear();
for (int i = 0; i < imageCount; ++i)
{
CSIBCPixMap pixMap;
CSLImage* image = imageList[i];
ZENIC_ASSERT(image);
char* fileName = image->GetSourceFile();
if (SI_SUCCESS != CSIBCPixMap::Load(fileName, pixMap))
{
ZENIC_WARNING("Unable to load file: " << fileName << " not supported format or missing.");
continue;
}
Serializable* texture = backend.buildTexture(image, pixMap);
if (texture)
{
backend.addTexture(image, texture);
m_textures.push_back(texture);
}
}
}
bool ScaleImage::run(Pixel* pSrc, uint uiSrcWidth, uint uiSrcHeight, Pixel* pDest, uint uiDestWidth, uint uiDestHeight)
{
// TODO: Rewrite to fit new coding stanard.
unsigned char* pkWidth = CreateFilter( uiSrcWidth, uiDestWidth );
ZENIC_ASSERT( pkWidth );
unsigned char* pkHeight = CreateFilter( uiSrcHeight, uiDestHeight );
ZENIC_ASSERT( pkHeight );
if( !pkWidth || !pkHeight )
return false;
Kernel* pkXKernel = (Kernel*)pkWidth;
Kernel* pkYKernel = (Kernel*)pkHeight;
Source* pXLimit = (Source*)(pkWidth + pkXKernel->m_uiSize);
Source* pYLimit = (Source*)(pkHeight + pkYKernel->m_uiSize);
// setup row table
unsigned int uiActive = 0;
FilterRow** pkActive = new FilterRow*[uiDestHeight];
FilterRow* pkRow = 0;
ZENIC_ASSERT( pkActive );
memset( pkActive, 0, uiDestHeight * sizeof(FilterRow*) );
Pixel* pkSourceRow = 0;
unsigned int uiSourceRow = 0;
FilterRow* pkRowCache = 0;
for( Source* pkYSource = pkYKernel->m_kSource; pkYSource < pYLimit; pkYSource = (Source*)(((unsigned char*)pkYSource) + pkYSource->m_uiSize) )
{
Dest* pkYDestLimit = (Dest*)(((unsigned char*)pkYSource) + pkYSource->m_uiSize);
Dest* pkYDest;
if( pkYSource->m_kDest < pkYDestLimit )
{
for( pkYDest = pkYSource->m_kDest; pkYDest < pkYDestLimit; pkYDest++ )
{
// create rows of pixels needed for accumulating to destination
if( !pkActive[pkYDest->m_uiDest] )
{
// create new if none in cache
if( !pkRowCache )
{
pkRowCache = new FilterRow;
ZENIC_ASSERT( pkRowCache );
pkRowCache->m_pkPixels = new Pixel[uiDestWidth];
ZENIC_ASSERT( pkRowCache->m_pkPixels );
}
pkRow = pkRowCache;
pkRowCache = pkRowCache->m_pkNext;
memset( pkRow->m_pkPixels, 0, uiDestWidth * sizeof(Pixel) );
pkRow->m_fWeight = 0;
pkRow->m_pkNext = 0;
pkActive[pkYDest->m_uiDest] = pkRow;;
uiActive++;
}
}
}
// get source row
pkSourceRow = &pSrc[uiSrcWidth * uiSourceRow];
Pixel* pkSourcePixel = pkSourceRow;
// process row
for( Source* pXSource = pkXKernel->m_kSource; pXSource < pXLimit; pXSource = (Source*)(((unsigned char*)pXSource) + pXSource->m_uiSize) )
{
Dest* pkXDestLimit = (Dest*)(((unsigned char*)pXSource) + pXSource->m_uiSize);
for( pkYDest = pkYSource->m_kDest; pkYDest < pkYDestLimit; pkYDest++ )
{
pkRow = pkActive[pkYDest->m_uiDest];
for( Dest* pkXDest = pXSource->m_kDest; pkXDest < pkXDestLimit; pkXDest++ )
{
float fWeight = pkYDest->m_fWeight * pkXDest->m_fWeight;
pkRow->m_pkPixels[pkXDest->m_uiDest].r += pkSourcePixel->r * fWeight;
pkRow->m_pkPixels[pkXDest->m_uiDest].g += pkSourcePixel->g * fWeight;
pkRow->m_pkPixels[pkXDest->m_uiDest].b += pkSourcePixel->b * fWeight;
pkRow->m_pkPixels[pkXDest->m_uiDest].a += pkSourcePixel->a * fWeight;
pkRow->m_pkPixels[pkXDest->m_uiDest].luma += pkSourcePixel->luma * fWeight;
}
}
pkSourcePixel++;
}
// store completed accumulation rows in dest
for( pkYDest = pkYSource->m_kDest; pkYDest < pkYDestLimit; pkYDest++ )
{
pkRow = pkActive[pkYDest->m_uiDest];
pkRow->m_fWeight += pkYDest->m_fWeight;
if( (pkRow->m_fWeight+0.00001) >= 1.0f )
{
for( unsigned int i = 0; i < uiDestWidth; i++ )
pDest[i + uiDestWidth * pkYDest->m_uiDest] = pkRow->m_pkPixels[i];
// send row back to the cache
pkActive[pkYDest->m_uiDest] = 0;
pkRow->m_pkNext = pkRowCache;
pkRowCache = pkRow;
uiActive--;
}
}
// advance to next row
uiSourceRow++;
}
ZENIC_ASSERT( !uiActive );
delete pkRowCache;
delete [] pkActive;
delete [] pkWidth;
delete [] pkHeight;
return true;
}
void Profiler::branchStepUp()
{
ZENIC_ASSERT(m_pos);
m_pos = m_pos->parent;
}
void BranchStatuePart::update(Dma& dmaChain, float time, float deltaTime, SyncPoints::Part* syncPoints)
{
if (m_splitCounter > 1.0f)
{
for (uint i = 0; i < 4; ++i)
m_branch[i].divide();
m_splitCounter = 0.0f;
}
Model::resetCollectedModelCount();
ZENIC_ASSERT(m_scene->rootNode());
m_scene->rootNode()->update(time);
Model** models = Model::collectedModels();
uint modelCount = Model::collectedModelsCount();
//m_branch->setModel(static_cast<BranchModel*>(models[0]));
#ifdef PS2_EMU
glBegin(GL_LINE_STRIP);
//glClearColorf(0.0f, 0.0f, 0.0f);
glColor3f(0.0f, 1.0f, 0.0f);
float fade = 1.0f;
for (uint k = 0; k < modelCount; ++k)
{
const BranchModel* model = static_cast<const BranchModel*>(models[k]);
const DataPtr<BranchModel::Vertex>& curves = model->curves();
BranchModel::Vertex* objects = curves.objects();
const Vector3& scale = model->scale();
for (uint i = 0; i < 14; ++i)
{
Vector3 pos(objects[i].x * scale.x, objects[i].y * scale.y, objects[i].z * scale.z);
glVertex3f(pos.x, pos.y, pos.z);
if (i & 1)
glColor3f(0, 1, 0.0f);
else
glColor3f(1.0f, 0, 0.0f);
}
}
glEnd();
#endif
s32 start = Branch::beginRender(dmaChain);
dmaChain.addSrcCntTag(0, VIF_UNPACK(vif::V4_32, 4, 10));
// Temporay identity matrix
Matrix4 temp;
temp = temp.identity();
float* matrix = temp.matrix();
for (uint i = 0; i < 16; i++)
dmaChain.addFloat(*matrix++);
dmaChain.endPacket();
dmaChain.addSrcCntTag();
dmaChain.add32(0);
dmaChain.add32(0);
dmaChain.add32(VIF_FLUSH());
//dmaChain.add32(0);
dmaChain.addMscal(start);
dmaChain.endPacket();
for (uint i = 0; i < 4; ++i)
m_branch[i].render(dmaChain, deltaTime);
m_splitCounter += deltaTime;
}
bool BranchStatuePart::create()
{
FileSystem& fileSystem = FileSystem::instance();
FileStream stream;
if (!fileSystem.open(stream, "Data/Output/BranchStatue.zse"))
return false;
InBinarySerializer inBinary;
if (!inBinary.load(stream))
return false;
m_scene = static_cast<SceneInfo*>(inBinary[0]);
m_branchSettings.m_length = 1.0f;
m_branchSettings.m_lengthVariation = 0.5f;
m_branchSettings.m_angle = 25.0f;
m_branchSettings.m_angleVariation = 15.0f;
m_branchSettings.m_startRadius = 0.05f;
m_branchSettings.m_startRadiusVariation = 0.01f;
m_branchSettings.m_contact = 99.0f;
m_branchSettings.m_contactVariation = 0.01f;
m_branchSettings.m_gravity = -0.2;
m_branchSettings.m_gravityVariation = 0.0f;
m_branchSettings.m_speed = 0.3f;
m_branchSettings.m_sides = 4+1;
Branch::s_settings = &m_branchSettings;
Branch::init();
BranchGenerator::m_branchIndex = 0;
BranchGenerator::m_stripIndex = 0;
// Temp temp
Model::resetCollectedModelCount();
ZENIC_ASSERT(m_scene->rootNode());
m_scene->rootNode()->update(0.0f);
Model** models = Model::collectedModels();
//uint modelCount = Model::collectedModelsCount();
// Just get the first model for now
BranchModel* model = static_cast<BranchModel*>(models[0]);
const DataPtr<u16>& curveCounts = model->curvesCount();
m_branch = zenic_new Branch[curveCounts.count()];
ZENIC_ASSERT(m_branch);
BranchModel::Vertex* vertices = model->curves().objects();
BranchModel::Vertex* verticesStart = model->curves().objects();
u16* curveCountArray = curveCounts.objects();
BranchModel::Vertex* verticesPrev = vertices;
vertices += curveCountArray[0];
vertices += curveCountArray[0];
for (uint i = 0; i < 4; ++i)
{
//if ((i + 1) == curveCounts.count())
// vertices = verticesStart;
m_branch[i].setControlPoints(verticesPrev, vertices, curveCountArray[i], i * 0.2f, model->scale());
m_branch[i].createRoot();
m_branch[i].divide();
}
m_branchSettings.m_speed = 1.0f;
m_splitCounter = 0.0f;
return true;
}
bool Branch::makeNewDirection(float angleMul, bool hasReatchedTarget)
{
if (m_curve)
{
if (m_curveTarget == m_curveCount)
return false;
Vector3 pos = curvePos();
Vector3 direction = pos - m_position;
// rand...
float x = (s_settings->m_angle + s_settings->m_angleVariation * floatRandom()) * angleMul * 0.005f;
float y = (s_settings->m_angle + s_settings->m_angleVariation * floatRandom()) * angleMul * 0.005f;
float z = (s_settings->m_angle + s_settings->m_angleVariation * floatRandom()) * angleMul * 0.005f;
direction = direction.normalize();
direction.x += x;
direction.y += y;
direction.z += z;
m_direction = direction.normalize();
// Set next target if we reatched our target point in the curve
if (hasReatchedTarget)
++m_curveTarget;
return true;
}
Matrix4 matrix;
float angle = (s_settings->m_angle + s_settings->m_angleVariation * floatRandom()) * angleMul;
if (random() & 1)
angle = -angle;
switch (random() %3 )
{
case 0 :
{
matrix.makeXrotation(angle * (3.1415f / 180.0f));
//m_direction.y = 1.0f;
break;
}
case 1 :
{
matrix.makeYrotation(angle * (3.1415f / 180.0f));
//m_direction.z = 1.0f;
break;
}
case 2 :
{
matrix.makeZrotation(angle * (3.1415f / 180.0f));
//m_direction.x = 1.0f;
break;
}
default : ZENIC_ASSERT(false);
}
m_direction = matrix.apply(m_direction);
m_direction.y += -s_settings->m_gravity;
m_direction = m_direction.normalize();
return true;
}
void demoMain()
{
Renderer* renderer = zenic_new ps2::Renderer(false);
ZENIC_ASSERT(renderer);
float deltaTime = 1.0f / 60.0f;
float time = 0.0f;
if (!renderer)
return;
#if defined(ZENIC_PS2)
#ifndef ONE_PART
#else
//FileSystem::instance().setIoMode(FileSystem::Host);
#endif
FileSystem::instance().setIoMode(FileSystem::Hdd);
//FileSystem::instance().setIoMode(FileSystem::Host);
#endif
Part* parts[14];
renderer->create();
renderer->setClearColor(127, 127, 127);
renderer->init();
LoadingPart* loadingPart = zenic_new LoadingPart(*renderer, MasterChain::instance()->chain());
loadingPart->create();
loadingPart->update();
FftStream::instance().create();
SyncPoints syncPoints;
SaPart::loadSaObjects();
// Alloc all parts parts
for (uint i = 0; i < 14; ++i)
parts[i] = 0;
#if defined(ZENIC_PS2)
#ifndef NO_MUSIC
MusicStream* stream = zenic_new MusicStream("DATA/OUTPUT/SAPART1.APM");
#else
MusicStream dummy;
MusicStream* stream = &dummy;
#endif
#endif
#ifndef ONE_PART
parts[0] = zenic_new StartPart(*renderer, MasterChain::instance()->chain());
parts[1] = zenic_new MountainsPart(*renderer, MasterChain::instance()->chain());
parts[2] = zenic_new SpeachPart1(*renderer, MasterChain::instance()->chain());;
parts[3] = zenic_new SaPart1(*renderer, MasterChain::instance()->chain());
parts[4] = zenic_new BlobPart(*renderer, MasterChain::instance()->chain());
parts[5] = zenic_new SaPart2(*renderer, MasterChain::instance()->chain());
parts[6] = zenic_new CityScapePart(*renderer, MasterChain::instance()->chain());
parts[7] = zenic_new TunnelPart(*renderer, MasterChain::instance()->chain());
parts[8] = zenic_new SpeachPart2(*renderer, MasterChain::instance()->chain());;
parts[9] = zenic_new SaPart3(*renderer, MasterChain::instance()->chain());
parts[10] = zenic_new ParkingHousePart(*renderer, MasterChain::instance()->chain());
parts[11] = zenic_new EndPart(*renderer, MasterChain::instance()->chain());
for (uint i = 0; i < 14; ++i)
{
if (parts[i])
parts[i]->create();
}
// Ugly but what the hell
((SaPart*)parts[8])->setScene(((SaPart*)parts[2])->scene());
/*
u8* tempBuffer = zenic_new u8[8 * ((512 * 512) / 2)];
ZENIC_ASSERT(tempBuffer);
for (uint i = 0; i < (8 * ((512 * 512) / 2)); ++i)
tempBuffer[i] = i;
*/
#else
parts[0] = zenic_new ParkingHousePart(*renderer, MasterChain::instance()->chain());
//parts[0] = zenic_new SpeachPart1(*renderer, MasterChain::instance()->chain());;
//parts[0] = zenic_new StartPart(*renderer, MasterChain::instance()->chain());
//parts[0] = zenic_new TunnelPart(*renderer, MasterChain::instance()->chain());
//parts[0] = zenic_new CityScapePart(*renderer, MasterChain::instance()->chain());
//parts[0] = zenic_new MountainsPart(*renderer, MasterChain::instance()->chain());
parts[0]->create();
#endif
while (time < 1.0f)
{
loadingPart->update(1.0f, time);
renderer->flip();
time += deltaTime;
}
// Fade down the Loading screen before the "real" demo start
while (time < 1.0f)
{
loadingPart->update(1.0f, time);
renderer->flip();
time += deltaTime;
}
// Do real demo
//MusicStream stream;
#ifndef ZENIC_FINAL
pad.create(0, 0);
PadCamera padCamera(pad);
parts[0]->setPadCamera(&padCamera);
#endif
#if defined(ZENIC_PS2)
#ifndef NO_MUSIC
stream->play();
#endif
#endif
uint prevPartId = 0;
time = 0.0f;
FftStream::instance().setTime(0);
//renderer->setRenderFrames(true);
while (1)
{
#ifndef ONE_PART
uint partId = syncPoints.partId();
if (prevPartId != partId)
{
if (parts[prevPartId])
parts[prevPartId]->reset();
prevPartId = partId;
}
if (parts[partId])
parts[partId]->update(time - syncPoints.partStartTime(), deltaTime);
#else
parts[0]->update(time, deltaTime);
#endif
#if !defined(ZENIC_FINAL) && defined(ZENIC_PS2)
time = syncPoints.update(pad, *stream, time);
#else
time = syncPoints.update(time);
#endif
#if !defined(ZENIC_FINAL) && defined(ZENIC_PS2)
pad.update();
padCamera.update();
if (pad.status().triangle)
{
renderer->screenShot("host:frames/screenshot.tga");
}
if (pad.status().select)
{
stream->stop();
}
#endif
#ifndef NO_MUSIC
#if defined(ZENIC_PS2)
if (time > 278.0f)
{
stream->stop();
}
#endif
#endif
FftStream::instance().update(*renderer, MasterChain::instance()->chain());
renderer->flip();
time += deltaTime;
}
}
unsigned char* ScaleImage::CreateFilter( unsigned int uiSrcLength, unsigned int uiDestLength )
{
ZENIC_ASSERT( uiSrcLength && uiDestLength );
if( !uiSrcLength || !uiDestLength )
return 0;
unsigned int i,j;
// compute filter scaling
float fScale = float(uiDestLength) / float(uiSrcLength);
float fInvScale = 0.5f / fScale;
// compute how much memory we will need
unsigned int uiMemSize = (sizeof(Kernel)-sizeof(Source)) + (sizeof(Source)-sizeof(Dest)) + sizeof(Dest);
for( i = 0; i < uiSrcLength; i++ )
{
float fSource = float(i) - 0.5f;
float fDestMin = fSource * fScale;
float fDestMax = fDestMin + fScale;
uiMemSize += (sizeof(Source)-sizeof(Dest)) + sizeof(Dest) + (unsigned int)(fDestMax - fDestMin + 1) * sizeof(Dest) * 2;
}
unsigned char* pkKernel = new unsigned char[uiMemSize];
ZENIC_ASSERT(pkKernel);
// start setting up filter
unsigned int uiSize = (sizeof(Kernel)-sizeof(Source));
unsigned int uiSum = 0;
float fSumWeight = 0;
for( i = 0; i < uiSrcLength; i++ )
{
unsigned int uiSourceSize = uiSize;
Source* pkSource = (Source*)(pkKernel + uiSize);
// make sure we do not overrun the buffer
uiSize += (sizeof(Source) - sizeof(Dest));
ZENIC_ASSERT( uiSize <= uiMemSize );
for( j = 0; j < 2; j++ )
{
// compute source pixel boundary
float fSource = float(i+j) - 0.5f;
float fDestMin = fSource * fScale;
float fDestMax = fDestMin + fScale;
// clamp filter to border edges
fDestMin = fDestMin < 0.0f ? 0.0f : fDestMin;
fDestMax = fDestMax > float(uiDestLength) ? float(uiDestLength) : fDestMax;
// compute dest pixel location
unsigned int uiDest = (unsigned int)floorf(fDestMin);
while(float(uiDest) < fDestMax)
{
float fDestStart = float(uiDest);
float fDestEnd = fDestStart + 1.0f;
if( uiSum != uiDest )
{
if(fSumWeight > 0.00001)
{
Dest *pkDest = (Dest*)(pkKernel + uiSize);
uiSize += sizeof(Dest);
ZENIC_ASSERT( uiSize <= uiMemSize );
pkDest->m_uiDest = uiSum;
pkDest->m_fWeight = fSumWeight;
}
fSumWeight = 0.0f;
uiSum = uiDest;
}
fDestStart = fDestStart < fDestMin ? fDestMin : fDestStart;
fDestEnd = fDestEnd > fDestMax ? fDestMax : fDestEnd;
float fWeight;
fWeight = (fSource < 0.0f) ? 1.0f : (fSource + 1.0f >= float(uiSrcLength)) ? 0 :
(fDestStart + fDestEnd) * fInvScale - fSource;
fSumWeight += (fDestEnd - fDestStart) * (j ? 1.0f - fWeight : fWeight);
uiDest++;
}
}
if(fSumWeight > 0.00001)
{
Dest *pkDest = (Dest*)(pkKernel + uiSize);
uiSize += sizeof(Dest);
ZENIC_ASSERT( uiSize <= uiMemSize );
pkDest->m_uiDest = uiSum;
pkDest->m_fWeight = fSumWeight;
}
fSumWeight = 0.0f;
pkSource->m_uiSize = uiSize - uiSourceSize;
}
((Kernel*)pkKernel)->m_uiSize = uiSize;
return pkKernel;
}
