HdSt_TestLightingShader::HdSt_TestLightingShader()
{
const char *lightingShader =
"-- glslfx version 0.1 \n"
"-- configuration \n"
"{\"techniques\": {\"default\": {\"fragmentShader\" : { \n"
" \"source\": [\"TestLighting.Lighting\"] \n"
"}}}} \n"
"-- glsl TestLighting.Lighting \n"
"vec3 FallbackLighting(vec3 Peye, vec3 Neye, vec3 color) { \n"
" vec3 n = normalize(Neye); \n"
" return HdGet_sceneAmbient() \n"
" + color * HdGet_l0color() * max(0.0, dot(n, HdGet_l0dir())) \n"
" + color * HdGet_l1color() * max(0.0, dot(n, HdGet_l1dir())); \n"
"} \n";
_lights[0].dir = GfVec3f(0, 0, 1);
_lights[0].color = GfVec3f(1, 1, 1);
_lights[1].dir = GfVec3f(0, 0, 1);
_lights[1].color = GfVec3f(0, 0, 0);
_sceneAmbient = GfVec3f(0.04, 0.04, 0.04);
std::stringstream ss(lightingShader);
_glslfx.reset(new HioGlslfx(ss));
}
PXR_NAMESPACE_CLOSE_SCOPE
// ===================================================================== //
// Feel free to add custom code below this line. It will be preserved by
// the code generator.
//
// Just remember to wrap code in the appropriate delimiters:
// 'PXR_NAMESPACE_OPEN_SCOPE', 'PXR_NAMESPACE_CLOSE_SCOPE'.
// ===================================================================== //
// --(BEGIN CUSTOM CODE)--
#include "pxr/usd/usdGeom/boundableComputeExtent.h"
#include "pxr/base/tf/registryManager.h"
PXR_NAMESPACE_OPEN_SCOPE
static bool
_ComputeExtentMax(double height, double radius, const TfToken& axis,
GfVec3f* max)
{
if (axis == UsdGeomTokens->x) {
*max = GfVec3f(height * 0.5, radius, radius);
} else if (axis == UsdGeomTokens->y) {
*max = GfVec3f(radius, height * 0.5, radius);
} else if (axis == UsdGeomTokens->z) {
*max = GfVec3f(radius, radius, height * 0.5);
} else {
return false; // invalid axis
}
return true;
}
GfVec4f GfHomogeneousCross(const GfVec4f &a, const GfVec4f &b)
{
GfVec4f ah(GfGetHomogenized(a));
GfVec4f bh(GfGetHomogenized(b));
GfVec3f prod =
GfCross(GfVec3f(ah[0], ah[1], ah[2]), GfVec3f(bh[0], bh[1], bh[2]));
return GfVec4f(prod[0], prod[1], prod[2], 1);
}
GfRange3f
GfRange3f::GetOctant(size_t i) const
{
if (i > 7) {
TF_CODING_ERROR("Invalid octant %zu > 7.", i);
return GfRange3f();
}
GfVec3f a = GetCorner(i);
GfVec3f b = .5 * (_min + _max);
return GfRange3f(
GfVec3f(GfMin(a[0], b[0]), GfMin(a[1], b[1]), GfMin(a[2], b[2])),
GfVec3f(GfMax(a[0], b[0]), GfMax(a[1], b[1]), GfMax(a[2], b[2])));
}
GfVec3f
GfMatrix3f::DecomposeRotation(const GfVec3f &axis0,
const GfVec3f &axis1,
const GfVec3f &axis2) const
{
return GfVec3f(ExtractRotation().Decompose(axis0, axis1, axis2));
}
/*
* BuildOrthonormalFrame constructs two unit vectors *v1 and *v2,
* with *v1 and *v2 perpendicular to each other and (*this).
* We arbitrarily cross *this with the X axis to form *v1,
* and if the result is degenerate, we set *v1 = (Y axis) X *this.
* If L = length(*this) < eps, we shrink v1 and v2 to be of
* length L/eps.
*/
void
GfBuildOrthonormalFrame(GfVec3f const &v0,
GfVec3f* v1,
GfVec3f* v2, float eps)
{
float len = v0.GetLength();
if (len == 0.) {
*v1 = *v2 = GfVec3f(0);
}
else {
GfVec3f unitDir = v0 / len;
*v1 = GfVec3f::XAxis() ^ unitDir;
if (GfSqr(*v1) < GfSqr(1e-4))
*v1 = GfVec3f::YAxis() ^ unitDir;
GfNormalize(v1);
*v2 = unitDir ^ *v1; // this is of unit length
if (len < eps) {
double desiredLen = len / eps;
*v1 *= desiredLen;
*v2 *= desiredLen;
}
}
}
GfMatrix3f &
GfMatrix3f::SetRotate(const GfRotation &rot)
{
GfQuaternion quat = rot.GetQuaternion();
_SetRotateFromQuat(quat.GetReal(), GfVec3f(quat.GetImaginary()));
return *this;
}
GfVec3f
operator *(const GfMatrix3d& m, const GfVec3f &vec)
{
return GfVec3f(
float(vec[0] * m._mtx[0][0] + vec[1] * m._mtx[0][1] + vec[2] * m._mtx[0][2]),
float(vec[0] * m._mtx[1][0] + vec[1] * m._mtx[1][1] + vec[2] * m._mtx[1][2]),
float(vec[0] * m._mtx[2][0] + vec[1] * m._mtx[2][1] + vec[2] * m._mtx[2][2]));
}
My_TestGLDrawing() {
_reprName = HdTokens->hull;
_refineLevel = 0;
_cullStyle = HdCullStyleNothing;
_testLighting = false;
SetCameraRotate(60.0f, 0.0f);
SetCameraTranslate(GfVec3f(0, 0, -20.0f-1.7320508f*2.0f));
}
bool
UsdGeomCylinder::ComputeExtent(double height, double radius,
const TfToken& axis, const GfMatrix4d& transform, VtVec3fArray* extent)
{
// Create Sized Extent
extent->resize(2);
GfVec3f max;
if (!_ComputeExtentMax(height, radius, axis, &max)) {
return false;
}
GfBBox3d bbox = GfBBox3d(GfRange3d(-max, max), transform);
GfRange3d range = bbox.ComputeAlignedRange();
(*extent)[0] = GfVec3f(range.GetMin());
(*extent)[1] = GfVec3f(range.GetMax());
return true;
}
bool
UsdGeomPointBased::ComputeExtent(const VtVec3fArray& points,
VtVec3fArray* extent)
{
// Create Sized Extent
extent->resize(2);
// Calculate bounds
GfRange3d bbox;
TF_FOR_ALL(pointsItr, points) {
bbox.UnionWith(GfVec3f(*pointsItr));
}
GfVec3f
GfRange3f::GetCorner(size_t i) const
{
if (i > 7) {
TF_CODING_ERROR("Invalid corner %zu > 7.", i);
return _min;
}
return GfVec3f(
(i & 1 ? _max : _min)[0],
(i & 2 ? _max : _min)[1],
(i & 4 ? _max : _min)[2]);
}
void
My_TestGLDrawing::InitTest()
{
_renderIndex = HdRenderIndex::New(&_renderDelegate);
TF_VERIFY(_renderIndex != nullptr);
_delegate.reset(new Hdx_UnitTestDelegate(_renderIndex));
// prepare render task
SdfPath renderSetupTask("/renderSetupTask");
SdfPath renderTask("/renderTask");
SdfPath selectionTask("/selectionTask");
_delegate->AddRenderSetupTask(renderSetupTask);
_delegate->AddRenderTask(renderTask);
_delegate->AddSelectionTask(selectionTask);
// render task parameters.
VtValue vParam = _delegate->GetTaskParam(renderSetupTask, HdTokens->params);
HdxRenderTaskParams param = vParam.Get<HdxRenderTaskParams>();
param.enableLighting = true; // use default lighting
_delegate->SetTaskParam(renderSetupTask, HdTokens->params,
VtValue(param));
_delegate->SetTaskParam(renderTask, HdTokens->collection,
VtValue(HdRprimCollection(HdTokens->geometry,
HdReprSelector(HdReprTokens->hull))));
HdxSelectionTaskParams selParam;
selParam.enableSelection = true;
selParam.selectionColor = GfVec4f(1, 1, 0, 1);
selParam.locateColor = GfVec4f(1, 0, 1, 1);
_delegate->SetTaskParam(selectionTask, HdTokens->params,
VtValue(selParam));
// prepare scene
_InitScene();
SetCameraTranslate(GfVec3f(0, 0, -20));
// picking related init
_pickablesCol = HdRprimCollection(_tokens->pickables,
HdReprSelector(HdReprTokens->hull));
_marquee.InitGLResources();
_picker.InitIntersector(_renderIndex);
_SetPickParams();
// We have to unfortunately explictly add collections besides 'geometry'
// See HdRenderIndex constructor.
_delegate->GetRenderIndex().GetChangeTracker().AddCollection(_tokens->pickables);
// XXX: Setup a VAO, the current drawing engine will not yet do this.
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
glBindVertexArray(0);
}
bool
HdxIntersector::Result::_ResolveHit(int index, int x, int y, float z,
HdxIntersector::Hit* hit) const
{
unsigned char const* primIds = _primIds.get();
unsigned char const* instanceIds = _instanceIds.get();
unsigned char const* elementIds = _elementIds.get();
GfVec3d hitPoint(0,0,0);
gluUnProject(x, y, z,
_params.viewMatrix.GetArray(),
_params.projectionMatrix.GetArray(),
&_viewport[0],
&((hitPoint)[0]),
&((hitPoint)[1]),
&((hitPoint)[2]));
int idIndex = index*4;
int primId = HdxRenderSetupTask::DecodeIDRenderColor(&primIds[idIndex]);
hit->objectId = _index->GetRprimPathFromPrimId(primId);
if (!hit->IsValid()) {
return false;
}
int instanceIndex = HdxRenderSetupTask::DecodeIDRenderColor(
&instanceIds[idIndex]);
int elementIndex = HdxRenderSetupTask::DecodeIDRenderColor(
&elementIds[idIndex]);
bool rprimValid = _index->GetSceneDelegateAndInstancerIds(hit->objectId,
&(hit->delegateId),
&(hit->instancerId));
if (!TF_VERIFY(rprimValid, "%s\n", hit->objectId.GetText())) {
return false;
}
hit->worldSpaceHitPoint = GfVec3f(hitPoint);
hit->ndcDepth = float(z);
hit->instanceIndex = instanceIndex;
hit->elementIndex = elementIndex;
if (TfDebug::IsEnabled(HDX_INTERSECT)) {
std::cout << *hit << std::endl;
}
return true;
}
/*static*/
VtValue
UsdImagingCubeAdapter::GetMeshPoints(UsdPrim const& prim,
UsdTimeCode time)
{
static GfVec3f points[] = {
GfVec3f( 0.5f, 0.5f, 0.5f ),
GfVec3f(-0.5f, 0.5f, 0.5f ),
GfVec3f(-0.5f,-0.5f, 0.5f ),
GfVec3f( 0.5f,-0.5f, 0.5f ),
GfVec3f(-0.5f,-0.5f,-0.5f ),
GfVec3f(-0.5f, 0.5f,-0.5f ),
GfVec3f( 0.5f, 0.5f,-0.5f ),
GfVec3f( 0.5f,-0.5f,-0.5f ),
};
size_t numPoints = sizeof(points) / sizeof(points[0]);
VtArray<GfVec3f> output(numPoints);
std::copy(points, points + numPoints, output.begin());
return VtValue(output);
}
bool
UsdGeomCurves::ComputeExtent(const VtVec3fArray& points,
const VtFloatArray& widths, VtVec3fArray* extent)
{
// We know nothing about the curve basis. Compute the extent as if it were
// a point cloud with some max width (convex hull).
float maxWidth = (widths.size() > 0 ?
*(std::max_element(widths.begin(), widths.end())) : 0);
if (not UsdGeomPointBased::ComputeExtent(points, extent)) {
return false;
}
GfVec3f widthVec = GfVec3f(maxWidth/2.);
(*extent)[0] -= widthVec;
(*extent)[1] += widthVec;
return true;
}
// Given an Op, value and time, set the Op value based on op type and precision
static void
setXformOp(const UsdGeomXformOp& op,
const GfVec3d& value,
const UsdTimeCode& usdTime)
{
if (op.GetOpType() == UsdGeomXformOp::TypeTransform) {
GfMatrix4d shearXForm(1.0);
shearXForm[1][0] = value[0]; //xyVal
shearXForm[2][0] = value[1]; //xzVal
shearXForm[2][1] = value[2]; //yzVal
op.Set(shearXForm, usdTime);
return;
}
if (UsdGeomXformOp::GetPrecisionFromValueTypeName(op.GetAttr().GetTypeName())
== UsdGeomXformOp::PrecisionDouble) {
_setXformOp<GfVec3d>(op, value, usdTime);
}
else { // float precision
_setXformOp<GfVec3f>(op, GfVec3f(value), usdTime);
}
}
bool
HdxIntersector::Result::_ResolveHit(int index, int x, int y, float z,
HdxIntersector::Hit* hit) const
{
unsigned char const* primIds = _primIds.get();
unsigned char const* instanceIds = _instanceIds.get();
unsigned char const* elementIds = _elementIds.get();
GfVec3d hitPoint(0,0,0);
gluUnProject(x, y, z,
_params.viewMatrix.GetArray(),
_params.projectionMatrix.GetArray(),
&_viewport[0],
&((hitPoint)[0]),
&((hitPoint)[1]),
&((hitPoint)[2]));
int idIndex = index*4;
GfVec4i primIdColor(
primIds[idIndex+0],
primIds[idIndex+1],
primIds[idIndex+2],
primIds[idIndex+3]);
GfVec4i instanceIdColor(
instanceIds[idIndex+0],
instanceIds[idIndex+1],
instanceIds[idIndex+2],
instanceIds[idIndex+3]);
int instanceIndex = 0;
hit->objectId = _index->GetPrimPathFromPrimIdColor(primIdColor,
instanceIdColor, &instanceIndex);
if (not hit->IsValid()) {
return false;
}
// XXX: either this should be done in the render index or all render index
// logic should be moved here. If moved here, the shader logic should move
// into Hdx as well.
int elemIndex = ((elementIds[idIndex+0] & 0xff) << 0) |
((elementIds[idIndex+1] & 0xff) << 8) |
((elementIds[idIndex+2] & 0xff) << 16);
HdRprimSharedPtr const& rprim = _index->GetRprim(hit->objectId);
if (not TF_VERIFY(rprim, "%s\n", hit->objectId.GetText())) {
return false;
}
hit->delegateId = rprim->GetDelegate()->GetDelegateID();
hit->instancerId = rprim->GetInstancerId();
hit->worldSpaceHitPoint = GfVec3f(hitPoint);
hit->ndcDepth = float(z);
hit->instanceIndex = instanceIndex;
hit->elementIndex = elemIndex;
if (TfDebug::IsEnabled(HDX_INTERSECT)) {
std::cout << *hit << std::endl;
}
return true;
}
/* static */
GlfSimpleLightingContextRefPtr
px_vp20Utils::GetLightingContextFromDrawContext(
const MHWRender::MDrawContext& context)
{
const GfVec4f blackColor(0.0f, 0.0f, 0.0f, 1.0f);
const GfVec4f whiteColor(1.0f, 1.0f, 1.0f, 1.0f);
GlfSimpleLightingContextRefPtr lightingContext =
GlfSimpleLightingContext::New();
MStatus status;
unsigned int numMayaLights =
context.numberOfActiveLights(MHWRender::MDrawContext::kFilteredToLightLimit,
&status);
if (status != MS::kSuccess || numMayaLights < 1) {
return lightingContext;
}
bool viewDirectionAlongNegZ = context.viewDirectionAlongNegZ(&status);
if (status != MS::kSuccess) {
// If we fail to find out the view direction for some reason, assume
// that it's along the negative Z axis (OpenGL).
viewDirectionAlongNegZ = true;
}
GlfSimpleLightVector lights;
for (unsigned int i = 0; i < numMayaLights; ++i) {
MHWRender::MLightParameterInformation* mayaLightParamInfo =
context.getLightParameterInformation(i);
if (!mayaLightParamInfo) {
continue;
}
// Setup some default values before we read the light parameters.
bool lightEnabled = true;
bool lightHasPosition = false;
GfVec4f lightPosition(0.0f, 0.0f, 0.0f, 1.0f);
bool lightHasDirection = false;
GfVec3f lightDirection(0.0f, 0.0f, -1.0f);
if (!viewDirectionAlongNegZ) {
// The convention for DirectX is positive Z.
lightDirection[2] = 1.0f;
}
float lightIntensity = 1.0f;
GfVec4f lightColor = blackColor;
bool lightEmitsDiffuse = true;
bool lightEmitsSpecular = false;
float lightDecayRate = 0.0f;
float lightDropoff = 0.0f;
// The cone angle is 180 degrees by default.
GfVec2f lightCosineConeAngle(-1.0f);
float lightShadowBias = 0.0f;
bool lightShadowOn = false;
bool globalShadowOn = false;
MStringArray paramNames;
mayaLightParamInfo->parameterList(paramNames);
for (unsigned int paramIndex = 0; paramIndex < paramNames.length(); ++paramIndex) {
const MString paramName = paramNames[paramIndex];
const MHWRender::MLightParameterInformation::ParameterType paramType =
mayaLightParamInfo->parameterType(paramName);
const MHWRender::MLightParameterInformation::StockParameterSemantic paramSemantic =
mayaLightParamInfo->parameterSemantic(paramName);
MIntArray intValues;
MFloatArray floatValues;
switch (paramType) {
case MHWRender::MLightParameterInformation::kBoolean:
case MHWRender::MLightParameterInformation::kInteger:
mayaLightParamInfo->getParameter(paramName, intValues);
break;
case MHWRender::MLightParameterInformation::kFloat:
case MHWRender::MLightParameterInformation::kFloat2:
case MHWRender::MLightParameterInformation::kFloat3:
case MHWRender::MLightParameterInformation::kFloat4:
mayaLightParamInfo->getParameter(paramName, floatValues);
break;
default:
// Unsupported paramType.
continue;
break;
}
switch (paramSemantic) {
case MHWRender::MLightParameterInformation::kLightEnabled:
_GetLightingParam(intValues, floatValues, lightEnabled);
break;
case MHWRender::MLightParameterInformation::kWorldPosition:
if (_GetLightingParam(intValues, floatValues, lightPosition)) {
lightHasPosition = true;
}
break;
case MHWRender::MLightParameterInformation::kWorldDirection:
if (_GetLightingParam(intValues, floatValues, lightDirection)) {
lightHasDirection = true;
}
break;
case MHWRender::MLightParameterInformation::kIntensity:
_GetLightingParam(intValues, floatValues, lightIntensity);
break;
case MHWRender::MLightParameterInformation::kColor:
_GetLightingParam(intValues, floatValues, lightColor);
break;
case MHWRender::MLightParameterInformation::kEmitsDiffuse:
_GetLightingParam(intValues, floatValues, lightEmitsDiffuse);
break;
case MHWRender::MLightParameterInformation::kEmitsSpecular:
_GetLightingParam(intValues, floatValues, lightEmitsSpecular);
break;
case MHWRender::MLightParameterInformation::kDecayRate:
_GetLightingParam(intValues, floatValues, lightDecayRate);
break;
case MHWRender::MLightParameterInformation::kDropoff:
_GetLightingParam(intValues, floatValues, lightDropoff);
break;
case MHWRender::MLightParameterInformation::kCosConeAngle:
_GetLightingParam(intValues, floatValues, lightCosineConeAngle);
break;
case MHWRender::MLightParameterInformation::kShadowBias:
_GetLightingParam(intValues, floatValues, lightShadowBias);
break;
case MHWRender::MLightParameterInformation::kShadowOn:
_GetLightingParam(intValues, floatValues, lightShadowOn);
break;
case MHWRender::MLightParameterInformation::kGlobalShadowOn:
_GetLightingParam(intValues, floatValues, globalShadowOn);
break;
default:
// Unsupported paramSemantic.
continue;
break;
}
if (!lightEnabled) {
// Stop reading light parameters if the light is disabled.
break;
}
}
if (!lightEnabled) {
// Skip to the next light if this light is disabled.
continue;
}
lightColor[0] *= lightIntensity;
lightColor[1] *= lightIntensity;
lightColor[2] *= lightIntensity;
// Populate a GlfSimpleLight from the light information from Maya.
GlfSimpleLight light;
GfVec4f lightAmbient = blackColor;
GfVec4f lightDiffuse = blackColor;
GfVec4f lightSpecular = blackColor;
// We receive the cone angle from Maya as a pair of floats which
// includes the penumbra, but GlfSimpleLights don't currently support
// that, so we only use the primary cone angle value.
float lightCutoff = GfRadiansToDegrees(std::acos(lightCosineConeAngle[0]));
float lightFalloff = lightDropoff;
// decayRate is actually an enum in Maya that we receive as a float:
// - 0.0 = no attenuation
// - 1.0 = linear attenuation
// - 2.0 = quadratic attenuation
// - 3.0 = cubic attenuation (not supported by GlfSimpleLight)
GfVec3f lightAttenuation(0.0f);
if (lightDecayRate > 1.5) {
// Quadratic attenuation.
lightAttenuation[2] = 1.0f;
} else if (lightDecayRate > 0.5f) {
// Linear attenuation.
lightAttenuation[1] = 1.0f;
} else {
// No/constant attenuation.
lightAttenuation[0] = 1.0f;
}
if (lightHasDirection && !lightHasPosition) {
// This is a directional light. Set the direction as its position.
lightPosition[0] = -lightDirection[0];
lightPosition[1] = -lightDirection[1];
lightPosition[2] = -lightDirection[2];
lightPosition[3] = 0.0f;
// Revert direction to the default value.
lightDirection = GfVec3f(0.0f, 0.0f, -1.0f);
if (!viewDirectionAlongNegZ) {
lightDirection[2] = 1.0f;
}
}
if (!lightHasPosition && !lightHasDirection) {
// This is an ambient light.
lightAmbient = lightColor;
} else {
if (lightEmitsDiffuse) {
lightDiffuse = lightColor;
}
if (lightEmitsSpecular) {
// XXX: It seems that the specular color cannot be specified
// separately from the diffuse color on Maya lights.
lightSpecular = lightColor;
}
}
light.SetAmbient(lightAmbient);
light.SetDiffuse(lightDiffuse);
light.SetSpecular(lightSpecular);
light.SetPosition(lightPosition);
light.SetSpotDirection(lightDirection);
light.SetSpotCutoff(lightCutoff);
light.SetSpotFalloff(lightFalloff);
light.SetAttenuation(lightAttenuation);
light.SetShadowBias(lightShadowBias);
light.SetHasShadow(lightShadowOn && globalShadowOn);
lights.push_back(light);
}
lightingContext->SetLights(lights);
// XXX: These material settings match what we used to get when we read the
// material from OpenGL. This should probably eventually be something more
// sophisticated.
GlfSimpleMaterial material;
material.SetAmbient(whiteColor);
material.SetDiffuse(whiteColor);
material.SetSpecular(blackColor);
material.SetEmission(blackColor);
material.SetShininess(0.0001f);
lightingContext->SetMaterial(material);
lightingContext->SetSceneAmbient(blackColor);
return lightingContext;
}
/* static */
bool
px_vp20Utils::RenderBoundingBox(
const MBoundingBox& bounds,
const GfVec4f& color,
const MMatrix& worldViewMat,
const MMatrix& projectionMat)
{
static const GfVec3f cubeLineVertices[24] = {
// Vertical edges
GfVec3f(-0.5f, -0.5f, 0.5f),
GfVec3f(-0.5f, 0.5f, 0.5f),
GfVec3f(0.5f, -0.5f, 0.5f),
GfVec3f(0.5f, 0.5f, 0.5f),
GfVec3f(0.5f, -0.5f, -0.5f),
GfVec3f(0.5f, 0.5f, -0.5f),
GfVec3f(-0.5f, -0.5f, -0.5f),
GfVec3f(-0.5f, 0.5f, -0.5f),
// Top face edges
GfVec3f(-0.5f, 0.5f, 0.5f),
GfVec3f(0.5f, 0.5f, 0.5f),
GfVec3f(0.5f, 0.5f, 0.5f),
GfVec3f(0.5f, 0.5f, -0.5f),
GfVec3f(0.5f, 0.5f, -0.5f),
GfVec3f(-0.5f, 0.5f, -0.5f),
GfVec3f(-0.5f, 0.5f, -0.5f),
GfVec3f(-0.5f, 0.5f, 0.5f),
// Bottom face edges
GfVec3f(-0.5f, -0.5f, 0.5f),
GfVec3f(0.5f, -0.5f, 0.5f),
GfVec3f(0.5f, -0.5f, 0.5f),
GfVec3f(0.5f, -0.5f, -0.5f),
GfVec3f(0.5f, -0.5f, -0.5f),
GfVec3f(-0.5f, -0.5f, -0.5f),
GfVec3f(-0.5f, -0.5f, -0.5f),
GfVec3f(-0.5f, -0.5f, 0.5f),
};
static const std::string vertexShaderSource(
"#version 140\n"
"\n"
"in vec3 position;\n"
"uniform mat4 mvpMatrix;\n"
"\n"
"void main()\n"
"{\n"
" gl_Position = vec4(position, 1.0) * mvpMatrix;\n"
"}\n");
static const std::string fragmentShaderSource(
"#version 140\n"
"\n"
"uniform vec4 color;\n"
"out vec4 outColor;\n"
"\n"
"void main()\n"
"{\n"
" outColor = color;\n"
"}\n");
PxrMayaGLSLProgram renderBoundsProgram;
if (!renderBoundsProgram.CompileShader(GL_VERTEX_SHADER,
vertexShaderSource)) {
MGlobal::displayError("Failed to compile bounding box vertex shader");
return false;
}
if (!renderBoundsProgram.CompileShader(GL_FRAGMENT_SHADER,
fragmentShaderSource)) {
MGlobal::displayError("Failed to compile bounding box fragment shader");
return false;
}
if (!renderBoundsProgram.Link()) {
MGlobal::displayError("Failed to link bounding box render program");
return false;
}
if (!renderBoundsProgram.Validate()) {
MGlobal::displayError("Failed to validate bounding box render program");
return false;
}
GLuint renderBoundsProgramId = renderBoundsProgram.GetProgramId();
glUseProgram(renderBoundsProgramId);
// Populate an array buffer with the cube line vertices.
GLuint cubeLinesVBO;
glGenBuffers(1, &cubeLinesVBO);
glBindBuffer(GL_ARRAY_BUFFER, cubeLinesVBO);
glBufferData(GL_ARRAY_BUFFER,
sizeof(cubeLineVertices),
cubeLineVertices,
GL_STATIC_DRAW);
// Create a transformation matrix from the bounding box's center and
// dimensions.
MTransformationMatrix bboxTransformMatrix = MTransformationMatrix::identity;
bboxTransformMatrix.setTranslation(bounds.center(), MSpace::kTransform);
const double scales[3] = { bounds.width(), bounds.height(), bounds.depth() };
bboxTransformMatrix.setScale(scales, MSpace::kTransform);
const MMatrix mvpMatrix =
bboxTransformMatrix.asMatrix() * worldViewMat * projectionMat;
GLfloat mvpMatrixArray[4][4];
mvpMatrix.get(mvpMatrixArray);
// Populate the shader variables.
GLuint mvpMatrixLocation = glGetUniformLocation(renderBoundsProgramId, "mvpMatrix");
glUniformMatrix4fv(mvpMatrixLocation, 1, GL_TRUE, &mvpMatrixArray[0][0]);
GLuint colorLocation = glGetUniformLocation(renderBoundsProgramId, "color");
glUniform4fv(colorLocation, 1, color.data());
// Enable the position attribute and draw.
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glDrawArrays(GL_LINES, 0, sizeof(cubeLineVertices));
glDisableVertexAttribArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glDeleteBuffers(1, &cubeLinesVBO);
glUseProgram(0);
return true;
}
void Xform::updateSample(Time t_)
{
super::updateSample(t_);
if (m_update_flag.bits == 0) {
m_sample.flags = (m_sample.flags & ~(int)XformData::Flags::UpdatedMask);
return;
}
if (m_update_flag.variant_set_changed) { m_summary_needs_update = true; }
auto t = UsdTimeCode(t_);
const auto& conf = getImportSettings();
auto& sample = m_sample;
auto prev = sample;
if (m_summary.type == XformSummary::Type::TRS) {
auto translate = float3::zero();
auto scale = float3::one();
auto rotation = quatf::identity();
for (auto& op : m_read_ops) {
switch (op.GetOpType()) {
case UsdGeomXformOp::TypeTranslate:
{
float3 tmp;
op.GetAs((GfVec3f*)&tmp, t);
translate += tmp;
break;
}
case UsdGeomXformOp::TypeScale:
{
float3 tmp;
op.GetAs((GfVec3f*)&tmp, t);
scale *= tmp;
break;
}
case UsdGeomXformOp::TypeOrient:
{
quatf tmp;
op.GetAs((GfQuatf*)&tmp, t);
rotation *= tmp;
break;
}
case UsdGeomXformOp::TypeRotateX:
{
float angle;
op.GetAs(&angle, t);
rotation *= rotateX(angle * Deg2Rad);
break;
}
case UsdGeomXformOp::TypeRotateY:
{
float angle;
op.GetAs(&angle, t);
rotation *= rotateY(angle * Deg2Rad);
break;
}
case UsdGeomXformOp::TypeRotateZ:
{
float angle;
op.GetAs(&angle, t);
rotation *= rotateZ(angle * Deg2Rad);
break;
}
case UsdGeomXformOp::TypeRotateXYZ: //
case UsdGeomXformOp::TypeRotateXZY: //
case UsdGeomXformOp::TypeRotateYXZ: //
case UsdGeomXformOp::TypeRotateYZX: //
case UsdGeomXformOp::TypeRotateZXY: //
case UsdGeomXformOp::TypeRotateZYX: // fall through
{
float3 euler;
op.GetAs((GfVec3f*)&euler, t);
rotation *= EulerToQuaternion(euler * Deg2Rad, op.GetOpType());
break;
}
default:
break;
}
}
if (conf.swap_handedness) {
translate.x *= -1.0f;
rotation = swap_handedness(sample.rotation);
}
sample.position = translate;
sample.rotation = rotation;
sample.scale = scale;
}
else {
GfMatrix4d result;
result.SetIdentity();
for (auto& op : m_read_ops) {
auto m = op.GetOpTransform(t);
result = m * result;
}
GfTransform gft;
gft.SetMatrix(result);
(GfMatrix4f&)sample.transform = GfMatrix4f(result);
(GfVec3f&)sample.position = GfVec3f(gft.GetTranslation());
(GfQuatf&)sample.rotation = GfQuatf(gft.GetRotation().GetQuat());
(GfVec3f&)sample.scale = GfVec3f(gft.GetScale());
}
int update_flags = 0;
if (!near_equal(prev.position, sample.position)) {
update_flags |= (int)XformData::Flags::UpdatedPosition;
}
if (!near_equal(prev.rotation, sample.rotation)) {
update_flags |= (int)XformData::Flags::UpdatedRotation;
}
if (!near_equal(prev.scale, sample.scale)) {
update_flags |= (int)XformData::Flags::UpdatedScale;
}
sample.flags = (sample.flags & ~(int)XformData::Flags::UpdatedMask) | update_flags;
}
{
if (i > 7) {
TF_CODING_ERROR("Invalid corner %zu > 7.", i);
return _min;
}
return GfVec3f(
(i & 1 ? _max : _min)[0],
(i & 2 ? _max : _min)[1],
(i & 4 ? _max : _min)[2]);
}
GfRange3f
GfRange3f::GetOctant(size_t i) const
{
if (i > 7) {
TF_CODING_ERROR("Invalid octant %zu > 7.", i);
return GfRange3f();
}
GfVec3f a = GetCorner(i);
GfVec3f b = .5 * (_min + _max);
return GfRange3f(
GfVec3f(GfMin(a[0], b[0]), GfMin(a[1], b[1]), GfMin(a[2], b[2])),
GfVec3f(GfMax(a[0], b[0]), GfMax(a[1], b[1]), GfMax(a[2], b[2])));
}
const GfRange3f GfRange3f::UnitCube(GfVec3f(0,0,0), GfVec3f(1,1,1));
PXR_NAMESPACE_CLOSE_SCOPE
My_TestGLDrawing() {
SetCameraRotate(0, 0);
SetCameraTranslate(GfVec3f(0));
_reprName = HdTokens->hull;
_refineLevel = 0;
}
/*static*/
VtValue
UsdImagingSphereAdapter::GetMeshPoints(UsdPrim const& prim,
UsdTimeCode time)
{
static GfVec3f points[] = {
GfVec3f( 0.2384, 0.1483, -0.9511) ,GfVec3f( 0.0839, 0.2606, -0.9511) ,GfVec3f(-0.1071, 0.2606, -0.9511),
GfVec3f(-0.2616, 0.1483, -0.9511) ,GfVec3f(-0.3206, -0.0333, -0.9511) ,GfVec3f(-0.2616, -0.2149, -0.9511),
GfVec3f(-0.1071, -0.3272, -0.9511) ,GfVec3f( 0.0839, -0.3272, -0.9511) ,GfVec3f( 0.2384, -0.2149, -0.9511),
GfVec3f( 0.2975, -0.0333, -0.9511) ,GfVec3f( 0.4640, 0.3122, -0.8090) ,GfVec3f( 0.1701, 0.5257, -0.8090),
GfVec3f(-0.1932, 0.5257, -0.8090) ,GfVec3f(-0.4871, 0.3122, -0.8090) ,GfVec3f(-0.5993, -0.0333, -0.8090),
GfVec3f(-0.4871, -0.3788, -0.8090) ,GfVec3f(-0.1932, -0.5923, -0.8090) ,GfVec3f( 0.1701, -0.5923, -0.8090),
GfVec3f( 0.4640, -0.3788, -0.8090) ,GfVec3f( 0.5762, -0.0333, -0.8090) ,GfVec3f( 0.6429, 0.4422, -0.5878),
GfVec3f( 0.2384, 0.7361, -0.5878) ,GfVec3f(-0.2616, 0.7361, -0.5878) ,GfVec3f(-0.6661, 0.4422, -0.5878),
GfVec3f(-0.8206, -0.0333, -0.5878) ,GfVec3f(-0.6661, -0.5088, -0.5878) ,GfVec3f(-0.2616, -0.8027, -0.5878),
GfVec3f( 0.2384, -0.8027, -0.5878) ,GfVec3f( 0.6429, -0.5088, -0.5878) ,GfVec3f( 0.7975, -0.0333, -0.5878),
GfVec3f( 0.7579, 0.5257, -0.3090) ,GfVec3f( 0.2823, 0.8712, -0.3090) ,GfVec3f(-0.3055, 0.8712, -0.3090),
GfVec3f(-0.7810, 0.5257, -0.3090) ,GfVec3f(-0.9626, -0.0333, -0.3090) ,GfVec3f(-0.7810, -0.5923, -0.3090),
GfVec3f(-0.3055, -0.9378, -0.3090) ,GfVec3f( 0.2823, -0.9378, -0.3090) ,GfVec3f( 0.7579, -0.5923, -0.3090),
GfVec3f( 0.9395, -0.0333, -0.3090) ,GfVec3f( 0.7975, 0.5545, -0.0000) ,GfVec3f( 0.2975, 0.9178, -0.0000),
GfVec3f(-0.3206, 0.9178, -0.0000) ,GfVec3f(-0.8206, 0.5545, -0.0000) ,GfVec3f(-1.0116, -0.0333, 0.0000),
GfVec3f(-0.8206, -0.6211, 0.0000) ,GfVec3f(-0.3206, -0.9844, 0.0000) ,GfVec3f( 0.2975, -0.9844, 0.0000),
GfVec3f( 0.7975, -0.6211, 0.0000) ,GfVec3f( 0.9884, -0.0333, 0.0000) ,GfVec3f( 0.7579, 0.5257, 0.3090),
GfVec3f( 0.2823, 0.8712, 0.3090) ,GfVec3f(-0.3055, 0.8712, 0.3090) ,GfVec3f(-0.7810, 0.5257, 0.3090),
GfVec3f(-0.9626, -0.0333, 0.3090) ,GfVec3f(-0.7810, -0.5923, 0.3090) ,GfVec3f(-0.3055, -0.9378, 0.3090),
GfVec3f( 0.2823, -0.9378, 0.3090) ,GfVec3f( 0.7579, -0.5923, 0.3090) ,GfVec3f( 0.9395, -0.0333, 0.3090),
GfVec3f( 0.6429, 0.4422, 0.5878) ,GfVec3f( 0.2384, 0.7361, 0.5878) ,GfVec3f(-0.2616, 0.7361, 0.5878),
GfVec3f(-0.6661, 0.4422, 0.5878) ,GfVec3f(-0.8206, -0.0333, 0.5878) ,GfVec3f(-0.6661, -0.5088, 0.5878),
GfVec3f(-0.2616, -0.8027, 0.5878) ,GfVec3f( 0.2384, -0.8027, 0.5878) ,GfVec3f( 0.6429, -0.5088, 0.5878),
GfVec3f( 0.7975, -0.0333, 0.5878) ,GfVec3f( 0.4640, 0.3122, 0.8090) ,GfVec3f( 0.1701, 0.5257, 0.8090),
GfVec3f(-0.1932, 0.5257, 0.8090) ,GfVec3f(-0.4871, 0.3122, 0.8090) ,GfVec3f(-0.5993, -0.0333, 0.8090),
GfVec3f(-0.4871, -0.3788, 0.8090) ,GfVec3f(-0.1932, -0.5923, 0.8090) ,GfVec3f( 0.1701, -0.5923, 0.8090),
GfVec3f( 0.4640, -0.3788, 0.8090) ,GfVec3f( 0.5762, -0.0333, 0.8090) ,GfVec3f( 0.2384, 0.1483, 0.9511),
GfVec3f( 0.0839, 0.2606, 0.9511) ,GfVec3f(-0.1071, 0.2606, 0.9511) ,GfVec3f(-0.2616, 0.1483, 0.9511),
GfVec3f(-0.3206, -0.0333, 0.9511) ,GfVec3f(-0.2616, -0.2149, 0.9511) ,GfVec3f(-0.1071, -0.3272, 0.9511),
GfVec3f( 0.0839, -0.3272, 0.9511) ,GfVec3f( 0.2384, -0.2149, 0.9511) ,GfVec3f( 0.2975, -0.0333, 0.9511),
GfVec3f(-0.0116, -0.0333, -1.0000) ,GfVec3f(-0.0116, -0.0333, 1.0000),
};
size_t numPoints = sizeof(points) / sizeof(points[0]);
VtArray<GfVec3f> output(numPoints);
std::copy(points, points + numPoints, output.begin());
return VtValue(output);
}
bool
UsdGeomPointInstancer::ComputeExtentAtTime(
VtVec3fArray* extent,
const UsdTimeCode time,
const UsdTimeCode baseTime) const
{
if (!extent) {
TF_WARN("%s -- null container passed to ComputeExtentAtTime()",
GetPrim().GetPath().GetText());
return false;
}
VtIntArray protoIndices;
if (!GetProtoIndicesAttr().Get(&protoIndices, time)) {
TF_WARN("%s -- no prototype indices",
GetPrim().GetPath().GetText());
return false;
}
const std::vector<bool> mask = ComputeMaskAtTime(time);
if (!mask.empty() && mask.size() != protoIndices.size()) {
TF_WARN("%s -- mask.size() [%zu] != protoIndices.size() [%zu]",
GetPrim().GetPath().GetText(),
mask.size(),
protoIndices.size());
return false;
}
const UsdRelationship prototypes = GetPrototypesRel();
SdfPathVector protoPaths;
if (!prototypes.GetTargets(&protoPaths) || protoPaths.empty()) {
TF_WARN("%s -- no prototypes",
GetPrim().GetPath().GetText());
return false;
}
// verify that all the protoIndices are in bounds.
TF_FOR_ALL(iter, protoIndices) {
const int protoIndex = *iter;
if (protoIndex < 0 ||
static_cast<size_t>(protoIndex) >= protoPaths.size()) {
TF_WARN("%s -- invalid prototype index: %d. Should be in [0, %zu)",
GetPrim().GetPath().GetText(),
protoIndex,
protoPaths.size());
return false;
}
}
// Note that we do NOT apply any masking when computing the instance
// transforms. This is so that for a particular instance we can determine
// both its transform and its prototype. Otherwise, the instanceTransforms
// array would have masked instances culled out and we would lose the
// mapping to the prototypes.
// Masked instances will be culled before being applied to the extent below.
VtMatrix4dArray instanceTransforms;
if (!ComputeInstanceTransformsAtTime(&instanceTransforms,
time,
baseTime,
IncludeProtoXform,
IgnoreMask)) {
TF_WARN("%s -- could not compute instance transforms",
GetPrim().GetPath().GetText());
return false;
}
UsdStageWeakPtr stage = GetPrim().GetStage();
const TfTokenVector purposes {
UsdGeomTokens->default_,
UsdGeomTokens->proxy,
UsdGeomTokens->render
};
UsdGeomBBoxCache bboxCache(time, purposes);
bboxCache.SetTime(time);
GfRange3d extentRange;
for (size_t instanceId = 0; instanceId < protoIndices.size(); ++instanceId) {
if (!mask.empty() && !mask[instanceId]) {
continue;
}
const int protoIndex = protoIndices[instanceId];
const SdfPath& protoPath = protoPaths[protoIndex];
const UsdPrim& protoPrim = stage->GetPrimAtPath(protoPath);
// Get the prototype bounding box.
GfBBox3d thisBounds = bboxCache.ComputeUntransformedBound(protoPrim);
// Apply the instance transform.
thisBounds.Transform(instanceTransforms[instanceId]);
extentRange.UnionWith(thisBounds.ComputeAlignedRange());
}
const GfVec3d extentMin = extentRange.GetMin();
const GfVec3d extentMax = extentRange.GetMax();
*extent = VtVec3fArray(2);
(*extent)[0] = GfVec3f(extentMin[0], extentMin[1], extentMin[2]);
(*extent)[1] = GfVec3f(extentMax[0], extentMax[1], extentMax[2]);
return true;
}
return GetNormalsAttr().SetMetadata(UsdGeomTokens->interpolation,
interpolation);
}
TF_CODING_ERROR("Attempt to set invalid interpolation "
"\"%s\" for normals attr on prim %s",
interpolation.GetText(),
GetPrim().GetPath().GetString().c_str());
return false;
}
bool
UsdGeomPointBased::ComputeExtent(const VtVec3fArray& points,
VtVec3fArray* extent)
{
// Create Sized Extent
extent->resize(2);
// Calculate bounds
GfRange3d bbox;
TF_FOR_ALL(pointsItr, points) {
bbox.UnionWith(GfVec3f(*pointsItr));
}
(*extent)[0] = GfVec3f(bbox.GetMin());
(*extent)[1] = GfVec3f(bbox.GetMax());
return true;
}
void
My_TestGLDrawing::InitTest()
{
_renderIndex = HdRenderIndex::New(&_renderDelegate);
TF_VERIFY(_renderIndex != nullptr);
_delegate = new Hdx_UnitTestDelegate(_renderIndex);
_delegate->SetRefineLevel(_refineLevel);
// prepare render task
SdfPath renderSetupTask("/renderSetupTask");
SdfPath renderTask("/renderTask");
_delegate->AddRenderSetupTask(renderSetupTask);
_delegate->AddRenderTask(renderTask);
// render task parameters.
HdxRenderTaskParams param
= _delegate->GetTaskParam(
renderSetupTask, HdTokens->params).Get<HdxRenderTaskParams>();
param.enableLighting = true; // use default lighting
_delegate->SetTaskParam(renderSetupTask, HdTokens->params, VtValue(param));
_delegate->SetTaskParam(renderTask, HdTokens->collection,
VtValue(HdRprimCollection(HdTokens->geometry,
_reprName)));
// prepare scene
// To ensure that the non-aggregated element index returned via picking,
// we need to have at least two cubes with uniform colors.
GfVec4f red(1,0,0,1), green(0,1,0,1), blue(0,0,1,1),
yellow(1,1,0,1), magenta(1,0,1,1), cyan(0,1,1,1),
white(1,1,1,1), black(0,0,0,1);
GfVec4f faceColors[] = { red, green, blue, yellow, magenta, cyan};
VtValue faceColor = VtValue(_BuildArray(&faceColors[0],
sizeof(faceColors)/sizeof(faceColors[0])));
GfVec4f vertColors[] = { white, blue, green, yellow,
black, blue, magenta, red};
VtValue vertColor = VtValue(_BuildArray(&vertColors[0],
sizeof(vertColors)/sizeof(vertColors[0])));
_delegate->AddCube(SdfPath("/cube0"), _GetTranslate( 5, 0, 5),
/*guide=*/false, /*instancerId=*/SdfPath(),
/*scheme=*/PxOsdOpenSubdivTokens->catmark,
/*color=*/faceColor,
/*colorInterpolation=*/Hdx_UnitTestDelegate::UNIFORM);
_delegate->AddCube(SdfPath("/cube1"), _GetTranslate(-5, 0, 5),
/*guide=*/false, /*instancerId=*/SdfPath(),
/*scheme=*/PxOsdOpenSubdivTokens->catmark,
/*color=*/faceColor,
/*colorInterpolation=*/Hdx_UnitTestDelegate::UNIFORM);
_delegate->AddCube(SdfPath("/cube2"), _GetTranslate(-5, 0,-5));
_delegate->AddCube(SdfPath("/cube3"), _GetTranslate( 5, 0,-5),
/*guide=*/false, /*instancerId=*/SdfPath(),
/*scheme=*/PxOsdOpenSubdivTokens->catmark,
/*color=*/vertColor,
/*colorInterpolation=*/Hdx_UnitTestDelegate::VERTEX);
{
_delegate->AddInstancer(SdfPath("/instancerTop"));
_delegate->AddCube(SdfPath("/protoTop"),
GfMatrix4d(1), false, SdfPath("/instancerTop"));
std::vector<SdfPath> prototypes;
prototypes.push_back(SdfPath("/protoTop"));
VtVec3fArray scale(3);
VtVec4fArray rotate(3);
VtVec3fArray translate(3);
VtIntArray prototypeIndex(3);
scale[0] = GfVec3f(1);
rotate[0] = GfVec4f(0);
translate[0] = GfVec3f(3, 0, 2);
prototypeIndex[0] = 0;
scale[1] = GfVec3f(1);
rotate[1] = GfVec4f(0);
translate[1] = GfVec3f(0, 0, 2);
prototypeIndex[1] = 0;
scale[2] = GfVec3f(1);
rotate[2] = GfVec4f(0);
translate[2] = GfVec3f(-3, 0, 2);
prototypeIndex[2] = 0;
_delegate->SetInstancerProperties(SdfPath("/instancerTop"),
prototypeIndex,
scale, rotate, translate);
}
{
_delegate->AddInstancer(SdfPath("/instancerBottom"));
_delegate->AddCube(SdfPath("/protoBottom"),
GfMatrix4d(1), false, SdfPath("/instancerBottom"));
std::vector<SdfPath> prototypes;
prototypes.push_back(SdfPath("/protoBottom"));
VtVec3fArray scale(3);
VtVec4fArray rotate(3);
VtVec3fArray translate(3);
VtIntArray prototypeIndex(3);
scale[0] = GfVec3f(1);
rotate[0] = GfVec4f(0);
translate[0] = GfVec3f(3, 0, -2);
prototypeIndex[0] = 0;
scale[1] = GfVec3f(1);
rotate[1] = GfVec4f(0);
translate[1] = GfVec3f(0, 0, -2);
prototypeIndex[1] = 0;
scale[2] = GfVec3f(1);
rotate[2] = GfVec4f(0);
translate[2] = GfVec3f(-3, 0, -2);
prototypeIndex[2] = 0;
_delegate->SetInstancerProperties(SdfPath("/instancerBottom"),
prototypeIndex,
scale, rotate, translate);
}
SetCameraTranslate(GfVec3f(0, 0, -20));
// XXX: Setup a VAO, the current drawing engine will not yet do this.
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
glBindVertexArray(0);
}
bool
PxrUsdMayaWriteUtil::SetUsdAttr(
const MPlug& attrPlug,
const UsdAttribute& usdAttr,
const UsdTimeCode& usdTime,
const bool translateMayaDoubleToUsdSinglePrecision)
{
if (!usdAttr || attrPlug.isNull()) {
return false;
}
bool isAnimated = attrPlug.isDestination();
if (usdTime.IsDefault() == isAnimated) {
return true;
}
// We perform a similar set of type-infererence acrobatics here as we do up
// above in GetUsdTypeName(). See the comments there for more detail on a
// few type-related oddities.
MObject attrObj(attrPlug.attribute());
if (attrObj.hasFn(MFn::kEnumAttribute)) {
MFnEnumAttribute enumAttrFn(attrObj);
const short enumIndex = attrPlug.asShort();
const TfToken enumToken(enumAttrFn.fieldName(enumIndex).asChar());
return usdAttr.Set(enumToken, usdTime);
}
MFnNumericData::Type numericDataType;
MFnData::Type typedDataType;
MFnUnitAttribute::Type unitDataType;
_GetMayaAttributeNumericTypedAndUnitDataTypes(attrPlug,
numericDataType,
typedDataType,
unitDataType);
if (attrObj.hasFn(MFn::kMatrixAttribute)) {
typedDataType = MFnData::kMatrix;
}
switch (typedDataType) {
case MFnData::kString: {
MFnStringData stringDataFn(attrPlug.asMObject());
const std::string usdVal(stringDataFn.string().asChar());
return usdAttr.Set(usdVal, usdTime);
break;
}
case MFnData::kMatrix: {
MFnMatrixData matrixDataFn(attrPlug.asMObject());
const GfMatrix4d usdVal(matrixDataFn.matrix().matrix);
return usdAttr.Set(usdVal, usdTime);
break;
}
case MFnData::kStringArray: {
MFnStringArrayData stringArrayDataFn(attrPlug.asMObject());
VtStringArray usdVal(stringArrayDataFn.length());
for (unsigned int i = 0; i < stringArrayDataFn.length(); ++i) {
usdVal[i] = std::string(stringArrayDataFn[i].asChar());
}
return usdAttr.Set(usdVal, usdTime);
break;
}
case MFnData::kDoubleArray: {
MFnDoubleArrayData doubleArrayDataFn(attrPlug.asMObject());
if (translateMayaDoubleToUsdSinglePrecision) {
VtFloatArray usdVal(doubleArrayDataFn.length());
for (unsigned int i = 0; i < doubleArrayDataFn.length(); ++i) {
usdVal[i] = (float)doubleArrayDataFn[i];
}
return usdAttr.Set(usdVal, usdTime);
} else {
VtDoubleArray usdVal(doubleArrayDataFn.length());
for (unsigned int i = 0; i < doubleArrayDataFn.length(); ++i) {
usdVal[i] = doubleArrayDataFn[i];
}
return usdAttr.Set(usdVal, usdTime);
}
break;
}
case MFnData::kFloatArray: {
MFnFloatArrayData floatArrayDataFn(attrPlug.asMObject());
VtFloatArray usdVal(floatArrayDataFn.length());
for (unsigned int i = 0; i < floatArrayDataFn.length(); ++i) {
usdVal[i] = floatArrayDataFn[i];
}
return usdAttr.Set(usdVal, usdTime);
break;
}
case MFnData::kIntArray: {
MFnIntArrayData intArrayDataFn(attrPlug.asMObject());
VtIntArray usdVal(intArrayDataFn.length());
for (unsigned int i = 0; i < intArrayDataFn.length(); ++i) {
usdVal[i] = intArrayDataFn[i];
}
return usdAttr.Set(usdVal, usdTime);
break;
}
case MFnData::kPointArray: {
MFnPointArrayData pointArrayDataFn(attrPlug.asMObject());
if (translateMayaDoubleToUsdSinglePrecision) {
VtVec3fArray usdVal(pointArrayDataFn.length());
for (unsigned int i = 0; i < pointArrayDataFn.length(); ++i) {
MPoint tmpMayaVal = pointArrayDataFn[i];
if (tmpMayaVal.w != 0) {
tmpMayaVal.cartesianize();
}
usdVal[i] = GfVec3f((float)tmpMayaVal[0],
(float)tmpMayaVal[1],
(float)tmpMayaVal[2]);
}
return usdAttr.Set(usdVal, usdTime);
} else {
VtVec3dArray usdVal(pointArrayDataFn.length());
for (unsigned int i = 0; i < pointArrayDataFn.length(); ++i) {
MPoint tmpMayaVal = pointArrayDataFn[i];
if (tmpMayaVal.w != 0) {
tmpMayaVal.cartesianize();
}
usdVal[i] = GfVec3d(tmpMayaVal[0],
tmpMayaVal[1],
tmpMayaVal[2]);
}
return usdAttr.Set(usdVal, usdTime);
}
break;
}
case MFnData::kVectorArray: {
MFnVectorArrayData vectorArrayDataFn(attrPlug.asMObject());
if (translateMayaDoubleToUsdSinglePrecision) {
VtVec3fArray usdVal(vectorArrayDataFn.length());
for (unsigned int i = 0; i < vectorArrayDataFn.length(); ++i) {
MVector tmpMayaVal = vectorArrayDataFn[i];
usdVal[i] = GfVec3f((float)tmpMayaVal[0],
(float)tmpMayaVal[1],
(float)tmpMayaVal[2]);
}
return usdAttr.Set(usdVal, usdTime);
} else {
VtVec3dArray usdVal(vectorArrayDataFn.length());
for (unsigned int i = 0; i < vectorArrayDataFn.length(); ++i) {
MVector tmpMayaVal = vectorArrayDataFn[i];
usdVal[i] = GfVec3d(tmpMayaVal[0],
tmpMayaVal[1],
tmpMayaVal[2]);
}
return usdAttr.Set(usdVal, usdTime);
}
break;
}
default:
break;
}
switch (numericDataType) {
case MFnNumericData::kBoolean: {
const bool usdVal(attrPlug.asBool());
return usdAttr.Set(usdVal, usdTime);
break;
}
case MFnNumericData::kByte:
case MFnNumericData::kChar: {
const int usdVal(attrPlug.asChar());
return usdAttr.Set(usdVal, usdTime);
break;
}
case MFnNumericData::kShort: {
const int usdVal(attrPlug.asShort());
return usdAttr.Set(usdVal, usdTime);
break;
}
case MFnNumericData::kInt: {
const int usdVal(attrPlug.asInt());
return usdAttr.Set(usdVal, usdTime);
break;
}
case MFnNumericData::k2Short: {
short tmp1, tmp2;
MFnNumericData numericDataFn(attrPlug.asMObject());
numericDataFn.getData(tmp1, tmp2);
return usdAttr.Set(GfVec2i(tmp1, tmp2), usdTime);
break;
}
case MFnNumericData::k2Int: {
int tmp1, tmp2;
MFnNumericData numericDataFn(attrPlug.asMObject());
numericDataFn.getData(tmp1, tmp2);
return usdAttr.Set(GfVec2i(tmp1, tmp2), usdTime);
break;
}
case MFnNumericData::k3Short: {
short tmp1, tmp2, tmp3;
MFnNumericData numericDataFn(attrPlug.asMObject());
numericDataFn.getData(tmp1, tmp2, tmp3);
return usdAttr.Set(GfVec3i(tmp1, tmp2, tmp3), usdTime);
break;
}
case MFnNumericData::k3Int: {
int tmp1, tmp2, tmp3;
MFnNumericData numericDataFn(attrPlug.asMObject());
numericDataFn.getData(tmp1, tmp2, tmp3);
return usdAttr.Set(GfVec3i(tmp1, tmp2, tmp3), usdTime);
break;
}
case MFnNumericData::kFloat: {
const float usdVal(attrPlug.asFloat());
return usdAttr.Set(usdVal, usdTime);
break;
}
case MFnNumericData::k2Float: {
float tmp1, tmp2;
MFnNumericData numericDataFn(attrPlug.asMObject());
numericDataFn.getData(tmp1, tmp2);
return usdAttr.Set(GfVec2f(tmp1, tmp2), usdTime);
break;
}
case MFnNumericData::k3Float: {
float tmp1, tmp2, tmp3;
MFnNumericData numericDataFn(attrPlug.asMObject());
numericDataFn.getData(tmp1, tmp2, tmp3);
return _SetVec(usdAttr, GfVec3f(tmp1, tmp2, tmp3), usdTime);
break;
}
case MFnNumericData::kDouble: {
const double usdVal(attrPlug.asDouble());
if (translateMayaDoubleToUsdSinglePrecision) {
return usdAttr.Set((float)usdVal, usdTime);
} else {
return usdAttr.Set(usdVal, usdTime);
}
break;
}
case MFnNumericData::k2Double: {
double tmp1, tmp2;
MFnNumericData numericDataFn(attrPlug.asMObject());
numericDataFn.getData(tmp1, tmp2);
if (translateMayaDoubleToUsdSinglePrecision) {
return usdAttr.Set(GfVec2f((float)tmp1, (float)tmp2), usdTime);
} else {
return usdAttr.Set(GfVec2d(tmp1, tmp2), usdTime);
}
break;
}
case MFnNumericData::k3Double: {
double tmp1, tmp2, tmp3;
MFnNumericData numericDataFn(attrPlug.asMObject());
numericDataFn.getData(tmp1, tmp2, tmp3);
if (translateMayaDoubleToUsdSinglePrecision) {
return _SetVec(usdAttr,
GfVec3f((float)tmp1,
(float)tmp2,
(float)tmp3),
usdTime);
} else {
return _SetVec(usdAttr, GfVec3d(tmp1, tmp2, tmp3), usdTime);
}
break;
}
case MFnNumericData::k4Double: {
double tmp1, tmp2, tmp3, tmp4;
MFnNumericData numericDataFn(attrPlug.asMObject());
numericDataFn.getData(tmp1, tmp2, tmp3, tmp4);
if (translateMayaDoubleToUsdSinglePrecision) {
return _SetVec(usdAttr,
GfVec4f((float)tmp1,
(float)tmp2,
(float)tmp3,
(float)tmp4),
usdTime);
} else {
return _SetVec(usdAttr,
GfVec4d(tmp1, tmp2, tmp3, tmp4),
usdTime);
}
break;
}
default:
break;
}
switch (unitDataType) {
case MFnUnitAttribute::kAngle:
case MFnUnitAttribute::kDistance:
if (translateMayaDoubleToUsdSinglePrecision) {
const float usdVal(attrPlug.asFloat());
return usdAttr.Set(usdVal, usdTime);
} else {
const double usdVal(attrPlug.asDouble());
return usdAttr.Set(usdVal, usdTime);
}
break;
default:
break;
}
return false;
}
int
main(int argc, char *argv[])
{
// GfVec2f
{
float vals[] = { 1.0f, 2.0f };
GfVec2f v(vals);
TF_AXIOM(v == GfVec2f(1,2));
float const *f = v.GetArray();
TF_AXIOM(f[0] == 1 and f[1] == 2);
}
// GfVec2i
{
int vals[] = { 1, 2 };
GfVec2i v(vals);
TF_AXIOM(v == GfVec2i(1,2));
int const *i = v.GetArray();
TF_AXIOM(i[0] == 1 and i[1] == 2);
v.Set(0, 1);
TF_AXIOM(v == GfVec2i(0,1));
}
// GfVec3i
{
int vals[] = { 1, 2, 3 };
GfVec3i v(vals);
TF_AXIOM(v == GfVec3i(1,2,3));
int const *i = v.GetArray();
TF_AXIOM(i[0] == 1 and i[1] == 2 and i[2] == 3);
v.Set(0, 1, 2);
TF_AXIOM(v == GfVec3i(0,1,2));
}
// GfVec4i
{
int vals[] = { 1, 2, 3, 4 };
GfVec4i v(vals);
TF_AXIOM(v == GfVec4i(1,2,3,4));
int const *i = v.GetArray();
TF_AXIOM(i[0] == 1 and i[1] == 2 and i[2] == 3 and i[3] == 4);
v.Set(0, 1, 2, 3);
TF_AXIOM(v == GfVec4i(0,1,2,3));
}
// GfVec3f
{
float vals[] = { 1.0f, 2.0f, 3.0f };
GfVec3f v(vals);
TF_AXIOM(v == GfVec3f(1,2,3));
float const *f = v.GetArray();
TF_AXIOM(f[0] == 1 and f[1] == 2 and f[2] == 3);
}
// GfVec4f
{
float vals[] = { 1.0f, 2.0f, 3.0f, 4.0f };
GfVec4f v(vals);
TF_AXIOM(v == GfVec4f(1,2,3,4));
float const *f = v.GetArray();
TF_AXIOM(f[0] == 1 and f[1] == 2 and f[2] == 3 and f[3] == 4);
}
// GfSize2, GfSize3
{
size_t vals[] = {1, 2, 3};
TF_AXIOM(GfSize2(vals) == GfSize2(1,2));
TF_AXIOM(GfSize3(vals) == GfSize3(1,2,3));
}
// GfMatrix2d
{
double vals[2][2] = {{1, 0},
{0, 1}};
TF_AXIOM(GfMatrix2d(vals) == GfMatrix2d(1));
GfMatrix2d m(vals);
double const *d = m.GetArray();
TF_AXIOM(d[0] == 1 and d[1] == 0 and
d[2] == 0 and d[3] == 1);
}
// GfMatrix2f
{
float vals[2][2] = {{1, 0},
{0, 1}};
TF_AXIOM(GfMatrix2f(vals) == GfMatrix2f(1));
GfMatrix2f m(vals);
float const *f = m.GetArray();
TF_AXIOM(f[0] == 1 and f[1] == 0 and
f[2] == 0 and f[3] == 1);
}
// GfMatrix3d
{
double vals[3][3] = {{1, 0, 0},
{0, 1, 0},
{0, 0, 1}};
TF_AXIOM(GfMatrix3d(vals) == GfMatrix3d(1));
GfMatrix3d m(vals);
double const *d = m.GetArray();
TF_AXIOM(d[0] == 1 and d[1] == 0 and d[2] == 0 and
d[3] == 0 and d[4] == 1 and d[5] == 0 and
d[6] == 0 and d[7] == 0 and d[8] == 1);
}
// GfMatrix4d
{
double vals[4][4] = {{1, 0, 0, 0},
{0, 1, 0, 0},
{0, 0, 1, 0},
{0, 0, 0, 1}};
TF_AXIOM(GfMatrix4d(vals) == GfMatrix4d(1));
GfMatrix4d m(vals);
double const *d = m.GetArray();
TF_AXIOM(d[ 0] == 1 and d[ 1] == 0 and d[ 2] == 0 and d[ 3] == 0 and
d[ 4] == 0 and d[ 5] == 1 and d[ 6] == 0 and d[ 7] == 0 and
d[ 8] == 0 and d[ 9] == 0 and d[10] == 1 and d[11] == 0 and
d[12] == 0 and d[13] == 0 and d[14] == 0 and d[15] == 1);
}
// half
{
float halfPosInf = half::posInf();
TF_AXIOM(not std::isfinite(halfPosInf));
TF_AXIOM(std::isinf(halfPosInf));
float halfNegInf = half::negInf();
TF_AXIOM(not std::isfinite(halfNegInf));
TF_AXIOM(std::isinf(halfNegInf));
float halfqNan = half::qNan();
TF_AXIOM(std::isnan(halfqNan));
float halfsNan = half::sNan();
TF_AXIOM(std::isnan(halfsNan));
}
return 0;
}
My_TestGLDrawing() {
SetCameraRotate(0, 0);
SetCameraTranslate(GfVec3f(0));
}
