void VertexInfoFactory::createVertexDeclaration( E_VDECL_USAGE_TYPE evutType, E_VERTEX_TYPE vertexType )
{
D3DVERTEXELEMENT9* velement = mpVElement[ u32( vertexType ) ];
switch ( evutType )
{
case EVUT_CG:
{
#ifdef BUILD_USING_CG
cgD3D9ValidateVertexDeclaration( mpCGprogram, velement );
// Clear out the CGprogram for next setCgProgram binding
mpCGprogram = 0;
#endif
} break;
case EVUT_DIRECT3D9:
{
DEBUG_BREAK( mpD3DDevice->CreateVertexDeclaration( velement, &mpVDecl[ u32( vertexType ) ] ) );
} break;
case EVUT_DIRECT3D9_AND_CG:
{
DEBUG_BREAK( mpD3DDevice->CreateVertexDeclaration( velement, &mpVDecl[ u32( vertexType ) ] ) );
#ifdef BUILD_USING_CG
cgD3D9ValidateVertexDeclaration( mpCGprogram, velement );
// Clear out the CGprogram for next setCgProgram binding
mpCGprogram = 0;
#endif
} break;
}
}
//========== =================================================================
CVector::CVector(const CVector& Src)
{
if (Src.Data == NULL) { DEBUG_BREAK(); return; }
if (SetSize(3, 1) == NULL) { DEBUG_BREAK(); return; }
Data[0][0] = Src.Data[0][0];
Data[1][0] = Src.Data[1][0];
Data[2][0] = Src.Data[2][0];
}
//==========================================================================
CVector CVector::operator - (const CVector& v)
{
if (v.Data == NULL) { DEBUG_BREAK(); return *this; }
if ( Data == NULL) { DEBUG_BREAK(); return *this; }
return CVector(Data[0][0] - v.Data[0][0],
Data[1][0] - v.Data[1][0],
Data[2][0] - v.Data[2][0]);
}
//===========================================================================
double CVector::operator * (const CVector& v)
{
if (v.Data == NULL) { DEBUG_BREAK(); return -999; }
if ( Data == NULL) { DEBUG_BREAK(); return -999; }
return (Data[0][0]*v.Data[0][0] +
Data[1][0]*v.Data[1][0] +
Data[2][0]*v.Data[2][0]);
}
//===========================================================================
CVector& CVector::operator += (const CVector& v)
{
if (v.Data == NULL) { DEBUG_BREAK(); return *this; }
if ( Data == NULL) { DEBUG_BREAK(); return *this; }
Data[0][0] += v.Data[0][0];
Data[1][0] += v.Data[1][0];
Data[2][0] += v.Data[2][0];
return *this;
}
//===========================================================================
CVector& CVector::operator /= (double s)
{
if (Data == NULL) { DEBUG_BREAK(); return *this; }
if ( s == 0 ) { DEBUG_BREAK(); return *this; }
Data[0][0] /= s;
Data[1][0] /= s;
Data[2][0] /= s;
return *this;
}
//===========================================================================
CVector CVector::operator ^ (const CVector& v)
{
if (v.Data == NULL) { DEBUG_BREAK(); return *this; }
if ( Data == NULL) { DEBUG_BREAK(); return *this; }
return CVector(Data[1][0] * v.Data[2][0] - Data[2][0] * v.Data[1][0],
Data[2][0] * v.Data[0][0] - Data[0][0] * v.Data[2][0],
Data[0][0] * v.Data[1][0] - Data[1][0] * v.Data[0][0]);
// return CVector(y*v.z - z*v.y, z*v.x - x*v.z, x*v.y - y*v.x);
}
//===========================================================================
CVector& CVector::operator = (double* pData)
{
if(pData == NULL) { DEBUG_BREAK(); return *this; }
if( Data == NULL) { DEBUG_BREAK(); return *this; }
Data[0][0] = pData[0];
Data[1][0] = pData[1];
Data[2][0] = pData[2];
return *this;
}
//===========================================================================
CVector operator * (const CMatrix& m, const CVector& v)
{
if (v.Data == NULL) { DEBUG_BREAK(); return CVector(); }
if (m.Data == NULL) { DEBUG_BREAK(); return CVector(); }
if (m.Columns != v.Rows) { DEBUG_BREAK(); return CVector(); }
CVector Res;
Res.Data[0][0] = m.Data[0][0]*v.Data[0][0] + m.Data[0][1]*v.Data[1][0] + m.Data[0][2]*v.Data[2][0];
Res.Data[1][0] = m.Data[1][0]*v.Data[0][0] + m.Data[1][1]*v.Data[1][0] + m.Data[1][2]*v.Data[2][0];
Res.Data[2][0] = m.Data[2][0]*v.Data[0][0] + m.Data[2][1]*v.Data[1][0] + m.Data[2][2]*v.Data[2][0];
return Res;
}
//===========================================================================
CVector& CVector::operator ^= (const CVector& v)
{
if (v.Data == NULL) { DEBUG_BREAK(); return *this; }
if ( Data == NULL) { DEBUG_BREAK(); return *this; }
double _x = Data[1][0]*v.Data[2][0] - Data[2][0]*v.Data[1][0];
double _y = Data[2][0]*v.Data[0][0] - Data[0][0]*v.Data[2][0];
double _z = Data[0][0]*v.Data[1][0] - Data[1][0]*v.Data[0][0];
Data[0][0] = _x;
Data[1][0] = _y;
Data[2][0] = _z;
return *this;
}
//===========================================================================
CMatrix CMatrix::operator / (const double s)
{
if ( Data == NULL) { DEBUG_BREAK(); return CMatrix(); }
if ( s == 0 ) { DEBUG_BREAK(); return CMatrix(); }
// ---
CMatrix Result(Rows, Columns);
if(Result.Data == NULL) return CMatrix();
// ---
for (int i = 0; i < Rows; i++)
for (int k = 0; k < Columns; k++){
Result.Data[i][k] = Data[i][k] / s;
}
// ---
return Result;
}
void vxPrintScalarValue(vx_scalar scalar)
{
switch (scalar->data_type)
{
case VX_TYPE_CHAR:
VX_PRINT(VX_ZONE_SCALAR, "scalar "VX_FMT_REF" = %c\n", scalar, scalar->data.chr);
break;
case VX_TYPE_INT8:
VX_PRINT(VX_ZONE_SCALAR, "scalar "VX_FMT_REF" = %d\n", scalar, scalar->data.s08);
break;
case VX_TYPE_UINT8:
VX_PRINT(VX_ZONE_SCALAR, "scalar "VX_FMT_REF" = %u\n", scalar, scalar->data.u08);
break;
case VX_TYPE_INT16:
VX_PRINT(VX_ZONE_SCALAR, "scalar "VX_FMT_REF" = %hd\n", scalar, scalar->data.s16);
break;
case VX_TYPE_UINT16:
VX_PRINT(VX_ZONE_SCALAR, "scalar "VX_FMT_REF" = %hu\n", scalar, scalar->data.u16);
break;
case VX_TYPE_INT32:
VX_PRINT(VX_ZONE_SCALAR, "scalar "VX_FMT_REF" = %d\n", scalar, scalar->data.s32);
break;
case VX_TYPE_UINT32:
VX_PRINT(VX_ZONE_SCALAR, "scalar "VX_FMT_REF" = %u\n", scalar, scalar->data.u32);
break;
case VX_TYPE_INT64:
VX_PRINT(VX_ZONE_SCALAR, "scalar "VX_FMT_REF" = %ld\n", scalar, scalar->data.s64);
break;
case VX_TYPE_UINT64:
VX_PRINT(VX_ZONE_SCALAR, "scalar "VX_FMT_REF" = %lu\n", scalar, scalar->data.u64);
break;
#if OVX_SUPPORT_HALF_FLOAT
case VX_TYPE_FLOAT16:
VX_PRINT(VX_ZONE_SCALAR, "scalar "VX_FMT_REF" = %f\n", scalar, scalar->data.f16);
break;
#endif
case VX_TYPE_FLOAT32:
VX_PRINT(VX_ZONE_SCALAR, "scalar "VX_FMT_REF" = %lf\n", scalar, scalar->data.f32);
break;
case VX_TYPE_FLOAT64:
VX_PRINT(VX_ZONE_SCALAR, "scalar "VX_FMT_REF" = %lf\n", scalar, scalar->data.f64);
break;
case VX_TYPE_DF_IMAGE:
VX_PRINT(VX_ZONE_SCALAR, "scalar "VX_FMT_REF" = %08x\n", scalar, scalar->data.fcc);
break;
case VX_TYPE_ENUM:
VX_PRINT(VX_ZONE_SCALAR, "scalar "VX_FMT_REF" = %d\n", scalar, scalar->data.enm);
break;
case VX_TYPE_SIZE:
VX_PRINT(VX_ZONE_SCALAR, "scalar "VX_FMT_REF" = %zu\n", scalar, scalar->data.size);
break;
case VX_TYPE_BOOL:
VX_PRINT(VX_ZONE_SCALAR, "scalar "VX_FMT_REF" = %s\n", scalar, (scalar->data.boolean == vx_true_e?"TRUE":"FALSE"));
break;
default:
VX_PRINT(VX_ZONE_ERROR, "Case %08x is not covered!\n", scalar->data_type);
DEBUG_BREAK();
break;
}
}
//===========================================================================
CMatrix CMatrix::operator - (const CMatrix &m)
{
if ( Data == NULL ) { DEBUG_BREAK(); return CMatrix(); }
if (m.Data == NULL ) { DEBUG_BREAK(); return CMatrix(); }
if (m.Rows < Rows ) { DEBUG_BREAK(); return CMatrix(); }
if (m.Columns < Columns) { DEBUG_BREAK(); return CMatrix(); }
//
CMatrix Result(Rows, Columns);
//
for (int i = 0; i < Rows; i++)
for (int k = 0; k < Columns; k++) {
Result.Data[i][k] = Data[i][k] - m.Data[i][k];
}
//
return Result;
}
//===========================================================================
CVector::CVector(double data[3])
{
if (SetSize(3, 1) == NULL) { DEBUG_BREAK(); return; }
Data[0][0] = data[0];
Data[1][0] = data[1];
Data[2][0] = data[2];
}
//===========================================================================
CVector::CVector(double _x, double _y, double _z)
{
if (SetSize(3, 1) == NULL) { DEBUG_BREAK(); return; }
Data[0][0] = _x;
Data[1][0] = _y;
Data[2][0] = _z;
}
//===========================================================================
double CVector::Norm()
{
if (Data == NULL) { DEBUG_BREAK(); return -999; }
return sqrt(Data[0][0] * Data[0][0] +
Data[1][0] * Data[1][0] +
Data[2][0] * Data[2][0]);
}
//===========================================================================
CMatrix CMatrix::operator * (const CMatrix& m)
{
// - умножение двух матриц A (MxN) и B (KxL), определено только дл¤ N=K. C=AB. => C Ц матрица размерности MxL.
if ( Data == NULL ) { DEBUG_BREAK(); return CMatrix(); }
if (m.Data == NULL ) { DEBUG_BREAK(); return CMatrix(); }
if (m.Rows != Columns) { DEBUG_BREAK(); return CMatrix(); }
//
CMatrix Result(Rows, m.Columns);
//
for(int i = 0; i < Rows; i++)
for(int j = 0; j < m.Columns; j++) {
for(int k = 0; k < Columns; k++)
Result.Data[i][j] += Data[i][k]*m.Data[k][j];
}
//
return Result;
}
//===========================================================================
double& CVector::operator [] (int row)
{
switch( row )
{
case 0: return Data[0][0]; // --- —кал¤рна¤ часть X ---
case 1: return Data[1][0]; // --- —кал¤рна¤ часть Y ---
case 2: return Data[2][0]; // --- —кал¤рна¤ часть Z ---
}
DEBUG_BREAK(); return Data[0][0]; // --- —кал¤рна¤ часть X ---
}
//===========================================================================
CMatrix::CMatrix(const CMatrix& Src)
{
if (Src.Data == NULL) return;
if ( SetSize(Src.Rows, Src.Columns) == NULL) { DEBUG_BREAK(); return; }
for(int i = 0; i < Rows; i++)
for(int j = 0; j < Columns; j++) {
Data[i][j] = Src.Data[i][j];
}
}
void assertion_failed_msg(
char const* expr,
char const* msg,
char const* function,
char const* /*file*/,
long /*line*/) {
daily::trace::LOG() << "Expression '" << expr << "' is false in function '"
<< function << "': " << (msg ? msg : "<...>") << ".\n"
<< "Backtrace:\n"
<< ::boost::stacktrace::stacktrace() << '\n';
DEBUG_BREAK();
}
//===========================================================================
void CVector::Normalize()
{
double norm = Norm();
// ----------
if ( norm == 0 ) { DEBUG_BREAK(); return; }
Data[0][0] = Data[0][0] / norm;
Data[1][0] = Data[1][0] / norm;
Data[2][0] = Data[2][0] / norm;
// ----------
}
//===========================================================================
CMatrix::CMatrix(int aRows, int aColumns, double *aData)
{
if ( aData == NULL ) return;
if ( aRows <= 0 ) return;
if ( aColumns <= 0 ) return;
if ( SetSize( aRows, aColumns ) == NULL ) { DEBUG_BREAK(); return; }
int counter = 0;
for( int i = 0; i < Rows; i++ )
for( int j = 0; j < Columns; j++, counter++) {
Data[i][j] = aData[counter];
}
}
//===========================================================================
CMatrix CMatrix::operator = (const CMatrix &m)
{
if (&m == this) return *this;
if (Data != NULL) DeleteMatrix();
if (m.Data == NULL) return *this;
// -----
if ( SetSize(m.Rows, m.Columns) == NULL ) { DEBUG_BREAK(); return *this; }
// -----
for(int i = 0; i < Rows; i++)
for(int j = 0; j < Columns; j++) {
Data[i][j] = m.Data[i][j];
}
// -----
return *this;
}
//===========================================================================
CMatrix CMatrix::Transpose()
{
if(Data == NULL) { DEBUG_BREAK(); return CMatrix(); }
//
CMatrix Result(Columns, Rows);
if(Result.Data == NULL) return CMatrix();
//
for(int i = 0; i < Rows; i++)
for(int j = 0; j < Columns; j++) {
Result.Data[j][i] = Data[i][j];
}
//
return Result;
}
//===========================================================================
CMatrix &CMatrix::Identity()
{
if ( Data == NULL ) { DEBUG_BREAK(); return *this;}
// --- ќбнул¤ю матрицу ----
for (int i = 0; i < Rows; i++)
memset(Data[i], 0, sizeof(double) * Columns);
// -- ќпредил¤ю минимальное значение размера масива ----
int aMin = min(Rows, Columns);
for (int i = 0; i <aMin; i ++) {
Data[i][i] = 1;
}
// ----
return *this;
}
/*-----------------------------------------------------------------------------------
* Name: dlbe_FreeUniqueRecordId
*
* Description:
* This function allocates and initializes a Unique Record Id
*
* Parameters:
* pRecordset (input)
* Attributes (output)
* Data (output)
*
* RETURN:
* A pointer to the unique record id of the current record
*
* ERROR CODES
* CSSMERR_DL_INTERNAL_ERROR
* CSSMERR_DL_INVALID_RECORD_UID
*-----------------------------------------------------------------------------------*/
CSSM_RETURN dlbe_FreeUniqueRecordId(CSSM_DL_DB_HANDLE DLDBHandle,
CSSM_DB_UNIQUE_RECORD_PTR UniqueRecordId)
{
if (!UniqueRecordId)
{
DEBUG_BREAK(); /* Algorithm error, freeze execution (in debug) */
return CSSMERR_DL_INTERNAL_ERROR;
}
if (UniqueRecordId->RecordIdentifier.Length != 8)
return CSSMERR_DL_INVALID_RECORD_UID;
App_Free(DLDBHandle.DLHandle, UniqueRecordId->RecordIdentifier.Data);
App_Free(DLDBHandle.DLHandle, UniqueRecordId);
return CSSM_OK;
}
void TestResults::OnTestFailure(TestDetails const& test, char const* failure)
{
++m_failureCount;
if (!m_currentTestFailed)
{
++m_failedTestCount;
std::string fullTestName(test.suiteName);
fullTestName.append(":");
fullTestName.append(test.testName);
m_failedTests.push_back(fullTestName);
m_currentTestFailed = true;
}
if (m_testReporter)
{
m_testReporter->ReportFailure(test, failure);
if(m_breakOnError)
{
DEBUG_BREAK();
}
}
}
/*-----------------------------------------------------------------------------
* Name: dlbe_CreateDatabase
*
* Description:
* Tells flat file to create a new data store. The access file is placed in the current
* directory.
*
* Parameters:
* DbName (input): The name of the Data store to create
* OpenParams (input): Unused.
*
* Return value:
* CSSM_OK on success, otherwise CSSM_FAIL
*
* Error Codes:
* TODO
*---------------------------------------------------------------------------*/
CSSM_RETURN dlbe_CreateDatabase(DATABASE_BACKEND_HANDLE *phDatabase, const char *DbName,
DAL_MODULE_PARAMETERS * Parameters)
{
ASSERT(phDatabase);
ASSERT(DbName);
ASSERT(Parameters);
FF_FUNCTION_BEGIN(dlbe_CreateDatabase);
if (ffutil_fIsBadDbName(DbName))
return CSSMERR_DL_INVALID_DB_NAME;
/* Fill in Parameters->AdditionalInformation.Data with the path start (CurrDir\DbName) */
CATCH_FUNCTION(ffport_eGetPathStart(DbName, GetPathStart(Parameters)))
{
DEBUG_BREAK(); /* Algorithm error, freeze execution (in debug) */
RETURN_ERROR();
}
/* Find the length of additional Information */
GetPathStartLength(Parameters) = strlen(GetPathStart(Parameters)) + 1;
return dlbe_OpenDatabase(phDatabase, DbName, Parameters);
}
//===========================================================================
CVector::CVector()
{
if ( SetSize(3, 1) == NULL) { DEBUG_BREAK(); return; }
}
//===========================================================================
CVector operator * (double s, const CVector& v)
{
if (v.Data == NULL) { DEBUG_BREAK(); return CVector(); }
return CVector(v.Data[0][0] * s, v.Data[1][0] * s, v.Data[2][0] * s);
}
