MFloatVector anisotropicShaderNode::calcHalfVector(
const MFloatVector& view,
const MFloatVector& light ) const
{
MFloatVector H = (light + view) / 2.0;
H.normalize();
return H;
}
//color_transform
void Ocio_log_convert::color_transform(MFloatVector& vec_input_color)
{
//pixels
float pixels[3];
vec_input_color.get(pixels);
//pixel_r, pixel_g, pixel_b;
float* pixel_r = &pixels[0];
float* pixel_g = &pixels[1];
float* pixel_b = &pixels[2];
//convert
OCIO_functionality::color_transform_single_pixel(pixel_r, pixel_g, pixel_b, processor);
//set colors back to vec_input_color
vec_input_color.x = pixels[0];
vec_input_color.y = pixels[1];
vec_input_color.z = pixels[2];
}
//
// Deform computation
//
MStatus jhMeshBlur::deform( MDataBlock& block,MItGeometry& iter,const MMatrix& m,unsigned int multiIndex)
{
MStatus returnStatus;
// Envelope
float envData = block.inputValue(envelope, &returnStatus).asFloat();
CHECK_MSTATUS(returnStatus);
if(envData == 0)
return MS::kFailure;
/*
VARIABLES
*/
//float factor = block.inputValue(aShapeFactor, &returnStatus).asFloat();
float fStrength = block.inputValue(aStrength, &returnStatus).asFloat();
CHECK_MSTATUS(returnStatus);
if (fStrength == 0)
return MS::kFailure;
float fThreshold = block.inputValue(aTreshhold, &returnStatus).asFloat();
CHECK_MSTATUS(returnStatus);
float fW = 0.0f; // weight
float fDistance;
fStrength *= envData;
double dKracht = block.inputValue(aInterpPower, &returnStatus).asDouble();
CHECK_MSTATUS(returnStatus);
double dDotProduct; // Dotproduct of the point
bool bTweakblur = block.inputValue(aTweakBlur, &returnStatus).asBool();
CHECK_MSTATUS(returnStatus);
bool bQuad = block.inputValue(aQuadInterp, &returnStatus).asBool();
CHECK_MSTATUS(returnStatus);
MTime inTime = block.inputValue(aTime).asTime();
int nTijd = (int)inTime.as(MTime::kFilm);
MFloatVectorArray currentNormals; // normals of mesh
MFnPointArrayData fnPoints; // help converting to MPointArrays
MFloatVector dirVector; // direction vector of the point
MFloatVector normal; // normal of the point
MPointArray savedPoints; // save all point before edited
MMatrix matInv = m.inverse(); // inversed matrix
MPoint ptA; // current point (iter mesh)
MPoint ptB; // previous point (iter mesh)
MPoint ptC; // mesh before previous point (iter mesh)
// get node, use node to get inputGeom, use inputGeom to get mesh data, use mesh data to get normal data
MFnDependencyNode nodeFn(this->thisMObject());
MPlug inGeomPlug(nodeFn.findPlug(this->inputGeom,true));
MObject inputObject(inGeomPlug.asMObject());
MFnMesh inMesh(inputObject);
inMesh.getVertexNormals(true, currentNormals);
// get the previous mesh data
MPlug oldMeshPlug = nodeFn.findPlug(MString("oldMesh"));
MPlug oldMeshPositionsAPlug = oldMeshPlug.elementByLogicalIndex((multiIndex*4) + 0);
MPlug oldMeshPositionsBPlug = oldMeshPlug.elementByLogicalIndex((multiIndex*4) + 1);
MPlug oldMeshPositionsCPlug = oldMeshPlug.elementByLogicalIndex((multiIndex*4) + 2); // cache for tweak mode
MPlug oldMeshPositionsDPlug = oldMeshPlug.elementByLogicalIndex((multiIndex*4) + 3); // cache for tweak mode
// convert to MPointArrays
MObject objOldMeshA;
MObject objOldMeshB;
MObject objOldMeshC; // cache
MObject objOldMeshD; // cache
oldMeshPositionsAPlug.getValue(objOldMeshA);
oldMeshPositionsBPlug.getValue(objOldMeshB);
oldMeshPositionsCPlug.getValue(objOldMeshC); // cache
oldMeshPositionsDPlug.getValue(objOldMeshD); // cache
fnPoints.setObject(objOldMeshA);
MPointArray oldMeshPositionsA = fnPoints.array();
fnPoints.setObject(objOldMeshB);
MPointArray oldMeshPositionsB = fnPoints.array();
fnPoints.setObject(objOldMeshC);
MPointArray oldMeshPositionsC = fnPoints.array(); // cache
fnPoints.setObject(objOldMeshD);
MPointArray oldMeshPositionsD = fnPoints.array(); // cache
// If mesh position variables are empty,fill them with default values
if(oldMeshPositionsA.length() == 0 || nTijd <= 1){
iter.allPositions(oldMeshPositionsA);
for(int i=0; i < oldMeshPositionsA.length(); i++)
{
// convert to world
oldMeshPositionsA[i] = oldMeshPositionsA[i] * m;
}
oldMeshPositionsB.copy(oldMeshPositionsA);
oldMeshPositionsC.copy(oldMeshPositionsA); // cache
oldMeshPositionsD.copy(oldMeshPositionsA); // cache
}
// get back old date again
if (bTweakblur == true) { // restore cache
oldMeshPositionsA.copy(oldMeshPositionsC);
oldMeshPositionsB.copy(oldMeshPositionsD);
}
iter.allPositions(savedPoints);
for(int i=0; i < savedPoints.length(); i++)
{
// convert points to world points
savedPoints[i] = savedPoints[i] * m;
}
// Actual Iteration through points
for (; !iter.isDone(); iter.next()){
// get current position
ptA = iter.position();
// get old positions
ptB = oldMeshPositionsA[iter.index()] * matInv;
ptC = oldMeshPositionsB[iter.index()] * matInv;
fDistance = ptA.distanceTo(ptB);
fW = weightValue(block,multiIndex,iter.index());
if (fDistance * (fStrength*fW) < fThreshold && fThreshold > 0){
iter.setPosition(ptA);
} else {
// aim/direction vector to calculate strength
dirVector = (ptA - ptB); // (per punt)
dirVector.normalize();
normal = currentNormals[iter.index()];
dDotProduct = normal.x * dirVector.x + normal.y * dirVector.y + normal.z * dirVector.z;
if(bQuad == true){
MVector vecA(((ptB - ptC) + (ptA - ptB)) / 2);
vecA.normalize();
MPoint hiddenPt(ptB + (vecA * fDistance) * dKracht);
ptA = quadInterpBetween(ptB, hiddenPt, ptA, (1 - fStrength * fW) + (linearInterp(dDotProduct, -1, 1) * (fStrength * fW) ) );
} else {
MPoint halfway = (ptA - ptB) * 0.5;
MPoint offset = halfway * dDotProduct * (fStrength*fW);
ptA = ptA - ((halfway * (fStrength*fW)) - offset); // + (offset * strength);
}
// set new value
iter.setPosition(ptA);
}
}
if(bTweakblur == false){
oldMeshPositionsD.copy(oldMeshPositionsB);
oldMeshPositionsC.copy(oldMeshPositionsA);
oldMeshPositionsB.copy(oldMeshPositionsA);
oldMeshPositionsA.copy(savedPoints);
// Save back to plugs
objOldMeshA = fnPoints.create(oldMeshPositionsA);
objOldMeshB = fnPoints.create(oldMeshPositionsB);
objOldMeshC = fnPoints.create(oldMeshPositionsC);
objOldMeshD = fnPoints.create(oldMeshPositionsD);
oldMeshPositionsAPlug.setValue(objOldMeshA);
oldMeshPositionsBPlug.setValue(objOldMeshB);
oldMeshPositionsCPlug.setValue(objOldMeshC);
oldMeshPositionsDPlug.setValue(objOldMeshD);
}
return returnStatus;
}
//
// DESCRIPTION:
///////////////////////////////////////////////////////
MStatus PhongNode::compute(
const MPlug& plug,
MDataBlock& block )
{
if ((plug != aOutColor) && (plug.parent() != aOutColor))
return MS::kUnknownParameter;
MFloatVector resultColor(0.0,0.0,0.0);
// get sample surface shading parameters
MFloatVector& surfaceNormal = block.inputValue( aNormalCamera ).asFloatVector();
MFloatVector& cameraPosition = block.inputValue( aPointCamera ).asFloatVector();
// use for raytracing api enhancement below
MFloatVector point = cameraPosition;
MFloatVector normal = surfaceNormal;
MFloatVector& surfaceColor = block.inputValue( aColor ).asFloatVector();
MFloatVector& incandescence = block.inputValue( aIncandescence ).asFloatVector();
float diffuseReflectivity = block.inputValue( aDiffuseReflectivity ).asFloat();
// float translucenceCoeff = block.inputValue( aTranslucenceCoeff ).asFloat();
// User-defined Reflection Color Gain
float reflectGain = block.inputValue( aReflectGain ).asFloat();
// Phong shading attributes
float power = block.inputValue( aPower ).asFloat();
float spec = block.inputValue( aSpecularity ).asFloat();
float specularR, specularG, specularB;
float diffuseR, diffuseG, diffuseB;
diffuseR = diffuseG = diffuseB = specularR = specularG = specularB = 0.0;
// get light list
MArrayDataHandle lightData = block.inputArrayValue( aLightData );
int numLights = lightData.elementCount();
// iterate through light list and get ambient/diffuse values
for( int count=1; count <= numLights; count++ )
{
MDataHandle currentLight = lightData.inputValue();
MFloatVector& lightIntensity = currentLight.child(aLightIntensity).asFloatVector();
// Find the blind data
void*& blindData = currentLight.child( aLightBlindData ).asAddr();
// find ambient component
if( currentLight.child(aLightAmbient).asBool() ) {
diffuseR += lightIntensity[0];
diffuseG += lightIntensity[1];
diffuseB += lightIntensity[2];
}
MFloatVector& lightDirection = currentLight.child(aLightDirection).asFloatVector();
if ( blindData == NULL )
{
// find diffuse and specular component
if( currentLight.child(aLightDiffuse).asBool() )
{
float cosln = lightDirection * surfaceNormal;;
if( cosln > 0.0f ) // calculate only if facing light
{
diffuseR += lightIntensity[0] * ( cosln * diffuseReflectivity );
diffuseG += lightIntensity[1] * ( cosln * diffuseReflectivity );
diffuseB += lightIntensity[2] * ( cosln * diffuseReflectivity );
}
CHECK_MSTATUS( cameraPosition.normalize() );
if( cosln > 0.0f ) // calculate only if facing light
{
float RV = ( ( (2*surfaceNormal) * cosln ) - lightDirection ) * cameraPosition;
if( RV > 0.0 ) RV = 0.0;
if( RV < 0.0 ) RV = -RV;
if ( power < 0 ) power = -power;
float s = spec * powf( RV, power );
specularR += lightIntensity[0] * s;
specularG += lightIntensity[1] * s;
specularB += lightIntensity[2] * s;
}
}
}
else
{
float cosln = MRenderUtil::diffuseReflectance( blindData, lightDirection, point, surfaceNormal, true );
if( cosln > 0.0f ) // calculate only if facing light
{
diffuseR += lightIntensity[0] * ( cosln * diffuseReflectivity );
diffuseG += lightIntensity[1] * ( cosln * diffuseReflectivity );
diffuseB += lightIntensity[2] * ( cosln * diffuseReflectivity );
}
CHECK_MSTATUS ( cameraPosition.normalize() );
if ( currentLight.child(aLightSpecular).asBool() )
{
MFloatVector specLightDirection = lightDirection;
MDataHandle directionH = block.inputValue( aRayDirection );
MFloatVector direction = directionH.asFloatVector();
float lightAttenuation = 1.0;
specLightDirection = MRenderUtil::maximumSpecularReflection( blindData,
lightDirection, point, surfaceNormal, direction );
lightAttenuation = MRenderUtil::lightAttenuation( blindData, point, surfaceNormal, false );
// Are we facing the light
if ( specLightDirection * surfaceNormal > 0.0f )
{
float power2 = block.inputValue( aPower ).asFloat();
MFloatVector rv = 2 * surfaceNormal * ( surfaceNormal * direction ) - direction;
float s = spec * powf( rv * specLightDirection, power2 );
specularR += lightIntensity[0] * s * lightAttenuation;
specularG += lightIntensity[1] * s * lightAttenuation;
specularB += lightIntensity[2] * s * lightAttenuation;
}
}
}
if( !lightData.next() ) break;
}
// factor incident light with surface color and add incandescence
resultColor[0] = ( diffuseR * surfaceColor[0] ) + specularR + incandescence[0];
resultColor[1] = ( diffuseG * surfaceColor[1] ) + specularG + incandescence[1];
resultColor[2] = ( diffuseB * surfaceColor[2] ) + specularB + incandescence[2];
// add the reflection color
if (reflectGain > 0.0) {
MStatus status;
// required attributes for using raytracer
// origin, direction, sampler, depth, and object id.
//
MDataHandle originH = block.inputValue( aRayOrigin, &status);
MFloatVector origin = originH.asFloatVector();
MDataHandle directionH = block.inputValue( aRayDirection, &status);
MFloatVector direction = directionH.asFloatVector();
MDataHandle samplerH = block.inputValue( aRaySampler, &status);
void*& samplerPtr = samplerH.asAddr();
MDataHandle depthH = block.inputValue( aRayDepth, &status);
short depth = depthH.asShort();
MDataHandle objH = block.inputValue( aObjectId, &status);
void*& objId = objH.asAddr();
MFloatVector reflectColor;
MFloatVector reflectTransparency;
MFloatVector& triangleNormal = block.inputValue( aTriangleNormalCamera ).asFloatVector();
// compute reflected ray
MFloatVector l = -direction;
float dot = l * normal;
if( dot < 0.0 ) dot = -dot;
MFloatVector refVector = 2 * normal * dot - l; // reflection ray
float dotRef = refVector * triangleNormal;
if( dotRef < 0.0 ) {
const float s = 0.01f;
MFloatVector mVec = refVector - dotRef * triangleNormal;
mVec.normalize();
refVector = mVec + s * triangleNormal;
}
CHECK_MSTATUS ( refVector.normalize() );
status = MRenderUtil::raytrace(
point, // origin
refVector, // direction
objId, // object id
samplerPtr, // sampler info
depth, // ray depth
reflectColor, // output color and transp
reflectTransparency);
// add in the reflection color
resultColor[0] += reflectGain * (reflectColor[0]);
resultColor[1] += reflectGain * (reflectColor[1]);
resultColor[2] += reflectGain * (reflectColor[2]);
}
// set ouput color attribute
MDataHandle outColorHandle = block.outputValue( aOutColor );
MFloatVector& outColor = outColorHandle.asFloatVector();
outColor = resultColor;
outColorHandle.setClean();
return MS::kSuccess;
}
MStatus anisotropicShaderNode::compute( const MPlug& plug, MDataBlock& block )
{
if ((plug == aOutColor) || (plug.parent() == aOutColor))
{
MFloatVector resultColor(0.0,0.0,0.0);
MFloatVector diffuseColor( 0.0,0.0,0.0 );
MFloatVector specularColor( 0.0,0.0,0.0 );
MFloatVector ambientColor( 0.0,0.0,0.0 );
// get matrix
MFloatMatrix& matrixOToW = block.inputValue( aMatrixOToW ).asFloatMatrix();
MFloatMatrix& matrixWToC = block.inputValue( aMatrixWToC ).asFloatMatrix();
// spin scratch around this vector (in object space )
MFloatVector& A = block.inputValue( aAxesVector ).asFloatVector();
A.normalize();
// spin scratch around this vector (in world space )
MFloatVector wa = A * matrixOToW;
wa.normalize();
// spin scratch around this vector (in camera space )
MFloatVector ca = wa * matrixWToC;
ca.normalize();
MFloatVector& surfacePoint = block.inputValue( aPointCamera ).asFloatVector();
// get sample surface shading parameters
MFloatVector& N = block.inputValue( aNormalCamera ).asFloatVector();
MFloatVector& surfaceColor = block.inputValue( aColor ).asFloatVector();
float diffuseReflectivity = block.inputValue( aDiffuseReflectivity ).asFloat();
float specularCoeff = block.inputValue( aSpecularCoeff ).asFloat();
// get light list
MArrayDataHandle lightData = block.inputArrayValue( aLightData );
int numLights = lightData.elementCount();
// iterate through light list and get ambient/diffuse values
for( int count=0; count < numLights; count++ ) {
MDataHandle currentLight = lightData.inputValue();
MFloatVector& lightIntensity =
currentLight.child( aLightIntensity ).asFloatVector();
MFloatVector& lightDirection =
currentLight.child( aLightDirection ).asFloatVector();
// find ambient component
if( currentLight.child(aLightAmbient).asBool()) {
ambientColor[0] += lightIntensity[0] * surfaceColor[0];
ambientColor[1] += lightIntensity[1] * surfaceColor[1];
ambientColor[2] += lightIntensity[2] * surfaceColor[2];
}
float cosln = lightDirection * N;
if( cosln > 0.0f ){ // illuminated!
// find diffuse component
if( currentLight.child(aLightDiffuse).asBool()) {
float cosDif = cosln * diffuseReflectivity;
diffuseColor[0] += lightIntensity[0] * cosDif * surfaceColor[0];
diffuseColor[1] += lightIntensity[1] * cosDif * surfaceColor[1];
diffuseColor[2] += lightIntensity[2] * cosDif * surfaceColor[2];
}
// find specular component
if( currentLight.child( aLightSpecular).asBool()){
MFloatVector& rayDirection = block.inputValue( aRayDirection ).asFloatVector();
MFloatVector viewDirection = -rayDirection;
MFloatVector half = calcHalfVector( viewDirection, lightDirection );
// Beckmann function
MFloatVector nA;
if( fabs(1.0-fabs(N*ca)) <= 0.0001f ){
MFloatPoint oo( 0.0,0.0,0.0 );
MFloatPoint ow = oo * matrixOToW;
MFloatPoint oc = ow * matrixWToC;
MFloatVector origin( oc[0], oc[1], oc[2] );
nA = origin - surfacePoint;
nA.normalize();
}else{
nA = ca;
}
MFloatVector x = N ^ nA;
x.normalize();
MFloatVector y = N ^ x;
y.normalize();
MFloatVector azimuthH = N ^ half;
azimuthH = N ^ azimuthH;
azimuthH.normalize();
float cos_phai = x * azimuthH;
float sin_phai = 0.0;
if( fabs(1 - cos_phai*cos_phai) < 0.0001 ){
sin_phai = 0.0;
}else{
sin_phai = sqrtf( 1.0f - cos_phai*cos_phai );
}
double co = pow( (half * N), 4.0f );
double t = tan( acos(half*N) );
t *= -t;
float rough1 = block.inputValue( aRoughness1 ).asFloat();
float rough2 = block.inputValue( aRoughness2 ).asFloat();
double aaa = cos_phai / rough1;
double bbb = sin_phai / rough2;
t = t * ( aaa*aaa + bbb*bbb );
double D = pow( (1.0/((double)rough1*(double)rough2 * co)), t );
double aa = (2.0 * (N*half) * (N*viewDirection) ) / (viewDirection*half);
double bb = (2.0 * (N*half) * (N*lightDirection) ) / (viewDirection*half);
double cc = 1.0;
double G = 0.0;
G = MIN( aa, bb );
G = MIN( G, cc );
float s = (float) (D * G /
(double)((N*lightDirection) * (N*viewDirection)));
MFloatVector& specColor = block.inputValue( aSpecColor ).asFloatVector();
specularColor[0] += lightIntensity[0] * specColor[0] *
s * specularCoeff;
specularColor[1] += lightIntensity[1] * specColor[1] *
s * specularCoeff;
specularColor[2] += lightIntensity[2] * specColor[2] *
s * specularCoeff;
}
}
if( !lightData.next() ){
break;
}
}
// result = specular + diffuse + ambient;
resultColor = diffuseColor + specularColor + ambientColor;
MFloatVector& transparency = block.inputValue( aInTransparency ).asFloatVector();
resultColor[0] *= ( 1.0f - transparency[0] );
resultColor[1] *= ( 1.0f - transparency[1] );
resultColor[2] *= ( 1.0f - transparency[2] );
// set ouput color attribute
MDataHandle outColorHandle = block.outputValue( aOutColor );
MFloatVector& outColor = outColorHandle.asFloatVector();
outColor = resultColor;
outColorHandle.setClean();
block.setClean( plug );
}
else if ((plug == aOutTransparency) || (plug.parent() == aOutTransparency))
{
MFloatVector& tr = block.inputValue( aInTransparency ).asFloatVector();
// set ouput color attribute
MDataHandle outTransHandle = block.outputValue( aOutTransparency );
MFloatVector& outTrans = outTransHandle.asFloatVector();
outTrans = tr;
block.setClean( plug );
} else
return MS::kUnknownParameter;
return MS::kSuccess;
}
//CURRENTLY ONLY SAVING THE MOST RELEVANT DATA
void Exporter::extractCamera(MObject& cam)
{
MSpace::Space world_space = MSpace::kWorld;
MSpace::Space transform_space = MSpace::kTransform;
//Temp storage for camera
cameraData TempCameraStorage;
//Create a fucntion set for the camera
MFnCamera fn(cam);
//Ignore orthographic cameras. Top, right, left....
if (fn.isOrtho())
return;
//attach a function set to the parent transform
MFnDependencyNode fnParent(fn.parent(0));
//Output some camera info
std::cout << "Camera: " << fn.name().asChar()
<< "\n\tparent "
<< fnParent.name().asChar()
<< std::endl;
//Get Transform experimentation
MFnTransform fs(fn.parent(0));
MMatrix matrix = fs.transformation().asMatrix();
std::cout << "\nTransform Matrix: " << matrix << std::endl;
TempCameraStorage.transformMatrix = matrix;
//aspect ratio
std::cout << "\nAspect ratio: " << fn.aspectRatio()
<< std::endl;
TempCameraStorage.aspectRatio = fn.aspectRatio();
//near clipping plane
std::cout << "\nNear: : " << fn.nearClippingPlane()
<< std::endl;
TempCameraStorage.nearClippingPlane = fn.nearClippingPlane();
//far clipping plane
std::cout << "\nFar: " << fn.farClippingPlane()
<< std::endl;
TempCameraStorage.farClippingPlane = fn.farClippingPlane();
//horizontal field of view
std::cout << "\nHorizontal fov: " << fn.horizontalFieldOfView()
<< std::endl;
//vertical field of view
std::cout << "\nVertical fov: " << fn.verticalFieldOfView()
<< std::endl;
TempCameraStorage.verticalFieldOfView = fn.verticalFieldOfView();
//badly formated Projection matrix
std::cout << "\nProjectionMatrix: " << fn.projectionMatrix()
<< std::endl;
TempCameraStorage.projectionMatrix = fn.projectionMatrix();
MFloatMatrix modelMatrix = fs.transformation().asMatrix().matrix;
MFloatVector direction = modelMatrix * (MFloatVector)fn.viewDirection();
direction.normalize();
direction.x *= -1.0f;
direction.y *= -1.0f;
//Up direction
std::cout << "\nUp Vector: " << fn.upDirection()
<< std::endl;
TempCameraStorage.upVector = fn.upDirection();
//view direction
std::cout << "\nView Direction: " << direction
<< std::endl;
TempCameraStorage.viewDirection = direction;
/*
MQuaternion rotation;
MEulerRotation eulerRotation1;
fs.getRotation(rotation, transform_space);
fs.getRotation(eulerRotation1);
MEulerRotation eulerRotation2 = rotation.asEulerRotation(); // samma som eulerRotation1
*/
TempCameraStorage.position = fs.translation(transform_space);
//pushback to store everything
scene_.cameras.push_back(TempCameraStorage);
}
