customTextureShader/customTextureShaderOverride.cpp

//-
// Copyright 2012 Autodesk, Inc.  All rights reserved.
//
// Use of this software is subject to the terms of the Autodesk license agreement
// provided at the time of installation or download, or which otherwise
// accompanies this software in either electronic or hard copy form.
//+

#include "customTextureShaderOverride.h"
#include "customTextureShader.h"

#include <maya/MString.h>
#include <maya/MDrawContext.h>

customTextureShaderOverride::customTextureShaderOverride(const MObject& obj)
: MHWRender::MPxShaderOverride(obj)
{
    m_beautyShaderInstance = NULL;
    m_shaderBound = false;
    m_inBeautyPass = false;

    // init custom texture data:
    m_customTextureData = NULL;

    MHWRender::MRenderer* renderer = MHWRender::MRenderer::theRenderer();
    if (!renderer)
        return;

    const MHWRender::MShaderManager* shaderMgr = renderer->getShaderManager();
    if (!shaderMgr)
        return;

    // tell Maya to get our shader
    MString shaderLocation(
        MString(getenv("MAYA_LOCATION")) +
        MString("/devkit/plug-ins/customTextureShader/CustomTextureBlock10.fx"));
    m_beautyShaderInstance = shaderMgr->getEffectsFileShader(shaderLocation, "Main");
}

MHWRender::MPxShaderOverride* customTextureShaderOverride::Creator(const MObject& obj)
{
    return new customTextureShaderOverride(obj);
}

customTextureShaderOverride::~customTextureShaderOverride()
{
    if (m_beautyShaderInstance)
    {
        MHWRender::MRenderer* renderer = MHWRender::MRenderer::theRenderer();
        if (renderer)
        {
            const MHWRender::MShaderManager* shaderMgr = renderer->getShaderManager();
            if (shaderMgr)
            {
                shaderMgr->releaseShader(m_beautyShaderInstance);
                m_beautyShaderInstance = NULL;
            }
        }
    }

    // clean custom texture data:
    delete m_customTextureData;
    m_customTextureData = NULL;
}

MString customTextureShaderOverride::initialize(const MInitContext& initContext, MInitFeedback& initFeedback)
{
    // Set the geometry requirements for drawing.
    MString empty;

    MHWRender::MVertexBufferDescriptor positionDesc(
        empty,
        MHWRender::MGeometry::kPosition,
        MHWRender::MGeometry::kFloat,
        3);

    MHWRender::MVertexBufferDescriptor uvDesc(
        empty,
        MHWRender::MGeometry::kTexture,
        MHWRender::MGeometry::kFloat,
        2);

    addGeometryRequirement(positionDesc);
    addGeometryRequirement(uvDesc);

    if (m_beautyShaderInstance)
    {
        addShaderSignature(*m_beautyShaderInstance);
    }

    return MString("customTextureShaderOverride");
}

MHWRender::MShaderInstance* customTextureShaderOverride::shaderInstance() const
{
    if (m_inBeautyPass)
    {
        return m_beautyShaderInstance;
    }

    return NULL;
}

void customTextureShaderOverride::updateDG(MObject object)
{
}

void customTextureShaderOverride::updateDevice()
{
    // Set parameters:
    updateShaderInstance();

    // build that custom data texture here and bind to shader:
    buildAndUpdateCustomDataTextureViaMaya();
}

void customTextureShaderOverride::endUpdate()
{
}

bool customTextureShaderOverride::handlesDraw(MHWRender::MDrawContext& context)
{
    const MHWRender::MPassContext& passCtx = context.getPassContext();
    const MStringArray& passSem = passCtx.passSemantics();

    m_inBeautyPass = false;

    // For color passes, only handle if there isn't already
    // a global override. This is the same as the default
    // logic for this method in MPxShaderOverride
    bool handlePass = false;
    for (unsigned int i=0; i<passSem.length(); i++)
    {
        if (passSem[i] == MHWRender::MPassContext::kColorPassSemantic)
        {
            bool hasOverrideShader = passCtx.hasShaderOverride();
            if (!hasOverrideShader)
                handlePass = true;

            m_inBeautyPass = true;
        }

        // If these semantics are specified then they override
        // the color pass semantic handling.
        else if (passSem[i] == MHWRender::MPassContext::kDepthPassSemantic ||
                 passSem[i] == MHWRender::MPassContext::kNormalDepthPassSemantic)
        {
            handlePass = false;
        }
    }
    return handlePass;
}

