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
d8eb714766
thug/Code/Gfx/NGC/NX/render.cpp

2831 lines
92 KiB
C++
Raw Normal View History

thug1src
2016-02-13 21:39:12 +00:00
#include <sys/profiler.h>
#include <core/defines.h>
#include <core/debug.h>
#include <core/HashTable.h>
#include <stdio.h>
#include <stdlib.h>
#include "nx_init.h"
#include "scene.h"
#include "render.h"
#include <gfx\ngc\p_nxgeom.h>
#include <gfx\nxflags.h>
#include "occlude.h"
#include "gfx/ngc/nx/mesh.h"
#include "charpipeline\skinning.h"
#include "gfx\NxMiscFX.h"
#include <sys/ngc\p_camera.h>
#include <sys/ngc\p_frame.h>
#include <sys/ngc\p_prim.h>
#include <sys/ngc\p_render.h>
#include "dolphin/base/ppcwgpipe.h"
#include "dolphin/gx/gxvert.h"
extern int g_object;
extern int g_view_object;
extern int g_material;
extern NxNgc::sScene * g_view_scene;
//extern u16 colorMap[];
bool g_skip_correctable = 0;
#define SHADOW_TEXTURE_SIZE 256
extern uint8 * shadowTextureData;
extern uint16 shadowPalette[16];
extern uint8 * zTextureData;
extern uint8 * blurTextureData;
NxNgc::sMaterial * p_last_material = NULL;
uint32 last_color_override = 0;
uint16 last_mesh_flags = 0;
bool last_correct = true;
bool reload_camera = false;
Mtx g_matrix0;
Mtx g_matrix90;
Mtx g_matrix180;
Mtx g_matrix270;
Mth::Vector g_shadow_object_pos;
int g_kill_layer = -1;
extern "C"
{
extern void FakeEnvMap( ROMtx m, s16 * srcPos, s16 * srcNorm, float * dstBase, u32 count );
extern void FakeEnvMapSkin( ROMtx m, s16 * srcPosNorm, float * dstBase, u32 count );
extern void FakeEnvMapFloat( ROMtx m, float * srcPos, s16 * srcNorm, float * dstBase, u32 count );
}
static float * sLastUV = NULL;
static bool first_mat = false;
//static bool one_mat = false;
extern uint16 shadowPalette[16];
//bool gOverDraw = false;
bool gMeshUseCorrection = false;
bool gMeshUseAniso = false;
const float CORRECTION_CUTOFF = ( 25.0f * 12.0f );
const float ANISO_CUTOFF = ( 100.0f * 12.0f );
int meshes_considered = 0;
namespace NxNgc
{
Lst::HashTable< sTextureProjectionDetails > *pTextureProjectionDetailsTable = NULL;
NsCamera current_cam;
#ifdef SHORT_VERT
static void cam_offset( float x, float y, float z )
{
Mtx m;
MTXTrans( m, x, y, z );
MTXConcat( EngineGlobals.current_uploaded, m, m );
GX::LoadPosMtxImm( m, GX_PNMTX0 );
}
#endif // SHORT_VERT
//static void reflect_uvs( sMesh * p_mesh, float * p_tex, s16 * p_posBuffer, s16 * p_normBuffer, int step )
//{
// if ( sLastUV == p_tex ) return;
//
// // Inverse transform the camera position by the local to world matrix.
// NsMatrix mp;
//// NsMatrix mi;
//
// mp.copy( *((NsMatrix*)EngineGlobals.current_uploaded) );
//// mp.copy( EngineGlobals.camera );
//#ifdef SHORT_VERT
// NsVector v( p_mesh->m_offset_x, p_mesh->m_offset_y, p_mesh->m_offset_z );
// mp.translate( &v, NsMatrix_Combine_Post );
//#endif // SHORT_VERT
//// mi.invert( mp );
//// mp.setRight( mi.getRight() );
//// mp.setUp( mi.getUp() );
//// mp.setAt( mi.getAt() );
//
//// mp.invert();
//
//// mp.setPosX( mi.getPosX() );
//// mp.setPosY( mi.getPosY() );
//// mp.setPosZ( mi.getPosZ() );
//
// ROMtx sm;
//
// sm[0][0] = mp.getRightX();
// sm[1][0] = mp.getRightY();
// sm[2][0] = mp.getRightZ();
//
// sm[0][1] = mp.getUpX();
// sm[1][1] = mp.getUpY();
// sm[2][1] = mp.getUpZ();
//
// sm[0][2] = mp.getAtX();
// sm[1][2] = mp.getAtY();
// sm[2][2] = mp.getAtZ();
//
// sm[3][0] = mp.getPosX();
// sm[3][1] = mp.getPosY();
// sm[3][2] = mp.getPosZ();
//
// if ( step == 6 )
// {
// // Skinned
// FakeEnvMapSkin( sm, p_posBuffer, p_tex, p_mesh->m_num_vertex );
// }
// else
// {
// // Not Skinned
// GQRSetup6( p_mesh->m_vertex_format - 1, // Pos
// GQR_TYPE_S16,
// 0, // UV
// GQR_TYPE_F32 );
//
// GQRSetup7( 14, // Normal
// GQR_TYPE_S16,
// 0, // UV
// GQR_TYPE_F32 );
//
//// NsMatrix mn;
//// mn.copy( mp );
////// mn.invert(;
//// mn.setPos( 0.0f, 0.0f, 0.0f );
////
//// float shift = (float)(1<<(p_mesh->m_vertex_format-1));
//// for ( int lp = 0; lp < p_mesh->m_num_vertex; lp++ )
//// {
//// NsVector in, tpos, tnorm;
//// in.x = (((float)p_posBuffer[(lp*3)+0])/shift);
//// in.y = (((float)p_posBuffer[(lp*3)+1])/shift);
//// in.z = (((float)p_posBuffer[(lp*3)+2])/shift);
//// mp.multiply( &in, &tpos );
//// in.x = (((float)p_normBuffer[(lp*3)+0])/(float)(1<<14));
//// in.y = (((float)p_normBuffer[(lp*3)+1])/(float)(1<<14));
//// in.z = (((float)p_normBuffer[(lp*3)+2])/(float)(1<<14));
//// mn.multiply( &in, &tnorm );
////// float z1 = 1.0f / 2000.0f;
////// p_tex[(lp*2)+0] = ( ( ( ( ( tpos.x / (tpos.z+(float)gAdd) ) * (float)gScale ) + tnorm.x ) + 1.0f ) * 0.5f ) * (float)gRepeat;
////// p_tex[(lp*2)+1] = ( ( ( ( ( tpos.y / (tpos.z+(float)gAdd) ) * (float)gScale ) + tnorm.y ) + 1.0f ) * 0.5f ) * (float)gRepeat;
////
//// p_tex[(lp*2)+0] = ( ( ( ( ( tpos.x / ( tpos.z > 1 ? 1 : tpos.z ) ) + tnorm.x ) * 1.0f ) * 0.5f ) + 0.5f );
//// p_tex[(lp*2)+1] = ( ( ( ( ( tpos.y / ( tpos.z > 1 ? 1 : tpos.z ) ) + tnorm.y ) * 1.0f ) * 0.5f ) + 0.5f );
////
////// p_tex[(lp*2)+0] = ( ( ( ( tpos.x + ( tnorm.x * tpos.z ) ) * ( 0.5f * tpos.z ) ) * ( 3.0f * tpos.z ) ) + ( 0.5f * tpos.z ) );
////// p_tex[(lp*2)+1] = ( ( ( ( tpos.y + ( tnorm.y * tpos.z ) ) * ( 0.5f * tpos.z ) ) * ( 3.0f * tpos.z ) ) + ( 0.5f * tpos.z ) );
////
////// p_tex[(lp*2)+0] = ( ( tnorm.x ) + 1.0f ) * 0.5f;
////// p_tex[(lp*2)+1] = ( ( tnorm.y ) + 1.0f ) * 0.5f;
//// }
//
// FakeEnvMap( sm, p_posBuffer, p_normBuffer, p_tex, p_mesh->m_num_vertex );
//
// // GQR back to normal.
// GQRSetup7( GQR_SCALE_128, // Pos/Normal
// GQR_TYPE_S16,
// GQR_SCALE_128,
// GQR_TYPE_S16 );
// GQRSetup6( GQR_SCALE_256, // Weights
// GQR_TYPE_U8,
// GQR_SCALE_256,
// GQR_TYPE_U8 );
// }
// sLastUV = p_tex;
//}
#ifndef SHORT_VERT
//static void float_reflect_uvs( sMesh * p_mesh, float * p_tex, float * p_posBuffer, s16 * p_normBuffer, int step )
//{
// if ( sLastUV == p_tex ) return;
//
// // Inverse transform the camera position by the local to world matrix.
// NsMatrix mp;
//
// mp.copy( *((NsMatrix*)EngineGlobals.current_uploaded) );
//
// ROMtx sm;
//
// sm[0][0] = mp.getRightX();
// sm[1][0] = mp.getRightY();
// sm[2][0] = mp.getRightZ();
//
// sm[0][1] = mp.getUpX();
// sm[1][1] = mp.getUpY();
// sm[2][1] = mp.getUpZ();
//
// sm[0][2] = mp.getAtX();
// sm[1][2] = mp.getAtY();
// sm[2][2] = mp.getAtZ();
//
// sm[3][0] = mp.getPosX();
// sm[3][1] = mp.getPosY();
// sm[3][2] = mp.getPosZ();
//
//// GQRSetup6( 0, // Pos
//// GQR_TYPE_F32,
//// 0, // UV
//// GQR_TYPE_F32 );
////
//// GQRSetup7( 14, // Normal
//// GQR_TYPE_S16,
//// 0, // UV
//// GQR_TYPE_F32 );
//
// FakeEnvMapFloat( sm, p_posBuffer, p_normBuffer, p_tex, p_mesh->m_num_vertex );
//
//// // GQR back to normal.
//// GQRSetup7( GQR_SCALE_128, // Pos/Normal
//// GQR_TYPE_S16,
//// GQR_SCALE_128,
//// GQR_TYPE_S16 );
//// GQRSetup6( GQR_SCALE_256, // Weights
//// GQR_TYPE_U8,
//// GQR_SCALE_256,
//// GQR_TYPE_U8 );
// sLastUV = p_tex;
//}
#endif // SHORT_VERT
/******************************************************************/
/* */
/* */
/******************************************************************/
void init_render_system( void )
{
pTextureProjectionDetailsTable = new Lst::HashTable< sTextureProjectionDetails >( 8 );
MTXRotDeg( g_matrix0, 'y', 0.0f );
MTXRotDeg( g_matrix90, 'y', 90.0f );
MTXRotDeg( g_matrix180, 'y', 180.0f );
MTXRotDeg( g_matrix270, 'y', 270.0f );
}
void set_blend_mode( uint64 mode )
{
// Low 32 bits contain the mode, high 32 bits contain the fixed alpha value.
uint32 actual_mode = (uint32)mode;
// uint32 fixed_alpha = (uint32)( mode >> 32 );
// Only do something if the blend mode is changing.
// if( actual_mode != EngineGlobals.blend_mode_value )
{
switch( actual_mode )
{
case vBLEND_MODE_ADD:
case vBLEND_MODE_ADD_FIXED:
GX::SetBlendMode ( GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_ONE, GX_LO_CLEAR, GX_TRUE, GX_FALSE, GX_TRUE );
break;
case vBLEND_MODE_SUBTRACT:
case vBLEND_MODE_SUB_FIXED:
GX::SetBlendMode ( GX_BM_SUBTRACT, GX_BL_ZERO, GX_BL_ZERO, GX_LO_CLEAR, GX_TRUE, GX_FALSE, GX_TRUE );
break;
case vBLEND_MODE_BLEND:
case vBLEND_MODE_BLEND_FIXED:
GX::SetBlendMode ( GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_CLEAR, GX_TRUE, GX_FALSE, GX_TRUE );
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_TRUE, GX_FALSE, GX_TRUE );
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_TRUE, GX_FALSE, GX_TRUE );
break;
case vBLEND_MODE_DIFFUSE:
default:
GX::SetBlendMode ( GX_BM_NONE, GX_BL_ONE, GX_BL_ONE, GX_LO_CLEAR, GX_TRUE, GX_FALSE, GX_TRUE );
break;
}
}
}
void set_render_state( uint32 type, uint32 state )
{
switch( type )
{
case RS_ZWRITEENABLE:
{
if( state > 0 )
{
if( EngineGlobals.z_write_enabled == FALSE )
{
GX::SetZMode ( EngineGlobals.z_test_enabled ? GX_TRUE : GX_FALSE, EngineGlobals.z_test_enabled ? GX_LEQUAL : GX_ALWAYS, GX_TRUE );
EngineGlobals.z_write_enabled = TRUE;
}
}
else
{
if( EngineGlobals.z_write_enabled == TRUE )
{
GX::SetZMode ( EngineGlobals.z_test_enabled ? GX_TRUE : GX_FALSE, EngineGlobals.z_test_enabled ? GX_LEQUAL : GX_ALWAYS, GX_FALSE );
EngineGlobals.z_write_enabled = FALSE;
}
}
break;
}
case RS_ZTESTENABLE:
{
if( state > 0 )
{
if( EngineGlobals.z_test_enabled == FALSE )
{
GX::SetZMode ( GX_TRUE, GX_LEQUAL, EngineGlobals.z_write_enabled ? GX_TRUE : GX_FALSE );
EngineGlobals.z_test_enabled = TRUE;
}
}
else
{
if( EngineGlobals.z_test_enabled == TRUE )
{
GX::SetZMode ( GX_FALSE, GX_ALWAYS, EngineGlobals.z_write_enabled ? GX_TRUE : GX_FALSE );
EngineGlobals.z_test_enabled = FALSE;
}
}
break;
}
case RS_ALPHACUTOFF:
{
// GX::SetAlphaCompare(GX_GREATER, 0, GX_AOP_AND, GX_GREATER, 0 );
// // Convert from state (where 1 means "render all pixels with alpha 1 or higher") to the D3D
// if( state != EngineGlobals.alpha_ref )
// {
// EngineGlobals.alpha_ref = state;
// if( state > 0 )
// {
// D3DDevice_SetRenderState( D3DRS_ALPHAFUNC, D3DCMP_GREATEREQUAL );
// D3DDevice_SetRenderState( D3DRS_ALPHAREF, state );
// D3DDevice_SetRenderState( D3DRS_ALPHATESTENABLE, TRUE );
// }
// else
// {
// D3DDevice_SetRenderState( D3DRS_ALPHATESTENABLE, FALSE );
// }
// }
break;
}
}
}
/******************************************************************/
/* */
/* */
/******************************************************************/
float frustum_sort_mid( Mth::Vector& p_sphere )
{
NsVector test_in;
NsVector test_mid;
// D3DXMATRIX *p_world_transform;
//
// // Build the composite transform if required.
// if( p_bbox_transform )
// {
// p_world_transform = p_bbox_transform;
// }
// else
// {
// p_world_transform = NULL;
// }
test_in.x = p_sphere[X];
test_in.y = p_sphere[Y];
test_in.z = p_sphere[Z];
EngineGlobals.local_to_camera.multiply( &test_in, &test_mid );
// if( p_world_transform )
// {
// D3DXVec3Transform( &test_mid, &test_in, p_world_transform );
// test_in.x = test_mid.x;
// test_in.y = test_mid.y;
// test_in.z = test_mid.z;
// }
// D3DXVec3Transform( &test_mid, &test_in, &EngineGlobals.view_matrix );
return test_mid.z;
}
struct sSortedMeshEntry
{
sMesh *p_mesh;
float sort;
sSortedMeshEntry *pNext;
};
//static sSortedMeshEntry sortedMeshArray[1000];
/******************************************************************/
/* */
/* */
/******************************************************************/
static int cmp( const void *p1, const void *p2 )
{
return((sSortedMeshEntry*)p1)->sort < ((sSortedMeshEntry*)p2)->sort ? -1 : ((sSortedMeshEntry*)p1)->sort > ((sSortedMeshEntry*)p2)->sort ? 1 : 0;
}
/******************************************************************/
/* */
/* */
/******************************************************************/
void create_texture_projection_details( sTexture *p_texture, Nx::CNgcModel *p_model, sScene *p_scene )
{
sTextureProjectionDetails *p_details = new sTextureProjectionDetails;
p_details->p_model = p_model;
p_details->p_scene = p_scene;
p_details->p_texture = p_texture;
// Flag this scene as receiving shadows.
// p_scene->m_flags |= SCENE_FLAG_RECEIVE_SHADOWS;
pTextureProjectionDetailsTable->PutItem((uint32)p_texture, p_details );
}
/******************************************************************/
/* */
/* */
/******************************************************************/
void destroy_texture_projection_details( sTexture *p_texture )
{
sTextureProjectionDetails *p_details = pTextureProjectionDetailsTable->GetItem((uint32)p_texture );
if( p_details )
{
pTextureProjectionDetailsTable->FlushItem((uint32)p_texture );
delete p_details;
}
}
/******************************************************************/
/* */
/* */
/******************************************************************/
void set_texture_projection_camera( sTexture *p_texture, NsVector * p_pos, NsVector * p_at )
{
// NsMatrix view_matrix;
sTextureProjectionDetails *p_details = pTextureProjectionDetailsTable->GetItem((uint32)p_texture );
if( p_details )
{
NsVector up;
// Check for 'straight down' vector.
if(( p_pos->x == p_at->x ) && ( p_pos->z == p_at->z ))
{
// D3DXMatrixLookAtRH( &p_details->view_matrix, p_pos, p_at, &D3DXVECTOR3( 0.0f, 0.0f, 1.0f ));
up.set( 0.0f, 0.0f, 1.0f );
}
else
{
up.set( 0.0f, 1.0f, 0.0f );
// D3DXMatrixLookAtRH( &p_details->view_matrix, p_pos, p_at, &D3DXVECTOR3( 0.0f, 1.0f, 0.0f ));
}
// Get the 'right' vector as the cross product of camera 'at and world 'up'.
// NsVector screen_right;
// NsVector screen_up;
// screen_right.cross( *p_at, up );
// screen_up.cross( screen_right, *p_at );
//
// screen_right.normalize();
// screen_up.normalize();
//
// p_details->view_matrix.setRight( &screen_right );
// p_details->view_matrix.setUp( &screen_up );
// p_details->view_matrix.setAt( p_at );
// p_details->view_matrix.setPos( p_pos );
p_details->view_matrix.lookAt( p_pos, &up, p_at );
// D3DXMatrixOrthoRH( &p_details->projection_matrix, 96.0f, 96.0f, 1.0f, 512.0f );
}
}
/******************************************************************/
/* */
/* */
/******************************************************************/
//static D3DXMATRIX world;
//static D3DXMATRIX view;
//static D3DXMATRIX projection;
void set_camera( Mth::Matrix *p_matrix, Mth::Vector *p_position, float screen_angle, float aspect_ratio, float scale )
{
NsMatrix m;
NsFrame f;
EngineGlobals.tx = 2.0f * tanf(screen_angle*8.72664626e-03f); // tan of half (angle in radians)
EngineGlobals.ty = -(EngineGlobals.tx / aspect_ratio);
EngineGlobals.near = -2.0;
EngineGlobals.far = -40000.0;
current_cam.perspective( EngineGlobals.tx, -EngineGlobals.ty, -EngineGlobals.near, -EngineGlobals.far * 2 );
// if ( scale > 1.0f )
// {
// current_cam.SetViewMatrix( 2, 2, -0.999999f );
// current_cam.SetViewMatrix( 3, 2, 0.0f );
// }
EngineGlobals.tx = tanf( Mth::DegToRad( screen_angle * 0.5f )); ; // tan of half (angle in radians)
EngineGlobals.ty = -(EngineGlobals.tx / aspect_ratio);
EngineGlobals.sx = 1.0f/sqrtf(1.0f+1.0f/(EngineGlobals.tx*EngineGlobals.tx));
EngineGlobals.sy = 1.0f/sqrtf(1.0f+1.0f/(EngineGlobals.ty*EngineGlobals.ty));
EngineGlobals.cx = 1.0f/sqrtf(1.0f+EngineGlobals.tx*EngineGlobals.tx);
EngineGlobals.cy = 1.0f/sqrtf(1.0f+EngineGlobals.ty*EngineGlobals.ty);
// EngineGlobals.near = -2.0;
// EngineGlobals.far = -40000.0;
m.setRight( -p_matrix->GetRight().GetX(), -p_matrix->GetRight().GetY(), -p_matrix->GetRight().GetZ() );
m.setUp( p_matrix->GetUp().GetX(), p_matrix->GetUp().GetY(), p_matrix->GetUp().GetZ() );
m.setAt( -p_matrix->GetAt().GetX(), -p_matrix->GetAt().GetY(), -p_matrix->GetAt().GetZ() );
m.setPos( p_position->GetX(), p_position->GetY(), p_position->GetZ() );
f.setModelMatrix( &m );
current_cam.setFrame( &f );
current_cam.begin(); // No need to end...
EngineGlobals.world_to_camera = *current_cam.getCurrent();
EngineGlobals.local_to_camera = *current_cam.getCurrent();
EngineGlobals.camera = m;
EngineGlobals.object_pos.x = 0.0f;
EngineGlobals.object_pos.y = 0.0f;
EngineGlobals.object_pos.z = 0.0f;
MTXCopy ( (MtxPtr)current_cam.getCurrent(), EngineGlobals.current_uploaded );
// NsVector wscale( 1.0f, 1.0f, 1.0f ); //scale, scale, scale );
NsVector wscale( scale, scale, scale );
NsMatrix ms;
ms.copy( m );
ms.scale( &wscale, NsMatrix_Combine_Pre );
f.setModelMatrix( &ms );
current_cam.setFrame( &f );
current_cam.end();
current_cam.begin(); // No need to end...
// NsMatrix ms;
// ms.setRight( m.getRightX() * scale, m.getRightY() * scale, m.getRightZ() * scale );
// ms.setUp( m.getUpX() * scale, m.getUpY() * scale, m.getUpZ() * scale );
// ms.setAt( m.getAtX() * scale, m.getAtY() * scale, m.getAtZ() * scale );
// ms.setPos( m.getPosX(), m.getPosY(), m.getPosZ() );
}
/******************************************************************/
/* */
/* Checks a bounding box against the current view frustum */
/* (iBgnoring far clipping), */
/* returns true if any part is visible. */
/* Horribly inefficient at present. */
/* */
/******************************************************************/
bool frustum_check_box( Mtx m, Mth::CBBox& box )
{
Vec test_in, test_out;
uint32 cumulative_projection_space_outcode = 0xFF;
float min_x = box.GetMin().GetX();
float min_y = box.GetMin().GetY();
float min_z = box.GetMin().GetZ();
float max_x = box.GetMax().GetX();
float max_y = box.GetMax().GetY();
float max_z = box.GetMax().GetZ();
for( uint32 v = 0; v < 8; ++v )
{
uint32 projection_space_outcode = 0;
test_in.x = ( v & 0x04 ) ? max_x : min_x;
test_in.y = ( v & 0x02 ) ? max_y : min_y;
test_in.z = ( v & 0x01 ) ? max_z : min_z;
// At this point it's important to check to see whether the point is in postive or negative z-space, since
// after the projection transform, both very large camera space z values and camera space z values where z < 0
// will give results with z > 1. (Camera space values in the range [0,near] give negative projection space z values).
MTXMultVec( m, &test_in, &test_out );
// if(( -test_mid.z < 0.0f ) && ( !EngineGlobals.is_orthographic ))
// {
// test_out.x = -test_out.x;
// test_out.y = -test_out.y;
// }
if( test_out.x > 1.0f )
{
projection_space_outcode |= 0x01;
}
else if( test_out.x < -1.0f )
{
projection_space_outcode |= 0x02;
}
if( test_out.y > 1.0f )
{
projection_space_outcode |= 0x04;
}
else if( test_out.y < -1.0f )
{
projection_space_outcode |= 0x08;
}
cumulative_projection_space_outcode &= projection_space_outcode;
if( cumulative_projection_space_outcode == 0 )
{
// Early out.
return true;
}
}
return false;
}
bool frustum_check_sphere( Mtx m, Mth::Vector& p_sphere )
{
// Vec in;
// Vec out;
//
// in.x = p_sphere[X];
// in.y = p_sphere[Y];
// in.z = p_sphere[Z];
//
//// NsMatrix mat;
//// mat.copy( EngineGlobals.local_to_camera );
//// NsVector s( 0.5f, 0.5f, 0.5f );
//// mat.scale( &s, NsMatrix_Combine_Post );
////
////
//// mat.multiply( &in, &out );
//// EngineGlobals.local_to_camera.multiply( &in, &out );
//
// MTXMultVec( m, &in, &out );
//
// float x = out.x;
// float y = out.y;
// float z = out.z;
// float R = p_sphere[W];
//
// if ( R < ( z - EngineGlobals.near ) ) return false;
// if ( R < ( EngineGlobals.far - z ) ) return false;
//
// float sx_z = EngineGlobals.sx * z;
// float cx_x = EngineGlobals.cx * x;
// if ( R < ( sx_z - cx_x ) ) return false;
// if ( R < ( sx_z + cx_x ) ) return false;
//
// float sy_z = EngineGlobals.sy * z;
// float cy_y = EngineGlobals.cy * y;
// if ( R < ( sy_z - cy_y ) ) return false;
// if ( R < ( sy_z + cy_y ) ) return false;
//
// return true;
Mth::CBBox bbox;
Mth::Vector p;
p.Set( p_sphere[X] + p_sphere[W], p_sphere[Y], p_sphere[Z] ); bbox.AddPoint( p );
p.Set( p_sphere[X] - p_sphere[W], p_sphere[Y], p_sphere[Z] ); bbox.AddPoint( p );
p.Set( p_sphere[X] , p_sphere[Y]+ p_sphere[W], p_sphere[Z] ); bbox.AddPoint( p );
p.Set( p_sphere[X] , p_sphere[Y]- p_sphere[W], p_sphere[Z] ); bbox.AddPoint( p );
p.Set( p_sphere[X] , p_sphere[Y], p_sphere[Z]+ p_sphere[W] ); bbox.AddPoint( p );
p.Set( p_sphere[X] , p_sphere[Y], p_sphere[Z]- p_sphere[W] ); bbox.AddPoint( p );
return frustum_check_box( m, bbox );
}
/******************************************************************/
/* */
/* Checks a bounding box against the current view frustum */
/* (iBgnoring far clipping), */
/* returns true if any part is visible. */
/* Horribly inefficient at present. */
/* */
/******************************************************************/
bool frustum_check_box( Mth::CBBox& box )
{
int lp;
unsigned int code;
unsigned int codeAND;
f32 rx[8], ry[8], rz[8];
f32 p[GX_PROJECTION_SZ];
f32 vp[GX_VIEWPORT_SZ];
u32 clip_x;
u32 clip_y;
u32 clip_w;
u32 clip_h;
float clip_l;
float clip_t;
float clip_r;
float clip_b;
MtxPtr view;
float minx, miny, minz;
float maxx, maxy, maxz;
GX::GetProjectionv( p );
GX::GetViewportv( vp );
GX::GetScissor ( &clip_x, &clip_y, &clip_w, &clip_h );
clip_l = (float)clip_x;
clip_t = (float)clip_y;
clip_r = (float)(clip_x + clip_w);
clip_b = (float)(clip_y + clip_h);
view = (MtxPtr)&EngineGlobals.local_to_camera;
minx = box.GetMin().GetX();
miny = box.GetMin().GetY();
minz = box.GetMin().GetZ();
maxx = box.GetMax().GetX();
maxy = box.GetMax().GetY();
maxz = box.GetMax().GetZ();
GX::Project ( minx, miny, minz, view, p, vp, &rx[0], &ry[0], &rz[0] );
GX::Project ( minx, maxy, minz, view, p, vp, &rx[1], &ry[1], &rz[1] );
GX::Project ( maxx, miny, minz, view, p, vp, &rx[2], &ry[2], &rz[2] );
GX::Project ( maxx, maxy, minz, view, p, vp, &rx[3], &ry[3], &rz[3] );
GX::Project ( minx, miny, maxz, view, p, vp, &rx[4], &ry[4], &rz[4] );
GX::Project ( minx, maxy, maxz, view, p, vp, &rx[5], &ry[5], &rz[5] );
GX::Project ( maxx, miny, maxz, view, p, vp, &rx[6], &ry[6], &rz[6] );
GX::Project ( maxx, maxy, maxz, view, p, vp, &rx[7], &ry[7], &rz[7] );
// Generate clip code. {page 178, Procedural Elements for Computer Graphics}
// 1001|1000|1010
// | |
// ----+----+----
// 0001|0000|0010
// | |
// ----+----+----
// 0101|0100|0110
// | |
//
// Addition: Bit 4 is used for z behind.
codeAND = 0x001f;
for ( lp = 0; lp < 8; lp++ ) {
// Only check x/y if z is valid (if z is invalid, the x/y values will be garbage).
if ( rz[lp] > 1.0f ) {
code = (1<<4);
} else {
code = 0;
if ( rx[lp] < clip_l ) code |= (1<<0);
if ( rx[lp] > clip_r ) code |= (1<<1);
if ( ry[lp] > clip_b ) code |= (1<<2);
if ( ry[lp] < clip_t ) code |= (1<<3);
}
codeAND &= code;
if ( !codeAND ) return true;
}
if ( !codeAND ) return true;
return false;
// m_cull.clipCodeAND = codeAND;
// // If any bits are set in the AND code, the object is invisible.
// if ( codeAND ) {
// m_cull.visible = 0;
// }
//
// return !m_cull.visible; // 0 = not culled, 1 = culled.
//
// NsVector test_in, test_out;
//
// uint32 cumulative_projection_space_outcode = 0xFF;
// float min_x = box.GetMin().GetX();
// float min_y = box.GetMin().GetY();
// float min_z = box.GetMin().GetZ();
// float max_x = box.GetMax().GetX();
// float max_y = box.GetMax().GetY();
// float max_z = box.GetMax().GetZ();
//
// for( uint32 v = 0; v < 8; ++v )
// {
// uint32 projection_space_outcode = 0;
//
// test_in.x = ( v & 0x04 ) ? max_x : min_x;
// test_in.y = ( v & 0x02 ) ? max_y : min_y;
// test_in.z = ( v & 0x01 ) ? max_z : min_z;
//
// // At this point it's important to check to see whether the point is in postive or negative z-space, since
// // after the projection transform, both very large camera space z values and camera space z values where z < 0
// // will give results with z > 1. (Camera space values in the range [0,near] give negative projection space z values).
// EngineGlobals.local_to_camera.multiply( &test_in, &test_out );
//// MTXMultVec( m, &test_in, &test_out );
//
//// if(( -test_mid.z < 0.0f ) && ( !EngineGlobals.is_orthographic ))
//// {
//// test_out.x = -test_out.x;
//// test_out.y = -test_out.y;
//// }
//
// if( test_out.x > 1.0f )
// {
// projection_space_outcode |= 0x01;
// }
// else if( test_out.x < -1.0f )
// {
// projection_space_outcode |= 0x02;
// }
//
// if( test_out.y > 1.0f )
// {
// projection_space_outcode |= 0x04;
// }
// else if( test_out.y < -1.0f )
// {
// projection_space_outcode |= 0x08;
// }
//
// cumulative_projection_space_outcode &= projection_space_outcode;
//
// if( cumulative_projection_space_outcode == 0 )
// {
// // Early out.
// return true;
// }
// }
// return false;
}
/******************************************************************/
/* Quick determination of if something is visible or not, uses */
/* the previously calculated s and c vectors and the */
/* WorldToCamera transform (note, no attempt is made to ensure */
/* this is the same camera that the object will eventually be */
/* rendered with. */
/******************************************************************/
bool IsVisible( Mth::Vector &sphere )
{
NsVector in;
NsVector out;
in.x = sphere.GetX();
in.y = sphere.GetY();
in.z = sphere.GetZ();
EngineGlobals.world_to_camera.multiply( &in, &out );
float x = out.x;
float y = out.y;
float z = out.z;
float R = sphere[W];
if( //( -z + R < EngineGlobals.near ) ||
// if ( R < ( -10000.0f/*EngineGlobals.far*/ - z ) ) return false;
( R < ( z - EngineGlobals.near ) ) ||
( R < ( EngineGlobals.far - z ) ) ||
( R < EngineGlobals.sy * z + EngineGlobals.cy * y ) ||
( R < EngineGlobals.sy * z - EngineGlobals.cy * y ) ||
( R < EngineGlobals.sx * z - EngineGlobals.cx * x ) ||
( R < EngineGlobals.sx * z + EngineGlobals.cx * x ))
{
return false;
}
else
{
if( TestSphereAgainstOccluders( &sphere ))
{
// Occluded.
return false;
}
else
{
return true;
}
}
// if (R<z-near || R<far-z || R<sy*z+cy*y || R<sy*z-cy*y || R<sx*z-cx*x || R<sx*z+cx*x) visible = false;
}
bool frustum_check_sphere( Mth::Vector& p_sphere )
{
NsVector in;
NsVector out;
in.x = p_sphere[X];
in.y = p_sphere[Y];
in.z = p_sphere[Z];
// NsMatrix mat;
// mat.copy( EngineGlobals.local_to_camera );
// NsVector s( 0.5f, 0.5f, 0.5f );
// mat.scale( &s, NsMatrix_Combine_Post );
//
//
// mat.multiply( &in, &out );
EngineGlobals.local_to_camera.multiply( &in, &out );
float x = out.x;
float y = out.y;
float z = out.z;
float R = p_sphere[W];
// // See if mesh is close enough to use color correction.
// if ( ( -z - R ) < CORRECTION_CUTOFF )
// {
// gMeshUseCorrection = true;
// }
// else
// {
// gMeshUseCorrection = false;
// }
//
// // See if mesh is close enough to use anisotropic filtering.
// if ( ( -z - R ) < ANISO_CUTOFF )
// {
// gMeshUseAniso = true;
// }
// else
// {
// gMeshUseAniso = false;
// }
if ( R < ( z - EngineGlobals.near ) ) return false;
if ( R < ( EngineGlobals.far - z ) ) return false;
float sx_z = EngineGlobals.sx * z;
float cx_x = EngineGlobals.cx * x;
if ( R < ( sx_z - cx_x ) ) return false;
if ( R < ( sx_z + cx_x ) ) return false;
float sy_z = EngineGlobals.sy * z;
float cy_y = EngineGlobals.cy * y;
if ( R < ( sy_z - cy_y ) ) return false;
if ( R < ( sy_z + cy_y ) ) return false;
return true;
}
bool frustum_check_sphere( Mth::Vector& p_sphere, float * p_z )
{
bool visible = true;
NsVector in;
NsVector out;
in.x = p_sphere[X];
in.y = p_sphere[Y];
in.z = p_sphere[Z];
EngineGlobals.local_to_camera.multiply( &in, &out );
float x = out.x;
float y = out.y;
float z = out.z;
float R = p_sphere[W];
if (R<z-EngineGlobals.near || R<EngineGlobals.far-z || R<EngineGlobals.sy*z+EngineGlobals.cy*y || R<EngineGlobals.sy*z-EngineGlobals.cy*y || R<EngineGlobals.sx*z-EngineGlobals.cx*x || R<EngineGlobals.sx*z+EngineGlobals.cx*x) visible = false;
if ( p_z ) *p_z = out.z;
return visible;
}
/******************************************************************/
/* */
/* */
/******************************************************************/
void calculate_tex_proj_matrix( NsMatrix * p_tex_view_matrix, NsMatrix * p_tex_proj_matrix, NsMatrix * p_tex_transform_matrix, NsMatrix * p_world_matrix )
{
// Get the current view matrix.
NsMatrix matView, matInvView;
matView.copy( EngineGlobals.camera );
matInvView.invert( matView );
NsMatrix matBiasScale;
matBiasScale.identity();
//# ifdef TEST_SB
// static float x0 = 256.0f;
// static float y0 = 256.0f;
//
// matBiasScale._11 = x0 * 0.5f;
// matBiasScale._22 = y0 * -0.5f;
//// matBiasScale._11 = 0.5f;
//// matBiasScale._22 = -0.5f;
//// matBiasScale._33 = D3DZ_MAX_D16;
// matBiasScale._33 = D3DZ_MAX_D24S8;
//# else
// matBiasScale._11 = 0.5f;
// matBiasScale._22 = -0.5f;
//# endif
matBiasScale.setUpY( 0.5f );
matBiasScale.setAtZ( -0.5f );
//# ifdef TEST_SB
// static float x1 = 256.0f;
// static float y1 = 256.0f;
//
// matBiasScale._41 = x1 * 0.5f + 0.5f;
// matBiasScale._42 = y1 * 0.5f + 0.5f;
//// matBiasScale._41 = 0.5f;
//// matBiasScale._42 = 0.5f;
//# else
// matBiasScale._41 = 0.5f;
// matBiasScale._42 = 0.5f;
//# endif
matBiasScale.setPosY( 0.5f );
matBiasScale.setPosZ( -0.5f );
NsMatrix m_matTexProj;
//# if defined( TEST_SB )
// // Don't bother with inverse view transform for Shadow Buffer, since we are picking up world-space coordinates directly.
// if( p_world_matrix )
// {
// m_matTexProj = *p_world_matrix; // Transform to world space.
// D3DXMatrixMultiply( &m_matTexProj, &m_matTexProj, p_tex_view_matrix ); // Transform to projection camera space.
// }
// else
// {
// m_matTexProj = *p_tex_view_matrix; // Transform to projection camera space.
// }
// D3DXMatrixMultiply( &m_matTexProj, &m_matTexProj, p_tex_proj_matrix ); // Situate verts relative to projector's view
// D3DXMatrixMultiply( p_tex_transform_matrix, &m_matTexProj, &matBiasScale ); // Scale and bias to map the near clipping plane to texcoords
//# else
// m_matTexProj = matInvView; // Transform cameraspace position to worldspace
// D3DXMatrixMultiply( &m_matTexProj, &m_matTexProj, p_tex_view_matrix ); // Transform to projection camera space.
// D3DXMatrixMultiply( &m_matTexProj, &m_matTexProj, p_tex_proj_matrix ); // Situate verts relative to projector's view
// D3DXMatrixMultiply( p_tex_transform_matrix, &m_matTexProj, &matBiasScale ); // Scale and bias to map the near clipping plane to texcoords
//# endif
m_matTexProj = matInvView; // Transform cameraspace position to worldspace
m_matTexProj.cat( m_matTexProj, *p_tex_view_matrix );
m_matTexProj.cat( m_matTexProj, *p_tex_proj_matrix );
p_tex_transform_matrix->cat( m_matTexProj, matBiasScale );
// This is just for displaying the frustum lines.
/*
// Convert from homogeneous texmap coords to worldspace
D3DXMATRIX matInvTexView, matInvTexProj;
D3DXMatrixInverse( &matInvTexView, NULL, &matTexView );
D3DXMatrixInverse( &matInvTexProj, NULL, &matTexProj );
for( int i = 0; i < 8; i++ )
{
D3DXVECTOR4 vT( 0.0f, 0.0f, 0.0f, 1.0f );
vT.x = (i%2) * ( i&0x2 ? -1.0f : 1.0f );
vT.y = (i%2) * ( i&0x4 ? -1.0f : 1.0f );
vT.z = (i%2) * ( 1.0f );
D3DXVec4Transform( &vT, &vT, &matInvTexProj );
D3DXVec4Transform( &vT, &vT, &matInvTexView );
g_FrustumLines[i].x = vT.x / vT.w;
g_FrustumLines[i].y = vT.y / vT.w;
g_FrustumLines[i].z = vT.z / vT.w;
}
*/
}
/******************************************************************/
/* */
/* */
/******************************************************************/
void render_shadow_targets( void )
{
GX::SetZMode(GX_FALSE, GX_ALWAYS, GX_FALSE);
// D3DXMATRIX stored_view_matrix = EngineGlobals.view_matrix;
// D3DXMATRIX stored_projection_matrix = EngineGlobals.projection_matrix;
// Goes through the list of render target textures, rendering to each one in turn.
pTextureProjectionDetailsTable->IterateStart();
sTextureProjectionDetails *p_details = pTextureProjectionDetailsTable->IterateNext();
//
// // Set the basic pixel shader that just copies a single color (in C0) over.
// EngineGlobals.pixel_shader_constants[0] = 1.0f;
// EngineGlobals.pixel_shader_constants[1] = 1.0f;
// EngineGlobals.pixel_shader_constants[2] = 1.0f;
// EngineGlobals.pixel_shader_constants[3] = 1.0f;
// EngineGlobals.upload_pixel_shader_constants = true;
// set_pixel_shader( PixelShader3 );
// EngineGlobals.pixel_shader_override = PixelShader3;
//
// Clear background of shadow.
// NsCamera cam;
// cam.orthographic( 0, 0, 640, 448 );
// cam.begin();
//
// GX::SetZMode ( GX_FALSE, GX_ALWAYS, GX_TRUE );
// //NsPrim::box( 0, 0, 256, 256, (GXColor){128,128,128,255} );
// float zf = -( EngineGlobals.far + 0.5f );
// NsPrim::quad( 0, 0, zf, 640, 0, zf, 640, 448, zf, 0, 448, zf, (GXColor){128,128,128,255} );
// cam.end();
while( p_details )
{
if( p_details->p_model )
{
// Set the new render target.
/// D3DDevice_SetRenderTarget( p_details->p_texture->pD3DSurface, NULL );
//
// D3DDevice_Clear( 0, 0, D3DCLEAR_TARGET, 0, 1.0f, 0 );
// Set the view and projection transforms.
// EngineGlobals.view_matrix = p_details->view_matrix;
// EngineGlobals.projection_matrix = p_details->projection_matrix;
// EngineGlobals.is_orthographic = true;
// Render all instances for the CGeom's contained in this model.
int num_geoms = p_details->p_model->GetNumGeoms();
for( int i = 0; i < num_geoms; ++i )
{
Nx::CNgcGeom *p_ngc_geom = static_cast<Nx::CNgcGeom*>( p_details->p_model->GetGeomByIndex( i ));
CInstance *p_instance = p_ngc_geom->GetInstance();
if( p_instance->GetActive())
{
// Create the camera and attach a frame.
NsCamera cam;
//NsFrame frame;
//cam.setFrame( &frame );
// Assume parallel projection in this case.
cam.orthographic();
cam.orthographic( 0, 0, 256, 256 );
cam.setViewWindow( 128, 128 );
// Position the camera somewhere near the object, pointing directly at it.
float at[3];
float pos[3];
at[0] = p_instance->GetTransform()->GetPos()[X];
at[1] = p_instance->GetTransform()->GetPos()[Y];
at[2] = p_instance->GetTransform()->GetPos()[Z];
pos[0] = p_instance->GetTransform()->GetPos()[X];
pos[1] = p_instance->GetTransform()->GetPos()[Y] + 64.0f;
pos[2] = p_instance->GetTransform()->GetPos()[Z];
g_shadow_object_pos = p_instance->GetTransform()->GetPos();
g_shadow_object_pos[Y] += ( 12.0f * 3.0f ); // Amount of leeway...
// Also need to take account of the view offset.
Mth::Vector object_up = p_instance->GetTransform()->GetUp();
at[0] += object_up.GetX() * 36.0f;
at[1] += object_up.GetY() * 36.0f;
at[2] += object_up.GetZ() * 36.0f;
pos[0] += object_up.GetX() * 36.0f;
pos[1] += object_up.GetY() * 36.0f;
pos[2] += object_up.GetZ() * 36.0f;
cam.pos( pos[0], pos[1], pos[2] );
cam.up( 1.0f, 0.0f, 0.0f );
cam.lookAt( at[0], at[1], at[2] );
// EngineGlobals.world_to_camera.identity();
// EngineGlobals.world_to_camera.setPos( pos[0], pos[1], pos[2] );
// EngineGlobals.world_to_camera.setRight( 1.0f, 0.0f, 0.0f );
// EngineGlobals.world_to_camera.setUp( 0.0f, 0.0f, 1.0f );
// EngineGlobals.world_to_camera.setAt( 0.0f, -1.0f, 0.0f );
cam.begin();
MTXCopy ( (MtxPtr)cam.getCurrent(), EngineGlobals.current_uploaded );
EngineGlobals.world_to_camera.copy( *cam.getCurrent() );
EngineGlobals.shadow_camera.copy( *cam.getCurrent() );
// Flag the scene as having the shadow version rendered.
p_instance->GetScene()->m_flags |= SCENE_FLAG_RENDERING_SHADOW;
// Render the model.
// ROMtx bone_mtx[60];
// p_instance->Transform( vRENDER_SHADOW_1ST_PASS, bone_mtx, NULL );
// p_instance->ClearFlag( NxNgc::CInstance::INSTANCE_FLAG_TRANSFORM_ME );
p_instance->Render( vRENDER_SHADOW_1ST_PASS );
// Clear the flag the scene as having the shadow version rendered.
p_instance->GetScene()->m_flags &= ~SCENE_FLAG_RENDERING_SHADOW;
// Flag the scene as self shadowing.
p_instance->GetScene()->m_flags |= SCENE_FLAG_SELF_SHADOWS;
}
}
}
p_details = pTextureProjectionDetailsTable->IterateNext();
}
//
// // Pixel shader override no longer required.
// EngineGlobals.pixel_shader_override = 0;
//
// // Restore the view and projection transforms.
// EngineGlobals.view_matrix = stored_view_matrix;
// EngineGlobals.projection_matrix = stored_projection_matrix;
// EngineGlobals.is_orthographic = false;
//
// // Restore the world transform.
// D3DDevice_SetTransform( D3DTS_WORLD, &EngineGlobals.world_matrix );
//
// // Restore the default render target.
// D3DDevice_SetRenderTarget( EngineGlobals.p_RenderSurface, EngineGlobals.p_ZStencilSurface );
}
/******************************************************************/
/* */
/* */
/******************************************************************/
void render_shadow_meshes( sScene *p_scene, int *p_mesh_indices, int num_meshes )
{
}
void figure_wibble_vc( sScene *p_scene )
{
if ( !p_scene->mp_scene_data ) return;
// The vertex color wibble flag is placed in pass 0.
NxNgc::sMaterialVCWibbleKeyHeader * p_key_header = p_scene->mp_vc_wibble;
NxNgc::sMaterialVCWibbleKey * p_key = (NxNgc::sMaterialVCWibbleKey *)&p_key_header[1];
int current_time = (int)Tmr::GetTime();
uint32 * p_col = p_scene->mp_col_pool;
for ( int wibble = 0; wibble < p_scene->mp_scene_data->m_num_vc_wibbles; wibble++ )
{
int num_keys = p_key_header->m_num_frames;
int phase_shift = p_key_header->m_phase;
// Time parameters.
int start_time = p_key[0].m_time;
int end_time = p_key[(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_key[key].m_time )
{
break;
}
}
// Parameter expressing how far we are between between this keyframe and the next.
float t = (float)( time - p_key[key].m_time ) / (float)( p_key[key+1].m_time - p_key[key].m_time );
// Interpolate the color.
GXColor rgba;
rgba.r = (uint8)((( 1.0f - t ) * p_key[key].m_color.r ) + ( t * p_key[key + 1].m_color.r ));
rgba.g = (uint8)((( 1.0f - t ) * p_key[key].m_color.g ) + ( t * p_key[key + 1].m_color.g ));
rgba.b = (uint8)((( 1.0f - t ) * p_key[key].m_color.b ) + ( t * p_key[key + 1].m_color.b ));
rgba.a = (uint8)((( 1.0f - t ) * p_key[key].m_color.a ) + ( t * p_key[key + 1].m_color.a ));
p_col[wibble] = *((uint32*)&rgba);
// Next wibble sequence.
p_key_header = (NxNgc::sMaterialVCWibbleKeyHeader *)&p_key[num_keys];
p_key = (NxNgc::sMaterialVCWibbleKey *)&p_key_header[1];
}
}
//sMaterialHeader * p_mat = p_mesh->mp_dl->m_material.p_header;
//sMaterialPassHeader * p_pass = (sMaterialPassHeader *)&p_mat[1];
// Cached GX commands.
float * g_p_pos = NULL;
char * g_p_col0 = NULL;
//char * g_p_col1 = NULL;
GXColor g_col0 = (GXColor){0,0,0,0};
//GXColor g_col1 = (GXColor){0,0,0,0};
static void _reset( void )
{
g_p_pos = NULL;
g_p_col0 = NULL;
// g_p_col1 = NULL;
g_col0 = (GXColor){0,0,0,0};
// g_col1 = (GXColor){0,0,0,0};
GX::SetChanMatColor( GX_COLOR0A0, g_col0 );
// GX::SetChanMatColor( GX_COLOR0A0, g_col1 );
}
static void _set_pos( float * p_pos )
{
if ( g_p_pos != p_pos )
{
GX::SetArray( GX_VA_POS, p_pos, sizeof( float ) * 3 );
g_p_pos = p_pos;
}
}
static void _set_col0( char * p_col0 )
{
if ( g_p_col0 != p_col0 )
{
GX::SetArray( GX_VA_CLR0, p_col0, sizeof( uint32 ) );
g_p_col0 = p_col0;
}
}
//static void _set_col1( char * p_col1 )
//{
// if ( g_p_col1 != p_col1 )
// {
// GX::SetArray( GX_VA_CLR1, p_col1, sizeof( uint32 ) );
// g_p_col1 = p_col1;
// }
//}
static void _set_mat0( GXColor col )
{
if ( ( col.r != g_col0.r ) || ( col.g != g_col0.g ) || ( col.b != g_col0.b ) || ( col.a != g_col0.a ) )
{
g_col0 = col;
GX::SetChanMatColor( GX_COLOR0A0, col );
}
}
//static void _set_mat1( GXColor col )
//{
// if ( ( col.r != g_col1.r ) || ( col.g != g_col1.g ) || ( col.b != g_col1.b ) || ( col.a != g_col1.a ) )
// {
// g_col1 = col;
// GX::SetChanMatColor( GX_COLOR1A1, col );
// }
//}
static void submit_mesh( sScene *p_scene, sMesh * p_mesh, s16* p_posNormBuffer, Mth::Matrix * p_bone_xform, Mth::Matrix * p_instance_xform, int * p_array_base, int * p_col_base, int * p_layer, float * p_pm, GXColor * p_base_color, bool * set_base_color, bool * p_world_fog, uint32 flags )
{
// if ( g_skip_correctable && p_mesh->mp_dl->m_material.p_header->m_flags & (1<<6) ) return;
if ( (int)p_mesh->mp_dl->m_material.p_header->m_layer_id == g_kill_layer ) return;
if ( !p_posNormBuffer )
{
// Deal with cloned pos pools.
if ( p_mesh->mp_dl->mp_pos_pool )
{
_set_pos( p_mesh->mp_dl->mp_pos_pool );
}
else
{
// Deal with verts outside of 65535.
_set_pos( &p_scene->mp_pos_pool[p_mesh->mp_dl->m_array_base*3] );
}
}
// Deal with cloned color pools.
if ( p_mesh->mp_dl->mp_col_pool )
{
_set_col0( &((char*)p_mesh->mp_dl->mp_col_pool)[0] );
// if ( p_mesh->mp_dl->m_material.p_header->m_flags & (1<<6) )
// {
// _set_col1( &((char*)p_mesh->mp_dl->mp_col_pool)[2] );
// }
}
else
{
// Deal with resetting cloned color pools.
// Assumes that this isn't a skinned object.
_set_col0( &((char*)p_scene->mp_col_pool)[0] );
// if ( p_mesh->mp_dl->m_material.p_header->m_flags & (1<<6) )
// {
// _set_col1( &((char*)p_scene->mp_col_pool)[2] );
// }
}
// Deal with zbias.
if ( (int)p_mesh->mp_dl->m_material.p_header->m_layer_id != *p_layer )
{
*p_layer = p_mesh->mp_dl->m_material.p_header->m_layer_id;
float layer = p_mesh->mp_dl->m_material.p_header->m_layer_id;
float value = p_pm[6] + ( 150.0f * layer ) * p_pm[5];
GXWGFifo.u8 = GX_LOAD_XF_REG;
GXWGFifo.u16 = 0;
GXWGFifo.u16 = 0x1025;
GXWGFifo.f32 = value;
}
// Billboard tweaking.
// enum BillboardType
// {
// BBT_NOT_BILLBOARD,
// BBT_SCREEN_ALIGNED,
// BBT_AXIAL_ALIGNED,
// };
// if ( p_mesh->mp_mod )
// {
// Mtx t;
// Mtx m;
//
//// MTXTrans( m, p_mesh->mp_mod.offset->GetX(), p_mesh->mp_mod.offset->GetY(), p_mesh->mp_mod.offset->GetZ() );
////
//// MTXRotAxisDeg(
//
// float w = p_mesh->mp_mod->offset[W];
// Mth::ERot90 rot = *((Mth::ERot90*)&w);
//
// if ( p_mesh->mp_mod->scale[X] > 1.0f ) OSReport( "X Scale > 1.0f: %8.3f\n", p_mesh->mp_mod->scale[X] );
// if ( p_mesh->mp_mod->scale[Y] > 1.0f ) OSReport( "Y Scale > 1.0f: %8.3f\n", p_mesh->mp_mod->scale[Y] );
// if ( p_mesh->mp_mod->scale[Z] > 1.0f ) OSReport( "Z Scale > 1.0f: %8.3f\n", p_mesh->mp_mod->scale[Z] );
//
// switch ( rot )
// {
// default:
// case Mth::ROT_0:
// MTXScaleApply( g_matrix0, t, p_mesh->mp_mod->scale[X], p_mesh->mp_mod->scale[Y], p_mesh->mp_mod->scale[Z] );
// break;
// case Mth::ROT_90:
// MTXScaleApply( g_matrix90, t, p_mesh->mp_mod->scale[X], p_mesh->mp_mod->scale[Y], p_mesh->mp_mod->scale[Z] );
// break;
// case Mth::ROT_180:
// MTXScaleApply( g_matrix180, t, p_mesh->mp_mod->scale[X], p_mesh->mp_mod->scale[Y], p_mesh->mp_mod->scale[Z] );
// break;
// case Mth::ROT_270:
// MTXScaleApply( g_matrix270, t, p_mesh->mp_mod->scale[X], p_mesh->mp_mod->scale[Y], p_mesh->mp_mod->scale[Z] );
// break;
// }
// t[0][3] = p_mesh->mp_mod->offset[X];
// t[1][3] = p_mesh->mp_mod->offset[Y];
// t[2][3] = p_mesh->mp_mod->offset[Z];
// MTXConcat( EngineGlobals.current_uploaded, t, m );
//
// GX::LoadPosMtxImm( m, GX_PNMTX0 );
// reload_camera = true;
// }
// Set Fog color if necessary.
bool mesh_world_fog = true;
if ( p_mesh->mp_dl->m_material.p_header )
{
switch ( p_mesh->mp_dl->m_material.p_header->m_base_blend )
{
case vBLEND_MODE_ADD:
case vBLEND_MODE_ADD_FIXED:
case vBLEND_MODE_SUBTRACT:
case vBLEND_MODE_SUB_FIXED:
mesh_world_fog = false;
break;
default:
break;
}
}
if ( mesh_world_fog != *p_world_fog )
{
*p_world_fog = mesh_world_fog;
if ( mesh_world_fog )
{
Nx::CFog::sSetFogColor();
}
else
{
GX::SetFogColor( (GXColor){0,0,0,0} );
}
}
MaterialSubmit( p_mesh, p_scene );
switch ( p_mesh->mp_dl->mp_object_header->m_billboard_type )
{
case 2:
{
NsMatrix* p_matrix = &EngineGlobals.world_to_camera;
NsVector at = *p_matrix->getAt();
// at.x = -at.x;
// at.y = -at.y;
// at.z = -at.z;
NsVector screen_right;
NsVector screen_up;
NsVector screen_at;
NsMatrix root;
// Create coordinate system based on camera at & pivot axis.
screen_up.set( p_mesh->mp_dl->mp_object_header->m_axis[X], p_mesh->mp_dl->mp_object_header->m_axis[Y], p_mesh->mp_dl->mp_object_header->m_axis[Z] );
// screen_right.cross( *p_matrix->getAt(), screen_up );
screen_right.cross( at, screen_up );
screen_at.cross( screen_up, screen_right );
screen_right.normalize();
screen_at.normalize();
root.setRightX( screen_right.x );
root.setRightY( screen_up.x );
root.setRightZ( screen_at.x );
root.setUpX( screen_right.y );
root.setUpY( screen_up.y );
root.setUpZ( screen_at.y );
root.setAtX( screen_right.z );
root.setAtY( screen_up.z );
root.setAtZ( screen_at.z );
// root.setRightX( screen_right.x );
// root.setRightY( screen_right.y );
// root.setRightZ( screen_right.z );
//
// root.setUpX( screen_up.x );
// root.setUpY( screen_up.y );
// root.setUpZ( screen_up.z );
//
// root.setAtX( screen_at.x );
// root.setAtY( screen_at.y );
// root.setAtZ( screen_at.z );
root.setPosX( p_mesh->mp_dl->mp_object_header->m_origin[X] );
root.setPosY( p_mesh->mp_dl->mp_object_header->m_origin[Y] );
root.setPosZ( p_mesh->mp_dl->mp_object_header->m_origin[Z] );
root.cat( EngineGlobals.world_to_camera, root );
GX::LoadPosMtxImm( (MtxPtr)&root, GX_PNMTX0 );
//GXSetCurrentMtx( GX_PNMTX1 );
reload_camera = true;
}
break;
case 1:
{
NsMatrix* p_matrix = &EngineGlobals.world_to_camera;
NsMatrix root;
// Just transpose the matrix for screen-facing.
root.setRightX( p_matrix->getRightX() );
root.setRightY( p_matrix->getUpX() );
root.setRightZ( p_matrix->getAtX() );
root.setUpX( p_matrix->getRightY() );
root.setUpY( p_matrix->getUpY() );
root.setUpZ( p_matrix->getAtY() );
root.setAtX( p_matrix->getRightZ() );
root.setAtY( p_matrix->getUpZ() );
root.setAtZ( p_matrix->getAtZ() );
root.setPosX( p_mesh->mp_dl->mp_object_header->m_origin[X] );
root.setPosY( p_mesh->mp_dl->mp_object_header->m_origin[Y] );
root.setPosZ( p_mesh->mp_dl->mp_object_header->m_origin[Z] );
root.cat( EngineGlobals.world_to_camera, root );
GX::LoadPosMtxImm( (MtxPtr)&root, GX_PNMTX0 );
//GXSetCurrentMtx( GX_PNMTX1 );
reload_camera = true;
}
break;
default:
// Don't do anything - not a billboard.
//GXSetCurrentMtx( GX_PNMTX0 );
break;
}
// // Create array of bone matrices if required.
// NsMatrix bone_xform[80];
// if ( p_scene->m_numHierarchyObjects && p_bone_xform )
// {
// for ( int bone = 0; bone < num_bones; bone++ )
// {
// Mth::Matrix temp = p_bone_xform[bone] * *p_instance_xform;
// NsMatrix local;
//
// local.setRightX( temp.GetRight()[X] );
// local.setRightY( temp.GetUp()[X] );
// local.setRightZ( temp.GetAt()[X] );
//
// local.setUpX( temp.GetRight()[Y] );
// local.setUpY( temp.GetUp()[Y] );
// local.setUpZ( temp.GetAt()[Y] );
//
// local.setAtX( temp.GetRight()[Z] );
// local.setAtY( temp.GetUp()[Z] );
// local.setAtZ( temp.GetAt()[Z] );
//
// local.setPosX( temp.GetPos()[X] );
// local.setPosY( temp.GetPos()[Y] );
// local.setPosZ( temp.GetPos()[Z] );
//
// bone_xform[bone].cat( EngineGlobals.world_to_camera, local );
// }
// }
if ( p_scene->m_numHierarchyObjects && p_bone_xform )
{
NsMatrix bone_xform;
Mth::Matrix temp = p_bone_xform[p_mesh->m_bone_idx] * *p_instance_xform;
NsMatrix local;
local.setRightX( temp.GetRight()[X] );
local.setRightY( temp.GetUp()[X] );
local.setRightZ( temp.GetAt()[X] );
local.setUpX( temp.GetRight()[Y] );
local.setUpY( temp.GetUp()[Y] );
local.setUpZ( temp.GetAt()[Y] );
local.setAtX( temp.GetRight()[Z] );
local.setAtY( temp.GetUp()[Z] );
local.setAtZ( temp.GetAt()[Z] );
local.setPosX( temp.GetPos()[X] );
local.setPosY( temp.GetPos()[Y] );
local.setPosZ( temp.GetPos()[Z] );
bone_xform.cat( EngineGlobals.world_to_camera, local );
GX::LoadPosMtxImm( (MtxPtr)&bone_xform, GX_PNMTX0 );
reload_camera = true;
GX::LoadNrmMtxImm((MtxPtr)&bone_xform, GX_PNMTX0);
}
if ( /*p_scene->mp_scene_data->m_num_nrm ||*/ p_posNormBuffer || ( p_scene->m_numHierarchyObjects && p_bone_xform ) )
{
// GXLightObj light_obj[3];
//
// // Always set ambient & diffuse colors.
// GX::SetChanAmbColor( GX_COLOR0A0, NxNgc::EngineGlobals.ambient_light_color );
//// GX::SetChanAmbColor( GX_COLOR0A0, (GXColor){128,128,128,255} );
//// GX::SetChanAmbColor( GX_COLOR1A1, NxNgc::EngineGlobals.ambient_light_color );
//
// GX::InitLightColor( &light_obj[0], NxNgc::EngineGlobals.diffuse_light_color[0] );
// GX::InitLightPos( &light_obj[0], NxNgc::EngineGlobals.light_x[0], NxNgc::EngineGlobals.light_y[0], NxNgc::EngineGlobals.light_z[0] );
// GX::LoadLightObjImm( &light_obj[0], GX_LIGHT0 );
//
// GX::InitLightColor( &light_obj[1], NxNgc::EngineGlobals.diffuse_light_color[1] );
// GX::InitLightPos( &light_obj[1], NxNgc::EngineGlobals.light_x[1], NxNgc::EngineGlobals.light_y[1], NxNgc::EngineGlobals.light_z[1] );
// GX::LoadLightObjImm( &light_obj[1], GX_LIGHT1 );
//
// // Set channel control for diffuse.
// GX::SetChanCtrl( GX_COLOR0, GX_ENABLE, GX_SRC_REG, GX_SRC_VTX, GX_LIGHT0|GX_LIGHT1, GX_DF_CLAMP, GX_AF_NONE );
// GX::SetChanCtrl( GX_ALPHA0, GX_DISABLE, GX_SRC_VTX, GX_SRC_VTX, GX_LIGHT_NULL, GX_DF_NONE, GX_AF_NONE );
//
//// if ( p_mesh->mp_dl->m_material.p_header->m_shininess > 0.0f )
//// {
//// // Set channel control for specular.
//// Vec ldir;
////
//// ldir.x = 0.0f; //NxNgc::EngineGlobals.light_x[0] * ( 1.0f / 200000.0f );
//// ldir.y = 0.0f; //NxNgc::EngineGlobals.light_y[0] * ( 1.0f / 200000.0f );
//// ldir.z = -1.0f; //NxNgc::EngineGlobals.light_z[0] * ( 1.0f / 200000.0f );
////
//// GX::InitSpecularDirv( &light_obj[2], &ldir );
//// GX::InitLightShininess( &light_obj[2], 8.0f );
//// GX::InitLightColor( &light_obj[2], (GXColor){255,255,255,255} );
//// GX::LoadLightObjImm( &light_obj[2], GX_LIGHT2 );
////
//// GX::SetChanCtrl( GX_COLOR1, GX_ENABLE, GX_SRC_REG, GX_SRC_VTX, GX_LIGHT2, GX_DF_NONE, GX_AF_SPEC );
//// GX::SetChanCtrl( GX_ALPHA1, GX_DISABLE, GX_SRC_VTX, GX_SRC_VTX, GX_LIGHT_NULL, GX_DF_NONE, GX_AF_NONE );
//// }
//
}
else
{
if ( !*set_base_color )
{
GX::SetChanCtrl( GX_COLOR0, GX_ENABLE, GX_SRC_VTX, GX_SRC_REG, GX_LIGHT_NULL, GX_DF_NONE, GX_AF_NONE );
GX::SetChanCtrl( GX_ALPHA0, GX_DISABLE, GX_SRC_VTX, GX_SRC_VTX, GX_LIGHT_NULL, GX_DF_NONE, GX_AF_NONE );
//// if ( p_mesh->mp_dl->m_material.p_header->m_flags & (1<<6) )
// {
// GX::SetChanCtrl( GX_COLOR1, GX_ENABLE, GX_SRC_VTX, GX_SRC_REG, GX_LIGHT_NULL, GX_DF_NONE, GX_AF_NONE );
// GX::SetChanCtrl( GX_ALPHA1, GX_DISABLE, GX_SRC_VTX, GX_SRC_VTX, GX_LIGHT_NULL, GX_DF_NONE, GX_AF_NONE );
// }
*set_base_color = true;
}
// GX::SetChanMatColor( GX_COLOR0A0, (GXColor){128,128,128,255} );
// GX::SetChanMatColor( GX_COLOR0A0, (GXColor){32,32,32,255} );
GXColor col;
col.r = p_mesh->m_base_color.r;
col.g = p_mesh->m_base_color.g;
col.b = p_mesh->m_base_color.b;
col.a = 255;
//// if ( !(p_mesh->mp_dl->m_material.p_header->m_flags & (1<<7)) )
// if ( !(flags & vRENDER_LIT) )
// {
// // Not sure why we need to force this to be set...
//// _set_mat0( col );
//// GX::SetChanMatColor( GX_COLOR0A0, col );
//// if ( p_mesh->mp_dl->m_material.p_header->m_flags & (1<<6) )
// {
//// _set_mat1( col );
//// GX::SetChanMatColor( GX_COLOR1A1, col );
// }
//// *((uint32*)p_base_color) = *((uint32*)&col);
//
// col.r = col.r >> 1;
// col.g = col.g >> 1;
// col.b = col.b >> 1;
// }
// if ( *((uint32*)p_base_color) != *((uint32*)&col) )
{
// p_mesh->m_base_color.a = 255;
// GX::SetChanMatColor( GX_COLOR0A0, col );
_set_mat0( col );
// if ( p_mesh->mp_dl->m_material.p_header->m_flags & (1<<6) )
// {
//// GX::SetChanMatColor( GX_COLOR1A1, col );
// _set_mat1( (GXColor){col.b,col.a,0,0} );
// }
// *((uint32*)p_base_color) = *((uint32*)&col);
}
// GX::SetChanCtrl( GX_COLOR1A1, GX_DISABLE, GX_SRC_VTX, GX_SRC_REG, GX_LIGHT_NULL, GX_DF_NONE, GX_AF_NONE );
// GX::SetChanMatColor( GX_COLOR1A1, (GXColor){128,128,128,255} );
// GX::SetChanAmbColor( GX_COLOR1A1, (GXColor){128,128,128,255} );
// GX::SetChanMatColor( GX_COLOR0A0, (GXColor){64,64,64,128} );
// GX::SetChanAmbColor( GX_COLOR0A0, (GXColor){64,64,64,128} );
}
// Major hack!!!
// if ( p_posNormBuffer )
// {
// unsigned char * p8 = (unsigned char *)&p_mesh->mp_dl[1];
// for ( uint lp = 0; lp < p_mesh->mp_dl->m_size; lp++ ) GXWGFifo.u8 = *p8++;
// }
// else
// {
/*if ( !p_mesh->mp_dl->mp_pos_pool )*/ GX::CallDisplayList ( &p_mesh->mp_dl[1], p_mesh->mp_dl->m_size );
// }
if ( reload_camera )
{
GX::LoadPosMtxImm( EngineGlobals.current_uploaded, GX_PNMTX0 );
// GX::LoadPosMtxImm( (Mtx)current_cam.getCurrent(), GX_PNMTX0 );
reload_camera = false;
}
// // Reload color texture if necessary.
// if ( p_mesh->mp_dl->m_material.p_header->m_flags & (1<<5) )
// {
// // Make sure color map is uploaded.
// GX::UploadTexture( colorMap,
// 64, //COLOR_MAP_SIZE,
// 64, //COLOR_MAP_SIZE,
// GX_TF_RGBA8,
// GX_CLAMP,
// GX_CLAMP,
// GX_FALSE,
// GX_LINEAR,
// GX_LINEAR,
// 0.0f,
// 0.0f,
// 0.0f,
// GX_FALSE,
// GX_TRUE,
// GX_ANISO_1,
// GX_TEXMAP7 );
// }
}
void render_scene( sScene *p_scene, s16* p_posNormBuffer, uint32 flags, Mth::Matrix * p_bone_xform, Mth::Matrix * p_instance_xform, int num_bones )
{
// Don't render dictionary scenes.
if( p_scene->m_is_dictionary )
{
return;
}
// // This forces the texture to go into the unusable region.
// GX::UploadTexture( colorMap,
// 64,
// 64,
// GX_TF_RGBA8,
// GX_CLAMP,
// GX_CLAMP,
// GX_FALSE,
// GX_LINEAR,
// GX_LINEAR,
// 0.0f,
// 0.0f,
// 0.0f,
// GX_FALSE,
// GX_TRUE,
// GX_ANISO_1,
// GX_TEXMAP7 );
sLastUV = NULL;
first_mat = true;
p_last_material = NULL;
last_correct = false;
// if ( p_scene->m_numHierarchyObjects == 0 )
// {
// // Not hierarchical, set to matrix 0.
// GXSetCurrentMtx( GX_PNMTX0 );
// }
ResetMaterialChange();
// int meshes_rendered = 0;
figure_wibble_vc( p_scene );
#define MAX_SHADOW_MESHES 512
// int shadow_meshes = 0;
// sMesh *pShadow[MAX_SHADOW_MESHES];
// sMesh *visible_mesh_array[2000];
// int visible_mesh_array_index = 0;
// Increment the scene framestamp.
//_scene->m_framestamp++;
// Set up the texture generation matrix here.
// Mtx light;
// MTXLightOrtho( light, -128.0f, 128.0f, -128.0f, 128.0f, 0.5f, 0.5f, 0.5f, 0.5f );
// MTXConcat( light, (Mtx)&EngineGlobals.shadow_camera, light );
//#ifndef SHORT_VERT
// GX::LoadTexMtxImm( light, GX_TEXMTX7, GX_MTX3x4 );
//#endif // SHORT_VERT
if ( p_posNormBuffer )
{
GX::SetArray( GX_VA_POS, p_posNormBuffer, sizeof( uint16 ) * 6 );
GX::SetArray( GX_VA_NRM, &p_posNormBuffer[3], sizeof( uint16 ) * 6 );
}
else
{
GX::SetArray( GX_VA_POS, p_scene->mp_pos_pool, sizeof( float ) * 3 );
GX::SetArray( GX_VA_NRM, p_scene->mp_nrm_pool, sizeof( uint16 ) * 3 );
}
int array_base = 0;
int col_base = 2;
int layer = -1;
bool set_chan = false;
GXColor base_color = { 0, 0, 0, 0 };
bool world_fog = true;
Nx::CFog::sSetFogColor();
GX::SetChanMatColor( GX_COLOR0A0, base_color );
GX::SetChanMatColor( GX_COLOR1A1, base_color );
f32 pm[GX_PROJECTION_SZ];
GX::GetProjectionv( pm );
// if ( flags & vRENDER_NEW_TEST )
{
// Pool setup.
GX::SetArray( GX_VA_CLR0, &((char*)p_scene->mp_col_pool)[0], sizeof( uint32 ) );
GX::SetArray( GX_VA_CLR1, &((char*)p_scene->mp_col_pool)[2], sizeof( uint32 ) );
// GX::SetArray( GX_VA_CLR1, p_scene->mp_col_pool, sizeof( uint32 ) );
// GX::SetArray( GX_VA_TEX0, p_scene->mp_tex_pool, sizeof( float ) * 2 );
//
// GX::SetArray( GX_VA_TEX1, p_scene->mp_tex_pool, sizeof( float ) * 2 );
// GX::SetArray( GX_VA_TEX2, p_scene->mp_tex_pool, sizeof( float ) * 2 );
// GX::SetArray( GX_VA_TEX3, p_scene->mp_tex_pool, sizeof( float ) * 2 );
GX::SetArray( GX_VA_TEX0, p_scene->mp_tex_pool, sizeof( uint16 ) * 2 );
GX::SetArray( GX_VA_TEX1, p_scene->mp_tex_pool, sizeof( uint16 ) * 2 );
GX::SetArray( GX_VA_TEX2, p_scene->mp_tex_pool, sizeof( uint16 ) * 2 );
GX::SetArray( GX_VA_TEX3, p_scene->mp_tex_pool, sizeof( uint16 ) * 2 );
// GXSetArray( GX_VA_TEX4, p_scene->mp_tex_pool, sizeof( float ) * 2 );
// GXSetArray( GX_VA_TEX5, p_scene->mp_tex_pool, sizeof( float ) * 2 );
// GXSetArray( GX_VA_TEX6, p_scene->mp_tex_pool, sizeof( float ) * 2 );
// GXSetArray( GX_VA_TEX7, p_scene->mp_tex_pool, sizeof( float ) * 2 );
//GXSetVtxAttrFmt( GX_VTXFMT0, GX_VA_TEX0, GX_TEX_ST, GX_F32, 0 );
}
if ( g_object == g_view_object ) g_view_scene = p_scene;
// Render all meshes.
# ifdef __USE_PROFILER__
Sys::VUProfiler->PushContext( 128,0,0 );
# endif // __USE_PROFILER__
// {
// GX::SetFog( GX_FOG_NONE, 0.0f, 0.0f, 0.0f, 0.0f, (GXColor){0,0,0,0} );
// GX::SetTevOrder( GX_TEVSTAGE0, GX_TEXCOORD_NULL, GX_TEXMAP_NULL, GX_COLOR0A0, GX_TEXCOORD_NULL, GX_TEXMAP_NULL, GX_COLOR0A0 );
//
// GX::SetTevColorInOp( GX_TEVSTAGE0, GX_CC_ZERO, GX_CC_ZERO, GX_CC_ZERO, GX_CC_KONST,
// GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV );
//
// GX::SetTevAlphaInOpSwap( GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_KONST,
// GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV,
// GX_TEV_SWAP0, GX_TEV_SWAP0 );
//
// GX::SetBlendMode ( GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_ONE, GX_LO_CLEAR, GX_TRUE, GX_FALSE, GX_TRUE );
//
// GX::SetTevKSel( GX_TEVSTAGE0, GX_TEV_KCSEL_K0, GX_TEV_KASEL_K0_A, GX_TEV_KCSEL_K0, GX_TEV_KASEL_K0_A );
// GX::SetTevKColor( GX_KCOLOR0, (GXColor){8,8,8,255} );
// GX::SetChanCtrl( GX_ALPHA0, GX_DISABLE, GX_SRC_REG, GX_SRC_REG, GX_LIGHT_NULL, GX_DF_NONE, GX_AF_NONE );
// GX::SetChanMatColor( GX_COLOR0A0, (GXColor){255,255,255,255});
// GX::SetChanAmbColor( GX_COLOR0A0, (GXColor){255,255,255,255});
//
// GX::SetZMode(GX_FALSE, GX_ALWAYS, GX_FALSE);
// GX::SetTexChanTevIndCull( 0, 1, 1, 0, GX_CULL_NONE );
// }
///////////////////////////////////////////////////////////////////////////////////////////
// Shadow Target.
///////////////////////////////////////////////////////////////////////////////////////////
if ( flags & vRENDER_SHADOW_1ST_PASS )
{
// GX::SetFog( GX_FOG_NONE, 0.0f, 0.0f, 0.0f, 0.0f, (GXColor){0,0,0,0} );
GX::SetTevOrder( GX_TEVSTAGE0, GX_TEXCOORD_NULL, GX_TEXMAP_NULL, GX_COLOR0A0, GX_TEXCOORD_NULL, GX_TEXMAP_NULL, GX_COLOR0A0 );
GX::SetTevColorInOp( GX_TEVSTAGE0, GX_CC_ZERO, GX_CC_ZERO, GX_CC_ZERO, GX_CC_KONST,
GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV );
GX::SetTevAlphaInOpSwap( GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_KONST,
GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV,
GX_TEV_SWAP0, GX_TEV_SWAP0 );
GX::SetBlendMode ( GX_BM_NONE, GX_BL_ONE, GX_BL_ONE, GX_LO_CLEAR, GX_TRUE, GX_FALSE, GX_TRUE ); // Replace
GX::SetTevKSel( GX_TEVSTAGE0, GX_TEV_KCSEL_K0, GX_TEV_KASEL_K0_A, GX_TEV_KCSEL_K0, GX_TEV_KASEL_K0_A );
GX::SetTevKColor( GX_KCOLOR0, (GXColor){64,64,64,255} );
GX::SetChanCtrl( GX_ALPHA0, GX_DISABLE, GX_SRC_REG, GX_SRC_REG, GX_LIGHT_NULL, GX_DF_NONE, GX_AF_NONE );
GX::SetChanMatColor( GX_COLOR0A0, (GXColor){255,255,255,255});
GX::SetChanAmbColor( GX_COLOR0A0, (GXColor){255,255,255,255});
GX::SetChanMatColor( GX_COLOR1A1, (GXColor){255,255,255,255});
GX::SetChanAmbColor( GX_COLOR1A1, (GXColor){255,255,255,255});
base_color = (GXColor){ 255, 255, 255, 255 };
// GX::SetZMode(GX_FALSE, GX_ALWAYS, GX_FALSE);
GX::SetTexChanTevIndCull( 0, 1, 1, 0, GX_CULL_NONE );
for ( int mesh = 0; mesh < p_scene->m_num_filled_meshes; mesh++ )
{
sMesh * p_mesh = p_scene->mpp_mesh_list[mesh];
if ( ( p_mesh->m_flags & sMesh::MESH_FLAG_VISIBLE ) &&
( ( g_object != g_view_object ) || ( &p_scene->mp_material_header[g_material] != p_mesh->mp_dl->m_material.p_header ) ) )
{
GX::CallDisplayList ( &p_mesh->mp_dl[1], p_mesh->mp_dl->m_size );
// submit_mesh( p_scene, p_mesh, p_posNormBuffer, p_bone_xform, p_instance_xform, &array_base, &col_base, &layer, pm, &world_fog, flags );
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////
// Opaque meshes.
///////////////////////////////////////////////////////////////////////////////////////////
_reset();
if ( flags & vRENDER_OPAQUE )
{
// GX::SetZMode( GX_TRUE, GX_LEQUAL, GX_TRUE );
for ( int mesh = 0; mesh < p_scene->m_num_opaque_meshes; mesh++ )
{
sMesh * p_mesh = p_scene->mpp_mesh_list[mesh];
if ( ( p_mesh->m_flags & sMesh::MESH_FLAG_VISIBLE ) &&
( ( g_object != g_view_object ) || ( &p_scene->mp_material_header[g_material] != p_mesh->mp_dl->m_material.p_header ) ) )
{
submit_mesh( p_scene, p_mesh, p_posNormBuffer, p_bone_xform, p_instance_xform, &array_base, &col_base, &layer, pm, &base_color, &set_chan, &world_fog, flags );
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////
// Semitransparent meshes.
///////////////////////////////////////////////////////////////////////////////////////////
if ( flags & vRENDER_SEMITRANSPARENT )
{
// GX::SetZMode( GX_TRUE, GX_LEQUAL, GX_TRUE );
int opaque = p_scene->m_num_opaque_meshes;
int presemi = opaque + p_scene->m_num_pre_semitrans_meshes;
int dynsemi = presemi + p_scene->m_num_dynamic_semitrans_meshes;
int postsemi = dynsemi + p_scene->m_num_post_semitrans_meshes;
// Pre meshes.
_reset();
for ( int mesh = opaque; mesh < presemi; mesh++ )
{
sMesh * p_mesh = p_scene->mpp_mesh_list[mesh];
if ( ( p_mesh->m_flags & sMesh::MESH_FLAG_VISIBLE ) &&
( ( g_object != g_view_object ) || ( &p_scene->mp_material_header[g_material] != p_mesh->mp_dl->m_material.p_header ) ) )
{
submit_mesh( p_scene, p_mesh, p_posNormBuffer, p_bone_xform, p_instance_xform, &array_base, &col_base, &layer, pm, &base_color, &set_chan, &world_fog, flags );
}
}
// Dynamic meshes.
sSortedMeshEntry sortedMeshArray[1000];
int next_sorted_mesh_entry = 0;
for ( int mesh = presemi; mesh < dynsemi; mesh++ )
{
sMesh * p_mesh = p_scene->mpp_mesh_list[mesh];
if ( ( p_mesh->m_flags & sMesh::MESH_FLAG_VISIBLE ) &&
( ( g_object != g_view_object ) || ( &p_scene->mp_material_header[g_material] != p_mesh->mp_dl->m_material.p_header ) ) )
{
sortedMeshArray[next_sorted_mesh_entry].p_mesh = p_mesh;
sortedMeshArray[next_sorted_mesh_entry].sort = frustum_sort_mid( p_mesh->mp_dl->m_sphere );
++next_sorted_mesh_entry;
}
}
qsort( sortedMeshArray, next_sorted_mesh_entry, sizeof( sSortedMeshEntry ), cmp );
_reset();
for( int m = 0; m < next_sorted_mesh_entry; ++m )
{
submit_mesh( p_scene, sortedMeshArray[m].p_mesh, p_posNormBuffer, p_bone_xform, p_instance_xform, &array_base, &col_base, &layer, pm, &base_color, &set_chan, &world_fog, flags );
}
// Post meshes.
_reset();
for ( int mesh = dynsemi; mesh < postsemi; mesh++ )
{
sMesh * p_mesh = p_scene->mpp_mesh_list[mesh];
if ( ( p_mesh->m_flags & sMesh::MESH_FLAG_VISIBLE ) &&
( ( g_object != g_view_object ) || ( &p_scene->mp_material_header[g_material] != p_mesh->mp_dl->m_material.p_header ) ) )
{
submit_mesh( p_scene, p_mesh, p_posNormBuffer, p_bone_xform, p_instance_xform, &array_base, &col_base, &layer, pm, &base_color, &set_chan, &world_fog, flags );
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////
// Shadow Mesh.
///////////////////////////////////////////////////////////////////////////////////////////
if ( flags & vRENDER_SHADOW_2ND_PASS )
{
Nx::CFog::sEnableFog( false );
Mtx light;
MTXLightOrtho( light, -128.0f, 128.0f, -128.0f, 128.0f, 0.5f, 0.5f, 0.5f, 0.5f );
MTXConcat( light, (Mtx)&EngineGlobals.shadow_camera, light );
GX::LoadTexMtxImm( light, GX_TEXMTX7, GX_MTX3x4 );
GX::SetZMode( GX_TRUE, GX_LEQUAL, GX_FALSE );
GX::SetZCompLoc( GX_TRUE );
GX::UploadTexture( shadowTextureData,
SHADOW_TEXTURE_SIZE,
SHADOW_TEXTURE_SIZE,
GX_TF_I4,
GX_CLAMP,
GX_CLAMP,
GX_FALSE,
GX_LINEAR,
GX_LINEAR,
0.0f,
0.0f,
0.0f,
GX_FALSE,
GX_TRUE,
GX_ANISO_1,
GX_TEXMAP0 );
GX::SetTexCoordScale( GX_TEXCOORD0, GX_TRUE, SHADOW_TEXTURE_SIZE, SHADOW_TEXTURE_SIZE );
GX::UploadPalette( shadowPalette,
GX_TL_RGB5A3,
GX_TLUT_16,
GX_TEXMAP0 );
GX::SetTexChanTevIndCull( 1, 0, 1, 0, GX_CULL_NONE );
GX::SetTexCoordGen( GX_TEXCOORD0, GX_TG_MTX3x4, GX_TG_POS, GX_FALSE, GX_PTIDENTITY );
GX::SetCurrMtxPosTex03( GX_PNMTX0, GX_IDENTITY, GX_IDENTITY, GX_IDENTITY, GX_IDENTITY );
GX::SetAlphaCompare(GX_ALWAYS, 0, GX_AOP_AND, GX_ALWAYS, 0 );
// GX::SetBlendMode ( GX_BM_NONE, GX_BL_ONE, GX_BL_ONE, GX_LO_CLEAR, GX_TRUE, GX_FALSE, GX_TRUE ); // Replace
GX::SetBlendMode( GX_BM_BLEND, GX_BL_DSTCLR, GX_BL_ZERO, GX_LO_CLEAR, GX_TRUE, GX_FALSE, GX_TRUE );
GX::SetCurrMtxPosTex03( GX_PNMTX0, GX_TEXMTX7, GX_TEXMTX7, GX_TEXMTX7, GX_TEXMTX7 );
GX::SetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP0, GX_COLOR_NULL, GX_TEXCOORD0, GX_TEXMAP_NULL, GX_COLOR_NULL);
GX::SetTevAlphaInOpSwap( GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO,
GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_DISABLE, GX_TEVPREV,
GX_TEV_SWAP0, GX_TEV_SWAP0 );
GX::SetTevColorInOp( GX_TEVSTAGE0, GX_CC_ONE, GX_CC_ZERO, GX_CC_TEXC, GX_CC_ZERO,
GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_DISABLE, GX_TEVPREV );
//out_reg = (d (op) ((1.0 - c)*a + c*b) + bias) * scale;
GX::SetVtxDesc( 2, GX_VA_POS, GX_DIRECT, GX_VA_TEX0, GX_DIRECT );
// visible_mesh_array[visible_mesh_array_index++] = p_scene->m_semitransparent_meshes[e];
// for ( int mesh = 0; mesh < p_scene->m_num_filled_meshes; mesh++ )
layer = 5; // Force subsequent materials to reset the layer.
// float value = pm[6] + ( 80.0f * p_mesh->mp_dl->m_material.p_header->m_layer_id ) * pm[5];
float value = pm[6] + ( 150.0f * 5 ) * pm[5];
GXWGFifo.u8 = GX_LOAD_XF_REG;
GXWGFifo.u16 = 0;
GXWGFifo.u16 = 0x1025;
GXWGFifo.f32 = value;
// for ( int mesh = 0; mesh < ( p_scene->m_num_opaque_meshes + p_scene->m_num_pre_semitrans_meshes ); mesh++ )
for ( int mesh = 0; mesh < ( p_scene->m_num_filled_meshes ); mesh++ )
{
sMesh * p_mesh = p_scene->mpp_mesh_list[mesh];
// if( frustum_check_sphere( light, p_scene->m_opaque_meshes[e]->m_sphere ))
float by;
// if ( p_mesh->mp_mod )
// {
//// by = ( p_mesh->m_bottom_y * p_mesh->mp_mod->scale[Y] ) + p_mesh->mp_mod->offset[Y];
// by = p_mesh->mp_mod->offset[Y];
// }
// else
// {
by = p_mesh->m_bottom_y;
// }
if ( ( p_mesh->m_flags & sMesh::MESH_FLAG_VISIBLE ) &&
frustum_check_sphere( light, p_mesh->mp_dl->m_sphere ) &&
( g_shadow_object_pos[Y] > by ) &&
!( p_mesh->m_flags & sMesh::MESH_FLAG_NO_SKATER_SHADOW ) )
{
// if ( (int)p_mesh->mp_dl->m_material.p_header->m_layer_id == g_kill_layer ) return;
// Deal with cloned pos pools.
if ( p_mesh->mp_dl->mp_pos_pool )
{
array_base = -1;
GX::SetArray( GX_VA_POS, p_mesh->mp_dl->mp_pos_pool, sizeof( float ) * 3 );
}
else
{
// Deal with verts outside of 65535.
if ( p_mesh->mp_dl->m_array_base != (uint32)array_base )
{
array_base = p_mesh->mp_dl->m_array_base;
// Assumes that this isn't a skinned object.
GX::SetArray( GX_VA_POS, &p_scene->mp_pos_pool[p_mesh->mp_dl->m_array_base*3], sizeof( float ) * 3 );
}
}
GX::CallDisplayList ( &p_mesh->mp_dl[1], p_mesh->mp_dl->m_size );
// submit_mesh( p_scene, p_mesh, p_posNormBuffer, p_bone_xform, p_instance_xform, &array_base, &col_base, &layer, pm, &world_fog, flags );
}
}
Nx::CFog::sEnableFog( true );
world_fog = true;
}
// // Render opaque meshes.
// if( (flags & vRENDER_OPAQUE) && !(flags & vRENDER_SHADOW_1ST_PASS) )
// {
// for( int e = 0; e < p_scene->m_num_opaque_entries; ++e )
// {
// if ( p_scene->m_opaque_meshes[e]->m_flags & sMesh::MESH_FLAG_VISIBLE )
// {
// sMesh * p_mesh = p_scene->m_opaque_meshes[e];
//
//// set_render_state( RS_ZWRITEENABLE, p_mesh->m_zwrite );
//
// if ( flags & vRENDER_NEW_TEST )
// {
// // Textured.
// // First pass material setup.
// sMaterialHeader * p_mat = p_mesh->mp_dl->m_material.p_header;
// sMaterialPassHeader * p_pass = (sMaterialPassHeader *)&p_mat[1];
//
// if ( p_pass[0].m_texture.p_data )
// {
// if ( first_mat || !one_mat )
// {
// first_mat = false;
//
// MaterialSubmit( p_mesh );
// }
// GX::CallDisplayList ( &p_mesh->mp_dl[1], p_mesh->mp_dl->m_size );
// }
// else
// {
// // Untextured.
// if ( !(p_mesh->mp_dl->m_flags & 0x00200000) )
// {
// GXSetNumTevStages( 1 );
// GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD_NULL, GX_TEXMAP_NULL, GX_COLOR0A0);
// GXSetTevSwapMode( GX_TEVSTAGE0, GX_TEV_SWAP0, GX_TEV_SWAP0 );
// GXSetNumTexGens( 0 );
// GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV );
// GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV );
//// GXSetAlphaCompare(GX_GREATER, 0, GX_AOP_AND, GX_GREATER, 0 );
// GXSetBlendMode ( GX_BM_NONE, GX_BL_ONE, GX_BL_ONE, GX_LO_CLEAR, GX_TRUE, GX_FALSE, GX_FALSE );
// GXSetTevAlphaIn ( GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_RASA );
// GXSetTevColorIn ( GX_TEVSTAGE0, GX_CC_ZERO, GX_CC_ZERO, GX_CC_ZERO, GX_CC_RASC );
// GXSetChanCtrl( GX_COLOR0A0, GX_ENABLE, GX_SRC_VTX, GX_SRC_REG, GX_LIGHT_NULL, GX_DF_NONE, GX_AF_NONE );
// GXSetChanMatColor( GX_COLOR0A0, (GXColor){255,255,255,255} );
//// GXSetChanMatColor( GX_COLOR0A0, p_pass->m_color );
//
// GX::CallDisplayList ( &p_mesh->mp_dl[1], p_mesh->mp_dl->m_size );
// }
// }
// }
// else
// {
// multi_mesh( p_mesh, p_posNormBuffer );
// }
//
// // Now draw the opaque meshes with shadow mapped on them.
// if( p_scene->m_flags & SCENE_FLAG_RECEIVE_SHADOWS )
// {
// if( !( p_mesh->m_flags & sMesh::MESH_FLAG_NO_SKATER_SHADOW ) )
// {
// if( frustum_check_sphere( light, p_scene->m_opaque_meshes[e]->m_sphere ))
// {
// //if( frustum_check_box( light, p_scene->m_opaque_meshes[e]->m_bbox ))
// {
// if ( shadow_meshes < MAX_SHADOW_MESHES )
// {
// pShadow[shadow_meshes] = p_mesh;
// shadow_meshes++;
// }
// }
// }
// }
// }
// }
// }
// }
//
//// Render semi-transparent meshes.
// if( (flags & vRENDER_SEMITRANSPARENT) && !(flags & vRENDER_SHADOW_1ST_PASS) )
// {
// int e = 0;
// int next_sorted_mesh_entry = 0;
//
// // Semitransparent rendering is done in three stages.
// // The first stage is meshes in the list up to the point where dynamic sorting starts.
// // The second stage is meshes in the list which use dynamic sorting.
// // The third stage is meshes in the list beyond the point where dynamic sorting ends.
// for( ; e < p_scene->m_first_dynamic_sort_entry; ++e )
// {
// if ( p_scene->m_semitransparent_meshes[e]->m_flags & sMesh::MESH_FLAG_VISIBLE )
// {
// sMesh * p_mesh = p_scene->m_semitransparent_meshes[e];
//
//// set_render_state( RS_ZWRITEENABLE, p_mesh->m_zwrite );
//
// ++meshes_rendered;
//
// if ( flags & vRENDER_NEW_TEST )
// {
// // Textured.
// // First pass material setup.
// sMaterialHeader * p_mat = p_mesh->mp_dl->m_material.p_header;
// sMaterialPassHeader * p_pass = (sMaterialPassHeader *)&p_mat[1];
//
// if ( p_pass[0].m_texture.p_data )
// {
// if ( first_mat || !one_mat )
// {
// first_mat = false;
//
// MaterialSubmit( p_mesh );
// }
//
// GX::CallDisplayList ( &p_mesh->mp_dl[1], p_mesh->mp_dl->m_size );
// }
// else
// {
// // Untextured.
// if ( !(p_mesh->mp_dl->m_flags & 0x00200000) )
// {
// GXSetNumTevStages( 1 );
// GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD_NULL, GX_TEXMAP_NULL, GX_COLOR0A0);
// GXSetTevSwapMode( GX_TEVSTAGE0, GX_TEV_SWAP0, GX_TEV_SWAP0 );
// GXSetNumTexGens( 0 );
// GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV );
// GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_2, GX_ENABLE, GX_TEVPREV );
// GXSetAlphaCompare(GX_GREATER, 0, GX_AOP_AND, GX_GREATER, 0 );
// GXSetBlendMode ( GX_BM_NONE, GX_BL_ONE, GX_BL_ONE, GX_LO_CLEAR, GX_TRUE, GX_FALSE, GX_FALSE );
// GXSetTevAlphaIn ( GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_RASA );
// GXSetTevColorIn ( GX_TEVSTAGE0, GX_CC_ZERO, GX_CC_ZERO, GX_CC_ZERO, GX_CC_RASC );
// GXSetChanCtrl( GX_COLOR0A0, GX_ENABLE, GX_SRC_VTX, GX_SRC_REG, GX_LIGHT_NULL, GX_DF_NONE, GX_AF_NONE );
// GXSetChanMatColor( GX_COLOR0A0, p_pass->m_color );
//
// GX::CallDisplayList ( &p_mesh->mp_dl[1], p_mesh->mp_dl->m_size );
// }
// }
// }
// else
// {
// multi_mesh( p_mesh, p_posNormBuffer );
// }
// }
// }
//
// if( p_scene->m_num_dynamic_sort_entries > 0 )
// {
// // Second stage - dynamically sorted meshes.
// int last_dynamic_sort_entry = p_scene->m_first_dynamic_sort_entry + p_scene->m_num_dynamic_sort_entries;
// for( ; e < last_dynamic_sort_entry; ++e )
// {
// if ( p_scene->m_semitransparent_meshes[e]->m_flags & sMesh::MESH_FLAG_VISIBLE )
// {
// ++meshes_rendered;
// // Figure the midpoint of this mesh, and sort it into the render list.
// float midpoint = frustum_sort_mid( p_scene->m_semitransparent_meshes[e]->m_sphere );
//
//// // Add this mesh to the visible list.
//// if( !( p_scene->m_semitransparent_meshes[e]->m_flags & sMesh::MESH_FLAG_NO_SKATER_SHADOW ))
//// {
//// visible_mesh_array[visible_mesh_array_index++] = p_scene->m_semitransparent_meshes[e];
//// }
//
// sortedMeshArray[next_sorted_mesh_entry].p_mesh = p_scene->m_semitransparent_meshes[e];
// sortedMeshArray[next_sorted_mesh_entry].sort = midpoint;
// ++next_sorted_mesh_entry;
// }
// }
// if( next_sorted_mesh_entry > 0 )
// {
// // Sort the array into ascending sort order.
// qsort( sortedMeshArray, next_sorted_mesh_entry, sizeof( sSortedMeshEntry ), cmp );
//
// for( int m = 0; m < next_sorted_mesh_entry; ++m )
// {
// sMesh * p_mesh = sortedMeshArray[m].p_mesh;
//
//// set_render_state( RS_ZWRITEENABLE, p_mesh->m_zwrite );
//
// if ( flags & vRENDER_NEW_TEST )
// {
// // Textured.
// // First pass material setup.
// sMaterialHeader * p_mat = p_mesh->mp_dl->m_material.p_header;
// sMaterialPassHeader * p_pass = (sMaterialPassHeader *)&p_mat[1];
//
// if ( p_pass[0].m_texture.p_data )
// {
// if ( first_mat || !one_mat )
// {
// first_mat = false;
//
// MaterialSubmit( p_mesh );
// }
//
// GX::CallDisplayList ( &p_mesh->mp_dl[1], p_mesh->mp_dl->m_size );
// }
// else
// {
// // Untextured.
// if ( !(p_mesh->mp_dl->m_flags & 0x00200000) )
// {
// GXSetNumTevStages( 1 );
// GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD_NULL, GX_TEXMAP_NULL, GX_COLOR0A0);
// GXSetTevSwapMode( GX_TEVSTAGE0, GX_TEV_SWAP0, GX_TEV_SWAP0 );
// GXSetNumTexGens( 0 );
// GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV );
// GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_2, GX_ENABLE, GX_TEVPREV );
// GXSetAlphaCompare(GX_GREATER, 0, GX_AOP_AND, GX_GREATER, 0 );
// GXSetBlendMode ( GX_BM_NONE, GX_BL_ONE, GX_BL_ONE, GX_LO_CLEAR, GX_TRUE, GX_FALSE, GX_FALSE );
// GXSetTevAlphaIn ( GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_RASA );
// GXSetTevColorIn ( GX_TEVSTAGE0, GX_CC_ZERO, GX_CC_ZERO, GX_CC_ZERO, GX_CC_RASC );
// GXSetChanCtrl( GX_COLOR0A0, GX_ENABLE, GX_SRC_VTX, GX_SRC_REG, GX_LIGHT_NULL, GX_DF_NONE, GX_AF_NONE );
// GXSetChanMatColor( GX_COLOR0A0, p_pass->m_color );
//
// GX::CallDisplayList ( &p_mesh->mp_dl[1], p_mesh->mp_dl->m_size );
// }
// }
// }
// else
// {
// multi_mesh( p_mesh, p_posNormBuffer );
// }
// }
// }
//
// // Third stage - meshes after the dynamically sorted set.
// for( ; e < p_scene->m_num_semitransparent_entries; ++e )
// {
// if ( p_scene->m_semitransparent_meshes[e]->m_flags & sMesh::MESH_FLAG_VISIBLE )
// {
// sMesh * p_mesh = p_scene->m_semitransparent_meshes[e];
//
//// set_render_state( RS_ZWRITEENABLE, p_mesh->m_zwrite );
//
// ++meshes_rendered;
//
// if ( flags & vRENDER_NEW_TEST )
// {
// // Textured.
// // First pass material setup.
// sMaterialHeader * p_mat = p_mesh->mp_dl->m_material.p_header;
// sMaterialPassHeader * p_pass = (sMaterialPassHeader *)&p_mat[1];
//
// if ( p_pass[0].m_texture.p_data )
// {
// if ( first_mat || !one_mat )
// {
// first_mat = false;
//
// MaterialSubmit( p_mesh );
// }
//
// GX::CallDisplayList ( &p_mesh->mp_dl[1], p_mesh->mp_dl->m_size );
// }
// else
// {
// // Untextured.
// if ( !(p_mesh->mp_dl->m_flags & 0x00200000) )
// {
// GXSetNumTevStages( 1 );
// GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD_NULL, GX_TEXMAP_NULL, GX_COLOR0A0);
// GXSetTevSwapMode( GX_TEVSTAGE0, GX_TEV_SWAP0, GX_TEV_SWAP0 );
// GXSetNumTexGens( 0 );
// GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV );
// GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_2, GX_ENABLE, GX_TEVPREV );
// GXSetAlphaCompare(GX_GREATER, 0, GX_AOP_AND, GX_GREATER, 0 );
// GXSetBlendMode ( GX_BM_NONE, GX_BL_ONE, GX_BL_ONE, GX_LO_CLEAR, GX_TRUE, GX_FALSE, GX_FALSE );
// GXSetTevAlphaIn ( GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_RASA );
// GXSetTevColorIn ( GX_TEVSTAGE0, GX_CC_ZERO, GX_CC_ZERO, GX_CC_ZERO, GX_CC_RASC );
// GXSetChanCtrl( GX_COLOR0A0, GX_ENABLE, GX_SRC_VTX, GX_SRC_REG, GX_LIGHT_NULL, GX_DF_NONE, GX_AF_NONE );
// GXSetChanMatColor( GX_COLOR0A0, p_pass->m_color );
//
// GX::CallDisplayList ( &p_mesh->mp_dl[1], p_mesh->mp_dl->m_size );
// }
// }
// }
// else
// {
// multi_mesh( p_mesh, p_posNormBuffer );
// }
// }
// }
// }
//
//// // Now draw the semitransparent meshes with shadow mapped on them.
//// if( p_scene->m_flags & SCENE_FLAG_RECEIVE_SHADOWS )
//// {
//// render_shadow_meshes( p_scene, visible_mesh_array, visible_mesh_array_index );
//// }
// }
//
//// if ( 0 )
// {
// // Render shadow meshes.
// if( flags & vRENDER_SHADOW_1ST_PASS )
// {
// int e;
// for( e = 0; e < p_scene->m_num_opaque_entries; ++e )
// {
// if ( p_scene->m_opaque_meshes[e]->m_flags & sMesh::MESH_FLAG_VISIBLE )
// {
// sMesh * p_mesh = p_scene->m_opaque_meshes[e];
//
//// set_render_state( RS_ZWRITEENABLE, p_mesh->m_zwrite );
//
// if ( p_posNormBuffer ) {
// // Skinned.
// multi_start_16 ( &p_posNormBuffer[0], &p_posNormBuffer[3], 6, 6 );
// } else {
// // Not skinned.
//#ifdef SHORT_VERT
// cam_offset( p_mesh->m_offset_x, p_mesh->m_offset_y, p_mesh->m_offset_z );
// multi_start_16 ( p_mesh->mp_posBuffer, p_mesh->mp_normBuffer, 3, 3 );
//#else
// multi_start ( p_mesh->mp_posBuffer, p_mesh->mp_normBuffer, 3, 3 );
//#endif // SHORT_VERT
// }
//
// multi_end( p_mesh, vRENDER_SHADOW_1ST_PASS );
// }
// }
//
// for( e = 0; e < p_scene->m_num_semitransparent_entries; ++e )
// {
// if ( p_scene->m_semitransparent_meshes[e]->m_flags & sMesh::MESH_FLAG_VISIBLE )
// {
// sMesh * p_mesh = p_scene->m_semitransparent_meshes[e];
//
//// set_render_state( RS_ZWRITEENABLE, p_mesh->m_zwrite );
//
// if ( p_posNormBuffer ) {
// // Skinned.
// multi_start_16 ( &p_posNormBuffer[0], &p_posNormBuffer[3], 6, 6 );
// } else {
// // Not skinned.
//#ifdef SHORT_VERT
// cam_offset( p_mesh->m_offset_x, p_mesh->m_offset_y, p_mesh->m_offset_z );
// multi_start_16 ( p_mesh->mp_posBuffer, p_mesh->mp_normBuffer, 3, 3 );
//#else
// multi_start ( p_mesh->mp_posBuffer, p_mesh->mp_normBuffer, 3, 3 );
//#endif // SHORT_VERT
// }
//
// multi_end( p_mesh, vRENDER_SHADOW_1ST_PASS );
// }
// }
// }
//
// // Render shadows from list.
//#if 1
// for ( int lp = 0; lp < shadow_meshes; lp++ )
// {
// GXTlutObj palObj;
// GXInitTlutObj( &palObj, &shadowPalette, GX_TL_RGB5A3, 16 );
// GXLoadTlut ( &palObj, GX_TLUT0 );
//
// // Set up shadow map texture
//#define SHADOW_TEXTURE_SIZE 256
//#define BLUR_TEXTURE_SIZE 64
// GXTexObj blurTexture;
// GXTexObj shadowTexture;
// GXInitTexObjCI(
// &blurTexture,
// blurTextureData, //shadowTextureData,
// BLUR_TEXTURE_SIZE, //SHADOW_TEXTURE_SIZE,
// BLUR_TEXTURE_SIZE, //SHADOW_TEXTURE_SIZE,
// GX_TF_C4,
// GX_CLAMP,
// GX_CLAMP,
// GX_FALSE,
// GX_TLUT0 );
//// GXInitTexObjLOD(&blurTexture, GX_NEAR, GX_NEAR, 0, 0, 0, 0, 0, GX_ANISO_1);
// GXLoadTexObj( &blurTexture, GX_TEXMAP5 );
// GXInitTexObjCI(
// &shadowTexture,
// shadowTextureData,
// SHADOW_TEXTURE_SIZE,
// SHADOW_TEXTURE_SIZE,
// GX_TF_C4,
// GX_CLAMP,
// GX_CLAMP,
// GX_FALSE,
// GX_TLUT0 );
//// GXInitTexObjLOD(&shadowTexture, GX_NEAR, GX_NEAR, 0, 0, 0, 0, 0, GX_ANISO_1);
// GXLoadTexObj( &shadowTexture, GX_TEXMAP6 );
//
// // Offset the texture matrix.
//#ifdef SHORT_VERT
// Mtx m;
// MTXTrans( m, pShadow[lp]->m_offset_x, pShadow[lp]->m_offset_y, pShadow[lp]->m_offset_z );
// MTXConcat( light, m, m );
// GXLoadTexMtxImm( m, GX_TEXMTX7, GX_MTX3x4 );
//#endif // SHORT_VERT
//
// if ( p_posNormBuffer ) {
// // Skinned.
// multi_start_16 ( &p_posNormBuffer[0], &p_posNormBuffer[3], 6, 6 );
// } else {
// // Not skinned.
//#ifdef SHORT_VERT
// cam_offset( pShadow[lp]->m_offset_x, pShadow[lp]->m_offset_y, pShadow[lp]->m_offset_z );
// multi_start_16 ( pShadow[lp]->mp_posBuffer, pShadow[lp]->mp_normBuffer, 3, 3 );
//#else
// multi_start ( pShadow[lp]->mp_posBuffer, pShadow[lp]->mp_normBuffer, 3, 3 );
//#endif // SHORT_VERT
// }
//
// multi_end( pShadow[lp], vRENDER_SHADOW_2ND_PASS );
// }
//#endif
// }
//
//// if( flags & vRENDER_SEMITRANSPARENT )
//// {
//// // Sort semi-transparent meshes.
//// int bucket_size = p_scene->m_num_semitransparent_entries * 2;
//// sMesh * sorted_meshes[bucket_size];
//// memset( sorted_meshes, 0, bucket_size * 4 );
//// for( int e = 0; e < p_scene->m_num_semitransparent_entries; ++e )
//// {
//// if( p_scene->m_semitransparent_meshes[e]->m_flags & sMesh::MESH_FLAG_ACTIVE )
//// {
//// // Frustum cull this set of meshes, using the associated bounding box.
//// float z;
//// if( frustum_check_sphere( p_scene->m_semitransparent_meshes[e]->m_sphere, &z ))
//// {
//// int index = (int)( z / ( 20000.0f / bucket_size ) );
//// if ( index < 0 ) index = 0;
//// if ( index > (bucket_size - 1) ) index = (bucket_size - 1);
////
//// if ( index >= (bucket_size / 2) )
//// {
//// // Search backwards to find an empty slot.
//// while ( sorted_meshes[index] ) index--;
//// if ( index >= 0 )
//// {
//// sorted_meshes[index] = p_scene->m_semitransparent_meshes[e];
//// }
//// }
//// else
//// {
//// // Search forwards to find an empty slot.
//// while ( sorted_meshes[index] ) index++;
//// if ( index < bucket_size )
//// {
//// sorted_meshes[index] = p_scene->m_semitransparent_meshes[e];
//// }
//// }
//// }
//// }
//// }
////
//// // Render semi-transparent meshes.
//// for( int e = 0; e < bucket_size; ++e )
//// {
//// if( sorted_meshes[e] )
//// {
//// ++meshes_rendered;
////
//// sMesh * p_mesh = sorted_meshes[e];
////
//// set_render_state( RS_ZWRITEENABLE, p_mesh->m_zwrite );
////
////// if ( p_mesh->mp_uvBuffer && p_mesh->mp_material->pTex[0] )
//// {
//// uint32 layer;
////
//// if ( p_posNormBuffer ) {
//// // Skinned.
//// multi_start ( &p_posNormBuffer[0], &p_posNormBuffer[3], 6, 6 );
//// } else {
//// // Not skinned.
//// multi_start ( p_mesh->mp_posBuffer, p_mesh->mp_normBuffer, 3, 3 );
//// }
//// multi_add_color ( p_mesh->mp_colBuffer );
//// int uv_set = 0;
//// float * p_tex;
//// for ( layer = 0; layer < p_mesh->mp_material->Passes ; layer++ )
//// {
//// GXTexWrapMode u_mode;
//// GXTexWrapMode v_mode;
//// if ( p_mesh->mp_material->Flags[layer] & MATFLAG_ENVIRONMENT )
//// {
//// p_tex = NULL;
//// u_mode = GX_REPEAT;
//// v_mode = GX_REPEAT;
//// }
//// else
//// {
//// p_tex = &p_mesh->mp_uvBuffer[2*uv_set];
//// u_mode = p_mesh->mp_material->UVAddressing[layer] & (1<<0) ? GX_CLAMP : GX_REPEAT;
//// v_mode = p_mesh->mp_material->UVAddressing[layer] & (1<<1) ? GX_CLAMP : GX_REPEAT;
//// }
//// uv_set++;
////
//// multi_add_texture ( p_tex, p_mesh->m_num_uv_sets, p_mesh->mp_material->uv_slot[layer], p_mesh->mp_material->Flags[layer], layer );
//// }
////
//// multi_end( p_mesh, 0 );
//// }
//// }
//// }
//// }
//
// if ( p_scene->m_numHierarchyObjects != 0 )
// {
// // Hierarchical, set to matrix 0.
// GXSetCurrentMtx( GX_PNMTX0 );
// }
GX::SetProjectionv( pm );
g_object++;
}
/******************************************************************/
/* */
/* Sets MESH_FLAG_VISIBLE if visible for all meshes in this scene */
/* */
/******************************************************************/
int cull_scene( sScene *p_scene, uint32 flags )
{
int meshes_visible = 0;
// Cull all meshes.
sMesh ** pp_mesh = p_scene->mpp_mesh_list;
for( int e = 0; e < p_scene->m_num_filled_meshes; ++e )
{
sMesh * p_mesh = pp_mesh[e];
if( ( p_mesh->m_flags & sMesh::MESH_FLAG_ACTIVE ) && ( p_mesh->GetVisibility() & EngineGlobals.viewport ) )
{
Mth::Vector sphere = p_mesh->mp_dl->m_sphere;
// Frustum cull this set of meshes, using the associated bounding box.
if( frustum_check_sphere( sphere ))
{
// Sphere is visible.
if( ( flags & vRENDER_OCCLUDED ) )
{
if ( TestSphereAgainstOccluders( &sphere ) )
{
// Occluded.
p_mesh->m_flags &= ~sMesh::MESH_FLAG_VISIBLE;
}
else
{
// Not occluded.
p_mesh->m_flags |= sMesh::MESH_FLAG_VISIBLE;
++meshes_visible;
}
}
else
{
// Sphere being visible is enough.
p_mesh->m_flags |= sMesh::MESH_FLAG_VISIBLE;
++meshes_visible;
}
}
else
{
// Sphere not visible.
p_mesh->m_flags &= ~sMesh::MESH_FLAG_VISIBLE;
}
}
else
{
// Force to be not visible.
p_mesh->m_flags &= ~sMesh::MESH_FLAG_VISIBLE;
}
}
return meshes_visible;
// make_scene_visible( p_scene );
// return p_scene->m_num_filled_meshes;
}
/******************************************************************/
/* */
/* Sets MESH_FLAG_VISIBLE for all meshes in this scene. */
/* */
/******************************************************************/
void make_scene_visible( sScene *p_scene )
{
// Set all meshes to be visible.
sMesh ** pp_mesh = p_scene->mpp_mesh_list;
for( int e = 0; e < p_scene->m_num_filled_meshes; ++e )
{
if( ( pp_mesh[e]->m_flags & sMesh::MESH_FLAG_ACTIVE ) && ( pp_mesh[e]->GetVisibility() & EngineGlobals.viewport ) )
{
pp_mesh[e]->m_flags |= sMesh::MESH_FLAG_VISIBLE;
}
}
}
void render_begin( void )
{
}
void render_end( void )
{
}
} // namespace NxNgc
Reference in New Issue Copy Permalink