/* ** Command & Conquer Renegade(tm) ** Copyright 2025 Electronic Arts Inc. ** ** This program is free software: you can redistribute it and/or modify ** it under the terms of the GNU General Public License as published by ** the Free Software Foundation, either version 3 of the License, or ** (at your option) any later version. ** ** This program is distributed in the hope that it will be useful, ** but WITHOUT ANY WARRANTY; without even the implied warranty of ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ** GNU General Public License for more details. ** ** You should have received a copy of the GNU General Public License ** along with this program. If not, see . */ /*********************************************************************************************** *** C O N F I D E N T I A L --- W E S T W O O D S T U D I O S *** *********************************************************************************************** * * * Project Name : WW3D * * * * $Archive:: /Commando/Code/ww3d2/sphereobj.h $* * * * Author:: Jason Andersen * * * * $Modtime:: 11/24/01 6:21p $* * * * $Revision:: 7 $* * * *---------------------------------------------------------------------------------------------* * Functions: * * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ #if defined(_MSC_VER) #pragma once #endif #ifndef SPHEREOBJ_H #define SPHEREOBJ_H #include "always.h" #include "rendobj.h" #include "w3d_file.h" #include "shader.h" #include "proto.h" #include "obbox.h" #include "vector3i.h" #include "quat.h" #include "prim_anim.h" #include "meshgeometry.h" class TextureClass; struct AlphaVectorStruct { AlphaVectorStruct (void) : angle (true), intensity (1.0F) { } AlphaVectorStruct (const AlphaVectorStruct &src) { *this = src; } bool operator== (const AlphaVectorStruct &src) { return (angle.X == src.angle.X) && (angle.Y == src.angle.Y) && (angle.Z == src.angle.Z) && (intensity == src.intensity); } bool operator!= (const AlphaVectorStruct &src) { return ! operator== (src); } const AlphaVectorStruct & operator= (const AlphaVectorStruct &src) { angle = src.angle; intensity = src.intensity; return *this; } Quaternion angle; float intensity; }; class AlphaVectorChannel : public PrimitiveAnimationChannelClass { public: AlphaVectorStruct Evaluate (float time) { int key_count = m_Data.Count (); AlphaVectorStruct value = m_Data[key_count - 1].Get_Value (); // // Don't interpolate past the last keyframe // if (time < m_Data[key_count - 1].Get_Time ()) { // Check to see if the last key index is valid if (time < m_Data[m_LastIndex].Get_Time ()) { m_LastIndex = 0; } KeyClass *key1 = &m_Data[m_LastIndex]; KeyClass *key2 = &m_Data[key_count - 1]; // // Search, using last_key as our starting point // for (int keyidx = m_LastIndex; keyidx < (key_count - 1); keyidx ++) { if (time < m_Data[keyidx+1].Get_Time ()) { key1 = &m_Data[keyidx]; key2 = &m_Data[keyidx+1]; m_LastIndex = keyidx; break; } } // Calculate the linear percent between the two keys float percent = (time - key1->Get_Time ()) / (key2->Get_Time () - key1->Get_Time ()); // Slerp the quaternions and lerp the intensities value.intensity = (key1->Get_Value ().intensity + (key2->Get_Value ().intensity - key1->Get_Value ().intensity) * percent); Fast_Slerp (value.angle, key1->Get_Value ().angle, key2->Get_Value ().angle, percent); } return value; } }; struct W3dSphereStruct { uint32 Version; // file format version uint32 Attributes; // sphere attributes (above #define's) char Name[2*W3D_NAME_LEN]; // name is in the form . W3dVectorStruct Center; // center of the sphere W3dVectorStruct Extent; // extent of the sphere float AnimDuration; // Animation time (in seconds) W3dVectorStruct DefaultColor; float DefaultAlpha; W3dVectorStruct DefaultScale; AlphaVectorStruct DefaultVector; char TextureName[2*W3D_NAME_LEN]; W3dShaderStruct Shader; // // Note this structure is followed by a series of // W3dSphereKeyArrayStruct structures which define the // variable set of keyframes for each channel. // }; typedef LERPAnimationChannelClass SphereColorChannelClass; typedef LERPAnimationChannelClass SphereAlphaChannelClass; typedef LERPAnimationChannelClass SphereScaleChannelClass; typedef AlphaVectorChannel SphereVectorChannelClass; //typedef AlphaVectorChannel ; class VertexMaterialClass; class SphereMeshClass { friend class SphereRenderObjClass; public: // Constructor SphereMeshClass(void); SphereMeshClass(float radius, int slices, int stacks); // Destructor ~SphereMeshClass(void); void Generate (float radius, int slices, int stacks); int Get_Num_Polys (void) { return face_ct; }; void Set_Alpha_Vector (const AlphaVectorStruct &v, bool inverse, bool is_additive, bool force = false); private: void Set_DCG (bool is_additive, int index, float value); void Free(void); float Radius; int Slices; int Stacks; int face_ct; // # of faces int Vertex_ct; // vertex count Vector3 *vtx; // array of vertices Vector3 *vtx_normal; // array of vertex normals Vector2 *vtx_uv; // array of vertex uv coordinates Vector4 *dcg; AlphaVectorStruct alpha_vector; // vector last used to computer vtx_alpha array bool inverse_alpha; // inverse alpha, or not bool IsAdditive; int strip_ct; // number of strips int strip_size; // size of each strip int *strips; // array of vertex indices for each strip (# stripbs x sizeof strip) int fan_ct; // number of fans int fan_size; // size of each fan int *fans; // array of vertex indices for each fan (# of fans by fan_size) TriIndex *tri_poly; // array of triangle poly's, vertex indices (can be discard if switched to strips + fans) }; inline void SphereMeshClass::Set_DCG (bool is_additive, int index, float value) { if (is_additive) { dcg[index].X = value; dcg[index].Y = value; dcg[index].Z = value; dcg[index].W = 0; } else { dcg[index].X = 1.0F; dcg[index].Y = 1.0F; dcg[index].Z = 1.0F; dcg[index].W = value; } return ; } /* ** SphereRenderObjClass: Procedurally generated render spheres ** */ class SphereRenderObjClass : public RenderObjClass { public: // These are bit masks, so they should enum 1,2,4,8,10,20,40 etc... enum SphereFlags { USE_ALPHA_VECTOR = 0x00000001, USE_CAMERA_ALIGN = 0x00000002, USE_INVERSE_ALPHA = 0x00000004, USE_ANIMATION_LOOP= 0x00000008, }; SphereRenderObjClass(void); SphereRenderObjClass(const W3dSphereStruct & def); SphereRenderObjClass(const SphereRenderObjClass & src); SphereRenderObjClass & operator = (const SphereRenderObjClass &); ~SphereRenderObjClass(void); ///////////////////////////////////////////////////////////////////////////// // Render Object Interface ///////////////////////////////////////////////////////////////////////////// virtual RenderObjClass * Clone(void) const; virtual int Class_ID(void) const; virtual void Render(RenderInfoClass & rinfo); virtual void Special_Render(SpecialRenderInfoClass & rinfo); virtual void Set_Transform(const Matrix3D &m); virtual void Set_Position(const Vector3 &v); virtual void Get_Obj_Space_Bounding_Sphere(SphereClass & sphere) const; virtual void Get_Obj_Space_Bounding_Box(AABoxClass & aabox) const; virtual void Set_Hidden(int onoff) { RenderObjClass::Set_Hidden (onoff); Update_On_Visibilty (); } virtual void Set_Visible(int onoff) { RenderObjClass::Set_Visible (onoff); Update_On_Visibilty (); } virtual void Set_Animation_Hidden(int onoff) { RenderObjClass::Set_Animation_Hidden (onoff); Update_On_Visibilty (); } virtual void Set_Force_Visible(int onoff) { RenderObjClass::Set_Force_Visible (onoff); Update_On_Visibilty (); } const AABoxClass & Get_Box(void); virtual int Get_Num_Polys(void) const; virtual const char * Get_Name(void) const; virtual void Set_Name(const char * name); unsigned int Get_Flags(void) { return Flags; } void Set_Flags(unsigned int flags) { Flags = flags; } void Set_Flag(unsigned int flag, bool onoff) { Flags &= (~flag); if (onoff) Flags |= flag; } // Animation access bool Is_Animating (void) { return IsAnimating; } void Start_Animating (void) { IsAnimating = true; anim_time = 0; } void Stop_Animating (void) { IsAnimating = false; anim_time = 0; } // Current state access void Set_Color(const Vector3 & color) { Color = color; } void Set_Alpha(float alpha) { Alpha = alpha; } void Set_Scale(const Vector3 & scale) { Scale = scale; } void Set_Vector(const AlphaVectorStruct &v) { Vector = v; } const Vector3 & Get_Color(void) const { return Color; } float Get_Alpha(void) const { return Alpha; } const Vector3 & Get_Scale(void) const { return Scale; } const AlphaVectorStruct & Get_Vector(void) const { return Vector; } Vector3 Get_Default_Color(void) const; float Get_Default_Alpha(void) const; Vector3 Get_Default_Scale(void) const; AlphaVectorStruct Get_Default_Vector(void) const; // Size/position methods void Set_Extent (const Vector3 &extent); void Set_Local_Center_Extent(const Vector3 & center,const Vector3 & extent); void Set_Local_Min_Max(const Vector3 & min,const Vector3 & max); // Texture access void Set_Texture(TextureClass *tf); TextureClass * Peek_Texture(void) {return SphereTexture;} ShaderClass & Get_Shader(void) {return SphereShader;} void Set_Shader(ShaderClass &shader) {SphereShader=shader;} // Animation control float Get_Animation_Duration (void) const { return AnimDuration; } void Set_Animation_Duration (float time) { AnimDuration = time; Restart_Animation (); } void Restart_Animation (void) { anim_time = 0; } // Animatable channel access SphereColorChannelClass & Get_Color_Channel (void) { return ColorChannel; } const SphereColorChannelClass & Peek_Color_Channel (void) { return ColorChannel; } SphereAlphaChannelClass & Get_Alpha_Channel (void) { return AlphaChannel; } const SphereAlphaChannelClass & Peek_Alpha_Channel (void) { return AlphaChannel; } SphereScaleChannelClass & Get_Scale_Channel (void) { return ScaleChannel; } const SphereScaleChannelClass & Peek_Scale_Channel (void) { return ScaleChannel; } SphereVectorChannelClass & Get_Vector_Channel (void) { return VectorChannel; } const SphereVectorChannelClass & Peek_Vector_Channel (void) { return VectorChannel; } void Set_Color_Channel (const SphereColorChannelClass &data) { ColorChannel = data; } void Set_Alpha_Channel (const SphereAlphaChannelClass &data) { AlphaChannel = data; } void Set_Scale_Channel (const SphereScaleChannelClass &data) { ScaleChannel = data; } void Set_Vector_Channel (const SphereVectorChannelClass &data) { VectorChannel = data; } protected: virtual void update_cached_box(void); virtual void Update_Cached_Bounding_Volumes(void) const; void Update_On_Visibilty(void); // Initialization stuff void Init_Material (void); static void Generate_Shared_Mesh_Arrays (const AlphaVectorStruct &alphavector); // Animation Stuff void animate(void); // animation update function float anim_time; // what time in seconds are we in the animation float AnimDuration; bool IsAnimating; SphereColorChannelClass ColorChannel; SphereAlphaChannelClass AlphaChannel; SphereScaleChannelClass ScaleChannel; SphereVectorChannelClass VectorChannel; void update_mesh_data(const Vector3 & center,const Vector3 & extent); void render_sphere(); void vis_render_sphere(SpecialRenderInfoClass & rinfo,const Vector3 & center,const Vector3 & extent); char Name[2*W3D_NAME_LEN]; Vector3 ObjSpaceCenter; Vector3 ObjSpaceExtent; int CurrentLOD; // Current State Vector3 Color; float Alpha; Vector3 Scale; AlphaVectorStruct Vector; Quaternion Orientation; // Flags unsigned int Flags; VertexMaterialClass *SphereMaterial; ShaderClass SphereShader; TextureClass *SphereTexture; AABoxClass CachedBox; // Friend classes friend class SpherePrototypeClass; }; inline void SphereRenderObjClass::Set_Extent (const Vector3 &extent) { ObjSpaceExtent = extent; update_cached_box(); Update_Cached_Bounding_Volumes(); } inline void SphereRenderObjClass::Set_Local_Center_Extent(const Vector3 & center,const Vector3 & extent) { ObjSpaceCenter = center; ObjSpaceExtent = extent; update_cached_box(); } inline void SphereRenderObjClass::Set_Local_Min_Max(const Vector3 & min,const Vector3 & max) { ObjSpaceCenter = (max + min) / 2.0f; ObjSpaceExtent = (max - min) / 2.0f; update_cached_box(); } inline const AABoxClass & SphereRenderObjClass::Get_Box(void) { Validate_Transform(); update_cached_box(); return CachedBox; } /* ** Loader for spheres */ class SphereLoaderClass : public PrototypeLoaderClass { public: virtual int Chunk_Type (void) { return W3D_CHUNK_SPHERE; } virtual PrototypeClass * Load_W3D(ChunkLoadClass & cload); }; /* ** Prototype for Sphere objects */ class SpherePrototypeClass : public PrototypeClass { public: SpherePrototypeClass (void); SpherePrototypeClass (SphereRenderObjClass *sphere); ~SpherePrototypeClass (void); virtual const char * Get_Name(void) const; virtual int Get_Class_ID(void) const; virtual RenderObjClass * Create(void); bool Load (ChunkLoadClass &cload); bool Save (ChunkSaveClass &csave); private: W3dSphereStruct Definition; SphereColorChannelClass ColorChannel; SphereAlphaChannelClass AlphaChannel; SphereScaleChannelClass ScaleChannel; SphereVectorChannelClass VectorChannel; }; /* ** Instance of the loader which the asset manager installs */ extern SphereLoaderClass _SphereLoader; #endif // SPHEREOBJ_H // EOF - sphereobj,h