Renegade/Code/Tools/max2w3d/vchannel.cpp

/*
**	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 <http://www.gnu.org/licenses/>.
*/

/* $Header: /Commando/Code/Tools/max2w3d/vchannel.cpp 12    11/29/01 2:17p Greg_h $ */
/*********************************************************************************************** 
 ***                            Confidential - Westwood Studios                              *** 
 *********************************************************************************************** 
 *                                                                                             * 
 *                 Project Name : Commando Tools - W3D export                                  * 
 *                                                                                             * 
 *                     $Archive:: /Commando/Code/Tools/max2w3d/vchannel.cpp                   $* 
 *                                                                                             * 
 *                      $Author:: Greg_h                                                      $* 
 *                                                                                             * 
 *                     $Modtime:: 11/29/01 2:17p                                              $* 
 *                                                                                             * 
 *                    $Revision:: 12                                                          $* 
 *                                                                                             * 
 *---------------------------------------------------------------------------------------------* 
 * Functions:                                                                                  * 
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */


#include "vchannel.h"
#include <assert.h>
#include <string.h>
#include <stdlib.h>
#include "w3d_file.h"
#include "w3dquat.h"
#include "bchannel.h"
#include "exportlog.h"


#define FILTER_TABLE_SIZE (256)
#define FILTER_TABLE_GEN_START (16)
#define FILTER_TABLE_GEN_SIZE  (FILTER_TABLE_SIZE - FILTER_TABLE_GEN_START)

static float filtertable[FILTER_TABLE_SIZE] = {
	0.00000001f,
	0.0000001f,
	0.000001f,
	0.00001f,
	0.0001f,
	0.001f,
	0.01f,
	0.1f,
	1.0f,
	10.0f,
	100.0f,
	1000.0f,
	10000.0f,
	100000.0f,
	1000000.0f,
	10000000.0f,

};
static bool table_valid = false; 


VectorChannelClass::VectorChannelClass
(
	uint32 id,
	int maxframes,
	uint32 flags,
	int vectorlength,
	float32 * identvect
) :
	ID(id),
	Flags(flags),
	MaxFrames(maxframes),
	VectorLen(vectorlength),
	IsEmpty(true),
	IdentVect(NULL),
	Data(NULL),
	Begin(0),
	End(0),
	ReduceAnimation(false),
	ReduceAnimationPercent(0),
	CompressAnimation(false),
	CompressAnimationFlavor(0),
	CompressAnimationTranslationError(0.0f),
	CompressAnimationRotationError(0.0f)
{

	assert(VectorLen > 0);
	IdentVect = new float32[VectorLen];
	Data = new float32[MaxFrames * VectorLen];
	assert(Data);
	assert(IdentVect);

	memcpy(IdentVect,identvect,VectorLen * sizeof(float32));
	memset(Data,0,MaxFrames * VectorLen * sizeof(float32));

	// start "Begin" at the end of the array, whenever we set a value
	// at an index less than "Begin", we push "Begin" back.
	Begin = MaxFrames;
	End = 0;	
	
	if (false == table_valid) {
		// Create Filter Table, used in delta compression

		for (int i=0; i<FILTER_TABLE_GEN_SIZE; i++)
		{
			float ratio = i;

			//ratio = ((ratio + 1.0f) / 128.0f); 
			ratio/=((float) FILTER_TABLE_GEN_SIZE);

			filtertable[i + FILTER_TABLE_GEN_START] = 1.0f - sin( DEG_TO_RAD(90.0f * ratio));
		}

		table_valid = true;

	}

  																											
}

VectorChannelClass::~VectorChannelClass(void)
{
	if (Data) {
		delete[] Data;
	}
	if (IdentVect) {
		delete[] IdentVect;
	}							 
}

void VectorChannelClass::Set_Vector(int frameidx,float32 * vector)
{
	assert(frameidx >= 0);
	assert(frameidx < MaxFrames);

	for (int vi=0; vi<VectorLen; vi++) {
		set_value(frameidx,vi,vector[vi]);
	}

	if (!is_identity(vector)) {
		IsEmpty = false;
	}
}

float * VectorChannelClass::Get_Vector(int frameidx)
{
	assert(frameidx >= 0);
	assert(frameidx < MaxFrames);

	return &(Data[frameidx * VectorLen]);
}
	

