void
UsdMayaGLBatchRenderer::Draw(
const MHWRender::MDrawContext& context,
const MUserData *userData)
{
// VP 2.0 Implementation
//
MHWRender::MRenderer* theRenderer = MHWRender::MRenderer::theRenderer();
if( !theRenderer || !theRenderer->drawAPIIsOpenGL() )
return;
const _BatchDrawUserData* batchData = static_cast<const _BatchDrawUserData*>(userData);
if( !batchData )
return;
MStatus status;
MMatrix projectionMat = context.getMatrix(MHWRender::MDrawContext::kProjectionMtx, &status);
if( batchData->_bounds )
{
MMatrix worldViewMat = context.getMatrix(MHWRender::MDrawContext::kWorldViewMtx, &status);
px_vp20Utils::RenderBoundingBox(*(batchData->_bounds),
*(batchData->_wireframeColor),
worldViewMat,
projectionMat);
}
if( batchData->_drawShape && !_renderQueue.empty() )
{
MMatrix viewMat = context.getMatrix(MHWRender::MDrawContext::kViewMtx, &status);
// Extract camera settings from maya view
int viewX, viewY, viewWidth, viewHeight;
context.getViewportDimensions(viewX, viewY, viewWidth, viewHeight);
GfVec4d viewport(viewX, viewY, viewWidth, viewHeight);
// Only the first call to this will do anything... After that the batch
// queue is cleared.
//
_RenderBatches( &context, viewMat, projectionMat, viewport );
}
}
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;
}
void UsdMayaGLHdRenderer::RenderVp2(
const RequestDataArray &requests,
const MHWRender::MDrawContext& context,
UsdImagingGLRenderParams params) const
{
using namespace MHWRender;
MStatus status;
MHWRender::MRenderer* theRenderer = MHWRender::MRenderer::theRenderer();
if (!theRenderer) return;
MHWRender::MStateManager* stateMgr = context.getStateManager();
if (!stateMgr) return;
const int displayStyle = context.getDisplayStyle();
if (displayStyle == 0) return;
if (displayStyle & MDrawContext::kXray) {
// Viewport 2.0 will call draw() twice when drawing transparent objects
// (X-Ray mode). We skip the first draw() call.
const MRasterizerState* rasterState = stateMgr->getRasterizerState();
if (rasterState && rasterState->desc().cullMode == MRasterizerState::kCullFront) {
return;
}
}
if (!theRenderer->drawAPIIsOpenGL()) return;
glPushAttrib(GL_CURRENT_BIT | GL_LIGHTING_BIT);
const MMatrix worldView =
context.getMatrix(MHWRender::MDrawContext::kWorldViewMtx, &status);
GfMatrix4d modelViewMatrix(worldView.matrix);
const MMatrix projection =
context.getMatrix(MHWRender::MDrawContext::kProjectionMtx, &status);
GfMatrix4d projectionMatrix(projection.matrix);
// get root matrix
MMatrix root = context.getMatrix(MHWRender::MDrawContext::kWorldMtx, &status);
GfMatrix4d rootMatrix(root.matrix);
// Extract camera settings from maya view
int viewX, viewY, viewWidth, viewHeight;
context.getViewportDimensions(viewX, viewY, viewWidth, viewHeight);
GfVec4d viewport(viewX, viewY, viewWidth, viewHeight);
M3dView::DisplayStyle viewDisplayStyle = displayStyle & MDrawContext::kWireFrame ?
M3dView::kWireFrame : M3dView::kGouraudShaded;
if(viewDisplayStyle == M3dView::kGouraudShaded)
{
px_vp20Utils::setupLightingGL(context);
glEnable(GL_LIGHTING);
}
_renderer->SetCameraState(modelViewMatrix, projectionMatrix, viewport);
_renderer->SetLightingStateFromOpenGL();
TF_FOR_ALL(it, requests) {
RequestData request = *it;
if(viewDisplayStyle == M3dView::kWireFrame && request.drawRequest.displayStyle() == M3dView::kGouraudShaded) {
request.drawRequest.setDisplayStyle(viewDisplayStyle);
}
switch(request.drawRequest.token()) {
case UsdMayaGLHdRenderer::DRAW_WIREFRAME:
case UsdMayaGLHdRenderer::DRAW_POINTS: {
params.drawMode = request.drawRequest.token() ==
UsdMayaGLHdRenderer::DRAW_WIREFRAME ?
UsdImagingGLDrawMode::DRAW_WIREFRAME :
UsdImagingGLDrawMode::DRAW_POINTS;
params.enableLighting = false;
params.cullStyle = UsdImagingGLCullStyle::CULL_STYLE_NOTHING;
params.overrideColor = request.fWireframeColor;
// Get and render usdPrim
_renderer->Render(_renderedPrim, params);
break;
}
case UsdMayaGLHdRenderer::DRAW_SHADED_FLAT:
case UsdMayaGLHdRenderer::DRAW_SHADED_SMOOTH: {
params.drawMode = ((request.drawRequest.token() ==
UsdMayaGLHdRenderer::DRAW_SHADED_FLAT) ?
UsdImagingGLDrawMode::DRAW_GEOM_FLAT :
UsdImagingGLDrawMode::DRAW_GEOM_SMOOTH);
params.enableLighting = true;
params.cullStyle =
UsdImagingGLCullStyle::CULL_STYLE_BACK_UNLESS_DOUBLE_SIDED;
_renderer->Render(_renderedPrim, params);
break;
}
case UsdMayaGLHdRenderer::DRAW_BOUNDING_BOX: {
px_vp20Utils::RenderBoundingBox(request.bounds,
request.fWireframeColor,
worldView,
projection);
break;
}
}
}
