void ProxyViz::updateViewFrustum(const MDagPath & cameraPath)
{
MMatrix cameraMat = cameraPath.inclusiveMatrix();
AHelper::ConvertToMatrix44F(*cameraSpaceR(), cameraMat);
MMatrix cameraInvMat = cameraPath.inclusiveMatrixInverse();
AHelper::ConvertToMatrix44F(*cameraInvSpaceR(), cameraInvMat);
float peye[3];
peye[0] = cameraMat.matrix[3][0];
peye[1] = cameraMat.matrix[3][1];
peye[2] = cameraMat.matrix[3][2];
setEyePosition(peye);
float farClip = -20.f;
if(numPlants() > 0) getFarClipDepth(farClip, gridBoundingBox() );
MFnCamera fcam(cameraPath.node() );
if(fcam.isOrtho() ) {
float orthoW = fcam.orthoWidth();
float orthoH = orthoW * fcam.aspectRatio();
setOrthoFrustum(orthoW, orthoH, -10.f, farClip );
} else {
float hfa = fcam.horizontalFilmAperture();
float vfa = fcam.verticalFilmAperture();
float fl = fcam.focalLength();
setFrustum(hfa, vfa, fl, -10.f, farClip );
}
setOverscan(fcam.overscan() );
}
void ProxyViz::updateWorldSpace(const MObject & thisNode)
{
MDagPath thisPath;
MDagPath::getAPathTo(thisNode, thisPath);
_worldSpace = thisPath.inclusiveMatrix();
_worldInverseSpace = thisPath.inclusiveMatrixInverse();
}
MStatus V3Manipulator::connectToDependNode( const MObject & node )
{
MFnDagNode dagFn( node );
MDagPath nodePath;
dagFn.getPath( nodePath );
MStatus status;
m_translatePlug = dagFn.findPlug( m_plug.partialName(), &status );
if( !status )
{
return MStatus::kFailure;
}
MFnFreePointTriadManip translateFn( m_translateManip );
translateFn.connectToPointPlug( m_translatePlug );
addManipToPlugConversionCallback( m_translatePlug, (manipToPlugConversionCallback)&V3Manipulator::vectorManipToPlugConversion );
addPlugToManipConversionCallback( translateFn.pointIndex(), (plugToManipConversionCallback)&V3Manipulator::vectorPlugToManipConversion );
MStatus stat = finishAddingManips();
if( stat == MStatus::kFailure )
{
return MStatus::kFailure;
}
MPxManipContainer::connectToDependNode( node );
readParameterOptions( dagFn );
if( m_worldSpace)
{
m_localMatrix.setToIdentity();
m_localMatrixInv.setToIdentity();
}
else
{
// Inherit any transform to the parent
MDagPath transformPath = nodePath;
transformPath.pop();
MFnTransform transformFn( transformPath );
m_localMatrix = transformPath.inclusiveMatrix();
m_localMatrixInv = transformPath.inclusiveMatrixInverse();
}
return stat;
}
MStatus BCIViz::compute( const MPlug& plug, MDataBlock& block )
{
if( plug == outValue ) {
MStatus status;
MDagPath path;
MDagPath::getAPathTo(thisMObject(), path);
MMatrix worldInverseSpace = path.inclusiveMatrixInverse();
MDataHandle inputdata = block.inputValue(ainput, &status);
if(status) {
const MMatrix drvSpace = inputdata.asMatrix();
fDriverPos.x = drvSpace(3, 0);
fDriverPos.y = drvSpace(3, 1);
fDriverPos.z = drvSpace(3, 2);
fDriverPos *= worldInverseSpace;
}
fTargetPositions.clear();
MArrayDataHandle htarget = block.inputArrayValue( atargets );
unsigned numTarget = htarget.elementCount();
fTargetPositions.setLength(numTarget);
for(unsigned i = 0; i<numTarget; i++) {
MDataHandle tgtdata = htarget.inputValue(&status);
if(status) {
const MMatrix tgtSpace = tgtdata.asMatrix();
MPoint tgtPos(tgtSpace(3,0), tgtSpace(3,1), tgtSpace(3,2));
tgtPos *= worldInverseSpace;
MVector disp = tgtPos;
disp.normalize();
tgtPos = disp;
fTargetPositions[i] = tgtPos;
}
htarget.next();
}
m_hitTriangle = 0;
neighbourId[0] = 0;
neighbourId[1] = 1;
neighbourId[2] = 2;
if(!checkTarget())
{
MGlobal::displayWarning("convex hull must have no less than 4 targes.");
return MS::kSuccess;
}
if(!checkFirstFour(fTargetPositions))
{
MGlobal::displayWarning("first 4 targes cannot sit on the same plane.");
return MS::kSuccess;
}
if(!constructHull())
{
MGlobal::displayWarning("convex hull failed on construction.");
return MS::kSuccess;
}
findNeighbours();
calculateWeight();
MArrayDataHandle outputHandle = block.outputArrayValue( outValue );
int numWeight = fTargetPositions.length();
m_resultWeights.setLength(numWeight);
for(int i=0; i < numWeight; i++)
m_resultWeights[i] = 0.0;
m_resultWeights[neighbourId[0]] = fAlpha;
m_resultWeights[neighbourId[1]] = fBeta;
m_resultWeights[neighbourId[2]] = fGamma;
MArrayDataBuilder builder(outValue, numWeight, &status);
for(int i=0; i < numWeight; i++) {
MDataHandle outWeightHandle = builder.addElement(i);
outWeightHandle.set( m_resultWeights[i] );
//MGlobal::displayInfo(MString("wei ") + i + " " + weights[i]);
}
outputHandle.set(builder);
outputHandle.setAllClean();
}
return MS::kSuccess;
}
/* virtual */
MStatus hwDecalBumpShader_NV20::bind(const MDrawRequest& request, M3dView& view)
{
MStatus status;
// Get the diffuse color
//
float diffuse_color[4];
status = getFloat3(color, diffuse_color);
diffuse_color[3] = 1.0;
if (!status)
return status;
// Get the light color
//
float light_color[4];
light_color[3] = 1.0f;
status = getFloat3(lightColor, light_color);
if (!status)
return status;
// Get the light direction (for directionalLight)
//
status = getFloat3(light, &lightRotation[0]);
if (!status)
return status;
// Get the bumpScale value
//
float bumpScaleValue = 2.0f;
// Get the bumpMap type
//
bool isHeightFieldMap = true;
// Direction of the directional light
//
// Convert the light direction (which is assumed in originally be in world space, in euler coordinates)
// into an eye space vector.
//
double scale = M_PI/180.0; // Internal rotations are in radian and not in degrees
MEulerRotation lightRot( lightRotation[0] * scale, lightRotation[1] * scale, lightRotation[2] * scale );
MVector light_v = MVector(0, 0, -1).rotateBy( lightRot ); // WS light vector
MDagPath camDag;
view.getCamera(camDag);
light_v = light_v * camDag.inclusiveMatrixInverse();
lightRotation[0] = (float) light_v[0];
lightRotation[1] = (float) light_v[1];
lightRotation[2] = (float) light_v[2];
// Get the camera position
//
status = getFloat3(camera, &cameraPos[0]);
if (!status)
return status;
// Get the decal and bump map file names
//
MString decalName = "";
MString bumpName = "";
ShadingConnection colorConnection(thisMObject(), request.multiPath().partialPathName(), "color");
ShadingConnection bumpConnection (thisMObject(), request.multiPath().partialPathName(), "bump");
// If the color attribute is ultimately connected to a file texture, find its filename.
// otherwise use the default color texture.
if (colorConnection.type() == ShadingConnection::TEXTURE &&
colorConnection.texture().hasFn(MFn::kFileTexture))
{
// Get the filename of the texture.
MFnDependencyNode textureNode(colorConnection.texture());
MPlug filenamePlug( colorConnection.texture(), textureNode.attribute(MString("fileTextureName")) );
filenamePlug.getValue(decalName);
}
// If the bump attribute is ultimately connected to a file texture, find its filename.
// otherwise use the default bump texture.
if (bumpConnection.type() == ShadingConnection::TEXTURE &&
bumpConnection.texture().hasFn(MFn::kFileTexture))
{
// Get the filename of the texture.
MFnDependencyNode textureNode(colorConnection.texture());
MPlug filenamePlug( bumpConnection.texture(), textureNode.attribute(MString("fileTextureName")) );
filenamePlug.getValue(bumpName);
}
// Fail safe quit
//
if (bumpName.length() == 0 ||
decalName.length() == 0)
{
view.beginGL();
glPushAttrib( GL_ALL_ATTRIB_BITS ); // This might be too conservative
glPushClientAttrib(GL_CLIENT_VERTEX_ARRAY_BIT);
glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
glEnable(GL_COLOR_MATERIAL);
glColor4fv(diffuse_color);
view.endGL();
return MS::kSuccess;
}
view.beginGL();
glPushAttrib( GL_ALL_ATTRIB_BITS );
glPushClientAttrib(GL_CLIENT_VERTEX_ARRAY_BIT);
/* Starts Here... */
glEnable(GL_TEXTURE_SHADER_NV);
// stage 0 -- decal map
glActiveTextureARB( GL_TEXTURE0_ARB );
if(m_pTextureCache)
m_pTextureCache->bind(colorConnection.texture(), MTexture::RGBA, false);
glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_2D);
// stage 1 -- bumpped normal map
glActiveTextureARB( GL_TEXTURE1_ARB );
// We need to be able to pass the bumpScaleValue
// to the texture cache and rebuild the bump or normal map
if( isHeightFieldMap ) {
// convert the HeightField to the NormalMap
if(m_pTextureCache)
m_pTextureCache->bind(bumpConnection.texture(), MTexture::NMAP, false);
}
else {
if(m_pTextureCache)
m_pTextureCache->bind(bumpConnection.texture(), MTexture::RGBA, false);
}
glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_2D);
// stage 2 -- dot product (diffuse component)
glActiveTextureARB( GL_TEXTURE2_ARB );
glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_DOT_PRODUCT_NV);
glTexEnvi(GL_TEXTURE_SHADER_NV, GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV, GL_EXPAND_NORMAL_NV);
glTexEnvi(GL_TEXTURE_SHADER_NV, GL_PREVIOUS_TEXTURE_INPUT_NV, GL_TEXTURE1_ARB);
// stage 3 -- dot product (specular component)
glActiveTextureARB( GL_TEXTURE3_ARB );
bind_lookup_table(); // 2D texture to get the diffuse and specular illumination
glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_DOT_PRODUCT_TEXTURE_2D_NV);
glTexEnvi(GL_TEXTURE_SHADER_NV, GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV, GL_EXPAND_NORMAL_NV);
glTexEnvi(GL_TEXTURE_SHADER_NV, GL_PREVIOUS_TEXTURE_INPUT_NV, GL_TEXTURE1_ARB);
// With light color and intensity
//
glCombinerParameterfvNV(GL_CONSTANT_COLOR0_NV, diffuse_color);
glCombinerParameterfvNV(GL_CONSTANT_COLOR1_NV, light_color);
// The register combiner will do the multiplication between
// the illumination and the decal color
//
glEnable(GL_REGISTER_COMBINERS_NV);
#ifndef DEBUGGING_VERTEX_PROGRAM
glCombinerParameteriNV(GL_NUM_GENERAL_COMBINERS_NV, 2);
#else
// For testing, only use one general register combiner.
glCombinerParameteriNV(GL_NUM_GENERAL_COMBINERS_NV, 1);
#endif
float constColor0[4];
constColor0[0] = constColor0[1] = constColor0[2] = constColor0[3] = 1.0;
glCombinerParameterfvNV(GL_CONSTANT_COLOR0_NV, constColor0);
#ifndef DEBUGGING_VERTEX_PROGRAM
// Combiner stage 0 does the illumination modulation on the surface decal color
//
glCombinerInputNV(GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_A_NV, GL_TEXTURE0_ARB, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glCombinerInputNV(GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_B_NV, GL_TEXTURE3_ARB, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glCombinerInputNV(GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_C_NV, GL_TEXTURE0_ARB, GL_UNSIGNED_IDENTITY_NV, GL_ALPHA);
glCombinerInputNV(GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_D_NV, GL_TEXTURE3_ARB, GL_UNSIGNED_IDENTITY_NV, GL_ALPHA);
glCombinerOutputNV(GL_COMBINER0_NV, GL_RGB, GL_DISCARD_NV, GL_DISCARD_NV, GL_SPARE1_NV,
GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE);
// Combiner stage 1, modulate the surface color by the light color
//
glCombinerInputNV(GL_COMBINER1_NV, GL_RGB, GL_VARIABLE_A_NV, GL_SPARE1_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glCombinerInputNV(GL_COMBINER1_NV, GL_RGB, GL_VARIABLE_B_NV, GL_CONSTANT_COLOR1_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glCombinerOutputNV(GL_COMBINER1_NV, GL_RGB, GL_DISCARD_NV, GL_DISCARD_NV, GL_SPARE1_NV,
GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE);
#else
// Simplified register combiners to help debugging vertex program.
glCombinerInputNV(GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_A_NV, GL_PRIMARY_COLOR_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glCombinerInputNV(GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_B_NV, GL_CONSTANT_COLOR0_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glCombinerInputNV(GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_C_NV, GL_TEXTURE0_ARB, GL_UNSIGNED_IDENTITY_NV, GL_ALPHA);
glCombinerInputNV(GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_D_NV, GL_TEXTURE3_ARB, GL_UNSIGNED_IDENTITY_NV, GL_ALPHA);
glCombinerOutputNV(GL_COMBINER0_NV, GL_RGB, GL_SPARE1_NV, GL_DISCARD_NV, GL_DISCARD_NV,
GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE);
#endif // DEBUGGING_VERTEX_PROGRAM
// The final Combiner just pass through
//
glFinalCombinerInputNV(GL_VARIABLE_A_NV, GL_ZERO, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glFinalCombinerInputNV(GL_VARIABLE_B_NV, GL_ZERO, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glFinalCombinerInputNV(GL_VARIABLE_C_NV, GL_ZERO, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glFinalCombinerInputNV(GL_VARIABLE_D_NV, GL_SPARE1_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
view.endGL();
return MS::kSuccess;
}