bool VectorChannelClass::SaveTimeCoded(ChunkSaveClass & csave, BitChannelClass *binmov)
{
	uint32 channelsize  = sizeof(W3dTimeCodedAnimChannelStruct);
	uint32 packetsize   = (VectorLen * sizeof(float32)) + sizeof(uint32);
	channelsize			 += packetsize * MaxFrames;
	channelsize			 -= sizeof(uint32);

	W3dTimeCodedAnimChannelStruct * chn = (W3dTimeCodedAnimChannelStruct *)malloc(channelsize);
	
	if (chn == NULL) {
		return false;
	}
  
	chn->NumTimeCodes = MaxFrames;
	chn->VectorLen = VectorLen;
	chn->Pivot = ID;
	chn->Flags = Flags;
	
	// Fetch Channel Data into new format
	// tc [data] tc [data] tc [data] .. ...
	uint32 fidx = 0;

	for (int fcount=0; fcount < MaxFrames; fcount++, fidx += (VectorLen+1) ) {
		
		uint32	* pivec;
		float32	* pfvec;

		pivec = 	&chn->Data[ fidx ];
		pfvec = 	(float32 *) (pivec + 1);
		
		*pivec = fcount;
								
		if (binmov) {
			
			bool binary_move = binmov->Get_Bit( fcount );

			// check for false binary movement
			if (fcount != Begin) {
				if (binary_move)  {
   				*pivec |= W3D_TIMECODED_BINARY_MOVEMENT_FLAG;
				}																		  
			}
			else {
				//if (log) log->printf("\nFALSE Binary\n");
			}
		} 
   
		
		// Copy Vector
		for (int vidx=0; vidx < VectorLen; vidx++) {

			pfvec[vidx] = get_value(fcount,vidx);
		}
	}

	// Compress the new structure

	VectorChannelClass::compress( chn );

	// update the size

	float original_channelsize = channelsize;

	channelsize  = sizeof(W3dTimeCodedAnimChannelStruct);
	channelsize += packetsize * chn->NumTimeCodes;
	channelsize -= sizeof(uint32);

	float percent = (((float)channelsize) / original_channelsize) * 100.0f;
	// save

	ExportLog::printf("%.0f", percent);

	if (csave.Write(chn,channelsize) != channelsize) {
		return false;
	}
	
	if (chn != NULL) {
		free(chn);
	}

	if (!csave.End_Chunk()) {
		return false;
	}
	
	return true;

} // SaveTimeCoded


/*
struct W3dAdaptiveDeltaAnimChannelStruct
{
	uint32		NumFrames;			// number of frames of animation
	uint16		Pivot;				// pivot effected by this channel
	uint8			VectorLen;			// num Channels
	uint8			Flags;				// channel type
	float			Scale;				// Filter Table Scale

	uint32		Data[1];				// OpCode Data Stream

};
*/

struct 
{
	unsigned	char	filter : 7;
	unsigned char	flag   : 1;
	unsigned char	d0		 : 4;
	unsigned char  d1     : 4;
	unsigned char	d2		 : 4;
	unsigned char  d3     : 4;
	unsigned char	d4		 : 4;
	unsigned char  d5     : 4;
	unsigned char	d6		 : 4;
	unsigned char  d7     : 4;
	unsigned char	d8		 : 4;
	unsigned char  d9     : 4;
	unsigned char	d10	 : 4;
	unsigned char  d11    : 4;
	unsigned char	d12	 : 4;
	unsigned char  d13    : 4;
	unsigned char	d14	 : 4;
	unsigned char  d15    : 4;

} AdaptiveDeltaPacketStruct;
							 	  
//
//	test compress Adaptive Delta packet
//
// inputs:  filter - forced filter to use
//				scale (filter table scale)
//				value1 (continue compression from this initial value)
//				float *indata  // 16 values to compress
//				float *outdata	// 16 decompressed values
//
// output: float error;		// aggregate error for packet
//                          
float VectorChannelClass::test_compress(int filter_index, float scale, float value1, float *indata, float *outdata)
{		
	
   float error = 0.0f;						
                     
   // compute filter
   
   float filter = filtertable[filter_index] * scale;
   			  
   assert(filter_index < FILTER_TABLE_SIZE);
                          
   float last_value = value1;	
      
   for(int data_idx=0; data_idx < 16; data_idx++)  {
   		
      // NOTE: DETERMINE best factor via Brute Force
      // This helps under/over-flow problems
      
      // brute
      int   best_factor = 100;
      float	least_error = 999999999.9f;
      for (float try_factor = -8.0f; try_factor < 8.0f; try_factor+=1.0f)  {
      	float temp = (try_factor * filter) + last_value; // decompress using this filter
         temp-=indata[data_idx];									 // delta decompressed value, vs original value
         temp=fabs(temp);
         if (temp < least_error)  {
         	least_error = temp;
            best_factor = try_factor;
         }
      }
      assert(best_factor <= 7);
      assert(best_factor >=-8);
      																	 
      float dfactor = best_factor;
                                                          
      outdata[data_idx] = (dfactor * filter) + last_value;
      // END BRUTE FORCE IT
      
		float delta = outdata[data_idx] - indata[data_idx];

		//if (delta > error) error = delta;
      error+= (delta * delta); 

      last_value = outdata[data_idx];
   }		
   
   return( sqrt(error) );
	
} // test_compress	
          
