//- Move a softParticle from one position to another.
bool Foam::softParticle::move
(
trackingData& td,
const scalar trackTime
)
{
td.switchProcessor = false;
td.keepParticle = true;
const polyBoundaryMesh& pbMesh = mesh_.boundaryMesh();
scalar tEnd = (1.0 - stepFraction())*trackTime;
scalar dtMax = tEnd;
while (td.keepParticle && !td.switchProcessor && tEnd > ROOTVSMALL)
{
if (debug)
{
Pout<< "Time = " << mesh_.time().timeName()
<< " trackTime = " << trackTime
<< " steptFraction() = " << stepFraction() << endl;
Pout<< "Before trackToFace, particle tag is: " << ptag()
<< ". Particle position is: " << position() << endl;
}
scalar dt = min(dtMax, tEnd);
dt *= trackToFace(position() + dt*moveU_, td);
tEnd -= dt;
stepFraction() = 1.0 - tEnd/trackTime;
if (debug)
{
Pout<< "After trackToFace, particle tag is: " << ptag()
<< ". Particle position is: " << position() << endl;
}
if (onBoundary() && td.keepParticle)
{
if (isA<processorPolyPatch>(pbMesh[patch(face())]))
{
td.switchProcessor = true;
// Pout<< "Cross the processor boundary.." << endl;
}
}
}
return td.keepParticle;
}
// Read Fifo into an ee tag, transfer it to sif2dma, and process it.
static __fi bool ProcessEETag()
{
static __aligned16 u32 tag[4];
tDMA_TAG& ptag(*(tDMA_TAG*)tag);
sif2.fifo.read((u32*)&tag[0], 4); // Tag
SIF_LOG("SIF2 EE read tag: %x %x %x %x", tag[0], tag[1], tag[2], tag[3]);
sif2dma.unsafeTransfer(&ptag);
sif2dma.madr = tag[1];
SIF_LOG("SIF2 EE dest chain tag madr:%08X qwc:%04X id:%X irq:%d(%08X_%08X)",
sif2dma.madr, sif2dma.qwc, ptag.ID, ptag.IRQ, tag[1], tag[0]);
if (sif2dma.chcr.TIE && ptag.IRQ)
{
//Console.WriteLn("SIF2 TIE");
sif2.ee.end = true;
}
switch (ptag.ID)
{
case TAG_CNT: break;
case TAG_CNTS:
break;
case TAG_END:
sif2.ee.end = true;
break;
}
return true;
}
// Read Fifo into an ee tag, transfer it to sif0ch, and process it.
static __fi bool ProcessEETag()
{
static __aligned16 u32 tag[4];
tDMA_TAG& ptag(*(tDMA_TAG*)tag);
sif0.fifo.read((u32*)&tag[0], 4); // Tag
SIF_LOG("SIF0 EE read tag: %x %x %x %x", tag[0], tag[1], tag[2], tag[3]);
sif0ch.unsafeTransfer(&ptag);
sif0ch.madr = tag[1];
SIF_LOG("SIF0 EE dest chain tag madr:%08X qwc:%04X id:%X irq:%d(%08X_%08X)",
sif0ch.madr, sif0ch.qwc, ptag.ID, ptag.IRQ, tag[1], tag[0]);
if (sif0ch.chcr.TIE && ptag.IRQ)
{
//Console.WriteLn("SIF0 TIE");
sif0.ee.end = true;
}
switch (ptag.ID)
{
case TAG_CNT: break;
case TAG_CNTS:
if (dmacRegs.ctrl.STS == STS_SIF0)
dmacRegs.stadr.ADDR = sif0ch.madr + (sif0ch.qwc * 16);
break;
case TAG_END:
sif0.ee.end = true;
break;
}
return true;
}
/**
* To run the power iteration, we set up a sparse matrix using Boost.uBLAS, transfer it over to a ViennaCL matrix, and then run the algorithm.
**/
int main()
{
// This example relies on double precision to be available and will provide only poor results with single precision
typedef double ScalarType;
/**
* Create the sparse uBLAS matrix and read the matrix from the matrix-market file:
**/
boost::numeric::ublas::compressed_matrix<ScalarType> ublas_A;
if (!viennacl::io::read_matrix_market_file(ublas_A, "../examples/testdata/mat65k.mtx"))
{
std::cout << "Error reading Matrix file" << std::endl;
return EXIT_FAILURE;
}
/**
* Transfer the data from the uBLAS matrix over to the ViennaCL sparse matrix:
**/
viennacl::compressed_matrix<ScalarType> vcl_A(ublas_A.size1(), ublas_A.size2());
viennacl::copy(ublas_A, vcl_A);
/**
* Run the power iteration up until the largest eigenvalue changes by less than the specified tolerance.
* Print the results of running with uBLAS as well as ViennaCL and exit.
**/
viennacl::linalg::power_iter_tag ptag(1e-6);
std::cout << "Starting computation of eigenvalue with largest modulus (might take about a minute)..." << std::endl;
std::cout << "Result of power iteration with ublas matrix (single-threaded): " << viennacl::linalg::eig(ublas_A, ptag) << std::endl;
std::cout << "Result of power iteration with ViennaCL (OpenCL accelerated): " << viennacl::linalg::eig(vcl_A, ptag) << std::endl;
return EXIT_SUCCESS;
}
s32 PrepareEERead()
{
static __aligned16 u32 tag[4];
// Process DMA tag at hw_dma9.tadr
sif0.iop.data = *(sifData *)iopPhysMem(hw_dma9.tadr);
sif0.iop.data.words = (sif0.iop.data.words + 3) & 0xfffffffc; // Round up to nearest 4.
memcpy(tag, (u32*)iopPhysMem(hw_dma9.tadr + 8), 16);
hw_dma9.tadr += 16; ///hw_dma9.madr + 16 + sif0.sifData.words << 2;
// We're only copying the first 24 bits.
hw_dma9.madr = sif0data & 0xFFFFFF;
sif0.iop.counter = sif0words;
if (sif0tag.IRQ || (sif0tag.ID & 4)) sif0.iop.end = true;
SIF_LOG("SIF0 IOP to EE Tag: madr=%lx, tadr=%lx, counter=%lx (%08X_%08X)"
"\n\tread tag: %x %x %x %x", hw_dma9.madr, hw_dma9.tadr, sif0.iop.counter, sif0words, sif0data,
tag[0], tag[1], tag[2], tag[3]);
sif0ch.unsafeTransfer(((tDMA_TAG*)(tag)));
sif0ch.madr = tag[1];
tDMA_TAG ptag(tag[0]);
SIF_LOG("SIF0 EE dest chain tag madr:%08X qwc:%04X id:%X irq:%d(%08X_%08X)",
sif0ch.madr, sif0ch.qwc, ptag.ID, ptag.IRQ, tag[1], tag[0]);
if (sif0ch.chcr.TIE && ptag.IRQ)
{
//Console.WriteLn("SIF0 TIE");
sif0.ee.end = true;
}
switch (ptag.ID)
{
case TAG_REFE:
sif0.ee.end = true;
if (dmacRegs.ctrl.STS != NO_STS)
dmacRegs.stadr.ADDR = sif0ch.madr + (sif0ch.qwc * 16);
break;
case TAG_REFS:
if (dmacRegs.ctrl.STS != NO_STS)
dmacRegs.stadr.ADDR = sif0ch.madr + (sif0ch.qwc * 16);
break;
case TAG_END:
sif0.ee.end = true;
break;
}
return true;
}
void OrganizationShowHandller::handleIqID( const IQ& iq, int context )
{
json::jobject jobj = json::jobject();
if (iq.m_subtype != gloox::IQ::Result)
{
universal_resource error_desc;
ELOG("app")->error(WCOOL(L"组织结构树查看权限获取错误") + boost::shared_ptr<gloox::Tag>(iq.tag())->xml());
error_desc = XL("biz.OrganizationShowHandller.fail");
callback_(true, error_desc,jobj);
}
else
{
boost::shared_ptr<gloox::Tag> ptag(iq.findExtension(kExtUser_iq_filter_organization_show)->tag());
if (ptag)
{
gloox::Tag* tag_basic_permission = ptag->findChild("basic_permissions");
if (tag_basic_permission)
{
ConstTagList ptag_list = tag_basic_permission->findTagList("//permission");
for (ConstTagList::iterator it = ptag_list.begin(); it != ptag_list.end(); ++it)
{
if ((*it)->findAttribute("name") == "show_organization")
{
if ((*it)->cdata() == "true")
{
jobj["is_show_organization"] = true;
}
else
{
jobj["is_show_organization"] = false;
}
callback_(false, XL(""),jobj);
}
}
}
}
}
}
void whistleVcardHandler::handleIqID( const IQ& iq, int context )
{
switch( iq.subtype() )
{
case IQ::Result:
{
switch( context )
{
case VCardHandler::FetchVCard:
{
json::jobject jobj;
json::jobject status = json::jobject();
if (iq.findExtension( ExtVCard ))
{
boost::shared_ptr<gloox::Tag> ptag(iq.findExtension( ExtVCard )->tag());
for (TagList::const_iterator cit = ptag->children().begin(); cit != ptag->children().end(); ++cit) {
Tag* ptag = *cit;
if (ptag->name() == s_VcardPrivacy)
{
jobj[ptag->name()] = json::jobject(ptag->cdata());
}
else if (ptag->name() == s_VcardStatus)
{
//获取vcard协议改变 新的解析iq
Tag* presource = ptag->findChild("resource");
Tag* pshow = ptag->findChild("show");
if ( presource && pshow)
{
json::jobject itemdata;
itemdata["resource"] = presource->cdata();
itemdata["show"] = pshow->cdata();
status.arr_push(itemdata);
}
}
else
{
jobj[ptag->name()] = ptag->cdata();
}
}
jobj[s_VcardJid] = iq.from().bare();
gwhistleVcard::instance().handleVCard(iq.from(), jobj, status, waitCallback_);
}
break;
}
case VCardHandler::StoreVCard:
gwhistleVcard::instance().handleVCardResult(VCardHandler::StoreVCard, iq.from());
break;
}
}
break;
case IQ::Error:
{
switch( context )
{
case VCardHandler::FetchVCard:
if (!waitCallback_.empty())
{
waitCallback_();
}
else
{
gwhistleVcard::instance().updatedVcard(iq.from());
}
break;
case VCardHandler::StoreVCard:
gwhistleVcard::instance().handleVCardResult( (VCardHandler::VCardContext)context,
iq.from(),
iq.error() ? iq.error()->error()
: StanzaErrorUndefined );
break;
}
}
default:
break;
}
}
void writeVtkData(const UnstructuredGrid& grid,
const DataMap& data,
std::ostream& os)
{
if (grid.dimensions != 3) {
OPM_THROW(std::runtime_error, "Vtk output for 3d grids only");
}
os.precision(12);
os << "<?xml version=\"1.0\"?>\n";
PMap pm;
pm["type"] = "UnstructuredGrid";
Tag vtkfiletag("VTKFile", pm, os);
Tag ugtag("UnstructuredGrid", os);
int num_pts = grid.number_of_nodes;
int num_cells = grid.number_of_cells;
pm.clear();
pm["NumberOfPoints"] = boost::lexical_cast<std::string>(num_pts);
pm["NumberOfCells"] = boost::lexical_cast<std::string>(num_cells);
Tag piecetag("Piece", pm, os);
{
Tag pointstag("Points", os);
pm.clear();
pm["type"] = "Float64";
pm["Name"] = "Coordinates";
pm["NumberOfComponents"] = "3";
pm["format"] = "ascii";
Tag datag("DataArray", pm, os);
for (int i = 0; i < num_pts; ++i) {
Tag::indent(os);
os << grid.node_coordinates[3*i + 0] << ' '
<< grid.node_coordinates[3*i + 1] << ' '
<< grid.node_coordinates[3*i + 2] << '\n';
}
}
{
Tag cellstag("Cells", os);
pm.clear();
pm["type"] = "Int32";
pm["NumberOfComponents"] = "1";
pm["format"] = "ascii";
std::vector<int> cell_numpts;
cell_numpts.reserve(num_cells);
{
pm["Name"] = "connectivity";
Tag t("DataArray", pm, os);
int hf = 0;
for (int c = 0; c < num_cells; ++c) {
std::set<int> cell_pts;
for (; hf < grid.cell_facepos[c+1]; ++hf) {
int f = grid.cell_faces[hf];
const int* fnbeg = grid.face_nodes + grid.face_nodepos[f];
const int* fnend = grid.face_nodes + grid.face_nodepos[f+1];
cell_pts.insert(fnbeg, fnend);
}
cell_numpts.push_back(cell_pts.size());
Tag::indent(os);
std::copy(cell_pts.begin(), cell_pts.end(),
std::ostream_iterator<int>(os, " "));
os << '\n';
}
}
{
pm["Name"] = "offsets";
Tag t("DataArray", pm, os);
int offset = 0;
const int num_per_line = 10;
for (int c = 0; c < num_cells; ++c) {
if (c % num_per_line == 0) {
Tag::indent(os);
}
offset += cell_numpts[c];
os << offset << ' ';
if (c % num_per_line == num_per_line - 1
|| c == num_cells - 1) {
os << '\n';
}
}
}
std::vector<int> cell_foffsets;
cell_foffsets.reserve(num_cells);
{
pm["Name"] = "faces";
Tag t("DataArray", pm, os);
const int* fp = grid.cell_facepos;
int offset = 0;
for (int c = 0; c < num_cells; ++c) {
Tag::indent(os);
os << fp[c+1] - fp[c] << '\n';
++offset;
for (int hf = fp[c]; hf < fp[c+1]; ++hf) {
int f = grid.cell_faces[hf];
const int* np = grid.face_nodepos;
int f_num_pts = np[f+1] - np[f];
Tag::indent(os);
os << f_num_pts << ' ';
++offset;
std::copy(grid.face_nodes + np[f],
grid.face_nodes + np[f+1],
std::ostream_iterator<int>(os, " "));
os << '\n';
offset += f_num_pts;
}
cell_foffsets.push_back(offset);
}
}
{
pm["Name"] = "faceoffsets";
Tag t("DataArray", pm, os);
const int num_per_line = 10;
for (int c = 0; c < num_cells; ++c) {
if (c % num_per_line == 0) {
Tag::indent(os);
}
os << cell_foffsets[c] << ' ';
if (c % num_per_line == num_per_line - 1
|| c == num_cells - 1) {
os << '\n';
}
}
}
{
pm["type"] = "UInt8";
pm["Name"] = "types";
Tag t("DataArray", pm, os);
const int num_per_line = 10;
for (int c = 0; c < num_cells; ++c) {
if (c % num_per_line == 0) {
Tag::indent(os);
}
os << "42 ";
if (c % num_per_line == num_per_line - 1
|| c == num_cells - 1) {
os << '\n';
}
}
}
}
{
pm.clear();
if (data.find("saturation") != data.end()) {
pm["Scalars"] = "saturation";
} else if (data.find("pressure") != data.end()) {
pm["Scalars"] = "pressure";
}
Tag celldatatag("CellData", pm, os);
pm.clear();
pm["NumberOfComponents"] = "1";
pm["format"] = "ascii";
pm["type"] = "Float64";
for (DataMap::const_iterator dit = data.begin(); dit != data.end(); ++dit) {
pm["Name"] = dit->first;
const std::vector<double>& field = *(dit->second);
const int num_comps = field.size()/grid.number_of_cells;
pm["NumberOfComponents"] = boost::lexical_cast<std::string>(num_comps);
Tag ptag("DataArray", pm, os);
const int num_per_line = num_comps == 1 ? 5 : num_comps;
for (int item = 0; item < num_cells*num_comps; ++item) {
if (item % num_per_line == 0) {
Tag::indent(os);
}
double value = field[item];
if (std::fabs(value) < std::numeric_limits<double>::min()) {
// Avoiding denormal numbers to work around
// bug in Paraview.
value = 0.0;
}
os << value << ' ';
if (item % num_per_line == num_per_line - 1
|| item == num_cells - 1) {
os << '\n';
}
}
}
}
}
static CTy *
declspecs(int *sclass)
{
CTy *t;
SrcPos *pos;
Sym *sym;
int bits;
enum {
BITCHAR = 1<<0,
BITSHORT = 1<<1,
BITINT = 1<<2,
BITLONG = 1<<3,
BITLONGLONG = 1<<4,
BITSIGNED = 1<<5,
BITUNSIGNED = 1<<6,
BITFLOAT = 1<<7,
BITDOUBLE = 1<<8,
BITENUM = 1<<9,
BITSTRUCT = 1<<10,
BITVOID = 1<<11,
BITIDENT = 1<<12,
};
t = 0;
bits = 0;
pos = &tok->pos;
*sclass = SCNONE;
for(;;) {
if(issclasstok(tok)) {
if(*sclass != SCNONE)
errorposf(pos, "multiple storage classes in declaration specifiers.");
switch(tok->k) {
case TOKEXTERN:
*sclass = SCEXTERN;
break;
case TOKSTATIC:
*sclass = SCSTATIC;
break;
case TOKREGISTER:
*sclass = SCREGISTER;
break;
case TOKAUTO:
*sclass = SCAUTO;
break;
case TOKTYPEDEF:
*sclass = SCTYPEDEF;
break;
default:
panic("internal error");
}
next();
continue;
}
switch(tok->k) {
case TOKCONST:
case TOKVOLATILE:
next();
break;
case TOKSTRUCT:
case TOKUNION:
if(bits)
goto err;
bits |= BITSTRUCT;
t = ptag();
goto done;
case TOKENUM:
if(bits)
goto err;
bits |= BITENUM;
t = ptag();
goto done;
case TOKVOID:
if(bits&BITVOID)
goto err;
bits |= BITVOID;
next();
goto done;
case TOKCHAR:
if(bits&BITCHAR)
goto err;
bits |= BITCHAR;
next();
break;
case TOKSHORT:
if(bits&BITSHORT)
goto err;
bits |= BITSHORT;
next();
break;
case TOKINT:
if(bits&BITINT)
goto err;
bits |= BITINT;
next();
break;
case TOKLONG:
if(bits&BITLONGLONG)
goto err;
if(bits&BITLONG) {
bits &= ~BITLONG;
bits |= BITLONGLONG;
} else {
bits |= BITLONG;
}
next();
break;
case TOKFLOAT:
if(bits&BITFLOAT)
goto err;
bits |= BITFLOAT;
next();
break;
case TOKDOUBLE:
if(bits&BITDOUBLE)
goto err;
bits |= BITDOUBLE;
next();
break;
case TOKSIGNED:
if(bits&BITSIGNED)
goto err;
bits |= BITSIGNED;
next();
break;
case TOKUNSIGNED:
if(bits&BITUNSIGNED)
goto err;
bits |= BITUNSIGNED;
next();
break;
case TOKIDENT:
sym = lookup(syms, tok->v);
if(sym && sym->k == SYMTYPE)
t = sym->type;
if(t && !bits) {
bits |= BITIDENT;
next();
goto done;
}
/* fallthrough */
default:
goto done;
}
}
done:
switch(bits){
case BITFLOAT:
return cfloat;
case BITDOUBLE:
return cdouble;
case BITLONG|BITDOUBLE:
return cldouble;
case BITSIGNED|BITCHAR:
case BITCHAR:
return cchar;
case BITUNSIGNED|BITCHAR:
return cuchar;
case BITSIGNED|BITSHORT|BITINT:
case BITSHORT|BITINT:
case BITSHORT:
return cshort;
case BITUNSIGNED|BITSHORT|BITINT:
case BITUNSIGNED|BITSHORT:
return cushort;
case BITSIGNED|BITINT:
case BITSIGNED:
case BITINT:
case 0:
return cint;
case BITUNSIGNED|BITINT:
case BITUNSIGNED:
return cuint;
case BITSIGNED|BITLONG|BITINT:
case BITSIGNED|BITLONG:
case BITLONG|BITINT:
case BITLONG:
return clong;
case BITUNSIGNED|BITLONG|BITINT:
case BITUNSIGNED|BITLONG:
return culong;
case BITSIGNED|BITLONGLONG|BITINT:
case BITSIGNED|BITLONGLONG:
case BITLONGLONG|BITINT:
case BITLONGLONG:
return cllong;
case BITUNSIGNED|BITLONGLONG|BITINT:
case BITUNSIGNED|BITLONGLONG:
return cullong;
case BITVOID:
t = cvoid;
return t;
case BITENUM:
case BITSTRUCT:
case BITIDENT:
return t;
default:
goto err;
}
err:
errorposf(pos, "invalid declaration specifiers");
return 0;
}
void writeFrames(const Kinect::FrameSource::IntrinsicParameters& ip,const Kinect::FrameBuffer& color,const Kinect::MeshBuffer& mesh,const char* lwoFileName)
{
/* Create the texture file name: */
std::string textureFileName(lwoFileName,Misc::getExtension(lwoFileName));
textureFileName.append("-color.png");
/* Write the color frame as a texture image: */
{
Images::RGBImage texImage(color.getSize(0),color.getSize(1));
Images::RGBImage::Color* tiPtr=texImage.modifyPixels();
const unsigned char* cfPtr=reinterpret_cast<const unsigned char*>(color.getBuffer());
for(int y=0;y<color.getSize(1);++y)
for(int x=0;x<color.getSize(0);++x,++tiPtr,cfPtr+=3)
*tiPtr=Images::RGBImage::Color(cfPtr);
Images::writeImageFile(texImage,textureFileName.c_str());
}
/* Open the LWO file: */
IO::FilePtr lwoFile=IO::openFile(lwoFileName,IO::File::WriteOnly);
lwoFile->setEndianness(Misc::BigEndian);
/* Create the LWO file structure via the FORM chunk: */
{
IFFChunkWriter form(lwoFile,"FORM");
form.write<char>("LWO2",4);
/* Create the TAGS chunk: */
{
IFFChunkWriter tags(&form,"TAGS");
tags.writeString("ColorImage");
tags.writeChunk();
}
/* Create the LAYR chunk: */
{
IFFChunkWriter layr(&form,"LAYR");
layr.write<Misc::UInt16>(0U);
layr.write<Misc::UInt16>(0x0U);
for(int i=0;i<3;++i)
layr.write<Misc::Float32>(0.0f);
layr.writeString("DepthImage");
layr.writeChunk();
}
/* Create an index map for all vertices to omit unused vertices: */
unsigned int* indices=new unsigned int[mesh.numVertices];
for(unsigned int i=0;i<mesh.numVertices;++i)
indices[i]=~0x0U;
unsigned int numUsedVertices=0;
/* Create the PNTS, BBOX and VMAP chunks in one go: */
{
typedef Kinect::FrameSource::IntrinsicParameters::PTransform PTransform;
typedef PTransform::Point Point;
typedef Geometry::Box<Point::Scalar,3> Box;
IFFChunkWriter bbox(&form,"BBOX");
IFFChunkWriter pnts(&form,"PNTS");
IFFChunkWriter vmap(&form,"VMAP");
/* Write the VMAP header: */
vmap.write<char>("TXUV",4);
vmap.write<Misc::UInt16>(2U);
vmap.writeString("ColorImageUV");
/* Process all triangle vertices: */
Box pBox=Box::empty;
const Kinect::MeshBuffer::Vertex* vertices=mesh.getVertices();
const Kinect::MeshBuffer::Index* tiPtr=mesh.getTriangleIndices();
for(unsigned int i=0;i<mesh.numTriangles*3;++i,++tiPtr)
{
/* Check if the triangle vertex doesn't already have an index: */
if(indices[*tiPtr]==~0x0U)
{
/* Assign an index to the triangle vertex: */
indices[*tiPtr]=numUsedVertices;
/* Transform the mesh vertex to camera space using the depth projection matrix: */
Point dp(vertices[*tiPtr].position.getXyzw());
Point cp=ip.depthProjection.transform(dp);
/* Transform the depth-space point to texture space using the color projection matrix: */
Point tp=ip.colorProjection.transform(dp);
/* Add the point to the bounding box: */
pBox.addPoint(cp);
/* Store the point and its texture coordinates: */
pnts.writePoint(cp);
vmap.writeVarIndex(numUsedVertices);
for(int i=0;i<2;++i)
vmap.write<Misc::Float32>(tp[i]);
++numUsedVertices;
}
}
/* Write the bounding box: */
bbox.writeBox(pBox);
/* Write the BBOX, PNTS, and VMAP chunks: */
bbox.writeChunk();
pnts.writeChunk();
vmap.writeChunk();
}
/* Create the POLS chunk: */
{
IFFChunkWriter pols(&form,"POLS");
pols.write<char>("FACE",4);
const Kinect::MeshBuffer::Index* tiPtr=mesh.getTriangleIndices();
for(unsigned int triangleIndex=0;triangleIndex<mesh.numTriangles;++triangleIndex,tiPtr+=3)
{
pols.write<Misc::UInt16>(3U);
for(int i=0;i<3;++i)
pols.writeVarIndex(indices[tiPtr[2-i]]);
}
pols.writeChunk();
}
/* Delete the vertex index map: */
delete[] indices;
/* Create the PTAG chunk: */
{
IFFChunkWriter ptag(&form,"PTAG");
ptag.write<char>("SURF",4);
for(unsigned int triangleIndex=0;triangleIndex<mesh.numTriangles;++triangleIndex)
{
ptag.writeVarIndex(triangleIndex);
ptag.write<Misc::UInt16>(0U);
}
ptag.writeChunk();
}
/* Create the CLIP chunk: */
{
IFFChunkWriter clip(&form,"CLIP");
clip.write<Misc::UInt32>(1U);
/* Create the STIL chunk: */
{
IFFChunkWriter stil(&clip,"STIL",true);
stil.writeString(textureFileName.c_str());
stil.writeChunk();
}
clip.writeChunk();
}
/* Create the SURF chunk: */
{
IFFChunkWriter surf(&form,"SURF");
surf.writeString("ColorImage");
surf.writeString("");
/* Create the SIDE subchunk: */
{
IFFChunkWriter side(&surf,"SIDE",true);
side.write<Misc::UInt16>(3U);
side.writeChunk();
}
/* Create the SMAN subchunk: */
{
IFFChunkWriter sman(&surf,"SMAN",true);
sman.write<Misc::Float32>(Math::rad(90.0f));
sman.writeChunk();
}
/* Create the COLR subchunk: */
{
IFFChunkWriter colr(&surf,"COLR",true);
colr.writeColor(1.0f,1.0f,1.0f);
colr.writeVarIndex(0U);
colr.writeChunk();
}
/* Create the DIFF subchunk: */
{
IFFChunkWriter diff(&surf,"DIFF",true);
diff.write<Misc::Float32>(1.0f);
diff.writeVarIndex(0U);
diff.writeChunk();
}
/* Create the LUMI subchunk: */
{
IFFChunkWriter lumi(&surf,"LUMI",true);
lumi.write<Misc::Float32>(0.0f);
lumi.writeVarIndex(0U);
lumi.writeChunk();
}
/* Create the BLOK subchunk: */
{
IFFChunkWriter blok(&surf,"BLOK",true);
/* Create the IMAP subchunk: */
{
IFFChunkWriter imap(&blok,"IMAP",true);
imap.writeString("1");
/* Create the CHAN subchunk: */
{
IFFChunkWriter chan(&imap,"CHAN",true);
chan.write<char>("COLR",4);
chan.writeChunk();
}
imap.writeChunk();
}
/* Create the PROJ subchunk: */
{
IFFChunkWriter proj(&blok,"PROJ",true);
proj.write<Misc::UInt16>(5U);
proj.writeChunk();
}
/* Create the IMAG subchunk: */
{
IFFChunkWriter imag(&blok,"IMAG",true);
imag.writeVarIndex(1U);
imag.writeChunk();
}
/* Create the VMAP subchunk: */
{
IFFChunkWriter vmap(&blok,"VMAP",true);
vmap.writeString("ColorImageUV");
vmap.writeChunk();
}
blok.writeChunk();
}
/* Write the SURF chunk: */
surf.writeChunk();
}
/* Write the FORM chunk: */
form.writeChunk();
}
}