void customTextureShaderOverride::activateKey(MHWRender::MDrawContext& context, const MString& /*key*/)
{
    if (m_inBeautyPass && m_beautyShaderInstance)
    {
        m_beautyShaderInstance->bind(context);  // make sure our shader is the active shader
        m_shaderBound = true;
    }
}

bool customTextureShaderOverride::draw(MHWRender::MDrawContext& context, const MHWRender::MRenderItemList& renderItemList) const
{
    if (!m_shaderBound)
        return false;

    // Draw for color pass
    if (m_inBeautyPass && m_beautyShaderInstance)
    {
        unsigned int passCount = m_beautyShaderInstance->getPassCount(context);
        if (passCount)
        {
            for (unsigned int i=0; i<passCount; i++)
            {
                m_beautyShaderInstance->activatePass(context, i);
                MHWRender::MPxShaderOverride::drawGeometry(context);
            }
        }

        return true;
    }

    return false;
}

void customTextureShaderOverride::terminateKey(MHWRender::MDrawContext& context, const MString& /*key*/)
{
    if (m_shaderBound)
    {
        if (m_inBeautyPass && m_beautyShaderInstance)
        {
            m_beautyShaderInstance->unbind(context);
        }
    }

    m_shaderBound = false;
}

MHWRender::DrawAPI customTextureShaderOverride::supportedDrawAPIs() const
{
    // this example supports DX only
    return MHWRender::kDirectX11;
}

bool customTextureShaderOverride::isTransparent()
{
    return false;
}

bool customTextureShaderOverride::overridesDrawState()
{
    return false;
}

void customTextureShaderOverride::updateShaderInstance()
{
    MHWRender::MRenderer *renderer = MHWRender::MRenderer::theRenderer();
    if (!renderer)
        return;

    // this could be optimized by checking if parameters actually changed
    // see hwPhongShader for a more complete example in this regards
    if (m_beautyShaderInstance)
    {
        m_beautyShaderInstance->setParameter("colVal", 1.0f);
    }
}

void customTextureShaderOverride::buildAndUpdateCustomDataTextureViaMaya()
{
    MHWRender::MRenderer *renderer = MHWRender::MRenderer::theRenderer();
    if (!renderer)
        return;

    MHWRender::MTextureManager* mt = renderer->getTextureManager();

    generateCustomTexture();

    MString newTextureName = MString("MyCustomTexture");
    MHWRender::MTexture* myTex = mt->acquireTexture(newTextureName, m_desc, m_customTextureData, false);

    if (myTex && m_beautyShaderInstance)
    {
        MHWRender::MTextureAssignment texResource;
        texResource.texture = myTex;
        m_beautyShaderInstance->setParameter("MyTexture", texResource);
    }
}

void customTextureShaderOverride::generateCustomTexture()
{
    int textureSize = 256;
    int numSlice = 1; // Number of array slices. e.g. 6 would be required for a cube-map

    // First time, we create a contiguous block of data for the texture.
    if (!m_customTextureData)
    {
        m_customTextureData = new unsigned char[4*textureSize*textureSize*numSlice];

        // init values
        // do whatever you would do with your custom texture data. E.g. generate procedural texture.
        float intensity = 1.0f;
        int index = 0;
        for (int face=0 ; face<numSlice ; face++)
        {
            for (int j=0 ; j<textureSize ; j++)
            {
                for (int i=0 ; i<textureSize ; i++)
                {
                    m_customTextureData[index++] = (unsigned char)(255*intensity);
                    m_customTextureData[index++] = (unsigned char)(255*intensity);
                    m_customTextureData[index++] = (unsigned char)(255*intensity);
                    m_customTextureData[index++] = 255;
                }
            }
        }

        // we still have to setup a texture description for Maya, even when using custom data:
        m_desc.setToDefault2DTexture();
        m_desc.fWidth = textureSize;
        m_desc.fHeight = textureSize;
        m_desc.fDepth = 1;
        m_desc.fBytesPerRow = 4*textureSize;
        m_desc.fBytesPerSlice = 4*textureSize*textureSize;
        m_desc.fMipmaps = 1;
        m_desc.fArraySlices = numSlice;
        m_desc.fFormat = MHWRender::kR8G8B8A8_UNORM;
        m_desc.fTextureType = MHWRender::kImage2D;
    }
}