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