#include <maya/M3dView.h>
#include "viewImageBlitOverride.h"
#include <maya/MDrawContext.h>
#include <maya/MFrameContext.h>
#include <maya/MImage.h>
#include <maya/MStateManager.h>
#include <maya/MGlobal.h>
#include <stdlib.h>
namespace viewImageBlitOverride
{
RenderOverride* RenderOverride::sViewImageBlitOverrideInstance = NULL;
RenderOverride::RenderOverride(
const MString & name )
: MRenderOverride( name )
, mUIName("Sample Image Blit Override")
, mCurrentOperation(-1)
, mLoadImagesFromDisk(false)
{
mOperations[0] = mOperations[1] = mOperations[2] = mOperations[3] = NULL;
mOperationNames[0] = "viewImageBlitOverride_SceneBlit";
mOperationNames[1] = "viewImageBlitOverride_UIDraw";
mOperationNames[2] = "viewImageBlitOverride_Present";
mColorTexture.texture = NULL;
mColorTextureDesc.setToDefault2DTexture();
mDepthTexture.texture = NULL;
mDepthTextureDesc.setToDefault2DTexture();
}
RenderOverride::~RenderOverride()
{
if (textureManager)
{
if (mColorTexture.texture)
if (mDepthTexture.texture)
}
for (unsigned int i=0; i<4; i++)
{
if (mOperations[i])
{
delete mOperations[i];
mOperations[i] = NULL;
}
}
}
{
}
bool RenderOverride::startOperationIterator()
{
mCurrentOperation = 0;
return true;
}
{
if (mCurrentOperation >= 0 && mCurrentOperation < 4)
{
if (mOperations[mCurrentOperation])
{
return mOperations[mCurrentOperation];
}
}
return NULL;
}
bool RenderOverride::nextRenderOperation()
{
mCurrentOperation++;
if (mCurrentOperation < 4)
{
return true;
}
return false;
}
{
if (!theRenderer || !textureManager)
return false;
unsigned int targetWidth = 0;
unsigned int targetHeight = 0;
bool acquireNewTexture = false;
int val = 0;
bool forceReload = false;
{
bool loadFromDisk = (val > 0);
if (loadFromDisk != mLoadImagesFromDisk)
{
mLoadImagesFromDisk = loadFromDisk;
forceReload = true;
}
}
MString imageLocation(
MString(getenv(
"MAYA_LOCATION")) +
MString(
"\\devkit\\plug-ins\\viewImageBlitOverride\\"));
MString colorImageFileName( imageLocation +
MString(
"renderedImage.iff") );
MString depthImageFileName( colorImageFileName );
if (forceReload ||
!mColorTexture.texture ||
!mDepthTexture.texture ||
(!mLoadImagesFromDisk &&
(mColorTextureDesc.fWidth != targetWidth ||
mColorTextureDesc.fHeight != targetHeight)))
{
if (mColorTexture.texture)
{
mColorTexture.texture = NULL;
}
if (mDepthTexture.texture)
{
mDepthTexture.texture = NULL;
}
acquireNewTexture = true;
forceReload = false;
}
if (!mColorTexture.texture)
{
unsigned char *textureData = NULL;
if (mLoadImagesFromDisk)
{
image.
getSize( targetWidth, targetHeight );
}
else
{
textureData = new unsigned char[4*targetWidth*targetHeight];
if (textureData)
{
for (unsigned int y = 0; y < targetHeight; y++)
{
unsigned char* pPixel = textureData + (y * targetWidth * 4);
for (unsigned int x = 0; x < targetWidth; x++)
{
bool checker = (((x >> 5) & 1) ^ ((y >> 5) & 1)) != 0;
*pPixel++ = checker ? 255 : 0;
*pPixel++ = 0;
*pPixel++ = 0;
*pPixel++ = 255;
}
}
}
}
mColorTextureDesc.fWidth = targetWidth;
mColorTextureDesc.fHeight = targetHeight;
mColorTextureDesc.fDepth = 1;
mColorTextureDesc.fBytesPerRow = 4*targetWidth;
mColorTextureDesc.fBytesPerSlice = mColorTextureDesc.fBytesPerRow*targetHeight;
mColorTexture.texture = textureManager->
acquireTexture(
"", mColorTextureDesc, textureData );
if (mColorTexture.texture)
if (!mLoadImagesFromDisk)
{
delete [] textureData;
}
}
else
{
bool updateOnEveryRefresh = false;
bool generateMipMaps = false;
if (updateOnEveryRefresh)
{
bool updateWithRawData = false;
if (updateWithRawData)
{
mColorTexture.texture->textureDescription( mColorTextureDesc );
int rowPitch = 0;
int slicePitch = 0;
unsigned char* textureData = (unsigned char *)mColorTexture.texture->rawData(rowPitch, slicePitch);
unsigned char* val = NULL;
if (textureData && rowPitch > 0 && slicePitch > 0)
{
for (unsigned int i=0; i<mColorTextureDesc.fHeight; i++)
{
val = textureData + (i*rowPitch);
for (unsigned int j=0; j<mColorTextureDesc.fWidth*4; j++)
{
*val = 255 - *val;
val++;
}
}
mColorTexture.texture->update(textureData, generateMipMaps, rowPitch);
}
delete [] textureData;
}
else
{
unsigned char* textureData = NULL;
bool updateWithMImage = true;
unsigned int tile = 5;
if (updateWithMImage)
{
}
else
{
textureData = new unsigned char[4*targetWidth*targetHeight];
}
if (textureData)
{
static unsigned int counter = 0;
for (unsigned int y = 0; y < targetHeight; y++)
{
unsigned char* pPixel = textureData + (y * targetWidth * 4);
for (unsigned int x = 0; x < targetWidth; x++)
{
bool checker = (((x >> tile) & 1) ^ ((y >> tile) & 1)) != 0;
*pPixel++ = (counter == 0 && checker) ? 255 : 0;
*pPixel++ = (counter == 1 && checker) ? 255 : 0;
*pPixel++ = (counter == 2 && checker) ? 255 : 0;
*pPixel++ = 255;
}
}
counter = (counter + 1) % 3;
}
if (!updateWithMImage)
{
mColorTexture.texture->update( textureData, generateMipMaps );
delete [] textureData;
}
else
{
mColorTexture.texture->update( image, generateMipMaps );
}
}
}
}
if (!mDepthTexture.texture)
{
mDepthTextureDesc.fWidth = targetWidth;
mDepthTextureDesc.fHeight = targetHeight;
mDepthTextureDesc.fDepth = 1;
mDepthTextureDesc.fBytesPerRow = targetWidth;
mDepthTextureDesc.fBytesPerSlice = mDepthTextureDesc.fBytesPerRow*targetHeight;
if (mLoadImagesFromDisk)
{
image, false, &normalizationDesc );
}
else
{
float *textureData = new float[targetWidth*targetHeight];
if (textureData)
{
bool createDepthWithMImage = false;
bool useCameraDistanceValues = false;
float depthValue = useCameraDistanceValues ? -1.0f / 100.0f : 1.0f;
float depthValue2 = useCameraDistanceValues ? -1.0f / 500.0f : 0.98f;
for (unsigned int y = 0; y < targetHeight; y++)
{
float* pPixel = textureData + (y * targetWidth);
for (unsigned int x = 0; x < targetWidth; x++)
{
bool checker = (((x >> 5) & 1) ^ ((y >> 5) & 1)) != 0;
*pPixel++ = checker ? depthValue : depthValue2;
}
}
if (createDepthWithMImage)
{
image.
setDepthMap( textureData, targetWidth, targetHeight );
image, false, useCameraDistanceValues ? &normalizationDesc : NULL );
}
else
{
textureData, targetWidth, targetHeight, false,
useCameraDistanceValues ? &normalizationDesc : NULL );
}
delete [] textureData;
}
}
if (mDepthTexture.texture)
}
if (acquireNewTexture)
{
SceneBlit* blit = (SceneBlit *)mOperations[0];
blit->setColorTexture( mColorTexture );
blit->setDepthTexture( mDepthTexture );
}
return (mDepthTexture.texture && mColorTexture.texture);
}
{
if (!theRenderer)
if (!textureManager)
if (!mOperations[0])
{
}
if (!mOperations[0] ||
!mOperations[1] ||
!mOperations[2] ||
!mOperations[3])
{
}
if (!updateTextures(theRenderer, textureManager))
{
{
}
}
}
{
mCurrentOperation = -1;
}
SceneBlit::SceneBlit(
const MString &name)
: MQuadRender( name )
, mShaderInstance(NULL)
, mColorTextureChanged(false)
, mDepthTextureChanged(false)
, mDepthStencilState(NULL)
{
mColorTexture.texture = NULL;
mDepthTexture.texture = NULL;
}
SceneBlit::~SceneBlit()
{
if (!renderer)
return;
if (mShaderInstance)
{
if (shaderMgr)
{
}
mShaderInstance = NULL;
}
if (mDepthStencilState)
{
mDepthStencilState = NULL;
}
}
{
if (!mShaderInstance)
{
if (shaderMgr)
{
bool showDepthAsColor = false;
mShaderInstance = shaderMgr->
getEffectsFileShader(
"mayaBlitColorDepth", showDepthAsColor ?
"DepthToColor" :
"" );
}
}
if (mShaderInstance)
{
if (mColorTextureChanged)
{
status = mShaderInstance->setParameter("gColorTex", mColorTexture);
mColorTextureChanged = false;
}
{
status = mShaderInstance->setParameter("gDepthTex", mDepthTexture);
mDepthTextureChanged = false;
}
}
{
return NULL;
}
return mShaderInstance;
}
{
return mClearOperation;
}
{
if (!mDepthStencilState)
{
}
return mDepthStencilState;
}
UIDraw::UIDraw(
const MString& name)
{
}
UIDraw::~UIDraw()
{
}
UIDraw::renderFilterOverride()
{
return MHWRender::MSceneRender::kRenderNonShadedItems;
}
MUint64
UIDraw::getObjectTypeExclusions()
{
}
UIDraw::clearOperation()
{
return mClearOperation;
}
}