//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // return: true=math good, false=math unstable bool gosFX::SplineCurve::SetCurve( Stuff::Scalar v0, Stuff::Scalar v1 ) { Check_Object(this); m_a = 0.0f; m_b = 0.0f; m_slope = v1 - v0; m_value = v0; return Stuff::Close_Enough(m_slope + v0, v1); }
//------------------------------------------------------------------------------ // gosFX::ShapeCloud* gosFX::ShapeCloud::Make( Specification *spec, unsigned flags ) { Check_Object(spec); gos_PushCurrentHeap(Heap); ShapeCloud *cloud = new gosFX::ShapeCloud(spec, flags); gos_PopCurrentHeap(); return cloud; }
// //############################################################################# // GetSize //############################################################################# // CollectionSize PlugIterator::GetSize() { Check_Object(this); CollectionSize i = 0; First(); while (GetCurrentImplementation() != NULL) { i++; Next(); } return i; }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // void gosFX::ComplexCurve::Load( Stuff::MemoryStream *stream, int gfx_version ) { Check_Pointer(this); Check_Object(stream); if (gfx_version < 15) { Stuff::Scalar duration; *stream >> duration; }
//------------------------------------------------------------------------------ // gosFX::CardCloud__Specification::CardCloud__Specification( std::iostream stream, uint32_t gfx_version) : SpinningCloud__Specification(gosFX::CardCloudClassID, stream, gfx_version) { // Check_Pointer(this); Check_Object(stream); _ASSERT(m_class == CardCloudClassID); // _ASSERT(gos_GetCurrentHeap() == Heap); m_halfHeight.Load(stream, gfx_version); m_aspectRatio.Load(stream, gfx_version); // //------------------------------------------------------------------- // If we are reading an old version of the card cloud, ignore all the // animation on the UV channels //------------------------------------------------------------------- // if (gfx_version < 10) { m_pIndex.m_ageCurve.SetCurve(0.0f); m_pIndex.m_seedCurve.SetCurve(1.0f); m_pIndex.m_seeded = false; SeededCurveOf<ComplexCurve, LinearCurve, Curve::e_ComplexLinearType> temp; temp.Load(stream, gfx_version); float v = temp.ComputeValue(0.0f, 0.0f); m_UOffset.SetCurve(v); temp.Load(stream, gfx_version); v = temp.ComputeValue(0.0f, 0.0f); m_VOffset.SetCurve(v); m_USize.Load(stream, gfx_version); m_VSize.Load(stream, gfx_version); m_animated = false; } // //------------------------------ // Otherwise, read in the curves //------------------------------ // else { m_pIndex.Load(stream, gfx_version); m_UOffset.Load(stream, gfx_version); m_VOffset.Load(stream, gfx_version); m_USize.Load(stream, gfx_version); m_VSize.Load(stream, gfx_version); *stream >> m_animated; } SetWidth(); m_totalParticleSize = gosFX::CardCloud::ParticleSize; m_particleClassSize = sizeof(gosFX::CardCloud::Particle); }
//------------------------------------------------------------------------------ // void gosFX::CardCloud__Specification::Save(std::iostream stream) { // Check_Object(this); Check_Object(stream); SpinningCloud__Specification::Save(stream); m_halfHeight.Save(stream); m_aspectRatio.Save(stream); m_pIndex.Save(stream); m_UOffset.Save(stream); m_VOffset.Save(stream); m_USize.Save(stream); m_VSize.Save(stream); *stream << m_animated; }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // MLR_I_L_TMesh* MLR_I_L_TMesh::Make( MemoryStream *stream, int version ) { Check_Object(stream); gos_PushCurrentHeap(Heap); MLR_I_L_TMesh *mesh = new MLR_I_L_TMesh(DefaultData, stream, version); gos_PopCurrentHeap(); return mesh; }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // void MLR_I_C_DT_PMesh::GetColorData( #if COLOR_AS_DWORD DWORD **data, #else RGBAColor **data, #endif int *dataSize ) { Check_Object(this); *data = colors.GetData(); *dataSize = colors.GetLength(); }
virtual void SetReferenceState(const MLRState& _state, size_t pass = 0) { Check_Object(this); Verify((intptr_t(pass) >= 0) && pass < 2); if(pass == 0) { referenceState = _state; } else { passes = 2; referenceState2 = _state; } }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // void MLRNGonCloud::Draw (DrawEffectInformation *dInfo, GOSVertexPool *allVerticesToDraw, MLRSorter *sorter) { Check_Object(this); worldToEffect.Invert(*dInfo->effectToWorld); Transform(*usedNrOfNGons, numOfVertices); if( Clip(dInfo->clippingFlags, allVerticesToDraw) ) { sorter->AddEffect(this, dInfo->state); } }
GOSVertex* GetActualVertexPool(bool db=false) { Check_Object(this); if(db) { return verticesDB.GetData(); } else { return (GOSVertex*)((char*)(vertices.GetData() + lastUsed)+vertexAlignment); } }
void SetAnimateTexture(bool yesNo) { Check_Object(this); if(yesNo==true) { textureMatrixIsIdentity = false; } else { textureMatrixIsIdentity = true; textureMatrix = Stuff::AffineMatrix4D::Identity; } }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // bool gosFX::Curve::IsComplex() { Check_Object(this); return m_type == e_ComplexLinearType || m_type == e_ComplexComplexType || m_type == e_ComplexSplineType || m_type == e_ConstantComplexType || m_type == e_ConstantLinearType || m_type == e_ConstantSplineType || m_type == e_SplineSplineType || m_type == e_SplineLinearType; }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // void Note::GetEntry(UnitQuaternion *value) { Check_Object(this); Check_Pointer(value); const char *contents = NULL; GetEntry(&contents); Check_Pointer(contents); YawPitchRoll ypr; int count = sscanf( contents, "%f %f %f", &ypr.yaw, &ypr.pitch, &ypr.roll ); if (count != 3) { Page *page = m_page; Check_Object(page); NotationFile *file = page->m_notationFile; Check_Object(file); STOP(( "%s: {[%s]%s=%s} is not a UnitQuaternion!", file->GetFileName(), page->m_name, m_name, contents )); } ypr.yaw *= Radians_Per_Degree; ypr.pitch *= Radians_Per_Degree; ypr.roll *= Radians_Per_Degree; *value = ypr; }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // MLRIndexedPrimitive::MLRIndexedPrimitive( ClassData *class_data, MemoryStream *stream, int version ): MLRPrimitive(class_data, stream, version) { Check_Pointer(this); Check_Object(stream); MemoryStreamIO_Read(stream, &index); visibleIndexedVerticesKey = false; visibleIndexedVertices.SetLength(numVertices); }
// //########################################################################### // Next //########################################################################### // void HashIterator::Next() { Check_Object(this); if (vchainIterator != NULL) { Check_Object(vchainIterator); if (vchainIterator->GetCurrentPlug() != NULL) { // // Try to step to the next item in this list // vchainIterator->Next(); } if (vchainIterator->GetCurrentPlug() == NULL) { // // At end of list, step to the next list // NextSortedChainIterator(currentPosition+1); } } }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // void MLRLookUpLight::Write(Stuff::Page *page) { Check_Object(this); Check_Object(page); MLRInfiniteLight::Write(page); char data[256]; sprintf(data, "%f %f %f", mapOrigin.x, mapOrigin.y, mapOrigin.z); Verify(strlen(data) < sizeof(data)); page->SetEntry("MapOrigin", data); sprintf(data, "%d %d", mapZoneCountX, mapZoneCountZ); Verify(strlen(data) < sizeof(data)); page->SetEntry("MapSize", data); sprintf(data, "%f %f", zoneSizeX, zoneSizeZ); Verify(strlen(data) < sizeof(data)); page->SetEntry("ZoneSize", data); page->SetEntry("MapName", mapName); }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // void MLR_I_L_TMesh::SetNormalData( const Vector3D *data, int dataSize ) { Check_Object(this); Check_Pointer(data); Verify(coords.GetLength() == 0 || dataSize == coords.GetLength()); Verify(colors.GetLength() == 0 || dataSize == colors.GetLength()); Verify(texCoords.GetLength() == 0 || dataSize == texCoords.GetLength()); normals.AssignData(data, dataSize); }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // return: true=math good, false=math unstable bool gosFX::CurveKey::SetLinearKey( float key_time, float v0, float v1, float dt ) { Check_Object(this); Verify(dt > Stuff::SMALL); m_time = key_time; m_slope = (v1 - v0) / dt; m_value = v0; return Stuff::Close_Enough(m_slope * dt + v0, v1); }
//------------------------------------------------------------------------------ // gosFX::Effect__Specification* gosFX::Effect__Specification::Make( Stuff::MemoryStream *stream, int gfx_version ) { Check_Object(stream); gos_PushCurrentHeap(Heap); Effect__Specification *spec = new gosFX::Effect__Specification(EffectClassID, stream, gfx_version); gos_PopCurrentHeap(); return spec; }
void Spew( const char* group, const EulerAngles &angle ) { Check_Object(&angle); SPEW((group, "<+")); Spew(group, angle.pitch); SPEW((group, ",+")); Spew(group, angle.yaw); SPEW((group, ",+")); Spew(group, angle.roll); SPEW((group, ">+")); }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // Trace::Trace( const char* name, Type type ): Plug(DefaultData) { traceNumber = NextTraceID++; traceType = (BYTE)type; traceName = name; lastActivity = 0.0; Check_Object(TraceManager::Instance); TraceManager::Instance->Add(this); }
//------------------------------------------------------------------------------ // gosFX::ShapeCloud__Specification* gosFX::ShapeCloud__Specification::Make( Stuff::MemoryStream *stream, int gfx_version ) { Check_Object(stream); gos_PushCurrentHeap(Heap); ShapeCloud__Specification *spec = new gosFX::ShapeCloud__Specification(stream, gfx_version); gos_PopCurrentHeap(); return spec; }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // void MLRIndexedPrimitive::SetIndexData( unsigned short *index_array, int index_count ) { Check_Object(this); Check_Pointer(index_array); if(coords.GetLength() > 0) { visibleIndexedVertices.SetLength(coords.GetLength()); } index.AssignData(index_array, index_count); }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // void MLRIndexedPrimitive::Transform(Matrix4D *mat) { Check_Object(this); int i, len = coords.GetLength(); for(i=0;i<len;i++) { transformedCoords[i].Multiply(coords[i], *mat); } #ifdef LAB_ONLY Statistics::MLR_TransformedVertices += len; #endif }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // bool MLR_I_L_TMesh::Copy(MLR_I_L_PMesh *pMesh) { Check_Pointer(this); Check_Object(pMesh); int len; Vector3D *_normals; MLR_I_C_TMesh::Copy(pMesh); pMesh->GetNormalData(&_normals, &len); SetNormalData(_normals, len); return true; }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // int MLRIndexedPolyMesh::FindBackFace(const Point3D& u) { Check_Object(this); int i, numPrimitives = GetNumPrimitives(); int ret = 0, len = lengths.GetLength(); unsigned char *iPtr; Plane *p; if(len <= 0) { visible = 0; return 0; } p = &facePlanes[0]; iPtr = &testList[0]; if(state.GetBackFaceMode() == MLRState::BackFaceOffMode) { ResetTestList(); ret = 1; } else { for(i=0;i<numPrimitives;i++,p++,iPtr++) { // Scalar s = p->DistanceTo(u); // *iPtr = !Get_Sign_Bit(s); *iPtr = (p->DistanceTo(u) >= 0.0f) ? (unsigned char)1: (unsigned char)0; ret += *iPtr; } visible = ret ? (unsigned char)1 : (unsigned char)0; } visible = ret ? (unsigned char)1 : (unsigned char)0; FindVisibleVertices(); return ret; }
// //############################################################################# //############################################################################# // Scalar UnitQuaternion::GetAngle() { Check_Object(this); Scalar sine_of_half = Sqrt(x*x + y*y + z*z); if (Small_Enough(sine_of_half)) { return 0.0f; } SinCosPair half_angle(sine_of_half, w); Radian angle; angle = half_angle; return angle * 2.0f; }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // void Note::SetEntry(const RGBColor &value) { Check_Object(this); static char contents[32]; sprintf( contents, "%f %f %f", value.red, value.green, value.blue ); Verify(strlen(contents) < sizeof(contents)); SetEntry(contents); }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // void Note::SetEntry(const YawPitchRoll &value) { Check_Object(this); static char contents[32]; sprintf( contents, "%f %f %f", value.yaw * Degrees_Per_Radian, value.pitch * Degrees_Per_Radian, value.roll * Degrees_Per_Radian ); Verify(strlen(contents) < sizeof(contents)); SetEntry(contents); }