Node::NodeSP SceneLoader::_LoadElement(const QDomElement& og_element, Node::NodeSP dt_node)
{
QString name = og_element.nodeName();
Node::NodeSP node = nullptr;
if(name == SL_LIGHT)
{
node = _LoadLight(og_element, dt_node); //Light
}
else if(name == SL_CAMERA)
{
node = _LoadCamera(og_element, dt_node); //Camera
}
else if(name == SL_SOUND)
{
node = _LoadSound(og_element, dt_node); //Sound
}
else if(name == SL_NODE)
{
if(og_element.firstChildElement(SL_ENTITY).isNull() && og_element.firstChildElement(SL_PLANE).isNull())
{
node = _LoadNode(og_element, dt_node); //Node
}
else
{
node = _LoadMesh(og_element, dt_node); //Mesh
}
}
return node;
}
OP_ERROR
GusdOBJ_usdcamera::_Cook(OP_Context& ctx)
{
_LoadCamera(ctx.getTime(), ctx.getThread());
/* XXX: There's a potential race condition here, between
loading and stealing cached errors.
Would be better to keep the camera cache locked
until the error stealing is done.*/
UT_AutoReadLock readLock(_lock);
stealErrors(_errors, /*borrow*/ true);
return error();
}
int
GusdOBJ_usdcamera::applyInputIndependentTransform(OP_Context& ctx, UT_DMatrix4& mx)
{
mx.identity();
fpreal t = ctx.getTime();
if(UsdGeomCamera cam = _LoadCamera(t, ctx.getThread()))
{
float frame = evalFloat(_frameIdx, 0, t);
GfMatrix4d ctm(1.);
bool stat = true;
bool resetsXformStack = false;
switch(evalInt("xformmode", 0, t))
{
case _POSTMULTCTM_TRANSFORM:
stat = true;
ctm = cam.ComputeLocalToWorldTransform(frame);
break;
case _CTM_TRANSFORM:
stat = true;
ctm = cam.ComputeParentToWorldTransform(frame);
break;
case _OBJ_TRANSFORM:
// XXX: how do we reset xformStack here?
// Is that (or should that
// be) handled by the Compute calls above?
stat = cam.GetLocalTransformation(&ctm, &resetsXformStack, frame);
break;
default: // _IGNORE_TRANSFORM:
stat = true;
ctm.SetIdentity();
break;
}
if(!stat)
{
stealErrors(_errors, /*borrow*/ true);
return 0;
}
mx = GusdUT_Gf::Cast(ctm);
}
return OBJ_Camera::applyInputIndependentTransform(ctx, mx);
}
bool
GusdOBJ_usdcamera::_EvalCamVariable(fpreal& val, int idx, int thread)
{
UT_ASSERT_P(idx >= 0 && idx < NUM_VARS);
const fpreal t = CHgetEvalTime(thread);
if(UsdGeomCamera cam = _LoadCamera(t, thread))
{
float frame = evalFloatT(_frameIdx, 0, t, thread);
switch(idx)
{
case VAR_SCREENASPECT:
{
val = cam.GetCamera(frame).GetAspectRatio();
return true;
}
case VAR_YRES:
{
// XXX This is redundant since resy can be set to
// "ch(\"resx\")/$SCREENASPECT" in runCreateScript,
// however it's needed to get around a Houdini bug
// (see bug 94389)
const float screenAspect =
cam.GetCamera(frame).GetAspectRatio();
float xRes = evalFloatT("res", 0, t, thread);
val = xRes / screenAspect;
return true;
}
case VAR_PROJECTION:
{
TfToken proj;
if(cam.GetProjectionAttr().Get(&proj) &&
proj == UsdGeomTokens->orthographic)
val = OBJ_PROJ_ORTHO;
else
val = OBJ_PROJ_PERSPECTIVE;
return true;
}
case VAR_FOCAL:
{
float focal = 50;
cam.GetFocalLengthAttr().Get(&focal, frame);
val = focal;
return true;
}
case VAR_HAPERTURE:
{
float aperture = 41.2136;
cam.GetHorizontalApertureAttr().Get(&aperture, frame);
val = aperture;
return true;
}
case VAR_VAPERTURE:
{
float aperture = 41.2136;
cam.GetVerticalApertureAttr().Get(&aperture, frame);
val = aperture;
return true;
}
case VAR_NEAR:
{
GfVec2f clipping;
val = cam.GetClippingRangeAttr().Get(&clipping, frame) ?
clipping[0] : 0.001;
return true;
}
case VAR_FAR:
{
GfVec2f clipping;
val = cam.GetClippingRangeAttr().Get(&clipping, frame) ?
clipping[1] : 10000;
return true;
}
case VAR_FOCUS:
{
float focus = 5;
cam.GetFocusDistanceAttr().Get(&focus, frame);
val = focus;
return true;
}
case VAR_FSTOP:
{
float fstop = 5.6;
cam.GetFStopAttr().Get(&fstop, frame);
val = fstop;
return true;
}
case VAR_HAPERTUREOFFSET:
{
float apertureOffset = 41.2136;
cam.GetHorizontalApertureOffsetAttr().Get(&apertureOffset, frame);
val = apertureOffset;
return true;
}
// for backwards compatibility with old stereo attributes {
// XXX:-matthias
// We are just writing out dummy values so that old assets do not
// break.
// The following code together with the definitions of
// VAR_ISSTEREO, ... should eventually be removed.
case VAR_ISSTEREO:
{
bool isStereo = false;
val = isStereo;
return true;
}
case VAR_CONVERGENCEDISTANCE:
{
float convergenceDistance = 1000;
val = convergenceDistance;
return true;
}
case VAR_INTEROCULARDISTANCE:
{
float interocularDistance = 50;
val = interocularDistance;
return true;
}
case VAR_LEFTEYEBIAS:
{
float leftEyeBias = 0.0;
val = leftEyeBias;
return true;
}
// }
};
}
/* Couldn't load a camera. Just return defaults.*/
switch(idx)
{
case VAR_SCREENASPECT: val = 1.0; break;
case VAR_YRES: val = 1080; break;
case VAR_PROJECTION: val = OBJ_PROJ_PERSPECTIVE; break;
case VAR_FOCAL: val = 50; break;
case VAR_HAPERTURE: val = 41.2136; break;
case VAR_VAPERTURE: val = 41.2136; break;
case VAR_NEAR: val = 0.001; break;
case VAR_FAR: val = 10000; break;
case VAR_FOCUS: val = 5; break;
case VAR_FSTOP: val = 5.6; break;
case VAR_HAPERTUREOFFSET: val = 41.2136;
// for backwards compatibility with old stereo attributes
case VAR_ISSTEREO: val = 0; break;
case VAR_CONVERGENCEDISTANCE: val = 1000; break;
case VAR_INTEROCULARDISTANCE: val = 50; break;
case VAR_LEFTEYEBIAS: val = 0.0; break;
};
/* Return true so that the variables are still considered valid,
even in the absence of the camera. This is done to prevent
evaluation errors during saves.*/
return true;
}
