mirrors/thug
1
Fork 0
mirror of https://github.com/thug1src/thug.git synced 2025-01-22 05:43:47 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
master
thug/Code/Gfx/XBox/NX/material.cpp
thug1src d8eb714766 thug1src
2016-02-14 08:39:12 +11:00

1181 lines
39 KiB
C++
Raw Permalink Blame History

#include <xtl.h>
#include <string.h>
#include <core/defines.h>
#include <core/debug.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/file/filesys.h>
#include <gfx/gfxman.h>
#include "gfx/xbox/p_nxtexture.h"
#include "anim_vertdefs.h"
#include "nx_init.h"
#include "material.h"
#include "scene.h"
#include "render.h"
namespace NxXbox
{
uint32 NumMaterials;
static const float pi_over_180 = (float)Mth::PI / 180.0f;
/******************************************************************/
/* */
/* */
/******************************************************************/
sUVWibbleParams::sUVWibbleParams( void )
{
// Zero out the members.
ZeroMemory( this, sizeof( sUVWibbleParams ));
// Set the matrix correctly.
m_UVMatrix[0] = 1.0f;
}
/******************************************************************/
/* */
/* */
/******************************************************************/
sUVWibbleParams::~sUVWibbleParams( void )
{
}
/******************************************************************/
/* */
/* */
/******************************************************************/
sMaterial::sMaterial( void )
{
m_num_wibble_vc_anims = 0;
mp_wibble_vc_params = NULL;
mp_wibble_vc_colors = NULL;
mp_wibble_texture_params = NULL;
m_uv_wibble = false;
m_texture_wibble = false;
m_grass_layers = 0;
m_zbias = 0;
for( int p = 0; p < MAX_PASSES; ++p )
{
m_flags[p] = 0;
mp_UVWibbleParams[p] = NULL;
m_envmap_tiling[p][0] = 3.0f;
m_envmap_tiling[p][1] = 3.0f;
}
}
/******************************************************************/
/* */
/* */
/******************************************************************/
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;
}
for( int p = 0; p < MAX_PASSES; ++p )
{
if( mp_UVWibbleParams[p] )
delete mp_UVWibbleParams[p];
}
if( mp_wibble_texture_params )
{
for( uint32 p = 0; p < MAX_PASSES; ++p )
{
delete [] mp_wibble_texture_params->mp_keyframes[p];
}
delete mp_wibble_texture_params;
}
}
/******************************************************************/
/* */
/* */
/******************************************************************/
void sMaterial::figure_wibble_uv( void )
{
if( m_uv_wibble )
{
// Get the time.
float t = (float)Tmr::GetTime() * 0.001f;
for( uint32 p = 0; p < m_passes; ++p )
{
// Figure out UV offsets for wibbling if required.
if( m_flags[p] & MATFLAG_UV_WIBBLE )
{
if( !( m_flags[p] & MATFLAG_EXPLICIT_UV_WIBBLE ))
{
float uoff, voff;
uoff = ( t * mp_UVWibbleParams[p]->m_UVel ) + ( mp_UVWibbleParams[p]->m_UAmplitude * sinf( mp_UVWibbleParams[p]->m_UFrequency * t + mp_UVWibbleParams[p]->m_UPhase ));
voff = ( t * mp_UVWibbleParams[p]->m_VVel ) + ( mp_UVWibbleParams[p]->m_VAmplitude * sinf( mp_UVWibbleParams[p]->m_VFrequency * t + mp_UVWibbleParams[p]->m_VPhase ));
// Reduce offset mod 16 and put it in the range -8 to +8.
uoff += 8.0f;
uoff -= (float)(( Ftoi_ASM( uoff ) >> 4 ) << 4 );
voff += 8.0f;
voff -= (float)(( Ftoi_ASM( voff ) >> 4 ) << 4 );
mp_UVWibbleParams[p]->m_UVMatrix[2] = ( uoff < 0.0f ) ? ( uoff + 8.0f ) : ( uoff - 8.0f );
mp_UVWibbleParams[p]->m_UVMatrix[3] = ( voff < 0.0f ) ? ( voff + 8.0f ) : ( voff - 8.0f );
}
}
}
}
}
/******************************************************************/
/* */
/* */
/******************************************************************/
void sMaterial::figure_wibble_vc( void )
{
// The vertex color wibble flag is placed in pass 0.
if( m_flags[0] & MATFLAG_VC_WIBBLE )
{
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 + ( NxXbox::EngineGlobals.render_start_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;
}
}
Dbg_Assert( key < ( num_keys - 1 ));
// Parameter expressing how far we are between between this keyframe and the next.
float t = (float)( time - p_sequence->mp_keyframes[key].m_time ) * ReciprocalEstimateNR_ASM((float)( p_sequence->mp_keyframes[key + 1].m_time - p_sequence->mp_keyframes[key].m_time ));
// Interpolate the color.
uint32 red = (uint32)Ftoi_ASM((( 1.0f - t ) * p_sequence->mp_keyframes[key].m_color.r ) + ( t * p_sequence->mp_keyframes[key + 1].m_color.r ));
uint32 grn = (uint32)Ftoi_ASM((( 1.0f - t ) * p_sequence->mp_keyframes[key].m_color.g ) + ( t * p_sequence->mp_keyframes[key + 1].m_color.g ));
uint32 blu = (uint32)Ftoi_ASM((( 1.0f - t ) * p_sequence->mp_keyframes[key].m_color.b ) + ( t * p_sequence->mp_keyframes[key + 1].m_color.b ));
uint32 alp = (uint32)Ftoi_ASM((( 1.0f - t ) * p_sequence->mp_keyframes[key].m_color.a ) + ( t * p_sequence->mp_keyframes[key + 1].m_color.a ));
// Switch red and blue, and store.
mp_wibble_vc_colors[i] = ( alp << 24 ) | ( red << 16 ) | ( grn << 8 ) | blu;
}
}
}
/******************************************************************/
/* */
/* */
/******************************************************************/
void sMaterial::figure_wibble_texture( void )
{
// The vertex color wibble flag is placed in pass 0.
if( m_texture_wibble )
{
int current_time = (int)Tmr::GetTime();
struct sTextureWibbleParams *p_sequence = mp_wibble_texture_params;
for( int pass = 0; pass < MAX_PASSES; ++pass )
{
if( m_flags[pass] & MATFLAG_PASS_TEXTURE_ANIMATES )
{
// Get phase-shift.
int phase_shift = p_sequence->m_phase[pass];
// Time parameters.
int num_keys = p_sequence->m_num_keyframes[pass];
int start_time = p_sequence->mp_keyframes[pass][0].m_time;
int end_time = p_sequence->mp_keyframes[pass][num_keys - 1].m_time;
int period = end_time - start_time;
int time = start_time + (( current_time + phase_shift ) % period );
// Keep track of the iterations, if iterations on this animation are required.
if( p_sequence->m_num_iterations[pass] > 0 )
{
int iteration = ( current_time - start_time ) / period;
if( iteration >= p_sequence->m_num_iterations[pass] )
{
// Set the time such that the animation no longer continues.
time = start_time + ((( period * p_sequence->m_num_iterations[pass] ) + phase_shift ) % period );
}
}
// Locate the keyframe.
int key;
for( key = num_keys - 1; key >= 0; --key )
{
if( time >= p_sequence->mp_keyframes[pass][key].m_time )
{
break;
}
}
// Set the texture.
// Dbg_Assert( p_sequence->mp_keyframes[pass][key].mp_texture );
mp_tex[pass] = p_sequence->mp_keyframes[pass][key].mp_texture;
}
}
}
}
inline DWORD F2DW( FLOAT f )
{
return *( ( DWORD *) & f );
}
/******************************************************************/
/* */
/* */
/******************************************************************/
void sMaterial::Submit( void )
{
// Dummy 8 element uv 'matrix' for custom pipeline.
static float custom_uv_mat[8] = { 1.0f, 0.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f, 0.0f };
// Matrix for UV wibbling texture transform.
static D3DMATRIX uv_mat = { 1.0f, 0.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f, 0.0f,
0.0f, 0.0f, 0.0f, 0.0f,
0.0f, 0.0f, 0.0f, 0.0f };
// Matrix for env mapping texture transform. Note that the [0][0] and [1][1] elements of the matrix are set up to scale, based on the
// material pass properties.
static D3DMATRIX env_mat = { 0.5f, 0.0f, 0.0f, 0.0f,
0.0f, -0.5f, 0.0f, 0.0f,
0.0f, 0.0f, 0.0f, 0.0f,
0.5f, 0.5f, 0.0f, 0.0f };
// Check for material change lockout.
if( EngineGlobals.material_override )
{
return;
}
// Set the alpha blend mode.
set_blend_mode( m_reg_alpha[0] );
// Set the alpha cutoff value.
set_render_state( RS_ALPHACUTOFF, (uint32)m_alpha_cutoff );
// Set the backface cull mode.
set_render_state( RS_CULLMODE, m_no_bfc ? D3DCULL_NONE : D3DCULL_CW );
// Set the z-bias.
set_render_state( RS_ZBIAS, m_zbias );
// Figure uv, vc and texture wibble updates if required.
figure_wibble_uv();
figure_wibble_vc();
figure_wibble_texture();
// Set specular properties of this material.
if( m_flags[0] & MATFLAG_SPECULAR )
{
if( EngineGlobals.specular_enabled == 0 )
{
set_render_state( RS_SPECULARENABLE, 1 );
// Set the specular material.
D3DMATERIAL8 test_mat;
ZeroMemory( &test_mat, sizeof( D3DMATERIAL8 ));
test_mat.Specular.r = m_specular_color[0];
test_mat.Specular.g = m_specular_color[1];
test_mat.Specular.b = m_specular_color[2];
test_mat.Specular.a = 1.0f;
test_mat.Power = m_specular_color[3];
D3DDevice_SetMaterial( &test_mat );
// If using a custom vertex shader, also need to load the specular color and power to vert shader registers here.
if( NxXbox::EngineGlobals.custom_pipeline_enabled )
{
D3DDevice_SetVertexShaderConstantFast( VSCONST_REG_SPECULAR_COLOR_OFFSET, (void*)&m_specular_color[0], 1 );
}
}
}
else
{
if( EngineGlobals.specular_enabled > 0 )
{
set_render_state( RS_SPECULARENABLE, 0 );
// Set the specular material (basically just to set the power to zero).
D3DMATERIAL8 test_mat;
ZeroMemory( &test_mat, sizeof( D3DMATERIAL8 ));
D3DDevice_SetMaterial( &test_mat );
}
}
// Set up the textures if present. This involves setting the texture and palette pointers and addressing mode.
// Also, for multipass textures, it may require loading of fixed alpha values into specific constant registers.
uint32 p;
for( p = 0; p < m_passes; ++p )
{
if( !( EngineGlobals.texture_stage_override & ( 1 << p )))
{
// Load pass color and fixed alpha values to the pixel shader, if required.
if( !EngineGlobals.upload_pixel_shader_constants )
{
// Do the comparison as 32bit unsigned ints.
uint32 *p_test0 = (uint32*)&m_color[p][0];
uint32 *p_test1 = (uint32*)&EngineGlobals.pixel_shader_constants[p * 4];
if(( p_test0[0] != p_test1[0] ) || ( p_test0[1] != p_test1[1] ) || ( p_test0[2] != p_test1[2] ) || ( p_test0[3] != p_test1[3] ))
{
EngineGlobals.upload_pixel_shader_constants = true;
}
}
if( mp_tex[p] )
{
set_texture( p, mp_tex[p]->pD3DTexture, mp_tex[p]->pD3DPalette );
// Set UV adressing mode.
set_render_state( RS_UVADDRESSMODE0 + p, m_uv_addressing[p] );
// Set filtering mode.
// set_render_state( RS_MINMAGFILTER0 + p, m_filtering_mode[p] );
// Set MIP lod bias.
set_render_state( RS_MIPLODBIASPASS0 + p, *((uint32*)( &m_k[p] )));
// Deal with bump mapping setup.
if( m_flags[p] & MATFLAG_BUMP_SIGNED_TEXTURE )
{
// Channel of bump texture value (v,u) MUST be signed.
if( EngineGlobals.color_sign[p] != ( D3DTSIGN_RSIGNED | D3DTSIGN_GSIGNED | D3DTSIGN_BSIGNED ))
{
EngineGlobals.color_sign[p] = ( D3DTSIGN_RSIGNED | D3DTSIGN_GSIGNED | D3DTSIGN_BSIGNED );
D3DDevice_SetTextureStageState( p, D3DTSS_COLORSIGN, D3DTSIGN_RSIGNED | D3DTSIGN_GSIGNED | D3DTSIGN_BSIGNED );
}
}
else
{
if( EngineGlobals.color_sign[p] != ( D3DTSIGN_RUNSIGNED | D3DTSIGN_GUNSIGNED | D3DTSIGN_BUNSIGNED ))
{
EngineGlobals.color_sign[p] = ( D3DTSIGN_RUNSIGNED | D3DTSIGN_GUNSIGNED | D3DTSIGN_BUNSIGNED );
D3DDevice_SetTextureStageState( p, D3DTSS_COLORSIGN, D3DTSIGN_RUNSIGNED | D3DTSIGN_GUNSIGNED | D3DTSIGN_BUNSIGNED );
}
}
if( m_flags[p] & MATFLAG_BUMP_LOAD_MATRIX )
{
D3DDevice_SetTextureStageState( p, D3DTSS_BUMPENVMAT00, F2DW( EngineGlobals.bump_env_matrix._11 ));
D3DDevice_SetTextureStageState( p, D3DTSS_BUMPENVMAT01, F2DW( EngineGlobals.bump_env_matrix._13 ));
D3DDevice_SetTextureStageState( p, D3DTSS_BUMPENVMAT10, F2DW( EngineGlobals.bump_env_matrix._31 ));
D3DDevice_SetTextureStageState( p, D3DTSS_BUMPENVMAT11, F2DW( EngineGlobals.bump_env_matrix._33 ));
}
if(( m_flags[p] & MATFLAG_ENVIRONMENT ) && ( EngineGlobals.allow_envmapping ))
{
// Handle environment mapping.
env_mat.m[0][0] = 0.5f * m_envmap_tiling[p][0];
env_mat.m[1][1] = 0.5f * m_envmap_tiling[p][1];
D3DDevice_SetTransform((D3DTRANSFORMSTATETYPE)( D3DTS_TEXTURE0 + p ), &env_mat );
D3DDevice_SetTextureStageState( p, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2 );
D3DDevice_SetTextureStageState( p, D3DTSS_TEXCOORDINDEX, D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR | p );
}
else if( m_flags[p] & MATFLAG_UV_WIBBLE )
{
D3DDevice_SetTextureStageState( p, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2 );
D3DDevice_SetTextureStageState( p, D3DTSS_TEXCOORDINDEX, D3DTSS_TCI_PASSTHRU | p );
if( NxXbox::EngineGlobals.custom_pipeline_enabled )
{
// If using a custom vertex shader, need to load the uv matrix here.
// If using a custom vertex shader, need to load the custom uv matrix here.
custom_uv_mat[0] = mp_UVWibbleParams[p]->m_UVMatrix[0];
custom_uv_mat[1] = -mp_UVWibbleParams[p]->m_UVMatrix[1];
custom_uv_mat[3] = mp_UVWibbleParams[p]->m_UVMatrix[2];
custom_uv_mat[4] = mp_UVWibbleParams[p]->m_UVMatrix[1];
custom_uv_mat[5] = mp_UVWibbleParams[p]->m_UVMatrix[0];
custom_uv_mat[7] = mp_UVWibbleParams[p]->m_UVMatrix[3];
D3DDevice_SetVertexShaderConstantFast( VSCONST_REG_UV_MAT_OFFSET + ( p * 2 ), (void*)&custom_uv_mat[0], 2 );
}
else
{
// Handle fixed function UV matrix.
uv_mat._31 = mp_UVWibbleParams[p]->m_UVMatrix[2];
uv_mat._32 = mp_UVWibbleParams[p]->m_UVMatrix[3];
D3DDevice_SetTransform((D3DTRANSFORMSTATETYPE)( D3DTS_TEXTURE0 + p ), &uv_mat );
}
}
else
{
if( NxXbox::EngineGlobals.custom_pipeline_enabled )
{
// If using a custom vertex shader, need to load the custom uv matrix here.
custom_uv_mat[0] = 1.0f; custom_uv_mat[1] = 0.0f; custom_uv_mat[3] = 0.0f;
custom_uv_mat[4] = 0.0f; custom_uv_mat[5] = 1.0f; custom_uv_mat[7] = 0.0f;
D3DDevice_SetVertexShaderConstantFast( VSCONST_REG_UV_MAT_OFFSET + ( p * 2 ), (void*)&custom_uv_mat[0], 2 );
}
// Regular case. Check states here since it is quicker for this common case than setting blindly.
uint32 tex_coord_index, tex_trans_flags;
D3DDevice_GetTextureStageState( p, D3DTSS_TEXTURETRANSFORMFLAGS, &tex_trans_flags );
D3DDevice_GetTextureStageState( p, D3DTSS_TEXCOORDINDEX, &tex_coord_index );
if( tex_trans_flags != D3DTTFF_DISABLE )
{
D3DDevice_SetTextureStageState( p, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE );
}
if( tex_coord_index != ( D3DTSS_TCI_PASSTHRU | p ))
{
D3DDevice_SetTextureStageState( p, D3DTSS_TEXCOORDINDEX, D3DTSS_TCI_PASSTHRU | p );
}
}
}
else
{
set_texture( p, NULL, NULL );
}
}
}
if( EngineGlobals.upload_pixel_shader_constants )
{
CopyMemory( EngineGlobals.pixel_shader_constants, &m_color[0][0], sizeof( float ) * 4 * m_passes );
}
// Make sure to set the textures for unused stages to NULL, to reduce texture overhead.
// for( ; p < 4; ++p )
// {
// if( !( EngineGlobals.texture_stage_override & ( 1 << p )))
// {
// set_texture( p, NULL, NULL );
// }
// }
}
/******************************************************************/
/* */
/* */
/******************************************************************/
uint32 sMaterial::GetIgnoreVertexAlphaPasses( void )
{
// Return a bitfield with a bit set for any pass that is flagged to ignore vertex alpha.
uint32 bf = 0;
for( uint32 p = 0; p < m_passes; ++p )
{
if( m_flags[p] & MATFLAG_PASS_IGNORE_VERTEX_ALPHA )
{
bf |= ( 1 << p );
}
}
return bf;
}
/******************************************************************/
/* */
/* */
/******************************************************************/
sMaterial* GetMaterial( uint32 checksum, sScene *p_scene )
{
if( p_scene->pMaterialTable )
{
p_scene->pMaterialTable->IterateStart();
sMaterial *p_mat = p_scene->pMaterialTable->IterateNext();
while( p_mat )
{
if( p_mat->m_checksum == checksum )
{
return p_mat;
}
p_mat = p_scene->pMaterialTable->IterateNext();
}
}
return NULL;
}
#define MemoryRead( dst, size, num, src ) CopyMemory(( dst ), ( src ), (( num ) * ( size ))); \
( src ) += (( num ) * ( size ))
/******************************************************************/
/* */
/* */
/******************************************************************/
Lst::HashTable< sMaterial > *LoadMaterialsFromMemory( void **pp_mem, Lst::HashTable< Nx::CTexture > *p_texture_table )
{
uint8 *p_data = (uint8*)( *pp_mem );
uint32 MMAG, MMIN, K, L, NumSeqs, seq, NumKeys;
// Get number of materials.
uint32 new_materials;
MemoryRead( &new_materials, sizeof( uint32 ), 1, p_data );
Lst::HashTable< sMaterial >* pMaterialTable;
// Create table, dynamically sizing it based on the number of new materials.
uint32 optimal_table_size = new_materials * 2;
uint32 test = 4;
uint32 size = 2;
for( ;; test <<= 1, ++size )
{
// Check if this iteration of table size is sufficient, or if we have hit the maximum size.
if(( optimal_table_size < test ) || ( size >= 12 ))
{
pMaterialTable = new Lst::HashTable< sMaterial >( size );
break;
}
}
// Loop over materials.
for( uint32 i = 0; i < new_materials; ++i )
{
// Create new material.
sMaterial *pMat = new sMaterial;
// Get material checksum.
MemoryRead( &pMat->m_checksum, sizeof( uint32 ), 1, p_data );
// Get material name checksum.
MemoryRead( &pMat->m_name_checksum, sizeof( uint32 ), 1, p_data );
// Get number of passes.
MemoryRead( &pMat->m_passes, sizeof( uint32 ), 1, p_data );
// Get alpha cutoff value.
uint32 AlphaCutoff;
MemoryRead( &AlphaCutoff, sizeof( uint32 ), 1, p_data );
Dbg_Assert( AlphaCutoff <= 0xFF );
pMat->m_alpha_cutoff = (uint8)AlphaCutoff;
// Get sorted flag.
MemoryRead( &pMat->m_sorted, sizeof( bool ), 1, p_data );
// Get draw order.
MemoryRead( &pMat->m_draw_order, sizeof( float ), 1, p_data );
// Get single sided flag.
bool single_sided;
MemoryRead( &single_sided, sizeof( bool ), 1, p_data );
// Get backface cull flag.
MemoryRead( &pMat->m_no_bfc, sizeof( bool ), 1, p_data );
// Get z-bias value.
int zbias;
MemoryRead( &zbias, sizeof( int ), 1, p_data );
pMat->m_zbias = (uint8)(( zbias > 16 ) ? 16 : zbias );
// Get grassify flag and (optionally) grassify data.
bool grassify;
MemoryRead( &grassify, sizeof( bool ), 1, p_data );
if( grassify )
{
MemoryRead( &pMat->m_grass_height, sizeof( float ), 1, p_data );
MemoryRead( &pMat->m_grass_layers, sizeof( int ), 1, p_data );
}
// Get specular power and (optionally) specular color.
MemoryRead( &pMat->m_specular_color[3], sizeof( float ), 1, p_data );
if( pMat->m_specular_color[3] > 0.0f )
{
MemoryRead( &pMat->m_specular_color[0], sizeof( float ) * 3, 1, p_data );
}
// Neutral under proven otherwise.
bool neutral_material_color = true;
for( uint32 pass = 0; pass < pMat->m_passes; ++pass )
{
// Get texture checksum.
uint32 TextureChecksum;
MemoryRead( &TextureChecksum, sizeof( uint32 ), 1, p_data );
// Get material flags.
MemoryRead( &pMat->m_flags[pass], sizeof( uint32 ), 1, p_data );
// Get pass color flag.
bool has_color;
MemoryRead( &has_color, sizeof( bool ), 1, p_data );
// Get pass color.
MemoryRead( &pMat->m_color[pass][0], sizeof( float ) * 3, 1, p_data );
// Check for color being neutral.
if( neutral_material_color )
{
if(( pMat->m_color[pass][0] != 0.5f ) || ( pMat->m_color[pass][1] != 0.5f ) || ( pMat->m_color[pass][2] != 0.5f ))
{
neutral_material_color = false;
}
}
// Get ALPHA register value.
uint64 reg_alpha;
MemoryRead( &reg_alpha, sizeof( uint64 ), 1, p_data );
uint32 blend_mode = (uint32)( reg_alpha & 0xFFFFFFUL );
uint32 fixed_alpha = (uint32)( reg_alpha >> 32 );
pMat->m_reg_alpha[pass] = blend_mode | ( fixed_alpha << 24 );
// Also calculate the floating point version of the fixed alpha.
pMat->m_color[pass][3] = fixed_alpha / 128.0f;
// Backface cull test - if this is an alpha blended material, turn off backface culling, except
// where the material has been explicitly flagged as single sided.
if(( pass == 0 ) && !single_sided && (( pMat->m_reg_alpha[pass] & sMaterial::BLEND_MODE_MASK ) != 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->m_uv_addressing[pass] = (( v_addressing << 16 ) | u_addressing );
// Get environment map u and v tiling multiples.
MemoryRead( &pMat->m_envmap_tiling[pass][0], sizeof( float ) * 2, 1, p_data );
// Get minification and magnification filtering mode.
MemoryRead( &pMat->m_filtering_mode[pass], sizeof( uint32 ), 1, p_data );
// Read uv wibble data if present.
if( pMat->m_flags[pass] & MATFLAG_UV_WIBBLE )
{
// Flag that this material wibbles.
pMat->m_uv_wibble = true;
// Create uv wibble params structure.
pMat->mp_UVWibbleParams[pass] = new sUVWibbleParams;
MemoryRead( pMat->mp_UVWibbleParams[pass], sizeof( float ) * 8, 1, p_data );
}
// Read vertex color wibble data.
if(( pass == 0 ) && ( pMat->m_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 D3DCOLOR[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 );
}
}
// Read texture wibble data.
if( pMat->m_flags[pass] & MATFLAG_PASS_TEXTURE_ANIMATES )
{
// Create the texture wibble structure if not created yet.
if( pMat->mp_wibble_texture_params == NULL )
{
pMat->mp_wibble_texture_params = new NxXbox::sTextureWibbleParams;
ZeroMemory( pMat->mp_wibble_texture_params, sizeof( NxXbox::sTextureWibbleParams ));
// Flag the material as having texture wibble.
pMat->m_texture_wibble = true;
}
int num_keyframes, period, iterations, phase;
MemoryRead( &num_keyframes, sizeof( int ), 1, p_data );
MemoryRead( &period, sizeof( int ), 1, p_data ); // This value is currently discarded.
MemoryRead( &iterations, sizeof( int ), 1, p_data );
MemoryRead( &phase, sizeof( int ), 1, p_data );
Dbg_Assert( num_keyframes > 0 );
pMat->mp_wibble_texture_params->m_num_keyframes[pass] = num_keyframes;
pMat->mp_wibble_texture_params->m_phase[pass] = phase;
pMat->mp_wibble_texture_params->m_num_iterations[pass] = iterations;
pMat->mp_wibble_texture_params->mp_keyframes[pass] = new NxXbox::sTextureWibbleKeyframe[num_keyframes];
for( int ati = 0; ati < num_keyframes; ++ati )
{
MemoryRead( &pMat->mp_wibble_texture_params->mp_keyframes[pass][ati].m_time, sizeof( uint32 ), 1, p_data );
// Read the texture checksum.
uint32 cs;
MemoryRead( &cs, sizeof( uint32 ), 1, p_data );
// Set the TextureChecksum variable so the mp_tex member will get populated.
if( ati == 0 )
{
TextureChecksum = cs;
}
// Resolve the checksum to a texture pointer.
Nx::CXboxTexture *p_xbox_texture = static_cast<Nx::CXboxTexture*>( p_texture_table->GetItem( cs ));
pMat->mp_wibble_texture_params->mp_keyframes[pass][ati].mp_texture = ( p_xbox_texture ) ? p_xbox_texture->GetEngineTexture() : NULL;
}
}
if( TextureChecksum )
{
// If textured, resolve texture checksum...
Nx::CXboxTexture *p_xbox_texture = static_cast<Nx::CXboxTexture*>( p_texture_table->GetItem( TextureChecksum ));
sTexture *mp_tex = ( p_xbox_texture ) ? p_xbox_texture->GetEngineTexture() : NULL;
// Bail if checksum not found.
if( mp_tex == NULL )
{
Dbg_Message( "error: couldn't find texture checksum %08X\n", TextureChecksum );
pMat->mp_tex[pass] = NULL;
}
else
{
// Set texture pointer.
pMat->mp_tex[pass] = mp_tex;
}
// 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->m_k[pass] = ( *(float*)&K ) + 8.0f;
// Dave note 09/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->m_k[pass] > 0.0f )
{
pMat->m_k[pass] = 0.0f;
}
}
else
{
// ...otherwise just step past mipmap info.
pMat->mp_tex[pass] = NULL;
p_data += 16;
}
}
// Set the no material color flag if appropriate.
if( neutral_material_color )
{
pMat->m_flags[0] |= MATFLAG_NO_MAT_COL_MOD;
}
// Set the specular flag if appropriate.
if( pMat->m_specular_color[3] > 0.0f )
{
pMat->m_flags[0] |= MATFLAG_SPECULAR;
}
// There is a problem adding materials with the same checksum into the table.
// This could happen when materials in different scenes share the same name.
// It also happens for the dummy material (checksum == 0), so for now just special-case
// that one.
if( pMat->m_checksum == 0 )
{
if( !pMaterialTable->GetItem( 0 ))
{
pMaterialTable->PutItem( pMat->m_checksum, pMat );
}
}
else
{
if( pMaterialTable->GetItem( pMat->m_checksum ))
{
Dbg_MsgAssert( 0, ( "NXXBOX ERROR: duplicate material: %x\n", pMat->m_checksum ));
}
else
{
pMaterialTable->PutItem( pMat->m_checksum, pMat );
}
}
}
// Set the data pointer to the new position on return.
*pp_mem = p_data;
return pMaterialTable;
}
/******************************************************************/
/* */
/* */
/******************************************************************/
Lst::HashTable< sMaterial > *LoadMaterials( void *p_FH, Lst::HashTable< Nx::CTexture > *p_texture_table )
{
uint32 MMAG, MMIN, K, L, NumSeqs, seq, NumKeys;
// Get number of materials.
uint32 new_materials;
File::Read( &new_materials, sizeof( uint32 ), 1, p_FH );
Lst::HashTable< sMaterial >* pMaterialTable;
// Create table, dynamically sizing it based on the number of new materials.
uint32 optimal_table_size = new_materials * 2;
uint32 test = 4;
uint32 size = 2;
for( ;; test <<= 1, ++size )
{
// Check if this iteration of table size is sufficient, or if we have hit the maximum size.
if(( optimal_table_size < test ) || ( size >= 12 ))
{
pMaterialTable = new Lst::HashTable< sMaterial >( size );
break;
}
}
// Loop over materials.
for( uint32 i = 0; i < new_materials; ++i )
{
// Create new material.
sMaterial *pMat = new sMaterial;
// Get material checksum.
File::Read( &pMat->m_checksum, sizeof( uint32 ), 1, p_FH );
// Get material name checksum.
File::Read( &pMat->m_name_checksum, sizeof( uint32 ), 1, p_FH );
// Get number of passes.
File::Read( &pMat->m_passes, sizeof( uint32 ), 1, p_FH );
// Get alpha cutoff value.
uint32 AlphaCutoff;
File::Read( &AlphaCutoff, sizeof( uint32 ), 1, p_FH );
pMat->m_alpha_cutoff = (uint8)AlphaCutoff;
// Get sorted flag.
File::Read( &pMat->m_sorted, sizeof( bool ), 1, p_FH );
// Get draw order.
File::Read( &pMat->m_draw_order, sizeof( float ), 1, p_FH );
// Get single sided flag.
bool single_sided;
File::Read( &single_sided, sizeof( bool ), 1, p_FH );
// Get backface cull flag.
File::Read( &pMat->m_no_bfc, sizeof( bool ), 1, p_FH );
// Get z-bias value.
int zbias;
File::Read( &zbias, sizeof( int ), 1, p_FH );
pMat->m_zbias = (uint8)(( zbias > 16 ) ? 16 : zbias );
// Get grassify flag and (optionally) grassify data.
bool grassify;
File::Read( &grassify, sizeof( bool ), 1, p_FH );
if( grassify )
{
File::Read( &pMat->m_grass_height, sizeof( float ), 1, p_FH );
File::Read( &pMat->m_grass_layers, sizeof( int ), 1, p_FH );
}
// Get specular power and (optionally) specular color.
File::Read( &pMat->m_specular_color[3], sizeof( float ), 1, p_FH );
if( pMat->m_specular_color[3] > 0.0f )
{
File::Read( &pMat->m_specular_color[0], sizeof( float ) * 3, 1, p_FH );
}
// Neutral under proven otherwise.
bool neutral_material_color = true;
for( uint32 pass = 0; pass < pMat->m_passes; ++pass )
{
// Get texture checksum.
uint32 TextureChecksum;
File::Read( &TextureChecksum, sizeof( uint32 ), 1, p_FH );
// Get material flags.
File::Read( &pMat->m_flags[pass], sizeof( uint32 ), 1, p_FH );
// Get pass color flag.
bool has_color;
File::Read( &has_color, sizeof( bool ), 1, p_FH );
// Get pass color.
File::Read( &pMat->m_color[pass][0], sizeof( float ) * 3, 1, p_FH );
// Check for color being neutral.
if( neutral_material_color )
{
if(( pMat->m_color[pass][0] != 0.5f ) || ( pMat->m_color[pass][1] != 0.5f ) || ( pMat->m_color[pass][2] != 0.5f ))
{
neutral_material_color = false;
}
}
// Get ALPHA register value.
uint64 reg_alpha;
File::Read( &reg_alpha, sizeof( uint64 ), 1, p_FH );
uint32 blend_mode = (uint32)( reg_alpha & 0xFFFFFFUL );
uint32 fixed_alpha = (uint32)( reg_alpha >> 32 );
pMat->m_reg_alpha[pass] = blend_mode | ( fixed_alpha << 24 );
// Also calculate the floating point version of the fixed alpha.
pMat->m_color[pass][3] = fixed_alpha / 128.0f;
// Backface cull test - if this is an alpha blended material, turn off backface culling, except
// where the material has been explicitly flagged as single sided.
if(( pass == 0 ) && !single_sided && (( pMat->m_reg_alpha[pass] & sMaterial::BLEND_MODE_MASK ) != 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->m_uv_addressing[pass] = (( v_addressing << 16 ) | u_addressing );
// Get environment map u and v tiling multiples.
File::Read( &pMat->m_envmap_tiling[pass][0], sizeof( float ) * 2, 1, p_FH );
// Get minification and magnification filtering mode.
File::Read( &pMat->m_filtering_mode[pass], sizeof( uint32 ), 1, p_FH );
// Read uv wibble data if present.
if( pMat->m_flags[pass] & MATFLAG_UV_WIBBLE )
{
// Flag that this material wibbles.
pMat->m_uv_wibble = true;
// Create uv wibble params structure.
pMat->mp_UVWibbleParams[pass] = new sUVWibbleParams;
File::Read( pMat->mp_UVWibbleParams[pass], sizeof( float ) * 8, 1, p_FH );
}
// Read vertex color wibble data.
if(( pass == 0 ) && ( pMat->m_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 D3DCOLOR[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 );
}
}
// Read texture wibble data.
if( pMat->m_flags[pass] & MATFLAG_PASS_TEXTURE_ANIMATES )
{
// Create the texture wibble structure if not created yet.
if( pMat->mp_wibble_texture_params == NULL )
{
pMat->mp_wibble_texture_params = new NxXbox::sTextureWibbleParams;
ZeroMemory( pMat->mp_wibble_texture_params, sizeof( NxXbox::sTextureWibbleParams ));
// Flag the material as having texture wibble.
pMat->m_texture_wibble = true;
}
int num_keyframes, period, iterations, phase;
File::Read( &num_keyframes, sizeof( int ), 1, p_FH );
File::Read( &period, sizeof( int ), 1, p_FH ); // This value is currently discarded.
File::Read( &iterations, sizeof( int ), 1, p_FH );
File::Read( &phase, sizeof( int ), 1, p_FH );
Dbg_Assert( num_keyframes > 0 );
pMat->mp_wibble_texture_params->m_num_keyframes[pass] = num_keyframes;
pMat->mp_wibble_texture_params->m_phase[pass] = phase;
pMat->mp_wibble_texture_params->m_num_iterations[pass] = iterations;
pMat->mp_wibble_texture_params->mp_keyframes[pass] = new NxXbox::sTextureWibbleKeyframe[num_keyframes];
for( int ati = 0; ati < num_keyframes; ++ati )
{
File::Read( &pMat->mp_wibble_texture_params->mp_keyframes[pass][ati].m_time, sizeof( uint32 ), 1, p_FH );
// Read the texture checksum.
uint32 cs;
File::Read( &cs, sizeof( uint32 ), 1, p_FH );
// Set the TextureChecksum variable so the mp_tex member will get populated.
if( ati == 0 )
{
TextureChecksum = cs;
}
// Resolve the checksum to a texture pointer.
Nx::CXboxTexture *p_xbox_texture = static_cast<Nx::CXboxTexture*>( p_texture_table->GetItem( cs ));
pMat->mp_wibble_texture_params->mp_keyframes[pass][ati].mp_texture = ( p_xbox_texture ) ? p_xbox_texture->GetEngineTexture() : NULL;
}
}
if( TextureChecksum )
{
// If textured, resolve texture checksum...
Nx::CXboxTexture *p_xbox_texture = static_cast<Nx::CXboxTexture*>( p_texture_table->GetItem( TextureChecksum ));
sTexture *mp_tex = ( p_xbox_texture ) ? p_xbox_texture->GetEngineTexture() : NULL;
// Bail if checksum not found.
if( mp_tex == NULL )
{
Dbg_Message( "error: couldn't find texture checksum %08X\n", TextureChecksum );
pMat->mp_tex[pass] = NULL;
}
else
{
// Set texture pointer.
pMat->mp_tex[pass] = mp_tex;
}
// 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->m_k[pass] = ( *(float*)&K ) + 8.0f;
// Dave note 09/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->m_k[pass] > 0.0f )
{
pMat->m_k[pass] = 0.0f;
}
}
else
{
// ...otherwise just step past mipmap info.
pMat->mp_tex[pass] = NULL;
File::Seek( p_FH, 16, SEEK_CUR );
}
}
// Set the no material color flag if appropriate.
if( neutral_material_color )
{
pMat->m_flags[0] |= MATFLAG_NO_MAT_COL_MOD;
}
// Set the specular flag if appropriate.
if( pMat->m_specular_color[3] > 0.0f )
{
pMat->m_flags[0] |= MATFLAG_SPECULAR;
}
// There is a problem adding materials with the same checksum into the table.
// This could happen when materials in different scenes share the same name.
// It also happens for the dummy material (checksum == 0), so for now just special-case
// that one.
if( pMat->m_checksum == 0 )
{
if( !pMaterialTable->GetItem( 0 ))
{
pMaterialTable->PutItem( pMat->m_checksum, pMat );
}
}
else
{
if( pMaterialTable->GetItem( pMat->m_checksum ))
{
Dbg_MsgAssert( 0, ( "NXXBOX ERROR: duplicate material: %x\n", pMat->m_checksum ));
}
else
{
pMaterialTable->PutItem( pMat->m_checksum, pMat );
}
}
}
return pMaterialTable;
}
} // namespace NxXbox
Reference in New Issue View Git Blame Copy Permalink