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; }