void CSoundRender_TargetA::start (CSoundRender_Emitter* E)
{
inherited::start(E);
// Calc storage
buf_block = sdef_target_block*wfx.nAvgBytesPerSec/1000;
g_target_temp_data.resize(buf_block);
}
int CKinematics::LL_GetBoneGroups(xr_vector<xr_vector<u16> >& groups)
{
groups.resize (children.size());
for (u16 bone_idx=0; bone_idx<(u16)bones->size(); bone_idx++) {
CBoneData* B = (*bones)[bone_idx];
for (u32 child_idx=0; child_idx<children.size(); child_idx++){
if (!B->child_faces[child_idx].empty()){
groups[child_idx].push_back(bone_idx);
}
}
}
return groups.size();
}
void read( INetReader &r, CDB::MODEL &m )
{
verts.clear();
tris.clear();
r_pod_vector( r, verts );
u32 tris_count = r.r_u32();
tris.resize( tris_count );
for( u32 i = 0; i < tris_count; ++i)
::read( r, tris[i] );
m.build( &*verts.begin(), (int)verts.size(), &*tris.begin(), (int)tris.size() );
verts.clear();
tris.clear();
}
void lm_layer::Pack_hemi (xr_vector<u32>& dest) //.
{
dest.resize (width*height);
xr_vector<base_color>::iterator I=surface.begin ();
xr_vector<base_color>::iterator E=surface.end ();
xr_vector<u32>::iterator W=dest.begin ();
for (; I!=E; I++)
{
base_color_c C; I->_get(C);
u8 _d = u8_clr (C.sun);
u8 _h = u8_clr (C.hemi);
*W++ = color_rgba(_h,_h,_h,_d);
}
}
void lm_layer::Pack (xr_vector<u32>& dest)
{
dest.resize (width*height);
xr_vector<base_color>::iterator I=surface.begin();
xr_vector<base_color>::iterator E=surface.end();
xr_vector<u32>::iterator W=dest.begin();
for (; I!=E; I++)
{
base_color_c C; I->_get(C);
u8 _r = u8_clr(C.rgb.x);
u8 _g = u8_clr(C.rgb.y);
u8 _b = u8_clr(C.rgb.z);
u8 _d = u8_clr(C.sun);
*W++ = color_rgba(_r,_g,_b,_d);
}
}
void read( INetReader &r, CDB::MODEL* &m, xrLC_GlobalData &lc_global_data )
{
verts.clear();
tris.clear();
r_pod_vector( r, verts );
u32 tris_count = r.r_u32();
tris.resize( tris_count );
for( u32 i = 0; i < tris_count; ++i)
::read( r, tris[i], lc_global_data );
VERIFY(!m);
m = xr_new<CDB::MODEL> ();
m->build( &*verts.begin(), (int)verts.size(), &*tris.begin(), (int)tris.size() );
verts.clear();
tris.clear();
}
void RearrangeTabButtons(CUITabControl* pTab, xr_vector<Fvector2>& vec_sign_places)
{
TABS_VECTOR * btn_vec = pTab->GetButtonsVector();
TABS_VECTOR::iterator it = btn_vec->begin();
TABS_VECTOR::iterator it_e = btn_vec->end();
vec_sign_places.clear ();
vec_sign_places.resize (btn_vec->size());
Fvector2 pos;
pos.set ((*it)->GetWndPos());
Fvector2 sign_sz;
sign_sz.set (9.0f+3.0f, 11.0f);
u32 idx = 0;
float btn_text_len = 0.0f;
CUIStatic* st = NULL;
for(;it!=it_e;++it,++idx)
{
if(idx!=0)
{
st = xr_new<CUIStatic>(); st->SetAutoDelete(true);pTab->AttachChild(st);
st->SetFont((*it)->GetFont());
st->SetTextColor (color_rgba(90,90,90,255));
st->SetText("//");
st->SetWndSize ((*it)->GetWndSize());
st->AdjustWidthToText();
st->SetWndPos (pos);
pos.x += st->GetWndSize().x;
}
vec_sign_places[idx].set(pos);
vec_sign_places[idx].y += iFloor(((*it)->GetWndSize().y - sign_sz.y)/2.0f);
vec_sign_places[idx].y = (float)iFloor(vec_sign_places[idx].y);
pos.x += sign_sz.x;
(*it)->SetWndPos (pos);
(*it)->AdjustWidthToText();
btn_text_len = (*it)->GetWndSize().x;
pos.x += btn_text_len+3.0f;
}
}
void CBuild::BuildSectors()
{
Status("Determining sectors...");
Progress(0);
u32 SectorMax=0;
for (u32 I=0; I<g_tree.size(); I++)
if (g_tree[I]->Sector>SectorMax) SectorMax=g_tree[I]->Sector;
R_ASSERT(SectorMax<0xffff);
u32 SectorCount = SectorMax+1;
g_sectors.resize(SectorCount);
ZeroMemory(&*g_sectors.begin(),(u32)g_sectors.size()*sizeof(void*));
clMsg("%d sectors accepted.",SectorCount);
Status("Spatializing geometry...");
for (u32 I=0; I<g_tree.size(); I++)
{
u32 Sector = g_tree[I]->Sector;
if (0==g_sectors[Sector]) g_sectors[Sector] = xr_new<CSector> (Sector);
}
Status("Building hierrarhy...");
for (u32 I=0; I<g_sectors.size(); I++)
{
R_ASSERT(g_sectors[I]);
g_sectors[I]->BuildHierrarhy();
Progress(float(I)/float(g_sectors.size()));
}
Status("Assigning portals, occluders, glows, lights...");
// portals
for (u32 I=0; I<portals.size(); I++)
{
b_portal &P = portals[I];
R_ASSERT(u32(P.sector_front)<g_sectors.size());
R_ASSERT(u32(P.sector_back) <g_sectors.size());
g_sectors[u32(P.sector_front)]->add_portal (u16(I));
g_sectors[u32(P.sector_back)]->add_portal (u16(I));
}
// glows
for (u32 I=0; I<glows.size(); I++)
{
b_glow &G = glows[I];
b_material &M = materials[G.dwMaterial];
R_ASSERT(M.sector<g_sectors.size());
g_sectors[M.sector]->add_glow (u16(I));
}
// lights
for (u32 I=0; I<L_dynamic.size(); I++)
{
b_light_dynamic &L = L_dynamic[I];
if (L.data.type == D3DLIGHT_DIRECTIONAL)
{
for (u32 j=0; j<g_sectors.size(); j++)
{
R_ASSERT(g_sectors[j]);
g_sectors[j]->add_light(u16(I));
}
} else {
if (L.sectors.size()) {
for (u32 j=0; j<L.sectors.size(); j++)
{
R_ASSERT (L.sectors[j]<g_sectors.size());
g_sectors [L.sectors[j]]->add_light(u16(I));
}
} else {
clMsg("F**k!!! Light at position %f,%f,%f non associated!!!",
L.data.position.x,L.data.position.y,L.data.position.z
);
}
}
}
}
void CKinematics::LL_GetBindTransform(xr_vector<Fmatrix>& matrices)
{
matrices.resize (LL_BoneCount());
RecursiveBindTransform (this,matrices,iRoot,Fidentity);
}
//-----------------------------------------------------------------------
void xrMU_Model::calc_lighting (xr_vector<base_color>& dest, const Fmatrix& xform, CDB::MODEL* MDL, base_lighting& lights, u32 flags)
{
// trans-map
typedef xr_multimap<float,v_vertices> mapVert;
typedef mapVert::iterator mapVertIt;
mapVert g_trans;
u32 I;
// trans-epsilons
const float eps = EPS_L;
const float eps2 = 2.f*eps;
// calc pure rotation matrix
Fmatrix Rxform,tmp,R;
R.set (xform );
R.translate_over (0,0,0 );
tmp.transpose (R );
Rxform.invert (tmp );
// Perform lighting
CDB::COLLIDER DB;
DB.ray_options (0);
// Disable faces if needed
/*
BOOL bDisableFaces = flags&LP_UseFaceDisable;
if (bDisableFaces)
for (I=0; I<m_faces.size(); I++) m_faces[I]->flags.bDisableShadowCast = true;
*/
// Perform lighting
for (I = 0; I<m_vertices.size(); I++)
{
_vertex* V = m_vertices[I];
// Get ambient factor
float v_amb = 0.f;
float v_trans = 0.f;
for (u32 f=0; f<V->m_adjacents.size(); f++)
{
_face* F = V->m_adjacents[f];
v_amb += F->Shader().vert_ambient;
v_trans += F->Shader().vert_translucency;
}
v_amb /= float(V->m_adjacents.size());
v_trans /= float(V->m_adjacents.size());
float v_inv = 1.f-v_amb;
base_color_c vC;
Fvector vP,vN;
xform.transform_tiny (vP,V->P);
Rxform.transform_dir (vN,V->N);
exact_normalize (vN);
// multi-sample
const int n_samples = (g_params().m_quality==ebqDraft)?1:6;
for (u32 sample=0; sample<(u32)n_samples; sample++)
{
float a = 0.2f * float(sample) / float(n_samples);
Fvector P,N;
N.random_dir (vN,deg2rad(30.f));
P.mad (vP,N,a);
LightPoint (&DB, MDL, vC, P, N, lights, flags, 0);
}
vC.scale (n_samples);
vC._tmp_ = v_trans;
if (flags&LP_dont_hemi) ;
else vC.hemi += v_amb;
V->C._set (vC);
// Search
const float key = V->P.x;
mapVertIt it = g_trans.lower_bound (key);
mapVertIt it2 = it;
// Decrement to the start and inc to end
while (it!=g_trans.begin() && ((it->first+eps2)>key)) it--;
while (it2!=g_trans.end() && ((it2->first-eps2)<key)) it2++;
if (it2!=g_trans.end()) it2++;
// Search
BOOL found = FALSE;
for (; it!=it2; it++)
{
v_vertices& VL = it->second;
_vertex* Front = VL.front();
R_ASSERT (Front);
if (Front->P.similar(V->P,eps))
{
found = TRUE;
VL.push_back (V);
}
}
// Register
if (!found) {
mapVertIt ins = g_trans.insert(mk_pair(key,v_vertices()));
ins->second.reserve (32);
ins->second.push_back (V);
}
}
// Enable faces if needed
/*
if (bDisableFaces)
for (I=0; I<m_faces.size(); I++) m_faces[I]->flags.bDisableShadowCast = true;
*/
// Process all groups
for (mapVertIt it=g_trans.begin(); it!=g_trans.end(); it++)
{
// Unique
v_vertices& VL = it->second;
std::sort (VL.begin(),VL.end());
VL.erase (std::unique(VL.begin(),VL.end()),VL.end());
// Calc summary color
base_color_c C;
for (int v=0; v<int(VL.size()); v++)
{
base_color_c vC;
VL[v]->C._get (vC);
C.max (vC);
}
// Calculate final vertex color
for (u32 v=0; v<int(VL.size()); v++)
{
base_color_c vC;
VL[v]->C._get (vC);
// trans-level
float level = vC._tmp_;
//
base_color_c R;
R.lerp (vC,C,level);
R.max (vC);
R.mul (.5f);
VL[v]->C._set (R);
}
}
// Transfer colors to destination
dest.resize (m_vertices.size());
for (I = 0; I<m_vertices.size(); I++)
{
Fvector ptPos = m_vertices[I]->P;
base_color ptColor = m_vertices[I]->C;
dest[I] = ptColor;
}
}
