mirror of
https://github.com/thug1src/thug.git
synced 2025-01-22 05:43:47 +00:00
1620 lines
58 KiB
C++
1620 lines
58 KiB
C++
|
#include <string.h>
|
||
|
|
#include <sys/timer.h>
|
||
|
|
#include <core/defines.h>
|
||
|
|
#include <core/debug.h>
|
||
|
|
#include <stdio.h>
|
||
|
|
#include <stdlib.h>
|
||
|
|
#include <sys/file/filesys.h>
|
||
|
|
//#include "import.h"
|
||
|
|
#include "material.h"
|
||
|
|
#include "scene.h"
|
||
|
|
#include "render.h"
|
||
|
|
#include "gfx/ngc/p_nxtexture.h"
|
||
|
|
#include "nx_init.h"
|
||
|
|
|
||
|
|
#include <sys/ngc/p_display.h>
|
||
|
|
#include <sys/ngc/p_gx.h>
|
||
|
|
|
||
|
|
//int gMatBytes = 0;
|
||
|
|
|
||
|
|
extern u16 colorMap[];
|
||
|
|
|
||
|
|
bool gCorrectColor = false;
|
||
|
|
|
||
|
|
extern bool gMeshUseCorrection;
|
||
|
|
extern bool gMeshUseAniso;
|
||
|
|
|
||
|
|
int g_mat = 0;
|
||
|
|
|
||
|
|
namespace NxNgc
|
||
|
|
{
|
||
|
|
|
||
|
|
/******************************************************************/
|
||
|
|
/* */
|
||
|
|
/* */
|
||
|
|
/******************************************************************/
|
||
|
|
//sMaterial::sMaterial( void )
|
||
|
|
//{
|
||
|
|
// m_num_wibble_vc_anims = 0;
|
||
|
|
// mp_wibble_vc_params = NULL;
|
||
|
|
// mp_wibble_vc_colors = NULL;
|
||
|
|
// m_uv_wibble = false;
|
||
|
|
// for( int p = 0; p < MAX_PASSES; ++p )
|
||
|
|
// {
|
||
|
|
// Flags[p] = 0;
|
||
|
|
// mp_UVWibbleParams[p] = NULL;
|
||
|
|
// }
|
||
|
|
//}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/******************************************************************/
|
||
|
|
/* */
|
||
|
|
/* */
|
||
|
|
/******************************************************************/
|
||
|
|
//sMaterial::~sMaterial( void )
|
||
|
|
//{
|
||
|
|
//// if( mp_wibble_vc_params )
|
||
|
|
//// {
|
||
|
|
//// for( uint32 i = 0; i < m_num_wibble_vc_anims; ++i )
|
||
|
|
//// {
|
||
|
|
//// delete [] mp_wibble_vc_params[i].mp_keyframes;
|
||
|
|
//// }
|
||
|
|
//// delete [] mp_wibble_vc_params;
|
||
|
|
//// }
|
||
|
|
//// if( mp_wibble_vc_colors )
|
||
|
|
//// {
|
||
|
|
//// delete [] mp_wibble_vc_colors;
|
||
|
|
//// }
|
||
|
|
//}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
///******************************************************************/
|
||
|
|
///* */
|
||
|
|
///* */
|
||
|
|
///******************************************************************/
|
||
|
|
//void sMaterial::figure_wibble_uv( void )
|
||
|
|
//{
|
||
|
|
// float uoff, voff, t;
|
||
|
|
//
|
||
|
|
// m_wibble_uv_time = (float)Tmr::GetTime();
|
||
|
|
// t = m_wibble_uv_time * 0.001f;
|
||
|
|
// m_wibble_uv_update = 0;
|
||
|
|
//
|
||
|
|
// for( uint32 p = 0; p < Passes; ++p )
|
||
|
|
// {
|
||
|
|
// // Figure out UV offsets for wibbling if required.
|
||
|
|
// if( Flags[p] & MATFLAG_UV_WIBBLE )
|
||
|
|
// {
|
||
|
|
// m_wibble_uv_update |= ( 1 << p );
|
||
|
|
//
|
||
|
|
// uoff = ( t * m_pUVControl->UVWibbleParams[p].m_UVel ) + ( m_pUVControl->UVWibbleParams[p].m_UAmplitude * sinf( m_pUVControl->UVWibbleParams[p].m_UFrequency * t + m_pUVControl->UVWibbleParams[p].m_UPhase ));
|
||
|
|
//// uoff -= (float)(int)uoff;
|
||
|
|
//
|
||
|
|
// voff = ( t * m_pUVControl->UVWibbleParams[p].m_VVel ) + ( m_pUVControl->UVWibbleParams[p].m_VAmplitude * sinf( m_pUVControl->UVWibbleParams[p].m_VFrequency * t + m_pUVControl->UVWibbleParams[p].m_VPhase ));
|
||
|
|
//// voff -= (float)(int)voff;
|
||
|
|
//
|
||
|
|
// m_pUVControl->UVWibbleOffset[p][0] = uoff;
|
||
|
|
// m_pUVControl->UVWibbleOffset[p][1] = voff;
|
||
|
|
// }
|
||
|
|
// }
|
||
|
|
//}
|
||
|
|
//
|
||
|
|
//
|
||
|
|
//
|
||
|
|
///******************************************************************/
|
||
|
|
///* */
|
||
|
|
///* */
|
||
|
|
///******************************************************************/
|
||
|
|
//void sMaterial::figure_wibble_vc( void )
|
||
|
|
//{
|
||
|
|
// // The vertex color wibble flag is placed in pass 0.
|
||
|
|
// if( Flags[0] & MATFLAG_VC_WIBBLE )
|
||
|
|
// {
|
||
|
|
// int current_time = (int)Tmr::GetTime();
|
||
|
|
//
|
||
|
|
// for( uint32 i = 0; i < m_num_wibble_vc_anims; ++i )
|
||
|
|
// {
|
||
|
|
// struct sVCWibbleParams *p_sequence = mp_wibble_vc_params + i;
|
||
|
|
//
|
||
|
|
// // Get phase-shift.
|
||
|
|
// int phase_shift = p_sequence->m_phase;
|
||
|
|
//
|
||
|
|
// // Time parameters.
|
||
|
|
// int num_keys = p_sequence->m_num_keyframes;
|
||
|
|
// int start_time = p_sequence->mp_keyframes[0].m_time;
|
||
|
|
// int end_time = p_sequence->mp_keyframes[num_keys - 1].m_time;
|
||
|
|
// int period = end_time - start_time;
|
||
|
|
// int time = start_time + (( current_time + phase_shift ) % period );
|
||
|
|
//
|
||
|
|
// // Locate the keyframe.
|
||
|
|
// int key;
|
||
|
|
// for( key = num_keys - 1; key >= 0; --key )
|
||
|
|
// {
|
||
|
|
// if( time >= p_sequence->mp_keyframes[key].m_time )
|
||
|
|
// {
|
||
|
|
// break;
|
||
|
|
// }
|
||
|
|
// }
|
||
|
|
//
|
||
|
|
// // Parameter expressing how far we are between between this keyframe and the next.
|
||
|
|
// float t = (float)( time - start_time ) / (float)period;
|
||
|
|
//
|
||
|
|
// // Interpolate the color.
|
||
|
|
// GXColor rgba;
|
||
|
|
// rgba.r = (uint8)((( 1.0f - t ) * p_sequence->mp_keyframes[key].m_color.r ) + ( t * p_sequence->mp_keyframes[key + 1].m_color.r ));
|
||
|
|
// rgba.g = (uint8)((( 1.0f - t ) * p_sequence->mp_keyframes[key].m_color.g ) + ( t * p_sequence->mp_keyframes[key + 1].m_color.g ));
|
||
|
|
// rgba.b = (uint8)((( 1.0f - t ) * p_sequence->mp_keyframes[key].m_color.b ) + ( t * p_sequence->mp_keyframes[key + 1].m_color.b ));
|
||
|
|
// rgba.a = (uint8)((( 1.0f - t ) * p_sequence->mp_keyframes[key].m_color.a ) + ( t * p_sequence->mp_keyframes[key + 1].m_color.a ));
|
||
|
|
//
|
||
|
|
// mp_wibble_vc_colors[i] = *((uint32*)&rgba);
|
||
|
|
// }
|
||
|
|
// }
|
||
|
|
//}
|
||
|
|
//
|
||
|
|
//static int stage_id = 0; // 0-15
|
||
|
|
//static int tev_id = 0; // 0-3
|
||
|
|
//static int uv_id = 0; // 0-7
|
||
|
|
//static int map_id = 0; // 0-3
|
||
|
|
//static int layer_id = 1; // 1-3
|
||
|
|
//static bool correct_color = false;
|
||
|
|
//
|
||
|
|
//static void multi_start ( int passes )
|
||
|
|
//{
|
||
|
|
// // Set everything to 0.
|
||
|
|
// stage_id = 0;
|
||
|
|
// tev_id = 0;
|
||
|
|
// uv_id = 0;
|
||
|
|
// map_id = 0;
|
||
|
|
// layer_id = 1;
|
||
|
|
//
|
||
|
|
// // Don't forget these!
|
||
|
|
//// GXSetNumChans(2);
|
||
|
|
//// GX::SetNumTexGens(2);
|
||
|
|
//// GX::SetNumTevStages(2);
|
||
|
|
//
|
||
|
|
// if ( gCorrectColor && gMeshUseCorrection )
|
||
|
|
// {
|
||
|
|
// GXTexObj texObj;
|
||
|
|
// GXInitTexObj( &texObj, colorMap, 256, 256, GX_TF_RGBA8, GX_CLAMP, GX_CLAMP, GX_FALSE );
|
||
|
|
// GXLoadTexObj( &texObj, GX_TEXMAP7 );
|
||
|
|
//
|
||
|
|
// // Tev 0: Use rasterization lookup table (RG)
|
||
|
|
// // Note: Blue = 0 and Alpha = 0;
|
||
|
|
// GX::SetTevSwapMode( GX_TEVSTAGE0, GX_TEV_SWAP0, GX_TEV_SWAP0 );
|
||
|
|
// GX::SetTevColorIn(GX_TEVSTAGE0, GX_CC_ZERO, GX_CC_ZERO, GX_CC_ZERO, GX_CC_TEXC);
|
||
|
|
// GX::SetTevAlphaIn(GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO);
|
||
|
|
// GX::SetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVREG1);
|
||
|
|
// GX::SetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVREG1);
|
||
|
|
// stage_id++;
|
||
|
|
//
|
||
|
|
// // Tev 1: Use rasterization lookup table (BA),
|
||
|
|
// // then add previous tev (RG + BA)
|
||
|
|
// GX::SetTevSwapMode( GX_TEVSTAGE1, GX_TEV_SWAP0, GX_TEV_SWAP3 );
|
||
|
|
// GX::SetTevColorIn(GX_TEVSTAGE1, GX_CC_TEXC, GX_CC_ZERO, GX_CC_ZERO, GX_CC_C1);
|
||
|
|
// GX::SetTevAlphaIn(GX_TEVSTAGE1, GX_CA_TEXA, GX_CA_ZERO, GX_CA_ZERO, GX_CA_A1);
|
||
|
|
// GX::SetTevColorOp(GX_TEVSTAGE1, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVREG2);
|
||
|
|
// GX::SetTevAlphaOp(GX_TEVSTAGE1, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVREG2);
|
||
|
|
// stage_id++;
|
||
|
|
// correct_color = true;
|
||
|
|
// }
|
||
|
|
// else
|
||
|
|
// {
|
||
|
|
// correct_color = false;
|
||
|
|
// }
|
||
|
|
//
|
||
|
|
//// // Create 2 dummy stages.
|
||
|
|
//// GXTevStageID s_id = (GXTevStageID)(((int)GX_TEVSTAGE0)+stage_id);
|
||
|
|
////
|
||
|
|
//// GX::SetTevOrder( s_id, GX_TEXCOORD_NULL, GX_TEX_DISABLE, GX_COLOR_NULL );
|
||
|
|
//// GX::SetTevSwapMode( s_id, GX_TEV_SWAP0, GX_TEV_SWAP0 );
|
||
|
|
//// GX::SetTevAlphaOp(s_id, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV );
|
||
|
|
//// GX::SetTevColorOp(s_id, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV );
|
||
|
|
//// GX::SetTevAlphaIn ( s_id, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO );
|
||
|
|
//// GX::SetTevColorIn ( s_id, GX_CC_ZERO, GX_CC_ZERO, GX_CC_ZERO, GX_CC_ZERO );
|
||
|
|
//// stage_id++;
|
||
|
|
////
|
||
|
|
//// s_id = (GXTevStageID)(((int)GX_TEVSTAGE0)+stage_id);
|
||
|
|
////
|
||
|
|
//// GX::SetTevOrder( s_id, GX_TEXCOORD_NULL, GX_TEX_DISABLE, GX_COLOR0A0 );
|
||
|
|
//// GX::SetTevSwapMode( s_id, GX_TEV_SWAP0, GX_TEV_SWAP0 );
|
||
|
|
//// GX::SetTevAlphaOp(s_id, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVREG2 );
|
||
|
|
//// GX::SetTevColorOp(s_id, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVREG2 );
|
||
|
|
//// GX::SetTevAlphaIn ( s_id, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_RASA );
|
||
|
|
//// GX::SetTevColorIn ( s_id, GX_CC_ZERO, GX_CC_ZERO, GX_CC_ZERO, GX_CC_RASC );
|
||
|
|
//// stage_id++;
|
||
|
|
//
|
||
|
|
//// if ( !gCorrectColor || !gMeshUseCorrection )
|
||
|
|
//// {
|
||
|
|
////// // Create 2 dummy stages.
|
||
|
|
////// GXTevStageID s_id = (GXTevStageID)(((int)GX_TEVSTAGE0)+stage_id);
|
||
|
|
//////
|
||
|
|
////// GX::SetTevOrder( s_id, GX_TEXCOORD_NULL, GX_TEX_DISABLE, GX_COLOR0A0 );
|
||
|
|
////// GX::SetTevSwapMode( s_id, GX_TEV_SWAP0, GX_TEV_SWAP0 );
|
||
|
|
////// GX::SetTevAlphaOp(s_id, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVREG2 );
|
||
|
|
////// GX::SetTevColorOp(s_id, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVREG2 );
|
||
|
|
////// GX::SetTevAlphaIn ( s_id, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_RASA );
|
||
|
|
////// GX::SetTevColorIn ( s_id, GX_CC_ZERO, GX_CC_ZERO, GX_CC_ZERO, GX_CC_RASC );
|
||
|
|
////// stage_id++;
|
||
|
|
//// correct_color = false;
|
||
|
|
//// }
|
||
|
|
//}
|
||
|
|
//
|
||
|
|
//static void multi_add_layer ( BlendModes blend, int raw_fix )
|
||
|
|
//{
|
||
|
|
// // Set inputs.
|
||
|
|
// GXTevStageID s_id = (GXTevStageID)(((int)GX_TEVSTAGE0)+stage_id);
|
||
|
|
//
|
||
|
|
// int reg_id = layer_id; //( layer_id > 1 ) ? 1 : layer_id; //( tev_id == 3 ) ? 2 : tev_id; // CPREV, C0, C1, C0.
|
||
|
|
// // int reg_id = layer_id; //( layer_id == 3 ) ? 2 : layer_id; // CPREV, C0, C1, C0.
|
||
|
|
//
|
||
|
|
//// GXTevAlphaArg newa = (GXTevAlphaArg)(((int)GX_CA_APREV)+layer_id);
|
||
|
|
// GXTevColorArg newc = (GXTevColorArg)(((int)GX_CC_CPREV)+(reg_id*2));
|
||
|
|
// GXTevColorArg newca= (GXTevColorArg)(((int)GX_CC_APREV)+(reg_id*2));
|
||
|
|
//
|
||
|
|
//
|
||
|
|
// // out_reg = (d (op) ((1.0 - c)*a + c*b) + bias) * scale;
|
||
|
|
//
|
||
|
|
// int fix = ( raw_fix >= 128 ) ? 255 : raw_fix * 2;
|
||
|
|
//
|
||
|
|
// switch ( blend ) {
|
||
|
|
// case vBLEND_MODE_ADD:
|
||
|
|
// case vBLEND_MODE_ADD_FIXED:
|
||
|
|
// // Add using texture or fixed alpha.
|
||
|
|
// GX::SetTevOrder( s_id, GX_TEXCOORD_NULL, GX_TEX_DISABLE, GX_COLOR_NULL );
|
||
|
|
// GX::SetTevSwapMode( s_id, GX_TEV_SWAP0, GX_TEV_SWAP0 );
|
||
|
|
// GX::SetTevAlphaOp(s_id, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV );
|
||
|
|
// GX::SetTevColorOp(s_id, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV );
|
||
|
|
// GX::SetTevAlphaIn ( s_id, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_APREV );
|
||
|
|
// GX::SetTevColorIn ( s_id, GX_CC_ZERO, newc, newca, GX_CC_CPREV );
|
||
|
|
// stage_id++;
|
||
|
|
// break;
|
||
|
|
// case vBLEND_MODE_SUBTRACT:
|
||
|
|
// case vBLEND_MODE_SUB_FIXED:
|
||
|
|
// // Subtract using texture or fixed alpha.
|
||
|
|
// GX::SetTevOrder( s_id, GX_TEXCOORD_NULL, GX_TEX_DISABLE, GX_COLOR_NULL );
|
||
|
|
// GX::SetTevSwapMode( s_id, GX_TEV_SWAP0, GX_TEV_SWAP0 );
|
||
|
|
// GX::SetTevAlphaOp(s_id, GX_TEV_SUB, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV );
|
||
|
|
// GX::SetTevColorOp(s_id, GX_TEV_SUB, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV );
|
||
|
|
// GX::SetTevAlphaIn ( s_id, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_APREV );
|
||
|
|
// GX::SetTevColorIn ( s_id, GX_CC_ZERO, newc, newca, GX_CC_CPREV );
|
||
|
|
// stage_id++;
|
||
|
|
// break;
|
||
|
|
// case vBLEND_MODE_BLEND:
|
||
|
|
// case vBLEND_MODE_BLEND_FIXED:
|
||
|
|
// // Blend using texture or fixed alpha.
|
||
|
|
// GX::SetTevOrder( s_id, GX_TEXCOORD_NULL, GX_TEX_DISABLE, GX_COLOR_NULL );
|
||
|
|
// GX::SetTevSwapMode( s_id, GX_TEV_SWAP0, GX_TEV_SWAP0 );
|
||
|
|
// GX::SetTevAlphaOp(s_id, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV );
|
||
|
|
// GX::SetTevColorOp(s_id, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV );
|
||
|
|
// GX::SetTevAlphaIn ( s_id, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_APREV );
|
||
|
|
// GX::SetTevColorIn ( s_id, GX_CC_CPREV, newc, newca, GX_CC_ZERO );
|
||
|
|
// stage_id++;
|
||
|
|
// break;
|
||
|
|
// case vBLEND_MODE_MODULATE:
|
||
|
|
// // Modulate current layer with previous layer.
|
||
|
|
// GX::SetTevOrder( s_id, GX_TEXCOORD_NULL, GX_TEX_DISABLE, GX_COLOR_NULL );
|
||
|
|
// GX::SetTevSwapMode( s_id, GX_TEV_SWAP0, GX_TEV_SWAP0 );
|
||
|
|
// GX::SetTevAlphaOp(s_id, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV );
|
||
|
|
// GX::SetTevColorOp(s_id, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV );
|
||
|
|
// GX::SetTevAlphaIn ( s_id, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_APREV );
|
||
|
|
// GX::SetTevColorIn ( s_id, GX_CC_ZERO, newca, GX_CC_CPREV, GX_CC_ZERO );
|
||
|
|
// stage_id++;
|
||
|
|
// break;
|
||
|
|
// case vBLEND_MODE_MODULATE_FIXED:
|
||
|
|
// // Modulate current layer with fixed alpha.
|
||
|
|
// GX::SetTevKAlphaSel( s_id, (GXTevKAlphaSel)(((int)GX_TEV_KASEL_K0_A)+layer_id) );
|
||
|
|
// GX::SetTevKColorSel( s_id, (GXTevKColorSel)(((int)GX_TEV_KCSEL_K0_A)+layer_id) );
|
||
|
|
// GX::SetTevKColor( (GXTevKColorID)(((int)GX_KCOLOR0)+layer_id), (GXColor){fix,fix,fix,fix} );
|
||
|
|
// GX::SetTevOrder( s_id, GX_TEXCOORD_NULL, GX_TEX_DISABLE, GX_COLOR_NULL );
|
||
|
|
// GX::SetTevSwapMode( s_id, GX_TEV_SWAP0, GX_TEV_SWAP0 );
|
||
|
|
// GX::SetTevAlphaOp(s_id, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV );
|
||
|
|
// GX::SetTevColorOp(s_id, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV );
|
||
|
|
// GX::SetTevAlphaIn ( s_id, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_APREV );
|
||
|
|
// GX::SetTevColorIn ( s_id, GX_CC_ZERO, GX_CC_CPREV, GX_CC_KONST, GX_CC_ZERO );
|
||
|
|
// stage_id++;
|
||
|
|
// break;
|
||
|
|
// case vBLEND_MODE_BRIGHTEN:
|
||
|
|
// // Modulate current layer with previous layer, & add current layer.
|
||
|
|
// GX::SetTevOrder( s_id, GX_TEXCOORD_NULL, GX_TEX_DISABLE, GX_COLOR_NULL );
|
||
|
|
// GX::SetTevSwapMode( s_id, GX_TEV_SWAP0, GX_TEV_SWAP0 );
|
||
|
|
// GX::SetTevAlphaOp(s_id, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV );
|
||
|
|
// GX::SetTevColorOp(s_id, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV );
|
||
|
|
// GX::SetTevAlphaIn ( s_id, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_APREV );
|
||
|
|
// GX::SetTevColorIn ( s_id, GX_CC_ZERO, newca, GX_CC_CPREV, GX_CC_CPREV );
|
||
|
|
// stage_id++;
|
||
|
|
// break;
|
||
|
|
// case vBLEND_MODE_BRIGHTEN_FIXED:
|
||
|
|
// // Modulate current layer with fixed alpha, & add current layer.
|
||
|
|
// GX::SetTevKAlphaSel( s_id, (GXTevKAlphaSel)(((int)GX_TEV_KASEL_K0_A)+layer_id) );
|
||
|
|
// GX::SetTevKColorSel( s_id, (GXTevKColorSel)(((int)GX_TEV_KCSEL_K0_A)+layer_id) );
|
||
|
|
// GX::SetTevKColor( (GXTevKColorID)(((int)GX_KCOLOR0)+layer_id), (GXColor){fix,fix,fix,fix} );
|
||
|
|
// GX::SetTevOrder( s_id, GX_TEXCOORD_NULL, GX_TEX_DISABLE, GX_COLOR_NULL );
|
||
|
|
// GX::SetTevSwapMode( s_id, GX_TEV_SWAP0, GX_TEV_SWAP0 );
|
||
|
|
// GX::SetTevAlphaOp(s_id, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV );
|
||
|
|
// GX::SetTevColorOp(s_id, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV );
|
||
|
|
// GX::SetTevAlphaIn ( s_id, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_APREV );
|
||
|
|
// GX::SetTevColorIn ( s_id, GX_CC_ZERO, GX_CC_CPREV, GX_CC_KONST, GX_CC_CPREV );
|
||
|
|
// stage_id++;
|
||
|
|
// break;
|
||
|
|
// case vBLEND_MODE_DIFFUSE:
|
||
|
|
// default:
|
||
|
|
// // Replace with this texture. Shouldn't ever be used, but here for compatibility.
|
||
|
|
// GX::SetTevOrder( s_id, GX_TEXCOORD_NULL, GX_TEX_DISABLE, GX_COLOR_NULL );
|
||
|
|
// GX::SetTevSwapMode( s_id, GX_TEV_SWAP0, GX_TEV_SWAP0 );
|
||
|
|
// GX::SetTevAlphaOp(s_id, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV );
|
||
|
|
// GX::SetTevColorOp(s_id, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV );
|
||
|
|
// GX::SetTevAlphaIn ( s_id, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_APREV );
|
||
|
|
// GX::SetTevColorIn ( s_id, newc, GX_CC_ZERO, GX_CC_ZERO, GX_CC_ZERO );
|
||
|
|
// stage_id++;
|
||
|
|
// break;
|
||
|
|
// }
|
||
|
|
//// layer_id++;
|
||
|
|
//}
|
||
|
|
//
|
||
|
|
//static void multi_add_texture ( sTexture * p_texture, GXColor matcol, GXTexWrapMode umode, GXTexWrapMode vmode, BlendModes blend, int fix, uint32 flags, char * p_uv_slot, float k )
|
||
|
|
//{
|
||
|
|
// if ( map_id >= 8 ) return;
|
||
|
|
//
|
||
|
|
// void * p_tex_data = p_texture->pTexelData;
|
||
|
|
// void * p_alpha_data = p_texture->has_alpha ? p_texture->pAlphaData : NULL;
|
||
|
|
// int width = p_texture->ActualWidth;
|
||
|
|
// int height = p_texture->ActualHeight;
|
||
|
|
// int levels = p_texture->Levels;
|
||
|
|
// int reg_id = ( tev_id > 1 ) ? 1 : tev_id; //( tev_id == 3 ) ? 2 : tev_id; // CPREV, C0, C1, C0.
|
||
|
|
//
|
||
|
|
// GXTevAlphaArg rasa;
|
||
|
|
// GXTevColorArg rasc;
|
||
|
|
// if ( correct_color )
|
||
|
|
// {
|
||
|
|
// rasa = GX_CA_A2;
|
||
|
|
// rasc = GX_CC_C2;
|
||
|
|
// }
|
||
|
|
// else
|
||
|
|
// {
|
||
|
|
// rasa = GX_CA_RASA;
|
||
|
|
// rasc = GX_CC_RASC;
|
||
|
|
// }
|
||
|
|
//
|
||
|
|
// int cur_map = map_id + 1;
|
||
|
|
// int alpha_map = -1;
|
||
|
|
// bool uniqueMaterialColor = false;
|
||
|
|
//
|
||
|
|
// if ( ( matcol.r == 128 ) && ( matcol.g == 128 ) && ( matcol.b == 128 ) && ( matcol.a == 255 ) )
|
||
|
|
// {
|
||
|
|
// uniqueMaterialColor = false;
|
||
|
|
// }
|
||
|
|
// else
|
||
|
|
// {
|
||
|
|
// uniqueMaterialColor = true;
|
||
|
|
// }
|
||
|
|
//
|
||
|
|
// if ( p_alpha_data )
|
||
|
|
// {
|
||
|
|
// switch ( blend )
|
||
|
|
// {
|
||
|
|
// case vBLEND_MODE_ADD:
|
||
|
|
// case vBLEND_MODE_SUBTRACT:
|
||
|
|
// case vBLEND_MODE_BLEND:
|
||
|
|
// case vBLEND_MODE_BRIGHTEN:
|
||
|
|
// case vBLEND_MODE_MODULATE:
|
||
|
|
// case vBLEND_MODE_DIFFUSE:
|
||
|
|
// if ( cur_map < 8 )
|
||
|
|
// {
|
||
|
|
// alpha_map = cur_map;
|
||
|
|
// cur_map++;
|
||
|
|
// }
|
||
|
|
// break;
|
||
|
|
// default:
|
||
|
|
// break;
|
||
|
|
// }
|
||
|
|
// }
|
||
|
|
//
|
||
|
|
// GXTexObj texObj;
|
||
|
|
// GXInitTexObj( &texObj, p_tex_data, width, height, ((GXTexFmt)p_texture->format), umode, vmode, levels > 1 ? GX_TRUE : GX_FALSE );
|
||
|
|
// if ( levels > 1 )
|
||
|
|
// {
|
||
|
|
// if ( gMeshUseAniso && ( tev_id == 0 ) )
|
||
|
|
// {
|
||
|
|
// // If we're correcting the color, we also want ANISO_4.
|
||
|
|
// GXInitTexObjLOD( &texObj, GX_LIN_MIP_LIN, GX_LINEAR, 0.0f, levels - 1, k, GX_FALSE, GX_TRUE, GX_ANISO_4 );
|
||
|
|
// }
|
||
|
|
// else
|
||
|
|
// {
|
||
|
|
// GXInitTexObjLOD( &texObj, GX_LIN_MIP_LIN, GX_LINEAR, 0.0f, levels - 1, k, GX_FALSE, GX_TRUE, GX_ANISO_1 );
|
||
|
|
// }
|
||
|
|
// }
|
||
|
|
// else
|
||
|
|
// {
|
||
|
|
// GXInitTexObjLOD( &texObj, GX_LINEAR, GX_LINEAR, 0.0f, 0.0f, k, GX_FALSE, GX_TRUE, GX_ANISO_1 );
|
||
|
|
// }
|
||
|
|
// GXLoadTexObj( &texObj, (GXTexMapID)(((int)GX_TEXMAP0)+map_id) );
|
||
|
|
//
|
||
|
|
// if ( alpha_map >= 0 )
|
||
|
|
// {
|
||
|
|
// switch ( blend )
|
||
|
|
// {
|
||
|
|
// case vBLEND_MODE_ADD:
|
||
|
|
// case vBLEND_MODE_SUBTRACT:
|
||
|
|
// case vBLEND_MODE_BLEND:
|
||
|
|
// case vBLEND_MODE_BRIGHTEN:
|
||
|
|
// case vBLEND_MODE_MODULATE:
|
||
|
|
// case vBLEND_MODE_DIFFUSE:
|
||
|
|
// GXTexObj alphaObj;
|
||
|
|
// GXInitTexObj( &alphaObj, p_alpha_data, width, height, ((GXTexFmt)p_texture->format), umode, vmode, levels > 1 ? GX_TRUE : GX_FALSE );
|
||
|
|
// if ( levels > 1 )
|
||
|
|
// {
|
||
|
|
// if ( gMeshUseAniso && ( tev_id == 0 ) )
|
||
|
|
// {
|
||
|
|
// // If we're correcting the color, we also want ANISO_4.
|
||
|
|
// GXInitTexObjLOD( &alphaObj, GX_LIN_MIP_LIN, GX_LINEAR, 0.0f, levels - 1, k, GX_FALSE, GX_TRUE, GX_ANISO_4 );
|
||
|
|
// }
|
||
|
|
// else
|
||
|
|
// {
|
||
|
|
// GXInitTexObjLOD( &alphaObj, GX_LIN_MIP_LIN, GX_LINEAR, 0.0f, levels - 1, k, GX_FALSE, GX_TRUE, GX_ANISO_1 );
|
||
|
|
// }
|
||
|
|
// }
|
||
|
|
// else
|
||
|
|
// {
|
||
|
|
// GXInitTexObjLOD( &alphaObj, GX_LINEAR, GX_LINEAR, 0.0f, 0.0f, k, GX_FALSE, GX_TRUE, GX_ANISO_1 );
|
||
|
|
// }
|
||
|
|
// GXLoadTexObj( &alphaObj, (GXTexMapID)(((int)GX_TEXMAP0)+alpha_map) );
|
||
|
|
// break;
|
||
|
|
// default:
|
||
|
|
// p_alpha_data = NULL;
|
||
|
|
// break;
|
||
|
|
// }
|
||
|
|
// }
|
||
|
|
//
|
||
|
|
// GXTexMapID t_id = (GXTexMapID)(((int)GX_TEXMAP0)+map_id);
|
||
|
|
// GXTexCoordID u_id = (GXTexCoordID)(((int)GX_TEXCOORD0)+uv_id);
|
||
|
|
// GXTevStageID s_id = (GXTevStageID)(((int)GX_TEVSTAGE0)+stage_id);
|
||
|
|
//
|
||
|
|
// // Modulate material color if required.
|
||
|
|
// if ( uniqueMaterialColor )
|
||
|
|
// {
|
||
|
|
// GX::SetTevKColor( (GXTevKColorID)(((int)GX_KCOLOR0)+tev_id), (GXColor){matcol.r,matcol.g,matcol.b,fix} );
|
||
|
|
// GX::SetTevKColorSel( s_id, (GXTevKColorSel)(((int)GX_TEV_KCSEL_K0)+tev_id) );
|
||
|
|
//
|
||
|
|
// GX::SetTevOrder( s_id, GX_TEXCOORD_NULL, GX_TEX_DISABLE, GX_COLOR0A0 );
|
||
|
|
// GX::SetTevSwapMode( s_id, GX_TEV_SWAP0, GX_TEV_SWAP0 );
|
||
|
|
// GX::SetTevAlphaOp(s_id, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, (GXTevRegID)(((int)GX_TEVPREV)+reg_id) );
|
||
|
|
// GX::SetTevColorOp(s_id, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_2, GX_ENABLE, (GXTevRegID)(((int)GX_TEVPREV)+reg_id) );
|
||
|
|
// GX::SetTevAlphaIn ( s_id, rasa, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO );
|
||
|
|
// GX::SetTevColorIn ( s_id, GX_CC_ZERO, rasc, GX_CC_KONST, GX_CC_ZERO );
|
||
|
|
// stage_id++;
|
||
|
|
// s_id = (GXTevStageID)(((int)GX_TEVSTAGE0)+stage_id);
|
||
|
|
// }
|
||
|
|
//
|
||
|
|
// // Set texture coordinates. Note: If p_tex is NULL, it means this layer is environment mapped.
|
||
|
|
//// if ( !(flags & MATFLAG_ENVIRONMENT) )
|
||
|
|
//// {
|
||
|
|
// *p_uv_slot = uv_id;
|
||
|
|
// uv_id++;
|
||
|
|
//// } else {
|
||
|
|
//// *p_uv_slot = -1;
|
||
|
|
//// }
|
||
|
|
//
|
||
|
|
// // Load this texture up into a temporary register for use later.
|
||
|
|
// // Note: conveniently, the 1st texture ends up in TEVPREV which means it will be fine
|
||
|
|
// // if no blends are performed.
|
||
|
|
// switch ( blend )
|
||
|
|
// {
|
||
|
|
// case vBLEND_MODE_ADD_FIXED:
|
||
|
|
// case vBLEND_MODE_SUB_FIXED:
|
||
|
|
// case vBLEND_MODE_BLEND_FIXED:
|
||
|
|
// case vBLEND_MODE_BRIGHTEN_FIXED:
|
||
|
|
// case vBLEND_MODE_MODULATE_FIXED:
|
||
|
|
// GX::SetTevKAlphaSel( s_id, (GXTevKAlphaSel)(((int)GX_TEV_KASEL_K0_A)+tev_id) );
|
||
|
|
// if ( !uniqueMaterialColor ) GX::SetTevKColor( (GXTevKColorID)(((int)GX_KCOLOR0)+tev_id), (GXColor){fix,fix,fix,fix} );
|
||
|
|
// GX::SetTevOrder( s_id, u_id, t_id, GX_COLOR0A0 );
|
||
|
|
// GX::SetTevSwapMode( s_id, GX_TEV_SWAP0, GX_TEV_SWAP0 );
|
||
|
|
// GX::SetTevAlphaOp(s_id, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_2, GX_ENABLE, (GXTevRegID)(((int)GX_TEVPREV)+reg_id) );
|
||
|
|
// GX::SetTevColorOp(s_id, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_2, GX_ENABLE, (GXTevRegID)(((int)GX_TEVPREV)+reg_id) );
|
||
|
|
// if ( uniqueMaterialColor )
|
||
|
|
// {
|
||
|
|
// GX::SetTevAlphaIn ( s_id, GX_CA_KONST, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO );
|
||
|
|
// GX::SetTevColorIn ( s_id, GX_CC_ZERO, GX_CC_TEXC, (GXTevColorArg)(((int)GX_CC_CPREV)+(reg_id*2)), GX_CC_ZERO );
|
||
|
|
// }
|
||
|
|
// else
|
||
|
|
// {
|
||
|
|
// GX::SetTevAlphaIn ( s_id, GX_CA_KONST, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO );
|
||
|
|
// GX::SetTevColorIn ( s_id, GX_CC_ZERO, GX_CC_TEXC, rasc, GX_CC_ZERO );
|
||
|
|
// }
|
||
|
|
// stage_id++;
|
||
|
|
// break;
|
||
|
|
// case vBLEND_MODE_ADD:
|
||
|
|
// case vBLEND_MODE_SUBTRACT:
|
||
|
|
// case vBLEND_MODE_BLEND:
|
||
|
|
// case vBLEND_MODE_BRIGHTEN:
|
||
|
|
// case vBLEND_MODE_MODULATE:
|
||
|
|
// case vBLEND_MODE_DIFFUSE:
|
||
|
|
// default:
|
||
|
|
// // We need to add a stage, if we have an alpha map.
|
||
|
|
// if ( alpha_map >= 0 )
|
||
|
|
// {
|
||
|
|
// // Set inputs.
|
||
|
|
// GXTexMapID a_id = (GXTexMapID)(((int)GX_TEXMAP0)+alpha_map);
|
||
|
|
//
|
||
|
|
// GX::SetTevSwapMode( s_id, GX_TEV_SWAP0, GX_TEV_SWAP1 ); // Alpha map is in Green channel, so use this to swap it to the alpha channel.
|
||
|
|
// GX::SetTevOrder( s_id, u_id, a_id, GX_COLOR0A0 );
|
||
|
|
// GX::SetTevAlphaOp(s_id, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, (GXTevRegID)(((int)GX_TEVPREV)+reg_id) );
|
||
|
|
// GX::SetTevColorOp(s_id, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, (GXTevRegID)(((int)GX_TEVPREV)+reg_id) );
|
||
|
|
// if ( uniqueMaterialColor )
|
||
|
|
// {
|
||
|
|
// GX::SetTevAlphaIn ( s_id, GX_CA_ZERO, GX_CA_TEXA, (GXTevAlphaArg)(((int)GX_CA_APREV)+reg_id), GX_CA_ZERO );
|
||
|
|
// GX::SetTevColorIn ( s_id, (GXTevColorArg)(((int)GX_CC_CPREV)+(reg_id*2)), GX_CC_ZERO, GX_CC_ZERO, GX_CC_ZERO );
|
||
|
|
// }
|
||
|
|
// else
|
||
|
|
// {
|
||
|
|
// GX::SetTevAlphaIn ( s_id, GX_CA_ZERO, GX_CA_TEXA, rasa, GX_CA_ZERO );
|
||
|
|
// GX::SetTevColorIn ( s_id, GX_CC_ZERO, GX_CC_ZERO, GX_CC_ZERO, GX_CC_ZERO );
|
||
|
|
// }
|
||
|
|
// stage_id++;
|
||
|
|
// s_id = (GXTevStageID)(((int)GX_TEVSTAGE0)+stage_id);
|
||
|
|
// GX::SetTevSwapMode( s_id, GX_TEV_SWAP0, GX_TEV_SWAP0 );
|
||
|
|
// GX::SetTevOrder( s_id, u_id, t_id, GX_COLOR0A0 );
|
||
|
|
// GX::SetTevAlphaOp(s_id, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, (GXTevRegID)(((int)GX_TEVPREV)+reg_id) );
|
||
|
|
// GX::SetTevColorOp(s_id, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_2, GX_ENABLE, (GXTevRegID)(((int)GX_TEVPREV)+reg_id) );
|
||
|
|
// GX::SetTevAlphaIn ( s_id, GX_CA_ZERO, (GXTevAlphaArg)(((int)GX_CA_APREV)+reg_id), GX_CA_TEXA, GX_CA_ZERO );
|
||
|
|
// if ( uniqueMaterialColor )
|
||
|
|
// {
|
||
|
|
// GX::SetTevColorIn ( s_id, GX_CC_ZERO, GX_CC_TEXC, (GXTevColorArg)(((int)GX_CC_CPREV)+(reg_id*2)), GX_CC_ZERO );
|
||
|
|
// }
|
||
|
|
// else
|
||
|
|
// {
|
||
|
|
// GX::SetTevColorIn ( s_id, GX_CC_ZERO, GX_CC_TEXC, rasc, GX_CC_ZERO );
|
||
|
|
// }
|
||
|
|
// stage_id++;
|
||
|
|
// } else {
|
||
|
|
// GX::SetTevOrder( s_id, u_id, t_id, GX_COLOR0A0 );
|
||
|
|
// GX::SetTevSwapMode( s_id, GX_TEV_SWAP0, GX_TEV_SWAP0 );
|
||
|
|
// GX::SetTevAlphaOp(s_id, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, (GXTevRegID)(((int)GX_TEVPREV)+reg_id) );
|
||
|
|
// GX::SetTevColorOp(s_id, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_2, GX_ENABLE, (GXTevRegID)(((int)GX_TEVPREV)+reg_id) );
|
||
|
|
// if ( uniqueMaterialColor )
|
||
|
|
// {
|
||
|
|
// GX::SetTevAlphaIn ( s_id, GX_CA_ZERO, GX_CA_TEXA, (GXTevAlphaArg)(((int)GX_CA_APREV)+reg_id), GX_CA_ZERO );
|
||
|
|
// GX::SetTevColorIn ( s_id, GX_CC_ZERO, GX_CC_TEXC, (GXTevColorArg)(((int)GX_CC_CPREV)+(reg_id*2)), GX_CC_ZERO );
|
||
|
|
// }
|
||
|
|
// else
|
||
|
|
// {
|
||
|
|
// GX::SetTevAlphaIn ( s_id, GX_CA_ZERO, GX_CA_TEXA, rasa, GX_CA_ZERO );
|
||
|
|
// GX::SetTevColorIn ( s_id, GX_CC_ZERO, GX_CC_TEXC, rasc, GX_CC_ZERO );
|
||
|
|
// }
|
||
|
|
// stage_id++;
|
||
|
|
// }
|
||
|
|
//
|
||
|
|
// break;
|
||
|
|
// }
|
||
|
|
//
|
||
|
|
// if ( tev_id > 0 ) {
|
||
|
|
// multi_add_layer ( blend, fix );
|
||
|
|
// } else {
|
||
|
|
// // Set blend mode for base layer.
|
||
|
|
// switch ( blend )
|
||
|
|
// {
|
||
|
|
// case vBLEND_MODE_ADD:
|
||
|
|
// case vBLEND_MODE_ADD_FIXED:
|
||
|
|
// GX::SetBlendMode ( GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_ONE, GX_LO_CLEAR );
|
||
|
|
// break;
|
||
|
|
// case vBLEND_MODE_SUBTRACT:
|
||
|
|
// case vBLEND_MODE_SUB_FIXED:
|
||
|
|
// GX::SetBlendMode ( GX_BM_SUBTRACT, GX_BL_ZERO, GX_BL_ZERO, GX_LO_CLEAR );
|
||
|
|
// break;
|
||
|
|
// case vBLEND_MODE_BLEND:
|
||
|
|
// case vBLEND_MODE_BLEND_FIXED:
|
||
|
|
// GX::SetBlendMode ( GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_CLEAR );
|
||
|
|
// break;
|
||
|
|
// case vBLEND_MODE_BRIGHTEN:
|
||
|
|
// case vBLEND_MODE_BRIGHTEN_FIXED:
|
||
|
|
//// GX::SetBlendMode ( GX_BM_BLEND, GX_BL_DSTCLR, GX_BL_ONE, GX_LO_CLEAR );
|
||
|
|
// GX::SetBlendMode ( GX_BM_NONE, GX_BL_ONE, GX_BL_ONE, GX_LO_CLEAR );
|
||
|
|
// break;
|
||
|
|
// case vBLEND_MODE_MODULATE_FIXED:
|
||
|
|
// case vBLEND_MODE_MODULATE:
|
||
|
|
//// GX::SetBlendMode ( GX_BM_BLEND, GX_BL_DSTCLR, GX_BL_ZERO, GX_LO_CLEAR );
|
||
|
|
// GX::SetBlendMode ( GX_BM_NONE, GX_BL_ONE, GX_BL_ONE, GX_LO_CLEAR );
|
||
|
|
// break;
|
||
|
|
// case vBLEND_MODE_DIFFUSE:
|
||
|
|
// default:
|
||
|
|
// GX::SetBlendMode ( GX_BM_NONE, GX_BL_ONE, GX_BL_ONE, GX_LO_CLEAR );
|
||
|
|
// break;
|
||
|
|
// }
|
||
|
|
// }
|
||
|
|
//
|
||
|
|
// tev_id++;
|
||
|
|
// map_id = cur_map;
|
||
|
|
//}
|
||
|
|
//
|
||
|
|
//static void multi_end ( BlendModes blend, uint32 alphacutoff )
|
||
|
|
//{
|
||
|
|
// // Special case. If the base layer uses subtractive mode, we need to add a stage to
|
||
|
|
// // modulate the color & alpha.
|
||
|
|
// switch ( blend )
|
||
|
|
// {
|
||
|
|
//// case vBLEND_MODE_DIFFUSE:
|
||
|
|
//// GX::SetAlphaCompare(GX_GEQUAL, 0, GX_AOP_AND, GX_GEQUAL, 0 );
|
||
|
|
//// if ( alphacutoff == 0 )
|
||
|
|
//// {
|
||
|
|
//// GXSetZCompLoc( GX_TRUE );
|
||
|
|
//// }
|
||
|
|
//// else
|
||
|
|
//// {
|
||
|
|
//// GXSetZCompLoc( GX_FALSE ); // Textures with holes will not write to the z buffer when a<=cutoff.
|
||
|
|
//// }
|
||
|
|
//// break;
|
||
|
|
// case vBLEND_MODE_SUB_FIXED:
|
||
|
|
// case vBLEND_MODE_SUBTRACT:
|
||
|
|
// {
|
||
|
|
// GXTevStageID s_id = (GXTevStageID)(((int)GX_TEVSTAGE0)+stage_id);
|
||
|
|
//
|
||
|
|
// GX::SetTevOrder( s_id, GX_TEXCOORD_NULL, GX_TEX_DISABLE, GX_COLOR_NULL );
|
||
|
|
// GX::SetTevSwapMode( s_id, GX_TEV_SWAP0, GX_TEV_SWAP0 );
|
||
|
|
// GX::SetTevAlphaOp(s_id, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV );
|
||
|
|
// GX::SetTevColorOp(s_id, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV );
|
||
|
|
// GX::SetTevAlphaIn ( s_id, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_APREV );
|
||
|
|
// GX::SetTevColorIn ( s_id, GX_CC_ZERO, GX_CC_CPREV, GX_CC_APREV, GX_CC_ZERO );
|
||
|
|
// stage_id++;
|
||
|
|
// //GX::SetAlphaCompare(GX_GEQUAL, 0, GX_AOP_AND, GX_GEQUAL, 0 );
|
||
|
|
//// GXSetZCompLoc( GX_FALSE );
|
||
|
|
// }
|
||
|
|
// break;
|
||
|
|
// default:
|
||
|
|
// //GX::SetAlphaCompare(GX_GEQUAL, alphacutoff, GX_AOP_AND, GX_GEQUAL, alphacutoff );
|
||
|
|
//// if ( alphacutoff == 0 )
|
||
|
|
//// {
|
||
|
|
//// GXSetZCompLoc( GX_TRUE );
|
||
|
|
//// }
|
||
|
|
//// else
|
||
|
|
//// {
|
||
|
|
//// GXSetZCompLoc( GX_FALSE ); // Textures with holes will not write to the z buffer when a<=cutoff.
|
||
|
|
//// }
|
||
|
|
// break;
|
||
|
|
// }
|
||
|
|
//
|
||
|
|
//// if ( blend == vBLEND_MODE_DIFFUSE )
|
||
|
|
//// {
|
||
|
|
//// //Always pass pixels with multi-texturing as the base must be opaque.
|
||
|
|
//// GX::SetAlphaCompare(GX_GEQUAL, 0, GX_AOP_AND, GX_GEQUAL, 0 );
|
||
|
|
//// GXSetZCompLoc( GX_TRUE );
|
||
|
|
//// }
|
||
|
|
//// else
|
||
|
|
//// {
|
||
|
|
//// }
|
||
|
|
//
|
||
|
|
// if ( correct_color )
|
||
|
|
// {
|
||
|
|
// GXTexCoordID u_id;
|
||
|
|
// // Convert color0 to s,t for 2-D texture lookup (RG)
|
||
|
|
// u_id = (GXTexCoordID)(((int)GX_TEXCOORD0)+uv_id);
|
||
|
|
// GX::SetTexCoordGen(u_id, GX_TG_SRTG, GX_TG_COLOR0, GX_IDENTITY);
|
||
|
|
// GX::SetTevOrder(GX_TEVSTAGE0, u_id, GX_TEXMAP7, GX_COLOR_NULL);
|
||
|
|
// uv_id++;
|
||
|
|
//
|
||
|
|
// // Convert color1 to s,t for 2-D texture lookup (BA)
|
||
|
|
// u_id = (GXTexCoordID)(((int)GX_TEXCOORD0)+uv_id);
|
||
|
|
// GX::SetTexCoordGen(u_id, GX_TG_SRTG, GX_TG_COLOR1, GX_IDENTITY);
|
||
|
|
// GX::SetTevOrder(GX_TEVSTAGE1, u_id, GX_TEXMAP7, GX_COLOR_NULL);
|
||
|
|
// uv_id++;
|
||
|
|
// GX::SetNumChans( 2 );
|
||
|
|
// }
|
||
|
|
// else
|
||
|
|
// {
|
||
|
|
// GX::SetNumChans( 1 );
|
||
|
|
// }
|
||
|
|
//
|
||
|
|
// // Set final number of textures/stages.
|
||
|
|
// GX::SetNumTexGens( uv_id );
|
||
|
|
// GX::SetNumTevStages( stage_id );
|
||
|
|
//}
|
||
|
|
//
|
||
|
|
////sMaterial *Materials;
|
||
|
|
//uint32 NumMaterials;
|
||
|
|
////Lst::HashTable< sMaterial > *pMaterialTable = NULL;
|
||
|
|
//
|
||
|
|
//void sMaterial::Submit( uint32 mesh_flags, GXColor mesh_color )
|
||
|
|
//{
|
||
|
|
// // Figure uv and vc wibble updates if required.
|
||
|
|
// figure_wibble_uv();
|
||
|
|
// figure_wibble_vc();
|
||
|
|
//
|
||
|
|
//
|
||
|
|
//
|
||
|
|
// for ( uint layer = 0; layer < Passes; layer++ )
|
||
|
|
// {
|
||
|
|
// if( Flags[layer] & MATFLAG_UV_WIBBLE )
|
||
|
|
// {
|
||
|
|
// // Set up the texture generation matrix here.
|
||
|
|
// Mtx m;
|
||
|
|
// MTXTrans( m, m_pUVControl->UVWibbleOffset[layer][0], m_pUVControl->UVWibbleOffset[layer][1], 0.0f );
|
||
|
|
// switch ( layer )
|
||
|
|
// {
|
||
|
|
// case 0:
|
||
|
|
// GX::LoadTexMtxImm( m, GX_TEXMTX0, GX_MTX2x4 );
|
||
|
|
// break;
|
||
|
|
// case 1:
|
||
|
|
// GX::LoadTexMtxImm( m, GX_TEXMTX1, GX_MTX2x4 );
|
||
|
|
// break;
|
||
|
|
// case 2:
|
||
|
|
// GX::LoadTexMtxImm( m, GX_TEXMTX2, GX_MTX2x4 );
|
||
|
|
// break;
|
||
|
|
// case 3:
|
||
|
|
// GX::LoadTexMtxImm( m, GX_TEXMTX3, GX_MTX2x4 );
|
||
|
|
// break;
|
||
|
|
// default:
|
||
|
|
// break;
|
||
|
|
//
|
||
|
|
// }
|
||
|
|
//
|
||
|
|
//// // Handle UV wibbling.
|
||
|
|
//// D3DXMATRIX mat;
|
||
|
|
//// mat._11 = 1.0f; mat._12 = 0.0f;
|
||
|
|
//// mat._21 = 0.0f; mat._22 = 1.0f;
|
||
|
|
//// mat._31 = UVWibbleOffset[p][0]; mat._32 = UVWibbleOffset[p][1];
|
||
|
|
//// mat._41 = 0.0f; mat._42 = 0.0f;
|
||
|
|
//// D3DDevice_SetTransform((D3DTRANSFORMSTATETYPE)( D3DTS_TEXTURE0 + p ), &mat );
|
||
|
|
//// D3DDevice_SetTextureStageState( p, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2 );
|
||
|
|
//// D3DDevice_SetTextureStageState( p, D3DTSS_TEXCOORDINDEX, D3DTSS_TCI_PASSTHRU | p );
|
||
|
|
// }
|
||
|
|
// }
|
||
|
|
//
|
||
|
|
//// // Generate display list.
|
||
|
|
////
|
||
|
|
//// multi_start ( Passes );
|
||
|
|
//// for ( uint layer = 0; layer < Passes ; layer++ )
|
||
|
|
//// {
|
||
|
|
//// GXTexWrapMode u_mode;
|
||
|
|
//// GXTexWrapMode v_mode;
|
||
|
|
//// if ( Flags[layer] & MATFLAG_ENVIRONMENT )
|
||
|
|
//// {
|
||
|
|
//// u_mode = GX_REPEAT;
|
||
|
|
//// v_mode = GX_REPEAT;
|
||
|
|
//// }
|
||
|
|
//// else
|
||
|
|
//// {
|
||
|
|
//// u_mode = UVAddressing[layer] & (1<<0) ? GX_CLAMP : GX_REPEAT;
|
||
|
|
//// v_mode = UVAddressing[layer] & (1<<1) ? GX_CLAMP : GX_REPEAT;
|
||
|
|
//// }
|
||
|
|
////
|
||
|
|
//// if ( pTex[layer] )
|
||
|
|
//// {
|
||
|
|
//// multi_add_texture ( pTex[layer],
|
||
|
|
//// matcol[layer],
|
||
|
|
//// u_mode,
|
||
|
|
//// v_mode,
|
||
|
|
//// (BlendModes)blendMode[layer],
|
||
|
|
//// fixAlpha[layer],
|
||
|
|
//// Flags[layer],
|
||
|
|
//// &uv_slot[layer],
|
||
|
|
//// K[layer] );
|
||
|
|
//// }
|
||
|
|
//// else
|
||
|
|
//// {
|
||
|
|
//// // Untextured.
|
||
|
|
//// GXTevStageID s_id = (GXTevStageID)(((int)GX_TEVSTAGE0)+stage_id);
|
||
|
|
//// BlendModes blend = (BlendModes)blendMode[layer];
|
||
|
|
//// uint32 fix = fixAlpha[layer];
|
||
|
|
////
|
||
|
|
//// uv_slot[layer] = -1;
|
||
|
|
////
|
||
|
|
//// switch ( blend )
|
||
|
|
//// {
|
||
|
|
//// case vBLEND_MODE_ADD_FIXED:
|
||
|
|
//// case vBLEND_MODE_SUB_FIXED:
|
||
|
|
//// case vBLEND_MODE_BLEND_FIXED:
|
||
|
|
//// case vBLEND_MODE_BRIGHTEN_FIXED:
|
||
|
|
//// case vBLEND_MODE_MODULATE_FIXED:
|
||
|
|
//// GX::SetTevKAlphaSel( s_id, (GXTevKAlphaSel)(((int)GX_TEV_KASEL_K0_A)+tev_id) );
|
||
|
|
//// GX::SetTevKColor( (GXTevKColorID)(((int)GX_KCOLOR0)+tev_id), (GXColor){fix,fix,fix,fix} );
|
||
|
|
//// GX::SetTevOrder( s_id, GX_TEXCOORD_NULL, GX_TEX_DISABLE, GX_COLOR0A0 );
|
||
|
|
//// GX::SetTevSwapMode( s_id, GX_TEV_SWAP0, GX_TEV_SWAP0 );
|
||
|
|
//// GX::SetTevAlphaOp(s_id, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, (GXTevRegID)(((int)GX_TEVPREV)+tev_id) );
|
||
|
|
//// GX::SetTevColorOp(s_id, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, (GXTevRegID)(((int)GX_TEVPREV)+tev_id) );
|
||
|
|
//// GX::SetTevAlphaIn ( s_id, GX_CA_KONST, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO );
|
||
|
|
//// GX::SetTevColorIn ( s_id, GX_CC_RASC, GX_CC_ZERO, GX_CC_ZERO, GX_CC_ZERO );
|
||
|
|
//// stage_id++;
|
||
|
|
//// break;
|
||
|
|
//// case vBLEND_MODE_ADD:
|
||
|
|
//// case vBLEND_MODE_SUBTRACT:
|
||
|
|
//// case vBLEND_MODE_BLEND:
|
||
|
|
//// case vBLEND_MODE_BRIGHTEN:
|
||
|
|
//// case vBLEND_MODE_MODULATE:
|
||
|
|
//// case vBLEND_MODE_DIFFUSE:
|
||
|
|
//// default:
|
||
|
|
//// GX::SetTevOrder( s_id, GX_TEXCOORD_NULL, GX_TEX_DISABLE, GX_COLOR0A0 );
|
||
|
|
//// GX::SetTevSwapMode( s_id, GX_TEV_SWAP0, GX_TEV_SWAP0 );
|
||
|
|
//// GX::SetTevAlphaOp(s_id, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, (GXTevRegID)(((int)GX_TEVPREV)+tev_id) );
|
||
|
|
//// GX::SetTevColorOp(s_id, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_2, GX_ENABLE, (GXTevRegID)(((int)GX_TEVPREV)+tev_id) );
|
||
|
|
//// GX::SetTevAlphaIn ( s_id, GX_CA_RASA, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO );
|
||
|
|
//// GX::SetTevColorIn ( s_id, GX_CC_RASC, GX_CC_ZERO, GX_CC_ZERO, GX_CC_ZERO );
|
||
|
|
//// stage_id++;
|
||
|
|
//// break;
|
||
|
|
//// }
|
||
|
|
////
|
||
|
|
//// if ( tev_id > 0 ) {
|
||
|
|
//// multi_add_layer ( blend, fix );
|
||
|
|
//// } else {
|
||
|
|
//// // Set blend mode for base layer.
|
||
|
|
//// switch ( blend )
|
||
|
|
//// {
|
||
|
|
//// case vBLEND_MODE_ADD:
|
||
|
|
//// case vBLEND_MODE_ADD_FIXED:
|
||
|
|
//// GX::SetBlendMode ( GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_ONE, GX_LO_CLEAR );
|
||
|
|
//// break;
|
||
|
|
//// case vBLEND_MODE_SUBTRACT:
|
||
|
|
//// case vBLEND_MODE_SUB_FIXED:
|
||
|
|
//// GX::SetBlendMode ( GX_BM_SUBTRACT, GX_BL_ZERO, GX_BL_ZERO, GX_LO_CLEAR );
|
||
|
|
//// break;
|
||
|
|
//// case vBLEND_MODE_BLEND:
|
||
|
|
//// case vBLEND_MODE_BLEND_FIXED:
|
||
|
|
//// GX::SetBlendMode ( GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_CLEAR );
|
||
|
|
//// break;
|
||
|
|
//// case vBLEND_MODE_BRIGHTEN:
|
||
|
|
//// case vBLEND_MODE_BRIGHTEN_FIXED:
|
||
|
|
//// GX::SetBlendMode ( GX_BM_BLEND, GX_BL_DSTCLR, GX_BL_ONE, GX_LO_CLEAR );
|
||
|
|
//// break;
|
||
|
|
//// case vBLEND_MODE_MODULATE_FIXED:
|
||
|
|
//// case vBLEND_MODE_MODULATE:
|
||
|
|
//// GX::SetBlendMode ( GX_BM_BLEND, GX_BL_DSTCLR, GX_BL_ZERO, GX_LO_CLEAR );
|
||
|
|
//// break;
|
||
|
|
//// case vBLEND_MODE_DIFFUSE:
|
||
|
|
//// default:
|
||
|
|
//// GX::SetBlendMode ( GX_BM_NONE, GX_BL_ONE, GX_BL_ONE, GX_LO_CLEAR );
|
||
|
|
//// break;
|
||
|
|
//// }
|
||
|
|
//// }
|
||
|
|
//// tev_id++;
|
||
|
|
//// }
|
||
|
|
//// }
|
||
|
|
////
|
||
|
|
//// multi_end( (BlendModes)blendMode[0], AlphaCutoff );
|
||
|
|
//
|
||
|
|
//
|
||
|
|
// // Set the cull mode, but only if the calling code didn't override this by setting CULL_NONE.
|
||
|
|
// if ( EngineGlobals.poly_culling )
|
||
|
|
// {
|
||
|
|
// GX::SetCullMode ( m_no_bfc ? GX_CULL_NONE : GX_CULL_FRONT );
|
||
|
|
// }
|
||
|
|
// else
|
||
|
|
// {
|
||
|
|
// GX::SetCullMode ( GX_CULL_NONE );
|
||
|
|
// }
|
||
|
|
//
|
||
|
|
//#ifdef __USE_MAT_DL__
|
||
|
|
// if ( mp_display_list )
|
||
|
|
// {
|
||
|
|
// GXCallDisplayList ( mp_display_list, m_display_list_size );
|
||
|
|
// }
|
||
|
|
//#else
|
||
|
|
// Initialize( mesh_flags, mesh_color );
|
||
|
|
//#endif // __USE_MAT_DL__
|
||
|
|
//
|
||
|
|
// // See if we need to set the comp location (just check the base layer).
|
||
|
|
// if ( pTex[0] )
|
||
|
|
// {
|
||
|
|
// if ( pTex[0]->HasHoles )
|
||
|
|
// {
|
||
|
|
// GX::SetZCompLoc( GX_FALSE );
|
||
|
|
// }
|
||
|
|
// else
|
||
|
|
// {
|
||
|
|
//// GX::SetZCompLoc( GX_FALSE );
|
||
|
|
// GX::SetZCompLoc( GX_TRUE );
|
||
|
|
//// GX::SetAlphaCompare(GX_GEQUAL, 0, GX_AOP_AND, GX_GEQUAL, 0 );
|
||
|
|
// }
|
||
|
|
// }
|
||
|
|
// GX::SetAlphaCompare(GX_GEQUAL, AlphaCutoff, GX_AOP_AND, GX_GEQUAL, AlphaCutoff );
|
||
|
|
//
|
||
|
|
//// if ( mp_display_list )
|
||
|
|
//// {
|
||
|
|
//// GXCallDisplayList ( mp_display_list, m_display_list_size );
|
||
|
|
//// }
|
||
|
|
//// else
|
||
|
|
//// {
|
||
|
|
//// // If no material, default to purple, untextured.
|
||
|
|
//// GX::SetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD_NULL, GX_TEXMAP_NULL, GX_COLOR0A0);
|
||
|
|
//// GX::SetTevSwapMode( GX_TEVSTAGE0, GX_TEV_SWAP0, GX_TEV_SWAP0 );
|
||
|
|
//// GX::SetNumTexGens( 0 );
|
||
|
|
//// GX::SetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_2, GX_ENABLE, GX_TEVPREV );
|
||
|
|
//// GX::SetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_2, GX_ENABLE, GX_TEVPREV );
|
||
|
|
//// GX::SetAlphaCompare(GX_GREATER, 0, GX_AOP_AND, GX_GREATER, 0 );
|
||
|
|
//// GX::SetBlendMode ( GX_BM_NONE, GX_BL_ONE, GX_BL_ONE, GX_LO_CLEAR );
|
||
|
|
//// GX::SetTevAlphaIn ( GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_RASA );
|
||
|
|
//// GX::SetTevColorIn ( GX_TEVSTAGE0, GX_CC_ZERO, GX_CC_ZERO, GX_CC_ZERO, GX_CC_RASC );
|
||
|
|
//// GX::SetChanMatColor( GX_COLOR0A0, (GXColor){255,0,255,255} );
|
||
|
|
//// GX::SetChanAmbColor( GX_COLOR0A0, (GXColor){128,128,128,255} );
|
||
|
|
//// GX::SetChanCtrl( GX_COLOR0A0, GX_ENABLE, GX_SRC_REG, GX_SRC_REG, GX_LIGHT_NULL, GX_DF_NONE, GX_AF_NONE );
|
||
|
|
//// }
|
||
|
|
//}
|
||
|
|
//
|
||
|
|
//void sMaterial::Initialize( uint32 mesh_flags, GXColor mesh_color )
|
||
|
|
//{
|
||
|
|
//#ifdef __USE_MAT_DL__
|
||
|
|
// // Generate display list.
|
||
|
|
// Mem::Manager::sHandle().BottomUpHeap()->PushAlign( 32 );
|
||
|
|
//#define DL_BUILD_SIZE (32*1024)
|
||
|
|
// uint8 * p_build_dl = new (Mem::Manager::sHandle().TopDownHeap()) uint8[DL_BUILD_SIZE];
|
||
|
|
// DCFlushRange ( p_build_dl, DL_BUILD_SIZE );
|
||
|
|
//
|
||
|
|
// GXBeginDisplayList ( p_build_dl, DL_BUILD_SIZE );
|
||
|
|
// GXResetWriteGatherPipe();
|
||
|
|
//#endif // __USE_MAT_DL__
|
||
|
|
//
|
||
|
|
// multi_start ( Passes );
|
||
|
|
// for ( uint layer = 0; layer < Passes ; layer++ )
|
||
|
|
// {
|
||
|
|
// GXTexWrapMode u_mode;
|
||
|
|
// GXTexWrapMode v_mode;
|
||
|
|
// if ( Flags[layer] & MATFLAG_ENVIRONMENT )
|
||
|
|
// {
|
||
|
|
// u_mode = GX_REPEAT;
|
||
|
|
// v_mode = GX_REPEAT;
|
||
|
|
// }
|
||
|
|
// else
|
||
|
|
// {
|
||
|
|
// u_mode = UVAddressing[layer] & (1<<0) ? GX_CLAMP : GX_REPEAT;
|
||
|
|
// v_mode = UVAddressing[layer] & (1<<1) ? GX_CLAMP : GX_REPEAT;
|
||
|
|
// }
|
||
|
|
//
|
||
|
|
// GXColor col;
|
||
|
|
//
|
||
|
|
// if ( mesh_flags & sMesh::MESH_FLAG_MATERIAL_COLOR_OVERRIDE && !( Flags[layer] & 0x80 ) )
|
||
|
|
// {
|
||
|
|
// col = mesh_color;
|
||
|
|
// }
|
||
|
|
// else
|
||
|
|
// {
|
||
|
|
// col = matcol[layer];
|
||
|
|
// }
|
||
|
|
//
|
||
|
|
// if ( pTex[layer] )
|
||
|
|
// {
|
||
|
|
// multi_add_texture ( pTex[layer],
|
||
|
|
// col,
|
||
|
|
// u_mode,
|
||
|
|
// v_mode,
|
||
|
|
// (BlendModes)blendMode[layer],
|
||
|
|
// fixAlpha[layer],
|
||
|
|
// Flags[layer],
|
||
|
|
// &uv_slot[layer],
|
||
|
|
// K[layer] );
|
||
|
|
// }
|
||
|
|
// else
|
||
|
|
// {
|
||
|
|
// // Untextured.
|
||
|
|
// GXTevStageID s_id = (GXTevStageID)(((int)GX_TEVSTAGE0)+stage_id);
|
||
|
|
// BlendModes blend = (BlendModes)blendMode[layer];
|
||
|
|
// uint32 fix = fixAlpha[layer];
|
||
|
|
//
|
||
|
|
// uv_slot[layer] = -1;
|
||
|
|
//
|
||
|
|
// switch ( blend )
|
||
|
|
// {
|
||
|
|
// case vBLEND_MODE_ADD_FIXED:
|
||
|
|
// case vBLEND_MODE_SUB_FIXED:
|
||
|
|
// case vBLEND_MODE_BLEND_FIXED:
|
||
|
|
// case vBLEND_MODE_BRIGHTEN_FIXED:
|
||
|
|
// case vBLEND_MODE_MODULATE_FIXED:
|
||
|
|
// GX::SetTevKAlphaSel( s_id, (GXTevKAlphaSel)(((int)GX_TEV_KASEL_K0_A)+tev_id) );
|
||
|
|
// GX::SetTevKColor( (GXTevKColorID)(((int)GX_KCOLOR0)+tev_id), (GXColor){fix,fix,fix,fix} );
|
||
|
|
// GX::SetTevOrder( s_id, GX_TEXCOORD_NULL, GX_TEX_DISABLE, GX_COLOR0A0 );
|
||
|
|
// GX::SetTevSwapMode( s_id, GX_TEV_SWAP0, GX_TEV_SWAP0 );
|
||
|
|
// GX::SetTevAlphaOp(s_id, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, (GXTevRegID)(((int)GX_TEVPREV)+tev_id) );
|
||
|
|
// GX::SetTevColorOp(s_id, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, (GXTevRegID)(((int)GX_TEVPREV)+tev_id) );
|
||
|
|
// GX::SetTevAlphaIn ( s_id, GX_CA_KONST, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO );
|
||
|
|
// GX::SetTevColorIn ( s_id, GX_CC_RASC, GX_CC_ZERO, GX_CC_ZERO, GX_CC_ZERO );
|
||
|
|
// stage_id++;
|
||
|
|
// break;
|
||
|
|
// case vBLEND_MODE_ADD:
|
||
|
|
// case vBLEND_MODE_SUBTRACT:
|
||
|
|
// case vBLEND_MODE_BLEND:
|
||
|
|
// case vBLEND_MODE_BRIGHTEN:
|
||
|
|
// case vBLEND_MODE_MODULATE:
|
||
|
|
// case vBLEND_MODE_DIFFUSE:
|
||
|
|
// default:
|
||
|
|
// GX::SetTevOrder( s_id, GX_TEXCOORD_NULL, GX_TEX_DISABLE, GX_COLOR0A0 );
|
||
|
|
// GX::SetTevSwapMode( s_id, GX_TEV_SWAP0, GX_TEV_SWAP0 );
|
||
|
|
// GX::SetTevAlphaOp(s_id, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, (GXTevRegID)(((int)GX_TEVPREV)+tev_id) );
|
||
|
|
// GX::SetTevColorOp(s_id, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_2, GX_ENABLE, (GXTevRegID)(((int)GX_TEVPREV)+tev_id) );
|
||
|
|
// GX::SetTevAlphaIn ( s_id, GX_CA_RASA, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO );
|
||
|
|
// GX::SetTevColorIn ( s_id, GX_CC_RASC, GX_CC_ZERO, GX_CC_ZERO, GX_CC_ZERO );
|
||
|
|
// stage_id++;
|
||
|
|
// break;
|
||
|
|
// }
|
||
|
|
//
|
||
|
|
// if ( tev_id > 0 ) {
|
||
|
|
// multi_add_layer ( blend, fix );
|
||
|
|
// } else {
|
||
|
|
// // Set blend mode for base layer.
|
||
|
|
// switch ( blend )
|
||
|
|
// {
|
||
|
|
// case vBLEND_MODE_ADD:
|
||
|
|
// case vBLEND_MODE_ADD_FIXED:
|
||
|
|
// GX::SetBlendMode ( GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_ONE, GX_LO_CLEAR );
|
||
|
|
// break;
|
||
|
|
// case vBLEND_MODE_SUBTRACT:
|
||
|
|
// case vBLEND_MODE_SUB_FIXED:
|
||
|
|
// GX::SetBlendMode ( GX_BM_SUBTRACT, GX_BL_ZERO, GX_BL_ZERO, GX_LO_CLEAR );
|
||
|
|
// break;
|
||
|
|
// case vBLEND_MODE_BLEND:
|
||
|
|
// case vBLEND_MODE_BLEND_FIXED:
|
||
|
|
// GX::SetBlendMode ( GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_CLEAR );
|
||
|
|
// break;
|
||
|
|
// case vBLEND_MODE_BRIGHTEN:
|
||
|
|
// case vBLEND_MODE_BRIGHTEN_FIXED:
|
||
|
|
// GX::SetBlendMode ( GX_BM_BLEND, GX_BL_DSTCLR, GX_BL_ONE, GX_LO_CLEAR );
|
||
|
|
// break;
|
||
|
|
// case vBLEND_MODE_MODULATE_FIXED:
|
||
|
|
// case vBLEND_MODE_MODULATE:
|
||
|
|
// GX::SetBlendMode ( GX_BM_BLEND, GX_BL_DSTCLR, GX_BL_ZERO, GX_LO_CLEAR );
|
||
|
|
// break;
|
||
|
|
// case vBLEND_MODE_DIFFUSE:
|
||
|
|
// default:
|
||
|
|
// GX::SetBlendMode ( GX_BM_NONE, GX_BL_ONE, GX_BL_ONE, GX_LO_CLEAR );
|
||
|
|
// break;
|
||
|
|
// }
|
||
|
|
// }
|
||
|
|
// tev_id++;
|
||
|
|
// }
|
||
|
|
// }
|
||
|
|
//
|
||
|
|
// multi_end( (BlendModes)blendMode[0], AlphaCutoff );
|
||
|
|
//
|
||
|
|
//#ifdef __USE_MAT_DL__
|
||
|
|
// int size = GXEndDisplayList();
|
||
|
|
//
|
||
|
|
// // If we already have a display list & this one will fit, just use the existing piece of memory.
|
||
|
|
// uint8 * p_dl;
|
||
|
|
// if ( mp_display_list && ( size <= m_display_list_size ) )
|
||
|
|
// {
|
||
|
|
// p_dl = mp_display_list;
|
||
|
|
// }
|
||
|
|
// else
|
||
|
|
// {
|
||
|
|
// if ( mp_display_list )
|
||
|
|
// {
|
||
|
|
// //gMatBytes -= m_display_list_size;
|
||
|
|
// delete mp_display_list;
|
||
|
|
// }
|
||
|
|
// p_dl = new uint8[size];
|
||
|
|
// //gMatBytes += size;
|
||
|
|
// }
|
||
|
|
//
|
||
|
|
// memcpy ( p_dl, p_build_dl, size );
|
||
|
|
// DCFlushRange ( p_dl, size );
|
||
|
|
//
|
||
|
|
// delete p_build_dl;
|
||
|
|
//
|
||
|
|
// mp_display_list = p_dl;
|
||
|
|
// m_display_list_size = size;
|
||
|
|
// Mem::Manager::sHandle().BottomUpHeap()->PopAlign();
|
||
|
|
//#endif // __USE_MAT_DL__
|
||
|
|
//}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
sMaterial* GetMaterial( uint32 checksum, sScene *p_scene )
|
||
|
|
{
|
||
|
|
// for ( int lp = 0; lp < p_scene->m_num_materials; lp++ )
|
||
|
|
// {
|
||
|
|
// if( p_scene->mp_material_array[lp].Checksum == checksum )
|
||
|
|
// {
|
||
|
|
// return &p_scene->mp_material_array[lp];
|
||
|
|
// }
|
||
|
|
// }
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
void InitializeMaterial( sMaterial* p_material )
|
||
|
|
{
|
||
|
|
// p_material->Initialize();
|
||
|
|
p_material->uv_slot[0] = 0;
|
||
|
|
p_material->uv_slot[1] = 1;
|
||
|
|
p_material->uv_slot[2] = 2;
|
||
|
|
p_material->uv_slot[3] = 3;
|
||
|
|
}
|
||
|
|
|
||
|
|
#define MemoryRead( dst, size, num, src ) memcpy(( dst ), ( src ), (( num ) * ( size ))); \
|
||
|
|
( src ) += (( num ) * ( size ))
|
||
|
|
|
||
|
|
/******************************************************************/
|
||
|
|
/* */
|
||
|
|
/* */
|
||
|
|
/******************************************************************/
|
||
|
|
sMaterial * LoadMaterialsFromMemory( void **pp_mem, Lst::HashTable< Nx::CTexture > *p_texture_table, int * p_num_materials )
|
||
|
|
{
|
||
|
|
uint8 *p_data = (uint8*)( *pp_mem );
|
||
|
|
uint32 MMAG, MMIN, K, L, NumSeqs, seq, NumKeys;
|
||
|
|
uint32 i;
|
||
|
|
|
||
|
|
// Get number of materials.
|
||
|
|
uint32 new_materials;
|
||
|
|
MemoryRead( &new_materials, sizeof( uint32 ), 1, p_data );
|
||
|
|
|
||
|
|
if ( p_num_materials ) *p_num_materials = new_materials;
|
||
|
|
|
||
|
|
// Create array of materials.
|
||
|
|
sMaterial * p_mat_array = new sMaterial[new_materials];
|
||
|
|
|
||
|
|
// Loop over materials.
|
||
|
|
for( i = 0; i < new_materials; ++i )
|
||
|
|
{
|
||
|
|
// Create new material.
|
||
|
|
sMaterial *pMat = &p_mat_array[i];
|
||
|
|
|
||
|
|
pMat->m_num_wibble_vc_anims = 0;
|
||
|
|
pMat->mp_wibble_vc_params = NULL;
|
||
|
|
pMat->mp_wibble_vc_colors = NULL;
|
||
|
|
|
||
|
|
// Get material checksum.
|
||
|
|
MemoryRead( &pMat->Checksum, sizeof( uint32 ), 1, p_data );
|
||
|
|
|
||
|
|
// Get number of passes.
|
||
|
|
uint32 pass;
|
||
|
|
MemoryRead( &pass, sizeof( uint32 ), 1, p_data );
|
||
|
|
pMat->Passes = pass;
|
||
|
|
|
||
|
|
// Get alpha cutoff value.
|
||
|
|
uint32 ac;
|
||
|
|
MemoryRead( &ac, sizeof( uint32 ), 1, p_data );
|
||
|
|
pMat->AlphaCutoff = ac; //( ac >= 128 ) ? 255 : ( ac * 2 );
|
||
|
|
|
||
|
|
// Get sorted flag.
|
||
|
|
bool sorted;
|
||
|
|
MemoryRead( &sorted, sizeof( bool ), 1, p_data );
|
||
|
|
pMat->m_sorted = sorted;
|
||
|
|
|
||
|
|
// Get draw order.
|
||
|
|
MemoryRead( &pMat->m_draw_order, sizeof( float ), 1, p_data );
|
||
|
|
|
||
|
|
// Get backface cull flag.
|
||
|
|
bool bfc;
|
||
|
|
MemoryRead( &bfc, sizeof( bool ), 1, p_data );
|
||
|
|
pMat->m_no_bfc = bfc;
|
||
|
|
|
||
|
|
// // Get grassify flag and (optionally) grassify data.
|
||
|
|
// bool grassify;
|
||
|
|
// MemoryRead( &grassify, sizeof( bool ), 1, p_data );
|
||
|
|
// pMat->m_grassify = (uint8)grassify;
|
||
|
|
// if( grassify )
|
||
|
|
// {
|
||
|
|
// MemoryRead( &pMat->m_grass_height, sizeof( float ), 1, p_data );
|
||
|
|
// int layers;
|
||
|
|
// MemoryRead( &layers, sizeof( int ), 1, p_data );
|
||
|
|
// pMat->m_grass_layers = (uint8)layers;
|
||
|
|
// }
|
||
|
|
|
||
|
|
GXColor mat_col[MAX_PASSES];
|
||
|
|
|
||
|
|
pMat->m_pUVControl = NULL;
|
||
|
|
for( uint32 pass = 0; pass < pMat->Passes; ++pass )
|
||
|
|
{
|
||
|
|
// Get texture checksum.
|
||
|
|
uint32 TextureChecksum;
|
||
|
|
MemoryRead( &TextureChecksum, sizeof( uint32 ), 1, p_data );
|
||
|
|
|
||
|
|
// Get material flags.
|
||
|
|
MemoryRead( &pMat->Flags[pass], sizeof( uint32 ), 1, p_data );
|
||
|
|
|
||
|
|
// Get ALPHA register value.
|
||
|
|
uint64 ra;
|
||
|
|
MemoryRead( &ra, sizeof( uint64 ), 1, p_data );
|
||
|
|
pMat->blendMode[pass] = ra & 0xff;
|
||
|
|
pMat->fixAlpha[pass] = ( ra >> 32 ) & 0xff;
|
||
|
|
|
||
|
|
// Backface cull test - if this is an alpha blended material, turn off backface culling.
|
||
|
|
if(( pass == 0 ) && (( ra & 0xFF ) != 0x00 ))
|
||
|
|
{
|
||
|
|
pMat->m_no_bfc = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Get UV addressing types.
|
||
|
|
uint32 u_addressing, v_addressing;
|
||
|
|
MemoryRead( &u_addressing, sizeof( uint32 ), 1, p_data );
|
||
|
|
MemoryRead( &v_addressing, sizeof( uint32 ), 1, p_data );
|
||
|
|
pMat->UVAddressing[pass] = (( v_addressing << 1 ) | u_addressing );
|
||
|
|
|
||
|
|
// Step past material colors, currently unsupported.
|
||
|
|
float col[9];
|
||
|
|
MemoryRead( col, sizeof( float ) * 9, 1, p_data );
|
||
|
|
|
||
|
|
mat_col[pass].r = (u8)((col[0] * 255.0f) + 0.5f);
|
||
|
|
mat_col[pass].g = (u8)((col[1] * 255.0f) + 0.5f);
|
||
|
|
mat_col[pass].b = (u8)((col[2] * 255.0f) + 0.5f);
|
||
|
|
mat_col[pass].a = 255;
|
||
|
|
|
||
|
|
// Read uv wibble data if present.
|
||
|
|
if( pMat->Flags[pass] & MATFLAG_UV_WIBBLE )
|
||
|
|
{
|
||
|
|
if ( !pMat->m_pUVControl ) pMat->m_pUVControl = new sUVControl;
|
||
|
|
MemoryRead( &( pMat->m_pUVControl->UVWibbleParams[pass] ), sizeof( sUVWibbleParams ), 1, p_data );
|
||
|
|
}
|
||
|
|
|
||
|
|
// Step past vc wibble data, currently unsupported.
|
||
|
|
if(( pass == 0 ) && ( pMat->Flags[0] & MATFLAG_VC_WIBBLE ))
|
||
|
|
{
|
||
|
|
MemoryRead( &NumSeqs, sizeof( uint32 ), 1, p_data );
|
||
|
|
pMat->m_num_wibble_vc_anims = NumSeqs;
|
||
|
|
|
||
|
|
// Create sequence data array.
|
||
|
|
pMat->mp_wibble_vc_params = new sVCWibbleParams[NumSeqs];
|
||
|
|
|
||
|
|
// Create resultant color array.
|
||
|
|
pMat->mp_wibble_vc_colors = new uint32[NumSeqs];
|
||
|
|
|
||
|
|
for( seq = 0; seq < NumSeqs; ++seq )
|
||
|
|
{
|
||
|
|
MemoryRead( &NumKeys, sizeof( uint32 ), 1, p_data );
|
||
|
|
|
||
|
|
int phase;
|
||
|
|
MemoryRead( &phase, sizeof( int ), 1, p_data );
|
||
|
|
|
||
|
|
// Create array for keyframes.
|
||
|
|
pMat->mp_wibble_vc_params[seq].m_num_keyframes = NumKeys;
|
||
|
|
pMat->mp_wibble_vc_params[seq].m_phase = phase;
|
||
|
|
pMat->mp_wibble_vc_params[seq].mp_keyframes = new sVCWibbleKeyframe[NumKeys];
|
||
|
|
|
||
|
|
// Read keyframes into array.
|
||
|
|
MemoryRead( pMat->mp_wibble_vc_params[seq].mp_keyframes, sizeof( sVCWibbleKeyframe ), NumKeys, p_data );
|
||
|
|
|
||
|
|
for ( uint lp = 0; lp < NumKeys; lp++ )
|
||
|
|
{
|
||
|
|
uint8 r = pMat->mp_wibble_vc_params[seq].mp_keyframes[lp].m_color.r;
|
||
|
|
uint8 g = pMat->mp_wibble_vc_params[seq].mp_keyframes[lp].m_color.g;
|
||
|
|
uint8 b = pMat->mp_wibble_vc_params[seq].mp_keyframes[lp].m_color.b;
|
||
|
|
uint8 a = pMat->mp_wibble_vc_params[seq].mp_keyframes[lp].m_color.a;
|
||
|
|
pMat->mp_wibble_vc_params[seq].mp_keyframes[lp].m_color.r = b;
|
||
|
|
pMat->mp_wibble_vc_params[seq].mp_keyframes[lp].m_color.g = r;
|
||
|
|
pMat->mp_wibble_vc_params[seq].mp_keyframes[lp].m_color.b = g;
|
||
|
|
pMat->mp_wibble_vc_params[seq].mp_keyframes[lp].m_color.a = a;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if( TextureChecksum )
|
||
|
|
{
|
||
|
|
// If textured, resolve texture checksum...
|
||
|
|
Nx::CNgcTexture *p_ngc_texture = static_cast<Nx::CNgcTexture*>( p_texture_table->GetItem( TextureChecksum ) );
|
||
|
|
sTexture *pTex = ( p_ngc_texture ) ? p_ngc_texture->GetEngineTexture() : NULL;
|
||
|
|
|
||
|
|
// Bail if checksum not found.
|
||
|
|
if( pTex == NULL )
|
||
|
|
{
|
||
|
|
Dbg_Message( "error: couldn't find texture checksum %08X\n", TextureChecksum );
|
||
|
|
// exit( 1 );
|
||
|
|
pMat->pTex[pass] = NULL;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// Set texture pointer.
|
||
|
|
pMat->pTex[pass] = pTex;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Get mipmap info.
|
||
|
|
MemoryRead( &MMAG, sizeof( uint32 ), 1, p_data );
|
||
|
|
MemoryRead( &MMIN, sizeof( uint32 ), 1, p_data );
|
||
|
|
|
||
|
|
MemoryRead( &K, sizeof( uint32 ), 1, p_data );
|
||
|
|
MemoryRead( &L, sizeof( uint32 ), 1, p_data );
|
||
|
|
|
||
|
|
// Default PS2 value for K appears to be -8.0f - we are interested in deviations from this value.
|
||
|
|
pMat->K[pass] = ( *(float*)&K ) + 8.0f;
|
||
|
|
|
||
|
|
// Dave note 08/03/02 - having MIPs selected earlier than normal seems to cause some problems, since Xbox
|
||
|
|
// MIP selection is so different to Ps2. Limit the k value such that Xbox can never select smaller MIPs
|
||
|
|
// earlier than it would do by default.
|
||
|
|
if( pMat->K[pass] > 0.0f )
|
||
|
|
{
|
||
|
|
pMat->K[pass] = 0.0f;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// ...otherwise just step past mipmap info.
|
||
|
|
pMat->pTex[pass] = NULL;
|
||
|
|
uint32 mip[4];
|
||
|
|
MemoryRead( mip, sizeof( uint32 ) * 4, 1, p_data );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Generate material colors.
|
||
|
|
for( uint32 pass = 0; pass < pMat->Passes; ++pass )
|
||
|
|
{
|
||
|
|
if ( ( mat_col[0].r == mat_col[pass].r ) &&
|
||
|
|
( mat_col[0].g == mat_col[pass].g ) &&
|
||
|
|
( mat_col[0].b == mat_col[pass].b ) &&
|
||
|
|
( mat_col[0].a == mat_col[pass].a ) )
|
||
|
|
{
|
||
|
|
// Do nothing.
|
||
|
|
pMat->matcol[pass] = (GXColor){128,128,128,255};
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// Work out the texture color.
|
||
|
|
GXColor tc;
|
||
|
|
float base_r = (float)(mat_col[0].r > 0 ? mat_col[0].r : 1 );
|
||
|
|
float base_g = (float)(mat_col[0].g > 0 ? mat_col[0].g : 1 );
|
||
|
|
float base_b = (float)(mat_col[0].b > 0 ? mat_col[0].b : 1 );
|
||
|
|
float base_a = (float)(mat_col[0].a > 0 ? mat_col[0].a : 1 );
|
||
|
|
float r = ( ((float)mat_col[pass].r) / base_r ) * 128.0f;
|
||
|
|
float g = ( ((float)mat_col[pass].g) / base_g ) * 128.0f;
|
||
|
|
float b = ( ((float)mat_col[pass].b) / base_b ) * 128.0f;
|
||
|
|
float a = ( ((float)mat_col[pass].a) / base_a ) * 255.0f;
|
||
|
|
int _r = (int)r;
|
||
|
|
int _g = (int)g;
|
||
|
|
int _b = (int)b;
|
||
|
|
int _a = (int)a;
|
||
|
|
if ( _r > 255 ) _r = 255;
|
||
|
|
if ( _g > 255 ) _g = 255;
|
||
|
|
if ( _b > 255 ) _b = 255;
|
||
|
|
if ( _a > 255 ) _a = 255;
|
||
|
|
tc.r = (u8)( _r );
|
||
|
|
tc.g = (u8)( _g );
|
||
|
|
tc.b = (u8)( _b );
|
||
|
|
tc.a = (u8)( _a );
|
||
|
|
pMat->matcol[pass] = tc;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// pMat->mp_display_list = NULL;
|
||
|
|
// pMat->Initialize();
|
||
|
|
pMat->uv_slot[0] = 0;
|
||
|
|
pMat->uv_slot[1] = 1;
|
||
|
|
pMat->uv_slot[2] = 2;
|
||
|
|
pMat->uv_slot[3] = 3;
|
||
|
|
}
|
||
|
|
*pp_mem = p_data;
|
||
|
|
|
||
|
|
return p_mat_array;
|
||
|
|
}
|
||
|
|
|
||
|
|
sMaterial *LoadMaterials( void *p_FH, Lst::HashTable< Nx::CTexture > *p_texture_table, int * p_num_materials )
|
||
|
|
{
|
||
|
|
uint32 MMAG, MMIN, K, L, NumSeqs, seq, NumKeys;
|
||
|
|
uint32 i;
|
||
|
|
|
||
|
|
// Get number of materials.
|
||
|
|
uint32 new_materials;
|
||
|
|
File::Read( &new_materials, sizeof( uint32 ), 1, p_FH );
|
||
|
|
|
||
|
|
if ( p_num_materials ) *p_num_materials = new_materials;
|
||
|
|
|
||
|
|
// Create array of materials.
|
||
|
|
sMaterial * p_mat_array = new sMaterial[new_materials];
|
||
|
|
|
||
|
|
// Loop over materials.
|
||
|
|
for( i = 0; i < new_materials; ++i )
|
||
|
|
{
|
||
|
|
// Create new material.
|
||
|
|
sMaterial *pMat = &p_mat_array[i];
|
||
|
|
|
||
|
|
pMat->m_num_wibble_vc_anims = 0;
|
||
|
|
pMat->mp_wibble_vc_params = NULL;
|
||
|
|
pMat->mp_wibble_vc_colors = NULL;
|
||
|
|
|
||
|
|
// Get material checksum.
|
||
|
|
File::Read( &pMat->Checksum, sizeof( uint32 ), 1, p_FH );
|
||
|
|
|
||
|
|
// Get number of passes.
|
||
|
|
uint32 pass;
|
||
|
|
File::Read( &pass, sizeof( uint32 ), 1, p_FH );
|
||
|
|
pMat->Passes = pass;
|
||
|
|
|
||
|
|
// Get alpha cutoff value.
|
||
|
|
uint32 ac;
|
||
|
|
File::Read( &ac, sizeof( uint32 ), 1, p_FH );
|
||
|
|
pMat->AlphaCutoff = ac; //( ac >= 128 ) ? 255 : ( ac * 2 );
|
||
|
|
|
||
|
|
// Get sorted flag.
|
||
|
|
bool sorted;
|
||
|
|
File::Read( &sorted, sizeof( bool ), 1, p_FH );
|
||
|
|
pMat->m_sorted = sorted;
|
||
|
|
|
||
|
|
// Get draw order.
|
||
|
|
File::Read( &pMat->m_draw_order, sizeof( float ), 1, p_FH );
|
||
|
|
|
||
|
|
// Get backface cull flag.
|
||
|
|
bool bfc;
|
||
|
|
File::Read( &bfc, sizeof( bool ), 1, p_FH );
|
||
|
|
pMat->m_no_bfc = bfc;
|
||
|
|
|
||
|
|
// // Get grassify flag and (optionally) grassify data.
|
||
|
|
// bool grassify;
|
||
|
|
// File::Read( &grassify, sizeof( bool ), 1, p_FH );
|
||
|
|
// pMat->m_grassify = (uint8)grassify;
|
||
|
|
// if( grassify )
|
||
|
|
// {
|
||
|
|
// File::Read( &pMat->m_grass_height, sizeof( float ), 1, p_FH );
|
||
|
|
// int layers;
|
||
|
|
// File::Read( &layers, sizeof( int ), 1, p_FH );
|
||
|
|
// pMat->m_grass_layers = (uint8)layers;
|
||
|
|
// }
|
||
|
|
|
||
|
|
GXColor mat_col[MAX_PASSES];
|
||
|
|
|
||
|
|
pMat->m_pUVControl = NULL;
|
||
|
|
for( uint32 pass = 0; pass < pMat->Passes; ++pass )
|
||
|
|
{
|
||
|
|
// Get texture checksum.
|
||
|
|
uint32 TextureChecksum;
|
||
|
|
File::Read( &TextureChecksum, sizeof( uint32 ), 1, p_FH );
|
||
|
|
|
||
|
|
// Get material flags.
|
||
|
|
File::Read( &pMat->Flags[pass], sizeof( uint32 ), 1, p_FH );
|
||
|
|
|
||
|
|
// Get ALPHA register value.
|
||
|
|
uint64 ra;
|
||
|
|
File::Read( &ra, sizeof( uint64 ), 1, p_FH );
|
||
|
|
pMat->blendMode[pass] = ra & 0xff;
|
||
|
|
pMat->fixAlpha[pass] = ( ra >> 32 ) & 0xff;
|
||
|
|
|
||
|
|
// Backface cull test - if this is an alpha blended material, turn off backface culling.
|
||
|
|
if(( pass == 0 ) && (( ra & 0xFF ) != 0x00 ))
|
||
|
|
{
|
||
|
|
pMat->m_no_bfc = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Get UV addressing types.
|
||
|
|
uint32 u_addressing, v_addressing;
|
||
|
|
File::Read( &u_addressing, sizeof( uint32 ), 1, p_FH );
|
||
|
|
File::Read( &v_addressing, sizeof( uint32 ), 1, p_FH );
|
||
|
|
pMat->UVAddressing[pass] = (( v_addressing << 1 ) | u_addressing );
|
||
|
|
|
||
|
|
// Step past material colors, currently unsupported.
|
||
|
|
float col[9];
|
||
|
|
File::Read( col, sizeof( float ) * 9, 1, p_FH );
|
||
|
|
|
||
|
|
mat_col[pass].r = (u8)((col[0] * 255.0f) + 0.5f);
|
||
|
|
mat_col[pass].g = (u8)((col[1] * 255.0f) + 0.5f);
|
||
|
|
mat_col[pass].b = (u8)((col[2] * 255.0f) + 0.5f);
|
||
|
|
mat_col[pass].a = 255;
|
||
|
|
|
||
|
|
// Read uv wibble data if present.
|
||
|
|
if( pMat->Flags[pass] & MATFLAG_UV_WIBBLE )
|
||
|
|
{
|
||
|
|
if ( !pMat->m_pUVControl ) pMat->m_pUVControl = new sUVControl;
|
||
|
|
File::Read( &( pMat->m_pUVControl->UVWibbleParams[pass] ), sizeof( sUVWibbleParams ), 1, p_FH );
|
||
|
|
}
|
||
|
|
|
||
|
|
// Step past vc wibble data, currently unsupported.
|
||
|
|
if(( pass == 0 ) && ( pMat->Flags[0] & MATFLAG_VC_WIBBLE ))
|
||
|
|
{
|
||
|
|
File::Read( &NumSeqs, sizeof( uint32 ), 1, p_FH );
|
||
|
|
pMat->m_num_wibble_vc_anims = NumSeqs;
|
||
|
|
|
||
|
|
// Create sequence data array.
|
||
|
|
pMat->mp_wibble_vc_params = new sVCWibbleParams[NumSeqs];
|
||
|
|
|
||
|
|
// Create resultant color array.
|
||
|
|
pMat->mp_wibble_vc_colors = new uint32[NumSeqs];
|
||
|
|
|
||
|
|
for( seq = 0; seq < NumSeqs; ++seq )
|
||
|
|
{
|
||
|
|
File::Read( &NumKeys, sizeof( uint32 ), 1, p_FH );
|
||
|
|
|
||
|
|
int phase;
|
||
|
|
File::Read( &phase, sizeof( int ), 1, p_FH );
|
||
|
|
|
||
|
|
// Create array for keyframes.
|
||
|
|
pMat->mp_wibble_vc_params[seq].m_num_keyframes = NumKeys;
|
||
|
|
pMat->mp_wibble_vc_params[seq].m_phase = phase;
|
||
|
|
pMat->mp_wibble_vc_params[seq].mp_keyframes = new sVCWibbleKeyframe[NumKeys];
|
||
|
|
|
||
|
|
// Read keyframes into array.
|
||
|
|
File::Read( pMat->mp_wibble_vc_params[seq].mp_keyframes, sizeof( sVCWibbleKeyframe ), NumKeys, p_FH );
|
||
|
|
|
||
|
|
for ( uint lp = 0; lp < NumKeys; lp++ )
|
||
|
|
{
|
||
|
|
uint8 r = pMat->mp_wibble_vc_params[seq].mp_keyframes[lp].m_color.r;
|
||
|
|
uint8 g = pMat->mp_wibble_vc_params[seq].mp_keyframes[lp].m_color.g;
|
||
|
|
uint8 b = pMat->mp_wibble_vc_params[seq].mp_keyframes[lp].m_color.b;
|
||
|
|
uint8 a = pMat->mp_wibble_vc_params[seq].mp_keyframes[lp].m_color.a;
|
||
|
|
pMat->mp_wibble_vc_params[seq].mp_keyframes[lp].m_color.r = b;
|
||
|
|
pMat->mp_wibble_vc_params[seq].mp_keyframes[lp].m_color.g = r;
|
||
|
|
pMat->mp_wibble_vc_params[seq].mp_keyframes[lp].m_color.b = g;
|
||
|
|
pMat->mp_wibble_vc_params[seq].mp_keyframes[lp].m_color.a = a;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if( TextureChecksum )
|
||
|
|
{
|
||
|
|
// If textured, resolve texture checksum...
|
||
|
|
Nx::CNgcTexture *p_ngc_texture = static_cast<Nx::CNgcTexture*>( p_texture_table->GetItem( TextureChecksum ) );
|
||
|
|
sTexture *pTex = ( p_ngc_texture ) ? p_ngc_texture->GetEngineTexture() : NULL;
|
||
|
|
|
||
|
|
// Bail if checksum not found.
|
||
|
|
if( pTex == NULL )
|
||
|
|
{
|
||
|
|
Dbg_Message( "error: couldn't find texture checksum %08X\n", TextureChecksum );
|
||
|
|
// exit( 1 );
|
||
|
|
pMat->pTex[pass] = NULL;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// Set texture pointer.
|
||
|
|
pMat->pTex[pass] = pTex;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Get mipmap info.
|
||
|
|
File::Read( &MMAG, sizeof( uint32 ), 1, p_FH );
|
||
|
|
File::Read( &MMIN, sizeof( uint32 ), 1, p_FH );
|
||
|
|
|
||
|
|
File::Read( &K, sizeof( uint32 ), 1, p_FH );
|
||
|
|
File::Read( &L, sizeof( uint32 ), 1, p_FH );
|
||
|
|
|
||
|
|
// Default PS2 value for K appears to be -8.0f - we are interested in deviations from this value.
|
||
|
|
pMat->K[pass] = ( *(float*)&K ) + 8.0f;
|
||
|
|
|
||
|
|
// Dave note 08/03/02 - having MIPs selected earlier than normal seems to cause some problems, since Xbox
|
||
|
|
// MIP selection is so different to Ps2. Limit the k value such that Xbox can never select smaller MIPs
|
||
|
|
// earlier than it would do by default.
|
||
|
|
if( pMat->K[pass] > 0.0f )
|
||
|
|
{
|
||
|
|
pMat->K[pass] = 0.0f;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// ...otherwise just step past mipmap info.
|
||
|
|
pMat->pTex[pass] = NULL;
|
||
|
|
uint32 mip[4];
|
||
|
|
File::Read( mip, sizeof( uint32 ) * 4, 1, p_FH );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Generate material colors.
|
||
|
|
for( uint32 pass = 0; pass < pMat->Passes; ++pass )
|
||
|
|
{
|
||
|
|
if ( ( mat_col[0].r == mat_col[pass].r ) &&
|
||
|
|
( mat_col[0].g == mat_col[pass].g ) &&
|
||
|
|
( mat_col[0].b == mat_col[pass].b ) &&
|
||
|
|
( mat_col[0].a == mat_col[pass].a ) )
|
||
|
|
{
|
||
|
|
// Do nothing.
|
||
|
|
pMat->matcol[pass] = (GXColor){128,128,128,255};
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// Work out the texture color.
|
||
|
|
GXColor tc;
|
||
|
|
float base_r = (float)(mat_col[0].r > 0 ? mat_col[0].r : 1 );
|
||
|
|
float base_g = (float)(mat_col[0].g > 0 ? mat_col[0].g : 1 );
|
||
|
|
float base_b = (float)(mat_col[0].b > 0 ? mat_col[0].b : 1 );
|
||
|
|
float base_a = (float)(mat_col[0].a > 0 ? mat_col[0].a : 1 );
|
||
|
|
float r = ( ((float)mat_col[pass].r) / base_r ) * 128.0f;
|
||
|
|
float g = ( ((float)mat_col[pass].g) / base_g ) * 128.0f;
|
||
|
|
float b = ( ((float)mat_col[pass].b) / base_b ) * 128.0f;
|
||
|
|
float a = ( ((float)mat_col[pass].a) / base_a ) * 255.0f;
|
||
|
|
int _r = (int)r;
|
||
|
|
int _g = (int)g;
|
||
|
|
int _b = (int)b;
|
||
|
|
int _a = (int)a;
|
||
|
|
if ( _r > 255 ) _r = 255;
|
||
|
|
if ( _g > 255 ) _g = 255;
|
||
|
|
if ( _b > 255 ) _b = 255;
|
||
|
|
if ( _a > 255 ) _a = 255;
|
||
|
|
tc.r = (u8)( _r );
|
||
|
|
tc.g = (u8)( _g );
|
||
|
|
tc.b = (u8)( _b );
|
||
|
|
tc.a = (u8)( _a );
|
||
|
|
pMat->matcol[pass] = tc;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// pMat->mp_display_list = NULL;
|
||
|
|
// pMat->Initialize();
|
||
|
|
pMat->uv_slot[0] = 0;
|
||
|
|
pMat->uv_slot[1] = 1;
|
||
|
|
pMat->uv_slot[2] = 2;
|
||
|
|
pMat->uv_slot[3] = 3;
|
||
|
|
}
|
||
|
|
|
||
|
|
return p_mat_array;
|
||
|
|
}
|
||
|
|
|
||
|
|
} // namespace NxNgc
|
||
|
|
|