//
//	compress Adaptive Delta packet
//
// inputs:  filter - forced filter to use
//				scale (filter table scale)
//				value1 (continue compression from this initial value)
//				float *indata  // 16 values to compress
//				unsigned char *pPacket
//
// output: float error;		// aggregate error for packet
//                          
float VectorChannelClass::compress(int filter_index, float scale, float value1, float *indata, unsigned char *pPacket, float *outdata)
{			
   float error = 0.0f;						
                     
   // compute filter
   
   float filter = filtertable[filter_index] * scale;
   			  
   assert(filter_index < FILTER_TABLE_SIZE);
                          
   *pPacket = filter_index;
   pPacket++;
   
   float last_value = value1;	
      
   for(int data_idx=0; data_idx < 16; data_idx++)  {
   		
      // NOTE: PLAN TO ADD A LOOP IN HERE, to DETERMINE best factor via Brute Force
      // This could help under/over-flow problems
      {
      	// brute
         int   best_factor = 100;
         float	least_error = 999999999.9f;
       	for (float try_factor = -8.0f; try_factor < 8.0f; try_factor+=1.0f)  {
       		float temp = (try_factor * filter) + last_value; // decompress using this filter
            temp-=indata[data_idx];									 // delta decompressed value, vs original value
            temp=fabs(temp);
            if (temp < least_error)  {
            	least_error = temp;
               best_factor = try_factor;
            }
       	}
         assert(best_factor <= 7);
         assert(best_factor >=-8);
         																	 
         float dfactor = best_factor;
           
         outdata[data_idx] = (dfactor * filter) + last_value;

         int pi = data_idx>>1;  
         
			if (data_idx & 1) {
				best_factor<<=4;
				pPacket[pi]&=0x0f;
				pPacket[pi]|=best_factor;
			}
			else {
			  	best_factor&=0xf;
				pPacket[pi]&=0xf0;
				pPacket[pi]|=best_factor;
			}
      }
             
      // END BRUTE FORCE IT
      
      error+=fabs(outdata[data_idx] - indata[data_idx]); 
      
      last_value = outdata[data_idx];
      	
   }		
   
   return( error );
	
} // compress	
                      

bool VectorChannelClass::SaveAdaptiveDelta(ChunkSaveClass & csave, BitChannelClass *binmov)
{
	uint32 channelsize  = sizeof(W3dAdaptiveDeltaAnimChannelStruct);
	int packetsize   = sizeof(AdaptiveDeltaPacketStruct);
	int numpackets   = (MaxFrames + 15) / 16;
	channelsize		 += packetsize * numpackets * VectorLen;
	channelsize		 -= sizeof(char);
	channelsize     += VectorLen * sizeof(float);

	W3dAdaptiveDeltaAnimChannelStruct * chn = (W3dAdaptiveDeltaAnimChannelStruct *)malloc(channelsize);
	
	if (chn == NULL) {
		return false;
	}

// Brute Force Compressor

	// Initialize Chan Data
	chn->NumFrames = MaxFrames;
	chn->Pivot = ID;
	chn->VectorLen = VectorLen;
	chn->Flags = Flags;
	chn->Scale = 0.0f;
	memset(&chn->Data[0], channelsize - (sizeof(W3dAdaptiveDeltaAnimChannelStruct) - sizeof(char)), 0x00);
	
	assert(VectorLen <= 4);	// otherwise temp vector won't have room

	float	*initial = (float *)&chn->Data[0];
	float work[4];

	// Fetch initial value
	for (int i=0; i < VectorLen; i++) {
		work[i] = initial[i] = get_value(0, i);
	}

	float  original_packet[16];
	float  decompressed_packet[16];
	float  scale = 0.0f;
	float  last_value=0.0f;
	int	 frame = 1;
	float delta;

	// Compute Scale

	for (int fidx=1; fidx < MaxFrames; fidx++) {
		for (i=0; i<VectorLen; i++) {
			
			delta = fabs( get_value(fidx, i) - get_value(fidx - 1, i));

			if (delta > scale) scale = delta;
		}
	}

	scale/=7.0f;	// range of the delta encode is +- 7 units, in which ever filter range
						// the smaller the scale, the better our precision is going to be
						
	// End Compute Scale

	for (i=0; i < numpackets; i++) {
		for (int vi=0; vi<VectorLen; vi++) {
			last_value = work[vi];
			// Copy Original Data into the original packet
			int temp_frame = frame;

			for(int gi=0; gi<16; gi++) {
				
				if (temp_frame < MaxFrames) {
					last_value = original_packet[gi] = get_value(temp_frame, vi);
				}
				else {
					original_packet[gi] = last_value;
				}

				temp_frame++;

			} // for gi
			
         // Brute Force Filter	
         
         int   best_filter = 2 * FILTER_TABLE_SIZE;
         float least_error = 999999999.9f;  		  
         last_value = work[vi];
            
         for(int try_filter=0; try_filter < FILTER_TABLE_SIZE; try_filter++) {
         
         	float temp_error = test_compress(try_filter, scale, last_value, original_packet, decompressed_packet);
                      			 
            if (temp_error < least_error)  {
            	best_filter = try_filter;
               least_error = temp_error;
            }                   
                              
         }	 
         
         assert(best_filter < FILTER_TABLE_SIZE);
			
         //log->printf("\nvi= %d frames %d to %d : error = %f ",vi, frame, frame+15, least_error);		
               
			// Encode current packet

			unsigned char * pPacket;

			pPacket = (unsigned char *) &chn->Data[0];			// beginning of data struct
			pPacket+= (VectorLen * sizeof(float));					// skip over initial values
			pPacket+= (sizeof(AdaptiveDeltaPacketStruct) * VectorLen * ((frame-1)>>4));  // skip up to the appropriate packet
			pPacket+=  sizeof(AdaptiveDeltaPacketStruct) * vi;	// skip up the appropriate vector index
					  
         compress(best_filter, scale, last_value, original_packet, pPacket, decompressed_packet);

			// update work[vi];
			work[vi] = decompressed_packet[15];

		}	// for vi
		frame+=16;
	}  // for numpackets


	// print how big we are vs non-compressed
	float rawsize = sizeof(W3dAnimChannelStruct);
	rawsize += (VectorLen * sizeof(float32) * (MaxFrames)) - sizeof(float32);

	float percent = ((float)channelsize) / rawsize;
	percent*=100.0f;

	ExportLog::printf("%.0f", percent);


	// update final scale
	chn->Scale = scale;

	if (csave.Write(chn,channelsize) != channelsize) {
		return false;
	}
	
	if (chn != NULL) {
		free(chn);
	}

	if (!csave.End_Chunk()) {
		return false;
	}
	
	return true;

} // SaveAdaptiveDelta

			
bool VectorChannelClass::Save(ChunkSaveClass & csave, BitChannelClass *binmov)
{
	if (IsEmpty) return true;
 	
	compute_range();
	if (End<Begin) {
		IsEmpty = true;
		return true;
	}

	if (CompressAnimation) {
		// Save the Channel Data compressed
		// TIMECODED

		if (!csave.Begin_Chunk(W3D_CHUNK_COMPRESSED_ANIMATION_CHANNEL)) {
			return false;
		}

		switch (CompressAnimationFlavor) 
		{
			case ANIM_FLAVOR_TIMECODED:
				{
					return(SaveTimeCoded(csave, binmov));

					break;
				}

			case ANIM_FLAVOR_ADAPTIVE_DELTA:
				{
					return(SaveAdaptiveDelta(csave, binmov));

					break;
				}

			default:
				assert(0);		// unknown compressed format
				return false;
		}

	}
	else {
		// Classic Non Compressed Data

		if (!csave.Begin_Chunk(W3D_CHUNK_ANIMATION_CHANNEL)) {
			return false;
		}


		unsigned int channelsize = sizeof(W3dAnimChannelStruct);
		int num_frames = End - Begin + 1;
		channelsize += VectorLen * sizeof(float32) * (num_frames) - sizeof(float32);

		W3dAnimChannelStruct * chn = (W3dAnimChannelStruct *)malloc(channelsize);
		
		if (chn == NULL) {
			return false;
		}
  
		chn->FirstFrame = Begin;
		chn->LastFrame = End;
		chn->VectorLen = VectorLen;
		chn->Pivot = ID;
		chn->Flags = Flags;
		
		for (int fcount=0; fcount < num_frames; fcount++) {
			for (int vidx=0; vidx < VectorLen; vidx++) {

				int writeidx = fcount * VectorLen + vidx;

				chn->Data[writeidx] = get_value(Begin + fcount,vidx);
			}
		}

		if (csave.Write(chn,channelsize) != channelsize) {
			return false;
		}
		
		if (chn != NULL) {
			free(chn);
		}

		if (!csave.End_Chunk()) {
			return false;
		}

	}

	return true;
}

