#include <stdio.h>
#include <maya/MViewport2Renderer.h>
#include <maya/MShaderManager.h>
#include <maya/MFnPlugin.h>
#include <maya/MSelectionList.h>
#include <maya/MFnSet.h>
#include <maya/MPxCommand.h>
#include <maya/MSyntax.h>
#include <maya/MArgDatabase.h>
#include <maya/MArgList.h>
#include <maya/MGlobal.h>
{
public:
MSceneRenderTester(
const MString& name )
, mShaderInstance( NULL )
, mSceneFilterOperation( MHWRender::MSceneRender::kNoSceneFilterOverride )
, mSceneUIDrawables(false)
, mOverrideViewRectangle(false)
, mDebugTrace(false)
{
}
{
if (mSetName.length())
{
if (mFilterSet.length())
{
if (mDebugTrace)
printf(" %s : Enable set filter = %s\n", mName.asChar(), mSetName.asChar() );
return &mFilterSet;
}
return NULL;
}
return NULL;
}
{
float c1[4] = { color1[0], color1[1], color1[2], 1.0f };
float c2[4] = { color2[0], color2[1], color2[2], 1.0f };
mClearOperation.setClearColor( c1 );
mClearOperation.setClearGradient( gradient);
mClearOperation.setClearColor2( c2 );
mClearOperation.setMask( mClearMask );
}
{
if (mDebugTrace)
{
if (mSceneFilterOperation != MHWRender::MSceneRender::kNoSceneFilterOverride &&
{
printf(" %s : Set scene filter = %d\n", mName.asChar(), mSceneFilterOperation);
}
}
return mSceneFilterOperation;
}
{
if (mDebugTrace && mShaderInstance)
printf(" %s : Enable shader override\n", mName.asChar() );
return mShaderInstance;
}
{
if (mDebugTrace)
printf(" %s : preRender callback\n", mName.asChar());
}
{
if (mDebugTrace)
printf(" %s : postRender callback\n", mName.asChar());
}
{
if (mDebugTrace)
printf(" %s : preScene callback\n", mName.asChar());
}
{
if (mDebugTrace)
printf(" %s : postScene callback\n", mName.asChar());
}
{
return mSceneUIDrawables;
}
{
if (mDebugTrace)
printf(" %s : add pre-UI drawables\n", mName.asChar());
}
{
if (mDebugTrace)
printf(" %s : add post-UI drawables\n", mName.asChar());
}
{
if (mOverrideViewRectangle)
{
if (mDebugTrace)
printf("%s : override viewport rectangle\n", mName.asChar());
mViewRectangle[0] = 0.25f;
mViewRectangle[1] = 0.25f;
mViewRectangle[2] = 0.75f;
mViewRectangle[3] = 0.75f;
return &mViewRectangle;
}
return NULL;
}
void setClearMask( unsigned int val )
{
mClearMask = val;
}
void setObjectSetOverride(
const MString & val )
{
mSetName = val;
}
{
mSceneFilterOperation = val;
}
{
mShaderInstance = val;
}
void setSceneUIDrawables(bool val)
{
mSceneUIDrawables = val;
}
void setOverrideViewRectangle(bool val)
{
mOverrideViewRectangle = val;
}
void setDebugTrace( bool val )
{
mDebugTrace = val;
}
protected:
unsigned int mClearMask;
bool mSceneUIDrawables;
bool mOverrideViewRectangle;
bool mDebugTrace;
};
{
public:
MUserRenderOperationTester(
const MString &name)
, mUserUIDrawables(false)
, mUserUILightData(false)
, mOverrideViewRectangle(false)
, mDebugTrace(false)
{
}
{
if (mDebugTrace)
printf("%s : call execute\n", mName.asChar());
}
{
return mUserUIDrawables;
}
{
if (mDebugTrace)
printf("%s : add ui drawables\n", mName.asChar());
}
{
if (mOverrideViewRectangle)
{
if (mDebugTrace)
printf("%s : override viewport rectangle\n", mName.asChar());
mViewRectangle[0] = 0.25f;
mViewRectangle[1] = 0.25f;
mViewRectangle[2] = 0.75f;
mViewRectangle[3] = 0.75f;
return &mViewRectangle;
}
return NULL;
}
{
return mUserUILightData;
}
void setUserUIDrawables(bool val)
{
mUserUIDrawables = val;
}
void setUserUILightData(bool val)
{
mUserUILightData = val;
}
void setOverrideViewRectangle(bool val)
{
mOverrideViewRectangle = val;
}
void setDebugTrace( bool val )
{
mDebugTrace = val;
}
protected:
bool mUserUIDrawables;
bool mUserUILightData;
bool mOverrideViewRectangle;
bool mDebugTrace;
};
{
public:
MHUDRenderTester(
const MString &name)
, mUserUIDrawables(false)
, mOverrideViewRectangle(false)
, mDebugTrace(false)
, mName(name)
{
}
{
return mUserUIDrawables;
}
{
if (mUserUIDrawables)
{
if (mDebugTrace)
printf("%s : add ui drawables\n", mName.asChar());
int x=0, y=0, w=0, h=0;
MString viewportInfoText(
"Viewport information: x= " );
viewportInfoText += x;
viewportInfoText += ", y= ";
viewportInfoText += y;
viewportInfoText += ", w= ";
viewportInfoText += w;
viewportInfoText += ", h= ";
viewportInfoText += h;
}
}
{
if (mOverrideViewRectangle)
{
if (mDebugTrace)
printf("%s : override viewport rectangle\n", mName.asChar());
mViewRectangle[0] = 0.25f;
mViewRectangle[1] = 0.25f;
mViewRectangle[2] = 0.75f;
mViewRectangle[3] = 0.75f;
return &mViewRectangle;
}
return NULL;
}
void setUserUIDrawables(bool val)
{
mUserUIDrawables = val;
}
void setOverrideViewRectangle(bool val)
{
mOverrideViewRectangle = val;
}
void setDebugTrace( bool val )
{
mDebugTrace = val;
}
protected:
bool mUserUIDrawables;
bool mOverrideViewRectangle;
bool mDebugTrace;
};
{
public:
MRenderOverrideTester(
const MString& name )
, mUIName("Render Override Options Renderer")
, mOperation(0)
, mUseSceneShaderInstance(false)
, mSceneShaderInstance(NULL)
, mSceneFilterOperation(
MHWRender::MSceneRender::kNoSceneFilterOverride )
, mSceneClearMask( (unsigned int)
MHWRender::MClearOperation::kClearAll )
, mSceneUIDrawables(false)
, mUserUIDrawables(false)
, mUserUILightData(false)
, mPresentDepth(false)
, mOverrideViewRectangle(false)
, mDebugTrace(false)
{
const MString render1Name(
"Scene Render 1");
const MString presentName(
"Present Target");
const MString userOperationName(
"User Operation 1");
const MString hudOperationName(
"HUD Operation");
mSceneRender1 = new MSceneRenderTester( render1Name );
mUserOperation1 = new MUserRenderOperationTester( userOperationName );
mHUDRender = new MHUDRenderTester( hudOperationName );
}
~MRenderOverrideTester() override
{
if (shaderMgr)
{
if (mSceneShaderInstance)
{
mSceneShaderInstance = NULL;
}
}
delete mSceneRender1; mSceneRender1 = NULL;
delete mUserOperation1; mUserOperation1 = NULL;
delete mHUDRender; mHUDRender = NULL;
delete mPresentTarget; mPresentTarget = NULL;
}
{
}
{
mOperation = 0;
return true;
}
{
switch( mOperation )
{
case 0 : return mSceneRender1;
case 1 : return mUserOperation1;
case 2 : return mHUDRender;
case 3 : return mPresentTarget;
}
return NULL;
}
{
mOperation++;
return mOperation < 4 ? true : false;
}
{
return mUIName;
}
{
if (mDebugTrace)
printf(
"In setup of renderer: %s. Rendering to destination: %s\n", mName.asChar(), destination.
asChar());
if (mSceneRender1)
{
if (shaderMgr && !mSceneShaderInstance)
{
float diffuse[4] = { 1.0f, 0.0, 0.5f, 1.0f };
mSceneShaderInstance->
setParameter(
"diffuseColor", &diffuse[0]);
}
if (mUseSceneShaderInstance && mSceneShaderInstance)
{
mSceneRender1->setShaderOverride(mSceneShaderInstance);
}
else
{
mSceneRender1->setShaderOverride(NULL);
}
mSceneRender1->setClearMask( mSceneClearMask );
mSceneRender1->setRenderFilterOverride( mSceneFilterOperation );
mSceneRender1->setObjectSetOverride( mSceneSetFilterName );
mSceneRender1->setSceneUIDrawables( mSceneUIDrawables );
mSceneRender1->setOverrideViewRectangle( mOverrideViewRectangle );
mSceneRender1->setDebugTrace( mDebugTrace );
}
if (mUserOperation1)
{
mUserOperation1->setUserUIDrawables( mUserUIDrawables );
mUserOperation1->setUserUILightData( mUserUILightData );
mUserOperation1->setOverrideViewRectangle( mOverrideViewRectangle );
mUserOperation1->setDebugTrace( mDebugTrace );
}
if (mHUDRender)
{
mHUDRender->setOverrideViewRectangle( mOverrideViewRectangle );
mHUDRender->setUserUIDrawables( mUserUIDrawables );
mHUDRender->setDebugTrace( mDebugTrace );
}
mPresentTarget->setPresentDepth( mPresentDepth );
}
{
if (mDebugTrace)
printf("In cleanup %s\n", mName.asChar());
}
void setUseSceneShaderInstance(bool val)
{
mUseSceneShaderInstance = val;
}
{
mSceneFilterOperation = val;
}
void setSceneSetFilterName(
const MString &val )
{
mSceneSetFilterName = val;
}
void setSceneUIDrawables( bool val )
{
mSceneUIDrawables = val;
}
void setPresentDepth( bool val )
{
mPresentDepth = val;
}
void setUserUIDrawables(bool val)
{
mUserUIDrawables = val;
}
void setUserUILightData(bool val)
{
mUserUILightData = val;
}
void setOverrideViewRectangle(bool val)
{
mOverrideViewRectangle = val;
}
void setDebugTrace( bool val )
{
mDebugTrace = val;
}
protected:
MSceneRenderTester* mSceneRender1;
MUserRenderOperationTester* mUserOperation1;
MHUDRenderTester* mHUDRender;
int mOperation;
bool mUseSceneShaderInstance;
unsigned int mSceneClearMask;
bool mSceneUIDrawables;
bool mUserUIDrawables;
bool mUserUILightData;
bool mOverrideViewRectangle;
bool mPresentDepth;
bool mDebugTrace;
};
{
public:
viewMRenderOverrideCmd();
~viewMRenderOverrideCmd() override;
static void* creator();
private:
bool mEnableShaderOverride;
int mSceneFilter;
bool mSceneUIDrawables;
bool mUserUIDrawables;
bool mUserUILightData;
bool mPresentDepth;
bool mOverrideViewRectangle;
bool mDebugTrace;
};
viewMRenderOverrideCmd::viewMRenderOverrideCmd()
: mEnableShaderOverride(false)
, mSceneFilter(0)
, mSceneUIDrawables(false)
, mUserUIDrawables(false)
, mUserUILightData(false)
, mPresentDepth(false)
, mOverrideViewRectangle(false)
, mDebugTrace(false)
{
}
viewMRenderOverrideCmd::~viewMRenderOverrideCmd()
{
}
void* viewMRenderOverrideCmd::creator()
{
return (void *) (new viewMRenderOverrideCmd);
}
const char *shaderOverrideShortName = "-so";
const char *shaderOverrideLongName = "-shaderOverride";
const char *objectSetFilterShortName = "-os";
const char *objectSetFilterLongName = "-objectSet";
const char *scenefilterShortName = "-sf";
const char *scenefilterLongName = "-sceneFilter";
const char *sceneUIDrawablesShortName = "-su";
const char *sceneUIDrawablesLongName = "-sceneUIDrawables";
const char *userUIDrawablesShortName = "-uu";
const char *userUIDrawablesLongName = "-userUIDrawables";
const char *userUILightDataShortName = "-ul";
const char *userUILightDataLongName = "-userUILightData";
const char *viewportRectangleShortName = "-vr";
const char *viewportRectangleLongName = "-viewportRectangle";
const char *presentDepthShortName = "-pd";
const char *presentDepthLongName = "-presentDepth";
const char *debugTraceShortName = "-db";
const char *debugTraceLongName = "-debug";
MSyntax viewMRenderOverrideCmd::newSyntax()
{
return syntax;
}
{
mEnableShaderOverride = false;
mObjectSetFilterName.clear();
mSceneFilter = 0;
mUserUIDrawables = false;
mUserUILightData = false;
mOverrideViewRectangle = false;
mPresentDepth = false;
for (
unsigned int i = 0; i < args.
length(); i++ )
{
if (!status)
continue;
if ( arg ==
MString(shaderOverrideShortName) || arg ==
MString(shaderOverrideLongName) )
{
arg += ": must specify a value for ";
arg += shaderOverrideLongName;
displayError(arg);
return MS::kFailure;
}
i++;
args.
get(i, mEnableShaderOverride);
}
if ( arg ==
MString(objectSetFilterShortName) || arg ==
MString(objectSetFilterLongName) )
{
arg += ": must specify a value for ";
arg += objectSetFilterLongName;
displayError(arg);
return MS::kFailure;
}
i++;
args.
get(i, mObjectSetFilterName);
}
if ( arg ==
MString(scenefilterShortName) || arg ==
MString(scenefilterLongName) )
{
arg += ": must specify a value for ";
arg += scenefilterLongName;
displayError(arg);
return MS::kFailure;
}
i++;
args.
get(i, mSceneFilter);
}
if ( arg ==
MString(sceneUIDrawablesShortName ) || arg ==
MString(sceneUIDrawablesLongName) )
{
arg += ": must specify a value for ";
arg += sceneUIDrawablesLongName;
displayError(arg);
return MS::kFailure;
}
i++;
args.
get(i, mSceneUIDrawables);
}
if ( arg ==
MString(userUIDrawablesShortName) || arg ==
MString(userUIDrawablesLongName) )
{
arg += ": must specify a value for ";
arg += userUIDrawablesLongName;
displayError(arg);
return MS::kFailure;
}
i++;
args.
get(i, mUserUIDrawables);
}
if ( arg ==
MString(userUILightDataShortName) || arg ==
MString(userUILightDataLongName) )
{
arg += ": must specify a value for ";
arg += userUILightDataLongName;
displayError(arg);
return MS::kFailure;
}
i++;
args.
get(i, mUserUILightData);
}
if ( arg ==
MString(viewportRectangleShortName) || arg ==
MString(viewportRectangleLongName) )
{
arg += ": must specify a value for ";
arg += viewportRectangleLongName;
displayError(arg);
return MS::kFailure;
}
i++;
args.
get(i, mOverrideViewRectangle);
}
if ( arg ==
MString(presentDepthShortName) || arg ==
MString(presentDepthLongName) )
{
arg += ": must specify a value for ";
arg += presentDepthLongName;
displayError(arg);
return MS::kFailure;
}
i++;
args.
get(i, mPresentDepth);
}
if ( arg ==
MString(debugTraceShortName) || arg ==
MString(debugTraceLongName) )
{
arg += ": must specify a value for ";
arg += debugTraceLongName;
displayError(arg);
return MS::kFailure;
}
i++;
args.
get(i, mDebugTrace);
}
}
return MS::kSuccess;
}
{
MRenderOverrideTester *renderOverride = NULL;
if (renderer)
{
renderOverride = (MRenderOverrideTester *) renderer->
findRenderOverride(
"viewMRenderOverride" );
}
if (!renderOverride)
{
return status;
}
renderOverride->setUseSceneShaderInstance( mEnableShaderOverride );
renderOverride->setSceneSetFilterName( mObjectSetFilterName );
renderOverride->setSceneUIDrawables( mSceneUIDrawables );
MHWRender::MSceneRender::kNoSceneFilterOverride,
MHWRender::MSceneRender::kRenderUIItems
};
if (mSceneFilter >=0 && mSceneFilter < 7)
{
renderOverride->setSceneFilterOperation( filters[mSceneFilter] );
}
renderOverride->setUserUIDrawables( mUserUIDrawables );
renderOverride->setUserUILightData( mUserUILightData );
renderOverride->setPresentDepth( mPresentDepth );
renderOverride->setOverrideViewRectangle( mOverrideViewRectangle );
renderOverride->setDebugTrace( mDebugTrace );
return status;
}
{
if (renderer)
{
status = renderer->
registerOverride(
new MRenderOverrideTester(
"viewMRenderOverride" ));
}
{
status = plugin.registerCommand("viewMRenderOverride",
viewMRenderOverrideCmd::creator,
viewMRenderOverrideCmd::newSyntax);
}
return status;
}
{
if (renderer)
{
}
status = plugin.deregisterCommand( "viewMRenderOverride" );
return status;
}