// fixture methods virtual void SetUp() { testFile1 = "logger_test_file1.txt"; testFile2 = "logger_test_file2.txt"; // avoid stomping over someone else's files. H_ASSERT( !fileExists( testFile1.c_str() ), "testfile1 exists" ); H_ASSERT( !fileExists( testFile2.c_str() ), "testfile2 exists" ); loggerNoEcho.open( testFile1, false, Logger::WARNING ); std::streambuf* tmpBuff = std::cout.rdbuf( &consoleTestBuff ); loggerEcho.open( testFile2, true, Logger::WARNING ); // now that the logger has attached to our test buffer put the // original back into cout std::cout.rdbuf( tmpBuff ); }
void CAES::setKey(const char *pszKey, const unsigned int uiKeyType) { size_t iRKLens(RKLENGTH(uiKeyType)); size_t iKeyLens(KEYLENGTH(uiKeyType)); m_pEncodeRK = new(std::nothrow) unsigned long[iRKLens + 1]; H_ASSERT(NULL != m_pEncodeRK, "malloc memory error."); H_Zero(m_pEncodeRK, iRKLens + 1); m_pDecodeRK = new(std::nothrow) unsigned long[iRKLens + 1]; H_ASSERT(NULL != m_pDecodeRK, "malloc memory error."); H_Zero(m_pDecodeRK, iRKLens + 1); unsigned char * pKey = new(std::nothrow) unsigned char[iKeyLens + 1]; H_ASSERT(NULL != pKey, "malloc memory error."); H_Zero(pKey, iKeyLens + 1); memcpy(pKey, pszKey, strlen(pszKey) > iKeyLens ? iKeyLens : strlen(pszKey)); m_iEncodeRounds = rijndaelSetupEncrypt(m_pEncodeRK, pKey, uiKeyType); m_iDecodeRounds = rijndaelSetupDecrypt(m_pDecodeRK, pKey, uiKeyType); H_SafeDelArray(pKey); }
double seval_deriv_forsythe( int n, double u, double *x, double *y, double *b, double *c, double *d ) { /* Evaluate the derivative of a cubic spline function. seval_deriv = b(i) + 2*c(i)*(u-x(i)) + 3*d(i)*(u-x(i))**2 where x(i) .lt. u .lt. x(i+1), using horner's rule. If u .lt. x(1) then i = 1 is used. If u .ge. x(n) then i = n is used. Input: n = the number of data points u = the abscissa at which the spline is to be evaluated x,y = the arrays of data abscissas and ordinates b,c,d = arrays of spline coefficients computed by spline If u is not in the same interval as the previous call, then a binary search is performed to determine the proper interval. The function seval() is invoked with the (x, y) pairs underlying the interpolating function specified by the arguments x and y, and the spline coefficients that define the function as specified by b, c, and d. The argument n is the number of data points and the length of the coefficient arrays. */ H_ASSERT( n && x && y && b && c && d, "seval_forsythe needs nonzero params" ); static int i = 0; int j, k; double dx; /* Test for u within the interval of definition of the interpolating function. If not, return the value at an end point of the interval. */ if (u < x[0]) { u = x[0]; } if (u > x[n-1]) { u = x[n-1]; } /* Search for the data points with independent values containing the argument u. */ if (i >= n-1) i = 0; /* If u is not in the current interval, then execute a binary search. */ if ((u < x[i]) || (u > x[i+1])) { i = 0; j = n; while (j > i + 1) { k = (int)(( i + j) / 2); if (u < x[k]) j = k; if (u >= x[k]) i = k; } } /* Evaluate the derivative of the spline function at the argument u. */ dx = u - x[i]; return b[i] + ( 2.0 * dx * c[i] ) + ( 3.0 * dx * dx * d[i] ); }
void r_WeatherEffectsParticleManager::Draw( const m_Mat4& view_matrix, const m_Vec3& cam_pos, const r_Texture& heightmap_texture, const m_Mat4& heightmap_matrix, float particel_size_px, const m_Vec3& light, float intensity ) { if( intensity > 1.0f ) { H_ASSERT(false); intensity= 1.0f; } static const GLenum blend_func[2]= { GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA }; static const r_OGLState state( true, false, true, true, blend_func ); r_OGLStateManager::UpdateState( state ); vbo_.Bind(); particle_texture_.Bind(0); heightmap_texture.Bind(1); shader_.Bind(); shader_.Uniform( "particle_coord_delta", float(hGetTimeMS() - startup_time_) * 0.001f * m_Vec3( 0.0f, 0.0f, -R_RAIN_SPEED_MPS ) ); shader_.Uniform( "particle_zone_coord", cam_pos - rain_zone_size_ * 0.5f ); shader_.Uniform( "particle_zone_size", rain_zone_size_ ); shader_.Uniform( "mat", view_matrix ); shader_.Uniform( "particle_size", particel_size_px ); shader_.Uniform( "tex", 0 ); shader_.Uniform( "heightmap", 1 ); shader_.Uniform( "heightmap_matrix", heightmap_matrix ); shader_.Uniform( "light", light ); glDrawArrays( GL_POINTS, 0, (unsigned int)( float(particles_count_) * intensity ) ); }
void CNetListener::addListener(const char *pszParser, const unsigned short &usType, const char *pszHost, const unsigned short &usPort) { CParser *pParser(m_pParserMgr->getParser(pszParser)); H_ASSERT(NULL != pParser, "get parser error."); CNetInfo *pNetInfo = new(std::nothrow) CNetInfo(this, pParser, usType, pszHost, usPort); if (NULL == pNetInfo) { H_LOG(LOGLV_ERROR, "%s", H_ERR_MEMORY); return; } CAddListenAdjure *pAdjure = new(std::nothrow) CAddListenAdjure(pNetInfo); if (NULL == pAdjure) { H_SafeDelete(pNetInfo); H_LOG(LOGLV_ERROR, "%s", H_ERR_MEMORY); return; } Adjure(pAdjure); }
CDESEncrypt::CDESEncrypt(void) { m_pContext = getcontext(); H_ASSERT(NULL != m_pContext, "malloc memory error."); }
void h_Player::UpdateBuildPos( const p_WorldPhysMesh& phys_mesh ) { m_Vec3 eye_dir( -std::sin( view_angle_.z ) * std::cos( view_angle_.x ), +std::cos( view_angle_.z ) * std::cos( view_angle_.x ), +std::sin( view_angle_.x ) ); m_Vec3 eye_pos= pos_; eye_pos.z+= eyes_level_; float square_dist= std::numeric_limits<float>::max(); h_Direction block_dir= h_Direction::Unknown; m_Vec3 intersect_pos; m_Vec3 candidate_pos; m_Vec3 n; for( const p_UpperBlockFace& face : phys_mesh.upper_block_faces ) { n= g_block_normals[ static_cast<size_t>(face.dir) ]; // Triangulate polygon and check intersection with triangles. m_Vec3 triangle[3]; triangle[0]= m_Vec3( face.vertices[0], face.z ); for( unsigned int i= 0; i < face.vertex_count - 2; i++ ) { triangle[1]= m_Vec3( face.vertices[ i + 1 ], face.z ); triangle[2]= m_Vec3( face.vertices[ i + 2 ], face.z ); if( pRayHasIniersectWithTriangle( triangle, n, eye_pos, eye_dir, &candidate_pos ) ) { float candidate_square_dist= ( candidate_pos - eye_pos ).SquareLength(); if( candidate_square_dist < square_dist ) { square_dist= candidate_square_dist; intersect_pos= candidate_pos; block_dir= face.dir; } } } } for( const p_BlockSide& side : phys_mesh.block_sides ) { n= g_block_normals[ static_cast<size_t>(side.dir) ]; m_Vec3 triangles[6]; triangles[0]= m_Vec3( side.edge[0], side.z0 ); triangles[1]= m_Vec3( side.edge[1], side.z0 ); triangles[2]= m_Vec3( side.edge[1], side.z1 ); triangles[3]= m_Vec3( side.edge[0], side.z1 ); triangles[4]= m_Vec3( side.edge[0], side.z0 ); triangles[5]= m_Vec3( side.edge[1], side.z1 ); for( unsigned int i= 0; i < 2; i++ ) { if( pRayHasIniersectWithTriangle( triangles + i * 3, n, eye_pos, eye_dir, &candidate_pos ) ) { float candidate_square_dist= ( candidate_pos - eye_pos ).SquareLength(); if( candidate_square_dist < square_dist ) { square_dist= candidate_square_dist; intersect_pos= candidate_pos; block_dir= side.dir; } } } } if( block_dir == h_Direction::Unknown || square_dist > g_max_build_distance * g_max_build_distance ) { build_direction_= h_Direction::Unknown; return; } // Fix accuracy. Move intersection point inside target block. intersect_pos-= g_block_normals[ static_cast<size_t>(block_dir) ] * 0.1f; pGetHexogonCoord( intersect_pos.xy(), &destroy_pos_[0], &destroy_pos_[1] ); destroy_pos_[2]= short( intersect_pos.z ); discret_build_pos_[0]= destroy_pos_[0]; discret_build_pos_[1]= destroy_pos_[1]; discret_build_pos_[2]= destroy_pos_[2]; switch( block_dir ) { case h_Direction::Up: discret_build_pos_[2]++; break; case h_Direction::Down: discret_build_pos_[2]--; break; case h_Direction::Forward: discret_build_pos_[1]++; break; case h_Direction::Back: discret_build_pos_[1]--; break; case h_Direction::ForwardRight: discret_build_pos_[1]+= ( (discret_build_pos_[0]^1) & 1 ); discret_build_pos_[0]++; break; case h_Direction::BackRight: discret_build_pos_[1]-= discret_build_pos_[0] & 1; discret_build_pos_[0]++; break; case h_Direction::ForwardLeft: discret_build_pos_[1]+= ( (discret_build_pos_[0]^1) & 1 ); discret_build_pos_[0]--; break; case h_Direction::BackLeft: discret_build_pos_[1]-= discret_build_pos_[0] & 1; discret_build_pos_[0]--; break; case h_Direction::Unknown: H_ASSERT(false); break; } build_pos_.x= float( discret_build_pos_[0] + 1.0f / 3.0f ) * H_SPACE_SCALE_VECTOR_X; build_pos_.y= float( discret_build_pos_[1] ) - 0.5f * float(discret_build_pos_[0]&1) + 0.5f; build_pos_.z= float( discret_build_pos_[2] ); build_direction_= block_dir; }
void spline_forsythe( int n, double *x, double *y, double *b, double *c, double *d ) { /* The coefficients b[i], c[i], and d[i], i = 1, 2, ..., n are computed for a cubic interpolating spline s(x) = y[i] + b[i]*(x-x[i]) + c[i]*(x-x[i])**2 + d[i]*(x-x[i])**3 for x[i] <= x <= x[i+1]. The accompanying function seval() can be used to evaluate the spline. Input: n = the number of data points or knots (n >= 2) x = the abscissas of the knots in strictly increasing order y = the ordinates of the knots Output: b, c, d = arrays of spline coefficients as defined above. Using p to denote differentiation, y[i] = s(x[i]) b[i] = sp(x[i]) c[i] = spp(x[i])/2 d[i] = sppp(x[i])/6 (derivative from the right). */ int i, ib; double t; H_ASSERT( n && x && y && b && c && d, "spline arguments must be nonzero" ); H_ASSERT( n >= 2, "Insufficient data for interpolation" ); if (n < 3) { b[0] = (y[1] - y[0]) / (x[1] - x[0]); c[0] = 0.0; d[0] = 0.0; b[1] = b[0]; c[1] = 0.0; d[1] = 0.0; } else { /* Set up tridiagonal system. b = diagonal, d = off-diagonal, c = right-hand side. */ d[0] = x[1] - x[0]; c[1] = (y[1] - y[0]) / d[0]; for (i = 1; i < n-1; ++i) { d[i] = x[i+1] - x[i]; b[i] = 2.0 * (d[i-1] + d[i]); c[i+1] = (y[i+1] - y[i]) / d[i]; c[i] = c[i+1] - c[i]; } /* End conditions. Third derivatives at x[1] and x[n] obtained from divided differences. */ b[0] = -d[0]; b[n-1] = -d[n-2]; c[0] = 0.0; c[n-1] = 0.0; if (n > 3) { c[0] = c[2] / (x[3] - x[1]) - c[1] / (x[2] - x[0]); c[n-1] = c[n-2] / (x[n-1] - x[n-3]) - c[n-3] / (x[n-2] - x[n-4]); c[0] = c[0] * d[0] * d[0] / (x[3] - x[0]); c[n-1] = -c[n-1] * d[n-2] * d[n-2] / (x[n-1] - x[n-4]); } /* Forward elimination. */ for (i = 1; i < n; ++i) { t = d[i-1] / b[i-1]; b[i] = b[i] - t * d[i-1]; c[i] = c[i] - t * c[i-1]; } /* Back substitution. */ c[n-1] = c[n-1] / b[n-1]; for (ib = 0; ib < n-1; ++ib) { i = n - ib - 1; c[i] = (c[i] - d[i] * c[i+1]) / b[i]; } /* c[i] is now the sigma[i] of the text. */ /* Compute polynomial coefficients. */ b[n-1] = (y[n-1] - y[n-2]) / d[n-2] + d[n-2] * (c[n-2] + 2.0 * c[n-1]); for (i = 0; i < n-1; ++i) { b[i] = (y[i+1] - y[i]) / d[i] - d[i] * (c[i+1] + 2.0 * c[i]); d[i] = (c[i+1] - c[i]) / d[i]; c[i] = 3.0 * c[i]; } c[n-1] = 3.0 * c[n-1]; d[n-1] = d[n-2]; } }