void VectorChannelClass::SetSaveOptions(bool compress, int flavor, float Terr, float Rerr, bool reduce, int reduce_percent)
{

	ReduceAnimation = reduce;
	ReduceAnimationPercent = reduce_percent;
	CompressAnimation = compress;
	CompressAnimationFlavor = flavor;
	CompressAnimationTranslationError = Terr;
	CompressAnimationRotationError = DEG_TO_RAD(Rerr);

} // SetSaveOptions

//
//  Set data in motion channel to identity vector
//  R2 - set invisible data to repeat last known position, the previous algorthm caused problems with 
//  the current movie assets
//
void VectorChannelClass::ClearInvisibleData(BitChannelClass *vis)
{
	float *tvec;

	assert(VectorLen <= 8);

	bool prev_state = vis->Get_Bit( 0 );

	tvec = Get_Vector( 0 );

	for (int idx=0; idx < MaxFrames; idx++) {

		bool cur_state = vis->Get_Bit( idx );

		if (cur_state != prev_state) {
			prev_state = cur_state;
			tvec = Get_Vector( idx );
		}

		if (false == cur_state) {
			//Set_Vector( idx, IdentVect );
			Set_Vector( idx, tvec );
		}
	}
} // ClearInvisibleData


void VectorChannelClass::set_value(int framenum,int vindex,float32 val)
{
	assert(framenum >= 0);
	assert(framenum < MaxFrames);
	assert(vindex >= 0);
	assert(vindex < VectorLen);

	Data[framenum * VectorLen + vindex] = val;
}

float32 VectorChannelClass::get_value(int framenum,int vindex)
{
	assert(framenum >= 0);
	assert(framenum < MaxFrames);
	assert(vindex >= 0);
	assert(vindex < VectorLen);

	return Data[framenum * VectorLen + vindex];
}

bool VectorChannelClass::is_identity(float32 * vec)
{
	const double ERROR_TOLERANCE = 0.00005 * 0.00005;
	double dist = 0.0;

	for (int vi=0; vi<VectorLen; vi++) {
 		dist += (vec[vi] - IdentVect[vi])*(vec[vi] - IdentVect[vi]);
	}

	// if distance from identity is very small, it is identity...
	if (dist < ERROR_TOLERANCE) {
		return true;
	} else {
		return false;
	}
}

