void SpatialGrid::expandBBoxByPercentage(
MBoundingBox& bbox,
double percentage,
double min[3]
)
//
// Description:
//
// Expands the given bounding box by the given percentage
// in all dimensions. Percentage should be a value between
// 0 and 1, representing 0% to 100%.
//
// The optional 3 "min" values specify minimum sizes along each
// axis that the bounding box size will be expanded to. This
// is useful for situations where one of the box axes is so small
// that a percentagewise increase will not be meaningful.
//
{
percentage += 1.0;
MPoint c = bbox.center();
float w = bbox.width();
float h = bbox.height();
float d = bbox.depth();
// clamp the box sizes to the minimums, if given
//
if( min != NULL )
{
if( w < min[0] )
{
w = min[0];
}
if( h < min[1] )
{
h = min[1];
}
if( d < min[2] )
{
d = min[2];
}
}
// increase the box size
//
MVector offset(w, h, d);
offset *= (0.5f * percentage);
bbox.expand( c + offset);
bbox.expand( c - offset);
}
double gpuCacheIsectUtil::getClosestPointOnBox(const MPoint& point, const MBoundingBox& bbox, MPoint& closestPoint){
MVector diff = point - bbox.center();
MVector axis[3] = { MVector(1.0,0.0,0.0),
MVector(0.0,1.0,0.0),
MVector(0.0,0.0,1.0)};
double dimensions[3] = {0.5*bbox.width(),0.5*bbox.height(),0.5*bbox.depth()};
double sqrDistance = 0.0;
double delta;
MPoint closest;
for (int i = 0; i < 3; ++i)
{
closest[i] = diff * axis[i];
if (closest[i] < -dimensions[i])
{
delta = closest[i] + dimensions[i];
sqrDistance += delta*delta;
closest[i] = -dimensions[i];
}
else if (closest[i] > dimensions[i])
{
delta = closest[i] - dimensions[i];
sqrDistance += delta*delta;
closest[i] = dimensions[i];
}
}
closestPoint = bbox.center();
for (int i = 0; i < 3; ++i)
{
closestPoint += closest[i]*axis[i];
}
return sqrt(sqrDistance);
}
bool SGTransformManip::build()
{
SGIntersectResult& result = generalResult[0];
if (result.resultType != SGComponentType::kNone) {
intersector.intersectPoint = result.intersectPoint;
}
m_selVertices = SGSelection::getIndices( SGSelection::sels.getSelVtxIndicesMap() );
if (!m_selVertices.length()) return false;
SGMesh* pMesh = SGMesh::pMesh;
MBoundingBox bb;
for (unsigned int i = 0; i < m_selVertices.length(); i++) {
MPoint& targetPoint = pMesh->points[m_selVertices[i]];
pMesh->isCenter(m_selVertices[i], SGComponentType::kVertex);
if( !pMesh->isCenter(m_selVertices[i], SGComponentType::kVertex ) &&
SGToolCondition::option.symInfo.compairIsMirror( intersector.intersectPoint, targetPoint ) ) continue;
bb.expand(targetPoint);
}
MPoint bbCenter = bb.center();
if (SGSpace::space == MSpace::kObject) {
bbCenter *= pMesh->dagPath.inclusiveMatrix();
}
MMatrix mtx;
mtx(3, 0) = bbCenter.x;
mtx(3, 1) = bbCenter.y;
mtx(3, 2) = bbCenter.z;
intersector.build( mtx );
intersectType = SGTransformManipIntersector::kCenter;
updateCenter();
return true;
}
MStatus viewRenderUserOperation::execute( const MHWRender::MDrawContext & drawContext )
{
// Sample code to debug pass information
static const bool debugPassInformation = false;
if (debugPassInformation)
{
const MHWRender::MPassContext & passCtx = drawContext.getPassContext();
const MString & passId = passCtx.passIdentifier();
const MStringArray & passSem = passCtx.passSemantics();
printf("viewRenderUserOperation: drawing in pass[%s], semantic[", passId.asChar());
for (unsigned int i=0; i<passSem.length(); i++)
printf(" %s", passSem[i].asChar());
printf("\n");
}
// Example code to find the active override.
// This is not necessary if the operations just keep a reference
// to the override, but this demonstrates how this
// contextual information can be extracted.
//
MHWRender::MRenderer *theRenderer = MHWRender::MRenderer::theRenderer();
const MHWRender::MRenderOverride *overridePtr = NULL;
if (theRenderer)
{
const MString & overrideName = theRenderer->activeRenderOverride();
overridePtr = theRenderer->findRenderOverride( overrideName );
}
// Some sample code to debug lighting information in the MDrawContext
//
if (fDebugLightingInfo)
{
viewRenderOverrideUtilities::printDrawContextLightInfo( drawContext );
}
// Some sample code to debug other MDrawContext information
//
if (fDebugDrawContext)
{
MStatus status;
MMatrix matrix = drawContext.getMatrix(MHWRender::MFrameContext::kWorldMtx, &status);
double dest[4][4];
status = matrix.get(dest);
printf("World matrix is:\n");
printf("\t%f, %f, %f, %f\n", dest[0][0], dest[0][1], dest[0][2], dest[0][3]);
printf("\t%f, %f, %f, %f\n", dest[1][0], dest[1][1], dest[1][2], dest[1][3]);
printf("\t%f, %f, %f, %f\n", dest[2][0], dest[2][1], dest[2][2], dest[2][3]);
printf("\t%f, %f, %f, %f\n", dest[3][0], dest[3][1], dest[3][2], dest[3][3]);
MDoubleArray viewDirection = drawContext.getTuple(MHWRender::MFrameContext::kViewDirection, &status);
printf("Viewdirection is: %f, %f, %f\n", viewDirection[0], viewDirection[1], viewDirection[2]);
MBoundingBox box = drawContext.getSceneBox(&status);
printf("Screen box is:\n");
printf("\twidth=%f, height=%f, depth=%f\n", box.width(), box.height(), box.depth());
float center[4];
box.center().get(center);
printf("\tcenter=(%f, %f, %f, %f)\n", center[0], center[1], center[2], center[3]);
int originX, originY, width, height;
status = drawContext.getViewportDimensions(originX, originY, width, height);
printf("Viewport dimension: center(%d, %d), width=%d, heigh=%d\n", originX, originY, width, height);
}
// Draw some addition things for scene draw
//
M3dView mView;
if (mPanelName.length() &&
(M3dView::getM3dViewFromModelPanel(mPanelName, mView) == MStatus::kSuccess))
{
// Get the current viewport and scale it relative to that
//
int targetW, targetH;
drawContext.getRenderTargetSize( targetW, targetH );
if (fDrawLabel)
{
MString testString("Drawing with override: ");
testString += overridePtr->name();
MPoint pos(0.0,0.0,0.0);
glColor3f( 1.0f, 1.0f, 1.0f );
mView.drawText( testString, pos);
}
// Some user drawing of scene bounding boxes
//
if (fDrawBoundingBoxes)
{
MDagPath cameraPath;
mView.getCamera( cameraPath);
MCustomSceneDraw userDraw;
userDraw.draw( cameraPath, targetW, targetH );
}
}
return MStatus::kSuccess;
}
/* 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;
}
