//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // MLRTexturePool::MLRTexturePool(GOSImagePool *image_pool, int insDep): RegisteredClass(DefaultData) { Check_Object(image_pool); Verify(gos_GetCurrentHeap() == Heap); instanceDepth = insDep; instanceMax = 1<<insDep; handleDepth = MLRState::TextureNumberBits - insDep; handleMax = 1<<handleDepth; freeHandle = new int [handleMax]; Register_Pointer(freeHandle); lastHandle = 0; firstFreeHandle = 0; lastFreeHandle = 0; storedTextures = 0; imagePool = image_pool; for(int i=0;i<MLRState::TextureMask+1;i++) { textureArray[i] = NULL; } unLoadedImages = false; }
//------------------------------------------------------------------------------ // gosFX::Effect__Specification::Effect__Specification( Stuff::RegisteredClass::ClassID class_id, Stuff::MemoryStream *stream, int gfx_version ): m_events(NULL) { Check_Pointer(this); Check_Object(stream); Verify(gos_GetCurrentHeap() == Heap); if (gfx_version < 9) { STOP(("This version of gosFX is no longer supported")); return; } // //-------------- // Read the name //-------------- // m_class = class_id; *stream >> m_name; // //-------------------------------------------------------------------- // Read the events. If we are using an array, no events will be saved //-------------------------------------------------------------------- // unsigned event_count; *stream >> event_count; while (event_count-- > 0) { Event *event = Event::Make(stream, gfx_version); Register_Object(event); m_events.Add(event); } // //-------------------------------------------------------- // Load the curves, variances, and MLRState if appropriate //-------------------------------------------------------- // m_lifeSpan.Load(stream, gfx_version); m_minimumChildSeed.Load(stream, gfx_version); m_maximumChildSeed.Load(stream, gfx_version); m_state.Load(stream, MidLevelRenderer::ReadMLRVersion(stream)); if (gfx_version < 14) { m_state.SetRenderPermissionMask( m_state.GetRenderPermissionMask() | MidLevelRenderer::MLRState::TextureMask ); } if ( m_state.GetAlphaMode() != MidLevelRenderer::MLRState::OneZeroMode && m_state.GetPriority() < MidLevelRenderer::MLRState::AlphaPriority ) m_state.SetPriority(MidLevelRenderer::MLRState::AlphaPriority); }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // MLR_I_L_TMesh::MLR_I_L_TMesh( ClassData *class_data, MemoryStream *stream, int version ): MLR_I_C_TMesh(class_data, stream, version) { Check_Pointer(this); Check_Pointer(stream); Verify(gos_GetCurrentHeap() == Heap); switch(version) { case 1: case 2: { STOP(("This class got created only after version 2 !")); } break; default: { MemoryStreamIO_Read(stream, &normals); } break; } litColors.SetLength(colors.GetLength()); }
//------------------------------------------------------------------------------ // gosFX::ShapeCloud__Specification::ShapeCloud__Specification( Stuff::MemoryStream *stream, int gfx_version ): SpinningCloud__Specification(gosFX::ShapeCloudClassID, stream, gfx_version) { Check_Pointer(this); Verify(m_class == ShapeCloudClassID); Verify(gos_GetCurrentHeap() == Heap); m_particleClassSize = sizeof(gosFX::ShapeCloud::Particle); m_totalParticleSize = sizeof(gosFX::ShapeCloud::Particle); // //--------------- // Load the shape //--------------- // m_shape = MidLevelRenderer::MLRShape::Make( stream, MidLevelRenderer::ReadMLRVersion(stream) ); Register_Object(m_shape); *stream >> m_radius; // //--------------------------------- // Make sure everything is in order //--------------------------------- // }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // MLRLookUpLight::MLRLookUpLight( Stuff::MemoryStream *stream, int version ) : MLRInfiniteLight(DefaultData, stream, version) { Check_Object(stream); Verify(gos_GetCurrentHeap() == Heap); *stream >> mapOrigin; *stream >> mapZoneCountX >> mapZoneCountZ; *stream >> zoneSizeX >> zoneSizeZ; *stream >> mapName; one_Over_zoneSizeX = 1.0f/zoneSizeX; one_Over_zoneSizeZ = 1.0f/zoneSizeZ; maps = new unsigned char * [mapZoneCountX * mapZoneCountZ]; Check_Pointer(maps); for(int i=0;i<mapZoneCountX*mapZoneCountZ;i++) { maps[i] = new unsigned char [256*256]; Check_Pointer(maps[i]); stream->ReadBytes(maps[i], 256*256); } }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // void MLR_I_C_DeT_TMesh::Copy( MLR_I_C_TMesh *tMesh, MLRState detailState, Stuff::Scalar xOff, Stuff::Scalar yOff, Stuff::Scalar xFac, Stuff::Scalar yFac ) { Check_Object(this); Check_Object(tMesh); Verify(gos_GetCurrentHeap() == Heap); int len; #if COLOR_AS_DWORD DWORD *_colors; #else RGBAColor *_colors; #endif MLR_I_DeT_TMesh::Copy(tMesh, detailState, xOff, yOff, xFac, yFac); tMesh->GetColorData(&_colors, &len); SetColorData(_colors, len); }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // MLRAmbientLight::MLRAmbientLight(Stuff::Page *page) : MLRLight(DefaultData, page) { Check_Object(page); Verify(gos_GetCurrentHeap() == Heap); lightMask = MLRState::FaceLightingMode|MLRState::VertexLightingMode; }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // MLRPointLight::MLRPointLight( Stuff::MemoryStream *stream, int version ) : MLRInfiniteLightWithFalloff(DefaultData, stream, version) { Check_Object(stream); Verify(gos_GetCurrentHeap() == Heap); lightMap = NULL; if (version > 7) { MString name; *stream >> name; if (name.GetLength() > 0) { Check_Object(MLRTexturePool::Instance); MLRTexture *texture = (*MLRTexturePool::Instance)(name, 0); if (!texture) texture = MLRTexturePool::Instance->Add(name, 0); Check_Object(texture); lightMap = new MLRLightMap(texture); Check_Object(lightMap); lightMask |= MLRState::LightMapLightingMode; } }
//------------------------------------------------------------------------------ // gosFX::ParticleCloud::ParticleCloud( ClassData *class_data, Specification *spec, unsigned flags ): Effect(class_data, spec, flags) { Check_Pointer(this); Check_Object(spec); Verify(gos_GetCurrentHeap() == Heap); // //------------------------------------------------ // Set up the data pointers into the channel block //------------------------------------------------ // m_data.SetLength(spec->m_maxParticleCount*spec->m_totalParticleSize); // //------------------------------- // Set up an empty particle cloud //------------------------------- // m_activeParticleCount = 0; m_birthAccumulator = 0.0f; }
//------------------------------------------------------------------------------ // void gosFX::Effect__Specification::AdoptEvent(Event *event) { Check_Object(this); Check_Object(event); Verify(event->m_time >= 0.0f && event->m_time <= 1.0f); Verify(gos_GetCurrentHeap() == Heap); // //----------------------------------------------------------- // The event must be inserted into the chain in order of time //----------------------------------------------------------- // Stuff::ChainIteratorOf<Event*> events(&m_events); Event *insert = NULL; while ((insert = events.GetCurrent()) != NULL) { Check_Object(insert); if (insert->m_time > event->m_time) { events.Insert(event); return; } events.Next(); } m_events.Add(event); }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // MLR_I_C_DeT_TMesh::MLR_I_C_DeT_TMesh( ClassData *class_data, MemoryStream *stream, int version ): MLR_I_DeT_TMesh(class_data, stream, version) { Check_Pointer(this); Check_Pointer(stream); Verify(gos_GetCurrentHeap() == Heap); switch(version) { case 1: case 2: { STOP(("This class got created only after version 2 !")); } break; default: { #if COLOR_AS_DWORD MemoryStreamIO_Read(stream, &colors); #else Stuff::DynamicArrayOf<DWORD> smallColors; MemoryStreamIO_Read(stream, &smallColors); int i, len = smallColors.GetLength(); colors.SetLength(len); DWORD theColor; for(i=0;i<len;i++) { theColor = smallColors[i]; colors[i].blue = (theColor & 0xff) * One_Over_256; theColor = theColor>>8; colors[i].green = (theColor & 0xff) * One_Over_256; theColor = theColor>>8; colors[i].red = (theColor & 0xff) * One_Over_256; theColor = theColor>>8; colors[i].alpha = (theColor & 0xff) * One_Over_256; } #endif } break; } actualColors = &colors; }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // MLR_I_C_DeT_TMesh::MLR_I_C_DeT_TMesh(ClassData *class_data): MLR_I_DeT_TMesh(class_data), colors(0) { Check_Pointer(this); Verify(gos_GetCurrentHeap() == Heap); actualColors = &colors; }
//------------------------------------------------------------------------------ // gosFX::ShapeCloud::ShapeCloud( Specification *spec, unsigned flags ): SpinningCloud(DefaultData, spec, flags) { Verify(gos_GetCurrentHeap() == Heap); }
//------------------------------------------------------------------------------ // gosFX::Card__Specification::Card__Specification(): Singleton__Specification(gosFX::CardClassID) { Check_Pointer(this); Verify(gos_GetCurrentHeap() == Heap); m_animated = false; m_width = 1; }
//------------------------------------------------------------------------------ // gosFX::ParticleCloud__Specification::ParticleCloud__Specification( Stuff::RegisteredClass::ClassID class_id ): Effect__Specification(class_id) { Verify(gos_GetCurrentHeap() == Heap); m_maxParticleCount = 0; Check_Pointer(this); }
//------------------------------------------------------------------------------ // gosFX::Shape::Shape( Specification *spec, unsigned flags ): Singleton(DefaultData, spec, flags) { Verify(gos_GetCurrentHeap() == Heap); m_radius = spec->m_radius; }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // MLRTexturePool::MLRTexturePool(MemoryStream *stream): RegisteredClass(DefaultData) { Verify(gos_GetCurrentHeap() == Heap); unLoadedImages = false; STOP(("Not implemented")); }
//------------------------------------------------------------------------------ // gosFX::Effect__Specification::Effect__Specification( Stuff::RegisteredClass::ClassID class_id ): m_events(NULL) { Check_Pointer(this); Verify(gos_GetCurrentHeap() == Heap); m_class = class_id; }
//------------------------------------------------------------------------------ // gosFX::Card__Specification::Card__Specification( Stuff::MemoryStream *stream, int gfx_version ): Singleton__Specification(gosFX::CardClassID, stream, gfx_version) { Check_Pointer(this); Verify(m_class == CardClassID); Verify(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_index.m_ageCurve.SetCurve(0.0f); m_index.m_seedCurve.SetCurve(1.0f); m_index.m_seeded = false; SeededCurveOf<ComplexCurve, LinearCurve,Curve::e_ComplexLinearType> temp; temp.Load(stream, gfx_version); Stuff::Scalar 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_index.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(); }
//------------------------------------------------------------------------------ // gosFX::Shape__Specification::Shape__Specification( MidLevelRenderer::MLRShape *shape ): Singleton__Specification(gosFX::ShapeClassID) { Check_Pointer(this); Verify(gos_GetCurrentHeap() == Heap); m_shape = NULL; SetShape(shape); }
//------------------------------------------------------------------------------ // gosFX::Event::Event(const Event& event): Plug(DefaultData) { Check_Pointer(this); Verify(gos_GetCurrentHeap() == Heap); m_time = event.m_time; m_flags = event.m_flags; m_effectID = event.m_effectID; }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // MLRAmbientLight::MLRAmbientLight( Stuff::MemoryStream *stream, int version ) : MLRLight(DefaultData, stream, version) { Check_Object(stream); Verify(gos_GetCurrentHeap() == Heap); lightMask = MLRState::FaceLightingMode|MLRState::VertexLightingMode; }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // MLRIndexedTriangleCloud::MLRIndexedTriangleCloud(int nr) : MLRTriangleCloud(nr) { Verify(gos_GetCurrentHeap() == Heap); usedNrOfPoints = NULL; Check_Pointer(this); drawMode = SortData::TriIndexedList; }
//------------------------------------------------------------------------------ // gosFX::ShapeCloud__Specification::ShapeCloud__Specification( MidLevelRenderer::MLRShape *shape ): SpinningCloud__Specification(gosFX::ShapeCloudClassID) { Check_Pointer(this); Verify(gos_GetCurrentHeap() == Heap); m_totalParticleSize = m_particleClassSize = sizeof(gosFX::ShapeCloud::Particle); m_shape = NULL; SetShape(shape); }
//------------------------------------------------------------------------------ // gosFX::Event::Event( Stuff::MemoryStream *stream, int gfx_version ): Plug(DefaultData) { Check_Pointer(this); Check_Object(stream); Verify(gos_GetCurrentHeap() == Heap); *stream >> m_time >> m_flags >> m_effectID >> m_localToParent; }
virtual void SetSubprimitiveLengths( unsigned char *length_array, int subprimitive_count ) { Check_Object(this); Verify(gos_GetCurrentHeap() == Heap); numOfTriangles = subprimitive_count; testList.SetLength(numOfTriangles); facePlanes.SetLength(numOfTriangles); }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // void MLRSorter::InitializeClass() { Verify(!DefaultData); Verify(gos_GetCurrentHeap() == StaticHeap); DefaultData = new ClassData( MLRSorterClassID, "MidLevelRenderer::MLRSorter", RegisteredClass::DefaultData ); Register_Object(DefaultData); }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // void MLRAmbientLight::InitializeClass() { Verify(!DefaultData); Verify(gos_GetCurrentHeap() == StaticHeap); DefaultData = new ClassData( MLRAmbientLightClassID, "MidLevelRenderer::MLRAmbientLight", MLRLight::DefaultData ); Register_Object(DefaultData); }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // void MLRLookUpLight::InitializeClass() { Verify(!DefaultData); Verify(gos_GetCurrentHeap() == StaticHeap); DefaultData = new ClassData( MLRLookUpLightClassID, "MidLevelRenderer::MLRLookUpLight", MLRInfiniteLight::DefaultData ); Check_Object(DefaultData); }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // MLRNGonCloud::MLRNGonCloud(int vertices, int nr) : MLREffect(nr, DefaultData) { Verify(gos_GetCurrentHeap() == Heap); usedNrOfNGons = NULL; numOfVertices = vertices; Check_Pointer(this); Verify(vertices*nr >= 0 && vertices*nr<=Limits::Max_Number_Vertices_Per_Mesh); specialClipColors.SetLength(vertices); drawMode = SortData::TriList; }