void VectorChannelClass::compute_range(void)
{
	Begin = 0;
	while ((Begin < MaxFrames) && (is_identity(Get_Vector(Begin)))) {
		Begin++;
	}

	End = MaxFrames-1;
	while ((End >= 0) && (is_identity(Get_Vector(End)))) {
		End--;
	}
}	// compute_range


//
//  Remove a packet from a W3dTimeCodedAnimChanelStruct
//
void VectorChannelClass::remove_packet(W3dTimeCodedAnimChannelStruct * c, uint32 packet_idx)
{												
	assert( c );
	assert( c->NumTimeCodes > 1 );
	
	uint32 packet_size = c->VectorLen + 1;
	uint32 packet_len  = packet_size * sizeof(uint32);
  												 
	uint32 *src, *dst;
  
	dst = (uint32 *) &c->Data[ packet_size * packet_idx ];
	src = (uint32 *) &c->Data[ packet_size * (packet_idx + 1) ];
   									 
	uint32 copy_length = (c->NumTimeCodes - (packet_idx + 1)) * packet_len;
  
	if (copy_length)  {
  	
		memcpy(dst, src, copy_length);
    
	}
  
	// Decrement Packet Count                  
	c->NumTimeCodes--;			
        
} // remove_packet	 
         
//
//  Take a non-compressed TimeCoded Motion Channel
//  and compress the packets
//
void VectorChannelClass::compress(W3dTimeCodedAnimChannelStruct * c)
{	
	
	assert( c );


	// Standard Error Threshold Compression

	double Terr = CompressAnimationTranslationError;
	double Rerr = CompressAnimationRotationError;

	float TimeCodes_ct = c->NumTimeCodes;

	switch( c->Flags )
	{
		case ANIM_CHANNEL_X:
		case ANIM_CHANNEL_Y:
		case ANIM_CHANNEL_Z: {
			
			while(1) {
				
				uint32 idx = find_useless_packet( c, Terr );
     
				if (PACKETS_ALL_USEFUL == idx) break;
    
				remove_packet( c, idx );
    			
			}	

			break;
		}
									
		case ANIM_CHANNEL_XR:
		case ANIM_CHANNEL_YR:
		case ANIM_CHANNEL_ZR: {

			while(1) {
				
				uint32 idx = find_useless_packet( c, Rerr );
     
				if (PACKETS_ALL_USEFUL == idx) break;
    
				remove_packet( c, idx );
    			
			}	

			break;
		}

		case ANIM_CHANNEL_Q: {
			
			while(1) {
				
				uint32 idx = find_useless_packetQ( c, Rerr );
     
				if (PACKETS_ALL_USEFUL == idx) break;
    
				remove_packet( c, idx );
    			
			}	

			break;
		}

		default:				// undefined channel
			assert(0);
			break;
	}

	// Forced Reduction Phase

	if (ReduceAnimation)	 {
		if (ReduceAnimationPercent) {

			float pct = ReduceAnimationPercent;

			pct *= (0.01f);

			pct = 1.0f - pct;

			// if out of range, don't even try
			if (pct <= 0.0f) return;
			if (pct >= 1.0f) return;

			pct*=TimeCodes_ct;

			pct+=0.5f;

			uint32 maxFrames = pct;

			if (maxFrames < 2) maxFrames = 2;

			if (maxFrames >= c->NumTimeCodes) return;	// desired minimum already attained


			switch( c->Flags )
			{
				case ANIM_CHANNEL_X:
				case ANIM_CHANNEL_Y:
				case ANIM_CHANNEL_Z: 
				case ANIM_CHANNEL_XR:
				case ANIM_CHANNEL_YR:
				case ANIM_CHANNEL_ZR: { 

					while(maxFrames < c->NumTimeCodes) {
						
						uint32 idx = find_least_useful_packet( c );
						if (PACKETS_ALL_USEFUL == idx) break;
						remove_packet( c, idx );
					}	

					break;
				}

				case ANIM_CHANNEL_Q: {
					
					while(maxFrames < c->NumTimeCodes) {
						
						uint32 idx = find_least_useful_packetQ( c );
						if (PACKETS_ALL_USEFUL == idx) break;
						remove_packet( c, idx );
					}	

					break;
				}

				default:				// undefined channel
					assert(0);
					break;
			}
		} // if ReducePercent

	} // if Reduce

} // compress



