//the simpliest case - a joint to be destroied
shell_root CPHShellSplitterHolder::SplitJoint(u16 aspl)
{
//create _new physics shell
CPhysicsShell *new_shell=P_create_Shell();
CPHShell *new_shell_desc=smart_cast<CPHShell*>(new_shell);
new_shell_desc->mXFORM.set(m_pShell->mXFORM);
new_shell_desc->m_object_in_root.set(m_pShell->m_object_in_root);
SPLITTER_I splitter=m_splitters.begin()+aspl;
u16 start_element=splitter->m_element;
u16 start_joint=splitter->m_joint;
u16 end_element=m_pShell->joints[start_joint]->JointDestroyInfo()->m_end_element;
u16 end_joint=m_pShell->joints[start_joint]->JointDestroyInfo()->m_end_joint;
shell_root ret = mk_pair(new_shell,(m_pShell->joints[start_joint])->BoneID());
CShellSplitInfo split_inf;
split_inf.m_bone_id=m_pShell->joints[start_joint]->BoneID();
split_inf.m_start_el_num=start_element;
split_inf.m_end_el_num=end_element;
split_inf.m_start_jt_num=start_joint;
split_inf.m_end_jt_num=end_joint;
m_splitters.erase(splitter);
PassEndSplitters(split_inf,new_shell_desc,1,0);
InitNewShell(new_shell_desc);
m_pShell->PassEndElements(start_element,end_element,new_shell_desc);
m_pShell->PassEndJoints(start_joint+1,end_joint,new_shell_desc);
new_shell_desc->set_PhysicsRefObject(0);
new_shell_desc->PureActivate();
//new_shell_desc->ObjectInRoot().identity();
m_pShell->DeleteJoint(start_joint);
new_shell->set_ObjectContactCallback(NULL);
new_shell->set_PhysicsRefObject(NULL);
return ret;
}
void CModelPool::DeleteInternal (dxRender_Visual* &V, BOOL bDiscard)
{
VERIFY (!g_bRendering);
if (!V) return;
V->Depart ();
if (bDiscard||bForceDiscard){
Discard (V, TRUE);
}else{
//
REGISTRY_IT it = Registry.find (V);
if (it!=Registry.end())
{
// Registry entry found - move it to pool
Pool.insert (mk_pair(it->second,V));
} else {
// Registry entry not-found - just special type of visual / particles / etc.
xr_delete (V);
}
}
V = NULL;
}
pair<environment, expr> operator()(name const & c, expr const & type, expr const & value, bool is_lemma, optional<bool> const & is_meta) {
lean_assert(!is_lemma || is_meta);
lean_assert(!is_lemma || *is_meta == false);
expr new_type = collect(m_ctx.instantiate_mvars(type));
expr new_value = collect(m_ctx.instantiate_mvars(value));
buffer<expr> norm_params;
collect_and_normalize_dependencies(norm_params);
new_type = replace_locals(new_type, m_params, norm_params);
new_value = replace_locals(new_value, m_params, norm_params);
expr def_type = m_ctx.mk_pi(norm_params, new_type);
expr def_value = m_ctx.mk_lambda(norm_params, new_value);
environment const & env = m_ctx.env();
declaration d;
if (is_lemma) {
d = mk_theorem(c, to_list(m_level_params), def_type, def_value);
} else if (is_meta) {
bool use_self_opt = true;
d = mk_definition(env, c, to_list(m_level_params), def_type, def_value, use_self_opt, !*is_meta);
} else {
bool use_self_opt = true;
d = mk_definition_inferring_trusted(env, c, to_list(m_level_params), def_type, def_value, use_self_opt);
}
environment new_env = module::add(env, check(env, d, true));
buffer<level> ls;
for (name const & n : m_level_params) {
if (level const * l = m_univ_meta_to_param_inv.find(n))
ls.push_back(*l);
else
ls.push_back(mk_param_univ(n));
}
buffer<expr> ps;
for (expr const & x : m_params) {
if (expr const * m = m_meta_to_param_inv.find(mlocal_name(x)))
ps.push_back(*m);
else
ps.push_back(x);
}
expr r = mk_app(mk_constant(c, to_list(ls)), ps);
return mk_pair(new_env, r);
}
//--------------------------------------------------------------------------------------------------------------
CTexture* CResourceManager::_CreateTexture (LPCSTR _Name)
{
// DBG_VerifyTextures ();
if (0==xr_strcmp(_Name,"null")) return 0;
R_ASSERT (_Name && _Name[0]);
string_path Name;
strcpy_s (Name,_Name); //. andy if (strext(Name)) *strext(Name)=0;
fix_texture_name (Name);
// ***** first pass - search already loaded texture
LPSTR N = LPSTR(Name);
map_TextureIt I = m_textures.find (N);
if (I!=m_textures.end()) return I->second;
else
{
CTexture * T = xr_new<CTexture>();
T->dwFlags |= xr_resource_flagged::RF_REGISTERED;
m_textures.insert (mk_pair(T->set_name(Name),T));
T->Preload ();
if (Device.b_is_Ready && !bDeferredLoad) T->Load();
return T;
}
}
dxRender_Visual* CModelPool::Create(const char* name, IReader* data)
{
#ifdef _EDITOR
if (!name||!name[0]) return 0;
#endif
string_path low_name; VERIFY (xr_strlen(name)<sizeof(low_name));
strcpy_s(low_name,name); strlwr (low_name);
if (strext(low_name)) *strext (low_name)=0;
// Msg ("-CREATE %s",low_name);
// 0. Search POOL
POOL_IT it = Pool.find (low_name);
if (it!=Pool.end())
{
// 1. Instance found
dxRender_Visual* Model = it->second;
Model->Spawn ();
Pool.erase (it);
return Model;
} else {
// 1. Search for already loaded model (reference, base model)
dxRender_Visual* Base = Instance_Find (low_name);
if (0==Base){
// 2. If not found
bAllowChildrenDuplicate = FALSE;
if (data) Base = Instance_Load(low_name,data,TRUE);
else Base = Instance_Load(low_name,TRUE);
bAllowChildrenDuplicate = TRUE;
#ifdef _EDITOR
if (!Base) return 0;
#endif
}
// 3. If found - return (cloned) reference
dxRender_Visual* Model = Instance_Duplicate(Base);
Registry.insert ( mk_pair(Model,low_name) );
return Model;
}
}
IC void CCar::fill_exhaust_vector(LPCSTR S,xr_vector<SExhaust>& exhausts)
{
IKinematics* pKinematics =smart_cast<IKinematics*>(Visual());
string64 S1;
int count = _GetItemCount(S);
for (int i=0 ;i<count; ++i)
{
_GetItem (S,i,S1);
u16 bone_id = pKinematics->LL_BoneID(S1);
exhausts.push_back (SExhaust(this));
SExhaust& exhaust = exhausts.back();
exhaust.bone_id = bone_id;
BONE_P_PAIR_IT J = bone_map.find(bone_id);
if (J == bone_map.end())
{
bone_map.insert(mk_pair(bone_id,physicsBone()));
}
}
}
void dxEnvDescriptorMixerRender::lerp(IEnvDescriptorRender *inA, IEnvDescriptorRender *inB)
{
dxEnvDescriptorRender *pA = (dxEnvDescriptorRender *)inA;
dxEnvDescriptorRender *pB = (dxEnvDescriptorRender *)inB;
sky_r_textures.clear ();
sky_r_textures.push_back (mk_pair(0,pA->sky_texture));
sky_r_textures.push_back (mk_pair(1,pB->sky_texture));
sky_r_textures_env.clear ();
sky_r_textures_env.push_back(mk_pair(0,pA->sky_texture_env));
sky_r_textures_env.push_back(mk_pair(1,pB->sky_texture_env));
clouds_r_textures.clear ();
clouds_r_textures.push_back (mk_pair(0,pA->clouds_texture));
clouds_r_textures.push_back (mk_pair(1,pB->clouds_texture));
}
CPhysicsShell* P_build_Shell (CGameObject* obj,bool not_active_state,BONE_P_MAP* p_bone_map,LPCSTR fixed_bones)
{
CPhysicsShell* pPhysicsShell;
CKinematics* pKinematics=smart_cast<CKinematics*>(obj->Visual());
if(fixed_bones)
{
int count = _GetItemCount(fixed_bones);
for (int i=0 ;i<count; ++i)
{
string64 fixed_bone ;
_GetItem (fixed_bones,i,fixed_bone) ;
u16 fixed_bone_id=pKinematics->LL_BoneID(fixed_bone) ;
R_ASSERT2(BI_NONE!=fixed_bone_id,"wrong fixed bone") ;
p_bone_map->insert(mk_pair(fixed_bone_id,physicsBone())) ;
}
pPhysicsShell=P_build_Shell(obj,not_active_state,p_bone_map);
//m_pPhysicsShell->add_Joint(P_create_Joint(CPhysicsJoint::enumType::full_control,0,fixed_element));
}
else
pPhysicsShell=P_build_Shell(obj,not_active_state);
BONE_P_PAIR_IT i=p_bone_map->begin(),e=p_bone_map->end();
if(i!=e) pPhysicsShell->SetPrefereExactIntegration();
for(;i!=e;i++)
{
CPhysicsElement* fixed_element=i->second.element;
R_ASSERT2(fixed_element,"fixed bone has no physics");
//if(!fixed_element) continue;
fixed_element->Fix();
}
return pPhysicsShell;
}
void dxEnvironmentRender::OnFrame(CEnvironment &env)
{
dxEnvDescriptorMixerRender &mixRen = *(dxEnvDescriptorMixerRender*)&*env.CurrentEnv->m_pDescriptorMixer;
if (::Render->get_generation()==IRender_interface::GENERATION_R2){
//. very very ugly hack
if (HW.Caps.raster_major >= 3 && HW.Caps.geometry.bVTF){
// tonemapping in VS
mixRen.sky_r_textures.push_back (mk_pair(u32(D3DVERTEXTEXTURESAMPLER0),tonemap)); //. hack
mixRen.sky_r_textures_env.push_back (mk_pair(u32(D3DVERTEXTEXTURESAMPLER0),tonemap)); //. hack
mixRen.clouds_r_textures.push_back (mk_pair(u32(D3DVERTEXTEXTURESAMPLER0),tonemap)); //. hack
} else {
// tonemapping in PS
mixRen.sky_r_textures.push_back (mk_pair(2,tonemap)); //. hack
mixRen.sky_r_textures_env.push_back (mk_pair(2,tonemap)); //. hack
mixRen.clouds_r_textures.push_back (mk_pair(2,tonemap)); //. hack
}
}
//. Setup skybox textures, somewhat ugly
ID3DBaseTexture* e0 = mixRen.sky_r_textures[0].second->surface_get();
ID3DBaseTexture* e1 = mixRen.sky_r_textures[1].second->surface_get();
tsky0->surface_set (e0); _RELEASE(e0);
tsky1->surface_set (e1); _RELEASE(e1);
// ******************** Environment params (setting)
#ifdef USE_DX10
// TODO: DX10: Implement environment parameters setting for DX10 (if necessary)
#else // USE_DX10
#if RENDER==R_R1
Fvector3 fog_color = env.CurrentEnv->fog_color;
fog_color.mul(ps_r1_fog_luminance);
#else // RENDER==R_R1
Fvector3 &fog_color = env.CurrentEnv->fog_color;
#endif // RENDER==R_R1
CHK_DX(HW.pDevice->SetRenderState( D3DRS_FOGCOLOR, color_rgba_f(fog_color.x,fog_color.y,fog_color.z,0) ));
CHK_DX(HW.pDevice->SetRenderState( D3DRS_FOGSTART, *(u32 *)(&env.CurrentEnv->fog_near) ));
CHK_DX(HW.pDevice->SetRenderState( D3DRS_FOGEND, *(u32 *)(&env.CurrentEnv->fog_far) ));
#endif // USE_DX10
}
void*
tbl_put(tbl_t* tt, char* key, void* value)
{
uint32_t index = tbl_hash(key) % tt->nalloc;
llist_t* ll = tt->buckets[index];
bool contains = false;
int i;
for (i = 0; llist_size(ll); ++i) {
if (strcmp(pair_key(llist_at(ll, i)), key) == 0) {
contains = true;
break;
}
}
if (contains) {
pair_t* p = ll->data[i];
p->value = value;
} else {
llist_push(ll, mk_pair(key, value));
}
return value;
}
expr apply(expr const & a) {
bool sh = false;
if (is_shared(a)) {
auto r = m_cache.find(a.raw());
if (r != m_cache.end())
return r->second;
sh = true;
}
switch (a.kind()) {
case expr_kind::Var: case expr_kind::Constant: case expr_kind::Type: case expr_kind::Value:
return save_result(a, copy(a), sh);
case expr_kind::App: {
buffer<expr> new_args;
for (expr const & old_arg : args(a))
new_args.push_back(apply(old_arg));
return save_result(a, mk_app(new_args), sh);
}
case expr_kind::HEq: return save_result(a, mk_heq(apply(heq_lhs(a)), apply(heq_rhs(a))), sh);
case expr_kind::Pair: return save_result(a, mk_pair(apply(pair_first(a)), apply(pair_second(a)), apply(pair_type(a))), sh);
case expr_kind::Proj: return save_result(a, mk_proj(proj_first(a), apply(proj_arg(a))), sh);
case expr_kind::Lambda: return save_result(a, mk_lambda(abst_name(a), apply(abst_domain(a)), apply(abst_body(a))), sh);
case expr_kind::Pi: return save_result(a, mk_pi(abst_name(a), apply(abst_domain(a)), apply(abst_body(a))), sh);
case expr_kind::Sigma: return save_result(a, mk_sigma(abst_name(a), apply(abst_domain(a)), apply(abst_body(a))), sh);
case expr_kind::Let: return save_result(a, mk_let(let_name(a), apply(let_type(a)), apply(let_value(a)), apply(let_body(a))), sh);
case expr_kind::MetaVar:
return save_result(a,
update_metavar(a, [&](local_entry const & e) -> local_entry {
if (e.is_inst())
return mk_inst(e.s(), apply(e.v()));
else
return e;
}),
sh);
}
lean_unreachable(); // LCOV_EXCL_LINE
}
void CUITextureMaster::ParseShTexInfo(LPCSTR xml_file)
{
CUIXml xml;
xml.Load (CONFIG_PATH, "ui\\textures_descr", xml_file);
int files_num = xml.GetNodesNum("",0,"file");
for(int fi=0; fi<files_num; ++fi)
{
XML_NODE* root_node = xml.GetLocalRoot();
shared_str file = xml.ReadAttrib("file", fi, "name");
XML_NODE* node = xml.NavigateToNode("file", fi);
//. Msg("-%s",file.c_str());
int num = xml.GetNodesNum(node, "texture");
for (int i = 0; i<num; i++)
{
TEX_INFO info;
info.file = file;
info.rect.x1 = xml.ReadAttribFlt(node, "texture",i,"x");
info.rect.x2 = xml.ReadAttribFlt(node, "texture",i,"width") + info.rect.x1;
info.rect.y1 = xml.ReadAttribFlt(node, "texture",i,"y");
info.rect.y2 = xml.ReadAttribFlt(node, "texture",i,"height") + info.rect.y1;
shared_str id = xml.ReadAttrib (node, "texture",i,"id");
//. Msg("--%s",id.c_str());
m_textures.insert(mk_pair(id,info));
}
xml.SetLocalRoot (root_node);
}
}
io_state_stream const & operator<<(io_state_stream const & out, kernel_exception const & ex) {
options const & opts = out.get_options();
out.get_stream() << mk_pair(ex.pp(out.get_formatter(), opts), opts);
return out;
}
void CControlAnimationBase::AddAnimTranslation(const MotionID &motion, LPCSTR str)
{
m_anim_motion_map.insert(mk_pair(motion, str));
}
void CPortalTraverser::fade_portal (CPortal* _p, float ssa)
{
f_portals.push_back (mk_pair(_p,ssa));
}
//--------------------------------------------------------------------------------------------------------------
SVS* CResourceManager::_CreateVS (LPCSTR _name)
{
string_path name;
strcpy_s (name,_name);
if (0 == ::Render->m_skinning) strcat(name,"_0");
if (1 == ::Render->m_skinning) strcat(name,"_1");
if (2 == ::Render->m_skinning) strcat(name,"_2");
LPSTR N = LPSTR (name);
map_VS::iterator I = m_vs.find (N);
if (I!=m_vs.end()) return I->second;
else
{
SVS* _vs = xr_new<SVS> ();
_vs->dwFlags |= xr_resource_flagged::RF_REGISTERED;
m_vs.insert (mk_pair(_vs->set_name(name),_vs));
if (0==stricmp(_name,"null")) {
_vs->vs = NULL;
return _vs;
}
includer Includer;
LPD3DXBUFFER pShaderBuf = NULL;
LPD3DXBUFFER pErrorBuf = NULL;
LPD3DXSHADER_CONSTANTTABLE pConstants = NULL;
HRESULT _hr = S_OK;
string_path cname;
strconcat (sizeof(cname),cname,::Render->getShaderPath(),_name,".vs");
FS.update_path (cname, "$game_shaders$", cname);
// LPCSTR target = NULL;
IReader* fs = FS.r_open(cname);
R_ASSERT3 (fs, "shader file doesnt exist", cname);
// Select target
LPCSTR c_target = "vs_2_0";
LPCSTR c_entry = "main";
/*if (HW.Caps.geometry.dwVersion>=CAP_VERSION(3,0)) target="vs_3_0";
else*/ if (HW.Caps.geometry_major>=2) c_target="vs_2_0";
else c_target="vs_1_1";
LPSTR pfs = xr_alloc<char>(fs->length() + 1);
strncpy (pfs, (LPCSTR)fs->pointer(), fs->length());
pfs [fs->length()] = 0;
if (strstr(pfs, "main_vs_1_1")) { c_target = "vs_1_1"; c_entry = "main_vs_1_1"; }
if (strstr(pfs, "main_vs_2_0")) { c_target = "vs_2_0"; c_entry = "main_vs_2_0"; }
xr_free(pfs);
// vertex
R_ASSERT2 (fs,cname);
_hr = ::Render->shader_compile(name,LPCSTR(fs->pointer()),fs->length(), NULL, &Includer, c_entry, c_target, D3DXSHADER_DEBUG | D3DXSHADER_PACKMATRIX_ROWMAJOR /*| D3DXSHADER_PREFER_FLOW_CONTROL*/, &pShaderBuf, &pErrorBuf, NULL);
// _hr = D3DXCompileShader (LPCSTR(fs->pointer()),fs->length(), NULL, &Includer, "main", target, D3DXSHADER_DEBUG | D3DXSHADER_PACKMATRIX_ROWMAJOR, &pShaderBuf, &pErrorBuf, NULL);
FS.r_close (fs);
if (SUCCEEDED(_hr))
{
if (pShaderBuf)
{
_hr = HW.pDevice->CreateVertexShader ((DWORD*)pShaderBuf->GetBufferPointer(), &_vs->vs);
if (SUCCEEDED(_hr)) {
LPCVOID data = NULL;
_hr = D3DXFindShaderComment ((DWORD*)pShaderBuf->GetBufferPointer(),MAKEFOURCC('C','T','A','B'),&data,NULL);
if (SUCCEEDED(_hr) && data)
{
pConstants = LPD3DXSHADER_CONSTANTTABLE(data);
_vs->constants.parse (pConstants,0x2);
} else _hr = E_FAIL;
}
}
else _hr = E_FAIL;
} else {
VERIFY (pErrorBuf);
Log ("! error: ",(LPCSTR)pErrorBuf->GetBufferPointer());
}
_RELEASE (pShaderBuf);
_RELEASE (pErrorBuf);
pConstants = NULL;
R_CHK (_hr);
return _vs;
}
}
//--------------------------------------------------------------------------------------------------------------
SPS* CResourceManager::_CreatePS (LPCSTR name)
{
LPSTR N = LPSTR(name);
map_PS::iterator I = m_ps.find (N);
if (I!=m_ps.end()) return I->second;
else
{
SPS* _ps = xr_new<SPS> ();
_ps->dwFlags |= xr_resource_flagged::RF_REGISTERED;
m_ps.insert (mk_pair(_ps->set_name(name),_ps));
if (0==stricmp(name,"null")) {
_ps->ps = NULL;
return _ps;
}
// Open file
includer Includer;
string_path cname;
strconcat (sizeof(cname), cname,::Render->getShaderPath(),name,".ps");
FS.update_path (cname, "$game_shaders$", cname);
// duplicate and zero-terminate
IReader* R = FS.r_open(cname);
R_ASSERT2 (R,cname);
u32 size = R->length();
char* data = xr_alloc<char>(size + 1);
CopyMemory (data,R->pointer(),size);
data[size] = 0;
FS.r_close (R);
// Select target
LPCSTR c_target = "ps_2_0";
LPCSTR c_entry = "main";
if (strstr(data,"main_ps_1_1")) { c_target = "ps_1_1"; c_entry = "main_ps_1_1"; }
if (strstr(data,"main_ps_1_2")) { c_target = "ps_1_2"; c_entry = "main_ps_1_2"; }
if (strstr(data,"main_ps_1_3")) { c_target = "ps_1_3"; c_entry = "main_ps_1_3"; }
if (strstr(data,"main_ps_1_4")) { c_target = "ps_1_4"; c_entry = "main_ps_1_4"; }
if (strstr(data,"main_ps_2_0")) { c_target = "ps_2_0"; c_entry = "main_ps_2_0"; }
// Compile
LPD3DXBUFFER pShaderBuf = NULL;
LPD3DXBUFFER pErrorBuf = NULL;
LPD3DXSHADER_CONSTANTTABLE pConstants = NULL;
HRESULT _hr = S_OK;
_hr = ::Render->shader_compile (name,data,size, NULL, &Includer, c_entry, c_target, D3DXSHADER_DEBUG | D3DXSHADER_PACKMATRIX_ROWMAJOR /*| D3DXSHADER_PREFER_FLOW_CONTROL*/, &pShaderBuf, &pErrorBuf, NULL);
//_hr = D3DXCompileShader (text,text_size, NULL, &Includer, c_entry, c_target, D3DXSHADER_DEBUG | D3DXSHADER_PACKMATRIX_ROWMAJOR, &pShaderBuf, &pErrorBuf, NULL);
xr_free (data);
LPCSTR last_error = "";
if (SUCCEEDED(_hr))
{
if (pShaderBuf)
{
_hr = HW.pDevice->CreatePixelShader ((DWORD*)pShaderBuf->GetBufferPointer(), &_ps->ps);
if (SUCCEEDED(_hr)) {
LPCVOID data = NULL;
_hr = D3DXFindShaderComment ((DWORD*)pShaderBuf->GetBufferPointer(),MAKEFOURCC('C','T','A','B'),&data,NULL);
if (SUCCEEDED(_hr) && data)
{
pConstants = LPD3DXSHADER_CONSTANTTABLE(data);
_ps->constants.parse (pConstants,0x1);
}
else
_hr = E_FAIL;
}
}
else
_hr = E_FAIL;
}else
{
if (pErrorBuf)
last_error = (LPCSTR)pErrorBuf->GetBufferPointer();
}
// Real Wolf.10.12.2014
string1024 buff;
if (FAILED(_hr))
{
if (xr_strlen(last_error))
sprintf_s(buff, 1023, "ќшибка компил¤ции шейдера %s: %s ", name, last_error);
else
sprintf_s(buff, 1023, "ќшибка компил¤ции шейдера %s. ¬озможна ошибка в скрипте, или\n видеокарта не поддерживает пиксельные шейдеры 1.1", name);
Msg(buff);
}
pConstants = NULL;
_RELEASE(pShaderBuf);
_RELEASE(pErrorBuf);
CHECK_OR_EXIT (
!FAILED(_hr),
make_string(buff)
);
return _ps;
}
}
static list<expr_pair> mk_singleton(expr const & e, expr const & H) {
return list<expr_pair>(mk_pair(e, H));
}
list<expr_pair> lift(expr const & local, list<expr_pair> const & l) {
lean_assert(is_local(local));
return map(l, [&](expr_pair const & e_H) {
return mk_pair(Pi(local, e_H.first), Fun(local, e_H.second));
});
}
void xrCompressor::CompressOne(LPCSTR path)
{
filesTOTAL ++;
if (testSKIP(path))
{
filesSKIP ++;
printf (" - a SKIP");
Msg ("%-80s - SKIP",path);
return;
}
string_path fn;
strconcat (sizeof(fn), fn, target_name.c_str(), "\\", path);
if (::GetFileAttributes(fn)==u32(-1))
{
filesSKIP ++;
printf (" - CAN'T OPEN");
Msg ("%-80s - CAN'T OPEN",path);
return;
}
IReader* src = FS.r_open (fn);
if (0==src)
{
filesSKIP ++;
printf (" - CAN'T OPEN");
Msg ("%-80s - CAN'T OPEN",path);
return;
}
bytesSRC += src->length ();
u32 c_crc32 = crc32 (src->pointer(),src->length());
u32 c_ptr = 0;
u32 c_size_real = 0;
u32 c_size_compressed = 0;
u32 a_tests = 0;
ALIAS* A = testALIAS (src,c_crc32,a_tests);
printf ("%3da ",a_tests);
if(A)
{
filesALIAS ++;
printf ("ALIAS");
Msg ("%-80s - ALIAS (%s)",path,A->path);
// Alias found
c_ptr = A->c_ptr;
c_size_real = A->c_size_real;
c_size_compressed = A->c_size_compressed;
} else
{
if (testVFS(path))
{
filesVFS ++;
// Write into BaseFS
c_ptr = fs_pack_writer->tell ();
c_size_real = src->length();
c_size_compressed = src->length();
fs_pack_writer->w (src->pointer(),c_size_real);
printf ("VFS");
Msg ("%-80s - VFS",path);
} else
{ //if(testVFS(path))
// Compress into BaseFS
c_ptr = fs_pack_writer->tell();
c_size_real = src->length();
if (0!=c_size_real)
{
u32 c_size_max = rtc_csize (src->length());
u8* c_data = xr_alloc<u8> (c_size_max);
t_compress.Begin ();
c_size_compressed = c_size_max;
if (bFast)
{
R_ASSERT(LZO_E_OK == lzo1x_1_compress ((u8*)src->pointer(),c_size_real,c_data,&c_size_compressed,c_heap));
}else
{
R_ASSERT(LZO_E_OK == lzo1x_999_compress ((u8*)src->pointer(),c_size_real,c_data,&c_size_compressed,c_heap));
}
t_compress.End ();
if ((c_size_compressed+16) >= c_size_real)
{
// Failed to compress - revert to VFS
filesVFS ++;
c_size_compressed = c_size_real;
fs_pack_writer->w (src->pointer(),c_size_real);
printf ("VFS (R)");
Msg ("%-80s - VFS (R)",path);
} else
{
// Compressed OK - optimize
if (!bFast)
{
u8* c_out = xr_alloc<u8> (c_size_real);
u32 c_orig = c_size_real;
R_ASSERT (LZO_E_OK == lzo1x_optimize (c_data,c_size_compressed,c_out,&c_orig, NULL));
R_ASSERT (c_orig == c_size_real );
xr_free (c_out);
}//bFast
fs_pack_writer->w (c_data,c_size_compressed);
printf ("%3.1f%%", 100.f*float(c_size_compressed)/float(src->length()));
Msg ("%-80s - OK (%3.1f%%)",path,100.f*float(c_size_compressed)/float(src->length()));
}
// cleanup
xr_free (c_data);
}else
{ //0!=c_size_real
filesVFS ++;
c_size_compressed = c_size_real;
printf ("VFS (R)");
Msg ("%-80s - EMPTY FILE",path);
}
}//test VFS
} //(A)
// Write description
write_file_header (path,c_crc32,c_ptr,c_size_real,c_size_compressed);
if (0==A)
{
// Register for future aliasing
ALIAS R;
R.path = xr_strdup (fn);
R.crc = c_crc32;
R.c_ptr = c_ptr;
R.c_size_real = c_size_real;
R.c_size_compressed = c_size_compressed;
aliases.insert (mk_pair(R.c_size_real,R));
}
FS.r_close (src);
}
shell_root CPHShellSplitterHolder::ElementSingleSplit(const element_fracture &split_elem,const CPHElement* source_element)
{
//const CPHShellSplitter& splitter=m_splitters[aspl];
//CPHElement* element=m_pShell->elements[splitter.m_element];
CPhysicsShell *new_shell_last=P_create_Shell();
CPHShell *new_shell_last_desc=smart_cast<CPHShell*>(new_shell_last);
new_shell_last->mXFORM.set(m_pShell->mXFORM); const u16 start_joint=split_elem.second.m_start_jt_num;
R_ASSERT(_valid(new_shell_last->mXFORM));
const u16 end_joint=split_elem.second.m_end_jt_num;
//it is not right for multiple joints attached to the unsplited part becource all these need to be reattached
if(start_joint!=end_joint)
{
JOINT_STORAGE& joints=m_pShell->joints;
JOINT_I i=joints.begin()+ start_joint,e=joints.begin()+ end_joint;
for(;i!=e;++i)
{
CPHJoint* joint=(*i);
if(joint->PFirst_element()==source_element)
{
IKinematics* K = m_pShell->PKinematics();
dVector3 safe_pos1, safe_pos2;
dQuaternion safe_q1, safe_q2;
CPhysicsElement* el1=cast_PhysicsElement(split_elem.first),*el2=joint->PSecond_element();
dBodyID body1=el1->get_body(), body2=el2->get_body();
dVectorSet(safe_pos1,dBodyGetPosition(body1));
dVectorSet(safe_pos2,dBodyGetPosition(body2));
dQuaternionSet(safe_q1,dBodyGetQuaternion(body1));
dQuaternionSet(safe_q2,dBodyGetQuaternion(body2));
//m_pShell->PlaceBindToElForms();
K->LL_GetBindTransform(bones_bind_forms);
el1->SetTransform(bones_bind_forms[el1->m_SelfID]);
el2->SetTransform(bones_bind_forms[el2->m_SelfID]);
joint->ReattachFirstElement(split_elem.first);
dVectorSet(const_cast<dReal*>(dBodyGetPosition(body1)),safe_pos1);
dVectorSet(const_cast<dReal*>(dBodyGetPosition(body2)),safe_pos2);
dQuaternionSet(const_cast<dReal*>(dBodyGetQuaternion(body1)),safe_q1);
dQuaternionSet(const_cast<dReal*>(dBodyGetQuaternion(body2)),safe_q2);
dBodySetPosition(body1,safe_pos1[0],safe_pos1[1],safe_pos1[2]);
dBodySetPosition(body2,safe_pos2[0],safe_pos2[1],safe_pos2[2]);
dBodySetQuaternion(body1,safe_q1);
dBodySetQuaternion(body2,safe_q2);
}
}
// m_pShell->joints[split_elem.second.m_start_jt_num]->ReattachFirstElement(split_elem.first);
}
//the last new shell will have all splitted old elements end joints and one new element reattached to old joint
//m_splitters.erase(m_splitters.begin()+aspl);
//now aspl points to the next splitter
if((split_elem.first)->FracturesHolder())//if this element can be splitted add a splitter for it
new_shell_last_desc->AddSplitter(CPHShellSplitter::splElement,0,u16(-1));//
new_shell_last_desc->add_Element(split_elem.first);
//pass splitters taking into account that one element was olready added
PassEndSplitters(split_elem.second,new_shell_last_desc,0,0);
InitNewShell(new_shell_last_desc);
m_pShell->PassEndElements(split_elem.second.m_start_el_num,split_elem.second.m_end_el_num,new_shell_last_desc);
m_pShell->PassEndJoints(split_elem.second.m_start_jt_num,split_elem.second.m_end_jt_num,new_shell_last_desc);
new_shell_last_desc->set_PhysicsRefObject(0);
///////////////////temporary for initialization set old Kinematics in new shell/////////////////
new_shell_last->set_Kinematics(m_pShell->PKinematics());
new_shell_last_desc->AfterSetActive();
new_shell_last->set_Kinematics(NULL);
VERIFY2(split_elem.second.m_bone_id<64,"strange root");
VERIFY(_valid(new_shell_last->mXFORM));
VERIFY(dBodyStateValide(source_element->get_bodyConst()));
VERIFY(dBodyStateValide(split_elem.first->get_body()));
new_shell_last->set_ObjectContactCallback(NULL);
new_shell_last->set_PhysicsRefObject(NULL);
return mk_pair(new_shell_last,split_elem.second.m_bone_id);
}
void CKinematics::Load(const char* N, IReader *data, u32 dwFlags)
{
//Msg ("skeleton: %s",N);
inherited::Load (N, data, dwFlags);
pUserData = NULL;
m_lod = NULL;
// loading lods
IReader* LD = data->open_chunk(OGF_S_LODS);
if (LD)
{
string_path short_name;
strcpy_s (short_name,sizeof(short_name),N);
if (strext(short_name)) *strext(short_name)=0;
// From stream
{
string_path lod_name;
LD->r_string (lod_name, sizeof(lod_name));
//. strconcat (sizeof(name_load),name_load, short_name, ":lod:", lod_name.c_str());
m_lod = ::Render->model_CreateChild(lod_name, NULL);
VERIFY3(m_lod,"Cant create LOD model for", N);
//. VERIFY2 (m_lod->Type==MT_HIERRARHY || m_lod->Type==MT_PROGRESSIVE || m_lod->Type==MT_NORMAL,lod_name.c_str());
/*
strconcat (name_load, short_name, ":lod:1");
m_lod = ::Render->model_CreateChild(name_load,LD);
VERIFY (m_lod->Type==MT_SKELETON_GEOMDEF_PM || m_lod->Type==MT_SKELETON_GEOMDEF_ST);
*/
}
LD->close ();
}
#ifndef _EDITOR
// User data
IReader* UD = data->open_chunk(OGF_S_USERDATA);
pUserData = UD?xr_new<CInifile>(UD,FS.get_path("$game_config$")->m_Path):0;
if (UD) UD->close();
#endif
// Globals
bone_map_N = xr_new<accel> ();
bone_map_P = xr_new<accel> ();
bones = xr_new<vecBones> ();
bone_instances = NULL;
// Load bones
#pragma todo("container is created in stack!")
xr_vector<shared_str> L_parents;
R_ASSERT (data->find_chunk(OGF_S_BONE_NAMES));
visimask.zero ();
int dwCount = data->r_u32();
// Msg ("!!! %d bones",dwCount);
// if (dwCount >= 64) Msg ("!!! More than 64 bones is a crazy thing! (%d), %s",dwCount,N);
VERIFY3 (dwCount < 64, "More than 64 bones is a crazy thing!",N);
for (; dwCount; dwCount--) {
string256 buf;
// Bone
u16 ID = u16(bones->size());
data->r_stringZ (buf,sizeof(buf)); strlwr(buf);
CBoneData* pBone = CreateBoneData(ID);
pBone->name = shared_str(buf);
pBone->child_faces.resize (children.size());
bones->push_back (pBone);
bone_map_N->push_back (mk_pair(pBone->name,ID));
bone_map_P->push_back (mk_pair(pBone->name,ID));
// It's parent
data->r_stringZ (buf,sizeof(buf)); strlwr(buf);
L_parents.push_back (buf);
data->r (&pBone->obb,sizeof(Fobb));
visimask.set (u64(1)<<ID,TRUE);
}
std::sort (bone_map_N->begin(),bone_map_N->end(),pred_sort_N);
std::sort (bone_map_P->begin(),bone_map_P->end(),pred_sort_P);
// Attach bones to their parents
iRoot = BI_NONE;
for (u32 i=0; i<bones->size(); i++) {
shared_str P = L_parents[i];
CBoneData* B = (*bones)[i];
if (!P||!P[0]) {
// no parent - this is root bone
R_ASSERT (BI_NONE==iRoot);
iRoot = u16(i);
B->SetParentID(BI_NONE);
continue;
} else {
u16 ID = LL_BoneID(P);
R_ASSERT (ID!=BI_NONE);
(*bones)[ID]->children.push_back(B);
B->SetParentID(ID);
}
}
R_ASSERT (BI_NONE != iRoot);
// Free parents
L_parents.clear();
// IK data
IReader* IKD = data->open_chunk(OGF_S_IKDATA);
if (IKD){
for (u32 i=0; i<bones->size(); i++) {
CBoneData* B = (*bones)[i];
u16 vers = (u16)IKD->r_u32();
IKD->r_stringZ (B->game_mtl_name);
IKD->r (&B->shape,sizeof(SBoneShape));
B->IK_data.Import(*IKD,vers);
Fvector vXYZ,vT;
IKD->r_fvector3 (vXYZ);
IKD->r_fvector3 (vT);
B->bind_transform.setXYZi(vXYZ);
B->bind_transform.translate_over(vT);
B->mass = IKD->r_float();
IKD->r_fvector3 (B->center_of_mass);
}
// calculate model to bone converting matrix
(*bones)[LL_GetBoneRoot()]->CalculateM2B(Fidentity);
IKD->close();
}
// after load process
{
for (u16 child_idx=0; child_idx<(u16)children.size(); child_idx++)
LL_GetChild(child_idx)->AfterLoad (this,child_idx);
}
// unique bone faces
{
for (u32 bone_idx=0; bone_idx<bones->size(); bone_idx++) {
CBoneData* B = (*bones)[bone_idx];
for (u32 child_idx=0; child_idx<children.size(); child_idx++){
CBoneData::FacesVec faces = B->child_faces[child_idx];
std::sort (faces.begin(),faces.end());
CBoneData::FacesVecIt new_end = std::unique(faces.begin(),faces.end());
faces.erase (new_end,faces.end());
B->child_faces[child_idx].clear_and_free();
B->child_faces[child_idx] = faces;
}
}
}
// reset update_callback
Update_Callback = NULL;
// reset update frame
wm_frame = u32(-1);
LL_Validate ();
}
//-----------------------------------------------------------------------
BOOL motions_value::load (LPCSTR N, IReader *data, vecBones* bones)
{
m_id = N;
bool bRes = true;
// Load definitions
U16Vec rm_bones (bones->size(),BI_NONE);
IReader* MP = data->open_chunk(OGF_S_SMPARAMS);
if (MP)
{
u16 vers = MP->r_u16();
u16 part_bone_cnt = 0;
string128 buf;
R_ASSERT3 (vers<=xrOGF_SMParamsVersion,"Invalid OGF/OMF version:",N);
// partitions
u16 part_count;
part_count = MP->r_u16();
for (u16 part_i=0; part_i<part_count; part_i++)
{
CPartDef& PART = m_partition[part_i];
MP->r_stringZ (buf,sizeof(buf));
PART.Name = _strlwr(buf);
PART.bones.resize (MP->r_u16());
for (xr_vector<u32>::iterator b_it=PART.bones.begin(); b_it<PART.bones.end(); b_it++)
{
MP->r_stringZ (buf,sizeof(buf));
u16 m_idx = u16 (MP->r_u32());
*b_it = find_bone_id (bones,buf);
#ifdef _EDITOR
if (*b_it==BI_NONE )
{
bRes = false;
Msg ("! Can't find bone: '%s'", buf);
}
if (rm_bones.size() <= m_idx)
{
bRes = false;
Msg ("! Can't load: '%s' invalid bones count", N);
}
#else
VERIFY3 (*b_it!=BI_NONE,"Can't find bone:", buf);
#endif
if (bRes) rm_bones[m_idx] = u16(*b_it);
}
part_bone_cnt = u16(part_bone_cnt + (u16)PART.bones.size());
}
#ifdef _EDITOR
if (part_bone_cnt!=(u16)bones->size()){
bRes = false;
Msg("! Different bone count[%s] [Object: '%d' <-> Motions: '%d']", N, bones->size(),part_bone_cnt);
}
#else
VERIFY3(part_bone_cnt==(u16)bones->size(),"Different bone count '%s'",N);
#endif
if (bRes)
{
// motion defs (cycle&fx)
u16 mot_count = MP->r_u16();
m_mdefs.resize (mot_count);
for (u16 mot_i=0; mot_i<mot_count; mot_i++)
{
MP->r_stringZ (buf,sizeof(buf));
shared_str nm = _strlwr (buf);
u32 dwFlags = MP->r_u32 ();
CMotionDef& D = m_mdefs[mot_i];
D.Load (MP,dwFlags,vers);
//. m_mdefs.push_back (D);
if (dwFlags&esmFX)
m_fx.insert (mk_pair(nm,mot_i));
else
m_cycle.insert (mk_pair(nm,mot_i));
m_motion_map.insert (mk_pair(nm,mot_i));
}
}
MP->close();
}else
{
xrDebug::Fatal (DEBUG_INFO,"Old skinned model version unsupported! (%s)",N);
}
if (!bRes) return false;
// Load animation
IReader* MS = data->open_chunk(OGF_S_MOTIONS);
if (!MS) return false;
u32 dwCNT = 0;
MS->r_chunk_safe (0,&dwCNT,sizeof(dwCNT));
VERIFY (dwCNT<0x3FFF); // MotionID 2 bit - slot, 14 bit - motion index
// set per bone motion size
for (u32 i=0; i<bones->size(); i++)
m_motions[bones->at(i)->name].resize(dwCNT);
// load motions
for (u16 m_idx=0; m_idx<(u16)dwCNT; m_idx++){
string128 mname;
R_ASSERT (MS->find_chunk(m_idx+1));
MS->r_stringZ (mname,sizeof(mname));
#ifdef _DEBUG
// sanity check
xr_strlwr (mname);
accel_map::iterator I= m_motion_map.find(mname);
VERIFY3 (I!=m_motion_map.end(),"Can't find motion:",mname);
VERIFY3 (I->second==m_idx,"Invalid motion index:",mname);
#endif
u32 dwLen = MS->r_u32();
for (u32 i=0; i<bones->size(); i++){
u16 bone_id = rm_bones[i];
VERIFY2 (bone_id!=BI_NONE,"Invalid remap index.");
CMotion& M = m_motions[bones->at(bone_id)->name][m_idx];
M.set_count (dwLen);
M.set_flags (MS->r_u8());
if (M.test_flag(flRKeyAbsent)) {
CKeyQR* r = (CKeyQR*)MS->pointer();
u32 crc_q = crc32(r,sizeof(CKeyQR));
M._keysR.create (crc_q,1,r);
MS->advance (1 * sizeof(CKeyQR));
}else{
u32 crc_q = MS->r_u32 ();
M._keysR.create (crc_q,dwLen,(CKeyQR*)MS->pointer());
MS->advance (dwLen * sizeof(CKeyQR));
}
if (M.test_flag(flTKeyPresent))
{
u32 crc_t = MS->r_u32 ();
if(M.test_flag(flTKey16IsBit))
{
M._keysT16.create (crc_t,dwLen,(CKeyQT16*)MS->pointer());
MS->advance (dwLen * sizeof(CKeyQT16));
}else
{
M._keysT8.create (crc_t,dwLen,(CKeyQT8*)MS->pointer());
MS->advance (dwLen * sizeof(CKeyQT8));
};
MS->r_fvector3 (M._sizeT);
MS->r_fvector3 (M._initT);
}else
{
MS->r_fvector3 (M._initT);
}
}
}
// Msg("Motions %d/%d %4d/%4d/%d, %s",p_cnt,m_cnt, m_load,m_total,m_r,N);
MS->close();
return bRes;
}
void CStepManager::reload(LPCSTR section)
{
m_legs_count = pSettings->r_u8 (section, "LegsCount");
LPCSTR anim_section = pSettings->r_string (section, "step_params");
if (!pSettings->section_exist(anim_section))
{
#ifdef DEBUG
Msg( "! no step_params section for :%s section :s", m_object->cName().c_str(), section );
#endif
return;
}
VERIFY((m_legs_count>=MIN_LEGS_COUNT) && (m_legs_count<=MAX_LEGS_COUNT));
SStepParam param;
param.step[0].time = 0.1f; // avoid warning
LPCSTR anim_name, val;
string16 cur_elem;
IKinematicsAnimated *skeleton_animated = smart_cast<IKinematicsAnimated*>(m_object->Visual());
VERIFY3(skeleton_animated, "object is not animated", m_object->cNameVisual().c_str());
#ifdef DEBUG
if( debug_step_info_load )
Msg( "loading step_params for object :%s, visual: %s, section: %s, step_params section: %s ", m_object->cName().c_str(), m_object->cNameVisual().c_str(), section, anim_section );
#endif
for (u32 i=0; pSettings->r_line(anim_section,i,&anim_name,&val); ++i) {
_GetItem (val,0,cur_elem);
param.cycles = u8(atoi(cur_elem));
R_ASSERT(param.cycles >= 1);
for (u32 j=0;j<m_legs_count;j++) {
_GetItem (val,1+j*2, cur_elem); param.step[j].time = float(atof(cur_elem));
_GetItem (val,1+j*2+1, cur_elem); param.step[j].power = float(atof(cur_elem));
VERIFY (_valid(param.step[j].power));
}
MotionID motion_id = skeleton_animated->ID_Cycle_Safe(anim_name);
if (!motion_id)
{
#ifdef DEBUG
IKinematicsAnimated *KA = smart_cast<IKinematicsAnimated*>(m_object->Visual());
VERIFY( KA );
Msg( "! (CStepManager::reload) no anim :%s object:%s, visual: %s, step_params section: %s ", anim_name, m_object->cName().c_str(), m_object->cNameVisual().c_str(), anim_section );
#endif
continue;
}
#ifdef DEBUG
if( debug_step_info_load )
{
IKinematicsAnimated *KA = smart_cast<IKinematicsAnimated*>(m_object->Visual());
VERIFY( KA );
std::pair<LPCSTR,LPCSTR> anim_name = KA->LL_MotionDefName_dbg( motion_id );
Msg( "step_params loaded for object :%s, visual: %s, motion: %s, anim set: %s ", m_object->cName().c_str(), m_object->cNameVisual().c_str(), anim_name.first, anim_name.second );
}
#endif
m_steps_map.insert(mk_pair(motion_id, param));
}
#ifdef DEBUG
if( m_steps_map.empty() )
Msg( "! no steps info loaded for :%s, section :s, step_params section: %s ", m_object->cName().c_str(), section, anim_section );
#endif
// reload foot bones
for (u32 i = 0; i < MAX_LEGS_COUNT; i++) m_foot_bones[i] = BI_NONE;
reload_foot_bones ();
m_time_anim_started = 0;
m_blend = 0;
}
io_state_stream const & operator<<(io_state_stream const & out, expr const & e) {
options const & opts = out.get_options();
out.get_stream() << mk_pair(out.get_formatter()(e, opts), opts);
return out;
}
io_state_stream const & operator<<(io_state_stream const & out, goal const & g) {
options const & opts = out.get_options();
out.get_stream() << mk_pair(g.pp(out.get_formatter()), opts);
return out;
}
io_state_stream const & operator<<(io_state_stream const & out, environment const & env) {
options const & opts = out.get_options();
out.get_stream() << mk_pair(out.get_formatter()(env, opts), opts);
return out;
}
io_state_stream const & operator<<(io_state_stream const & out, object const & obj) {
options const & opts = out.get_options();
out.get_stream() << mk_pair(out.get_formatter()(obj, opts), opts);
return out;
}
static environment mk_brec_on(environment const & env, name const & n, bool ind) {
if (!is_recursive_datatype(env, n))
return env;
if (is_inductive_predicate(env, n))
return env;
inductive::inductive_decls decls = *inductive::is_inductive_decl(env, n);
type_checker tc(env);
name_generator ngen;
unsigned nparams = std::get<1>(decls);
declaration ind_decl = env.get(n);
declaration rec_decl = env.get(inductive::get_elim_name(n));
// declaration below_decl = env.get(name(n, ind ? "ibelow" : "below"));
unsigned nindices = *inductive::get_num_indices(env, n);
unsigned nminors = *inductive::get_num_minor_premises(env, n);
unsigned ntypeformers = length(std::get<2>(decls));
level_param_names lps = rec_decl.get_univ_params();
bool is_reflexive = is_reflexive_datatype(tc, n);
level lvl = mk_param_univ(head(lps));
levels lvls = param_names_to_levels(tail(lps));
level rlvl;
level_param_names blps;
levels blvls; // universe level parameters of brec_on/binduction_on
// The arguments of brec_on (binduction_on) are the ones in the recursor - minor premises.
// The universe we map to is also different (l+1 for below of reflexive types) and (0 fo ibelow).
expr ref_type;
if (ind) {
// we are eliminating to Prop
blps = tail(lps);
blvls = lvls;
rlvl = mk_level_zero();
ref_type = instantiate_univ_param(rec_decl.get_type(), param_id(lvl), mk_level_zero());
} else if (is_reflexive) {
blps = lps;
blvls = cons(lvl, lvls);
rlvl = get_datatype_level(ind_decl.get_type());
// if rlvl is of the form (max 1 l), then rlvl <- l
if (is_max(rlvl) && is_one(max_lhs(rlvl)))
rlvl = max_rhs(rlvl);
rlvl = mk_max(mk_succ(lvl), rlvl);
// inner_prod, inner_prod_intro, pr1, pr2 do not use the same universe levels for
// reflective datatypes.
ref_type = instantiate_univ_param(rec_decl.get_type(), param_id(lvl), mk_succ(lvl));
} else {
// we can simplify the universe levels for non-reflexive datatypes
blps = lps;
blvls = cons(lvl, lvls);
rlvl = mk_max(mk_level_one(), lvl);
ref_type = rec_decl.get_type();
}
buffer<expr> ref_args;
to_telescope(ngen, ref_type, ref_args);
if (ref_args.size() != nparams + ntypeformers + nminors + nindices + 1)
throw_corrupted(n);
// args contains the brec_on/binduction_on arguments
buffer<expr> args;
buffer<name> typeformer_names;
// add parameters and typeformers
for (unsigned i = 0; i < nparams; i++)
args.push_back(ref_args[i]);
for (unsigned i = nparams; i < nparams + ntypeformers; i++) {
args.push_back(ref_args[i]);
typeformer_names.push_back(mlocal_name(ref_args[i]));
}
// add indices and major premise
for (unsigned i = nparams + ntypeformers + nminors; i < ref_args.size(); i++)
args.push_back(ref_args[i]);
// create below terms (one per datatype)
// (below.{lvls} params type-formers)
// Remark: it also creates the result type
buffer<expr> belows;
expr result_type;
unsigned k = 0;
for (auto const & decl : std::get<2>(decls)) {
name const & n1 = inductive::inductive_decl_name(decl);
if (n1 == n) {
result_type = ref_args[nparams + k];
for (unsigned i = nparams + ntypeformers + nminors; i < ref_args.size(); i++)
result_type = mk_app(result_type, ref_args[i]);
}
k++;
name bname = name(n1, ind ? "ibelow" : "below");
expr below = mk_constant(bname, blvls);
for (unsigned i = 0; i < nparams; i++)
below = mk_app(below, ref_args[i]);
for (unsigned i = nparams; i < nparams + ntypeformers; i++)
below = mk_app(below, ref_args[i]);
belows.push_back(below);
}
// create functionals (one for each type former)
// Pi idxs t, below idxs t -> C idxs t
buffer<expr> Fs;
name F_name("F");
for (unsigned i = nparams, j = 0; i < nparams + ntypeformers; i++, j++) {
expr const & C = ref_args[i];
buffer<expr> F_args;
to_telescope(ngen, mlocal_type(C), F_args);
expr F_result = mk_app(C, F_args);
expr F_below = mk_app(belows[j], F_args);
F_args.push_back(mk_local(ngen.next(), "f", F_below, binder_info()));
expr F_type = Pi(F_args, F_result);
expr F = mk_local(ngen.next(), F_name.append_after(j+1), F_type, binder_info());
Fs.push_back(F);
args.push_back(F);
}
// We define brec_on/binduction_on using the recursor for this type
levels rec_lvls = cons(rlvl, lvls);
expr rec = mk_constant(rec_decl.get_name(), rec_lvls);
// add parameters to rec
for (unsigned i = 0; i < nparams; i++)
rec = mk_app(rec, ref_args[i]);
// add type formers to rec
// Pi indices t, prod (C ... t) (below ... t)
for (unsigned i = nparams, j = 0; i < nparams + ntypeformers; i++, j++) {
expr const & C = ref_args[i];
buffer<expr> C_args;
to_telescope(ngen, mlocal_type(C), C_args);
expr C_t = mk_app(C, C_args);
expr below_t = mk_app(belows[j], C_args);
expr prod = mk_prod(tc, C_t, below_t, ind);
rec = mk_app(rec, Fun(C_args, prod));
}
// add minor premises to rec
for (unsigned i = nparams + ntypeformers, j = 0; i < nparams + ntypeformers + nminors; i++, j++) {
expr minor = ref_args[i];
expr minor_type = mlocal_type(minor);
buffer<expr> minor_args;
minor_type = to_telescope(ngen, minor_type, minor_args);
buffer<expr> pairs;
for (expr & minor_arg : minor_args) {
buffer<expr> minor_arg_args;
expr minor_arg_type = to_telescope(tc, mlocal_type(minor_arg), minor_arg_args);
if (auto k = is_typeformer_app(typeformer_names, minor_arg_type)) {
buffer<expr> C_args;
get_app_args(minor_arg_type, C_args);
expr new_minor_arg_type = mk_prod(tc, minor_arg_type, mk_app(belows[*k], C_args), ind);
minor_arg = update_mlocal(minor_arg, Pi(minor_arg_args, new_minor_arg_type));
if (minor_arg_args.empty()) {
pairs.push_back(minor_arg);
} else {
expr r = mk_app(minor_arg, minor_arg_args);
expr r_1 = Fun(minor_arg_args, mk_pr1(tc, r, ind));
expr r_2 = Fun(minor_arg_args, mk_pr2(tc, r, ind));
pairs.push_back(mk_pair(tc, r_1, r_2, ind));
}
}
}
expr b = foldr([&](expr const & a, expr const & b) { return mk_pair(tc, a, b, ind); },
[&]() { return mk_unit_mk(rlvl, ind); },
pairs.size(), pairs.data());
unsigned F_idx = *is_typeformer_app(typeformer_names, minor_type);
expr F = Fs[F_idx];
buffer<expr> F_args;
get_app_args(minor_type, F_args);
F_args.push_back(b);
expr new_arg = mk_pair(tc, mk_app(F, F_args), b, ind);
rec = mk_app(rec, Fun(minor_args, new_arg));
}
// add indices and major to rec
for (unsigned i = nparams + ntypeformers + nminors; i < ref_args.size(); i++)
rec = mk_app(rec, ref_args[i]);
name brec_on_name = name(n, ind ? "binduction_on" : "brec_on");
expr brec_on_type = Pi(args, result_type);
expr brec_on_value = Fun(args, mk_pr1(tc, rec, ind));
bool use_conv_opt = true;
declaration new_d = mk_definition(env, brec_on_name, blps, brec_on_type, brec_on_value,
use_conv_opt);
environment new_env = module::add(env, check(env, new_d));
new_env = set_reducible(new_env, brec_on_name, reducible_status::Reducible);
if (!ind)
new_env = add_unfold_hint(new_env, brec_on_name, nparams + nindices + ntypeformers);
return add_protected(new_env, brec_on_name);
}
void CEnvironment::OnFrame()
{
#ifdef _EDITOR
SetGameTime (fGameTime+Device.fTimeDelta*fTimeFactor,fTimeFactor);
if (fsimilar(ed_to_time,DAY_LENGTH)&&fsimilar(ed_from_time,0.f)){
if (fGameTime>DAY_LENGTH) fGameTime-=DAY_LENGTH;
}else{
if (fGameTime>ed_to_time){
fGameTime=fGameTime-ed_to_time+ed_from_time;
Current[0]=Current[1]=0;
}
if (fGameTime<ed_from_time){
fGameTime=ed_from_time;
Current[0]=Current[1]=0;
}
}
if (!psDeviceFlags.is(rsEnvironment)) return;
#else
if (!g_pGameLevel) return;
#endif
// if (pInput->iGetAsyncKeyState(DIK_O)) SetWeatherFX("surge_day");
if (bWFX&&(wfx_time<=0.f)) StopWFX();
SelectEnvs (fGameTime);
VERIFY (Current[0]&&Current[1]);
float current_weight = TimeWeight(fGameTime,Current[0]->exec_time,Current[1]->exec_time);
// modifiers
CEnvModifier EM;
EM.far_plane = 0;
EM.fog_color.set ( 0,0,0 );
EM.fog_density = 0;
EM.ambient.set ( 0,0,0 );
EM.sky_color.set ( 0,0,0 );
EM.hemi_color.set ( 0,0,0 );
Fvector view = Device.vCameraPosition;
float mpower = 0;
for (xr_vector<CEnvModifier>::iterator mit=Modifiers.begin(); mit!=Modifiers.end(); mit++)
mpower += EM.sum(*mit,view);
// final lerp
CurrentEnv.lerp (this,*Current[0],*Current[1],current_weight,EM,mpower);
#ifndef SUN_DIR_NOT_DEBUG
if(CurrentEnv.sun_dir.y>0)
{
Log("CurrentEnv.sun_dir", CurrentEnv.sun_dir);
Log("current_weight", current_weight);
Log("mpower", mpower);
Log("Current[0]->sun_dir", Current[0]->sun_dir);
Log("Current[1]->sun_dir", Current[1]->sun_dir);
}
#endif
VERIFY2 (CurrentEnv.sun_dir.y<0,"Invalid sun direction settings in lerp");
if (::Render->get_generation()==IRender_interface::GENERATION_R2){
//. very very ugly hack
if (HW.Caps.raster_major >= 3 && HW.Caps.geometry.bVTF){
// tonemapping in VS
CurrentEnv.sky_r_textures.push_back (mk_pair(u32(D3DVERTEXTEXTURESAMPLER0),tonemap)); //. hack
CurrentEnv.sky_r_textures_env.push_back (mk_pair(u32(D3DVERTEXTEXTURESAMPLER0),tonemap)); //. hack
CurrentEnv.clouds_r_textures.push_back (mk_pair(u32(D3DVERTEXTEXTURESAMPLER0),tonemap)); //. hack
} else {
// tonemapping in PS
CurrentEnv.sky_r_textures.push_back (mk_pair(2,tonemap)); //. hack
CurrentEnv.sky_r_textures_env.push_back (mk_pair(2,tonemap)); //. hack
CurrentEnv.clouds_r_textures.push_back (mk_pair(2,tonemap)); //. hack
}
}
//. Setup skybox textures, somewhat ugly
IDirect3DBaseTexture9* e0 = CurrentEnv.sky_r_textures[0].second->surface_get();
IDirect3DBaseTexture9* e1 = CurrentEnv.sky_r_textures[1].second->surface_get();
tsky0->surface_set (e0); _RELEASE(e0);
tsky1->surface_set (e1); _RELEASE(e1);
PerlinNoise1D->SetFrequency (wind_gust_factor*MAX_NOISE_FREQ);
wind_strength_factor = clampr(PerlinNoise1D->GetContinious(Device.fTimeGlobal)+0.5f,0.f,1.f);
int l_id = (current_weight<0.5f)?Current[0]->lens_flare_id:Current[1]->lens_flare_id;
eff_LensFlare->OnFrame (l_id);
int t_id = (current_weight<0.5f)?Current[0]->tb_id:Current[1]->tb_id;
eff_Thunderbolt->OnFrame (t_id,CurrentEnv.bolt_period,CurrentEnv.bolt_duration);
eff_Rain->OnFrame ();
// ******************** Environment params (setting)
CHK_DX(HW.pDevice->SetRenderState( D3DRS_FOGCOLOR, color_rgba_f(CurrentEnv.fog_color.x,CurrentEnv.fog_color.y,CurrentEnv.fog_color.z,0) ));
CHK_DX(HW.pDevice->SetRenderState( D3DRS_FOGSTART, *(u32 *)(&CurrentEnv.fog_near) ));
CHK_DX(HW.pDevice->SetRenderState( D3DRS_FOGEND, *(u32 *)(&CurrentEnv.fog_far) ));
}
