// Implements __getitem__ for a slice
static list __getslice__(const GfVec4f &self, slice indices) {
list result;
const float* begin = self.data();
const float* end = begin + 4;
slice::range<const float*> bounds;
try {
// This appears to be a typo in the boost headers. The method
// name should be "get_indices".
//
bounds = indices.get_indicies<>(begin, end);
} catch (std::invalid_argument) {
return result;
}
while (bounds.start != bounds.stop) {
result.append(*bounds.start);
bounds.start += bounds.step;
}
// Unlike STL ranges, bounds represents a *closed* interval. This
// means that we must append exactly one more item at the end of
// the list.
//
result.append(*bounds.start);
return result;
}
/* static */
GT_DataArrayHandle
GusdPrimWrapper::convertPrimvarData( const UsdGeomPrimvar& primvar, UsdTimeCode time ) {
SdfValueTypeName typeName = primvar.GetTypeName();
if( typeName == SdfValueTypeNames->Int )
{
int usdVal;
primvar.Get( &usdVal, time );
return new GT_Int32Array( &usdVal, 1, 1 );
}
else if( typeName == SdfValueTypeNames->Int64 )
{
int64_t usdVal;
primvar.Get( &usdVal, time );
return new GT_Int64Array( &usdVal, 1, 1 );
}
else if( typeName == SdfValueTypeNames->Float )
{
float usdVal;
primvar.Get( &usdVal, time );
return new GT_Real32Array( &usdVal, 1, 1 );
}
else if( typeName == SdfValueTypeNames->Double )
{
double usdVal;
primvar.Get( &usdVal, time );
return new GT_Real64Array( &usdVal, 1, 1 );
}
else if( typeName == SdfValueTypeNames->Float3 )
{
GfVec3f usdVal;
primvar.Get( &usdVal, time );
return new GT_Real32Array( usdVal.data(), 1, 3 );
}
else if( typeName == SdfValueTypeNames->Double3 )
{
GfVec3d usdVal;
primvar.Get( &usdVal, time );
return new GT_Real64Array( usdVal.data(), 1, 3 );
}
else if( typeName == SdfValueTypeNames->Color3f )
{
GfVec3f usdVal;
primvar.Get( &usdVal, time );
return new GT_Real32Array( usdVal.data(), 1, 3, GT_TYPE_COLOR );
}
else if( typeName == SdfValueTypeNames->Color3d )
{
GfVec3d usdVal;
primvar.Get( &usdVal, time );
return new GT_Real64Array( usdVal.data(), 1, 3, GT_TYPE_COLOR );
}
else if( typeName == SdfValueTypeNames->Normal3f )
{
GfVec3f usdVal;
primvar.Get( &usdVal, time );
return new GT_Real32Array( usdVal.data(), 1, 3, GT_TYPE_NORMAL );
}
else if( typeName == SdfValueTypeNames->Normal3d )
{
GfVec3d usdVal;
primvar.Get( &usdVal, time );
return new GT_Real64Array( usdVal.data(), 1, 3, GT_TYPE_NORMAL );
}
else if( typeName == SdfValueTypeNames->Point3f )
{
GfVec3f usdVal;
primvar.Get( &usdVal, time );
return new GT_Real32Array( usdVal.data(), 1, 3, GT_TYPE_POINT );
}
else if( typeName == SdfValueTypeNames->Point3d )
{
GfVec3d usdVal;
primvar.Get( &usdVal, time );
return new GT_Real64Array( usdVal.data(), 1, 3, GT_TYPE_POINT );
}
else if( typeName == SdfValueTypeNames->Float4 )
{
GfVec4f usdVal;
primvar.Get( &usdVal, time );
return new GT_Real32Array( usdVal.data(), 1, 4 );
}
else if( typeName == SdfValueTypeNames->Double4 )
{
GfVec4d usdVal;
primvar.Get( &usdVal, time );
return new GT_Real64Array( usdVal.data(), 1, 4 );
}
else if( typeName == SdfValueTypeNames->Quatf )
{
GfVec4f usdVal;
primvar.Get( &usdVal, time );
return new GT_Real32Array( usdVal.data(), 1, 4, GT_TYPE_QUATERNION );
}
else if( typeName == SdfValueTypeNames->Quatd )
{
GfVec4d usdVal;
primvar.Get( &usdVal, time );
return new GT_Real64Array( usdVal.data(), 1, 4, GT_TYPE_QUATERNION );
}
else if( typeName == SdfValueTypeNames->Matrix3d )
{
GfMatrix3d usdVal;
primvar.Get( &usdVal, time );
return new GT_Real64Array( usdVal.GetArray(), 1, 9, GT_TYPE_MATRIX3 );
}
else if( typeName == SdfValueTypeNames->Matrix4d ||
typeName == SdfValueTypeNames->Frame4d )
{
GfMatrix4d usdVal;
primvar.Get( &usdVal, time );
return new GT_Real64Array( usdVal.GetArray(), 1, 16, GT_TYPE_MATRIX );
}
else if( typeName == SdfValueTypeNames->String )
{
string usdVal;
primvar.Get( &usdVal, time );
auto gtString = new GT_DAIndexedString( 1 );
gtString->setString( 0, 0, usdVal.c_str() );
return gtString;
}
else if( typeName == SdfValueTypeNames->StringArray )
{
VtArray<string> usdVal;
primvar.ComputeFlattened( &usdVal, time );
auto gtString = new GT_DAIndexedString( usdVal.size() );
for( size_t i = 0; i < usdVal.size(); ++i )
gtString->setString( i, 0, usdVal[i].c_str() );
return gtString;
}
else if( typeName == SdfValueTypeNames->IntArray )
{
VtArray<int> usdVal;
primvar.ComputeFlattened( &usdVal, time );
return new GusdGT_VtArray<int>(usdVal);
}
else if( typeName == SdfValueTypeNames->Int64Array )
{
VtArray<int64_t> usdVal;
primvar.ComputeFlattened( &usdVal, time );
return new GusdGT_VtArray<int64_t>(usdVal);
}
else if( typeName == SdfValueTypeNames->FloatArray )
{
VtArray<float> usdVal;
primvar.ComputeFlattened( &usdVal, time );
return new GusdGT_VtArray<float>(usdVal);
}
else if( typeName == SdfValueTypeNames->DoubleArray )
{
VtArray<double> usdVal;
primvar.ComputeFlattened( &usdVal, time );
return new GusdGT_VtArray<double>(usdVal);
}
else if( typeName == SdfValueTypeNames->Float2Array )
{
VtArray<GfVec2f> usdVal;
primvar.ComputeFlattened( &usdVal, time );
return new GusdGT_VtArray<GfVec2f>(usdVal);
}
else if( typeName == SdfValueTypeNames->Double2Array )
{
VtArray<GfVec2d> usdVal;
primvar.ComputeFlattened( &usdVal, time );
return new GusdGT_VtArray<GfVec2d>(usdVal);
}
else if( typeName == SdfValueTypeNames->Float3Array )
{
VtArray<GfVec3f> usdVal;
primvar.ComputeFlattened( &usdVal, time );
return new GusdGT_VtArray<GfVec3f>(usdVal);
}
else if( typeName == SdfValueTypeNames->Double3Array )
{
VtArray<GfVec3d> usdVal;
primvar.ComputeFlattened( &usdVal, time );
return new GusdGT_VtArray<GfVec3d>(usdVal);
}
else if( typeName == SdfValueTypeNames->Color3fArray )
{
VtArray<GfVec3f> usdVal;
primvar.ComputeFlattened( &usdVal, time );
return new GusdGT_VtArray<GfVec3f>(usdVal,GT_TYPE_COLOR);
}
else if( typeName == SdfValueTypeNames->Color3dArray )
{
VtArray<GfVec3d> usdVal;
primvar.ComputeFlattened( &usdVal, time );
return new GusdGT_VtArray<GfVec3d>(usdVal,GT_TYPE_COLOR);
}
else if( typeName == SdfValueTypeNames->Vector3fArray )
{
VtArray<GfVec3f> usdVal;
primvar.ComputeFlattened( &usdVal, time );
return new GusdGT_VtArray<GfVec3f>(usdVal, GT_TYPE_VECTOR);
}
else if( typeName == SdfValueTypeNames->Vector3dArray )
{
VtArray<GfVec3d> usdVal;
primvar.ComputeFlattened( &usdVal, time );
return new GusdGT_VtArray<GfVec3d>(usdVal, GT_TYPE_VECTOR);
}
else if( typeName == SdfValueTypeNames->Normal3fArray )
{
VtArray<GfVec3f> usdVal;
primvar.ComputeFlattened( &usdVal, time );
return new GusdGT_VtArray<GfVec3f>(usdVal, GT_TYPE_NORMAL);
}
else if( typeName == SdfValueTypeNames->Normal3dArray )
{
VtArray<GfVec3d> usdVal;
primvar.ComputeFlattened( &usdVal, time );
return new GusdGT_VtArray<GfVec3d>(usdVal, GT_TYPE_NORMAL);
}
else if( typeName == SdfValueTypeNames->Point3fArray )
{
VtArray<GfVec3f> usdVal;
primvar.ComputeFlattened( &usdVal, time );
return new GusdGT_VtArray<GfVec3f>(usdVal, GT_TYPE_POINT);
}
else if( typeName == SdfValueTypeNames->Point3dArray )
{
VtArray<GfVec3d> usdVal;
primvar.ComputeFlattened( &usdVal, time );
return new GusdGT_VtArray<GfVec3d>(usdVal, GT_TYPE_POINT);
}
else if( typeName == SdfValueTypeNames->Float4Array )
{
VtArray<GfVec4f> usdVal;
primvar.ComputeFlattened( &usdVal, time );
return new GusdGT_VtArray<GfVec4f>(usdVal);
}
else if( typeName == SdfValueTypeNames->Double4Array )
{
VtArray<GfVec4d> usdVal;
primvar.ComputeFlattened( &usdVal, time );
return new GusdGT_VtArray<GfVec4d>(usdVal);
}
else if( typeName == SdfValueTypeNames->QuatfArray )
{
VtArray<GfVec4f> usdVal;
primvar.ComputeFlattened( &usdVal, time );
return new GusdGT_VtArray<GfVec4f>(usdVal, GT_TYPE_QUATERNION);
}
else if( typeName == SdfValueTypeNames->QuatdArray )
{
VtArray<GfVec4d> usdVal;
primvar.ComputeFlattened( &usdVal, time );
return new GusdGT_VtArray<GfVec4d>(usdVal, GT_TYPE_QUATERNION);
}
else if( typeName == SdfValueTypeNames->Matrix3dArray )
{
VtArray<GfMatrix3d> usdVal;
primvar.ComputeFlattened( &usdVal, time );
return new GusdGT_VtArray<GfMatrix3d>(usdVal, GT_TYPE_MATRIX3);
}
else if( typeName == SdfValueTypeNames->Matrix4dArray ||
typeName == SdfValueTypeNames->Frame4dArray )
{
VtArray<GfMatrix4d> usdVal;
primvar.ComputeFlattened( &usdVal, time );
return new GusdGT_VtArray<GfMatrix4d>(usdVal, GT_TYPE_MATRIX);
}
return NULL;
}
/* 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;
}
static void __setslice__(GfVec4f &self, slice indices, object values) {
// Verify our arguments
//
PyObject* valuesObj = values.ptr();
if (!PySequence_Check(valuesObj)) {
TfPyThrowTypeError("value must be a sequence");
}
float* begin = self.data();
float* end = begin + 4;
Py_ssize_t sliceLength = -1;
slice::range<float*> bounds;
// Convince g++ that we're not using uninitialized values.
//
bounds.start = 0;
bounds.stop = 0;
bounds.step = 0;
try {
// This appears to be a typo in the boost headers. The method
// name should be "get_indices".
//
bounds = indices.get_indicies<>(begin, end);
} catch (std::invalid_argument) {
sliceLength = 0;
}
// If sliceLength was not set in the exception handling code above,
// figure out how long it really is.
//
if (sliceLength == -1) {
sliceLength = ((bounds.stop - bounds.start) / bounds.step) + 1;
}
if (PySequence_Length(valuesObj) != sliceLength) {
TfPyThrowValueError(
TfStringPrintf(
"attempt to assign sequence of size %zd to slice of size %zd",
PySequence_Length(valuesObj), sliceLength));
}
// Short circuit for empty slices
//
if (sliceLength == 0) {
return;
}
// Make sure that all items can be extracted before changing the GfVec4f.
//
for (Py_ssize_t i = 0; i < sliceLength; ++i) {
// This will throw a TypeError if any of the items cannot be
// converted.
//
(void)extract<float>(PySequence_GetItem(valuesObj, i));
}
for (Py_ssize_t i = 0; i < sliceLength; ++i) {
*bounds.start =
extract<float>(PySequence_GetItem(valuesObj, i));
bounds.start += bounds.step;
}
}