//
// find a packet that isn't needed, and return the index
// if all packets are necessary, then return back PACKETS_ALL_USEFUL
// a useless packet is defined, as a packet that can be recreated
// via interpolation
// 
// Make Sure we NEVER get rid of binary movement packets
// The rule is, you can't interpolate TOO a binary movement, but you can
// interpolate FROM
//#define W3D_TIMECODED_BINARY_MOVEMENT_FLAG  0x80000000
//      
uint32 VectorChannelClass::find_useless_packet(W3dTimeCodedAnimChannelStruct * c, double tolerance)
{												
#define MAX_VECTOR_SIZE 8
static  float32 tempvec[MAX_VECTOR_SIZE];		
	
  assert( c );	// make sure pointer exists
  assert( c->NumTimeCodes );	// make sure some packets exist
  assert( c->VectorLen <= MAX_VECTOR_SIZE );
  		 
  uint32 packet_size = c->VectorLen + 1;
                       
  if (c->NumTimeCodes > 1) {
  	if (c->NumTimeCodes > 2)  {
  						 
  		float32 *pVecSrc, *pVecDst, *pVecOriginal;
      uint32	*pTcSrc,  *pTcDst,  *pTcOriginal;
              
      for(uint32 try_idx = 0; try_idx < (c->NumTimeCodes - 2); try_idx++)  {
      	
        // Src Pointers
        pTcSrc  = (uint32 *) &c->Data[ try_idx * packet_size ];
        pVecSrc	= (float32 *) pTcSrc+1;
        				 
        // Original Vector we're trying to recreate         
        pTcOriginal  = (uint32 *) &c->Data[ (try_idx + 1) * packet_size ];
        pVecOriginal = (float32 *) pTcOriginal+1;
        
        // Dst Pointers
        pTcDst  = (uint32 *) &c->Data[ (try_idx + 2 ) * packet_size ];
        pVecDst =	(float32 *) pTcDst+1;	 
        
        // Skip automagically, if binary movement involved		
        if (*pTcOriginal & W3D_TIMECODED_BINARY_MOVEMENT_FLAG) {
				continue;	// can't get rid of this guy	
        }			  
        if (*pTcDst & W3D_TIMECODED_BINARY_MOVEMENT_FLAG)  {
        		continue;	// can't get rid of this guy either
        }
            
        // Linear Interpolate between Src, and Dst, to recreate the
        // Original
        
        float32 tStart    = ((*pTcSrc) & ~W3D_TIMECODED_BINARY_MOVEMENT_FLAG);				// upgrade to floats
        float32 tRecreate = *pTcOriginal;
        float32 tEnd      = *pTcDst; 
        float32 tRatio    = (tRecreate - tStart) / (tEnd - tStart);
        																		
        for (uint32 idx=0; idx < c->VectorLen; idx++)  {
        
        	tempvec[ idx ] = WWMath::Lerp(pVecSrc[idx], pVecDst[idx], tRatio);
          	
        }                                    
        
        // Compare Original to our re-creation
        
        bool close_enough = true;
        
        for (idx=0; idx < c->VectorLen; idx++)  {
        	
          float32 delta;
          
          delta = fabs(pVecOriginal[idx] - tempvec[idx]);
          
          if (delta > tolerance)  {
          	close_enough = false;
            break;
          }
          
        }													 
                                   
        // If our Recreation is very close to the original,
        // then discard the original
        
        if (true == close_enough)  {
        		return (try_idx + 1);
        }
        
        // else continue
               
      }	// for 
        
  	}	
    else  {
    	// Special Case, when there are only 2 time codes
      // Check to see if they are equal, value
      // if so, then return the 2nd timecode as useless
       	
      float32 *pVecSrc = (float32 *) &c->Data[ 1 ];
      float32 *pVecDst = (float32 *) &c->Data[ packet_size + 1 ];  
       	
      bool identical = true;  
        
      if ((c->Data[ packet_size ] & W3D_TIMECODED_BINARY_MOVEMENT_FLAG) == 0) {
      	
	      for(uint32 idx=0; idx < c->VectorLen; idx++) {
	      
	      	float32 delta;
	        
	        delta = fabs(pVecDst[idx] - pVecSrc[idx]);
	        
	        if (delta > tolerance)  {
	       		identical = false;
	          break;	
	        }	
	        
	      }	 
	      
	      if (identical) return( 1 );
         
      }
    }
  }
	
	return( PACKETS_ALL_USEFUL );
	
} // find_useless_packet	


