void ModelEditor::newColors(ColorHelper help) {
_Tn("newColors()");
int newSize = FileSize + sizeof(ModelColorDef) * help.nColors;
char *n = f;
f = SMemNew(newSize);
memcpy(f, n, FileSize);
SetStructure();
header_m->ofsColors = FileSize;
header_m->nColors = help.nColors;
FileSize = newSize;
FillLine();
for (int i = 0; i < help.nColors; i++) {
writeAnimation(&(color_m[i].color), help.color[i]);
writeAnimation(&(color_m[i].opacity), help.opacity[i]);
}
FillLine();
}
void ModelEditor::newBones(BoneHelper help) {
_Tn("newBones");
int newSize = FileSize + sizeof(ModelBoneDef) * help.nBones;
char *n = f;
f = SMemNew(newSize);
memcpy(f, n, FileSize);
SetStructure();
header_m->ofsBones = FileSize;
header_m->nBones = help.nBones;
memcpy(f + FileSize, help.Bones, help.nBones * sizeof(ModelBoneDef));
FileSize = newSize;
FillLine();
for (int i = 0; i < header_m->nBones; i++) {
printf("Processing Bone %d\n", i);
writeAnimation(&(bone_m[i].rotation), help.rotation[i]);
writeAnimation(&(bone_m[i].translation), help.translation[i]);
writeAnimation(&(bone_m[i].scaling), help.scaling[i]);
}
}
void ModelEditor::newTexAnim(TexAnimHelper help) {
_Tn("newTexAnim");
int newSize = FileSize + sizeof(ModelTexAnimDef) * help.nTexAnims;
char *n = f;
f = SMemNew(newSize);
memcpy(f, n, FileSize);
memcpy(f + FileSize, help.TexAnims, sizeof(ModelTexAnimDef)
* help.nTexAnims);
SetStructure();
header_m->ofsTexAnims = FileSize;
header_m->nTexAnims = help.nTexAnims;
FileSize = newSize;
FillLine();
for (int i = 0; i < header_m->nTexAnims; i++) {
writeAnimation(&(texanim_m[i].trans), help.trans[i]);
writeAnimation(&(texanim_m[i].rot), help.rot[i]);
writeAnimation(&(texanim_m[i].scale), help.scaling[i]);
}
FillLine();
}
void ModelEditor::newCameras(CamHelper help) {
_Tn("newCameras");
int newSize = FileSize + sizeof(ModelCameraDef) * help.nCameras;
char *n = f;
f = SMemNew(newSize);
memcpy(f, n, FileSize);
memcpy(f + FileSize, help.camera, sizeof(ModelCameraDef) * help.nCameras);
SetStructure();
header_m->ofsCameras = FileSize;
header_m->nCameras = help.nCameras;
FileSize = newSize;
FillLine();
for (int i = 0; i < header_m->nCameras; i++) {
writeAnimation(&(cam_m[i].rot), help.rotation[i]);
writeAnimation(&(cam_m[i].transTarget), help.translationtar[i]);
writeAnimation(&(cam_m[i].transPos), help.translationpos[i]);
}
FillLine();
//I only know about two different cameras...
int nCamLookup = 2;
newSize = FileSize + sizeof(short) * nCamLookup;
n = f;
f = SMemNew(newSize);
memcpy(f, n, FileSize);
SetStructure();
header_m->ofsCameraLookup = FileSize;
header_m->nCameraLookup = nCamLookup;
SetStructure();
for (int i = 0; i < header_m->nCameraLookup; i++) {
for (int j = 0; j < header_m->nCameras; j++) {
if (cam_m[j].id == i) {
camlookup_m[i] = j;
break;
} else
camlookup_m[i] = -1;
}
}
FileSize = newSize;
FillLine();
}
void ModelEditor::newTransparency(AnimationHelper<short> *help, int nTrans) {
_Tn("void ModelEditor::newTransparency(AnimationHelper<short> *help,int nTrans)");
int newSize = FileSize + sizeof(AnimationBlock) * nTrans;
char *n = f;
f = SMemNew(newSize);
memcpy(f, n, FileSize);
SetStructure();
header_m->ofsTransparency = FileSize;
header_m->nTransparency = nTrans;
FileSize = newSize;
FillLine();
for (int i = 0; i < nTrans; i++) {
writeAnimation(&(trans_m[i].trans), help[i]);
}
}
//---------------------------------------------------------------------
void SkeletonSerializer::exportSkeleton(const Skeleton* pSkeleton,
const String& filename, Endian endianMode)
{
// Decide on endian mode
determineEndianness(endianMode);
String msg;
mpfFile = fopen(filename.c_str(), "wb");
if (!mpfFile)
{
OGRE_EXCEPT(Exception::ERR_CANNOT_WRITE_TO_FILE,
"Unable to open file " + filename + " for writing",
"SkeletonSerializer::exportSkeleton");
}
writeFileHeader();
// Write main skeleton data
LogManager::getSingleton().logMessage("Exporting bones..");
writeSkeleton(pSkeleton);
LogManager::getSingleton().logMessage("Bones exported.");
// Write all animations
unsigned short numAnims = pSkeleton->getNumAnimations();
LogManager::getSingleton().stream()
<< "Exporting animations, count=" << numAnims;
for (unsigned short i = 0; i < numAnims; ++i)
{
Animation* pAnim = pSkeleton->getAnimation(i);
LogManager::getSingleton().stream()
<< "Exporting animation: " << pAnim->getName();
writeAnimation(pSkeleton, pAnim);
LogManager::getSingleton().logMessage("Animation exported.");
}
// Write links
Skeleton::LinkedSkeletonAnimSourceIterator linkIt =
pSkeleton->getLinkedSkeletonAnimationSourceIterator();
while(linkIt.hasMoreElements())
{
const LinkedSkeletonAnimationSource& link = linkIt.getNext();
writeSkeletonAnimationLink(pSkeleton, link);
}
fclose(mpfFile);
}
//---------------------------------------------------------------------
void SkeletonSerializer::exportSkeleton(const Skeleton* pSkeleton,
DataStreamPtr stream, SkeletonVersion ver, Endian endianMode)
{
setWorkingVersion(ver);
// Decide on endian mode
determineEndianness(endianMode);
String msg;
mStream = stream;
if (!stream->isWriteable())
{
OGRE_EXCEPT(Exception::ERR_CANNOT_WRITE_TO_FILE,
"Unable to write to stream " + stream->getName(),
"SkeletonSerializer::exportSkeleton");
}
writeFileHeader();
// Write main skeleton data
LogManager::getSingleton().logMessage("Exporting bones..");
writeSkeleton(pSkeleton, ver);
LogManager::getSingleton().logMessage("Bones exported.");
// Write all animations
unsigned short numAnims = pSkeleton->getNumAnimations();
LogManager::getSingleton().stream()
<< "Exporting animations, count=" << numAnims;
for (unsigned short i = 0; i < numAnims; ++i)
{
Animation* pAnim = pSkeleton->getAnimation(i);
LogManager::getSingleton().stream()
<< "Exporting animation: " << pAnim->getName();
writeAnimation(pSkeleton, pAnim, ver);
LogManager::getSingleton().logMessage("Animation exported.");
}
// Write links
Skeleton::LinkedSkeletonAnimSourceIterator linkIt =
pSkeleton->getLinkedSkeletonAnimationSourceIterator();
while(linkIt.hasMoreElements())
{
const LinkedSkeletonAnimationSource& link = linkIt.getNext();
writeSkeletonAnimationLink(pSkeleton, link);
}
}
std::string SkeletonData::writeAnimations(Joint * j, unsigned int indent){
std::stringstream json;
indent++;
json << writeAnimation(j->translateX, "translateX", indent) << "," << std::endl;
json << writeAnimation(j->translateY, "translateY", indent) << "," << std::endl;
json << writeAnimation(j->translateZ, "translateZ", indent) << "," << std::endl;
json << writeAnimation(j->rotate, "rotate", indent) << "," << std::endl;
json << writeAnimation(j->scaleX, "scaleX", indent) << "," << std::endl;
json << writeAnimation(j->scaleY, "scaleY", indent) << "," << std::endl;
json << writeAnimation(j->scaleZ, "scaleZ", indent) << std::endl;
return json.str();
}
void ModelEditor::newLights(LightHelper help){
_Tn("void ModelEditor::newLights(LightHelper help)");
int newSize = FileSize + sizeof(ModelLightDef) * help.nLights;
char *n = f;
f = SMemNew(newSize);
memcpy(f, n, FileSize);
memcpy(f+FileSize,help.lights,sizeof(ModelLightDef) * help.nLights);
SetStructure();
header_m->ofsLights = FileSize;
header_m->nLights = help.nLights;
FileSize = newSize;
FillLine();
for (int i = 0; i < help.nLights; i++) {
writeAnimation(&(light_m[i].ambColor), help.AmbientColor[i]);
writeAnimation(&(light_m[i].ambIntensity), help.AmbientIntensity[i]);
writeAnimation(&(light_m[i].diffcolor), help.DiffuseColor[i]);
writeAnimation(&(light_m[i].diffintensity), help.DiffuseIntensity[i]);
writeAnimation(&(light_m[i].attEnd), help.AttenuationEnd[i]);
writeAnimation(&(light_m[i].attStart), help.AttenuationStart[i]);
writeAnimation(&(light_m[i].Enabled), help.Enabled[i]);
}
FillLine();
}
void ModelEditor::newRibbons(RibbonHelper help){
_Tn("void ModelEditor::newRibbons(RibbonHelper help)");
int newSize = FileSize + sizeof(ModelRibbonEmitterDef) * help.nRibbons;
char *n = f;
f = SMemNew(newSize);
memcpy(f, n, FileSize);
memcpy(f+FileSize,help.ribbons,sizeof(ModelRibbonEmitterDef) * help.nRibbons);
SetStructure();
header_m->ofsRibbonEmitters = FileSize;
header_m->nRibbonEmitters = help.nRibbons;
FileSize = newSize;
FillLine();
for (int i = 0; i < help.nRibbons; i++) {
writeAnimation(&(ribbon_m[i].color), help.Color[i]);
writeAnimation(&(ribbon_m[i].opacity), help.Opacity[i]);
writeAnimation(&(ribbon_m[i].above), help.Above[i]);
writeAnimation(&(ribbon_m[i].below), help.Below[i]);
writeAnimation(&(ribbon_m[i].enabled), help.Enabled[i]);
writeAnimation(&(ribbon_m[i].unk1), help.Unk1[i]);
}
FillLine();
}
void ModelEditor::newParticles(ParticleHelper help) {
_Tn("void ModelEditor::newParticles(ParticleHelper help) ");
int newSize = FileSize + sizeof(ModelParticleEmitterDef) * help.nParticles;
char *n = f;
f = SMemNew(newSize);
memcpy(f, n, FileSize);
SetStructure();
header_m->ofsParticleEmitters = FileSize;
header_m->nParticleEmitters = help.nParticles;
memcpy(f + FileSize, help.particles, help.nParticles
* sizeof(ModelParticleEmitterDef));
FileSize = newSize;
FillLine();
for (int i = 0; i < header_m->nParticleEmitters; i++) {
writeAnimation(&(part_m[i].Emissionspeed), help.Emissionspeed[i]);
writeAnimation(&(part_m[i].SpeedVariation), help.SpeedVariation[i]);
writeAnimation(&(part_m[i].VerticalRange), help.VerticalRange[i]);
writeAnimation(&(part_m[i].HorizontalRange), help.HorizontalRange[i]);
writeAnimation(&(part_m[i].Gravity), help.Gravity[i]);
writeAnimation(&(part_m[i].Lifespan), help.Lifespan[i]);
writeAnimation(&(part_m[i].EmissionRate), help.EmissionRate[i]);
writeAnimation(&(part_m[i].EmissionAreaLength),
help.EmissionAreaLength[i]);
writeAnimation(&(part_m[i].EmissionAreaWidth),
help.EmissionAreaWidth[i]);
writeAnimation(&(part_m[i].Gravity2), help.Gravity2[i]);
writeAnimation(&(part_m[i].Enabled), help.Enabled[i]);
}
//start fake color
{
for (int i = 0; i < header_m->nParticleEmitters; i++) {
part_m[i].colors.nTimes = help.info[i].nColor;
part_m[i].colors.ofsTimes = FileSize;
short *time = new short[help.info[i].nColor];
for (int k = 0; k < help.info[i].nColor; k++) {
time[k] = help.info[i].Color[k].timestamp;
}
writeAnimblockData(time, help.info[i].nColor);
part_m[i].colors.nKeys = help.info[i].nColor;
part_m[i].colors.ofsKeys = FileSize;
Vec3D *val = new Vec3D[help.info[i].nColor];
for (int k = 0; k < help.info[i].nColor; k++) {
val[k] = help.info[i].Color[k].value;
}
writeAnimblockData(val, help.info[i].nColor);
}
FillLine();
}
//end fake color
//start fake opacity
{
for (int i = 0; i < header_m->nParticleEmitters; i++) {
part_m[i].opacity.nTimes = help.info[i].nOpacity;
part_m[i].opacity.ofsTimes = FileSize;
short *time = new short[help.info[i].nOpacity];
for (int k = 0; k < help.info[i].nOpacity; k++) {
time[k] = help.info[i].Opacity[k].timestamp;
}
writeAnimblockData(time, help.info[i].nOpacity);
part_m[i].opacity.nKeys = help.info[i].nOpacity;
part_m[i].opacity.ofsKeys = FileSize;
short *val = new short[help.info[i].nOpacity];
for (int k = 0; k < help.info[i].nOpacity; k++) {
val[k] = help.info[i].Opacity[k].value;
}
writeAnimblockData(val, help.info[i].nOpacity);
}
FillLine();
}
//end fake opacity
//start fake sizes
{
for (int i = 0; i < header_m->nParticleEmitters; i++) {
part_m[i].sizes.nTimes = help.info[i].nSize;
part_m[i].sizes.ofsTimes = FileSize;
short *time = new short[help.info[i].nSize];
for (int k = 0; k < help.info[i].nSize; k++) {
time[k] = help.info[i].Size[k].timestamp;
}
writeAnimblockData(time, help.info[i].nSize);
part_m[i].sizes.nKeys = help.info[i].nSize;
part_m[i].sizes.ofsKeys = FileSize;
Vec2D *val = new Vec2D[help.info[i].nSize];
for (int k = 0; k < help.info[i].nSize; k++) {
val[k] = help.info[i].Size[k].value;
}
writeAnimblockData(val, help.info[i].nSize);
}
FillLine();
}
//end fake sizes
//start fake Intensity
{
for (int i = 0; i < header_m->nParticleEmitters; i++) {
part_m[i].intensity.nTimes = help.info[i].nIntensity;
part_m[i].intensity.ofsTimes = FileSize;
short *time = new short[help.info[i].nIntensity];
for (int k = 0; k < help.info[i].nIntensity; k++) {
time[k] = help.info[i].Intensity[k].timestamp;
}
writeAnimblockData(time, help.info[i].nIntensity);
part_m[i].intensity.nKeys = help.info[i].nIntensity;
part_m[i].intensity.ofsKeys = FileSize;
short *val = new short[help.info[i].nIntensity];
for (int k = 0; k < help.info[i].nIntensity; k++) {
val[k] = help.info[i].Intensity[k].value;
}
writeAnimblockData(val, help.info[i].nIntensity);
}
FillLine();
}
//end fake Intensity
//start fake unk
{
for (int i = 0; i < header_m->nParticleEmitters; i++) {
part_m[i].unknownblock.nTimes = help.info[i].nUnk;
part_m[i].unknownblock.ofsTimes = FileSize;
short *time = new short[help.info[i].nUnk];
for (int k = 0; k < help.info[i].nUnk; k++) {
time[k] = help.info[i].Unk[k].timestamp;
}
writeAnimblockData(time, help.info[i].nUnk);
part_m[i].unknownblock.nKeys = help.info[i].nUnk;
part_m[i].unknownblock.ofsKeys = FileSize;
short *val = new short[help.info[i].nUnk];
for (int k = 0; k < help.info[i].nUnk; k++) {
val[k] = help.info[i].Unk[k].value;
}
writeAnimblockData(val, help.info[i].nUnk);
}
FillLine();
}
//end fake unk
//now the referenced files:
//models
for (int i = 0; i < help.nParticles; i++) {
int newSize = FileSize + help.info[i].lengthModelName;
char *n = f;
f = SMemNew(newSize);
memcpy(f, n, FileSize);
SetStructure();
part_m[i].ofsModelName = FileSize;
memcpy(f + FileSize, help.info[i].ModelName,
help.info[i].lengthModelName);
FileSize = newSize;
FillLine();
}
//particles
for (int i = 0; i < help.nParticles; i++) {
int newSize = FileSize + help.info[i].lengthParticleName;
char *n = f;
f = SMemNew(newSize);
memcpy(f, n, FileSize);
SetStructure();
part_m[i].ofsParticleName = FileSize;
memcpy(f + FileSize, help.info[i].ParticleName,
help.info[i].lengthParticleName);
FileSize = newSize;
FillLine();
}
}
//---------------------------------------------------------------------
void XMLSkeletonSerializer::exportSkeleton(const Skeleton* pSkeleton,
const String& filename)
{
LogManager::getSingleton().logMessage("XMLSkeletonSerializer writing "
" skeleton data to " + filename + "...");
mXMLDoc = new TiXmlDocument();
mXMLDoc->InsertEndChild(TiXmlElement("skeleton"));
TiXmlElement* rootNode = mXMLDoc->RootElement();
LogManager::getSingleton().logMessage("Populating DOM...");
// Write main skeleton data
LogManager::getSingleton().logMessage("Exporting bones..");
writeSkeleton(pSkeleton);
LogManager::getSingleton().logMessage("Bones exported.");
// Write all animations
unsigned short numAnims = pSkeleton->getNumAnimations();
String msg = "Exporting animations, count=" + StringConverter::toString(numAnims);
LogManager::getSingleton().logMessage(msg);
TiXmlElement* animsNode =
rootNode->InsertEndChild(TiXmlElement("animations"))->ToElement();
for (unsigned short i = 0; i < numAnims; ++i)
{
Animation* pAnim = pSkeleton->getAnimation(i);
msg = "Exporting animation: " + pAnim->getName();
LogManager::getSingleton().logMessage(msg);
writeAnimation(animsNode, pAnim);
LogManager::getSingleton().logMessage("Animation exported.");
}
// Write links
Skeleton::LinkedSkeletonAnimSourceIterator linkIt =
pSkeleton->getLinkedSkeletonAnimationSourceIterator();
if (linkIt.hasMoreElements())
{
LogManager::getSingleton().logMessage("Exporting animation links.");
TiXmlElement* linksNode =
rootNode->InsertEndChild(TiXmlElement("animationlinks"))->ToElement();
while(linkIt.hasMoreElements())
{
const LinkedSkeletonAnimationSource& link = linkIt.getNext();
writeSkeletonAnimationLink(linksNode, link);
}
}
LogManager::getSingleton().logMessage("DOM populated, writing XML file..");
// Write out to a file
if(! mXMLDoc->SaveFile(filename.c_str()) )
{
LogManager::getSingleton().logMessage("XMLSkeletonSerializer failed writing the XML file.", LML_CRITICAL);
}
else
{
LogManager::getSingleton().logMessage("XMLSkeletonSerializer export successful.");
}
delete mXMLDoc;
}
