hwPhongShader/hwPhongShader.cpp

hwPhongShader/hwPhongShader.cpp
//-
// ==========================================================================
// Copyright 2010 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.
// ==========================================================================
//+
//
// NOTE: PLEASE READ THE README.TXT FILE FOR INSTRUCTIONS ON
// COMPILING AND USAGE REQUIREMENTS.
//
// DESCRIPTION:
// This is an example of a using a cube-environment map
// to perforce per pixel Phong shading.
//
// The light direction is currently fixed at the eye
// position. This could be changed to track an actual
// light but has not been coded for this example.
//
// If multiple lights are to be supported, than the environment
// map would need to be looked up for each light either
// using multitexturing or multipass.
//
#ifdef WIN32
#pragma warning( disable : 4786 ) // Disable STL warnings.
#endif
#include <maya/MIOStream.h>
#include <math.h>
#include <cstdlib>
#include <maya/MGlobal.h>
#include <maya/MString.h>
#include <maya/MPlug.h>
#include <maya/MDataBlock.h>
#include <maya/MDataHandle.h>
#include <maya/MFnNumericAttribute.h>
#include <maya/MFloatVector.h>
#include <maya/MFnPlugin.h>
#include <maya/MSceneMessage.h>
#include <maya/MUserData.h>
#include <maya/MHWShaderSwatchGenerator.h>
#include <maya/MHardwareRenderer.h>
#include <maya/MGeometryData.h>
#include <maya/MImage.h>
#include <maya/MMatrix.h>
// Viewport 2.0 includes
#include <maya/MDrawRegistry.h>
#include <maya/MPxShaderOverride.h>
#include <maya/MDrawContext.h>
#include <maya/MStateManager.h>
#include <maya/MViewport2Renderer.h>
#include <maya/MTextureManager.h>
#include <maya/MShaderManager.h>
#include <maya/MGLdefinitions.h>
#include <maya/MGLFunctionTable.h>
#if defined(OSMac_MachO_)
#include <OpenGL/gl.h>
#include <OpenGL/glu.h>
#else
#include <GL/gl.h>
#include <GL/glu.h>
#endif
#undef ENABLE_TRACE_API_CALLS
#ifdef ENABLE_TRACE_API_CALLS
#define TRACE_API_CALLS(x) cerr << "hwPhongShader: "<<(x)<<"\n"
#else
#define TRACE_API_CALLS(x)
#endif
#ifndef GL_EXT_texture_cube_map
# define GL_NORMAL_MAP_EXT 0x8511
# define GL_REFLECTION_MAP_EXT 0x8512
# define GL_TEXTURE_CUBE_MAP_EXT 0x8513
# define GL_TEXTURE_BINDING_CUBE_MAP_EXT 0x8514
# define GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT 0x8515
# define GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT 0x8516
# define GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT 0x8517
# define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT 0x8518
# define GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT 0x8519
# define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT 0x851A
# define GL_PROXY_TEXTURE_CUBE_MAP_EXT 0x851B
# define GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT 0x851C
#endif
#include "hwPhongShader.h"
#include "hwPhongShaderBehavior.h"
MTypeId hwPhongShader::id( 0x00105449 );
MObject hwPhongShader::aColor;
MObject hwPhongShader::aTransparency;
MObject hwPhongShader::aDiffuseColor;
MObject hwPhongShader::aSpecularColor;
MObject hwPhongShader::aShininess;
MObject hwPhongShader::aGeometryShape;
void hwPhongShader::postConstructor( )
{
TRACE_API_CALLS("postConstructor");
setMPSafe(false);
}
//
// DESCRIPTION:
void hwPhongShader::printGlError( const char *call )
{
GLenum error;
while( (error = glGetError()) != GL_NO_ERROR ) {
cerr << call << ":" << error << " is " << (const char *)gluErrorString( error ) << "\n";
}
}
MFloatVector hwPhongShader::Phong ( double cos_a )
{
MFloatVector p;
if ( cos_a < 0.0 ) cos_a = 0.0;
p[0] = (float)(mSpecularColor[0]*pow(cos_a,double(mShininess[0])) +
mDiffuseColor[0]*cos_a + mAmbientColor[0]);
p[1] = (float)(mSpecularColor[1]*pow(cos_a,double(mShininess[1])) +
mDiffuseColor[1]*cos_a + mAmbientColor[1]);
p[2] = (float)(mSpecularColor[2]*pow(cos_a,double(mShininess[2])) +
mDiffuseColor[2]*cos_a + mAmbientColor[2]);
if ( p[0] > 1.0f ) p[0] = 1.0f;
if ( p[1] > 1.0f ) p[1] = 1.0f;
if ( p[2] > 1.0f ) p[2] = 1.0f;
return p;
}
#define PHONG_TEXTURE_RES 256
static const GLenum faceTarget[6] =
{
GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT,
GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT,
GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT,
GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT,
GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT,
GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT
};
// Small reusable utility to bind and unbind a cube map texture by id.
class CubeMapTextureDrawUtility
{
public:
static void bind( unsigned int phong_map_id )
{
// Setup up phong texture
{
glPushAttrib ( GL_ENABLE_BIT | GL_LIGHTING_BIT | GL_TEXTURE_BIT | GL_TRANSFORM_BIT );
glDisable ( GL_LIGHTING );
glDisable ( GL_TEXTURE_1D );
glDisable ( GL_TEXTURE_2D );
// Setup cube map generation
glEnable ( GL_TEXTURE_CUBE_MAP_EXT );
glBindTexture ( GL_TEXTURE_CUBE_MAP_EXT, phong_map_id );
glEnable ( GL_TEXTURE_GEN_S );
glEnable ( GL_TEXTURE_GEN_T );
glEnable ( GL_TEXTURE_GEN_R );
glTexGeni ( GL_S, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_EXT );
glTexGeni ( GL_T, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_EXT );
glTexGeni ( GL_R, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_EXT );
glTexParameteri(GL_TEXTURE_CUBE_MAP_EXT, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri(GL_TEXTURE_CUBE_MAP_EXT, GL_TEXTURE_WRAP_T, GL_CLAMP);
glTexParameteri(GL_TEXTURE_CUBE_MAP_EXT, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP_EXT, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexEnvi ( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
// Setup texture matrix
glMatrixMode ( GL_TEXTURE );
glPushMatrix ();
glLoadIdentity ();
glMatrixMode ( GL_MODELVIEW );
}
}
static void unbind()
{
// Restore texture matrix
glMatrixMode ( GL_TEXTURE );
glPopMatrix ();
glMatrixMode ( GL_MODELVIEW );
// Disable cube map texture (bind 0)
glBindTexture( GL_TEXTURE_CUBE_MAP_EXT, 0 );
glDisable ( GL_TEXTURE_CUBE_MAP_EXT );
glPopAttrib();
}
};
static void cubeToDir ( int face, double s, double t,
double &x, double &y, double &z )
//
// Description:
// Map uv to cube direction
{
switch ( face )
{
case 0:
x = 1;
y = -t;
z = -s;
break;
case 1:
x = -1;
y = -t;
z = s;
break;
case 2:
x = s;
y = 1;
z = t;
break;
case 3:
x = s;
y = -1;
z = -t;
break;
case 4:
x = s;
y = -t;
z = 1;
break;
case 5:
x = -s;
y = -t;
z = -1;
break;
}
double invLen = 1.0 / sqrt ( x*x + y*y + z*z );
x *= invLen;
y *= invLen;
z *= invLen;
}
void hwPhongShader::init_Phong_texture ( void )
//
// Description:
// Set up a cube map for Phong lookup
//
{
// There is nothing dirty, so don't rebuild the texture.
if ( !mAttributesChanged && (phong_map_id != 0))
{
return;
}
GLubyte * texture_data;
// Always release the old texture id before getting a
// new one.
if (phong_map_id != 0)
glDeleteTextures( 1, &phong_map_id );
glGenTextures ( 1, &phong_map_id );
glEnable ( GL_TEXTURE_CUBE_MAP_EXT );
glPixelStorei ( GL_UNPACK_ALIGNMENT, 1 );
glPixelStorei ( GL_UNPACK_ROW_LENGTH, 0 );
glBindTexture ( GL_TEXTURE_CUBE_MAP_EXT, phong_map_id );
texture_data = new GLubyte[3*PHONG_TEXTURE_RES*PHONG_TEXTURE_RES];
for ( int face=0 ; face<6 ; face++ )
{
int index = 0;
for ( int j=0 ; j<PHONG_TEXTURE_RES ; j++ )
{
double t = 2*double(j)/(PHONG_TEXTURE_RES - 1) - 1; // -1 to 1
for ( int i=0 ; i<PHONG_TEXTURE_RES ; i++ )
{
double s = 2*double(i)/(PHONG_TEXTURE_RES - 1) - 1; // -1 to 1
double x = 0.0, y = 0.0, z = 0.0;
cubeToDir ( face, s, t, x, y, z );
MFloatVector intensity = Phong ( z );
texture_data[index++] = (GLubyte)(255*intensity[0]);
texture_data[index++] = (GLubyte)(255*intensity[1]);
texture_data[index++] = (GLubyte)(255*intensity[2]);
}
}
glTexImage2D ( faceTarget[face], 0, GL_RGB, PHONG_TEXTURE_RES, PHONG_TEXTURE_RES,
0, GL_RGB, GL_UNSIGNED_BYTE, texture_data );
}
glDisable ( GL_TEXTURE_CUBE_MAP_EXT );
delete [] texture_data;
// Make sure to mark attributes "clean".
mAttributesChanged = false;
}
hwPhongShader::hwPhongShader()
{
TRACE_API_CALLS("hwPhongShader");
attachSceneCallbacks();
mAmbientColor[0] = mAmbientColor[1] = mAmbientColor[2] = 0.1f;
mDiffuseColor[0] = mDiffuseColor[1] = mDiffuseColor[2] = 0.5f;
mSpecularColor[0] = mSpecularColor[1] = mSpecularColor[2] = 0.5f;
mShininess[0] = mShininess[1] = mShininess[2] = 100.0f;
mAttributesChanged = false;
markAttributesChangedVP2();
phong_map_id = 0;
mGeometryShape = 0;
mTransparency = 0.0f;
}
hwPhongShader::~hwPhongShader()
{
TRACE_API_CALLS("~hwPhongShader");
detachSceneCallbacks();
}
void hwPhongShader::releaseEverything()
{
if (phong_map_id != 0) {
M3dView view = M3dView::active3dView();
// The M3dView class doesn't return the correct status if there isn't
// an active 3D view, so we rely on the success of beginGL() which
// will make the context current.
//
if (view.beginGL()) {
glDeleteTextures( 1, &phong_map_id );
phong_map_id = 0;
}
view.endGL();
}
}
void hwPhongShader::attachSceneCallbacks()
{
fBeforeNewCB = MSceneMessage::addCallback(MSceneMessage::kBeforeNew, releaseCallback, this);
fBeforeOpenCB = MSceneMessage::addCallback(MSceneMessage::kBeforeOpen, releaseCallback, this);
fBeforeRemoveReferenceCB = MSceneMessage::addCallback(MSceneMessage::kBeforeRemoveReference,
releaseCallback, this);
fMayaExitingCB = MSceneMessage::addCallback(MSceneMessage::kMayaExiting, releaseCallback, this);
}
/*static*/
void hwPhongShader::releaseCallback(void* clientData)
{
hwPhongShader *pThis = (hwPhongShader*) clientData;
pThis->releaseEverything();
}
void hwPhongShader::detachSceneCallbacks()
{
if (fBeforeNewCB)
MMessage::removeCallback(fBeforeNewCB);
if (fBeforeOpenCB)
MMessage::removeCallback(fBeforeOpenCB);
if (fBeforeRemoveReferenceCB)
MMessage::removeCallback(fBeforeRemoveReferenceCB);
if (fMayaExitingCB)
MMessage::removeCallback(fMayaExitingCB);
fBeforeNewCB = 0;
fBeforeOpenCB = 0;
fBeforeRemoveReferenceCB = 0;
fMayaExitingCB = 0;
}
static const MString sHWPhongShaderRegistrantId("HWPhongShaderRegistrantId");
// Custom data for using Viewport 2.0 implementation of shader
class hwPhongShaderData : public MUserData
{
public:
hwPhongShaderData() : MUserData(true) {}
virtual ~hwPhongShaderData() {}
MString fPath;
};
// Viewport 2.0 implementation for the shader
class hwPhongShaderOverride : public MHWRender::MPxShaderOverride
{
public:
static MHWRender::MPxShaderOverride* Creator(const MObject& obj)
{
return new hwPhongShaderOverride(obj);
}
virtual ~hwPhongShaderOverride()
{
delete[] fTextureData;
fTextureData = NULL;
// It is possible for the MPxShaderOverride object to be deleted when
// the fShaderNode is not. If this happens we need to be sure that the
// next hwPhongShaderOverride created sets the parameters on the shader
// instance at least once, or we'll render with unititialized parameters.
if (fShaderNode) fShaderNode->markAttributesChangedVP2();
fShaderNode = NULL;
MHWRender::MRenderer* theRenderer = MHWRender::MRenderer::theRenderer();
if (theRenderer)
{
MHWRender::MTextureManager *theTextureManager = theRenderer->getTextureManager();
if (theTextureManager)
{
if (fTexture)
{
theTextureManager->releaseTexture(fTexture);
}
}
const MHWRender::MShaderManager* shaderMgr = theRenderer->getShaderManager();
if (shaderMgr)
{
if (fColorShaderInstance)
{
shaderMgr->releaseShader(fColorShaderInstance);
}
if (fShadowShaderInstance)
{
shaderMgr->releaseShader(fShadowShaderInstance);
}
}
}
fTexture = NULL;
fColorShaderInstance = NULL;
fShadowShaderInstance = NULL;
}
// Initialize phase
virtual MString initialize(
const MInitContext& initContext,
MInitFeedback& initFeedback)
{
TRACE_API_CALLS("hwPhongShaderOverride::initialize");
bool setRequirementsFromShader = false;
if (fColorShaderInstance)
{
// Use the requirements for the color shader which is a superset
// of the requirements for the color and shadow shadowers.
//
// - Generally this is the easiest way to set geometry requirements since they
// are taken directly from the shader. To use the custom primitive types
// branch this has been disabled so that explicit requirments can be set.
// - The type and format should be made to exactly match the shader.
if (setRequirementsFromShader)
setGeometryRequirements( *fColorShaderInstance );
// This plugin is using the utility method
// MPxShaderOverride::drawGeometry(). For DX11 drawing,
// a shader signature is required. We use
// the signature from the same MShaderInstance used to
// set the geometry requirements so that the signature
// will match the requirements.
//
addShaderSignature( *fColorShaderInstance );
}
if (!setRequirementsFromShader)
{
// Set the geometry requirements for drawing. Only need
// position and normals.
MString empty;
// custom primitive types can be used by shader overrides.
// This code is a simple example to show the mechanics of how that works.
// Here we declare a custom custom indexing requirements.
// The name "customPrimitiveTest" will be used to look up a registered
// MPxPrimitiveGenerator that will handle the generation of the index buffer.
// The example primitive generator is registered at startup by this plugin.
//
// As part of this example the plugin customPrimitiveGenerator should
// be loaded. Note that this plugin will only handle polygonal meshes
// where "Smooth Mesh Preview" has not be turned on. That is it will only
// rebuild indexing apropriately for the original non-smoothed mesh.
//
static bool useCustomPrimitiveGenerator = (getenv("MAYA_USE_CUSTOMPRIMITIVEGENERATOR") != NULL);
if(useCustomPrimitiveGenerator)
{
MString customPrimitiveName("customPrimitiveTest");
MHWRender::MIndexBufferDescriptor indexingRequirement(
MHWRender::MIndexBufferDescriptor::kCustom,
customPrimitiveName,
MHWRender::MGeometry::kTriangles);
addIndexingRequirement(indexingRequirement);
MHWRender::MVertexBufferDescriptor positionDesc(
empty,
MHWRender::MGeometry::kPosition,
MHWRender::MGeometry::kFloat,
3);
positionDesc.setSemanticName("customPositionStream");
MHWRender::MVertexBufferDescriptor normalDesc(
empty,
MHWRender::MGeometry::kNormal,
MHWRender::MGeometry::kFloat,
3);
normalDesc.setSemanticName("customNormalStream");
addGeometryRequirement(positionDesc);
addGeometryRequirement(normalDesc);
}
else
{
MHWRender::MVertexBufferDescriptor positionDesc(
empty,
MHWRender::MGeometry::kPosition,
MHWRender::MGeometry::kFloat,
3);
// Use the custom semantic name "swizzlePosition"
// When the vertexBufferMutator plugin is loaded,
// this will swap the x,y and z values of the vertex buffer.
positionDesc.setSemanticName("swizzlePosition");
MHWRender::MVertexBufferDescriptor normalDesc(
empty,
MHWRender::MGeometry::kNormal,
MHWRender::MGeometry::kFloat,
3);
addGeometryRequirement(positionDesc);
addGeometryRequirement(normalDesc);
}
}
// Store path name as string to show Maya source on draw
// NOTE 1: We cannot use the path to access the DAG object during the
// draw callback since that could trigger DG evaluation, we
// just use the string for debugging info.
// NOTE 2: Adding custom data here makes consolidation of objects
// sharing the same hwPhongShader impossible. Performance will
// suffer in that case.
hwPhongShaderData* data = new hwPhongShaderData();
data->fPath = initContext.dagPath.fullPathName();
initFeedback.customData = data;
return MString("Autodesk Maya hwPhongShaderOverride");
}
// Update phase
virtual void updateDG(MObject object)
{
TRACE_API_CALLS("hwPhongShaderOverride::updateDG");
if (object != MObject::kNullObj)
{
// Get the hardware shader node from the MObject.
fShaderNode = (hwPhongShader *) MPxHwShaderNode::getHwShaderNodePtr( object );
if (fShaderNode)
{
fTransparency = fShaderNode->Transparency();
}
else
{
fTransparency = 0.0f;
}
const float3 * amb = fShaderNode->Ambient();
const float3 * diff = fShaderNode->Diffuse();
const float3 * spec = fShaderNode->Specular();
const float3 * shininess = fShaderNode->Shininess();
fAmbient[0] = (*amb)[0]; fAmbient[1] = (*amb)[1]; fAmbient[2] = (*amb)[2];
fDiffuse[0] = (*diff)[0]; fDiffuse[1] = (*diff)[1]; fDiffuse[2] = (*diff)[2];
fDiffuse[3] = 1.0f - fTransparency;
fSpecular[0] = (*spec)[0]; fSpecular[1] = (*spec)[1]; fSpecular[2] = (*spec)[2];
fShininess[0] = (*shininess)[0]; fShininess[1] = (*shininess)[1]; fShininess[2] = (*shininess)[2];
}
}
virtual void updateDevice()
{
TRACE_API_CALLS("hwPhongShaderOverride::updateDevice");
if (fDrawUsingShader)
updateShaderInstance();
if (!fColorShaderInstance)
rebuildTexture();
}
virtual void endUpdate()
{
TRACE_API_CALLS("hwPhongShaderOverride::endUpdate");
}
// Draw phase
virtual bool handlesDraw(MHWRender::MDrawContext& context)
{
const MHWRender::MPassContext & passCtx = context.getPassContext();
const MString & passId = passCtx.passIdentifier();
const MStringArray & passSem = passCtx.passSemantics();
fInShadowPass = false;
fInColorPass = false;
// Enable to debug what is occuring in handlesDraw()
//
bool debugHandlesDraw = false;
if (debugHandlesDraw)
printf("In hwPhong shader handlesDraw(). Pass Identifier = %s\n", passId.asChar());
bool handlePass = false;
for (unsigned int i=0; i<passSem.length(); i++)
{
if (passSem[i] == MHWRender::MPassContext::kColorPassSemantic)
{
bool hasOverrideShader = passCtx.hasShaderOverride();
if (!hasOverrideShader)
{
if (debugHandlesDraw)
printf("-> handle semantic[%d][%s]\n", i, passSem[i].asChar());
handlePass = true;
fInColorPass = true;
}
}
else if (passSem[i] == MHWRender::MPassContext::kShadowPassSemantic)
{
// Only if we can load in a shadow shader will we handle
// the shadow pass.
//
if (fShadowShaderInstance)
handlePass = true;
if (debugHandlesDraw)
printf("-> handle semantic[%d][%s] = %d\n", i, passSem[i].asChar(), handlePass);
// Remember that we are currently drawing in a shadow pass
fInShadowPass = true;
}
else if (passSem[i] == MHWRender::MPassContext::kDepthPassSemantic)
{
if (debugHandlesDraw)
printf("-> don't handle semantic[%d][%s]\n", i, passSem[i].asChar());
handlePass = false;
}
else if (passSem[i] == MHWRender::MPassContext::kNormalDepthPassSemantic)
{
if (debugHandlesDraw)
printf("-> don't handle semantic[%d][%s]\n", i, passSem[i].asChar());
handlePass = false;
}
else
{
if (debugHandlesDraw)
printf("-> additional semantic[%d][%s]\n", i, passSem[i].asChar());
}
}
// Any other passes, don't override drawing
//
return handlePass;
}
virtual MHWRender::MShaderInstance* shaderInstance() const
{
if (fDrawUsingShader)
{
if (fInColorPass)
{
// If color pass
if (fColorShaderInstance)
return fColorShaderInstance;
}
else if (fInShadowPass)
{
// If shadow pass
if (fShadowShaderInstance)
return fShadowShaderInstance;
}
}
return NULL;
}
// Example of using an MShaderInstance for draw.
// We make the activation occur in activateKey() and
// the termination occur in terminateKey().
virtual void activateKey(MHWRender::MDrawContext& context, const MString& key)
{
TRACE_API_CALLS("hwPhongShaderOverride::activateKey");
fShaderBound = false;
if (fDrawUsingShader)
{
if (fInColorPass && fColorShaderInstance)
{
fColorShaderInstance->bind( context );
fShaderBound = true;
}
else if (fInShadowPass && fShadowShaderInstance)
{
// Update the parameters on the shadow shader
MMatrix viewProj = context.getMatrix(MHWRender::MFrameContext::kViewProjMtx);
fShadowShaderInstance->setParameter("shadowViewProj", viewProj );
fShadowShaderInstance->bind( context );
fShaderBound = true;
}
}
}
// Example of using MShaderInstace to draw. Terminate
// the shader instance here.
virtual void terminateKey(MHWRender::MDrawContext& context, const MString& key)
{
TRACE_API_CALLS("hwPhongShaderOverride::terminateKey");
if (fShaderBound)
{
if (fInColorPass && fColorShaderInstance)
{
fColorShaderInstance->unbind( context );
}
else if (fInShadowPass && fShadowShaderInstance)
{
fShadowShaderInstance->unbind( context );
}
}
fShaderBound = false;
}
virtual bool draw(
MHWRender::MDrawContext& context,
const MHWRender::MRenderItemList& renderItemList) const
{
TRACE_API_CALLS("hwPhongShaderOverride::draw");
MHWRender::MStateManager* stateMgr = context.getStateManager();
//initialize hwPhongShader blend state once
if(sBlendState == NULL)
{
//initilize blend state
MHWRender::MBlendStateDesc blendStateDesc;
for(int i = 0; i < (blendStateDesc.independentBlendEnable ? MHWRender::MBlendState::kMaxTargets : 1); ++i)
{
blendStateDesc.targetBlends[i].blendEnable = true;
blendStateDesc.targetBlends[i].sourceBlend = MHWRender::MBlendState::kSourceAlpha;
blendStateDesc.targetBlends[i].destinationBlend = MHWRender::MBlendState::kInvSourceAlpha;
blendStateDesc.targetBlends[i].blendOperation = MHWRender::MBlendState::kAdd;
blendStateDesc.targetBlends[i].alphaSourceBlend = MHWRender::MBlendState::kOne;
blendStateDesc.targetBlends[i].alphaDestinationBlend = MHWRender::MBlendState::kInvSourceAlpha;
blendStateDesc.targetBlends[i].alphaBlendOperation = MHWRender::MBlendState::kAdd;
}
blendStateDesc.blendFactor[0] = 1.0f;
blendStateDesc.blendFactor[1] = 1.0f;
blendStateDesc.blendFactor[2] = 1.0f;
blendStateDesc.blendFactor[3] = 1.0f;
sBlendState = stateMgr->acquireBlendState(blendStateDesc);
}
int val = 0;
bool debugDrawContext = false;
if (MGlobal::getOptionVarValue("hwPhong_debugDrawContext", val))
{
debugDrawContext = (val > 0);
}
if (debugDrawContext)
printContextInformation(context);
const MHWRender::MPassContext & passCtx = context.getPassContext();
const MStringArray & passSem = passCtx.passSemantics();
bool debugPassInformation = false;
if (debugPassInformation)
{
const MString & passId = passCtx.passIdentifier();
printf("hwPhong node drawing in pass[%s], semantic[", passId.asChar());
for (unsigned int i=0; i<passSem.length(); i++)
printf(" %s", passSem[i].asChar());
printf(" ]\n");
}
// save old render state
const MHWRender::MBlendState* pOldBlendState = stateMgr->getBlendState();
// Have a MShaderInstance bound then just need to draw the geometry
//
if (fShaderBound)
{
// Draw for color pass
if (fInColorPass)
{
bool needBlending = false;
if (fTransparency > 0.0f)
{
needBlending = true;
stateMgr->setBlendState(sBlendState);
}
unsigned int passCount = fColorShaderInstance->getPassCount( context );
if (passCount)
{
for (unsigned int i=0; i<passCount; i++)
{
fColorShaderInstance->activatePass( context, i );
MHWRender::MPxShaderOverride::drawGeometry(context);
}
}
if (needBlending)
{
stateMgr->setBlendState(pOldBlendState);
}
}
// Draw for shadow pass
else if (fInShadowPass)
{
unsigned int passCount = fShadowShaderInstance->getPassCount( context );
if (passCount)
{
for (unsigned int i=0; i<passCount; i++)
{
fShadowShaderInstance->activatePass( context, i );
MHWRender::MPxShaderOverride::drawGeometry(context);
}
}
}
}
// Use old method of a cube-map texture to draw
//
else
{
int phongTextureId = 0;
MHWRender::MRenderer *theRenderer = MHWRender::MRenderer::theRenderer();
if (theRenderer)
{
MHWRender::MTextureManager *theTextureManager = theRenderer->getTextureManager();
if(theTextureManager)
{
if(fTexture)
{
void *idPtr = fTexture->resourceHandle();
if (idPtr)
{
phongTextureId = *((int *)idPtr);
}
}
}
}
if (phongTextureId == 0)
{
return false;
}
// Setup the matrix to draw the object in world space
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
MStatus status;
MMatrix transform =
context.getMatrix(MHWRender::MFrameContext::kWorldViewMtx, &status);
if (status)
{
glLoadMatrixd(transform.matrix[0]);
}
// set projection matrix
glMatrixMode(GL_PROJECTION);
glPushMatrix();
MMatrix projection =
context.getMatrix(MHWRender::MFrameContext::kProjectionMtx, &status);
if (status)
{
glLoadMatrixd(projection.matrix[0]);
}
bool needBlending = false;
if (fTransparency > 0.0f)
{
needBlending = true;
stateMgr->setBlendState(sBlendState);
glColor4f(1.0, 1.0, 1.0, 1.0f-fTransparency );
}
else
glColor4f(1.0, 1.0, 1.0, 1.0f);
// Setup up phong texture
CubeMapTextureDrawUtility::bind( phongTextureId );
// Trigger geometric draw
bool debugGeometricDraw = false; // Set to true to debug
if (debugGeometricDraw)
{
// Debugging code to see what is being sent down to draw
// by MDrawContext::drawGeometry().
//
// The sample draw code does basically what is done internally.
//
customDraw(context, renderItemList);
}
else
{
// Draw the geometry through the internal interface instead
// of drawing via the plugin.
MHWRender::MPxShaderOverride::drawGeometry(context);
}
// Disable texture state
CubeMapTextureDrawUtility::unbind();
if (needBlending)
{
glColor4f(1.0, 1.0, 1.0, 1.0 );
//restore blend state
stateMgr->setBlendState(pOldBlendState);
}
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
}
return true;
}
// Custom draw. OpenGL version only
//
void customDraw(
MHWRender::MDrawContext& context,
const MHWRender::MRenderItemList& renderItemList) const
{
static MGLFunctionTable *gGLFT = 0;
if ( 0 == gGLFT )
gGLFT = MHardwareRenderer::theRenderer()->glFunctionTable();
MGLenum currentError = 0;
glPushClientAttrib ( GL_CLIENT_ALL_ATTRIB_BITS );
{
int numRenderItems = renderItemList.length();
for (int renderItemIdx=0; renderItemIdx<numRenderItems; renderItemIdx++)
{
const MHWRender::MRenderItem* renderItem = renderItemList.itemAt(renderItemIdx);
if (!renderItem) continue;
const MHWRender::MGeometry* geometry = renderItem->geometry();
if (!geometry) continue;
hwPhongShaderData* phongData = dynamic_cast<hwPhongShaderData*>(renderItem->customData());
if (phongData)
{
fprintf(stderr, "Source object path=%s\n", phongData->fPath.asChar());
}
// Dump out vertex field information for each field
//
int bufferCount = geometry->vertexBufferCount();
#define GLOBJECT_BUFFER_OFFSET(i) ((char *)NULL + (i)) // For GLObject offsets
bool boundData = true;
for (int i=0; i<bufferCount && boundData; i++)
{
const MHWRender::MVertexBuffer* buffer = geometry->vertexBuffer(i);
if (!buffer)
{
boundData = false;
continue;
}
const MHWRender::MVertexBufferDescriptor& desc = buffer->descriptor();
GLuint * dataBufferId = NULL;
void *dataHandle = buffer->resourceHandle();
if (!dataHandle)
{
boundData = false;
continue;
}
dataBufferId = (GLuint *)(dataHandle);
unsigned int fieldOffset = desc.offset();
unsigned int fieldStride = desc.stride();
{
fprintf(stderr, "Buffer(%d), Name(%s), BufferType(%s), BufferDimension(%d), BufferSemantic(%s), Offset(%d), Stride(%d), Handle(%d)\n",
i,
desc.name().asChar(),
MHWRender::MGeometry::dataTypeString(desc.dataType()).asChar(),
desc.dimension(),
MHWRender::MGeometry::semanticString(desc.semantic()).asChar(),
fieldOffset,
fieldStride,
*dataBufferId);
}
// Bind each data buffer
if (*dataBufferId > 0)
{
gGLFT->glBindBufferARB(MGL_ARRAY_BUFFER_ARB, *dataBufferId);
currentError = gGLFT->glGetError();
if (currentError != MGL_NO_ERROR)
boundData = false;
}
else
boundData = false;
if (boundData)
{
// Set the data pointers
if (desc.semantic() == MHWRender::MGeometry::kPosition)
{
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, fieldStride*4, GLOBJECT_BUFFER_OFFSET(fieldOffset));
currentError = gGLFT->glGetError();
if (currentError != MGL_NO_ERROR)
boundData = false;
}
else if (desc.semantic() == MHWRender::MGeometry::kNormal)
{
glEnableClientState(GL_NORMAL_ARRAY);
glNormalPointer(GL_FLOAT, fieldStride*4, GLOBJECT_BUFFER_OFFSET(fieldOffset));
currentError = gGLFT->glGetError();
if (currentError != MGL_NO_ERROR)
boundData = false;
}
}
}
if (boundData && geometry->indexBufferCount() > 0)
{
// Dump out indexing information
//
const MHWRender::MIndexBuffer* buffer = geometry->indexBuffer(0);
void *indexHandle = buffer->resourceHandle();
unsigned int indexBufferCount = 0;
GLuint *indexBufferId = NULL;
MHWRender::MGeometry::Primitive indexPrimType = renderItem->primitive();
if (indexHandle)
{
indexBufferId = (GLuint *)(indexHandle);
indexBufferCount = buffer->size();
{
fprintf(stderr, "IndexingPrimType(%s), IndexType(%s), IndexCount(%d), Handle(%d)\n",
MHWRender::MGeometry::primitiveString(indexPrimType).asChar(),
MHWRender::MGeometry::dataTypeString(buffer->dataType()).asChar(),
indexBufferCount,
*indexBufferId);
}
}
// Bind the index buffer
if (indexBufferId && (*indexBufferId > 0))
{
gGLFT->glBindBufferARB(MGL_ELEMENT_ARRAY_BUFFER_ARB, *indexBufferId);
currentError = gGLFT->glGetError();
if (currentError == MGL_NO_ERROR)
{
GLenum indexPrimTypeGL = GL_TRIANGLES;
switch (indexPrimType) {
case MHWRender::MGeometry::kPoints:
indexPrimTypeGL = GL_POINTS; break;
case MHWRender::MGeometry::kLines:
indexPrimTypeGL = GL_LINES; break;
case MHWRender::MGeometry::kLineStrip:
indexPrimTypeGL = GL_LINE_STRIP; break;
case MHWRender::MGeometry::kTriangles:
indexPrimTypeGL = GL_TRIANGLES; break;
case MHWRender::MGeometry::kTriangleStrip:
indexPrimTypeGL = GL_TRIANGLE_STRIP; break;
default:
boundData = false;
break;
};
if (boundData)
{
// Draw the geometry
GLenum indexType =
( buffer->dataType() == MHWRender::MGeometry::kUnsignedInt32 ? GL_UNSIGNED_INT : GL_UNSIGNED_SHORT );
glDrawElements(indexPrimTypeGL, indexBufferCount, indexType, GLOBJECT_BUFFER_OFFSET(0));
}
}
}
}
}
}
glPopClientAttrib();
}
virtual MHWRender::DrawAPI supportedDrawAPIs() const
{
// Using a custom internal shader means we can draw in OpenGL
// and DirectX.
if (fDrawUsingShader)
return (MHWRender::kOpenGL | MHWRender::kDirectX11);
else
return MHWRender::kOpenGL;
}
virtual bool isTransparent()
{
TRACE_API_CALLS("hwPhongShaderOverride::isTransparent");
if (fShaderNode)
{
return (fTransparency > 0.0f);
}
return false;
}
virtual bool overridesDrawState()
{
return true;
}
void debugShaderParameters(const MHWRender::MShaderInstance *shaderInstance)
{
MStringArray params;
shaderInstance->parameterList(params);
unsigned int numParams = params.length();
printf("DEBUGGING SHADER, BEGIN PARAM LIST OF LENGTH %d\n", numParams);
for (unsigned int i=0; i<numParams; i++)
{
printf("ParamName='%s', ParamType=", params[i].asChar());
switch (shaderInstance->parameterType(params[i]))
{
case MHWRender::MShaderInstance::kInvalid:
printf("'Invalid', ");
break;
case MHWRender::MShaderInstance::kBoolean:
printf("'Boolean', ");
break;
case MHWRender::MShaderInstance::kInteger:
printf("'Integer', ");
break;
case MHWRender::MShaderInstance::kFloat:
printf("'Float', ");
break;
case MHWRender::MShaderInstance::kFloat2:
printf("'Float2', ");
break;
case MHWRender::MShaderInstance::kFloat3:
printf("'Float3', ");
break;
case MHWRender::MShaderInstance::kFloat4:
printf("'Float4', ");
break;
case MHWRender::MShaderInstance::kFloat4x4Row:
printf("'Float4x4Row', ");
break;
case MHWRender::MShaderInstance::kFloat4x4Col:
printf("'Float4x4Col', ");
break;
case MHWRender::MShaderInstance::kTexture1:
printf("'1D Texture', ");
break;
case MHWRender::MShaderInstance::kTexture2:
printf("'2D Texture', ");
break;
case MHWRender::MShaderInstance::kTexture3:
printf("'3D Texture', ");
break;
case MHWRender::MShaderInstance::kTextureCube:
printf("'Cube Texture', ");
break;
case MHWRender::MShaderInstance::kSampler:
printf("'Sampler', ");
break;
default:
printf("'Unknown', ");
break;
}
printf("IsArrayParameter='%s'\n", shaderInstance->isArrayParameter(params[i]) ? "YES" : "NO");
}
printf("END PARAM LIST\n");
}
// Code to create a cached MShaderInstance
void createShaderInstance()
{
TRACE_API_CALLS("hwPhongShaderOverride::createShaderInstance");
MHWRender::MRenderer *renderer = MHWRender::MRenderer::theRenderer();
if (!renderer)
return;
const MHWRender::MShaderManager* shaderMgr = renderer->getShaderManager();
if (!shaderMgr)
return;
bool debugShader = false;
// If no shadow shader instance created yet acquire one. Use
// the stock shadow shader provided.
//
if (!fShadowShaderInstance)
{
fShadowShaderInstance = shaderMgr->getStockShader( MHWRender::MShaderManager::k3dShadowerShader );
// Some sample debugging code to see what parameters are available.
if (fShadowShaderInstance)
{
if (debugShader)
debugShaderParameters( fShadowShaderInstance );
}
else
{
fprintf(stderr, "Failed to load shadower shader for hwPhong\n");
}
}
// If no color shader instance created yet acquire one. For
// now it's just using an internal shader for convenience but
// a custom shader could be written here as well.
if (!fColorShaderInstance)
{
fColorShaderInstance = shaderMgr->getStockShader( MHWRender::MShaderManager::k3dBlinnShader );
// Some sample debugging code to see what parameters are available.
if (fColorShaderInstance && debugShader)
{
debugShaderParameters( fColorShaderInstance );
}
}
}
// Code to update a cached MShaderInstance
//
void updateShaderInstance()
{
TRACE_API_CALLS("hwPhongShaderOverride::updateShaderInstance");
MHWRender::MRenderer *renderer = MHWRender::MRenderer::theRenderer();
if (!renderer)
return;
// Update the parameters on the color shader
//
if (fColorShaderInstance)
{
// Update shader to mark it as drawing with transparency or not.
fColorShaderInstance->setIsTransparent( isTransparent() );
if (fShaderNode && fShaderNode->attributesChangedVP2())
{
fColorShaderInstance->setParameter("emissionColor", &fAmbient[0] );
fColorShaderInstance->setParameter("diffuseColor", &fDiffuse[0] );
fColorShaderInstance->setParameter("specularColor", &fSpecular[0] );
// "specularPower" is set using single-float argument version of setParameter()
float specPower = fShininess[0];
fColorShaderInstance->setParameter("specularPower", specPower );
fShaderNode->markAttributesCleanVP2();
}
}
}
// Code to recreate a new texture on parameter change.
// Not used when using a shader to draw with.
void rebuildTexture()
{
TRACE_API_CALLS("hwPhongShaderOverride::rebuildTexture");
// Rebuild the hardware Phong texture if needed
if (fShaderNode && fShaderNode->attributesChangedVP2())
{
MHWRender::MRenderer *theRenderer = MHWRender::MRenderer::theRenderer();
if (theRenderer)
{
MHWRender::MTextureManager *theTextureManager = theRenderer ? theRenderer->getTextureManager() : NULL;
// Set a unique identifier for this texture
// based on the shading parameters used to create
// the texture
//
MString newTextureName = MString("MyPhongCubeMap__");
const float3 * amb = fShaderNode->Ambient();
const float3 * diff = fShaderNode->Diffuse();
const float3 * spec= fShaderNode->Specular();
const float3 * shininess = fShaderNode->Shininess();
newTextureName += (*amb)[0]; newTextureName += MString("_");
newTextureName += (*amb)[1]; newTextureName += MString("_");
newTextureName += (*amb)[2]; newTextureName += MString("_");
newTextureName += (*diff)[0]; newTextureName += MString("_");
newTextureName += (*diff)[1]; newTextureName += MString("_");
newTextureName += (*diff)[2]; newTextureName += MString("_");
newTextureName += (*spec)[0]; newTextureName += MString("_");
newTextureName += (*spec)[1]; newTextureName += MString("_");
newTextureName += (*spec)[2]; newTextureName += MString("_");
newTextureName += (*shininess)[0]; newTextureName += MString("_");
newTextureName += (*shininess)[1]; newTextureName += MString("_");
newTextureName += (*shininess)[2];
// Release the old one, and set the new name
//
if(fTexture)
{
if (theTextureManager)
{
theTextureManager->releaseTexture(fTexture);
}
fTexture = NULL;
}
// We create 1 contiguous block of data for the texture.
//
if (!fTextureData)
{
fTextureData =
new unsigned char[4*PHONG_TEXTURE_RES*PHONG_TEXTURE_RES*6];
}
if (fTextureData)
{
int index = 0;
for ( int face=0 ; face<6 ; face++ )
{
for ( int j=0 ; j<PHONG_TEXTURE_RES ; j++ )
{
double t = 2*double(j)/(PHONG_TEXTURE_RES - 1) - 1; // -1 to 1
for ( int i=0 ; i<PHONG_TEXTURE_RES ; i++ )
{
double s = 2*double(i)/(PHONG_TEXTURE_RES - 1) - 1; // -1 to 1
double x = 0.0, y = 0.0, z = 0.0;
cubeToDir ( face, s, t, x, y, z );
MFloatVector intensity = fShaderNode->Phong ( z );
fTextureData[index++] = (unsigned char)(255*intensity[0]);
fTextureData[index++] = (unsigned char)(255*intensity[1]);
fTextureData[index++] = (unsigned char)(255*intensity[2]);
fTextureData[index++] = 255;
}
}
}
MHWRender::MTextureDescription desc;
{
desc.setToDefault2DTexture();
desc.fWidth = PHONG_TEXTURE_RES;
desc.fHeight = PHONG_TEXTURE_RES;
desc.fDepth = 1;
desc.fBytesPerRow = 4*PHONG_TEXTURE_RES;
desc.fBytesPerSlice = 4*PHONG_TEXTURE_RES*PHONG_TEXTURE_RES;
desc.fMipmaps = 1;
desc.fArraySlices = 6;
desc.fFormat = MHWRender::kR8G8B8A8_UNORM;
desc.fTextureType = MHWRender::kCubeMap;
}
if (theTextureManager)
{
fTexture = theTextureManager->acquireTexture( newTextureName, desc, fTextureData );
}
}
// Mark the texture clean
fShaderNode->markAttributesCleanVP2();
}
}
}
// Utility code to print the current context information
//
static void printContextInformation( const MHWRender::MDrawContext & context )
{
TRACE_API_CALLS("hwPhongShaderOverride::printContextInformation");
// Sample code to print out the information found in MDrawContext
//
MDoubleArray dtuple;
printf("Draw Context Diagnostics {\n");
{
dtuple = context.getTuple( MHWRender::MFrameContext::kViewPosition );
printf("\tView position: %f, %f, %f\n", dtuple[0], dtuple[1], dtuple[2]);
dtuple = context.getTuple( MHWRender::MFrameContext::kViewPosition );
printf("\tView dir : %f, %f, %f\n", dtuple[0], dtuple[1], dtuple[2]);
dtuple = context.getTuple( MHWRender::MFrameContext::kViewUp );
printf("\tView up : %f, %f, %f\n", dtuple[0], dtuple[1], dtuple[2]);
dtuple = context.getTuple( MHWRender::MFrameContext::kViewRight );
printf("\tView right : %f, %f, %f\n", dtuple[0], dtuple[1], dtuple[2]);
printf("\n");
MBoundingBox bbox = context.getSceneBox();
MPoint bmin = bbox.min();
MPoint bmax = bbox.max();
printf("\tScene bounding box = %g,%g,%g -> %g,%g,%g\n",
bmin[0],bmin[1],bmin[2],
bmax[0],bmax[1],bmax[2]);
int originX; int originY; int width; int height;
context.getRenderTargetSize( width, height );
printf("\tRender target size: %d x %d\n", width, height);
context.getViewportDimensions( originX, originY, width, height);
printf("\tViewport dimensions: %d, %d, -> %d, %d\n", originX, originY, width, height);
MStatus xStatus;
printf("\tView direction along neg z = %d\n", context.viewDirectionAlongNegZ( &xStatus ));
// Flag to test getting all scene lights or the subset used for lighting
//
static MHWRender::MDrawContext::LightFilter considerAllSceneLights = MHWRender::MDrawContext::kFilteredToLightLimit;
if (considerAllSceneLights == MHWRender::MDrawContext::kFilteredToLightLimit)
considerAllSceneLights = MHWRender::MDrawContext::kFilteredIgnoreLightLimit;
else
considerAllSceneLights = MHWRender::MDrawContext::kFilteredToLightLimit;
printf("\tLight Information for %s\n",
considerAllSceneLights == MHWRender::MDrawContext::kFilteredToLightLimit
? "only lights clamped to light limit." : "lights not clamped to light limit.");
unsigned int lightCount = context.numberOfActiveLights(considerAllSceneLights);
MFloatPointArray positions;
MFloatPoint position;
MFloatVector direction;
float intensity = 1.0f;
MColor color;
bool hasDirection = false;
bool hasPosition = false;
bool visualizeLighting = false;
// Reuse for each light.
MMatrix identity;
if (visualizeLighting )
{
for (unsigned int i=0; i<8; i++)
{
GLenum light = GL_LIGHT0+i;
glDisable(light);
}
if (!lightCount)
glDisable(GL_LIGHTING);
else
glEnable(GL_LIGHTING);
}
for (unsigned int i=0; i<lightCount; i++)
{
//
// Shown here are 2 avenues for accessing light data:
//
// If only some basic information which is common to all
// light types is required then the getLightInformation()
// interface can be used. It is a simpler interface and
// in general will be faster to execute.
//
// The alternative is to access the lights by parameter
// via the getLightParameterInformation() interface
// which allows us to inspect all the per light type specific
// information (e.g. the drop off on spot lights).
// As shown it is a bit more complex
// to use but provides more information.
//
bool getCommonParametersOnly = true;
// Look at common information only
//
if (getCommonParametersOnly)
{
context.getLightInformation( i,
positions, direction,
intensity, color, hasDirection,
hasPosition,
considerAllSceneLights);
printf("\tLight %d {\n", i);
printf("\t\tDirectional %d, Positional %d\n", hasDirection, hasPosition);
printf("\t\tDirection = %g, %g, %g\n", direction[0],direction[1],direction[2]);
unsigned int positionCount = positions.length();
if (hasPosition && positionCount)
{
for (unsigned int p=0; p<positions.length(); p++)
{
printf("\t\tPosition[%d] = %g, %g, %g\n", p, positions[p][0], positions[p][1], positions[p][2]);
position += positions[p];
}
position[0] /= (float)positionCount;
position[1] /= (float)positionCount;
position[2] /= (float)positionCount;
}
printf("\t\tColor = %g, %g, %g\n", color[0], color[1], color[2]);
printf("\t\tIntensity = %g\n", intensity);
printf("\t}\n");
}
// Look at all information which may differ per light type
//
else
{
unsigned int positionCount = 0;
position[0] = position[1] = position[2] = 0.0f;
MHWRender::MLightParameterInformation *lightParam =
context.getLightParameterInformation( i, considerAllSceneLights );
if (lightParam)
{
printf("\tLight %d {\n", i);
MStringArray params;
lightParam->parameterList(params);
for (unsigned int p=0; p<params.length(); p++)
{
MString pname = params[p];
MHWRender::MLightParameterInformation::ParameterType ptype = lightParam->parameterType( pname );
MFloatArray floatVals;
MIntArray intVals;
MMatrix matrixVal;
MHWRender::MSamplerStateDesc samplerDesc;
switch (ptype)
{
case MHWRender::MLightParameterInformation::kBoolean:
lightParam->getParameter( pname, intVals );
printf("\t\tLight parameter %s. Bool[%d]\n", pname.asChar(),
intVals[0]);
break;
case MHWRender::MLightParameterInformation::kInteger:
lightParam->getParameter( pname, intVals );
printf("\t\tLight parameter %s. Integer[%d]\n", pname.asChar(),
intVals[0]);
break;
case MHWRender::MLightParameterInformation::kFloat:
lightParam->getParameter( pname, floatVals );
printf("\t\tLight parameter %s. Float[%g]\n", pname.asChar(),
floatVals[0]);
break;
case MHWRender::MLightParameterInformation::kFloat2:
lightParam->getParameter( pname, floatVals );
printf("\t\tLight parameter %s. Float[%g,%g]\n", pname.asChar(),
floatVals[0], floatVals[1]);
break;
case MHWRender::MLightParameterInformation::kFloat3:
lightParam->getParameter( pname, floatVals );
printf("\t\tLight parameter %s. Float3[%g,%g,%g]\n", pname.asChar(),
floatVals[0], floatVals[1], floatVals[2]);
break;
case MHWRender::MLightParameterInformation::kFloat4:
lightParam->getParameter( pname, floatVals );
printf("\t\tLight parameter %s. Float4[%g,%g,%g,%g]\n", pname.asChar(),
floatVals[0], floatVals[1], floatVals[2], floatVals[3]);
break;
case MHWRender::MLightParameterInformation::kFloat4x4Row:
lightParam->getParameter( pname, matrixVal );
printf("\t\tLight parameter %s. Float4x4Row [%g,%g,%g,%g]\n\t\t[%g,%g,%g,%g]\n\t\t[%g,%g,%g,%g]\n\t\t[%g,%g,%g,%g]\n",
pname.asChar(),
matrixVal[0][0], matrixVal[0][1], matrixVal[0][2], matrixVal[0][3],
matrixVal[1][0], matrixVal[1][1], matrixVal[1][2], matrixVal[1][3],
matrixVal[2][0], matrixVal[2][1], matrixVal[2][2], matrixVal[2][3],
matrixVal[3][0], matrixVal[3][1], matrixVal[3][2], matrixVal[3][3]
);
break;
case MHWRender::MLightParameterInformation::kFloat4x4Col:
lightParam->getParameter( pname, matrixVal );
printf("\t\tLight parameter %s. Float4x4Row\n", pname.asChar() );
break;
case MHWRender::MLightParameterInformation::kTexture2:
{
void *handle = lightParam->getParameterTextureHandle( pname );
printf("\t\tLight texture parameter %s. OpenGL texture id = %d\n", pname.asChar(),
*((int *)handle));
break;
}
case MHWRender::MLightParameterInformation::kSampler:
lightParam->getParameter( pname, samplerDesc );
printf("\t\tLight sampler parameter %s. filter = %d\n", pname.asChar(),
samplerDesc.filter );
break;
default:
break;
}
// Do some discovery to map stock parameters to usable values
// based on the semantic
//
MHWRender::MLightParameterInformation::StockParameterSemantic semantic = lightParam->parameterSemantic( pname );
switch (semantic)
{
case MHWRender::MLightParameterInformation::kLightEnabled:
printf("\t\t- Parameter semantic : light enabled\n");
break;
case MHWRender::MLightParameterInformation::kWorldPosition:
printf("\t\t- Parameter semantic : world position\n");
position += MFloatPoint( floatVals[0], floatVals[1], floatVals[2] );
positionCount++;
hasPosition = true;
break;
case MHWRender::MLightParameterInformation::kWorldDirection:
printf("\t\t- Parameter semantic : world direction\n");
direction = MFloatVector( floatVals[0], floatVals[1], floatVals[2] );
hasDirection = true;
break;
case MHWRender::MLightParameterInformation::kIntensity:
printf("\t\t- Parameter semantic : intensity\n");
intensity = floatVals[0];
break;
case MHWRender::MLightParameterInformation::kColor:
printf("\t\t- Parameter semantic : color\n");
color = MColor( floatVals[0], floatVals[1], floatVals[2] );
break;
case MHWRender::MLightParameterInformation::kEmitsDiffuse:
printf("\t\t- Parameter semantic : emits-diffuse\n");
break;
case MHWRender::MLightParameterInformation::kEmitsSpecular:
printf("\t\t- Parameter semantic : emits-specular\n");
break;
case MHWRender::MLightParameterInformation::kDecayRate:
printf("\t\t- Parameter semantic : decay rate\n");
break;
case MHWRender::MLightParameterInformation::kDropoff:
printf("\t\t- Parameter semantic : drop-off\n");
break;
case MHWRender::MLightParameterInformation::kCosConeAngle:
printf("\t\t- Parameter semantic : cosine cone angle\n");
break;
case MHWRender::MLightParameterInformation::kShadowMap:
printf("\t\t- Parameter semantic : shadow map\n");
break;
case MHWRender::MLightParameterInformation::kShadowSamp:
printf("\t\t- Parameter semantic : shadow map sampler\n");
break;
case MHWRender::MLightParameterInformation::kShadowBias:
printf("\t\t- Parameter semantic : shadow map bias\n");
break;
case MHWRender::MLightParameterInformation::kShadowMapSize:
printf("\t\t- Parameter semantic : shadow map size\n");
break;
case MHWRender::MLightParameterInformation::kShadowViewProj:
printf("\t\t- Parameter semantic : shadow map view projection matrix\n");
break;
case MHWRender::MLightParameterInformation::kShadowColor:
printf("\t\t- Parameter semantic : shadow color\n");
break;
case MHWRender::MLightParameterInformation::kGlobalShadowOn:
printf("\t\t- Parameter semantic : global shadows on \n");
break;
case MHWRender::MLightParameterInformation::kShadowOn:
printf("\t\t- Parameter semantic : local shadows on\n");
break;
default:
break;
}
}
// Compute an average position
if (positionCount > 1)
{
position[0] /= (float)positionCount;
position[1] /= (float)positionCount;
position[2] /= (float)positionCount;
printf("\t\tCompute average position [%g,%g,%g]\n", position[0],
position[1], position[2]);
}
//delete lightParam;
printf("\t}\n");
}
}
MHWRender::MRenderer *theRenderer = MHWRender::MRenderer::theRenderer();
if (theRenderer && theRenderer->drawAPIIsOpenGL() && visualizeLighting
&& lightCount < 8)
{
GLenum light = GL_LIGHT0+i;
// Set light parameters
float ambient[3] = { 0.0f, 0.0f, 0.0f };
float specular[3] = { 1.0f, 1.0f, 1.0f };
glLightfv(light, GL_AMBIENT, &ambient[0]);
color[0] *= intensity;
color[1] *= intensity;
color[2] *= intensity;
glLightfv(light, GL_DIFFUSE, &color[0]);
glLightfv(light, GL_SPECULAR, &specular[0]);
glLightf(light, GL_CONSTANT_ATTENUATION, 1.0f);
glLightf(light, GL_LINEAR_ATTENUATION, 0.0f);
glLightf(light, GL_QUADRATIC_ATTENUATION, 0.0f);
glPushMatrix();
glLoadMatrixd( identity.matrix[0] );
// Set light position
if (hasPosition)
glLightfv(light, GL_POSITION, &position[0]);
else {
position[0] = position[1] = position[2] = 0.0f;
glLightfv(light, GL_POSITION, &position[0]);
}
// Set rest of parameters.
if (hasDirection)
{
glLightf(light, GL_SPOT_CUTOFF, 90.0f);
glLightf(light, GL_SPOT_EXPONENT, 64.0f);
glLightfv(light, GL_SPOT_DIRECTION, &direction[0]);
}
else
{
glLightf(light, GL_SPOT_CUTOFF, 180.0f);
glLightf(light, GL_SPOT_EXPONENT, 0.0f);
}
glEnable(light);
glPopMatrix();
}
}
}
printf("}\n");
}
protected:
hwPhongShaderOverride(const MObject& obj)
: MHWRender::MPxShaderOverride(obj)
, fShaderNode(NULL)
, fTextureData(NULL)
, fDrawUsingShader(true) // Disabling this will use fixed-function which only has an OpenGL implementation
, fShaderBound(false)
, fTexture(NULL)
, fInColorPass(false)
, fColorShaderInstance(NULL)
, fInShadowPass(false)
, fShadowShaderInstance(NULL)
, fTransparency(0.0f)
{
// Create a shader instance to use for drawing
//
if (fDrawUsingShader)
{
createShaderInstance();
}
fAmbient[0] = fAmbient[1] = fAmbient[2] = 0.0f;
fDiffuse[0] = fDiffuse[1] = fDiffuse[2] = fDiffuse[3] = 0.0f;
fSpecular[0] = fSpecular[1] = fSpecular[2] = 0.0f;
fShininess[0] = fShininess[1] = fShininess[2] = 500.0f;
}
// override blend state when there is blending
static const MHWRender::MBlendState *sBlendState;
// Current hwPhongShader node associated with the shader override.
// Updated during doDG() time.
hwPhongShader *fShaderNode;
// Shader inputs values including transparency
float fTransparency;
float fAmbient[3];
float fDiffuse[4];
float fSpecular[3];
float fShininess[3];
// Temporary system buffer for creating textures
unsigned char* fTextureData;
// Pass tracking
bool fInColorPass;
bool fInShadowPass;
// Draw with texture or shader flag
bool fDrawUsingShader;
// VP2 texture
MHWRender::MTexture *fTexture;
// VP2 color shader
MHWRender::MShaderInstance *fColorShaderInstance;
// VP2 shadow shader
MHWRender::MShaderInstance *fShadowShaderInstance;
mutable bool fShaderBound;
};
const MHWRender::MBlendState* hwPhongShaderOverride::sBlendState = NULL;
MStatus initializePlugin( MObject obj )
{
TRACE_API_CALLS("initializePlugin");
MStatus status;
const MString& swatchName = MHWShaderSwatchGenerator::initialize();
const MString UserClassify( "shader/surface/utility/:drawdb/shader/surface/hwPhongShader:swatch/"+swatchName );
MFnPlugin plugin( obj, PLUGIN_COMPANY, "4.5", "Any");
status = plugin.registerNode( "hwPhongShader", hwPhongShader::id,
hwPhongShader::creator, hwPhongShader::initialize,
MPxNode::kHwShaderNode, &UserClassify );
if (!status) {
status.perror("registerNode");
return status;
}
plugin.registerDragAndDropBehavior("hwPhongShaderBehavior",
hwPhongShaderBehavior::creator);
// Register a shader override for this node
MHWRender::MDrawRegistry::registerShaderOverrideCreator(
"drawdb/shader/surface/hwPhongShader",
sHWPhongShaderRegistrantId,
hwPhongShaderOverride::Creator);
if (status != MS::kSuccess) return status;
return MS::kSuccess;
}
MStatus uninitializePlugin( MObject obj )
{
TRACE_API_CALLS("uninitializePlugin");
MStatus status;
MFnPlugin plugin( obj );
// Unregister all chamelion shader nodes
plugin.deregisterNode( hwPhongShader::id );
if (!status) {
status.perror("deregisterNode");
return status;
}
plugin.deregisterDragAndDropBehavior("hwPhongShaderBehavior");
// Deregister the shader override
status = MHWRender::MDrawRegistry::deregisterShaderOverrideCreator(
"drawdb/shader/surface/hwPhongShader", sHWPhongShaderRegistrantId);
if (status != MS::kSuccess) return status;
return MS::kSuccess;
}
void * hwPhongShader::creator()
{
TRACE_API_CALLS("creator");
return new hwPhongShader();
}
MStatus hwPhongShader::initialize()
{
// Make sure that all attributes are cached internal for
// optimal performance !
TRACE_API_CALLS("initialize");
MFnNumericAttribute nAttr;
// Create input attributes
aColor = nAttr.createColor( "color", "c");
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(0.1f, 0.1f, 0.1f);
nAttr.setCached( true );
nAttr.setInternal( true );
nAttr.setAffectsAppearance( true );
aTransparency = nAttr.create( "transparency", "tr", MFnNumericData::kFloat );
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(0.0f);
nAttr.setMax(1.0f);
nAttr.setMin(0.0f);
nAttr.setCached( true );
nAttr.setInternal( true );
nAttr.setAffectsAppearance( true );
aDiffuseColor = nAttr.createColor( "diffuseColor", "dc" );
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(1.f, 0.5f, 0.5f);
nAttr.setCached( true );
nAttr.setInternal( true );
nAttr.setAffectsAppearance( true );
aSpecularColor = nAttr.createColor( "specularColor", "sc" );
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(0.5f, 0.5f, 0.5f);
nAttr.setCached( true );
nAttr.setInternal( true );
nAttr.setAffectsAppearance( true );
// This is defined as a point, so that users can easily enter
// values beyond 1.
aShininess = nAttr.createPoint( "shininess", "sh" );
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(100.0f, 100.0f, 100.0f);
nAttr.setCached( true );
nAttr.setInternal( true );
nAttr.setAffectsAppearance( true );
aGeometryShape = nAttr.create( "geometryShape", "gs", MFnNumericData::kInt );
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(0);
nAttr.setCached( true );
nAttr.setInternal( true );
// create output attributes here
// outColor is the only output attribute and it is inherited
// so we do not need to create or add it.
//
// Add the attributes here
addAttribute(aColor);
addAttribute(aTransparency);
addAttribute(aDiffuseColor);
addAttribute(aSpecularColor);
addAttribute(aShininess);
addAttribute(aGeometryShape);
attributeAffects (aColor, outColor);
attributeAffects (aTransparency, outColor);
attributeAffects (aDiffuseColor, outColor);
attributeAffects (aSpecularColor, outColor);
attributeAffects (aShininess, outColor);
return MS::kSuccess;
}
// DESCRIPTION:
//
MStatus hwPhongShader::compute(
const MPlug& plug,
MDataBlock& block )
{
TRACE_API_CALLS("compute");
if ((plug != outColor) && (plug.parent() != outColor))
return MS::kUnknownParameter;
MFloatVector & color = block.inputValue( aDiffuseColor ).asFloatVector();
// set output color attribute
MDataHandle outColorHandle = block.outputValue( outColor );
MFloatVector& outColor = outColorHandle.asFloatVector();
outColor = color;
outColorHandle.setClean();
return MS::kSuccess;
}
/* virtual */
bool hwPhongShader::setInternalValueInContext( const MPlug &plug,
const MDataHandle &handle,
MDGContext & )
{
bool handledAttribute = false;
if (plug == aColor)
{
handledAttribute = true;
float3 & val = handle.asFloat3();
if (val[0] != mAmbientColor[0] ||
val[1] != mAmbientColor[1] ||
val[2] != mAmbientColor[2])
{
mAmbientColor[0] = val[0];
mAmbientColor[1] = val[1];
mAmbientColor[2] = val[2];
mAttributesChanged = true;
mAttributesChangedVP2 = true;
}
}
else if (plug == aTransparency)
{
handledAttribute = true;
float val = handle.asFloat();
if (val != mTransparency)
{
mTransparency = val;
mAttributesChanged = true;
mAttributesChangedVP2 = true;
}
}
else if (plug == aDiffuseColor)
{
handledAttribute = true;
float3 & val = handle.asFloat3();
if (val[0] != mDiffuseColor[0] ||
val[1] != mDiffuseColor[1] ||
val[2] != mDiffuseColor[2])
{
mDiffuseColor[0] = val[0];
mDiffuseColor[1] = val[1];
mDiffuseColor[2] = val[2];
mAttributesChanged = true;
mAttributesChangedVP2 = true;
}
}
else if (plug == aSpecularColor)
{
handledAttribute = true;
float3 & val = handle.asFloat3();
if (val[0] != mSpecularColor[0] ||
val[1] != mSpecularColor[1] ||
val[2] != mSpecularColor[2])
{
mSpecularColor[0] = val[0];
mSpecularColor[1] = val[1];
mSpecularColor[2] = val[2];
mAttributesChanged = true;
mAttributesChangedVP2 = true;
}
}
else if (plug == aShininess)
{
handledAttribute = true;
float3 & val = handle.asFloat3();
if (val[0] != mShininess[0] ||
val[1] != mShininess[1] ||
val[2] != mShininess[2])
{
mShininess[0] = val[0];
mShininess[1] = val[1];
mShininess[2] = val[2];
mAttributesChanged = true;
mAttributesChangedVP2 = true;
}
}
else if (plug == aGeometryShape)
{
handledAttribute = true;
mGeometryShape = handle.asInt();
}
return handledAttribute;
}
/* virtual */
bool
hwPhongShader::getInternalValueInContext( const MPlug& plug,
MDataHandle& handle,
MDGContext&)
{
bool handledAttribute = false;
if (plug == aColor)
{
handledAttribute = true;
handle.set( mAmbientColor[0], mAmbientColor[1], mAmbientColor[2] );
}
if (plug == aTransparency)
{
handledAttribute = true;
handle.set( mTransparency );
}
else if (plug == aDiffuseColor)
{
handledAttribute = true;
handle.set( mDiffuseColor[0], mDiffuseColor[1], mDiffuseColor[2] );
}
else if (plug == aSpecularColor)
{
handledAttribute = true;
handle.set( mSpecularColor[0], mSpecularColor[1], mSpecularColor[2] );
}
else if (plug == aShininess)
{
handledAttribute = true;
handle.set( mShininess[0], mShininess[1], mShininess[2] );
}
else if (plug == aGeometryShape)
{
handledAttribute = true;
handle.set( (int) mGeometryShape );
}
return handledAttribute;
}
/* virtual */
MStatus hwPhongShader::bind(const MDrawRequest& request, M3dView& view)
{
TRACE_API_CALLS("bind");
init_Phong_texture ();
return MS::kSuccess;
}
/* virtual */
MStatus hwPhongShader::glBind(const MDagPath&)
{
TRACE_API_CALLS("glBind");
init_Phong_texture ();
return MS::kSuccess;
}
/* virtual */
MStatus hwPhongShader::unbind(const MDrawRequest& request, M3dView& view)
{
TRACE_API_CALLS("unbind");
// The texture may have been allocated by the draw; it's kept
// around for use again. When scene new or open is performed this
// texture will be released in releaseEverything().
return MS::kSuccess;
}
/* virtual */
MStatus hwPhongShader::glUnbind(const MDagPath&)
{
TRACE_API_CALLS("glUnbind");
// The texture may have been allocated by the draw; it's kept
// around for use again. When scene new or open is performed this
// texture will be released in releaseEverything().
return MS::kSuccess;
}
/* virtual */
MStatus hwPhongShader::geometry( const MDrawRequest& request,
M3dView& view,
int prim,
unsigned int writable,
int indexCount,
const unsigned int * indexArray,
int vertexCount,
const int * vertexIDs,
const float * vertexArray,
int normalCount,
const float ** normalArrays,
int colorCount,
const float ** colorArrays,
int texCoordCount,
const float ** texCoordArrays)
{
TRACE_API_CALLS("geometry");
MStatus stat = MStatus::kSuccess;
if (mGeometryShape != 0)
drawDefaultGeometry();
else
stat = draw( prim, writable, indexCount, indexArray, vertexCount,
vertexIDs, vertexArray, normalCount, normalArrays, colorCount,
colorArrays, texCoordCount, texCoordArrays);
return stat;
}
/* virtual */
MStatus hwPhongShader::glGeometry(const MDagPath & path,
int prim,
unsigned int writable,
int indexCount,
const unsigned int * indexArray,
int vertexCount,
const int * vertexIDs,
const float * vertexArray,
int normalCount,
const float ** normalArrays,
int colorCount,
const float ** colorArrays,
int texCoordCount,
const float ** texCoordArrays)
{
TRACE_API_CALLS("glGeometry");
MStatus stat = MStatus::kSuccess;
if (mGeometryShape != 0)
drawDefaultGeometry();
else
stat = draw( prim, writable, indexCount, indexArray, vertexCount,
vertexIDs, vertexArray, normalCount, normalArrays, colorCount,
colorArrays, texCoordCount, texCoordArrays);
return stat;
}
/* virtual */
MStatus
hwPhongShader::renderSwatchImage( MImage & outImage )
{
MStatus status = MStatus::kFailure;
// Get the hardware renderer utility class
MHardwareRenderer *pRenderer = MHardwareRenderer::theRenderer();
if (pRenderer)
{
const MString& backEndStr = pRenderer->backEndString();
// Get geometry
// ============
unsigned int* pIndexing = 0;
unsigned int numberOfData = 0;
unsigned int indexCount = 0;
MHardwareRenderer::GeometricShape gshape = MHardwareRenderer::kDefaultSphere;
if (mGeometryShape == 2)
{
gshape = MHardwareRenderer::kDefaultCube;
}
else if (mGeometryShape == 3)
{
gshape = MHardwareRenderer::kDefaultPlane;
}
MGeometryData* pGeomData =
pRenderer->referenceDefaultGeometry( gshape, numberOfData, pIndexing, indexCount );
if( !pGeomData )
{
return MStatus::kFailure;
}
// Make the swatch context current
// ===============================
//
unsigned int width, height;
outImage.getSize( width, height );
unsigned int origWidth = width;
unsigned int origHeight = height;
MStatus status2 = pRenderer->makeSwatchContextCurrent( backEndStr, width, height );
if( status2 == MS::kSuccess )
{
glPushAttrib ( GL_ALL_ATTRIB_BITS );
// Get camera
// ==========
{
// Get the camera frustum from the API
double l, r, b, t, n, f;
pRenderer->getSwatchOrthoCameraSetting( l, r, b, t, n, f );
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho( l, r, b, t, n, f );
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
// Rotate the cube a bit so we don't see it head on
if (gshape == MHardwareRenderer::kDefaultCube)
glRotatef( 45, 1.0, 1.0, 1.0 );
else if (gshape == MHardwareRenderer::kDefaultPlane)
glScalef( 1.5, 1.5, 1.5 );
else
glScalef( 1.0, 1.0, 1.0 );
}
// Draw The Swatch
// ===============
drawTheSwatch( pGeomData, pIndexing, numberOfData, indexCount );
// Read pixels back from swatch context to MImage
// ==============================================
pRenderer->readSwatchContextPixels( backEndStr, outImage );
// Double check the outing going image size as image resizing
// was required to properly read from the swatch context
outImage.getSize( width, height );
if (width != origWidth || height != origHeight)
{
status = MStatus::kFailure;
}
else
{
status = MStatus::kSuccess;
}
glPopAttrib();
}
else
{
pRenderer->dereferenceGeometry( pGeomData, numberOfData );
}
}
return status;
}
void
hwPhongShader::drawTheSwatch( MGeometryData* pGeomData,
unsigned int* pIndexing,
unsigned int numberOfData,
unsigned int indexCount )
{
TRACE_API_CALLS("drwaTheSwatch");
MHardwareRenderer *pRenderer = MHardwareRenderer::theRenderer();
if( !pRenderer ) return;
if ( mAttributesChanged || (phong_map_id == 0))
{
init_Phong_texture ();
}
// Get the default background color
float r, g, b, a;
MHWShaderSwatchGenerator::getSwatchBackgroundColor( r, g, b, a );
glClearColor( r, g, b, a );
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glShadeModel(GL_SMOOTH);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
CubeMapTextureDrawUtility::bind( phong_map_id );
// Draw default geometry
{
if (pGeomData)
{
glPushClientAttrib ( GL_CLIENT_VERTEX_ARRAY_BIT );
float *vertexData = (float *)( pGeomData[0].data() );
if (vertexData)
{
glEnableClientState( GL_VERTEX_ARRAY );
glVertexPointer ( 3, GL_FLOAT, 0, vertexData );
}
float *normalData = (float *)( pGeomData[1].data() );
if (normalData)
{
glEnableClientState( GL_NORMAL_ARRAY );
glNormalPointer ( GL_FLOAT, 0, normalData );
}
if (vertexData && normalData && pIndexing )
glDrawElements ( GL_TRIANGLES, indexCount, GL_UNSIGNED_INT, pIndexing );
glPopClientAttrib();
// Release data references
pRenderer->dereferenceGeometry( pGeomData, numberOfData );
}
}
CubeMapTextureDrawUtility::unbind();
}
void hwPhongShader::drawDefaultGeometry()
{
TRACE_API_CALLS("drawDefaultGeometry");
MHardwareRenderer *pRenderer = MHardwareRenderer::theRenderer();
if (!pRenderer)
return;
CubeMapTextureDrawUtility::bind( phong_map_id );
// Get default geometry
{
unsigned int numberOfData = 0;
unsigned int *pIndexing = 0;
unsigned int indexCount = 0;
MHardwareRenderer::GeometricShape gshape = MHardwareRenderer::kDefaultSphere;
if (mGeometryShape == 2)
{
gshape = MHardwareRenderer::kDefaultCube;
}
else if (mGeometryShape == 3)
{
gshape = MHardwareRenderer::kDefaultPlane;
}
// Get data references
MGeometryData * pGeomData =
pRenderer->referenceDefaultGeometry( gshape, numberOfData, pIndexing, indexCount);
if (pGeomData)
{
glPushClientAttrib ( GL_CLIENT_VERTEX_ARRAY_BIT );
float *vertexData = (float *)( pGeomData[0].data() );
if (vertexData)
{
glEnableClientState( GL_VERTEX_ARRAY );
glVertexPointer ( 3, GL_FLOAT, 0, vertexData );
}
float *normalData = (float *)( pGeomData[1].data() );
if (normalData)
{
glEnableClientState( GL_NORMAL_ARRAY );
glNormalPointer ( GL_FLOAT, 0, normalData );
}
if (vertexData && normalData && pIndexing )
glDrawElements ( GL_TRIANGLES, indexCount, GL_UNSIGNED_INT, pIndexing );
glPopClientAttrib();
// Release data references
pRenderer->dereferenceGeometry( pGeomData, numberOfData );
}
}
CubeMapTextureDrawUtility::unbind();
}
MStatus hwPhongShader::draw(int prim,
unsigned int writable,
int indexCount,
const unsigned int * indexArray,
int vertexCount,
const int * vertexIDs,
const float * vertexArray,
int normalCount,
const float ** normalArrays,
int colorCount,
const float ** colorArrays,
int texCoordCount,
const float ** texCoordArrays)
{
TRACE_API_CALLS("draw");
if ( prim != GL_TRIANGLES && prim != GL_TRIANGLE_STRIP) {
return MS::kFailure;
}
CubeMapTextureDrawUtility::bind( phong_map_id );
// Draw the surface.
//
{
bool needBlending = false;
if (mTransparency > 0.0f)
{
needBlending = true;
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f-mTransparency );
}
else
glColor4f(1.0, 1.0, 1.0, 1.0f);
glPushClientAttrib ( GL_CLIENT_VERTEX_ARRAY_BIT );
// GL_VERTEX_ARRAY does not necessarily need to be
// enabled, as it should be enabled before this routine
// is valled.
glEnableClientState( GL_VERTEX_ARRAY );
glEnableClientState( GL_NORMAL_ARRAY );
glVertexPointer ( 3, GL_FLOAT, 0, &vertexArray[0] );
glNormalPointer ( GL_FLOAT, 0, &normalArrays[0][0] );
glDrawElements ( prim, indexCount, GL_UNSIGNED_INT, indexArray );
// The client attribute is already being popped. You
// don't need to reset state here.
//glDisableClientState( GL_NORMAL_ARRAY );
//glDisableClientState( GL_VERTEX_ARRAY );
glPopClientAttrib();
if (needBlending)
{
glColor4f(1.0, 1.0, 1.0, 1.0f);
glDisable(GL_BLEND);
}
}
CubeMapTextureDrawUtility::unbind();
return MS::kSuccess;
}
/* virtual */
int hwPhongShader::normalsPerVertex()
{
TRACE_API_CALLS("normalsPerVertex");
return 1;
}
/* virtual */
int hwPhongShader::texCoordsPerVertex()
{
TRACE_API_CALLS("texCoordsPerVertex");
return 0;
}
/* virtual */
int hwPhongShader::getTexCoordSetNames(MStringArray& names)
{
return 0;
}
/* virtual */
bool hwPhongShader::hasTransparency()
{
return (mTransparency > 0.0f);
}
このトピックについてのコメントをお送りください