//
// Special Case for Quaternion Packets
//
// Make Sure we NEVER get rid of binary movement packets
// The rule is, you can't interpolate TOO a binary movement, but you can
// interpolate FROM
//#define W3D_TIMECODED_BINARY_MOVEMENT_FLAG  0x80000000
//
uint32 VectorChannelClass::find_useless_packetQ(W3dTimeCodedAnimChannelStruct * c, double tolerance)
{												
	
  assert( c );	// make sure pointer exists
  assert( c->NumTimeCodes );	// make sure some packets exist
  assert( c->VectorLen == 4);
  		 
  uint32 packet_size = c->VectorLen + 1;
                       
  if (c->NumTimeCodes > 1) {
  	if (c->NumTimeCodes > 2)  {
  						 
  		float32 *pVecSrc, *pVecDst, *pVecOrg;
      uint32	*pTcSrc,  *pTcDst,  *pTcOrg;
              
		for(uint32 try_idx = 0; try_idx < (c->NumTimeCodes - 2); try_idx++)  {
      	
			// Src Pointers
			pTcSrc  = (uint32 *) &c->Data[ try_idx * packet_size ];
			pVecSrc	= (float32 *) pTcSrc+1;
        				 
			// Original Vector we're trying to recreate         
			pTcOrg  = (uint32 *) &c->Data[ (try_idx + 1) * packet_size ];
			pVecOrg = (float32 *) pTcOrg+1;
        
			// Dst Pointers
			pTcDst  = (uint32 *) &c->Data[ (try_idx + 2 ) * packet_size ];
			pVecDst = (float32 *) pTcDst+1;	 
        
			// Sphereical Linear Interpolate between Src, and Dst, to recreate the
			// Original
         
        	// Skip automagically, if binary movement involved		
        	if (*pTcOrg & W3D_TIMECODED_BINARY_MOVEMENT_FLAG) {
				continue;	// can't get rid of this guy	
        	}			  
       	if (*pTcDst & W3D_TIMECODED_BINARY_MOVEMENT_FLAG)  {
        		continue;	// can't get rid of this guy either
        	}
        
			float32 tStart    = ((*pTcSrc) & ~W3D_TIMECODED_BINARY_MOVEMENT_FLAG); // upgrade to floats
			float32 tRecreate = *pTcOrg;
			float32 tEnd      = *pTcDst; 
			float32 tRatio    = (tRecreate - tStart) / (tEnd - tStart);
        				  
		  
			Quaternion qSrc(1);
			qSrc.Set(pVecSrc[0],pVecSrc[1],pVecSrc[2],pVecSrc[3]);

			Quaternion qOrg(1);
			qOrg.Set(pVecOrg[0],pVecOrg[1],pVecOrg[2],pVecOrg[3]);

			Quaternion qDst(1);
			qDst.Set(pVecDst[0],pVecDst[1],pVecDst[2],pVecDst[3]);

			Quaternion q = Slerp( qSrc, qDst, tRatio );

			Quaternion Delta(1);
			Delta =  Inverse(qOrg) * q; 
 
			double angle = acosf( fabs( Delta.W ) ) * 2.0;
				
			if (angle <= tolerance ) {
				return (try_idx + 1);
			}

			// else continue
               
		}	// for
		
	}
        
  	}	
    else  {
    	// Special Case, when there are only 2 time codes
      // Check to see if they are equal, value
      // if so, then return the 2nd timecode as useless
      
		float32 *pVecSrc = (float32 *) &c->Data[ 1 ];
      float32 *pVecDst = (float32 *) &c->Data[ packet_size + 1 ];  
       
      if ((c->Data[ packet_size ] & W3D_TIMECODED_BINARY_MOVEMENT_FLAG) == 0)  {
      	
			Quaternion qSrc(1);
			qSrc.Set(pVecSrc[0], pVecSrc[1], pVecSrc[2], pVecSrc[3]);

			Quaternion qDst(1);
			qDst.Set(pVecDst[0], pVecDst[1], pVecDst[2], pVecDst[3]);

			Quaternion Delta(1);
			Delta = Inverse(qSrc) * qDst;

			double angle = acosf( fabs( Delta.W ) ) * 2.0;
				
			if (angle <= tolerance ) {
				return (1);
			}
      }
  }
	
	return( PACKETS_ALL_USEFUL );
	
} // find_useless_packetQ	


//
//	Instead of using a fixed error threshold, find the packet
// that generates the least amount of error, via removal
// 
// Make Sure we NEVER get rid of binary movement packets
// The rule is, you can't interpolate too a binary movement, but you can
// interpolate FROM
//#define W3D_TIMECODED_BINARY_MOVEMENT_FLAG  0x80000000
//
uint32 VectorChannelClass::find_least_useful_packet(W3dTimeCodedAnimChannelStruct *c)
{

static  float32 tempvec[MAX_VECTOR_SIZE];		
	
  assert( c );	// make sure pointer exists
  assert( c->NumTimeCodes );	// make sure some packets exist
  assert( c->VectorLen <= MAX_VECTOR_SIZE );
  		 
  uint32 packet_size = c->VectorLen + 1;
  
  double leasterror = 9999999.0f;
  uint32 ret_idx = PACKETS_ALL_USEFUL;
                       
	if (c->NumTimeCodes > 1) {
		if (c->NumTimeCodes > 2)  {
  						 
  			float32 *pVecSrc, *pVecDst, *pVecOriginal;
			uint32	*pTcSrc,  *pTcDst,  *pTcOriginal;
              
			for(uint32 try_idx = 0; try_idx < (c->NumTimeCodes - 2); try_idx++)  {
      	
				// Src Pointers
				pTcSrc  = (uint32 *) &c->Data[ try_idx * packet_size ];
				pVecSrc	= (float32 *) pTcSrc+1;
        				 
				// Original Vector we're trying to recreate         
				pTcOriginal  = (uint32 *) &c->Data[ (try_idx + 1) * packet_size ];
				pVecOriginal = (float32 *) pTcOriginal+1;
        
				// Dst Pointers
				pTcDst  = (uint32 *) &c->Data[ (try_idx + 2 ) * packet_size ];
				pVecDst =	(float32 *) pTcDst+1;	 
        		
	        	// Skip automagically, if binary movement involved		
	       	if (*pTcOriginal & W3D_TIMECODED_BINARY_MOVEMENT_FLAG) {
					continue;	// can't get rid of this guy	
	         }			  
	         if (*pTcDst & W3D_TIMECODED_BINARY_MOVEMENT_FLAG)  {
	        		continue;	// can't get rid of this guy either
	         }
                              
				// Linear Interpolate between Src, and Dst, to recreate the
				// Original
        
				float32 tStart    = ((*pTcSrc) & ~W3D_TIMECODED_BINARY_MOVEMENT_FLAG);				// upgrade to floats
				float32 tRecreate = *pTcOriginal;
				float32 tEnd      = *pTcDst; 
				float32 tRatio    = (tRecreate - tStart) / (tEnd - tStart);
        		 																	
				for (uint32 idx=0; idx < c->VectorLen; idx++)  {
        
        		 tempvec[ idx ] = WWMath::Lerp(pVecSrc[idx], pVecDst[idx], tRatio);
          	 	
				}                                    
        
				// Compare Original to our re-creation

				double delta = 0.0;
				
        
				for (idx=0; idx < c->VectorLen; idx++)  {
        		 
					double tmp;

					tmp = pVecOriginal[idx] - tempvec[idx];

					delta += (tmp * tmp);
          
				}													 
                   
				delta = sqrtf( delta );

				if (delta < leasterror)
				{

					// If our Recreation is very close to the original,
					// then discard the original
					leasterror = delta;
					ret_idx =(try_idx + 1);
				}
        
				// else continue
               
			}	// for 

			return( ret_idx );
        
		}	
		else  {
         
      	if ((c->Data[ packet_size ] & W3D_TIMECODED_BINARY_MOVEMENT_FLAG) == 0) {
				return( 1 );																				 
         }
		}
  }
			
  
  return( PACKETS_ALL_USEFUL );
         

}  // Find Least useful packet


