virtual tjs_error TJS_INTF_METHOD FuncCall( // function invocation tjs_uint32 flag, // calling flag const tjs_char * membername,// member name ( NULL for a default member ) tjs_uint32 *hint, // hint for the member name (in/out) tTJSVariant *result, // result tjs_int numparams, // number of parameters tTJSVariant **param, // parameters iTJSDispatch2 *objthis // object as "this" ) { if (numparams > 1) { tTVInteger flag = param[1]->AsInteger(); if (!(flag & TJS_HIDDENMEMBER)) { if (first) { first = false; } else { writer->write((tjs_char)','); writer->newline(); } const tjs_char *name = param[0]->GetString(); quoteString(name, writer); writer->write(L"=>"); getVariantString(*param[2], writer); } } if (result) { *result = true; } return TJS_S_OK; }
void SaveDATA(IWriter &fs, xr_vector<vecW> &C) { for (xr_vector<vecW>::iterator it=C.begin(); it!=C.end(); it++) { fs.Wword(it->size()); fs.write(it->begin(),it->size()*sizeof(u16)); } }
bool ImageFormat_JPEG::encode(const Image& image, IWriter& writer, int32 quality) const { quality = Clamp(quality, 0, 100); const int32 width = image.width(); const int32 height = image.height(); const size_t size = ::tjBufSize(width, height, TJSAMP::TJSAMP_420); uint8* buffer = static_cast<uint8*>(::malloc(size)); unsigned long retJPEGsize = 0; tjhandle tj = ::tjInitCompress(); ::tjCompress( tj, const_cast<uint8*>(image.dataAsUint8()), width, width * 4, height, 4, buffer, &retJPEGsize, TJ_420, quality, 0 ); ::tjDestroy(tj); const bool result = static_cast<int64>(retJPEGsize) == writer.write(buffer, retJPEGsize); ::free(buffer); return result; }
void CBuild::BuildRelevance(IWriter &fs) { static Fvector size; static u32 nx,ny,nz; Status("Preparing..."); R_ASSERT(g_TREE_ROOT); g_TREE_ROOT->bbox.getsize(size); clMsg("Level dimensions: [%3.1f,%3.1f,%3.1f]",size.x,size.y,size.z); nx = iROUND(ceilf(size.x/g_params.m_relevance)); ny = iROUND(ceilf(size.y/g_params.m_relevance)); nz = iROUND(ceilf(size.z/g_params.m_relevance)); clMsg("Ceiling dimensions: [%3d,%3d,%3d]",nx, ny, nz); fs.open_chunk(fsL_VISIBILITY); fs.open_chunk(fsV_HEADER); V_Header H; H.nX = nx; H.nY = ny; H.nZ = nz; H.relevance = g_params.m_relevance; H.min.set (g_TREE_ROOT->bbox.min); fs.write (&H,sizeof(H)); fs.close_chunk (); // Build Visibility static xr_vector< u32 > slots; static xr_vector< vecW > vis_nodes; static xr_vector< vecW > vis_lights; static xr_vector< vecW > vis_glows; static xr_vector< vecW > vis_occluders; static vecW rel_set; static vecW unroll; CVirtualFileStream* pvs_map_stream=0; if (g_params.m_bTestOcclusion) { pvs_map_stream = xr_new<CVirtualFileStream> ("pvs.temp"); g_pvs_map_vm = (int *)pvs_map_stream->Pointer(); } static u32 dwSlot = 0; for (int z=0; z<nz; z++) { for (int x=0; x<nx; x++) { for (int y=0; y<ny; y++) { Status("Volume #%d...",dwSlot); static Fvector pos; pos.set(x,y,z); pos.add(.5f); pos.mul(g_params.m_relevance); pos.add(g_TREE_ROOT->bbox.min); // ******* Nodes relevance if (g_params.m_bTestOcclusion) { CalculateRelSet(pos,unroll); if (unroll.empty() || g_TREE_ROOT->VisCapture(unroll,rel_set)) rel_set.push_back(g_tree.size()-1); unroll.clear(); slots.push_back(PlaceData(vis_nodes,rel_set)); } else { // Unroll hierrarhy VERIFY(g_TREE_ROOT); g_TREE_ROOT->VisUnroll(pos,unroll); if (unroll.size()>1) std::sort(unroll.begin(),unroll.end()); // Capture results if (g_TREE_ROOT->VisCapture(unroll,rel_set)) rel_set.push_back(g_tree.size()-1); unroll.clear(); // Register in container slots.push_back(PlaceData(vis_nodes,rel_set)); } // Lights relevance for (int i=0; i<lights.size(); i++) { if ((pos.distance_to(lights[i].position) - lights[i].range) < g_params.m_viewdist) { rel_set.push_back(i); } } slots.push_back(PlaceData(vis_lights,rel_set)); // Glows relevance for (i=0; i<glows.size(); i++) { if ((pos.distance_to(glows[i].P) - glows[i].size) < g_params.m_viewdist) { rel_set.push_back(i); } } slots.push_back(PlaceData(vis_glows,rel_set)); // Occluders relevance for (i=0; i<occluders.size(); i++) { Fvector P; float R=-1; float T; P.add(occluders[i].V2,occluders[i].V4); P.mul(.5f); T = P.distance_to(occluders[i].V1); if (T>R) R=T; T = P.distance_to(occluders[i].V2); if (T>R) R=T; T = P.distance_to(occluders[i].V4); if (T>R) R=T; if ((pos.distance_to(P) - R) < g_params.m_viewdist*g_params.m_occluder_rel_scale) { rel_set.push_back(i); } } slots.push_back(PlaceData(vis_occluders,rel_set)); dwSlot++; Progress(float(dwSlot)/float(nz*nx*ny)); } } } xr_delete (pvs_map_stream); fs.open_chunk (fsV_NODES); SaveDATA (fs,vis_nodes); fs.close_chunk (); fs.open_chunk(fsV_LIGHTS); SaveDATA(fs,vis_lights); fs.close_chunk(); fs.open_chunk(fsV_GLOWS); SaveDATA(fs,vis_glows); fs.close_chunk(); fs.open_chunk(fsV_OCCLUDERS); SaveDATA(fs,vis_occluders); fs.close_chunk(); fs.open_chunk(fsV_MAP); fs.write(slots.begin(),slots.size()*sizeof(u32)); fs.close_chunk(); fs.close_chunk(); }
bool AudioFormat_WAVE::encode(const Wave& wave, IWriter& writer, const WAVEFormat format) const { if (!wave || !writer.isOpened()) { return false; } const uint16 bitsWidth = format == WAVEFormat::Stereo8U ? 1 : format == WAVEFormat::Stereo16S ? 2 : 4; const uint16 channels = 2; const uint32 sampleRate = wave.samplingRate(); const size_t waveSize = wave.size() * channels * bitsWidth; const uint32 headerSize = sizeof(RiffHeader) + sizeof(ChunkHeader) + sizeof(FormatHeader) + sizeof(ChunkHeader); const RiffHeader riffHeader { { 'R', 'I', 'F', 'F' }, static_cast<uint32>(waveSize + headerSize - 8), { 'W', 'A', 'V', 'E' }, }; const ChunkHeader chunkHeader1 { { 'f', 'm', 't', ' ' }, sizeof(FormatHeader), }; const FormatHeader formatHeader { uint16((format == WAVEFormat::Stereo32F) ? WAVE_FORMAT_IEEE_FLOAT : 1), channels, sampleRate, sampleRate * bitsWidth * channels, uint16(bitsWidth * channels), uint16(bitsWidth * 8), }; const ChunkHeader chunkHeader2 { { 'd', 'a', 't', 'a' }, static_cast<uint32>(waveSize), }; writer.write(&riffHeader, sizeof(riffHeader)); writer.write(&chunkHeader1, sizeof(chunkHeader1)); writer.write(&formatHeader, sizeof(formatHeader)); writer.write(&chunkHeader2, sizeof(chunkHeader2)); if (format == WAVEFormat::Stereo8U) { size_t samplesToWrite = wave.size(); const uint32 bufferSize = 16384; Array<WS8bit> buffer(bufferSize); const WaveSample* pSrc = &wave[0]; for (;;) { WS8bit* pDst = buffer.data(); if (samplesToWrite > bufferSize) { for (uint32 i = 0; i < bufferSize; ++i) { pDst->left = static_cast<uint8>((pSrc->left + 1.0f) * 127.999f); pDst->right = static_cast<uint8>((pSrc->right + 1.0f) * 127.999f); ++pDst; ++pSrc; } writer.write(buffer.data(), bufferSize * sizeof(WS8bit)); samplesToWrite -= bufferSize; } else { for (uint32 i = 0; i < samplesToWrite; ++i) { pDst->left = static_cast<uint8>((pSrc->left + 1.0f) * 127.999f); pDst->right = static_cast<uint8>((pSrc->right + 1.0f) * 127.999f); ++pDst; ++pSrc; } writer.write(buffer.data(), samplesToWrite * sizeof(WS8bit)); break; } } } else if (format == WAVEFormat::Stereo16S) { size_t samplesToWrite = wave.size(); const uint32 bufferCount = 16384; Array<WaveSampleS16> buffer(bufferCount); const WaveSample* pSrc = &wave[0]; for (;;) { WaveSampleS16* pDst = buffer.data(); if (samplesToWrite > bufferCount) { for (uint32 i = 0; i < bufferCount; ++i) { pDst->left = static_cast<int16>(pSrc->left * 32767.0f); pDst->right = static_cast<int16>(pSrc->right * 32767.0f); ++pDst; ++pSrc; } writer.write(buffer.data(), bufferCount * sizeof(WaveSampleS16)); samplesToWrite -= bufferCount; } else { for (uint32 i = 0; i < samplesToWrite; ++i) { pDst->left = static_cast<int16>(pSrc->left * 32767.0f); pDst->right = static_cast<int16>(pSrc->right * 32767.0f); ++pDst; ++pSrc; } writer.write(buffer.data(), samplesToWrite * sizeof(WaveSampleS16)); break; } } } else { writer.write(wave.data(), waveSize); } return true; }