// 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; } }