//
//	Instead of using a fixed error threshold, find the packet
// that generates the least amount of error, via removal
// special case for Quaternion channel
// 
// Make Sure we NEVER get rid of binary movement packets
// The rule is, you can't interpolate FROM a binary movement, but you can
// interpolate TOO
//#define W3D_TIMECODED_BINARY_MOVEMENT_FLAG  0x80000000
//
uint32 VectorChannelClass::find_least_useful_packetQ(W3dTimeCodedAnimChannelStruct *c)
{

  assert( c );	// make sure pointer exists
  assert( c->NumTimeCodes );	// make sure some packets exist
  assert( c->VectorLen == 4);
  		 
  uint32 packet_size = c->VectorLen + 1;

  double leasterror = 9999999.0f;
  uint32 ret_idx = PACKETS_ALL_USEFUL;
  
  if (c->NumTimeCodes > 1) {
  	if (c->NumTimeCodes > 2)  {
  						 
  		float32 *pVecSrc, *pVecDst, *pVecOrg;
      uint32	*pTcSrc,  *pTcDst,  *pTcOrg;
              
		for(uint32 try_idx = 0; try_idx < (c->NumTimeCodes - 2); try_idx++)  {
      	
			// Src Pointers
			pTcSrc  = (uint32 *) &c->Data[ try_idx * packet_size ];
			pVecSrc	= (float32 *) pTcSrc+1;
        				 
			// Original Vector we're trying to recreate         
			pTcOrg  = (uint32 *) &c->Data[ (try_idx + 1) * packet_size ];
			pVecOrg = (float32 *) pTcOrg+1;
        
			// Dst Pointers
			pTcDst  = (uint32 *) &c->Data[ (try_idx + 2 ) * packet_size ];
			pVecDst = (float32 *) pTcDst+1;	 
        	
	      // Skip automagically, if binary movement involved		
	      if (*pTcOrg & W3D_TIMECODED_BINARY_MOVEMENT_FLAG) {
				continue;	// can't get rid of this guy	
	      }			  
	      if (*pTcDst & W3D_TIMECODED_BINARY_MOVEMENT_FLAG)  {
	      	continue;	// can't get rid of this guy either
	      }
                         
			// Spherical Linear Interpolate between Src, and Dst, to recreate the
			// Original
        
			float32 tStart    = ((*pTcSrc) & ~W3D_TIMECODED_BINARY_MOVEMENT_FLAG);				// upgrade to floats
			float32 tRecreate = *pTcOrg;
			float32 tEnd      = *pTcDst; 
			float32 tRatio    = (tRecreate - tStart) / (tEnd - tStart);
        				  
		  
			Quaternion qSrc(1);
			qSrc.Set(pVecSrc[0],pVecSrc[1],pVecSrc[2],pVecSrc[3]);

			Quaternion qOrg(1);
			qOrg.Set(pVecOrg[0],pVecOrg[1],pVecOrg[2],pVecOrg[3]);

			Quaternion qDst(1);
			qDst.Set(pVecDst[0],pVecDst[1],pVecDst[2],pVecDst[3]);

			Quaternion q = Slerp( qSrc, qDst, tRatio );

			Quaternion Delta(1);
			Delta =  Inverse(qOrg) * q; 
 
			double angle = acosf( fabs( Delta.W ) ) * 2;
				
			if (angle < leasterror ) {
				leasterror = angle;
				ret_idx = (try_idx + 1);
			}
        
			// else continue
               
		}	// for

		return( ret_idx );
		
	}
        
  	}	
    else  {
    	// Special Case, when there are only 2 time codes
      // Check to see if they are equal, value
      // if so, then return the 2nd timecode as useless
      
      	if ((c->Data[ packet_size ] & W3D_TIMECODED_BINARY_MOVEMENT_FLAG) == 0) {
				return( 1 );																				 
         }
  }

	 
  return( PACKETS_ALL_USEFUL );

} // find_least_useful_packetQ


// EOF - vchannel.cpp