NxStream& UserStream::storeBuffer(const void* buffer, NxU32 size) { size_t w = fwrite(buffer, size, 1, fp); NX_ASSERT(w); return *this; }
double UserStream::readDouble() const { NxF64 f; size_t r = fread(&f, sizeof(NxF64), 1, fp); NX_ASSERT(r); return f; }
NxStream& UserStream::storeDouble(NxF64 f) { size_t w = fwrite(&f, sizeof(NxF64), 1, fp); NX_ASSERT(w); return *this; }
bool FindTouchedGeometry( void* user_data, const NxExtendedBounds3& worldBounds, // ### we should also accept other volumes TriArray& world_triangles, TriArray* world_edge_normals, IntArray& edge_flags, IntArray& geom_stream, NxU32 group_flags, bool static_shapes, bool dynamic_shapes, const NxGroupsMask* groupsMask) { NX_ASSERT(user_data); NxScene* scene = (NxScene*)user_data; NxExtendedVec3 Origin; // Will be TouchedGeom::mOffset worldBounds.getCenter(Origin); // Reserve a stack buffer big enough to hold all shapes in the world. This is a lazy approach that is // acceptable here since the total number of shapes is limited to 64K anyway, which would "only" consume // 256 Kb on the stack (hence, stack overflow is unlikely). // ### TODO: the new callback mechanism would allow us to use less memory here // NxU32 total = scene->getNbStaticShapes() + scene->getNbDynamicShapes(); NxU32 total = scene->getTotalNbShapes(); NxShape** buffer = (NxShape**)NxAlloca(total*sizeof(NxShape*)); // Find touched *boxes* i.e. touched objects' AABBs in the world // We collide against dynamic shapes too, to get back dynamic boxes/etc // TODO: add active groups in interface! NxU32 Flags = 0; if(static_shapes) Flags |= NX_STATIC_SHAPES; if(dynamic_shapes) Flags |= NX_DYNAMIC_SHAPES; // ### this one is dangerous NxBounds3 tmpBounds; // LOSS OF ACCURACY tmpBounds.min.x = (float)worldBounds.min.x; tmpBounds.min.y = (float)worldBounds.min.y; tmpBounds.min.z = (float)worldBounds.min.z; tmpBounds.max.x = (float)worldBounds.max.x; tmpBounds.max.y = (float)worldBounds.max.y; tmpBounds.max.z = (float)worldBounds.max.z; NxU32 nbTouchedBoxes = scene->overlapAABBShapes(tmpBounds, NxShapesType(Flags), total, buffer, NULL, group_flags, groupsMask); // Early exit if no AABBs found if(!nbTouchedBoxes) return false; NX_ASSERT(nbTouchedBoxes<=total); // Else we just trashed some stack memory // Loop through touched world AABBs NxShape** touched = buffer; while(nbTouchedBoxes--) { // Get current shape NxShape* shape = *touched++; // Filtering // Discard all CCT shapes, i.e. kinematic actors we created ourselves. We don't need to collide with them since they're surrounded // by the real CCT volume - and collisions with those are handled elsewhere. We use the userData field for filtering because that's // really our only valid option (filtering groups are already used by clients and we don't have control over them, clients might // create other kinematic actors that we may want to keep here, etc, etc) if(size_t(shape->userData)=='CCTS') continue; // Discard if not collidable // PT: this shouldn't be possible at this point since: // - the SF flag is only used for compounds // - the AF flag is already tested in scene query // - we shouldn't get compound shapes here if(shape->getFlag(NX_SF_DISABLE_COLLISION)) continue; // Ubi (EA) : Discarding Triggers : if ( shape->getFlag(NX_TRIGGER_ENABLE) ) continue; // PT: here you might want to disable kinematic objects. // Output shape to stream NxShapeType type = shape->getType(); if(type==NX_SHAPE_SPHERE) outputSphereToStream((NxSphereShape*)shape, shape, geom_stream, Origin); else if(type==NX_SHAPE_CAPSULE) outputCapsuleToStream((NxCapsuleShape*)shape, shape, geom_stream, Origin); else if(type==NX_SHAPE_BOX) outputBoxToStream((NxBoxShape*)shape, shape, geom_stream, Origin); else if(type==NX_SHAPE_MESH) outputMeshToStream((NxTriangleMeshShape*)shape, shape, geom_stream, world_triangles, world_edge_normals, edge_flags, Origin, tmpBounds); else if(type==NX_SHAPE_HEIGHTFIELD) outputHeightFieldToStream((NxHeightFieldShape*)shape, shape, geom_stream, world_triangles, world_edge_normals, edge_flags, Origin, tmpBounds); else if(type==NX_SHAPE_CONVEX) outputConvexToStream((NxConvexShape*)shape, shape, geom_stream, world_triangles, world_edge_normals, edge_flags, Origin, tmpBounds); } return true; }
/** * @brief Get a base address of register set * @return Module's base address. * @see NX_CRYPTO_GetPhysicalAddress, NX_CRYPTO_GetSizeOfRegisterSet, * NX_CRYPTO_SetBaseAddress, * NX_CRYPTO_OpenModule, NX_CRYPTO_CloseModule, * NX_CRYPTO_CheckBusy, */ U32 NX_CRYPTO_GetBaseAddress( U32 ModuleIndex ) { NX_ASSERT( NUMBER_OF_CRYPTO_MODULE > ModuleIndex ); return (U32)__g_pRegister[ModuleIndex]; }
NxStream& UserStream::storeWord(NxU16 w) { size_t ww = fwrite(&w, sizeof(NxU16), 1, fp); NX_ASSERT(ww); return *this; }
NxStream& UserStream::storeFloat(NxReal f) { size_t w = fwrite(&f, sizeof(NxReal), 1, fp); NX_ASSERT(w); return *this; }
/** * @brief Read Count Value of Low Period * @return Value of Low period ( 0 ~ 0xFFFF ) * @see NX_PPM_GetPPMHighPeriodValue */ U32 NX_PPM_GetPPMLowPeriodValue ( void ) { NX_ASSERT( CNULL != __g_pRegister ); return(U32)( __g_pRegister->PPM_LOWPERIOD ); }
/** * @brief Read Count Value of High Period * @return Value of High period ( 0 ~ 0xFFFF ) * @see NX_PPM_GetPPMLowPeriodValue */ U32 NX_PPM_GetPPMHighPeriodValue ( void ) { NX_ASSERT( CNULL != __g_pRegister ); return(U32)( __g_pRegister->PPM_HIGHPERIOD ); }
/** * @brief Indicates current setting value of interrupt pending bit. * @return Current setting value of pending bit. \n * "1" means pend bit is occured. \n * "0" means pend bit is NOT occured. \n * - Return Value[0] : Rising edge detect pending state. \n * - Return Value[1] : Falling edge detect pending state. \n * - Return Value[2] : Overflow interrupt pending state. \n * @see NX_PPM_GetInterruptNumber, NX_PPM_SetInterruptEnable, * NX_PPM_GetInterruptEnable, NX_PPM_SetInterruptEnable32, * NX_PPM_GetInterruptEnable32, NX_PPM_GetInterruptPending, * NX_PPM_ClearInterruptPending, * NX_PPM_ClearInterruptPending32, NX_PPM_SetInterruptEnableAll, * NX_PPM_GetInterruptEnableAll, NX_PPM_GetInterruptPendingAll, * NX_PPM_ClearInterruptPendingAll, NX_PPM_GetInterruptPendingNumber */ U32 NX_PPM_GetInterruptPending32( void ) { NX_ASSERT( CNULL != __g_pRegister ); return (CBOOL)( __g_pRegister->PPM_STAT & 0x07 ); }
/** * @brief Set a base address of register set. * @param[in] BaseAddress Module's base address * @return None. * @see NX_PPM_GetPhysicalAddress, NX_PPM_GetSizeOfRegisterSet, * NX_PPM_GetBaseAddress, * NX_PPM_OpenModule, NX_PPM_CloseModule, * NX_PPM_CheckBusy, NX_PPM_CanPowerDown */ void NX_PPM_SetBaseAddress( U32 BaseAddress ) { NX_ASSERT( CNULL != BaseAddress ); __g_pRegister = (struct NX_PPM_RegisterSet *)BaseAddress; }
/** * @brief Indicates current setting value of interrupt enable bit. * @return Current setting value of interrupt. \n * "1" means interrupt is enabled. \n * "0" means interrupt is disabled. \n * - Return Value[0] : Rising edge detect interrupt's setting value. \n * - Return Value[1] : Falling edge detect interrupt's setting value. \n * - Return Value[2] : Overflow interrupt interrupt's setting value. \n * @see NX_PPM_GetInterruptNumber, NX_PPM_SetInterruptEnable, * NX_PPM_GetInterruptEnable, NX_PPM_SetInterruptEnable32, * NX_PPM_GetInterruptPending, * NX_PPM_GetInterruptPending32, NX_PPM_ClearInterruptPending, * NX_PPM_ClearInterruptPending32, NX_PPM_SetInterruptEnableAll, * NX_PPM_GetInterruptEnableAll, NX_PPM_GetInterruptPendingAll, * NX_PPM_ClearInterruptPendingAll, NX_PPM_GetInterruptPendingNumber */ U32 NX_PPM_GetInterruptEnable32( void ) { NX_ASSERT( CNULL != __g_pRegister ); return (U32)(__g_pRegister->PPM_CTRL & 0x07 ); }
/** * @brief Set a base address of register set. * @param[in] BaseAddress Module's base address * @return None. * @see NX_CRYPTO_GetPhysicalAddress, NX_CRYPTO_GetSizeOfRegisterSet, * NX_CRYPTO_GetBaseAddress, * NX_CRYPTO_OpenModule, NX_CRYPTO_CloseModule, * NX_CRYPTO_CheckBusy, */ void NX_CRYPTO_SetBaseAddress( U32 ModuleIndex, U32 BaseAddress ) { NX_ASSERT( CNULL != BaseAddress ); NX_ASSERT( NUMBER_OF_CRYPTO_MODULE > ModuleIndex ); __g_pRegister[ModuleIndex] = (NX_CRYPTO_RegisterSet *)BaseAddress; }
//------------------------------------------------------------------------------ // // Basic Interface // //------------------------------------------------------------------------------ //---------- CLKGEN 을 위한 prototype U32 NX_CRYPTO_GetClockNumber (U32 ModuleIndex) { static const U32 CLKGEN_LIST[] = { CLOCKINDEX_LIST( CRYPTO ) }; NX_ASSERT( NUMBER_OF_CRYPTO_MODULE > ModuleIndex ); return (U32)CLKGEN_LIST[ModuleIndex]; }
void UserStream::readBuffer(void* buffer, NxU32 size) const { size_t w = fread(buffer, size, 1, fp); NX_ASSERT(w); }
void NX_DISPTOP_CLKGEN_SetBaseAddress( U32 ModuleIndex, U32 BaseAddress ) { NX_ASSERT( CNULL != BaseAddress ); NX_ASSERT( NUMBER_OF_DISPTOP_CLKGEN_MODULE > ModuleIndex ); __g_ModuleVariables[ModuleIndex].__g_pRegister = (struct NX_DISPTOP_CLKGEN_RegisterSet *)BaseAddress; }
// Saving API NxStream& UserStream::storeByte(NxU8 b) { size_t w = fwrite(&b, sizeof(NxU8), 1, fp); NX_ASSERT(w); return *this; }
U32 NX_DISPTOP_CLKGEN_GetBaseAddress( U32 ModuleIndex ) { NX_ASSERT( NUMBER_OF_DISPTOP_CLKGEN_MODULE > ModuleIndex ); return (U32)__g_ModuleVariables[ModuleIndex].__g_pRegister; }
NxStream& UserStream::storeDword(NxU32 d) { size_t w = fwrite(&d, sizeof(NxU32), 1, fp); NX_ASSERT(w); return *this; }
NxU8 UserStream::readByte() const { NxU8 b; size_t r = fread(&b, sizeof(NxU8), 1, fp); NX_ASSERT(r); return b; }
static void outputConvexToStream( NxConvexShape* convexShape, NxShape* shape, IntArray& geom_stream, TriArray& world_triangles, TriArray* world_edge_normals, IntArray& edge_flags, const NxExtendedVec3& origin, const NxBounds3& tmpBounds ) { // Do AABB-mesh query NxU32 Nb; const NxU32* TF; // Collide AABB against current mesh // The overlap function doesn't exist for convexes so let's just dump all tris NxConvexMesh& cm = convexShape->getConvexMesh(); Nb = cm.getCount(0, NX_ARRAY_TRIANGLES); NX_ASSERT(cm.getFormat(0, NX_ARRAY_TRIANGLES)==NX_FORMAT_INT); TF = (const NxU32*)cm.getBase(0, NX_ARRAY_TRIANGLES); NX_ASSERT(cm.getFormat(0, NX_ARRAY_VERTICES)==NX_FORMAT_FLOAT); const NxVec3* verts = (const NxVec3*)cm.getBase(0, NX_ARRAY_VERTICES); NxMat34 absPose = shape->getGlobalPose(); NxVec3 tmp = shape->getGlobalPosition(); // LOSS OF ACCURACY NxVec3 MeshOffset; MeshOffset.x = float(tmp.x - origin.x); MeshOffset.y = float(tmp.y - origin.y); MeshOffset.z = float(tmp.z - origin.z); TouchedMesh* touchedMesh = (TouchedMesh*)reserve(geom_stream, sizeof(TouchedMesh)/sizeof(NxU32)); touchedMesh->mType = TOUCHED_MESH; touchedMesh->mUserData = shape; touchedMesh->mOffset = origin; touchedMesh->mNbTris = Nb; touchedMesh->mIndexWorldTriangles = world_triangles.size(); touchedMesh->mIndexWorldEdgeNormals = world_edge_normals ? world_edge_normals->size() : 0; touchedMesh->mIndexEdgeFlags = edge_flags.size(); // Reserve memory for incoming triangles NxTriangle* TouchedTriangles = reserve(world_triangles, Nb); NxTriangle* EdgeTriangles = world_edge_normals ? reserve(*world_edge_normals, Nb) : NULL; // Loop through touched triangles while(Nb--) { // Compute triangle in world space, add to array NxTriangle& CurrentTriangle = *TouchedTriangles++; NxU32 vref0 = *TF++; NxU32 vref1 = *TF++; NxU32 vref2 = *TF++; NxVec3 v0 = verts[vref0]; NxVec3 v1 = verts[vref1]; NxVec3 v2 = verts[vref2]; absPose.M.multiply(v0, v0); absPose.M.multiply(v1, v1); absPose.M.multiply(v2, v2); CurrentTriangle.verts[0] = v0; CurrentTriangle.verts[1] = v1; CurrentTriangle.verts[2] = v2; CurrentTriangle.verts[0] += MeshOffset; CurrentTriangle.verts[1] += MeshOffset; CurrentTriangle.verts[2] += MeshOffset; if(EdgeTriangles) { // #### hmmm NxTriangle edgeTri; edgeTri.verts[0].zero(); edgeTri.verts[1].zero(); edgeTri.verts[2].zero(); *EdgeTriangles++ = edgeTri; } // #### hmmm NxU32 edgeFlags = 7; edge_flags.pushBack(edgeFlags); } }
NxU32 UserStream::readDword() const { NxU32 d; size_t r = fread(&d, sizeof(NxU32), 1, fp); NX_ASSERT(r); return d; }
void mv_semaphore_destroy(mv_sem_t *sem) { mv_scheduler_lock(); NX_ASSERT(sem->count >= 0); nx_free(sem); mv_scheduler_unlock(); }
void tests_util(void) { U32 u = 0; S32 s = 0; hello(); /* * streq() tests. */ /* Simple equality. */ NX_ASSERT(streq("foo", "foo")); /* Simple inequality. */ NX_ASSERT(!streq("foo", "bar")); NX_ASSERT(!streq("bar", "foo")); /* Inequality towards the end of the string. */ NX_ASSERT(!streq("foo", "fob")); NX_ASSERT(!streq("fob", "foo")); /* Inequality of different length strings. */ NX_ASSERT(!streq("foo", "foobar")); NX_ASSERT(!streq("foobar", "foo")); /* Inequality vs. the empty string. */ NX_ASSERT(!streq("foo", "")); NX_ASSERT(!streq("", "foo")); /* The border case of the empty string. */ NX_ASSERT(streq("", "")); /* * streqn() tests. */ /* Simple equality. */ NX_ASSERT(streqn("foo", "foo", 3)); /* Simple inequality. */ NX_ASSERT(!streqn("foo", "bar", 3)); NX_ASSERT(!streqn("bar", "foo", 3)); /* Inequality towards the end of the string. */ NX_ASSERT(!streqn("foo", "fob", 3)); NX_ASSERT(!streqn("fob", "foo", 3)); /* Inequality of different length strings. */ NX_ASSERT(!streqn("foo", "foobar", 6)); NX_ASSERT(!streqn("foobar", "foo", 6)); /* Inequality vs. the empty string. */ NX_ASSERT(!streqn("foo", "", 3)); NX_ASSERT(!streqn("", "foo", 3)); /* Equality of the empty string, no matter the given length. */ NX_ASSERT(streqn("", "", 42)); /* Equality of unequal strings if length == 0 */ NX_ASSERT(streqn("bleh", "foo", 0)); /* Prefix equality of unequal strings */ NX_ASSERT(streqn("feh", "foo", 1)); /* * atou32() tests. */ NX_ASSERT(atou32("42", &u) && u == 42); NX_ASSERT(atou32("0", &u) && u == 0); NX_ASSERT(atou32("00000000000000", &u) && u == 0); NX_ASSERT(atou32("0042", &u) && u == 42); NX_ASSERT(!atou32("arthur", &u)); /* 4294967295 is 2^32-1, aka U32_MAX */ NX_ASSERT(atou32("4294967295", &u) && u == 4294967295U); NX_ASSERT(!atou32("4294967296", &u)); /* TODO: massive overflows don't get caught because of our naive * checking logic. Need to fix. */ NX_ASSERT(atou32("9999999999", &u)); /* * atos32() tests. */ NX_ASSERT(atos32("42", &s) && s == 42); NX_ASSERT(atos32("-42", &s) && s == -42); NX_ASSERT(atos32("0", &s) && s == 0); NX_ASSERT(atos32("-0", &s) && s == 0); NX_ASSERT(atos32("00000000000000", &s) && s == 0); NX_ASSERT(atos32("0042", &s) && s == 42); NX_ASSERT(atos32("-0042", &s) && s == -42); NX_ASSERT(!atos32("arthur", &s)); /* 2147483647 is 2^32-1, aka S32_MAX */ NX_ASSERT(atos32("2147483647", &s) && s == 2147483647); NX_ASSERT(atos32("-2147483647", &s) && s == -2147483647); NX_ASSERT(!atos32("2147483648", &s)); /* TODO: We should be able to represent -2^31, but our conversion logic * considers it an error. Fix it if one day we actually need -2^31. */ NX_ASSERT(!atos32("-2147483648", &s)); /* TODO: massive overflows and underflows don't get caught because * of our naive checking logic. Need to fix. */ NX_ASSERT(atos32("9999999999", &s)); NX_ASSERT(atos32("-9999999999", &s)); goodbye(); }