//-----------------------------------------------------------------------
void DualQuaternionSkinning::addIndexedPositionWeight(Function* vsMain, int index,
ParameterPtr& pWorldMatrix, ParameterPtr& pPositionTempParameter,
ParameterPtr& pPositionRelatedOutputParam, int& funcCounter)
{
Operand::OpMask indexMask = indexToMask(index);
FunctionInvocation* curFuncInvocation;
//multiply position with world matrix and put into temporary param
curFuncInvocation = OGRE_NEW FunctionInvocation(SGX_FUNC_BLEND_WEIGHT, FFP_VS_TRANSFORM, funcCounter++);
curFuncInvocation->pushOperand(mParamInWeights, Operand::OPS_IN, indexMask);
curFuncInvocation->pushOperand(pWorldMatrix, Operand::OPS_IN);
curFuncInvocation->pushOperand(pPositionTempParameter, Operand::OPS_OUT);
vsMain->addAtomInstance(curFuncInvocation);
//check if on first iteration
if (index == 0)
{
//set the local param as the value of the world param
curFuncInvocation = OGRE_NEW FunctionInvocation(FFP_FUNC_ASSIGN, FFP_VS_TRANSFORM, funcCounter++);
curFuncInvocation->pushOperand(pPositionTempParameter, Operand::OPS_IN);
curFuncInvocation->pushOperand(pPositionRelatedOutputParam, Operand::OPS_OUT);
vsMain->addAtomInstance(curFuncInvocation);
}
else
{
//add the local param as the value of the world param
curFuncInvocation = OGRE_NEW FunctionInvocation(FFP_FUNC_ADD, FFP_VS_TRANSFORM, funcCounter++);
curFuncInvocation->pushOperand(pPositionTempParameter, Operand::OPS_IN);
curFuncInvocation->pushOperand(pPositionRelatedOutputParam, Operand::OPS_IN);
curFuncInvocation->pushOperand(pPositionRelatedOutputParam, Operand::OPS_OUT);
vsMain->addAtomInstance(curFuncInvocation);
}
}
//-----------------------------------------------------------------------
void HardwareSkinning::addIndexedPositionWeight(Function* vsMain,
int index, int& funcCounter)
{
Operand::OpMask indexMask = indexToMask(index);
FunctionInvocation* curFuncInvocation;
//multiply position with world matrix and put into temporary param
curFuncInvocation = OGRE_NEW FunctionInvocation(FFP_FUNC_TRANSFORM, FFP_VS_TRANSFORM, funcCounter++);
curFuncInvocation->pushOperand(mParamInWorldMatrices, Operand::OPS_IN);
curFuncInvocation->pushOperand(mParamInIndices, Operand::OPS_IN, indexMask, 1);
curFuncInvocation->pushOperand(mParamInPosition, Operand::OPS_IN);
curFuncInvocation->pushOperand(mParamTempFloat4, Operand::OPS_OUT, Operand::OPM_X | Operand::OPM_Y | Operand::OPM_Z);
vsMain->addAtomInstance(curFuncInvocation);
//set w value of temporary param to 1
curFuncInvocation = OGRE_NEW FunctionInvocation(FFP_FUNC_ASSIGN, FFP_VS_TRANSFORM, funcCounter++);
curFuncInvocation->pushOperand(ParameterFactory::createConstParamFloat(1.0f), Operand::OPS_IN);
curFuncInvocation->pushOperand(mParamTempFloat4, Operand::OPS_OUT, Operand::OPM_W);
vsMain->addAtomInstance(curFuncInvocation);
//multiply temporary param with weight
curFuncInvocation = OGRE_NEW FunctionInvocation(FFP_FUNC_MODULATE, FFP_VS_TRANSFORM, funcCounter++);
curFuncInvocation->pushOperand(mParamTempFloat4, Operand::OPS_IN);
curFuncInvocation->pushOperand(mParamInWeights, Operand::OPS_IN, indexMask);
curFuncInvocation->pushOperand(mParamTempFloat4, Operand::OPS_OUT);
vsMain->addAtomInstance(curFuncInvocation);
//check if on first iteration
if (index == 0)
{
//set the local param as the value of the world param
curFuncInvocation = OGRE_NEW FunctionInvocation(FFP_FUNC_ASSIGN, FFP_VS_TRANSFORM, funcCounter++);
curFuncInvocation->pushOperand(mParamTempFloat4, Operand::OPS_IN);
curFuncInvocation->pushOperand(mParamLocalPositionWorld, Operand::OPS_OUT);
vsMain->addAtomInstance(curFuncInvocation);
}
else
{
//add the local param as the value of the world param
curFuncInvocation = OGRE_NEW FunctionInvocation(FFP_FUNC_ADD, FFP_VS_TRANSFORM, funcCounter++);
curFuncInvocation->pushOperand(mParamLocalPositionWorld, Operand::OPS_IN);
curFuncInvocation->pushOperand(mParamLocalPositionWorld, Operand::OPS_OUT);
curFuncInvocation->pushOperand(mParamTempFloat4, Operand::OPS_IN);
vsMain->addAtomInstance(curFuncInvocation);
}
}
//-----------------------------------------------------------------------
void HardwareSkinning::addIndexedNormalRelatedWeight(Function* vsMain,
ParameterPtr& pNormalParam,
ParameterPtr& pNormalWorldRelatedParam,
int index, int& funcCounter)
{
FunctionInvocation* curFuncInvocation;
Operand::OpMask indexMask = indexToMask(index);
//multiply position with world matrix and put into temporary param
curFuncInvocation = OGRE_NEW FunctionInvocation(FFP_FUNC_TRANSFORM, FFP_VS_TRANSFORM, funcCounter++);
curFuncInvocation->pushOperand(mParamInWorldMatrices, Operand::OPS_IN, Operand::OPM_ALL);
curFuncInvocation->pushOperand(mParamInIndices, Operand::OPS_IN, indexMask, 1);
curFuncInvocation->pushOperand(pNormalParam, Operand::OPS_IN);
curFuncInvocation->pushOperand(mParamTempFloat3, Operand::OPS_OUT, Operand::OPM_X | Operand::OPM_Y | Operand::OPM_Z);
vsMain->addAtomInstance(curFuncInvocation);
//multiply temporary param with weight
curFuncInvocation = OGRE_NEW FunctionInvocation(FFP_FUNC_MODULATE, FFP_VS_TRANSFORM, funcCounter++);
curFuncInvocation->pushOperand(mParamTempFloat3, Operand::OPS_IN);
curFuncInvocation->pushOperand(mParamInWeights, Operand::OPS_IN, indexMask);
curFuncInvocation->pushOperand(mParamTempFloat3, Operand::OPS_OUT);
vsMain->addAtomInstance(curFuncInvocation);
//check if on first iteration
if (index == 0)
{
//set the local param as the value of the world normal
curFuncInvocation = OGRE_NEW FunctionInvocation(FFP_FUNC_ASSIGN, FFP_VS_TRANSFORM, funcCounter++);
curFuncInvocation->pushOperand(mParamTempFloat3, Operand::OPS_IN);
curFuncInvocation->pushOperand(pNormalWorldRelatedParam, Operand::OPS_OUT);
vsMain->addAtomInstance(curFuncInvocation);
}
else
{
//add the local param as the value of the world normal
curFuncInvocation = OGRE_NEW FunctionInvocation(FFP_FUNC_ADD, FFP_VS_TRANSFORM, funcCounter++);
curFuncInvocation->pushOperand(pNormalWorldRelatedParam, Operand::OPS_IN);
curFuncInvocation->pushOperand(pNormalWorldRelatedParam, Operand::OPS_OUT);
curFuncInvocation->pushOperand(mParamTempFloat3, Operand::OPS_IN);
vsMain->addAtomInstance(curFuncInvocation);
}
}
int PressureSensor::flush(int handle)
{
int id;
switch (handle) {
case ID_PRS:
id = PRS;
case ID_TMP:
/* One-shot sensors must return -EINVAL */
return -EINVAL;
default:
ALOGE("PressureSensor: unknown handle %d", handle);
return -EINVAL;
}
if (!(mEnabled & indexToMask(id)))
return -EINVAL;
mPendingEventsFlushCount[id]++;
return 0;
}
//-----------------------------------------------------------------------
void DualQuaternionSkinning::addPositionCalculations(Function* vsMain, int& funcCounter)
{
FunctionInvocation* curFuncInvocation = NULL;
if (mDoBoneCalculations == true)
{
if(mScalingShearingSupport)
{
//Construct a scaling and shearing matrix based on the blend weights
for(int i = 0 ; i < getWeightCount() ; ++i)
{
//Assign the local param based on the current index of the scaling and shearing matrices
curFuncInvocation = OGRE_NEW FunctionInvocation(FFP_FUNC_ASSIGN, FFP_VS_TRANSFORM, funcCounter++);
curFuncInvocation->pushOperand(mParamInScaleShearMatrices, Operand::OPS_IN);
curFuncInvocation->pushOperand(mParamInIndices, Operand::OPS_IN, indexToMask(i), 1);
curFuncInvocation->pushOperand(mParamTempFloat3x4, Operand::OPS_OUT);
vsMain->addAtomInstance(curFuncInvocation);
//Calculate the resultant scaling and shearing matrix based on the weights given
addIndexedPositionWeight(vsMain, i, mParamTempFloat3x4, mParamTempFloat3x4, mParamBlendS, funcCounter);
}
//Transform the position based by the scaling and shearing matrix
curFuncInvocation = OGRE_NEW FunctionInvocation(FFP_FUNC_TRANSFORM, FFP_VS_TRANSFORM, funcCounter++);
curFuncInvocation->pushOperand(mParamBlendS, Operand::OPS_IN);
curFuncInvocation->pushOperand(mParamInPosition, Operand::OPS_IN, Operand::OPM_XYZ);
curFuncInvocation->pushOperand(mParamLocalBlendPosition, Operand::OPS_OUT);
vsMain->addAtomInstance(curFuncInvocation);
}
else
{
//Assign the input position to the local blended position
curFuncInvocation = OGRE_NEW FunctionInvocation(FFP_FUNC_ASSIGN, FFP_VS_TRANSFORM, funcCounter++);
curFuncInvocation->pushOperand(mParamInPosition, Operand::OPS_IN, Operand::OPM_XYZ);
curFuncInvocation->pushOperand(mParamLocalBlendPosition, Operand::OPS_OUT);
vsMain->addAtomInstance(curFuncInvocation);
}
//Set functions to calculate world position
for(int i = 0 ; i < getWeightCount() ; ++i)
{
//Set the index of the matrix
curFuncInvocation = OGRE_NEW FunctionInvocation(FFP_FUNC_ASSIGN, FFP_VS_TRANSFORM, funcCounter++);
curFuncInvocation->pushOperand(mParamInIndices, Operand::OPS_IN, indexToMask(i));
curFuncInvocation->pushOperand(mParamIndex1, Operand::OPS_OUT);
vsMain->addAtomInstance(curFuncInvocation);
//Multiply the index by 2
curFuncInvocation = OGRE_NEW FunctionInvocation(FFP_FUNC_MODULATE, FFP_VS_TRANSFORM, funcCounter++);
curFuncInvocation->pushOperand(ParameterFactory::createConstParamFloat(2.0f), Operand::OPS_IN);
curFuncInvocation->pushOperand(mParamIndex1, Operand::OPS_IN);
curFuncInvocation->pushOperand(mParamIndex1, Operand::OPS_OUT);
vsMain->addAtomInstance(curFuncInvocation);
//Add 1 to the index and assign as the second row's index
curFuncInvocation = OGRE_NEW FunctionInvocation(FFP_FUNC_ADD, FFP_VS_TRANSFORM, funcCounter++);
curFuncInvocation->pushOperand(ParameterFactory::createConstParamFloat(1.0f), Operand::OPS_IN);
curFuncInvocation->pushOperand(mParamIndex1, Operand::OPS_IN);
curFuncInvocation->pushOperand(mParamIndex2, Operand::OPS_OUT);
vsMain->addAtomInstance(curFuncInvocation);
//Build the dual quaternion matrix
curFuncInvocation = OGRE_NEW FunctionInvocation(SGX_FUNC_BUILD_DUAL_QUATERNION_MATRIX, FFP_VS_TRANSFORM, funcCounter++);
curFuncInvocation->pushOperand(mParamInWorldMatrices, Operand::OPS_IN);
curFuncInvocation->pushOperand(mParamIndex1, Operand::OPS_IN, Operand::OPM_ALL, 1);
curFuncInvocation->pushOperand(mParamInWorldMatrices, Operand::OPS_IN);
curFuncInvocation->pushOperand(mParamIndex2, Operand::OPS_IN, Operand::OPM_ALL, 1);
curFuncInvocation->pushOperand(mParamTempFloat2x4, Operand::OPS_OUT);
vsMain->addAtomInstance(curFuncInvocation);
//Adjust the podalities of the dual quaternions
if(mCorrectAntipodalityHandling)
{
adjustForCorrectAntipodality(vsMain, i, funcCounter, mParamTempFloat2x4);
}
//Calculate the resultant dual quaternion based on the weights given
addIndexedPositionWeight(vsMain, i, mParamTempFloat2x4, mParamTempFloat2x4, mParamBlendDQ, funcCounter);
}
//Normalize the dual quaternion
curFuncInvocation = OGRE_NEW FunctionInvocation(SGX_FUNC_NORMALIZE_DUAL_QUATERNION, FFP_VS_TRANSFORM, funcCounter++);
curFuncInvocation->pushOperand(mParamBlendDQ, Operand::OPS_INOUT);
vsMain->addAtomInstance(curFuncInvocation);
//Calculate the blend position
curFuncInvocation = OGRE_NEW FunctionInvocation(SGX_FUNC_CALCULATE_BLEND_POSITION, FFP_VS_TRANSFORM, funcCounter++);
curFuncInvocation->pushOperand(mParamLocalBlendPosition, Operand::OPS_IN);
curFuncInvocation->pushOperand(mParamBlendDQ, Operand::OPS_IN);
curFuncInvocation->pushOperand(mParamTempFloat4, Operand::OPS_OUT);
vsMain->addAtomInstance(curFuncInvocation);
//Update from object to projective space
curFuncInvocation = OGRE_NEW FunctionInvocation(FFP_FUNC_TRANSFORM, FFP_VS_TRANSFORM, funcCounter++);
curFuncInvocation->pushOperand(mParamInViewProjMatrix, Operand::OPS_IN);
curFuncInvocation->pushOperand(mParamTempFloat4, Operand::OPS_IN);
curFuncInvocation->pushOperand(mParamOutPositionProj, Operand::OPS_OUT);
vsMain->addAtomInstance(curFuncInvocation);
}
else
{
//update from object to world space
curFuncInvocation = OGRE_NEW FunctionInvocation(FFP_FUNC_TRANSFORM, FFP_VS_TRANSFORM, funcCounter++);
curFuncInvocation->pushOperand(mParamInWorldMatrix, Operand::OPS_IN);
curFuncInvocation->pushOperand(mParamInPosition, Operand::OPS_IN);
curFuncInvocation->pushOperand(mParamLocalPositionWorld, Operand::OPS_OUT);
vsMain->addAtomInstance(curFuncInvocation);
//update from object to projective space
curFuncInvocation = OGRE_NEW FunctionInvocation(FFP_FUNC_TRANSFORM, FFP_VS_TRANSFORM, funcCounter++);
curFuncInvocation->pushOperand(mParamInWorldViewProjMatrix, Operand::OPS_IN);
curFuncInvocation->pushOperand(mParamInPosition, Operand::OPS_IN);
curFuncInvocation->pushOperand(mParamOutPositionProj, Operand::OPS_OUT);
vsMain->addAtomInstance(curFuncInvocation);
}
}
int PressureSensor::readEvents(sensors_event_t* data, int count)
{
if (count < 1)
return -EINVAL;
ssize_t n = mInputReader.fill(data_fd);
if (n < 0)
return n;
int numEventReceived = 0;
input_event const* event;
for (int i = 0; i < NUM_SENSORS; i++) {
if (!count)
break;
if (!mPendingEventsFlushCount[i])
continue;
sensors_meta_data_event_t flushEvent;
flushEvent.version = META_DATA_VERSION;
flushEvent.type = SENSOR_TYPE_META_DATA;
flushEvent.meta_data.what = META_DATA_FLUSH_COMPLETE;
flushEvent.meta_data.sensor = mPendingEvents[i].sensor;
flushEvent.reserved0 = 0;
flushEvent.timestamp = getTimestamp();
*data++ = flushEvent;
mPendingEventsFlushCount[i]--;
count--;
numEventReceived++;
}
while (count && mInputReader.readEvent(&event)) {
int type = event->type;
if (type == EV_REL) {
float value = event->value;
if (event->code == REL_HWHEEL || event->code == REL_X) {
ALOGE("Pressure Sensor: Pressure! %d", event->value);
if (mPressureActive) {
mPendingEventsMask |= 1 << PRS;
mPendingEvents[PRS].pressure = event-> value;
}
} else if (event->code == REL_DIAL || event->value == REL_Y) {
ALOGE("Pressure Sensor: Sea Level! %d", event->value);
mPendingEventsMask |= 1 << PRS;
mSeaLevel = event->value;
} else if (event->code == REL_WHEEL || event->code == REL_Z) {
ALOGE("Pressure Sensor: Temperature! %d", event->value);
if (mPressureActive) {
mPendingEventsMask |= 1 << PRS;
mPendingEvents[PRS].temperature = event->value;
} else if (mTemperatureActive && mLastTemperature != event->value) {
mPendingEventsMask |= 1 << TMP;
mPendingEvents[TMP].temperature = event->value;
mLastTemperature = event->value;
}
} else {
ALOGE("PressureSensor: unknown event (type=%d, code=%d)",
type, event->code);
}
} else if (type == EV_SYN) {
for (int i = 0; count && mPendingEventsMask && i < NUM_SENSORS; i++) {
if (mPendingEventsMask & (1 << i)) {
mPendingEventsMask &= ~(1 << i);
mPendingEvents[i].timestamp = timevalToNano(event->time);
if (mEnabled & indexToMask(i)) {
*data++ = mPendingEvents[i];
count--;
numEventReceived++;
}
}
}
} else {
ALOGE("PressureSensor: unknown event (type=%d, code=%d)",
type, event->code);
}
mInputReader.next();
}
return numEventReceived;
}
