Extension::Extension(X509_EXTENSION *ext) throw (CertificationException)
{
if (ext == NULL)
{
throw CertificationException(CertificationException::INVALID_EXTENSION, "Extension::Extension");
}
this->objectIdentifier = ObjectIdentifier(OBJ_dup(ext->object));
this->critical = X509_EXTENSION_get_critical(ext)?true:false;
this->value = ByteArray(ext->value->data, ext->value->length);
}
//---------------------------------------------------------------
void ControllerExporter::exportControllers( ExportNode* exportNode )
{
ControllerList* controllerList = exportNode->getControllerList();
if ( !controllerList->hasControllers() )
return;
size_t controllerCount = controllerList->getControllerCount();
for ( size_t j = 0; j < controllerCount; ++j)
{
size_t i = controllerCount - j - 1;
Controller* controller = controllerList->getController(i);
ObjectIdentifier poseAfter(controller->getDerivedObject(), (int)i);
if ( mDocumentExporter->isExportedObject(poseAfter) )
{
if ( controller->getType() == Controller::SKIN )
determineReferencedJoints(exportNode, (SkinController*)controller);
continue;
}
String controllerId = getControllerId(*exportNode, controllerCount - i, controller->getType());
String controllerSource;
if ( i < controllerCount - 1)
{
ExportNode* previousControllerExportNode = mDocumentExporter->getExportedObjectExportNode(ObjectIdentifier(controllerList->getController(i+1)->getDerivedObject(), (int)i+1));
assert( previousControllerExportNode );
controllerSource = '#' + getControllerId(*previousControllerExportNode, controllerCount - i - 1, controllerList->getController(i+1)->getType());
}
else
{
ExportNode* geometryExportNode = mDocumentExporter->getExportedObjectExportNode(ObjectIdentifier(exportNode->getInitialPose()));
assert( geometryExportNode );
controllerSource = '#' + GeometriesExporter::getGeometryId(*geometryExportNode);
}
exportController(exportNode, controller, controllerId, controllerSource);
mDocumentExporter->insertExportedObject(poseAfter, exportNode);
}
}
//---------------------------------------------------------------
void LightExporter::exportLight( ExportNode* exportNode )
{
if ( !exportNode->getIsInVisualScene() )
return;
String lightId = getLightId(*exportNode);
INode * iNode = exportNode->getINode();
LightObject* lightObject = (LightObject*) (iNode->GetObjectRef());
if ( !lightObject )
return;
if ( mDocumentExporter->isExportedObject(ObjectIdentifier(lightObject)) )
return;
mDocumentExporter->insertExportedObject(ObjectIdentifier(lightObject), exportNode);
// Retrieve the target node, if we are not baking matrices.
// Baked matrices must always sample the transform!
ULONG ClassId = lightObject->ClassID().PartA();
bool isTargeted = !mDocumentExporter->getOptions().getBakeMatrices() && (ClassId == SPOT_LIGHT_CLASS_ID || ClassId == TDIR_LIGHT_CLASS_ID);
INode* targetNode = isTargeted ? iNode->GetTarget() : 0;
// some lights are not supported at all
switch (ClassId)
{
case FSPOT_LIGHT_CLASS_ID:
case SPOT_LIGHT_CLASS_ID:
case DIR_LIGHT_CLASS_ID:
case TDIR_LIGHT_CLASS_ID:
case SKY_LIGHT_CLASS_ID_PART_A:
case OMNI_LIGHT_CLASS_ID:
break;
default:
return;
}
// Determine the light's type
bool isSpot = false;
bool isDirectional = false;
bool isPoint = false;
bool isSky = false;
COLLADASW::Light::LightType lightType;
switch (ClassId)
{
case FSPOT_LIGHT_CLASS_ID:
case SPOT_LIGHT_CLASS_ID:
lightType = COLLADASW::Light::SPOT;
isSpot = true;
break;
case DIR_LIGHT_CLASS_ID:
case TDIR_LIGHT_CLASS_ID:
lightType = COLLADASW::Light::DIRECTIONAL;
isDirectional = true;
break;
case SKY_LIGHT_CLASS_ID_PART_A:
lightType = COLLADASW::Light::POINT;
isSky = true;
break;
case OMNI_LIGHT_CLASS_ID:
lightType = COLLADASW::Light::POINT;
isPoint = true;
break;
}
COLLADASW::Light * colladaLight = 0;
switch ( lightType )
{
case COLLADASW::Light::DIRECTIONAL:
colladaLight = new COLLADASW::DirectionalLight(COLLADASW::LibraryLights::mSW, lightId, COLLADASW::Utils::checkNCName(NativeString(exportNode->getINode()->GetName())));
break;
case COLLADASW::Light::POINT:
colladaLight = new COLLADASW::PointLight(COLLADASW::LibraryLights::mSW, lightId, COLLADASW::Utils::checkNCName(NativeString(exportNode->getINode()->GetName())));
break;
case COLLADASW::Light::SPOT:
colladaLight = new COLLADASW::SpotLight(COLLADASW::LibraryLights::mSW, lightId, COLLADASW::Utils::checkNCName(NativeString(exportNode->getINode()->GetName())));
break;
}
// Retrieve the parameter block
IParamBlock* parameters = 0;
IParamBlock2* parametersSky = 0;
if (isSky)
parametersSky = (IParamBlock2*) lightObject->GetReference(MaxLight::PBLOCK_REF_SKY);
else
parameters = (IParamBlock*) lightObject->GetReference(MaxLight::PBLOCK_REF);
if (!parameters && !parametersSky)
{
delete colladaLight;
return;
}
if (parameters)
{
bool hasAnimatedColor = mAnimationExporter->addAnimatedParameter(parameters, MaxLight::PB_COLOR, lightId, colladaLight->getColorDefaultSid(), 0 );
colladaLight->setColor(EffectExporter::maxColor2Color(parameters->GetColor(MaxLight::PB_COLOR)), hasAnimatedColor);
}
else if (parametersSky )
{
bool hasAnimatedColor = mAnimationExporter->addAnimatedParameter(parametersSky, MaxLight::PB_SKY_COLOR, lightId, colladaLight->getColorDefaultSid(), 0 );
colladaLight->setColor(EffectExporter::maxColor2Color(parametersSky->GetColor(MaxLight::PB_SKY_COLOR)), hasAnimatedColor);
}
if (isSpot || isPoint)
{
int decayFunction = parameters->GetInt(isPoint ? MaxLight::PB_DECAY : MaxLight::PB_OMNIDECAY, mDocumentExporter->getOptions().getAnimationStart());
switch (decayFunction)
{
case 1:
colladaLight->setConstantAttenuation(0.0f);
colladaLight->setLinearAttenuation(1.0f);
break;
case 2:
colladaLight->setConstantAttenuation(0.0f);
colladaLight->setQuadraticAttenuation(1.0f);
break;
case 0:
default:
colladaLight->setConstantAttenuation(1.0f);
break;
}
}
else if (isSky)
{
colladaLight->setConstantAttenuation(1.0f);
}
setExtraTechnique(colladaLight);
if ( parameters )
addParamBlockAnimatedExtraParameters(LIGHT_ELEMENT, LIGHT_PARAMETERS, LIGHT_PARAMETER_COUNT, parameters, lightId);
else
addParamBlockAnimatedExtraParameters(SKYLIGHT_ELEMENT, SKYLIGHT_PARAMETERS, SKYLIGHT_PARAMETER_COUNT, parametersSky, lightId);
// add all the information to extra tag, that are not contained in IParamBlock
if (isSpot || isDirectional || isPoint)
{
GenLight* light = (GenLight*)(lightObject);
if (!light)
{
delete colladaLight;
return;
}
// Export the overshoot flag for directional lights
if (isDirectional || isSpot)
{
addExtraChildParameter(LIGHT_ELEMENT, OVERSHOOT_PARAMETER, light->GetOvershoot() != false);
}
addExtraChildParameter(LIGHT_ELEMENT, DECAY_TYPE_PARAMETER, (int)light->GetDecayType());
addExtraChildParameter(LIGHT_ELEMENT, USE_NEAR_ATTENUATION_PARAMETER, (light->GetUseAttenNear() != false));
addExtraChildParameter(LIGHT_ELEMENT, USE_FAR_ATTENUATION_PARAMETER, (light->GetUseAtten() != false));
exportShadowParameters(light);
if (light->GetProjector())
{
Texmap* projectorMap = light->GetProjMap();
if (projectorMap)
{
String imageId = exportTexMap(projectorMap);
if ( !imageId.empty() )
{
addExtraChildParameter(LIGHT_ELEMENT, LIGHT_MAP_ELEMENT, "#" + imageId);
}
}
}
}
else // isSky
{
Texmap *colorMap = parametersSky->GetTexmap(MaxLight::PB_SKY_COLOR_MAP, mDocumentExporter->getOptions().getAnimationStart());
String imageId = exportTexMap(colorMap);
if ( !imageId.empty())
{
addExtraChildParameter(SKYLIGHT_ELEMENT, SKYLIGHT_COLORMAP_ELEMENT, "#" + imageId);
}
}
addLight(*colladaLight);
delete colladaLight;
}
//---------------------------------------------------------------
void ControllerExporter::exportMorphController( ExportNode* exportNode, MorphController* morphController, const String& controllerId, const String& morphSource )
{
MorphR3* morpher = morphController->getMorph();
FloatList listOfWeights;
StringList listOfTargetIds;
String weightsId = controllerId + WEIGHTS_SOURCE_ID_SUFFIX;
size_t channelBankCount = morpher->chanBank.size();
for ( size_t i = 0; i<channelBankCount; ++i)
{
morphChannel& channel = morpher->chanBank[i];
if (!channel.mActive || channel.mNumPoints == 0)
continue;
INode* targetINode = channel.mConnection;
listOfWeights.push_back(ConversionFunctors::fromPercent(channel.cblock->GetFloat(morphChannel::cblock_weight_index, mDocumentExporter->getOptions().getAnimationStart())));
Control* weightController = channel.cblock->GetController(morphChannel::cblock_weight_index);
mDocumentExporter->getAnimationExporter()->addAnimatedFloat(weightController, weightsId, EMPTY_STRING, (int)i, true, &ConversionFunctors::fromPercent );
if ( !targetINode )
{
MorphControllerHelperGeometry morphControllerHelperGeometry;
morphControllerHelperGeometry.exportNode = exportNode;
morphControllerHelperGeometry.controllerId = controllerId;
morphControllerHelperGeometry.morphController = morphController;
morphControllerHelperGeometry.channelBankindex = i;
String targetId = ExportSceneGraph::getMorphControllerHelperId(morphControllerHelperGeometry);
listOfTargetIds.push_back(targetId);
}
else
{
ExportNode* targetExportNode = mExportSceneGraph->getExportNode(targetINode);
assert(targetExportNode);
ExportNode* geometryExportNode = mDocumentExporter->getExportedObjectExportNode(ObjectIdentifier(targetExportNode->getInitialPose()));
assert( geometryExportNode );
// listOfTargetIds.push_back(geometryExportNode);
listOfTargetIds.push_back(GeometriesExporter::getGeometryId(*geometryExportNode));
}
}
openMorph(controllerId, EMPTY_STRING, morphSource);
//export weights source
String targetId = controllerId + TARGETS_SOURCE_ID_SUFFIX;
COLLADASW::IdRefSource targetsSource(mSW);
targetsSource.setId(targetId);
targetsSource.setArrayId(targetId + ARRAY_ID_SUFFIX);
targetsSource.setAccessorStride(1);
targetsSource.getParameterNameList().push_back("MORPH_TARGET");
targetsSource.setAccessorCount((unsigned long)listOfTargetIds.size());
targetsSource.prepareToAppendValues();
for ( StringList::const_iterator it = listOfTargetIds.begin(); it != listOfTargetIds.end(); ++it)
targetsSource.appendValues(*it);
targetsSource.finish();
//export weights source
COLLADASW::FloatSource weightsSource(mSW);
weightsSource.setId(weightsId);
weightsSource.setArrayId(weightsId + ARRAY_ID_SUFFIX);
weightsSource.setAccessorStride(1);
weightsSource.getParameterNameList().push_back("MORPH_WEIGHT");
weightsSource.setAccessorCount((unsigned long)listOfWeights.size());
weightsSource.prepareToAppendValues();
for ( FloatList::const_iterator it = listOfWeights.begin(); it != listOfWeights.end(); ++it)
weightsSource.appendValues(*it);
weightsSource.finish();
COLLADASW::TargetsElement targets(mSW);
targets.getInputList().push_back(COLLADASW::Input(COLLADASW::InputSemantic::MORPH_TARGET, "#" + targetId));
targets.getInputList().push_back(COLLADASW::Input(COLLADASW::InputSemantic::MORPH_WEIGHT, "#" + weightsId));
targets.add();
closeMorph();
}
void WorldManagementSystem::installWMS() {
const World& world = FreeThread__getWorld();
UpdateSystem* updateSystem = world.getSystem<UpdateSystem>();
ControlBlockDef* loopInput = updateSystem->getLockedAPI().
get<ControlBlockDef>("s/update/loopInput", true);
phaseVariable = updateSystem->getLockedAPI().newVariable(0,
&ObjectIdentifier("s/wms/phase"));
phase2CountVariable = updateSystem->getLockedAPI().newVariable(0,
&ObjectIdentifier("s/wms/p2Count"));
ControlBlockDef* wmsBlock = updateSystem->getLockedAPI().
newBlock(&ObjectIdentifier("s/wms/wmsBlock"));
loopInput->addStatement(*wmsBlock, &ObjectIdentifier("s/wms/doWMS"));
TaskStatementDef* swapBufferDef = updateSystem->getLockedAPI().
newTaskStatement<swapBuffer>(this, NULL);
Statement& swapBufferStatement = wmsBlock->addStatement(*swapBufferDef,
&ObjectIdentifier("s/wms/swapBuffer"));
SignalStatementDef* prePhaseSignalDef = updateSystem->getLockedAPI().
newSignalStatement(*phaseVariable, 1);
Statement& prePhaseSignalStatement = wmsBlock->addStatement(*
prePhaseSignalDef);
// This is where pre-world tasks can be added.
ControlBlockDef* preWorldPhaseDef = updateSystem->getLockedAPI().
newBlock();
Statement& preWorldStatement = wmsBlock->addStatement(*preWorldPhaseDef,
&ObjectIdentifier("s/wms/preWorld"));
TaskStatementDef* swapWorldDef = updateSystem->getLockedAPI().
newTaskStatement<swapWorld>(this, NULL);
Statement& swapWorldStatement = wmsBlock->addStatement(*swapWorldDef,
&ObjectIdentifier("s/wms/swapWorld"));
SignalStatementDef* postPhaseSignalDef = updateSystem->getLockedAPI().
newSignalStatement(*phaseVariable, 2);
Statement& postPhaseSignalStatement = wmsBlock->addStatement(*
postPhaseSignalDef);
// This is where post-world tasks can be added.
ControlBlockDef* postWorldPhaseDef = updateSystem->getLockedAPI().
newBlock();
Statement& postWorldStatement = wmsBlock->addStatement(*postWorldPhaseDef,
&ObjectIdentifier("s/wms/postWorld"));
// Wait for completion of the post-world tasks.
WatcherStatementDef* watchPostPhaseDef = updateSystem->getLockedAPI().
newWatcherStatement(*phase2CountVariable, 0);
Statement& watchPostPhaseStatement = wmsBlock->addStatement(
*watchPostPhaseDef);
SignalStatementDef* noPhaseSignalDef = updateSystem->getLockedAPI().
newSignalStatement(*phaseVariable, 0);
Statement& noPhaseSignalStatement = wmsBlock->addStatement(*
noPhaseSignalDef);
wmsBlock->addConstraintChain(swapBufferStatement, prePhaseSignalStatement,
preWorldStatement, swapWorldStatement, postPhaseSignalStatement,
postWorldStatement, watchPostPhaseStatement,
noPhaseSignalStatement);
}
//---------------------------------------------------------------
void CameraExporter::exportCamera( ExportNode* exportNode )
{
if ( !exportNode->getIsInVisualScene() )
return;
String cameraId = getCameraId(*exportNode);
INode* iNode = exportNode->getINode();
CameraObject* camera = (CameraObject*)iNode->GetObjectRef();
INode* targetNode = ( camera->ClassID().PartA() == LOOKAT_CAM_CLASS_ID) ? iNode->GetTarget() : 0;
if ( camera )
{
if ( mDocumentExporter->isExportedObject(ObjectIdentifier(camera)) )
return;
mDocumentExporter->insertExportedObject(ObjectIdentifier(camera), exportNode);
// Retrieve the camera parameters block
IParamBlock* parameters = (IParamBlock*) camera->GetReference(MaxCamera::PBLOCK_REF);
COLLADASW::BaseOptic * optics = 0;
if ( camera->IsOrtho() )
{
optics = new COLLADASW::OrthographicOptic(COLLADASW::LibraryCameras::mSW);
// Calculate the target distance for FOV calculations
float targetDistance;
if ( targetNode )
{
Point3 targetTrans = targetNode->GetNodeTM(mDocumentExporter->getOptions().getAnimationStart()).GetTrans();
Point3 cameraTrans = iNode->GetNodeTM(mDocumentExporter->getOptions().getAnimationStart()).GetTrans();
targetDistance = (targetTrans - cameraTrans).Length();
}
else
{
targetDistance = camera->GetTDist(mDocumentExporter->getOptions().getAnimationStart());
}
ConversionInverseOrthoFOVFunctor conversionInverseOrthoFOVFunctor(targetDistance);
if ( AnimationExporter::isAnimated(parameters, MaxCamera::FOV) )
{
optics->setXMag(conversionInverseOrthoFOVFunctor(parameters->GetFloat(MaxCamera::FOV)), XMAG_SID);
mAnimationExporter->addAnimatedParameter(parameters, MaxCamera::FOV, cameraId, XMAG_SID, 0, true, &conversionInverseOrthoFOVFunctor);
}
else
{
optics->setXMag(conversionInverseOrthoFOVFunctor(parameters->GetFloat(MaxCamera::FOV)));
}
}
else
{
optics = new COLLADASW::PerspectiveOptic(COLLADASW::LibraryCameras::mSW);
if ( AnimationExporter::isAnimated(parameters, MaxCamera::FOV) )
{
optics->setXFov(COLLADASW::MathUtils::radToDegF(parameters->GetFloat(MaxCamera::FOV)), XFOV_SID);
mAnimationExporter->addAnimatedParameter(parameters, MaxCamera::FOV, cameraId, XFOV_SID, 0, true, &ConversionFunctors::radToDeg);
}
else
{
optics->setXFov(COLLADASW::MathUtils::radToDegF(parameters->GetFloat(MaxCamera::FOV)));
}
}
bool hasAnimatedZNear = mAnimationExporter->addAnimatedParameter(parameters, MaxCamera::NEAR_CLIP, cameraId, optics->getZNearDefaultSid(), 0);
optics->setZNear(parameters->GetFloat(MaxCamera::NEAR_CLIP), hasAnimatedZNear);
bool hasAnimatedZFar = mAnimationExporter->addAnimatedParameter(parameters, MaxCamera::FAR_CLIP, cameraId, optics->getZFarDefaultSid(), 0);
optics->setZFar(parameters->GetFloat(MaxCamera::FAR_CLIP), hasAnimatedZFar);
#ifdef UNICODE
String exportNodeName = COLLADABU::StringUtils::wideString2utf8String(exportNode->getINode()->GetName());
COLLADASW::Camera colladaCamera(COLLADASW::LibraryCameras::mSW, optics, cameraId, COLLADASW::Utils::checkNCName(exportNodeName));
#else
COLLADASW::Camera colladaCamera(COLLADASW::LibraryCameras::mSW, optics, cameraId, COLLADASW::Utils::checkNCName(exportNode->getINode()->GetName()));
#endif
setExtraTechnique(&colladaCamera);
// Retrieve the camera target
if ( targetNode )
{
ExportNode* targetExportNode = mExportSceneGraph->getExportNode(targetNode);
addExtraParameter(EXTRA_PARAMETER_TARGET, "#" + targetExportNode->getId());
}
if (camera->GetMultiPassEffectEnabled(0, FOREVER))
{
IMultiPassCameraEffect *multiPassCameraEffect = camera->GetIMultiPassCameraEffect();
if (multiPassCameraEffect)
{
Class_ID id = multiPassCameraEffect->ClassID();
// the camera could have both effects, but not in Max
if (id == FMULTI_PASS_MOTION_BLUR_CLASS_ID)
{
IParamBlock2 *parameters = multiPassCameraEffect->GetParamBlock(0);
if (parameters )
{
addParamBlockAnimatedExtraParameters(MOTION_BLUR_ELEMENT, MOTION_BLUR_PARAMETERS, MOTION_BLUR_PARAMETER_COUNT, parameters, cameraId);
}
}
else if (id == FMULTI_PASS_DOF_CLASS_ID)
{
IParamBlock2 *parameters = multiPassCameraEffect->GetParamBlock(0);
if (parameters )
{
addParamBlockAnimatedExtraParameters(DEPTH_OF_FIELD_ELEMENT, DEPTH_OF_FIELD_PARAMETERS, DEPTH_OF_FIELD_PARAMETER_COUNT, parameters, cameraId);
addExtraParameter(TARGETDISTANCE_PARAMETER, camera->GetTDist(0));
}
}
}
}
addCamera(colladaCamera);
delete optics;
}
}
